From patchwork Mon Feb 24 14:41:12 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11400683 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id E9AC4924 for ; Mon, 24 Feb 2020 14:42:30 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 C3B3B2084E for ; Mon, 24 Feb 2020 14:42:30 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="kX0t9SHZ" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C3B3B2084E Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=S+IVo1sgMM3nUvqpjeDNuM844dnWH0Ab5aI7NBI5ogM=; b=kX0t9SHZkLI6aFO8pap7Dy/u60 F1JwBn2KTJaNFkBCBzIr51s99fHcyf5yz0mw2lddlmXwU3SPby8f52zqLIeLGEeJHJeqPmC5biziI duv3HbT2UyTjGkbvVWXSEXCq8haBstiUM3e7fy0Zh2f8kldMNOSkAB0irZ2VlVa9XRk/5GPE/NHhi XklZyIniO0L9Tp11gAXHv/EcJcsR+JHl1ckR7qPBztVWuD/NnL2bpF+XdK4WFesJxFAHAYWoCYEUI 3c9qS2k/oAA7dJb+EnxIHxQnnCndCW3LIE5k1ADQACZUpO2mRbRl3XhJAD8hDEfsLFvc22ydmMGr+ peYyooEA==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6EwI-0003Nq-2w; Mon, 24 Feb 2020 14:42:30 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Evv-00036A-VF for linux-arm-kernel@lists.infradead.org; Mon, 24 Feb 2020 14:42:09 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 8939D31B; Mon, 24 Feb 2020 06:42:07 -0800 (PST) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 8A6323F534; Mon, 24 Feb 2020 06:42:06 -0800 (PST) From: Cristian Marussi To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [RFC PATCH v3 01/13] firmware: arm_scmi: Add receive buffer support for notifications Date: Mon, 24 Feb 2020 14:41:12 +0000 Message-Id: <20200224144124.2008-2-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200224144124.2008-1-cristian.marussi@arm.com> References: <20200224144124.2008-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200224_064208_088828_1C998C0B X-CRM114-Status: GOOD ( 13.69 ) X-Spam-Score: -2.3 (--) X-Spam-Report: SpamAssassin version 3.4.3 on bombadil.infradead.org summary: Content analysis details: (-2.3 points) pts rule name description ---- ---------------------- -------------------------------------------------- -2.3 RCVD_IN_DNSWL_MED RBL: Sender listed at https://www.dnswl.org/, medium trust [217.140.110.172 listed in list.dnswl.org] 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jonathan.Cameron@Huawei.com, cristian.marussi@arm.com, james.quinlan@broadcom.com, lukasz.luba@arm.com, sudeep.holla@arm.com MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org From: Sudeep Holla With all the plumbing in place, let's just add the separate dedicated receive buffers to handle notifications that can arrive asynchronously from the platform firmware to OS. Also add one check to see if the platform supports any receive channels before allocating the receive buffers: since those buffers are optionally supported though, the whole xfer initialization is also postponed to be able to check for their existence in advance. Signed-off-by: Sudeep Holla [Changed parameters in __scmi_xfer_info_init()] Signed-off-by: Cristian Marussi Reviewed-by: Jonathan Cameron --- V1 --> V2: - reviewed commit message - reviewed parameters of __scmi_xfer_info_init() --- drivers/firmware/arm_scmi/driver.c | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/drivers/firmware/arm_scmi/driver.c b/drivers/firmware/arm_scmi/driver.c index dbec767222e9..efb660c34b57 100644 --- a/drivers/firmware/arm_scmi/driver.c +++ b/drivers/firmware/arm_scmi/driver.c @@ -76,6 +76,7 @@ struct scmi_xfers_info { * implementation version and (sub-)vendor identification. * @handle: Instance of SCMI handle to send to clients * @tx_minfo: Universal Transmit Message management info + * @rx_minfo: Universal Receive Message management info * @tx_idr: IDR object to map protocol id to Tx channel info pointer * @rx_idr: IDR object to map protocol id to Rx channel info pointer * @protocols_imp: List of protocols implemented, currently maximum of @@ -89,6 +90,7 @@ struct scmi_info { struct scmi_revision_info version; struct scmi_handle handle; struct scmi_xfers_info tx_minfo; + struct scmi_xfers_info rx_minfo; struct idr tx_idr; struct idr rx_idr; u8 *protocols_imp; @@ -525,13 +527,13 @@ int scmi_handle_put(const struct scmi_handle *handle) return 0; } -static int scmi_xfer_info_init(struct scmi_info *sinfo) +static int __scmi_xfer_info_init(struct scmi_info *sinfo, + struct scmi_xfers_info *info) { int i; struct scmi_xfer *xfer; struct device *dev = sinfo->dev; const struct scmi_desc *desc = sinfo->desc; - struct scmi_xfers_info *info = &sinfo->tx_minfo; /* Pre-allocated messages, no more than what hdr.seq can support */ if (WARN_ON(desc->max_msg >= MSG_TOKEN_MAX)) { @@ -566,6 +568,16 @@ static int scmi_xfer_info_init(struct scmi_info *sinfo) return 0; } +static int scmi_xfer_info_init(struct scmi_info *sinfo) +{ + int ret = __scmi_xfer_info_init(sinfo, &sinfo->tx_minfo); + + if (!ret && idr_find(&sinfo->rx_idr, SCMI_PROTOCOL_BASE)) + ret = __scmi_xfer_info_init(sinfo, &sinfo->rx_minfo); + + return ret; +} + static int scmi_chan_setup(struct scmi_info *info, struct device *dev, int prot_id, bool tx) { @@ -699,10 +711,6 @@ static int scmi_probe(struct platform_device *pdev) info->desc = desc; INIT_LIST_HEAD(&info->node); - ret = scmi_xfer_info_init(info); - if (ret) - return ret; - platform_set_drvdata(pdev, info); idr_init(&info->tx_idr); idr_init(&info->rx_idr); @@ -715,6 +723,10 @@ static int scmi_probe(struct platform_device *pdev) if (ret) return ret; + ret = scmi_xfer_info_init(info); + if (ret) + return ret; + ret = scmi_base_protocol_init(handle); if (ret) { dev_err(dev, "unable to communicate with SCMI(%d)\n", ret); From patchwork Mon Feb 24 14:41:13 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11400687 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 61AF7138D for ; Mon, 24 Feb 2020 14:42:52 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 39A2020828 for ; Mon, 24 Feb 2020 14:42:52 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="px4kRV8m" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 39A2020828 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=E5a9Wy5GS7IS6F5xi/UbMqj/dxfqV7Lm5eYXgTeDYVI=; b=px4kRV8mY8tmUmfcubLxwi1Fa5 2k/ow0fs+NMqV7AIBax9eML6PbhV1YAZQ1OXRKark/ZFPrIAJW4/zn6i7CXMKou+aJAZkWv9PdTfc v/f3eEmZjmFFeLgIn3l2k4/XVAacHd3//s9KkuCJGS1as1GaBHWYzwxkwuO9YTez0WcJoEkq617D9 JDa2Q0F1TBkdogrP/PGaZpb+mEGI2xGwnhUznL1N+O6nBBF37BMEk8XODaocd6Ggq5r2CkWr0CPU8 0J3IzFTOYXpwC0VkjO/2TfAQ7wkjJECjadTxnb+3t61oePVP5huXGCudaY6blmaGnmJRpPYTDImzZ MUcp58Aw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6EwZ-0003cX-F7; Mon, 24 Feb 2020 14:42:47 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Evx-00036Q-45 for linux-arm-kernel@lists.infradead.org; Mon, 24 Feb 2020 14:42:10 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id BB81A1063; Mon, 24 Feb 2020 06:42:08 -0800 (PST) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id BCB923F534; Mon, 24 Feb 2020 06:42:07 -0800 (PST) From: Cristian Marussi To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [RFC PATCH v3 02/13] firmware: arm_scmi: Update protocol commands and notification list Date: Mon, 24 Feb 2020 14:41:13 +0000 Message-Id: <20200224144124.2008-3-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200224144124.2008-1-cristian.marussi@arm.com> References: <20200224144124.2008-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200224_064209_221943_4B446A36 X-CRM114-Status: UNSURE ( 8.47 ) X-CRM114-Notice: Please train this message. X-Spam-Score: -2.3 (--) X-Spam-Report: SpamAssassin version 3.4.3 on bombadil.infradead.org summary: Content analysis details: (-2.3 points) pts rule name description ---- ---------------------- -------------------------------------------------- -2.3 RCVD_IN_DNSWL_MED RBL: Sender listed at https://www.dnswl.org/, medium trust [217.140.110.172 listed in list.dnswl.org] 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jonathan.Cameron@Huawei.com, cristian.marussi@arm.com, james.quinlan@broadcom.com, lukasz.luba@arm.com, sudeep.holla@arm.com MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org From: Sudeep Holla Add commands' enumerations and messages definitions for all existing notify-enable commands across all protocols. Signed-off-by: Sudeep Holla Signed-off-by: Cristian Marussi --- drivers/firmware/arm_scmi/base.c | 7 +++++++ drivers/firmware/arm_scmi/perf.c | 5 +++++ drivers/firmware/arm_scmi/power.c | 6 ++++++ drivers/firmware/arm_scmi/sensors.c | 4 ++++ 4 files changed, 22 insertions(+) diff --git a/drivers/firmware/arm_scmi/base.c b/drivers/firmware/arm_scmi/base.c index f804e8af6521..ce7d9203e41b 100644 --- a/drivers/firmware/arm_scmi/base.c +++ b/drivers/firmware/arm_scmi/base.c @@ -14,6 +14,13 @@ enum scmi_base_protocol_cmd { BASE_DISCOVER_LIST_PROTOCOLS = 0x6, BASE_DISCOVER_AGENT = 0x7, BASE_NOTIFY_ERRORS = 0x8, + BASE_SET_DEVICE_PERMISSIONS = 0x9, + BASE_SET_PROTOCOL_PERMISSIONS = 0xa, + BASE_RESET_AGENT_CONFIGURATION = 0xb, +}; + +enum scmi_base_protocol_notify { + BASE_ERROR_EVENT = 0x0, }; struct scmi_msg_resp_base_attributes { diff --git a/drivers/firmware/arm_scmi/perf.c b/drivers/firmware/arm_scmi/perf.c index ec81e6f7e7a4..88509ec637d0 100644 --- a/drivers/firmware/arm_scmi/perf.c +++ b/drivers/firmware/arm_scmi/perf.c @@ -27,6 +27,11 @@ enum scmi_performance_protocol_cmd { PERF_DESCRIBE_FASTCHANNEL = 0xb, }; +enum scmi_performance_protocol_notify { + PERFORMANCE_LIMITS_CHANGED = 0x0, + PERFORMANCE_LEVEL_CHANGED = 0x1, +}; + struct scmi_opp { u32 perf; u32 power; diff --git a/drivers/firmware/arm_scmi/power.c b/drivers/firmware/arm_scmi/power.c index 214886ce84f1..cf7f0312381b 100644 --- a/drivers/firmware/arm_scmi/power.c +++ b/drivers/firmware/arm_scmi/power.c @@ -12,6 +12,12 @@ enum scmi_power_protocol_cmd { POWER_STATE_SET = 0x4, POWER_STATE_GET = 0x5, POWER_STATE_NOTIFY = 0x6, + POWER_STATE_CHANGE_REQUESTED_NOTIFY = 0x7, +}; + +enum scmi_power_protocol_notify { + POWER_STATE_CHANGED = 0x0, + POWER_STATE_CHANGE_REQUESTED = 0x1, }; struct scmi_msg_resp_power_attributes { diff --git a/drivers/firmware/arm_scmi/sensors.c b/drivers/firmware/arm_scmi/sensors.c index eba61b9c1f53..db1b1ab303da 100644 --- a/drivers/firmware/arm_scmi/sensors.c +++ b/drivers/firmware/arm_scmi/sensors.c @@ -14,6 +14,10 @@ enum scmi_sensor_protocol_cmd { SENSOR_READING_GET = 0x6, }; +enum scmi_sensor_protocol_notify { + SENSOR_TRIP_POINT_EVENT = 0x0, +}; + struct scmi_msg_resp_sensor_attributes { __le16 num_sensors; u8 max_requests; From patchwork Mon Feb 24 14:41:14 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11400689 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 0C07C924 for ; Mon, 24 Feb 2020 14:43:08 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 DA93520828 for ; Mon, 24 Feb 2020 14:43:07 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="GxMieJsG" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org DA93520828 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=YEAnPZNZX+D12Xl1bLJuFqVHxTvSiG1nlpvWGrQki1o=; b=GxMieJsGsTTq957hYmhrnYfiip p9qV/mUQEqRQykCrHu0NC7v9d3FiIUS78IP2j7m2djBp7t0eCJzqUrHKrGzwX1O7iGWfAqOV5C1tt 7czYrpy/XfjLf5uZXtfexj1R8KAXjHiWaScDNWX4jFbRbyROcYFwPqQZFbMwKG63peuMHfh3Nnnpr BJIjpn7jobv8vlQmV2bn7b72xSxYqseryU3tAjjlOfcYxkLf3jWRmz+KXq0kAQRFp2Twj/wmHFMGB UqO0cN0vPYNauiPuqBQ9b5XghYTfFIdikU9qioXLz43QU2DPqvH6do/ac9pWGqdrmyh6AWWxsfWoA 0FA17xZg==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Ews-0003rW-Sb; Mon, 24 Feb 2020 14:43:06 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Evy-00036q-KF for linux-arm-kernel@lists.infradead.org; Mon, 24 Feb 2020 14:42:12 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id F0D68106F; Mon, 24 Feb 2020 06:42:09 -0800 (PST) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id EFB8A3F534; Mon, 24 Feb 2020 06:42:08 -0800 (PST) From: Cristian Marussi To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [RFC PATCH v3 03/13] firmware: arm_scmi: Add notifications support in transport layer Date: Mon, 24 Feb 2020 14:41:14 +0000 Message-Id: <20200224144124.2008-4-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200224144124.2008-1-cristian.marussi@arm.com> References: <20200224144124.2008-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200224_064210_758653_1068D03A X-CRM114-Status: GOOD ( 11.81 ) X-Spam-Score: -2.3 (--) X-Spam-Report: SpamAssassin version 3.4.3 on bombadil.infradead.org summary: Content analysis details: (-2.3 points) pts rule name description ---- ---------------------- -------------------------------------------------- -2.3 RCVD_IN_DNSWL_MED RBL: Sender listed at https://www.dnswl.org/, medium trust [217.140.110.172 listed in list.dnswl.org] 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jonathan.Cameron@Huawei.com, cristian.marussi@arm.com, james.quinlan@broadcom.com, lukasz.luba@arm.com, sudeep.holla@arm.com MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Add common transport-layer methods to: - fetch a notification instead of a response - clear a pending notification Add also all the needed support in mailbox/shmem transports. Reviewed-by: Viresh Kumar Signed-off-by: Cristian Marussi --- drivers/firmware/arm_scmi/common.h | 8 ++++++++ drivers/firmware/arm_scmi/mailbox.c | 17 +++++++++++++++++ drivers/firmware/arm_scmi/shmem.c | 15 +++++++++++++++ 3 files changed, 40 insertions(+) diff --git a/drivers/firmware/arm_scmi/common.h b/drivers/firmware/arm_scmi/common.h index 5ac06469b01c..3c2e5d0d7b68 100644 --- a/drivers/firmware/arm_scmi/common.h +++ b/drivers/firmware/arm_scmi/common.h @@ -178,6 +178,8 @@ struct scmi_chan_info { * @send_message: Callback to send a message * @mark_txdone: Callback to mark tx as done * @fetch_response: Callback to fetch response + * @fetch_notification: Callback to fetch notification + * @clear_notification: Callback to clear a pending notification * @poll_done: Callback to poll transfer status */ struct scmi_transport_ops { @@ -190,6 +192,9 @@ struct scmi_transport_ops { void (*mark_txdone)(struct scmi_chan_info *cinfo, int ret); void (*fetch_response)(struct scmi_chan_info *cinfo, struct scmi_xfer *xfer); + void (*fetch_notification)(struct scmi_chan_info *cinfo, + size_t max_len, struct scmi_xfer *xfer); + void (*clear_notification)(struct scmi_chan_info *cinfo); bool (*poll_done)(struct scmi_chan_info *cinfo, struct scmi_xfer *xfer); }; @@ -222,5 +227,8 @@ void shmem_tx_prepare(struct scmi_shared_mem __iomem *shmem, u32 shmem_read_header(struct scmi_shared_mem __iomem *shmem); void shmem_fetch_response(struct scmi_shared_mem __iomem *shmem, struct scmi_xfer *xfer); +void shmem_fetch_notification(struct scmi_shared_mem __iomem *shmem, + size_t max_len, struct scmi_xfer *xfer); +void shmem_clear_notification(struct scmi_shared_mem __iomem *shmem); bool shmem_poll_done(struct scmi_shared_mem __iomem *shmem, struct scmi_xfer *xfer); diff --git a/drivers/firmware/arm_scmi/mailbox.c b/drivers/firmware/arm_scmi/mailbox.c index 73077bbc4ad9..19ee058f9f44 100644 --- a/drivers/firmware/arm_scmi/mailbox.c +++ b/drivers/firmware/arm_scmi/mailbox.c @@ -158,6 +158,21 @@ static void mailbox_fetch_response(struct scmi_chan_info *cinfo, shmem_fetch_response(smbox->shmem, xfer); } +static void mailbox_fetch_notification(struct scmi_chan_info *cinfo, + size_t max_len, struct scmi_xfer *xfer) +{ + struct scmi_mailbox *smbox = cinfo->transport_info; + + shmem_fetch_notification(smbox->shmem, max_len, xfer); +} + +static void mailbox_clear_notification(struct scmi_chan_info *cinfo) +{ + struct scmi_mailbox *smbox = cinfo->transport_info; + + shmem_clear_notification(smbox->shmem); +} + static bool mailbox_poll_done(struct scmi_chan_info *cinfo, struct scmi_xfer *xfer) { @@ -173,6 +188,8 @@ static struct scmi_transport_ops scmi_mailbox_ops = { .send_message = mailbox_send_message, .mark_txdone = mailbox_mark_txdone, .fetch_response = mailbox_fetch_response, + .fetch_notification = mailbox_fetch_notification, + .clear_notification = mailbox_clear_notification, .poll_done = mailbox_poll_done, }; diff --git a/drivers/firmware/arm_scmi/shmem.c b/drivers/firmware/arm_scmi/shmem.c index ca0ffd302ea2..e1ab05be90e3 100644 --- a/drivers/firmware/arm_scmi/shmem.c +++ b/drivers/firmware/arm_scmi/shmem.c @@ -67,6 +67,21 @@ void shmem_fetch_response(struct scmi_shared_mem __iomem *shmem, memcpy_fromio(xfer->rx.buf, shmem->msg_payload + 4, xfer->rx.len); } +void shmem_fetch_notification(struct scmi_shared_mem __iomem *shmem, + size_t max_len, struct scmi_xfer *xfer) +{ + /* Skip only the length of header in shmem area i.e 4 bytes */ + xfer->rx.len = min_t(size_t, max_len, ioread32(&shmem->length) - 4); + + /* Take a copy to the rx buffer.. */ + memcpy_fromio(xfer->rx.buf, shmem->msg_payload, xfer->rx.len); +} + +void shmem_clear_notification(struct scmi_shared_mem __iomem *shmem) +{ + iowrite32(SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE, &shmem->channel_status); +} + bool shmem_poll_done(struct scmi_shared_mem __iomem *shmem, struct scmi_xfer *xfer) { From patchwork Mon Feb 24 14:41:15 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11400691 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id C4D8C138D for ; Mon, 24 Feb 2020 14:43:28 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 8D3A720828 for ; Mon, 24 Feb 2020 14:43:28 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="Zm6QBnHX" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8D3A720828 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=y8yita2hSDEii/2p5lCM4iLYuaRnfjEGW5Il0lYY6bU=; b=Zm6QBnHX3fpG4Qr8pBDbSxgUPN pEs/H1wPkd/4mRSGF1CMwHTilUwB7up6es7pugQ0iRDM2tvESZpLktNhcsKW1thQiKFeu8iEueUV+ dEg654nALi1qixrBeYtOzwLdb58ep0zcw5IFaEEEfrYxH8bMZONK8kZhHMT/d3e/n4MBRWCa2hEHC KNSpUwC7MiS73b3WaLNKU3QJyGn9KcvfGJNOFdEARUorJOTqRJ/7qb7U+4SpV91F9OmH83Vb2B9f2 xmvT1+f0/sBbumiRGsB8s5980MLrE3msVEGDV1haCX9V4R/eai8Y6xnsAqJaS/YStTH/o7JIfUAIb juLjsTVw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6ExC-00047z-FX; Mon, 24 Feb 2020 14:43:26 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Evz-000384-KI for linux-arm-kernel@lists.infradead.org; Mon, 24 Feb 2020 14:42:13 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 30112113E; Mon, 24 Feb 2020 06:42:11 -0800 (PST) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 305743F534; Mon, 24 Feb 2020 06:42:10 -0800 (PST) From: Cristian Marussi To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [RFC PATCH v3 04/13] firmware: arm_scmi: Add support for notifications message processing Date: Mon, 24 Feb 2020 14:41:15 +0000 Message-Id: <20200224144124.2008-5-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200224144124.2008-1-cristian.marussi@arm.com> References: <20200224144124.2008-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200224_064211_764266_3428C9B7 X-CRM114-Status: GOOD ( 12.61 ) X-Spam-Score: -2.3 (--) X-Spam-Report: SpamAssassin version 3.4.3 on bombadil.infradead.org summary: Content analysis details: (-2.3 points) pts rule name description ---- ---------------------- -------------------------------------------------- -2.3 RCVD_IN_DNSWL_MED RBL: Sender listed at https://www.dnswl.org/, medium trust [217.140.110.172 listed in list.dnswl.org] 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jonathan.Cameron@Huawei.com, cristian.marussi@arm.com, james.quinlan@broadcom.com, lukasz.luba@arm.com, sudeep.holla@arm.com MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org From: Sudeep Holla Add the mechanisms to distinguish notifications from delayed responses and to properly fetch notification messages upon reception: notifications processing does not continue further after the fetch phase. Signed-off-by: Sudeep Holla [Reworked/renamed scmi_handle_xfer_delayed_resp()] Signed-off-by: Cristian Marussi --- V1 --> V2 - switch the notif/delayed_resp message processing logic to use new transport independent layer methods - reviewed logic of scmi_handle_xfer_delayed_resp() while renaming it as scmi_handle_response() - properly relocated tracer points --- drivers/firmware/arm_scmi/driver.c | 84 +++++++++++++++++++++++------- 1 file changed, 64 insertions(+), 20 deletions(-) diff --git a/drivers/firmware/arm_scmi/driver.c b/drivers/firmware/arm_scmi/driver.c index efb660c34b57..868cc36a07c9 100644 --- a/drivers/firmware/arm_scmi/driver.c +++ b/drivers/firmware/arm_scmi/driver.c @@ -202,29 +202,42 @@ __scmi_xfer_put(struct scmi_xfers_info *minfo, struct scmi_xfer *xfer) spin_unlock_irqrestore(&minfo->xfer_lock, flags); } -/** - * scmi_rx_callback() - callback for receiving messages - * - * @cinfo: SCMI channel info - * @msg_hdr: Message header - * - * Processes one received message to appropriate transfer information and - * signals completion of the transfer. - * - * NOTE: This function will be invoked in IRQ context, hence should be - * as optimal as possible. - */ -void scmi_rx_callback(struct scmi_chan_info *cinfo, u32 msg_hdr) +static void scmi_handle_notification(struct scmi_chan_info *cinfo, u32 msg_hdr) { - struct scmi_info *info = handle_to_scmi_info(cinfo->handle); - struct scmi_xfers_info *minfo = &info->tx_minfo; - u16 xfer_id = MSG_XTRACT_TOKEN(msg_hdr); - u8 msg_type = MSG_XTRACT_TYPE(msg_hdr); - struct device *dev = cinfo->dev; struct scmi_xfer *xfer; + struct device *dev = cinfo->dev; + struct scmi_info *info = handle_to_scmi_info(cinfo->handle); + struct scmi_xfers_info *minfo = &info->rx_minfo; + + xfer = scmi_xfer_get(cinfo->handle, minfo); + if (IS_ERR(xfer)) { + dev_err(dev, "failed to get free message slot (%ld)\n", + PTR_ERR(xfer)); + info->desc->ops->clear_notification(cinfo); + return; + } + + unpack_scmi_header(msg_hdr, &xfer->hdr); + scmi_dump_header_dbg(dev, &xfer->hdr); + info->desc->ops->fetch_notification(cinfo, info->desc->max_msg_size, + xfer); + + trace_scmi_rx_done(xfer->transfer_id, xfer->hdr.id, + xfer->hdr.protocol_id, xfer->hdr.seq, + MSG_TYPE_NOTIFICATION); - if (msg_type == MSG_TYPE_NOTIFICATION) - return; /* Notifications not yet supported */ + __scmi_xfer_put(minfo, xfer); + + info->desc->ops->clear_notification(cinfo); +} + +static void scmi_handle_response(struct scmi_chan_info *cinfo, + u16 xfer_id, u8 msg_type) +{ + struct scmi_xfer *xfer; + struct device *dev = cinfo->dev; + struct scmi_info *info = handle_to_scmi_info(cinfo->handle); + struct scmi_xfers_info *minfo = &info->tx_minfo; /* Are we even expecting this? */ if (!test_bit(xfer_id, minfo->xfer_alloc_table)) { @@ -248,6 +261,37 @@ void scmi_rx_callback(struct scmi_chan_info *cinfo, u32 msg_hdr) complete(&xfer->done); } +/** + * scmi_rx_callback() - callback for receiving messages + * + * @cinfo: SCMI channel info + * @msg_hdr: Message header + * + * Processes one received message to appropriate transfer information and + * signals completion of the transfer. + * + * NOTE: This function will be invoked in IRQ context, hence should be + * as optimal as possible. + */ +void scmi_rx_callback(struct scmi_chan_info *cinfo, u32 msg_hdr) +{ + u16 xfer_id = MSG_XTRACT_TOKEN(msg_hdr); + u8 msg_type = MSG_XTRACT_TYPE(msg_hdr); + + switch (msg_type) { + case MSG_TYPE_NOTIFICATION: + scmi_handle_notification(cinfo, msg_hdr); + break; + case MSG_TYPE_COMMAND: + case MSG_TYPE_DELAYED_RESP: + scmi_handle_response(cinfo, xfer_id, msg_type); + break; + default: + WARN_ONCE(1, "received unknown msg_type:%d\n", msg_type); + break; + } +} + /** * scmi_xfer_put() - Release a transmit message * From patchwork Mon Feb 24 14:41:16 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11400693 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 05952138D for ; Mon, 24 Feb 2020 14:43:43 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 D2F8020828 for ; Mon, 24 Feb 2020 14:43:42 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="WAh9TnBv" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D2F8020828 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=qKitc9B+fFSmgmC0JTc5NL7WF4Xe8/81jR1yexUSL6k=; b=WAh9TnBvev9QgDCo0QCfWjx0Cd 81pYQpF5KU03Hskj4oPXGWl76CG5Kd+julMZBE7xJwkZn6oBBOWSmi5Z6y+umA9DCGyHFAFJfWQGn zetWLSXN/5FAoGXzL5XYaDkzu5DHaAkkTMIjBHpbsN2rWGJ8JbMo92eZghVDxJUNdJoCwkt9Nqrqq kyywTpWaQZo9kZ6hSDC8XGchxIVR8rsg+n4208cKVYfajkPerwgOBS44vX6mO/L2XhfSF7piaj4pe 07YO8hZvVZMt//KXICyIdNcMdirEDj/uEmCx/ht/Ba2ZkKjDGJV8J6+UOFEXhHP2OnN28H4ygBBkK Ps4iM4OA==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6ExR-0004Ju-75; Mon, 24 Feb 2020 14:43:41 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Ew0-00036q-O1 for linux-arm-kernel@lists.infradead.org; Mon, 24 Feb 2020 14:42:15 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 7D17311B3; Mon, 24 Feb 2020 06:42:12 -0800 (PST) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 636DD3F534; Mon, 24 Feb 2020 06:42:11 -0800 (PST) From: Cristian Marussi To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [RFC PATCH v3 05/13] firmware: arm_scmi: Add notification protocol-registration Date: Mon, 24 Feb 2020 14:41:16 +0000 Message-Id: <20200224144124.2008-6-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200224144124.2008-1-cristian.marussi@arm.com> References: <20200224144124.2008-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200224_064212_908710_4CCB715A X-CRM114-Status: GOOD ( 24.73 ) X-Spam-Score: -2.3 (--) X-Spam-Report: SpamAssassin version 3.4.3 on bombadil.infradead.org summary: Content analysis details: (-2.3 points) pts rule name description ---- ---------------------- -------------------------------------------------- -2.3 RCVD_IN_DNSWL_MED RBL: Sender listed at https://www.dnswl.org/, medium trust [217.140.110.172 listed in list.dnswl.org] 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jonathan.Cameron@Huawei.com, cristian.marussi@arm.com, james.quinlan@broadcom.com, lukasz.luba@arm.com, sudeep.holla@arm.com MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Add core SCMI Notifications protocol-registration support: allow protocols to register their own set of supported events, during their initialization phase. Notification core can track multiple platform instances. Signed-off-by: Cristian Marussi --- V2 --> V3 - added scmi_notify_instance to track target platform instance V1 --> V2 - splitted out of V1 patch 04 - moved from IDR maps to real HashTables to store events - scmi_notifications_initialized is now an atomic_t - reviewed protocol registration/unregistration to use devres - fixed: drivers/firmware/arm_scmi/notify.c:483:18-23: ERROR: reference preceded by free on line 482 Reported-by: kbuild test robot Reported-by: Julia Lawall --- drivers/firmware/arm_scmi/Makefile | 2 +- drivers/firmware/arm_scmi/common.h | 4 + drivers/firmware/arm_scmi/notify.c | 497 +++++++++++++++++++++++++++++ drivers/firmware/arm_scmi/notify.h | 59 ++++ include/linux/scmi_protocol.h | 9 + 5 files changed, 570 insertions(+), 1 deletion(-) create mode 100644 drivers/firmware/arm_scmi/notify.c create mode 100644 drivers/firmware/arm_scmi/notify.h diff --git a/drivers/firmware/arm_scmi/Makefile b/drivers/firmware/arm_scmi/Makefile index 6694d0d908d6..24a03a36aee4 100644 --- a/drivers/firmware/arm_scmi/Makefile +++ b/drivers/firmware/arm_scmi/Makefile @@ -1,7 +1,7 @@ # SPDX-License-Identifier: GPL-2.0-only obj-y = scmi-bus.o scmi-driver.o scmi-protocols.o scmi-transport.o scmi-bus-y = bus.o -scmi-driver-y = driver.o +scmi-driver-y = driver.o notify.o scmi-transport-y = mailbox.o shmem.o scmi-protocols-y = base.o clock.o perf.o power.o reset.o sensors.o obj-$(CONFIG_ARM_SCMI_POWER_DOMAIN) += scmi_pm_domain.o diff --git a/drivers/firmware/arm_scmi/common.h b/drivers/firmware/arm_scmi/common.h index 3c2e5d0d7b68..2106c35195ce 100644 --- a/drivers/firmware/arm_scmi/common.h +++ b/drivers/firmware/arm_scmi/common.h @@ -6,6 +6,8 @@ * * Copyright (C) 2018 ARM Ltd. */ +#ifndef _SCMI_COMMON_H +#define _SCMI_COMMON_H #include #include @@ -232,3 +234,5 @@ void shmem_fetch_notification(struct scmi_shared_mem __iomem *shmem, void shmem_clear_notification(struct scmi_shared_mem __iomem *shmem); bool shmem_poll_done(struct scmi_shared_mem __iomem *shmem, struct scmi_xfer *xfer); + +#endif /* _SCMI_COMMON_H */ diff --git a/drivers/firmware/arm_scmi/notify.c b/drivers/firmware/arm_scmi/notify.c new file mode 100644 index 000000000000..f032c4e9fd89 --- /dev/null +++ b/drivers/firmware/arm_scmi/notify.c @@ -0,0 +1,497 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * System Control and Management Interface (SCMI) Notification support + * + * Copyright (C) 2019 ARM Ltd. + * + * SCMI Protocol specification allows the platform to signal events to + * interested agents via notification messages: this is an implementation + * of the dispatch and delivery of such notifications to the interested users + * inside the Linux kernel. + * + * An SCMI Notification core instance is initialized for each active platform + * instance identified by the means of the usual @scmi_handle. + * + * Each SCMI Protocol implementation, during its initialization, registers with + * this core its set of supported events using @scmi_register_protocol_events(): + * all the needed descriptors are stored in the @registered_protocols and + * @registered_events hashtables. + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "notify.h" + +#define SCMI_ALL_SRC_IDS 0xffffUL +/* + * Builds an unsigned 32bit key from the given input tuple to be used + * as a key in hashtables. + */ +#define MAKE_HASH_KEY(p, e, s) \ + ((u32)(((p) << 24) | ((e) << 16) | ((s) & SCMI_ALL_SRC_IDS))) + +#define MAKE_PROTO_KEY(p) \ + MAKE_HASH_KEY((p), 0, SCMI_ALL_SRC_IDS) + +#define MAKE_REVT_KEY(p, e) \ + MAKE_HASH_KEY((p), (e), SCMI_ALL_SRC_IDS) + +/** + * Assumes that the stored obj includes its own hash-key in a field named 'key': + * with this simplification this macro can be equally used for all the objects' + * types hashed by this implementation. + * + * @__ht: The hashtable name + * @__obj: A pointer to the object type to be retrieved from the hashtable; + * it will be used as a cursor while scanning the hastable and it will + * be possibly left as NULL when @__k is not found + * @__k: The key to search for + */ +#define KEY_FIND(__ht, __obj, __k) \ +({ \ + hash_for_each_possible((__ht), (__obj), hash, (__k)) \ + if (likely((__obj)->key == (__k))) \ + break; \ + __obj; \ +}) + +/** + * scmi_notify_instance - Represents an instance of the notification core + * + * Each platform instance, represented by a handle, has its own instance of + * the notification subsystem. + * + * @gid: GroupID used for devres + * @handle: A reference to the platform instance + * @initialized: A flag that indicates if the core resources have been allocated + * and protocols are allowed to register their supported events + * @disabled: A flag to indicate when event's handlers registration phase has + * completed and events can be enabled and start flowing + * @registered_protocols: An hashtable containing all protocol-level specific + * information related to events' handling + * @registered_events: An hashtable containing all events' descriptors + * registered by the protocols, together with their + * ancillary data + */ +struct scmi_notify_instance { + void *gid; + struct scmi_handle *handle; + atomic_t initialized; + atomic_t disabled; + + DECLARE_HASHTABLE(registered_protocols, 4); + DECLARE_HASHTABLE(registered_events, 5); +}; + +/** + * events_queue - Describes a queue and its associated worker + * + * Each protocol has its own dedicated events_queue descriptor. + * + * @sz: Size in bytes of the related kfifo + * @qbuf: Pre-allocated buffer of @sz bytes to be used by the kfifo + * @kfifo: A dedicated Kernel kfifo descriptor + */ +struct events_queue { + size_t sz; + u8 *qbuf; + struct kfifo kfifo; +}; + +/** + * scmi_registered_protocol_events_desc - Protocol Specific information + * + * All protocols that registers at least one event have their protocol-specific + * information stored here, together with the embedded allocated events_queue. + * These descriptors are stored in the @registered_protocols hashtable. + * + * @key: The used hashkey + * @id: Protocol ID + * @ops: Protocol specific and event-related operations + * @equeue: The embedded per-protocol events_queue + * @hash: The hlist_node used for collision handling + * @ni: A reference to the initialized instance descriptor + * @gid: The associated devres group id, for cleanup purposes + */ +struct scmi_registered_protocol_events_desc { + u32 key; + u8 id; + const struct scmi_protocol_event_ops *ops; + struct events_queue equeue; + struct hlist_node hash; + struct scmi_notify_instance *ni; + void *gid; +}; + +/** + * scmi_registered_event - Event Specific Information + * + * All registered events are represented by one of these structures. + * These descriptors are stored in the @registered_events hashtable. + * + * @key: The used hashkey + * @proto: A reference to the associated protocol descriptor + * @evt: A reference to the associated event descriptor (as provided at + * registration time) + * @scratch_isr: A pre-allocated buffer to be used as a scratch area by ISR + * @scratch_bh: A pre-allocated buffer to be used as a scratch area by the + * deferred worker + * @report: A pre-allocated buffer used by the deferred worker to fill a + * customized event report + * @hash: The hlist_node used for collision handling + * @num_sources: The number of possible sources for this event as stated at + * events' registration time + * @sources: A reference to a dynamically allocated array used to refcount the + * events' enable requests for all the existing sources + * @sources_mtx: A mutex to serialize the access to @sources + */ +struct scmi_registered_event { + u32 key; + struct scmi_registered_protocol_events_desc *proto; + const struct scmi_event *evt; + void *scratch_isr; + void *scratch_bh; + void *report; + struct hlist_node hash; + u32 num_sources; + refcount_t *sources; + struct mutex sources_mtx; +}; + +/** + * scmi_event_header - A utility header + * + * This header is prepended to each received event message payload before + * queueing it on the related events_queue: it carries ancillary information + * for the attached event message payload. + * + * @timestamp: The timestamp, in nanoseconds (boottime), which was associated + * to this event as soon as it entered the SCMI RX ISR + * @proto_id: Protocol ID + * @evt_id: Event ID (corresponds to the Event MsgID for this Protocol) + * @payld_sz: Effective size of the embedded message payload which follows + * @payld: A reference to the embedded event payload + */ +struct scmi_event_header { + u64 timestamp; + u8 proto_id; + u8 evt_id; + size_t payld_sz; + u8 payld[]; +} __packed; + +/** + * scmi_initialize_events_queue - Allocate/Initialize a kfifo buffer + * + * Allocate a buffer for the kfifo and initialize it. + * + * @ni: A reference to the notification instance to use + * @equeue: The events_queue to initialize + * @sz: Size of the kfifo buffer to allocate + * + * Return: 0 on Success + */ +static int scmi_initialize_events_queue(struct scmi_notify_instance *ni, + struct events_queue *equeue, size_t sz) +{ + int ret; + + equeue->qbuf = devm_kzalloc(ni->handle->dev, sz, GFP_KERNEL); + if (!equeue->qbuf) + return -ENOMEM; + equeue->sz = sz; + + ret = kfifo_init(&equeue->kfifo, equeue->qbuf, equeue->sz); + if (ret) + return ret; + + return 0; +} + +/** + * scmi_allocate_registered_protocol_desc - Allocate a registered protocol + * events' descriptor + * + * Descriptor is used to keep protocol specific information related to events + * handling for any protocol which has registered at least one event. + * + * @ni: A reference to the notification instance to use + * @gid: Devres group id to be stored + * @proto_id: Protocol ID + * @queue_sz: Size of the associated queue to allocate + * @ops: Pointer to a struct holding references to protocol specific helpers + * needed during events handling + */ +static struct scmi_registered_protocol_events_desc * +scmi_allocate_registered_protocol_desc(struct scmi_notify_instance *ni, + void *gid, u8 proto_id, size_t queue_sz, + const struct scmi_protocol_event_ops *ops) +{ + int ret; + struct scmi_registered_protocol_events_desc *pd; + u32 proto_key = MAKE_PROTO_KEY(proto_id); + + pd = KEY_FIND(ni->registered_protocols, pd, proto_key); + if (pd) + return pd; + + pd = devm_kzalloc(ni->handle->dev, sizeof(*pd), GFP_KERNEL); + if (!pd) + return ERR_PTR(-ENOMEM); + pd->key = proto_key; + pd->id = proto_id; + pd->ops = ops; + pd->ni = ni; + + ret = scmi_initialize_events_queue(ni, &pd->equeue, queue_sz); + if (ret) + return ERR_PTR(ret); + + hash_add(ni->registered_protocols, &pd->hash, pd->key); + + return pd; +} + +/** + * scmi_register_protocol_events - Register Protocol Events with the core + * + * Used by SCMI Protocols initialization code to register with the notification + * core the list of supported events and their descriptors: takes care to + * pre-allocate and store all needed descriptors, scratch buffers and event + * queues. + * + * @handle: The handle identifying the platform instance against which the + * the protocol's events are registered + * @proto_id: Protocol ID + * @queue_sz: Size in bytes of the associated queue to be allocated + * @ops: Protocol specific event-related operations + * @evt: Event descriptor array + * @num_events: Number of events in @evt array + * @num_sources: Number of possible sources for this protocol on this + * platform. + * + * Return: 0 on Success + */ +int scmi_register_protocol_events(const struct scmi_handle *handle, + u8 proto_id, size_t queue_sz, + const struct scmi_protocol_event_ops *ops, + const struct scmi_event *evt, int num_events, + int num_sources) +{ + int i; + void *gid; + struct scmi_registered_protocol_events_desc *pd; + struct scmi_notify_instance *ni = handle->notify_priv; + + if (!ops || !evt) + return -EINVAL; + /* Ensure atomic value is updated */ + smp_mb__before_atomic(); + if (unlikely(!ni || !atomic_read(&ni->initialized))) + return -EAGAIN; + + gid = devres_open_group(ni->handle->dev, NULL, GFP_KERNEL); + if (!gid) + return -ENOMEM; + + pd = scmi_allocate_registered_protocol_desc(ni, gid, proto_id, + queue_sz, ops); + if (IS_ERR(pd)) + goto err; + + for (i = 0; i < num_events; i++, evt++) { + struct scmi_registered_event *r_evt; + + r_evt = devm_kzalloc(ni->handle->dev, sizeof(*r_evt), + GFP_KERNEL); + if (!r_evt) + goto err; + r_evt->proto = pd; + r_evt->evt = evt; + + r_evt->sources = devm_kcalloc(ni->handle->dev, num_sources, + sizeof(refcount_t), GFP_KERNEL); + if (!r_evt->sources) + goto err; + r_evt->num_sources = num_sources; + mutex_init(&r_evt->sources_mtx); + + r_evt->scratch_isr = devm_kzalloc(ni->handle->dev, + sizeof(struct scmi_event_header) + + evt->max_payld_sz, GFP_KERNEL); + if (!r_evt->scratch_isr) + goto err; + + r_evt->scratch_bh = devm_kzalloc(ni->handle->dev, + evt->max_payld_sz, GFP_KERNEL); + if (!r_evt->scratch_bh) + goto err; + + r_evt->report = devm_kzalloc(ni->handle->dev, + evt->max_report_sz, GFP_KERNEL); + if (!r_evt->report) + goto err; + + r_evt->key = MAKE_REVT_KEY(r_evt->proto->id, + r_evt->evt->evt_id); + hash_add(ni->registered_events, &r_evt->hash, r_evt->key); + + pr_info("SCMI Notifications: registered event - key:%X\n", + r_evt->key); + } + devres_close_group(ni->handle->dev, NULL); + + return 0; + +err: + pr_warn("SCMI Notifications - Proto:%X - Registration Failed !\n", + proto_id); + devres_release_group(ni->handle->dev, NULL); + + return -ENOMEM; +} + +/** + * scmi_unregister_protocol_events - Unregister protocol-event resources + * + * Removes all registered events related to this protocol descriptor and + * frees all the underlying resources associated with this protocol devres + * group id. + * + * Assumes that the caller has already taken care to stop events dispatching + * and to flush the related queues. + * + * @handle: The handle identifying the platform instance against which the + * the protocol's events are unregistered + * @proto_id: The protocol to act upon + * + * Return: The number of released non-group resources + */ +int scmi_unregister_protocol_events(const struct scmi_handle *handle, + u8 proto_id) +{ + int bkt; + struct scmi_registered_event *r_evt; + struct scmi_registered_protocol_events_desc *pd; + struct scmi_notify_instance *ni = handle->notify_priv; + + if (unlikely(!ni || !atomic_read(&ni->initialized))) + return 0; + + pd = KEY_FIND(ni->registered_protocols, pd, MAKE_PROTO_KEY(proto_id)); + if (unlikely(!pd)) + return 0; + + /* + * Remove all registered events for this protocol and the + * protocol descriptor itself. + */ + hash_for_each(ni->registered_events, bkt, r_evt, hash) + if (r_evt->proto == pd) + hash_del(&r_evt->hash); + hash_del(&pd->hash); + + /* Free all underlying resources */ + return devres_release_group(ni->handle->dev, pd->gid); +} + +/** + * scmi_notification_init - Initializes Notification Core Support + * + * This function lays out all the basic resources needed by the notification + * core instance identified by this handle: once done, all SCMI Protocols can + * register their events with the core during their own initializations. + * + * Note that failing to initialize the core notifications support does not + * cause the whole SCMI Protocols stack to fail its initialization. + * + * SCMI Notification Initialization happens in 3 phases: + * + * - initialization: basic common allocations (this function) -> .initialized + * - registration: protocols asynchronously come into life and registers their + * own supported list of events with the core; this causes + * further per-protocol allocations. + * Notifications' dispatching remains globally .disabled till + * all defined and implemented protocols have been successfully + * initialized: this way access to @registered_events table + * needs not to be synchronized, which is critical since it's + * accessed heavily at dispatch time in interrupt context. + * Any user's callback registration attempt happening during + * this phase, if referring a still not initialized event, it's + * delayed till this phase completes. + * - enable: once all implemented protocols have completed their registration + * phase, (if any...refcounting on @pending_protocols), a completion + * is used to kick @init_work, which in turn finally processes and + * binds any pending handler: after that, notifications are finally + * enabled as a whole and dispatch and delivery of events can start. + * + * @handle: The handle identifying the platform instance to initialize + * + * Return: 0 on Success + */ +int scmi_notification_init(struct scmi_handle *handle) +{ + void *gid; + struct scmi_notify_instance *ni; + + gid = devres_open_group(handle->dev, NULL, GFP_KERNEL); + if (!gid) + return -ENOMEM; + + ni = devm_kzalloc(handle->dev, sizeof(*ni), GFP_KERNEL); + if (!ni) + goto err; + + ni->gid = gid; + ni->handle = handle; + + hash_init(ni->registered_protocols); + hash_init(ni->registered_events); + + handle->notify_priv = ni; + + atomic_set(&ni->disabled, 1); + atomic_set(&ni->initialized, 1); + /* Ensure atomic values are updated */ + smp_mb__after_atomic(); + + pr_info("SCMI Notifications Core Initializing.\n"); + + devres_close_group(handle->dev, NULL); + + return 0; + +err: + pr_warn("SCMI Notifications - Initialization Failed.\n"); + devres_release_group(handle->dev, NULL); + return -ENOMEM; +} + +/** + * scmi_notification_exit - Shutdown and clean Notification core + */ +void scmi_notification_exit(struct scmi_handle *handle) +{ + struct scmi_notify_instance *ni = handle->notify_priv; + + if (unlikely(!ni || !atomic_read(&ni->initialized))) + return; + + devres_release_group(ni->handle->dev, ni->gid); + + pr_info("SCMI Notifications Core Cleaned.\n"); +} diff --git a/drivers/firmware/arm_scmi/notify.h b/drivers/firmware/arm_scmi/notify.h new file mode 100644 index 000000000000..8de19a3b75ab --- /dev/null +++ b/drivers/firmware/arm_scmi/notify.h @@ -0,0 +1,59 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * System Control and Management Interface (SCMI) Message Protocol + * notification header file containing some definitions, structures + * and function prototypes related to SCMI Notification handling. + * + * Copyright (C) 2019 ARM Ltd. + */ +#ifndef _SCMI_NOTIFY_H +#define _SCMI_NOTIFY_H + +#include +#include + +/** + * scmi_event - Describes an event to be supported + * + * Each SCMI protocol, during its initialization phase, can describe the events + * it wishes to support in a few struct scmi_event and pass them to the core + * using scmi_register_protocol_events(). + * + * @evt_id: Event ID + * @max_payld_sz: Max possible size for the payload of a notif msg of this kind + * @max_report_sz: Max possible size for the report of a notif msg of this kind + */ +struct scmi_event { + u8 evt_id; + size_t max_payld_sz; + size_t max_report_sz; + +}; + +/** + * scmi_protocol_event_ops - Helpers called by notification core. + * + * These are called only in process context. + * + * @set_notify_enabled: Enable/disable the required evt_id/src_id notifications + * using the proper custom protocol commands. + * Return true if at least one the required src_id + * has been successfully enabled/disabled + */ +struct scmi_protocol_event_ops { + bool (*set_notify_enabled)(const struct scmi_handle *handle, + u8 evt_id, u32 src_id, bool enabled); +}; + +int scmi_notification_init(struct scmi_handle *handle); +void scmi_notification_exit(struct scmi_handle *handle); + +int scmi_register_protocol_events(const struct scmi_handle *handle, + u8 proto_id, size_t queue_sz, + const struct scmi_protocol_event_ops *ops, + const struct scmi_event *evt, int num_events, + int num_sources); +int scmi_unregister_protocol_events(const struct scmi_handle *handle, + u8 proto_id); + +#endif /* _SCMI_NOTIFY_H */ diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h index 5c873a59b387..0679f10ab05e 100644 --- a/include/linux/scmi_protocol.h +++ b/include/linux/scmi_protocol.h @@ -4,6 +4,10 @@ * * Copyright (C) 2018 ARM Ltd. */ + +#ifndef _LINUX_SCMI_PROTOCOL_H +#define _LINUX_SCMI_PROTOCOL_H + #include #include @@ -227,6 +231,8 @@ struct scmi_reset_ops { * protocol(for internal use only) * @reset_priv: pointer to private data structure specific to reset * protocol(for internal use only) + * @notify_priv: pointer to private data structure specific to notifications + * (for internal use only) */ struct scmi_handle { struct device *dev; @@ -242,6 +248,7 @@ struct scmi_handle { void *power_priv; void *sensor_priv; void *reset_priv; + void *notify_priv; }; enum scmi_std_protocol { @@ -319,3 +326,5 @@ static inline void scmi_driver_unregister(struct scmi_driver *driver) {} typedef int (*scmi_prot_init_fn_t)(struct scmi_handle *); int scmi_protocol_register(int protocol_id, scmi_prot_init_fn_t fn); void scmi_protocol_unregister(int protocol_id); + +#endif /* _LINUX_SCMI_PROTOCOL_H */ From patchwork Mon Feb 24 14:41:17 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11400697 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 8E303924 for ; Mon, 24 Feb 2020 14:43:55 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 5B8C020828 for ; Mon, 24 Feb 2020 14:43:55 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="TDPNRPHw" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 5B8C020828 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=QX1XDvdsOfhIlvL9bGP/b0CBdDZRd3RPUW7GV75Au3Y=; b=TDPNRPHwnt805V5zxHb4H0nvdN nTeQ8CAhDot7a0QcYaRZPrzKneqdil41PEYXTzeDqdb4UF620+PSkmZIP1XhNc3iIvV4e1nQQz5yb 2saLpiHgSJwbT1m38xurZKZPom3wYr0+F6stXtWEPFmSMTza0UQbDlekVu6//MC28ab4+gK0vzt9W qVlBF79//8x9c6dmak/+1hgc2AIzIkBuWvhzkEcGe0B7D7QBhT3CEwCj1biKYt95GL0XW4y2cvOz5 60zDZjBECf+2mfMmNawjdoTsblaldNyhOiznzjU35E0RhnI+Je2sDw1cFTESmP+BRhJE0FhJKEvGe +hv5WqjQ==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Exd-0004WM-OG; Mon, 24 Feb 2020 14:43:53 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Ew2-000384-3P for linux-arm-kernel@lists.infradead.org; Mon, 24 Feb 2020 14:42:17 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id CA25030E; Mon, 24 Feb 2020 06:42:13 -0800 (PST) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id B0B8C3F534; Mon, 24 Feb 2020 06:42:12 -0800 (PST) From: Cristian Marussi To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [RFC PATCH v3 06/13] firmware: arm_scmi: Add notification callbacks-registration Date: Mon, 24 Feb 2020 14:41:17 +0000 Message-Id: <20200224144124.2008-7-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200224144124.2008-1-cristian.marussi@arm.com> References: <20200224144124.2008-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200224_064214_451023_EBFFC0A6 X-CRM114-Status: GOOD ( 25.46 ) X-Spam-Score: -2.3 (--) X-Spam-Report: SpamAssassin version 3.4.3 on bombadil.infradead.org summary: Content analysis details: (-2.3 points) pts rule name description ---- ---------------------- -------------------------------------------------- -2.3 RCVD_IN_DNSWL_MED RBL: Sender listed at https://www.dnswl.org/, medium trust [217.140.110.172 listed in list.dnswl.org] 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jonathan.Cameron@Huawei.com, cristian.marussi@arm.com, james.quinlan@broadcom.com, lukasz.luba@arm.com, sudeep.holla@arm.com MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Add core SCMI Notifications callbacks-registration support: allow users to register their own callbacks against the desired events. Signed-off-by: Cristian Marussi --- V2 --> V3 - refactored get/put event_handler - removed generic non-handle-based API V1 --> V2 - splitted out of V1 patch 04 - moved from IDR maps to real HashTables to store event_handlers - added proper enable_events refcounting via __scmi_enable_evt() [was broken in V1 when using ALL_SRCIDs notification chains] - reviewed hashtable cleanup strategy in scmi_notifications_exit() - added scmi_register_event_notifier()/scmi_unregister_event_notifier() to include/linux/scmi_protocol.h as a candidate user API [no EXPORTs still] - added notify_ops to handle during initialization as an additional internal API for scmi_drivers --- drivers/firmware/arm_scmi/notify.c | 525 ++++++++++++++++++++++++++++- drivers/firmware/arm_scmi/notify.h | 13 + include/linux/scmi_protocol.h | 50 +++ 3 files changed, 586 insertions(+), 2 deletions(-) diff --git a/drivers/firmware/arm_scmi/notify.c b/drivers/firmware/arm_scmi/notify.c index f032c4e9fd89..5f95602ec13c 100644 --- a/drivers/firmware/arm_scmi/notify.c +++ b/drivers/firmware/arm_scmi/notify.c @@ -16,11 +16,39 @@ * this core its set of supported events using @scmi_register_protocol_events(): * all the needed descriptors are stored in the @registered_protocols and * @registered_events hashtables. + * + * Kernel users interested in some specific event can register their callbacks + * providing the usual notifier_block descriptor, since this core implements + * events' delivery using the standard Kernel notification chains machinery. + * + * Given the number of possible events defined by SCMI and the extensibility + * of the SCMI Protocol itself, the underlying notification chains are created + * and destroyed dynamically on demand depending on the number of users + * effectively registered for an event, so that no support structures or chains + * are allocated until at least one user has registered a notifier_block for + * such event. Similarly, events' generation itself is enabled at the platform + * level only after at least one user has registered, and it is shutdown after + * the last user for that event has gone. + * + * All users provided callbacks and allocated notification-chains are instead + * stored in the @registered_events_handlers hashtable. + * + * An event is identified univocally by the tuple (proto_id, evt_id, src_id) + * and is served by its own dedicated notification chain; information contained + * in such tuples is used, in a few different ways, to generate the needed + * hash-keys. + * + * Here proto_id and evt_id are simply the protocol_id and message_id numbers + * as described in the SCMI Protocol specification, while src_id represents an + * optional, protocol dependent, source identifier (like domain_id, perf_id + * or sensor_id and so forth). */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include +#include +#include #include #include #include @@ -28,11 +56,11 @@ #include #include #include +#include #include #include #include #include -#include #include "notify.h" @@ -69,6 +97,17 @@ __obj; \ }) +#define PROTO_ID_MASK GENMASK(31, 24) +#define EVT_ID_MASK GENMASK(23, 16) +#define SRC_ID_MASK GENMASK(15, 0) +#define KEY_XTRACT_PROTO_ID(key) FIELD_GET(PROTO_ID_MASK, (key)) +#define KEY_XTRACT_EVT_ID(key) FIELD_GET(EVT_ID_MASK, (key)) +#define KEY_XTRACT_SRC_ID(key) FIELD_GET(SRC_ID_MASK, (key)) + +/* A couple of utility macros to limit cruft when calling protocols' helpers */ +#define REVT_NOTIFY_ENABLE(revt, ...) \ + ((revt)->proto->ops->set_notify_enabled((revt)->proto->ni->handle, \ + __VA_ARGS__)) /** * scmi_notify_instance - Represents an instance of the notification core * @@ -81,11 +120,15 @@ * and protocols are allowed to register their supported events * @disabled: A flag to indicate when event's handlers registration phase has * completed and events can be enabled and start flowing + * @events_handlers_mtx: A mutex to protect @registered_events_handlers access * @registered_protocols: An hashtable containing all protocol-level specific * information related to events' handling * @registered_events: An hashtable containing all events' descriptors * registered by the protocols, together with their * ancillary data + * @registered_events_handlers: An hashtable containing all events' handlers + * descriptors, created to collect all the users' + * notifier_block callbacks and related chains */ struct scmi_notify_instance { void *gid; @@ -93,8 +136,10 @@ struct scmi_notify_instance { atomic_t initialized; atomic_t disabled; + struct mutex events_handlers_mtx; DECLARE_HASHTABLE(registered_protocols, 4); DECLARE_HASHTABLE(registered_events, 5); + DECLARE_HASHTABLE(registered_events_handlers, 8); }; /** @@ -172,6 +217,34 @@ struct scmi_registered_event { struct mutex sources_mtx; }; +/** + * scmi_event_handler - Event handler information + * + * This structure collects all the information needed to process a received + * event identified by the tuple (proto_id, evt_id, src_id) invoking all the + * currently registered users' callbacks. + * These descriptors are stored in the @registered_events_handlers table using + * as a key a value derived from that tuple. + * + * @key: The used hashkey + * @users: A reference count for number of active users for this handler + * @r_evt: A reference to the associated registered event + * @chain: The notification chain dedicated to this specific event tuple + * @hash: The hlist_node used for collision handling + * @deferred_enable: A flag to defer the enabling of events + * @enabled: A boolean which records if event's generation has been already + * enabled for this handler as a whole + */ +struct scmi_event_handler { + u32 key; + refcount_t users; + struct scmi_registered_event *r_evt; + struct blocking_notifier_head chain; + struct hlist_node hash; + bool deferred_enable; + bool enabled; +}; + /** * scmi_event_header - A utility header * @@ -194,10 +267,16 @@ struct scmi_event_header { u8 payld[]; } __packed; +static struct scmi_event_handler * +scmi_get_event_handler(struct scmi_notify_instance *ni, u32 evt_key); +static void scmi_put_event_handler(struct scmi_event_handler *hndl); +static void scmi_free_event_handler(struct scmi_event_handler *hndl); + /** * scmi_initialize_events_queue - Allocate/Initialize a kfifo buffer * - * Allocate a buffer for the kfifo and initialize it. + * Allocate a buffer for the kfifo and initialize it together with the + * associated work item. * * @ni: A reference to the notification instance to use * @equeue: The events_queue to initialize @@ -396,6 +475,25 @@ int scmi_unregister_protocol_events(const struct scmi_handle *handle, if (unlikely(!pd)) return 0; + mutex_lock(&ni->events_handlers_mtx); + if (!hash_empty(ni->registered_events_handlers)) { + struct scmi_event_handler *hndl; + + /* + * We should get here only after all users have unregistered + * their handlers using the API, if it's not the case clean up. + */ + hash_for_each(ni->registered_events_handlers, bkt, hndl, hash) { + if (hndl->r_evt->proto == pd) { + WARN_ONCE(1, + "SCMI Notifications: active users at exit protocol:%X\n", + pd->id); + scmi_free_event_handler(hndl); + } + } + } + mutex_unlock(&ni->events_handlers_mtx); + /* * Remove all registered events for this protocol and the * protocol descriptor itself. @@ -409,6 +507,426 @@ int scmi_unregister_protocol_events(const struct scmi_handle *handle, return devres_release_group(ni->handle->dev, pd->gid); } +/** + * scmi_allocate_event_handler - Allocate Event handler + * + * Allocate an event handler and related notification chain associated with + * the provided event handler key. + * Note that, at this point, a related registered_event is still to be + * associated to this handler descriptor (hndl->r_evt == NULL) + * + * @ni: A reference to the notification instance to use + * @evt_key: 32bit key uniquely bind to the event identified by the tuple + * (proto_id, evt_id, src_id) + * + * Return: the freshly allocated structure on Success + */ +static struct scmi_event_handler * +scmi_allocate_event_handler(struct scmi_notify_instance *ni, u32 evt_key) +{ + struct scmi_event_handler *hndl; + + hndl = kzalloc(sizeof(*hndl), GFP_KERNEL); + if (!hndl) + return ERR_PTR(-ENOMEM); + hndl->key = evt_key; + BLOCKING_INIT_NOTIFIER_HEAD(&hndl->chain); + refcount_set(&hndl->users, 1); + + return hndl; +} + +/** + * scmi_bind_event_handler - Bind an handler to the associated registered + * event + * + * Search for the related registered_event to bind; if no registered event could + * be found and @allow_delayed is true, just carry on: binding will be retried + * again later once protocols' registration has completed. + * + * @ni: A reference to the notification instance to use + * @hndl: The event handler to bind + * @allow_delayed: A boolean to indicate if registration can be deferred to the + * @init_work worker in case no existent registered_event could + * be found for this hndl->key. + * + * Return: 0 on Success + */ +static int scmi_bind_event_handler(struct scmi_notify_instance *ni, + struct scmi_event_handler *hndl, + bool allow_delayed) +{ + u8 proto_id, evt_id; + struct scmi_registered_event *r_evt; + + proto_id = KEY_XTRACT_PROTO_ID(hndl->key); + evt_id = KEY_XTRACT_EVT_ID(hndl->key); + r_evt = KEY_FIND(ni->registered_events, r_evt, + MAKE_REVT_KEY(proto_id, evt_id)); + + if (!r_evt && !allow_delayed) + return -EINVAL; + + if (likely(r_evt)) + hndl->r_evt = r_evt; + /* Delay enabling events anyway if allowing delayed binding */ + hndl->deferred_enable = allow_delayed; + + return 0; +} + +/** + * scmi_register_event_handler - Register whenever possible an Event handler + * + * This routine tries to bind an event handler to its associated event and, on + * a successful binding, registers the handler amongst + * @registered_events_handlers. + * + * It can happen that NO such related registered event could be found: this can + * be caused not only by errors (due to registrations attempts made with wrong + * proto_id/evt_id tuple values), but also simply because the related event has + * still not been registered since initialization was still in progress when a + * user requested this handler registration. + * Pending incomplete bindings will be retried later by a dedicated worker once + * the initialization has completed for all protocols. + * + * @ni: A reference to the notification instance to use + * @hndl: The event handler to register + * @allow_delayed: A boolean to indicate if registration can be deferred to the + * @init_work worker in case no existent registered_event could + * be found for this hndl->key. + * + * Return: 0 on Success + */ +static int scmi_register_event_handler(struct scmi_notify_instance *ni, + struct scmi_event_handler *hndl, + bool allow_delayed) +{ + int ret = 0; + + ret = scmi_bind_event_handler(ni, hndl, allow_delayed); + if (ret) + return ret; + + /* Register freshly allocated event handler */ + hash_add(ni->registered_events_handlers, &hndl->hash, hndl->key); + + return 0; +} + +/** + * scmi_free_event_handler - Free the provided Event handler + * + * @hndl: The event handler structure to free + */ +static void scmi_free_event_handler(struct scmi_event_handler *hndl) +{ + hash_del(&hndl->hash); + kfree(hndl); +} + +/** + * __scmi_event_handler_get_ops - Utility to get or create an event handler + * + * After having got exclusive access to the registered events hashtable, + * search for the desired handler matching the key: + * - if found adjust users refcount + * - if not found and @create is true, create and register the new handler: + * registration can be @allow_delayed if core is still disabled, since not + * all protocols have completed registration. + * + * Events generation is NOT enabled on create within this routine since at + * creation time we usually want to have all setup and registered before events + * really start flowing. + * + * @ni: A reference to the notification instance to use + * @evt_key: The event key to use + * @create: A boolean flag to specify if a handler must be created when + * not already existent + * + * Return: the freshly allocated structure on Success + */ +static inline struct scmi_event_handler * +__scmi_event_handler_get_ops(struct scmi_notify_instance *ni, + u32 evt_key, bool create) +{ + bool allow_delayed; + struct scmi_event_handler *hndl = NULL; + + mutex_lock(&ni->events_handlers_mtx); + + /* Ensure atomic value is updated */ + smp_mb__before_atomic(); + allow_delayed = atomic_read(&ni->disabled); + + hndl = KEY_FIND(ni->registered_events_handlers, hndl, evt_key); + if (likely(hndl)) { + refcount_inc(&hndl->users); + } else if (create) { + hndl = scmi_allocate_event_handler(ni, evt_key); + if (!IS_ERR_OR_NULL(hndl)) { + int ret; + + ret = scmi_register_event_handler(ni, hndl, + allow_delayed); + if (ret) { + scmi_free_event_handler(hndl); + hndl = ERR_PTR(ret); + } + } + } + mutex_unlock(&ni->events_handlers_mtx); + + return hndl; +} + +static struct scmi_event_handler * +scmi_get_event_handler(struct scmi_notify_instance *ni, u32 evt_key) +{ + return __scmi_event_handler_get_ops(ni, evt_key, false); +} + +static struct scmi_event_handler * +scmi_get_or_create_event_handler(struct scmi_notify_instance *ni, u32 evt_key) +{ + return __scmi_event_handler_get_ops(ni, evt_key, true); +} + +/** + * __scmi_enable_evt - Enable/disable events generation + * + * Takes care of proper refcounting while performing enable/disable: + * handles the special case of ALL sources requests by itself. + * + * @r_evt: The registered event to act upon + * @src_id: The src_id to act upon + * @enable: The action to perform: true->Enable, false->Disable + * + * Return: True when the required @action has been successfully executed + */ +static inline bool __scmi_enable_evt(struct scmi_registered_event *r_evt, + u32 src_id, bool enable) +{ + int ret = 0; + u32 num_sources; + refcount_t *sid; + + if (src_id == SCMI_ALL_SRC_IDS) { + src_id = 0; + num_sources = r_evt->num_sources; + } else if (src_id < r_evt->num_sources) { + num_sources = 1; + } else { + return ret; + } + + mutex_lock(&r_evt->sources_mtx); + if (enable) { + for (; num_sources; src_id++, num_sources--) { + bool r; + + sid = &r_evt->sources[src_id]; + if (refcount_read(sid) == 0) { + r = REVT_NOTIFY_ENABLE(r_evt, + r_evt->evt->evt_id, + src_id, enable); + if (r) + refcount_set(sid, 1); + } else { + refcount_inc(sid); + r = true; + } + ret += r; + } + } else { + for (; num_sources; src_id++, num_sources--) { + sid = &r_evt->sources[src_id]; + if (refcount_dec_and_test(sid)) + REVT_NOTIFY_ENABLE(r_evt, + r_evt->evt->evt_id, + src_id, enable); + } + ret = 1; + } + mutex_unlock(&r_evt->sources_mtx); + + return ret; +} + +static bool scmi_enable_events(struct scmi_event_handler *hndl) +{ + if (!hndl->enabled) + hndl->enabled = __scmi_enable_evt(hndl->r_evt, + KEY_XTRACT_SRC_ID(hndl->key), + true); + return hndl->enabled; +} + +static bool scmi_disable_events(struct scmi_event_handler *hndl) +{ + if (hndl->enabled) + hndl->enabled = !__scmi_enable_evt(hndl->r_evt, + KEY_XTRACT_SRC_ID(hndl->key), + false); + return !hndl->enabled; +} + +/** + * scmi_put_event_handler - Put an event handler + * + * After having got exclusive access to the registered events hashtable, update + * the refcount and if @hndl is no more in use by anyone: + * + * - ask for events' generation disabling + * - unregister and free the handler itself + * + * @hndl: The event handler to act upon + */ +static void scmi_put_event_handler(struct scmi_event_handler *hndl) +{ + mutex_lock(&((hndl)->r_evt->proto->ni->events_handlers_mtx)); + if (refcount_dec_and_test(&hndl->users)) { + scmi_disable_events(hndl); + scmi_free_event_handler(hndl); + } + mutex_unlock(&((hndl)->r_evt->proto->ni->events_handlers_mtx)); +} + +/** + * scmi_event_handler_enable_events - Enable events associated to an handler + * + * @hndl: The Event handler to act upon + * + * Return: 0 on success + */ +static int scmi_event_handler_enable_events(struct scmi_event_handler *hndl) +{ + if (!scmi_enable_events(hndl)) { + pr_err("SCMI Notifications: Failed to ENABLE events for key:%X !\n", + hndl->key); + return -EINVAL; + } + + return 0; +} + +/** + * scmi_register_notifier - Register a notifier_block for an event + * + * Generic helper to register a notifier_block against a protocol event. + * + * A notifier_block @nb will be registered for each distinct event identified + * by the tuple (proto_id, evt_id, src_id) on a dedicated notification chain + * so that: + * + * (proto_X, evt_Y, src_Z) --> chain_X_Y_Z + * + * @src_id meaning is protocol specific and identifies the origin of the event + * (like domain_id, sensor_id and os forth). + * + * @src_id can be NULL to signify that the caller is interested in receiving + * notifications from ALL the available sources for that protocol OR simply that + * the protocol does not support distinct sources. + * + * As soon as one user for the specified tuple appears, an handler is created, + * and that specific event's generation is enabled at the platform level, unless + * @deferred_enabled is found true, meaning that the core is still initializing + * and the just registered handler is still pending: we do not want to enable + * event's generation for pending handlers since they will be discarded. + * + * @handle: The handle identifying the platform instance against which the + * callback is registered + * @proto_id: Protocol ID + * @evt_id: Event ID + * @src_id: Source ID, when NULL register for events coming form ALL possible + * sources + * @nb: A standard notifier block to register for the specified event + * + * Return: Return 0 on Success + */ +static int scmi_register_notifier(const struct scmi_handle *handle, + u8 proto_id, u8 evt_id, u32 *src_id, + struct notifier_block *nb) +{ + int ret = 0; + u32 evt_key; + struct scmi_event_handler *hndl; + struct scmi_notify_instance *ni = handle->notify_priv; + + evt_key = MAKE_HASH_KEY(proto_id, evt_id, + src_id ? *src_id : SCMI_ALL_SRC_IDS); + hndl = scmi_get_or_create_event_handler(ni, evt_key); + if (IS_ERR_OR_NULL(hndl)) + return PTR_ERR(hndl); + + blocking_notifier_chain_register(&hndl->chain, nb); + /* + * Ask platform to enable events': effective requests are emitted + * only when required by the current state of the underlying sources. + */ + if (!hndl->deferred_enable) { + ret = scmi_event_handler_enable_events(hndl); + if (ret) + scmi_put_event_handler(hndl); + } + + return ret; +} + +/** + * scmi_unregister_notifier - Unregister a notifier_block for an event + * + * Takes care to unregister the provided @nb from the notification chain + * associated to the specified event and, if there are no more users for the + * event handler, frees also the associated event handler structures. + * + * @handle: The handle identifying the platform instance against which the + * callback is unregistered + * @proto_id: Protocol ID + * @evt_id: Event ID + * @src_id: Source ID + * @nb: The notifier_block to unregister + * + * Return: 0 on Success + */ +static int scmi_unregister_notifier(const struct scmi_handle *handle, + u8 proto_id, u8 evt_id, u32 *src_id, + struct notifier_block *nb) +{ + u32 evt_key; + struct scmi_event_handler *hndl; + struct scmi_notify_instance *ni = handle->notify_priv; + + evt_key = MAKE_HASH_KEY(proto_id, evt_id, + src_id ? *src_id : SCMI_ALL_SRC_IDS); + hndl = scmi_get_event_handler(ni, evt_key); + if (IS_ERR_OR_NULL(hndl)) + return -EINVAL; + + blocking_notifier_chain_unregister(&hndl->chain, nb); + scmi_put_event_handler(hndl); + + /* + * If this was the last user callback for this handler, this last + * additional put will cause the handler to be freed; moreover if this + * was the last user, but @scmi_lookup_and_call_event_chain was ongoing, + * walking this chain, it will be its @scmi_put_event_handler which will + * finally free the handler. + */ + scmi_put_event_handler(hndl); + + return 0; +} + +/* + * notify_ops are attached to the handle so that can be accessed + * directly from an scmi_driver to register its own notifiers. + */ +static struct scmi_notify_ops notify_ops = { + .register_event_notifier = scmi_register_notifier, + .unregister_event_notifier = scmi_unregister_notifier, +}; + /** * scmi_notification_init - Initializes Notification Core Support * @@ -461,8 +979,11 @@ int scmi_notification_init(struct scmi_handle *handle) hash_init(ni->registered_protocols); hash_init(ni->registered_events); + hash_init(ni->registered_events_handlers); + mutex_init(&ni->events_handlers_mtx); handle->notify_priv = ni; + handle->notify_ops = ¬ify_ops; atomic_set(&ni->disabled, 1); atomic_set(&ni->initialized, 1); diff --git a/drivers/firmware/arm_scmi/notify.h b/drivers/firmware/arm_scmi/notify.h index 8de19a3b75ab..93f7a2503b45 100644 --- a/drivers/firmware/arm_scmi/notify.h +++ b/drivers/firmware/arm_scmi/notify.h @@ -9,9 +9,22 @@ #ifndef _SCMI_NOTIFY_H #define _SCMI_NOTIFY_H +#include #include +#include #include +#define MAP_EVT_TO_ENABLE_CMD(id, map) \ +({ \ + int ret = -1; \ + \ + if (likely((id) < ARRAY_SIZE((map)))) \ + ret = (map)[(id)]; \ + else \ + WARN(1, "UN-KNOWN evt_id:%d\n", (id)); \ + ret; \ +}) + /** * scmi_event - Describes an event to be supported * diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h index 0679f10ab05e..797e1e03ae52 100644 --- a/include/linux/scmi_protocol.h +++ b/include/linux/scmi_protocol.h @@ -9,6 +9,8 @@ #define _LINUX_SCMI_PROTOCOL_H #include +#include +#include #include #define SCMI_MAX_STR_SIZE 16 @@ -211,6 +213,52 @@ struct scmi_reset_ops { int (*deassert)(const struct scmi_handle *handle, u32 domain); }; +/** + * scmi_notify_ops - represents notifications' operations provided by SCMI core + * + * A user can register/unregister its own notifier_block against the wanted + * platform instance regarding the desired event identified by the + * tuple: (proto_id, evt_id, src_id) + * + * @register_event_notifier: Register a notifier_block for the requested event + * @unregister_event_notifier: Unregister a notifier_block for the requested + * event + * + * where: + * + * @handle: The handle identifying the platform instance to use + * @proto_id: The protocol ID as in SCMI Specification + * @evt_id: The message ID of the desired event as in SCMI Specification + * @src_id: A pointer to the desired source ID if different sources are + * possible for the protocol (like domain_id, sensor_id...etc) + * + * @src_id can be provided as NULL if it simply does NOT make sense for + * the protocol at hand, OR if the user is explicitly interested in + * receiving notifications from ANY existent source associated to the + * specified proto_id / evt_id. + * + * Received notifications are finally delivered to the registered users, + * invoking the callback provided with the notifier_block *nb as follows: + * + * int user_cb(nb, evt_id, report) + * + * with: + * + * @nb: The notifier block provided by the user + * @evt_id: The message ID of the delivered event + * @report: A custom struct describing the specific event delivered + * + * Events' customized report structs are detailed in the following. + */ +struct scmi_notify_ops { + int (*register_event_notifier)(const struct scmi_handle *handle, + u8 proto_id, u8 evt_id, u32 *src_id, + struct notifier_block *nb); + int (*unregister_event_notifier)(const struct scmi_handle *handle, + u8 proto_id, u8 evt_id, u32 *src_id, + struct notifier_block *nb); +}; + /** * struct scmi_handle - Handle returned to ARM SCMI clients for usage. * @@ -221,6 +269,7 @@ struct scmi_reset_ops { * @clk_ops: pointer to set of clock protocol operations * @sensor_ops: pointer to set of sensor protocol operations * @reset_ops: pointer to set of reset protocol operations + * @notify_ops: pointer to set of notifications related operations * @perf_priv: pointer to private data structure specific to performance * protocol(for internal use only) * @clk_priv: pointer to private data structure specific to clock @@ -242,6 +291,7 @@ struct scmi_handle { struct scmi_power_ops *power_ops; struct scmi_sensor_ops *sensor_ops; struct scmi_reset_ops *reset_ops; + struct scmi_notify_ops *notify_ops; /* for protocol internal use */ void *perf_priv; void *clk_priv; From patchwork Mon Feb 24 14:41:18 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11400699 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 6B4BE138D for ; Mon, 24 Feb 2020 14:44:15 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 4356520828 for ; Mon, 24 Feb 2020 14:44:15 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="S9BonJoX" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 4356520828 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=WBkECnDAdCBDIeDZUjKe9cuSQdApv9+xTt4+RlUPVVw=; b=S9BonJoX0ylhM2XTe5JJY9QsX9 gvt3ySENMdDYQO0ncfrifCCGbtTEb2NRQCO590+3Nul58UpcRXnp+U3cD+1fO/0b7YgIS4zyAZ2lF ZjtSVf4YGG2x84EmxYPOji9yV2jAfLIj9zOPbZ34YnBlw89TdSq5CQE4iGdkJ0rbdcAk2VAlWvzNB 2vrS4h4IolAncF2laAP0DRavO2WP7nM8nacMoi+rYwz0ptvIX8kgST087JaQVZavm9hgcEYuwcMp+ wYtiSGyN9VsfCvaLQ+HWhENUhI6JicxzCX4OJPDOsqgiRodLuSrKbjLNgTr1cL9wNGU2bKznQj4QD MX8ZiqnA==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Exw-0004om-32; Mon, 24 Feb 2020 14:44:12 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Ew3-0003C8-QX for linux-arm-kernel@lists.infradead.org; Mon, 24 Feb 2020 14:42:18 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 0906E11FB; Mon, 24 Feb 2020 06:42:15 -0800 (PST) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 0A2E53F534; Mon, 24 Feb 2020 06:42:13 -0800 (PST) From: Cristian Marussi To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [RFC PATCH v3 07/13] firmware: arm_scmi: Add notification dispatch and delivery Date: Mon, 24 Feb 2020 14:41:18 +0000 Message-Id: <20200224144124.2008-8-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200224144124.2008-1-cristian.marussi@arm.com> References: <20200224144124.2008-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200224_064216_182644_9690339F X-CRM114-Status: GOOD ( 25.81 ) X-Spam-Score: -2.3 (--) X-Spam-Report: SpamAssassin version 3.4.3 on bombadil.infradead.org summary: Content analysis details: (-2.3 points) pts rule name description ---- ---------------------- -------------------------------------------------- -2.3 RCVD_IN_DNSWL_MED RBL: Sender listed at https://www.dnswl.org/, medium trust [217.140.110.172 listed in list.dnswl.org] 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jonathan.Cameron@Huawei.com, cristian.marussi@arm.com, james.quinlan@broadcom.com, lukasz.luba@arm.com, sudeep.holla@arm.com MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Add core SCMI Notifications dispatch and delivery support logic which is able, at first, to dispatch well-known received events from the RX ISR to the dedicated deferred worker, and then, from there, to final deliver the events to the registered users' callbacks. Dispatch and delivery is just added here, still not enabled. Signed-off-by: Cristian Marussi --- V2 --> V3 - exposing wq in sysfs via WQ_SYSFS V1 --> V2 - splitted out of V1 patch 04 - moved from IDR maps to real HashTables to store event_handlers - simplified delivery logic --- drivers/firmware/arm_scmi/notify.c | 230 ++++++++++++++++++++++++++++- drivers/firmware/arm_scmi/notify.h | 9 ++ 2 files changed, 237 insertions(+), 2 deletions(-) diff --git a/drivers/firmware/arm_scmi/notify.c b/drivers/firmware/arm_scmi/notify.c index 5f95602ec13c..e4e4916aeb42 100644 --- a/drivers/firmware/arm_scmi/notify.c +++ b/drivers/firmware/arm_scmi/notify.c @@ -42,6 +42,27 @@ * as described in the SCMI Protocol specification, while src_id represents an * optional, protocol dependent, source identifier (like domain_id, perf_id * or sensor_id and so forth). + * + * Upon reception of a notification message from the platform the SCMI RX ISR + * passes the received message payload and some ancillary information (including + * an arrival timestamp in nanoseconds) to the core via @scmi_notify() which + * pushes the event-data itself on a protocol-dedicated kfifo queue for further + * deferred processing as specified in @scmi_events_dispatcher(). + * + * Each protocol has it own dedicated work_struct and worker which, once kicked + * by the ISR, takes care to empty its own dedicated queue, deliverying the + * queued items into the proper notification-chain: notifications processing can + * proceed concurrently on distinct workers only between events belonging to + * different protocols while delivery of events within the same protocol is + * still strictly sequentially ordered by time of arrival. + * + * Events' information is then extracted from SCMI Notification messages and + * conveyed, converted into a custom per-event report struct, as the void *data + * param to the user callback provided by the registered notifier_block, so that + * from the user perspective his callback will look invoked like: + * + * int user_cb(struct notifier_block *nb, unsigned long event_id, void *report) + * */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt @@ -61,6 +82,7 @@ #include #include #include +#include #include "notify.h" @@ -108,6 +130,9 @@ #define REVT_NOTIFY_ENABLE(revt, ...) \ ((revt)->proto->ops->set_notify_enabled((revt)->proto->ni->handle, \ __VA_ARGS__)) +#define REVT_FILL_REPORT(revt, ...) \ + ((revt)->proto->ops->fill_custom_report(__VA_ARGS__)) + /** * scmi_notify_instance - Represents an instance of the notification core * @@ -120,6 +145,7 @@ * and protocols are allowed to register their supported events * @disabled: A flag to indicate when event's handlers registration phase has * completed and events can be enabled and start flowing + * @notify_wq: A reference to the allocated Kernel cmwq * @events_handlers_mtx: A mutex to protect @registered_events_handlers access * @registered_protocols: An hashtable containing all protocol-level specific * information related to events' handling @@ -136,6 +162,8 @@ struct scmi_notify_instance { atomic_t initialized; atomic_t disabled; + struct workqueue_struct *notify_wq; + struct mutex events_handlers_mtx; DECLARE_HASHTABLE(registered_protocols, 4); DECLARE_HASHTABLE(registered_events, 5); @@ -150,11 +178,15 @@ struct scmi_notify_instance { * @sz: Size in bytes of the related kfifo * @qbuf: Pre-allocated buffer of @sz bytes to be used by the kfifo * @kfifo: A dedicated Kernel kfifo descriptor + * @notify_work: A custom work item bound to this queue + * @wq: A reference to the related workqueue */ struct events_queue { size_t sz; u8 *qbuf; struct kfifo kfifo; + struct work_struct notify_work; + struct workqueue_struct *wq; }; /** @@ -272,6 +304,188 @@ scmi_get_event_handler(struct scmi_notify_instance *ni, u32 evt_key); static void scmi_put_event_handler(struct scmi_event_handler *hndl); static void scmi_free_event_handler(struct scmi_event_handler *hndl); +/** + * scmi_discard_bad_evt_payload() - Utility to discard data from a kfifo + * + * @kq: The kfifo to act on + * @count: Number of bytes to flush + */ +static inline void scmi_discard_bad_evt_payload(struct kfifo *kq, + const unsigned int count) +{ + int i = 0; + + pr_warn("SCMI Notifications: WQ skipping bad EVT Payload - %d bytes\n", + count); + /* Discard stale pending queued payload. */ + for (i = 0; i < count; i++) + kfifo_skip(kq); +} + +/** + * scmi_lookup_and_call_event_chain - Lookup the proper chain and call it + * + * @ni: A reference to the notification instance to use + * @evt_key: The key to use to lookup the related notification chain + * @report: The customized event-specific report to pass down to the callbacks + * as their *data parameter. + */ +static inline void +scmi_lookup_and_call_event_chain(struct scmi_notify_instance *ni, + u32 evt_key, void *report) +{ + int ret; + struct scmi_event_handler *hndl; + + /* Here ensure the event handler cannot vanish while using it */ + hndl = scmi_get_event_handler(ni, evt_key); + if (IS_ERR_OR_NULL(hndl)) + return; + + ret = blocking_notifier_call_chain(&hndl->chain, + KEY_XTRACT_EVT_ID(evt_key), + report); + /* Notifiers are NOT supposed to cut the chain */ + WARN_ON_ONCE(ret & NOTIFY_STOP_MASK); + + scmi_put_event_handler(hndl); +} + +/** + * scmi_events_dispatcher - Common worker logic for all work items. + * + * In turn: + * 1. dequeue one pending RX notification (queued in SCMI RX ISR context) + * 2. generate a custom event report from the received event message + * 3. lookup for any registered ALL_SRC_IDs handler + * - > call the related notification chain passing in the report + * 4. lookup for any registered specific SRC_ID handler + * - > call the related notification chain passing in the report + * + * Note that: + * - a dedicated per-protocol kfifo queue is used: in this way an anomalous + * flood of events cannot saturate other protocols' queues. + * + * - each per-protocol queue is associated to a distinct work_item, which + * means, in turn, that: + * + all protocols can process their dedicated queues concurrently + * (since notify_wq:max_active != 1) + * + anyway at most one worker instance is allowed to run on the same queue + * concurrently: this ensures that we can have only one concurrent + * reader/writer on the associated kfifo, so that we can use it lock-less + * + * @work: The work item to use, which is associated to a dedicated events_queue + */ +static void scmi_events_dispatcher(struct work_struct *work) +{ + struct events_queue *eq; + struct scmi_registered_protocol_events_desc *pd; + struct scmi_event_header eh; + + eq = container_of(work, struct events_queue, notify_work); + pd = container_of(eq, struct scmi_registered_protocol_events_desc, + equeue); + /* Read the scmi_event_header at first since it contains payld_sz ... */ + while (kfifo_out(&eq->kfifo, &eh, sizeof(eh))) { + u32 src_id, key; + unsigned int outs; + struct scmi_registered_event *r_evt; + void *report = NULL; + + key = MAKE_REVT_KEY(eh.proto_id, eh.evt_id); + r_evt = KEY_FIND(pd->ni->registered_events, r_evt, key); + if (!r_evt) { + scmi_discard_bad_evt_payload(&eq->kfifo, eh.payld_sz); + continue; + } + + /* ... then read payld_sz bytes holding the evt-msg payload */ + outs = kfifo_out(&eq->kfifo, r_evt->scratch_bh, eh.payld_sz); + if (outs != eh.payld_sz) { + pr_warn("SCMI Notifications: WQ SKIP corrupted EVT Payload.\n"); + continue; + } + + /* Reset and fill custom report, and obtain src_id */ + memset(r_evt->report, 0x00, r_evt->evt->max_report_sz); + report = REVT_FILL_REPORT(r_evt, eh.evt_id, eh.timestamp, + r_evt->scratch_bh, eh.payld_sz, + r_evt->report, &src_id); + if (!report) + continue; + + /* At first search for a generic ALL src_ids handler... */ + scmi_lookup_and_call_event_chain(pd->ni, key, report); + /* ...then search for any specific src_id */ + key = MAKE_HASH_KEY(eh.proto_id, eh.evt_id, src_id); + scmi_lookup_and_call_event_chain(pd->ni, key, report); + } +} + +/** + * scmi_notify - Queues a notification for further deferred processing + * + * This is called in interrupt context to queue a received event for + * deferred processing. + * + * @handle: The handle identifying the platform instance from which the + * dispatched event is generated + * @proto_id: Protocol ID + * @evt_id: Event ID (msgID) + * @buf: Event Message Payload (without the header) + * @len: Event Message Payload size + * @ts: RX Timestamp in nanoseconds (boottime) + * + * Return: 0 on Success + */ +int scmi_notify(const struct scmi_handle *handle, u8 proto_id, u8 evt_id, + const void *buf, size_t len, u64 ts) +{ + struct scmi_registered_event *r_evt; + struct scmi_event_header *eh; + struct scmi_notify_instance *ni = handle->notify_priv; + + /* Ensure atomic value is updated */ + smp_mb__before_atomic(); + if (unlikely(atomic_read(&ni->disabled))) + return 0; + + r_evt = KEY_FIND(ni->registered_events, r_evt, + MAKE_REVT_KEY(proto_id, evt_id)); + if (unlikely(!r_evt)) + return -EINVAL; + + if (unlikely(len > r_evt->evt->max_payld_sz)) { + pr_err("SCMI Notifications: discard badly sized message\n"); + return -EINVAL; + } + if (unlikely(kfifo_avail(&r_evt->proto->equeue.kfifo) < + sizeof(*eh) + len)) { + pr_warn("SCMI Notifications: queue full dropping proto_id:%d evt_id:%d ts:%lld\n", + proto_id, evt_id, ts); + return -ENOMEM; + } + + /* + * Note that we can use the per protocol kfifo in a lock-less manner + * since we have only one concurrent reader and writer but, in order + * to avoid any trouble on the reader side, here we ensure to perform + * one single kfifo write, so we have to collate in advance the event + * header and payload in a scratch area at first. + */ + eh = r_evt->scratch_isr; + eh->timestamp = ts; + eh->proto_id = proto_id; + eh->evt_id = evt_id; + eh->payld_sz = len; + memcpy(eh->payld, buf, eh->payld_sz); + kfifo_in(&r_evt->proto->equeue.kfifo, eh, sizeof(*eh) + eh->payld_sz); + queue_work(r_evt->proto->equeue.wq, + &r_evt->proto->equeue.notify_work); + + return 0; +} + /** * scmi_initialize_events_queue - Allocate/Initialize a kfifo buffer * @@ -298,6 +512,9 @@ static int scmi_initialize_events_queue(struct scmi_notify_instance *ni, if (ret) return ret; + INIT_WORK(&equeue->notify_work, scmi_events_dispatcher); + equeue->wq = ni->notify_wq; + return 0; } @@ -602,7 +819,7 @@ static int scmi_register_event_handler(struct scmi_notify_instance *ni, struct scmi_event_handler *hndl, bool allow_delayed) { - int ret = 0; + int ret; ret = scmi_bind_event_handler(ni, hndl, allow_delayed); if (ret) @@ -611,7 +828,7 @@ static int scmi_register_event_handler(struct scmi_notify_instance *ni, /* Register freshly allocated event handler */ hash_add(ni->registered_events_handlers, &hndl->hash, hndl->key); - return 0; + return ret; } /** @@ -977,6 +1194,12 @@ int scmi_notification_init(struct scmi_handle *handle) ni->gid = gid; ni->handle = handle; + ni->notify_wq = alloc_workqueue("scmi_notify", + WQ_UNBOUND | WQ_FREEZABLE | WQ_SYSFS, + 0); + if (!ni->notify_wq) + goto err; + hash_init(ni->registered_protocols); hash_init(ni->registered_events); hash_init(ni->registered_events_handlers); @@ -1012,6 +1235,9 @@ void scmi_notification_exit(struct scmi_handle *handle) if (unlikely(!ni || !atomic_read(&ni->initialized))) return; + /* Destroy while letting pending work complete */ + destroy_workqueue(ni->notify_wq); + devres_release_group(ni->handle->dev, ni->gid); pr_info("SCMI Notifications Core Cleaned.\n"); diff --git a/drivers/firmware/arm_scmi/notify.h b/drivers/firmware/arm_scmi/notify.h index 93f7a2503b45..fbb2c5247531 100644 --- a/drivers/firmware/arm_scmi/notify.h +++ b/drivers/firmware/arm_scmi/notify.h @@ -52,10 +52,17 @@ struct scmi_event { * using the proper custom protocol commands. * Return true if at least one the required src_id * has been successfully enabled/disabled + * @fill_custom_report: fills a custom event report from the provided + * event message payld identifying the event + * specific src_id. + * Return NULL on failure otherwise @report now fully + * populated */ struct scmi_protocol_event_ops { bool (*set_notify_enabled)(const struct scmi_handle *handle, u8 evt_id, u32 src_id, bool enabled); + void *(*fill_custom_report)(u8 evt_id, u64 timestamp, const void *payld, + size_t payld_sz, void *report, u32 *src_id); }; int scmi_notification_init(struct scmi_handle *handle); @@ -68,5 +75,7 @@ int scmi_register_protocol_events(const struct scmi_handle *handle, int num_sources); int scmi_unregister_protocol_events(const struct scmi_handle *handle, u8 proto_id); +int scmi_notify(const struct scmi_handle *handle, u8 proto_id, u8 evt_id, + const void *buf, size_t len, u64 ts); #endif /* _SCMI_NOTIFY_H */ From patchwork Mon Feb 24 14:41:19 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11400705 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id C7B97924 for ; Mon, 24 Feb 2020 14:44:58 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 9784E20828 for ; Mon, 24 Feb 2020 14:44:58 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="iwOxviMX" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 9784E20828 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=e8AAcgVIk9Bo2HVKIEOaYxTyy1KYpWXVBbsib0whk6U=; b=iwOxviMXXt4tMTN4ZGskX76Ofb odZCGiwg+vNisycSClGHZQh8+zjtgwryvFkvCdcznkIaCrcPgbNWwACOhhglCDjpqPTzd16Lcp3tq ruTbxcpBNyYgkRNWrtOUHGgHszI1vMT2UDWrpTLMfbIB4puvJoTDUfEdWZnfOupg7Y+XJh/jncnBw Efp4ZYSd+SBgwgLdY0l2uq8EU+z1mq1etyR3Z08pZ6BHdUkY8nHJ9OcvYnm1BrKM6GTxGzACdxQHV hCcTnnXRURHdFeRJ0OGP1Kxk1JLZ88b7q+cTZT4w2R0foy9LGKUQ7bcv7p8alNLEOapE44Hvu5Ck4 b5ePa28Q==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Eyf-0005W2-32; Mon, 24 Feb 2020 14:44:57 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Ew4-00036q-CA for linux-arm-kernel@lists.infradead.org; Mon, 24 Feb 2020 14:42:20 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 3B49D31B; Mon, 24 Feb 2020 06:42:16 -0800 (PST) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 3C8923F534; Mon, 24 Feb 2020 06:42:15 -0800 (PST) From: Cristian Marussi To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [RFC PATCH v3 08/13] firmware: arm_scmi: Enable notification core Date: Mon, 24 Feb 2020 14:41:19 +0000 Message-Id: <20200224144124.2008-9-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200224144124.2008-1-cristian.marussi@arm.com> References: <20200224144124.2008-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200224_064216_593708_68DBF79E X-CRM114-Status: GOOD ( 21.12 ) X-Spam-Score: -2.3 (--) X-Spam-Report: SpamAssassin version 3.4.3 on bombadil.infradead.org summary: Content analysis details: (-2.3 points) pts rule name description ---- ---------------------- -------------------------------------------------- -2.3 RCVD_IN_DNSWL_MED RBL: Sender listed at https://www.dnswl.org/, medium trust [217.140.110.172 listed in list.dnswl.org] 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jonathan.Cameron@Huawei.com, cristian.marussi@arm.com, james.quinlan@broadcom.com, lukasz.luba@arm.com, sudeep.holla@arm.com MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Initialize and enable SCMI Notifications core support during bus/driver init and probe phases, so that protocols can start registering their supported events during their initialization, and later users can start enrolling their callbacks for the subset of events their interested in. Signed-off-by: Cristian Marussi --- V2 --> V3 - reviewed core initialization: all implemented protocols must complete their protocol-events registration phases before notifications can be enabled as a whole; in the meantime any user's callback registration requests possibly issued while the notifications were not enabled remain pending: a dedicated worker completes the handlers registration once all protocols have been initialized. NOTE THAT this can lead to ISSUES with late inserted or missing SCMI modules (i.e. for protocols defined in the DT and implemented by the platform but lazily loaded or not loaded at all.), since in these scenarios notifications dispatching will be enabled later or never. - reviewed core exit: protocol users (devices) are accounted on probe/ remove, and protocols' events are unregisteredonce last user go (can happen only at shutdown) V1 --> V2 - added timestamping - moved notification init/exit and using devres --- drivers/firmware/arm_scmi/bus.c | 25 +++-- drivers/firmware/arm_scmi/driver.c | 12 +++ drivers/firmware/arm_scmi/notify.c | 168 +++++++++++++++++++++++++++++ drivers/firmware/arm_scmi/notify.h | 6 ++ 4 files changed, 201 insertions(+), 10 deletions(-) diff --git a/drivers/firmware/arm_scmi/bus.c b/drivers/firmware/arm_scmi/bus.c index db55c43a2cbd..e4f2e629b88f 100644 --- a/drivers/firmware/arm_scmi/bus.c +++ b/drivers/firmware/arm_scmi/bus.c @@ -14,6 +14,7 @@ #include #include "common.h" +#include "notify.h" static DEFINE_IDA(scmi_bus_id); static DEFINE_IDR(scmi_protocols); @@ -53,16 +54,17 @@ static int scmi_dev_match(struct device *dev, struct device_driver *drv) static int scmi_protocol_init(int protocol_id, struct scmi_handle *handle) { + int ret; scmi_prot_init_fn_t fn = idr_find(&scmi_protocols, protocol_id); - if (unlikely(!fn)) - return -EINVAL; - return fn(handle); -} + if (!fn) + return 0; -static int scmi_protocol_dummy_init(struct scmi_handle *handle) -{ - return 0; + idr_remove(&scmi_protocols, protocol_id); + ret = fn(handle); + scmi_notification_set_proto_initialized(handle); + + return ret; } static int scmi_dev_probe(struct device *dev) @@ -83,9 +85,9 @@ static int scmi_dev_probe(struct device *dev) if (ret) return ret; - /* Skip protocol initialisation for additional devices */ - idr_replace(&scmi_protocols, &scmi_protocol_dummy_init, - scmi_dev->protocol_id); + /* Count this device */ + scmi_notification_inc_proto_users(scmi_dev->handle, + scmi_dev->protocol_id); return scmi_drv->probe(scmi_dev); } @@ -95,6 +97,9 @@ static int scmi_dev_remove(struct device *dev) struct scmi_driver *scmi_drv = to_scmi_driver(dev->driver); struct scmi_device *scmi_dev = to_scmi_dev(dev); + scmi_notification_dec_proto_users(scmi_dev->handle, + scmi_dev->protocol_id); + if (scmi_drv->remove) scmi_drv->remove(scmi_dev); diff --git a/drivers/firmware/arm_scmi/driver.c b/drivers/firmware/arm_scmi/driver.c index 868cc36a07c9..0268cfe3849e 100644 --- a/drivers/firmware/arm_scmi/driver.c +++ b/drivers/firmware/arm_scmi/driver.c @@ -26,6 +26,7 @@ #include #include "common.h" +#include "notify.h" #define CREATE_TRACE_POINTS #include @@ -204,11 +205,13 @@ __scmi_xfer_put(struct scmi_xfers_info *minfo, struct scmi_xfer *xfer) static void scmi_handle_notification(struct scmi_chan_info *cinfo, u32 msg_hdr) { + u64 ts; struct scmi_xfer *xfer; struct device *dev = cinfo->dev; struct scmi_info *info = handle_to_scmi_info(cinfo->handle); struct scmi_xfers_info *minfo = &info->rx_minfo; + ts = ktime_get_boottime_ns(); xfer = scmi_xfer_get(cinfo->handle, minfo); if (IS_ERR(xfer)) { dev_err(dev, "failed to get free message slot (%ld)\n", @@ -221,6 +224,8 @@ static void scmi_handle_notification(struct scmi_chan_info *cinfo, u32 msg_hdr) scmi_dump_header_dbg(dev, &xfer->hdr); info->desc->ops->fetch_notification(cinfo, info->desc->max_msg_size, xfer); + scmi_notify(cinfo->handle, xfer->hdr.protocol_id, + xfer->hdr.id, xfer->rx.buf, xfer->rx.len, ts); trace_scmi_rx_done(xfer->transfer_id, xfer->hdr.id, xfer->hdr.protocol_id, xfer->hdr.seq, @@ -771,6 +776,9 @@ static int scmi_probe(struct platform_device *pdev) if (ret) return ret; + if (scmi_notification_init(handle)) + dev_err(dev, "SCMI Notifications NOT available.\n"); + ret = scmi_base_protocol_init(handle); if (ret) { dev_err(dev, "unable to communicate with SCMI(%d)\n", ret); @@ -796,8 +804,10 @@ static int scmi_probe(struct platform_device *pdev) continue; } + scmi_notification_set_proto_pending(handle); scmi_create_protocol_devices(child, info, prot_id); } + scmi_notification_set_proto_initialized(handle); return 0; } @@ -813,6 +823,8 @@ static int scmi_remove(struct platform_device *pdev) struct scmi_info *info = platform_get_drvdata(pdev); struct idr *idr = &info->tx_idr; + scmi_notification_exit(&info->handle); + mutex_lock(&scmi_list_mutex); if (info->users) ret = -EBUSY; diff --git a/drivers/firmware/arm_scmi/notify.c b/drivers/firmware/arm_scmi/notify.c index e4e4916aeb42..6bab1c23a1a0 100644 --- a/drivers/firmware/arm_scmi/notify.c +++ b/drivers/firmware/arm_scmi/notify.c @@ -70,9 +70,11 @@ #include #include #include +#include #include #include #include +#include #include #include #include @@ -145,6 +147,12 @@ * and protocols are allowed to register their supported events * @disabled: A flag to indicate when event's handlers registration phase has * completed and events can be enabled and start flowing + * @pending_protocols: A refcount to the number of protocols still pending + * initialization: once this drops to zero @init_completion + * is completed, unblocking @init_work as a consequence + * @init_complete: A completion used to stall @init_work till all pending + * protocols have completed their registration phase + * @init_work: A work item to perform final initializations of pending handlers * @notify_wq: A reference to the allocated Kernel cmwq * @events_handlers_mtx: A mutex to protect @registered_events_handlers access * @registered_protocols: An hashtable containing all protocol-level specific @@ -162,6 +170,10 @@ struct scmi_notify_instance { atomic_t initialized; atomic_t disabled; + refcount_t pending_protocols; + struct completion init_complete; + struct work_struct init_work; + struct workqueue_struct *notify_wq; struct mutex events_handlers_mtx; @@ -203,6 +215,8 @@ struct events_queue { * @hash: The hlist_node used for collision handling * @ni: A reference to the initialized instance descriptor * @gid: The associated devres group id, for cleanup purposes + * @users: The number of active protocol users, when it drops to zero (at system + * shutdown) protocol is unregistered and resources are freed */ struct scmi_registered_protocol_events_desc { u32 key; @@ -212,6 +226,7 @@ struct scmi_registered_protocol_events_desc { struct hlist_node hash; struct scmi_notify_instance *ni; void *gid; + refcount_t users; }; /** @@ -317,6 +332,7 @@ static inline void scmi_discard_bad_evt_payload(struct kfifo *kq, pr_warn("SCMI Notifications: WQ skipping bad EVT Payload - %d bytes\n", count); + /* Discard stale pending queued payload. */ for (i = 0; i < count; i++) kfifo_skip(kq); @@ -552,6 +568,7 @@ scmi_allocate_registered_protocol_desc(struct scmi_notify_instance *ni, pd->id = proto_id; pd->ops = ops; pd->ni = ni; + refcount_set(&pd->users, 1); ret = scmi_initialize_events_queue(ni, &pd->equeue, queue_sz); if (ret) @@ -724,6 +741,70 @@ int scmi_unregister_protocol_events(const struct scmi_handle *handle, return devres_release_group(ni->handle->dev, pd->gid); } +/** + * scmi_notification_inc_proto_users - Helper to account for protocols' users + * + * @handle: The handle identifying the platform instance + * @proto_id: The protocol to act upon + */ +void scmi_notification_inc_proto_users(const struct scmi_handle *handle, + const u32 proto_id) +{ + struct scmi_registered_protocol_events_desc *pd; + struct scmi_notify_instance *ni = handle->notify_priv; + + if (unlikely(!ni || !atomic_read(&ni->initialized))) + return; + + pd = KEY_FIND(ni->registered_protocols, pd, MAKE_PROTO_KEY(proto_id)); + if (!pd) + return; + + refcount_inc(&pd->users); +} + +/** + * scmi_notification_dec_proto_users - Helper to account for protocols' users + * + * Once no more users are active for this protocol stop ISR dispatching as a + * whole and flush protocol queue: after this point no more events will be + * queued for this protocol. + * Events dispatching won't be enabled anymore, we are shutting down. + * + * Note that normally when we get here any user of the notification subsystem + * would have already unregistered their callbacks and caused the events + * generation to be stopped: here we want to address also the possibility that + * a faulty platform keeps on emitting notification messages, even after having + * being asked explicitly to stop, by forcibly stopping the dispatching and + * emptying the queues. + * + * @handle: The handle identifying the platform instance to target + * @proto_id: The protocol to act upon + */ +void scmi_notification_dec_proto_users(const struct scmi_handle *handle, + const u32 proto_id) +{ + struct scmi_registered_protocol_events_desc *pd; + struct scmi_notify_instance *ni = handle->notify_priv; + + if (unlikely(!ni || !atomic_read(&ni->initialized))) + return; + + pd = KEY_FIND(ni->registered_protocols, pd, MAKE_PROTO_KEY(proto_id)); + if (!pd) + return; + + if (refcount_dec_and_test(&pd->users)) { + atomic_set(&ni->disabled, 1); + /* Ensure atomic value is updated */ + smp_mb__after_atomic(); + + cancel_work_sync(&pd->equeue.notify_work); + + scmi_unregister_protocol_events(handle, proto_id); + } +} + /** * scmi_allocate_event_handler - Allocate Event handler * @@ -1135,6 +1216,88 @@ static int scmi_unregister_notifier(const struct scmi_handle *handle, return 0; } +/** + * scmi_notification_set_proto_pending - Helper for protocol-initialization + * + * Account for one protocol initialization pending + * + * @handle: The handle identifying the platform instance which is initializing + */ +void scmi_notification_set_proto_pending(const struct scmi_handle *handle) +{ + struct scmi_notify_instance *ni = handle->notify_priv; + + if (unlikely(!ni || !atomic_read(&ni->initialized))) + return; + + refcount_inc(&ni->pending_protocols); +} + +/** + * scmi_notification_set_proto_initialized - Helper for protocol-initialization + * + * Account for one protocol initialization completed. Once no more protocols are + * pending initialization, a completion is used to kick @init_work for final + * binding of pending handlers. + * + * @handle: The handle identifying the platform instance which is initializing + */ +void scmi_notification_set_proto_initialized(const struct scmi_handle *handle) +{ + struct scmi_notify_instance *ni = handle->notify_priv; + + if (unlikely(!ni || !atomic_read(&ni->initialized))) + return; + + if (refcount_dec_and_test(&ni->pending_protocols)) { + pr_info("SCMI Notifications Core Initialized.\n"); + complete(&ni->init_complete); + } +} + +/** + * scmi_protocols_late_init - Worker for late initialization + * + * This kicks in once the all the pending protocols have initialized, and tries + * to finalize the registration of pending handlers, binding the underlying + * associated registered events and enabling events' generation for pending + * handlers; still failing to bind handlers are removed. + * + * @work: The work item to use associated to the proper SCMI instance + */ +static void scmi_protocols_late_init(struct work_struct *work) +{ + int bkt; + struct scmi_event_handler *hndl; + struct scmi_notify_instance *ni; + + ni = container_of(work, struct scmi_notify_instance, init_work); + wait_for_completion(&ni->init_complete); + + mutex_lock(&ni->events_handlers_mtx); + hash_for_each(ni->registered_events_handlers, bkt, hndl, hash) { + int ret = 0; + bool was_deferred = hndl->deferred_enable; + + /* + * Register pending registrations (r_evt == NULL)... + * no further delay is allowed, since all the possible + * events should have been already registered by now. + */ + if (!hndl->r_evt) + ret = scmi_bind_event_handler(ni, hndl, false); + if (!ret && was_deferred) + ret = scmi_event_handler_enable_events(hndl); + if (ret) + scmi_free_event_handler(hndl); + } + mutex_unlock(&ni->events_handlers_mtx); + atomic_set(&ni->disabled, 0); + /* Ensure atomic value is updated */ + smp_mb__after_atomic(); + pr_info("SCMI Notifications Core Enabled.\n"); +} + /* * notify_ops are attached to the handle so that can be accessed * directly from an scmi_driver to register its own notifiers. @@ -1205,15 +1368,20 @@ int scmi_notification_init(struct scmi_handle *handle) hash_init(ni->registered_events_handlers); mutex_init(&ni->events_handlers_mtx); + init_completion(&ni->init_complete); + INIT_WORK(&ni->init_work, scmi_protocols_late_init); + handle->notify_priv = ni; handle->notify_ops = ¬ify_ops; atomic_set(&ni->disabled, 1); + refcount_set(&ni->pending_protocols, 1); atomic_set(&ni->initialized, 1); /* Ensure atomic values are updated */ smp_mb__after_atomic(); pr_info("SCMI Notifications Core Initializing.\n"); + schedule_work(&ni->init_work); devres_close_group(handle->dev, NULL); diff --git a/drivers/firmware/arm_scmi/notify.h b/drivers/firmware/arm_scmi/notify.h index fbb2c5247531..014ec1a4bb9b 100644 --- a/drivers/firmware/arm_scmi/notify.h +++ b/drivers/firmware/arm_scmi/notify.h @@ -67,6 +67,12 @@ struct scmi_protocol_event_ops { int scmi_notification_init(struct scmi_handle *handle); void scmi_notification_exit(struct scmi_handle *handle); +void scmi_notification_set_proto_pending(const struct scmi_handle *handle); +void scmi_notification_set_proto_initialized(const struct scmi_handle *handle); +void scmi_notification_inc_proto_users(const struct scmi_handle *handle, + const u32 proto_id); +void scmi_notification_dec_proto_users(const struct scmi_handle *handle, + const u32 proto_id); int scmi_register_protocol_events(const struct scmi_handle *handle, u8 proto_id, size_t queue_sz, From patchwork Mon Feb 24 14:41:20 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11400701 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 2187913A4 for ; Mon, 24 Feb 2020 14:44:24 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 ED2DB20828 for ; Mon, 24 Feb 2020 14:44:23 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="SbbwZ/6E" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org ED2DB20828 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=PgYQoNcbgmbP6OsAd9saiQEszEfx/SHV818jRJE6MGU=; b=SbbwZ/6E8XhzBOupwFrve8o9ZU xVRBBZPIlANWVx1bMkaHYIrq2WF6ZjwOKCJiBtIoFhcswLwxrG8z9+eqeAtugy/4iku4Uutzji0BZ obl82JIXp4ka44cT32c80zjksXzJ37+fDh+kMk1qhzozGrYaUU2fQ8M+IIVaqfuF9xQurlSYPhSws M2ex0hRn183vp7NbGFxt1DXYbDb1nod+5PBI63AToyfFZ7M7RDdYWPEEyMihn4XQhLwDfN5xdPMUh 1418xDSQoZKbg1HKnI+Z4RsRdSEq49UdLxLGIpgMSsnwl0CH9Z4VhLVbl7zsKb0RXn/zYvNT4gwrz yqBk/8YQ==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Ey7-00052r-GR; Mon, 24 Feb 2020 14:44:23 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Ew5-000384-NC for linux-arm-kernel@lists.infradead.org; Mon, 24 Feb 2020 14:42:20 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 6D7021063; Mon, 24 Feb 2020 06:42:17 -0800 (PST) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 6E93A3F534; Mon, 24 Feb 2020 06:42:16 -0800 (PST) From: Cristian Marussi To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [RFC PATCH v3 09/13] firmware: arm_scmi: Add Power notifications support Date: Mon, 24 Feb 2020 14:41:20 +0000 Message-Id: <20200224144124.2008-10-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200224144124.2008-1-cristian.marussi@arm.com> References: <20200224144124.2008-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200224_064217_864363_3E0E8D63 X-CRM114-Status: GOOD ( 11.91 ) X-Spam-Score: -2.3 (--) X-Spam-Report: SpamAssassin version 3.4.3 on bombadil.infradead.org summary: Content analysis details: (-2.3 points) pts rule name description ---- ---------------------- -------------------------------------------------- -2.3 RCVD_IN_DNSWL_MED RBL: Sender listed at https://www.dnswl.org/, medium trust [217.140.110.172 listed in list.dnswl.org] 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jonathan.Cameron@Huawei.com, cristian.marussi@arm.com, james.quinlan@broadcom.com, lukasz.luba@arm.com, sudeep.holla@arm.com MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Make SCMI Power protocol register with the notification core. Signed-off-by: Cristian Marussi --- V2 --> V3 - added handle awareness V1 --> V2 - simplified .set_notify_enabled() implementation moving the ALL_SRCIDs logic out of protocol. ALL_SRCIDs logic is now in charge of the notification core, together with proper reference counting of enables - switched to devres protocol-registration --- drivers/firmware/arm_scmi/power.c | 123 ++++++++++++++++++++++++++++++ include/linux/scmi_protocol.h | 15 ++++ 2 files changed, 138 insertions(+) diff --git a/drivers/firmware/arm_scmi/power.c b/drivers/firmware/arm_scmi/power.c index cf7f0312381b..c69aedf69187 100644 --- a/drivers/firmware/arm_scmi/power.c +++ b/drivers/firmware/arm_scmi/power.c @@ -6,6 +6,7 @@ */ #include "common.h" +#include "notify.h" enum scmi_power_protocol_cmd { POWER_DOMAIN_ATTRIBUTES = 0x3, @@ -48,6 +49,12 @@ struct scmi_power_state_notify { __le32 notify_enable; }; +struct scmi_power_state_notify_payld { + __le32 agent_id; + __le32 domain_id; + __le32 power_state; +}; + struct power_dom_info { bool state_set_sync; bool state_set_async; @@ -63,6 +70,11 @@ struct scmi_power_info { struct power_dom_info *dom_info; }; +static enum scmi_power_protocol_cmd evt_2_cmd[] = { + POWER_STATE_NOTIFY, + POWER_STATE_CHANGE_REQUESTED_NOTIFY, +}; + static int scmi_power_attributes_get(const struct scmi_handle *handle, struct scmi_power_info *pi) { @@ -186,6 +198,111 @@ static struct scmi_power_ops power_ops = { .state_get = scmi_power_state_get, }; +static int scmi_power_request_notify(const struct scmi_handle *handle, + u32 domain, int message_id, bool enable) +{ + int ret; + struct scmi_xfer *t; + struct scmi_power_state_notify *notify; + + ret = scmi_xfer_get_init(handle, message_id, SCMI_PROTOCOL_POWER, + sizeof(*notify), 0, &t); + if (ret) + return ret; + + notify = t->tx.buf; + notify->domain = cpu_to_le32(domain); + notify->notify_enable = enable ? cpu_to_le32(BIT(0)) : 0; + + ret = scmi_do_xfer(handle, t); + + scmi_xfer_put(handle, t); + return ret; +} + +static bool scmi_power_set_notify_enabled(const struct scmi_handle *handle, + u8 evt_id, u32 src_id, bool enable) +{ + int ret, cmd_id; + + cmd_id = MAP_EVT_TO_ENABLE_CMD(evt_id, evt_2_cmd); + if (cmd_id < 0) + return false; + + ret = scmi_power_request_notify(handle, src_id, cmd_id, enable); + if (ret) + pr_warn("SCMI Notifications - Proto:%X - FAIL_ENABLE - evt[%X] dom[%d] - ret:%d\n", + SCMI_PROTOCOL_POWER, evt_id, src_id, ret); + + return !ret ? true : false; +} + +static void *scmi_power_fill_custom_report(u8 evt_id, u64 timestamp, + const void *payld, size_t payld_sz, + void *report, u32 *src_id) +{ + void *rep = NULL; + + switch (evt_id) { + case POWER_STATE_CHANGED: + { + const struct scmi_power_state_notify_payld *p = payld; + struct scmi_power_state_changed_report *r = report; + + if (sizeof(*p) != payld_sz) + break; + + r->timestamp = timestamp; + r->agent_id = le32_to_cpu(p->agent_id); + r->domain_id = le32_to_cpu(p->domain_id); + r->power_state = le32_to_cpu(p->power_state); + *src_id = r->domain_id; + rep = r; + break; + } + case POWER_STATE_CHANGE_REQUESTED: + { + const struct scmi_power_state_notify_payld *p = payld; + struct scmi_power_state_change_requested_report *r = report; + + if (sizeof(*p) != payld_sz) + break; + + r->timestamp = timestamp; + r->agent_id = le32_to_cpu(p->agent_id); + r->domain_id = le32_to_cpu(p->domain_id); + r->power_state = le32_to_cpu(p->power_state); + *src_id = r->domain_id; + rep = r; + break; + } + default: + break; + } + + return rep; +} + +static const struct scmi_event power_events[] = { + { + .evt_id = POWER_STATE_CHANGED, + .max_payld_sz = 12, + .max_report_sz = + sizeof(struct scmi_power_state_changed_report), + }, + { + .evt_id = POWER_STATE_CHANGE_REQUESTED, + .max_payld_sz = 12, + .max_report_sz = + sizeof(struct scmi_power_state_change_requested_report), + }, +}; + +static const struct scmi_protocol_event_ops power_event_ops = { + .set_notify_enabled = scmi_power_set_notify_enabled, + .fill_custom_report = scmi_power_fill_custom_report, +}; + static int scmi_power_protocol_init(struct scmi_handle *handle) { int domain; @@ -214,6 +331,12 @@ static int scmi_power_protocol_init(struct scmi_handle *handle) scmi_power_domain_attributes_get(handle, domain, dom); } + scmi_register_protocol_events(handle, + SCMI_PROTOCOL_POWER, PAGE_SIZE, + &power_event_ops, power_events, + ARRAY_SIZE(power_events), + pinfo->num_domains); + pinfo->version = version; handle->power_ops = &power_ops; handle->power_priv = pinfo; diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h index 797e1e03ae52..baa117f9eda3 100644 --- a/include/linux/scmi_protocol.h +++ b/include/linux/scmi_protocol.h @@ -377,4 +377,19 @@ typedef int (*scmi_prot_init_fn_t)(struct scmi_handle *); int scmi_protocol_register(int protocol_id, scmi_prot_init_fn_t fn); void scmi_protocol_unregister(int protocol_id); +/* SCMI Notification API - Custom Event Reports */ +struct scmi_power_state_changed_report { + ktime_t timestamp; + u32 agent_id; + u32 domain_id; + u32 power_state; +}; + +struct scmi_power_state_change_requested_report { + ktime_t timestamp; + u32 agent_id; + u32 domain_id; + u32 power_state; +}; + #endif /* _LINUX_SCMI_PROTOCOL_H */ From patchwork Mon Feb 24 14:41:21 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11400703 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 6DD60924 for ; Mon, 24 Feb 2020 14:44:42 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 3CFE820828 for ; Mon, 24 Feb 2020 14:44:42 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="iorUGh7A" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 3CFE820828 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=FsGgknY6d/oXh4qtG8R1NFyIR5NQpSxKRMGCb49UWoc=; b=iorUGh7AJOFqPaXbrLp2Z8I2xm dHmUQNEkMoLDbtD/41mKoas8PS/kyCoWu63dXq1k0074meZq0UlWxoz4Grad1zKFbDecVfR/bzhEP 5XNi577Gw8UvVWirPGl3HoT3O3GYLFI75GJTwbOKZPr9pIEtN/RexwdHmCfY5v4/w2G4g08uPXmnO 18z1wHD9Q7IsymmYiZIv7QA1OYh7k100/GV4IIE9hXZuPp6x1wl4F4Gwb6ch4KzNtb592ucnteeYu UTNNo0WTEstyyrInRqwvT+ALG9NAKpD5en/AazSvU6mDBhar0iMwhhWhg802vS7GFbHsCY4ja7yie PWQtRlqw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6EyP-0005Jd-26; Mon, 24 Feb 2020 14:44:41 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Ew6-0003C8-PL for linux-arm-kernel@lists.infradead.org; Mon, 24 Feb 2020 14:42:20 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id A02FF106F; Mon, 24 Feb 2020 06:42:18 -0800 (PST) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id A0E443F534; Mon, 24 Feb 2020 06:42:17 -0800 (PST) From: Cristian Marussi To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [RFC PATCH v3 10/13] firmware: arm_scmi: Add Perf notifications support Date: Mon, 24 Feb 2020 14:41:21 +0000 Message-Id: <20200224144124.2008-11-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200224144124.2008-1-cristian.marussi@arm.com> References: <20200224144124.2008-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200224_064218_941543_2C8EC5EB X-CRM114-Status: GOOD ( 12.10 ) X-Spam-Score: -2.3 (--) X-Spam-Report: SpamAssassin version 3.4.3 on bombadil.infradead.org summary: Content analysis details: (-2.3 points) pts rule name description ---- ---------------------- -------------------------------------------------- -2.3 RCVD_IN_DNSWL_MED RBL: Sender listed at https://www.dnswl.org/, medium trust [217.140.110.172 listed in list.dnswl.org] 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jonathan.Cameron@Huawei.com, cristian.marussi@arm.com, james.quinlan@broadcom.com, lukasz.luba@arm.com, sudeep.holla@arm.com MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Make SCMI Perf protocol register with the notification core. Signed-off-by: Cristian Marussi --- V2 --> V3 - added handle awareness V1 --> V2 - simplified .set_notify_enabled() implementation moving the ALL_SRCIDs logic out of protocol. ALL_SRCIDs logic is now in charge of the notification core, together with proper reference counting of enables - switched to devres protocol-registration --- drivers/firmware/arm_scmi/perf.c | 130 +++++++++++++++++++++++++++++++ include/linux/scmi_protocol.h | 15 ++++ 2 files changed, 145 insertions(+) diff --git a/drivers/firmware/arm_scmi/perf.c b/drivers/firmware/arm_scmi/perf.c index 88509ec637d0..610b6fed8f8c 100644 --- a/drivers/firmware/arm_scmi/perf.c +++ b/drivers/firmware/arm_scmi/perf.c @@ -14,6 +14,7 @@ #include #include "common.h" +#include "notify.h" enum scmi_performance_protocol_cmd { PERF_DOMAIN_ATTRIBUTES = 0x3, @@ -86,6 +87,19 @@ struct scmi_perf_notify_level_or_limits { __le32 notify_enable; }; +struct scmi_perf_limits_notify_payld { + __le32 agent_id; + __le32 domain_id; + __le32 range_max; + __le32 range_min; +}; + +struct scmi_perf_level_notify_payld { + __le32 agent_id; + __le32 domain_id; + __le32 performance_level; +}; + struct scmi_msg_resp_perf_describe_levels { __le16 num_returned; __le16 num_remaining; @@ -158,6 +172,11 @@ struct scmi_perf_info { struct perf_dom_info *dom_info; }; +static enum scmi_performance_protocol_cmd evt_2_cmd[] = { + PERF_NOTIFY_LIMITS, + PERF_NOTIFY_LEVEL, +}; + static int scmi_perf_attributes_get(const struct scmi_handle *handle, struct scmi_perf_info *pi) { @@ -488,6 +507,29 @@ static int scmi_perf_level_get(const struct scmi_handle *handle, u32 domain, return scmi_perf_mb_level_get(handle, domain, level, poll); } +static int scmi_perf_level_limits_notify(const struct scmi_handle *handle, + u32 domain, int message_id, + bool enable) +{ + int ret; + struct scmi_xfer *t; + struct scmi_perf_notify_level_or_limits *notify; + + ret = scmi_xfer_get_init(handle, message_id, SCMI_PROTOCOL_PERF, + sizeof(*notify), 0, &t); + if (ret) + return ret; + + notify = t->tx.buf; + notify->domain = cpu_to_le32(domain); + notify->notify_enable = enable ? cpu_to_le32(BIT(0)) : 0; + + ret = scmi_do_xfer(handle, t); + + scmi_xfer_put(handle, t); + return ret; +} + static bool scmi_perf_fc_size_is_valid(u32 msg, u32 size) { if ((msg == PERF_LEVEL_GET || msg == PERF_LEVEL_SET) && size == 4) @@ -710,6 +752,88 @@ static struct scmi_perf_ops perf_ops = { .est_power_get = scmi_dvfs_est_power_get, }; +static bool scmi_perf_set_notify_enabled(const struct scmi_handle *handle, + u8 evt_id, u32 src_id, bool enable) +{ + int ret, cmd_id; + + cmd_id = MAP_EVT_TO_ENABLE_CMD(evt_id, evt_2_cmd); + if (cmd_id < 0) + return false; + + ret = scmi_perf_level_limits_notify(handle, src_id, cmd_id, enable); + if (ret) + pr_warn("SCMI Notifications - Proto:%X - FAIL_ENABLED - evt[%X] dom[%d] - ret:%d\n", + SCMI_PROTOCOL_PERF, evt_id, src_id, ret); + + return !ret ? true : false; +} + +static void *scmi_perf_fill_custom_report(u8 evt_id, u64 timestamp, + const void *payld, size_t payld_sz, + void *report, u32 *src_id) +{ + void *rep = NULL; + + switch (evt_id) { + case PERFORMANCE_LIMITS_CHANGED: + { + const struct scmi_perf_limits_notify_payld *p = payld; + struct scmi_perf_limits_report *r = report; + + if (sizeof(*p) != payld_sz) + break; + + r->timestamp = timestamp; + r->agent_id = le32_to_cpu(p->agent_id); + r->domain_id = le32_to_cpu(p->domain_id); + r->range_max = le32_to_cpu(p->range_max); + r->range_min = le32_to_cpu(p->range_min); + *src_id = r->domain_id; + rep = r; + break; + } + case PERFORMANCE_LEVEL_CHANGED: + { + const struct scmi_perf_level_notify_payld *p = payld; + struct scmi_perf_level_report *r = report; + + if (sizeof(*p) != payld_sz) + break; + + r->timestamp = timestamp; + r->agent_id = le32_to_cpu(p->agent_id); + r->domain_id = le32_to_cpu(p->domain_id); + r->performance_level = le32_to_cpu(p->performance_level); + *src_id = r->domain_id; + rep = r; + break; + } + default: + break; + } + + return rep; +} + +static const struct scmi_event perf_events[] = { + { + .evt_id = PERFORMANCE_LIMITS_CHANGED, + .max_payld_sz = 16, + .max_report_sz = sizeof(struct scmi_perf_limits_report), + }, + { + .evt_id = PERFORMANCE_LEVEL_CHANGED, + .max_payld_sz = 12, + .max_report_sz = sizeof(struct scmi_perf_level_report), + }, +}; + +static const struct scmi_protocol_event_ops perf_event_ops = { + .set_notify_enabled = scmi_perf_set_notify_enabled, + .fill_custom_report = scmi_perf_fill_custom_report, +}; + static int scmi_perf_protocol_init(struct scmi_handle *handle) { int domain; @@ -742,6 +866,12 @@ static int scmi_perf_protocol_init(struct scmi_handle *handle) scmi_perf_domain_init_fc(handle, domain, &dom->fc_info); } + scmi_register_protocol_events(handle, + SCMI_PROTOCOL_PERF, PAGE_SIZE, + &perf_event_ops, perf_events, + ARRAY_SIZE(perf_events), + pinfo->num_domains); + pinfo->version = version; handle->perf_ops = &perf_ops; handle->perf_priv = pinfo; diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h index baa117f9eda3..5e7c28c8bcac 100644 --- a/include/linux/scmi_protocol.h +++ b/include/linux/scmi_protocol.h @@ -392,4 +392,19 @@ struct scmi_power_state_change_requested_report { u32 power_state; }; +struct scmi_perf_limits_report { + ktime_t timestamp; + u32 agent_id; + u32 domain_id; + u32 range_max; + u32 range_min; +}; + +struct scmi_perf_level_report { + ktime_t timestamp; + u32 agent_id; + u32 domain_id; + u32 performance_level; +}; + #endif /* _LINUX_SCMI_PROTOCOL_H */ From patchwork Mon Feb 24 14:41:22 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11400707 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id C593B138D for ; Mon, 24 Feb 2020 14:45:18 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 8C73520828 for ; Mon, 24 Feb 2020 14:45:18 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="airlcvjr" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8C73520828 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=xKK5lyoAGBu7drLNl0Nfe4LC4LMRRquUYw9wg12RSyA=; b=airlcvjr1ckCY/ztp80VTfWnnA BTZlG8N/qisyjLRwC7Jow5EP0Bb81ksXrz5o+GI+83uwsKw+9bcdzytZwilSrPwuWJFZOXia5y7K7 JOUkMrwJsjY8/cx/OGE4lt5ToPrE7FXUsTnMzqZCFIkSmqhpPSVnShzOsZ3IfoqcjFoHzD+zDO6Jf yzCT9292rwhqtlkV3jo5Uw5QEnayTSz4Skah5TpiHqy8pS1+hXL/9vFBrx7kyfziX7tU8K1YpSKur EASMFSGyUIvuRcv+bdA9N+9HQmnbhKRvlMxDT94qL/2YFRh5c6op3IaSj0zy4Qbj1pxqFcov0gHVW 2uL+Q23w==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Eyy-0006vV-FN; Mon, 24 Feb 2020 14:45:16 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Ew8-0003GU-6B for linux-arm-kernel@lists.infradead.org; Mon, 24 Feb 2020 14:42:22 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id D311011B3; Mon, 24 Feb 2020 06:42:19 -0800 (PST) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id D39743F534; Mon, 24 Feb 2020 06:42:18 -0800 (PST) From: Cristian Marussi To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [RFC PATCH v3 11/13] firmware: arm_scmi: Add Sensor notifications support Date: Mon, 24 Feb 2020 14:41:22 +0000 Message-Id: <20200224144124.2008-12-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200224144124.2008-1-cristian.marussi@arm.com> References: <20200224144124.2008-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200224_064220_325329_76184EAE X-CRM114-Status: GOOD ( 11.73 ) X-Spam-Score: -2.3 (--) X-Spam-Report: SpamAssassin version 3.4.3 on bombadil.infradead.org summary: Content analysis details: (-2.3 points) pts rule name description ---- ---------------------- -------------------------------------------------- -2.3 RCVD_IN_DNSWL_MED RBL: Sender listed at https://www.dnswl.org/, medium trust [217.140.110.172 listed in list.dnswl.org] 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jonathan.Cameron@Huawei.com, cristian.marussi@arm.com, james.quinlan@broadcom.com, lukasz.luba@arm.com, sudeep.holla@arm.com MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Make SCMI Sensor protocol register with the notification core. Signed-off-by: Cristian Marussi --- V2 --> V3 - added handle awareness V1 --> V2 - simplified .set_notify_enabled() implementation moving the ALL_SRCIDs logic out of protocol. ALL_SRCIDs logic is now in charge of the notification core, together with proper reference counting of enables - switched to devres protocol-registration --- drivers/firmware/arm_scmi/sensors.c | 69 +++++++++++++++++++++++++++++ include/linux/scmi_protocol.h | 7 +++ 2 files changed, 76 insertions(+) diff --git a/drivers/firmware/arm_scmi/sensors.c b/drivers/firmware/arm_scmi/sensors.c index db1b1ab303da..907f52ecaa32 100644 --- a/drivers/firmware/arm_scmi/sensors.c +++ b/drivers/firmware/arm_scmi/sensors.c @@ -6,6 +6,7 @@ */ #include "common.h" +#include "notify.h" enum scmi_sensor_protocol_cmd { SENSOR_DESCRIPTION_GET = 0x3, @@ -71,6 +72,12 @@ struct scmi_msg_sensor_reading_get { #define SENSOR_READ_ASYNC BIT(0) }; +struct scmi_sensor_trip_notify_payld { + __le32 agent_id; + __le32 sensor_id; + __le32 trip_point_desc; +}; + struct sensors_info { u32 version; int num_sensors; @@ -276,6 +283,62 @@ static struct scmi_sensor_ops sensor_ops = { .reading_get = scmi_sensor_reading_get, }; +static bool scmi_sensor_set_notify_enabled(const struct scmi_handle *handle, + u8 evt_id, u32 src_id, bool enable) +{ + int ret; + + ret = scmi_sensor_trip_point_notify(handle, src_id, enable); + if (ret) + pr_warn("SCMI Notifications - Proto:%X - FAIL_ENABLED - evt[%X] dom[%d] - ret:%d\n", + SCMI_PROTOCOL_SENSOR, evt_id, src_id, ret); + + return !ret ? true : false; +} + +static void *scmi_sensor_fill_custom_report(u8 evt_id, u64 timestamp, + const void *payld, size_t payld_sz, + void *report, u32 *src_id) +{ + void *rep = NULL; + + switch (evt_id) { + case SENSOR_TRIP_POINT_EVENT: + { + const struct scmi_sensor_trip_notify_payld *p = payld; + struct scmi_sensor_trip_point_report *r = report; + + if (sizeof(*p) != payld_sz) + break; + + r->timestamp = timestamp; + r->agent_id = le32_to_cpu(p->agent_id); + r->sensor_id = le32_to_cpu(p->sensor_id); + r->trip_point_desc = le32_to_cpu(p->trip_point_desc); + *src_id = r->sensor_id; + rep = r; + break; + } + default: + break; + } + + return rep; +} + +static const struct scmi_event sensor_events[] = { + { + .evt_id = SENSOR_TRIP_POINT_EVENT, + .max_payld_sz = 12, + .max_report_sz = sizeof(struct scmi_sensor_trip_point_report), + }, +}; + +static const struct scmi_protocol_event_ops sensor_event_ops = { + .set_notify_enabled = scmi_sensor_set_notify_enabled, + .fill_custom_report = scmi_sensor_fill_custom_report, +}; + static int scmi_sensors_protocol_init(struct scmi_handle *handle) { u32 version; @@ -299,6 +362,12 @@ static int scmi_sensors_protocol_init(struct scmi_handle *handle) scmi_sensor_description_get(handle, sinfo); + scmi_register_protocol_events(handle, + SCMI_PROTOCOL_SENSOR, PAGE_SIZE, + &sensor_event_ops, sensor_events, + ARRAY_SIZE(sensor_events), + sinfo->num_sensors); + sinfo->version = version; handle->sensor_ops = &sensor_ops; handle->sensor_priv = sinfo; diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h index 5e7c28c8bcac..23408dacc69d 100644 --- a/include/linux/scmi_protocol.h +++ b/include/linux/scmi_protocol.h @@ -407,4 +407,11 @@ struct scmi_perf_level_report { u32 performance_level; }; +struct scmi_sensor_trip_point_report { + ktime_t timestamp; + u32 agent_id; + u32 sensor_id; + u32 trip_point_desc; +}; + #endif /* _LINUX_SCMI_PROTOCOL_H */ From patchwork Mon Feb 24 14:41:23 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11400709 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 5E406138D for ; Mon, 24 Feb 2020 14:45:32 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 38B3620828 for ; Mon, 24 Feb 2020 14:45:32 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="cTgUX5p5" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 38B3620828 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=IyzuvmTkoKj8ruwdC+aj1QP/Om7bUrZdzOxYfRIi4xI=; b=cTgUX5p5wArbO8wR2Mkq+18oLu c6hQO+J+SNVd/tIdNyoETkLMqPZno1BY9X46A+58SYdasgkbxGQsqhQPSjX7nqSkGkoAoCenW9Fwf p5g73JyP+UKMg4LnHHj4QnsrT0nKkHFsWEcsYC/5i+MrRfRYmD2sOCLrp4JnuL84Za/7n8hAaVEkS mXIzE9vXWsM3WIIBQ89ewS7vY2TiXo8M2acy62jDUz8G1C2z6hmLhJe/NBLDIEY5HHGucS4lR30x+ jLbznKFlNg+ubEZBNDKU8h5qnWLmd/IBpSXIEVdIbTTj7zud//G/HqCOxBPrD/TWpsCUmB926wA5c p3ic0EVg==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6EzC-00079Z-VR; Mon, 24 Feb 2020 14:45:31 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6Ew9-00036q-Ch for linux-arm-kernel@lists.infradead.org; Mon, 24 Feb 2020 14:42:23 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 12CDC113E; Mon, 24 Feb 2020 06:42:21 -0800 (PST) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 125373F534; Mon, 24 Feb 2020 06:42:19 -0800 (PST) From: Cristian Marussi To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [RFC PATCH v3 12/13] firmware: arm_scmi: Add Reset notifications support Date: Mon, 24 Feb 2020 14:41:23 +0000 Message-Id: <20200224144124.2008-13-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200224144124.2008-1-cristian.marussi@arm.com> References: <20200224144124.2008-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200224_064221_535947_4739AE80 X-CRM114-Status: GOOD ( 12.10 ) X-Spam-Score: -2.3 (--) X-Spam-Report: SpamAssassin version 3.4.3 on bombadil.infradead.org summary: Content analysis details: (-2.3 points) pts rule name description ---- ---------------------- -------------------------------------------------- -2.3 RCVD_IN_DNSWL_MED RBL: Sender listed at https://www.dnswl.org/, medium trust [217.140.110.172 listed in list.dnswl.org] 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jonathan.Cameron@Huawei.com, cristian.marussi@arm.com, james.quinlan@broadcom.com, lukasz.luba@arm.com, sudeep.holla@arm.com MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Make SCMI Reset protocol register with the notification core. Signed-off-by: Cristian Marussi --- V2 --> V3 - added handle awareness V1 --> V2 - simplified .set_notify_enabled() implementation moving the ALL_SRCIDs logic out of protocol. ALL_SRCIDs logic is now in charge of the notification core, together with proper reference counting of enables - switched to devres protocol-registration --- drivers/firmware/arm_scmi/reset.c | 96 +++++++++++++++++++++++++++++++ include/linux/scmi_protocol.h | 6 ++ 2 files changed, 102 insertions(+) diff --git a/drivers/firmware/arm_scmi/reset.c b/drivers/firmware/arm_scmi/reset.c index de73054554f3..7c0633b66edf 100644 --- a/drivers/firmware/arm_scmi/reset.c +++ b/drivers/firmware/arm_scmi/reset.c @@ -6,6 +6,7 @@ */ #include "common.h" +#include "notify.h" enum scmi_reset_protocol_cmd { RESET_DOMAIN_ATTRIBUTES = 0x3, @@ -40,6 +41,17 @@ struct scmi_msg_reset_domain_reset { #define ARCH_COLD_RESET (ARCH_RESET_TYPE | COLD_RESET_STATE) }; +struct scmi_msg_reset_notify { + __le32 id; + __le32 event_control; +#define RESET_TP_NOTIFY_ALL BIT(0) +}; + +struct scmi_reset_issued_notify_payld { + __le32 domain_id; + __le32 reset_state; +}; + struct reset_dom_info { bool async_reset; bool reset_notify; @@ -190,6 +202,84 @@ static struct scmi_reset_ops reset_ops = { .deassert = scmi_reset_domain_deassert, }; +static int scmi_reset_notify(const struct scmi_handle *handle, u32 domain_id, + bool enable) +{ + int ret; + u32 evt_cntl = enable ? RESET_TP_NOTIFY_ALL : 0; + struct scmi_xfer *t; + struct scmi_msg_reset_notify *cfg; + + ret = scmi_xfer_get_init(handle, RESET_NOTIFY, + SCMI_PROTOCOL_RESET, sizeof(*cfg), 0, &t); + if (ret) + return ret; + + cfg = t->tx.buf; + cfg->id = cpu_to_le32(domain_id); + cfg->event_control = cpu_to_le32(evt_cntl); + + ret = scmi_do_xfer(handle, t); + + scmi_xfer_put(handle, t); + return ret; +} + +static bool scmi_reset_set_notify_enabled(const struct scmi_handle *handle, + u8 evt_id, u32 src_id, bool enable) +{ + int ret; + + ret = scmi_reset_notify(handle, src_id, enable); + if (ret) + pr_warn("SCMI Notifications - Proto:%X - FAIL_ENABLED - evt[%X] dom[%d] - ret:%d\n", + SCMI_PROTOCOL_RESET, evt_id, src_id, ret); + + return !ret ? true : false; +} + +static void *scmi_reset_fill_custom_report(u8 evt_id, u64 timestamp, + const void *payld, size_t payld_sz, + void *report, u32 *src_id) +{ + void *rep = NULL; + + switch (evt_id) { + case RESET_ISSUED: + { + const struct scmi_reset_issued_notify_payld *p = payld; + struct scmi_reset_issued_report *r = report; + + if (sizeof(*p) != payld_sz) + break; + + r->timestamp = timestamp; + r->domain_id = le32_to_cpu(p->domain_id); + r->reset_state = le32_to_cpu(p->reset_state); + *src_id = r->domain_id; + rep = r; + break; + } + default: + break; + } + + return rep; +} + +static const struct scmi_event reset_events[] = { + { + .evt_id = RESET_NOTIFY, + .max_payld_sz = 8, + .max_report_sz = sizeof(struct scmi_reset_issued_report), + }, +}; + +static const struct scmi_protocol_event_ops reset_event_ops = { + .set_notify_enabled = scmi_reset_set_notify_enabled, + .fill_custom_report = scmi_reset_fill_custom_report, +}; + static int scmi_reset_protocol_init(struct scmi_handle *handle) { int domain; @@ -218,6 +308,12 @@ static int scmi_reset_protocol_init(struct scmi_handle *handle) scmi_reset_domain_attributes_get(handle, domain, dom); } + scmi_register_protocol_events(handle, + SCMI_PROTOCOL_RESET, PAGE_SIZE, + &reset_event_ops, reset_events, + ARRAY_SIZE(reset_events), + pinfo->num_domains); + pinfo->version = version; handle->reset_ops = &reset_ops; handle->reset_priv = pinfo; diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h index 23408dacc69d..91c5fdf567d5 100644 --- a/include/linux/scmi_protocol.h +++ b/include/linux/scmi_protocol.h @@ -414,4 +414,10 @@ struct scmi_sensor_trip_point_report { u32 trip_point_desc; }; +struct scmi_reset_issued_report { + ktime_t timestamp; + u32 domain_id; + u32 reset_state; +}; + #endif /* _LINUX_SCMI_PROTOCOL_H */ From patchwork Mon Feb 24 14:41:24 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Marussi X-Patchwork-Id: 11400711 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 59C6E138D for ; Mon, 24 Feb 2020 14:45:49 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 0FE2920714 for ; Mon, 24 Feb 2020 14:45:49 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="ExNR5aIQ" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 0FE2920714 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=WgbONxvw87FQd+VCm3feJSGT/hUgPWtIoZMNS1q1esA=; b=ExNR5aIQkD6OD9HQYZ+HO0MvS2 HXk+D6J/h/MfbRpRIWd4KCqdN1hW+rcbVKN8gSZd+QLadSwDnoccLXK5WnuiaXYHNGOHqFrsSzMNi oqK9DOo0ayQiTprCwx6k7kotIS7YdfPMB3t7Hy8i+bE4774QGacDRwXduT7Tsu6ctwA2UP2Z2E9Xe NxpewyxZxZjBbrS7FMlmlCH1idtLjLlXiue3q/WinnE5LYybR7v2/kQ8d45meZ7gWDqjB9kjRHP99 tg1HXo2TIzZemrtNOamzWO/EgFnfDh+PH+pRrSxF++R29D2I6MElFoq8bqfz973laNNfQt7FcvDMi /xGgkScg==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6EzT-0007Ql-0G; Mon, 24 Feb 2020 14:45:47 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6EwA-0003GU-Og for linux-arm-kernel@lists.infradead.org; Mon, 24 Feb 2020 14:42:25 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 7FC3330E; Mon, 24 Feb 2020 06:42:22 -0800 (PST) Received: from e120937-lin.cambridge.arm.com (e120937-lin.cambridge.arm.com [10.1.197.50]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 465AE3F534; Mon, 24 Feb 2020 06:42:21 -0800 (PST) From: Cristian Marussi To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [RFC PATCH v3 13/13] firmware: arm_scmi: Add Base notifications support Date: Mon, 24 Feb 2020 14:41:24 +0000 Message-Id: <20200224144124.2008-14-cristian.marussi@arm.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200224144124.2008-1-cristian.marussi@arm.com> References: <20200224144124.2008-1-cristian.marussi@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200224_064223_064062_D3C3C8BB X-CRM114-Status: GOOD ( 14.22 ) X-Spam-Score: -2.3 (--) X-Spam-Report: SpamAssassin version 3.4.3 on bombadil.infradead.org summary: Content analysis details: (-2.3 points) pts rule name description ---- ---------------------- -------------------------------------------------- -2.3 RCVD_IN_DNSWL_MED RBL: Sender listed at https://www.dnswl.org/, medium trust [217.140.110.172 listed in list.dnswl.org] 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record -0.0 SPF_PASS SPF: sender matches SPF record X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jonathan.Cameron@Huawei.com, cristian.marussi@arm.com, james.quinlan@broadcom.com, lukasz.luba@arm.com, sudeep.holla@arm.com MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org Make SCMI Base protocol register with the notification core. Signed-off-by: Cristian Marussi --- V2 --> V3 - added handle awareness V1 --> V2 - simplified .set_notify_enabled() implementation moving the ALL_SRCIDs logic out of protocol. ALL_SRCIDs logic is now in charge of the notification core, together with proper reference counting of enables - switched to devres protocol-registration --- drivers/firmware/arm_scmi/base.c | 109 +++++++++++++++++++++++++++++++ include/linux/scmi_protocol.h | 8 +++ 2 files changed, 117 insertions(+) diff --git a/drivers/firmware/arm_scmi/base.c b/drivers/firmware/arm_scmi/base.c index ce7d9203e41b..0d4bbf313a4a 100644 --- a/drivers/firmware/arm_scmi/base.c +++ b/drivers/firmware/arm_scmi/base.c @@ -6,6 +6,9 @@ */ #include "common.h" +#include "notify.h" + +#define SCMI_BASE_NUM_SOURCES 1 enum scmi_base_protocol_cmd { BASE_DISCOVER_VENDOR = 0x3, @@ -29,6 +32,19 @@ struct scmi_msg_resp_base_attributes { __le16 reserved; }; +struct scmi_msg_base_error_notify { + __le32 event_control; +#define BASE_TP_NOTIFY_ALL BIT(0) +}; + +struct scmi_base_error_notify_payld { + __le32 agent_id; + __le32 error_status; +#define IS_FATAL_ERROR(x) ((x) & BIT(31)) +#define ERROR_CMD_COUNT(x) FIELD_GET(GENMASK(9, 0), (x)) + __le64 msg_reports[8192]; +}; + /** * scmi_base_attributes_get() - gets the implementation details * that are associated with the base protocol. @@ -222,6 +238,93 @@ static int scmi_base_discover_agent_get(const struct scmi_handle *handle, return ret; } +static int scmi_base_error_notify(const struct scmi_handle *handle, bool enable) +{ + int ret; + u32 evt_cntl = enable ? BASE_TP_NOTIFY_ALL : 0; + struct scmi_xfer *t; + struct scmi_msg_base_error_notify *cfg; + + ret = scmi_xfer_get_init(handle, BASE_NOTIFY_ERRORS, + SCMI_PROTOCOL_BASE, sizeof(*cfg), 0, &t); + if (ret) + return ret; + + cfg = t->tx.buf; + cfg->event_control = cpu_to_le32(evt_cntl); + + ret = scmi_do_xfer(handle, t); + + scmi_xfer_put(handle, t); + return ret; +} + +static bool scmi_base_set_notify_enabled(const struct scmi_handle *handle, + u8 evt_id, u32 src_id, bool enable) +{ + int ret; + + ret = scmi_base_error_notify(handle, enable); + if (ret) + pr_warn("SCMI Notifications - Proto:%X - FAIL_ENABLED - evt[%X] ret:%d\n", + SCMI_PROTOCOL_BASE, evt_id, ret); + + return !ret ? true : false; +} + +static void *scmi_base_fill_custom_report(u8 evt_id, u64 timestamp, + const void *payld, size_t payld_sz, + void *report, u32 *src_id) +{ + void *rep = NULL; + + switch (evt_id) { + case BASE_ERROR_EVENT: + { + int i; + const struct scmi_base_error_notify_payld *p = payld; + struct scmi_base_error_report *r = report; + + /* + * BaseError notification payload is variable in size but + * up to a maximum length determined by the struct ponted by p. + * Instead payld_sz is the effective length of this notification + * payload so cannot be greater of the maximum allowed size as + * pointed by p. + */ + if (sizeof(*p) < payld_sz) + break; + + r->timestamp = timestamp; + r->agent_id = le32_to_cpu(p->agent_id); + r->fatal = IS_FATAL_ERROR(le32_to_cpu(p->error_status)); + r->cmd_count = ERROR_CMD_COUNT(le32_to_cpu(p->error_status)); + for (i = 0; i < r->cmd_count; i++) + r->reports[i] = le64_to_cpu(p->msg_reports[i]); + *src_id = 0; + rep = r; + break; + } + default: + break; + } + + return rep; +} + +static const struct scmi_event base_events[] = { + { + .evt_id = BASE_ERROR_EVENT, + .max_payld_sz = 8192, + .max_report_sz = sizeof(struct scmi_base_error_report), + }, +}; + +static const struct scmi_protocol_event_ops base_event_ops = { + .set_notify_enabled = scmi_base_set_notify_enabled, + .fill_custom_report = scmi_base_fill_custom_report, +}; + int scmi_base_protocol_init(struct scmi_handle *h) { int id, ret; @@ -256,6 +359,12 @@ int scmi_base_protocol_init(struct scmi_handle *h) dev_dbg(dev, "Found %d protocol(s) %d agent(s)\n", rev->num_protocols, rev->num_agents); + scmi_register_protocol_events(handle, + SCMI_PROTOCOL_BASE, (4 * PAGE_SIZE), + &base_event_ops, base_events, + ARRAY_SIZE(base_events), + SCMI_BASE_NUM_SOURCES); + for (id = 0; id < rev->num_agents; id++) { scmi_base_discover_agent_get(handle, id, name); dev_dbg(dev, "Agent %d: %s\n", id, name); diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h index 91c5fdf567d5..3a1bc8014f51 100644 --- a/include/linux/scmi_protocol.h +++ b/include/linux/scmi_protocol.h @@ -420,4 +420,12 @@ struct scmi_reset_issued_report { u32 reset_state; }; +struct scmi_base_error_report { + ktime_t timestamp; + u32 agent_id; + bool fatal; + u16 cmd_count; + u64 reports[8192]; +}; + #endif /* _LINUX_SCMI_PROTOCOL_H */