Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437// SPDX-License-Identifier: GPL-2.0/* * System Control and Management Interface (SCMI) Base Protocol * * Copyright (C) 2018-2021 ARM Ltd. */
#define pr_fmt(fmt) "SCMI Notifications BASE - " fmt
#include <linux/math.h>#include <linux/module.h>#include <linux/scmi_protocol.h>
#include "common.h"#include "notify.h"
/* Updated only after ALL the mandatory features for that version are merged */#define SCMI_PROTOCOL_SUPPORTED_VERSION 0x20001
#define SCMI_BASE_NUM_SOURCES 1#define SCMI_BASE_MAX_CMD_ERR_COUNT 1024
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, BASE_SET_DEVICE_PERMISSIONS = 0x9, BASE_SET_PROTOCOL_PERMISSIONS = 0xa, BASE_RESET_AGENT_CONFIGURATION = 0xb,};
struct scmi_msg_resp_base_attributes { u8 num_protocols; u8 num_agents; __le16 reserved;};
struct scmi_msg_resp_base_discover_agent { __le32 agent_id; u8 name[SCMI_SHORT_NAME_MAX_SIZE];};
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[SCMI_BASE_MAX_CMD_ERR_COUNT];};
/** * scmi_base_attributes_get() - gets the implementation details * that are associated with the base protocol. * * @ph: SCMI protocol handle * * Return: 0 on success, else appropriate SCMI error. */static int scmi_base_attributes_get(const struct scmi_protocol_handle *ph){ int ret; struct scmi_xfer *t; struct scmi_msg_resp_base_attributes *attr_info; struct scmi_base_info *rev = ph->get_priv(ph);
ret = ph->xops->xfer_get_init(ph, PROTOCOL_ATTRIBUTES, 0, sizeof(*attr_info), &t); if (ret) return ret;
ret = ph->xops->do_xfer(ph, t); if (!ret) { attr_info = t->rx.buf; rev->num_protocols = attr_info->num_protocols; rev->num_agents = attr_info->num_agents; }
ph->xops->xfer_put(ph, t);
return ret;}
/** * scmi_base_vendor_id_get() - gets vendor/subvendor identifier ASCII string. * * @ph: SCMI protocol handle * @sub_vendor: specify true if sub-vendor ID is needed * * Return: 0 on success, else appropriate SCMI error. */static intscmi_base_vendor_id_get(const struct scmi_protocol_handle *ph, bool sub_vendor){ u8 cmd; int ret, size; char *vendor_id; struct scmi_xfer *t; struct scmi_base_info *rev = ph->get_priv(ph);
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 = ph->xops->xfer_get_init(ph, cmd, 0, size, &t); if (ret) return ret;
ret = ph->xops->do_xfer(ph, t); if (!ret) strscpy(vendor_id, t->rx.buf, size);
ph->xops->xfer_put(ph, 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 * * @ph: SCMI protocol handle * * Return: 0 on success, else appropriate SCMI error. */static intscmi_base_implementation_version_get(const struct scmi_protocol_handle *ph){ int ret; __le32 *impl_ver; struct scmi_xfer *t; struct scmi_base_info *rev = ph->get_priv(ph);
ret = ph->xops->xfer_get_init(ph, BASE_DISCOVER_IMPLEMENT_VERSION, 0, sizeof(*impl_ver), &t); if (ret) return ret;
ret = ph->xops->do_xfer(ph, t); if (!ret) { impl_ver = t->rx.buf; rev->impl_ver = le32_to_cpu(*impl_ver); }
ph->xops->xfer_put(ph, t);
return ret;}
/** * scmi_base_implementation_list_get() - gets the list of protocols it is * OSPM is allowed to access * * @ph: SCMI protocol handle * @protocols_imp: pointer to hold the list of protocol identifiers * * Return: 0 on success, else appropriate SCMI error. */static intscmi_base_implementation_list_get(const struct scmi_protocol_handle *ph, 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 = ph->dev; struct scmi_base_info *rev = ph->get_priv(ph);
ret = ph->xops->xfer_get_init(ph, BASE_DISCOVER_LIST_PROTOCOLS, 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 { 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);
ret = ph->xops->do_xfer(ph, t); if (ret) break;
loop_num_ret = le32_to_cpu(*num_ret); 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 = round_up(loop_num_ret, sizeof(u32)); if (calc_list_sz != real_list_sz) { dev_warn(dev, "Malformed reply - real_sz:%zd calc_sz:%u (loop_num_ret:%d)\n", real_list_sz, calc_list_sz, loop_num_ret); /* * Bail out if the expected list size is bigger than the * total payload size of the received reply. */ if (calc_list_sz > real_list_sz) { ret = -EPROTO; break; } }
for (loop = 0; loop < loop_num_ret; loop++) protocols_imp[tot_num_ret + loop] = *(list + loop);
tot_num_ret += loop_num_ret;
ph->xops->reset_rx_to_maxsz(ph, t); } while (tot_num_ret < rev->num_protocols);
ph->xops->xfer_put(ph, t);
return ret;}
/** * scmi_base_discover_agent_get() - discover the name of an agent * * @ph: SCMI protocol 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_protocol_handle *ph, int id, char *name){ int ret; struct scmi_msg_resp_base_discover_agent *agent_info; struct scmi_xfer *t;
ret = ph->xops->xfer_get_init(ph, BASE_DISCOVER_AGENT, sizeof(__le32), sizeof(*agent_info), &t); if (ret) return ret;
put_unaligned_le32(id, t->tx.buf);
ret = ph->xops->do_xfer(ph, t); if (!ret) { agent_info = t->rx.buf; strscpy(name, agent_info->name, SCMI_SHORT_NAME_MAX_SIZE); }
ph->xops->xfer_put(ph, t);
return ret;}
static int scmi_base_error_notify(const struct scmi_protocol_handle *ph, 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 = ph->xops->xfer_get_init(ph, BASE_NOTIFY_ERRORS, sizeof(*cfg), 0, &t); if (ret) return ret;
cfg = t->tx.buf; cfg->event_control = cpu_to_le32(evt_cntl);
ret = ph->xops->do_xfer(ph, t);
ph->xops->xfer_put(ph, t); return ret;}
static int scmi_base_set_notify_enabled(const struct scmi_protocol_handle *ph, u8 evt_id, u32 src_id, bool enable){ int ret;
ret = scmi_base_error_notify(ph, enable); if (ret) pr_debug("FAIL_ENABLED - evt[%X] ret:%d\n", evt_id, ret);
return ret;}
static void *scmi_base_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){ int i; u32 error_status; size_t expected_sz; 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 (evt_id != SCMI_EVENT_BASE_ERROR_EVENT || sizeof(*p) < payld_sz) return NULL;
expected_sz = offsetof(typeof(*p), msg_reports); if (payld_sz < expected_sz) return NULL;
r->timestamp = timestamp; r->agent_id = le32_to_cpu(p->agent_id); error_status = le32_to_cpu(p->error_status); r->fatal = IS_FATAL_ERROR(error_status); r->cmd_count = ERROR_CMD_COUNT(error_status); expected_sz += r->cmd_count * sizeof(p->msg_reports[0]); if (payld_sz < expected_sz) return NULL;
for (i = 0; i < r->cmd_count; i++) r->reports[i] = le64_to_cpu(p->msg_reports[i]); *src_id = 0;
return r;}
static const struct scmi_event base_events[] = { { .id = SCMI_EVENT_BASE_ERROR_EVENT, .max_payld_sz = sizeof(struct scmi_base_error_notify_payld), .max_report_sz = sizeof(struct scmi_base_error_report) + SCMI_BASE_MAX_CMD_ERR_COUNT * sizeof(u64), },};
static const struct scmi_event_ops base_event_ops = { .set_notify_enabled = scmi_base_set_notify_enabled, .fill_custom_report = scmi_base_fill_custom_report,};
static const struct scmi_protocol_events base_protocol_events = { .queue_sz = 4 * SCMI_PROTO_QUEUE_SZ, .ops = &base_event_ops, .evts = base_events, .num_events = ARRAY_SIZE(base_events), .num_sources = SCMI_BASE_NUM_SOURCES,};
static int scmi_base_protocol_init(const struct scmi_protocol_handle *ph){ int id, ret; u8 *prot_imp; char name[SCMI_SHORT_NAME_MAX_SIZE]; struct device *dev = ph->dev; struct scmi_base_info *rev = scmi_revision_area_get(ph);
rev->major_ver = PROTOCOL_REV_MAJOR(ph->version); rev->minor_ver = PROTOCOL_REV_MINOR(ph->version); ph->set_priv(ph, rev);
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); scmi_base_implementation_list_get(ph, prot_imp);
scmi_setup_protocol_implemented(ph, 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(ph, id, name); dev_dbg(dev, "Agent %d: %s\n", id, name); }
return 0;}
static const struct scmi_protocol scmi_base = { .id = SCMI_PROTOCOL_BASE, .owner = NULL, .instance_init = &scmi_base_protocol_init, .ops = NULL, .events = &base_protocol_events, .supported_version = SCMI_PROTOCOL_SUPPORTED_VERSION,};
DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(base, scmi_base)