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) 429