Patch Detail
get:
Show a patch.
patch:
Update a patch.
put:
Update a patch.
GET /api/1.0/patches/2219149/?format=api
{ "id": 2219149, "url": "http://patchwork.ozlabs.org/api/1.0/patches/2219149/?format=api", "project": { "id": 14, "url": "http://patchwork.ozlabs.org/api/1.0/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": "" }, "msgid": "<20260402-write_booster-v1-4-e4fed1df6c7e@samsung.com>", "date": "2026-04-02T09:43:48", "name": "[4/5] hw/ufs: Add UFS Write Booster Support", "commit_ref": null, "pull_url": null, "state": "new", "archived": false, "hash": "2cb6139b43483b51afdc1c5e6ddf8fa9de97a4f4", "submitter": { "id": 93039, "url": "http://patchwork.ozlabs.org/api/1.0/people/93039/?format=api", "name": "Jaemyung Lee", "email": "ldc.jml@gmail.com" }, "delegate": null, "mbox": "http://patchwork.ozlabs.org/project/qemu-devel/patch/20260402-write_booster-v1-4-e4fed1df6c7e@samsung.com/mbox/", "series": [ { "id": 498486, "url": "http://patchwork.ozlabs.org/api/1.0/series/498486/?format=api", "date": "2026-04-02T09:43:48", "name": "hw/ufs: Add Write Booster Support on UFS", "version": 1, "mbox": "http://patchwork.ozlabs.org/series/498486/mbox/" } ], "check": "pending", "checks": "http://patchwork.ozlabs.org/api/patches/2219149/checks/", "tags": {}, "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=nQqfzBnJ;\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 (lists.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 4fmjwf2pscz1xtJ\n\tfor <incoming@patchwork.ozlabs.org>; Fri, 03 Apr 2026 00:52:50 +1100 (AEDT)", "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 1w8ISn-0003GB-Eh; Thu, 02 Apr 2026 09:52:03 -0400", "from eggs.gnu.org ([2001:470:142:3::10])\n by lists.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 1w8Eay-0001Dx-Jt\n for qemu-devel@nongnu.org; Thu, 02 Apr 2026 05:44:14 -0400", "from mail-pf1-x429.google.com ([2607:f8b0:4864:20::429])\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 1w8Eau-0005OO-8A\n for qemu-devel@nongnu.org; Thu, 02 Apr 2026 05:44:11 -0400", "by mail-pf1-x429.google.com with SMTP id\n d2e1a72fcca58-82cf83bf375so294921b3a.0\n for <qemu-devel@nongnu.org>; Thu, 02 Apr 2026 02:44:07 -0700 (PDT)", "from [172.17.0.5] ([168.126.243.22])\n by smtp.gmail.com with ESMTPSA id\n d2e1a72fcca58-82cf9c6ad8asm2668477b3a.40.2026.04.02.02.44.04\n (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256);\n Thu, 02 Apr 2026 02:44:06 -0700 (PDT)" ], "DKIM-Signature": "v=1; a=rsa-sha256; c=relaxed/relaxed;\n d=gmail.com; s=20251104; t=1775123047; x=1775727847; 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=Bfb8YXGRc71OupZ3vGGVhFCM1RFW8zaN1q08/2Gx108=;\n b=nQqfzBnJnnBw6nk5za1aovPUvhKDodaVRWEv6iPKO0hWHm5ixKqV7pHsbwZNRXWRUy\n yO4jcKuz2cF41n6KhwYw7tMkJ2JrkItobPytEHmku0mF0fms6BAv4rSmmGp2sbmoIDYt\n iLmkSyKQxuMHIIkbxYqaxcwqCEvCcAxmKCmuoisc17G9O9hWSeYMgaQABPpVOzGWfsYj\n 7Q8LyRptIlveZp68sgkiUgCyeXVhT5arM4ULt3VeTlpMY2Olj3yD6bJejBI3pYzAu19S\n 8f9FD8KS3Dj692UAVUU36HVxuWnB2hw8rOHMmflCnOZX1LC85fLSmfVR1J8TRQvbATqe\n DIoA==", "X-Google-DKIM-Signature": "v=1; a=rsa-sha256; c=relaxed/relaxed;\n d=1e100.net; s=20251104; t=1775123047; x=1775727847;\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=Bfb8YXGRc71OupZ3vGGVhFCM1RFW8zaN1q08/2Gx108=;\n b=owpFpUDLcaeXVEQNljklLmUZfaFZnCTi25bgB3ac6WvBvH1okdzjH1uSUfC6Bmbr+5\n 6m/F2r40YRrLSOPdOyI5XJFR3vW/IdPBbjmFG4pY1F+M7SzDVSPlvQB3uxxgaIoP9hqC\n ee75uqP4HkcnxMtPbvZuCPFp5NkB985AMSeD5NzUlY08EzdQtNdBkhGKaUpsAO+bjASk\n 929Av8dnbPecnu+Hd2F9QDJ31iz659h2fw2MYkNDK2TafWJO3fV/TFZg/oK2HGNwtQDc\n VJS/YjZvJ+8CMqxCQ+dbzQrSzKPoqEJpQVGVHil196XOfoZ4fkBy3VRY7NV02QZw6R2t\n 8rJQ==", "X-Gm-Message-State": "AOJu0YzclvUW9R2Je1s+TqHeT2Y62Go40VYT5rVCBQ9tAqiJAI6V2EoN\n 7RbZYVX/SKaWz7dCBqLnibFnlMZWGlAIIMGqOVKaf3G631K1yVQEbGJ9", "X-Gm-Gg": "ATEYQzwiAsYYOw9JFYkADAepJ5h7FBiWf+Z2NV+o+wUnxbrmX1VCex5m3PEQMN5I5B1\n w1aK7qORGLtAZ26+ScWq6evT3X8mvkViXJDP8VzkeoFMGJvrbnJSUODNlDomAR1fIkCGxmmMN5A\n fXBPh0KHh+JBqiRzCDnHjsRVaCydQlmw0k1cMI18dBoKXxPYCaic6aokhlxpZoRxkqWj+Eq7Cvq\n fi8ceNsOYG52MhB/cN0gSjkhNW9CO12TsU+p3qR/b48mPxGg82rO1D40g2CPgHUvoQVppnYPYs7\n L+gDiN39Fqus0xefSF0/Abd0k8QoR79SInAkCtgG1c3l1T9X46PD+gutLW3RAvGgYC9ktDtuNJ5\n iA5G5d5wEDNoJP8fl+u8aKG74bWq52i6czPMuphycT2L7N1ZUReAppG1jibo07YDmHMuCX4M20r\n ZpzNfmzOuWEu88CI4zaAb1O+24ZV+WF8DiTXwNDBSF", "X-Received": "by 2002:a05:6a00:448d:b0:82c:70a8:faec with SMTP id\n d2e1a72fcca58-82ce8960f03mr7774704b3a.21.1775123046654;\n Thu, 02 Apr 2026 02:44:06 -0700 (PDT)", "From": "Jaemyung Lee <ldc.jml@gmail.com>", "X-Google-Original-From": "Jaemyung Lee <jaemyung.lee@samsung.com>", "Date": "Thu, 02 Apr 2026 18:43:48 +0900", "Subject": "[PATCH 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": "<20260402-write_booster-v1-4-e4fed1df6c7e@samsung.com>", "References": "<20260402-write_booster-v1-0-e4fed1df6c7e@samsung.com>", "In-Reply-To": "<20260402-write_booster-v1-0-e4fed1df6c7e@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=1775123032; l=25227;\n i=jaemyung.lee@samsung.com; s=20260402; h=from:subject:message-id;\n bh=+yxVF3yyPUOckIo8ni1rA7x2VicWb/OlpmcBy20wq50=;\n b=zujFV2ZcMzP+2vtX+eS1R+xZaWAFm1SQac8+pI4HPa4z/vhxhfoHvG25DL9Ou6Nx+Smjsu+nz\n jBfEyHHicTpAITm5DR4d/MOT0CoHjEckaBUugmDEx+mDsCniodHacKM", "X-Developer-Key": "i=jaemyung.lee@samsung.com; a=ed25519;\n pk=bZPd7A/kteUO62FfUM6IrI1LuBPe5QrcqfvsitM1ZjE=", "Received-SPF": "pass client-ip=2607:f8b0:4864:20::429;\n envelope-from=ldc.jml@gmail.com; helo=mail-pf1-x429.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=ham autolearn_force=no", "X-Spam_action": "no action", "X-Mailman-Approved-At": "Thu, 02 Apr 2026 09:51:39 -0400", "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 | 85 ++++++++++++++\n hw/ufs/ufs.c | 328 +++++++++++++++++++++++++++++++++++++++++++++++++---\n hw/ufs/ufs.h | 39 +++++++\n include/block/ufs.h | 51 ++++++++\n 4 files changed, 488 insertions(+), 15 deletions(-)", "diff": "diff --git a/hw/ufs/lu.c b/hw/ufs/lu.c\nindex 3f3c9589cee57ae3e77e2f486476d5fcec204d80..7c25c15169f76f22059c3ae03dfc1f21b0e41e8d 100644\n--- a/hw/ufs/lu.c\n+++ b/hw/ufs/lu.c\n@@ -247,6 +247,89 @@ static UfsReqResult ufs_emulate_scsi_cmd(UfsLu *lu, UfsRequest *req)\n return UFS_REQUEST_SUCCESS;\n }\n \n+#define UFS_GROUP_NUMBER_MASK 0x1F\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 group_number = req->req_upiu.sc.cdb[6] & UFS_GROUP_NUMBER_MASK;\n+\n+ if (u->attributes.wb_buffer_partial_flush_mode != UFS_WB_FLUSH_PINNED) {\n+ return false;\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+{\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 >= req->data_len) {\n+ wb->pinned_total_written_bytes += req->data_len;\n+ wb->pinned_used_bytes += req->data_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 = req->data_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+{\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, req->data_len);\n+}\n+\n+static void ufs_wb_process_write_cmd(UfsRequest *req)\n+{\n+ uint8_t command = req->req_upiu.sc.cdb[0];\n+ UfsHc *u = req->hc;\n+\n+ if (command != WRITE_10 || !u->flags.wb_en) {\n+ return;\n+ }\n+\n+ if (ufs_wb_check_write_pinned(u, req)) {\n+ ufs_wb_process_write_pinned(u, req);\n+ } else {\n+ ufs_wb_process_write_normal(u, req);\n+ }\n+}\n+\n static UfsReqResult ufs_process_scsi_cmd(UfsLu *lu, UfsRequest *req)\n {\n uint8_t task_tag = req->req_upiu.header.task_tag;\n@@ -261,6 +344,8 @@ static UfsReqResult ufs_process_scsi_cmd(UfsLu *lu, UfsRequest *req)\n return ufs_emulate_scsi_cmd(lu, req);\n }\n \n+ ufs_wb_process_write_cmd(req);\n+\n SCSIRequest *scsi_req =\n scsi_req_new(lu->scsi_dev, task_tag, lu->lun, req->req_upiu.sc.cdb,\n UFS_CDB_SIZE, req);\ndiff --git a/hw/ufs/ufs.c b/hw/ufs/ufs.c\nindex 111ce3c3a0b03a1ead722f48b799e3ed0c403cce..3c58760663d2752c3478d83a0675b879c7f5c6f2 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@@ -1899,11 +2144,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@@ -1965,8 +2241,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(0x400); /* 4GB */\n \n memset(&u->geometry_desc, 0, sizeof(GeometryDescriptor));\n u->geometry_desc.length = sizeof(GeometryDescriptor);\n@@ -1982,6 +2263,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@@ -1996,6 +2287,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@@ -2061,6 +2354,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..f27c30d202195636726e6920d14c3ee9c03494be 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,19 @@ 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 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 #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": [ "4/5" ] }