1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * System Control and Management Interface (SCMI) Sensor Protocol
4  *
5  * Copyright (C) 2018 ARM Ltd.
6  */
7 
8 #include "common.h"
9 
10 enum scmi_sensor_protocol_cmd {
11 	SENSOR_DESCRIPTION_GET = 0x3,
12 	SENSOR_CONFIG_SET = 0x4,
13 	SENSOR_TRIP_POINT_SET = 0x5,
14 	SENSOR_READING_GET = 0x6,
15 };
16 
17 struct scmi_msg_resp_sensor_attributes {
18 	__le16 num_sensors;
19 	u8 max_requests;
20 	u8 reserved;
21 	__le32 reg_addr_low;
22 	__le32 reg_addr_high;
23 	__le32 reg_size;
24 };
25 
26 struct scmi_msg_resp_sensor_description {
27 	__le16 num_returned;
28 	__le16 num_remaining;
29 	struct {
30 		__le32 id;
31 		__le32 attributes_low;
32 #define SUPPORTS_ASYNC_READ(x)	((x) & BIT(31))
33 #define NUM_TRIP_POINTS(x)	(((x) >> 4) & 0xff)
34 		__le32 attributes_high;
35 #define SENSOR_TYPE(x)		((x) & 0xff)
36 #define SENSOR_SCALE(x)		(((x) >> 11) & 0x3f)
37 #define SENSOR_UPDATE_SCALE(x)	(((x) >> 22) & 0x1f)
38 #define SENSOR_UPDATE_BASE(x)	(((x) >> 27) & 0x1f)
39 		    u8 name[SCMI_MAX_STR_SIZE];
40 	} desc[0];
41 };
42 
43 struct scmi_msg_set_sensor_config {
44 	__le32 id;
45 	__le32 event_control;
46 };
47 
48 struct scmi_msg_set_sensor_trip_point {
49 	__le32 id;
50 	__le32 event_control;
51 #define SENSOR_TP_EVENT_MASK	(0x3)
52 #define SENSOR_TP_DISABLED	0x0
53 #define SENSOR_TP_POSITIVE	0x1
54 #define SENSOR_TP_NEGATIVE	0x2
55 #define SENSOR_TP_BOTH		0x3
56 #define SENSOR_TP_ID(x)		(((x) & 0xff) << 4)
57 	__le32 value_low;
58 	__le32 value_high;
59 };
60 
61 struct scmi_msg_sensor_reading_get {
62 	__le32 id;
63 	__le32 flags;
64 #define SENSOR_READ_ASYNC	BIT(0)
65 };
66 
67 struct sensors_info {
68 	int num_sensors;
69 	int max_requests;
70 	u64 reg_addr;
71 	u32 reg_size;
72 	struct scmi_sensor_info *sensors;
73 };
74 
75 static int scmi_sensor_attributes_get(const struct scmi_handle *handle,
76 				      struct sensors_info *si)
77 {
78 	int ret;
79 	struct scmi_xfer *t;
80 	struct scmi_msg_resp_sensor_attributes *attr;
81 
82 	ret = scmi_xfer_get_init(handle, PROTOCOL_ATTRIBUTES,
83 				 SCMI_PROTOCOL_SENSOR, 0, sizeof(*attr), &t);
84 	if (ret)
85 		return ret;
86 
87 	attr = t->rx.buf;
88 
89 	ret = scmi_do_xfer(handle, t);
90 	if (!ret) {
91 		si->num_sensors = le16_to_cpu(attr->num_sensors);
92 		si->max_requests = attr->max_requests;
93 		si->reg_addr = le32_to_cpu(attr->reg_addr_low) |
94 				(u64)le32_to_cpu(attr->reg_addr_high) << 32;
95 		si->reg_size = le32_to_cpu(attr->reg_size);
96 	}
97 
98 	scmi_xfer_put(handle, t);
99 	return ret;
100 }
101 
102 static int scmi_sensor_description_get(const struct scmi_handle *handle,
103 				       struct sensors_info *si)
104 {
105 	int ret, cnt;
106 	u32 desc_index = 0;
107 	u16 num_returned, num_remaining;
108 	struct scmi_xfer *t;
109 	struct scmi_msg_resp_sensor_description *buf;
110 
111 	ret = scmi_xfer_get_init(handle, SENSOR_DESCRIPTION_GET,
112 				 SCMI_PROTOCOL_SENSOR, sizeof(__le32), 0, &t);
113 	if (ret)
114 		return ret;
115 
116 	buf = t->rx.buf;
117 
118 	do {
119 		/* Set the number of sensors to be skipped/already read */
120 		*(__le32 *)t->tx.buf = cpu_to_le32(desc_index);
121 
122 		ret = scmi_do_xfer(handle, t);
123 		if (ret)
124 			break;
125 
126 		num_returned = le16_to_cpu(buf->num_returned);
127 		num_remaining = le16_to_cpu(buf->num_remaining);
128 
129 		if (desc_index + num_returned > si->num_sensors) {
130 			dev_err(handle->dev, "No. of sensors can't exceed %d",
131 				si->num_sensors);
132 			break;
133 		}
134 
135 		for (cnt = 0; cnt < num_returned; cnt++) {
136 			u32 attrh;
137 			struct scmi_sensor_info *s;
138 
139 			attrh = le32_to_cpu(buf->desc[cnt].attributes_high);
140 			s = &si->sensors[desc_index + cnt];
141 			s->id = le32_to_cpu(buf->desc[cnt].id);
142 			s->type = SENSOR_TYPE(attrh);
143 			memcpy(s->name, buf->desc[cnt].name, SCMI_MAX_STR_SIZE);
144 		}
145 
146 		desc_index += num_returned;
147 		/*
148 		 * check for both returned and remaining to avoid infinite
149 		 * loop due to buggy firmware
150 		 */
151 	} while (num_returned && num_remaining);
152 
153 	scmi_xfer_put(handle, t);
154 	return ret;
155 }
156 
157 static int
158 scmi_sensor_configuration_set(const struct scmi_handle *handle, u32 sensor_id)
159 {
160 	int ret;
161 	u32 evt_cntl = BIT(0);
162 	struct scmi_xfer *t;
163 	struct scmi_msg_set_sensor_config *cfg;
164 
165 	ret = scmi_xfer_get_init(handle, SENSOR_CONFIG_SET,
166 				 SCMI_PROTOCOL_SENSOR, sizeof(*cfg), 0, &t);
167 	if (ret)
168 		return ret;
169 
170 	cfg = t->tx.buf;
171 	cfg->id = cpu_to_le32(sensor_id);
172 	cfg->event_control = cpu_to_le32(evt_cntl);
173 
174 	ret = scmi_do_xfer(handle, t);
175 
176 	scmi_xfer_put(handle, t);
177 	return ret;
178 }
179 
180 static int scmi_sensor_trip_point_set(const struct scmi_handle *handle,
181 				      u32 sensor_id, u8 trip_id, u64 trip_value)
182 {
183 	int ret;
184 	u32 evt_cntl = SENSOR_TP_BOTH;
185 	struct scmi_xfer *t;
186 	struct scmi_msg_set_sensor_trip_point *trip;
187 
188 	ret = scmi_xfer_get_init(handle, SENSOR_TRIP_POINT_SET,
189 				 SCMI_PROTOCOL_SENSOR, sizeof(*trip), 0, &t);
190 	if (ret)
191 		return ret;
192 
193 	trip = t->tx.buf;
194 	trip->id = cpu_to_le32(sensor_id);
195 	trip->event_control = cpu_to_le32(evt_cntl | SENSOR_TP_ID(trip_id));
196 	trip->value_low = cpu_to_le32(trip_value & 0xffffffff);
197 	trip->value_high = cpu_to_le32(trip_value >> 32);
198 
199 	ret = scmi_do_xfer(handle, t);
200 
201 	scmi_xfer_put(handle, t);
202 	return ret;
203 }
204 
205 static int scmi_sensor_reading_get(const struct scmi_handle *handle,
206 				   u32 sensor_id, bool async, u64 *value)
207 {
208 	int ret;
209 	struct scmi_xfer *t;
210 	struct scmi_msg_sensor_reading_get *sensor;
211 
212 	ret = scmi_xfer_get_init(handle, SENSOR_READING_GET,
213 				 SCMI_PROTOCOL_SENSOR, sizeof(*sensor),
214 				 sizeof(u64), &t);
215 	if (ret)
216 		return ret;
217 
218 	sensor = t->tx.buf;
219 	sensor->id = cpu_to_le32(sensor_id);
220 	sensor->flags = cpu_to_le32(async ? SENSOR_READ_ASYNC : 0);
221 
222 	ret = scmi_do_xfer(handle, t);
223 	if (!ret) {
224 		__le32 *pval = t->rx.buf;
225 
226 		*value = le32_to_cpu(*pval);
227 		*value |= (u64)le32_to_cpu(*(pval + 1)) << 32;
228 	}
229 
230 	scmi_xfer_put(handle, t);
231 	return ret;
232 }
233 
234 static const struct scmi_sensor_info *
235 scmi_sensor_info_get(const struct scmi_handle *handle, u32 sensor_id)
236 {
237 	struct sensors_info *si = handle->sensor_priv;
238 
239 	return si->sensors + sensor_id;
240 }
241 
242 static int scmi_sensor_count_get(const struct scmi_handle *handle)
243 {
244 	struct sensors_info *si = handle->sensor_priv;
245 
246 	return si->num_sensors;
247 }
248 
249 static struct scmi_sensor_ops sensor_ops = {
250 	.count_get = scmi_sensor_count_get,
251 	.info_get = scmi_sensor_info_get,
252 	.configuration_set = scmi_sensor_configuration_set,
253 	.trip_point_set = scmi_sensor_trip_point_set,
254 	.reading_get = scmi_sensor_reading_get,
255 };
256 
257 static int scmi_sensors_protocol_init(struct scmi_handle *handle)
258 {
259 	u32 version;
260 	struct sensors_info *sinfo;
261 
262 	scmi_version_get(handle, SCMI_PROTOCOL_SENSOR, &version);
263 
264 	dev_dbg(handle->dev, "Sensor Version %d.%d\n",
265 		PROTOCOL_REV_MAJOR(version), PROTOCOL_REV_MINOR(version));
266 
267 	sinfo = devm_kzalloc(handle->dev, sizeof(*sinfo), GFP_KERNEL);
268 	if (!sinfo)
269 		return -ENOMEM;
270 
271 	scmi_sensor_attributes_get(handle, sinfo);
272 
273 	sinfo->sensors = devm_kcalloc(handle->dev, sinfo->num_sensors,
274 				      sizeof(*sinfo->sensors), GFP_KERNEL);
275 	if (!sinfo->sensors)
276 		return -ENOMEM;
277 
278 	scmi_sensor_description_get(handle, sinfo);
279 
280 	handle->sensor_ops = &sensor_ops;
281 	handle->sensor_priv = sinfo;
282 
283 	return 0;
284 }
285 
286 static int __init scmi_sensors_init(void)
287 {
288 	return scmi_protocol_register(SCMI_PROTOCOL_SENSOR,
289 				      &scmi_sensors_protocol_init);
290 }
291 subsys_initcall(scmi_sensors_init);
292