1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Freescale Layerscape MC I/O wrapper
4 *
5 * Copyright 2013-2016 Freescale Semiconductor, Inc.
6 * Copyright 2017 NXP
7 */
8
9 #include <fsl-mc/fsl_mc_sys.h>
10 #include <fsl-mc/fsl_mc_cmd.h>
11 #include <fsl-mc/fsl_dprc.h>
12
dprc_get_container_id(struct fsl_mc_io * mc_io,uint32_t cmd_flags,int * container_id)13 int dprc_get_container_id(struct fsl_mc_io *mc_io,
14 uint32_t cmd_flags,
15 int *container_id)
16 {
17 struct mc_command cmd = { 0 };
18 int err;
19
20 /* prepare command */
21 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONT_ID,
22 cmd_flags,
23 0);
24
25 /* send command to mc*/
26 err = mc_send_command(mc_io, &cmd);
27 if (err)
28 return err;
29
30 /* retrieve response parameters */
31 DPRC_RSP_GET_CONTAINER_ID(cmd, *container_id);
32
33 return 0;
34 }
35
dprc_open(struct fsl_mc_io * mc_io,uint32_t cmd_flags,int container_id,uint16_t * token)36 int dprc_open(struct fsl_mc_io *mc_io,
37 uint32_t cmd_flags,
38 int container_id,
39 uint16_t *token)
40 {
41 struct mc_command cmd = { 0 };
42 int err;
43
44 /* prepare command */
45 cmd.header = mc_encode_cmd_header(DPRC_CMDID_OPEN, cmd_flags,
46 0);
47 DPRC_CMD_OPEN(cmd, container_id);
48
49 /* send command to mc*/
50 err = mc_send_command(mc_io, &cmd);
51 if (err)
52 return err;
53
54 /* retrieve response parameters */
55 *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
56
57 return 0;
58 }
59
dprc_close(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token)60 int dprc_close(struct fsl_mc_io *mc_io,
61 uint32_t cmd_flags,
62 uint16_t token)
63 {
64 struct mc_command cmd = { 0 };
65
66 /* prepare command */
67 cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLOSE, cmd_flags,
68 token);
69
70 /* send command to mc*/
71 return mc_send_command(mc_io, &cmd);
72 }
73
dprc_create_container(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,struct dprc_cfg * cfg,int * child_container_id,uint64_t * child_portal_paddr)74 int dprc_create_container(struct fsl_mc_io *mc_io,
75 uint32_t cmd_flags,
76 uint16_t token,
77 struct dprc_cfg *cfg,
78 int *child_container_id,
79 uint64_t *child_portal_paddr)
80 {
81 struct mc_command cmd = { 0 };
82 int err;
83
84 /* prepare command */
85 DPRC_CMD_CREATE_CONTAINER(cmd, cfg);
86
87 cmd.header = mc_encode_cmd_header(DPRC_CMDID_CREATE_CONT,
88 cmd_flags,
89 token);
90
91 /* send command to mc*/
92 err = mc_send_command(mc_io, &cmd);
93 if (err)
94 return err;
95
96 /* retrieve response parameters */
97 DPRC_RSP_CREATE_CONTAINER(cmd, *child_container_id,
98 *child_portal_paddr);
99
100 return 0;
101 }
102
dprc_destroy_container(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,int child_container_id)103 int dprc_destroy_container(struct fsl_mc_io *mc_io,
104 uint32_t cmd_flags,
105 uint16_t token,
106 int child_container_id)
107 {
108 struct mc_command cmd = { 0 };
109
110 /* prepare command */
111 cmd.header = mc_encode_cmd_header(DPRC_CMDID_DESTROY_CONT,
112 cmd_flags,
113 token);
114 DPRC_CMD_DESTROY_CONTAINER(cmd, child_container_id);
115
116 /* send command to mc*/
117 return mc_send_command(mc_io, &cmd);
118 }
119
dprc_reset_container(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,int child_container_id)120 int dprc_reset_container(struct fsl_mc_io *mc_io,
121 uint32_t cmd_flags,
122 uint16_t token,
123 int child_container_id)
124 {
125 struct mc_command cmd = { 0 };
126
127 /* prepare command */
128 cmd.header = mc_encode_cmd_header(DPRC_CMDID_RESET_CONT,
129 cmd_flags,
130 token);
131 DPRC_CMD_RESET_CONTAINER(cmd, child_container_id);
132
133 /* send command to mc*/
134 return mc_send_command(mc_io, &cmd);
135 }
136
dprc_get_attributes(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,struct dprc_attributes * attr)137 int dprc_get_attributes(struct fsl_mc_io *mc_io,
138 uint32_t cmd_flags,
139 uint16_t token,
140 struct dprc_attributes *attr)
141 {
142 struct mc_command cmd = { 0 };
143 int err;
144
145 /* prepare command */
146 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_ATTR,
147 cmd_flags,
148 token);
149
150 /* send command to mc*/
151 err = mc_send_command(mc_io, &cmd);
152 if (err)
153 return err;
154
155 /* retrieve response parameters */
156 DPRC_RSP_GET_ATTRIBUTES(cmd, attr);
157
158 return 0;
159 }
160
dprc_get_obj_count(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,int * obj_count)161 int dprc_get_obj_count(struct fsl_mc_io *mc_io,
162 uint32_t cmd_flags,
163 uint16_t token,
164 int *obj_count)
165 {
166 struct mc_command cmd = { 0 };
167 int err;
168
169 /* prepare command */
170 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_COUNT,
171 cmd_flags,
172 token);
173
174 /* send command to mc*/
175 err = mc_send_command(mc_io, &cmd);
176 if (err)
177 return err;
178
179 /* retrieve response parameters */
180 DPRC_RSP_GET_OBJ_COUNT(cmd, *obj_count);
181
182 return 0;
183 }
184
dprc_get_obj(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,int obj_index,struct dprc_obj_desc * obj_desc)185 int dprc_get_obj(struct fsl_mc_io *mc_io,
186 uint32_t cmd_flags,
187 uint16_t token,
188 int obj_index,
189 struct dprc_obj_desc *obj_desc)
190 {
191 struct mc_command cmd = { 0 };
192 int err;
193
194 /* prepare command */
195 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ,
196 cmd_flags,
197 token);
198 DPRC_CMD_GET_OBJ(cmd, obj_index);
199
200 /* send command to mc*/
201 err = mc_send_command(mc_io, &cmd);
202 if (err)
203 return err;
204
205 /* retrieve response parameters */
206 DPRC_RSP_GET_OBJ(cmd, obj_desc);
207
208 return 0;
209 }
210
dprc_get_res_count(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,char * type,int * res_count)211 int dprc_get_res_count(struct fsl_mc_io *mc_io,
212 uint32_t cmd_flags,
213 uint16_t token,
214 char *type,
215 int *res_count)
216 {
217 struct mc_command cmd = { 0 };
218 int err;
219
220 *res_count = 0;
221
222 /* prepare command */
223 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_COUNT,
224 cmd_flags,
225 token);
226 DPRC_CMD_GET_RES_COUNT(cmd, type);
227
228 /* send command to mc*/
229 err = mc_send_command(mc_io, &cmd);
230 if (err)
231 return err;
232
233 /* retrieve response parameters */
234 DPRC_RSP_GET_RES_COUNT(cmd, *res_count);
235
236 return 0;
237 }
238
dprc_get_res_ids(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,char * type,struct dprc_res_ids_range_desc * range_desc)239 int dprc_get_res_ids(struct fsl_mc_io *mc_io,
240 uint32_t cmd_flags,
241 uint16_t token,
242 char *type,
243 struct dprc_res_ids_range_desc *range_desc)
244 {
245 struct mc_command cmd = { 0 };
246 int err;
247
248 /* prepare command */
249 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_IDS,
250 cmd_flags,
251 token);
252 DPRC_CMD_GET_RES_IDS(cmd, range_desc, type);
253
254 /* send command to mc*/
255 err = mc_send_command(mc_io, &cmd);
256 if (err)
257 return err;
258
259 /* retrieve response parameters */
260 DPRC_RSP_GET_RES_IDS(cmd, range_desc);
261
262 return 0;
263 }
264
dprc_get_obj_region(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,char * obj_type,int obj_id,uint8_t region_index,struct dprc_region_desc * region_desc)265 int dprc_get_obj_region(struct fsl_mc_io *mc_io,
266 uint32_t cmd_flags,
267 uint16_t token,
268 char *obj_type,
269 int obj_id,
270 uint8_t region_index,
271 struct dprc_region_desc *region_desc)
272 {
273 struct mc_command cmd = { 0 };
274 int err;
275
276 /* prepare command */
277 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG,
278 cmd_flags,
279 token);
280 DPRC_CMD_GET_OBJ_REGION(cmd, obj_type, obj_id, region_index);
281
282 /* send command to mc*/
283 err = mc_send_command(mc_io, &cmd);
284 if (err)
285 return err;
286
287 /* retrieve response parameters */
288 DPRC_RSP_GET_OBJ_REGION(cmd, region_desc);
289
290 return 0;
291 }
292
dprc_connect(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,const struct dprc_endpoint * endpoint1,const struct dprc_endpoint * endpoint2,const struct dprc_connection_cfg * cfg)293 int dprc_connect(struct fsl_mc_io *mc_io,
294 uint32_t cmd_flags,
295 uint16_t token,
296 const struct dprc_endpoint *endpoint1,
297 const struct dprc_endpoint *endpoint2,
298 const struct dprc_connection_cfg *cfg)
299 {
300 struct mc_command cmd = { 0 };
301
302 /* prepare command */
303 cmd.header = mc_encode_cmd_header(DPRC_CMDID_CONNECT,
304 cmd_flags,
305 token);
306 DPRC_CMD_CONNECT(cmd, endpoint1, endpoint2, cfg);
307
308 /* send command to mc*/
309 return mc_send_command(mc_io, &cmd);
310 }
311
dprc_disconnect(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,const struct dprc_endpoint * endpoint)312 int dprc_disconnect(struct fsl_mc_io *mc_io,
313 uint32_t cmd_flags,
314 uint16_t token,
315 const struct dprc_endpoint *endpoint)
316 {
317 struct mc_command cmd = { 0 };
318
319 /* prepare command */
320 cmd.header = mc_encode_cmd_header(DPRC_CMDID_DISCONNECT,
321 cmd_flags,
322 token);
323 DPRC_CMD_DISCONNECT(cmd, endpoint);
324
325 /* send command to mc*/
326 return mc_send_command(mc_io, &cmd);
327 }
328
dprc_get_connection(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,const struct dprc_endpoint * endpoint1,struct dprc_endpoint * endpoint2,int * state)329 int dprc_get_connection(struct fsl_mc_io *mc_io,
330 uint32_t cmd_flags,
331 uint16_t token,
332 const struct dprc_endpoint *endpoint1,
333 struct dprc_endpoint *endpoint2,
334 int *state)
335 {
336 struct mc_command cmd = { 0 };
337 int err;
338
339 /* prepare command */
340 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONNECTION,
341 cmd_flags,
342 token);
343 DPRC_CMD_GET_CONNECTION(cmd, endpoint1);
344
345 /* send command to mc*/
346 err = mc_send_command(mc_io, &cmd);
347 if (err)
348 return err;
349
350 /* retrieve response parameters */
351 DPRC_RSP_GET_CONNECTION(cmd, endpoint2, *state);
352
353 return 0;
354 }
355
dprc_get_api_version(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 * major_ver,u16 * minor_ver)356 int dprc_get_api_version(struct fsl_mc_io *mc_io,
357 u32 cmd_flags,
358 u16 *major_ver,
359 u16 *minor_ver)
360 {
361 struct mc_command cmd = { 0 };
362 int err;
363
364 /* prepare command */
365 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_API_VERSION,
366 cmd_flags, 0);
367
368 /* send command to mc */
369 err = mc_send_command(mc_io, &cmd);
370 if (err)
371 return err;
372
373 /* retrieve response parameters */
374 mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
375
376 return 0;
377 }
378