1 // SPDX-License-Identifier: GPL-2.0
3 * System Control and Management Interface (SCMI) Voltage Protocol
5 * Copyright (C) 2020-2022 ARM Ltd.
8 #include <linux/module.h>
9 #include <linux/scmi_protocol.h>
11 #include "protocols.h"
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)
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,
27 #define NUM_VOLTAGE_DOMAINS(x) ((u16)(FIELD_GET(VOLTAGE_DOMS_NUM_MASK, (x))))
29 struct scmi_msg_resp_domain_attributes {
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];
36 struct scmi_msg_cmd_describe_levels {
41 struct scmi_msg_resp_describe_levels {
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))
49 struct scmi_msg_cmd_config_set {
54 struct scmi_msg_cmd_level_set {
60 struct scmi_resp_voltage_level_set_complete {
67 unsigned int num_domains;
68 struct scmi_voltage_info *domains;
71 static int scmi_protocol_attributes_get(const struct scmi_protocol_handle *ph,
72 struct voltage_info *vinfo)
77 ret = ph->xops->xfer_get_init(ph, PROTOCOL_ATTRIBUTES, 0,
82 ret = ph->xops->do_xfer(ph, t);
85 NUM_VOLTAGE_DOMAINS(get_unaligned_le32(t->rx.buf));
87 ph->xops->xfer_put(ph, t);
91 static int scmi_init_voltage_levels(struct device *dev,
92 struct scmi_voltage_info *v,
93 u32 num_returned, u32 num_remaining,
98 num_levels = num_returned + num_remaining;
100 * segmented levels entries are represented by a single triplet
101 * returned all in one go.
104 (segmented && (num_remaining || num_returned != 3))) {
106 "Invalid level descriptor(%d/%d/%d) for voltage dom %d\n",
107 num_levels, num_returned, num_remaining, v->id);
111 v->levels_uv = devm_kcalloc(dev, num_levels, sizeof(u32), GFP_KERNEL);
115 v->num_levels = num_levels;
116 v->segmented = segmented;
121 struct scmi_volt_ipriv {
123 struct scmi_voltage_info *v;
126 static void iter_volt_levels_prepare_message(void *message,
127 unsigned int desc_index,
130 struct scmi_msg_cmd_describe_levels *msg = message;
131 const struct scmi_volt_ipriv *p = priv;
133 msg->domain_id = cpu_to_le32(p->v->id);
134 msg->level_index = cpu_to_le32(desc_index);
137 static int iter_volt_levels_update_state(struct scmi_iterator_state *st,
138 const void *response, void *priv)
142 const struct scmi_msg_resp_describe_levels *r = response;
143 struct scmi_volt_ipriv *p = priv;
145 flags = le32_to_cpu(r->flags);
146 st->num_returned = NUM_RETURNED_LEVELS(flags);
147 st->num_remaining = NUM_REMAINING_LEVELS(flags);
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,
153 SUPPORTS_SEGMENTED_LEVELS(flags));
155 st->max_resources = p->v->num_levels;
162 iter_volt_levels_process_response(const struct scmi_protocol_handle *ph,
163 const void *response,
164 struct scmi_iterator_state *st, void *priv)
167 const struct scmi_msg_resp_describe_levels *r = response;
168 struct scmi_volt_ipriv *p = priv;
170 val = (s32)le32_to_cpu(r->voltage[st->loop_idx]);
171 p->v->levels_uv[st->desc_index + st->loop_idx] = val;
173 p->v->negative_volts_allowed = true;
178 static int scmi_voltage_levels_get(const struct scmi_protocol_handle *ph,
179 struct scmi_voltage_info *v)
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,
188 struct scmi_volt_ipriv vpriv = {
193 iter = ph->hops->iter_response_init(ph, &ops, v->num_levels,
194 VOLTAGE_DESCRIBE_LEVELS,
195 sizeof(struct scmi_msg_cmd_describe_levels),
198 return PTR_ERR(iter);
200 ret = ph->hops->iter_response_run(iter);
203 devm_kfree(ph->dev, v->levels_uv);
209 static int scmi_voltage_descriptors_get(const struct scmi_protocol_handle *ph,
210 struct voltage_info *vinfo)
213 struct scmi_xfer *td;
214 struct scmi_msg_resp_domain_attributes *resp_dom;
216 ret = ph->xops->xfer_get_init(ph, VOLTAGE_DOMAIN_ATTRIBUTES,
217 sizeof(__le32), sizeof(*resp_dom), &td);
220 resp_dom = td->rx.buf;
222 for (dom = 0; dom < vinfo->num_domains; dom++) {
224 struct scmi_voltage_info *v;
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))
232 v = vinfo->domains + dom;
234 attributes = le32_to_cpu(resp_dom->attr);
235 strscpy(v->name, resp_dom->name, SCMI_SHORT_NAME_MAX_SIZE);
238 * If supported overwrite short name with the extended one;
239 * on error just carry on and use already provided short name.
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,
247 if (SUPPORTS_ASYNC_LEVEL_SET(attributes))
248 v->async_level_set = true;
251 /* Skip invalid voltage descriptors */
252 scmi_voltage_levels_get(ph, v);
255 ph->xops->xfer_put(ph, td);
260 static int __scmi_voltage_get_u32(const struct scmi_protocol_handle *ph,
261 u8 cmd_id, u32 domain_id, u32 *value)
265 struct voltage_info *vinfo = ph->get_priv(ph);
267 if (domain_id >= vinfo->num_domains)
270 ret = ph->xops->xfer_get_init(ph, cmd_id, sizeof(__le32), 0, &t);
274 put_unaligned_le32(domain_id, t->tx.buf);
275 ret = ph->xops->do_xfer(ph, t);
277 *value = get_unaligned_le32(t->rx.buf);
279 ph->xops->xfer_put(ph, t);
283 static int scmi_voltage_config_set(const struct scmi_protocol_handle *ph,
284 u32 domain_id, u32 config)
288 struct voltage_info *vinfo = ph->get_priv(ph);
289 struct scmi_msg_cmd_config_set *cmd;
291 if (domain_id >= vinfo->num_domains)
294 ret = ph->xops->xfer_get_init(ph, VOLTAGE_CONFIG_SET,
295 sizeof(*cmd), 0, &t);
300 cmd->domain_id = cpu_to_le32(domain_id);
301 cmd->config = cpu_to_le32(config & GENMASK(3, 0));
303 ret = ph->xops->do_xfer(ph, t);
305 ph->xops->xfer_put(ph, t);
309 static int scmi_voltage_config_get(const struct scmi_protocol_handle *ph,
310 u32 domain_id, u32 *config)
312 return __scmi_voltage_get_u32(ph, VOLTAGE_CONFIG_GET,
316 static int scmi_voltage_level_set(const struct scmi_protocol_handle *ph,
318 enum scmi_voltage_level_mode mode,
323 struct voltage_info *vinfo = ph->get_priv(ph);
324 struct scmi_msg_cmd_level_set *cmd;
325 struct scmi_voltage_info *v;
327 if (domain_id >= vinfo->num_domains)
330 ret = ph->xops->xfer_get_init(ph, VOLTAGE_LEVEL_SET,
331 sizeof(*cmd), 0, &t);
335 v = vinfo->domains + domain_id;
338 cmd->domain_id = cpu_to_le32(domain_id);
339 cmd->voltage_level = cpu_to_le32(volt_uV);
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);
345 cmd->flags = cpu_to_le32(0x1);
346 ret = ph->xops->do_xfer_with_response(ph, t);
348 struct scmi_resp_voltage_level_set_complete *resp;
351 if (le32_to_cpu(resp->domain_id) == domain_id)
353 "Voltage domain %d set async to %d\n",
355 le32_to_cpu(resp->voltage_level));
361 ph->xops->xfer_put(ph, t);
365 static int scmi_voltage_level_get(const struct scmi_protocol_handle *ph,
366 u32 domain_id, s32 *volt_uV)
368 return __scmi_voltage_get_u32(ph, VOLTAGE_LEVEL_GET,
369 domain_id, (u32 *)volt_uV);
372 static const struct scmi_voltage_info * __must_check
373 scmi_voltage_info_get(const struct scmi_protocol_handle *ph, u32 domain_id)
375 struct voltage_info *vinfo = ph->get_priv(ph);
377 if (domain_id >= vinfo->num_domains ||
378 !vinfo->domains[domain_id].num_levels)
381 return vinfo->domains + domain_id;
384 static int scmi_voltage_domains_num_get(const struct scmi_protocol_handle *ph)
386 struct voltage_info *vinfo = ph->get_priv(ph);
388 return vinfo->num_domains;
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,
400 static int scmi_voltage_protocol_init(const struct scmi_protocol_handle *ph)
404 struct voltage_info *vinfo;
406 ret = ph->xops->version_get(ph, &version);
410 dev_dbg(ph->dev, "Voltage Version %d.%d\n",
411 PROTOCOL_REV_MAJOR(version), PROTOCOL_REV_MINOR(version));
413 vinfo = devm_kzalloc(ph->dev, sizeof(*vinfo), GFP_KERNEL);
416 vinfo->version = version;
418 ret = scmi_protocol_attributes_get(ph, vinfo);
422 if (vinfo->num_domains) {
423 vinfo->domains = devm_kcalloc(ph->dev, vinfo->num_domains,
424 sizeof(*vinfo->domains),
428 ret = scmi_voltage_descriptors_get(ph, vinfo);
432 dev_warn(ph->dev, "No Voltage domains found.\n");
435 return ph->set_priv(ph, vinfo);
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,
445 DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(voltage, scmi_voltage)