Merge tag 'scmi-updates-5.19' of... (a4f7f931) · Commits · EulixOS / Software / Kernel

drivers/firmware/arm_scmi/Kconfig

+1 −0

Original line number	Diff line number	Diff line
		@@ -59,6 +59,7 @@ config ARM_SCMI_TRANSPORT_OPTEE
		depends on OPTEE=y \|\| OPTEE=ARM_SCMI_PROTOCOL
		select ARM_SCMI_HAVE_TRANSPORT
		select ARM_SCMI_HAVE_SHMEM
		select ARM_SCMI_HAVE_MSG
		default y
		help
		This enables the OP-TEE service based transport for SCMI.

drivers/firmware/arm_scmi/base.c

+38 −8

Original line number	Diff line number	Diff line
		@@ -178,6 +178,7 @@ scmi_base_implementation_list_get(const struct scmi_protocol_handle *ph,
		__le32 num_skip, num_ret;
		u32 tot_num_ret = 0, loop_num_ret;
		struct device *dev = ph->dev;
		struct scmi_revision_info *rev = ph->get_priv(ph);

		ret = ph->xops->xfer_get_init(ph, BASE_DISCOVER_LIST_PROTOCOLS,
		sizeof(*num_skip), 0, &t);
		@@ -189,6 +190,9 @@ scmi_base_implementation_list_get(const struct scmi_protocol_handle *ph,
		list = t->rx.buf + sizeof(*num_ret);

		do {
		size_t real_list_sz;
		u32 calc_list_sz;

		/* Set the number of protocols to be skipped/already read */
		*num_skip = cpu_to_le32(tot_num_ret);

		@@ -197,8 +201,30 @@ scmi_base_implementation_list_get(const struct scmi_protocol_handle *ph,
		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");
		if (!loop_num_ret)
		break;

		if (loop_num_ret > rev->num_protocols - tot_num_ret) {
		dev_err(dev,
		"No. Returned protocols > Total protocols.\n");
		break;
		}

		if (t->rx.len < (sizeof(u32) * 2)) {
		dev_err(dev, "Truncated reply - rx.len:%zd\n",
		t->rx.len);
		ret = -EPROTO;
		break;
		}

		real_list_sz = t->rx.len - sizeof(u32);
		calc_list_sz = (1 + (loop_num_ret - 1) / sizeof(u32)) *
		sizeof(u32);
		if (calc_list_sz != real_list_sz) {
		dev_err(dev,
		"Malformed reply - real_sz:%zd calc_sz:%u\n",
		real_list_sz, calc_list_sz);
		ret = -EPROTO;
		break;
		}

		@@ -208,7 +234,7 @@ scmi_base_implementation_list_get(const struct scmi_protocol_handle *ph,
		tot_num_ret += loop_num_ret;

		ph->xops->reset_rx_to_maxsz(ph, t);
		} while (loop_num_ret);
		} while (tot_num_ret < rev->num_protocols);

		ph->xops->xfer_put(ph, t);

		@@ -351,15 +377,19 @@ static int scmi_base_protocol_init(const struct scmi_protocol_handle *ph)
		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);
		ph->set_priv(ph, rev);

		scmi_base_attributes_get(ph);
		ret = scmi_base_attributes_get(ph);
		if (ret)
		return ret;

		prot_imp = devm_kcalloc(dev, rev->num_protocols, sizeof(u8),
		GFP_KERNEL);
		if (!prot_imp)
		return -ENOMEM;

		scmi_base_vendor_id_get(ph, false);
		scmi_base_vendor_id_get(ph, true);
		scmi_base_implementation_version_get(ph);

drivers/firmware/arm_scmi/clock.c

+268 −75

Original line number	Diff line number	Diff line
		@@ -2,13 +2,15 @@
		/*
		* System Control and Management Interface (SCMI) Clock Protocol
		*
		* Copyright (C) 2018-2021 ARM Ltd.
		* Copyright (C) 2018-2022 ARM Ltd.
		*/

		#include <linux/module.h>
		#include <linux/limits.h>
		#include <linux/sort.h>

		#include "common.h"
		#include "protocols.h"
		#include "notify.h"

		enum scmi_clock_protocol_cmd {
		CLOCK_ATTRIBUTES = 0x3,
		@@ -16,6 +18,9 @@ enum scmi_clock_protocol_cmd {
		CLOCK_RATE_SET = 0x5,
		CLOCK_RATE_GET = 0x6,
		CLOCK_CONFIG_SET = 0x7,
		CLOCK_NAME_GET = 0x8,
		CLOCK_RATE_NOTIFY = 0x9,
		CLOCK_RATE_CHANGE_REQUESTED_NOTIFY = 0xA,
		};

		struct scmi_msg_resp_clock_protocol_attributes {
		@@ -27,7 +32,10 @@ struct scmi_msg_resp_clock_protocol_attributes {
		struct scmi_msg_resp_clock_attributes {
		__le32 attributes;
		#define CLOCK_ENABLE BIT(0)
		u8 name[SCMI_MAX_STR_SIZE];
		#define SUPPORTS_RATE_CHANGED_NOTIF(x) ((x) & BIT(31))
		#define SUPPORTS_RATE_CHANGE_REQUESTED_NOTIF(x) ((x) & BIT(30))
		#define SUPPORTS_EXTENDED_NAMES(x) ((x) & BIT(29))
		u8 name[SCMI_SHORT_NAME_MAX_SIZE];
		__le32 clock_enable_latency;
		};

		@@ -68,6 +76,24 @@ struct scmi_clock_set_rate {
		__le32 value_high;
		};

		struct scmi_msg_resp_set_rate_complete {
		__le32 id;
		__le32 rate_low;
		__le32 rate_high;
		};

		struct scmi_msg_clock_rate_notify {
		__le32 clk_id;
		__le32 notify_enable;
		};

		struct scmi_clock_rate_notify_payld {
		__le32 agent_id;
		__le32 clock_id;
		__le32 rate_low;
		__le32 rate_high;
		};

		struct clock_info {
		u32 version;
		int num_clocks;
		@@ -76,6 +102,11 @@ struct clock_info {
		struct scmi_clock_info *clk;
		};

		static enum scmi_clock_protocol_cmd evt_2_cmd[] = {
		CLOCK_RATE_NOTIFY,
		CLOCK_RATE_CHANGE_REQUESTED_NOTIFY,
		};

		static int
		scmi_clock_protocol_attributes_get(const struct scmi_protocol_handle *ph,
		struct clock_info *ci)
		@@ -102,9 +133,11 @@ scmi_clock_protocol_attributes_get(const struct scmi_protocol_handle *ph,
		}

		static int scmi_clock_attributes_get(const struct scmi_protocol_handle *ph,
		u32 clk_id, struct scmi_clock_info *clk)
		u32 clk_id, struct scmi_clock_info *clk,
		u32 version)
		{
		int ret;
		u32 attributes;
		struct scmi_xfer *t;
		struct scmi_msg_resp_clock_attributes *attr;

		@@ -118,16 +151,33 @@ static int scmi_clock_attributes_get(const struct scmi_protocol_handle *ph,

		ret = ph->xops->do_xfer(ph, t);
		if (!ret) {
		u32 latency = 0;
		attributes = le32_to_cpu(attr->attributes);
		strlcpy(clk->name, attr->name, SCMI_MAX_STR_SIZE);
		/* Is optional field clock_enable_latency provided ? */
		if (t->rx.len == sizeof(*attr))
		clk->enable_latency =
		le32_to_cpu(attr->clock_enable_latency);
		} else {
		clk->name[0] = '\0';
		/* clock_enable_latency field is present only since SCMI v3.1 */
		if (PROTOCOL_REV_MAJOR(version) >= 0x2)
		latency = le32_to_cpu(attr->clock_enable_latency);
		clk->enable_latency = latency ? : U32_MAX;
		}

		ph->xops->xfer_put(ph, t);

		/*
		* If supported overwrite short name with the extended one;
		* on error just carry on and use already provided short name.
		*/
		if (!ret && PROTOCOL_REV_MAJOR(version) >= 0x2) {
		if (SUPPORTS_EXTENDED_NAMES(attributes))
		ph->hops->extended_name_get(ph, CLOCK_NAME_GET, clk_id,
		clk->name,
		SCMI_MAX_STR_SIZE);

		if (SUPPORTS_RATE_CHANGED_NOTIF(attributes))
		clk->rate_changed_notifications = true;
		if (SUPPORTS_RATE_CHANGE_REQUESTED_NOTIF(attributes))
		clk->rate_change_requested_notifications = true;
		}

		return ret;
		}

		@@ -143,81 +193,111 @@ static int rate_cmp_func(const void _r1, const void _r2)
		return 1;
		}

		static int
		scmi_clock_describe_rates_get(const struct scmi_protocol_handle *ph, u32 clk_id,
		struct scmi_clock_info *clk)
		{
		u64 *rate = NULL;
		int ret, cnt;
		bool rate_discrete = false;
		u32 tot_rate_cnt = 0, rates_flag;
		u16 num_returned, num_remaining;
		struct scmi_xfer *t;
		struct scmi_msg_clock_describe_rates *clk_desc;
		struct scmi_msg_resp_clock_describe_rates *rlist;

		ret = ph->xops->xfer_get_init(ph, CLOCK_DESCRIBE_RATES,
		sizeof(*clk_desc), 0, &t);
		if (ret)
		return ret;
		struct scmi_clk_ipriv {
		u32 clk_id;
		struct scmi_clock_info *clk;
		};

		clk_desc = t->tx.buf;
		rlist = t->rx.buf;
		static void iter_clk_describe_prepare_message(void *message,
		const unsigned int desc_index,
		const void *priv)
		{
		struct scmi_msg_clock_describe_rates *msg = message;
		const struct scmi_clk_ipriv *p = priv;

		do {
		clk_desc->id = cpu_to_le32(clk_id);
		msg->id = cpu_to_le32(p->clk_id);
		/* Set the number of rates to be skipped/already read */
		clk_desc->rate_index = cpu_to_le32(tot_rate_cnt);
		msg->rate_index = cpu_to_le32(desc_index);
		}

		ret = ph->xops->do_xfer(ph, t);
		if (ret)
		goto err;
		static int
		iter_clk_describe_update_state(struct scmi_iterator_state *st,
		const void response, void priv)
		{
		u32 flags;
		struct scmi_clk_ipriv *p = priv;
		const struct scmi_msg_resp_clock_describe_rates *r = response;

		rates_flag = le32_to_cpu(rlist->num_rates_flags);
		num_remaining = NUM_REMAINING(rates_flag);
		rate_discrete = RATE_DISCRETE(rates_flag);
		num_returned = NUM_RETURNED(rates_flag);
		flags = le32_to_cpu(r->num_rates_flags);
		st->num_remaining = NUM_REMAINING(flags);
		st->num_returned = NUM_RETURNED(flags);
		p->clk->rate_discrete = RATE_DISCRETE(flags);

		if (tot_rate_cnt + num_returned > SCMI_MAX_NUM_RATES) {
		dev_err(ph->dev, "No. of rates > MAX_NUM_RATES");
		break;
		return 0;
		}

		if (!rate_discrete) {
		clk->range.min_rate = RATE_TO_U64(rlist->rate[0]);
		clk->range.max_rate = RATE_TO_U64(rlist->rate[1]);
		clk->range.step_size = RATE_TO_U64(rlist->rate[2]);
		dev_dbg(ph->dev, "Min %llu Max %llu Step %llu Hz\n",
		clk->range.min_rate, clk->range.max_rate,
		clk->range.step_size);
		static int
		iter_clk_describe_process_response(const struct scmi_protocol_handle *ph,
		const void *response,
		struct scmi_iterator_state st, void priv)
		{
		int ret = 0;
		struct scmi_clk_ipriv *p = priv;
		const struct scmi_msg_resp_clock_describe_rates *r = response;

		if (!p->clk->rate_discrete) {
		switch (st->desc_index + st->loop_idx) {
		case 0:
		p->clk->range.min_rate = RATE_TO_U64(r->rate[0]);
		break;
		case 1:
		p->clk->range.max_rate = RATE_TO_U64(r->rate[1]);
		break;
		case 2:
		p->clk->range.step_size = RATE_TO_U64(r->rate[2]);
		break;
		default:
		ret = -EINVAL;
		break;
		}
		} else {
		u64 *rate = &p->clk->list.rates[st->desc_index + st->loop_idx];

		rate = &clk->list.rates[tot_rate_cnt];
		for (cnt = 0; cnt < num_returned; cnt++, rate++) {
		*rate = RATE_TO_U64(rlist->rate[cnt]);
		dev_dbg(ph->dev, "Rate %llu Hz\n", *rate);
		*rate = RATE_TO_U64(r->rate[st->loop_idx]);
		p->clk->list.num_rates++;
		//XXX dev_dbg(ph->dev, "Rate %llu Hz\n", *rate);
		}

		tot_rate_cnt += num_returned;
		return ret;
		}

		ph->xops->reset_rx_to_maxsz(ph, t);
		/*
		* check for both returned and remaining to avoid infinite
		* loop due to buggy firmware
		*/
		} while (num_returned && num_remaining);
		static int
		scmi_clock_describe_rates_get(const struct scmi_protocol_handle *ph, u32 clk_id,
		struct scmi_clock_info *clk)
		{
		int ret;

		if (rate_discrete && rate) {
		clk->list.num_rates = tot_rate_cnt;
		sort(clk->list.rates, tot_rate_cnt, sizeof(*rate),
		rate_cmp_func, NULL);
		}
		void *iter;
		struct scmi_msg_clock_describe_rates *msg;
		struct scmi_iterator_ops ops = {
		.prepare_message = iter_clk_describe_prepare_message,
		.update_state = iter_clk_describe_update_state,
		.process_response = iter_clk_describe_process_response,
		};
		struct scmi_clk_ipriv cpriv = {
		.clk_id = clk_id,
		.clk = clk,
		};

		clk->rate_discrete = rate_discrete;
		iter = ph->hops->iter_response_init(ph, &ops, SCMI_MAX_NUM_RATES,
		CLOCK_DESCRIBE_RATES,
		sizeof(*msg), &cpriv);
		if (IS_ERR(iter))
		return PTR_ERR(iter);

		ret = ph->hops->iter_response_run(iter);
		if (ret)
		return ret;

		if (!clk->rate_discrete) {
		dev_dbg(ph->dev, "Min %llu Max %llu Step %llu Hz\n",
		clk->range.min_rate, clk->range.max_rate,
		clk->range.step_size);
		} else if (clk->list.num_rates) {
		sort(clk->list.rates, clk->list.num_rates,
		sizeof(clk->list.rates[0]), rate_cmp_func, NULL);
		}

		err:
		ph->xops->xfer_put(ph, t);
		return ret;
		}

		@@ -266,10 +346,22 @@ static int scmi_clock_rate_set(const struct scmi_protocol_handle *ph,
		cfg->value_low = cpu_to_le32(rate & 0xffffffff);
		cfg->value_high = cpu_to_le32(rate >> 32);

		if (flags & CLOCK_SET_ASYNC)
		if (flags & CLOCK_SET_ASYNC) {
		ret = ph->xops->do_xfer_with_response(ph, t);
		if (!ret) {
		struct scmi_msg_resp_set_rate_complete *resp;

		resp = t->rx.buf;
		if (le32_to_cpu(resp->id) == clk_id)
		dev_dbg(ph->dev,
		"Clk ID %d set async to %llu\n", clk_id,
		get_unaligned_le64(&resp->rate_low));
		else
		ret = -EPROTO;
		}
		} else {
		ret = ph->xops->do_xfer(ph, t);
		}

		if (ci->max_async_req)
		atomic_dec(&ci->cur_async_req);
		@@ -355,13 +447,111 @@ static const struct scmi_clk_proto_ops clk_proto_ops = {
		.disable_atomic = scmi_clock_disable_atomic,
		};

		static int scmi_clk_rate_notify(const struct scmi_protocol_handle *ph,
		u32 clk_id, int message_id, bool enable)
		{
		int ret;
		struct scmi_xfer *t;
		struct scmi_msg_clock_rate_notify *notify;

		ret = ph->xops->xfer_get_init(ph, message_id, sizeof(*notify), 0, &t);
		if (ret)
		return ret;

		notify = t->tx.buf;
		notify->clk_id = cpu_to_le32(clk_id);
		notify->notify_enable = enable ? cpu_to_le32(BIT(0)) : 0;

		ret = ph->xops->do_xfer(ph, t);

		ph->xops->xfer_put(ph, t);
		return ret;
		}

		static int scmi_clk_set_notify_enabled(const struct scmi_protocol_handle *ph,
		u8 evt_id, u32 src_id, bool enable)
		{
		int ret, cmd_id;

		if (evt_id >= ARRAY_SIZE(evt_2_cmd))
		return -EINVAL;

		cmd_id = evt_2_cmd[evt_id];
		ret = scmi_clk_rate_notify(ph, src_id, cmd_id, enable);
		if (ret)
		pr_debug("FAIL_ENABLED - evt[%X] dom[%d] - ret:%d\n",
		evt_id, src_id, ret);

		return ret;
		}

		static void scmi_clk_fill_custom_report(const struct scmi_protocol_handle ph,
		u8 evt_id, ktime_t timestamp,
		const void *payld, size_t payld_sz,
		void report, u32 src_id)
		{
		const struct scmi_clock_rate_notify_payld *p = payld;
		struct scmi_clock_rate_notif_report *r = report;

		if (sizeof(*p) != payld_sz \|\|
		(evt_id != SCMI_EVENT_CLOCK_RATE_CHANGED &&
		evt_id != SCMI_EVENT_CLOCK_RATE_CHANGE_REQUESTED))
		return NULL;

		r->timestamp = timestamp;
		r->agent_id = le32_to_cpu(p->agent_id);
		r->clock_id = le32_to_cpu(p->clock_id);
		r->rate = get_unaligned_le64(&p->rate_low);
		*src_id = r->clock_id;

		return r;
		}

		static int scmi_clk_get_num_sources(const struct scmi_protocol_handle *ph)
		{
		struct clock_info *ci = ph->get_priv(ph);

		if (!ci)
		return -EINVAL;

		return ci->num_clocks;
		}

		static const struct scmi_event clk_events[] = {
		{
		.id = SCMI_EVENT_CLOCK_RATE_CHANGED,
		.max_payld_sz = sizeof(struct scmi_clock_rate_notify_payld),
		.max_report_sz = sizeof(struct scmi_clock_rate_notif_report),
		},
		{
		.id = SCMI_EVENT_CLOCK_RATE_CHANGE_REQUESTED,
		.max_payld_sz = sizeof(struct scmi_clock_rate_notify_payld),
		.max_report_sz = sizeof(struct scmi_clock_rate_notif_report),
		},
		};

		static const struct scmi_event_ops clk_event_ops = {
		.get_num_sources = scmi_clk_get_num_sources,
		.set_notify_enabled = scmi_clk_set_notify_enabled,
		.fill_custom_report = scmi_clk_fill_custom_report,
		};

		static const struct scmi_protocol_events clk_protocol_events = {
		.queue_sz = SCMI_PROTO_QUEUE_SZ,
		.ops = &clk_event_ops,
		.evts = clk_events,
		.num_events = ARRAY_SIZE(clk_events),
		};

		static int scmi_clock_protocol_init(const struct scmi_protocol_handle *ph)
		{
		u32 version;
		int clkid, ret;
		struct clock_info *cinfo;

		ph->xops->version_get(ph, &version);
		ret = ph->xops->version_get(ph, &version);
		if (ret)
		return ret;

		dev_dbg(ph->dev, "Clock Version %d.%d\n",
		PROTOCOL_REV_MAJOR(version), PROTOCOL_REV_MINOR(version));
		@@ -370,7 +560,9 @@ static int scmi_clock_protocol_init(const struct scmi_protocol_handle *ph)
		if (!cinfo)
		return -ENOMEM;

		scmi_clock_protocol_attributes_get(ph, cinfo);
		ret = scmi_clock_protocol_attributes_get(ph, cinfo);
		if (ret)
		return ret;

		cinfo->clk = devm_kcalloc(ph->dev, cinfo->num_clocks,
		sizeof(*cinfo->clk), GFP_KERNEL);
		@@ -380,7 +572,7 @@ static int scmi_clock_protocol_init(const struct scmi_protocol_handle *ph)
		for (clkid = 0; clkid < cinfo->num_clocks; clkid++) {
		struct scmi_clock_info *clk = cinfo->clk + clkid;

		ret = scmi_clock_attributes_get(ph, clkid, clk);
		ret = scmi_clock_attributes_get(ph, clkid, clk, version);
		if (!ret)
		scmi_clock_describe_rates_get(ph, clkid, clk);
		}
		@@ -394,6 +586,7 @@ static const struct scmi_protocol scmi_clock = {
		.owner = THIS_MODULE,
		.instance_init = &scmi_clock_protocol_init,
		.ops = &clk_proto_ops,
		.events = &clk_protocol_events,
		};

		DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(clock, scmi_clock)

drivers/firmware/arm_scmi/common.h

+2 −223

Original line number	Diff line number	Diff line
		@@ -4,7 +4,7 @@
		* driver common header file containing some definitions, structures
		* and function prototypes used in all the different SCMI protocols.
		*
		* Copyright (C) 2018-2021 ARM Ltd.
		* Copyright (C) 2018-2022 ARM Ltd.
		*/
		#ifndef _SCMI_COMMON_H
		#define _SCMI_COMMON_H
		@@ -24,38 +24,9 @@

		#include <asm/unaligned.h>

		#include "protocols.h"
		#include "notify.h"

		#define PROTOCOL_REV_MINOR_MASK GENMASK(15, 0)
		#define PROTOCOL_REV_MAJOR_MASK GENMASK(31, 16)
		#define PROTOCOL_REV_MAJOR(x) (u16)(FIELD_GET(PROTOCOL_REV_MAJOR_MASK, (x)))
		#define PROTOCOL_REV_MINOR(x) (u16)(FIELD_GET(PROTOCOL_REV_MINOR_MASK, (x)))
		#define MAX_PROTOCOLS_IMP 16
		#define MAX_OPPS 16

		enum scmi_common_cmd {
		PROTOCOL_VERSION = 0x0,
		PROTOCOL_ATTRIBUTES = 0x1,
		PROTOCOL_MESSAGE_ATTRIBUTES = 0x2,
		};

		/**
		* struct scmi_msg_resp_prot_version - Response for a message
		*
		* @minor_version: Minor version of the ABI that firmware supports
		* @major_version: Major 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;
		};

		#define MSG_ID_MASK GENMASK(7, 0)
		#define MSG_XTRACT_ID(hdr) FIELD_GET(MSG_ID_MASK, (hdr))
		#define MSG_TYPE_MASK GENMASK(9, 8)
		@@ -79,28 +50,6 @@ struct scmi_msg_resp_prot_version {
		*/
		#define SCMI_PENDING_XFERS_HT_ORDER_SZ 9

		/**
		* struct scmi_msg_hdr - Message(Tx/Rx) header
		*
		* @id: The identifier of the message being sent
		* @protocol_id: The identifier of the protocol used to send @id message
		* @type: The SCMI type for this message
		* @seq: The token to identify the message. When a message returns, the
		* platform returns the whole message header unmodified including the
		* token
		* @status: Status of the transfer once it's complete
		* @poll_completion: Indicate if the transfer needs to be polled for
		* completion or interrupt mode is used
		*/
		struct scmi_msg_hdr {
		u8 id;
		u8 protocol_id;
		u8 type;
		u16 seq;
		u32 status;
		bool poll_completion;
		};

		/**
		* pack_scmi_header() - packs and returns 32-bit header
		*
		@@ -130,72 +79,6 @@ static inline void unpack_scmi_header(u32 msg_hdr, struct scmi_msg_hdr *hdr)
		hdr->type = MSG_XTRACT_TYPE(msg_hdr);
		}

		/**
		* struct scmi_msg - Message(Tx/Rx) structure
		*
		* @buf: Buffer pointer
		* @len: Length of data in the Buffer
		*/
		struct scmi_msg {
		void *buf;
		size_t len;
		};

		/**
		* struct scmi_xfer - Structure representing a message flow
		*
		* @transfer_id: Unique ID for debug & profiling purpose
		* @hdr: Transmit message header
		* @tx: Transmit message
		* @rx: Receive message, the buffer should be pre-allocated to store
		* message. If request-ACK protocol is used, we can reuse the same
		* buffer for the rx path as we use for the tx path.
		* @done: command message transmit completion event
		* @async_done: pointer to delayed response message received event completion
		* @pending: True for xfers added to @pending_xfers hashtable
		* @node: An hlist_node reference used to store this xfer, alternatively, on
		* the free list @free_xfers or in the @pending_xfers hashtable
		* @users: A refcount to track the active users for this xfer.
		* This is meant to protect against the possibility that, when a command
		* transaction times out concurrently with the reception of a valid
		* response message, the xfer could be finally put on the TX path, and
		* so vanish, while on the RX path scmi_rx_callback() is still
		* processing it: in such a case this refcounting will ensure that, even
		* though the timed-out transaction will anyway cause the command
		* request to be reported as failed by time-out, the underlying xfer
		* cannot be discarded and possibly reused until the last one user on
		* the RX path has released it.
		* @busy: An atomic flag to ensure exclusive write access to this xfer
		* @state: The current state of this transfer, with states transitions deemed
		* valid being:
		* - SCMI_XFER_SENT_OK -> SCMI_XFER_RESP_OK [ -> SCMI_XFER_DRESP_OK ]
		* - SCMI_XFER_SENT_OK -> SCMI_XFER_DRESP_OK
		* (Missing synchronous response is assumed OK and ignored)
		* @lock: A spinlock to protect state and busy fields.
		* @priv: A pointer for transport private usage.
		*/
		struct scmi_xfer {
		int transfer_id;
		struct scmi_msg_hdr hdr;
		struct scmi_msg tx;
		struct scmi_msg rx;
		struct completion done;
		struct completion *async_done;
		bool pending;
		struct hlist_node node;
		refcount_t users;
		#define SCMI_XFER_FREE 0
		#define SCMI_XFER_BUSY 1
		atomic_t busy;
		#define SCMI_XFER_SENT_OK 0
		#define SCMI_XFER_RESP_OK 1
		#define SCMI_XFER_DRESP_OK 2
		int state;
		/* A lock to protect state and busy fields */
		spinlock_t lock;
		void *priv;
		};

		/*
		* An helper macro to lookup an xfer from the @pending_xfers hashtable
		* using the message sequence number token as a key.
		@@ -211,64 +94,6 @@ struct scmi_xfer {
		xfer_; \
		})

		struct scmi_xfer_ops;

		/**
		* struct scmi_protocol_handle - Reference to an initialized protocol instance
		*
		* @dev: A reference to the associated SCMI instance device (handle->dev).
		* @xops: A reference to a struct holding refs to the core xfer operations that
		* can be used by the protocol implementation to generate SCMI messages.
		* @set_priv: A method to set protocol private data for this instance.
		* @get_priv: A method to get protocol private data previously set.
		*
		* This structure represents a protocol initialized against specific SCMI
		* instance and it will be used as follows:
		* - as a parameter fed from the core to the protocol initialization code so
		* that it can access the core xfer operations to build and generate SCMI
		* messages exclusively for the specific underlying protocol instance.
		* - as an opaque handle fed by an SCMI driver user when it tries to access
		* this protocol through its own protocol operations.
		* In this case this handle will be returned as an opaque object together
		* with the related protocol operations when the SCMI driver tries to access
		* the protocol.
		*/
		struct scmi_protocol_handle {
		struct device *dev;
		const struct scmi_xfer_ops *xops;
		int (set_priv)(const struct scmi_protocol_handle ph, void *priv);
		void (get_priv)(const struct scmi_protocol_handle *ph);
		};

		/**
		* struct scmi_xfer_ops - References to the core SCMI xfer operations.
		* @version_get: Get this version protocol.
		* @xfer_get_init: Initialize one struct xfer if any xfer slot is free.
		* @reset_rx_to_maxsz: Reset rx size to max transport size.
		* @do_xfer: Do the SCMI transfer.
		* @do_xfer_with_response: Do the SCMI transfer waiting for a response.
		* @xfer_put: Free the xfer slot.
		*
		* Note that all this operations expect a protocol handle as first parameter;
		* they then internally use it to infer the underlying protocol number: this
		* way is not possible for a protocol implementation to forge messages for
		* another protocol.
		*/
		struct scmi_xfer_ops {
		int (version_get)(const struct scmi_protocol_handle ph, u32 *version);
		int (xfer_get_init)(const struct scmi_protocol_handle ph, u8 msg_id,
		size_t tx_size, size_t rx_size,
		struct scmi_xfer **p);
		void (reset_rx_to_maxsz)(const struct scmi_protocol_handle ph,
		struct scmi_xfer *xfer);
		int (do_xfer)(const struct scmi_protocol_handle ph,
		struct scmi_xfer *xfer);
		int (do_xfer_with_response)(const struct scmi_protocol_handle ph,
		struct scmi_xfer *xfer);
		void (xfer_put)(const struct scmi_protocol_handle ph,
		struct scmi_xfer *xfer);
		};

		struct scmi_revision_info *
		scmi_revision_area_get(const struct scmi_protocol_handle *ph);
		int scmi_handle_put(const struct scmi_handle *handle);
		@@ -277,55 +102,9 @@ void scmi_set_handle(struct scmi_device *scmi_dev);
		void scmi_setup_protocol_implemented(const struct scmi_protocol_handle *ph,
		u8 *prot_imp);

		typedef int (scmi_prot_init_ph_fn_t)(const struct scmi_protocol_handle );

		/**
		* struct scmi_protocol - Protocol descriptor
		* @id: Protocol ID.
		* @owner: Module reference if any.
		* @instance_init: Mandatory protocol initialization function.
		* @instance_deinit: Optional protocol de-initialization function.
		* @ops: Optional reference to the operations provided by the protocol and
		* exposed in scmi_protocol.h.
		* @events: An optional reference to the events supported by this protocol.
		*/
		struct scmi_protocol {
		const u8 id;
		struct module *owner;
		const scmi_prot_init_ph_fn_t instance_init;
		const scmi_prot_init_ph_fn_t instance_deinit;
		const void *ops;
		const struct scmi_protocol_events *events;
		};

		int __init scmi_bus_init(void);
		void __exit scmi_bus_exit(void);

		#define DECLARE_SCMI_REGISTER_UNREGISTER(func) \
		int __init scmi_##func##_register(void); \
		void __exit scmi_##func##_unregister(void)
		DECLARE_SCMI_REGISTER_UNREGISTER(base);
		DECLARE_SCMI_REGISTER_UNREGISTER(clock);
		DECLARE_SCMI_REGISTER_UNREGISTER(perf);
		DECLARE_SCMI_REGISTER_UNREGISTER(power);
		DECLARE_SCMI_REGISTER_UNREGISTER(reset);
		DECLARE_SCMI_REGISTER_UNREGISTER(sensors);
		DECLARE_SCMI_REGISTER_UNREGISTER(voltage);
		DECLARE_SCMI_REGISTER_UNREGISTER(system);

		#define DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(name, proto) \
		static const struct scmi_protocol *__this_proto = &(proto); \
		\
		int __init scmi_##name##_register(void) \
		{ \
		return scmi_protocol_register(__this_proto); \
		} \
		\
		void __exit scmi_##name##_unregister(void) \
		{ \
		scmi_protocol_unregister(__this_proto); \
		}

		const struct scmi_protocol *scmi_protocol_get(int protocol_id);
		void scmi_protocol_put(int protocol_id);

drivers/firmware/arm_scmi/driver.c

+166 −2

File changed.

Preview size limit exceeded, changes collapsed.