1 /*
2 * Freescale Layerscape MC I/O wrapper
3 *
4 * Copyright (C) 2013-2015 Freescale Semiconductor, Inc.
5 * Author: German Rivera <German.Rivera@freescale.com>
6 *
7 * SPDX-License-Identifier: GPL-2.0+
8 */
9
10 #include <fsl-mc/fsl_mc_sys.h>
11 #include <fsl-mc/fsl_mc_cmd.h>
12 #include <fsl-mc/fsl_dprc.h>
13
dprc_get_container_id(struct fsl_mc_io * mc_io,int * container_id)14 int dprc_get_container_id(struct fsl_mc_io *mc_io, int *container_id)
15 {
16 struct mc_command cmd = { 0 };
17 int err;
18
19 /* prepare command */
20 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONT_ID,
21 MC_CMD_PRI_LOW, 0);
22
23 /* send command to mc*/
24 err = mc_send_command(mc_io, &cmd);
25 if (err)
26 return err;
27
28 /* retrieve response parameters */
29 DPRC_RSP_GET_CONTAINER_ID(cmd, *container_id);
30
31 return 0;
32 }
33
dprc_open(struct fsl_mc_io * mc_io,int container_id,uint16_t * token)34 int dprc_open(struct fsl_mc_io *mc_io, int container_id, uint16_t *token)
35 {
36 struct mc_command cmd = { 0 };
37 int err;
38
39 /* prepare command */
40 cmd.header = mc_encode_cmd_header(DPRC_CMDID_OPEN, MC_CMD_PRI_LOW,
41 0);
42 DPRC_CMD_OPEN(cmd, container_id);
43
44 /* send command to mc*/
45 err = mc_send_command(mc_io, &cmd);
46 if (err)
47 return err;
48
49 /* retrieve response parameters */
50 *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
51
52 return 0;
53 }
54
dprc_close(struct fsl_mc_io * mc_io,uint16_t token)55 int dprc_close(struct fsl_mc_io *mc_io, uint16_t token)
56 {
57 struct mc_command cmd = { 0 };
58
59 /* prepare command */
60 cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLOSE, MC_CMD_PRI_HIGH,
61 token);
62
63 /* send command to mc*/
64 return mc_send_command(mc_io, &cmd);
65 }
66
dprc_reset_container(struct fsl_mc_io * mc_io,uint16_t token,int child_container_id)67 int dprc_reset_container(struct fsl_mc_io *mc_io,
68 uint16_t token,
69 int child_container_id)
70 {
71 struct mc_command cmd = { 0 };
72
73 /* prepare command */
74 cmd.header = mc_encode_cmd_header(DPRC_CMDID_RESET_CONT,
75 MC_CMD_PRI_LOW, token);
76 DPRC_CMD_RESET_CONTAINER(cmd, child_container_id);
77
78 /* send command to mc*/
79 return mc_send_command(mc_io, &cmd);
80 }
81
dprc_get_attributes(struct fsl_mc_io * mc_io,uint16_t token,struct dprc_attributes * attr)82 int dprc_get_attributes(struct fsl_mc_io *mc_io,
83 uint16_t token,
84 struct dprc_attributes *attr)
85 {
86 struct mc_command cmd = { 0 };
87 int err;
88
89 /* prepare command */
90 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_ATTR,
91 MC_CMD_PRI_LOW,
92 token);
93
94 /* send command to mc*/
95 err = mc_send_command(mc_io, &cmd);
96 if (err)
97 return err;
98
99 /* retrieve response parameters */
100 DPRC_RSP_GET_ATTRIBUTES(cmd, attr);
101
102 return 0;
103 }
104
dprc_get_obj_count(struct fsl_mc_io * mc_io,uint16_t token,int * obj_count)105 int dprc_get_obj_count(struct fsl_mc_io *mc_io, uint16_t token, int *obj_count)
106 {
107 struct mc_command cmd = { 0 };
108 int err;
109
110 /* prepare command */
111 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_COUNT,
112 MC_CMD_PRI_LOW, token);
113
114 /* send command to mc*/
115 err = mc_send_command(mc_io, &cmd);
116 if (err)
117 return err;
118
119 /* retrieve response parameters */
120 DPRC_RSP_GET_OBJ_COUNT(cmd, *obj_count);
121
122 return 0;
123 }
124
dprc_get_obj(struct fsl_mc_io * mc_io,uint16_t token,int obj_index,struct dprc_obj_desc * obj_desc)125 int dprc_get_obj(struct fsl_mc_io *mc_io,
126 uint16_t token,
127 int obj_index,
128 struct dprc_obj_desc *obj_desc)
129 {
130 struct mc_command cmd = { 0 };
131 int err;
132
133 /* prepare command */
134 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ,
135 MC_CMD_PRI_LOW,
136 token);
137 DPRC_CMD_GET_OBJ(cmd, obj_index);
138
139 /* send command to mc*/
140 err = mc_send_command(mc_io, &cmd);
141 if (err)
142 return err;
143
144 /* retrieve response parameters */
145 DPRC_RSP_GET_OBJ(cmd, obj_desc);
146
147 return 0;
148 }
149
dprc_get_res_count(struct fsl_mc_io * mc_io,uint16_t token,char * type,int * res_count)150 int dprc_get_res_count(struct fsl_mc_io *mc_io,
151 uint16_t token,
152 char *type,
153 int *res_count)
154 {
155 struct mc_command cmd = { 0 };
156 int err;
157
158 *res_count = 0;
159
160 /* prepare command */
161 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_COUNT,
162 MC_CMD_PRI_LOW, token);
163 DPRC_CMD_GET_RES_COUNT(cmd, type);
164
165 /* send command to mc*/
166 err = mc_send_command(mc_io, &cmd);
167 if (err)
168 return err;
169
170 /* retrieve response parameters */
171 DPRC_RSP_GET_RES_COUNT(cmd, *res_count);
172
173 return 0;
174 }
175
dprc_get_res_ids(struct fsl_mc_io * mc_io,uint16_t token,char * type,struct dprc_res_ids_range_desc * range_desc)176 int dprc_get_res_ids(struct fsl_mc_io *mc_io,
177 uint16_t token,
178 char *type,
179 struct dprc_res_ids_range_desc *range_desc)
180 {
181 struct mc_command cmd = { 0 };
182 int err;
183
184 /* prepare command */
185 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_IDS,
186 MC_CMD_PRI_LOW, token);
187 DPRC_CMD_GET_RES_IDS(cmd, range_desc, type);
188
189 /* send command to mc*/
190 err = mc_send_command(mc_io, &cmd);
191 if (err)
192 return err;
193
194 /* retrieve response parameters */
195 DPRC_RSP_GET_RES_IDS(cmd, range_desc);
196
197 return 0;
198 }
199
dprc_get_obj_region(struct fsl_mc_io * mc_io,uint16_t token,char * obj_type,int obj_id,uint8_t region_index,struct dprc_region_desc * region_desc)200 int dprc_get_obj_region(struct fsl_mc_io *mc_io,
201 uint16_t token,
202 char *obj_type,
203 int obj_id,
204 uint8_t region_index,
205 struct dprc_region_desc *region_desc)
206 {
207 struct mc_command cmd = { 0 };
208 int err;
209
210 /* prepare command */
211 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG,
212 MC_CMD_PRI_LOW, token);
213 DPRC_CMD_GET_OBJ_REGION(cmd, obj_type, obj_id, region_index);
214
215 /* send command to mc*/
216 err = mc_send_command(mc_io, &cmd);
217 if (err)
218 return err;
219
220 /* retrieve response parameters */
221 DPRC_RSP_GET_OBJ_REGION(cmd, region_desc);
222
223 return 0;
224 }
225
dprc_connect(struct fsl_mc_io * mc_io,uint16_t token,const struct dprc_endpoint * endpoint1,const struct dprc_endpoint * endpoint2)226 int dprc_connect(struct fsl_mc_io *mc_io,
227 uint16_t token,
228 const struct dprc_endpoint *endpoint1,
229 const struct dprc_endpoint *endpoint2)
230 {
231 struct mc_command cmd = { 0 };
232
233 /* prepare command */
234 cmd.header = mc_encode_cmd_header(DPRC_CMDID_CONNECT,
235 MC_CMD_PRI_LOW,
236 token);
237 DPRC_CMD_CONNECT(cmd, endpoint1, endpoint2);
238
239 /* send command to mc*/
240 return mc_send_command(mc_io, &cmd);
241 }
242
dprc_disconnect(struct fsl_mc_io * mc_io,uint16_t token,const struct dprc_endpoint * endpoint)243 int dprc_disconnect(struct fsl_mc_io *mc_io,
244 uint16_t token,
245 const struct dprc_endpoint *endpoint)
246 {
247 struct mc_command cmd = { 0 };
248
249 /* prepare command */
250 cmd.header = mc_encode_cmd_header(DPRC_CMDID_DISCONNECT,
251 MC_CMD_PRI_LOW,
252 token);
253 DPRC_CMD_DISCONNECT(cmd, endpoint);
254
255 /* send command to mc*/
256 return mc_send_command(mc_io, &cmd);
257 }
258
dprc_get_connection(struct fsl_mc_io * mc_io,uint16_t token,const struct dprc_endpoint * endpoint1,struct dprc_endpoint * endpoint2,int * state)259 int dprc_get_connection(struct fsl_mc_io *mc_io,
260 uint16_t token,
261 const struct dprc_endpoint *endpoint1,
262 struct dprc_endpoint *endpoint2,
263 int *state)
264 {
265 struct mc_command cmd = { 0 };
266 int err;
267
268 /* prepare command */
269 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONNECTION,
270 MC_CMD_PRI_LOW,
271 token);
272 DPRC_CMD_GET_CONNECTION(cmd, endpoint1);
273
274 /* send command to mc*/
275 err = mc_send_command(mc_io, &cmd);
276 if (err)
277 return err;
278
279 /* retrieve response parameters */
280 DPRC_RSP_GET_CONNECTION(cmd, endpoint2, *state);
281
282 return 0;
283 }
284