From patchwork Thu May 22 12:37:05 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Neil Armstrong X-Patchwork-Id: 891703 Delivered-To: patch@linaro.org Received: by 2002:adf:e88a:0:b0:3a3:61c9:c5d4 with SMTP id d10csp2610890wrm; Thu, 22 May 2025 05:37:23 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCXWKSbI7D1LprvT5irVUprMgRlkcUZeb0UIFqk7kWsJbz2gtFbmYQz5DJvMTJM0Qk7bzL7sQg==@linaro.org X-Google-Smtp-Source: AGHT+IHSWaXYcgMZWQfhfSdDoyYcaPpZoQJPDMixTGyd0UXEEyH4dVtsQSFGRNK7OmvH9W4U66ds X-Received: by 2002:a05:6000:4310:b0:3a3:699a:3108 with SMTP id ffacd0b85a97d-3a3699a347fmr17026668f8f.14.1747917443256; Thu, 22 May 2025 05:37:23 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1747917443; cv=none; d=google.com; s=arc-20240605; b=ZlsvTy+wlK2hbeTvIRokljMCbjBZHuoAX586JWMcwanOXfrMFhgEryWFBtcNVGa1+t L8YiONjwdJVsYl7gomHMP4FhJXPXGcDOcfCnnIJlPRgPiXmUnPRgSvAbgG09mFfODUwN lZfwewGgVsZng0SVpkPKy9Zlvej9ALs+6Vou0ZgDDX4QylLpan5y8ll35+3pDsKTXJof +KVFX5fuK32lde2cxw8lKHuyytmLwqyCPVttW6KHpptebn2KyQnvEKIOD2z61xB6wCIm uPfmvNfKMS10FKpAp3suIgmopnaa5wqs8aX4ul9CFqvzpv7CmSTPg5GNqBHLVNrUomw9 QdFA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20240605; h=sender:errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:cc:to:in-reply-to:references :message-id:content-transfer-encoding:mime-version:subject:date:from :dkim-signature; bh=/YPHwMzz1kHeByJZyGaprIJA3EOq7dCpM2gKxh2o3z8=; fh=+i+RTkrPvc0CCcB6rXKbnTZaOKShRvWA2CazXh31SXM=; b=V5T8y5akAYBBY4xsNJZuI9KqJgXjI8398+oB6yyonO0lwkADpM6PGGVIKvur0rnrmX 6C30L6rPkGipwghR4FtPiRsrDLa9IRJD6M5MoAh1PCKVccQz4wg0YD41bZb1zYCwZB4c rxn5W/xOteARRt/ADUW9fDKAFkLb8hz9s485BUUeSKKtsy0r41Kj4ndzZwRrucPYitKx 1zaGJkjA3vxLytzf3IH2yfX63n6Y8pQSqFeTTbVFeCDU5gGClqOm+pvpUS8e1Yyy122I RgqEMjdInt/WgewNshdBaozvsLXsF+VB9cbKuzWrHrjC3A+pRrIooe9eqqG9lgQkYA2R C0Hg==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=V+OnE+Rs; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 2a01:238:438b:c500:173d:9f52:ddab:ee01 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org; dara=neutral header.i=@linaro.org Return-Path: Received: from phobos.denx.de (phobos.denx.de. [2a01:238:438b:c500:173d:9f52:ddab:ee01]) by mx.google.com with ESMTPS id ffacd0b85a97d-3a362bfccaesi10480008f8f.38.2025.05.22.05.37.22 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 22 May 2025 05:37:23 -0700 (PDT) Received-SPF: pass (google.com: domain of u-boot-bounces@lists.denx.de designates 2a01:238:438b:c500:173d:9f52:ddab:ee01 as permitted sender) client-ip=2a01:238:438b:c500:173d:9f52:ddab:ee01; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=V+OnE+Rs; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 2a01:238:438b:c500:173d:9f52:ddab:ee01 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org; dara=neutral header.i=@linaro.org Received: from h2850616.stratoserver.net (localhost [IPv6:::1]) by phobos.denx.de (Postfix) with ESMTP id B0F058309A; Thu, 22 May 2025 14:37:15 +0200 (CEST) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=u-boot-bounces@lists.denx.de Authentication-Results: phobos.denx.de; dkim=pass (2048-bit key; unprotected) header.d=linaro.org header.i=@linaro.org header.b="V+OnE+Rs"; dkim-atps=neutral Received: by phobos.denx.de (Postfix, from userid 109) id 4C9F083043; Thu, 22 May 2025 14:37:12 +0200 (CEST) X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on phobos.denx.de X-Spam-Level: X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_BLOCKED, SPF_HELO_NONE,T_SPF_TEMPERROR autolearn=ham autolearn_force=no version=3.4.2 Received: from mail-wm1-x331.google.com (mail-wm1-x331.google.com [IPv6:2a00:1450:4864:20::331]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits)) (No client certificate requested) by phobos.denx.de (Postfix) with ESMTPS id 705BD83096 for ; Thu, 22 May 2025 14:37:09 +0200 (CEST) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=neil.armstrong@linaro.org Received: by mail-wm1-x331.google.com with SMTP id 5b1f17b1804b1-43cf680d351so54502995e9.0 for ; Thu, 22 May 2025 05:37:09 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1747917428; x=1748522228; darn=lists.denx.de; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=/YPHwMzz1kHeByJZyGaprIJA3EOq7dCpM2gKxh2o3z8=; b=V+OnE+RsAFL6sVCcb8q18qAX4C1PFYqyLJ8G5JwTc/tT7Yminx3nrkWTRHKPyVe0ZI 5PXMkP1sG8NPcd64pt0nxT9yUKK2fh/d1gRYBuPAueYmLKbdpM8Ln9LJYfBmtSMpxUaf kA7V2GxUzNaWg6Wb0BP0DqJoqcNrnXU5ggpw6xZcNEGHPquMMHtWA+Wjl/FIrQCZ4Og4 oua2d/DEGxAdjNt3rAqKFddl531VWc1LtF2GHZRA4xEvxVeF8faB5RbcoHr+Zyo0PNCz 1Njjgf0czo55Em4sEZ8ZPgILY6WIoBMTmEi1sQfTICrSA6/XL/wQcex8vrkKybqoJU0T Oj/g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1747917428; x=1748522228; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=/YPHwMzz1kHeByJZyGaprIJA3EOq7dCpM2gKxh2o3z8=; b=Mdlq5Fz7rXnPVm9HkISZVov0K2vwFmtfw2fptvSTUcLl6vtJgenEza03hoHxAYuZzu GINkDA8lB42rT8ti73wIuSIkCn2+1Eq2rBp26FI8X7SlKL2euV/f13W4ujTj4JDtfzg/ zB9wkMOOVhPHs6ezh5MFaJGEHzFkhr0hZI1MbN7IkeK5rQ7pUa+eQV/vffhu5jK+6FGm SFzz5I/zQgznGtEUGHppH395koTNaNMg5h7qOEUd/WT0BmEKaOtopZinlo0COFiiDRg+ GBXj8HdPK9X1ovSJcKfdIZEj0hxjV5jZ/mveKBW5oK6zwJPYmp5bRMM4XYxwAbOLnYDb FQRw== X-Gm-Message-State: AOJu0YyeL3VF5CPeCga91gDl1z6S5ubc2lYAyMMuIDAXvqJCXCfl0cOd xk6uMMN6WBi+Cr2ngyYkTv/y+b40KwnfUa2nXoxv5DQACPVSVDBUJcO37qkHRt5B6hQ= X-Gm-Gg: ASbGncvcTJ7KFpNCshSBHc4emuW7kdAsqWz8l8E56LebRez9OBJd0BtQYfKFC3DHGLt SUVKk2vRokpGDwKR1lWBmKDE0mYWsBR6aefdo2kFfFa2GLlTidaqSaphP85AfLpwc9vG6UmLIIi yxVSXQ85WUET8tFVKzpbifnipafE1iIAbwuUaDY4Howgf3c7ldrTokblaZctjEV8HtHroO84NPE R39PHkmBbRSVwbB2dmt5RQNbKszgAsTIahyhaPaUmrGlXcltYyNgQv6xUHsnmXIgYK3mT4FFjj1 fKzk1FXGbXBMaB2ZVqtGVWUAJXiSeWiu8tRaMx1f8n13y7grqkG7xm+m7W9rdgF/HQva1Y09 X-Received: by 2002:a05:600c:1f82:b0:441:bbe5:f562 with SMTP id 5b1f17b1804b1-442f8534e53mr292082435e9.16.1747917428464; Thu, 22 May 2025 05:37:08 -0700 (PDT) Received: from arrakeen.starnux.net ([2a01:e0a:3d9:2080:8261:5fff:fe11:bdda]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-447f38145eesm102271045e9.26.2025.05.22.05.37.07 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 22 May 2025 05:37:08 -0700 (PDT) From: Neil Armstrong Date: Thu, 22 May 2025 14:37:05 +0200 Subject: [PATCH RFT v4 1/3] fastboot: blk: introduce fastboot block flashing support MIME-Version: 1.0 Message-Id: <20250522-topic-fastboot-blk-v4-1-af7f7f30564d@linaro.org> References: <20250522-topic-fastboot-blk-v4-0-af7f7f30564d@linaro.org> In-Reply-To: <20250522-topic-fastboot-blk-v4-0-af7f7f30564d@linaro.org> To: Tom Rini , Mattijs Korpershoek , Mattijs Korpershoek Cc: u-boot@lists.denx.de, Neil Armstrong , Dmitrii Merkurev X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=14744; i=neil.armstrong@linaro.org; h=from:subject:message-id; bh=u38gyfBbqcgweukdputMcJtzWtuesaIscq4GIrJIkOU=; b=owEBbQKS/ZANAwAKAXfc29rIyEnRAcsmYgBoLxpyV4N1CRJrmVunZnG3IqVXJ+9pZg+zlVpzsrgH 0l1Tm0KJAjMEAAEKAB0WIQQ9U8YmyFYF/h30LIt33NvayMhJ0QUCaC8acgAKCRB33NvayMhJ0U8VEA DE1fPJOKSmn7iBjla0Gndhrwc7bPit2PR3SH4mOKjS3ojAuSWYk5ArExAzag07uplmJwY0185hvHPk CwZ/7vOvCcBROlIpIhCEpQ/EzP8f4RQb9tKSBEGT5GYj+uEn56Rb0hY0LLwl6m1e4PZ0Vyoh/uIX4G A9bEAy9eJ37n2IDtkMRPcG6tm7yGCPcDrur0doiOgoHhFIW5g3CI/ry7/KXnLIHeRIFbKnxbBa6tFN 2xhWF9SooSOKPdPd+PHV3RxyA6LJ6iDJ/uofeLjl89HFd/d7DXgVgNDQ5OyPd7i9uOOsYgb8WrFNtg eSoYPDHjKLlxuk+HAXw/9P26RKXXEnBOELkDpaMIOfINXcu4R7Mn7x6YltTq5tdagCfyVgG1sYORP2 R84vJeDk29ukJpj0IesIVdPxO4v6oneAdoWCJNjVoGz6S7E3YY6y0Oxc+pQJjL4tcJZPPgCfnAfnRo SV/0OZXkCIIDwXXvkp7pkZGWfL5stmZwHEWVm5n+CU9DImeD1r7ns8xbMCRbXVSGWodrQoruvb1ZS5 UiFnE+Vsc4TDOd8gKDvvhSQtbwhZ9HEGbizdV5GT3uEhYjGjekuH7+xJ7N+amhIG/9gbeVm5oePzfd t0a6hvAhV88sqzGmkEh+eEvxY3dgiJBWNSnyH+MApnqyGI9MLFXn1lPA+MOw== X-Developer-Key: i=neil.armstrong@linaro.org; a=openpgp; fpr=89EC3D058446217450F22848169AB7B1A4CFF8AE X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.39 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: u-boot-bounces@lists.denx.de Sender: "U-Boot" X-Virus-Scanned: clamav-milter 0.103.8 at phobos.denx.de X-Virus-Status: Clean From: Dmitrii Merkurev Introduce fastboot block flashing functions and helpers to be shared with the MMC implementation. The write logic comes from the mmc implementation, while the partition lookup is much simpler and could be extended. For the erase logic, allmost no block drivers exposes the erase operation, except mmc & virtio, so in order to allow erasiong any partition a soft-erase logic has been added to write zero-ed buffers in a loop. Signed-off-by: Dmitrii Merkurev Reviewed-by: Mattijs Korpershoek Tested-by: Mattijs Korpershoek Signed-off-by: Neil Armstrong --- drivers/fastboot/fb_block.c | 323 ++++++++++++++++++++++++++++++++++++++++++++ include/fb_block.h | 105 ++++++++++++++ 2 files changed, 428 insertions(+) diff --git a/drivers/fastboot/fb_block.c b/drivers/fastboot/fb_block.c new file mode 100644 index 0000000000000000000000000000000000000000..b725397c91af2717812e69e2b624076eb30f781d --- /dev/null +++ b/drivers/fastboot/fb_block.c @@ -0,0 +1,323 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Copyright (C) 2024 The Android Open Source Project + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +/** + * FASTBOOT_MAX_BLOCKS_ERASE - maximum blocks to erase per derase call + * + * in the ERASE case we can have much larger buffer size since + * we're not transferring an actual buffer + */ +#define FASTBOOT_MAX_BLOCKS_ERASE 1048576 +/** + * FASTBOOT_MAX_BLOCKS_SOFT_ERASE - maximum blocks to software erase at once + */ +#define FASTBOOT_MAX_BLOCKS_SOFT_ERASE 4096 +/** + * FASTBOOT_MAX_BLOCKS_WRITE - maximum blocks to write per dwrite call + */ +#define FASTBOOT_MAX_BLOCKS_WRITE 65536 + +struct fb_block_sparse { + struct blk_desc *dev_desc; +}; + +/* Write 0s instead of using erase operation, inefficient but functional */ +static lbaint_t fb_block_soft_erase(struct blk_desc *block_dev, lbaint_t blk, + lbaint_t cur_blkcnt, lbaint_t erase_buf_blks, + void *erase_buffer) +{ + lbaint_t blks_written = 0; + int j; + + memset(erase_buffer, 0, erase_buf_blks * block_dev->blksz); + + for (j = 0; j < cur_blkcnt; j += erase_buf_blks) { + lbaint_t remain = min_t(lbaint_t, cur_blkcnt - j, + erase_buf_blks); + + blks_written += blk_dwrite(block_dev, blk + j, + remain, erase_buffer); + printf("."); + } + + return blks_written; +} + +static lbaint_t fb_block_write(struct blk_desc *block_dev, lbaint_t start, + lbaint_t blkcnt, const void *buffer) +{ + lbaint_t blk = start; + lbaint_t blks_written = 0; + lbaint_t cur_blkcnt = 0; + lbaint_t blks = 0; + void *erase_buf = NULL; + int erase_buf_blks = 0; + int step = buffer ? FASTBOOT_MAX_BLOCKS_WRITE : FASTBOOT_MAX_BLOCKS_ERASE; + int i; + + for (i = 0; i < blkcnt; i += step) { + cur_blkcnt = min((int)blkcnt - i, step); + 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"); + + if (!erase_buf) { + blks_written = blk_derase(block_dev, blk, cur_blkcnt); + + /* Allocate erase buffer if erase is not implemented */ + if ((long)blks_written == -ENOSYS) { + erase_buf_blks = min_t(long, blkcnt, + FASTBOOT_MAX_BLOCKS_SOFT_ERASE); + erase_buf = malloc(erase_buf_blks * block_dev->blksz); + + printf("Slowly writing empty buffers due to missing erase operation\n"); + } + } + + if (erase_buf) + blks_written = fb_block_soft_erase(block_dev, blk, cur_blkcnt, + erase_buf_blks, erase_buf); + } + blk += blks_written; + blks += blks_written; + } + + if (erase_buf) + free(erase_buf); + + return blks; +} + +static lbaint_t fb_block_sparse_write(struct sparse_storage *info, + lbaint_t blk, lbaint_t blkcnt, + const void *buffer) +{ + struct fb_block_sparse *sparse = info->priv; + struct blk_desc *dev_desc = sparse->dev_desc; + + return fb_block_write(dev_desc, blk, blkcnt, buffer); +} + +static lbaint_t fb_block_sparse_reserve(struct sparse_storage *info, + lbaint_t blk, lbaint_t blkcnt) +{ + return blkcnt; +} + +int fastboot_block_get_part_info(const char *part_name, + struct blk_desc **dev_desc, + struct disk_partition *part_info, + char *response) +{ + int ret; + const char *interface = config_opt_enabled(CONFIG_FASTBOOT_FLASH_BLOCK, + CONFIG_FASTBOOT_FLASH_BLOCK_INTERFACE_NAME, + NULL); + const int device = config_opt_enabled(CONFIG_FASTBOOT_FLASH_BLOCK, + CONFIG_FASTBOOT_FLASH_BLOCK_DEVICE_ID, -1); + + if (!part_name || !strcmp(part_name, "")) { + fastboot_fail("partition not given", response); + return -ENOENT; + } + if (!interface || !strcmp(interface, "")) { + fastboot_fail("block interface isn't provided", response); + return -EINVAL; + } + + *dev_desc = blk_get_dev(interface, device); + if (!dev_desc) { + fastboot_fail("no such device", response); + return -ENODEV; + } + + ret = part_get_info_by_name(*dev_desc, part_name, part_info); + if (ret < 0) + fastboot_fail("failed to get partition info", response); + + return ret; +} + +void fastboot_block_raw_erase_disk(struct blk_desc *dev_desc, const char *disk_name, + char *response) +{ + lbaint_t written; + + debug("Start Erasing %s...\n", disk_name); + + written = fb_block_write(dev_desc, 0, dev_desc->lba, NULL); + if (written != dev_desc->lba) { + pr_err("Failed to erase %s\n", disk_name); + fastboot_response("FAIL", response, "Failed to erase %s", disk_name); + return; + } + + printf("........ erased " LBAFU " bytes from '%s'\n", + dev_desc->lba * dev_desc->blksz, disk_name); + fastboot_okay(NULL, response); +} + +void fastboot_block_raw_erase(struct blk_desc *dev_desc, struct disk_partition *info, + const char *part_name, uint alignment, char *response) +{ + lbaint_t written, blks_start, blks_size; + + if (alignment) { + blks_start = (info->start + alignment - 1) & ~(alignment - 1); + if (info->size >= alignment) + blks_size = (info->size - (blks_start - info->start)) & + (~(alignment - 1)); + else + blks_size = 0; + + printf("Erasing blocks " LBAFU " to " LBAFU " due to alignment\n", + blks_start, blks_start + blks_size); + } else { + blks_start = info->start; + blks_size = info->size; + } + + written = fb_block_write(dev_desc, blks_start, blks_size, NULL); + if (written != blks_size) { + fastboot_fail("failed to erase partition", response); + return; + } + + printf("........ erased " LBAFU " bytes from '%s'\n", + blks_size * info->blksz, part_name); + fastboot_okay(NULL, response); +} + +void fastboot_block_erase(const char *part_name, char *response) +{ + struct blk_desc *dev_desc; + struct disk_partition part_info; + + if (fastboot_block_get_part_info(part_name, &dev_desc, &part_info, response) < 0) + return; + + fastboot_block_raw_erase(dev_desc, &part_info, part_name, 0, response); +} + +void fastboot_block_write_raw_disk(struct blk_desc *dev_desc, const char *disk_name, + void *buffer, u32 download_bytes, char *response) +{ + lbaint_t blkcnt; + lbaint_t blks; + + /* determine number of blocks to write */ + blkcnt = ((download_bytes + (dev_desc->blksz - 1)) & ~(dev_desc->blksz - 1)); + blkcnt = lldiv(blkcnt, dev_desc->blksz); + + if (blkcnt > dev_desc->lba) { + pr_err("too large for disk: '%s'\n", disk_name); + fastboot_fail("too large for disk", response); + return; + } + + printf("Flashing Raw Image\n"); + + blks = fb_block_write(dev_desc, 0, blkcnt, buffer); + + if (blks != blkcnt) { + pr_err("failed writing to %s\n", disk_name); + fastboot_fail("failed writing to device", response); + return; + } + + printf("........ wrote " LBAFU " bytes to '%s'\n", blkcnt * dev_desc->blksz, + disk_name); + fastboot_okay(NULL, response); +} + +void fastboot_block_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; + } + + printf("Flashing Raw Image\n"); + + blks = fb_block_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); +} + +void fastboot_block_write_sparse_image(struct blk_desc *dev_desc, struct disk_partition *info, + const char *part_name, void *buffer, char *response) +{ + struct fb_block_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_block_sparse_write; + sparse.reserve = fb_block_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, part_name, buffer, + response); + if (!err) + fastboot_okay(NULL, response); +} + +void fastboot_block_flash_write(const char *part_name, void *download_buffer, + u32 download_bytes, char *response) +{ + struct blk_desc *dev_desc; + struct disk_partition part_info; + + if (fastboot_block_get_part_info(part_name, &dev_desc, &part_info, response) < 0) + return; + + if (is_sparse_image(download_buffer)) { + fastboot_block_write_sparse_image(dev_desc, &part_info, part_name, + download_buffer, response); + } else { + fastboot_block_write_raw_image(dev_desc, &part_info, part_name, + download_buffer, download_bytes, response); + } +} diff --git a/include/fb_block.h b/include/fb_block.h new file mode 100644 index 0000000000000000000000000000000000000000..189c708e2f0eaccf4871f68f93c8d38eabc4349a --- /dev/null +++ b/include/fb_block.h @@ -0,0 +1,105 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Copyright (C) 2024 The Android Open Source Project + */ + +#ifndef _FB_BLOCK_H_ +#define _FB_BLOCK_H_ + +struct blk_desc; +struct disk_partition; + +/** + * fastboot_block_get_part_info() - Lookup block partition by name + * + * @part_name: Named partition to lookup + * @dev_desc: Pointer to returned blk_desc pointer + * @part_info: Pointer to returned struct disk_partition + * @response: Pointer to fastboot response buffer + * Return: 0 on success, -ve on error + */ +int fastboot_block_get_part_info(const char *part_name, + struct blk_desc **dev_desc, + struct disk_partition *part_info, + char *response); + +/** + * fastboot_block_raw_erase() - Erase raw block device partition + * + * @dev_desc: Block device we're going write to + * @info: Partition we're going write to + * @part_name: Name of partition we're going write to + * @alignment: erase start and size alignment, specify 0 to ignore + * @response: Pointer to fastboot response buffer + */ +void fastboot_block_raw_erase(struct blk_desc *dev_desc, struct disk_partition *info, + const char *part_name, uint alignment, char *response); + +/** + * fastboot_block_raw_erase_disk() - Erase raw block device + * + * @dev_desc: Block device we're going write to + * @disk_name: Name of disk we're going write to + * @response: Pointer to fastboot response buffer + */ +void fastboot_block_raw_erase_disk(struct blk_desc *dev_desc, const char *disk_name, + char *response); + +/** + * fastboot_block_erase() - Erase partition on block device for fastboot + * + * @part_name: Named partition to erase + * @response: Pointer to fastboot response buffer + */ +void fastboot_block_erase(const char *part_name, char *response); + +/** + * fastboot_block_write_raw_disk() - Write raw image to block device + * + * @dev_desc: Block device we're going write to + * @disk_name: Name of disk we're going write to + * @buffer: Downloaded buffer pointer + * @download_bytes: Size of content on downloaded buffer pointer + * @response: Pointer to fastboot response buffer + */ +void fastboot_block_write_raw_disk(struct blk_desc *dev_desc, const char *disk_name, + void *buffer, u32 download_bytes, char *response); + +/** + * fastboot_block_write_raw_image() - Write raw image to block device partition + * + * @dev_desc: Block device we're going write to + * @info: Partition we're going write to + * @part_name: Name of partition we're going write to + * @buffer: Downloaded buffer pointer + * @download_bytes: Size of content on downloaded buffer pointer + * @response: Pointer to fastboot response buffer + */ +void fastboot_block_write_raw_image(struct blk_desc *dev_desc, + struct disk_partition *info, const char *part_name, + void *buffer, u32 download_bytes, char *response); + +/** + * fastboot_block_write_sparse_image() - Write sparse image to block device partition + * + * @dev_desc: Block device we're going write to + * @info: Partition we're going write to + * @part_name: Name of partition we're going write to + * @buffer: Downloaded buffer pointer + * @response: Pointer to fastboot response buffer + */ +void fastboot_block_write_sparse_image(struct blk_desc *dev_desc, struct disk_partition *info, + const char *part_name, void *buffer, char *response); + +/** + * fastboot_block_flash_write() - Write image to block device for fastboot + * + * @part_name: Named partition to write image to + * @download_buffer: Pointer to image data + * @download_bytes: Size of image data + * @response: Pointer to fastboot response buffer + */ +void fastboot_block_flash_write(const char *part_name, void *download_buffer, + u32 download_bytes, char *response); + +#endif // _FB_BLOCK_H_ From patchwork Thu May 22 12:37:06 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Neil Armstrong X-Patchwork-Id: 891705 Delivered-To: patch@linaro.org Received: by 2002:adf:e88a:0:b0:3a3:61c9:c5d4 with SMTP id d10csp2611024wrm; Thu, 22 May 2025 05:37:42 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCXJIyPFenhHkpJBoHRMwkrVIZM8CkU4C4lwpDovYxOjlBB3eb/LJaLXjCW8kI/hENrHrr9PuA==@linaro.org X-Google-Smtp-Source: AGHT+IEZtXrGIVkv/PyeU51vDjo1PCn3i2Oaarx56Z639vhReoRiw6IPmmEVGJG2hQmf9lqwiDve X-Received: by 2002:a5d:5f8a:0:b0:3a3:6b16:3bb3 with SMTP id ffacd0b85a97d-3a36b163d10mr14890724f8f.3.1747917461968; Thu, 22 May 2025 05:37:41 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1747917461; cv=none; d=google.com; s=arc-20240605; b=l1BqhRWL5AJJEXlbDiwQDqGGJzR3bK8L27dxiuiku6qE0K7RXwxaD4Jtpr6Rt8RoWz 8Uqtyni4tBfqQlTDIALn1oALvSnaGcd056lR0qfKr1ANQGMD8QIs1qdyNnbor9AJUuSq OalYtxZ4+Fd3tx8hi0owdOzHZAolOVZ6WP/mWwkoFTzJNZrLyEt5zsSRpsuN4b+cBZrn 74bR2FQ7UUBCbguqe7O5Ymg9elWZQyYJB0Xo7SwdmY9aEMuCwSek2SjuK4BEYiF28H+f S0Bp6bh6+EBK89nwmDXSTGSjpyfK0//tOfzLNokh54gr6X2jbtb0mpMVmrvu6vPday5J OrUg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20240605; h=sender:errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:cc:to:in-reply-to:references :message-id:content-transfer-encoding:mime-version:subject:date:from :dkim-signature; bh=Gyg5PpwU4CD9cJiRhZcK+WURB1BEd3sclML6Fqchsrs=; fh=+i+RTkrPvc0CCcB6rXKbnTZaOKShRvWA2CazXh31SXM=; b=hD0fPacIiZG40jO6LU6dN0SH5jTJ/waEPDcngYoEznX2raXV4oylR+6rIMo0jrLRv8 5ixnaxvsY0nDV/36zM7PZ4NZwfAazIobnHE23mT9SqvrqQD5hYYtGsWCm55az0PAsX6A yWo65RbmfRRfU5oc7z4Fkl6V+BZn7IMFFXiFuOiBv9FWLaTazOd3sesWjEcmLzpz6OfH IMRwpfT7IAAmUP9w45As1FXt0Keb2Bi8yZ36nVT2eLTMtdet4cfLA2VKPaBsN2k1N2cw 02Z/s8vL8q1gyRXXfAsKq+ANdhRUjr3Xm7xvGaWpgK9G+ji/tPreIAcxvtiUQcRMIPIZ Wj5A==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=mRsLarRL; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 2a01:238:438b:c500:173d:9f52:ddab:ee01 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org; dara=neutral header.i=@linaro.org Return-Path: Received: from phobos.denx.de (phobos.denx.de. [2a01:238:438b:c500:173d:9f52:ddab:ee01]) by mx.google.com with ESMTPS id ffacd0b85a97d-3a35ca80161si11346135f8f.285.2025.05.22.05.37.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 22 May 2025 05:37:41 -0700 (PDT) Received-SPF: pass (google.com: domain of u-boot-bounces@lists.denx.de designates 2a01:238:438b:c500:173d:9f52:ddab:ee01 as permitted sender) client-ip=2a01:238:438b:c500:173d:9f52:ddab:ee01; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=mRsLarRL; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 2a01:238:438b:c500:173d:9f52:ddab:ee01 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org; dara=neutral header.i=@linaro.org Received: from h2850616.stratoserver.net (localhost [IPv6:::1]) by phobos.denx.de (Postfix) with ESMTP id 652BC830CA; Thu, 22 May 2025 14:37:16 +0200 (CEST) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=u-boot-bounces@lists.denx.de Authentication-Results: phobos.denx.de; dkim=pass (2048-bit key; unprotected) header.d=linaro.org header.i=@linaro.org header.b="mRsLarRL"; dkim-atps=neutral Received: by phobos.denx.de (Postfix, from userid 109) id 7984D82F67; Thu, 22 May 2025 14:37:14 +0200 (CEST) X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on phobos.denx.de X-Spam-Level: X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_BLOCKED, SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.2 Received: from mail-wr1-x42c.google.com (mail-wr1-x42c.google.com [IPv6:2a00:1450:4864:20::42c]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits)) (No client certificate requested) by phobos.denx.de (Postfix) with ESMTPS id C518E8309A for ; Thu, 22 May 2025 14:37:09 +0200 (CEST) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=neil.armstrong@linaro.org Received: by mail-wr1-x42c.google.com with SMTP id ffacd0b85a97d-3a35b7e60cbso5427114f8f.1 for ; Thu, 22 May 2025 05:37:09 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1747917429; x=1748522229; darn=lists.denx.de; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=Gyg5PpwU4CD9cJiRhZcK+WURB1BEd3sclML6Fqchsrs=; b=mRsLarRLMMB/avMSaudxwlrfJarnxq3LLo+8qfnvOfDZpBbZfufw+CkEs8VX170wbJ XuCRgz8NY7V+dyoeRGx3dcOMQ9wNyxCxuVGLtQJ1KXS9xOwCUCSgOFQGf4iU9s3AqoBV 4NujKzDOBoRiawMb4klSCzDOa44NSxe4+H2rYyDBw6pxHwqXekgUuT+aL+eO1zlcPMOQ 1kQwFGSOnSQts1OWqztuGbEq73/pcC0nGEd5Oez1ZOEIgPN/J1RvauyO1La54M0qcSki nrDS0rTRwzvcEx/2ZcIwMlRd5TbBTPdX6tCorF3EnbRvMF8pM1wVqJMSx9L+bhlTSOHh l+jg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1747917429; x=1748522229; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=Gyg5PpwU4CD9cJiRhZcK+WURB1BEd3sclML6Fqchsrs=; b=vJIcXH1a2q4po7vFRp4nkS/Ien4TIePx5XA9Tqg43q7qOWepMYt8dLYPbUSEROxEP8 nmj3lcNkNiHohjraw+zvOhvvYRynbXe53HlnLRbn1Jt3RayGZ3bknJrRZsZ0eQ8+Wa16 LGziNXJdyr1UguSn0ZSY16HkHtv8Qc2mM99FQnCD4/7ZLaqQAtR/BX9mDPnraCXPKTYG v2EJqWm25a23ijWZ+pOd1x6KdmTmZAPiU3gqgd5U0uzpatIO8lBZyrOAEPvSLgYjmsOQ gOW2UTMkscldLrTmG3lk4orILKHuU94KLVokjcumV7kOzWzNjdQkrxi4AbaphV559lev fmlg== X-Gm-Message-State: AOJu0YyoIMBFjFpMEdwXdwtQpYpQ/uIdlT11b1zozpBdjm9eKAXD0qpH g1I7pxBlY43kRNXGs2wqrtz2VkuKGbOeCaqPN4oV0QFN55ZnJ/8rNrQ5JMMl8Fxt3bE= X-Gm-Gg: ASbGncubzwEh5dhyrYky82zo+aiX54JI7H3NM9LVisStEdeDM4pVRmcOybminzLynjQ tpRJqaMKGbTwap4gkC76/7vENjkE2J16YE3+NvecfGpDnHQ5OIvRXRMRJGmHYSMMe/JXLvP5XEu 4EiAVK8mzHkMCbl+z4FjbA0vgRcvl/ez6P/+tYzWvtANGBopeNTwiRLpxOIuJxISJEpGAabAyoA FT5B6DFLOkUWfY4DRr3orwYCmZy4hSH0FfC9LKogxOHBKkAq1JSFQkkhs5+D+g8EOk/EcNOdudN 6p1LdE6vCry8H3LvBZ/2XLIpBZyjUsijPwQjuX1kJJJkbY62j6RplqudwQK9HKVgD+tIG73c X-Received: by 2002:a05:6000:40db:b0:3a3:7465:7e60 with SMTP id ffacd0b85a97d-3a374657eb0mr13816352f8f.26.1747917429098; Thu, 22 May 2025 05:37:09 -0700 (PDT) Received: from arrakeen.starnux.net ([2a01:e0a:3d9:2080:8261:5fff:fe11:bdda]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-447f38145eesm102271045e9.26.2025.05.22.05.37.08 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 22 May 2025 05:37:08 -0700 (PDT) From: Neil Armstrong Date: Thu, 22 May 2025 14:37:06 +0200 Subject: [PATCH RFT v4 2/3] fastboot: blk: switch emmc to use the block helpers MIME-Version: 1.0 Message-Id: <20250522-topic-fastboot-blk-v4-2-af7f7f30564d@linaro.org> References: <20250522-topic-fastboot-blk-v4-0-af7f7f30564d@linaro.org> In-Reply-To: <20250522-topic-fastboot-blk-v4-0-af7f7f30564d@linaro.org> To: Tom Rini , Mattijs Korpershoek , Mattijs Korpershoek Cc: u-boot@lists.denx.de, Neil Armstrong , Dmitrii Merkurev X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=10219; i=neil.armstrong@linaro.org; h=from:subject:message-id; bh=uMz8CRy7r5aiY+RXMuwlpDrNuBnn/k4JkniSgEy84VI=; b=owEBbQKS/ZANAwAKAXfc29rIyEnRAcsmYgBoLxpyiSp2a6yIrpB5IO/1LA/jySFKugv0Wu8ibbQy w26qbUqJAjMEAAEKAB0WIQQ9U8YmyFYF/h30LIt33NvayMhJ0QUCaC8acgAKCRB33NvayMhJ0edLEA CyQ1/wU4PrbwFO+ud/MUBj6DFSqlIWchKYjxsaJRINxQl5pqvth1DBfHiaXtrhyd9la4TjAHIyTFX0 wVop2F2uMTFrYVMbgtEH70Lt4+m3Ry8beskrfXh7YEk0O+OsdfbncEO+V1FOebhGOMSKyDunYP8HrA zcgkg/goFkLstDdZLJvxhqf8HeT52Vn4bzaodhmt2s6Hl39qesoZceendR/QENd4ra6NaO3Zjw0VjF ORv/L6YQV5AutWTe+J6akOHea/dnP1q9COJLFosS8mKlCCZOv1ENtHoGhqXI/C8DXNFlApIpzdbLhG Y+7bAuOUhRIwvIlU58p6PGdGjJgDYZS1096svNG/vEfWLOhfcMebEzJOrCNgOVmx+dkXiFLypTXjS0 DmUUjGATS0AWklaHhHEqWyKHvG3+iv2oJauhaAKwuNM/gV641DUIwDnScFjzoraMtSLy/wlTuyuU+7 zim0qZzououhdLhFLWZ7m2nSKJeFhr3ucCIhuuDWRNpR/Gf7T1pPaMFuD2yrjkt2EZ4cEF0iI1S33k +JuIcmHbxc0eL/Nkrbu6d84XTS+9mzcCSFG/wDgHNDFj07RJVxybK+HGNX58D2Vyy+p4oF9rr7587P XSSiFJ1itx0jfu6jRrKMynCC9zV+cEgMUv3cWpWy+iLb7YH9N0pbQ4KPuAvA== X-Developer-Key: i=neil.armstrong@linaro.org; a=openpgp; fpr=89EC3D058446217450F22848169AB7B1A4CFF8AE X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.39 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: u-boot-bounces@lists.denx.de Sender: "U-Boot" X-Virus-Scanned: clamav-milter 0.103.8 at phobos.denx.de X-Virus-Status: Clean From: Dmitrii Merkurev Switch the mmc backend to this new shared block helpers, reducing block logic and only leaving MMC specific logic. Signed-off-by: Dmitrii Merkurev Reviewed-by: Mattijs Korpershoek Tested-by: Mattijs Korpershoek Signed-off-by: Neil Armstrong --- drivers/fastboot/Kconfig | 4 +- drivers/fastboot/Makefile | 3 +- drivers/fastboot/fb_mmc.c | 210 +++------------------------------------------- 3 files changed, 16 insertions(+), 201 deletions(-) diff --git a/drivers/fastboot/Kconfig b/drivers/fastboot/Kconfig index 70207573de2bd0d56b4b7fa6f7e17fdc5803ba15..33825ee408fbd9aff26cd390a140421c7c98ecc3 100644 --- a/drivers/fastboot/Kconfig +++ b/drivers/fastboot/Kconfig @@ -91,7 +91,7 @@ config FASTBOOT_USB_DEV config FASTBOOT_FLASH bool "Enable FASTBOOT FLASH command" default y if ARCH_SUNXI || ARCH_ROCKCHIP - depends on MMC || (MTD_RAW_NAND && CMD_MTDPARTS) + depends on MMC || (MTD_RAW_NAND && CMD_MTDPARTS) || BLK select IMAGE_SPARSE help The fastboot protocol includes a "flash" command for writing @@ -113,7 +113,7 @@ choice config FASTBOOT_FLASH_MMC bool "FASTBOOT on MMC" - depends on MMC + depends on MMC && BLK config FASTBOOT_FLASH_NAND bool "FASTBOOT on NAND" diff --git a/drivers/fastboot/Makefile b/drivers/fastboot/Makefile index 048af5aa823436956142a536c5f7dcf1a8948726..c2214c968ab357371f5d3d27ecc9c1a3e9404e89 100644 --- a/drivers/fastboot/Makefile +++ b/drivers/fastboot/Makefile @@ -3,5 +3,6 @@ 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 diff --git a/drivers/fastboot/fb_mmc.c b/drivers/fastboot/fb_mmc.c index dca7c222f35659b22d327541b245760a6a6d7b35..11d9c8e84602c7434733c060b84c91c38772ac9f 100644 --- a/drivers/fastboot/fb_mmc.c +++ b/drivers/fastboot/fb_mmc.c @@ -8,6 +8,7 @@ #include #include #include +#include #include #include #include @@ -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); } From patchwork Thu May 22 12:37:07 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Neil Armstrong X-Patchwork-Id: 891704 Delivered-To: patch@linaro.org Received: by 2002:adf:e88a:0:b0:3a3:61c9:c5d4 with SMTP id d10csp2610959wrm; Thu, 22 May 2025 05:37:33 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCXDuVUXlC+TbvxF/eVbMJILT2Axex6jE5UT1RY8Xc46eV+6du9xuPuz4d2CPXIoJh7mcL2DQw==@linaro.org X-Google-Smtp-Source: AGHT+IHZj0FWlC68I5q5VkGE3wXGKRVGOOhl8kaW4HFlpkTgyVJdZUgQEZLVPGUt1q2Btbx+Aq17 X-Received: by 2002:a05:6000:1848:b0:3a3:64d5:5b5b with SMTP id ffacd0b85a97d-3a364d55c21mr19142302f8f.5.1747917452788; Thu, 22 May 2025 05:37:32 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1747917452; cv=none; d=google.com; s=arc-20240605; b=DtzQcM2Lpa88o3RGrvYYPdchdOk0d5lHhppCKa552Yw7NyEWAlWSsguvADp7cL8M9n +w67fnZkqSUhWFGW8+lmAnwXH8bcWKtagqBrvAywKLRKn4EV33Ry0ReFBstCmlM42McF iU5RC7/hEVepPTXYPctUvqRhpm9gfhsE8mdN/Td8pVMd3eYBtiryQoBLWsvN5FGMF/f3 WB5bUpmtRs+TvJ9pjIv7wNubnb/hYeUsViQOwvFw5+UejEJn1EpSnk6UxvGX/DU24wYZ BUKl4lAxvXV+q14Gy14Dj8qwjvUaEIzBXGiJjDUGHgQ3kimIIzTmFYE63acxWMlATzBs WMwA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20240605; h=sender:errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:cc:to:in-reply-to:references :message-id:content-transfer-encoding:mime-version:subject:date:from :dkim-signature; bh=FuuqfMQ8lg9iQu/AzUV9PTzWCbszBbS9wH7Up4Yct6c=; fh=+i+RTkrPvc0CCcB6rXKbnTZaOKShRvWA2CazXh31SXM=; b=WHDbhk7v9prAimQovLKnwR1A6DY1J84gA5SMDgEzkm4vI4Zbzph1IbTox2Kbu9/P1u uKO5FjL5AxP/xrHkv2S0O/4qsAlBH2okagYKbTwxUstGYNyW/cSmESedrhN4ViEboEid GeNdTLXiwaqgY8Z4/6vmPTi3zajAXNBU5jMDTJooG94p3QfFTyJAzMehuG4wXDgXgulR lhHc8XhgfwAbSm1iMwI2QNvhMbLli4j2RF2Qzp5C7X7YEEAyXatIvgpAkLBftuory99j oyhSd01eLn5XnPZ9tgWpa/lbY/UZ66dHoee7oknhqIZ8818sphX9Wc1QAB+PrntbBdmk EKcQ==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=QrjTH4SM; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 2a01:238:438b:c500:173d:9f52:ddab:ee01 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org; dara=neutral header.i=@linaro.org Return-Path: Received: from phobos.denx.de (phobos.denx.de. [2a01:238:438b:c500:173d:9f52:ddab:ee01]) by mx.google.com with ESMTPS id ffacd0b85a97d-3a35ca93692si11271817f8f.838.2025.05.22.05.37.32 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 22 May 2025 05:37:32 -0700 (PDT) Received-SPF: pass (google.com: domain of u-boot-bounces@lists.denx.de designates 2a01:238:438b:c500:173d:9f52:ddab:ee01 as permitted sender) client-ip=2a01:238:438b:c500:173d:9f52:ddab:ee01; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=QrjTH4SM; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 2a01:238:438b:c500:173d:9f52:ddab:ee01 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org; dara=neutral header.i=@linaro.org Received: from h2850616.stratoserver.net (localhost [IPv6:::1]) by phobos.denx.de (Postfix) with ESMTP id 10AC2830B4; Thu, 22 May 2025 14:37:16 +0200 (CEST) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=u-boot-bounces@lists.denx.de Authentication-Results: phobos.denx.de; dkim=pass (2048-bit key; unprotected) header.d=linaro.org header.i=@linaro.org header.b="QrjTH4SM"; dkim-atps=neutral Received: by phobos.denx.de (Postfix, from userid 109) id D7F0C830AF; Thu, 22 May 2025 14:37:13 +0200 (CEST) X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on phobos.denx.de X-Spam-Level: X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_BLOCKED, SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.2 Received: from mail-wm1-x329.google.com (mail-wm1-x329.google.com [IPv6:2a00:1450:4864:20::329]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits)) (No client certificate requested) by phobos.denx.de (Postfix) with ESMTPS id 4E98182F67 for ; Thu, 22 May 2025 14:37:10 +0200 (CEST) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=neil.armstrong@linaro.org Received: by mail-wm1-x329.google.com with SMTP id 5b1f17b1804b1-441d437cfaaso49853375e9.1 for ; Thu, 22 May 2025 05:37:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1747917430; x=1748522230; darn=lists.denx.de; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=FuuqfMQ8lg9iQu/AzUV9PTzWCbszBbS9wH7Up4Yct6c=; b=QrjTH4SMXxy5L5+GdIH9uhA39V8U2uYDLClLEwMsqmcwGiRbQQGbWeJI/TtCtfWgR9 EiUx6lxUWSZ6RAgwaX9exnPlEiFSwetDSnS0G5o8IJOfbx7WIZy5hQsR1he924C671KV CTyRS7A+KOZ84n6RVv0OJM1XPViFPFuJxbmT1S2MDDCpG5Cx0hGgCugFZkmiQnb04gzv 12RlBdrmmf8Vu2riUMfui5j5/oTemlEzMoRQJDztoVHjrynIkHCtSatYkZtOl2F+ffKg WVeVfJSFCRE08l+D6zen05pYQA8FmPv2W4G2LrXGGOfyV9Pi13A8YDuZ6kcvEGtxI0N6 9VJQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1747917430; x=1748522230; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=FuuqfMQ8lg9iQu/AzUV9PTzWCbszBbS9wH7Up4Yct6c=; b=iKt+U+3jUnC2fNU9ETYfw55/jfvqJ9FqTZmX669Wcgp9o7O8LTokwHnx+FKyinUp4k FcYJpaZ1/HmjGN8qRCcBeIm+9DytcLPLvnwqNwW3bs4Bz4MdQ84/HRBrmjLtwwYMLaH+ d5IB7aTSRvRJMOFZuGqsB6FnADpKbk5ZcIgYZ5bgQA5LdSagFHCOHuCGSkYnipuMXMyu oDCbqUOdPGL1oUIUZmgKr8uRh1Z2SnLtTvajr/JGqA91fNcAGO2LxDAF0q39iNO9pr8s 9g0xLu9sc1ayCj+JBzmhF6jfB1fDl6Dwctb5ZqHsrUcg2QZ2aQMGlsUO5ji8xwuc45US Z0VQ== X-Gm-Message-State: AOJu0YxHPRWH5dlk65d3KXXHUD5LqWkKERMS+8aA22SyqLYba0iRKVNl S5pjXFMyVoeCFkIhcf5bRcDHVN6Pc7nvfnzCcIDSjxG6niep2eHICEtcS/3wrLK3L78= X-Gm-Gg: ASbGncuHF2JdkQYCw8JAwgUvuB2M1IR9C3apYDT5wnOfmjP7TNIJksLO/vN+IuGN7jF C93yTVWm3kVRdGjBglKjO4rjP3f5KK6Ib36igyV7pN8W+tfENDsNiTLOxaCjj0q3IFcnf8ysJOD 6sFdJyR8JT6aGrY5Bhu2cnYREWWgm2kOEhHCw5/isKK4CjS8gbPsZeNG1GEcDvIv1gIgAC/SUez KjzxTA7qNJTXPOgRNIJScQmBcPKLENzoxUzrzQY46KWwcxZJNO0FCk9P4R0x93D4oNxHzABg0ba EhHJVhwwYbXHKMosS1U6BYrIeYAWhvtfMstAM4fZWsU2oEGa8ipvP/DnMLEbFoyH4672PM0Zjfc DPyOJODQ= X-Received: by 2002:a05:600c:3b86:b0:43c:f513:958a with SMTP id 5b1f17b1804b1-442fefee241mr197404205e9.13.1747917429692; Thu, 22 May 2025 05:37:09 -0700 (PDT) Received: from arrakeen.starnux.net ([2a01:e0a:3d9:2080:8261:5fff:fe11:bdda]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-447f38145eesm102271045e9.26.2025.05.22.05.37.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 22 May 2025 05:37:09 -0700 (PDT) From: Neil Armstrong Date: Thu, 22 May 2025 14:37:07 +0200 Subject: [PATCH RFT v4 3/3] fastboot: integrate block flashing back-end MIME-Version: 1.0 Message-Id: <20250522-topic-fastboot-blk-v4-3-af7f7f30564d@linaro.org> References: <20250522-topic-fastboot-blk-v4-0-af7f7f30564d@linaro.org> In-Reply-To: <20250522-topic-fastboot-blk-v4-0-af7f7f30564d@linaro.org> To: Tom Rini , Mattijs Korpershoek , Mattijs Korpershoek Cc: u-boot@lists.denx.de, Neil Armstrong , Dmitrii Merkurev X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=7093; i=neil.armstrong@linaro.org; h=from:subject:message-id; bh=I2XfY0aQLJO/FWUs4f6+IXGVMeuS/xUx6DP9kROkGoY=; b=owEBbQKS/ZANAwAKAXfc29rIyEnRAcsmYgBoLxpyBPqzTu6xa3oPkVbT1zCyBloRVf1HaMHWZTmG BIJWxnmJAjMEAAEKAB0WIQQ9U8YmyFYF/h30LIt33NvayMhJ0QUCaC8acgAKCRB33NvayMhJ0Q8dEA CdE2tu6aOPbSKFEwRKc6TkiFhtYxcLi9E0JqZll/JodV3Wt7ZvmuOde665JmYDf0OigbuDNj2PkJjQ CzsAT1h60svzfwIpuKMB/OMaxWyzx7BCb/g+C04hYZL4tuvErlFBHMPnfhzUhMt+cqIj6aBJyZDMqM yQ79Ynu0isgd2YSmoDoH4jrIDhHLBfhHOBqNky+jyq2binnfi5vlTXLIkDZLrqHZAjW36GHcKKAJIt IIwNIkeTQJs3nBJGOXKKpixii9bLZZw8DU8bgGsHWFy9UjvWTYImVf8UpxIxB3pYwUlr2rl7pc3ebY ghcHQrLPiEY7tY6BsvPoo7BJKjqLh2NqxvWmlHnEbnqLg1MamUYB5tnv+wiZD2lPJkXeBWarcD8q+k NqoyjIQ3BL5pNdtQV5bwhYtw10yw8JGVXnyjALNVSFQNpLiMKU+NZjd5aKMtwxAmbj3Zhez7+ULQxc XHfJ8LinpwvhF8cvT0qtw0ldwksgEKczNEp3/ISWqHn5G18lhCvaitqhwyS/UAxxWPO46prU0yH812 C5nW2Wz3EUIYYNuebyBz5BOBwfb6WwrvrrtYnZkWh11qb8C3sshGDUVaocGb+kc4e45GGlhyYN7t76 NJkssHhB9BdBL3io+yUSh+sTmytpYFJlBI1PqJnrKuDobEjkROyX9Hh6yF0g== X-Developer-Key: i=neil.armstrong@linaro.org; a=openpgp; fpr=89EC3D058446217450F22848169AB7B1A4CFF8AE X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.39 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: u-boot-bounces@lists.denx.de Sender: "U-Boot" X-Virus-Scanned: clamav-milter 0.103.8 at phobos.denx.de X-Virus-Status: Clean From: Dmitrii Merkurev 1. Get partition info/size 2. Erase partition 3. Flash partition 4. BCB Signed-off-by: Dmitrii Merkurev Reviewed-by: Mattijs Korpershoek Tested-by: Mattijs Korpershoek Signed-off-by: Neil Armstrong --- drivers/fastboot/Kconfig | 29 +++++++++++++++++++++++++++++ drivers/fastboot/Makefile | 1 + drivers/fastboot/fb_command.c | 8 ++++++++ drivers/fastboot/fb_common.c | 22 ++++++++++++++++++---- drivers/fastboot/fb_getvar.c | 8 +++++++- 5 files changed, 63 insertions(+), 5 deletions(-) diff --git a/drivers/fastboot/Kconfig b/drivers/fastboot/Kconfig index 33825ee408fbd9aff26cd390a140421c7c98ecc3..2ea5b7f73c1338ad435e87cb1ecfbcc7728f2244 100644 --- a/drivers/fastboot/Kconfig +++ b/drivers/fastboot/Kconfig @@ -119,6 +119,10 @@ config FASTBOOT_FLASH_NAND bool "FASTBOOT on NAND" depends on MTD_RAW_NAND && CMD_MTDPARTS +config FASTBOOT_FLASH_BLOCK + bool "FASTBOOT on block device" + depends on BLK + endchoice config FASTBOOT_FLASH_MMC_DEV @@ -193,6 +197,31 @@ config FASTBOOT_MMC_USER_NAME defined here. The default target name for erasing EMMC_USER is "mmc0". +config FASTBOOT_FLASH_BLOCK_INTERFACE_NAME + string "Define FASTBOOT block interface name" + depends on FASTBOOT_FLASH_BLOCK + default "" + help + The fastboot "flash" and "erase" commands support operations + on any Block device, this should specify the block device name + like ide, scsi, usb, sata, nvme, virtio, blkmap, mtd... + The mmc block device type can be used but most of the features + available in the FASTBOOT_MMC will be missing. + Consider using FASTBOOT_MMC on a MMC block device until all + features are migrated. + +config FASTBOOT_FLASH_BLOCK_DEVICE_ID + int "Define FASTBOOT block device identifier" + depends on FASTBOOT_FLASH_BLOCK + default 0 + help + The fastboot "flash" and "erase" commands support operations + on any Block device, this should specify the block device + identifier on the system, as a number. + The device identifier should be 0 for first device on the + interface type specified in FLASH_BLOCK_INTERFACE_NAME config, + 1 the second, etc... + config FASTBOOT_GPT_NAME string "Target name for updating GPT" depends on FASTBOOT_FLASH_MMC && EFI_PARTITION diff --git a/drivers/fastboot/Makefile b/drivers/fastboot/Makefile index c2214c968ab357371f5d3d27ecc9c1a3e9404e89..91e98763e8eab84ccd9b8e5354ff1419f61ef372 100644 --- a/drivers/fastboot/Makefile +++ b/drivers/fastboot/Makefile @@ -3,6 +3,7 @@ obj-y += fb_common.o obj-y += fb_getvar.o obj-y += fb_command.o +obj-$(CONFIG_FASTBOOT_FLASH_BLOCK) += fb_block.o # MMC reuses block implementation obj-$(CONFIG_FASTBOOT_FLASH_MMC) += fb_block.o fb_mmc.o obj-$(CONFIG_FASTBOOT_FLASH_NAND) += fb_nand.o diff --git a/drivers/fastboot/fb_command.c b/drivers/fastboot/fb_command.c index 2cdbac50ac4a0ce501753e95c1918ffa5d11158d..e6aee13e01618ee6567bf00527d3df327ae06f1c 100644 --- a/drivers/fastboot/fb_command.c +++ b/drivers/fastboot/fb_command.c @@ -8,6 +8,7 @@ #include #include #include +#include #include #include #include @@ -337,6 +338,10 @@ void fastboot_data_complete(char *response) */ static void __maybe_unused flash(char *cmd_parameter, char *response) { + if (IS_ENABLED(CONFIG_FASTBOOT_FLASH_BLOCK)) + fastboot_block_flash_write(cmd_parameter, fastboot_buf_addr, + image_size, response); + if (IS_ENABLED(CONFIG_FASTBOOT_FLASH_MMC)) fastboot_mmc_flash_write(cmd_parameter, fastboot_buf_addr, image_size, response); @@ -357,6 +362,9 @@ static void __maybe_unused flash(char *cmd_parameter, char *response) */ static void __maybe_unused erase(char *cmd_parameter, char *response) { + if (IS_ENABLED(CONFIG_FASTBOOT_FLASH_BLOCK)) + fastboot_block_erase(cmd_parameter, response); + if (IS_ENABLED(CONFIG_FASTBOOT_FLASH_MMC)) fastboot_mmc_erase(cmd_parameter, response); diff --git a/drivers/fastboot/fb_common.c b/drivers/fastboot/fb_common.c index 68f92c4b887c8442cc212b8613fb70c7251cdcdf..dac5528f80908bf5b1224284c9ecd492394e4f0e 100644 --- a/drivers/fastboot/fb_common.c +++ b/drivers/fastboot/fb_common.c @@ -97,16 +97,24 @@ int __weak fastboot_set_reboot_flag(enum fastboot_reboot_reason reason) [FASTBOOT_REBOOT_REASON_FASTBOOTD] = "boot-fastboot", [FASTBOOT_REBOOT_REASON_RECOVERY] = "boot-recovery" }; - const int mmc_dev = config_opt_enabled(CONFIG_FASTBOOT_FLASH_MMC, - CONFIG_FASTBOOT_FLASH_MMC_DEV, -1); - if (!IS_ENABLED(CONFIG_FASTBOOT_FLASH_MMC)) + int device = config_opt_enabled(CONFIG_FASTBOOT_FLASH_BLOCK, + CONFIG_FASTBOOT_FLASH_BLOCK_DEVICE_ID, -1); + if (device == -1) { + device = config_opt_enabled(CONFIG_FASTBOOT_FLASH_MMC, + CONFIG_FASTBOOT_FLASH_MMC_DEV, -1); + } + const char *bcb_iface = config_opt_enabled(CONFIG_FASTBOOT_FLASH_BLOCK, + CONFIG_FASTBOOT_FLASH_BLOCK_INTERFACE_NAME, + "mmc"); + + if (device == -1) return -EINVAL; if (reason >= FASTBOOT_REBOOT_REASONS_COUNT) return -EINVAL; - ret = bcb_find_partition_and_load("mmc", mmc_dev, "misc"); + ret = bcb_find_partition_and_load(bcb_iface, device, "misc"); if (ret) goto out; @@ -226,8 +234,14 @@ void fastboot_set_progress_callback(void (*progress)(const char *msg)) */ void fastboot_init(void *buf_addr, u32 buf_size) { +#if IS_ENABLED(CONFIG_FASTBOOT_FLASH_BLOCK) + if (!strcmp(CONFIG_FASTBOOT_FLASH_BLOCK_INTERFACE_NAME, "mmc")) + printf("Warning: the fastboot block backend features are limited, consider using the MMC backend\n"); +#endif + fastboot_buf_addr = buf_addr ? buf_addr : (void *)CONFIG_FASTBOOT_BUF_ADDR; fastboot_buf_size = buf_size ? buf_size : CONFIG_FASTBOOT_BUF_SIZE; fastboot_set_progress_callback(NULL); + } diff --git a/drivers/fastboot/fb_getvar.c b/drivers/fastboot/fb_getvar.c index 9c2ce65a4e5bce0da6b18aa1b2818f7db556c528..f083b21c797dc7e55315f2cba017a4372483fa92 100644 --- a/drivers/fastboot/fb_getvar.c +++ b/drivers/fastboot/fb_getvar.c @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include @@ -114,7 +115,12 @@ static int getvar_get_part_info(const char *part_name, char *response, struct disk_partition disk_part; struct part_info *part_info; - if (IS_ENABLED(CONFIG_FASTBOOT_FLASH_MMC)) { + if (IS_ENABLED(CONFIG_FASTBOOT_FLASH_BLOCK)) { + r = fastboot_block_get_part_info(part_name, &dev_desc, &disk_part, + response); + if (r >= 0 && size) + *size = disk_part.size * disk_part.blksz; + } else if (IS_ENABLED(CONFIG_FASTBOOT_FLASH_MMC)) { r = fastboot_mmc_get_part_info(part_name, &dev_desc, &disk_part, response); if (r >= 0 && size)