Patch Detail
get:
Show a patch.
patch:
Update a patch.
put:
Update a patch.
GET /api/1.2/patches/2221283/?format=api
{ "id": 2221283, "url": "http://patchwork.ozlabs.org/api/1.2/patches/2221283/?format=api", "web_url": "http://patchwork.ozlabs.org/project/qemu-devel/patch/20260409-write_booster-v3-4-dd2f1c0119c8@samsung.com/", "project": { "id": 14, "url": "http://patchwork.ozlabs.org/api/1.2/projects/14/?format=api", "name": "QEMU Development", "link_name": "qemu-devel", "list_id": "qemu-devel.nongnu.org", "list_email": "qemu-devel@nongnu.org", "web_url": "", "scm_url": "", "webscm_url": "", "list_archive_url": "", "list_archive_url_format": "", "commit_url_format": "" }, "msgid": "<20260409-write_booster-v3-4-dd2f1c0119c8@samsung.com>", "list_archive_url": null, "date": "2026-04-09T05:37:48", "name": "[v3,4/5] hw/ufs: Add UFS Write Booster Support", "commit_ref": null, "pull_url": null, "state": "new", "archived": false, "hash": "44e3ede67855077101eb135d4a69775f37e025ab", "submitter": { "id": 93039, "url": "http://patchwork.ozlabs.org/api/1.2/people/93039/?format=api", "name": "Jaemyung Lee", "email": "ldc.jml@gmail.com" }, "delegate": null, "mbox": "http://patchwork.ozlabs.org/project/qemu-devel/patch/20260409-write_booster-v3-4-dd2f1c0119c8@samsung.com/mbox/", "series": [ { "id": 499238, "url": "http://patchwork.ozlabs.org/api/1.2/series/499238/?format=api", "web_url": "http://patchwork.ozlabs.org/project/qemu-devel/list/?series=499238", "date": "2026-04-09T05:37:44", "name": "hw/ufs: Add Write Booster Support on UFS", "version": 3, "mbox": "http://patchwork.ozlabs.org/series/499238/mbox/" } ], "comments": "http://patchwork.ozlabs.org/api/patches/2221283/comments/", "check": "pending", "checks": "http://patchwork.ozlabs.org/api/patches/2221283/checks/", "tags": {}, "related": [], "headers": { "Return-Path": "<qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org>", "X-Original-To": "incoming@patchwork.ozlabs.org", "Delivered-To": "patchwork-incoming@legolas.ozlabs.org", "Authentication-Results": [ "legolas.ozlabs.org;\n\tdkim=pass (2048-bit key;\n unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256\n header.s=20251104 header.b=ZjzjF/j5;\n\tdkim-atps=neutral", "legolas.ozlabs.org;\n spf=pass (sender SPF authorized) smtp.mailfrom=nongnu.org\n (client-ip=209.51.188.17; helo=lists.gnu.org;\n envelope-from=qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org;\n receiver=patchwork.ozlabs.org)" ], "Received": [ "from lists.gnu.org (lists1p.gnu.org [209.51.188.17])\n\t(using TLSv1.2 with cipher ECDHE-ECDSA-AES256-GCM-SHA384 (256/256 bits))\n\t(No client certificate requested)\n\tby legolas.ozlabs.org (Postfix) with ESMTPS id 4frpfK0XfTz1yCv\n\tfor <incoming@patchwork.ozlabs.org>; Thu, 09 Apr 2026 15:39:37 +1000 (AEST)", "from localhost ([::1] helo=lists1p.gnu.org)\n\tby lists.gnu.org with esmtp (Exim 4.90_1)\n\t(envelope-from <qemu-devel-bounces@nongnu.org>)\n\tid 1wAi65-00057D-Ix; Thu, 09 Apr 2026 01:38:33 -0400", "from eggs.gnu.org ([2001:470:142:3::10])\n by lists1p.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256)\n (Exim 4.90_1) (envelope-from <ldc.jml@gmail.com>) id 1wAi60-00054j-Da\n for qemu-devel@nongnu.org; Thu, 09 Apr 2026 01:38:29 -0400", "from mail-pl1-x634.google.com ([2607:f8b0:4864:20::634])\n by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128)\n (Exim 4.90_1) (envelope-from <ldc.jml@gmail.com>) id 1wAi5x-0002q8-Jm\n for qemu-devel@nongnu.org; Thu, 09 Apr 2026 01:38:28 -0400", "by mail-pl1-x634.google.com with SMTP id\n d9443c01a7336-2ab232cc803so2950985ad.3\n for <qemu-devel@nongnu.org>; Wed, 08 Apr 2026 22:38:25 -0700 (PDT)", "from [172.17.0.5] ([168.126.243.22])\n by smtp.gmail.com with ESMTPSA id\n d9443c01a7336-2b2747a7115sm211108905ad.36.2026.04.08.22.38.21\n (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256);\n Wed, 08 Apr 2026 22:38:23 -0700 (PDT)" ], "DKIM-Signature": "v=1; a=rsa-sha256; c=relaxed/relaxed;\n d=gmail.com; s=20251104; t=1775713104; x=1776317904; darn=nongnu.org;\n h=cc:to:in-reply-to:references:message-id:content-transfer-encoding\n :mime-version:subject:date:from:from:to:cc:subject:date:message-id\n :reply-to; bh=uUt1EJs6advV9trvSP0ehtqoz/VUp+VqQMmayMrl/gs=;\n b=ZjzjF/j5vEXV7Y4f3gXTeERxZL5murS8gJN0PwitCqUvyejbUnW1qmFAbgrnCNEo7S\n GBT6bXO3vbn+jda/NkP+3tDZK0Gm/m8u/20p4LI6v6Zfd8s8fMrtjyO2dyPCoLkELbdO\n bqGJJRVmdXTM+hmScqlnMITR2W81ohWkQyj4m0Fr2kEEe0FUYhfowgx3dll912oR0Dp8\n 9FmfmVI/G5xtWCN6whenyGm2+a+v8N4jxE6jsOnw1Z1hpuhsAai+iJaimJgGcT5oMHJr\n 8nFMhqwnka0zYn86Oy4xrSVgLKdGyzKXkDt7O1m+wkJK+3ky2dr9Up7A/riK8byu6k9S\n QX8w==", "X-Google-DKIM-Signature": "v=1; a=rsa-sha256; c=relaxed/relaxed;\n d=1e100.net; s=20251104; t=1775713104; x=1776317904;\n h=cc:to:in-reply-to:references:message-id:content-transfer-encoding\n :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to\n :cc:subject:date:message-id:reply-to;\n bh=uUt1EJs6advV9trvSP0ehtqoz/VUp+VqQMmayMrl/gs=;\n b=rA7rl5nkcIsz+7of5PEr1sNP12YqxDPsUkT2RPrg8kMeWXn5wsTbJrSPr4S3jnnlM1\n RC+NQJ12yQWPYlHWkelFPUo1Z2LIyf1nZGxld1G93atka152AGM5UI1TEDVvCpkR4Gm0\n JEO7dZF1DDfI4vEcfWLAANBU7aK2IuDZ31H+PHkXrgF4WSDy3qQEvp/ziaElXLkpwuAd\n V+8Q9p5Y+GnqETLsClmyClkOxCTDOYYSAJ4e3Vx5+QhYtxlUgqEwumkgQds7sLZhGpu8\n SSt8L76o4OpqZF5J6uuN/B4TqoZZdaKEYG/h2D/gTXEMpxBE+qoh6qrCxBBV1DhB8AwM\n rofA==", "X-Gm-Message-State": "AOJu0YzOm+eJTEOEPkltsVWtUuohlJSxwcAk4BNerA3axxxSHmT6HY/L\n 29f9LoKJBOBJedVQSdNjEXuieQjc4motJTX49cCsvpqvCXYrbLYU7qeEv0kuddKS5gU=", "X-Gm-Gg": "AeBDievA088JPzYhDfdaErwJZWCStxBZzB2hHAZ4/75EU8dECsRq4xRxj+Rcc+gMiYQ\n 4z1W5ZB+F1JQ4N5116mxnfiVtk5Izq1qSmhhK163FToqSMpOoQvTiuW5mY1b04LTQnPbNfQVq2r\n 4djAoyvXyDkCliBwIraCzQOzBLdwpMYHfCDM1pfmLOKpQD4Cc8WecdfWsbtOJq1UYol5twLZXzD\n V/SidulGLNOweA5gtaW1JrxrZdXNdLeVY++xERTPYhTILYPDdsoXDs75YZBbMs1rfJAKb3v+YUG\n fLdzxB6WVckJ2UXtoh6HOKdI4Dw6Rl3q0qtA+yCHOwLCWboL2SmUDmX/eaM72mkh9+BOglMV88C\n Q6mLyU0FmEqhm5v4NQWp/4oAmBzJBnUsL/XMDobRrRIlqP5ZtSI/hCEl7FFmbiGUCvt0iiXVAvz\n Mgm8LIyc/eMmwzSR31+AfBh6ZsNo9i+OAdkSm/ZIS6", "X-Received": "by 2002:a17:903:2a88:b0:2b2:5840:808e with SMTP id\n d9443c01a7336-2b2c7331551mr24736025ad.10.1775713103888;\n Wed, 08 Apr 2026 22:38:23 -0700 (PDT)", "From": "Jaemyung Lee <ldc.jml@gmail.com>", "X-Google-Original-From": "Jaemyung Lee <jaemyung.lee@samsung.com>", "Date": "Thu, 09 Apr 2026 14:37:48 +0900", "Subject": "[PATCH v3 4/5] hw/ufs: Add UFS Write Booster Support", "MIME-Version": "1.0", "Content-Type": "text/plain; charset=\"utf-8\"", "Content-Transfer-Encoding": "7bit", "Message-Id": "<20260409-write_booster-v3-4-dd2f1c0119c8@samsung.com>", "References": "<20260409-write_booster-v3-0-dd2f1c0119c8@samsung.com>", "In-Reply-To": "<20260409-write_booster-v3-0-dd2f1c0119c8@samsung.com>", "To": "qemu-devel@nongnu.org", "Cc": "Jeuk Kim <jeuk20.kim@samsung.com>, Kevin Wolf <kwolf@redhat.com>,\n Hanna Reitz <hreitz@redhat.com>, qemu-block@nongnu.org,\n Fabiano Rosas <farosas@suse.de>, Laurent Vivier <lvivier@redhat.com>,\n Paolo Bonzini <pbonzini@redhat.com>,\n Jaemyung Lee <jaemyung.lee@samsung.com>", "X-Mailer": "b4 0.14.2", "X-Developer-Signature": "v=1; a=ed25519-sha256; t=1775713090; l=26331;\n i=jaemyung.lee@samsung.com; s=20260402; h=from:subject:message-id;\n bh=G4/KPcK/Uu4VBiwxcdsE2Sr+OdihNDBnNl5VWaNK9MA=;\n b=xBOHqTW2RRVKikCvfvzgoeE3b6RWOf7F2DOaXRZ02HjdBgxeZYa0TG4ZJaBmJ0v8ZIfVGW+66\n GNMIaRQxP80AWb4M+uGbY80+NFC8KVaW1f2st8l5RJ9m1BbGC83f86E", "X-Developer-Key": "i=jaemyung.lee@samsung.com; a=ed25519;\n pk=bZPd7A/kteUO62FfUM6IrI1LuBPe5QrcqfvsitM1ZjE=", "Received-SPF": "pass client-ip=2607:f8b0:4864:20::634;\n envelope-from=ldc.jml@gmail.com; helo=mail-pl1-x634.google.com", "X-Spam_score_int": "-20", "X-Spam_score": "-2.1", "X-Spam_bar": "--", "X-Spam_report": "(-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1,\n DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FROM=0.001,\n RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001,\n SPF_PASS=-0.001 autolearn=unavailable autolearn_force=no", "X-Spam_action": "no action", "X-BeenThere": "qemu-devel@nongnu.org", "X-Mailman-Version": "2.1.29", "Precedence": "list", "List-Id": "qemu development <qemu-devel.nongnu.org>", "List-Unsubscribe": "<https://lists.nongnu.org/mailman/options/qemu-devel>,\n <mailto:qemu-devel-request@nongnu.org?subject=unsubscribe>", "List-Archive": "<https://lists.nongnu.org/archive/html/qemu-devel>", "List-Post": "<mailto:qemu-devel@nongnu.org>", "List-Help": "<mailto:qemu-devel-request@nongnu.org?subject=help>", "List-Subscribe": "<https://lists.nongnu.org/mailman/listinfo/qemu-devel>,\n <mailto:qemu-devel-request@nongnu.org?subject=subscribe>", "Errors-To": "qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org", "Sender": "qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org" }, "content": "Add UFS Write Booster implementation which follows UFS 4.1 Spec.\n\nSigned-off-by: Jaemyung Lee <jaemyung.lee@samsung.com>\n---\n hw/ufs/lu.c | 94 +++++++++++++++\n hw/ufs/ufs.c | 333 +++++++++++++++++++++++++++++++++++++++++++++++++---\n hw/ufs/ufs.h | 47 ++++++++\n include/block/ufs.h | 51 ++++++++\n 4 files changed, 510 insertions(+), 15 deletions(-)", "diff": "diff --git a/hw/ufs/lu.c b/hw/ufs/lu.c\nindex 3f3c9589cee57ae3e77e2f486476d5fcec204d80..993fea8aae8d0b9135f4f1664b6cfa1bc34a9c82 100644\n--- a/hw/ufs/lu.c\n+++ b/hw/ufs/lu.c\n@@ -58,6 +58,99 @@ static void ufs_build_scsi_response_upiu(UfsRequest *req, uint8_t *sense,\n status, data_segment_length);\n }\n \n+#define UFS_GROUP_NUMBER_MASK 0x1F\n+#define UFS_WB_GROUP_NUMBER_DEFAULT 0x00 /* 00000b */\n+#define UFS_WB_GROUP_NUMBER_PINNED 0x18 /* 11000b */\n+static bool ufs_wb_check_write_pinned(UfsHc *u, UfsRequest *req)\n+{\n+ uint8_t cmd = req->req_upiu.sc.cdb[0];\n+ uint8_t group_number = UFS_WB_GROUP_NUMBER_DEFAULT;\n+\n+ if (u->attributes.wb_buffer_partial_flush_mode != UFS_WB_FLUSH_PINNED) {\n+ return false;\n+ }\n+\n+ if (cmd == WRITE_16) {\n+ group_number = req->req_upiu.sc.cdb[14] & UFS_GROUP_NUMBER_MASK;\n+\n+ } else if (cmd == WRITE_10) {\n+ group_number = req->req_upiu.sc.cdb[6] & UFS_GROUP_NUMBER_MASK;\n+ }\n+\n+ return (group_number == UFS_WB_GROUP_NUMBER_PINNED);\n+}\n+\n+#define UFS_WB_TOTAL_WRITTEN_SHIFT 21 /* 10MB */\n+static void ufs_wb_process_write_pinned(UfsHc *u, UfsRequest *req,\n+ uint32_t transfered_len)\n+{\n+ UfsWb *wb = &u->wb;\n+ uint64_t remain_bytes, remain_data;\n+ uint32_t total_written;\n+\n+ if (!wb->pinned_curr_bytes) {\n+ return;\n+ }\n+\n+ if (wb->pinned_used_bytes >= wb->pinned_curr_bytes) {\n+ return;\n+ }\n+\n+ remain_bytes = wb->pinned_curr_bytes - wb->pinned_used_bytes;\n+ if (remain_bytes >= transfered_len) {\n+ wb->pinned_total_written_bytes += transfered_len;\n+ wb->pinned_used_bytes += transfered_len;\n+ remain_data = 0;\n+\n+ } else {\n+ wb->pinned_total_written_bytes += remain_bytes;\n+ wb->pinned_used_bytes += remain_bytes;\n+ remain_data = transfered_len - remain_bytes;\n+ }\n+\n+ total_written = wb->pinned_total_written_bytes >> UFS_WB_TOTAL_WRITTEN_SHIFT;\n+ u->attributes.pinned_wb_cumm_written_size = cpu_to_be32(total_written);\n+\n+ remain_bytes = wb->curr_bytes - wb->used_bytes;\n+ wb->used_bytes += MIN(remain_bytes, remain_data);\n+}\n+\n+static void ufs_wb_process_write_normal(UfsHc *u, UfsRequest *req,\n+ uint32_t transfered_len)\n+{\n+ UfsWb *wb = &u->wb;\n+ uint64_t curr_bytes, used_bytes, remain_bytes;\n+\n+ if (!wb->curr_bytes) {\n+ return;\n+ }\n+\n+ curr_bytes = wb->curr_bytes - wb->pinned_curr_bytes;\n+ used_bytes = wb->used_bytes - wb->pinned_used_bytes;\n+\n+ if (used_bytes >= curr_bytes) {\n+ return;\n+ }\n+\n+ remain_bytes = curr_bytes - used_bytes;\n+ wb->used_bytes += MIN(remain_bytes, transfered_len);\n+}\n+\n+static void ufs_wb_process_write_req(UfsRequest *req, uint32_t transfered_len)\n+{\n+ UfsHc *u = req->hc;\n+\n+ if (!u->flags.wb_en || !ufs_is_write_req(req)) {\n+ return;\n+ }\n+\n+ if (ufs_wb_check_write_pinned(u, req)) {\n+ ufs_wb_process_write_pinned(u, req, transfered_len);\n+ } else {\n+ ufs_wb_process_write_normal(u, req, transfered_len);\n+ }\n+}\n+\n static void ufs_scsi_command_complete(SCSIRequest *scsi_req, size_t resid)\n {\n UfsRequest *req = scsi_req->hba_private;\n@@ -68,6 +161,7 @@ static void ufs_scsi_command_complete(SCSIRequest *scsi_req, size_t resid)\n ufs_build_scsi_response_upiu(req, scsi_req->sense, scsi_req->sense_len,\n transfered_len, status);\n \n+ ufs_wb_process_write_req(req, transfered_len);\n ufs_complete_req(req, UFS_REQUEST_SUCCESS);\n \n scsi_req->hba_private = NULL;\ndiff --git a/hw/ufs/ufs.c b/hw/ufs/ufs.c\nindex 33887ac12a4bae647acb94b292f1d680bff9a007..0e0d206f83f53ad70b50d4372b6918d5fce7a3a6 100644\n--- a/hw/ufs/ufs.c\n+++ b/hw/ufs/ufs.c\n@@ -996,11 +996,15 @@ static const int flag_permission[UFS_QUERY_FLAG_IDN_COUNT] = {\n [UFS_QUERY_FLAG_IDN_FPHYRESOURCEREMOVAL] = UFS_QUERY_FLAG_READ,\n [UFS_QUERY_FLAG_IDN_BUSY_RTC] = UFS_QUERY_FLAG_READ,\n [UFS_QUERY_FLAG_IDN_PERMANENTLY_DISABLE_FW_UPDATE] = UFS_QUERY_FLAG_READ,\n- /* Write Booster is not supported */\n- [UFS_QUERY_FLAG_IDN_WB_EN] = UFS_QUERY_FLAG_READ,\n- [UFS_QUERY_FLAG_IDN_WB_BUFF_FLUSH_EN] = UFS_QUERY_FLAG_READ,\n+ [UFS_QUERY_FLAG_IDN_WB_EN] = UFS_QUERY_FLAG_READ | UFS_QUERY_FLAG_SET |\n+ UFS_QUERY_FLAG_CLEAR | UFS_QUERY_FLAG_TOGGLE,\n+ [UFS_QUERY_FLAG_IDN_WB_BUFF_FLUSH_EN] =\n+ UFS_QUERY_FLAG_READ | UFS_QUERY_FLAG_SET | UFS_QUERY_FLAG_CLEAR |\n+ UFS_QUERY_FLAG_TOGGLE,\n [UFS_QUERY_FLAG_IDN_WB_BUFF_FLUSH_DURING_HIBERN8] = UFS_QUERY_FLAG_READ,\n- [UFS_QUERY_FLAG_IDN_UNPIN_EN] = UFS_QUERY_FLAG_READ,\n+ [UFS_QUERY_FLAG_IDN_UNPIN_EN] = UFS_QUERY_FLAG_READ | UFS_QUERY_FLAG_SET |\n+ UFS_QUERY_FLAG_CLEAR |\n+ UFS_QUERY_FLAG_TOGGLE,\n };\n \n static inline QueryRespCode ufs_flag_check_idn_valid(uint8_t idn, int op)\n@@ -1097,6 +1101,9 @@ static QueryRespCode ufs_write_flag_value(UfsHc *u, uint8_t idn, uint8_t value)\n case UFS_QUERY_FLAG_IDN_WB_BUFF_FLUSH_DURING_HIBERN8:\n u->flags.wb_buffer_flush_during_hibernate = value;\n break;\n+ case UFS_QUERY_FLAG_IDN_UNPIN_EN:\n+ u->flags.unpin_en = value;\n+ break;\n default:\n return UFS_QUERY_RESULT_INVALID_VALUE;\n }\n@@ -1189,16 +1196,20 @@ static const int attr_permission[UFS_QUERY_ATTR_IDN_COUNT] = {\n [UFS_QUERY_ATTR_IDN_HID_PROG_RATIO] = UFS_QUERY_ATTR_READ,\n [UFS_QUERY_ATTR_IDN_HID_STATE] = UFS_QUERY_ATTR_READ,\n [UFS_QUERY_ATTR_IDN_WB_BUFF_RESIZE_HINT] = UFS_QUERY_ATTR_READ,\n- [UFS_QUERY_ATTR_IDN_WB_BUFF_RESIZE_EN] = UFS_QUERY_ATTR_READ,\n+ [UFS_QUERY_ATTR_IDN_WB_BUFF_RESIZE_EN] = UFS_QUERY_ATTR_WRITE,\n [UFS_QUERY_ATTR_IDN_WB_BUFF_RESIZE_STATUS] = UFS_QUERY_ATTR_READ,\n- [UFS_QUERY_ATTR_IDN_WB_BUFF_PARTIAL_FLUSH_MODE] = UFS_QUERY_ATTR_READ,\n- [UFS_QUERY_ATTR_IDN_MAX_FIFO_WB_PARTIAL_FLUSH_MODE] = UFS_QUERY_ATTR_READ,\n+ [UFS_QUERY_ATTR_IDN_WB_BUFF_PARTIAL_FLUSH_MODE] =\n+ UFS_QUERY_ATTR_READ | UFS_QUERY_ATTR_WRITE,\n+ [UFS_QUERY_ATTR_IDN_MAX_FIFO_WB_PARTIAL_FLUSH_MODE] =\n+ UFS_QUERY_ATTR_READ | UFS_QUERY_ATTR_WRITE,\n [UFS_QUERY_ATTR_IDN_CURR_FIFO_WB_PARTIAL_FLUSH_MODE] = UFS_QUERY_ATTR_READ,\n [UFS_QUERY_ATTR_IDN_PINNED_WB_BUFF_CURR_ALLOC_UNITS] = UFS_QUERY_ATTR_READ,\n [UFS_QUERY_ATTR_IDN_PINNED_WB_BUFF_AVAIL_PERCENT] = UFS_QUERY_ATTR_READ,\n [UFS_QUERY_ATTR_IDN_PINNED_WB_CUMM_WRITTEN_SIZE] = UFS_QUERY_ATTR_READ,\n- [UFS_QUERY_ATTR_IDN_PINNED_WB_NUM_ALLOC_UNITS] = UFS_QUERY_ATTR_READ,\n- [UFS_QUERY_ATTR_IDN_NON_PINNED_WB_MIN_NUM_ALLOC_UNITS] = UFS_QUERY_ATTR_READ,\n+ [UFS_QUERY_ATTR_IDN_PINNED_WB_NUM_ALLOC_UNITS] =\n+ UFS_QUERY_ATTR_READ | UFS_QUERY_ATTR_WRITE,\n+ [UFS_QUERY_ATTR_IDN_NON_PINNED_WB_MIN_NUM_ALLOC_UNITS] =\n+ UFS_QUERY_ATTR_READ | UFS_QUERY_ATTR_WRITE,\n };\n \n static inline QueryRespCode ufs_attr_check_idn_valid(uint8_t idn, int op)\n@@ -1238,6 +1249,27 @@ static inline uint8_t ufs_read_device_temp(UfsHc *u)\n return 0;\n }\n \n+static inline uint32_t ufs_wb_read_flush_status(UfsHc *u)\n+{\n+ if (u->attributes.wb_buffer_flush_status == UFS_WB_FLUSH_SUSPENDED ||\n+ u->attributes.wb_buffer_flush_status == UFS_WB_FLUSH_COMPLETED ||\n+ u->attributes.wb_buffer_flush_status == UFS_WB_FLUSH_FAILED) {\n+ u->attributes.wb_buffer_flush_status = UFS_WB_FLUSH_IDLE;\n+ }\n+\n+ return u->attributes.wb_buffer_flush_status;\n+}\n+\n+static inline uint32_t ufs_wb_read_resize_status(UfsHc *u)\n+{\n+ if (u->attributes.wb_buffer_resize_status == UFS_WB_RESIZE_COMPLETED ||\n+ u->attributes.wb_buffer_resize_status == UFS_WB_RESIZE_FAILED) {\n+ u->attributes.wb_buffer_resize_status = UFS_WB_RESIZE_IDLE;\n+ }\n+\n+ return u->attributes.wb_buffer_resize_status;\n+}\n+\n static uint32_t ufs_read_attr_value(UfsHc *u, uint8_t idn)\n {\n switch (idn) {\n@@ -1292,7 +1324,7 @@ static uint32_t ufs_read_attr_value(UfsHc *u, uint8_t idn)\n case UFS_QUERY_ATTR_IDN_THROTTLING_STATUS:\n return u->attributes.throttling_status;\n case UFS_QUERY_ATTR_IDN_WB_FLUSH_STATUS:\n- return u->attributes.wb_buffer_flush_status;\n+ return ufs_wb_read_flush_status(u);\n case UFS_QUERY_ATTR_IDN_AVAIL_WB_BUFF_SIZE:\n return u->attributes.available_wb_buffer_size;\n case UFS_QUERY_ATTR_IDN_WB_BUFF_LIFE_TIME_EST:\n@@ -1323,10 +1355,8 @@ static uint32_t ufs_read_attr_value(UfsHc *u, uint8_t idn)\n return u->attributes.hid_state;\n case UFS_QUERY_ATTR_IDN_WB_BUFF_RESIZE_HINT:\n return u->attributes.wb_buffer_resize_hint;\n- case UFS_QUERY_ATTR_IDN_WB_BUFF_RESIZE_EN:\n- return u->attributes.wb_buffer_resize_en;\n case UFS_QUERY_ATTR_IDN_WB_BUFF_RESIZE_STATUS:\n- return u->attributes.wb_buffer_resize_status;\n+ return ufs_wb_read_resize_status(u);\n case UFS_QUERY_ATTR_IDN_WB_BUFF_PARTIAL_FLUSH_MODE:\n return u->attributes.wb_buffer_partial_flush_mode;\n case UFS_QUERY_ATTR_IDN_MAX_FIFO_WB_PARTIAL_FLUSH_MODE:\n@@ -1347,6 +1377,32 @@ static uint32_t ufs_read_attr_value(UfsHc *u, uint8_t idn)\n return 0;\n }\n \n+static void ufs_wb_resize_op(UfsHc *u, uint32_t value)\n+{\n+ if (u->attributes.wb_buffer_resize_status == UFS_WB_RESIZE_IN_PROGRESS) {\n+ return;\n+ }\n+\n+ u->attributes.wb_buffer_resize_en = value;\n+ u->attributes.wb_buffer_resize_status = UFS_WB_RESIZE_IN_PROGRESS;\n+}\n+\n+static void ufs_wb_pinned_max_size(UfsHc *u, uint32_t value)\n+{\n+ UfsWb *wb = &u->wb;\n+\n+ u->attributes.pinned_wb_num_alloc_units = cpu_to_be32(value);\n+ wb->pinned_max_bytes = ufs_unit_to_byte(u, value);\n+}\n+\n+static void ufs_wb_pinned_min_size(UfsHc *u, uint32_t value)\n+{\n+ UfsWb *wb = &u->wb;\n+\n+ u->attributes.non_pinned_wb_min_num_alloc_units = cpu_to_be32(value);\n+ wb->pinned_min_bytes = ufs_unit_to_byte(u, value);\n+}\n+\n static QueryRespCode ufs_write_attr_value(UfsHc *u, uint8_t idn, uint32_t value)\n {\n switch (idn) {\n@@ -1383,6 +1439,27 @@ static QueryRespCode ufs_write_attr_value(UfsHc *u, uint8_t idn, uint32_t value)\n case UFS_QUERY_ATTR_IDN_TIMESTAMP:\n u->attributes.timestamp = cpu_to_be64(value);\n break;\n+ case UFS_QUERY_ATTR_IDN_WB_BUFF_RESIZE_EN:\n+ if (value >= UFS_WB_RESIZE_OP_MAX) {\n+ return UFS_QUERY_RESULT_INVALID_VALUE;\n+ }\n+ ufs_wb_resize_op(u, value);\n+ break;\n+ case UFS_QUERY_ATTR_IDN_WB_BUFF_PARTIAL_FLUSH_MODE:\n+ if (value >= UFS_WB_FLUSH_MODE_MAX) {\n+ return UFS_QUERY_RESULT_INVALID_VALUE;\n+ }\n+ u->attributes.wb_buffer_partial_flush_mode = value;\n+ break;\n+ case UFS_QUERY_ATTR_IDN_MAX_FIFO_WB_PARTIAL_FLUSH_MODE:\n+ u->attributes.max_fifo_wb_partial_flush_mode = cpu_to_be32(value);\n+ break;\n+ case UFS_QUERY_ATTR_IDN_PINNED_WB_NUM_ALLOC_UNITS:\n+ ufs_wb_pinned_max_size(u, value);\n+ break;\n+ case UFS_QUERY_ATTR_IDN_NON_PINNED_WB_MIN_NUM_ALLOC_UNITS:\n+ ufs_wb_pinned_min_size(u, value);\n+ break;\n default:\n g_assert_not_reached();\n return 0;\n@@ -1801,9 +1878,177 @@ static void ufs_sendback_req(void *opaque)\n ufs_irq_check(u);\n }\n \n+static inline void ufs_wb_update_avail_buffer(UfsHc *u)\n+{\n+ UfsWb *wb = &u->wb;\n+ uint64_t non_pinned_curr_bytes, non_pinned_used_bytes;\n+ uint32_t units;\n+\n+ units = ufs_byte_to_unit(u, wb->pinned_curr_bytes);\n+ u->attributes.pinned_wb_buffer_curr_alloc_units = cpu_to_be32(units);\n+\n+ if (!wb->pinned_curr_bytes)\n+ u->attributes.pinned_wb_buffer_avail_percent = 0;\n+ else\n+ u->attributes.pinned_wb_buffer_avail_percent =\n+ (wb->pinned_curr_bytes - wb->pinned_used_bytes) * 10 /\n+ wb->pinned_curr_bytes;\n+\n+ non_pinned_curr_bytes = wb->curr_bytes - wb->pinned_curr_bytes;\n+ non_pinned_used_bytes = wb->used_bytes - wb->pinned_used_bytes;\n+\n+ units = ufs_byte_to_unit(u, non_pinned_curr_bytes);\n+ u->attributes.current_wb_buffer_size = cpu_to_be32(units);\n+\n+ if (!non_pinned_curr_bytes)\n+ u->attributes.available_wb_buffer_size = 0;\n+ else\n+ u->attributes.available_wb_buffer_size =\n+ (non_pinned_curr_bytes - non_pinned_used_bytes) * 10 /\n+ non_pinned_curr_bytes;\n+}\n+\n+static inline bool ufs_wb_is_flush_needed(UfsHc *u, uint64_t *no_flush_bytes)\n+{\n+ UfsWb *wb = &u->wb;\n+ uint32_t max_unit;\n+\n+ switch (u->attributes.wb_buffer_partial_flush_mode) {\n+ case UFS_WB_FLUSH_NONE:\n+ *no_flush_bytes = 0;\n+ break;\n+ case UFS_WB_FLUSH_FIFO:\n+ max_unit = be32_to_cpu(u->attributes.max_fifo_wb_partial_flush_mode);\n+ *no_flush_bytes = ufs_unit_to_byte(u, max_unit);\n+ break;\n+ case UFS_WB_FLUSH_PINNED:\n+ *no_flush_bytes = (u->flags.unpin_en) ? 0 : wb->pinned_used_bytes;\n+ break;\n+ default:\n+ g_assert_not_reached();\n+ break;\n+ }\n+\n+ return wb->used_bytes > *no_flush_bytes;\n+}\n+\n+#define UFS_WB_FLUSH_BYTES (4096 * 1024)\n+static void ufs_wb_process_flush(UfsHc *u)\n+{\n+ UfsWb *wb = &u->wb;\n+ uint64_t flush_bytes, no_flush_bytes;\n+\n+ switch (u->attributes.wb_buffer_flush_status) {\n+ case UFS_WB_FLUSH_IDLE:\n+ if (u->flags.wb_buffer_flush_en &&\n+ ufs_wb_is_flush_needed(u, &no_flush_bytes)) {\n+ u->attributes.wb_buffer_flush_status = UFS_WB_FLUSH_IN_PROGRESS;\n+ }\n+\n+ break;\n+ case UFS_WB_FLUSH_IN_PROGRESS:\n+ if (!u->flags.wb_buffer_flush_en) {\n+ u->attributes.wb_buffer_flush_status = UFS_WB_FLUSH_FAILED;\n+\n+ } else if (!ufs_wb_is_flush_needed(u, &no_flush_bytes)) {\n+ u->attributes.wb_buffer_flush_status = UFS_WB_FLUSH_COMPLETED;\n+\n+ } else if (wb->pinned_used_bytes && u->flags.unpin_en) {\n+ flush_bytes = MIN(wb->pinned_used_bytes, UFS_WB_FLUSH_BYTES);\n+ wb->pinned_used_bytes -= flush_bytes;\n+ wb->used_bytes -= flush_bytes;\n+\n+ } else {\n+ flush_bytes = MIN(wb->used_bytes - no_flush_bytes, UFS_WB_FLUSH_BYTES);\n+ wb->used_bytes -= flush_bytes;\n+ }\n+\n+ break;\n+ case UFS_WB_FLUSH_COMPLETED:\n+ if (ufs_wb_is_flush_needed(u, &no_flush_bytes)) {\n+ u->attributes.wb_buffer_flush_status =\n+ (u->flags.wb_buffer_flush_en) ? UFS_WB_FLUSH_IDLE :\n+ UFS_WB_FLUSH_IN_PROGRESS;\n+ }\n+ }\n+}\n+\n+static void ufs_wb_process_resize(UfsHc *u)\n+{\n+ UfsWb *wb = &u->wb;\n+\n+ if (u->attributes.wb_buffer_resize_status != UFS_WB_RESIZE_IN_PROGRESS) {\n+ return;\n+ }\n+\n+ switch (u->attributes.wb_buffer_resize_en) {\n+ case UFS_WB_DECREASE:\n+ if (wb->curr_bytes <= wb->min_bytes) {\n+ u->attributes.wb_buffer_resize_status = UFS_WB_RESIZE_FAILED;\n+ return;\n+\n+ } else if (wb->curr_bytes <= wb->used_bytes) {\n+ u->attributes.wb_buffer_resize_status = UFS_WB_RESIZE_FAILED;\n+ return;\n+ }\n+\n+ if (wb->curr_bytes - wb->used_bytes >= wb->resize_bytes) {\n+ wb->curr_bytes -= wb->resize_bytes;\n+ } else {\n+ wb->curr_bytes = wb->used_bytes;\n+ }\n+\n+ if (wb->curr_bytes < wb->min_bytes) {\n+ wb->curr_bytes = wb->min_bytes;\n+ }\n+\n+ break;\n+ case UFS_WB_INCREASE:\n+ if (wb->curr_bytes >= wb->max_bytes) {\n+ u->attributes.wb_buffer_resize_status = UFS_WB_RESIZE_FAILED;\n+ return;\n+ }\n+\n+ wb->curr_bytes += wb->resize_bytes;\n+ if (wb->curr_bytes >= wb->max_bytes) {\n+ wb->curr_bytes = wb->max_bytes;\n+ }\n+\n+ break;\n+ default:\n+ g_assert_not_reached();\n+ break;\n+ }\n+\n+ u->attributes.wb_buffer_resize_status = UFS_WB_RESIZE_COMPLETED;\n+}\n+\n+static void ufs_wb_process_pinned(UfsHc *u)\n+{\n+ UfsWb *wb = &u->wb;\n+ uint64_t avail_bytes;\n+\n+ avail_bytes = wb->curr_bytes - wb->used_bytes + wb->pinned_used_bytes;\n+\n+ if ((u->attributes.wb_buffer_partial_flush_mode != UFS_WB_FLUSH_PINNED) ||\n+ (wb->curr_bytes <= wb->pinned_min_bytes)) {\n+ wb->pinned_curr_bytes = 0;\n+ wb->pinned_used_bytes = 0;\n+\n+ } else if (avail_bytes <= wb->pinned_max_bytes) {\n+ wb->pinned_curr_bytes = avail_bytes;\n+\n+ } else {\n+ wb->pinned_curr_bytes = wb->pinned_max_bytes;\n+ }\n+}\n+\n static void ufs_process_idle(UfsHc *u)\n {\n- /* Currently do nothing */\n+ ufs_wb_process_flush(u);\n+ ufs_wb_process_resize(u);\n+ ufs_wb_process_pinned(u);\n+ ufs_wb_update_avail_buffer(u);\n return;\n }\n \n@@ -1877,6 +2122,11 @@ static bool ufs_check_constraints(UfsHc *u, Error **errp)\n return false;\n }\n \n+ if (u->params.wb_min_size > u->params.wb_max_size) {\n+ error_setg(errp, \"wb-min-size must be less than or equal wb-max-size\");\n+ return false;\n+ }\n+\n return true;\n }\n \n@@ -1915,11 +2165,42 @@ static void ufs_init_state(UfsHc *u)\n }\n }\n \n+static void ufs_wb_init(UfsHc *u)\n+{\n+ UfsWb *wb = &u->wb;\n+\n+ wb->max_bytes = ufs_unit_to_byte(u, u->params.wb_max_size);\n+ wb->min_bytes = ufs_unit_to_byte(u, u->params.wb_min_size);\n+\n+ wb->curr_bytes = wb->max_bytes;\n+ wb->used_bytes = 0;\n+ wb->resize_bytes = (wb->max_bytes - wb->min_bytes) / 10;\n+\n+ u->attributes.wb_buffer_flush_status = UFS_WB_FLUSH_IDLE;\n+ u->attributes.available_wb_buffer_size = 0xA;\n+ u->attributes.wb_buffer_life_time_est = 0x1;\n+ u->attributes.current_wb_buffer_size = cpu_to_be32(u->params.wb_max_size);\n+\n+ u->attributes.wb_buffer_resize_hint = UFS_WB_HINT_KEEP;\n+ u->attributes.wb_buffer_resize_status = UFS_WB_RESIZE_IDLE;\n+\n+ u->attributes.wb_buffer_partial_flush_mode = UFS_WB_FLUSH_NONE;\n+\n+ wb->pinned_curr_bytes = 0;\n+ wb->pinned_used_bytes = 0;\n+ wb->pinned_min_bytes = 0;\n+ wb->pinned_total_written_bytes = 0;\n+}\n+\n static void ufs_init_hc(UfsHc *u)\n {\n uint32_t cap = 0;\n uint32_t mcqconfig = 0;\n uint32_t mcqcap = 0;\n+ uint32_t ext_wb_sup = WB_RESIZE | WB_FIFO | WB_PINNED;\n+ uint32_t ext_ufs_feat_sup = UFS_DEV_WB_SUPPORT |\n+ UFS_DEV_HIGH_TEMP_NOTIF |\n+ UFS_DEV_LOW_TEMP_NOTIF;\n int64_t now = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT);\n \n u->reg_size = pow2ceil(ufs_reg_size(u));\n@@ -1981,8 +2262,13 @@ static void ufs_init_hc(UfsHc *u)\n UFS_DEV_LOW_TEMP_NOTIF;\n u->device_desc.queue_depth = u->params.nutrs;\n u->device_desc.product_revision_level = 0x04;\n+ u->device_desc.extended_wb_support |= cpu_to_be16(ext_wb_sup);\n u->device_desc.extended_ufs_features_support =\n- cpu_to_be32(UFS_DEV_HIGH_TEMP_NOTIF | UFS_DEV_LOW_TEMP_NOTIF);\n+ cpu_to_be32((ext_ufs_feat_sup));\n+ u->device_desc.write_booster_buffer_preserve_user_space_en = 0x01;\n+ u->device_desc.write_booster_buffer_type = 0x01;\n+ u->device_desc.num_shared_write_booster_buffer_alloc_units =\n+ cpu_to_be32(u->params.wb_max_size);\n \n memset(&u->geometry_desc, 0, sizeof(GeometryDescriptor));\n u->geometry_desc.length = sizeof(GeometryDescriptor);\n@@ -1998,6 +2284,16 @@ static void ufs_init_hc(UfsHc *u)\n 0x0; /* out-of-order data transfer is not supported */\n u->geometry_desc.max_context_id_number = 0x5;\n u->geometry_desc.supported_memory_types = cpu_to_be16(0x8001);\n+ u->geometry_desc.write_booster_buffer_max_n_alloc_units =\n+ cpu_to_be32(u->params.wb_max_size);\n+ u->geometry_desc.device_max_write_booster_l_us =\n+ u->params.wb_max_lus;\n+ u->geometry_desc.write_booster_buffer_cap_adj_fac =\n+ u->params.wb_cap_adj_fac;\n+ u->geometry_desc.supported_write_booster_buffer_user_space_reduction_types =\n+ u->params.wb_reduction;\n+ u->geometry_desc.supported_write_booster_buffer_types =\n+ 0x1; /* lu-dedicated buffer type is not supported */\n \n memset(&u->attributes, 0, sizeof(u->attributes));\n u->attributes.max_data_in_size = 0x08;\n@@ -2012,6 +2308,8 @@ static void ufs_init_hc(UfsHc *u)\n memset(&u->flags, 0, sizeof(u->flags));\n u->flags.permanently_disable_fw_update = 1;\n \n+ ufs_wb_init(u);\n+\n /*\n * The temperature value is fixed to UFS_TEMPERATURE and does not change\n * dynamically\n@@ -2077,6 +2375,11 @@ static const Property ufs_props[] = {\n DEFINE_PROP_UINT8(\"nutmrs\", UfsHc, params.nutmrs, 8),\n DEFINE_PROP_BOOL(\"mcq\", UfsHc, params.mcq, false),\n DEFINE_PROP_UINT8(\"mcq-maxq\", UfsHc, params.mcq_maxq, 2),\n+ DEFINE_PROP_UINT32(\"wb-max-size\", UfsHc, params.wb_max_size, 0x400),\n+ DEFINE_PROP_UINT32(\"wb-min-size\", UfsHc, params.wb_min_size, 0x100),\n+ DEFINE_PROP_UINT8(\"wb-max-lus\", UfsHc, params.wb_max_lus, 1),\n+ DEFINE_PROP_UINT8(\"wb-cap-adj-fac\", UfsHc, params.wb_cap_adj_fac, 3),\n+ DEFINE_PROP_UINT8(\"wb-reduction\", UfsHc, params.wb_reduction, 1),\n };\n \n static const VMStateDescription ufs_vmstate = {\ndiff --git a/hw/ufs/ufs.h b/hw/ufs/ufs.h\nindex b5f040302129f4d02732ddd20ef82eb33c41922a..42a20245128a765afc2560342135ced81dcc684c 100644\n--- a/hw/ufs/ufs.h\n+++ b/hw/ufs/ufs.h\n@@ -91,6 +91,11 @@ typedef struct UfsParams {\n bool mcq; /* Multiple Command Queue support */\n uint8_t mcq_qcfgptr; /* MCQ Queue Configuration Pointer in MCQCAP */\n uint8_t mcq_maxq; /* MCQ Maximum number of Queues */\n+ uint32_t wb_max_size; /* WB Maximum allocation units */\n+ uint32_t wb_min_size; /* WB Minimum allocation units */\n+ uint8_t wb_max_lus; /* WB Maximum number of LUs */\n+ uint8_t wb_cap_adj_fac; /* WB Capacity Adjustment Factor */\n+ uint8_t wb_reduction; /* WB User Space Reduction */\n } UfsParams;\n \n /*\n@@ -118,6 +123,24 @@ typedef struct UfsCq {\n QTAILQ_HEAD(, UfsRequest) req_list;\n } UfsCq;\n \n+/*\n+ * Extended features\n+ */\n+typedef struct UfsWb {\n+ struct UfsHc *u;\n+ uint64_t max_bytes;\n+ uint64_t min_bytes;\n+ uint64_t curr_bytes;\n+ uint64_t used_bytes;\n+ uint64_t resize_bytes;\n+\n+ uint64_t pinned_max_bytes;\n+ uint64_t pinned_min_bytes;\n+ uint64_t pinned_curr_bytes;\n+ uint64_t pinned_used_bytes;\n+ uint64_t pinned_total_written_bytes;\n+} UfsWb;\n+\n typedef struct UfsHc {\n PCIDevice parent_obj;\n UfsBus bus;\n@@ -147,6 +170,9 @@ typedef struct UfsHc {\n UfsSq *sq[UFS_MAX_MCQ_QNUM];\n UfsCq *cq[UFS_MAX_MCQ_QNUM];\n \n+ /* Extended features */\n+ UfsWb wb;\n+\n uint8_t temperature;\n \n QEMUTimer idle_timer;\n@@ -211,6 +237,27 @@ static inline bool ufs_mcq_cq_full(UfsHc *u, uint32_t qid)\n return tail == ufs_mcq_cq_head(u, qid);\n }\n \n+static inline uint64_t ufs_unit_to_byte(UfsHc *u, uint32_t unit)\n+{\n+ return (uint64_t)unit * u->geometry_desc.allocation_unit_size *\n+ be32_to_cpu(u->geometry_desc.segment_size) * BDRV_SECTOR_SIZE;\n+}\n+\n+static inline uint32_t ufs_byte_to_unit(UfsHc *u, uint64_t byte)\n+{\n+ return byte / BDRV_SECTOR_SIZE /\n+ be32_to_cpu(u->geometry_desc.segment_size) /\n+ u->geometry_desc.allocation_unit_size;\n+}\n+\n+static inline bool ufs_is_write_req(UfsRequest *req)\n+{\n+ uint8_t cmd = req->req_upiu.sc.cdb[0];\n+\n+ /* UFS 4.1 Specifiaction doesn't support WRITE_12 */\n+ return (cmd == WRITE_6) || (cmd == WRITE_10) || (cmd == WRITE_16);\n+}\n+\n #define TYPE_UFS \"ufs\"\n #define UFS(obj) OBJECT_CHECK(UfsHc, (obj), TYPE_UFS)\n \ndiff --git a/include/block/ufs.h b/include/block/ufs.h\nindex 4dacfb776f947a285d86018add82115f148b7dd9..aa0dde805826d0b06ab80fb74034192ba06c2045 100644\n--- a/include/block/ufs.h\n+++ b/include/block/ufs.h\n@@ -1126,11 +1126,24 @@ enum health_desc_param {\n UFS_HEALTH_DESC_PARAM_LIFE_TIME_EST_B = 0x4,\n };\n \n+/* Possible values for bUFSFeaturesSupport */\n enum {\n UFS_DEV_HIGH_TEMP_NOTIF = BIT(4),\n UFS_DEV_LOW_TEMP_NOTIF = BIT(5),\n };\n \n+/* Possible values for dExtendedWriteBoosterSupport */\n+enum {\n+ WB_RESIZE = BIT(0),\n+ WB_FIFO = BIT(1),\n+ WB_PINNED = BIT(2),\n+};\n+\n+/* Possible values for dExtendedUFSFeaturesSupport */\n+enum {\n+ UFS_DEV_WB_SUPPORT = BIT(8),\n+};\n+\n /* WriteBooster buffer mode */\n enum {\n UFS_WB_BUF_MODE_LU_DEDICATED = 0x0,\n@@ -1207,6 +1220,44 @@ enum ufs_dev_pwr_mode {\n UFS_DEEPSLEEP_PWR_MODE = 4,\n };\n \n+/* UFS Write Booster */\n+enum ufs_wb_flush_status {\n+ UFS_WB_FLUSH_IDLE = 0,\n+ UFS_WB_FLUSH_IN_PROGRESS = 1,\n+ UFS_WB_FLUSH_SUSPENDED = 2,\n+ UFS_WB_FLUSH_COMPLETED = 3,\n+ UFS_WB_FLUSH_FAILED = 4,\n+ UFS_WB_FLUSH_STATUS_MAX,\n+};\n+\n+enum ufs_wb_flush_mode {\n+ UFS_WB_FLUSH_NONE = 0,\n+ UFS_WB_FLUSH_FIFO = 1,\n+ UFS_WB_FLUSH_PINNED = 2,\n+ UFS_WB_FLUSH_MODE_MAX,\n+};\n+\n+enum ufs_wb_resize_hint {\n+ UFS_WB_HINT_KEEP = 0,\n+ UFS_WB_HINT_DECREASE = 1,\n+ UFS_WB_HINT_ENCREASE = 2,\n+ UFS_WB_RESIZE_HINT_MAX,\n+};\n+\n+enum ufs_wb_resize_op {\n+ UFS_WB_DECREASE = 0,\n+ UFS_WB_INCREASE = 1,\n+ UFS_WB_RESIZE_OP_MAX,\n+};\n+\n+enum ufs_wb_resize_status {\n+ UFS_WB_RESIZE_IDLE = 0,\n+ UFS_WB_RESIZE_IN_PROGRESS = 1,\n+ UFS_WB_RESIZE_COMPLETED = 2,\n+ UFS_WB_RESIZE_FAILED = 3,\n+ UFS_WB_RESIZE_STATUS_MAX,\n+};\n+\n /*\n * struct UtpCmdRsp - Response UPIU structure\n * @residual_transfer_count: Residual transfer count DW-3\n", "prefixes": [ "v3", "4/5" ] }