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