drivers/firmware/arm_scmi/sensors.c

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