From patchwork Tue May 6 16:10: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: 887845 Delivered-To: patch@linaro.org Received: by 2002:a5d:430f:0:b0:38f:210b:807b with SMTP id h15csp2631265wrq; Tue, 6 May 2025 09:10:22 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCVUmvdCqNHBP1NUwXW9bwOHJG+53QfOetSP4LgQ6MJCSYMIvam/P9r2jWir215718MstGQ6sg==@linaro.org X-Google-Smtp-Source: AGHT+IGmpxhTQqfO7AQJn3GK1VjDNecdxD8NBjfn73m35BeJEZ7GqOC3dIfc/eWYCEJNHJ/nD9rx X-Received: by 2002:a05:6000:220e:b0:39a:d20b:5c25 with SMTP id ffacd0b85a97d-3a0b4a189a8mr25122f8f.26.1746547822243; Tue, 06 May 2025 09:10:22 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1746547822; cv=none; d=google.com; s=arc-20240605; b=R+jBZTzl8yuMpJTeflGcHrbsBHaxM4IG+aiqzwqX+oTZjlOLS9BZ24qoM1wDolfY20 /dwVLcPInsOahKgqRjZeDv8fQpzDGpaUqIyrQtH8ePDv+mBR38/dFijV76Bhs3S4mhv1 CXozTwsVTFf/cCKKOskLjMpR4p71mZHnCYURofFV7H3OgC9f3DYs1xwv0fYjcuRZnw+d xlLw73ckU2MSs24VPGkxlfQqs/3Tfqq7OTgtaXAaL/jQ/Bs4qKpvTJS+MreutCGKCZ09 7A8VQp7FGvjRHo4HJ9z+oxKL4twc4wI3ECW6hpGVO+RpAtVGJvZFjXos7ALmf+e9UfVH dn8w== 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=oY38sKia3A6xChXj2rxwZ2AgXIVtjFs5S4vYPxEIQFo=; fh=+i+RTkrPvc0CCcB6rXKbnTZaOKShRvWA2CazXh31SXM=; b=DTQ+o33ZtUs//Mp0wB8F6ZVLB9DxGkyW1YQGay3Lct1dI9PgPhEvIh06KojWJmQkXx xP6FN/jVkbVo43kCgXM4iiWOKlsqicDnKwxGU0d+D1/cH3x1A/7YdOF7U7NLF8ZNbAXf aiS7q/+5gyi3uYNQKJ44J0K0v9G9B8DAMb+UoT6GkSspdbFTUSR8qhkv4SXLpeZoVb72 b0ngy71YuwvaEKFuYVkyBBCeuaeCaxduH/1JtXGoxNxqik/KlaaB8JHm5wPeqvDQ5M4l RdCMOV1Ft5kceL+ZKX937ePn2D3qbKMgjS8EsKX3p8RpjP9wFgP/W++reMQ8a7xTvHSs v1nw==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b="gbSW/Ow2"; 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 ffacd0b85a97d-3a099b10903si7216106f8f.706.2025.05.06.09.10.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 06 May 2025 09:10:22 -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="gbSW/Ow2"; 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 1C1DF8210D; Tue, 6 May 2025 18:10:21 +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="gbSW/Ow2"; dkim-atps=neutral Received: by phobos.denx.de (Postfix, from userid 109) id C331581FAB; Tue, 6 May 2025 18:10:20 +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 3E5758210D for ; Tue, 6 May 2025 18:10: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=neil.armstrong@linaro.org Received: by mail-wm1-x333.google.com with SMTP id 5b1f17b1804b1-43cf257158fso32689725e9.2 for ; Tue, 06 May 2025 09:10:15 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1746547815; x=1747152615; 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=oY38sKia3A6xChXj2rxwZ2AgXIVtjFs5S4vYPxEIQFo=; b=gbSW/Ow2l68g0rw+vt1Kp9902lQenyGn3ZdlMW2bWnVk/AdbFz332LulW/IE09/o/B A20nnetzPfUXXqFuaRdkhgB5ry8jitKHp6pmCEnLqMW7NXAzGoGYxSU1ugbvx/bII76F 88Cibxnk6s/Y9AYZmFLUhXrFbCxCPguQuoP4UX6PfJ35SHOJw9yNADlMVgqmIU7h1BGp fR8OiZYnplHpbHjibN1w+kf4kFqum8iBvDnZOBJAKAnm6l8jQz+I+TK/tTX7o2Cb77nM 1fCpM0y+DYyo1gBqO5ddi9ddwXp0qJo9S54wZwT53Wj7/cSyyJntegG8ANfnkV2R3jAa Ps2A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746547815; x=1747152615; 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=oY38sKia3A6xChXj2rxwZ2AgXIVtjFs5S4vYPxEIQFo=; b=QHXqwjkESDsfCWFM6D3amMrm8Yi1s4OpjOi3SjkK+LOmO7zmVsKPw+2hWrFNf6e2CG JhzMVpD5sR3pNtPBfNrN+dcdYR5YB1mJsKSusVOU98GjXBuDbyVTjfxjn0VxjG3yUWud M6P1jz7Z18xqXikqq5rLlbsvoIH0HpKITcQS1jm9okLUzueQ2ozwnHesdAMBkMdpql46 r8V4fL1obksmQOsy9/DG1evABI3iWf6ZYLBrblPCwvw2eZagilkOKku92MT9vmaMNcDJ GPgz0UK125IY0TCnr41xnDh/jspcggWJxG0dFQxhrEj3Og9GoYfnk6cuv5sf/kIrl4pG TN3w== X-Gm-Message-State: AOJu0Yw7LzXbFQYW7+icNF73tkwiP/3uhPMdLG7lxQM7kXrmREH/WTPD DXeQLP3SZPJ2d8aNa7Txf2cphizIjXyA918Vq/iRHi/VjZIQdlrQrR4mo/OkDTKAL0epFEg+3Pc b X-Gm-Gg: ASbGncsR8PlFFjFePoB7aYuw82DS6Qv3pkn/yDQUo9eGnQ5Y1bw0CGORiD7cHPJGIgJ KNC0KkTG/f4IJjSDBUnhxZQzVdbbv8YRSNdyXH6+rn4ebqjWKk1YtMK5+1ta4nXNSU5XDkhw2pe WhGaRXnYHDuq6DwK/L59C1YO2/uAKZ7GQRvJ/RJaRglxcbNtjiFfnpwzT6bzePNF6FOxqbqm2zQ e7IcJXDI4jmKSnyWmhGzQFTw/tnoXEjK74OoU+jITDm0FsUwvneY2hr0lPYs/0lFIl20J2W0DKv vCsoZj+IL3tt8xo9s2aKYerPDInKrHdDAKOLcOfjDA5gr4U0LpimBVnso49fVA== X-Received: by 2002:a05:6000:178f:b0:3a0:88e5:dbb2 with SMTP id ffacd0b85a97d-3a0b49ea2femr47754f8f.11.1746547814661; Tue, 06 May 2025 09:10:14 -0700 (PDT) Received: from arrakeen.starnux.net ([2a01:e0a:3d9:2080:8261:5fff:fe11:bdda]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3a0b0dffaa1sm2103960f8f.31.2025.05.06.09.10.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 06 May 2025 09:10:14 -0700 (PDT) From: neil.armstrong@linaro.org Date: Tue, 06 May 2025 18:10:07 +0200 Subject: [PATCH RFT v3 1/3] fastboot: blk: introduce fastboot block flashing support MIME-Version: 1.0 Message-Id: <20250506-topic-fastboot-blk-v3-1-d94be5829f46@linaro.org> References: <20250506-topic-fastboot-blk-v3-0-d94be5829f46@linaro.org> In-Reply-To: <20250506-topic-fastboot-blk-v3-0-d94be5829f46@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=14626; i=neil.armstrong@linaro.org; h=from:subject:message-id; bh=aRghPl5ExrSZup+p8WpxC63khnYOQJPIvZS00/FtTi4=; b=owEBbQKS/ZANAwAKAXfc29rIyEnRAcsmYgBoGjRjGfNjEM5ZmQVQNE+jxvvX+zcSMD2iWrRupCk1 lfAYQYKJAjMEAAEKAB0WIQQ9U8YmyFYF/h30LIt33NvayMhJ0QUCaBo0YwAKCRB33NvayMhJ0aiyD/ 94ubEQ9rzjyjUlqzEu5YiRyZ7P6YhipsoJTLiO95OBEXFbVrBcTJL8pKIqLSw2ZoS/JtIrWnIsQ53i nLAcXr3Ho6DHkbOEUDECGmQY6P4k3B5by4Oq0Rjmb8DdBwODvJWrMk+/HNQWF7bMtdE0PMvKPo/Uiq ETS2MlhutqxMl2Yf/1BwDUzE4D8B8f3Ch2Q44THfppN7YN0F0jq0DZb7ncVmnd5ayACeSzvBUj+St8 rjLlMlEb43eZjYDksiEdtFRitJlowTWK1O7+a/5cSxonPvxSGqyHiFfPpypaLv1/P0tN2Fitlj6LP8 3iXjF84bLWK2DS8aFhZ4wUBTh+xXRt/AKkrwOQ/2mIFVUGeD8kvD+9i9VivqlzeQ4WHL5+3J4gPa1c r9Mbamy0kzwIqQiK5fG9ywjuhhk7aIh0aKiwtu5WhgmNvkHrS6uxrBCfIigsuhF8SZbzS3Nksajbre DMP/OaaaLsRSa9AbPhZia4D37+qMp3dS57Jzup9GEM+cSZu1pjY82Zq1q/s70vwAGoExPC3znek804 9XPSU8L8WWVcUREMXhyDrTnMyFVsP2zmrH+r8EKj8mWOPoOxuNIplZXdx3Ra7pannYe7dGF+Xnz80x HTjUZ8/9vMGeX/DXqMSkNeVYuunmUhCRpdjgdOXQR4Z0ycZJuDTwa8b0eS+w== 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 Signed-off-by: Neil Armstrong Reviewed-by: Mattijs Korpershoek --- 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 Tue May 6 16:10: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: 887848 Delivered-To: patch@linaro.org Received: by 2002:a5d:430f:0:b0:38f:210b:807b with SMTP id h15csp2631522wrq; Tue, 6 May 2025 09:10:46 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCXHvfIHveu6xhfPIMTnMfbwgqkL7kTrxsL0IqgID8niYV3hRhR5OXSC4+KFYpo6sq2DJ6M5Ug==@linaro.org X-Google-Smtp-Source: AGHT+IGvIXmGYIM18mPEcf4SWiJjQ4a4nfKY1A323SrI/kOkE3YeBU84tQyYvfkMFvWJTCny2GHS X-Received: by 2002:a05:600c:6303:b0:43d:300f:fa51 with SMTP id 5b1f17b1804b1-441d0fccaefmr39289015e9.9.1746547846302; Tue, 06 May 2025 09:10:46 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1746547846; cv=none; d=google.com; s=arc-20240605; b=QILN9UcMbQwkFE9P0UYriMxH1vHnzdLhE/HZ4G/0aeOefDR6zlZKojwKk5NnWsb8J7 ATTy2aGhc45iz+xfJ3P7y5giBEgaJ3YjUuytiicPJPFIywrYpuijnwy2XgsliCIYLwlL h99RicsFKFqtAwaIsADL6kCkxagmqlDYtP97bKDMMXPIMh4k7wMqNMimQkchh8o0fs41 dppux3M91RBUm6Z8tx1U+ad6GDUuMg5sthOGYq32hPbK+CQSzEZkccU4euVEcPvGb094 y6eXocgxBtEurqnSBOS3Knvg/+ygMsuOwzG6Iu2SBP6pJTPGU8AbbM4OTuD9k30y9za/ k08g== 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=WF23jBpCJ1tyjHiXL5OSRL9eZIslHT12Wv1X4psD4+o=; fh=+i+RTkrPvc0CCcB6rXKbnTZaOKShRvWA2CazXh31SXM=; b=FF3SLmSDrhb/BAsDO7siEIv4+4hsGiSpq/J0yBHLNARpCzd90jzJqd+iv2Rtk5Zv6L lUWFqcJLLNLO3a1QUicDnG2iqDL+1bUr5Vf3ZHw7rBPygCqEGmNcZ7s+HbVjkbE+wtfA Ssf3IlQx/Rts9EUxwJdpn97Yo/UGfjSc0xGslb2gI8DRItxnZIyXijovKCvdnuGU14xZ T7CjsgIzNr3wZNo9xglHeJjN7HLT+ZHZS4rzizLD1ttGkh/bAm0D6YZrCfGklThe+84S 9yQkcRmmOQSW3ckp1B610QtSHQQykfvQCRer9vHYkmaxC0o5eBf+wwKTLClweV1NwymM hkVg==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=dzeWFvRk; 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 ffacd0b85a97d-3a099b0ef2csi7425493f8f.640.2025.05.06.09.10.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 06 May 2025 09:10:46 -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=dzeWFvRk; 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 EBA3782999; Tue, 6 May 2025 18:10:23 +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="dzeWFvRk"; dkim-atps=neutral Received: by phobos.denx.de (Postfix, from userid 109) id EB501822D7; Tue, 6 May 2025 18:10:22 +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-x436.google.com (mail-wr1-x436.google.com [IPv6:2a00:1450:4864:20::436]) (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 F0A1382163 for ; Tue, 6 May 2025 18:10: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=neil.armstrong@linaro.org Received: by mail-wr1-x436.google.com with SMTP id ffacd0b85a97d-39c1efbefc6so4384067f8f.1 for ; Tue, 06 May 2025 09:10:15 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1746547815; x=1747152615; 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=WF23jBpCJ1tyjHiXL5OSRL9eZIslHT12Wv1X4psD4+o=; b=dzeWFvRk+7tgaa/Jh24GBuXXlTXT0xuLdbsASWPP2dSjUru2axJXRo25HZjTYx+1JJ N8sod23BjTISJAHSVMQNcGtjbvm3l8VL7aEPQeemsMEpKeIbj0UJLfLSnB81UYMUqUug f7iTjNYA40IowiTtdNj1/o4PbGLV3jC6aWxAPJfPloCGCo721oCxTIWUXd7Wvc5YTe9k wlDbgUg766pzKE8Q7tsMNXb4OuKN7M87riVBWK00LwWKxN9Nwu3tzQjWRrhEhV05HYjU VezL5eIw1LAbzZgdyIPBbvraDqkWnuX1l1pcGCKr8mUORPd+feRqcF29P43O++Z/nBpz kIow== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746547815; x=1747152615; 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=WF23jBpCJ1tyjHiXL5OSRL9eZIslHT12Wv1X4psD4+o=; b=pT8V+wTeE0+k4k4Rid/vhNzAi9cWQ0TXvoWgIhc96lNdHvpL4S2ZkhoLU2T+qui6MU GHx8H8aKIaK12cJdGBWIRW8AHK5LHga3Z0xw2tnx60JoeU3/AMPReEJePwDbsv6IJ8Bk ua/bQR9D1FrbGIE8TOrs0cJyru9Cwch+EiJo/2zUKGIO1seegHbQVMkWK4V8I6Qqug+q iEJ9nAazhqy8YMX7slddqOTSTf9sRqHBiyiDqUZ/n92wT4CG+YlzRe2F1PGzH5eTFqbN OhwMNjE2SqRohcpRJBmtczV2BtmAWo2G85BlWQ5ctIs0NEk2aGkTAjpnQj2T9I1Wzu7y 6ZHQ== X-Gm-Message-State: AOJu0YzWS/sy90GEWXPVi0ZVhVqkGHnJ3GoOhYX5wNBQ4Mf5RbmHSW3E lRQA3sRbJa9jgvSpFXcZMZjZCJ5sin6qaBf2eCbTb++fGPAljuRXkwRUeudoovQ= X-Gm-Gg: ASbGncsD9emrE3zX47xjZP3nRFZYRWg6HR/t+kTZuDkt7TVW1ov4CIsPrwiNCq3hDrn shE5FZ/ZuvRyOT/qErtsgS11+R0e3AaUhr1aHg55nnnCKduIkceuUXfLp6saJSL/Uo7EHaIOdUd JPlgsMk77zEpqlW4LFFBgAWwZ980U4kmkKPuSO30zJ5y1jqcoe12rRmIFsvQ7VFxl4oPqiCxogx hAlRRZddamEkdyfb3w0XACSq+iSymuEHame1aD0rWvl4LgVoePI2rZhBxA0JQj941WWRXe4jVb3 /KWsb4vkKZ8xTTb8cytNQyL8LGTWhvWDrYaaF2Obo/a+GB2VrKVuOm0KrSl6nA== X-Received: by 2002:a5d:64ac:0:b0:3a0:90bf:b9b with SMTP id ffacd0b85a97d-3a0b499c71emr67346f8f.8.1746547815441; Tue, 06 May 2025 09:10:15 -0700 (PDT) Received: from arrakeen.starnux.net ([2a01:e0a:3d9:2080:8261:5fff:fe11:bdda]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3a0b0dffaa1sm2103960f8f.31.2025.05.06.09.10.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 06 May 2025 09:10:14 -0700 (PDT) From: neil.armstrong@linaro.org Date: Tue, 06 May 2025 18:10:08 +0200 Subject: [PATCH RFT v3 2/3] fastboot: blk: switch emmc to use the block helpers MIME-Version: 1.0 Message-Id: <20250506-topic-fastboot-blk-v3-2-d94be5829f46@linaro.org> References: <20250506-topic-fastboot-blk-v3-0-d94be5829f46@linaro.org> In-Reply-To: <20250506-topic-fastboot-blk-v3-0-d94be5829f46@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=10101; i=neil.armstrong@linaro.org; h=from:subject:message-id; bh=lHkkgroSNmeyt5PIPA2eY/TP0/y3BXJ8Ah6LMg1/Ybo=; b=owEBbQKS/ZANAwAKAXfc29rIyEnRAcsmYgBoGjRjrrmWInY/EtBN8AkNbpMWVdnDN1yOMlEjpFWZ WrHdKPWJAjMEAAEKAB0WIQQ9U8YmyFYF/h30LIt33NvayMhJ0QUCaBo0YwAKCRB33NvayMhJ0aMrEA CSdEbAiX+qWzSeIe9Z/I+FLhVMTa3NrJdwov+M856UsVU9f9jL7drYUzVv1d1KqfoPveCsMnVxD2w+ 9HAMUWFx6Wx/BcCYpoc8FmPcdRAlXcmj22FOJ1bDfTxvtxVH2PZTQhPzqAbD0g2g9nV54yNATTbvMq Xn+i7coj/jQOBem2TmB4QZPmUynyX6k/Y21meqxUIbY/g9KXkZf30Fn6eptJo15s5BwV7pM1fc7TZF PiszeTFT3+Os53AgAIGdSCyDZv0hiObAPf0cRh6lS1pTRCEHTgjrM0cWiez9ETf6mNmM5sneTmMVEE u6xOKmDB6amRSgfujIvvCvkZlkN0vHqIcCYfOf7hIkk2a3aqc+7WHNRkvyZZuEgxyl5ma9fMxOk0gY pLQ+sGxqAO2bv8YCFAOHjbyfGEvNsnb/ma9zvmTqYtqk7BhT+ZBaaU+CuksgHe0NJRVRv2MJMcjHqH FVGFIT66w4X9sZigY+4tTqvX+CW51hbqpTvyVyth3dd0lzc9Yz+ieKsaTNPd0bF5HvTitf9OjJ4lGg CLWVPGYk0l6Oiyng3WdF65XIv4owfZ7tPrzpqpA5S0gVXYPMO876W6bPg5NmymE3KDQXn94lBZ9rHi XAoYQxWFh6gDlLWOVC7Z3wr8G3Q7IOHIyEA4oy2N6u3Mjxi1qkpFmAFFQ2xw== 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 Signed-off-by: Neil Armstrong Reviewed-by: Mattijs Korpershoek --- 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 Tue May 6 16:10: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: 887847 Delivered-To: patch@linaro.org Received: by 2002:a5d:430f:0:b0:38f:210b:807b with SMTP id h15csp2631415wrq; Tue, 6 May 2025 09:10:38 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCVi8vTyr42tsNf0ABc358WOJcXy4f9lRG/W5n8nq2pU0pIABx4M9STQioNxzDPcSc/Y/p4gSQ==@linaro.org X-Google-Smtp-Source: AGHT+IE9xHejsKqv7mRmLqMUInT9sRZJn/FvbH8LQVfLzZZCKn70/in9EmGwJ9IGZ4rnJbCx98vF X-Received: by 2002:a05:600c:19cf:b0:43d:45a:8fc1 with SMTP id 5b1f17b1804b1-441d050b1a7mr35226445e9.4.1746547838228; Tue, 06 May 2025 09:10:38 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1746547838; cv=none; d=google.com; s=arc-20240605; b=i+ArdaV9oUfc9quuWSyg488IDtFHKLUo+WsdhC4yvc9OT9CtRsdTA/T8VSujpol1AI denhU+rp5/HsoAqS/tplUNk/TgxdbaFuxl5E1W0fgC7upIr1qnMlt9hzdWD1EdY5psHY iyEIWTp/7DIGAULPAWm9AK6rfZ0tyxl9UypLUs0qikgUqgYSf9Wn7RsYT5rrrQuxxWQq uIa9IReJ2wRfBGhFdLoiqWtcFVWhaPSQJgwipuCAZQlHNbi5DMi1AiADZFnjc2vUf2K6 YJammcOTXMOscIC9yDbeF/WijlSEJYOWl00EvAjijtrNYAg/TT8s6IDT6TrZgscKdtqF N8yQ== 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=vghMrZJGET8uzFQGRt6atFm9U3VvwEwrffjvJwdC4bY=; fh=+i+RTkrPvc0CCcB6rXKbnTZaOKShRvWA2CazXh31SXM=; b=BXqRmdb9NKpE15wPnHermcx+Z1yyWFa2Rqkw92drzgVN9ci9iqZf5kQLMYtLPNED8H +/Nbw4oOuMbDBGLaEJpQYKkeKkmVFe1RIMF3wIePNBUKCNHw672EDmVIyq7tfeAuOrwJ ABUg2aVETnUZlvPy3EP4wPAwpNQ5furcTtfW4lBEVfnbPKxyE9trBotUJP7+5m45ld3l FNqFARH5XTYEf5Uqm0o5i3YWXN9HfwJlSPL/SrXKGsyHE3fG8I++hAseXz6ykYMmIczl SjlDxfzOH2ZGcQ+7mc2uTudwV4V/aI7BmCCditWGNQvhA1CI7K2XYHhnLfZvDv9W1aa5 YZ2A==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=DZG3LNri; 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 ffacd0b85a97d-3a099adf519si7144959f8f.170.2025.05.06.09.10.37 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 06 May 2025 09:10:38 -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=DZG3LNri; 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 A66AF8219D; Tue, 6 May 2025 18:10:23 +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="DZG3LNri"; dkim-atps=neutral Received: by phobos.denx.de (Postfix, from userid 109) id D973582998; Tue, 6 May 2025 18:10:22 +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-x431.google.com (mail-wr1-x431.google.com [IPv6:2a00:1450:4864:20::431]) (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 D6C13822D7 for ; Tue, 6 May 2025 18:10: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=neil.armstrong@linaro.org Received: by mail-wr1-x431.google.com with SMTP id ffacd0b85a97d-39c1ee0fd43so6122261f8f.0 for ; Tue, 06 May 2025 09:10:16 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1746547816; x=1747152616; 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=vghMrZJGET8uzFQGRt6atFm9U3VvwEwrffjvJwdC4bY=; b=DZG3LNriiYCeabEGprcLMpTCNAbmrvaDRKJN9FYbM517KwyAouVqQxpS7kyjcQtZz+ 34OXd1ZPtmgQQe0gPHuxWrf6VoDGly8UOB2KKitjz/g0BNBR9T4MawzMHpAh3O2QGygu 7hp0QBDDL3FynksYDh95geOPwHmiKX/XQ6Q5XSpfOnrCx+nGHque2JKEL8Kk/Y/7PL2t 38llXLvrAfYcnormoQUGAf5XvEhUaOBQNzCU0QUQmruGoBQDM54yo1GeWbWwSZMx1Ob+ s1M39jmFWA5WzEzIqpLNpdgkSlG5UuPK5QuOFZ3amC6kkD31te9u7DzgkaTf9qIKGukG o0ew== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746547816; x=1747152616; 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=vghMrZJGET8uzFQGRt6atFm9U3VvwEwrffjvJwdC4bY=; b=cYE4e8DNdlBr/rMVKPGI7sSC67a5VtlfPTq97ku2Q8EmMW7xoIUGvUcSZY571d5L/v EdwbyuKaWMprBhSoiUE8G5fGX1cftuDr8WiWyRpI1XuyEupxXRKmrRP+rCZoU3J/YvCg 99S7yZrYI2XIrXTNwMlt76WXNIOx4BhhMs/bYdzWFwtYBDW0dkydUeQCUb+N6WFD1WGi nJEJPxTapLlC+F62oPfOamBcj33ZOsg0YOCudU6FWssueXlP9cunkpvz+BPhaaClt1z6 L2T25/CM7y8C5u3ot96YaUPfhnl1n1Eb2Dmhh8LH2k5TP1iwqPvRzKkVV8ANOSi3GrSQ SdEQ== X-Gm-Message-State: AOJu0YyoNk6D9muuj6muozNXyYb24Tpcenb/FEqQ+tdBGHCTnN1Jv0Ak YbTMCkpkMmHR4bNysL31I5VxlsYqtoi20tjAeyVJP+4LivDiiZcQZGFlRHuj6V8= X-Gm-Gg: ASbGncsB5ifbTrhru4VE0lpnI4uozyNEIxQqs4kj4TPNCP4gzMo5EKeD3yWPE+mtoZe b6jQNDDXy+pwniqpJ4KA9ZDuX35uLLyqnpZ8wzMZp4IPg8FBVTcFK4OgtZXkFLpWbo81Cw1IX62 CF2e3JOABUhaDV7KcV9bVjir897LsQP366Fy0RzoZkjM4OTFzNt7CcpvTvqAvUPj9HKpyLBujDQ EYKPgYuMNUxVtPCodm3jHnld5M/BtMSzdrDem6zXuX+fWm9BIFkuRkjsVJdQ0/a6UjUz7YwLkY3 l/bL2tyAiI2yyPwJ7Ow2llbnCBLrlpc0IUY+wyPZBDHTFg4D3K4XO5Zezx+2pQ== X-Received: by 2002:a05:6000:310d:b0:39c:e0e:bb46 with SMTP id ffacd0b85a97d-3a0b4a060f0mr30196f8f.4.1746547816170; Tue, 06 May 2025 09:10:16 -0700 (PDT) Received: from arrakeen.starnux.net ([2a01:e0a:3d9:2080:8261:5fff:fe11:bdda]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3a0b0dffaa1sm2103960f8f.31.2025.05.06.09.10.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 06 May 2025 09:10:15 -0700 (PDT) From: neil.armstrong@linaro.org Date: Tue, 06 May 2025 18:10:09 +0200 Subject: [PATCH RFT v3 3/3] fastboot: integrate block flashing back-end MIME-Version: 1.0 Message-Id: <20250506-topic-fastboot-blk-v3-3-d94be5829f46@linaro.org> References: <20250506-topic-fastboot-blk-v3-0-d94be5829f46@linaro.org> In-Reply-To: <20250506-topic-fastboot-blk-v3-0-d94be5829f46@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=6809; i=neil.armstrong@linaro.org; h=from:subject:message-id; bh=zGJrKdXkNJR8l9GpIB0ZjvxL62DS9PORGV3xh9A2bCM=; b=owEBbQKS/ZANAwAKAXfc29rIyEnRAcsmYgBoGjRjPo/a+OunyUxAJLTJWMrJZzCGZQlIqSk7TOXJ Nj8FsuuJAjMEAAEKAB0WIQQ9U8YmyFYF/h30LIt33NvayMhJ0QUCaBo0YwAKCRB33NvayMhJ0d+YEA DBzIph8NAJo0/fA1VcIdGnUKditG7mOXNxPYtzDECJDD3T8IuIiVCODX/66w0uvI1bqMJprjdaAOdY qwAKI9dfEKb/DZRZf9DwqmKER1rRkt61p0/Hg4tKIisWZvCKgROTtPDZdp3dAF2z0ocJsP3mTP1KgG T5HYzxZRI+Mqf6VjD+RORjgn3m6wd0//ZpvYm4KgVNRBv1smTJu4MTahwh3PYA+k7YD8aGi/y3b7Vt WKcb51UsZpZOc+j1dPfI4TqVDvRFvSlzNpAb5hrizKqlmxbbh9sjioVSX0cJixo2XJ+CxFCN3CEVgn kp9EYA6QSxvGj7qbzrq/c5VekcbmJTKD+uEf4jDyG56xuENLn9RR5Y1PXNhKtXgAmXErgPxIXRoCkv IDVwSKTj//1znqpdn3+hULPNSlnRMg54kPuLVyuA3CN1RqtkgEGLK/1+X6ouBnukyMZCQtMPDfJSl3 KUvvqnsZPjsi9PPnGRBnnZ3eXHUbcLuV/0YYWX56Ks0EqRxpOTvp4E/2Ir7oFiQXcXJoSIj68szm9o A8sKFkhxle6AYhk2i+41uh5kquzgv+zUfD3/WfK3i1B4o/Bjog7y5g3Y0QptrEesgG4jC+hhJfN16z NRVHq+RuOhYqYeb21ZUvkJUKWd5ulCTAmU+N0/gW4KTUwxnv3kIF1PMKfL+w== 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 Signed-off-by: Neil Armstrong --- drivers/fastboot/Kconfig | 24 ++++++++++++++++++++++++ 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, 58 insertions(+), 5 deletions(-) diff --git a/drivers/fastboot/Kconfig b/drivers/fastboot/Kconfig index 33825ee408fbd9aff26cd390a140421c7c98ecc3..68967abb751ed512f157bc32bfafc863943a2265 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,26 @@ 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 virtio, scsi, etc... + 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 + 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. + 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)