write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/drivers/firmware/arm_scmi/reset.c
..
..
@@ -2,19 +2,21 @@
2
2
 /*
3
3
  * System Control and Management Interface (SCMI) Reset Protocol
4
4
  *
5
- * Copyright (C) 2019 ARM Ltd.
5
+ * Copyright (C) 2019-2020 ARM Ltd.
6
6
  */
7
7
 
8
+#define pr_fmt(fmt) "SCMI Notifications RESET - " fmt
9
+
10
+#include <linux/module.h>
11
+#include <linux/scmi_protocol.h>
12
+
8
13
 #include "common.h"
14
+#include "notify.h"
9
15
 
10
16
 enum scmi_reset_protocol_cmd {
11
17
 	RESET_DOMAIN_ATTRIBUTES = 0x3,
12
18
 	RESET = 0x4,
13
19
 	RESET_NOTIFY = 0x5,
14
-};
15
-
16
-enum scmi_reset_protocol_notify {
17
-	RESET_ISSUED = 0x0,
18
20
 };
19
21
 
20
22
 #define NUM_RESET_DOMAIN_MASK	0xffff
..
..
@@ -38,6 +40,18 @@
38
40
 #define ARCH_COLD_RESET		0
39
41
 };
40
42
 
43
+struct scmi_msg_reset_notify {
44
+	__le32 id;
45
+	__le32 event_control;
46
+#define RESET_TP_NOTIFY_ALL	BIT(0)
47
+};
48
+
49
+struct scmi_reset_issued_notify_payld {
50
+	__le32 agent_id;
51
+	__le32 domain_id;
52
+	__le32 reset_state;
53
+};
54
+
41
55
 struct reset_dom_info {
42
56
 	bool async_reset;
43
57
 	bool reset_notify;
..
..
@@ -51,46 +65,45 @@
51
65
 	struct reset_dom_info *dom_info;
52
66
 };
53
67
 
