From patchwork Thu Sep 28 13:11:29 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 114442 Delivered-To: patch@linaro.org Received: by 10.140.106.117 with SMTP id d108csp732408qgf; Thu, 28 Sep 2017 06:18:43 -0700 (PDT) X-Google-Smtp-Source: AOwi7QBnNRmxmIp6493YfyyUkQiu6/equbgUpfP9CxDy+cKSIQojtkX5zsUsm6ejpZlJ9N6VAivU X-Received: by 10.84.238.139 with SMTP id v11mr4069715plk.344.1506604723280; Thu, 28 Sep 2017 06:18:43 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1506604723; cv=none; d=google.com; s=arc-20160816; b=hVTyqxyQf8xIlKK2Oo+zBYZArAZohTJ6O82m95tqYwM833D8TE+fypy0DHUbkkv6I5 TgM0QC2p7n6AHuO1NQssjOlUwZCj25KADO+NjgTPjMf8UlaZTN64B2L1P3UwOwqH7inx fyvo9r5lLaDEXie+kGZ6WrJtr81cOgSwt42NVnfKyTJ0Q5VdOcmn1P0JJ+oLbs3Lah35 Vhdru2kdkPz4v67v596kX8IgjfteJjSrsd/hO7rWiY3smirr3CRLMVXapgIsS/8dNBar dga4ILmhczimPUkixFKicOGweJZaxg//pYirYJz3MuGWtc3gxmDOjBPbRKuBqt4F8IdV fpnA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:arc-authentication-results; bh=0TbTsZ02MQFX35msv3HhZs1ikGrWBZKMgpIrxuhiQ/Y=; b=GzjeVC6UT/tMbZruASXslLYJcUXq7b9lE0/JSnazd0NbvQhwc44JOadwNxOu4Ooj5M 1R6EI3wsb3XPEOhNP49uT3FpiAiKj7uMK7IppQC1VAXmYmAuhk8HqGg2UTNOovNh/Frb pMnz2hOqNl9U/ax/GO3R5dUuE7oKVR8JfhhTA8V3pDh8nA53LY4C2Y42Q0/6HFtF/g/j 8TKgzsXta9FWGjh3Vd+A6dbI/8C7Xy43RNSj8OxAfZptv77TpN6VGzBOBphtzjZpOpaX tVSywzGa30GO5Zo2a1IOITOFtv2EaMNmvFogDoZhGduSXUyaudDjpaEIH03kFZDwPZMZ IvVA== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: best guess record for domain of devicetree-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=devicetree-owner@vger.kernel.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id bf3si1407174plb.498.2017.09.28.06.18.43; Thu, 28 Sep 2017 06:18:43 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of devicetree-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; spf=pass (google.com: best guess record for domain of devicetree-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=devicetree-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753107AbdI1NSl (ORCPT + 6 others); Thu, 28 Sep 2017 09:18:41 -0400 Received: from usa-sjc-mx-foss1.foss.arm.com ([217.140.101.70]:56998 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753252AbdI1NOQ (ORCPT ); Thu, 28 Sep 2017 09:14:16 -0400 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.72.51.249]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 8754F1682; Thu, 28 Sep 2017 06:14:16 -0700 (PDT) Received: from e107155-lin.cambridge.arm.com (unknown [10.1.210.28]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPA id 74BBB3F483; Thu, 28 Sep 2017 06:14:14 -0700 (PDT) From: Sudeep Holla To: ALKML , LKML , DTML Cc: Sudeep Holla , Roy Franz , Harb Abdulhamid , Nishanth Menon , Arnd Bergmann , Loc Ho , Alexey Klimov , Ryan Harkin , Jassi Brar Subject: [PATCH v3 05/22] firmware: arm_scmi: add common infrastructure and support for base protocol Date: Thu, 28 Sep 2017 14:11:29 +0100 Message-Id: <1506604306-20739-6-git-send-email-sudeep.holla@arm.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1506604306-20739-1-git-send-email-sudeep.holla@arm.com> References: <1506604306-20739-1-git-send-email-sudeep.holla@arm.com> Sender: devicetree-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org The base protocol describes the properties of the implementation and provide generic error management. The base protocol provides commands to describe protocol version, discover implementation specific attributes and vendor/sub-vendor identification, list of protocols implemented and the various agents are in the system including OSPM and the platform. It also supports registering for notifications of platform errors. This protocol is mandatory. This patch adds support for the same along with some basic infrastructure to add support for other protocols. Cc: Arnd Bergmann Signed-off-by: Sudeep Holla --- drivers/firmware/arm_scmi/Makefile | 2 +- drivers/firmware/arm_scmi/base.c | 293 +++++++++++++++++++++++++++++++++++++ drivers/firmware/arm_scmi/common.h | 46 ++++++ drivers/firmware/arm_scmi/driver.c | 68 +++++++++ include/linux/scmi_protocol.h | 28 ++++ 5 files changed, 436 insertions(+), 1 deletion(-) create mode 100644 drivers/firmware/arm_scmi/base.c -- 2.7.4 -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html diff --git a/drivers/firmware/arm_scmi/Makefile b/drivers/firmware/arm_scmi/Makefile index 58e94c95e523..21d01d1d6b9c 100644 --- a/drivers/firmware/arm_scmi/Makefile +++ b/drivers/firmware/arm_scmi/Makefile @@ -1,2 +1,2 @@ obj-$(CONFIG_ARM_SCMI_PROTOCOL) = arm_scmi.o -arm_scmi-y = driver.o +arm_scmi-y = base.o driver.o diff --git a/drivers/firmware/arm_scmi/base.c b/drivers/firmware/arm_scmi/base.c new file mode 100644 index 000000000000..2b5fbb724899 --- /dev/null +++ b/drivers/firmware/arm_scmi/base.c @@ -0,0 +1,293 @@ +/* + * System Control and Management Interface (SCMI) Base Protocol + * + * Copyright (C) 2017 ARM Ltd. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#include "common.h" + +enum scmi_base_protocol_cmd { + BASE_DISCOVER_VENDOR = 0x3, + BASE_DISCOVER_SUB_VENDOR = 0x4, + BASE_DISCOVER_IMPLEMENT_VERSION = 0x5, + BASE_DISCOVER_LIST_PROTOCOLS = 0x6, + BASE_DISCOVER_AGENT = 0x7, + BASE_NOTIFY_ERRORS = 0x8, +}; + +struct scmi_msg_resp_base_attributes { + u8 num_protocols; + u8 num_agents; + __le16 reserved; +}; + +/** + * scmi_base_attributes_get() - gets the implementation details + * that are associated with the base protocol. + * + * @handle - SCMI entity handle + * + * Return: 0 on success, else appropriate SCMI error. + */ +static int scmi_base_attributes_get(const struct scmi_handle *handle) +{ + int ret; + struct scmi_xfer *t; + struct scmi_msg_resp_base_attributes *attr_info; + struct scmi_revision_info *rev = handle->version; + + ret = scmi_one_xfer_init(handle, PROTOCOL_ATTRIBUTES, + SCMI_PROTOCOL_BASE, 0, sizeof(*attr_info), &t); + if (ret) + return ret; + + ret = scmi_do_xfer(handle, t); + if (!ret) { + attr_info = t->rx.buf; + rev->num_protocols = attr_info->num_protocols; + rev->num_agents = attr_info->num_agents; + } + + scmi_one_xfer_put(handle, t); + return ret; +} + +/** + * scmi_base_vendor_id_get() - gets vendor/subvendor identifier ASCII string. + * + * @handle - SCMI entity handle + * @sub_vendor - specify true if sub-vendor ID is needed + * + * Return: 0 on success, else appropriate SCMI error. + */ +static int +scmi_base_vendor_id_get(const struct scmi_handle *handle, bool sub_vendor) +{ + u8 cmd; + int ret, size; + char *vendor_id; + struct scmi_xfer *t; + struct scmi_revision_info *rev = handle->version; + + if (sub_vendor) { + cmd = BASE_DISCOVER_SUB_VENDOR; + vendor_id = rev->sub_vendor_id; + size = ARRAY_SIZE(rev->sub_vendor_id); + } else { + cmd = BASE_DISCOVER_VENDOR; + vendor_id = rev->vendor_id; + size = ARRAY_SIZE(rev->vendor_id); + } + + ret = scmi_one_xfer_init(handle, cmd, SCMI_PROTOCOL_BASE, 0, size, &t); + if (ret) + return ret; + + ret = scmi_do_xfer(handle, t); + if (!ret) + memcpy(vendor_id, t->rx.buf, size); + + scmi_one_xfer_put(handle, t); + return ret; +} + +/** + * scmi_base_implementation_version_get() - gets a vendor-specific + * implementation 32-bit version. The format of the version number is + * vendor-specific + * + * @handle - SCMI entity handle + * + * Return: 0 on success, else appropriate SCMI error. + */ +static int +scmi_base_implementation_version_get(const struct scmi_handle *handle) +{ + int ret; + __le32 *impl_ver; + struct scmi_xfer *t; + struct scmi_revision_info *rev = handle->version; + + ret = scmi_one_xfer_init(handle, BASE_DISCOVER_IMPLEMENT_VERSION, + SCMI_PROTOCOL_BASE, 0, sizeof(*impl_ver), &t); + if (ret) + return ret; + + ret = scmi_do_xfer(handle, t); + if (!ret) { + impl_ver = t->rx.buf; + rev->impl_ver = le32_to_cpu(*impl_ver); + } + + scmi_one_xfer_put(handle, t); + return ret; +} + +/** + * scmi_base_implementation_list_get() - gets the list of protocols it is + * OSPM is allowed to access + * + * @handle - SCMI entity handle + * @protocols_imp - pointer to hold the list of protocol identifiers + * + * Return: 0 on success, else appropriate SCMI error. + */ +static int scmi_base_implementation_list_get(const struct scmi_handle *handle, + u8 *protocols_imp) +{ + u8 *list; + int ret, loop; + struct scmi_xfer *t; + __le32 *num_skip, *num_ret; + u32 tot_num_ret = 0, loop_num_ret; + struct device *dev = handle->dev; + + ret = scmi_one_xfer_init(handle, BASE_DISCOVER_LIST_PROTOCOLS, + SCMI_PROTOCOL_BASE, sizeof(*num_skip), 0, &t); + if (ret) + return ret; + + num_skip = t->tx.buf; + num_ret = t->rx.buf; + list = t->rx.buf + sizeof(*num_ret); + + do { + /* Set the number of protocols to be skipped/already read */ + *num_skip = cpu_to_le32(tot_num_ret); + + ret = scmi_do_xfer(handle, t); + if (ret) + break; + + loop_num_ret = le32_to_cpu(*num_ret); + if (tot_num_ret + loop_num_ret > MAX_PROTOCOLS_IMP) { + dev_err(dev, "No. of Protocol > MAX_PROTOCOLS_IMP"); + break; + } + + for (loop = 0; loop < loop_num_ret; loop++) + protocols_imp[tot_num_ret + loop] = *(list + loop); + + tot_num_ret += loop_num_ret; + } while (loop_num_ret); + + scmi_one_xfer_put(handle, t); + return ret; +} + +/** + * scmi_base_discover_agent_get() - discover the name of an agent + * + * @handle - SCMI entity handle + * @id - Agent identifier + * @name - Agent identifier ASCII string + * + * An agent id of 0 is reserved to identify the platform itself. + * Generally operating system is represented as "OSPM" + * + * Return: 0 on success, else appropriate SCMI error. + */ +static int scmi_base_discover_agent_get(const struct scmi_handle *handle, + int id, char *name) +{ + int ret; + struct scmi_xfer *t; + + ret = scmi_one_xfer_init(handle, BASE_DISCOVER_AGENT, + SCMI_PROTOCOL_BASE, sizeof(__le32), + SCMI_MAX_STR_SIZE, &t); + if (ret) + return ret; + + *(__le32 *)t->tx.buf = cpu_to_le32(id); + + ret = scmi_do_xfer(handle, t); + if (!ret) + memcpy(name, t->rx.buf, SCMI_MAX_STR_SIZE); + + scmi_one_xfer_put(handle, t); + return ret; +} + +/** + * scmi_base_error_notifications_enable() - register/unregister for + * notifications of errors in the platform + * + * @handle - SCMI entity handle + * @enable - Enable/Disable the notification + * + * Return: 0 on success, else appropriate SCMI error. + */ +static int +scmi_base_error_notifications_enable(const struct scmi_handle *handle, bool en) +{ + int ret; + struct scmi_xfer *t; + + ret = scmi_one_xfer_init(handle, BASE_NOTIFY_ERRORS, SCMI_PROTOCOL_BASE, + sizeof(__le32), 0, &t); + if (ret) + return ret; + + *(__le32 *)t->tx.buf = cpu_to_le32(en & BIT(0)); + + ret = scmi_do_xfer(handle, t); + + scmi_one_xfer_put(handle, t); + return ret; +} + +int scmi_base_protocol_init(struct scmi_handle *h) +{ + int id, ret; + u8 *prot_imp; + u32 version; + char name[SCMI_MAX_STR_SIZE]; + const struct scmi_handle *handle = h; + struct device *dev = handle->dev; + struct scmi_revision_info *rev = handle->version; + + ret = scmi_version_get(handle, SCMI_PROTOCOL_BASE, &version); + if (ret) + return ret; + + prot_imp = devm_kcalloc(dev, MAX_PROTOCOLS_IMP, sizeof(u8), GFP_KERNEL); + if (!prot_imp) + return -ENOMEM; + + rev->major_ver = PROTOCOL_REV_MAJOR(version), + rev->minor_ver = PROTOCOL_REV_MINOR(version); + + scmi_base_attributes_get(handle); + scmi_base_vendor_id_get(handle, false); + scmi_base_vendor_id_get(handle, true); + scmi_base_implementation_version_get(handle); + scmi_base_implementation_list_get(handle, prot_imp); + scmi_base_error_notifications_enable(handle, true); + scmi_setup_protocol_implemented(handle, prot_imp); + + dev_info(dev, "SCMI Protocol v%d.%d '%s:%s' Firmware version 0x%x\n", + rev->major_ver, rev->minor_ver, rev->vendor_id, + rev->sub_vendor_id, rev->impl_ver); + dev_dbg(dev, "Found %d protocol(s) %d agent(s)\n", rev->num_protocols, + rev->num_agents); + + 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); + } + + return 0; +} diff --git a/drivers/firmware/arm_scmi/common.h b/drivers/firmware/arm_scmi/common.h index 344b234d4e64..7a30a517a10b 100644 --- a/drivers/firmware/arm_scmi/common.h +++ b/drivers/firmware/arm_scmi/common.h @@ -19,9 +19,50 @@ */ #include +#include +#include +#include #include #include +#define PROTOCOL_REV_MINOR_BITS 16 +#define PROTOCOL_REV_MINOR_MASK ((1U << PROTOCOL_REV_MINOR_BITS) - 1) +#define PROTOCOL_REV_MAJOR(x) ((x) >> PROTOCOL_REV_MINOR_BITS) +#define PROTOCOL_REV_MINOR(x) ((x) & PROTOCOL_REV_MINOR_MASK) +#define MAX_PROTOCOLS_IMP 16 + +enum scmi_std_protocol { + SCMI_PROTOCOL_BASE = 0x10, + SCMI_PROTOCOL_POWER = 0x11, + SCMI_PROTOCOL_SYSTEM = 0x12, + SCMI_PROTOCOL_PERF = 0x13, + SCMI_PROTOCOL_CLOCK = 0x14, + SCMI_PROTOCOL_SENSOR = 0x15, +}; + +enum scmi_common_cmd { + PROTOCOL_VERSION = 0x0, + PROTOCOL_ATTRIBUTES = 0x1, + PROTOCOL_MESSAGE_ATTRIBUTES = 0x2, +}; + +/** + * struct scmi_msg_resp_prot_version - Response for a message + * + * @major_version: Major version of the ABI that firmware supports + * @minor_version: Minor version of the ABI that firmware supports + * + * In general, ABI version changes follow the rule that minor version increments + * are backward compatible. Major revision changes in ABI may not be + * backward compatible. + * + * Response to a generic message with message type SCMI_MSG_VERSION + */ +struct scmi_msg_resp_prot_version { + __le16 minor_version; + __le16 major_version; +}; + /** * struct scmi_msg_hdr - Message(Tx/Rx) header * @@ -73,3 +114,8 @@ void scmi_one_xfer_put(const struct scmi_handle *h, struct scmi_xfer *xfer); int scmi_do_xfer(const struct scmi_handle *h, struct scmi_xfer *xfer); int scmi_one_xfer_init(const struct scmi_handle *h, u8 msg_id, u8 prot_id, size_t tx_size, size_t rx_size, struct scmi_xfer **p); +int scmi_version_get(const struct scmi_handle *h, u8 protocol, u32 *version); +void scmi_setup_protocol_implemented(const struct scmi_handle *handle, + u8 *prot_imp); + +int scmi_base_protocol_init(struct scmi_handle *h); diff --git a/drivers/firmware/arm_scmi/driver.c b/drivers/firmware/arm_scmi/driver.c index 1d556a928de9..5df76512a291 100644 --- a/drivers/firmware/arm_scmi/driver.c +++ b/drivers/firmware/arm_scmi/driver.c @@ -108,21 +108,27 @@ struct scmi_desc { * @dev: Device pointer * @desc: SoC description for this instance * @handle: Instance of SCMI handle to send to clients + * @version: SCMI revision information containing protocol version, + * implementation version and (sub-)vendor identification. * @cl: Mailbox Client * @tx_chan: Transmit mailbox channel * @tx_payload: Transmit mailbox channel payload area * @minfo: Message info + * @protocols_imp: list of protocols implemented, currently maximum of + * MAX_PROTOCOLS_IMP elements allocated by the base protocol * @node: list head * @users: Number of users of this instance */ struct scmi_info { struct device *dev; const struct scmi_desc *desc; + struct scmi_revision_info version; struct scmi_handle handle; struct mbox_client cl; struct mbox_chan *tx_chan; void __iomem *tx_payload; struct scmi_xfers_info minfo; + u8 *protocols_imp; struct list_head node; int users; }; @@ -450,6 +456,60 @@ int scmi_one_xfer_init(const struct scmi_handle *handle, u8 msg_id, u8 prot_id, } /** + * scmi_version_get() - command to get the revision of the SCMI entity + * + * @handle: Handle to SCMI entity information + * + * Updates the SCMI information in the internal data structure. + * + * Return: 0 if all went fine, else return appropriate error. + */ +int scmi_version_get(const struct scmi_handle *handle, u8 protocol, + u32 *version) +{ + int ret; + __le32 *rev_info; + struct scmi_xfer *t; + + ret = scmi_one_xfer_init(handle, PROTOCOL_VERSION, protocol, 0, + sizeof(*version), &t); + if (ret) + return ret; + + ret = scmi_do_xfer(handle, t); + if (!ret) { + rev_info = t->rx.buf; + *version = le32_to_cpu(*rev_info); + } + + scmi_one_xfer_put(handle, t); + return ret; +} + +void scmi_setup_protocol_implemented(const struct scmi_handle *handle, + u8 *prot_imp) +{ + struct scmi_info *info = handle_to_scmi_info(handle); + + info->protocols_imp = prot_imp; +} + +static bool +scmi_is_protocol_implemented(const struct scmi_handle *handle, u8 prot_id) +{ + int i; + struct scmi_info *info = handle_to_scmi_info(handle); + + if (!info->protocols_imp) + return false; + + for (i = 0; i < MAX_PROTOCOLS_IMP; i++) + if (info->protocols_imp[i] == prot_id) + return true; + return false; +} + +/** * scmi_handle_get() - Get the SCMI handle for a device * * @dev: pointer to device for which we want SCMI handle @@ -740,11 +800,19 @@ static int scmi_probe(struct platform_device *pdev) handle = &info->handle; handle->dev = info->dev; + handle->version = &info->version; ret = scmi_mbox_chan_setup(info); if (ret) return ret; + ret = scmi_base_protocol_init(handle); + if (ret) { + dev_err(dev, "unable to communicate with SCMI(%d)\n", ret); + scmi_mbox_free_channel(info); + return ret; + } + mutex_lock(&scmi_list_mutex); list_add_tail(&info->node, &scmi_list); mutex_unlock(&scmi_list_mutex); diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h index fbe80fa1ec9f..3ef2d48f03c2 100644 --- a/include/linux/scmi_protocol.h +++ b/include/linux/scmi_protocol.h @@ -17,13 +17,41 @@ */ #include +#define SCMI_MAX_STR_SIZE 16 + +/** + * struct scmi_revision_info - version information structure + * + * @major_ver: Major ABI version. Change here implies risk of backward + * compatibility break. + * @minor_ver: Minor ABI version. Change here implies new feature addition, + * or compatible change in ABI. + * @num_protocols: Number of protocols that are implemented, excluding the + * base protocol. + * @num_agents: Number of agents in the system. + * @impl_ver: A vendor-specific implementation version. + * @vendor_id: A vendor identifier(Null terminated ASCII string) + * @sub_vendor_id: A sub-vendor identifier(Null terminated ASCII string) + */ +struct scmi_revision_info { + u16 major_ver; + u16 minor_ver; + u8 num_protocols; + u8 num_agents; + u32 impl_ver; + char vendor_id[SCMI_MAX_STR_SIZE]; + char sub_vendor_id[SCMI_MAX_STR_SIZE]; +}; + /** * struct scmi_handle - Handle returned to ARM SCMI clients for usage. * * @dev: pointer to the SCMI device + * @version: pointer to the structure containing SCMI version information */ struct scmi_handle { struct device *dev; + struct scmi_revision_info *version; }; #if IS_REACHABLE(CONFIG_ARM_SCMI_PROTOCOL) From patchwork Thu Sep 28 13:11:40 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 114430 Delivered-To: patch@linaro.org Received: by 10.140.106.117 with SMTP id d108csp727949qgf; Thu, 28 Sep 2017 06:14:46 -0700 (PDT) X-Google-Smtp-Source: AOwi7QArbawcFd3DyiVQKtjq2q4v7RJdwxmYnFRxlqhtT+8UUkNJXbaYGtWvX6ca1/oCR6luLaxV X-Received: by 10.159.246.5 with SMTP id b5mr4030182pls.109.1506604486045; Thu, 28 Sep 2017 06:14:46 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1506604486; cv=none; d=google.com; s=arc-20160816; b=QjqO81IlzwHiClbIthruWYq+gvFBWVAyR/RaXq0982AmfKY5kRHsVPAuDhS/HT+FQQ 9OiaGIzKLm9fMMVCzWNbzUHxrWD0goKsNakYC7S+bbI0AUWdIL3poW66Aamc8QBdgVsh fRbH5/y5rOCdtTWe7KQKLkgKcM+qinethMwSyZltOuzDtgFooNUjGxA56V3Hmgh5jQbL NFT9EteMqV8AFGyynHIhbIpvfAAAKFF9C5+sW4SEBvVi1GhktipBEIWoO+Ja4L+ykec8 c+yoEQlApN6/nT7EIkZoDNPDHoFIq2HxQuxxKxOfFRkF+ikK2pq/Z3qrtLbJTldGmtQ+ Il1Q== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:arc-authentication-results; bh=VK4a7JMGqOjUhjFdHyDymRbkOBu7WKw4YJWkrvdFWuk=; b=g8xBMXHhj+2Qm3JSoDJw3xfdsHIzTZZGnJ2oLytVLw0BmU8TH4pd2a16LE9KFDAJAp NHW98gMEuXoMv1dalV9BVlf3auF1b8tWRU0gc2OpYg2zQelx0RrhV3YhCN/uTc8D+6HG GLqg5dPVXeom4Hrx+5oH9G+wZTM04pubrt5O8dbr4yt2yEUMLebYUjIzkKwxv0I9N0+z /oAkk+cbBjSu0JJ+ssCHNN9LR7qL8Bwhno+jBVDLXxMAoLDrRR95sG/QpfMEtBGbIlsj CbGczgjv7MEOPeGbtJ5jvf/YqcGKRpqhEEZSRx9V9HIeK9hos3hFp9QVdjioHkdjcx1e z3EQ== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: best guess record for domain of devicetree-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=devicetree-owner@vger.kernel.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id q11si1378625pli.749.2017.09.28.06.14.45; Thu, 28 Sep 2017 06:14:46 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of devicetree-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; spf=pass (google.com: best guess record for domain of devicetree-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=devicetree-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753317AbdI1NOn (ORCPT + 6 others); Thu, 28 Sep 2017 09:14:43 -0400 Received: from usa-sjc-mx-foss1.foss.arm.com ([217.140.101.70]:57198 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752079AbdI1NOm (ORCPT ); Thu, 28 Sep 2017 09:14:42 -0400 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.72.51.249]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 45EB9199B; Thu, 28 Sep 2017 06:14:42 -0700 (PDT) Received: from e107155-lin.cambridge.arm.com (unknown [10.1.210.28]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPA id 334F53F483; Thu, 28 Sep 2017 06:14:40 -0700 (PDT) From: Sudeep Holla To: ALKML , LKML , DTML Cc: Sudeep Holla , Roy Franz , Harb Abdulhamid , Nishanth Menon , Arnd Bergmann , Loc Ho , Alexey Klimov , Ryan Harkin , Jassi Brar Subject: [PATCH v3 16/22] firmware: arm_scmi: add arm_mhu specific mailbox interface Date: Thu, 28 Sep 2017 14:11:40 +0100 Message-Id: <1506604306-20739-17-git-send-email-sudeep.holla@arm.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1506604306-20739-1-git-send-email-sudeep.holla@arm.com> References: <1506604306-20739-1-git-send-email-sudeep.holla@arm.com> Sender: devicetree-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org This patch adds ARM MHU specific mailbox interface for SCMI. Cc: Arnd Bergmann Signed-off-by: Sudeep Holla --- drivers/firmware/arm_scmi/Makefile | 1 + drivers/firmware/arm_scmi/arm_mhu_if.c | 106 +++++++++++++++++++++++++++++++++ drivers/firmware/arm_scmi/driver.c | 3 + drivers/firmware/arm_scmi/mbox_if.h | 3 + 4 files changed, 113 insertions(+) create mode 100644 drivers/firmware/arm_scmi/arm_mhu_if.c -- 2.7.4 -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html diff --git a/drivers/firmware/arm_scmi/Makefile b/drivers/firmware/arm_scmi/Makefile index 733157c5b4e2..7fb026c71833 100644 --- a/drivers/firmware/arm_scmi/Makefile +++ b/drivers/firmware/arm_scmi/Makefile @@ -1,2 +1,3 @@ obj-$(CONFIG_ARM_SCMI_PROTOCOL) = arm_scmi.o arm_scmi-y = base.o clock.o driver.o mbox_if.o perf.o power.o sensors.o +arm_scmi-$(CONFIG_ARM_MHU) += arm_mhu_if.o diff --git a/drivers/firmware/arm_scmi/arm_mhu_if.c b/drivers/firmware/arm_scmi/arm_mhu_if.c new file mode 100644 index 000000000000..2271a4811378 --- /dev/null +++ b/drivers/firmware/arm_scmi/arm_mhu_if.c @@ -0,0 +1,106 @@ +/* + * System Control and Management Interface (SCMI) MHU mailbox interface + * + * Copyright (C) 2017 ARM Ltd. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#include +#include + +#include "common.h" +#include "mbox_if.h" + +union mhu_data { + void *ptr; + u32 val; +}; + +static void mhu_tx_prepare(struct mbox_client *cl, void *m) +{ + struct scmi_chan_info *cinfo = client_to_scmi_chan_info(cl); + union mhu_data tmp; + + scmi_generic_tx_prepare(cinfo, m); + + /* clear only the relavant bit */ + tmp.ptr = cinfo->priv; + *(u32 *)m &= tmp.val; +} + +static void mhu_rx_callback(struct mbox_client *cl, void *m) +{ + struct scmi_chan_info *cinfo = client_to_scmi_chan_info(cl); + + scmi_generic_rx_callback(cinfo); +} + +static int mhu_mbox_request_channel(struct scmi_chan_info *cinfo, int index) +{ + int ret = 0; + struct mbox_client *cl = &cinfo->cl; + struct device_node *np = cl->dev->of_node; + union mhu_data tmp = {0}; + + if (index != 0 && index != 1) /* Tx = 0, Rx =1 */ + return -EINVAL; + + cl->rx_callback = mhu_rx_callback; + cl->tx_prepare = mhu_tx_prepare; + + ret = of_property_read_u32_index(np, "mbox-data", index, &tmp.val); + if (ret) + return ret; + + cinfo->chan = mbox_request_channel(cl, index); + if (IS_ERR(cinfo->chan)) + ret = PTR_ERR(cinfo->chan); + + cinfo->priv = tmp.ptr; + + return ret; +} + +static int mhu_mbox_send_message(struct scmi_chan_info *cinfo, void *msg) +{ + struct scmi_xfer *t = msg; + + t->con_priv = cinfo->priv; + + return mbox_send_message(cinfo->chan, msg); +} + +static void mhu_mbox_client_txdone(struct scmi_chan_info *cinfo, int r) +{ + mbox_client_txdone(cinfo->chan, r); +} + +static void mhu_mbox_free_channel(struct scmi_chan_info *cinfo) +{ + mbox_free_channel(cinfo->chan); +} + +static struct scmi_mbox_ops arm_mhu_mbox_ops = { + .request_channel = mhu_mbox_request_channel, + .send_message = mhu_mbox_send_message, + .client_txdone = mhu_mbox_client_txdone, + .free_channel = mhu_mbox_free_channel, +}; + +const struct scmi_desc mhu_scmi_desc = { + .max_rx_timeout_ms = 30, + .max_msg = 20, + .max_msg_size = 128, + .mbox_ops = &arm_mhu_mbox_ops, +}; diff --git a/drivers/firmware/arm_scmi/driver.c b/drivers/firmware/arm_scmi/driver.c index 97285a22dfaa..bdc9c566e6c1 100644 --- a/drivers/firmware/arm_scmi/driver.c +++ b/drivers/firmware/arm_scmi/driver.c @@ -648,6 +648,9 @@ EXPORT_SYMBOL_GPL(devm_scmi_handle_get); /* Each compatible listed below must have descriptor associated with it */ static const struct of_device_id scmi_of_match[] = { { .compatible = "arm,scmi", .data = &scmi_generic_desc }, +#if IS_REACHABLE(CONFIG_ARM_MHU) + { .compatible = "arm,mhu-scmi", .data = &mhu_scmi_desc }, +#endif { /* Sentinel */ }, }; diff --git a/drivers/firmware/arm_scmi/mbox_if.h b/drivers/firmware/arm_scmi/mbox_if.h index 02baa73e8613..a23fc6d7a91f 100644 --- a/drivers/firmware/arm_scmi/mbox_if.h +++ b/drivers/firmware/arm_scmi/mbox_if.h @@ -66,3 +66,6 @@ void scmi_generic_rx_callback(struct scmi_chan_info *cinfo); void scmi_generic_tx_prepare(struct scmi_chan_info *cinfo, void *m); extern const struct scmi_desc scmi_generic_desc; +#if IS_REACHABLE(CONFIG_ARM_MHU) +extern const struct scmi_desc mhu_scmi_desc; +#endif