This source file includes following definitions.
- scmi_reset_attributes_get
- scmi_reset_domain_attributes_get
- scmi_reset_num_domains_get
- scmi_reset_name_get
- scmi_reset_latency_get
- scmi_domain_reset
- scmi_reset_domain_reset
- scmi_reset_domain_assert
- scmi_reset_domain_deassert
- scmi_reset_protocol_init
- scmi_reset_init
1
2
3
4
5
6
7
8 #include "common.h"
9
10 enum scmi_reset_protocol_cmd {
11 RESET_DOMAIN_ATTRIBUTES = 0x3,
12 RESET = 0x4,
13 RESET_NOTIFY = 0x5,
14 };
15
16 enum scmi_reset_protocol_notify {
17 RESET_ISSUED = 0x0,
18 };
19
20 #define NUM_RESET_DOMAIN_MASK 0xffff
21 #define RESET_NOTIFY_ENABLE BIT(0)
22
23 struct scmi_msg_resp_reset_domain_attributes {
24 __le32 attributes;
25 #define SUPPORTS_ASYNC_RESET(x) ((x) & BIT(31))
26 #define SUPPORTS_NOTIFY_RESET(x) ((x) & BIT(30))
27 __le32 latency;
28 u8 name[SCMI_MAX_STR_SIZE];
29 };
30
31 struct scmi_msg_reset_domain_reset {
32 __le32 domain_id;
33 __le32 flags;
34 #define AUTONOMOUS_RESET BIT(0)
35 #define EXPLICIT_RESET_ASSERT BIT(1)
36 #define ASYNCHRONOUS_RESET BIT(2)
37 __le32 reset_state;
38 #define ARCH_RESET_TYPE BIT(31)
39 #define COLD_RESET_STATE BIT(0)
40 #define ARCH_COLD_RESET (ARCH_RESET_TYPE | COLD_RESET_STATE)
41 };
42
43 struct reset_dom_info {
44 bool async_reset;
45 bool reset_notify;
46 u32 latency_us;
47 char name[SCMI_MAX_STR_SIZE];
48 };
49
50 struct scmi_reset_info {
51 int num_domains;
52 struct reset_dom_info *dom_info;
53 };
54
55 static int scmi_reset_attributes_get(const struct scmi_handle *handle,
56 struct scmi_reset_info *pi)
57 {
58 int ret;
59 struct scmi_xfer *t;
60 u32 attr;
61
62 ret = scmi_xfer_get_init(handle, PROTOCOL_ATTRIBUTES,
63 SCMI_PROTOCOL_RESET, 0, sizeof(attr), &t);
64 if (ret)
65 return ret;
66
67 ret = scmi_do_xfer(handle, t);
68 if (!ret) {
69 attr = get_unaligned_le32(t->rx.buf);
70 pi->num_domains = attr & NUM_RESET_DOMAIN_MASK;
71 }
72
73 scmi_xfer_put(handle, t);
74 return ret;
75 }
76
77 static int
78 scmi_reset_domain_attributes_get(const struct scmi_handle *handle, u32 domain,
79 struct reset_dom_info *dom_info)
80 {
81 int ret;
82 struct scmi_xfer *t;
83 struct scmi_msg_resp_reset_domain_attributes *attr;
84
85 ret = scmi_xfer_get_init(handle, RESET_DOMAIN_ATTRIBUTES,
86 SCMI_PROTOCOL_RESET, sizeof(domain),
87 sizeof(*attr), &t);
88 if (ret)
89 return ret;
90
91 put_unaligned_le32(domain, t->tx.buf);
92 attr = t->rx.buf;
93
94 ret = scmi_do_xfer(handle, t);
95 if (!ret) {
96 u32 attributes = le32_to_cpu(attr->attributes);
97
98 dom_info->async_reset = SUPPORTS_ASYNC_RESET(attributes);
99 dom_info->reset_notify = SUPPORTS_NOTIFY_RESET(attributes);
100 dom_info->latency_us = le32_to_cpu(attr->latency);
101 if (dom_info->latency_us == U32_MAX)
102 dom_info->latency_us = 0;
103 strlcpy(dom_info->name, attr->name, SCMI_MAX_STR_SIZE);
104 }
105
106 scmi_xfer_put(handle, t);
107 return ret;
108 }
109
110 static int scmi_reset_num_domains_get(const struct scmi_handle *handle)
111 {
112 struct scmi_reset_info *pi = handle->reset_priv;
113
114 return pi->num_domains;
115 }
116
117 static char *scmi_reset_name_get(const struct scmi_handle *handle, u32 domain)
118 {
119 struct scmi_reset_info *pi = handle->reset_priv;
120 struct reset_dom_info *dom = pi->dom_info + domain;
121
122 return dom->name;
123 }
124
125 static int scmi_reset_latency_get(const struct scmi_handle *handle, u32 domain)
126 {
127 struct scmi_reset_info *pi = handle->reset_priv;
128 struct reset_dom_info *dom = pi->dom_info + domain;
129
130 return dom->latency_us;
131 }
132
133 static int scmi_domain_reset(const struct scmi_handle *handle, u32 domain,
134 u32 flags, u32 state)
135 {
136 int ret;
137 struct scmi_xfer *t;
138 struct scmi_msg_reset_domain_reset *dom;
139 struct scmi_reset_info *pi = handle->reset_priv;
140 struct reset_dom_info *rdom = pi->dom_info + domain;
141
142 if (rdom->async_reset)
143 flags |= ASYNCHRONOUS_RESET;
144
145 ret = scmi_xfer_get_init(handle, RESET, SCMI_PROTOCOL_RESET,
146 sizeof(*dom), 0, &t);
147 if (ret)
148 return ret;
149
150 dom = t->tx.buf;
151 dom->domain_id = cpu_to_le32(domain);
152 dom->flags = cpu_to_le32(flags);
153 dom->reset_state = cpu_to_le32(state);
154
155 if (rdom->async_reset)
156 ret = scmi_do_xfer_with_response(handle, t);
157 else
158 ret = scmi_do_xfer(handle, t);
159
160 scmi_xfer_put(handle, t);
161 return ret;
162 }
163
164 static int scmi_reset_domain_reset(const struct scmi_handle *handle, u32 domain)
165 {
166 return scmi_domain_reset(handle, domain, AUTONOMOUS_RESET,
167 ARCH_COLD_RESET);
168 }
169
170 static int
171 scmi_reset_domain_assert(const struct scmi_handle *handle, u32 domain)
172 {
173 return scmi_domain_reset(handle, domain, EXPLICIT_RESET_ASSERT,
174 ARCH_COLD_RESET);
175 }
176
177 static int
178 scmi_reset_domain_deassert(const struct scmi_handle *handle, u32 domain)
179 {
180 return scmi_domain_reset(handle, domain, 0, ARCH_COLD_RESET);
181 }
182
183 static struct scmi_reset_ops reset_ops = {
184 .num_domains_get = scmi_reset_num_domains_get,
185 .name_get = scmi_reset_name_get,
186 .latency_get = scmi_reset_latency_get,
187 .reset = scmi_reset_domain_reset,
188 .assert = scmi_reset_domain_assert,
189 .deassert = scmi_reset_domain_deassert,
190 };
191
192 static int scmi_reset_protocol_init(struct scmi_handle *handle)
193 {
194 int domain;
195 u32 version;
196 struct scmi_reset_info *pinfo;
197
198 scmi_version_get(handle, SCMI_PROTOCOL_RESET, &version);
199
200 dev_dbg(handle->dev, "Reset Version %d.%d\n",
201 PROTOCOL_REV_MAJOR(version), PROTOCOL_REV_MINOR(version));
202
203 pinfo = devm_kzalloc(handle->dev, sizeof(*pinfo), GFP_KERNEL);
204 if (!pinfo)
205 return -ENOMEM;
206
207 scmi_reset_attributes_get(handle, pinfo);
208
209 pinfo->dom_info = devm_kcalloc(handle->dev, pinfo->num_domains,
210 sizeof(*pinfo->dom_info), GFP_KERNEL);
211 if (!pinfo->dom_info)
212 return -ENOMEM;
213
214 for (domain = 0; domain < pinfo->num_domains; domain++) {
215 struct reset_dom_info *dom = pinfo->dom_info + domain;
216
217 scmi_reset_domain_attributes_get(handle, domain, dom);
218 }
219
220 handle->reset_ops = &reset_ops;
221 handle->reset_priv = pinfo;
222
223 return 0;
224 }
225
226 static int __init scmi_reset_init(void)
227 {
228 return scmi_protocol_register(SCMI_PROTOCOL_RESET,
229 &scmi_reset_protocol_init);
230 }
231 subsys_initcall(scmi_reset_init);