From patchwork Fri Jun 6 09:33: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: 894448 Delivered-To: patch@linaro.org Received: by 2002:a05:6000:ecd:b0:3a4:ee3f:8f15 with SMTP id ea13csp403698wrb; Fri, 6 Jun 2025 02:33:23 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCWRPxeEF2Nyp9/4z/MzQIjMi6VZp69DnvXL6nx7y6+HT34nHNt2/gwhcIdzUYFrsbMo70l6NA==@linaro.org X-Google-Smtp-Source: AGHT+IGKWgqEBHuPzLeAtQZH3saiOMnR36dg4b0OGB265qmX2iqPbU+ox3belgdnfvGsvxfNpwxr X-Received: by 2002:a17:907:c1c:b0:ad2:3fa9:7511 with SMTP id a640c23a62f3a-ade1ab87348mr213769866b.41.1749202403596; Fri, 06 Jun 2025 02:33:23 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1749202403; cv=none; d=google.com; s=arc-20240605; b=h942YY78U+pebX19zzY05DEiA9L9uspXszO0S7rqYCuuJzuDXYap8++QgGZDbgNTOV 9e/oCJcAUCY2ne+VPsuZv3wtGvYRAtFHiLIX9T3uAMpSQGq9XH44W82v/N5RPnGW+UFK oHNin1wIl/Om0i6OFdrwBg0NKNAmLdH64RIyUmcw7DJ6H7RTyBxluR7+5jbGPeq8qzni vOA7ZXzrqi5LMsj7IUQDYN0m21MOXqKwpC8Y1XQqAB2w1xEdnCWX+pVvVJT1OEhV90BU 0g03L1RBV7i5/nox770C85vQhaPKV0BxjQXDyf+qiluxjgUoV/mhsZqHUZe1iGe1z+ym /Q1g== 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=Mugt6E4XQOEVLwVb65poXSfkSGUkGKE/BBJmvT5FtYVPyQM784Tc4Wgyqjju5zMOR+ XrIgK+Z40Dm/PbMpdIG8MlWjw/WWFQhD78Gcs2FJtOg3g88VzFll+Fa8XWIrhEbNJcl7 TaQV+xSt0rOatFlknhcOwlTU9jGPoVGYvmNwqaaUHv0bbJWo0QYr9wijkb4KZhM4GtMi OwbGBOTJRHrAa4jo+WsrpldTatYoYQ5/M1lLViNqCPRXTv0xkUm1XdvQ+ztUpZJ2BnVl aPDFr9vGaXSZrpmzsatHETcUlr6IQZISuIY2Ppz+Vrl18uvOBKBs9O/pdI9SP/tJ4zwZ L1/A==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=TGSJwguz; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 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. [85.214.62.61]) by mx.google.com with ESMTPS id a640c23a62f3a-ade1d754989si125585166b.41.2025.06.06.02.33.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 06 Jun 2025 02:33:23 -0700 (PDT) Received-SPF: pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 as permitted sender) client-ip=85.214.62.61; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=TGSJwguz; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 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 977B182B00; Fri, 6 Jun 2025 11:33: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="TGSJwguz"; dkim-atps=neutral Received: by phobos.denx.de (Postfix, from userid 109) id E42E5828F8; Fri, 6 Jun 2025 11:33: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-x333.google.com (mail-wm1-x333.google.com [IPv6:2a00:1450:4864:20::333]) (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 A074382A8D for ; Fri, 6 Jun 2025 11:33:11 +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-x333.google.com with SMTP id 5b1f17b1804b1-450cf214200so17000345e9.1 for ; Fri, 06 Jun 2025 02:33:11 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1749202391; x=1749807191; 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=TGSJwguzbK+J/pW1OXqA9fS2W8LJO0zR5484OG9hhxgsXC0jMdzc2GiiVO3lxLTpjo RUXkHLsJVYWXN/L/p9uB1+jg++whyZVZPNfeyvQZ1YQHCKUasOtPKjo7BwFEMLNWm7K2 zKFQiUmm6eF1XkvS62m9xoR1tmKgLnrKuKpBQRrf6o9v1i8UqRZ7rLc+vZs99OPlkM0F 0VRQGVftlGh7BfzUgrZnPSxr7E9YpmhUgYy0de6BrINQ5xL5ZMhntMSjyIlgZuxUnwtT S9pHOqQ5/4w7g8BH5nV/ma06S1mnGH6dlFtsOj43UlMwBh2fEhRpNZ/sHidylXa2VkWt lOQA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1749202391; x=1749807191; 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=Vluy8f+nb1QHtdXumuMxZjSwPGZPZXb3eRuJC23/gg/juDLnHqNiX0VX60N38ZPZVk siOht1BN62AMjgQ/tQV2rZi0IARwQ6KCsy4Art9f8bA50B9f9jEo1C09Zxow2Gri1Nmx AzDkxE4VDVetOBeYWEH3Id9zTILfmQFOhvvPi39ci7ZNgrbTMseaQiqYQbzEc6M+MQ5n PAGOfTXOx45LomSNTQmjac102v16kLpNfun5dwfMr28eQr7paFu6OYLUvN0iBKOMnQys AnCGTVLPTHVarivAG3IkjnVa6QR/980+5kntETXLt6ELr8weh7uGKSyD0pFDZLy6IKtI Kl7w== X-Gm-Message-State: AOJu0Yxe+zJFV27GJ4A7W/vaZQ+QB71ELn06EEmTgdNgMcjbQXjAIHUM 6FzEH8qM1ntIGXCap1l/+xdbll36m8bzao+7aHePC0UKj2CqnIuCwlLE/i/UbYnHF1c= X-Gm-Gg: ASbGncva2EFI4vSB8bDdhYZ2R+Wtp6fcE65/10J4SItZxyAWhtg45vmHUQ64VR5+60B clRBOWpvVrbiS0QXpOWiBcOplN/nKVCWIplIfZ6rL67mMT8RwHc8MvAxDVqTKA0bschmoYOyS4x MR/xVVDfcAJPOuhVxMPBUlAJSfLc/SjkhLLPOkjmVdJh99Pxs1UuNrdZILEpbjqQQAUczj/Bvn3 V3A1TpW5e2KMbLy30u/HH/7W7HxOtuQ0Y87ll3JeSaIGm2xn9IShkjA+itzgOho27sl2TCaKG/X 87wJcllAeqKp8BxvosIPqPGGmULbaV1F6CoMOcal8MrCiLKQgh6dPkBihzeZgdLps65PoIMzY16 YnB5nvHQ= X-Received: by 2002:a5d:588f:0:b0:3a4:eeb5:21cb with SMTP id ffacd0b85a97d-3a53189ec50mr2243634f8f.26.1749202390956; Fri, 06 Jun 2025 02:33:10 -0700 (PDT) Received: from arrakeen.starnux.net ([2a01:e0a:3d9:2080:52eb:f6ff:feb3:451a]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3a532452d7esm1302439f8f.85.2025.06.06.02.33.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 06 Jun 2025 02:33:10 -0700 (PDT) From: Neil Armstrong Date: Fri, 06 Jun 2025 11:33:07 +0200 Subject: [PATCH RFT v5 1/3] fastboot: blk: introduce fastboot block flashing support MIME-Version: 1.0 Message-Id: <20250606-topic-fastboot-blk-v5-1-203538ec5b32@linaro.org> References: <20250606-topic-fastboot-blk-v5-0-203538ec5b32@linaro.org> In-Reply-To: <20250606-topic-fastboot-blk-v5-0-203538ec5b32@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/ZANAwAKAXfc29rIyEnRAcsmYgBoQrXU0YwPz30DPkA0C2KKGiN+xTbwgTbdgnoqbcES zmixeA+JAjMEAAEKAB0WIQQ9U8YmyFYF/h30LIt33NvayMhJ0QUCaEK11AAKCRB33NvayMhJ0YQIEA CFJ+tD8omS7p9CKcj7OZS9DGHZ+eiBNWQloKgD+B8Ufva5cWYpfybDVS5RVz66JfJNCUG+j9e8Z6Xl pt/U2Oh9SW2cmZwv6cUBVE85lbsG07azOETanC4QXvNe56vLU+WmgMlW21ImQKu7d0dGftZ10P8Jhx KLCwrRoKHnDgRKB849QUEx0lML1s7C/orLrda+9QNZHUjRMmc43uKFNT8yS5lIxu7rqlthUsVtTW4L Slhe62zzm3tQwNPTY1CjSEUDYT4A7wLVcpqVYbqT6vWCY3OZeat5Aon5hiBwEx00x/rf+RZHTmMdts psAHgBHvO2judfMW+yq4fWGtJ/it4+PFFwEOeTayzcI/vPZaCTJzcyBJ7HMg+dKe1dPHWAzCs6j/8g /FG5+SkXRwsWnasNWdDOaMec8nqbpfL6H7oT1QjiJEGSDp7OaKThk3ybK21YddSY5y6q5l5Pg+oNAp qpuUigH89+9XG1LCb6+ORzDbV1qIDsyyIE4j8vf5zijPzVXWZpdigNKlNFAoLkCfoAuo8GLDFnik41 a3fPZVedplO/5zEw3SXjcce9YfsOG2NHenOpopEUxob4E20/cRNQTeYNVNcLJzENqySIHFxIi3wRUH OV5F98OUWgSBAyoZ0CjSGteVwgrNyKHXkO5U5+MP8WYVwztfDeWxx3xJXDKA== 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 Fri Jun 6 09:33:08 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Neil Armstrong X-Patchwork-Id: 894450 Delivered-To: patch@linaro.org Received: by 2002:a05:6000:ecd:b0:3a4:ee3f:8f15 with SMTP id ea13csp403803wrb; Fri, 6 Jun 2025 02:33:40 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCXZEPeyt1V1D8M3e72zyEP8X6kKoTUw/2R3e0v79zmwA0MxyQHDeq0fNzIv2NK1MEklYL5xvw==@linaro.org X-Google-Smtp-Source: AGHT+IFC98UIkX019md3xgZRsPAy7PW2eUFUS5L4jdxZLM9VkPajq1aczWs5Kml25mDcirl8TyVS X-Received: by 2002:a17:906:9f86:b0:ad8:8621:9268 with SMTP id a640c23a62f3a-ade1aaff713mr225404266b.59.1749202420030; Fri, 06 Jun 2025 02:33:40 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1749202420; cv=none; d=google.com; s=arc-20240605; b=KrX0c0t+ftaZUmtvXzz1gFurl1m1dnZYW2XpVoxeauOkvpIdyn8f2Z+/KTxXroq8ij UVTROYbhaMFpJvdoVi14ObG4YbePHjxXYIwgWLeVGyjXmq7wVexdut7mBybZSAmmTu/r Dh+LiQXnvaB2KqH6aOGy/0CJyRDvDTjuEUbCl9tkALQwocdsXxnNkAR5QMNcVR0q3ZVR gdXVDMcR7+Y2ANwFdRZb5+D4Ylw/YiT2DtrEz1hh8Yim/QeCsRX73KT3W7+e6zXF7WAC tbADSv4OT/2WzJbr1//8c6O0eUbh76Y29eJp89HV+X7tJBQmfCnvfP3wGFqhP97PTAsV nQKA== 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=EEjue6a//58KimZBKjkj7bMaZyR7hvKl1178M90j21k=; fh=+i+RTkrPvc0CCcB6rXKbnTZaOKShRvWA2CazXh31SXM=; b=gZwj+RB/spEMnJFc/eTPWlXrNXhzy6EZFyUxXjfds/UBnM+hKnUmjcjkGecNZhuCzL YehNDCw2Cy1naXCSbiDrQSQneMk94Ob7u93ihwpLF7OxK4ne4JFYXrexF9vrEUMf1kVo W2ovXZNTuuxintOyPh1yJjar6bXKY73mRjiKqfrchNlr/IZ8TL5JocZYDGH6rNTbpIgD G0mYFFi9k3CaPUMm0dUfd+zsGq7aP746oWjKF8II3BOa4DmoF7knc2o4B6EVxcd4li7k sFmspLtLMBiYYt1IxdCXHd2LBWsd/kAaNzwpLjB4Uu1u3SSzglifspntx/PVQnuDCaG1 TYcg==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=AQSd7LKy; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 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. [85.214.62.61]) by mx.google.com with ESMTPS id a640c23a62f3a-ade1e362d2bsi97182966b.781.2025.06.06.02.33.39 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 06 Jun 2025 02:33:40 -0700 (PDT) Received-SPF: pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 as permitted sender) client-ip=85.214.62.61; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=AQSd7LKy; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 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 4107A82AFC; Fri, 6 Jun 2025 11:33:18 +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="AQSd7LKy"; dkim-atps=neutral Received: by phobos.denx.de (Postfix, from userid 109) id A338082AE9; Fri, 6 Jun 2025 11:33:16 +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-x435.google.com (mail-wr1-x435.google.com [IPv6:2a00:1450:4864:20::435]) (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 4594882AA7 for ; Fri, 6 Jun 2025 11:33:12 +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-x435.google.com with SMTP id ffacd0b85a97d-3a50fc819f2so1497467f8f.2 for ; Fri, 06 Jun 2025 02:33:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1749202392; x=1749807192; 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=EEjue6a//58KimZBKjkj7bMaZyR7hvKl1178M90j21k=; b=AQSd7LKyTAxhOyDu9TFEUWK9pk+8oJJsGtvIG7ONbLitF7lSBKpuzc+qzJdtzovbmW gzeWfFs8XvHloonLSEhmNAefgv4s3+gPzt5VmgHMTjdTEErINPmanvM+NQcNGKFdXZYn wxiLLOZAIfOQJr0TZVHfmNasmOXKK6by/eiBTOTBD1kCvglq1etRjKg5Fti0q8YZblqf 5bMT5Oa18y/5ElAPz5+0hBqQ6df7+doOvM9Ro3V9hwR790xellfF3YfihqxvCNtDh66y nq0YWAQwpWtLymj8NvH9LaGTzOgF2jArbtbbUIU+oPN9Bh2MU7CXZGsRp3eHLlaxx7Us Zqpw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1749202392; x=1749807192; 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=EEjue6a//58KimZBKjkj7bMaZyR7hvKl1178M90j21k=; b=NdbJKExGDi3B8+pJUylaM6yfKEPx/kM8MjD58IOBN7iVHwuhSlhd7oZC0Gv0UM0u8f Bv4hOwS1vE/J6W1AEuJc+wRolLDxX8aA5MeWoBgFW0reFvy+2cVjd6gfyiDHfDskKzPn W9VgNg675AmM4pNA71gxKcN407tXTuPkENRbAW2pPUlv6tGF67N7B9/KVsnRMVRAHYlA KWUItqZs349wiEsSegNqlWqGYAse0ARtM11fd2McFRlcR7BslvFo0KVLbw1U6bRAaRSB PjN/T41TPqUXJ0eluPZczgxewPvhMynHyMHhCc/dnbn0CK2Vir7bYvLlWbQbjbfMU/wh 20Lg== X-Gm-Message-State: AOJu0YyB7awZrOMIBUR3y2RPG1T6jwSMaUNBT3oY03CixVl8hNLTBAXQ j9RaTZMPD8KJCHUjGQWvCgghM4vsJj0/MyqYKaoI/kygUT80M1qRbM11AFo2CaSk6lQ= X-Gm-Gg: ASbGncu1U1lO2Dc4RSuX4C4C946CW5HG57FfcnrZMgA0GzBAcmi4DDxBr00Fa2lm51g fYpkxqlbF0U70EKz2VXQDRk45ni+nFqoYX+UOj7T0yLfMOgvSRAYTOzqb333rRY+6RY1OeolJ2C AIAlCKenjXKKQ051qdqGb6yygTQ+AnSThn+uMvTsBW85RTj3Yq4XbtIqOiqUz2p62mhk/IYRrQS oMHFSHe+odn5N/b80EPGf4THuQ+xzcU4MD/7TMYl2rraA8iZnAHTFsAao2GUzXnUiBLB7BX5kUy YPh6hmyrAjcdv4lFHI7rActbJ75IC2g2bL8Ae66+E3+QUbjwEUoQg0zgAcAJkxuGjepFd/Td8Oy FTtwR2Wpx7ab5iXqPdg== X-Received: by 2002:a05:6000:288c:b0:3a4:f7e6:2b29 with SMTP id ffacd0b85a97d-3a53188d91emr2516776f8f.5.1749202391555; Fri, 06 Jun 2025 02:33:11 -0700 (PDT) Received: from arrakeen.starnux.net ([2a01:e0a:3d9:2080:52eb:f6ff:feb3:451a]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3a532452d7esm1302439f8f.85.2025.06.06.02.33.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 06 Jun 2025 02:33:11 -0700 (PDT) From: Neil Armstrong Date: Fri, 06 Jun 2025 11:33:08 +0200 Subject: [PATCH RFT v5 2/3] fastboot: blk: switch emmc to use the block helpers MIME-Version: 1.0 Message-Id: <20250606-topic-fastboot-blk-v5-2-203538ec5b32@linaro.org> References: <20250606-topic-fastboot-blk-v5-0-203538ec5b32@linaro.org> In-Reply-To: <20250606-topic-fastboot-blk-v5-0-203538ec5b32@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=9409; i=neil.armstrong@linaro.org; h=from:subject:message-id; bh=i00E8Gtz4m/2fVqy2mO1ocM94d9KHU3NlieYR42vMkk=; b=owEBbQKS/ZANAwAKAXfc29rIyEnRAcsmYgBoQrXVLpt6ojtulDyuOFQhgBTD5/r9ZbxDX/NYN1xk bDjirQuJAjMEAAEKAB0WIQQ9U8YmyFYF/h30LIt33NvayMhJ0QUCaEK11QAKCRB33NvayMhJ0V6UD/ 47veE8LWE2Z9YvK3QgMwsb3Mr/dywTFzhjlfjSGtwY9NIAeyltwF7sR40mpbH0ZCDai8lrcZFSa1MW igczZIaJrcQh7WRkJVkj1uzGiwXIfqEDcX999kaBJDBLJLFJDYIYhdAdJ4U85HL8PdHHlWgh9yV4l3 1ttCDTOKhQVm2dqWr9hip9QwyLhEusFy8CvzjkldpF+cJyCVjqnFi9j/nUo4xtoaTt/aXtd6CpGvH7 rNWCcSrAYxJRKPCb5OjCzIRGLE3oA6U3iRLd4TruDOA/X/i1hEQKODGlx+fz0OiI5+2rFNyHsArNY+ 8kRuW0h5A16LY6XLed8kXiIAuUPDwXyL/vJmj4jqRXnY/x1hS/2Ics0bWBr8wGhtoe3fDcmQJe9zi9 rtEBdgAqn5iH50LwwxvJ2Rhd0hr5TN5VoECKCEhaJ4YYBs3C+HTeXbHzjrNKW0+/tfV0RgFXF9SRuu psfWYDglat8wjDIVGGDldUhjONbfy8PV/p+R07nCCyMO2bTL8xBesXI+pz0SkUaPzcqM8woW+fhpV1 QzRVKmwyHOJBH0ucZdpb2yxWmhKyg5jk28RS5WZsjEhJgcQjbMrMSjrvG/a04gawM2jg1tZ5Fq6M2Z ZTnEfNu2EE7n12gFhZLwHAbANzZwfrT0nPSbPKgVVuX2gAm/68Uv1gV+8FdQ== 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/Makefile | 3 +- drivers/fastboot/fb_mmc.c | 210 +++------------------------------------------- 2 files changed, 14 insertions(+), 199 deletions(-) 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 Fri Jun 6 09:33:09 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Neil Armstrong X-Patchwork-Id: 894449 Delivered-To: patch@linaro.org Received: by 2002:a05:6000:ecd:b0:3a4:ee3f:8f15 with SMTP id ea13csp403748wrb; Fri, 6 Jun 2025 02:33:32 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCVhXXKv2rI4xlH+vflM6dfuBbU2zNkdomBl4LqES14jaL+GK9fA10D3YOpp3o5kDllJwxpwPQ==@linaro.org X-Google-Smtp-Source: AGHT+IFe7K8Dk/Elwj3DCVBv+tLzNqcEuZbk0PCAOmYJ4b7+O8gCReVuOZHBGIJXCipNYgDLvior X-Received: by 2002:a17:906:478c:b0:ad8:9428:6a3c with SMTP id a640c23a62f3a-ade1a9e29e6mr189382966b.11.1749202411934; Fri, 06 Jun 2025 02:33:31 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1749202411; cv=none; d=google.com; s=arc-20240605; b=Z3NqXVm6dBUf8Mo37xWUr9vv3AsDojp6Y8TSN2uUSUtRScdp8I3pQSyCpINSRODOmi vZmaac4mGdyfjBiQaJ/gK3V7qfAu3HhaUktv2kymJoajIQcWl5gLzl9dv2frQ2otbSx1 tHP79CRsz/Pequb77dwEiCR1xk/C5THHL391/+RxPkLAhHx9RGkqgHL/FbGWbc7QktIU mBX9l2I3H2ZXmfmoSRTfk+lq1CUewPoYgx6vGvqNG8lZJX8S4285SIlf4/QAurorYhRW ARUEKmShsVAZr5tX8x0GPClCniC7ukG3p9ZD8kGDAJG0MXZpSaUXe2NYFvpyeaF6XMDg T5Ig== 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=xWgWJ3EmulB0xqoNRZUrGW3JTHhPF1wM/EEGqrw9zyU=; fh=+i+RTkrPvc0CCcB6rXKbnTZaOKShRvWA2CazXh31SXM=; b=fRwIgR30Z5ToUfChp7x6GnYcswb2WG9CyfijSeFd0QNIvBwGPfZqC3WVeRZrpzMyoe CuH0CKDQBMqZSCv0uy6VrTPSGFhXOU1BSbGiadj/4MDIkRckDZpuQyCrx+sIMoX+6sNZ eCjDlHedUPtcUn6elVrVBZiO4e195HISXTgLTbpELJ+7he5raBFi3otMcVxihBKR2giI kaGhKfSjA17y5627Ps5q9njW98k8iS4tey2cjZ0sApSy6bDqiZycs0YP2IWDnge/zCYr xn79e3zxS2AiuMrz45ylGqr9az7yRQzxfJlAg5bZqK0aThvBKuTryGdFz3hv6od8TlMy h1HA==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=gCyEjFm6; 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 a640c23a62f3a-ade1e36c4basi103213866b.777.2025.06.06.02.33.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 06 Jun 2025 02:33:31 -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=gCyEjFm6; 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 E4B6382AAF; Fri, 6 Jun 2025 11:33: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="gCyEjFm6"; dkim-atps=neutral Received: by phobos.denx.de (Postfix, from userid 109) id ABDC382ADA; Fri, 6 Jun 2025 11:33:15 +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-x433.google.com (mail-wr1-x433.google.com [IPv6:2a00:1450:4864:20::433]) (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 E180982ADA for ; Fri, 6 Jun 2025 11:33:12 +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-x433.google.com with SMTP id ffacd0b85a97d-3a4fb9c2436so966551f8f.1 for ; Fri, 06 Jun 2025 02:33:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1749202392; x=1749807192; 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=xWgWJ3EmulB0xqoNRZUrGW3JTHhPF1wM/EEGqrw9zyU=; b=gCyEjFm6E/grMhcJ9CmEagJOQUldfS3/bHqCDGy0sTcaLxt+Qkclxe9yKGV1inNgeC pAajiIRYvG6VWQ+TIWcMMp1+HJXOYwrGkZwgfpRhDiMqWRkCaxlU47a6Xf1kvh5YeJtO IsbPpGwvH/SV+JqLaG5x11Hao6lKGpQllmOdNxP+tQTTA/8Lh73NLKXmPE1FdcusNhha BeQwP3muIbz3abZjxMMZbJtEEivgBljpR6t8kIj7EpbTmuQhfU/HMUwVU09FrjUmfLuq 2be+pefoh2Nohv3f+7VjyiP0rwnlOWYZytiraWwuu7F/sewkafPW41qztdKoUflgbayW bfow== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1749202392; x=1749807192; 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=xWgWJ3EmulB0xqoNRZUrGW3JTHhPF1wM/EEGqrw9zyU=; b=BT9SoFrM3vUhbkq68db2O4Wok5/+0xFXona0X2+r+qjmUMqlsUxDZYmwuwQq1tSkBU ssULMprEALD0B1zmL6VeMP4nWWkYN7PKucqhUpCG1xuSyPsDqdNAr1SV5n1d2O5aL6ZV tTJ9YMHs7bjiEFfuGbUIa52vgSrXCjmqN/z6+4jamwWiu5b7Z6OzX0lCJbAvr/C4U/xi /NxQnUBejjcfzxpzj+xHxjGI+3iUAlHfch70ApL4XZcitIQyRNKqT6ma31vh6ApDJzdq QCORGlZMlzdCbiRahmL/jhGL35rE92TSKdpYtcQ4VL5vF0A2sfZa2o77Ogb14lY1HV3n YjQg== X-Gm-Message-State: AOJu0YxWpKh77whClYwrGLItvS9wQwJfyckAfNs3I4G+/1UvOQkTnXym VRGSFJcXvySZoJfnh36yZK3Cji4ObVqSiQB68aakU9qMhGUlNcJTuxW7dEG4uz0M+JA= X-Gm-Gg: ASbGnct6u07QkQPjzgDu67X6VMwde3Q+/I0jqM2M32gqhLa89d2mwRCnU3I/6GFXO6c 6yQaoetuXRnCuqreF5Hew9QkfrXOOMF7zX5iCcfz1q+PGgOOGOUSkqhuFzpfeZ78JbKSVA7a28g mAZs+fz3ORQH/EbAHyRUTeZbbvMZFBr2LI4Ka4JR6NCTvIAMfEixwjaUxI3DHB1f06Khz2oDu06 BsP54WIQASjHpD5MIOp/VLATKzS9bh/lT1dsSLSNsTh7SWpHApkyyH1D9NMpIw40iEk+4eODkmN AsZJth6gv/a03t6PzCLDYJ6MiZzq1yUq4ejlU0xTmFPsB/khPgj8ud5YBxMwBZQ646rdgBI4 X-Received: by 2002:a05:6000:1786:b0:3a4:d452:fff with SMTP id ffacd0b85a97d-3a5318837d3mr2320036f8f.17.1749202392295; Fri, 06 Jun 2025 02:33:12 -0700 (PDT) Received: from arrakeen.starnux.net ([2a01:e0a:3d9:2080:52eb:f6ff:feb3:451a]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3a532452d7esm1302439f8f.85.2025.06.06.02.33.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 06 Jun 2025 02:33:11 -0700 (PDT) From: Neil Armstrong Date: Fri, 06 Jun 2025 11:33:09 +0200 Subject: [PATCH RFT v5 3/3] fastboot: integrate block flashing back-end MIME-Version: 1.0 Message-Id: <20250606-topic-fastboot-blk-v5-3-203538ec5b32@linaro.org> References: <20250606-topic-fastboot-blk-v5-0-203538ec5b32@linaro.org> In-Reply-To: <20250606-topic-fastboot-blk-v5-0-203538ec5b32@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=7403; i=neil.armstrong@linaro.org; h=from:subject:message-id; bh=y6qvaiEMUchMXQgKuNyGVteFx7uQoBYQun68FGcztHk=; b=owEBbQKS/ZANAwAKAXfc29rIyEnRAcsmYgBoQrXVMitMq0QXQzo2iO286ByGDCE9XyXGkpN8+l4n eVUOmxKJAjMEAAEKAB0WIQQ9U8YmyFYF/h30LIt33NvayMhJ0QUCaEK11QAKCRB33NvayMhJ0dHaD/ 0es+CySRg9CSxyWmNRka487AfFFORsUsy6kSYZLPiH8cewyCZjIERl3VfC7cjb1wiM+5HTNgvJ/S0V x2K5pT8sqxyd/C1rzw0IgrLUm0En75RcSxslHAlns+qYiL9xVWN9F+VWU7i9Ys0YVyZMqamGD1NAZL 4qrkKLD8R7pfSN+qoSQbBUA4E5XKF/ILoKeO7NhP83kwRAVH2kiTnDR8xip6IGc4P47xPqqS6jdNja h93MKP4xGXNEkdDkKXxW+SreWFtLz6ZmLbQ/+9AaUobgndeIKrN5117n+X136yEIM5nRx6ySuCLeMv h4D7Rx9Upvz1qqkakqrEC7Q/YR7/AUDfhF4Xz/jtBgQmBDcAyKA+h6C+ep6XhpQjw/fN5ghXcCMT2/ tzcGQgeeNoeknxWLxcfGEQBuNBkR1pse1tQeFz0NO08elj7KWSWL7IwAqVjBv0WvRROQmp1cD9N/jg 6yV3Fi62GA00oQhsiHdv9RfpflFTPG1XQ5VkPUcDS9ppKXjp16maRBGuhwGk6ZVfSKepCY2nRc2vzN +7q9DcRFNGuve2DpIyj3L2W4R5FvmFbUGWTIr0agIMGWX4Mk1tS1tZEd6ilEwusVKV83qF77fOZsvY lhXLQvQTWXUlxbcPaHn2VddhPVSpa5Jfder1lbTgChrJB3uUhVSIyYmSZDFA== 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, 62 insertions(+), 6 deletions(-) diff --git a/drivers/fastboot/Kconfig b/drivers/fastboot/Kconfig index 70207573de2bd0d56b4b7fa6f7e17fdc5803ba15..75911468ba4980d9b96e2af9e708f08b9ef16ac8 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 @@ -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,29 @@ 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 + 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. + Device identifiers are numbered starting from 0 and the most + common case is to use the first controller on the system. + 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)