Patch Detail
get:
Show a patch.
patch:
Update a patch.
put:
Update a patch.
GET /api/patches/2217681/?format=api
{ "id": 2217681, "url": "http://patchwork.ozlabs.org/api/patches/2217681/?format=api", "web_url": "http://patchwork.ozlabs.org/project/qemu-devel/patch/20260330113348epcms2p2d7a91b4e09f78a4fce6d3cd5514e2871@epcms2p2/", "project": { "id": 14, "url": "http://patchwork.ozlabs.org/api/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": "<20260330113348epcms2p2d7a91b4e09f78a4fce6d3cd5514e2871@epcms2p2>", "list_archive_url": null, "date": "2026-03-30T11:33:48", "name": "[4/5] hw/ufs: Add UFS Write Booster Support", "commit_ref": null, "pull_url": null, "state": "new", "archived": false, "hash": "2e16271f6fada8f63f24ad4cc653965c8b3efc6b", "submitter": { "id": 93006, "url": "http://patchwork.ozlabs.org/api/people/93006/?format=api", "name": "Jaemyung Lee", "email": "jaemyung.lee@samsung.com" }, "delegate": null, "mbox": "http://patchwork.ozlabs.org/project/qemu-devel/patch/20260330113348epcms2p2d7a91b4e09f78a4fce6d3cd5514e2871@epcms2p2/mbox/", "series": [ { "id": 497999, "url": "http://patchwork.ozlabs.org/api/series/497999/?format=api", "web_url": "http://patchwork.ozlabs.org/project/qemu-devel/list/?series=497999", "date": "2026-03-30T11:29:39", "name": "[1/5] hw/ufs: Apply UFS 4.1 Specification", "version": 1, "mbox": "http://patchwork.ozlabs.org/series/497999/mbox/" } ], "comments": "http://patchwork.ozlabs.org/api/patches/2217681/comments/", "check": "pending", "checks": "http://patchwork.ozlabs.org/api/patches/2217681/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 (1024-bit key;\n unprotected) header.d=samsung.com header.i=@samsung.com header.a=rsa-sha256\n header.s=mail20170921 header.b=SgT8nBqj;\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 4fkpzy0q67z1y1q\n\tfor <incoming@patchwork.ozlabs.org>; Mon, 30 Mar 2026 22:34:06 +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 1w7AsY-00019J-UK; Mon, 30 Mar 2026 07:33:58 -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 <jaemyung.lee@samsung.com>)\n id 1w7AsX-000190-NG\n for qemu-devel@nongnu.org; Mon, 30 Mar 2026 07:33:57 -0400", "from mailout4.samsung.com ([203.254.224.34])\n by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256)\n (Exim 4.90_1) (envelope-from <jaemyung.lee@samsung.com>)\n id 1w7AsT-0001Rc-LZ\n for qemu-devel@nongnu.org; Mon, 30 Mar 2026 07:33:57 -0400", "from epcas2p2.samsung.com (unknown [182.195.41.54])\n by mailout4.samsung.com (KnoxPortal) with ESMTP id\n 20260330113350epoutp0469e5b7e25d2642c874fa359a65255401~hm0C33BNo3269332693epoutp04y\n for <qemu-devel@nongnu.org>; Mon, 30 Mar 2026 11:33:50 +0000 (GMT)", "from epsnrtp04.localdomain (unknown [182.195.42.156]) by\n epcas2p1.samsung.com (KnoxPortal) with ESMTPS id\n 20260330113350epcas2p1d1d8f779843490ffb40160c9187d81e3~hm0CfPhG61781117811epcas2p1G;\n Mon, 30 Mar 2026 11:33:50 +0000 (GMT)", "from epcas2p3.samsung.com (unknown [182.195.38.203]) by\n epsnrtp04.localdomain (Postfix) with ESMTP id 4fkpzd4r2kz6B9m7; Mon, 30 Mar\n 2026 11:33:49 +0000 (GMT)" ], "DKIM-Filter": "OpenDKIM Filter v2.11.0 mailout4.samsung.com\n 20260330113350epoutp0469e5b7e25d2642c874fa359a65255401~hm0C33BNo3269332693epoutp04y", "DKIM-Signature": "v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com;\n s=mail20170921; t=1774870430;\n bh=gczioRrcSTxNgslueZB38Od9SCsDV8D0L/VBI/AswqU=;\n h=Subject:Reply-To:From:To:CC:Date:References:From;\n b=SgT8nBqj2Xnuvuv3Fc7jq7ZRM88PX2NVdxQS7dqzrYCqzN0elYxx99R68Z1u4V5Hq\n J4wAeGarVQZPidNEqZ0nf6US6AH5hVFOvmq28XveNsNy43PheD7G6Mu+wWn+wa4UjK\n D2RwLNb0phORWFf3LqFIcpz87LvmaRqDQ7Le+78E=", "Mime-Version": "1.0", "Subject": "[PATCH 4/5] hw/ufs: Add UFS Write Booster Support", "From": "Jaemyung Lee <jaemyung.lee@samsung.com>", "To": "\"qemu-devel@nongnu.org\" <qemu-devel@nongnu.org>", "CC": "Jeuk Kim <jeuk20.kim@samsung.com>, \"kwolf@redhat.com\"\n <kwolf@redhat.com>, \"hreitz@redhat.com\" <hreitz@redhat.com>,\n \"qemu-block@nongnu.org\" <qemu-block@nongnu.org>, \"farosas@suse.de\"\n <farosas@suse.de>, \"lvivier@redhat.com\" <lvivier@redhat.com>,\n \"pbonzini@redhat.com\" <pbonzini@redhat.com>", "X-Priority": "3", "X-Content-Kind-Code": "NORMAL", "X-CPGS-Detection": "blocking_info_exchange", "X-Drm-Type": "N,general", "X-Msg-Generator": "Mail", "X-Msg-Type": "PERSONAL", "X-Reply-Demand": "N", "Message-ID": "<20260330113348epcms2p2d7a91b4e09f78a4fce6d3cd5514e2871@epcms2p2>", "Date": "Mon, 30 Mar 2026 20:33:48 +0900", "X-CMS-MailID": "20260330113348epcms2p2d7a91b4e09f78a4fce6d3cd5514e2871", "Content-Transfer-Encoding": "7bit", "Content-Type": "text/plain; charset=\"utf-8\"", "X-Sendblock-Type": "AUTO_CONFIDENTIAL", "CMS-TYPE": "102P", "cpgsPolicy": "CPGSC10-223,Y", "X-CFilter-Loop": "Reflected", "X-CMS-RootMailID": "20260330112748epcms2p1717e93009f7fb87a8156ee07a9400502", "References": "\n <CGME20260330112748epcms2p1717e93009f7fb87a8156ee07a9400502@epcms2p2>", "Received-SPF": "pass client-ip=203.254.224.34;\n envelope-from=jaemyung.lee@samsung.com; helo=mailout4.samsung.com", "X-Spam_score_int": "-29", "X-Spam_score": "-3.0", "X-Spam_bar": "---", "X-Spam_report": "(-3.0 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.54,\n DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1,\n RCVD_IN_DNSWL_MED=-2.3, RCVD_IN_MSPIKE_H3=-0.01, RCVD_IN_MSPIKE_WL=-0.01,\n RCVD_IN_VALIDITY_CERTIFIED_BLOCKED=1, RCVD_IN_VALIDITY_RPBL_BLOCKED=1,\n SPF_HELO_PASS=-0.001, SPF_PASS=-0.001 autolearn=ham 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>", "Reply-To": "jaemyung.lee@samsung.com", "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 <jameyung.lee@samsung.com>\n---\n hw/ufs/lu.c | 85 ++++++++++++\n hw/ufs/ufs.c | 330 +++++++++++++++++++++++++++++++++++++++++---\n hw/ufs/ufs.h | 39 ++++++\n include/block/ufs.h | 51 +++++++\n 4 files changed, 486 insertions(+), 19 deletions(-)\n\n--\n2.34.1", "diff": "diff --git a/hw/ufs/lu.c b/hw/ufs/lu.c\nindex 3f3c9589ce..7c25c15169 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 19438c89e1..22a8e39617 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,31 @@ 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 +1438,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,11 +1877,174 @@ 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 /* IDLE */\n static void ufs_process_idle(UfsHc *u)\n {\n- /* Currently do nothing */\n- return;\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 }\n\n static inline bool ufs_check_idle(UfsHc *u)\n@@ -1832,7 +2071,7 @@ static inline bool ufs_mcq_check_idle(UfsHc *u)\n static void ufs_idle_timer_cb(void *opaque)\n {\n UfsHc *u = opaque;\n- int64_t now = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL);\n+ int64_t now = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT);\n\n if (ufs_check_idle(u) && ufs_mcq_check_idle(u)) {\n ufs_process_idle(u);\n@@ -1898,12 +2137,43 @@ 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- int64_t now = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL);\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\n@@ -1964,8 +2234,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@@ -1981,6 +2256,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@@ -1995,13 +2280,15 @@ 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 */\n u->temperature = UFS_TEMPERATURE;\n\n- timer_init_ms(&u->idle_timer, QEMU_CLOCK_VIRTUAL, ufs_idle_timer_cb, u);\n+ timer_init_ms(&u->idle_timer, QEMU_CLOCK_VIRTUAL_RT, ufs_idle_timer_cb, u);\n timer_mod(&u->idle_timer, now + UFS_IDLE_TIMER_TICK);\n }\n\n@@ -2060,6 +2347,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 f0b1f8b0e0..a993140567 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 /* IDLE timer */\n@@ -212,6 +238,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 4dacfb776f..aa0dde8058 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" ] }