drivers/firmware/arm_scmi/voltage.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * System Control and Management Interface (SCMI) Voltage Protocol
   4  *
   5  * Copyright (C) 2020-2022 ARM Ltd.
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/scmi_protocol.h>
  10
  11 #include "protocols.h"
  12
  13 #define VOLTAGE_DOMS_NUM_MASK           GENMASK(15, 0)
  14 #define REMAINING_LEVELS_MASK           GENMASK(31, 16)
  15 #define RETURNED_LEVELS_MASK            GENMASK(11, 0)
  16
  17 enum scmi_voltage_protocol_cmd {
  18         VOLTAGE_DOMAIN_ATTRIBUTES = 0x3,
  19         VOLTAGE_DESCRIBE_LEVELS = 0x4,
  20         VOLTAGE_CONFIG_SET = 0x5,
  21         VOLTAGE_CONFIG_GET = 0x6,
  22         VOLTAGE_LEVEL_SET = 0x7,
  23         VOLTAGE_LEVEL_GET = 0x8,
  24         VOLTAGE_DOMAIN_NAME_GET = 0x09,
  25 };
  26
  27 #define NUM_VOLTAGE_DOMAINS(x)  ((u16)(FIELD_GET(VOLTAGE_DOMS_NUM_MASK, (x))))
  28
  29 struct scmi_msg_resp_domain_attributes {
  30         __le32 attr;
  31 #define SUPPORTS_ASYNC_LEVEL_SET(x)     ((x) & BIT(31))
  32 #define SUPPORTS_EXTENDED_NAMES(x)      ((x) & BIT(30))
  33         u8 name[SCMI_SHORT_NAME_MAX_SIZE];
  34 };
  35
  36 struct scmi_msg_cmd_describe_levels {
  37         __le32 domain_id;
  38         __le32 level_index;
  39 };
  40
  41 struct scmi_msg_resp_describe_levels {
  42         __le32 flags;
  43 #define NUM_REMAINING_LEVELS(f) ((u16)(FIELD_GET(REMAINING_LEVELS_MASK, (f))))
  44 #define NUM_RETURNED_LEVELS(f)  ((u16)(FIELD_GET(RETURNED_LEVELS_MASK, (f))))
  45 #define SUPPORTS_SEGMENTED_LEVELS(f)    ((f) & BIT(12))
  46         __le32 voltage[];
  47 };
  48
  49 struct scmi_msg_cmd_config_set {
  50         __le32 domain_id;
  51         __le32 config;
  52 };
  53
  54 struct scmi_msg_cmd_level_set {
  55         __le32 domain_id;
  56         __le32 flags;
  57         __le32 voltage_level;
  58 };
  59
  60 struct scmi_resp_voltage_level_set_complete {
  61         __le32 domain_id;
  62         __le32 voltage_level;
  63 };
  64
  65 struct voltage_info {
  66         unsigned int version;
  67         unsigned int num_domains;
  68         struct scmi_voltage_info *domains;
  69 };
  70
  71 static int scmi_protocol_attributes_get(const struct scmi_protocol_handle *ph,
  72                                         struct voltage_info *vinfo)
  73 {
  74         int ret;
  75         struct scmi_xfer *t;
  76
  77         ret = ph->xops->xfer_get_init(ph, PROTOCOL_ATTRIBUTES, 0,
  78                                       sizeof(__le32), &t);
  79         if (ret)
  80                 return ret;
  81
  82         ret = ph->xops->do_xfer(ph, t);
  83         if (!ret)
  84                 vinfo->num_domains =
  85                         NUM_VOLTAGE_DOMAINS(get_unaligned_le32(t->rx.buf));
  86
  87         ph->xops->xfer_put(ph, t);
  88         return ret;
  89 }
  90
  91 static int scmi_init_voltage_levels(struct device *dev,
  92                                     struct scmi_voltage_info *v,
  93                                     u32 num_returned, u32 num_remaining,
  94                                     bool segmented)
  95 {
  96         u32 num_levels;
  97
  98         num_levels = num_returned + num_remaining;
  99         /*
 100          * segmented levels entries are represented by a single triplet
 101          * returned all in one go.
 102          */
 103         if (!num_levels ||
 104             (segmented && (num_remaining || num_returned != 3))) {
 105                 dev_err(dev,
 106                         "Invalid level descriptor(%d/%d/%d) for voltage dom %d\n",
 107                         num_levels, num_returned, num_remaining, v->id);
 108                 return -EINVAL;
 109         }
 110
 111         v->levels_uv = devm_kcalloc(dev, num_levels, sizeof(u32), GFP_KERNEL);
 112         if (!v->levels_uv)
 113                 return -ENOMEM;
 114
 115         v->num_levels = num_levels;
 116         v->segmented = segmented;
 117
 118         return 0;
 119 }
 120
 121 struct scmi_volt_ipriv {
 122         struct device *dev;
 123         struct scmi_voltage_info *v;
 124 };
 125
 126 static void iter_volt_levels_prepare_message(void *message,
 127                                              unsigned int desc_index,
 128                                              const void *priv)
 129 {
 130         struct scmi_msg_cmd_describe_levels *msg = message;
 131         const struct scmi_volt_ipriv *p = priv;
 132
 133         msg->domain_id = cpu_to_le32(p->v->id);
 134         msg->level_index = cpu_to_le32(desc_index);
 135 }
 136
 137 static int iter_volt_levels_update_state(struct scmi_iterator_state *st,
 138                                          const void *response, void *priv)
 139 {
 140         int ret = 0;
 141         u32 flags;
 142         const struct scmi_msg_resp_describe_levels *r = response;
 143         struct scmi_volt_ipriv *p = priv;
 144
 145         flags = le32_to_cpu(r->flags);
 146         st->num_returned = NUM_RETURNED_LEVELS(flags);
 147         st->num_remaining = NUM_REMAINING_LEVELS(flags);
 148
 149         /* Allocate space for num_levels if not already done */
 150         if (!p->v->num_levels) {
 151                 ret = scmi_init_voltage_levels(p->dev, p->v, st->num_returned,
 152                                                st->num_remaining,
 153                                               SUPPORTS_SEGMENTED_LEVELS(flags));
 154                 if (!ret)
 155                         st->max_resources = p->v->num_levels;
 156         }
 157
 158         return ret;
 159 }
 160
 161 static int
 162 iter_volt_levels_process_response(const struct scmi_protocol_handle *ph,
 163                                   const void *response,
 164                                   struct scmi_iterator_state *st, void *priv)
 165 {
 166         s32 val;
 167         const struct scmi_msg_resp_describe_levels *r = response;
 168         struct scmi_volt_ipriv *p = priv;
 169
 170         val = (s32)le32_to_cpu(r->voltage[st->loop_idx]);
 171         p->v->levels_uv[st->desc_index + st->loop_idx] = val;
 172         if (val < 0)
 173                 p->v->negative_volts_allowed = true;
 174
 175         return 0;
 176 }
 177
 178 static int scmi_voltage_levels_get(const struct scmi_protocol_handle *ph,
 179                                    struct scmi_voltage_info *v)
 180 {
 181         int ret;
 182         void *iter;
 183         struct scmi_iterator_ops ops = {
 184                 .prepare_message = iter_volt_levels_prepare_message,
 185                 .update_state = iter_volt_levels_update_state,
 186                 .process_response = iter_volt_levels_process_response,
 187         };
 188         struct scmi_volt_ipriv vpriv = {
 189                 .dev = ph->dev,
 190                 .v = v,
 191         };
 192
 193         iter = ph->hops->iter_response_init(ph, &ops, v->num_levels,
 194                                             VOLTAGE_DESCRIBE_LEVELS,
 195                                             sizeof(struct scmi_msg_cmd_describe_levels),
 196                                             &vpriv);
 197         if (IS_ERR(iter))
 198                 return PTR_ERR(iter);
 199
 200         ret = ph->hops->iter_response_run(iter);
 201         if (ret) {
 202                 v->num_levels = 0;
 203                 devm_kfree(ph->dev, v->levels_uv);
 204         }
 205
 206         return ret;
 207 }
 208
 209 static int scmi_voltage_descriptors_get(const struct scmi_protocol_handle *ph,
 210                                         struct voltage_info *vinfo)
 211 {
 212         int ret, dom;
 213         struct scmi_xfer *td;
 214         struct scmi_msg_resp_domain_attributes *resp_dom;
 215
 216         ret = ph->xops->xfer_get_init(ph, VOLTAGE_DOMAIN_ATTRIBUTES,
 217                                       sizeof(__le32), sizeof(*resp_dom), &td);
 218         if (ret)
 219                 return ret;
 220         resp_dom = td->rx.buf;
 221
 222         for (dom = 0; dom < vinfo->num_domains; dom++) {
 223                 u32 attributes;
 224                 struct scmi_voltage_info *v;
 225
 226                 /* Retrieve domain attributes at first ... */
 227                 put_unaligned_le32(dom, td->tx.buf);
 228                 /* Skip domain on comms error */
 229                 if (ph->xops->do_xfer(ph, td))
 230                         continue;
 231
 232                 v = vinfo->domains + dom;
 233                 v->id = dom;
 234                 attributes = le32_to_cpu(resp_dom->attr);
 235                 strscpy(v->name, resp_dom->name, SCMI_SHORT_NAME_MAX_SIZE);
 236
 237                 /*
 238                  * If supported overwrite short name with the extended one;
 239                  * on error just carry on and use already provided short name.
 240                  */
 241                 if (PROTOCOL_REV_MAJOR(vinfo->version) >= 0x2) {
 242                         if (SUPPORTS_EXTENDED_NAMES(attributes))
 243                                 ph->hops->extended_name_get(ph,
 244                                                         VOLTAGE_DOMAIN_NAME_GET,
 245                                                         v->id, v->name,
 246                                                         SCMI_MAX_STR_SIZE);
 247                         if (SUPPORTS_ASYNC_LEVEL_SET(attributes))
 248                                 v->async_level_set = true;
 249                 }
 250
 251                 /* Skip invalid voltage descriptors */
 252                 scmi_voltage_levels_get(ph, v);
 253         }
 254
 255         ph->xops->xfer_put(ph, td);
 256
 257         return ret;
 258 }
 259
 260 static int __scmi_voltage_get_u32(const struct scmi_protocol_handle *ph,
 261                                   u8 cmd_id, u32 domain_id, u32 *value)
 262 {
 263         int ret;
 264         struct scmi_xfer *t;
 265         struct voltage_info *vinfo = ph->get_priv(ph);
 266
 267         if (domain_id >= vinfo->num_domains)
 268                 return -EINVAL;
 269
 270         ret = ph->xops->xfer_get_init(ph, cmd_id, sizeof(__le32), 0, &t);
 271         if (ret)
 272                 return ret;
 273
 274         put_unaligned_le32(domain_id, t->tx.buf);
 275         ret = ph->xops->do_xfer(ph, t);
 276         if (!ret)
 277                 *value = get_unaligned_le32(t->rx.buf);
 278
 279         ph->xops->xfer_put(ph, t);
 280         return ret;
 281 }
 282
 283 static int scmi_voltage_config_set(const struct scmi_protocol_handle *ph,
 284                                    u32 domain_id, u32 config)
 285 {
 286         int ret;
 287         struct scmi_xfer *t;
 288         struct voltage_info *vinfo = ph->get_priv(ph);
 289         struct scmi_msg_cmd_config_set *cmd;
 290
 291         if (domain_id >= vinfo->num_domains)
 292                 return -EINVAL;
 293
 294         ret = ph->xops->xfer_get_init(ph, VOLTAGE_CONFIG_SET,
 295                                      sizeof(*cmd), 0, &t);
 296         if (ret)
 297                 return ret;
 298
 299         cmd = t->tx.buf;
 300         cmd->domain_id = cpu_to_le32(domain_id);
 301         cmd->config = cpu_to_le32(config & GENMASK(3, 0));
 302
 303         ret = ph->xops->do_xfer(ph, t);
 304
 305         ph->xops->xfer_put(ph, t);
 306         return ret;
 307 }
 308
 309 static int scmi_voltage_config_get(const struct scmi_protocol_handle *ph,
 310                                    u32 domain_id, u32 *config)
 311 {
 312         return __scmi_voltage_get_u32(ph, VOLTAGE_CONFIG_GET,
 313                                       domain_id, config);
 314 }
 315
 316 static int scmi_voltage_level_set(const struct scmi_protocol_handle *ph,
 317                                   u32 domain_id,
 318                                   enum scmi_voltage_level_mode mode,
 319                                   s32 volt_uV)
 320 {
 321         int ret;
 322         struct scmi_xfer *t;
 323         struct voltage_info *vinfo = ph->get_priv(ph);
 324         struct scmi_msg_cmd_level_set *cmd;
 325         struct scmi_voltage_info *v;
 326
 327         if (domain_id >= vinfo->num_domains)
 328                 return -EINVAL;
 329
 330         ret = ph->xops->xfer_get_init(ph, VOLTAGE_LEVEL_SET,
 331                                       sizeof(*cmd), 0, &t);
 332         if (ret)
 333                 return ret;
 334
 335         v = vinfo->domains + domain_id;
 336
 337         cmd = t->tx.buf;
 338         cmd->domain_id = cpu_to_le32(domain_id);
 339         cmd->voltage_level = cpu_to_le32(volt_uV);
 340
 341         if (!v->async_level_set || mode != SCMI_VOLTAGE_LEVEL_SET_AUTO) {
 342                 cmd->flags = cpu_to_le32(0x0);
 343                 ret = ph->xops->do_xfer(ph, t);
 344         } else {
 345                 cmd->flags = cpu_to_le32(0x1);
 346                 ret = ph->xops->do_xfer_with_response(ph, t);
 347                 if (!ret) {
 348                         struct scmi_resp_voltage_level_set_complete *resp;
 349
 350                         resp = t->rx.buf;
 351                         if (le32_to_cpu(resp->domain_id) == domain_id)
 352                                 dev_dbg(ph->dev,
 353                                         "Voltage domain %d set async to %d\n",
 354                                         v->id,
 355                                         le32_to_cpu(resp->voltage_level));
 356                         else
 357                                 ret = -EPROTO;
 358                 }
 359         }
 360
 361         ph->xops->xfer_put(ph, t);
 362         return ret;
 363 }
 364
 365 static int scmi_voltage_level_get(const struct scmi_protocol_handle *ph,
 366                                   u32 domain_id, s32 *volt_uV)
 367 {
 368         return __scmi_voltage_get_u32(ph, VOLTAGE_LEVEL_GET,
 369                                       domain_id, (u32 *)volt_uV);
 370 }
 371
 372 static const struct scmi_voltage_info * __must_check
 373 scmi_voltage_info_get(const struct scmi_protocol_handle *ph, u32 domain_id)
 374 {
 375         struct voltage_info *vinfo = ph->get_priv(ph);
 376
 377         if (domain_id >= vinfo->num_domains ||
 378             !vinfo->domains[domain_id].num_levels)
 379                 return NULL;
 380
 381         return vinfo->domains + domain_id;
 382 }
 383
 384 static int scmi_voltage_domains_num_get(const struct scmi_protocol_handle *ph)
 385 {
 386         struct voltage_info *vinfo = ph->get_priv(ph);
 387
 388         return vinfo->num_domains;
 389 }
 390
 391 static struct scmi_voltage_proto_ops voltage_proto_ops = {
 392         .num_domains_get = scmi_voltage_domains_num_get,
 393         .info_get = scmi_voltage_info_get,
 394         .config_set = scmi_voltage_config_set,
 395         .config_get = scmi_voltage_config_get,
 396         .level_set = scmi_voltage_level_set,
 397         .level_get = scmi_voltage_level_get,
 398 };
 399
 400 static int scmi_voltage_protocol_init(const struct scmi_protocol_handle *ph)
 401 {
 402         int ret;
 403         u32 version;
 404         struct voltage_info *vinfo;
 405
 406         ret = ph->xops->version_get(ph, &version);
 407         if (ret)
 408                 return ret;
 409
 410         dev_dbg(ph->dev, "Voltage Version %d.%d\n",
 411                 PROTOCOL_REV_MAJOR(version), PROTOCOL_REV_MINOR(version));
 412
 413         vinfo = devm_kzalloc(ph->dev, sizeof(*vinfo), GFP_KERNEL);
 414         if (!vinfo)
 415                 return -ENOMEM;
 416         vinfo->version = version;
 417
 418         ret = scmi_protocol_attributes_get(ph, vinfo);
 419         if (ret)
 420                 return ret;
 421
 422         if (vinfo->num_domains) {
 423                 vinfo->domains = devm_kcalloc(ph->dev, vinfo->num_domains,
 424                                               sizeof(*vinfo->domains),
 425                                               GFP_KERNEL);
 426                 if (!vinfo->domains)
 427                         return -ENOMEM;
 428                 ret = scmi_voltage_descriptors_get(ph, vinfo);
 429                 if (ret)
 430                         return ret;
 431         } else {
 432                 dev_warn(ph->dev, "No Voltage domains found.\n");
 433         }
 434
 435         return ph->set_priv(ph, vinfo);
 436 }
 437
 438 static const struct scmi_protocol scmi_voltage = {
 439         .id = SCMI_PROTOCOL_VOLTAGE,
 440         .owner = THIS_MODULE,
 441         .instance_init = &scmi_voltage_protocol_init,
 442         .ops = &voltage_proto_ops,
 443 };
 444
 445 DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(voltage, scmi_voltage)