From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-19.0 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,MENTIONS_GIT_HOSTING,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8C203C43381 for ; Thu, 11 Mar 2021 17:30:42 +0000 (UTC) Received: from desiato.infradead.org (desiato.infradead.org [90.155.92.199]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id DA77664F8D for ; Thu, 11 Mar 2021 17:30:41 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org DA77664F8D Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=opensynergy.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=desiato.20200630; h=Sender:Content-Transfer-Encoding :Content-Type:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:Date:Message-ID:Subject: From:References:CC:To:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=eD3NoEmwh2Z8nmcLNKnGWGnAVD3qvGLShniWcFu56cg=; b=AWSgEgQmaRri4UIEYVSiCODr/ 6hgxqTEyCmhIroy3+5l0v6SDBR/8sv4qTl1QP3ekhID9nJVhqs3nYIOIJyAQd6Eml6Cr5HvgNb+eA s1SYT4NvsR60XYnqfB7QDtnC5ZeCHmV6Jw0KxL1CnxNUR+idYFs6+DG9BJw0v3fVXmsfV4O1NR0Ht O74a/sMYxpIXna6f6DG01dcAMrrMNyxigZAEVS8QnFYrpgSHgcEAfPPyNDrH1sEwtvvR5bztJTf1K QvS65yIAYq3WFmTGEIskAWDSmS1BYFlpNEJ4kMWQcicZ3omQUD3iJrC5IHni1OgTSqq+/YwAViIPu P0TobMIZA==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lKP7g-009jD8-69; Thu, 11 Mar 2021 17:29:20 +0000 Received: from mx1.opensynergy.com ([217.66.60.4]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lKP7b-009jCI-KU for linux-arm-kernel@lists.infradead.org; Thu, 11 Mar 2021 17:29:18 +0000 Received: from SR-MAILGATE-02.opensynergy.com (localhost.localdomain [127.0.0.1]) by mx1.opensynergy.com (Proxmox) with ESMTP id 031C9A191E; Thu, 11 Mar 2021 18:19:27 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=opensynergy.com; h=cc:cc:content-transfer-encoding:content-type:content-type :date:from:from:in-reply-to:message-id:mime-version:references :reply-to:subject:subject:to:to; s=srmailgate02; bh=zPsjmKn4FsM5 v/BxhNWc+5Pe5obGbYsR+5Szvm4SyiI=; b=KfCDCdKlUpKNXVu/rbHOj8bqwz8c Jq5pf64eDapT/7aEeg8z5Ydq626m6fySd4nHT8dPqjNBpEprNoqMWv3JebV0c3UA ScgLtT/qdIaM+LjfPxkH7Y3dyM+0EHaiLivMhcoqyO6mmtm+RZm9x98B68eNWaeS HrN4At2wUNts99ZOxmCFzineiCoqTzseLxSRdzc8XqJ83apdGJBB8U2Eh7u7+DVs YQlvngXrukGj2KG/u9y2H+jSdaOHnU1Iq3rxSTg5XJTGMabUyvDowP6VnDO3qDtf mw62JHERkatHxNRZSqC/1ZyyjOg5GSiT1OBu5uuqKxqcD/ZZZxDOOdIk4g== To: CC: , , , , , , References: <20210212095920.249768-1-peter.hilber@opensynergy.com> From: Peter Hilber Subject: Re: [PATCH v6] Add virtio SCMI device specification Message-ID: <182c86c3-730b-12e2-1a9a-347d5e8e25af@opensynergy.com> Date: Thu, 11 Mar 2021 18:19:23 +0100 MIME-Version: 1.0 In-Reply-To: <20210212095920.249768-1-peter.hilber@opensynergy.com> Content-Language: en-US X-ClientProxiedBy: SR-MAIL-01.open-synergy.com (10.26.10.21) To SR-MAIL-02.open-synergy.com (10.26.10.22) X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210311_172915_991249_D2D9892B X-CRM114-Status: GOOD ( 44.69 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org T24gMTIuMDIuMjEgMTA6NTksIFBldGVyIEhpbGJlciB3cm90ZToKPiBUaGlzIHBhdGNoIHByb3Bv c2VzIGEgbmV3IHZpcnRpbyBkZXZpY2UgZm9yIHRoZSBBcm0gU0NNSSBwcm90b2NvbC4KPiAKPiBU aGUgZGV2aWNlIHByb3ZpZGVzIGEgc2ltcGxlIHRyYW5zcG9ydCBmb3IgdGhlIEFybSBTQ01JIHBy b3RvY29sWzFdLiBUaGUKPiAqUyp5c3RlbSAqQypvbnRyb2wgYW5kICpNKmFuYWdlbWVudCAqSSpu dGVyZmFjZSBwcm90b2NvbCBhbGxvd3Mgc3BlYWtpbmcKPiB0byBzeXN0ZW0gY29udHJvbGxlcnMg dGhhdCBhbGxvdyBvcmNoZXN0cmF0aW5nIHRoaW5ncyBsaWtlIHBvd2VyCj4gbWFuYWdlbWVudCwg c3lzdGVtIHN0YXRlIG1hbmFnZW1lbnQgYW5kIHNlbnNvciBhY2Nlc3MuIFRoZSBTQ01JIHByb3Rv Y29sCj4gaXMgdXNlZCBvbiBTb0NzIHdoZXJlIG11bHRpcGxlIGNvcmVzIGFuZCBjby1wcm9jZXNz b3JzIG5lZWQgYWNjZXNzIHRvCj4gdGhlc2UgcmVzb3VyY2VzLgo+IAo+IFRoZSB2aXJ0aW8gdHJh bnNwb3J0IGFsbG93cyBtYWtpbmcgdXNlIG9mIHRoaXMgcHJvdG9jb2wgaW4gdmlydHVhbGl6ZWQK PiBzeXN0ZW1zLgo+IAo+IFsxXSBodHRwczovL2RldmVsb3Blci5hcm0uY29tL2RvY3MvZGVuMDA1 Ni9jCj4gCj4gU2lnbmVkLW9mZi1ieTogUGV0ZXIgSGlsYmVyIDxwZXRlci5oaWxiZXJAb3BlbnN5 bmVyZ3kuY29tPgo+IC0tLQo+IAo+IE5vdGVzOgo+IAo+ICAgICBTaW5jZSBzZW5kaW5nIG91dCB2 NSBpbiBNYXkgMjAyMCwgdGhlcmUgaGFzIGJlZW4gbm8gYWRkaXRpb25hbAo+ICAgICBmZWVkYmFj ayB3LnIudC4gdGhlIHNwZWMuIEFuIFJmQyBwYXRjaCBzZXJpZXMgZm9yIHRoZSBkcml2ZXIgaXMg bm93Cj4gICAgIGF2YWlsYWJsZSBhdCBbMV0uIE9wZW5TeW5lcmd5IGFsc28gaGFzIGEgcHJvcHJp ZXRhcnkgaW1wbGVtZW50YXRpb24KPiAgICAgb2YgdGhlIGRldmljZSAod2l0aG91dCB0aGUgVklS VElPX1NDTUlfRl9TSEFSRURfTUVNT1JZIGZlYXR1cmUgc28KPiAgICAgZmFyKS4KPiAKPiAgICAg U28gSSB3b3VsZCBsaWtlIHRvIHJlcXVlc3QgYSB2b3RlIG9uIGFkZGluZyB0aGUgZGV2aWNlIGlu IGEgZmV3IHdlZWtzLgo+ICAgICAKCkkgd291bGQgbGlrZSB0byByZXF1ZXN0IGEgdm90ZSBvbiBh ZGRpbmcgdGhlIHZpcnRpbyBTQ01JIGRldmljZSB0byB0aGUgc3BlYy4KCkZpeGVzOiBodHRwczov L2dpdGh1Yi5jb20vb2FzaXMtdGNzL3ZpcnRpby1zcGVjL2lzc3Vlcy8xMDAKCkJlc3QgcmVnYXJk cywKClBldGVyCgo+ICAgICBUaGUgUERGIG91dHB1dCBpcyBhdmFpbGFibGUgYXQgWzJdLgo+ICAg ICAKPiAgICAgWzFdIGh0dHBzOi8vbG9yZS5rZXJuZWwub3JnL2xpbnV4LWFybS1rZXJuZWwvMjAy MDExMDUyMTIxMTYuNDExNDIyLTEtcGV0ZXIuaGlsYmVyQG9wZW5zeW5lcmd5LmNvbS8KPiAgICAg WzJdIGh0dHBzOi8vc2hhcmUubWFpbGJveC5vcmcvYWpheC9zaGFyZS8wNTYwNzZlNzA1NzExNDRm NTBjNGNhNzU3MTE0NGIzMTlhMWQ3MjM2ZGRhMWNkM2IvMS84L016US9NelF2TVEKPiAKPiAgICAg Q2hhbmdlcyBmb3IgdjY6Cj4gCj4gICAgIC0gUmVmZXIgdG8gbmV3IFNDTUkgc3BlYyB2ZXJzaW9u IDMuMCAoREVOMDA1NkMpLCB3aGljaCBoYXMgYQo+ICAgICAgIHByb3Zpc2lvbiBmb3IgU0hNIHJh Y2UgY29uZGl0aW9ucy4KPiAKPiAgICAgLSBSZXNvbHZlIGNvbmZsaWN0cyB3aXRoIG90aGVyIGFk ZGVkIGRldmljZSBkb2N1bWVudGF0aW9uLgo+IAo+ICAgICBDaGFuZ2VzIGZvciB2NToKPiAgICAg Cj4gICAgIC0gUmVtb3ZlIHJlcXVpcmVtZW50cyBvbiBzaGFyZWQgbWVtb3J5IGFkZGVkIGluIHY0 LCBzaW5jZSBhbiB1cGNvbWluZwo+ICAgICBuZXcgdmVyc2lvbiBvZiB0aGUgQXJtIFNDTUkgc3Bl Y1sxXSB3aWxsIHByb3ZpZGUgYSBnZW5lcmljLCBtb3JlCj4gICAgIHBvd2VyZnVsIHdheSB0byBo YW5kbGUgY29uY3VycmVudCBhY2Nlc3MgdG8gc2hhcmVkIG1lbW9yeS4KPiAgICAgCj4gICAgIENo YW5nZXMgZm9yIHY0Ogo+ICAgICAKPiAgICAgLSBBZGQgbW9yZSByZXF1aXJlbWVudHMgb24gc2hh cmVkIG1lbW9yeSByZWdpb25zIGFmdGVyIGZlZWRiYWNrIGZyb20KPiAgICAgICBBbGV4IEJlbm7D qWUuCj4gICAgIAo+ICAgICBDaGFuZ2VzIGZvciB2MzoKPiAgICAgCj4gICAgIC0gQWRkIHRlbnRh dGl2ZSBkZXZpY2UgSUQgMzIgaW4gZGV2aWNlIHNlY3Rpb24uCj4gICAgIAo+ICAgICAtIFJlbW92 ZSByZWR1bmRhbnQgJ2xlbicgZmllbGRzLiBUaGUgbGVuZ3RoIG9mIHRoZSBwYXlsb2FkIGZpZWxk cyBjYW4KPiAgICAgICBhbHJlYWR5IGJlIGRlZHVjZWQgZnJvbSB0aGUgZ2VuZXJpYyB2aXJ0cXVl dWUgJ2xlbicgZmllbGRzLiBUaGVyZWZvcmUsCj4gICAgICAgcmVtb3ZlIHRoZSByZWR1bmRhbnQg ZGV2aWNlLXNwZWNpZmljICdsZW4nIGZpZWxkcy4KPiAgICAgCj4gICAgIC0gUmV3b3JkIHJlcXVp cmVtZW50IHRoYXQgZHJpdmVyIG11c3Qgbm90IHB1dCB0b28gc21hbGwgYnVmZmVycyBpbnRvCj4g ICAgICAgZXZlbnRxLgo+ICAgICAKPiAgICAgQ2hhbmdlcyBmb3IgdjI6Cj4gICAgIAo+ICAgICAt IENDIHZpcnRpby1kZXYgbGlzdC4KPiAgICAgLSBEZWZpbmUgc2l6ZSBvZiBlcnJvbmVvdXMgZGVs YXllZC9ub3QgZGVsYXllZCByZXNwb25zZXMuCj4gICAgIC0gVXNlIGNvcnJlY3QgbG9uZyBuYW1l IGZvciBTQ01JLgo+ICAgICAtIFJlbW92ZSByZXN0cmljdGlvbiB0byBgZW1iZWRkZWQnIGluIGNv bW1pdCBtZXNzYWdlLgo+ICAgICAtIEFkZCBtb3RpdmF0aW9uIGZvciBjb25jZXB0dWFsIHBlci1t ZXNzYWdlLWNoYW5uZWxzLgo+ICAgICAtIERldmljZSBtYXkgbm93IGp1c3QgZHJvcCBub3RpZmlj YXRpb24gaWYgbm8gYnVmZmVycyBhcmUgYXZhaWxhYmxlLgo+ICAgICAKPiAKPiAgY29uZm9ybWFu Y2UudGV4ICB8ICAzNCArKysrLS0KPiAgY29udGVudC50ZXggICAgICB8ICAgMSArCj4gIGludHJv ZHVjdGlvbi50ZXggfCAgIDMgKwo+ICB2aXJ0aW8tc2NtaS50ZXggIHwgMjcxICsrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4gIDQgZmlsZXMgY2hhbmdlZCwg MzAzIGluc2VydGlvbnMoKyksIDYgZGVsZXRpb25zKC0pCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCB2 aXJ0aW8tc2NtaS50ZXgKPiAKPiBkaWZmIC0tZ2l0IGEvY29uZm9ybWFuY2UudGV4IGIvY29uZm9y bWFuY2UudGV4Cj4gaW5kZXggMTdjMzkwZC4uYTE2NGNiYiAxMDA2NDQKPiAtLS0gYS9jb25mb3Jt YW5jZS50ZXgKPiArKysgYi9jb25mb3JtYW5jZS50ZXgKPiBAQCAtMjcsOSArMjcsMTAgQEAgXHNl Y3Rpb257Q29uZm9ybWFuY2UgVGFyZ2V0c31cbGFiZWx7c2VjOkNvbmZvcm1hbmNlIC8gQ29uZm9y bWFuY2UgVGFyZ2V0c30KPiAgXHJlZntzZWM6Q29uZm9ybWFuY2UgLyBEcml2ZXIgQ29uZm9ybWFu Y2UgLyBTb2NrZXQgRHJpdmVyIENvbmZvcm1hbmNlfSwKPiAgXHJlZntzZWM6Q29uZm9ybWFuY2Ug LyBEcml2ZXIgQ29uZm9ybWFuY2UgLyBSUE1CIERyaXZlciBDb25mb3JtYW5jZX0sCj4gIFxyZWZ7 c2VjOkNvbmZvcm1hbmNlIC8gRHJpdmVyIENvbmZvcm1hbmNlIC8gSU9NTVUgRHJpdmVyIENvbmZv cm1hbmNlfSwKPiAtXHJlZntzZWM6Q29uZm9ybWFuY2UgLyBEcml2ZXIgQ29uZm9ybWFuY2UgLyBT b3VuZCBEcml2ZXIgQ29uZm9ybWFuY2V9Cj4gLVxyZWZ7c2VjOkNvbmZvcm1hbmNlIC8gRHJpdmVy IENvbmZvcm1hbmNlIC8gTWVtb3J5IERyaXZlciBDb25mb3JtYW5jZX0gb3IKPiAtXHJlZntzZWM6 Q29uZm9ybWFuY2UgLyBEcml2ZXIgQ29uZm9ybWFuY2UgLyBJMkMgQWRhcHRlciBEcml2ZXIgQ29u Zm9ybWFuY2V9Lgo+ICtccmVme3NlYzpDb25mb3JtYW5jZSAvIERyaXZlciBDb25mb3JtYW5jZSAv IFNvdW5kIERyaXZlciBDb25mb3JtYW5jZX0sCj4gK1xyZWZ7c2VjOkNvbmZvcm1hbmNlIC8gRHJp dmVyIENvbmZvcm1hbmNlIC8gTWVtb3J5IERyaXZlciBDb25mb3JtYW5jZX0sCj4gK1xyZWZ7c2Vj OkNvbmZvcm1hbmNlIC8gRHJpdmVyIENvbmZvcm1hbmNlIC8gSTJDIEFkYXB0ZXIgRHJpdmVyIENv bmZvcm1hbmNlfSBvcgo+ICtccmVme3NlYzpDb25mb3JtYW5jZSAvIERyaXZlciBDb25mb3JtYW5j ZSAvIFNDTUkgRHJpdmVyIENvbmZvcm1hbmNlfS4KPiAgCj4gICAgICBcaXRlbSBDbGF1c2UgXHJl ZntzZWM6Q29uZm9ybWFuY2UgLyBMZWdhY3kgSW50ZXJmYWNlOiBUcmFuc2l0aW9uYWwgRGV2aWNl IGFuZCBUcmFuc2l0aW9uYWwgRHJpdmVyIENvbmZvcm1hbmNlfS4KPiAgICBcZW5ke2l0ZW1pemV9 Cj4gQEAgLTQ5LDkgKzUwLDEwIEBAIFxzZWN0aW9ue0NvbmZvcm1hbmNlIFRhcmdldHN9XGxhYmVs e3NlYzpDb25mb3JtYW5jZSAvIENvbmZvcm1hbmNlIFRhcmdldHN9Cj4gIFxyZWZ7c2VjOkNvbmZv cm1hbmNlIC8gRGV2aWNlIENvbmZvcm1hbmNlIC8gU29ja2V0IERldmljZSBDb25mb3JtYW5jZX0s IAo+ICBccmVme3NlYzpDb25mb3JtYW5jZSAvIERldmljZSBDb25mb3JtYW5jZSAvIFJQTUIgRGV2 aWNlIENvbmZvcm1hbmNlfSwKPiAgXHJlZntzZWM6Q29uZm9ybWFuY2UgLyBEZXZpY2UgQ29uZm9y bWFuY2UgLyBJT01NVSBEZXZpY2UgQ29uZm9ybWFuY2V9LAo+IC1ccmVme3NlYzpDb25mb3JtYW5j ZSAvIERldmljZSBDb25mb3JtYW5jZSAvIFNvdW5kIERldmljZSBDb25mb3JtYW5jZX0KPiAtXHJl ZntzZWM6Q29uZm9ybWFuY2UgLyBEZXZpY2UgQ29uZm9ybWFuY2UgLyBNZW1vcnkgRGV2aWNlIENv bmZvcm1hbmNlfSBvcgo+IC1ccmVme3NlYzpDb25mb3JtYW5jZSAvIERldmljZSBDb25mb3JtYW5j ZSAvIEkyQyBBZGFwdGVyIERldmljZSBDb25mb3JtYW5jZX0uCj4gK1xyZWZ7c2VjOkNvbmZvcm1h bmNlIC8gRGV2aWNlIENvbmZvcm1hbmNlIC8gU291bmQgRGV2aWNlIENvbmZvcm1hbmNlfSwKPiAr XHJlZntzZWM6Q29uZm9ybWFuY2UgLyBEZXZpY2UgQ29uZm9ybWFuY2UgLyBNZW1vcnkgRGV2aWNl IENvbmZvcm1hbmNlfSwKPiArXHJlZntzZWM6Q29uZm9ybWFuY2UgLyBEZXZpY2UgQ29uZm9ybWFu Y2UgLyBJMkMgQWRhcHRlciBEZXZpY2UgQ29uZm9ybWFuY2V9IG9yCj4gK1xyZWZ7c2VjOkNvbmZv cm1hbmNlIC8gRGV2aWNlIENvbmZvcm1hbmNlIC8gU0NNSSBEZXZpY2UgQ29uZm9ybWFuY2V9Lgo+ ICAKPiAgICAgIFxpdGVtIENsYXVzZSBccmVme3NlYzpDb25mb3JtYW5jZSAvIExlZ2FjeSBJbnRl cmZhY2U6IFRyYW5zaXRpb25hbCBEZXZpY2UgYW5kIFRyYW5zaXRpb25hbCBEcml2ZXIgQ29uZm9y bWFuY2V9Lgo+ICAgIFxlbmR7aXRlbWl6ZX0KPiBAQCAtMjc3LDYgKzI3OSwxNSBAQCBcc2VjdGlv bntDb25mb3JtYW5jZSBUYXJnZXRzfVxsYWJlbHtzZWM6Q29uZm9ybWFuY2UgLyBDb25mb3JtYW5j ZSBUYXJnZXRzfQo+ICBcaXRlbSBccmVme2RyaXZlcm5vcm1hdGl2ZTpEZXZpY2UgVHlwZXMgLyBJ MkMgQWRhcHRlciBEZXZpY2UgLyBEZXZpY2UgT3BlcmF0aW9ufQo+ICBcZW5ke2l0ZW1pemV9Cj4g IAo+ICtcY29uZm9ybWFuY2V7XHN1YnNlY3Rpb259e1NDTUkgRHJpdmVyIENvbmZvcm1hbmNlfVxs YWJlbHtzZWM6Q29uZm9ybWFuY2UgLyBEcml2ZXIgQ29uZm9ybWFuY2UgLyBTQ01JIERyaXZlciBD b25mb3JtYW5jZX0KPiArCj4gK0FuIFNDTUkgZHJpdmVyIE1VU1QgY29uZm9ybSB0byB0aGUgZm9s bG93aW5nIG5vcm1hdGl2ZSBzdGF0ZW1lbnRzOgo+ICsKPiArXGJlZ2lue2l0ZW1pemV9Cj4gK1xp dGVtIFxyZWZ7ZHJpdmVybm9ybWF0aXZlOkRldmljZSBUeXBlcyAvIFNDTUkgRGV2aWNlIC8gRGV2 aWNlIE9wZXJhdGlvbiAvIGNtZHEgT3BlcmF0aW9ufQo+ICtcaXRlbSBccmVme2RyaXZlcm5vcm1h dGl2ZTpEZXZpY2UgVHlwZXMgLyBTQ01JIERldmljZSAvIERldmljZSBPcGVyYXRpb24gLyBTZXR0 aW5nIFVwIGV2ZW50cSBCdWZmZXJzfQo+ICtcZW5ke2l0ZW1pemV9Cj4gKwo+ICBcY29uZm9ybWFu Y2V7XHNlY3Rpb259e0RldmljZSBDb25mb3JtYW5jZX1cbGFiZWx7c2VjOkNvbmZvcm1hbmNlIC8g RGV2aWNlIENvbmZvcm1hbmNlfQo+ICAKPiAgQSBkZXZpY2UgTVVTVCBjb25mb3JtIHRvIHRoZSBm b2xsb3dpbmcgbm9ybWF0aXZlIHN0YXRlbWVudHM6Cj4gQEAgLTUwNSw2ICs1MTYsMTcgQEAgXHNl Y3Rpb257Q29uZm9ybWFuY2UgVGFyZ2V0c31cbGFiZWx7c2VjOkNvbmZvcm1hbmNlIC8gQ29uZm9y bWFuY2UgVGFyZ2V0c30KPiAgXGl0ZW0gXHJlZntkZXZpY2Vub3JtYXRpdmU6RGV2aWNlIFR5cGVz IC8gSTJDIEFkYXB0ZXIgRGV2aWNlIC8gRGV2aWNlIE9wZXJhdGlvbn0KPiAgXGVuZHtpdGVtaXpl fQo+ICAKPiArXGNvbmZvcm1hbmNle1xzdWJzZWN0aW9ufXtTQ01JIERldmljZSBDb25mb3JtYW5j ZX1cbGFiZWx7c2VjOkNvbmZvcm1hbmNlIC8gRGV2aWNlIENvbmZvcm1hbmNlIC8gU0NNSSBEZXZp Y2UgQ29uZm9ybWFuY2V9Cj4gKwo+ICtBbiBTQ01JIGRldmljZSBNVVNUIGNvbmZvcm0gdG8gdGhl IGZvbGxvd2luZyBub3JtYXRpdmUgc3RhdGVtZW50czoKPiArCj4gK1xiZWdpbntpdGVtaXplfQo+ ICtcaXRlbSBccmVme2RldmljZW5vcm1hdGl2ZTpEZXZpY2UgVHlwZXMgLyBTQ01JIERldmljZSAv IEZlYXR1cmUgYml0c30KPiArXGl0ZW0gXHJlZntkZXZpY2Vub3JtYXRpdmU6RGV2aWNlIFR5cGVz IC8gU0NNSSBEZXZpY2UgLyBEZXZpY2UgT3BlcmF0aW9uIC8gY21kcSBPcGVyYXRpb259Cj4gK1xp dGVtIFxyZWZ7ZGV2aWNlbm9ybWF0aXZlOkRldmljZSBUeXBlcyAvIFNDTUkgRGV2aWNlIC8gRGV2 aWNlIE9wZXJhdGlvbiAvIGV2ZW50cSBPcGVyYXRpb259Cj4gK1xpdGVtIFxyZWZ7ZGV2aWNlbm9y bWF0aXZlOkRldmljZSBUeXBlcyAvIFNDTUkgRGV2aWNlIC8gRGV2aWNlIE9wZXJhdGlvbiAvIFNo YXJlZCBNZW1vcnkgT3BlcmF0aW9ufQo+ICtcZW5ke2l0ZW1pemV9Cj4gKwo+ICBcY29uZm9ybWFu Y2V7XHNlY3Rpb259e0xlZ2FjeSBJbnRlcmZhY2U6IFRyYW5zaXRpb25hbCBEZXZpY2UgYW5kIFRy YW5zaXRpb25hbCBEcml2ZXIgQ29uZm9ybWFuY2V9XGxhYmVse3NlYzpDb25mb3JtYW5jZSAvIExl Z2FjeSBJbnRlcmZhY2U6IFRyYW5zaXRpb25hbCBEZXZpY2UgYW5kIFRyYW5zaXRpb25hbCBEcml2 ZXIgQ29uZm9ybWFuY2V9Cj4gIEEgY29uZm9ybWFudCBpbXBsZW1lbnRhdGlvbiBNVVNUIGJlIGVp dGhlciB0cmFuc2l0aW9uYWwgb3IKPiAgbm9uLXRyYW5zaXRpb25hbCwgc2VlIFxyZWZ7aW50cm86 TGVnYWN5Cj4gZGlmZiAtLWdpdCBhL2NvbnRlbnQudGV4IGIvY29udGVudC50ZXgKPiBpbmRleCA4 MzVmMWVhLi40MGFiMzBhIDEwMDY0NAo+IC0tLSBhL2NvbnRlbnQudGV4Cj4gKysrIGIvY29udGVu dC50ZXgKPiBAQCAtNjUzMiw2ICs2NTMyLDcgQEAgXHN1YnN1YnNlY3Rpb257TGVnYWN5IEludGVy ZmFjZTogRnJhbWluZyBSZXF1aXJlbWVudHN9XGxhYmVse3NlYzpEZXZpY2UKPiAgXGlucHV0e3Zp cnRpby1zb3VuZC50ZXh9Cj4gIFxpbnB1dHt2aXJ0aW8tbWVtLnRleH0KPiAgXGlucHV0e3ZpcnRp by1pMmMudGV4fQo+ICtcaW5wdXR7dmlydGlvLXNjbWkudGV4fQo+ICAKPiAgXGNoYXB0ZXJ7UmVz ZXJ2ZWQgRmVhdHVyZSBCaXRzfVxsYWJlbHtzZWM6UmVzZXJ2ZWQgRmVhdHVyZSBCaXRzfQo+ICAK PiBkaWZmIC0tZ2l0IGEvaW50cm9kdWN0aW9uLnRleCBiL2ludHJvZHVjdGlvbi50ZXgKPiBpbmRl eCBiYzAyMTdmLi43MjA0YjI0IDEwMDY0NAo+IC0tLSBhL2ludHJvZHVjdGlvbi50ZXgKPiArKysg Yi9pbnRyb2R1Y3Rpb24udGV4Cj4gQEAgLTc2LDYgKzc2LDkgQEAgXHNlY3Rpb257Tm9ybWF0aXZl IFJlZmVyZW5jZXN9XGxhYmVse3NlYzpOb3JtYXRpdmUgUmVmZXJlbmNlc30KPiAgCVxwaGFudG9t c2VjdGlvblxsYWJlbHtpbnRybzpJMkN9XHRleHRiZntbSTJDXX0gJgo+ICAJSTJDLWJ1cyBzcGVj aWZpY2F0aW9uIGFuZCB1c2VyIG1hbnVhbCwKPiAgCVxuZXdsaW5lXHVybHtodHRwczovL3d3dy5u eHAuY29tL2RvY3MvZW4vdXNlci1ndWlkZS9VTTEwMjA0LnBkZn1cXAo+ICsJXHBoYW50b21zZWN0 aW9uXGxhYmVse2ludHJvOlNDTUl9XHRleHRiZntbU0NNSV19ICYKPiArCUFybSBTeXN0ZW0gQ29u dHJvbCBhbmQgTWFuYWdlbWVudCBJbnRlcmZhY2UsIERFTjAwNTYsCj4gKwlcbmV3bGluZVx1cmx7 aHR0cHM6Ly9kZXZlbG9wZXIuYXJtLmNvbS9kb2NzL2RlbjAwNTYvY30sIHZlcnNpb24gQyBhbmQg YW55IGZ1dHVyZSByZXZpc2lvbnNcXAo+ICAKPiAgXGVuZHtsb25ndGFibGV9Cj4gIAo+IGRpZmYg LS1naXQgYS92aXJ0aW8tc2NtaS50ZXggYi92aXJ0aW8tc2NtaS50ZXgKPiBuZXcgZmlsZSBtb2Rl IDEwMDY0NAo+IGluZGV4IDAwMDAwMDAuLmM0YjhkZDAKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIv dmlydGlvLXNjbWkudGV4Cj4gQEAgLTAsMCArMSwyNzEgQEAKPiArXHNlY3Rpb257U0NNSSBEZXZp Y2V9XGxhYmVse3NlYzpEZXZpY2UgVHlwZXMgLyBTQ01JIERldmljZX0KPiArCj4gK0FuIFNDTUkg ZGV2aWNlIGltcGxlbWVudHMgdGhlIEFybSBTeXN0ZW0gQ29udHJvbCBhbmQgTWFuYWdlbWVudAo+ ICtJbnRlcmZhY2UgKFNDTUkpLiBTQ01JIGNhbiBiZSB1c2VkIGZvciBzZW5zb3JzLCBwb3dlciBz dGF0ZSBtYW5hZ2VtZW50LAo+ICtjbG9jayBtYW5hZ2VtZW50IGFuZCBwZXJmb3JtYW5jZSBtYW5h Z2VtZW50IGFtb25nIG90aGVyIHRoaW5ncy4KPiArCj4gK1RoaXMgc2VjdGlvbiByZWxpZXMgb24g ZGVmaW5pdGlvbnMgZnJvbSB0aGUgXGh5cGVycmVmW2ludHJvOlNDTUlde1NDTUkKPiArc3BlY2lm aWNhdGlvbn0uCj4gKwo+ICtWaXJ0aW8gU0NNSSBkZXZpY2UgYW5kIGRyaXZlciBhcmUgbWFwcGVk IHRvIFNDTUkgcGxhdGZvcm0gYW5kIGFnZW50Cj4gK3Jlc3BlY3RpdmVseS4gVGhlIGRldmljZSBp cyB2aXNpYmxlIHRvIGEgcGFydGljdWxhciBTQ01JIGFnZW50LiBUaGUKPiArZGV2aWNlIGFsbG93 cyBhIGd1ZXN0IHRvIGNvbW11bmljYXRlIGFzIGFuIFNDTUkgYWdlbnQgdXNpbmcgb25lIG9yIG1v cmUKPiArU0NNSSBwcm90b2NvbHMuIFRoZSBkZWZhdWx0IFNDTUkgcHJvdG9jb2xzIGFyZSBkZWZp bmVkIGluIHRoZQo+ICtcaHlwZXJyZWZbaW50cm86U0NNSV17U0NNSSBzcGVjaWZpY2F0aW9ufS4g VmlydGlvIHByb3ZpZGVzIGEgdHJhbnNwb3J0Cj4gK21lZGl1bSBmb3IgZXhjaGFuZ2luZyBTQ01J IG1lc3NhZ2VzIGJldHdlZW4gdGhlIFNDTUkgYWdlbnQgYW5kIHBsYXRmb3JtLgo+ICtUaGUgdmly dGlvIFNDTUkgdHJhbnNwb3J0IGFsbG93cyB0aGUgcXVldWVpbmcgb2YgbXVsdGlwbGUgbWVzc2Fn ZXMgYW5kCj4gK3Jlc3BvbnNlcy4KPiArCj4gK1NDTUkgRmFzdENoYW5uZWxzIGFyZSBub3Qgc3Vw cG9ydGVkLgo+ICsKPiArXHN1YnNlY3Rpb257RGV2aWNlIElEfVxsYWJlbHtzZWM6RGV2aWNlIFR5 cGVzIC8gU0NNSSBEZXZpY2UgLyBEZXZpY2UgSUR9Cj4gKwo+ICszMgo+ICsKPiArXHN1YnNlY3Rp b257VmlydHF1ZXVlc31cbGFiZWx7c2VjOkRldmljZSBUeXBlcyAvIFNDTUkgRGV2aWNlIC8gVmly dHF1ZXVlc30KPiArCj4gK1xiZWdpbntkZXNjcmlwdGlvbn0KPiArXGl0ZW1bMF0gY21kcQo+ICtc aXRlbVsxXSBldmVudHEKPiArXGVuZHtkZXNjcmlwdGlvbn0KPiArCj4gK1RoZSBjbWRxIGlzIHVz ZWQgYnkgdGhlIGRyaXZlciB0byBzZW5kIGNvbW1hbmRzIHRvIHRoZSBkZXZpY2UuIFRoZQo+ICtk ZXZpY2UgcmVwbGllcyB3aXRoIHJlc3BvbnNlcyAobm90IGRlbGF5ZWQgcmVzcG9uc2VzKSBvdmVy IHRoZSBjbWRxLgo+ICsKPiArVGhlIGV2ZW50cSBpcyB1c2VkIGJ5IHRoZSBkZXZpY2UgdG8gc2Vu ZCBub3RpZmljYXRpb25zIGFuZCBkZWxheWVkCj4gK3Jlc3BvbnNlcy4gVGhlIGV2ZW50cSBvbmx5 IGV4aXN0cyBpZiBWSVJUSU9fU0NNSV9GX1AyQV9DSEFOTkVMUyB3YXMKPiArbmVnb3RpYXRlZC4K PiArCj4gK1xzdWJzZWN0aW9ue0ZlYXR1cmUgYml0c31cbGFiZWx7c2VjOkRldmljZSBUeXBlcyAv IFNDTUkgRGV2aWNlIC8gRmVhdHVyZSBiaXRzfQo+ICsKPiArXGJlZ2lue2Rlc2NyaXB0aW9ufQo+ ICtcaXRlbVtWSVJUSU9fU0NNSV9GX1AyQV9DSEFOTkVMUyAoMCldIERldmljZSBpbXBsZW1lbnRz IHNvbWUgU0NNSQo+ICtub3RpZmljYXRpb25zLCBvciBkZWxheWVkIHJlc3BvbnNlcy4KPiArXGl0 ZW1bVklSVElPX1NDTUlfRl9TSEFSRURfTUVNT1JZICgxKV0gRGV2aWNlIGltcGxlbWVudHMgYW55 IFNDTUkKPiArc3RhdGlzdGljcyBzaGFyZWQgbWVtb3J5IHJlZ2lvbi4KPiArXGVuZHtkZXNjcmlw dGlvbn0KPiArCj4gK1ZJUlRJT19TQ01JX0ZfUDJBX0NIQU5ORUxTIGlzIHVzZWQgdG8gZGV0ZXJt aW5lIHRoZSBleGlzdGVuY2Ugb2YgdGhlCj4gK2V2ZW50cS4gVGhlIGV2ZW50cSBpcyByZXF1aXJl ZCBmb3IgU0NNSSBub3RpZmljYXRpb25zIGFuZCBkZWxheWVkCj4gK3Jlc3BvbnNlcy4KPiArCj4g K1ZJUlRJT19TQ01JX0ZfU0hBUkVEX01FTU9SWSBpcyB1c2VkIHRvIGRldGVybWluZSB3aGV0aGVy IHRoZSBkZXZpY2UKPiArcHJvdmlkZXMgYW55IFNDTUkgc3RhdGlzdGljcyBzaGFyZWQgbWVtb3J5 IHJlZ2lvbi4gU0NNSSBzdGF0aXN0aWNzCj4gK3NoYXJlZCBtZW1vcnkgcmVnaW9ucyBhcmUgZGVm aW5lZCBieSBzb21lIFNDTUkgcHJvdG9jb2xzLgo+ICsKPiArVGhlIFNDTUkgcHJvdG9jb2xzIHBy b3ZpZGUgdGhlIFBST1RPQ09MX01FU1NBR0VfQVRUUklCVVRFUyBjb21tYW5kcyB0bwo+ICtpbnF1 aXJlIGFib3V0IHRoZSBwYXJ0aWN1bGFyIFNDTUkgbm90aWZpY2F0aW9ucyBhbmQgZGVsYXllZCBy ZXNwb25zZXMKPiAraW1wbGVtZW50ZWQgYnkgdGhlIGRldmljZS4gVGhlIFNDTUkgcHJvdG9jb2xz IHByb3ZpZGUgYWRkaXRpb25hbAo+ICtjb21tYW5kcyB0byBkZXRlY3Qgb3RoZXIgZmVhdHVyZXMg aW1wbGVtZW50ZWQgYnkgdGhlIGRldmljZS4KPiArCj4gK1xkZXZpY2Vub3JtYXRpdmV7XHN1YnN1 YnNlY3Rpb259e0ZlYXR1cmUgYml0c317RGV2aWNlIFR5cGVzIC8gU0NNSSBEZXZpY2UgLyBGZWF0 dXJlIGJpdHN9Cj4gKwo+ICtUaGUgZGV2aWNlIE1VU1Qgb2ZmZXIgVklSVElPX1NDTUlfRl9QMkFf Q0hBTk5FTFMgaWYgdGhlIGRldmljZSBjYW4KPiAraW1wbGVtZW50IGF0IGxlYXN0IG9uZSBTQ01J IG5vdGlmaWNhdGlvbiwgb3IgZGVsYXllZCByZXNwb25zZS4KPiArCj4gK1RoZSBkZXZpY2UgTVVT VCBvZmZlciBWSVJUSU9fU0NNSV9GX1NIQVJFRF9NRU1PUlkgaWYgdGhlIGRldmljZSBjYW4KPiAr aW1wbGVtZW50IGF0IGxlYXN0IG9uZSBTQ01JIHN0YXRpc3RpY3Mgc2hhcmVkIG1lbW9yeSByZWdp b24uCj4gKwo+ICtcc3Vic2VjdGlvbntEZXZpY2UgY29uZmlndXJhdGlvbiBsYXlvdXR9XGxhYmVs e3NlYzpEZXZpY2UgVHlwZXMgLyBTQ01JIERldmljZSAvIERldmljZSBjb25maWd1cmF0aW9uIGxh eW91dH0KPiArCj4gK1RoZXJlIGlzIG5vIGNvbmZpZ3VyYXRpb24gZGF0YSBmb3IgdGhlIGRldmlj ZS4KPiArCj4gK1xzdWJzZWN0aW9ue0RldmljZSBJbml0aWFsaXphdGlvbn1cbGFiZWx7c2VjOkRl dmljZSBUeXBlcyAvIFNDTUkgRGV2aWNlIC8gRGV2aWNlIEluaXRpYWxpemF0aW9ufQo+ICsKPiAr VGhlCj4gK1xoeXBlcnJlZltzZWM6R2VuZXJhbCBJbml0aWFsaXphdGlvbiBBbmQgRGV2aWNlIE9w ZXJhdGlvbiAvIERldmljZSBJbml0aWFsaXphdGlvbl17Z2VuZXJhbAo+ICtyZXF1aXJlbWVudHMg b24gZGV2aWNlIGluaXRpYWxpemF0aW9ufSBhcHBseS4KPiArCj4gK1xzdWJzZWN0aW9ue0Rldmlj ZSBPcGVyYXRpb259XGxhYmVse3NlYzpEZXZpY2UgVHlwZXMgLyBTQ01JIERldmljZSAvIERldmlj ZSBPcGVyYXRpb259Cj4gKwo+ICtUaGUgU0NNSSB0cmFuc3BvcnQgdXNlZCBmb3IgdGhlIGRldmlj ZSBwdXRzIGVhY2ggU0NNSSBtZXNzYWdlIGludG8gYQo+ICtkZWRpY2F0ZWQgdmlydGlvIGJ1ZmZl ci4gVGhlIGRyaXZlciB1c2VzIHRoZSBjbWRxIGZvciB0cmFuc21pdHRpbmcgU0NNSQo+ICtjb21t YW5kcyBhbmQgcmVjZWl2aW5nIHRoZSBjb3JyZXNwb25kaW5nIFNDTUkgcmVzcG9uc2VzLiBUaGUg ZGV2aWNlIHVzZXMKPiArdGhlIGV2ZW50cSBmb3IgdHJhbnNtaXR0aW5nIFNDTUkgbm90aWZpY2F0 aW9ucyBhbmQgZGVsYXllZCByZXNwb25zZXMuCj4gK0VhY2ggbWVzc2FnZSBpbmNsdWRlcyBhbiBT Q01JIHByb3RvY29sIGhlYWRlciBhbmQgcGF5bG9hZCwgYXMgZGVmaW5lZCBieQo+ICt0aGUgXGh5 cGVycmVmW2ludHJvOlNDTUlde1NDTUkgc3BlY2lmaWNhdGlvbn0uCj4gKwo+ICtcc3Vic3Vic2Vj dGlvbntjbWRxIE9wZXJhdGlvbn1cbGFiZWx7c2VjOkRldmljZSBUeXBlcyAvIFNDTUkgRGV2aWNl IC8gRGV2aWNlIE9wZXJhdGlvbiAvIGNtZHEgT3BlcmF0aW9ufQo+ICsKPiArRWFjaCBidWZmZXIg aW4gdGhlIGNtZHEgaG9sZHMgYSBzaW5nbGUgU0NNSSBjb21tYW5kIG9uY2UgdGhlIGJ1ZmZlciBo YXMKPiArYmVlbiBtYWRlIGF2YWlsYWJsZS4gV2hlbiB0aGUgYnVmZmVyIGhhcyBiZWVuIG1hcmtl ZCBhcyB1c2VkLCBpdAo+ICtjb250YWlucyB0aGUgU0NNSSByZXNwb25zZS4gQW4gYXJiaXRyYXJ5 IG51bWJlciBvZiBzdWNoIFNDTUkgbWVzc2FnZXMKPiArY2FuIGJlIGluIHRyYW5zaXQgYXQgdGhl IHNhbWUgdGltZS4gQ29uY2VwdHVhbGx5LCBlYWNoIFNDTUkgbWVzc2FnZSBpbgo+ICt0aGUgY21k cSB1c2VzIGl0cyBvd24gU0NNSSBBMlAgKGFnZW50IHRvIHBsYXRmb3JtKSBjaGFubmVsLgo+ICsK PiArVGhlIFNDTUkgcmVzcG9uc2UgaXMgaW4gdGhlIHNhbWUgdmlydGlvIGJ1ZmZlciBhcyB0aGUg Y29ycmVzcG9uZGluZyBTQ01JCj4gK2NvbW1hbmQuIFRoZSByZXNwb25zZSBjb250YWlucyB0aGUg cmV0dXJuIHZhbHVlcyB3aGljaCBTQ01JIHNwZWNpZmllcwo+ICtmb3IgZWFjaCBjb21tYW5kLCB3 aGV0aGVyIHN5bmNocm9ub3VzIG9yIGFzeW5jaHJvbm91cy4gRGVsYXllZCByZXNwb25zZXMKPiAr YXJlIGRpc3RpbmN0IFNDTUkgbWVzc2FnZXMgdHJhbnNtaXR0ZWQgb3ZlciB0aGUgZXZlbnRxLgo+ ICsKPiArQnVmZmVycyBpbiB0aGUgY21kcSBjb250YWluIGJvdGggdGhlIHJlcXVlc3QgYW5kIHRo ZSByZXNwb25zZS4gQSByZXF1ZXN0Cj4gK2hhcyB0aGUgZm9sbG93aW5nIGxheW91dDoKPiArCj4g K1xiZWdpbntsc3RsaXN0aW5nfQo+ICtzdHJ1Y3QgdmlydGlvX3NjbWlfcmVxdWVzdCB7Cj4gKyAg ICAgICAgbGUzMiBoZHI7Cj4gKyAgICAgICAgdTggcGFyYW1zWzxhY3R1YWwgcGFyYW1ldGVycyBz aXplPl07Cj4gK307Cj4gK1xlbmR7bHN0bGlzdGluZ30KPiArCj4gK1RoZSB2aXJ0aW9fc2NtaV9y ZXF1ZXN0IGZpZWxkcyBhcmUgaW50ZXJwcmV0ZWQgYXMgZm9sbG93czoKPiArCj4gK1xiZWdpbntk ZXNjcmlwdGlvbn0KPiArXGl0ZW1bXGZpZWxke2hkcn1dIChkZXZpY2UtcmVhZGFibGUpIGNvbnRh aW5zIHRoZSBTQ01JIG1lc3NhZ2UgaGVhZGVyCj4gK1xpdGVtW1xmaWVsZHtwYXJhbXN9XSAoZGV2 aWNlLXJlYWRhYmxlKSBjb21wcmlzZXMgdGhlIFNDTUkgbWVzc2FnZQo+ICtwYXJhbWV0ZXJzCj4g K1xlbmR7ZGVzY3JpcHRpb259Cj4gKwo+ICtBIGNtZHEgcmVzcG9uc2UgaGFzIHRoZSBmb2xsb3dp bmcgbGF5b3V0Ogo+ICsKPiArXGJlZ2lue2xzdGxpc3Rpbmd9Cj4gK3N0cnVjdCB2aXJ0aW9fc2Nt aV9yZXNwb25zZSB7Cj4gKyAgICAgICAgbGUzMiBoZHI7Cj4gKyAgICAgICAgdTggcmV0X3ZhbHVl c1s8YWN0dWFsIHJldHVybiB2YWx1ZXMgc2l6ZT5dOwo+ICt9Owo+ICtcZW5ke2xzdGxpc3Rpbmd9 Cj4gKwo+ICtUaGUgdmlydGlvX3NjbWlfcmVzcG9uc2UgZmllbGRzIGFyZSBpbnRlcnByZXRlZCBh cyBmb2xsb3dzOgo+ICsKPiArXGJlZ2lue2Rlc2NyaXB0aW9ufQo+ICtcaXRlbVtcZmllbGR7aGRy fV0gKGRldmljZS13cml0YWJsZSkgY29udGFpbnMgdGhlIFNDTUkgbWVzc2FnZSBoZWFkZXIKPiAr XGl0ZW1bXGZpZWxke3JldF92YWx1ZXN9XSAoZGV2aWNlLXdyaXRhYmxlKSBjb21wcmlzZXMgdGhl IFNDTUkgbWVzc2FnZQo+ICtyZXR1cm4gdmFsdWVzCj4gK1xlbmR7ZGVzY3JpcHRpb259Cj4gKwo+ ICtJZiBWSVJUSU9fU0NNSV9GX1AyQV9DSEFOTkVMUyB3YXMgbm90IG5lZ290aWF0ZWQsIHRoZSBk ZXZpY2UgcmVzcG9uZHMgdG8KPiArU0NNSSBjb21tYW5kcyBhcyBpZiBubyBTQ01JIG5vdGlmaWNh dGlvbnMgb3IgZGVsYXllZCByZXNwb25zZXMgd2VyZQo+ICtpbXBsZW1lbnRlZC4KPiArCj4gK1xk ZXZpY2Vub3JtYXRpdmV7XHBhcmFncmFwaH17Y21kcSBPcGVyYXRpb259e0RldmljZSBUeXBlcyAv IFNDTUkgRGV2aWNlIC8gRGV2aWNlIE9wZXJhdGlvbiAvIGNtZHEgT3BlcmF0aW9ufQo+ICsKPiAr VGhlIGRldmljZSBNQVkgcHJvY2VzcyBhdmFpbGFibGUgY29tbWFuZHMgb3V0IG9mIG9yZGVyIGFu ZCBpbiBwYXJhbGxlbC4KPiArCj4gK1RoZSBkZXZpY2UgTVVTVCBwcm9jZXNzIGFsbCBhdmFpbGFi bGUgY29tbWFuZHMgZXZlbnR1YWxseSwgZXZlbiBpbiB0aGUKPiArY2FzZSBvZiBidXJzdHMgb2Yg bXVsdGlwbGUgY29tbWFuZCBtZXNzYWdlcy4KPiArCj4gK0lmIHRoZSBcZmllbGR7c3RhdHVzfSBm aWVsZCBpbiB0aGUgXGZpZWxke3ZpcnRpb19zY21pX3Jlc3BvbnNlfQo+ICtcZmllbGR7cmV0X3Zh bHVlc30gaGFzIGEgdmFsdWUgb3RoZXIgdGhhbiBTVUNDRVNTLCB0aGUgZGV2aWNlIE1VU1Qgc2V0 Cj4gK3RoZSBzaXplIG9mIFxmaWVsZHtyZXRfdmFsdWVzfSB0byB0aGUgc2l6ZSBvZiB0aGUgXGZp ZWxke3N0YXR1c30gZmllbGQuCj4gKwo+ICtJZiB0aGUgZHJpdmVyIHJlcXVlc3RzIGFuIFNDTUkg bm90aWZpY2F0aW9uIG9yIGEgZGVsYXllZCByZXNwb25zZSBhbmQKPiArdGhlcmUgYXJlIGN1cnJl bnRseSBOT1QgZW5vdWdoIGF2YWlsYWJsZSBidWZmZXJzIGluIHRoZSBldmVudHEsIHRoZQo+ICtk ZXZpY2UgU0hPVUxEIHN0aWxsIHJldHVybiBTQ01JIHN0YXR1cyBjb2RlIFNVQ0NFU1MuCj4gKwo+ ICtJZiBWSVJUSU9fU0NNSV9GX1AyQV9DSEFOTkVMUyB3YXMgbm90IG5lZ290aWF0ZWQsIHRoZSBk ZXZpY2UgTVVTVCBkZW55Cj4gK2FueSByZXF1ZXN0IGZvciBhbiBTQ01JIG5vdGlmaWNhdGlvbiBv ciBhIGRlbGF5ZWQgcmVzcG9uc2UgYnkgcmV0dXJuaW5nCj4gK1NDTUkgc3RhdHVzIGNvZGUgTk9U X1NVUFBPUlRFRC4KPiArCj4gK0lmIFZJUlRJT19TQ01JX0ZfUDJBX0NIQU5ORUxTIHdhcyBub3Qg bmVnb3RpYXRlZCwgdGhlIGRldmljZSBNVVNUIE5PVAo+ICtpbmRpY2F0ZSBpbiB0aGUgUFJPVE9D T0xfTUVTU0FHRV9BVFRSSUJVVEVTIHJldHVybiB2YWx1ZXMgdGhhdCBhbnkgU0NNSQo+ICtub3Rp ZmljYXRpb24sIG9yIGRlbGF5ZWQgcmVzcG9uc2UsIGlzIGltcGxlbWVudGVkLgo+ICsKPiArXGRy aXZlcm5vcm1hdGl2ZXtccGFyYWdyYXBofXtjbWRxIE9wZXJhdGlvbn17RGV2aWNlIFR5cGVzIC8g U0NNSSBEZXZpY2UgLyBEZXZpY2UgT3BlcmF0aW9uIC8gY21kcSBPcGVyYXRpb259Cj4gKwo+ICtC ZWZvcmUgc2VuZGluZyBhIGNvbW1hbmQsIHRoZSBkcml2ZXIgTVVTVCB3YWl0IGZvciByZXNwb25z ZXMgdG8gYWxsCj4gK2NvbW1hbmRzIHdob3NlIGNvbXBsZXRpb24gdGhlIGRyaXZlciBjb25zaWRl cnMgcHJlcmVxdWlzaXRlcyB0bwo+ICtleGVjdXRpbmcgdGhlIGNvbW1hbmQuCj4gKwo+ICtXaXRo IGV2ZXJ5IGNvbW1hbmQgbWVzc2FnZSwgdGhlIGRyaXZlciBNVVNUIHByb3ZpZGUgZW5vdWdoCj4g K2RldmljZS13cml0YWJsZSBtZW1vcnkgdG8gZW5hYmxlIHRoZSBkZXZpY2UgdG8gcmV0dXJuIGNv cnJlc3BvbmRpbmcKPiArcmV0dXJuIHZhbHVlcy4KPiArCj4gK0lmIFZJUlRJT19TQ01JX0ZfUDJB X0NIQU5ORUxTIHdhcyBub3QgbmVnb3RpYXRlZCwgdGhlIGRyaXZlciBNVVNUIE5PVAo+ICtyZXF1 ZXN0IGFueSBTQ01JIG5vdGlmaWNhdGlvbiwgbm9yIGFueSBkZWxheWVkIHJlc3BvbnNlLgo+ICsK PiArXHN1YnN1YnNlY3Rpb257U2V0dGluZyBVcCBldmVudHEgQnVmZmVyc30KPiArCj4gK1RoZSBk cml2ZXIgaGFzIHRvIHBvcHVsYXRlIHRoZSBldmVudHEgYmVmb3JlIHRoZSBkZXZpY2UgY2FuIHVz ZSBpdC4KPiArCj4gK1xkcml2ZXJub3JtYXRpdmV7XHBhcmFncmFwaH17U2V0dGluZyBVcCBldmVu dHEgQnVmZmVyc317RGV2aWNlIFR5cGVzIC8gU0NNSSBEZXZpY2UgLyBEZXZpY2UgT3BlcmF0aW9u IC8gU2V0dGluZyBVcCBldmVudHEgQnVmZmVyc30KPiArCj4gK0lmIFZJUlRJT19TQ01JX0ZfUDJB X0NIQU5ORUxTIHdhcyBuZWdvdGlhdGVkLCB0aGUgZHJpdmVyIFNIT1VMRCBwb3B1bGF0ZQo+ICt0 aGUgZXZlbnRxIHdpdGggYnVmZmVycy4KPiArCj4gK1RoZSBkcml2ZXIgTVVTVCBOT1QgcHV0IGRl dmljZS1yZWFkYWJsZSBkZXNjcmlwdG9ycyBpbnRvIHRoZSBldmVudHEuCj4gKwo+ICtUaGUgZHJp dmVyIE1VU1QgTk9UIHB1dCBpbnRvIHRoZSBldmVudHEgYW55IGJ1ZmZlciB3aGljaCBpcyBzbWFs bGVyIHRoYW4KPiArdGhlIGxhcmdlc3QgU0NNSSBQMkEgKHBsYXRmb3JtIHRvIGFnZW50KSBtZXNz YWdlIHdoaWNoIHRoZSBkcml2ZXIgd2lsbAo+ICtyZXF1ZXN0Lgo+ICsKPiArXHN1YnN1YnNlY3Rp b257ZXZlbnRxIE9wZXJhdGlvbn0KPiArCj4gK0VhY2ggYnVmZmVyIGluIHRoZSBldmVudHEgaG9s ZHMgKG9uY2UgdGhlIGJ1ZmZlciBpcyBtYXJrZWQgYXMgdXNlZCkKPiArZWl0aGVyIGEgc2luZ2xl IFNDTUkgbm90aWZpY2F0aW9uLCBvciBhIHNpbmdsZSBTQ01JIGRlbGF5ZWQgcmVzcG9uc2UuIEFu Cj4gK2FyYml0cmFyeSBudW1iZXIgb2Ygc3VjaCBTQ01JIG1lc3NhZ2VzIGNhbiBiZSBpbiB0cmFu c2l0IGF0IHRoZSBzYW1lCj4gK3RpbWUuIENvbmNlcHR1YWxseSwgZWFjaCBTQ01JIG1lc3NhZ2Ug dHJhbnNtaXR0ZWQgb3ZlciB0aGUgZXZlbnRxIHVzZXMKPiAraXRzIG93biBTQ01JIFAyQSAocGxh dGZvcm0gdG8gYWdlbnQpIGNoYW5uZWwuIEJ1ZmZlcnMgaW4gdGhlIGV2ZW50cSBoYXZlCj4gK3Ro ZSBmb2xsb3dpbmcgbGF5b3V0Ogo+ICsKPiArXGJlZ2lue2xzdGxpc3Rpbmd9Cj4gK3N0cnVjdCB2 aXJ0aW9fc2NtaV9ldmVudF9tc2cgewo+ICsgICAgICAgIC8qIHN0YXJ0IG9mIGRldmljZS13cml0 YWJsZSBkYXRhICovCj4gKyAgICAgICAgbGUzMiBoZHI7Cj4gKyAgICAgICAgdTggcGF5bG9hZFs8 YWN0dWFsIHBheWxvYWQgc2l6ZT5dOwo+ICt9Owo+ICtcZW5ke2xzdGxpc3Rpbmd9Cj4gKwo+ICtc YmVnaW57ZGVzY3JpcHRpb259Cj4gK1xpdGVtW1xmaWVsZHtoZHJ9XSAoZGV2aWNlLXdyaXRhYmxl KSBjb250YWlucyB0aGUgU0NNSSBtZXNzYWdlIGhlYWRlcgo+ICtcaXRlbVtcZmllbGR7cGF5bG9h ZH1dIChkZXZpY2Utd3JpdGFibGUpIGNvbXByaXNlcyB0aGUgU0NNSSBtZXNzYWdlCj4gK3BheWxv YWQKPiArXGVuZHtkZXNjcmlwdGlvbn0KPiArCj4gK1xkZXZpY2Vub3JtYXRpdmV7XHBhcmFncmFw aH17ZXZlbnRxIE9wZXJhdGlvbn17RGV2aWNlIFR5cGVzIC8gU0NNSSBEZXZpY2UgLyBEZXZpY2Ug T3BlcmF0aW9uIC8gZXZlbnRxIE9wZXJhdGlvbn0KPiArCj4gK0lmIHRoZSBkZXZpY2UgaW50ZW5k cyB0byBzZW5kIGEgbm90aWZpY2F0aW9uIGFuZCB0aGVyZSBhcmUgbm8gYXZhaWxhYmxlCj4gK2J1 ZmZlcnMgaW4gdGhlIGV2ZW50cSwgdGhlIGRldmljZSBNQVkgZHJvcCB0aGUgbm90aWZpY2F0aW9u LCBvciBzZW5kIGEKPiArY29ycmVzcG9uZGluZyBub3RpZmljYXRpb24gbGF0ZXIsIG9uY2UgZW5v dWdoIGJ1ZmZlcnMgYmVjb21lIGF2YWlsYWJsZS4KPiArCj4gK1RoZSBkZXZpY2UgTUFZIHNlbmQg dGhlIG5vdGlmaWNhdGlvbiBsYXRlciBpZiB0aGUgZXZlbnRzIHdoaWNoIGNhdXNlIHRoZQo+ICtu b3RpZmljYXRpb24gdGFrZSBwbGFjZSBpbiBxdWljayBzdWNjZXNzaW9uLgo+ICsKPiArSWYgdGhl IGRldmljZSBzZW5kcyB0aGUgbm90aWZpY2F0aW9uIGxhdGVyLCB0aGUgZGV2aWNlIE1BWSBzZW5k IHRoZQo+ICtub3RpZmljYXRpb24gd2l0aCB1cGRhdGVkIGRhdGEsIHVubGVzcyB0aGUgc3BlY2lm aWMgU0NNSSBwcm90b2NvbAo+ICtkaXNhbGxvd3MgdGhpcy4KPiArCj4gK0lmIHRoZSBkZXZpY2Ug aW50ZW5kcyB0byBzZW5kIGEgbm90aWZpY2F0aW9uIGFuZCB0aGVyZSBhcmUgYXZhaWxhYmxlCj4g K2J1ZmZlcnMsIGJ1dCBvbmUgb2YgdGhlIGJ1ZmZlcnMgaXMgdG9vIHNtYWxsIHRvIGZpdCB0aGUg bm90aWZpY2F0aW9uLAo+ICt0aGUgZGV2aWNlIE1BWSBvbWl0IHRoZSBub3RpZmljYXRpb24uCj4g Kwo+ICtJZiB0aGUgZGV2aWNlIGludGVuZHMgdG8gc2VuZCBhIGRlbGF5ZWQgcmVzcG9uc2UgYW5k IHRoZXJlIGFyZSBubwo+ICthdmFpbGFibGUgYnVmZmVycyBpbiB0aGUgZXZlbnRxLCB0aGUgZGV2 aWNlIE1VU1Qgc2VuZCB0aGUgY29ycmVzcG9uZGluZwo+ICtkZWxheWVkIHJlc3BvbnNlIG9uY2Ug ZW5vdWdoIGJ1ZmZlcnMgYmVjb21lIGF2YWlsYWJsZS4KPiArCj4gK0lmIHRoZSBcZmllbGR7c3Rh dHVzfSBmaWVsZCBpbiBhIGRlbGF5ZWQgcmVzcG9uc2UgXGZpZWxke3BheWxvYWR9IGhhcyBhCj4g K3ZhbHVlIG90aGVyIHRoYW4gU1VDQ0VTUywgdGhlIGRldmljZSBNVVNUIHNldCB0aGUgc2l6ZSBv Zgo+ICtcZmllbGR7cGF5bG9hZH0gdG8gdGhlIHNpemUgb2YgdGhlIFxmaWVsZHtzdGF0dXN9IGZp ZWxkLgo+ICsKPiArXHN1YnN1YnNlY3Rpb257U2hhcmVkIE1lbW9yeSBPcGVyYXRpb259Cj4gKwo+ ICtWYXJpb3VzIFNDTUkgcHJvdG9jb2xzIGRlZmluZSBzdGF0aXN0aWNzIHNoYXJlZCBtZW1vcnkg cmVnaW9ucyAoZm9yCj4gK3N0YXRpc3RpY3MgYW5kIHNlbnNvciB2YWx1ZXMpLgo+ICsKPiArXGRl dmljZW5vcm1hdGl2ZXtccGFyYWdyYXBofXtTaGFyZWQgTWVtb3J5IE9wZXJhdGlvbn17RGV2aWNl IFR5cGVzIC8gU0NNSSBEZXZpY2UgLyBEZXZpY2UgT3BlcmF0aW9uIC8gU2hhcmVkIE1lbW9yeSBP cGVyYXRpb259Cj4gKwo+ICtJZiBWSVJUSU9fU0NNSV9GX1NIQVJFRF9NRU1PUlkgd2FzIG5lZ290 aWF0ZWQsIHRoZSBkZXZpY2UgTUFZIGltcGxlbWVudAo+ICthbiBTQ01JIHN0YXRpc3RpY3Mgc2hh cmVkIG1lbW9yeSByZWdpb24gdXNpbmcgYSB2aXJ0aW8gc2hhcmVkIG1lbW9yeQo+ICtyZWdpb24u Cj4gKwo+ICtJZiB0aGUgZGV2aWNlIGltcGxlbWVudHMgYSBzaGFyZWQgbWVtb3J5IHJlZ2lvbiwg dGhlIGRldmljZSBNVVNUIGFzc2lnbgo+ICt0aGUgY29ycmVzcG9uZGluZyBzaG1pZCBhcyBwZXIg dGhlIGZvbGxvd2luZyB0YWJsZToKPiArCj4gK1xiZWdpbnt0YWJ1bGFyfXt8bHxsfH0KPiArXGhs aW5lCj4gK1NDTUkgc3RhdGlzdGljcyBzaGFyZWQgbWVtb3J5IHJlZ2lvbiAmIFZpcnRpbyBzaG1p ZCBcXAo+ICtcaGxpbmUgXGhsaW5lCj4gK1Jlc2VydmVkIChpbnZhbGlkKSAmIDAgXFwKPiArXGhs aW5lCj4gK1Bvd2VyIHN0YXRlIHN0YXRpc3RpY3Mgc2hhcmVkIG1lbW9yeSByZWdpb24gJiAxIFxc Cj4gK1xobGluZQo+ICtQZXJmb3JtYW5jZSBkb21haW4gc3RhdGlzdGljcyBzaGFyZWQgbWVtb3J5 IHJlZ2lvbiAmIDIgXFwKPiArXGhsaW5lCj4gK1NlbnNvciBWYWx1ZXMgU2hhcmVkIE1lbW9yeSAm IDMgXFwKPiArXGhsaW5lCj4gK1Jlc2VydmVkIGZvciBmdXR1cmUgdXNlICYgNCB0byAweDdGIFxc Cj4gK1xobGluZQo+ICtWZW5kb3Itc3BlY2lmaWMgc3RhdGlzdGljcyBzaGFyZWQgbWVtb3J5IHJl Z2lvbnMgJiAweDgwIHRvIDB4RkYgXFwKPiArXGhsaW5lCj4gK1Jlc2VydmVkIGZvciBmdXR1cmUg dXNlICYgMHgxMDAgYW5kIGdyZWF0ZXIgXFwKPiArXGhsaW5lCj4gK1xlbmR7dGFidWxhcn0KPiAK PiBiYXNlLWNvbW1pdDogZjVmZDNmY2E3ZTQwMDYxMDhiM2Y5YmE5MWMwYjc2YzVlYjZjMDcyNgo+ IAoKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51 eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVh ZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1h cm0ta2VybmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: virtio-comment-return-1736-cohuck=redhat.com@lists.oasis-open.org Sender: List-Post: List-Help: List-Unsubscribe: List-Subscribe: References: <20210212095920.249768-1-peter.hilber@opensynergy.com> From: Peter Hilber Message-ID: <182c86c3-730b-12e2-1a9a-347d5e8e25af@opensynergy.com> Date: Thu, 11 Mar 2021 18:19:23 +0100 MIME-Version: 1.0 In-Reply-To: <20210212095920.249768-1-peter.hilber@opensynergy.com> Subject: [virtio-comment] Re: [PATCH v6] Add virtio SCMI device specification Content-Type: text/plain; charset="utf-8" Content-Language: en-US Content-Transfer-Encoding: quoted-printable To: virtio-comment@lists.oasis-open.org Cc: linux-arm-kernel@lists.infradead.org, Souvik.Chakravarty@arm.com, Sudeep.Holla@arm.com, virtio-dev@lists.oasis-open.org, alex.bennee@linaro.org, jean-philippe@linaro.org, cristian.marussi@arm.com List-ID: On 12.02.21 10:59, Peter Hilber wrote: > This patch proposes a new virtio device for the Arm SCMI protocol. >=20 > The device provides a simple transport for the Arm SCMI protocol[1]. The > *S*ystem *C*ontrol and *M*anagement *I*nterface protocol allows speaking > to system controllers that allow orchestrating things like power > management, system state management and sensor access. The SCMI protocol > is used on SoCs where multiple cores and co-processors need access to > these resources. >=20 > The virtio transport allows making use of this protocol in virtualized > systems. >=20 > [1] https://developer.arm.com/docs/den0056/c >=20 > Signed-off-by: Peter Hilber > --- >=20 > Notes: >=20 > Since sending out v5 in May 2020, there has been no additional > feedback w.r.t. the spec. An RfC patch series for the driver is now > available at [1]. OpenSynergy also has a proprietary implementation > of the device (without the VIRTIO_SCMI_F_SHARED_MEMORY feature so > far). >=20 > So I would like to request a vote on adding the device in a few weeks= . > =20 I would like to request a vote on adding the virtio SCMI device to the spec= . Fixes: https://github.com/oasis-tcs/virtio-spec/issues/100 Best regards, Peter > The PDF output is available at [2]. > =20 > [1] https://lore.kernel.org/linux-arm-kernel/20201105212116.411422-1-= peter.hilber@opensynergy.com/ > [2] https://share.mailbox.org/ajax/share/056076e70571144f50c4ca757114= 4b319a1d7236dda1cd3b/1/8/MzQ/MzQvMQ >=20 > Changes for v6: >=20 > - Refer to new SCMI spec version 3.0 (DEN0056C), which has a > provision for SHM race conditions. >=20 > - Resolve conflicts with other added device documentation. >=20 > Changes for v5: > =20 > - Remove requirements on shared memory added in v4, since an upcoming > new version of the Arm SCMI spec[1] will provide a generic, more > powerful way to handle concurrent access to shared memory. > =20 > Changes for v4: > =20 > - Add more requirements on shared memory regions after feedback from > Alex Benn=C3=A9e. > =20 > Changes for v3: > =20 > - Add tentative device ID 32 in device section. > =20 > - Remove redundant 'len' fields. The length of the payload fields can > already be deduced from the generic virtqueue 'len' fields. Therefo= re, > remove the redundant device-specific 'len' fields. > =20 > - Reword requirement that driver must not put too small buffers into > eventq. > =20 > Changes for v2: > =20 > - CC virtio-dev list. > - Define size of erroneous delayed/not delayed responses. > - Use correct long name for SCMI. > - Remove restriction to `embedded' in commit message. > - Add motivation for conceptual per-message-channels. > - Device may now just drop notification if no buffers are available. > =20 >=20 > conformance.tex | 34 ++++-- > content.tex | 1 + > introduction.tex | 3 + > virtio-scmi.tex | 271 +++++++++++++++++++++++++++++++++++++++++++++++ > 4 files changed, 303 insertions(+), 6 deletions(-) > create mode 100644 virtio-scmi.tex >=20 > diff --git a/conformance.tex b/conformance.tex > index 17c390d..a164cbb 100644 > --- a/conformance.tex > +++ b/conformance.tex > @@ -27,9 +27,10 @@ \section{Conformance Targets}\label{sec:Conformance / = Conformance Targets} > \ref{sec:Conformance / Driver Conformance / Socket Driver Conformance}, > \ref{sec:Conformance / Driver Conformance / RPMB Driver Conformance}, > \ref{sec:Conformance / Driver Conformance / IOMMU Driver Conformance}, > -\ref{sec:Conformance / Driver Conformance / Sound Driver Conformance} > -\ref{sec:Conformance / Driver Conformance / Memory Driver Conformance} o= r > -\ref{sec:Conformance / Driver Conformance / I2C Adapter Driver Conforman= ce}. > +\ref{sec:Conformance / Driver Conformance / Sound Driver Conformance}, > +\ref{sec:Conformance / Driver Conformance / Memory Driver Conformance}, > +\ref{sec:Conformance / Driver Conformance / I2C Adapter Driver Conforman= ce} or > +\ref{sec:Conformance / Driver Conformance / SCMI Driver Conformance}. > =20 > \item Clause \ref{sec:Conformance / Legacy Interface: Transitional D= evice and Transitional Driver Conformance}. > \end{itemize} > @@ -49,9 +50,10 @@ \section{Conformance Targets}\label{sec:Conformance / = Conformance Targets} > \ref{sec:Conformance / Device Conformance / Socket Device Conformance},= =20 > \ref{sec:Conformance / Device Conformance / RPMB Device Conformance}, > \ref{sec:Conformance / Device Conformance / IOMMU Device Conformance}, > -\ref{sec:Conformance / Device Conformance / Sound Device Conformance} > -\ref{sec:Conformance / Device Conformance / Memory Device Conformance} o= r > -\ref{sec:Conformance / Device Conformance / I2C Adapter Device Conforman= ce}. > +\ref{sec:Conformance / Device Conformance / Sound Device Conformance}, > +\ref{sec:Conformance / Device Conformance / Memory Device Conformance}, > +\ref{sec:Conformance / Device Conformance / I2C Adapter Device Conforman= ce} or > +\ref{sec:Conformance / Device Conformance / SCMI Device Conformance}. > =20 > \item Clause \ref{sec:Conformance / Legacy Interface: Transitional D= evice and Transitional Driver Conformance}. > \end{itemize} > @@ -277,6 +279,15 @@ \section{Conformance Targets}\label{sec:Conformance = / Conformance Targets} > \item \ref{drivernormative:Device Types / I2C Adapter Device / Device Op= eration} > \end{itemize} > =20 > +\conformance{\subsection}{SCMI Driver Conformance}\label{sec:Conformance= / Driver Conformance / SCMI Driver Conformance} > + > +An SCMI driver MUST conform to the following normative statements: > + > +\begin{itemize} > +\item \ref{drivernormative:Device Types / SCMI Device / Device Operation= / cmdq Operation} > +\item \ref{drivernormative:Device Types / SCMI Device / Device Operation= / Setting Up eventq Buffers} > +\end{itemize} > + > \conformance{\section}{Device Conformance}\label{sec:Conformance / Devic= e Conformance} > =20 > A device MUST conform to the following normative statements: > @@ -505,6 +516,17 @@ \section{Conformance Targets}\label{sec:Conformance = / Conformance Targets} > \item \ref{devicenormative:Device Types / I2C Adapter Device / Device Op= eration} > \end{itemize} > =20 > +\conformance{\subsection}{SCMI Device Conformance}\label{sec:Conformance= / Device Conformance / SCMI Device Conformance} > + > +An SCMI device MUST conform to the following normative statements: > + > +\begin{itemize} > +\item \ref{devicenormative:Device Types / SCMI Device / Feature bits} > +\item \ref{devicenormative:Device Types / SCMI Device / Device Operation= / cmdq Operation} > +\item \ref{devicenormative:Device Types / SCMI Device / Device Operation= / eventq Operation} > +\item \ref{devicenormative:Device Types / SCMI Device / Device Operation= / Shared Memory Operation} > +\end{itemize} > + > \conformance{\section}{Legacy Interface: Transitional Device and Transit= ional Driver Conformance}\label{sec:Conformance / Legacy Interface: Transit= ional Device and Transitional Driver Conformance} > A conformant implementation MUST be either transitional or > non-transitional, see \ref{intro:Legacy > diff --git a/content.tex b/content.tex > index 835f1ea..40ab30a 100644 > --- a/content.tex > +++ b/content.tex > @@ -6532,6 +6532,7 @@ \subsubsection{Legacy Interface: Framing Requiremen= ts}\label{sec:Device > \input{virtio-sound.tex} > \input{virtio-mem.tex} > \input{virtio-i2c.tex} > +\input{virtio-scmi.tex} > =20 > \chapter{Reserved Feature Bits}\label{sec:Reserved Feature Bits} > =20 > diff --git a/introduction.tex b/introduction.tex > index bc0217f..7204b24 100644 > --- a/introduction.tex > +++ b/introduction.tex > @@ -76,6 +76,9 @@ \section{Normative References}\label{sec:Normative Refe= rences} > =09\phantomsection\label{intro:I2C}\textbf{[I2C]} & > =09I2C-bus specification and user manual, > =09\newline\url{https://www.nxp.com/docs/en/user-guide/UM10204.pdf}\\ > +=09\phantomsection\label{intro:SCMI}\textbf{[SCMI]} & > +=09Arm System Control and Management Interface, DEN0056, > +=09\newline\url{https://developer.arm.com/docs/den0056/c}, version C and= any future revisions\\ > =20 > \end{longtable} > =20 > diff --git a/virtio-scmi.tex b/virtio-scmi.tex > new file mode 100644 > index 0000000..c4b8dd0 > --- /dev/null > +++ b/virtio-scmi.tex > @@ -0,0 +1,271 @@ > +\section{SCMI Device}\label{sec:Device Types / SCMI Device} > + > +An SCMI device implements the Arm System Control and Management > +Interface (SCMI). SCMI can be used for sensors, power state management, > +clock management and performance management among other things. > + > +This section relies on definitions from the \hyperref[intro:SCMI]{SCMI > +specification}. > + > +Virtio SCMI device and driver are mapped to SCMI platform and agent > +respectively. The device is visible to a particular SCMI agent. The > +device allows a guest to communicate as an SCMI agent using one or more > +SCMI protocols. The default SCMI protocols are defined in the > +\hyperref[intro:SCMI]{SCMI specification}. Virtio provides a transport > +medium for exchanging SCMI messages between the SCMI agent and platform. > +The virtio SCMI transport allows the queueing of multiple messages and > +responses. > + > +SCMI FastChannels are not supported. > + > +\subsection{Device ID}\label{sec:Device Types / SCMI Device / Device ID} > + > +32 > + > +\subsection{Virtqueues}\label{sec:Device Types / SCMI Device / Virtqueue= s} > + > +\begin{description} > +\item[0] cmdq > +\item[1] eventq > +\end{description} > + > +The cmdq is used by the driver to send commands to the device. The > +device replies with responses (not delayed responses) over the cmdq. > + > +The eventq is used by the device to send notifications and delayed > +responses. The eventq only exists if VIRTIO_SCMI_F_P2A_CHANNELS was > +negotiated. > + > +\subsection{Feature bits}\label{sec:Device Types / SCMI Device / Feature= bits} > + > +\begin{description} > +\item[VIRTIO_SCMI_F_P2A_CHANNELS (0)] Device implements some SCMI > +notifications, or delayed responses. > +\item[VIRTIO_SCMI_F_SHARED_MEMORY (1)] Device implements any SCMI > +statistics shared memory region. > +\end{description} > + > +VIRTIO_SCMI_F_P2A_CHANNELS is used to determine the existence of the > +eventq. The eventq is required for SCMI notifications and delayed > +responses. > + > +VIRTIO_SCMI_F_SHARED_MEMORY is used to determine whether the device > +provides any SCMI statistics shared memory region. SCMI statistics > +shared memory regions are defined by some SCMI protocols. > + > +The SCMI protocols provide the PROTOCOL_MESSAGE_ATTRIBUTES commands to > +inquire about the particular SCMI notifications and delayed responses > +implemented by the device. The SCMI protocols provide additional > +commands to detect other features implemented by the device. > + > +\devicenormative{\subsubsection}{Feature bits}{Device Types / SCMI Devic= e / Feature bits} > + > +The device MUST offer VIRTIO_SCMI_F_P2A_CHANNELS if the device can > +implement at least one SCMI notification, or delayed response. > + > +The device MUST offer VIRTIO_SCMI_F_SHARED_MEMORY if the device can > +implement at least one SCMI statistics shared memory region. > + > +\subsection{Device configuration layout}\label{sec:Device Types / SCMI D= evice / Device configuration layout} > + > +There is no configuration data for the device. > + > +\subsection{Device Initialization}\label{sec:Device Types / SCMI Device = / Device Initialization} > + > +The > +\hyperref[sec:General Initialization And Device Operation / Device Initi= alization]{general > +requirements on device initialization} apply. > + > +\subsection{Device Operation}\label{sec:Device Types / SCMI Device / Dev= ice Operation} > + > +The SCMI transport used for the device puts each SCMI message into a > +dedicated virtio buffer. The driver uses the cmdq for transmitting SCMI > +commands and receiving the corresponding SCMI responses. The device uses > +the eventq for transmitting SCMI notifications and delayed responses. > +Each message includes an SCMI protocol header and payload, as defined by > +the \hyperref[intro:SCMI]{SCMI specification}. > + > +\subsubsection{cmdq Operation}\label{sec:Device Types / SCMI Device / De= vice Operation / cmdq Operation} > + > +Each buffer in the cmdq holds a single SCMI command once the buffer has > +been made available. When the buffer has been marked as used, it > +contains the SCMI response. An arbitrary number of such SCMI messages > +can be in transit at the same time. Conceptually, each SCMI message in > +the cmdq uses its own SCMI A2P (agent to platform) channel. > + > +The SCMI response is in the same virtio buffer as the corresponding SCMI > +command. The response contains the return values which SCMI specifies > +for each command, whether synchronous or asynchronous. Delayed responses > +are distinct SCMI messages transmitted over the eventq. > + > +Buffers in the cmdq contain both the request and the response. A request > +has the following layout: > + > +\begin{lstlisting} > +struct virtio_scmi_request { > + le32 hdr; > + u8 params[]; > +}; > +\end{lstlisting} > + > +The virtio_scmi_request fields are interpreted as follows: > + > +\begin{description} > +\item[\field{hdr}] (device-readable) contains the SCMI message header > +\item[\field{params}] (device-readable) comprises the SCMI message > +parameters > +\end{description} > + > +A cmdq response has the following layout: > + > +\begin{lstlisting} > +struct virtio_scmi_response { > + le32 hdr; > + u8 ret_values[]; > +}; > +\end{lstlisting} > + > +The virtio_scmi_response fields are interpreted as follows: > + > +\begin{description} > +\item[\field{hdr}] (device-writable) contains the SCMI message header > +\item[\field{ret_values}] (device-writable) comprises the SCMI message > +return values > +\end{description} > + > +If VIRTIO_SCMI_F_P2A_CHANNELS was not negotiated, the device responds to > +SCMI commands as if no SCMI notifications or delayed responses were > +implemented. > + > +\devicenormative{\paragraph}{cmdq Operation}{Device Types / SCMI Device = / Device Operation / cmdq Operation} > + > +The device MAY process available commands out of order and in parallel. > + > +The device MUST process all available commands eventually, even in the > +case of bursts of multiple command messages. > + > +If the \field{status} field in the \field{virtio_scmi_response} > +\field{ret_values} has a value other than SUCCESS, the device MUST set > +the size of \field{ret_values} to the size of the \field{status} field. > + > +If the driver requests an SCMI notification or a delayed response and > +there are currently NOT enough available buffers in the eventq, the > +device SHOULD still return SCMI status code SUCCESS. > + > +If VIRTIO_SCMI_F_P2A_CHANNELS was not negotiated, the device MUST deny > +any request for an SCMI notification or a delayed response by returning > +SCMI status code NOT_SUPPORTED. > + > +If VIRTIO_SCMI_F_P2A_CHANNELS was not negotiated, the device MUST NOT > +indicate in the PROTOCOL_MESSAGE_ATTRIBUTES return values that any SCMI > +notification, or delayed response, is implemented. > + > +\drivernormative{\paragraph}{cmdq Operation}{Device Types / SCMI Device = / Device Operation / cmdq Operation} > + > +Before sending a command, the driver MUST wait for responses to all > +commands whose completion the driver considers prerequisites to > +executing the command. > + > +With every command message, the driver MUST provide enough > +device-writable memory to enable the device to return corresponding > +return values. > + > +If VIRTIO_SCMI_F_P2A_CHANNELS was not negotiated, the driver MUST NOT > +request any SCMI notification, nor any delayed response. > + > +\subsubsection{Setting Up eventq Buffers} > + > +The driver has to populate the eventq before the device can use it. > + > +\drivernormative{\paragraph}{Setting Up eventq Buffers}{Device Types / S= CMI Device / Device Operation / Setting Up eventq Buffers} > + > +If VIRTIO_SCMI_F_P2A_CHANNELS was negotiated, the driver SHOULD populate > +the eventq with buffers. > + > +The driver MUST NOT put device-readable descriptors into the eventq. > + > +The driver MUST NOT put into the eventq any buffer which is smaller than > +the largest SCMI P2A (platform to agent) message which the driver will > +request. > + > +\subsubsection{eventq Operation} > + > +Each buffer in the eventq holds (once the buffer is marked as used) > +either a single SCMI notification, or a single SCMI delayed response. An > +arbitrary number of such SCMI messages can be in transit at the same > +time. Conceptually, each SCMI message transmitted over the eventq uses > +its own SCMI P2A (platform to agent) channel. Buffers in the eventq have > +the following layout: > + > +\begin{lstlisting} > +struct virtio_scmi_event_msg { > + /* start of device-writable data */ > + le32 hdr; > + u8 payload[]; > +}; > +\end{lstlisting} > + > +\begin{description} > +\item[\field{hdr}] (device-writable) contains the SCMI message header > +\item[\field{payload}] (device-writable) comprises the SCMI message > +payload > +\end{description} > + > +\devicenormative{\paragraph}{eventq Operation}{Device Types / SCMI Devic= e / Device Operation / eventq Operation} > + > +If the device intends to send a notification and there are no available > +buffers in the eventq, the device MAY drop the notification, or send a > +corresponding notification later, once enough buffers become available. > + > +The device MAY send the notification later if the events which cause the > +notification take place in quick succession. > + > +If the device sends the notification later, the device MAY send the > +notification with updated data, unless the specific SCMI protocol > +disallows this. > + > +If the device intends to send a notification and there are available > +buffers, but one of the buffers is too small to fit the notification, > +the device MAY omit the notification. > + > +If the device intends to send a delayed response and there are no > +available buffers in the eventq, the device MUST send the corresponding > +delayed response once enough buffers become available. > + > +If the \field{status} field in a delayed response \field{payload} has a > +value other than SUCCESS, the device MUST set the size of > +\field{payload} to the size of the \field{status} field. > + > +\subsubsection{Shared Memory Operation} > + > +Various SCMI protocols define statistics shared memory regions (for > +statistics and sensor values). > + > +\devicenormative{\paragraph}{Shared Memory Operation}{Device Types / SCM= I Device / Device Operation / Shared Memory Operation} > + > +If VIRTIO_SCMI_F_SHARED_MEMORY was negotiated, the device MAY implement > +an SCMI statistics shared memory region using a virtio shared memory > +region. > + > +If the device implements a shared memory region, the device MUST assign > +the corresponding shmid as per the following table: > + > +\begin{tabular}{|l|l|} > +\hline > +SCMI statistics shared memory region & Virtio shmid \\ > +\hline \hline > +Reserved (invalid) & 0 \\ > +\hline > +Power state statistics shared memory region & 1 \\ > +\hline > +Performance domain statistics shared memory region & 2 \\ > +\hline > +Sensor Values Shared Memory & 3 \\ > +\hline > +Reserved for future use & 4 to 0x7F \\ > +\hline > +Vendor-specific statistics shared memory regions & 0x80 to 0xFF \\ > +\hline > +Reserved for future use & 0x100 and greater \\ > +\hline > +\end{tabular} >=20 > base-commit: f5fd3fca7e4006108b3f9ba91c0b76c5eb6c0726 >=20 This publicly archived list offers a means to provide input to the OASIS Virtual I/O Device (VIRTIO) TC. In order to verify user consent to the Feedback License terms and to minimize spam in the list archive, subscription is required before posting. Subscribe: virtio-comment-subscribe@lists.oasis-open.org Unsubscribe: virtio-comment-unsubscribe@lists.oasis-open.org List help: virtio-comment-help@lists.oasis-open.org List archive: https://lists.oasis-open.org/archives/virtio-comment/ Feedback License: https://www.oasis-open.org/who/ipr/feedback_license.pdf List Guidelines: https://www.oasis-open.org/policies-guidelines/mailing-lis= ts Committee: https://www.oasis-open.org/committees/virtio/ Join OASIS: https://www.oasis-open.org/join/