From nobody Mon Feb 9 19:10:10 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1767650259; cv=none; d=zohomail.com; s=zohoarc; b=A8GwLHM7OKkzOZnnugwPWXmFxMuhXX453q98oBdlaNiE+pI3HMQCtvhghzrFO6/3H97LuDvWBDkh9yNzEXv6qE0oG2aQmInCYJ0FCD0W0ekcFbRO/EbjysrFvJkMbWhkT5axiVjvEAF7HW28JPIH2IjlSIgGJPIbh4DBcLKwdPA= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1767650259; h=Content-Type:Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=Slpfs7WZ+iKZoWhCiiERgzqaUb4eUR5jnMkodGSowFE=; b=AZYWlkM4GDOi1Sbwh1L9UJhSSq36Cz8P7Js4YWKqYS+TqBkZvJ6rFfNPQ5FVZY/oet9mtAiTnPsjrXmwx9ucgxbdcArHIGoXfxwrOju8hAl2PtYStHAxOqTjWLF/5EJu34EoPp1qJJaTZnJ9DVE6z+H03QLTTDbEQm2zRuyHDPs= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1767650259108442.63959084553835; Mon, 5 Jan 2026 13:57:39 -0800 (PST) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1vcsXV-0006Jz-Rm; Mon, 05 Jan 2026 16:55:01 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1vcsXU-0006I1-8U; Mon, 05 Jan 2026 16:55:00 -0500 Received: from tor.source.kernel.org ([2600:3c04:e001:324:0:1991:8:25]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1vcsXP-0006CX-1l; Mon, 05 Jan 2026 16:54:59 -0500 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by tor.source.kernel.org (Postfix) with ESMTP id 0D7EE6011E; Mon, 5 Jan 2026 21:54:51 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 85D65C16AAE; Mon, 5 Jan 2026 21:54:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1767650090; bh=7PBKYqI5XMpagFd21xzmh3DIpzHMfcpMSp6vyVCkpXI=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=Elmjlh1y0GK8TrGX2FmYOyam1nohNzTns5RtVUMP+E1DwQks1iTf0dD60obZCZorj VHQCwkSWXW5YyxBQNFBfXI1NkMs6jIffgZz5Z6vCKsD53a7iEm6DRaETCAPAJnkbin sOZQMnAci//wl8yNG8vOjn7EMwoe0pmEACm92rGQkp+6MZ4g/P6kVwcBSB3itchCkf WBess/ZKSpv47xAI/jEciGzCTPuWi8eAaq3oK63Kbt9fmV6tdMZxTuXydgWB1OQiPx /fFUXaR/FhOuCadNiQuwKpCUSBGXXPy6Cv4NwS0FJFnk6vEHnD58/nRb6+zaJzhHbg 83Thi0+W1fh7Q== From: Drew Fustini Date: Mon, 05 Jan 2026 13:54:19 -0800 Subject: [PATCH v4 1/6] riscv: implement Ssqosid extension and srmcfg CSR MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260105-riscv-ssqosid-cbqri-v4-1-9ad7671dde78@kernel.org> References: <20260105-riscv-ssqosid-cbqri-v4-0-9ad7671dde78@kernel.org> In-Reply-To: <20260105-riscv-ssqosid-cbqri-v4-0-9ad7671dde78@kernel.org> To: qemu-devel@nongnu.org Cc: qemu-riscv@nongnu.org, Palmer Dabbelt , Alistair Francis , Weiwei Li , Daniel Henrique Barboza , Liu Zhiwei , Paolo Bonzini , Nicolas Pitre , =?utf-8?q?Kornel_Dul=C4=99ba?= , Atish Kumar Patra , Atish Patra , Vasudevan Srinivasan , =?utf-8?q?Radim_Kr=C4=8Dm=C3=A1=C5=99?= , yunhui cui , Chen Pei , guo.wenjia23@zte.com.cn, liu.qingtao2@zte.com.cn, Drew Fustini X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=6693; i=fustini@kernel.org; h=from:subject:message-id; bh=xYM47oqTdnfm4nufTRjEyNgDVz96xV9bD7l4VUuUTuw=; b=owGbwMvMwCV2+43O4ZsaG3kYT6slMWTGGGtyP7PKEeJec5jztf6dvXvMZuv9cix49Z3TirF10 6bVPGorO0pZGMS4GGTFFFk2fci7sMQr9OuC+S+2wcxhZQIZwsDFKQAT+abL8D8zoeofz/XP3MxG GgGH7rRoFAs8U3z1x3LdD+9ok+DCHyyMDC8f6yy44digqXf4yJT2V6UKW7ayRVzbuIfXSDPL7Oi BKi4A X-Developer-Key: i=fustini@kernel.org; a=openpgp; fpr=1B6F948213EA489734F3997035D5CD577C1E6010 Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2600:3c04:e001:324:0:1991:8:25; envelope-from=fustini@kernel.org; helo=tor.source.kernel.org 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, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=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: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1767650261671158500 From: Kornel Dul=C4=99ba Implement the srmcfg CSR defined by the Ssqosid ISA extension (Supervisor-mode Quality of Service ID). The CSR contains two fields: - Resource Control ID (RCID) used determine resource allocation - Monitoring Counter ID (MCID) used to track resource usage The CSR is defined for S-mode, so check mstateen0.srmcfg to determine if s-mode is allowed to access it. In addition, accessing it when V=3D1 shall cause a virtual instruction exception. Link: https://github.com/riscv-non-isa/riscv-cbqri/releases/download/v1.0/r= iscv-cbqri.pdf Link: https://docs.riscv.org/reference/isa/priv/smstateen.html Signed-off-by: Kornel Dul=C4=99ba [fustini: rebase on v10.1.50, fix check_srmcfg] Signed-off-by: Drew Fustini --- disas/riscv.c | 1 + target/riscv/cpu.c | 2 ++ target/riscv/cpu.h | 3 +++ target/riscv/cpu_bits.h | 9 +++++++++ target/riscv/cpu_cfg_fields.h.inc | 1 + target/riscv/csr.c | 37 +++++++++++++++++++++++++++++++++++= ++ 6 files changed, 53 insertions(+) diff --git a/disas/riscv.c b/disas/riscv.c index 85cd2a9c2aef..86fc710528c1 100644 --- a/disas/riscv.c +++ b/disas/riscv.c @@ -2289,6 +2289,7 @@ static const char *csr_name(int csrno) case 0x0143: return "stval"; case 0x0144: return "sip"; case 0x0180: return "satp"; + case 0x0181: return "srmcfg"; case 0x0200: return "hstatus"; case 0x0202: return "hedeleg"; case 0x0203: return "hideleg"; diff --git a/target/riscv/cpu.c b/target/riscv/cpu.c index 8f26d8b8b076..f665308896e5 100644 --- a/target/riscv/cpu.c +++ b/target/riscv/cpu.c @@ -216,6 +216,7 @@ const RISCVIsaExtData isa_edata_arr[] =3D { ISA_EXT_DATA_ENTRY(ssdbltrp, PRIV_VERSION_1_13_0, ext_ssdbltrp), ISA_EXT_DATA_ENTRY(ssnpm, PRIV_VERSION_1_13_0, ext_ssnpm), ISA_EXT_DATA_ENTRY(sspm, PRIV_VERSION_1_13_0, ext_sspm), + ISA_EXT_DATA_ENTRY(ssqosid, PRIV_VERSION_1_13_0, ext_ssqosid), ISA_EXT_DATA_ENTRY(ssstateen, PRIV_VERSION_1_12_0, ext_ssstateen), ISA_EXT_DATA_ENTRY(ssstrict, PRIV_VERSION_1_12_0, has_priv_1_12), ISA_EXT_DATA_ENTRY(sstc, PRIV_VERSION_1_12_0, ext_sstc), @@ -1268,6 +1269,7 @@ const RISCVCPUMultiExtConfig riscv_cpu_extensions[] = =3D { MULTI_EXT_CFG_BOOL("zvfbfwma", ext_zvfbfwma, false), MULTI_EXT_CFG_BOOL("zvfh", ext_zvfh, false), MULTI_EXT_CFG_BOOL("zvfhmin", ext_zvfhmin, false), + MULTI_EXT_CFG_BOOL("ssqosid", ext_ssqosid, true), MULTI_EXT_CFG_BOOL("sstc", ext_sstc, true), MULTI_EXT_CFG_BOOL("ssnpm", ext_ssnpm, false), MULTI_EXT_CFG_BOOL("sspm", ext_sspm, false), diff --git a/target/riscv/cpu.h b/target/riscv/cpu.h index 90b3e951053a..20c2eada1014 100644 --- a/target/riscv/cpu.h +++ b/target/riscv/cpu.h @@ -336,6 +336,9 @@ struct CPUArchState { uint64_t ctr_dst[16 << SCTRDEPTH_MAX]; uint64_t ctr_data[16 << SCTRDEPTH_MAX]; =20 + /* Ssqosid extension */ + target_ulong srmcfg; + /* Machine and Supervisor interrupt priorities */ uint8_t miprio[64]; uint8_t siprio[64]; diff --git a/target/riscv/cpu_bits.h b/target/riscv/cpu_bits.h index b62dd82fe7c0..bd73f9232d70 100644 --- a/target/riscv/cpu_bits.h +++ b/target/riscv/cpu_bits.h @@ -228,6 +228,9 @@ #define CSR_SPTBR 0x180 #define CSR_SATP 0x180 =20 +/* Ssqosid extension */ +#define CSR_SRMCFG 0x181 + /* Supervisor-Level Window to Indirectly Accessed Registers (AIA) */ #define CSR_SISELECT 0x150 #define CSR_SIREG 0x151 @@ -356,6 +359,7 @@ #define SMSTATEEN0_FCSR (1ULL << 1) #define SMSTATEEN0_JVT (1ULL << 2) #define SMSTATEEN0_CTR (1ULL << 54) +#define SMSTATEEN0_SRMCFG (1ULL << 55) #define SMSTATEEN0_P1P13 (1ULL << 56) #define SMSTATEEN0_HSCONTXT (1ULL << 57) #define SMSTATEEN0_IMSIC (1ULL << 58) @@ -1164,4 +1168,9 @@ typedef enum CTRType { #define MCONTEXT64 0x0000000000001FFFULL #define MCONTEXT32_HCONTEXT 0x0000007F #define MCONTEXT64_HCONTEXT 0x0000000000003FFFULL + +/* SRMCFG CSR field masks (Ssqosid extensions) */ +#define SRMCFG_RCID 0x00000FFF +#define SRMCFG_MCID 0x0FFF0000 + #endif diff --git a/target/riscv/cpu_cfg_fields.h.inc b/target/riscv/cpu_cfg_field= s.h.inc index a154ecdc792b..6518f6f9c571 100644 --- a/target/riscv/cpu_cfg_fields.h.inc +++ b/target/riscv/cpu_cfg_fields.h.inc @@ -105,6 +105,7 @@ BOOL_FIELD(ext_ssaia) BOOL_FIELD(ext_smctr) BOOL_FIELD(ext_ssctr) BOOL_FIELD(ext_sscofpmf) +BOOL_FIELD(ext_ssqosid) BOOL_FIELD(ext_smepmp) BOOL_FIELD(ext_smrnmi) BOOL_FIELD(ext_ssnpm) diff --git a/target/riscv/csr.c b/target/riscv/csr.c index 5c91658c3dc4..298829c0239f 100644 --- a/target/riscv/csr.c +++ b/target/riscv/csr.c @@ -1759,6 +1759,40 @@ static RISCVException write_stimecmph(CPURISCVState = *env, int csrno, return RISCV_EXCP_NONE; } =20 +static RISCVException check_srmcfg(CPURISCVState *env, int csrno) +{ + if (!riscv_cpu_cfg(env)->ext_ssqosid) { + return RISCV_EXCP_ILLEGAL_INST; + } + + RISCVException ret =3D smstateen_acc_ok(env, 0, SMSTATEEN0_SRMCFG); + if (ret !=3D RISCV_EXCP_NONE) { + return ret; + } + + /* + * Even though this is an S-mode CSR the spec says that we need to thr= ow + * and virt instruction fault if a guest tries to access it. + */ + return env->virt_enabled ? + RISCV_EXCP_VIRT_INSTRUCTION_FAULT : smode(env, csrno); +} + +static RISCVException read_srmcfg(CPURISCVState *env, int csrno, + target_ulong *val) +{ + *val =3D env->srmcfg; + return RISCV_EXCP_NONE; +} + +static RISCVException write_srmcfg(CPURISCVState *env, int csrno, + target_ulong val, uintptr_t ra) +{ + env->srmcfg =3D val & (SRMCFG_RCID | SRMCFG_MCID); + return RISCV_EXCP_NONE; +} + + #define VSTOPI_NUM_SRCS 5 =20 /* @@ -6035,6 +6069,9 @@ riscv_csr_operations csr_ops[CSR_TABLE_SIZE] =3D { /* Supervisor Protection and Translation */ [CSR_SATP] =3D { "satp", satp, read_satp, write_satp }, =20 + /* Supervisor-Level Quality-of-Service Identifiers (Ssqosid) */ + [CSR_SRMCFG] =3D { "srmcfg", check_srmcfg, read_srmcfg, write_srmcf= g }, + /* Supervisor-Level Window to Indirectly Accessed Registers (AIA) */ [CSR_SISELECT] =3D { "siselect", csrind_or_aia_smode, NULL, NULL, rmw_xiselect = }, --=20 2.43.0 From nobody Mon Feb 9 19:10:10 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1767650128; cv=none; d=zohomail.com; s=zohoarc; b=D6E9/lHlgr8vxNRTouAVcrKxghPskMmJNh0zZ6eQ2JNfBUFnOSFENLiduYxZ952wQB9fy+gkt22RCitPXD4Ras/yodot7JVkGFou4QhXUoQu6ZXsgnlLtLGeuDu8tvtMhiGQC7alW1S9gXBD7nfJU+A/TnDDL7L7PHQyNbrrDoM= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1767650128; h=Content-Type:Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=O6W66gsSqjk0zYgLGDWkqQ+Pdb30epeaYP2b3UdVUrE=; b=Dq+lm0TX9JGRXxZwD8IUkJThNt6Qf83e/vPrndOelStIwiP9jASfH2GraelKsmENBk4sDeXmbNZPUe4W/aDJWASAGhjIiVhGwdqlCLhSQR7pEFuny9n79ulYXxnSff9sIEhyvelSWSKodkJqohhtrqIFZ9efPoSnff/kLrYt0vA= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1767650128874918.2280788457768; Mon, 5 Jan 2026 13:55:28 -0800 (PST) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1vcsXV-0006IY-2o; Mon, 05 Jan 2026 16:55:01 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1vcsXS-0006HL-VW; Mon, 05 Jan 2026 16:54:59 -0500 Received: from tor.source.kernel.org ([172.105.4.254]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1vcsXP-0006Ca-3T; Mon, 05 Jan 2026 16:54:58 -0500 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by tor.source.kernel.org (Postfix) with ESMTP id 3BEB86013C; Mon, 5 Jan 2026 21:54:51 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id D215EC19424; Mon, 5 Jan 2026 21:54:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1767650091; bh=87yUqJH6aCJ3Tzr0TY4MD9gaivxrl+oPobd3+WA3yRw=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=BjwJ41T2NaEfHEbf9IyqvzC54fMtvDdm5Kx0SL5FqyGx34USd1LHa4u2sRDZMcQx4 HxrxEkVjo4hyQbWCYIm6dSFbG3NwxSVHCA9aIIGcfrxd++FQyVZjNFTk9mcdGxezOo t/cGr0qp/NJEWANg/V4DpeLWZYeLRG7m7oLlb91cvTwVguUeNlXojammpKkH9oa96H dMpSvmzC8KFKm1Hw8Pnxm/NJBbqoctXAjNxkYJOy2XYQtmu8bj5W+P8ZDb9LGb9v6T seUx83FluArlR6YZHnyQr25kGQMD7hiZm8EDFBz3Oxo6n1hNG+9ZSaploPEffWujQ8 6mAP/crg092Gg== From: Drew Fustini Date: Mon, 05 Jan 2026 13:54:20 -0800 Subject: [PATCH v4 2/6] hw/riscv: define capabilities of CBQRI controllers MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260105-riscv-ssqosid-cbqri-v4-2-9ad7671dde78@kernel.org> References: <20260105-riscv-ssqosid-cbqri-v4-0-9ad7671dde78@kernel.org> In-Reply-To: <20260105-riscv-ssqosid-cbqri-v4-0-9ad7671dde78@kernel.org> To: qemu-devel@nongnu.org Cc: qemu-riscv@nongnu.org, Palmer Dabbelt , Alistair Francis , Weiwei Li , Daniel Henrique Barboza , Liu Zhiwei , Paolo Bonzini , Nicolas Pitre , =?utf-8?q?Kornel_Dul=C4=99ba?= , Atish Kumar Patra , Atish Patra , Vasudevan Srinivasan , =?utf-8?q?Radim_Kr=C4=8Dm=C3=A1=C5=99?= , yunhui cui , Chen Pei , guo.wenjia23@zte.com.cn, liu.qingtao2@zte.com.cn, Drew Fustini X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=4086; i=fustini@kernel.org; h=from:subject:message-id; bh=DEQYQbjVSlboGU+BOdVfGwtVHZcRjAKo5oA3AsVDxuE=; b=owGbwMvMwCV2+43O4ZsaG3kYT6slMWTGGGsePTUjqY1v5sJL+5dkPOXvztixrmGVifE/5sUn1 n1VneS1u6OUhUGMi0FWTJFl04e8C0u8Qr8umP9iG8wcViaQIQxcnAIwkem3GBney0r4FXEd91s9 W4lVpCRs96dkvnV6UX0f9vv9+Mo7xWQWI8NmsaiQmPeTsqd1Je9pPqnYy/shdnJOb/K/Ve4Hp6z eoMgPAA== X-Developer-Key: i=fustini@kernel.org; a=openpgp; fpr=1B6F948213EA489734F3997035D5CD577C1E6010 Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=172.105.4.254; envelope-from=fustini@kernel.org; helo=tor.source.kernel.org 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, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_VALIDITY_RPBL_BLOCKED=0.001, RCVD_IN_VALIDITY_SAFE_BLOCKED=0.001, SPF_HELO_NONE=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: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1767650131559158500 From: Nicolas Pitre Define structs to represent the hardware capabilities of capacity and bandwidth controllers according to the RISC-V Capacity and Bandwidth QoS Register Interface (CBQRI). Link: https://github.com/riscv-non-isa/riscv-cbqri/releases/tag/v1.0 Signed-off-by: Nicolas Pitre Reviewed-by: Daniel Henrique Barboza Signed-off-by: Drew Fustini --- MAINTAINERS | 7 +++++ include/hw/riscv/cbqri.h | 82 ++++++++++++++++++++++++++++++++++++++++++++= ++++ 2 files changed, 89 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index cbae7c26f83e..9d1b2b411010 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -357,6 +357,13 @@ F: target/riscv/XVentanaCondOps.decode F: target/riscv/insn_trans/trans_xventanacondops.c.inc F: disas/riscv-xventana* =20 +RISC-V QoS (Ssqosid ext and CBQRI spec) +M: Nicolas Pitre +M: Drew Fustini +L: qemu-riscv@nongnu.org +S: Supported +F: include/hw/riscv/cbqri.h + RENESAS RX CPUs R: Yoshinori Sato S: Orphan diff --git a/include/hw/riscv/cbqri.h b/include/hw/riscv/cbqri.h new file mode 100644 index 000000000000..a07f1e3a2dde --- /dev/null +++ b/include/hw/riscv/cbqri.h @@ -0,0 +1,82 @@ +/* + * RISC-V Capacity and Bandwidth QoS Register Interface + * URL: https://github.com/riscv-non-isa/riscv-cbqri/releases/tag/v1.0 + * + * Copyright (c) 2023 BayLibre SAS + * SPDX-License-Identifier: GPL-2.0-or-later + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2 or later, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License f= or + * more details. + * + * You should have received a copy of the GNU General Public License along= with + * this program. If not, see . + */ + +#ifndef HW_RISCV_CBQRI_H +#define HW_RISCV_CBQRI_H + +#include "qemu/typedefs.h" + +#define RISCV_CBQRI_VERSION_MAJOR 0 +#define RISCV_CBQRI_VERSION_MINOR 1 + +#define TYPE_RISCV_CBQRI_CC "riscv.cbqri.capacity" +#define TYPE_RISCV_CBQRI_BC "riscv.cbqri.bandwidth" + +/* Capacity Controller hardware capabilities */ +typedef struct RiscvCbqriCapacityCaps { + uint16_t nb_mcids; + uint16_t nb_rcids; + + uint16_t ncblks; + + bool supports_at_data:1; + bool supports_at_code:1; + + bool supports_alloc_op_config_limit:1; + bool supports_alloc_op_read_limit:1; + bool supports_alloc_op_flush_rcid:1; + + bool supports_mon_op_config_event:1; + bool supports_mon_op_read_counter:1; + + bool supports_mon_evt_id_none:1; + bool supports_mon_evt_id_occupancy:1; +} RiscvCbqriCapacityCaps; + +/* Bandwidth Controller hardware capabilities */ +typedef struct RiscvCbqriBandwidthCaps { + uint16_t nb_mcids; + uint16_t nb_rcids; + + uint16_t nbwblks; + uint16_t mrbwb; + + bool supports_at_data:1; + bool supports_at_code:1; + + bool supports_alloc_op_config_limit:1; + bool supports_alloc_op_read_limit:1; + + bool supports_mon_op_config_event:1; + bool supports_mon_op_read_counter:1; + + bool supports_mon_evt_id_none:1; + bool supports_mon_evt_id_rdwr_count:1; + bool supports_mon_evt_id_rdonly_count:1; + bool supports_mon_evt_id_wronly_count:1; +} RiscvCbqriBandwidthCaps; + +DeviceState *riscv_cbqri_cc_create(hwaddr addr, + const RiscvCbqriCapacityCaps *caps, + const char *target_name); +DeviceState *riscv_cbqri_bc_create(hwaddr addr, + const RiscvCbqriBandwidthCaps *caps, + const char *target_name); +#endif --=20 2.43.0 From nobody Mon Feb 9 19:10:10 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1767650180; cv=none; d=zohomail.com; s=zohoarc; b=EflpJwLqhbga4Xlf+BTXd/8EV5nraB5q276dWJHMFbPurooa+7SCAg4Ii2tJWyPvxzqV9FtophIJT/aEr18m9CFz5o7qX94cELVoONcn5tjJQRih/oLyhHOcubxZS/vtzIAtFvZePnLo5DpJDkb0WHRNCWiwqTsHWiYV1jkRCCU= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1767650180; h=Content-Type:Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=jHLdwXtMlyd+VZGZHSRkfd/0XyfJciBYkdZNUozyf+A=; b=JKHyD4vBzdGHJScaGnZl+ePQxYVS7pDMmQH4sGhXogS2Qu2rVgJFJbLE6izfGTTMekYsnFz3622Q9J7SSfOc78tNs+mbg+YgcqZ6h3v36X6w9nq6U2mueuCnTGyPZYZsqAsucAOQKdHquyR6BDSUGuTEsQIF368w0ctTXR7MmD4= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1767650180071155.13908340520607; Mon, 5 Jan 2026 13:56:20 -0800 (PST) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1vcsXY-0006Pr-8A; Mon, 05 Jan 2026 16:55:04 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1vcsXV-0006Jj-AS; Mon, 05 Jan 2026 16:55:01 -0500 Received: from tor.source.kernel.org ([172.105.4.254]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1vcsXP-0006Ce-1p; Mon, 05 Jan 2026 16:55:01 -0500 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by tor.source.kernel.org (Postfix) with ESMTP id A321460143; Mon, 5 Jan 2026 21:54:51 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 285FBC16AAE; Mon, 5 Jan 2026 21:54:51 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1767650091; bh=K37RtNJ0zAXsnaRdDGr02sGPgFo/N4q9DUtX8VTIP3Q=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=cqBW9Q5z8t12wBn7ysI3Tz87sHUG34aTNS4us+RtIRF0za3WgLRw7/ET1M8n/3qJK iOti7lQka7xTizpC9LRMVKEitVs5UHGDN8wOs4hSeuWtO9bB9qK6Y1nTrDaeUIFxyC Z4CWRNl7PLHSyumu97NXLQwjsNvtdMF4tmm/yMTl54igtM9hMSsg4kSr41oRSpBRQ7 SQd//PD4O+j3e/TcS1T4CYQbdCv7rx7mJSjeaL4d414yK1C8mu3rIHZW5T98gI/AHH Tk9OwuMkD3KJSKvrBZo7uM3MwR5FBM81KyMDfeMrVSczfhaUO3ltcKY7aldWXS3CSp RWXJpsSG4JDeA== From: Drew Fustini Date: Mon, 05 Jan 2026 13:54:21 -0800 Subject: [PATCH v4 3/6] hw/riscv: implement CBQRI capacity controller MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260105-riscv-ssqosid-cbqri-v4-3-9ad7671dde78@kernel.org> References: <20260105-riscv-ssqosid-cbqri-v4-0-9ad7671dde78@kernel.org> In-Reply-To: <20260105-riscv-ssqosid-cbqri-v4-0-9ad7671dde78@kernel.org> To: qemu-devel@nongnu.org Cc: qemu-riscv@nongnu.org, Palmer Dabbelt , Alistair Francis , Weiwei Li , Daniel Henrique Barboza , Liu Zhiwei , Paolo Bonzini , Nicolas Pitre , =?utf-8?q?Kornel_Dul=C4=99ba?= , Atish Kumar Patra , Atish Patra , Vasudevan Srinivasan , =?utf-8?q?Radim_Kr=C4=8Dm=C3=A1=C5=99?= , yunhui cui , Chen Pei , guo.wenjia23@zte.com.cn, liu.qingtao2@zte.com.cn, Drew Fustini X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=25955; i=fustini@kernel.org; h=from:subject:message-id; bh=gx73Inp2q04OczsXEVLfNjmeBYBWKGfGs8Dc5otLyiw=; b=owGbwMvMwCV2+43O4ZsaG3kYT6slMWTGGGueTpC6H+rp9/d/ogU3x5nD1y42fElTY6+tyBFf8 Np/VQFLRykLgxgXg6yYIsumD3kXlniFfl0w/8U2mDmsTCBDGLg4BWAil/gYGa7XW7xb90amdsqN mRf3HD3j3Pz+QsqdmTqqfwM2rbJ+48rL8N9129c4DeVfNdPEduz7Z/ZP98u1YymvWo9a/32RtEy lpJMPAA== X-Developer-Key: i=fustini@kernel.org; a=openpgp; fpr=1B6F948213EA489734F3997035D5CD577C1E6010 Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=172.105.4.254; envelope-from=fustini@kernel.org; helo=tor.source.kernel.org 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, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_VALIDITY_RPBL_BLOCKED=0.001, RCVD_IN_VALIDITY_SAFE_BLOCKED=0.001, SPF_HELO_NONE=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: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1767650181365158500 From: Nicolas Pitre Implement a capacity controller according to the Capacity and Bandwidth QoS Register Interface (CBQRI) which supports these capabilities: - Number of access types: 2 (code and data) - Usage monitoring operations: CONFIG_EVENT, READ_COUNTER - Event IDs supported: None, Occupancy - Capacity allocation ops: CONFIG_LIMIT, READ_LIMIT, FLUSH_RCID Link: https://github.com/riscv-non-isa/riscv-cbqri/releases/tag/v1.0 Signed-off-by: Nicolas Pitre [fustini: add fields introduced in the ratified spec: cunits, rpfx, p] Signed-off-by: Drew Fustini --- MAINTAINERS | 1 + hw/riscv/cbqri_capacity.c | 706 ++++++++++++++++++++++++++++++++++++++++++= ++++ 2 files changed, 707 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 9d1b2b411010..99f4c12f3b92 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -362,6 +362,7 @@ M: Nicolas Pitre M: Drew Fustini L: qemu-riscv@nongnu.org S: Supported +F: hw/riscv/cbqri_capacity.c F: include/hw/riscv/cbqri.h =20 RENESAS RX CPUs diff --git a/hw/riscv/cbqri_capacity.c b/hw/riscv/cbqri_capacity.c new file mode 100644 index 000000000000..9382ba5ee989 --- /dev/null +++ b/hw/riscv/cbqri_capacity.c @@ -0,0 +1,706 @@ +/* + * RISC-V Capacity and Bandwidth QoS Register Interface + * URL: https://github.com/riscv-non-isa/riscv-cbqri/releases/tag/v1.0 + * + * Copyright (c) 2023 BayLibre SAS + * SPDX-License-Identifier: GPL-2.0-or-later + * + * This file contains the Capacity-controller QoS Register Interface. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2 or later, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License f= or + * more details. + * + * You should have received a copy of the GNU General Public License along= with + * this program. If not, see . + */ + +#include "qemu/osdep.h" +#include "qapi/error.h" +#include "qemu/error-report.h" +#include "qemu/log.h" +#include "qemu/module.h" +#include "qemu/bitmap.h" +#include "hw/core/qdev-properties.h" +#include "hw/core/sysbus.h" +#include "target/riscv/cpu.h" +#include "hw/riscv/cbqri.h" + +/* Encodings of `AT` field */ +enum { + CC_AT_DATA =3D 0, + CC_AT_CODE =3D 1, +}; + +/* Capabilities */ +REG64(CC_CAPABILITIES, 0); +FIELD(CC_CAPABILITIES, VER, 0, 8); +FIELD(CC_CAPABILITIES, VER_MINOR, 0, 4); +FIELD(CC_CAPABILITIES, VER_MAJOR, 4, 4); +FIELD(CC_CAPABILITIES, NCBLKS, 8, 16); +FIELD(CC_CAPABILITIES, FRCID, 24, 1); +FIELD(CC_CAPABILITIES, CUNITS, 25, 1); +FIELD(CC_CAPABILITIES, RPFX, 26, 1); +FIELD(CC_CAPABILITIES, P, 27, 4); + +/* Usage monitoring control */ +REG64(CC_MON_CTL, 8); +FIELD(CC_MON_CTL, OP, 0, 5); +FIELD(CC_MON_CTL, AT, 5, 3); +FIELD(CC_MON_CTL, MCID, 8, 12); +FIELD(CC_MON_CTL, EVT_ID, 20, 8); +FIELD(CC_MON_CTL, ATV, 28, 1); +FIELD(CC_MON_CTL, STATUS, 32, 7); +FIELD(CC_MON_CTL, BUSY, 39, 1); + +/* Usage monitoring operations */ +enum { + CC_MON_OP_CONFIG_EVENT =3D 1, + CC_MON_OP_READ_COUNTER =3D 2, +}; + +/* Usage monitoring event ID */ +enum { + CC_EVT_ID_None =3D 0, + CC_EVT_ID_Occupancy =3D 1, +}; + +/* CC_MON_CTL.STATUS field encodings */ +enum { + CC_MON_CTL_STATUS_SUCCESS =3D 1, + CC_MON_CTL_STATUS_INVAL_OP =3D 2, + CC_MON_CTL_STATUS_INVAL_MCID =3D 3, + CC_MON_CTL_STATUS_INVAL_EVT_ID =3D 4, + CC_MON_CTL_STATUS_INVAL_AT =3D 5, +}; + +/* Monitoring counter value */ +REG64(CC_MON_CTR_VAL, 16); +FIELD(CC_MON_CTR_VAL, CTR, 0, 63); +FIELD(CC_MON_CTR_VAL, INVALID, 63, 1); + +/* Capacity allocation control */ +REG64(CC_ALLOC_CTL, 24); +FIELD(CC_ALLOC_CTL, OP, 0, 5); +FIELD(CC_ALLOC_CTL, AT, 5, 3); +FIELD(CC_ALLOC_CTL, RCID, 8, 12); +FIELD(CC_ALLOC_CTL, STATUS, 32, 7); +FIELD(CC_ALLOC_CTL, BUSY, 39, 1); + +/* Capacity allocation operations */ +enum { + CC_ALLOC_OP_CONFIG_LIMIT =3D 1, + CC_ALLOC_OP_READ_LIMIT =3D 2, + CC_ALLOC_OP_FLUSH_RCID =3D 3, +}; + +/* CC_ALLOC_CTL.STATUS field encodings */ +enum { + CC_ALLOC_STATUS_SUCCESS =3D 1, + CC_ALLOC_STATUS_INVAL_OP =3D 2, + CC_ALLOC_STATUS_INVAL_RCID =3D 3, + CC_ALLOC_STATUS_INVAL_AT =3D 4, + CC_ALLOC_STATUS_INVAL_BLKMASK =3D 5, +}; + +REG64(CC_BLOCK_MASK, 32); + + +typedef struct MonitorCounter { + uint64_t ctr_val; + int at; + int evt_id; + bool active; +} MonitorCounter; + +typedef struct RiscvCbqriCapacityState { + SysBusDevice parent_obj; + MemoryRegion mmio; + + /* cached value of some registers */ + uint64_t cc_mon_ctl; + uint64_t cc_mon_ctr_val; + uint64_t cc_alloc_ctl; + + /* monitoring counters */ + MonitorCounter *mon_counters; + + /* allocation blockmasks (1st one is the CC_BLOCK_MASK register) */ + uint64_t *alloc_blockmasks; + + /* properties */ + uint64_t mmio_base; + char *target; + uint16_t nb_mcids; + uint16_t nb_rcids; + + uint16_t ncblks; + + bool supports_at_data; + bool supports_at_code; + + bool supports_alloc_op_config_limit; + bool supports_alloc_op_read_limit; + bool supports_alloc_op_flush_rcid; + + bool supports_mon_op_config_event; + bool supports_mon_op_read_counter; + + bool supports_mon_evt_id_none; + bool supports_mon_evt_id_occupancy; +} RiscvCbqriCapacityState; + +#define RISCV_CBQRI_CC(obj) \ + OBJECT_CHECK(RiscvCbqriCapacityState, (obj), TYPE_RISCV_CBQRI_CC) + +static inline unsigned int get_bmw(RiscvCbqriCapacityState *cc) +{ + unsigned int bmw =3D ((cc->ncblks + 63) / 64) * 64; + + return bmw; +} + +static inline unsigned int get_slots(RiscvCbqriCapacityState *cc) +{ + unsigned int slots =3D (cc->ncblks + 63) / 64; + + return slots; +} + +static uint64_t get_blockmask_offset(RiscvCbqriCapacityState *cc, + uint32_t rcid, uint32_t at) +{ + /* + * Each blockmask is made of one or more uint64_t "slots". + * + * The first slot (or set of slots when BMW is great than 64) + * holds the CC_BLOCK_MASK register content. + * + * The following slot holds the the CC_CUNITS register content + * which has a fixed size of 8 bytes. + * + * The remaining slots contain the blockmask for each AT per RCID. + * + * For example, this would be the layout of the slots for a + * controller which has AT types Data and Code enabled and + * NCBLKS of 16. This results in a BMW of 64 so each blockmask + * can fit in 1 slot. The first 6 slots would be: + * + * Slot + * [ 0] register: CC_BLOCK_MASK + * [ 1] register: CC_CUNITS + * [ 2] RCID=3D 0 AT=3D0: cc_block_mask + * [ 3] RCID=3D 0 AT=3D1: cc_block_mask + * [ 4] RCID=3D 1 AT=3D0: cc_block_mask + * [ 5] RCID=3D 1 AT=3D1: cc_block_mask + * + * This would be the layout for NCBLKS of 100 and AT types Data + * and Code. BMW would be 128 so each blockmask takes 2 slots. + * The first 11 slots would be: + * + * Slot + * [ 0] register: CC_BLOCK_MASK + * [ 1] register: CC_BLOCK_MASK + * [ 2] register: CC_CUNITS + * [ 3] RCID=3D 0 AT=3D0: cc_block_mask + * [ 4] RCID=3D 0 AT=3D0: cc_block_mask + * [ 5] RCID=3D 0 AT=3D1: cc_block_mask + * [ 6] RCID=3D 0 AT=3D1: cc_block_mask + * [ 7] RCID=3D 1 AT=3D0: cc_block_mask + * [ 8] RCID=3D 1 AT=3D0: cc_block_mask + * [ 9] RCID=3D 1 AT=3D1: cc_block_mask + * [10] RCID=3D 1 AT=3D1: cc_block_mask + * + */ + unsigned int nb_ats =3D 0; + nb_ats +=3D !!cc->supports_at_data; + nb_ats +=3D !!cc->supports_at_code; + nb_ats =3D MAX(nb_ats, 1); + assert(at < nb_ats); + + unsigned int blockmask_offset; + unsigned int blockmask_slots =3D get_slots(cc); + blockmask_offset =3D blockmask_slots * ((rcid * nb_ats) + at); + + /* + * Add offset for cc_blockmask register in slot 0 to (blockmask_slots-= 1) + */ + blockmask_offset +=3D blockmask_slots; + + /* + * Add offset to account for cc_cunits register which is always 1 slot + */ + blockmask_offset +=3D 1; + + return blockmask_offset; +} + +static uint64_t *get_blockmask_location(RiscvCbqriCapacityState *cc, + uint32_t rcid, uint32_t at) +{ + assert(cc->alloc_blockmasks !=3D NULL); + unsigned int blockmask_offset =3D get_blockmask_offset(cc, rcid, at); + return cc->alloc_blockmasks + blockmask_offset; +} + +static uint32_t alloc_blockmask_config(RiscvCbqriCapacityState *cc, + uint32_t rcid, uint32_t at, + bool *busy) +{ + unsigned int blockmask_slots =3D get_slots(cc); + + if ((cc->ncblks % 64) !=3D 0) { + /* make sure provided mask isn't too large */ + uint64_t tail =3D cc->alloc_blockmasks[blockmask_slots - 1]; + if ((tail >> (cc->ncblks % 64)) !=3D 0) { + return CC_ALLOC_STATUS_INVAL_BLKMASK; + } + } + + /* for now we only preserve the current CC_BLOCK_MASK register content= */ + memcpy(get_blockmask_location(cc, rcid, at), + cc->alloc_blockmasks, blockmask_slots * 8); + return CC_ALLOC_STATUS_SUCCESS; +} + +static uint32_t alloc_blockmask_read(RiscvCbqriCapacityState *cc, + uint32_t rcid, uint32_t at, + bool *busy) +{ + unsigned int blockmask_slots =3D get_slots(cc); + + memcpy(cc->alloc_blockmasks, + get_blockmask_location(cc, rcid, at), + blockmask_slots * 8); + return CC_ALLOC_STATUS_SUCCESS; +} + +static uint32_t alloc_blockmask_init(RiscvCbqriCapacityState *cc, + uint32_t rcid, uint32_t at, bool set, + bool *busy) +{ + void *blockmask =3D get_blockmask_location(cc, rcid, at); + + if (set) { + bitmap_fill(blockmask, cc->ncblks); + } else { + bitmap_zero(blockmask, cc->ncblks); + } + return CC_ALLOC_STATUS_SUCCESS; +} + +static bool is_valid_at(RiscvCbqriCapacityState *cc, uint32_t at) +{ + switch (at) { + case CC_AT_DATA: + return cc->supports_at_data; + case CC_AT_CODE: + return cc->supports_at_code; + default: + return false; + } +} + +static void riscv_cbqri_cc_write_mon_ctl(RiscvCbqriCapacityState *cc, + uint64_t value) +{ + if (!cc->supports_mon_op_config_event && + !cc->supports_mon_op_read_counter) { + /* monitoring not supported: leave mon_ctl set to 0 */ + return; + } + + /* extract writable fields */ + uint32_t op =3D FIELD_EX64(value, CC_MON_CTL, OP); + uint32_t at =3D FIELD_EX64(value, CC_MON_CTL, AT); + uint32_t mcid =3D FIELD_EX64(value, CC_MON_CTL, MCID); + uint32_t evt_id =3D FIELD_EX64(value, CC_MON_CTL, EVT_ID); + bool atv =3D FIELD_EX64(value, CC_MON_CTL, ATV); + + /* extract read-only fields */ + uint32_t status =3D FIELD_EX64(cc->cc_mon_ctl, CC_MON_CTL, STATUS); + bool busy =3D FIELD_EX64(cc->cc_mon_ctl, CC_MON_CTL, BUSY); + + if (busy) { + qemu_log_mask(LOG_GUEST_ERROR, + "%s: busy flag still set, ignored", + __func__); + return; + } + + if (!cc->supports_at_data && + !cc->supports_at_code) { + /* AT not supported: hardwire to 0 */ + at =3D 0; + atv =3D false; + } + + if (mcid >=3D cc->nb_mcids) { + status =3D CC_MON_CTL_STATUS_INVAL_MCID; + } else if (op =3D=3D CC_MON_OP_CONFIG_EVENT && + cc->supports_mon_op_config_event) { + if (evt_id =3D=3D CC_EVT_ID_None && + cc->supports_mon_evt_id_none) { + cc->mon_counters[mcid].active =3D false; + status =3D CC_MON_CTL_STATUS_SUCCESS; + } else if (evt_id =3D=3D CC_EVT_ID_Occupancy && + cc->supports_mon_evt_id_occupancy) { + if (atv && !is_valid_at(cc, at)) { + status =3D CC_MON_CTL_STATUS_INVAL_AT; + } else { + cc->mon_counters[mcid].ctr_val =3D + FIELD_DP64(0, CC_MON_CTR_VAL, INVALID, 1); + cc->mon_counters[mcid].evt_id =3D evt_id; + cc->mon_counters[mcid].at =3D atv ? at : -1; + cc->mon_counters[mcid].active =3D true; + status =3D CC_MON_CTL_STATUS_SUCCESS; + } + } else { + status =3D CC_MON_CTL_STATUS_INVAL_EVT_ID; + } + } else if (op =3D=3D CC_MON_OP_READ_COUNTER && + cc->supports_mon_op_read_counter) { + cc->cc_mon_ctr_val =3D cc->mon_counters[mcid].ctr_val; + status =3D CC_MON_CTL_STATUS_SUCCESS; + } else { + status =3D CC_MON_CTL_STATUS_INVAL_OP; + } + + /* reconstruct updated register value */ + value =3D 0; + value =3D FIELD_DP64(value, CC_MON_CTL, OP, op); + value =3D FIELD_DP64(value, CC_MON_CTL, AT, at); + value =3D FIELD_DP64(value, CC_MON_CTL, MCID, mcid); + value =3D FIELD_DP64(value, CC_MON_CTL, EVT_ID, evt_id); + value =3D FIELD_DP64(value, CC_MON_CTL, ATV, atv); + value =3D FIELD_DP64(value, CC_MON_CTL, STATUS, status); + value =3D FIELD_DP64(value, CC_MON_CTL, BUSY, busy); + cc->cc_mon_ctl =3D value; +} + +static void riscv_cbqri_cc_write_alloc_ctl(RiscvCbqriCapacityState *cc, + uint64_t value) +{ + if (cc->ncblks =3D=3D 0 || + (!cc->supports_alloc_op_config_limit && + !cc->supports_alloc_op_read_limit && + !cc->supports_alloc_op_flush_rcid)) { + /* capacity allocation not supported: leave alloc_ctl set to 0 */ + return; + } + + /* extract writable fields */ + uint32_t op =3D FIELD_EX64(value, CC_ALLOC_CTL, OP); + uint32_t at =3D FIELD_EX64(value, CC_ALLOC_CTL, AT); + uint32_t rcid =3D FIELD_EX64(value, CC_ALLOC_CTL, RCID); + + /* extract read-only fields */ + uint32_t status =3D FIELD_EX64(cc->cc_alloc_ctl, CC_ALLOC_CTL, STATUS); + bool busy =3D FIELD_EX64(cc->cc_alloc_ctl, CC_ALLOC_CTL, BUSY); + + if (busy) { + qemu_log_mask(LOG_GUEST_ERROR, + "%s: busy flag still set, ignored", + __func__); + return; + } + + bool atv =3D true; + if (!cc->supports_at_data && + !cc->supports_at_code) { + /* AT not supported: hardwire to 0 */ + at =3D 0; + atv =3D false; + } + + if (rcid >=3D cc->nb_rcids) { + status =3D CC_ALLOC_STATUS_INVAL_RCID; + } else if (atv && !is_valid_at(cc, at)) { + status =3D CC_ALLOC_STATUS_INVAL_AT; + } else if (op =3D=3D CC_ALLOC_OP_CONFIG_LIMIT && + cc->supports_alloc_op_config_limit) { + status =3D alloc_blockmask_config(cc, rcid, at, &busy); + } else if (op =3D=3D CC_ALLOC_OP_READ_LIMIT && + cc->supports_alloc_op_read_limit) { + status =3D alloc_blockmask_read(cc, rcid, at, &busy); + } else if (op =3D=3D CC_ALLOC_OP_FLUSH_RCID && + cc->supports_alloc_op_flush_rcid) { + /* + * The flush operation is not allowed to change the configured + * capacity block allocation or the capacity unit limit. + */ + status =3D CC_ALLOC_STATUS_SUCCESS; + } else { + status =3D CC_ALLOC_STATUS_INVAL_OP; + } + + /* reconstruct updated register value */ + value =3D 0; + value =3D FIELD_DP64(value, CC_ALLOC_CTL, OP, op); + value =3D FIELD_DP64(value, CC_ALLOC_CTL, AT, at); + value =3D FIELD_DP64(value, CC_ALLOC_CTL, RCID, rcid); + value =3D FIELD_DP64(value, CC_ALLOC_CTL, STATUS, status); + value =3D FIELD_DP64(value, CC_ALLOC_CTL, BUSY, busy); + cc->cc_alloc_ctl =3D value; +} + +static void riscv_cbqri_cc_write(void *opaque, hwaddr addr, + uint64_t value, unsigned size) +{ + RiscvCbqriCapacityState *cc =3D opaque; + + assert((addr % 8) =3D=3D 0); + assert(size =3D=3D 8); + + switch (addr) { + case A_CC_CAPABILITIES: + /* read-only register */ + break; + case A_CC_MON_CTL: + riscv_cbqri_cc_write_mon_ctl(cc, value); + break; + case A_CC_ALLOC_CTL: + riscv_cbqri_cc_write_alloc_ctl(cc, value); + break; + case A_CC_MON_CTR_VAL: + /* read-only register */ + break; + case A_CC_BLOCK_MASK: + if (cc->ncblks =3D=3D 0) { + break; + } + /* fallthrough */ + default: + uint32_t blkmask_slot =3D (addr - A_CC_BLOCK_MASK) / 8; + if (blkmask_slot =3D=3D get_slots(cc)) { + /* this is cc_cunits register */ + break; + } else if (blkmask_slot > get_slots(cc)) { + qemu_log_mask(LOG_GUEST_ERROR, + "%s: out of bounds (addr=3D0x%x)", + __func__, (uint32_t)addr); + break; + } + cc->alloc_blockmasks[blkmask_slot] =3D value; + } +} + +static uint64_t riscv_cbqri_cc_read(void *opaque, hwaddr addr, unsigned si= ze) +{ + RiscvCbqriCapacityState *cc =3D opaque; + uint64_t value =3D 0; + + assert((addr % 8) =3D=3D 0); + assert(size =3D=3D 8); + switch (addr) { + case A_CC_CAPABILITIES: + value =3D FIELD_DP64(value, CC_CAPABILITIES, VER_MAJOR, + RISCV_CBQRI_VERSION_MAJOR); + value =3D FIELD_DP64(value, CC_CAPABILITIES, VER_MINOR, + RISCV_CBQRI_VERSION_MINOR); + value =3D FIELD_DP64(value, CC_CAPABILITIES, NCBLKS, + cc->ncblks); + value =3D FIELD_DP64(value, CC_CAPABILITIES, FRCID, + cc->supports_alloc_op_flush_rcid); + value =3D FIELD_DP64(value, CC_CAPABILITIES, CUNITS, 0); + value =3D FIELD_DP64(value, CC_CAPABILITIES, RPFX, 0); + value =3D FIELD_DP64(value, CC_CAPABILITIES, P, 0); + break; + case A_CC_MON_CTL: + value =3D cc->cc_mon_ctl; + break; + case A_CC_ALLOC_CTL: + value =3D cc->cc_alloc_ctl; + break; + case A_CC_MON_CTR_VAL: + value =3D cc->cc_mon_ctr_val; + break; + case A_CC_BLOCK_MASK: + if (cc->ncblks =3D=3D 0) { + break; + } + /* fallthrough */ + default: + unsigned int blkmask_slot =3D (addr - A_CC_BLOCK_MASK) / 8; + if (blkmask_slot =3D=3D get_slots(cc)) { + /* + * The cc_cunits register is always the slot following the + * last slot of cc_blockmask register. Capacity units are + * not supported by this implementation so must return 0. + */ + value =3D 0; + break; + } else if (blkmask_slot > get_slots(cc)) { + qemu_log_mask(LOG_GUEST_ERROR, "%s: out of bounds (addr=3D0x%x= )", + __func__, (uint32_t)addr); + break; + } + value =3D cc->alloc_blockmasks[blkmask_slot]; + } + + return value; +} + +static const MemoryRegionOps riscv_cbqri_cc_ops =3D { + .read =3D riscv_cbqri_cc_read, + .write =3D riscv_cbqri_cc_write, + .endianness =3D DEVICE_LITTLE_ENDIAN, + .valid.min_access_size =3D 4, + .valid.max_access_size =3D 8, + .impl.min_access_size =3D 8, + .impl.max_access_size =3D 8, +}; + +static void riscv_cbqri_cc_realize(DeviceState *dev, Error **errp) +{ + RiscvCbqriCapacityState *cc =3D RISCV_CBQRI_CC(dev); + unsigned int bmw =3D get_bmw(cc); + /* The size of the CC registers other than bmw is 40 bytes */ + unsigned int mmio_size =3D (bmw / 8) + 40; + + if (!cc->mmio_base) { + error_setg(errp, "mmio_base property not set"); + return; + } + + assert(cc->mon_counters =3D=3D NULL); + cc->mon_counters =3D g_new0(MonitorCounter, cc->nb_mcids); + + assert(cc->alloc_blockmasks =3D=3D NULL); + unsigned int blockmasks_size =3D get_blockmask_offset(cc, cc->nb_rcids= , 0); + cc->alloc_blockmasks =3D g_new0(uint64_t, blockmasks_size); + + memory_region_init_io(&cc->mmio, OBJECT(dev), &riscv_cbqri_cc_ops, + cc, TYPE_RISCV_CBQRI_CC".mmio", mmio_size); + sysbus_init_mmio(SYS_BUS_DEVICE(dev), &cc->mmio); + sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, cc->mmio_base); +} + +static void riscv_cbqri_cc_reset(DeviceState *dev) +{ + RiscvCbqriCapacityState *cc =3D RISCV_CBQRI_CC(dev); + + /* + * The spec requires that the reset value is 0 for the cc_mon_ctl.BUSY + * and cc_alloc_ctl.BUSY fields, and that the reset value is UNSPECIFI= ED + * for all other registers fields. + * + * Therefore, it is legal to set the entire contents of cc_mon_ctl and + * cc_alloc_ctl to 0. + */ + cc->cc_mon_ctl =3D 0; + cc->cc_alloc_ctl =3D 0; + + /* + * The capacity controllers at reset must allocate all available + * capacity to RCID value of 0. + * + * When the capacity controller supports capacity allocation per + * access-type, then all available capacity is shared by all the + * access-type for RCID=3D0. + * + * For unsupported AT values the resource controller behaves as + * if AT was 0 (CC_AT_DATA). + */ + alloc_blockmask_init(cc, 0, CC_AT_DATA, 1, NULL); + if (cc->supports_at_code) { + alloc_blockmask_init(cc, 0, CC_AT_CODE, 1, NULL); + } +} + +static Property riscv_cbqri_cc_properties[] =3D { + DEFINE_PROP_UINT64("mmio_base", RiscvCbqriCapacityState, mmio_base, 0), + DEFINE_PROP_STRING("target", RiscvCbqriCapacityState, target), + + DEFINE_PROP_UINT16("max_mcids", RiscvCbqriCapacityState, nb_mcids, 256= ), + DEFINE_PROP_UINT16("max_rcids", RiscvCbqriCapacityState, nb_rcids, 64), + DEFINE_PROP_UINT16("ncblks", RiscvCbqriCapacityState, ncblks, 16), + + DEFINE_PROP_BOOL("at_data", RiscvCbqriCapacityState, + supports_at_data, true), + DEFINE_PROP_BOOL("at_code", RiscvCbqriCapacityState, + supports_at_code, true), + + DEFINE_PROP_BOOL("alloc_op_config_limit", RiscvCbqriCapacityState, + supports_alloc_op_config_limit, true), + DEFINE_PROP_BOOL("alloc_op_read_limit", RiscvCbqriCapacityState, + supports_alloc_op_read_limit, true), + DEFINE_PROP_BOOL("alloc_op_flush_rcid", RiscvCbqriCapacityState, + supports_alloc_op_flush_rcid, true), + + DEFINE_PROP_BOOL("mon_op_config_event", RiscvCbqriCapacityState, + supports_mon_op_config_event, true), + DEFINE_PROP_BOOL("mon_op_read_counter", RiscvCbqriCapacityState, + supports_mon_op_read_counter, true), + + DEFINE_PROP_BOOL("mon_evt_id_none", RiscvCbqriCapacityState, + supports_mon_evt_id_none, true), + DEFINE_PROP_BOOL("mon_evt_id_occupancy", RiscvCbqriCapacityState, + supports_mon_evt_id_occupancy, true), +}; + +static void riscv_cbqri_cc_class_init(ObjectClass *klass, const void *data) +{ + DeviceClass *dc =3D DEVICE_CLASS(klass); + dc->realize =3D riscv_cbqri_cc_realize; + set_bit(DEVICE_CATEGORY_MISC, dc->categories); + dc->desc =3D "RISC-V CBQRI Capacity Controller"; + device_class_set_props(dc, riscv_cbqri_cc_properties); + dc->legacy_reset =3D riscv_cbqri_cc_reset; + dc->user_creatable =3D true; +} + +static const TypeInfo riscv_cbqri_cc_info =3D { + .name =3D TYPE_RISCV_CBQRI_CC, + .parent =3D TYPE_SYS_BUS_DEVICE, + .instance_size =3D sizeof(RiscvCbqriCapacityState), + .class_init =3D riscv_cbqri_cc_class_init, +}; + +static void riscv_cbqri_cc_register_types(void) +{ + type_register_static(&riscv_cbqri_cc_info); +} + +DeviceState *riscv_cbqri_cc_create(hwaddr addr, + const RiscvCbqriCapacityCaps *caps, + const char *target_name) +{ + DeviceState *dev =3D qdev_new(TYPE_RISCV_CBQRI_CC); + + qdev_prop_set_uint64(dev, "mmio_base", addr); + qdev_prop_set_string(dev, "target", target_name); + qdev_prop_set_uint16(dev, "max_mcids", caps->nb_mcids); + qdev_prop_set_uint16(dev, "max_rcids", caps->nb_rcids); + qdev_prop_set_uint16(dev, "ncblks", caps->ncblks); + + qdev_prop_set_bit(dev, "at_data", + caps->supports_at_data); + qdev_prop_set_bit(dev, "at_code", + caps->supports_at_code); + qdev_prop_set_bit(dev, "alloc_op_config_limit", + caps->supports_alloc_op_config_limit); + qdev_prop_set_bit(dev, "alloc_op_read_limit", + caps->supports_alloc_op_read_limit); + qdev_prop_set_bit(dev, "alloc_op_flush_rcid", + caps->supports_alloc_op_flush_rcid); + qdev_prop_set_bit(dev, "mon_op_config_event", + caps->supports_mon_op_config_event); + qdev_prop_set_bit(dev, "mon_op_read_counter", + caps->supports_mon_op_read_counter); + qdev_prop_set_bit(dev, "mon_evt_id_none", + caps->supports_mon_evt_id_none); + qdev_prop_set_bit(dev, "mon_evt_id_occupancy", + caps->supports_mon_evt_id_occupancy); + + sysbus_realize_and_unref(SYS_BUS_DEVICE(dev), &error_fatal); + + return dev; +} + +type_init(riscv_cbqri_cc_register_types) --=20 2.43.0 From nobody Mon Feb 9 19:10:10 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1767650259; cv=none; d=zohomail.com; s=zohoarc; b=TUk1SBmw9r9JZNVxh3cvGq8Q7xBQNk9sbF6wKpD1KuT3y4SEYbZuxjht6w90xGFH/uLVeTLdybPMEI9yVeNpx4z8a/Kz6ATs3RKqQIxSV3ocmRS1LwPgXUAoyVpWj/1/vVfiIVMF1o1OosX351njvFyJtcStZZZ3Q1UmXihthjw= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1767650259; h=Content-Type:Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=Rec/DeLJGTikacNJfe2jfKy8bmkn4FFsGBS5JYyKdi8=; b=k4B1KWpAj2yg7nByPuVvHgcWgu4Pj2I9IQPoCy9eeYiVPhznwJVWpe12Hx0s4aKpum1GBTnRoGCbnGLNjaV57SMCWye+6aRUTQFTwmF7YKodw/Tll+LkohsoH6igBraiWJSMuqlr09m+I2tEMAz4Yi5rH/ysO8e3tJBaeHbkrpo= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1767650259049836.6818595120286; Mon, 5 Jan 2026 13:57:39 -0800 (PST) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1vcsXX-0006LN-0v; Mon, 05 Jan 2026 16:55:03 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1vcsXT-0006HT-Ey; Mon, 05 Jan 2026 16:54:59 -0500 Received: from tor.source.kernel.org ([172.105.4.254]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1vcsXP-0006Cn-3R; Mon, 05 Jan 2026 16:54:59 -0500 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by tor.source.kernel.org (Postfix) with ESMTP id 0287E60144; Mon, 5 Jan 2026 21:54:52 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 73CE7C19422; Mon, 5 Jan 2026 21:54:51 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1767650091; bh=xCUPL4TaxwpY9S9K7SPxY1BH5DJsdSqZAJHjoSFzSMs=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=nn6gqeKKJlrHlAK4JHhCF1R/uZWbCm/R5qJuZlB/GhoXjm8e0p0MBVyOPFo5Tmx3Y R5Nyg4UZr+jahmDXdfYS8LjlsE8XLGOdix6kCyiXqfYxVFjXfYzsCpnYpza0n4bpF7 k7OL98A/YkMIMgOMWgrLJCYmSOhY3PVOzx2XNvYFEdddalUZNIwu44Mfah0IsMLAAe 5psHA7ghz2kjRRKXvEg0EW4t9imVRN9vqXrYeGVf73y/e1HEqieXn1Y5RkSckhlCdt Ot3nHY4FEBslIADIuMxLhNW64Wv0rhurEXKe/WujFqdUoEe9zFBqAasAPXZ6TBFMhO 9kiPx5b05JjFQ== From: Drew Fustini Date: Mon, 05 Jan 2026 13:54:22 -0800 Subject: [PATCH v4 4/6] hw/riscv: implement CBQRI bandwidth controller MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260105-riscv-ssqosid-cbqri-v4-4-9ad7671dde78@kernel.org> References: <20260105-riscv-ssqosid-cbqri-v4-0-9ad7671dde78@kernel.org> In-Reply-To: <20260105-riscv-ssqosid-cbqri-v4-0-9ad7671dde78@kernel.org> To: qemu-devel@nongnu.org Cc: qemu-riscv@nongnu.org, Palmer Dabbelt , Alistair Francis , Weiwei Li , Daniel Henrique Barboza , Liu Zhiwei , Paolo Bonzini , Nicolas Pitre , =?utf-8?q?Kornel_Dul=C4=99ba?= , Atish Kumar Patra , Atish Patra , Vasudevan Srinivasan , =?utf-8?q?Radim_Kr=C4=8Dm=C3=A1=C5=99?= , yunhui cui , Chen Pei , guo.wenjia23@zte.com.cn, liu.qingtao2@zte.com.cn, Drew Fustini X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=22948; i=fustini@kernel.org; h=from:subject:message-id; bh=Ufs3tqBanIKaM/QhceuLbJjqbCpK0f1mzLTyolO3/mI=; b=owGbwMvMwCV2+43O4ZsaG3kYT6slMWTGGGt2PumRWuhzVSkxM/zazQcl/Rym6sG5ERtZd8Y4N b7ty3naUcrCIMbFICumyLLpQ96FJV6hXxfMf7ENZg4rE8gQBi5OAZgIfxIjw+MpzOFZLb8Xbfmr ds5CP3JJQWt/4I4HJcYtB4V+fnkj1cTIcI4jTPhWb9jfj/cPW19rtntkxaL6rSzEKqvk4rS79y+ fYQQA X-Developer-Key: i=fustini@kernel.org; a=openpgp; fpr=1B6F948213EA489734F3997035D5CD577C1E6010 Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=172.105.4.254; envelope-from=fustini@kernel.org; helo=tor.source.kernel.org 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, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_VALIDITY_RPBL_BLOCKED=0.001, RCVD_IN_VALIDITY_SAFE_BLOCKED=0.001, SPF_HELO_NONE=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: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1767650261643158500 From: Nicolas Pitre Implement a bandwidth controller according to the Capacity and Bandwidth QoS Register Interface (CBQRI) which supports these capabilities: - Number of access types: 2 (code and data) - Usage monitoring operations: CONFIG_EVENT, READ_COUNTER - Event IDs supported: None, Total read/write byte count, Total read byte count, Total write byte count - Bandwidth allocation operations: CONFIG_LIMIT, READ_LIMIT Link: https://github.com/riscv-non-isa/riscv-cbqri/releases/tag/v1.0 Signed-off-by: Nicolas Pitre [fustini: add fields introduced in the ratified spec: rpfx and p] Signed-off-by: Drew Fustini --- MAINTAINERS | 1 + hw/riscv/cbqri_bandwidth.c | 612 +++++++++++++++++++++++++++++++++++++++++= ++++ 2 files changed, 613 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 99f4c12f3b92..3c10cd154635 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -362,6 +362,7 @@ M: Nicolas Pitre M: Drew Fustini L: qemu-riscv@nongnu.org S: Supported +F: hw/riscv/cbqri_bandwidth.c F: hw/riscv/cbqri_capacity.c F: include/hw/riscv/cbqri.h =20 diff --git a/hw/riscv/cbqri_bandwidth.c b/hw/riscv/cbqri_bandwidth.c new file mode 100644 index 000000000000..c5de74410169 --- /dev/null +++ b/hw/riscv/cbqri_bandwidth.c @@ -0,0 +1,612 @@ +/* + * RISC-V Capacity and Bandwidth QoS Register Interface + * URL: https://github.com/riscv-non-isa/riscv-cbqri/releases/tag/v1.0 + * + * Copyright (c) 2023 BayLibre SAS + * SPDX-License-Identifier: GPL-2.0-or-later + * + * This file contains the Bandwidth-controller QoS Register Interface. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2 or later, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License f= or + * more details. + * + * You should have received a copy of the GNU General Public License along= with + * this program. If not, see . + */ + +#include "qemu/osdep.h" +#include "qapi/error.h" +#include "qemu/error-report.h" +#include "qemu/log.h" +#include "qemu/module.h" +#include "hw/core/qdev-properties.h" +#include "hw/core/sysbus.h" +#include "target/riscv/cpu.h" +#include "hw/riscv/cbqri.h" + +/* Encodings of `AT` field */ +enum { + BC_AT_DATA =3D 0, + BC_AT_CODE =3D 1, +}; + +/* Capabilities */ +REG64(BC_CAPABILITIES, 0); +FIELD(BC_CAPABILITIES, VER, 0, 8); +FIELD(BC_CAPABILITIES, VER_MINOR, 0, 4); +FIELD(BC_CAPABILITIES, VER_MAJOR, 4, 4); +FIELD(BC_CAPABILITIES, NBWBLKS, 8, 16); +FIELD(BC_CAPABILITIES, RPFX, 24, 1); +FIELD(BC_CAPABILITIES, P, 25, 4); +FIELD(BC_CAPABILITIES, MRBWB, 32, 16); + +/* Usage monitoring control */ +REG64(BC_MON_CTL, 8); +FIELD(BC_MON_CTL, OP, 0, 5); +FIELD(BC_MON_CTL, AT, 5, 3); +FIELD(BC_MON_CTL, MCID, 8, 12); +FIELD(BC_MON_CTL, EVT_ID, 20, 8); +FIELD(BC_MON_CTL, ATV, 28, 1); +FIELD(BC_MON_CTL, STATUS, 32, 7); +FIELD(BC_MON_CTL, BUSY, 39, 1); + +/* Usage monitoring operations */ +enum { + BC_MON_OP_CONFIG_EVENT =3D 1, + BC_MON_OP_READ_COUNTER =3D 2, +}; + +/* Bandwidth monitoring event ID */ +enum { + BC_EVT_ID_None =3D 0, + BC_EVT_ID_RDWR_count =3D 1, + BC_EVT_ID_RDONLY_count =3D 2, + BC_EVT_ID_WRONLY_count =3D 3, +}; + +/* BC_MON_CTL.STATUS field encodings */ +enum { + BC_MON_CTL_STATUS_SUCCESS =3D 1, + BC_MON_CTL_STATUS_INVAL_OP =3D 2, + BC_MON_CTL_STATUS_INVAL_MCID =3D 3, + BC_MON_CTL_STATUS_INVAL_EVT_ID =3D 4, + BC_MON_CTL_STATUS_INVAL_AT =3D 5, +}; + +/* Monitoring counter value */ +REG64(BC_MON_CTR_VAL, 16); +FIELD(BC_MON_CTR_VAL, CTR, 0, 62); +FIELD(BC_MON_CTR_VAL, INVALID, 62, 1); +FIELD(BC_MON_CTR_VAL, OVF, 63, 1); + +/* Bandwidth Allocation control */ +REG64(BC_ALLOC_CTL, 24); +FIELD(BC_ALLOC_CTL, OP, 0, 5); +FIELD(BC_ALLOC_CTL, AT, 5, 3); +FIELD(BC_ALLOC_CTL, RCID, 8, 12); +FIELD(BC_ALLOC_CTL, STATUS, 32, 7); +FIELD(BC_ALLOC_CTL, BUSY, 39, 1); + +/* Bandwidth allocation operations */ +enum { + BC_ALLOC_OP_CONFIG_LIMIT =3D 1, + BC_ALLOC_OP_READ_LIMIT =3D 2, +}; + +/* BC_ALLOC_CTL.STATUS field encodings */ +enum { + BC_ALLOC_STATUS_SUCCESS =3D 1, + BC_ALLOC_STATUS_INVAL_OP =3D 2, + BC_ALLOC_STATUS_INVAL_RCID =3D 3, + BC_ALLOC_STATUS_INVAL_AT =3D 4, + BC_ALLOC_STATUS_INVAL_BLKS =3D 5, +}; + +/* Bandwidth allocation */ +REG64(BC_BW_ALLOC, 32); +FIELD(BC_BW_ALLOC, Rbwb, 0, 16); +FIELD(BC_BW_ALLOC, Mweight, 20, 8); +FIELD(BC_BW_ALLOC, sharedAT, 28, 3); +FIELD(BC_BW_ALLOC, useShared, 31, 1); + + +typedef struct MonitorCounter { + uint64_t ctr_val; + int at; + int evt_id; + bool active; +} MonitorCounter; + +typedef struct BandwidthAllocation { + uint32_t Rbwb:16; + uint32_t Mweight:8; + uint32_t sharedAT:3; + bool useShared:1; +} BandwidthAllocation; + +typedef struct RiscvCbqriBandwidthState { + SysBusDevice parent_obj; + MemoryRegion mmio; + + /* cached value of some registers */ + uint64_t bc_mon_ctl; + uint64_t bc_mon_ctr_val; + uint64_t bc_alloc_ctl; + uint64_t bc_bw_alloc; + + MonitorCounter *mon_counters; + BandwidthAllocation *bw_allocations; + + /* properties */ + + uint64_t mmio_base; + char *target; + uint16_t nb_mcids; + uint16_t nb_rcids; + + uint16_t nbwblks; + uint16_t mrbwb; + + bool supports_at_data; + bool supports_at_code; + + bool supports_alloc_op_config_limit; + bool supports_alloc_op_read_limit; + + bool supports_mon_op_config_event; + bool supports_mon_op_read_counter; + + bool supports_mon_evt_id_none; + bool supports_mon_evt_id_rdwr_count; + bool supports_mon_evt_id_rdonly_count; + bool supports_mon_evt_id_wronly_count; +} RiscvCbqriBandwidthState; + +#define RISCV_CBQRI_BC(obj) \ + OBJECT_CHECK(RiscvCbqriBandwidthState, (obj), TYPE_RISCV_CBQRI_BC) + +static BandwidthAllocation *get_bw_alloc(RiscvCbqriBandwidthState *bc, + uint32_t rcid, uint32_t at) +{ + /* + * All bandwidth allocation records are contiguous to simplify + * allocation. The first one is used to hold the BC_BW_ALLOC register + * content, followed by respective records for each AT per RCID. + */ + + unsigned int nb_ats =3D 0; + nb_ats +=3D !!bc->supports_at_data; + nb_ats +=3D !!bc->supports_at_code; + nb_ats =3D MAX(nb_ats, 1); + assert(at < nb_ats); + + return &bc->bw_allocations[1 + rcid * nb_ats + at]; +} + +static uint32_t bandwidth_config(RiscvCbqriBandwidthState *bc, + uint32_t rcid, uint32_t at, + bool *busy) +{ + BandwidthAllocation *bw_alloc =3D get_bw_alloc(bc, rcid, at); + + /* + * Bandwidth is allocated in multiples of bandwidth blocks, and the + * value in Rbwb must be at least 1 and must not exceed MRBWB value. + */ + if (bc->bw_allocations[0].Rbwb < 1) { + return BC_ALLOC_STATUS_INVAL_OP; + } else if (bc->bw_allocations[0].Rbwb > bc->mrbwb) { + return BC_ALLOC_STATUS_INVAL_OP; + } + + /* Save contents of BC_BW_ALLOC register for this rcid and at */ + *bw_alloc =3D bc->bw_allocations[0]; + return BC_ALLOC_STATUS_SUCCESS; +} + +static uint32_t bandwidth_read(RiscvCbqriBandwidthState *bc, + uint32_t rcid, uint32_t at, + bool *busy) +{ + BandwidthAllocation *bw_alloc =3D get_bw_alloc(bc, rcid, at); + + /* Populate BC_BW_ALLOC register with selected content */ + bc->bw_allocations[0] =3D *bw_alloc; + return BC_ALLOC_STATUS_SUCCESS; +} + +static bool is_valid_at(RiscvCbqriBandwidthState *bc, uint32_t at) +{ + switch (at) { + case BC_AT_DATA: + return bc->supports_at_data; + case BC_AT_CODE: + return bc->supports_at_code; + default: + return false; + } +} + +static void riscv_cbqri_bc_write_mon_ctl(RiscvCbqriBandwidthState *bc, + uint64_t value) +{ + if (!bc->supports_mon_op_config_event && + !bc->supports_mon_op_read_counter) { + /* monitoring not supported: leave mon_ctl set to 0 */ + return; + } + + /* extract writable fields */ + uint32_t op =3D FIELD_EX64(value, BC_MON_CTL, OP); + uint32_t at =3D FIELD_EX64(value, BC_MON_CTL, AT); + uint32_t mcid =3D FIELD_EX64(value, BC_MON_CTL, MCID); + uint32_t evt_id =3D FIELD_EX64(value, BC_MON_CTL, EVT_ID); + bool atv =3D FIELD_EX64(value, BC_MON_CTL, ATV); + + /* extract read-only fields */ + uint32_t status =3D FIELD_EX64(bc->bc_mon_ctl, BC_MON_CTL, STATUS); + bool busy =3D FIELD_EX64(bc->bc_mon_ctl, BC_MON_CTL, BUSY); + + if (busy) { + qemu_log_mask(LOG_GUEST_ERROR, + "%s: busy flag still set, ignored", + __func__); + return; + } + + if (!bc->supports_at_data && + !bc->supports_at_code) { + /* AT not supported: hardwire to 0 */ + at =3D 0; + atv =3D false; + } + + if (mcid >=3D bc->nb_mcids) { + status =3D BC_MON_CTL_STATUS_INVAL_MCID; + } else if (op =3D=3D BC_MON_OP_CONFIG_EVENT && + bc->supports_mon_op_config_event) { + if (evt_id =3D=3D BC_EVT_ID_None && + bc->supports_mon_evt_id_none) { + bc->mon_counters[mcid].active =3D false; + status =3D BC_MON_CTL_STATUS_SUCCESS; + } else if ((evt_id =3D=3D BC_EVT_ID_RDWR_count && + bc->supports_mon_evt_id_rdwr_count) || + (evt_id =3D=3D BC_EVT_ID_RDONLY_count && + bc->supports_mon_evt_id_rdonly_count) || + (evt_id =3D=3D BC_EVT_ID_WRONLY_count && + bc->supports_mon_evt_id_wronly_count)) { + if (atv && !is_valid_at(bc, at)) { + status =3D BC_MON_CTL_STATUS_INVAL_AT; + } else { + bc->mon_counters[mcid].ctr_val =3D + FIELD_DP64(0, BC_MON_CTR_VAL, INVALID, 1); + bc->mon_counters[mcid].evt_id =3D evt_id; + bc->mon_counters[mcid].at =3D atv ? at : -1; + bc->mon_counters[mcid].active =3D true; + status =3D BC_MON_CTL_STATUS_SUCCESS; + } + } else { + status =3D BC_MON_CTL_STATUS_INVAL_EVT_ID; + } + } else if (op =3D=3D BC_MON_OP_READ_COUNTER && + bc->supports_mon_op_read_counter) { + bc->bc_mon_ctr_val =3D bc->mon_counters[mcid].ctr_val; + status =3D BC_MON_CTL_STATUS_SUCCESS; + } else { + status =3D BC_MON_CTL_STATUS_INVAL_OP; + } + + /* reconstruct updated register value */ + value =3D 0; + value =3D FIELD_DP64(value, BC_MON_CTL, OP, op); + value =3D FIELD_DP64(value, BC_MON_CTL, AT, at); + value =3D FIELD_DP64(value, BC_MON_CTL, MCID, mcid); + value =3D FIELD_DP64(value, BC_MON_CTL, EVT_ID, evt_id); + value =3D FIELD_DP64(value, BC_MON_CTL, ATV, atv); + value =3D FIELD_DP64(value, BC_MON_CTL, STATUS, status); + value =3D FIELD_DP64(value, BC_MON_CTL, BUSY, busy); + bc->bc_mon_ctl =3D value; +} + +static void riscv_cbqri_bc_write_alloc_ctl(RiscvCbqriBandwidthState *bc, + uint64_t value) +{ + if (bc->nbwblks =3D=3D 0 || + (!bc->supports_alloc_op_config_limit && + !bc->supports_alloc_op_read_limit)) { + /* capacity allocation not supported: leave bc_alloc_ctl set to 0 = */ + return; + } + + /* extract writable fields */ + uint32_t op =3D FIELD_EX64(value, BC_ALLOC_CTL, OP); + uint32_t at =3D FIELD_EX64(value, BC_ALLOC_CTL, AT); + uint32_t rcid =3D FIELD_EX64(value, BC_ALLOC_CTL, RCID); + + /* extract read-only fields */ + uint32_t status =3D FIELD_EX64(bc->bc_alloc_ctl, BC_ALLOC_CTL, STATUS); + bool busy =3D FIELD_EX64(bc->bc_alloc_ctl, BC_ALLOC_CTL, BUSY); + + if (busy) { + qemu_log_mask(LOG_GUEST_ERROR, + "%s: busy flag still set, ignored", + __func__); + return; + } + + bool atv =3D true; + if (!bc->supports_at_data && + !bc->supports_at_code) { + /* AT not supported: hardwire to 0 */ + at =3D 0; + atv =3D false; + } + + if (rcid >=3D bc->nb_rcids) { + status =3D BC_ALLOC_STATUS_INVAL_RCID; + } else if (atv && !is_valid_at(bc, at)) { + status =3D BC_ALLOC_STATUS_INVAL_AT; + } else if (op =3D=3D BC_ALLOC_OP_CONFIG_LIMIT && + bc->supports_alloc_op_config_limit) { + status =3D bandwidth_config(bc, rcid, at, &busy); + } else if (op =3D=3D BC_ALLOC_OP_READ_LIMIT && + bc->supports_alloc_op_read_limit) { + status =3D bandwidth_read(bc, rcid, at, &busy); + } else { + status =3D BC_ALLOC_STATUS_INVAL_OP; + } + + /* reconstruct updated register value */ + value =3D 0; + value =3D FIELD_DP64(value, BC_ALLOC_CTL, OP, op); + value =3D FIELD_DP64(value, BC_ALLOC_CTL, AT, at); + value =3D FIELD_DP64(value, BC_ALLOC_CTL, RCID, rcid); + value =3D FIELD_DP64(value, BC_ALLOC_CTL, STATUS, status); + value =3D FIELD_DP64(value, BC_ALLOC_CTL, BUSY, busy); + bc->bc_alloc_ctl =3D value; +} + +static void riscv_cbqri_bc_write_bw_alloc(RiscvCbqriBandwidthState *bc, + uint64_t value) +{ + if (bc->nbwblks =3D=3D 0) { + /* capacity allocation not supported: leave bw_alloc set to 0 */ + return; + } + + BandwidthAllocation *bc_bw_alloc =3D &bc->bw_allocations[0]; + + /* extract writable fields */ + bc_bw_alloc->Rbwb =3D FIELD_EX64(value, BC_BW_ALLOC, Rbwb); + bc_bw_alloc->Mweight =3D FIELD_EX64(value, BC_BW_ALLOC, Mweight); + bc_bw_alloc->sharedAT =3D FIELD_EX64(value, BC_BW_ALLOC, sharedAT); + bc_bw_alloc->useShared =3D FIELD_EX64(value, BC_BW_ALLOC, useShared); + + if (!bc->supports_at_data && + !bc->supports_at_code) { + /* AT not supported: hardwire to 0 */ + bc_bw_alloc->sharedAT =3D 0; + bc_bw_alloc->useShared =3D false; + } +} + +static void riscv_cbqri_bc_write(void *opaque, hwaddr addr, + uint64_t value, unsigned size) +{ + RiscvCbqriBandwidthState *bc =3D opaque; + + assert((addr % 8) =3D=3D 0); + assert(size =3D=3D 8); + + switch (addr) { + case A_BC_CAPABILITIES: + /* read-only register */ + break; + case A_BC_MON_CTL: + riscv_cbqri_bc_write_mon_ctl(bc, value); + break; + case A_BC_MON_CTR_VAL: + /* read-only register */ + break; + case A_BC_ALLOC_CTL: + riscv_cbqri_bc_write_alloc_ctl(bc, value); + break; + case A_BC_BW_ALLOC: + riscv_cbqri_bc_write_bw_alloc(bc, value); + break; + default: + qemu_log_mask(LOG_GUEST_ERROR, + "%s: out of bounds (addr=3D0x%x)", + __func__, (uint32_t)addr); + } +} + +static uint64_t riscv_cbqri_bc_read(void *opaque, hwaddr addr, unsigned si= ze) +{ + RiscvCbqriBandwidthState *bc =3D opaque; + uint64_t value =3D 0; + + + assert((addr % 8) =3D=3D 0); + assert(size =3D=3D 8); + + switch (addr) { + case A_BC_CAPABILITIES: + value =3D FIELD_DP64(value, BC_CAPABILITIES, VER_MAJOR, + RISCV_CBQRI_VERSION_MAJOR); + value =3D FIELD_DP64(value, BC_CAPABILITIES, VER_MINOR, + RISCV_CBQRI_VERSION_MINOR); + value =3D FIELD_DP64(value, BC_CAPABILITIES, RPFX, 0); + value =3D FIELD_DP64(value, BC_CAPABILITIES, P, 0); + value =3D FIELD_DP64(value, BC_CAPABILITIES, NBWBLKS, bc->nbwblks); + value =3D FIELD_DP64(value, BC_CAPABILITIES, MRBWB, bc->mrbwb); + break; + case A_BC_MON_CTL: + value =3D bc->bc_mon_ctl; + break; + case A_BC_MON_CTR_VAL: + value =3D bc->bc_mon_ctr_val; + break; + case A_BC_ALLOC_CTL: + value =3D bc->bc_alloc_ctl; + break; + case A_BC_BW_ALLOC: + BandwidthAllocation *bc_bw_alloc =3D &bc->bw_allocations[0]; + value =3D FIELD_DP64(value, BC_BW_ALLOC, Rbwb, bc_bw_alloc->Rbwb); + value =3D FIELD_DP64(value, BC_BW_ALLOC, Mweight, bc_bw_alloc->Mwe= ight); + value =3D FIELD_DP64(value, BC_BW_ALLOC, sharedAT, bc_bw_alloc->sh= aredAT); + value =3D FIELD_DP64(value, BC_BW_ALLOC, useShared, + bc_bw_alloc->useShared); + break; + default: + qemu_log_mask(LOG_GUEST_ERROR, + "%s: out of bounds (addr=3D0x%x)", + __func__, (uint32_t)addr); + } + + return value; +} + +static const MemoryRegionOps riscv_cbqri_bc_ops =3D { + .read =3D riscv_cbqri_bc_read, + .write =3D riscv_cbqri_bc_write, + .endianness =3D DEVICE_LITTLE_ENDIAN, + .valid.min_access_size =3D 4, + .valid.max_access_size =3D 8, + .impl.min_access_size =3D 8, + .impl.max_access_size =3D 8, +}; + +static void riscv_cbqri_bc_realize(DeviceState *dev, Error **errp) +{ + RiscvCbqriBandwidthState *bc =3D RISCV_CBQRI_BC(dev); + + if (!bc->mmio_base) { + error_setg(errp, "mmio_base property not set"); + return; + } + + assert(bc->mon_counters =3D=3D NULL); + bc->mon_counters =3D g_new0(MonitorCounter, bc->nb_mcids); + + assert(bc->bw_allocations =3D=3D NULL); + BandwidthAllocation *bw_alloc_end =3D get_bw_alloc(bc, bc->nb_rcids, 0= ); + unsigned int bw_alloc_size =3D bw_alloc_end - bc->bw_allocations; + bc->bw_allocations =3D g_new0(BandwidthAllocation, bw_alloc_size); + + memory_region_init_io(&bc->mmio, OBJECT(dev), &riscv_cbqri_bc_ops, + bc, TYPE_RISCV_CBQRI_BC".mmio", 4 * 1024); + sysbus_init_mmio(SYS_BUS_DEVICE(dev), &bc->mmio); + sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, bc->mmio_base); +} + +static void riscv_cbqri_bc_reset(DeviceState *dev) +{ + RiscvCbqriBandwidthState *bc =3D RISCV_CBQRI_BC(dev); + + bc->bc_mon_ctl =3D 0; + bc->bc_alloc_ctl =3D 0; +} + +static Property riscv_cbqri_bc_properties[] =3D { + DEFINE_PROP_UINT64("mmio_base", RiscvCbqriBandwidthState, mmio_base, 0= ), + DEFINE_PROP_STRING("target", RiscvCbqriBandwidthState, target), + + DEFINE_PROP_UINT16("max_mcids", RiscvCbqriBandwidthState, nb_mcids, 25= 6), + DEFINE_PROP_UINT16("max_rcids", RiscvCbqriBandwidthState, nb_rcids, 64= ), + DEFINE_PROP_UINT16("nbwblks", RiscvCbqriBandwidthState, nbwblks, 1024), + DEFINE_PROP_UINT16("mrbwb", RiscvCbqriBandwidthState, mrbwb, 819), + + DEFINE_PROP_BOOL("at_data", RiscvCbqriBandwidthState, + supports_at_data, true), + DEFINE_PROP_BOOL("at_code", RiscvCbqriBandwidthState, + supports_at_code, true), + + DEFINE_PROP_BOOL("alloc_op_config_limit", RiscvCbqriBandwidthState, + supports_alloc_op_config_limit, true), + DEFINE_PROP_BOOL("alloc_op_read_limit", RiscvCbqriBandwidthState, + supports_alloc_op_read_limit, true), + + DEFINE_PROP_BOOL("mon_op_config_event", RiscvCbqriBandwidthState, + supports_mon_op_config_event, true), + DEFINE_PROP_BOOL("mon_op_read_counter", RiscvCbqriBandwidthState, + supports_mon_op_read_counter, true), + + DEFINE_PROP_BOOL("mon_evt_id_none", RiscvCbqriBandwidthState, + supports_mon_evt_id_none, true), + DEFINE_PROP_BOOL("mon_evt_id_rdwr_count", RiscvCbqriBandwidthState, + supports_mon_evt_id_rdwr_count, true), + DEFINE_PROP_BOOL("mon_evt_id_rdonly_count", RiscvCbqriBandwidthState, + supports_mon_evt_id_rdonly_count, true), + DEFINE_PROP_BOOL("mon_evt_id_wronly_count", RiscvCbqriBandwidthState, + supports_mon_evt_id_wronly_count, true), +}; + +static void riscv_cbqri_bc_class_init(ObjectClass *klass, const void *data) +{ + DeviceClass *dc =3D DEVICE_CLASS(klass); + dc->realize =3D riscv_cbqri_bc_realize; + set_bit(DEVICE_CATEGORY_MISC, dc->categories); + dc->desc =3D "RISC-V CBQRI Bandwidth Controller"; + device_class_set_props(dc, riscv_cbqri_bc_properties); + dc->legacy_reset =3D riscv_cbqri_bc_reset; + dc->user_creatable =3D true; +} + +static const TypeInfo riscv_cbqri_bc_info =3D { + .name =3D TYPE_RISCV_CBQRI_BC, + .parent =3D TYPE_SYS_BUS_DEVICE, + .instance_size =3D sizeof(RiscvCbqriBandwidthState), + .class_init =3D riscv_cbqri_bc_class_init, +}; + +static void riscv_cbqri_bc_register_types(void) +{ + type_register_static(&riscv_cbqri_bc_info); +} + +DeviceState *riscv_cbqri_bc_create(hwaddr addr, + const RiscvCbqriBandwidthCaps *caps, + const char *target_name) +{ + DeviceState *dev =3D qdev_new(TYPE_RISCV_CBQRI_BC); + + qdev_prop_set_uint64(dev, "mmio_base", addr); + qdev_prop_set_string(dev, "target", target_name); + qdev_prop_set_uint16(dev, "max_mcids", caps->nb_mcids); + qdev_prop_set_uint16(dev, "max_rcids", caps->nb_rcids); + qdev_prop_set_uint16(dev, "nbwblks", caps->nbwblks); + + qdev_prop_set_bit(dev, "at_data", + caps->supports_at_data); + qdev_prop_set_bit(dev, "at_code", + caps->supports_at_code); + qdev_prop_set_bit(dev, "alloc_op_config_limit", + caps->supports_alloc_op_config_limit); + qdev_prop_set_bit(dev, "alloc_op_read_limit", + caps->supports_alloc_op_read_limit); + qdev_prop_set_bit(dev, "mon_op_config_event", + caps->supports_mon_op_config_event); + qdev_prop_set_bit(dev, "mon_op_read_counter", + caps->supports_mon_op_read_counter); + qdev_prop_set_bit(dev, "mon_evt_id_none", + caps->supports_mon_evt_id_none); + qdev_prop_set_bit(dev, "mon_evt_id_rdwr_count", + caps->supports_mon_evt_id_rdwr_count); + qdev_prop_set_bit(dev, "mon_evt_id_rdonly_count", + caps->supports_mon_evt_id_rdonly_count); + qdev_prop_set_bit(dev, "mon_evt_id_wronly_count", + caps->supports_mon_evt_id_wronly_count); + + sysbus_realize_and_unref(SYS_BUS_DEVICE(dev), &error_fatal); + + return dev; +} + +type_init(riscv_cbqri_bc_register_types) --=20 2.43.0 From nobody Mon Feb 9 19:10:10 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1767650261; cv=none; d=zohomail.com; s=zohoarc; b=R2fDO5N7gyheNAwd8ksrIYIGlHMr9lRHK0XpIi3sGQsTJHkWWYeCbxVrur7TbHi8qbLMUSnTCxTlTMEg3ph+oPkWGg1w/PktglKl9w3wMeznPnVwEQYy97xwm1rZ6Nvv6Khwn4q/sd3QzbdVMDo+Ciyr1r34MGWc8wMvC3KEBh4= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1767650261; h=Content-Type:Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=H3w74aYdyrjHflQnUKmPE55gWiMpFmBUhhpZ8Q1RDqk=; b=lc+mWBRY8TOPx9IS7kLww47ZJaXsm5KbMoC9+pK0RYW560qKwzx+hMwcx/L3FWLJzCOA4LxGT46zk1SoCx32AZ6fJfxs+NmIy3UkM5CNiUnam5hBsRs6hDVzZwni81R5RbeLEJ6BgArdGt7x1uyXEmwuizZgQHSphea/N3kIlKs= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1767650261569175.55446975454106; Mon, 5 Jan 2026 13:57:41 -0800 (PST) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1vcsXX-0006Nr-Qa; Mon, 05 Jan 2026 16:55:03 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1vcsXV-0006KB-Tw; Mon, 05 Jan 2026 16:55:02 -0500 Received: from tor.source.kernel.org ([172.105.4.254]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1vcsXT-0006E4-Kj; Mon, 05 Jan 2026 16:55:01 -0500 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by tor.source.kernel.org (Postfix) with ESMTP id 24C5F60145; Mon, 5 Jan 2026 21:54:52 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id BD47CC2BC86; Mon, 5 Jan 2026 21:54:51 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1767650092; bh=JieCMwyS0dmjhE3hJJyzeCoQ/1nKVfDaK15QBXDcDVQ=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=Fry7hAopogtfRtuSeVa65tZzgZq0dgm2myhWY/YSY3HMS+sJwrZfDkk8Ox6cwH71h aN5LBVvmYAWG70rc2rARRnW+accGMh2rRFGMMzLWB1vmRNlvaqZWUi3NbI89X1jXG/ oySppTEJ7vvWWV+6Bglc2npTa4q6gyQJq2WLDCNVgT6kMb4LJN3Bpq9LkXex0tXGER FGEhBpCF/lojP9ZMC6sxmkCROuMXQfJFXtB6A3nz8IADWdaK9pkPtWsGKmYCB1VKC2 QvWQMWcHiAq+n+bCoHE0U9d17sptsZFiwvmYIisQG2hQqpNNFJtVheXhF4KuDAJh35 M6jocVug/T5UA== From: Drew Fustini Date: Mon, 05 Jan 2026 13:54:23 -0800 Subject: [PATCH v4 5/6] hw/riscv: add CBQRI to Kconfig and build if enabled MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260105-riscv-ssqosid-cbqri-v4-5-9ad7671dde78@kernel.org> References: <20260105-riscv-ssqosid-cbqri-v4-0-9ad7671dde78@kernel.org> In-Reply-To: <20260105-riscv-ssqosid-cbqri-v4-0-9ad7671dde78@kernel.org> To: qemu-devel@nongnu.org Cc: qemu-riscv@nongnu.org, Palmer Dabbelt , Alistair Francis , Weiwei Li , Daniel Henrique Barboza , Liu Zhiwei , Paolo Bonzini , Nicolas Pitre , =?utf-8?q?Kornel_Dul=C4=99ba?= , Atish Kumar Patra , Atish Patra , Vasudevan Srinivasan , =?utf-8?q?Radim_Kr=C4=8Dm=C3=A1=C5=99?= , yunhui cui , Chen Pei , guo.wenjia23@zte.com.cn, liu.qingtao2@zte.com.cn, Drew Fustini X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=1382; i=fustini@kernel.org; h=from:subject:message-id; bh=kehPvMBHTRUHu6S9Q2DPtFbCgSRsdDVPdSLNBUBFc4s=; b=owGbwMvMwCV2+43O4ZsaG3kYT6slMWTGGGueuvv2lPkZx0kWEsd0mo1nZj5fZvTi8Rn+prXb7 ob5J08Q7ihlYRDjYpAVU2TZ9CHvwhKv0K8L5r/YBjOHlQlkCAMXpwBMpOgMw3+3WfyFPtu+/Tm3 IXnZp0YpSwV9rRqBgjD2V9Y/KkL2+W5jZNhk4CfYt0xxQupNbeNM1xmNi+4tTdTZuf5qn8TXqgP 3DnIAAA== X-Developer-Key: i=fustini@kernel.org; a=openpgp; fpr=1B6F948213EA489734F3997035D5CD577C1E6010 Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=172.105.4.254; envelope-from=fustini@kernel.org; helo=tor.source.kernel.org 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, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_VALIDITY_RPBL_BLOCKED=0.001, RCVD_IN_VALIDITY_SAFE_BLOCKED=0.001, SPF_HELO_NONE=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: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1767650263462158500 From: Nicolas Pitre Add boolean property for CBQRI and imply it should be enabled for the RISC-V virt machine. Build the CBQRI controllers when RISC-V CBQRI is enabled. Signed-off-by: Nicolas Pitre Signed-off-by: Drew Fustini --- hw/riscv/Kconfig | 4 ++++ hw/riscv/meson.build | 1 + 2 files changed, 5 insertions(+) diff --git a/hw/riscv/Kconfig b/hw/riscv/Kconfig index fc9c35bd981e..663cb78b813c 100644 --- a/hw/riscv/Kconfig +++ b/hw/riscv/Kconfig @@ -1,3 +1,6 @@ +config RISCV_CBQRI + bool + config RISCV_IOMMU bool =20 @@ -68,6 +71,7 @@ config RISCV_VIRT select PLATFORM_BUS select ACPI select ACPI_PCI + imply RISCV_CBQRI =20 config SHAKTI_C bool diff --git a/hw/riscv/meson.build b/hw/riscv/meson.build index 2a8d5b136cc4..79e15514b797 100644 --- a/hw/riscv/meson.build +++ b/hw/riscv/meson.build @@ -14,5 +14,6 @@ riscv_ss.add(when: 'CONFIG_RISCV_IOMMU', if_true: files( 'riscv-iommu.c', 'riscv-iommu-pci.c', 'riscv-iommu-sys.c', 'riscv-iommu-h= pm.c')) riscv_ss.add(when: 'CONFIG_MICROBLAZE_V', if_true: files('microblaze-v-gen= eric.c')) riscv_ss.add(when: 'CONFIG_XIANGSHAN_KUNMINGHU', if_true: files('xiangshan= _kmh.c')) +riscv_ss.add(when: 'CONFIG_RISCV_CBQRI', if_true: files('cbqri_capacity.c'= , 'cbqri_bandwidth.c')) =20 hw_arch +=3D {'riscv': riscv_ss} --=20 2.43.0 From nobody Mon Feb 9 19:10:10 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=kernel.org ARC-Seal: i=1; a=rsa-sha256; t=1767650201; cv=none; d=zohomail.com; s=zohoarc; b=VAHzwKtXIKkXiJ/r4IcoZmy+lI7w25sDK9YVHE/Vrux9YEsLt34MTNUsB3yP09x0pNV9jGLRerEQIyc7Mxyc1LTFjEY8JmIyAXzZ+gNbeKe/TUCmiUMIRIfLWMCUxAk8fV4DHnEnHIMNWvZWCfqSmQt8TF6Z9e47zj8IvmL5nxQ= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1767650201; h=Content-Type:Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=op/Hej9nBSyfdqBErr/sNlN23OFcnPlmjZDT8J0vV90=; b=lhyBKbLMcdLTyCbrSKpZAxKL8odp1+gBrW80L2DLo4JUI22QzFXGhIj4HnCAIQIsUUHfQqvHhB3BJP5Lz0oKWXvRAUsBJ/wDIwR4WOt1xdEn9T9ue1smzoL0+vGcoBSRZvaw2H2qJ3spayYlnD2xLElr+oaF5f6p9WKC9D+0u/g= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1767650201905183.98296112286482; Mon, 5 Jan 2026 13:56:41 -0800 (PST) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1vcsXY-0006Qp-TU; Mon, 05 Jan 2026 16:55:05 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1vcsXV-0006KE-UP; Mon, 05 Jan 2026 16:55:02 -0500 Received: from tor.source.kernel.org ([172.105.4.254]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1vcsXT-0006E3-J1; Mon, 05 Jan 2026 16:55:01 -0500 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by tor.source.kernel.org (Postfix) with ESMTP id 8A40C60149; Mon, 5 Jan 2026 21:54:52 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 1263FC16AAE; Mon, 5 Jan 2026 21:54:52 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1767650092; bh=nVXcBke4+Xpy+dP8Jn1js2x8PMSpowa0B2KjBZEzC9o=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=Pb/YhpJZXo+P2VAaxxSkCTb54nMxvt0iFhhxRDTNss5wdAfmLx0pefqBrnf9tvwVg 3UdSpLtFCnY512wB+aKg3fgSsRBDC/yZRnqx9pkXTFppWCA/VAVsL0hw64ZaBo9Fci 6fZ/L/IIoMu0GxWa9B8ihqf8BI8HbfKbfAb9k56Md+r0MRrlpBin7KDXHYFNpAEo2+ j893uTc04ERutdt2piuQ7qY56rhOMAgrtGRSkZBgMpS/oVDOYHOd6m/B3qqOCe15Iz wHq7VgQGgmRPcsL57XvdxKYMiOqHL4NHxetQhO0pllaDP9VbrGSeTShnMFaTWadjZo cOeMBldG4pGPg== From: Drew Fustini Date: Mon, 05 Jan 2026 13:54:24 -0800 Subject: [PATCH v4 6/6] hw/riscv: add CBQRI controllers to virt machine MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260105-riscv-ssqosid-cbqri-v4-6-9ad7671dde78@kernel.org> References: <20260105-riscv-ssqosid-cbqri-v4-0-9ad7671dde78@kernel.org> In-Reply-To: <20260105-riscv-ssqosid-cbqri-v4-0-9ad7671dde78@kernel.org> To: qemu-devel@nongnu.org Cc: qemu-riscv@nongnu.org, Palmer Dabbelt , Alistair Francis , Weiwei Li , Daniel Henrique Barboza , Liu Zhiwei , Paolo Bonzini , Nicolas Pitre , =?utf-8?q?Kornel_Dul=C4=99ba?= , Atish Kumar Patra , Atish Patra , Vasudevan Srinivasan , =?utf-8?q?Radim_Kr=C4=8Dm=C3=A1=C5=99?= , yunhui cui , Chen Pei , guo.wenjia23@zte.com.cn, liu.qingtao2@zte.com.cn, Drew Fustini X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=3217; i=fustini@kernel.org; h=from:subject:message-id; bh=e3aHR89QXlGWitka8WoVRilMH1bltd7QHZqaKaGawDs=; b=owGbwMvMwCV2+43O4ZsaG3kYT6slMWTGGGslbL/uFthZ/Y07cVm6Tz+H3QUzG+HXantTjhzlS u6fGGHZUcrCIMbFICumyLLpQ96FJV6hXxfMf7ENZg4rE8gQBi5OAZhIbzUjw97+3ZXaf0Ssdyya p/Km4IGm1VeWhzekTM7VOB0q7E8pmcfI8H9z7rSObaKly+03z49nWf+eX6FWWP1QT22xGc+XrfF OTAA= X-Developer-Key: i=fustini@kernel.org; a=openpgp; fpr=1B6F948213EA489734F3997035D5CD577C1E6010 Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=172.105.4.254; envelope-from=fustini@kernel.org; helo=tor.source.kernel.org 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, DKIMWL_WL_HIGH=-0.001, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_VALIDITY_RPBL_BLOCKED=0.001, RCVD_IN_VALIDITY_SAFE_BLOCKED=0.001, SPF_HELO_NONE=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: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @kernel.org) X-ZM-MESSAGEID: 1767650203363158500 From: Nicolas Pitre Add CBQRI controllers to the RISC-V virt machine. The device properties can be fully configured from the command line: $ qemu-system-riscv64 -M virt ... \ -device riscv.cbqri.capacity,mmio_base=3D0x04828000[,...] -device riscv.cbqri.bandwidth,mmio_base=3D0x04829000[,...] The mmio_base option is mandatory, the others are optional. Many -device arguments as wanted can be provided as long as their mmio regions don't conflict. To see all possible options: $ qemu-system-riscv64 -device riscv.cbqri.capacity,help riscv.cbqri.capacity options: alloc_op_config_limit=3D - (default: true) alloc_op_flush_rcid=3D - (default: true) alloc_op_read_limit=3D - (default: true) at_code=3D - (default: true) at_data=3D - (default: true) max_mcids=3D - (default: 256) max_rcids=3D - (default: 64) mmio_base=3D - (default: 0) mon_evt_id_none=3D - (default: true) mon_evt_id_occupancy=3D - (default: true) mon_op_config_event=3D - (default: true) mon_op_read_counter=3D - (default: true) ncblks=3D - (default: 16) target=3D $ qemu-system-riscv64 -device riscv.cbqri.bandwidth,help riscv.cbqri.bandwidth options: alloc_op_config_limit=3D - (default: true) alloc_op_read_limit=3D - (default: true) at_code=3D - (default: true) at_data=3D - (default: true) max_mcids=3D - (default: 256) max_rcids=3D - (default: 64) mmio_base=3D - (default: 0) mon_evt_id_none=3D - (default: true) mon_evt_id_rdonly_count=3D - (default: true) mon_evt_id_rdwr_count=3D - (default: true) mon_evt_id_wronly_count=3D - (default: true) mon_op_config_event=3D - (default: true) mon_op_read_counter=3D - (default: true) nbwblks=3D - (default: 1024) target=3D Boolean options correspond to hardware capabilities that can be disabled Signed-off-by: Nicolas Pitre Reviewed-by: Daniel Henrique Barboza Signed-off-by: Drew Fustini --- hw/riscv/virt.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/hw/riscv/virt.c b/hw/riscv/virt.c index c87c169d38cd..99871119be44 100644 --- a/hw/riscv/virt.c +++ b/hw/riscv/virt.c @@ -55,6 +55,7 @@ #include "hw/pci-host/gpex.h" #include "hw/display/ramfb.h" #include "hw/acpi/aml-build.h" +#include "hw/riscv/cbqri.h" #include "qapi/qapi-visit-common.h" #include "hw/virtio/virtio-iommu.h" #include "hw/uefi/var-service-api.h" @@ -1941,6 +1942,8 @@ static void virt_machine_class_init(ObjectClass *oc, = const void *data) #ifdef CONFIG_TPM machine_class_allow_dynamic_sysbus_dev(mc, TYPE_TPM_TIS_SYSBUS); #endif + machine_class_allow_dynamic_sysbus_dev(mc, TYPE_RISCV_CBQRI_BC); + machine_class_allow_dynamic_sysbus_dev(mc, TYPE_RISCV_CBQRI_CC); =20 object_class_property_add_bool(oc, "aclint", virt_get_aclint, virt_set_aclint); --=20 2.43.0