1// SPDX-License-Identifier: GPL-2.0 2/* 3 * System Control and Management Interface (SCMI) Sensor Protocol 4 * 5 * Copyright (C) 2018-2022 ARM Ltd. 6 */ 7 8#define pr_fmt(fmt) "SCMI Notifications SENSOR - " fmt 9 10#include <linux/bitfield.h> 11#include <linux/module.h> 12#include <linux/scmi_protocol.h> 13 14#include "protocols.h" 15#include "notify.h" 16 17#define SCMI_MAX_NUM_SENSOR_AXIS 63 18#define SCMIv2_SENSOR_PROTOCOL 0x10000 19 20enum scmi_sensor_protocol_cmd { 21 SENSOR_DESCRIPTION_GET = 0x3, 22 SENSOR_TRIP_POINT_NOTIFY = 0x4, 23 SENSOR_TRIP_POINT_CONFIG = 0x5, 24 SENSOR_READING_GET = 0x6, 25 SENSOR_AXIS_DESCRIPTION_GET = 0x7, 26 SENSOR_LIST_UPDATE_INTERVALS = 0x8, 27 SENSOR_CONFIG_GET = 0x9, 28 SENSOR_CONFIG_SET = 0xA, 29 SENSOR_CONTINUOUS_UPDATE_NOTIFY = 0xB, 30 SENSOR_NAME_GET = 0xC, 31 SENSOR_AXIS_NAME_GET = 0xD, 32}; 33 34struct scmi_msg_resp_sensor_attributes { 35 __le16 num_sensors; 36 u8 max_requests; 37 u8 reserved; 38 __le32 reg_addr_low; 39 __le32 reg_addr_high; 40 __le32 reg_size; 41}; 42 43/* v3 attributes_low macros */ 44#define SUPPORTS_UPDATE_NOTIFY(x) FIELD_GET(BIT(30), (x)) 45#define SENSOR_TSTAMP_EXP(x) FIELD_GET(GENMASK(14, 10), (x)) 46#define SUPPORTS_TIMESTAMP(x) FIELD_GET(BIT(9), (x)) 47#define SUPPORTS_EXTEND_ATTRS(x) FIELD_GET(BIT(8), (x)) 48 49/* v2 attributes_high macros */ 50#define SENSOR_UPDATE_BASE(x) FIELD_GET(GENMASK(31, 27), (x)) 51#define SENSOR_UPDATE_SCALE(x) FIELD_GET(GENMASK(26, 22), (x)) 52 53/* v3 attributes_high macros */ 54#define SENSOR_AXIS_NUMBER(x) FIELD_GET(GENMASK(21, 16), (x)) 55#define SUPPORTS_AXIS(x) FIELD_GET(BIT(8), (x)) 56 57/* v3 resolution macros */ 58#define SENSOR_RES(x) FIELD_GET(GENMASK(26, 0), (x)) 59#define SENSOR_RES_EXP(x) FIELD_GET(GENMASK(31, 27), (x)) 60 61struct scmi_msg_resp_attrs { 62 __le32 min_range_low; 63 __le32 min_range_high; 64 __le32 max_range_low; 65 __le32 max_range_high; 66}; 67 68struct scmi_msg_sensor_description { 69 __le32 desc_index; 70}; 71 72struct scmi_msg_resp_sensor_description { 73 __le16 num_returned; 74 __le16 num_remaining; 75 struct scmi_sensor_descriptor { 76 __le32 id; 77 __le32 attributes_low; 78/* Common attributes_low macros */ 79#define SUPPORTS_ASYNC_READ(x) FIELD_GET(BIT(31), (x)) 80#define SUPPORTS_EXTENDED_NAMES(x) FIELD_GET(BIT(29), (x)) 81#define NUM_TRIP_POINTS(x) FIELD_GET(GENMASK(7, 0), (x)) 82 __le32 attributes_high; 83/* Common attributes_high macros */ 84#define SENSOR_SCALE(x) FIELD_GET(GENMASK(15, 11), (x)) 85#define SENSOR_SCALE_SIGN BIT(4) 86#define SENSOR_SCALE_EXTEND GENMASK(31, 5) 87#define SENSOR_TYPE(x) FIELD_GET(GENMASK(7, 0), (x)) 88 u8 name[SCMI_SHORT_NAME_MAX_SIZE]; 89 /* only for version > 2.0 */ 90 __le32 power; 91 __le32 resolution; 92 struct scmi_msg_resp_attrs scalar_attrs; 93 } desc[]; 94}; 95 96/* Base scmi_sensor_descriptor size excluding extended attrs after name */ 97#define SCMI_MSG_RESP_SENS_DESCR_BASE_SZ 28 98 99/* Sign extend to a full s32 */ 100#define S32_EXT(v) \ 101 ({ \ 102 int __v = (v); \ 103 \ 104 if (__v & SENSOR_SCALE_SIGN) \ 105 __v |= SENSOR_SCALE_EXTEND; \ 106 __v; \ 107 }) 108 109struct scmi_msg_sensor_axis_description_get { 110 __le32 id; 111 __le32 axis_desc_index; 112}; 113 114struct scmi_msg_resp_sensor_axis_description { 115 __le32 num_axis_flags; 116#define NUM_AXIS_RETURNED(x) FIELD_GET(GENMASK(5, 0), (x)) 117#define NUM_AXIS_REMAINING(x) FIELD_GET(GENMASK(31, 26), (x)) 118 struct scmi_axis_descriptor { 119 __le32 id; 120 __le32 attributes_low; 121#define SUPPORTS_EXTENDED_AXIS_NAMES(x) FIELD_GET(BIT(9), (x)) 122 __le32 attributes_high; 123 u8 name[SCMI_SHORT_NAME_MAX_SIZE]; 124 __le32 resolution; 125 struct scmi_msg_resp_attrs attrs; 126 } desc[]; 127}; 128 129struct scmi_msg_resp_sensor_axis_names_description { 130 __le32 num_axis_flags; 131 struct scmi_sensor_axis_name_descriptor { 132 __le32 axis_id; 133 u8 name[SCMI_MAX_STR_SIZE]; 134 } desc[]; 135}; 136 137/* Base scmi_axis_descriptor size excluding extended attrs after name */ 138#define SCMI_MSG_RESP_AXIS_DESCR_BASE_SZ 28 139 140struct scmi_msg_sensor_list_update_intervals { 141 __le32 id; 142 __le32 index; 143}; 144 145struct scmi_msg_resp_sensor_list_update_intervals { 146 __le32 num_intervals_flags; 147#define NUM_INTERVALS_RETURNED(x) FIELD_GET(GENMASK(11, 0), (x)) 148#define SEGMENTED_INTVL_FORMAT(x) FIELD_GET(BIT(12), (x)) 149#define NUM_INTERVALS_REMAINING(x) FIELD_GET(GENMASK(31, 16), (x)) 150 __le32 intervals[]; 151}; 152 153struct scmi_msg_sensor_request_notify { 154 __le32 id; 155 __le32 event_control; 156#define SENSOR_NOTIFY_ALL BIT(0) 157}; 158 159struct scmi_msg_set_sensor_trip_point { 160 __le32 id; 161 __le32 event_control; 162#define SENSOR_TP_EVENT_MASK (0x3) 163#define SENSOR_TP_DISABLED 0x0 164#define SENSOR_TP_POSITIVE 0x1 165#define SENSOR_TP_NEGATIVE 0x2 166#define SENSOR_TP_BOTH 0x3 167#define SENSOR_TP_ID(x) (((x) & 0xff) << 4) 168 __le32 value_low; 169 __le32 value_high; 170}; 171 172struct scmi_msg_sensor_config_set { 173 __le32 id; 174 __le32 sensor_config; 175}; 176 177struct scmi_msg_sensor_reading_get { 178 __le32 id; 179 __le32 flags; 180#define SENSOR_READ_ASYNC BIT(0) 181}; 182 183struct scmi_resp_sensor_reading_complete { 184 __le32 id; 185 __le32 readings_low; 186 __le32 readings_high; 187}; 188 189struct scmi_sensor_reading_resp { 190 __le32 sensor_value_low; 191 __le32 sensor_value_high; 192 __le32 timestamp_low; 193 __le32 timestamp_high; 194}; 195 196struct scmi_resp_sensor_reading_complete_v3 { 197 __le32 id; 198 struct scmi_sensor_reading_resp readings[]; 199}; 200 201struct scmi_sensor_trip_notify_payld { 202 __le32 agent_id; 203 __le32 sensor_id; 204 __le32 trip_point_desc; 205}; 206 207struct scmi_sensor_update_notify_payld { 208 __le32 agent_id; 209 __le32 sensor_id; 210 struct scmi_sensor_reading_resp readings[]; 211}; 212 213struct sensors_info { 214 u32 version; 215 int num_sensors; 216 int max_requests; 217 u64 reg_addr; 218 u32 reg_size; 219 struct scmi_sensor_info *sensors; 220}; 221 222static int scmi_sensor_attributes_get(const struct scmi_protocol_handle *ph, 223 struct sensors_info *si) 224{ 225 int ret; 226 struct scmi_xfer *t; 227 struct scmi_msg_resp_sensor_attributes *attr; 228 229 ret = ph->xops->xfer_get_init(ph, PROTOCOL_ATTRIBUTES, 230 0, sizeof(*attr), &t); 231 if (ret) 232 return ret; 233 234 attr = t->rx.buf; 235 236 ret = ph->xops->do_xfer(ph, t); 237 if (!ret) { 238 si->num_sensors = le16_to_cpu(attr->num_sensors); 239 si->max_requests = attr->max_requests; 240 si->reg_addr = le32_to_cpu(attr->reg_addr_low) | 241 (u64)le32_to_cpu(attr->reg_addr_high) << 32; 242 si->reg_size = le32_to_cpu(attr->reg_size); 243 } 244 245 ph->xops->xfer_put(ph, t); 246 return ret; 247} 248 249static inline void scmi_parse_range_attrs(struct scmi_range_attrs *out, 250 const struct scmi_msg_resp_attrs *in) 251{ 252 out->min_range = get_unaligned_le64((void *)&in->min_range_low); 253 out->max_range = get_unaligned_le64((void *)&in->max_range_low); 254} 255 256struct scmi_sens_ipriv { 257 void *priv; 258 struct device *dev; 259}; 260 261static void iter_intervals_prepare_message(void *message, 262 unsigned int desc_index, 263 const void *p) 264{ 265 struct scmi_msg_sensor_list_update_intervals *msg = message; 266 const struct scmi_sensor_info *s; 267 268 s = ((const struct scmi_sens_ipriv *)p)->priv; 269 /* Set the number of sensors to be skipped/already read */ 270 msg->id = cpu_to_le32(s->id); 271 msg->index = cpu_to_le32(desc_index); 272} 273 274static int iter_intervals_update_state(struct scmi_iterator_state *st, 275 const void *response, void *p) 276{ 277 u32 flags; 278 struct scmi_sensor_info *s = ((struct scmi_sens_ipriv *)p)->priv; 279 struct device *dev = ((struct scmi_sens_ipriv *)p)->dev; 280 const struct scmi_msg_resp_sensor_list_update_intervals *r = response; 281 282 flags = le32_to_cpu(r->num_intervals_flags); 283 st->num_returned = NUM_INTERVALS_RETURNED(flags); 284 st->num_remaining = NUM_INTERVALS_REMAINING(flags); 285 286 /* 287 * Max intervals is not declared previously anywhere so we 288 * assume it's returned+remaining on first call. 289 */ 290 if (!st->max_resources) { 291 s->intervals.segmented = SEGMENTED_INTVL_FORMAT(flags); 292 s->intervals.count = st->num_returned + st->num_remaining; 293 /* segmented intervals are reported in one triplet */ 294 if (s->intervals.segmented && 295 (st->num_remaining || st->num_returned != 3)) { 296 dev_err(dev, 297 "Sensor ID:%d advertises an invalid segmented interval (%d)\n", 298 s->id, s->intervals.count); 299 s->intervals.segmented = false; 300 s->intervals.count = 0; 301 return -EINVAL; 302 } 303 /* Direct allocation when exceeding pre-allocated */ 304 if (s->intervals.count >= SCMI_MAX_PREALLOC_POOL) { 305 s->intervals.desc = 306 devm_kcalloc(dev, 307 s->intervals.count, 308 sizeof(*s->intervals.desc), 309 GFP_KERNEL); 310 if (!s->intervals.desc) { 311 s->intervals.segmented = false; 312 s->intervals.count = 0; 313 return -ENOMEM; 314 } 315 } 316 317 st->max_resources = s->intervals.count; 318 } 319 320 return 0; 321} 322 323static int 324iter_intervals_process_response(const struct scmi_protocol_handle *ph, 325 const void *response, 326 struct scmi_iterator_state *st, void *p) 327{ 328 const struct scmi_msg_resp_sensor_list_update_intervals *r = response; 329 struct scmi_sensor_info *s = ((struct scmi_sens_ipriv *)p)->priv; 330 331 s->intervals.desc[st->desc_index + st->loop_idx] = 332 le32_to_cpu(r->intervals[st->loop_idx]); 333 334 return 0; 335} 336 337static int scmi_sensor_update_intervals(const struct scmi_protocol_handle *ph, 338 struct scmi_sensor_info *s) 339{ 340 void *iter; 341 struct scmi_iterator_ops ops = { 342 .prepare_message = iter_intervals_prepare_message, 343 .update_state = iter_intervals_update_state, 344 .process_response = iter_intervals_process_response, 345 }; 346 struct scmi_sens_ipriv upriv = { 347 .priv = s, 348 .dev = ph->dev, 349 }; 350 351 iter = ph->hops->iter_response_init(ph, &ops, s->intervals.count, 352 SENSOR_LIST_UPDATE_INTERVALS, 353 sizeof(struct scmi_msg_sensor_list_update_intervals), 354 &upriv); 355 if (IS_ERR(iter)) 356 return PTR_ERR(iter); 357 358 return ph->hops->iter_response_run(iter); 359} 360 361struct scmi_apriv { 362 bool any_axes_support_extended_names; 363 struct scmi_sensor_info *s; 364}; 365 366static void iter_axes_desc_prepare_message(void *message, 367 const unsigned int desc_index, 368 const void *priv) 369{ 370 struct scmi_msg_sensor_axis_description_get *msg = message; 371 const struct scmi_apriv *apriv = priv; 372 373 /* Set the number of sensors to be skipped/already read */ 374 msg->id = cpu_to_le32(apriv->s->id); 375 msg->axis_desc_index = cpu_to_le32(desc_index); 376} 377 378static int 379iter_axes_desc_update_state(struct scmi_iterator_state *st, 380 const void *response, void *priv) 381{ 382 u32 flags; 383 const struct scmi_msg_resp_sensor_axis_description *r = response; 384 385 flags = le32_to_cpu(r->num_axis_flags); 386 st->num_returned = NUM_AXIS_RETURNED(flags); 387 st->num_remaining = NUM_AXIS_REMAINING(flags); 388 st->priv = (void *)&r->desc[0]; 389 390 return 0; 391} 392 393static int 394iter_axes_desc_process_response(const struct scmi_protocol_handle *ph, 395 const void *response, 396 struct scmi_iterator_state *st, void *priv) 397{ 398 u32 attrh, attrl; 399 struct scmi_sensor_axis_info *a; 400 size_t dsize = SCMI_MSG_RESP_AXIS_DESCR_BASE_SZ; 401 struct scmi_apriv *apriv = priv; 402 const struct scmi_axis_descriptor *adesc = st->priv; 403 404 attrl = le32_to_cpu(adesc->attributes_low); 405 if (SUPPORTS_EXTENDED_AXIS_NAMES(attrl)) 406 apriv->any_axes_support_extended_names = true; 407 408 a = &apriv->s->axis[st->desc_index + st->loop_idx]; 409 a->id = le32_to_cpu(adesc->id); 410 a->extended_attrs = SUPPORTS_EXTEND_ATTRS(attrl); 411 412 attrh = le32_to_cpu(adesc->attributes_high); 413 a->scale = S32_EXT(SENSOR_SCALE(attrh)); 414 a->type = SENSOR_TYPE(attrh); 415 strscpy(a->name, adesc->name, SCMI_SHORT_NAME_MAX_SIZE); 416 417 if (a->extended_attrs) { 418 unsigned int ares = le32_to_cpu(adesc->resolution); 419 420 a->resolution = SENSOR_RES(ares); 421 a->exponent = S32_EXT(SENSOR_RES_EXP(ares)); 422 dsize += sizeof(adesc->resolution); 423 424 scmi_parse_range_attrs(&a->attrs, &adesc->attrs); 425 dsize += sizeof(adesc->attrs); 426 } 427 st->priv = ((u8 *)adesc + dsize); 428 429 return 0; 430} 431 432static int 433iter_axes_extended_name_update_state(struct scmi_iterator_state *st, 434 const void *response, void *priv) 435{ 436 u32 flags; 437 const struct scmi_msg_resp_sensor_axis_names_description *r = response; 438 439 flags = le32_to_cpu(r->num_axis_flags); 440 st->num_returned = NUM_AXIS_RETURNED(flags); 441 st->num_remaining = NUM_AXIS_REMAINING(flags); 442 st->priv = (void *)&r->desc[0]; 443 444 return 0; 445} 446 447static int 448iter_axes_extended_name_process_response(const struct scmi_protocol_handle *ph, 449 const void *response, 450 struct scmi_iterator_state *st, 451 void *priv) 452{ 453 struct scmi_sensor_axis_info *a; 454 const struct scmi_apriv *apriv = priv; 455 struct scmi_sensor_axis_name_descriptor *adesc = st->priv; 456 u32 axis_id = le32_to_cpu(adesc->axis_id); 457 458 if (axis_id >= st->max_resources) 459 return -EPROTO; 460 461 /* 462 * Pick the corresponding descriptor based on the axis_id embedded 463 * in the reply since the list of axes supporting extended names 464 * can be a subset of all the axes. 465 */ 466 a = &apriv->s->axis[axis_id]; 467 strscpy(a->name, adesc->name, SCMI_MAX_STR_SIZE); 468 st->priv = ++adesc; 469 470 return 0; 471} 472 473static int 474scmi_sensor_axis_extended_names_get(const struct scmi_protocol_handle *ph, 475 struct scmi_sensor_info *s) 476{ 477 int ret; 478 void *iter; 479 struct scmi_iterator_ops ops = { 480 .prepare_message = iter_axes_desc_prepare_message, 481 .update_state = iter_axes_extended_name_update_state, 482 .process_response = iter_axes_extended_name_process_response, 483 }; 484 struct scmi_apriv apriv = { 485 .any_axes_support_extended_names = false, 486 .s = s, 487 }; 488 489 iter = ph->hops->iter_response_init(ph, &ops, s->num_axis, 490 SENSOR_AXIS_NAME_GET, 491 sizeof(struct scmi_msg_sensor_axis_description_get), 492 &apriv); 493 if (IS_ERR(iter)) 494 return PTR_ERR(iter); 495 496 /* 497 * Do not cause whole protocol initialization failure when failing to 498 * get extended names for axes. 499 */ 500 ret = ph->hops->iter_response_run(iter); 501 if (ret) 502 dev_warn(ph->dev, 503 "Failed to get axes extended names for %s (ret:%d).\n", 504 s->name, ret); 505 506 return 0; 507} 508 509static int scmi_sensor_axis_description(const struct scmi_protocol_handle *ph, 510 struct scmi_sensor_info *s, 511 u32 version) 512{ 513 int ret; 514 void *iter; 515 struct scmi_iterator_ops ops = { 516 .prepare_message = iter_axes_desc_prepare_message, 517 .update_state = iter_axes_desc_update_state, 518 .process_response = iter_axes_desc_process_response, 519 }; 520 struct scmi_apriv apriv = { 521 .any_axes_support_extended_names = false, 522 .s = s, 523 }; 524 525 s->axis = devm_kcalloc(ph->dev, s->num_axis, 526 sizeof(*s->axis), GFP_KERNEL); 527 if (!s->axis) 528 return -ENOMEM; 529 530 iter = ph->hops->iter_response_init(ph, &ops, s->num_axis, 531 SENSOR_AXIS_DESCRIPTION_GET, 532 sizeof(struct scmi_msg_sensor_axis_description_get), 533 &apriv); 534 if (IS_ERR(iter)) 535 return PTR_ERR(iter); 536 537 ret = ph->hops->iter_response_run(iter); 538 if (ret) 539 return ret; 540 541 if (PROTOCOL_REV_MAJOR(version) >= 0x3 && 542 apriv.any_axes_support_extended_names) 543 ret = scmi_sensor_axis_extended_names_get(ph, s); 544 545 return ret; 546} 547 548static void iter_sens_descr_prepare_message(void *message, 549 unsigned int desc_index, 550 const void *priv) 551{ 552 struct scmi_msg_sensor_description *msg = message; 553 554 msg->desc_index = cpu_to_le32(desc_index); 555} 556 557static int iter_sens_descr_update_state(struct scmi_iterator_state *st, 558 const void *response, void *priv) 559{ 560 const struct scmi_msg_resp_sensor_description *r = response; 561 562 st->num_returned = le16_to_cpu(r->num_returned); 563 st->num_remaining = le16_to_cpu(r->num_remaining); 564 st->priv = (void *)&r->desc[0]; 565 566 return 0; 567} 568 569static int 570iter_sens_descr_process_response(const struct scmi_protocol_handle *ph, 571 const void *response, 572 struct scmi_iterator_state *st, void *priv) 573 574{ 575 int ret = 0; 576 u32 attrh, attrl; 577 size_t dsize = SCMI_MSG_RESP_SENS_DESCR_BASE_SZ; 578 struct scmi_sensor_info *s; 579 struct sensors_info *si = priv; 580 const struct scmi_sensor_descriptor *sdesc = st->priv; 581 582 s = &si->sensors[st->desc_index + st->loop_idx]; 583 s->id = le32_to_cpu(sdesc->id); 584 585 attrl = le32_to_cpu(sdesc->attributes_low); 586 /* common bitfields parsing */ 587 s->async = SUPPORTS_ASYNC_READ(attrl); 588 s->num_trip_points = NUM_TRIP_POINTS(attrl); 589 /** 590 * only SCMIv3.0 specific bitfield below. 591 * Such bitfields are assumed to be zeroed on non 592 * relevant fw versions...assuming fw not buggy ! 593 */ 594 s->update = SUPPORTS_UPDATE_NOTIFY(attrl); 595 s->timestamped = SUPPORTS_TIMESTAMP(attrl); 596 if (s->timestamped) 597 s->tstamp_scale = S32_EXT(SENSOR_TSTAMP_EXP(attrl)); 598 s->extended_scalar_attrs = SUPPORTS_EXTEND_ATTRS(attrl); 599 600 attrh = le32_to_cpu(sdesc->attributes_high); 601 /* common bitfields parsing */ 602 s->scale = S32_EXT(SENSOR_SCALE(attrh)); 603 s->type = SENSOR_TYPE(attrh); 604 /* Use pre-allocated pool wherever possible */ 605 s->intervals.desc = s->intervals.prealloc_pool; 606 if (si->version == SCMIv2_SENSOR_PROTOCOL) { 607 s->intervals.segmented = false; 608 s->intervals.count = 1; 609 /* 610 * Convert SCMIv2.0 update interval format to 611 * SCMIv3.0 to be used as the common exposed 612 * descriptor, accessible via common macros. 613 */ 614 s->intervals.desc[0] = (SENSOR_UPDATE_BASE(attrh) << 5) | 615 SENSOR_UPDATE_SCALE(attrh); 616 } else { 617 /* 618 * From SCMIv3.0 update intervals are retrieved 619 * via a dedicated (optional) command. 620 * Since the command is optional, on error carry 621 * on without any update interval. 622 */ 623 if (scmi_sensor_update_intervals(ph, s)) 624 dev_dbg(ph->dev, 625 "Update Intervals not available for sensor ID:%d\n", 626 s->id); 627 } 628 /** 629 * only > SCMIv2.0 specific bitfield below. 630 * Such bitfields are assumed to be zeroed on non 631 * relevant fw versions...assuming fw not buggy ! 632 */ 633 s->num_axis = min_t(unsigned int, 634 SUPPORTS_AXIS(attrh) ? 635 SENSOR_AXIS_NUMBER(attrh) : 0, 636 SCMI_MAX_NUM_SENSOR_AXIS); 637 strscpy(s->name, sdesc->name, SCMI_SHORT_NAME_MAX_SIZE); 638 639 /* 640 * If supported overwrite short name with the extended 641 * one; on error just carry on and use already provided 642 * short name. 643 */ 644 if (PROTOCOL_REV_MAJOR(si->version) >= 0x3 && 645 SUPPORTS_EXTENDED_NAMES(attrl)) 646 ph->hops->extended_name_get(ph, SENSOR_NAME_GET, s->id, 647 s->name, SCMI_MAX_STR_SIZE); 648 649 if (s->extended_scalar_attrs) { 650 s->sensor_power = le32_to_cpu(sdesc->power); 651 dsize += sizeof(sdesc->power); 652 653 /* Only for sensors reporting scalar values */ 654 if (s->num_axis == 0) { 655 unsigned int sres = le32_to_cpu(sdesc->resolution); 656 657 s->resolution = SENSOR_RES(sres); 658 s->exponent = S32_EXT(SENSOR_RES_EXP(sres)); 659 dsize += sizeof(sdesc->resolution); 660 661 scmi_parse_range_attrs(&s->scalar_attrs, 662 &sdesc->scalar_attrs); 663 dsize += sizeof(sdesc->scalar_attrs); 664 } 665 } 666 667 if (s->num_axis > 0) 668 ret = scmi_sensor_axis_description(ph, s, si->version); 669 670 st->priv = ((u8 *)sdesc + dsize); 671 672 return ret; 673} 674 675static int scmi_sensor_description_get(const struct scmi_protocol_handle *ph, 676 struct sensors_info *si) 677{ 678 void *iter; 679 struct scmi_iterator_ops ops = { 680 .prepare_message = iter_sens_descr_prepare_message, 681 .update_state = iter_sens_descr_update_state, 682 .process_response = iter_sens_descr_process_response, 683 }; 684 685 iter = ph->hops->iter_response_init(ph, &ops, si->num_sensors, 686 SENSOR_DESCRIPTION_GET, 687 sizeof(__le32), si); 688 if (IS_ERR(iter)) 689 return PTR_ERR(iter); 690 691 return ph->hops->iter_response_run(iter); 692} 693 694static inline int 695scmi_sensor_request_notify(const struct scmi_protocol_handle *ph, u32 sensor_id, 696 u8 message_id, bool enable) 697{ 698 int ret; 699 u32 evt_cntl = enable ? SENSOR_NOTIFY_ALL : 0; 700 struct scmi_xfer *t; 701 struct scmi_msg_sensor_request_notify *cfg; 702 703 ret = ph->xops->xfer_get_init(ph, message_id, sizeof(*cfg), 0, &t); 704 if (ret) 705 return ret; 706 707 cfg = t->tx.buf; 708 cfg->id = cpu_to_le32(sensor_id); 709 cfg->event_control = cpu_to_le32(evt_cntl); 710 711 ret = ph->xops->do_xfer(ph, t); 712 713 ph->xops->xfer_put(ph, t); 714 return ret; 715} 716 717static int scmi_sensor_trip_point_notify(const struct scmi_protocol_handle *ph, 718 u32 sensor_id, bool enable) 719{ 720 return scmi_sensor_request_notify(ph, sensor_id, 721 SENSOR_TRIP_POINT_NOTIFY, 722 enable); 723} 724 725static int 726scmi_sensor_continuous_update_notify(const struct scmi_protocol_handle *ph, 727 u32 sensor_id, bool enable) 728{ 729 return scmi_sensor_request_notify(ph, sensor_id, 730 SENSOR_CONTINUOUS_UPDATE_NOTIFY, 731 enable); 732} 733 734static int 735scmi_sensor_trip_point_config(const struct scmi_protocol_handle *ph, 736 u32 sensor_id, u8 trip_id, u64 trip_value) 737{ 738 int ret; 739 u32 evt_cntl = SENSOR_TP_BOTH; 740 struct scmi_xfer *t; 741 struct scmi_msg_set_sensor_trip_point *trip; 742 743 ret = ph->xops->xfer_get_init(ph, SENSOR_TRIP_POINT_CONFIG, 744 sizeof(*trip), 0, &t); 745 if (ret) 746 return ret; 747 748 trip = t->tx.buf; 749 trip->id = cpu_to_le32(sensor_id); 750 trip->event_control = cpu_to_le32(evt_cntl | SENSOR_TP_ID(trip_id)); 751 trip->value_low = cpu_to_le32(trip_value & 0xffffffff); 752 trip->value_high = cpu_to_le32(trip_value >> 32); 753 754 ret = ph->xops->do_xfer(ph, t); 755 756 ph->xops->xfer_put(ph, t); 757 return ret; 758} 759 760static int scmi_sensor_config_get(const struct scmi_protocol_handle *ph, 761 u32 sensor_id, u32 *sensor_config) 762{ 763 int ret; 764 struct scmi_xfer *t; 765 struct sensors_info *si = ph->get_priv(ph); 766 767 if (sensor_id >= si->num_sensors) 768 return -EINVAL; 769 770 ret = ph->xops->xfer_get_init(ph, SENSOR_CONFIG_GET, 771 sizeof(__le32), sizeof(__le32), &t); 772 if (ret) 773 return ret; 774 775 put_unaligned_le32(sensor_id, t->tx.buf); 776 ret = ph->xops->do_xfer(ph, t); 777 if (!ret) { 778 struct scmi_sensor_info *s = si->sensors + sensor_id; 779 780 *sensor_config = get_unaligned_le64(t->rx.buf); 781 s->sensor_config = *sensor_config; 782 } 783 784 ph->xops->xfer_put(ph, t); 785 return ret; 786} 787 788static int scmi_sensor_config_set(const struct scmi_protocol_handle *ph, 789 u32 sensor_id, u32 sensor_config) 790{ 791 int ret; 792 struct scmi_xfer *t; 793 struct scmi_msg_sensor_config_set *msg; 794 struct sensors_info *si = ph->get_priv(ph); 795 796 if (sensor_id >= si->num_sensors) 797 return -EINVAL; 798 799 ret = ph->xops->xfer_get_init(ph, SENSOR_CONFIG_SET, 800 sizeof(*msg), 0, &t); 801 if (ret) 802 return ret; 803 804 msg = t->tx.buf; 805 msg->id = cpu_to_le32(sensor_id); 806 msg->sensor_config = cpu_to_le32(sensor_config); 807 808 ret = ph->xops->do_xfer(ph, t); 809 if (!ret) { 810 struct scmi_sensor_info *s = si->sensors + sensor_id; 811 812 s->sensor_config = sensor_config; 813 } 814 815 ph->xops->xfer_put(ph, t); 816 return ret; 817} 818 819/** 820 * scmi_sensor_reading_get - Read scalar sensor value 821 * @ph: Protocol handle 822 * @sensor_id: Sensor ID 823 * @value: The 64bit value sensor reading 824 * 825 * This function returns a single 64 bit reading value representing the sensor 826 * value; if the platform SCMI Protocol implementation and the sensor support 827 * multiple axis and timestamped-reads, this just returns the first axis while 828 * dropping the timestamp value. 829 * Use instead the @scmi_sensor_reading_get_timestamped to retrieve the array of 830 * timestamped multi-axis values. 831 * 832 * Return: 0 on Success 833 */ 834static int scmi_sensor_reading_get(const struct scmi_protocol_handle *ph, 835 u32 sensor_id, u64 *value) 836{ 837 int ret; 838 struct scmi_xfer *t; 839 struct scmi_msg_sensor_reading_get *sensor; 840 struct scmi_sensor_info *s; 841 struct sensors_info *si = ph->get_priv(ph); 842 843 if (sensor_id >= si->num_sensors) 844 return -EINVAL; 845 846 ret = ph->xops->xfer_get_init(ph, SENSOR_READING_GET, 847 sizeof(*sensor), 0, &t); 848 if (ret) 849 return ret; 850 851 sensor = t->tx.buf; 852 sensor->id = cpu_to_le32(sensor_id); 853 s = si->sensors + sensor_id; 854 if (s->async) { 855 sensor->flags = cpu_to_le32(SENSOR_READ_ASYNC); 856 ret = ph->xops->do_xfer_with_response(ph, t); 857 if (!ret) { 858 struct scmi_resp_sensor_reading_complete *resp; 859 860 resp = t->rx.buf; 861 if (le32_to_cpu(resp->id) == sensor_id) 862 *value = 863 get_unaligned_le64(&resp->readings_low); 864 else 865 ret = -EPROTO; 866 } 867 } else { 868 sensor->flags = cpu_to_le32(0); 869 ret = ph->xops->do_xfer(ph, t); 870 if (!ret) 871 *value = get_unaligned_le64(t->rx.buf); 872 } 873 874 ph->xops->xfer_put(ph, t); 875 return ret; 876} 877 878static inline void 879scmi_parse_sensor_readings(struct scmi_sensor_reading *out, 880 const struct scmi_sensor_reading_resp *in) 881{ 882 out->value = get_unaligned_le64((void *)&in->sensor_value_low); 883 out->timestamp = get_unaligned_le64((void *)&in->timestamp_low); 884} 885 886/** 887 * scmi_sensor_reading_get_timestamped - Read multiple-axis timestamped values 888 * @ph: Protocol handle 889 * @sensor_id: Sensor ID 890 * @count: The length of the provided @readings array 891 * @readings: An array of elements each representing a timestamped per-axis 892 * reading of type @struct scmi_sensor_reading. 893 * Returned readings are ordered as the @axis descriptors array 894 * included in @struct scmi_sensor_info and the max number of 895 * returned elements is min(@count, @num_axis); ideally the provided 896 * array should be of length @count equal to @num_axis. 897 * 898 * Return: 0 on Success 899 */ 900static int 901scmi_sensor_reading_get_timestamped(const struct scmi_protocol_handle *ph, 902 u32 sensor_id, u8 count, 903 struct scmi_sensor_reading *readings) 904{ 905 int ret; 906 struct scmi_xfer *t; 907 struct scmi_msg_sensor_reading_get *sensor; 908 struct scmi_sensor_info *s; 909 struct sensors_info *si = ph->get_priv(ph); 910 911 if (sensor_id >= si->num_sensors) 912 return -EINVAL; 913 914 s = si->sensors + sensor_id; 915 if (!count || !readings || 916 (!s->num_axis && count > 1) || (s->num_axis && count > s->num_axis)) 917 return -EINVAL; 918 919 ret = ph->xops->xfer_get_init(ph, SENSOR_READING_GET, 920 sizeof(*sensor), 0, &t); 921 if (ret) 922 return ret; 923 924 sensor = t->tx.buf; 925 sensor->id = cpu_to_le32(sensor_id); 926 if (s->async) { 927 sensor->flags = cpu_to_le32(SENSOR_READ_ASYNC); 928 ret = ph->xops->do_xfer_with_response(ph, t); 929 if (!ret) { 930 int i; 931 struct scmi_resp_sensor_reading_complete_v3 *resp; 932 933 resp = t->rx.buf; 934 /* Retrieve only the number of requested axis anyway */ 935 if (le32_to_cpu(resp->id) == sensor_id) 936 for (i = 0; i < count; i++) 937 scmi_parse_sensor_readings(&readings[i], 938 &resp->readings[i]); 939 else 940 ret = -EPROTO; 941 } 942 } else { 943 sensor->flags = cpu_to_le32(0); 944 ret = ph->xops->do_xfer(ph, t); 945 if (!ret) { 946 int i; 947 struct scmi_sensor_reading_resp *resp_readings; 948 949 resp_readings = t->rx.buf; 950 for (i = 0; i < count; i++) 951 scmi_parse_sensor_readings(&readings[i], 952 &resp_readings[i]); 953 } 954 } 955 956 ph->xops->xfer_put(ph, t); 957 return ret; 958} 959 960static const struct scmi_sensor_info * 961scmi_sensor_info_get(const struct scmi_protocol_handle *ph, u32 sensor_id) 962{ 963 struct sensors_info *si = ph->get_priv(ph); 964 965 if (sensor_id >= si->num_sensors) 966 return NULL; 967 968 return si->sensors + sensor_id; 969} 970 971static int scmi_sensor_count_get(const struct scmi_protocol_handle *ph) 972{ 973 struct sensors_info *si = ph->get_priv(ph); 974 975 return si->num_sensors; 976} 977 978static const struct scmi_sensor_proto_ops sensor_proto_ops = { 979 .count_get = scmi_sensor_count_get, 980 .info_get = scmi_sensor_info_get, 981 .trip_point_config = scmi_sensor_trip_point_config, 982 .reading_get = scmi_sensor_reading_get, 983 .reading_get_timestamped = scmi_sensor_reading_get_timestamped, 984 .config_get = scmi_sensor_config_get, 985 .config_set = scmi_sensor_config_set, 986}; 987 988static int scmi_sensor_set_notify_enabled(const struct scmi_protocol_handle *ph, 989 u8 evt_id, u32 src_id, bool enable) 990{ 991 int ret; 992 993 switch (evt_id) { 994 case SCMI_EVENT_SENSOR_TRIP_POINT_EVENT: 995 ret = scmi_sensor_trip_point_notify(ph, src_id, enable); 996 break; 997 case SCMI_EVENT_SENSOR_UPDATE: 998 ret = scmi_sensor_continuous_update_notify(ph, src_id, enable); 999 break; 1000 default: 1001 ret = -EINVAL; 1002 break; 1003 } 1004 1005 if (ret) 1006 pr_debug("FAIL_ENABLED - evt[%X] dom[%d] - ret:%d\n", 1007 evt_id, src_id, ret); 1008 1009 return ret; 1010} 1011 1012static void * 1013scmi_sensor_fill_custom_report(const struct scmi_protocol_handle *ph, 1014 u8 evt_id, ktime_t timestamp, 1015 const void *payld, size_t payld_sz, 1016 void *report, u32 *src_id) 1017{ 1018 void *rep = NULL; 1019 1020 switch (evt_id) { 1021 case SCMI_EVENT_SENSOR_TRIP_POINT_EVENT: 1022 { 1023 const struct scmi_sensor_trip_notify_payld *p = payld; 1024 struct scmi_sensor_trip_point_report *r = report; 1025 1026 if (sizeof(*p) != payld_sz) 1027 break; 1028 1029 r->timestamp = timestamp; 1030 r->agent_id = le32_to_cpu(p->agent_id); 1031 r->sensor_id = le32_to_cpu(p->sensor_id); 1032 r->trip_point_desc = le32_to_cpu(p->trip_point_desc); 1033 *src_id = r->sensor_id; 1034 rep = r; 1035 break; 1036 } 1037 case SCMI_EVENT_SENSOR_UPDATE: 1038 { 1039 int i; 1040 struct scmi_sensor_info *s; 1041 const struct scmi_sensor_update_notify_payld *p = payld; 1042 struct scmi_sensor_update_report *r = report; 1043 struct sensors_info *sinfo = ph->get_priv(ph); 1044 1045 /* payld_sz is variable for this event */ 1046 r->sensor_id = le32_to_cpu(p->sensor_id); 1047 if (r->sensor_id >= sinfo->num_sensors) 1048 break; 1049 r->timestamp = timestamp; 1050 r->agent_id = le32_to_cpu(p->agent_id); 1051 s = &sinfo->sensors[r->sensor_id]; 1052 /* 1053 * The generated report r (@struct scmi_sensor_update_report) 1054 * was pre-allocated to contain up to SCMI_MAX_NUM_SENSOR_AXIS 1055 * readings: here it is filled with the effective @num_axis 1056 * readings defined for this sensor or 1 for scalar sensors. 1057 */ 1058 r->readings_count = s->num_axis ?: 1; 1059 for (i = 0; i < r->readings_count; i++) 1060 scmi_parse_sensor_readings(&r->readings[i], 1061 &p->readings[i]); 1062 *src_id = r->sensor_id; 1063 rep = r; 1064 break; 1065 } 1066 default: 1067 break; 1068 } 1069 1070 return rep; 1071} 1072 1073static int scmi_sensor_get_num_sources(const struct scmi_protocol_handle *ph) 1074{ 1075 struct sensors_info *si = ph->get_priv(ph); 1076 1077 return si->num_sensors; 1078} 1079 1080static const struct scmi_event sensor_events[] = { 1081 { 1082 .id = SCMI_EVENT_SENSOR_TRIP_POINT_EVENT, 1083 .max_payld_sz = sizeof(struct scmi_sensor_trip_notify_payld), 1084 .max_report_sz = sizeof(struct scmi_sensor_trip_point_report), 1085 }, 1086 { 1087 .id = SCMI_EVENT_SENSOR_UPDATE, 1088 .max_payld_sz = 1089 sizeof(struct scmi_sensor_update_notify_payld) + 1090 SCMI_MAX_NUM_SENSOR_AXIS * 1091 sizeof(struct scmi_sensor_reading_resp), 1092 .max_report_sz = sizeof(struct scmi_sensor_update_report) + 1093 SCMI_MAX_NUM_SENSOR_AXIS * 1094 sizeof(struct scmi_sensor_reading), 1095 }, 1096}; 1097 1098static const struct scmi_event_ops sensor_event_ops = { 1099 .get_num_sources = scmi_sensor_get_num_sources, 1100 .set_notify_enabled = scmi_sensor_set_notify_enabled, 1101 .fill_custom_report = scmi_sensor_fill_custom_report, 1102}; 1103 1104static const struct scmi_protocol_events sensor_protocol_events = { 1105 .queue_sz = SCMI_PROTO_QUEUE_SZ, 1106 .ops = &sensor_event_ops, 1107 .evts = sensor_events, 1108 .num_events = ARRAY_SIZE(sensor_events), 1109}; 1110 1111static int scmi_sensors_protocol_init(const struct scmi_protocol_handle *ph) 1112{ 1113 u32 version; 1114 int ret; 1115 struct sensors_info *sinfo; 1116 1117 ret = ph->xops->version_get(ph, &version); 1118 if (ret) 1119 return ret; 1120 1121 dev_dbg(ph->dev, "Sensor Version %d.%d\n", 1122 PROTOCOL_REV_MAJOR(version), PROTOCOL_REV_MINOR(version)); 1123 1124 sinfo = devm_kzalloc(ph->dev, sizeof(*sinfo), GFP_KERNEL); 1125 if (!sinfo) 1126 return -ENOMEM; 1127 sinfo->version = version; 1128 1129 ret = scmi_sensor_attributes_get(ph, sinfo); 1130 if (ret) 1131 return ret; 1132 sinfo->sensors = devm_kcalloc(ph->dev, sinfo->num_sensors, 1133 sizeof(*sinfo->sensors), GFP_KERNEL); 1134 if (!sinfo->sensors) 1135 return -ENOMEM; 1136 1137 ret = scmi_sensor_description_get(ph, sinfo); 1138 if (ret) 1139 return ret; 1140 1141 return ph->set_priv(ph, sinfo); 1142} 1143 1144static const struct scmi_protocol scmi_sensors = { 1145 .id = SCMI_PROTOCOL_SENSOR, 1146 .owner = THIS_MODULE, 1147 .instance_init = &scmi_sensors_protocol_init, 1148 .ops = &sensor_proto_ops, 1149 .events = &sensor_protocol_events, 1150}; 1151 1152DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(sensors, scmi_sensors) 1153