1 // SPDX-License-Identifier: GPL-2.0
3 * System Control and Management Interface (SCMI) Voltage Protocol
5 * Copyright (C) 2020-2021 ARM Ltd.
8 #include <linux/module.h>
9 #include <linux/scmi_protocol.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,
26 #define NUM_VOLTAGE_DOMAINS(x) ((u16)(FIELD_GET(VOLTAGE_DOMS_NUM_MASK, (x))))
28 struct scmi_msg_resp_domain_attributes {
30 u8 name[SCMI_MAX_STR_SIZE];
33 struct scmi_msg_cmd_describe_levels {
38 struct scmi_msg_resp_describe_levels {
40 #define NUM_REMAINING_LEVELS(f) ((u16)(FIELD_GET(REMAINING_LEVELS_MASK, (f))))
41 #define NUM_RETURNED_LEVELS(f) ((u16)(FIELD_GET(RETURNED_LEVELS_MASK, (f))))
42 #define SUPPORTS_SEGMENTED_LEVELS(f) ((f) & BIT(12))
46 struct scmi_msg_cmd_config_set {
51 struct scmi_msg_cmd_level_set {
59 unsigned int num_domains;
60 struct scmi_voltage_info *domains;
63 static int scmi_protocol_attributes_get(const struct scmi_protocol_handle *ph,
64 struct voltage_info *vinfo)
69 ret = ph->xops->xfer_get_init(ph, PROTOCOL_ATTRIBUTES, 0,
74 ret = ph->xops->do_xfer(ph, t);
77 NUM_VOLTAGE_DOMAINS(get_unaligned_le32(t->rx.buf));
79 ph->xops->xfer_put(ph, t);
83 static int scmi_init_voltage_levels(struct device *dev,
84 struct scmi_voltage_info *v,
85 u32 num_returned, u32 num_remaining,
90 num_levels = num_returned + num_remaining;
92 * segmented levels entries are represented by a single triplet
93 * returned all in one go.
96 (segmented && (num_remaining || num_returned != 3))) {
98 "Invalid level descriptor(%d/%d/%d) for voltage dom %d\n",
99 num_levels, num_returned, num_remaining, v->id);
103 v->levels_uv = devm_kcalloc(dev, num_levels, sizeof(u32), GFP_KERNEL);
107 v->num_levels = num_levels;
108 v->segmented = segmented;
113 static int scmi_voltage_descriptors_get(const struct scmi_protocol_handle *ph,
114 struct voltage_info *vinfo)
117 struct scmi_xfer *td, *tl;
118 struct device *dev = ph->dev;
119 struct scmi_msg_resp_domain_attributes *resp_dom;
120 struct scmi_msg_resp_describe_levels *resp_levels;
122 ret = ph->xops->xfer_get_init(ph, VOLTAGE_DOMAIN_ATTRIBUTES,
123 sizeof(__le32), sizeof(*resp_dom), &td);
126 resp_dom = td->rx.buf;
128 ret = ph->xops->xfer_get_init(ph, VOLTAGE_DESCRIBE_LEVELS,
129 sizeof(__le64), 0, &tl);
132 resp_levels = tl->rx.buf;
134 for (dom = 0; dom < vinfo->num_domains; dom++) {
136 u16 num_returned = 0, num_remaining = 0;
137 struct scmi_msg_cmd_describe_levels *cmd;
138 struct scmi_voltage_info *v;
140 /* Retrieve domain attributes at first ... */
141 put_unaligned_le32(dom, td->tx.buf);
142 ret = ph->xops->do_xfer(ph, td);
143 /* Skip domain on comms error */
147 v = vinfo->domains + dom;
149 v->attributes = le32_to_cpu(resp_dom->attr);
150 strlcpy(v->name, resp_dom->name, SCMI_MAX_STR_SIZE);
153 /* ...then retrieve domain levels descriptions */
158 cmd->domain_id = cpu_to_le32(v->id);
159 cmd->level_index = cpu_to_le32(desc_index);
160 ret = ph->xops->do_xfer(ph, tl);
164 flags = le32_to_cpu(resp_levels->flags);
165 num_returned = NUM_RETURNED_LEVELS(flags);
166 num_remaining = NUM_REMAINING_LEVELS(flags);
168 /* Allocate space for num_levels if not already done */
169 if (!v->num_levels) {
170 ret = scmi_init_voltage_levels(dev, v,
173 SUPPORTS_SEGMENTED_LEVELS(flags));
178 if (desc_index + num_returned > v->num_levels) {
180 "No. of voltage levels can't exceed %d\n",
186 for (cnt = 0; cnt < num_returned; cnt++) {
190 (s32)le32_to_cpu(resp_levels->voltage[cnt]);
191 v->levels_uv[desc_index + cnt] = val;
193 v->negative_volts_allowed = true;
196 desc_index += num_returned;
198 ph->xops->reset_rx_to_maxsz(ph, tl);
199 /* check both to avoid infinite loop due to buggy fw */
200 } while (num_returned && num_remaining);
204 devm_kfree(dev, v->levels_uv);
207 ph->xops->reset_rx_to_maxsz(ph, td);
210 ph->xops->xfer_put(ph, tl);
212 ph->xops->xfer_put(ph, td);
217 static int __scmi_voltage_get_u32(const struct scmi_protocol_handle *ph,
218 u8 cmd_id, u32 domain_id, u32 *value)
222 struct voltage_info *vinfo = ph->get_priv(ph);
224 if (domain_id >= vinfo->num_domains)
227 ret = ph->xops->xfer_get_init(ph, cmd_id, sizeof(__le32), 0, &t);
231 put_unaligned_le32(domain_id, t->tx.buf);
232 ret = ph->xops->do_xfer(ph, t);
234 *value = get_unaligned_le32(t->rx.buf);
236 ph->xops->xfer_put(ph, t);
240 static int scmi_voltage_config_set(const struct scmi_protocol_handle *ph,
241 u32 domain_id, u32 config)
245 struct voltage_info *vinfo = ph->get_priv(ph);
246 struct scmi_msg_cmd_config_set *cmd;
248 if (domain_id >= vinfo->num_domains)
251 ret = ph->xops->xfer_get_init(ph, VOLTAGE_CONFIG_SET,
252 sizeof(*cmd), 0, &t);
257 cmd->domain_id = cpu_to_le32(domain_id);
258 cmd->config = cpu_to_le32(config & GENMASK(3, 0));
260 ret = ph->xops->do_xfer(ph, t);
262 ph->xops->xfer_put(ph, t);
266 static int scmi_voltage_config_get(const struct scmi_protocol_handle *ph,
267 u32 domain_id, u32 *config)
269 return __scmi_voltage_get_u32(ph, VOLTAGE_CONFIG_GET,
273 static int scmi_voltage_level_set(const struct scmi_protocol_handle *ph,
274 u32 domain_id, u32 flags, s32 volt_uV)
278 struct voltage_info *vinfo = ph->get_priv(ph);
279 struct scmi_msg_cmd_level_set *cmd;
281 if (domain_id >= vinfo->num_domains)
284 ret = ph->xops->xfer_get_init(ph, VOLTAGE_LEVEL_SET,
285 sizeof(*cmd), 0, &t);
290 cmd->domain_id = cpu_to_le32(domain_id);
291 cmd->flags = cpu_to_le32(flags);
292 cmd->voltage_level = cpu_to_le32(volt_uV);
294 ret = ph->xops->do_xfer(ph, t);
296 ph->xops->xfer_put(ph, t);
300 static int scmi_voltage_level_get(const struct scmi_protocol_handle *ph,
301 u32 domain_id, s32 *volt_uV)
303 return __scmi_voltage_get_u32(ph, VOLTAGE_LEVEL_GET,
304 domain_id, (u32 *)volt_uV);
307 static const struct scmi_voltage_info * __must_check
308 scmi_voltage_info_get(const struct scmi_protocol_handle *ph, u32 domain_id)
310 struct voltage_info *vinfo = ph->get_priv(ph);
312 if (domain_id >= vinfo->num_domains ||
313 !vinfo->domains[domain_id].num_levels)
316 return vinfo->domains + domain_id;
319 static int scmi_voltage_domains_num_get(const struct scmi_protocol_handle *ph)
321 struct voltage_info *vinfo = ph->get_priv(ph);
323 return vinfo->num_domains;
326 static struct scmi_voltage_proto_ops voltage_proto_ops = {
327 .num_domains_get = scmi_voltage_domains_num_get,
328 .info_get = scmi_voltage_info_get,
329 .config_set = scmi_voltage_config_set,
330 .config_get = scmi_voltage_config_get,
331 .level_set = scmi_voltage_level_set,
332 .level_get = scmi_voltage_level_get,
335 static int scmi_voltage_protocol_init(const struct scmi_protocol_handle *ph)
339 struct voltage_info *vinfo;
341 ret = ph->xops->version_get(ph, &version);
345 dev_dbg(ph->dev, "Voltage Version %d.%d\n",
346 PROTOCOL_REV_MAJOR(version), PROTOCOL_REV_MINOR(version));
348 vinfo = devm_kzalloc(ph->dev, sizeof(*vinfo), GFP_KERNEL);
351 vinfo->version = version;
353 ret = scmi_protocol_attributes_get(ph, vinfo);
357 if (vinfo->num_domains) {
358 vinfo->domains = devm_kcalloc(ph->dev, vinfo->num_domains,
359 sizeof(*vinfo->domains),
363 ret = scmi_voltage_descriptors_get(ph, vinfo);
367 dev_warn(ph->dev, "No Voltage domains found.\n");
370 return ph->set_priv(ph, vinfo);
373 static const struct scmi_protocol scmi_voltage = {
374 .id = SCMI_PROTOCOL_VOLTAGE,
375 .owner = THIS_MODULE,
376 .instance_init = &scmi_voltage_protocol_init,
377 .ops = &voltage_proto_ops,
380 DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(voltage, scmi_voltage)