drivers/firmware/arm_scmi/base.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * System Control and Management Interface (SCMI) Base Protocol
   4  *
   5  * Copyright (C) 2018-2021 ARM Ltd.
   6  */
   7
   8 #define pr_fmt(fmt) "SCMI Notifications BASE - " fmt
   9
  10 #include <linux/module.h>
  11 #include <linux/scmi_protocol.h>
  12
  13 #include "common.h"
  14 #include "notify.h"
  15
  16 #define SCMI_BASE_NUM_SOURCES           1
  17 #define SCMI_BASE_MAX_CMD_ERR_COUNT     1024
  18
  19 enum scmi_base_protocol_cmd {
  20         BASE_DISCOVER_VENDOR = 0x3,
  21         BASE_DISCOVER_SUB_VENDOR = 0x4,
  22         BASE_DISCOVER_IMPLEMENT_VERSION = 0x5,
  23         BASE_DISCOVER_LIST_PROTOCOLS = 0x6,
  24         BASE_DISCOVER_AGENT = 0x7,
  25         BASE_NOTIFY_ERRORS = 0x8,
  26         BASE_SET_DEVICE_PERMISSIONS = 0x9,
  27         BASE_SET_PROTOCOL_PERMISSIONS = 0xa,
  28         BASE_RESET_AGENT_CONFIGURATION = 0xb,
  29 };
  30
  31 struct scmi_msg_resp_base_attributes {
  32         u8 num_protocols;
  33         u8 num_agents;
  34         __le16 reserved;
  35 };
  36
  37 struct scmi_msg_resp_base_discover_agent {
  38         __le32 agent_id;
  39         u8 name[SCMI_SHORT_NAME_MAX_SIZE];
  40 };
  41
  42
  43 struct scmi_msg_base_error_notify {
  44         __le32 event_control;
  45 #define BASE_TP_NOTIFY_ALL      BIT(0)
  46 };
  47
  48 struct scmi_base_error_notify_payld {
  49         __le32 agent_id;
  50         __le32 error_status;
  51 #define IS_FATAL_ERROR(x)       ((x) & BIT(31))
  52 #define ERROR_CMD_COUNT(x)      FIELD_GET(GENMASK(9, 0), (x))
  53         __le64 msg_reports[SCMI_BASE_MAX_CMD_ERR_COUNT];
  54 };
  55
  56 /**
  57  * scmi_base_attributes_get() - gets the implementation details
  58  *      that are associated with the base protocol.
  59  *
  60  * @ph: SCMI protocol handle
  61  *
  62  * Return: 0 on success, else appropriate SCMI error.
  63  */
  64 static int scmi_base_attributes_get(const struct scmi_protocol_handle *ph)
  65 {
  66         int ret;
  67         struct scmi_xfer *t;
  68         struct scmi_msg_resp_base_attributes *attr_info;
  69         struct scmi_revision_info *rev = ph->get_priv(ph);
  70
  71         ret = ph->xops->xfer_get_init(ph, PROTOCOL_ATTRIBUTES,
  72                                       0, sizeof(*attr_info), &t);
  73         if (ret)
  74                 return ret;
  75
  76         ret = ph->xops->do_xfer(ph, t);
  77         if (!ret) {
  78                 attr_info = t->rx.buf;
  79                 rev->num_protocols = attr_info->num_protocols;
  80                 rev->num_agents = attr_info->num_agents;
  81         }
  82
  83         ph->xops->xfer_put(ph, t);
  84
  85         return ret;
  86 }
  87
  88 /**
  89  * scmi_base_vendor_id_get() - gets vendor/subvendor identifier ASCII string.
  90  *
  91  * @ph: SCMI protocol handle
  92  * @sub_vendor: specify true if sub-vendor ID is needed
  93  *
  94  * Return: 0 on success, else appropriate SCMI error.
  95  */
  96 static int
  97 scmi_base_vendor_id_get(const struct scmi_protocol_handle *ph, bool sub_vendor)
  98 {
  99         u8 cmd;
 100         int ret, size;
 101         char *vendor_id;
 102         struct scmi_xfer *t;
 103         struct scmi_revision_info *rev = ph->get_priv(ph);
 104
 105
 106         if (sub_vendor) {
 107                 cmd = BASE_DISCOVER_SUB_VENDOR;
 108                 vendor_id = rev->sub_vendor_id;
 109                 size = ARRAY_SIZE(rev->sub_vendor_id);
 110         } else {
 111                 cmd = BASE_DISCOVER_VENDOR;
 112                 vendor_id = rev->vendor_id;
 113                 size = ARRAY_SIZE(rev->vendor_id);
 114         }
 115
 116         ret = ph->xops->xfer_get_init(ph, cmd, 0, size, &t);
 117         if (ret)
 118                 return ret;
 119
 120         ret = ph->xops->do_xfer(ph, t);
 121         if (!ret)
 122                 strscpy(vendor_id, t->rx.buf, size);
 123
 124         ph->xops->xfer_put(ph, t);
 125
 126         return ret;
 127 }
 128
 129 /**
 130  * scmi_base_implementation_version_get() - gets a vendor-specific
 131  *      implementation 32-bit version. The format of the version number is
 132  *      vendor-specific
 133  *
 134  * @ph: SCMI protocol handle
 135  *
 136  * Return: 0 on success, else appropriate SCMI error.
 137  */
 138 static int
 139 scmi_base_implementation_version_get(const struct scmi_protocol_handle *ph)
 140 {
 141         int ret;
 142         __le32 *impl_ver;
 143         struct scmi_xfer *t;
 144         struct scmi_revision_info *rev = ph->get_priv(ph);
 145
 146         ret = ph->xops->xfer_get_init(ph, BASE_DISCOVER_IMPLEMENT_VERSION,
 147                                       0, sizeof(*impl_ver), &t);
 148         if (ret)
 149                 return ret;
 150
 151         ret = ph->xops->do_xfer(ph, t);
 152         if (!ret) {
 153                 impl_ver = t->rx.buf;
 154                 rev->impl_ver = le32_to_cpu(*impl_ver);
 155         }
 156
 157         ph->xops->xfer_put(ph, t);
 158
 159         return ret;
 160 }
 161
 162 /**
 163  * scmi_base_implementation_list_get() - gets the list of protocols it is
 164  *      OSPM is allowed to access
 165  *
 166  * @ph: SCMI protocol handle
 167  * @protocols_imp: pointer to hold the list of protocol identifiers
 168  *
 169  * Return: 0 on success, else appropriate SCMI error.
 170  */
 171 static int
 172 scmi_base_implementation_list_get(const struct scmi_protocol_handle *ph,
 173                                   u8 *protocols_imp)
 174 {
 175         u8 *list;
 176         int ret, loop;
 177         struct scmi_xfer *t;
 178         __le32 *num_skip, *num_ret;
 179         u32 tot_num_ret = 0, loop_num_ret;
 180         struct device *dev = ph->dev;
 181         struct scmi_revision_info *rev = ph->get_priv(ph);
 182
 183         ret = ph->xops->xfer_get_init(ph, BASE_DISCOVER_LIST_PROTOCOLS,
 184                                       sizeof(*num_skip), 0, &t);
 185         if (ret)
 186                 return ret;
 187
 188         num_skip = t->tx.buf;
 189         num_ret = t->rx.buf;
 190         list = t->rx.buf + sizeof(*num_ret);
 191
 192         do {
 193                 size_t real_list_sz;
 194                 u32 calc_list_sz;
 195
 196                 /* Set the number of protocols to be skipped/already read */
 197                 *num_skip = cpu_to_le32(tot_num_ret);
 198
 199                 ret = ph->xops->do_xfer(ph, t);
 200                 if (ret)
 201                         break;
 202
 203                 loop_num_ret = le32_to_cpu(*num_ret);
 204                 if (!loop_num_ret)
 205                         break;
 206
 207                 if (loop_num_ret > rev->num_protocols - tot_num_ret) {
 208                         dev_err(dev,
 209                                 "No. Returned protocols > Total protocols.\n");
 210                         break;
 211                 }
 212
 213                 if (t->rx.len < (sizeof(u32) * 2)) {
 214                         dev_err(dev, "Truncated reply - rx.len:%zd\n",
 215                                 t->rx.len);
 216                         ret = -EPROTO;
 217                         break;
 218                 }
 219
 220                 real_list_sz = t->rx.len - sizeof(u32);
 221                 calc_list_sz = (1 + (loop_num_ret - 1) / sizeof(u32)) *
 222                                 sizeof(u32);
 223                 if (calc_list_sz != real_list_sz) {
 224                         dev_warn(dev,
 225                                  "Malformed reply - real_sz:%zd  calc_sz:%u  (loop_num_ret:%d)\n",
 226                                  real_list_sz, calc_list_sz, loop_num_ret);
 227                         /*
 228                          * Bail out if the expected list size is bigger than the
 229                          * total payload size of the received reply.
 230                          */
 231                         if (calc_list_sz > real_list_sz) {
 232                                 ret = -EPROTO;
 233                                 break;
 234                         }
 235                 }
 236
 237                 for (loop = 0; loop < loop_num_ret; loop++)
 238                         protocols_imp[tot_num_ret + loop] = *(list + loop);
 239
 240                 tot_num_ret += loop_num_ret;
 241
 242                 ph->xops->reset_rx_to_maxsz(ph, t);
 243         } while (tot_num_ret < rev->num_protocols);
 244
 245         ph->xops->xfer_put(ph, t);
 246
 247         return ret;
 248 }
 249
 250 /**
 251  * scmi_base_discover_agent_get() - discover the name of an agent
 252  *
 253  * @ph: SCMI protocol handle
 254  * @id: Agent identifier
 255  * @name: Agent identifier ASCII string
 256  *
 257  * An agent id of 0 is reserved to identify the platform itself.
 258  * Generally operating system is represented as "OSPM"
 259  *
 260  * Return: 0 on success, else appropriate SCMI error.
 261  */
 262 static int scmi_base_discover_agent_get(const struct scmi_protocol_handle *ph,
 263                                         int id, char *name)
 264 {
 265         int ret;
 266         struct scmi_msg_resp_base_discover_agent *agent_info;
 267         struct scmi_xfer *t;
 268
 269         ret = ph->xops->xfer_get_init(ph, BASE_DISCOVER_AGENT,
 270                                       sizeof(__le32), sizeof(*agent_info), &t);
 271         if (ret)
 272                 return ret;
 273
 274         put_unaligned_le32(id, t->tx.buf);
 275
 276         ret = ph->xops->do_xfer(ph, t);
 277         if (!ret) {
 278                 agent_info = t->rx.buf;
 279                 strscpy(name, agent_info->name, SCMI_SHORT_NAME_MAX_SIZE);
 280         }
 281
 282         ph->xops->xfer_put(ph, t);
 283
 284         return ret;
 285 }
 286
 287 static int scmi_base_error_notify(const struct scmi_protocol_handle *ph,
 288                                   bool enable)
 289 {
 290         int ret;
 291         u32 evt_cntl = enable ? BASE_TP_NOTIFY_ALL : 0;
 292         struct scmi_xfer *t;
 293         struct scmi_msg_base_error_notify *cfg;
 294
 295         ret = ph->xops->xfer_get_init(ph, BASE_NOTIFY_ERRORS,
 296                                       sizeof(*cfg), 0, &t);
 297         if (ret)
 298                 return ret;
 299
 300         cfg = t->tx.buf;
 301         cfg->event_control = cpu_to_le32(evt_cntl);
 302
 303         ret = ph->xops->do_xfer(ph, t);
 304
 305         ph->xops->xfer_put(ph, t);
 306         return ret;
 307 }
 308
 309 static int scmi_base_set_notify_enabled(const struct scmi_protocol_handle *ph,
 310                                         u8 evt_id, u32 src_id, bool enable)
 311 {
 312         int ret;
 313
 314         ret = scmi_base_error_notify(ph, enable);
 315         if (ret)
 316                 pr_debug("FAIL_ENABLED - evt[%X] ret:%d\n", evt_id, ret);
 317
 318         return ret;
 319 }
 320
 321 static void *scmi_base_fill_custom_report(const struct scmi_protocol_handle *ph,
 322                                           u8 evt_id, ktime_t timestamp,
 323                                           const void *payld, size_t payld_sz,
 324                                           void *report, u32 *src_id)
 325 {
 326         int i;
 327         const struct scmi_base_error_notify_payld *p = payld;
 328         struct scmi_base_error_report *r = report;
 329
 330         /*
 331          * BaseError notification payload is variable in size but
 332          * up to a maximum length determined by the struct ponted by p.
 333          * Instead payld_sz is the effective length of this notification
 334          * payload so cannot be greater of the maximum allowed size as
 335          * pointed by p.
 336          */
 337         if (evt_id != SCMI_EVENT_BASE_ERROR_EVENT || sizeof(*p) < payld_sz)
 338                 return NULL;
 339
 340         r->timestamp = timestamp;
 341         r->agent_id = le32_to_cpu(p->agent_id);
 342         r->fatal = IS_FATAL_ERROR(le32_to_cpu(p->error_status));
 343         r->cmd_count = ERROR_CMD_COUNT(le32_to_cpu(p->error_status));
 344         for (i = 0; i < r->cmd_count; i++)
 345                 r->reports[i] = le64_to_cpu(p->msg_reports[i]);
 346         *src_id = 0;
 347
 348         return r;
 349 }
 350
 351 static const struct scmi_event base_events[] = {
 352         {
 353                 .id = SCMI_EVENT_BASE_ERROR_EVENT,
 354                 .max_payld_sz = sizeof(struct scmi_base_error_notify_payld),
 355                 .max_report_sz = sizeof(struct scmi_base_error_report) +
 356                                   SCMI_BASE_MAX_CMD_ERR_COUNT * sizeof(u64),
 357         },
 358 };
 359
 360 static const struct scmi_event_ops base_event_ops = {
 361         .set_notify_enabled = scmi_base_set_notify_enabled,
 362         .fill_custom_report = scmi_base_fill_custom_report,
 363 };
 364
 365 static const struct scmi_protocol_events base_protocol_events = {
 366         .queue_sz = 4 * SCMI_PROTO_QUEUE_SZ,
 367         .ops = &base_event_ops,
 368         .evts = base_events,
 369         .num_events = ARRAY_SIZE(base_events),
 370         .num_sources = SCMI_BASE_NUM_SOURCES,
 371 };
 372
 373 static int scmi_base_protocol_init(const struct scmi_protocol_handle *ph)
 374 {
 375         int id, ret;
 376         u8 *prot_imp;
 377         u32 version;
 378         char name[SCMI_SHORT_NAME_MAX_SIZE];
 379         struct device *dev = ph->dev;
 380         struct scmi_revision_info *rev = scmi_revision_area_get(ph);
 381
 382         ret = ph->xops->version_get(ph, &version);
 383         if (ret)
 384                 return ret;
 385
 386         rev->major_ver = PROTOCOL_REV_MAJOR(version),
 387         rev->minor_ver = PROTOCOL_REV_MINOR(version);
 388         ph->set_priv(ph, rev);
 389
 390         ret = scmi_base_attributes_get(ph);
 391         if (ret)
 392                 return ret;
 393
 394         prot_imp = devm_kcalloc(dev, rev->num_protocols, sizeof(u8),
 395                                 GFP_KERNEL);
 396         if (!prot_imp)
 397                 return -ENOMEM;
 398
 399         scmi_base_vendor_id_get(ph, false);
 400         scmi_base_vendor_id_get(ph, true);
 401         scmi_base_implementation_version_get(ph);
 402         scmi_base_implementation_list_get(ph, prot_imp);
 403
 404         scmi_setup_protocol_implemented(ph, prot_imp);
 405
 406         dev_info(dev, "SCMI Protocol v%d.%d '%s:%s' Firmware version 0x%x\n",
 407                  rev->major_ver, rev->minor_ver, rev->vendor_id,
 408                  rev->sub_vendor_id, rev->impl_ver);
 409         dev_dbg(dev, "Found %d protocol(s) %d agent(s)\n", rev->num_protocols,
 410                 rev->num_agents);
 411
 412         for (id = 0; id < rev->num_agents; id++) {
 413                 scmi_base_discover_agent_get(ph, id, name);
 414                 dev_dbg(dev, "Agent %d: %s\n", id, name);
 415         }
 416
 417         return 0;
 418 }
 419
 420 static const struct scmi_protocol scmi_base = {
 421         .id = SCMI_PROTOCOL_BASE,
 422         .owner = NULL,
 423         .instance_init = &scmi_base_protocol_init,
 424         .ops = NULL,
 425         .events = &base_protocol_events,
 426 };
 427
 428 DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(base, scmi_base)