54
-static int scmi_reset_attributes_get(const struct scmi_handle *handle,
68
+static int scmi_reset_attributes_get(const struct scmi_protocol_handle *ph,
55
69
 				     struct scmi_reset_info *pi)
56
70
 {
57
71
 	int ret;
58
72
 	struct scmi_xfer *t;
59
73
 	u32 attr;
60
74
 
61
-	ret = scmi_xfer_get_init(handle, PROTOCOL_ATTRIBUTES,
62
-				 SCMI_PROTOCOL_RESET, 0, sizeof(attr), &t);
75
+	ret = ph->xops->xfer_get_init(ph, PROTOCOL_ATTRIBUTES,
76
+				      0, sizeof(attr), &t);
63
77
 	if (ret)
64
78
 		return ret;
65
79
 
66
-	ret = scmi_do_xfer(handle, t);
80
+	ret = ph->xops->do_xfer(ph, t);
67
81
 	if (!ret) {
68
82
 		attr = get_unaligned_le32(t->rx.buf);
69
83
 		pi->num_domains = attr & NUM_RESET_DOMAIN_MASK;
70
84
 	}
71
85
 
72
-	scmi_xfer_put(handle, t);
86
+	ph->xops->xfer_put(ph, t);
73
87
 	return ret;
74
88
 }
75
89
 
76
90
 static int
77
-scmi_reset_domain_attributes_get(const struct scmi_handle *handle, u32 domain,
78
-				 struct reset_dom_info *dom_info)
91
+scmi_reset_domain_attributes_get(const struct scmi_protocol_handle *ph,
92
+				 u32 domain, struct reset_dom_info *dom_info)
79
93
 {
80
94
 	int ret;
81
95
 	struct scmi_xfer *t;
82
96
 	struct scmi_msg_resp_reset_domain_attributes *attr;
83
97
 
84
-	ret = scmi_xfer_get_init(handle, RESET_DOMAIN_ATTRIBUTES,
85
-				 SCMI_PROTOCOL_RESET, sizeof(domain),
86
-				 sizeof(*attr), &t);
98
+	ret = ph->xops->xfer_get_init(ph, RESET_DOMAIN_ATTRIBUTES,
99
+				      sizeof(domain), sizeof(*attr), &t);
87
100
 	if (ret)
88
101
 		return ret;
89
102
 
90
103
 	put_unaligned_le32(domain, t->tx.buf);
91
104
 	attr = t->rx.buf;
92
105
 
93
-	ret = scmi_do_xfer(handle, t);
106
+	ret = ph->xops->do_xfer(ph, t);
94
107
 	if (!ret) {
95
108
 		u32 attributes = le32_to_cpu(attr->attributes);
96
109
 
..
..
@@ -102,47 +115,49 @@
102
115
 		strlcpy(dom_info->name, attr->name, SCMI_MAX_STR_SIZE);
103
116
 	}
104
117
 
105
-	scmi_xfer_put(handle, t);
118
+	ph->xops->xfer_put(ph, t);
106
119
 	return ret;
107
120
 }
108
121
 
109
-static int scmi_reset_num_domains_get(const struct scmi_handle *handle)
122
+static int scmi_reset_num_domains_get(const struct scmi_protocol_handle *ph)
110
123
 {
111
-	struct scmi_reset_info *pi = handle->reset_priv;
124
+	struct scmi_reset_info *pi = ph->get_priv(ph);
112
125
 
113
126
 	return pi->num_domains;
114
127
 }
115
128
 
116
-static char *scmi_reset_name_get(const struct scmi_handle *handle, u32 domain)
129
+static char *scmi_reset_name_get(const struct scmi_protocol_handle *ph,
130
+				 u32 domain)
117
131
 {
118
-	struct scmi_reset_info *pi = handle->reset_priv;
132
+	struct scmi_reset_info *pi = ph->get_priv(ph);
133
+
119
134
 	struct reset_dom_info *dom = pi->dom_info + domain;
120
135
 
121
136
 	return dom->name;
122
137
 }
123
138
 
124
-static int scmi_reset_latency_get(const struct scmi_handle *handle, u32 domain)
139
+static int scmi_reset_latency_get(const struct scmi_protocol_handle *ph,
140
+				  u32 domain)
125
141
 {
126
-	struct scmi_reset_info *pi = handle->reset_priv;
142
+	struct scmi_reset_info *pi = ph->get_priv(ph);
127
143
 	struct reset_dom_info *dom = pi->dom_info + domain;
128
144
 
129
145
 	return dom->latency_us;
130
146
 }
131
147
 
132
-static int scmi_domain_reset(const struct scmi_handle *handle, u32 domain,
148
+static int scmi_domain_reset(const struct scmi_protocol_handle *ph, u32 domain,
133
149
 			     u32 flags, u32 state)
134
150
 {
135
151
 	int ret;
136
152
 	struct scmi_xfer *t;
137
153
 	struct scmi_msg_reset_domain_reset *dom;
138
-	struct scmi_reset_info *pi = handle->reset_priv;
154
+	struct scmi_reset_info *pi = ph->get_priv(ph);
139
155
 	struct reset_dom_info *rdom = pi->dom_info + domain;
140
156
 
141
157
 	if (rdom->async_reset)
142
158
 		flags |= ASYNCHRONOUS_RESET;
143
159
 
144
-	ret = scmi_xfer_get_init(handle, RESET, SCMI_PROTOCOL_RESET,
145
-				 sizeof(*dom), 0, &t);
160
+	ret = ph->xops->xfer_get_init(ph, RESET, sizeof(*dom), 0, &t);
146
161
 	if (ret)
147
162
 		return ret;
148
163
 
..
..
@@ -152,34 +167,35 @@
152
167
 	dom->reset_state = cpu_to_le32(state);
153
168
 
154
169
 	if (rdom->async_reset)
155
-		ret = scmi_do_xfer_with_response(handle, t);
170
+		ret = ph->xops->do_xfer_with_response(ph, t);
156
171
 	else
157
-		ret = scmi_do_xfer(handle, t);
172
+		ret = ph->xops->do_xfer(ph, t);
158
173
 
159
-	scmi_xfer_put(handle, t);
174
+	ph->xops->xfer_put(ph, t);
160
175
 	return ret;
161
176
 }
162
177
 
163
-static int scmi_reset_domain_reset(const struct scmi_handle *handle, u32 domain)
178
+static int scmi_reset_domain_reset(const struct scmi_protocol_handle *ph,
179
+				   u32 domain)
164
180
 {
165
-	return scmi_domain_reset(handle, domain, AUTONOMOUS_RESET,
181
+	return scmi_domain_reset(ph, domain, AUTONOMOUS_RESET,
166
182
 				 ARCH_COLD_RESET);
167
183
 }
168
184
 
169
185
 static int
170
-scmi_reset_domain_assert(const struct scmi_handle *handle, u32 domain)
186
+scmi_reset_domain_assert(const struct scmi_protocol_handle *ph, u32 domain)
171
187
 {
172
-	return scmi_domain_reset(handle, domain, EXPLICIT_RESET_ASSERT,
188
+	return scmi_domain_reset(ph, domain, EXPLICIT_RESET_ASSERT,
173
189
 				 ARCH_COLD_RESET);
174
190
 }
175
191
 
176
192
 static int
177
-scmi_reset_domain_deassert(const struct scmi_handle *handle, u32 domain)
193
+scmi_reset_domain_deassert(const struct scmi_protocol_handle *ph, u32 domain)
178
194
 {
179
-	return scmi_domain_reset(handle, domain, 0, ARCH_COLD_RESET);
195
+	return scmi_domain_reset(ph, domain, 0, ARCH_COLD_RESET);
180
196
 }
181
197
 
182
-static struct scmi_reset_ops reset_ops = {
198
+static const struct scmi_reset_proto_ops reset_proto_ops = {
183
199
 	.num_domains_get = scmi_reset_num_domains_get,
184
200
 	.name_get = scmi_reset_name_get,
185
201
 	.latency_get = scmi_reset_latency_get,
..
..
@@ -188,24 +204,111 @@
188
204
 	.deassert = scmi_reset_domain_deassert,
189
205
 };
190
206
 
191
-static int scmi_reset_protocol_init(struct scmi_handle *handle)
207
+static int scmi_reset_notify(const struct scmi_protocol_handle *ph,
208
+			     u32 domain_id, bool enable)
209
+{
210
+	int ret;
211
+	u32 evt_cntl = enable ? RESET_TP_NOTIFY_ALL : 0;
212
+	struct scmi_xfer *t;
213
+	struct scmi_msg_reset_notify *cfg;
214
+
215
+	ret = ph->xops->xfer_get_init(ph, RESET_NOTIFY, sizeof(*cfg), 0, &t);
216
+	if (ret)
217
+		return ret;
218
+
219
+	cfg = t->tx.buf;
220
+	cfg->id = cpu_to_le32(domain_id);
221
+	cfg->event_control = cpu_to_le32(evt_cntl);
222
+
223
+	ret = ph->xops->do_xfer(ph, t);
224
+
225
+	ph->xops->xfer_put(ph, t);
226
+	return ret;
227
+}
228
+
229
+static int scmi_reset_set_notify_enabled(const struct scmi_protocol_handle *ph,
230
+					 u8 evt_id, u32 src_id, bool enable)
231
+{
232
+	int ret;
233
+
234
+	ret = scmi_reset_notify(ph, src_id, enable);
235
+	if (ret)
236
+		pr_debug("FAIL_ENABLED - evt[%X] dom[%d] - ret:%d\n",
237
+			 evt_id, src_id, ret);
238
+
239
+	return ret;
240
+}
241
+
242
+static void *
243
+scmi_reset_fill_custom_report(const struct scmi_protocol_handle *ph,
244
+			      u8 evt_id, ktime_t timestamp,
245
+			      const void *payld, size_t payld_sz,
246
+			      void *report, u32 *src_id)
247
+{
248
+	const struct scmi_reset_issued_notify_payld *p = payld;
249
+	struct scmi_reset_issued_report *r = report;
250
+
251
+	if (evt_id != SCMI_EVENT_RESET_ISSUED || sizeof(*p) != payld_sz)
252
+		return NULL;
253
+
254
+	r->timestamp = timestamp;
255
+	r->agent_id = le32_to_cpu(p->agent_id);
256
+	r->domain_id = le32_to_cpu(p->domain_id);
257
+	r->reset_state = le32_to_cpu(p->reset_state);
258
+	*src_id = r->domain_id;
259
+
260
+	return r;
261
+}
262
+
263
+static int scmi_reset_get_num_sources(const struct scmi_protocol_handle *ph)
264
+{
265
+	struct scmi_reset_info *pinfo = ph->get_priv(ph);
266
+
267
+	if (!pinfo)
268
+		return -EINVAL;
269
+
270
+	return pinfo->num_domains;
271
+}
272
+
273
+static const struct scmi_event reset_events[] = {
274
+	{
275
+		.id = SCMI_EVENT_RESET_ISSUED,
276
+		.max_payld_sz = sizeof(struct scmi_reset_issued_notify_payld),
277
+		.max_report_sz = sizeof(struct scmi_reset_issued_report),
278
+	},
279
+};
280
+
281
+static const struct scmi_event_ops reset_event_ops = {
282
+	.get_num_sources = scmi_reset_get_num_sources,
283
+	.set_notify_enabled = scmi_reset_set_notify_enabled,
284
+	.fill_custom_report = scmi_reset_fill_custom_report,
285
+};
286
+
287
+static const struct scmi_protocol_events reset_protocol_events = {
288
+	.queue_sz = SCMI_PROTO_QUEUE_SZ,
289
+	.ops = &reset_event_ops,
290
+	.evts = reset_events,
291
+	.num_events = ARRAY_SIZE(reset_events),
292
+};
293
+
294
+static int scmi_reset_protocol_init(const struct scmi_protocol_handle *ph)
192
295
 {
193
296
 	int domain;
194
297
 	u32 version;
195
298
 	struct scmi_reset_info *pinfo;
196
299
 
197
-	scmi_version_get(handle, SCMI_PROTOCOL_RESET, &version);
300
+	ph->xops->version_get(ph, &version);
198
301
 
199
-	dev_dbg(handle->dev, "Reset Version %d.%d\n",
302
+	dev_dbg(ph->dev, "Reset Version %d.%d\n",
200
303
 		PROTOCOL_REV_MAJOR(version), PROTOCOL_REV_MINOR(version));
201
304
 
202
-	pinfo = devm_kzalloc(handle->dev, sizeof(*pinfo), GFP_KERNEL);
305
+	pinfo = devm_kzalloc(ph->dev, sizeof(*pinfo), GFP_KERNEL);
203
306
 	if (!pinfo)
204
307
 		return -ENOMEM;
205
308
 
206
-	scmi_reset_attributes_get(handle, pinfo);
309
+	scmi_reset_attributes_get(ph, pinfo);
207
310
 
208
-	pinfo->dom_info = devm_kcalloc(handle->dev, pinfo->num_domains,
311
+	pinfo->dom_info = devm_kcalloc(ph->dev, pinfo->num_domains,
209
312
 				       sizeof(*pinfo->dom_info), GFP_KERNEL);
210
313
 	if (!pinfo->dom_info)
211
314
 		return -ENOMEM;
..
..
@@ -213,14 +316,19 @@
213
316
 	for (domain = 0; domain < pinfo->num_domains; domain++) {
214
317
 		struct reset_dom_info *dom = pinfo->dom_info + domain;
215
318
 
216
-		scmi_reset_domain_attributes_get(handle, domain, dom);
319
+		scmi_reset_domain_attributes_get(ph, domain, dom);
217
320
 	}
218
321
 
219
322
 	pinfo->version = version;
220
-	handle->reset_ops = &reset_ops;
221
-	handle->reset_priv = pinfo;
222
-
223
-	return 0;
323
+	return ph->set_priv(ph, pinfo);
224
324
 }
225
325
 
226
-DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(SCMI_PROTOCOL_RESET, reset)
326
+static const struct scmi_protocol scmi_reset = {
327
+	.id = SCMI_PROTOCOL_RESET,
328
+	.owner = THIS_MODULE,
329
+	.init_instance = &scmi_reset_protocol_init,
330
+	.ops = &reset_proto_ops,
331
+	.events = &reset_protocol_events,
332
+};
333
+
334
+DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(reset, scmi_reset)