1 /* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
2 *
3 * Copyright 2013-2016 Freescale Semiconductor Inc.
4 * Copyright 2016-2017 NXP
5 *
6 */
7 #include <fsl_mc_sys.h>
8 #include <fsl_mc_cmd.h>
9 #include <fsl_dpbp.h>
10 #include <fsl_dpbp_cmd.h>
11
12 /**
13 * dpbp_open() - Open a control session for the specified object.
14 * @mc_io: Pointer to MC portal's I/O object
15 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
16 * @dpbp_id: DPBP unique ID
17 * @token: Returned token; use in subsequent API calls
18 *
19 * This function can be used to open a control session for an
20 * already created object; an object may have been declared in
21 * the DPL or by calling the dpbp_create function.
22 * This function returns a unique authentication token,
23 * associated with the specific object ID and the specific MC
24 * portal; this token must be used in all subsequent commands for
25 * this specific object
26 *
27 * Return: '0' on Success; Error code otherwise.
28 */
dpbp_open(struct fsl_mc_io * mc_io,uint32_t cmd_flags,int dpbp_id,uint16_t * token)29 int dpbp_open(struct fsl_mc_io *mc_io,
30 uint32_t cmd_flags,
31 int dpbp_id,
32 uint16_t *token)
33 {
34 struct dpbp_cmd_open *cmd_params;
35 struct mc_command cmd = { 0 };
36 int err;
37
38 /* prepare command */
39 cmd.header = mc_encode_cmd_header(DPBP_CMDID_OPEN,
40 cmd_flags, 0);
41 cmd_params = (struct dpbp_cmd_open *)cmd.params;
42 cmd_params->dpbp_id = cpu_to_le32(dpbp_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);
51
52 return err;
53 }
54
55 /**
56 * dpbp_close() - Close the control session of the object
57 * @mc_io: Pointer to MC portal's I/O object
58 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
59 * @token: Token of DPBP object
60 *
61 * After this function is called, no further operations are
62 * allowed on the object without opening a new control session.
63 *
64 * Return: '0' on Success; Error code otherwise.
65 */
dpbp_close(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token)66 int dpbp_close(struct fsl_mc_io *mc_io,
67 uint32_t cmd_flags,
68 uint16_t token)
69 {
70 struct mc_command cmd = { 0 };
71
72 /* prepare command */
73 cmd.header = mc_encode_cmd_header(DPBP_CMDID_CLOSE, cmd_flags,
74 token);
75
76 /* send command to mc*/
77 return mc_send_command(mc_io, &cmd);
78 }
79
80 /**
81 * dpbp_create() - Create the DPBP object.
82 * @mc_io: Pointer to MC portal's I/O object
83 * @dprc_token: Parent container token; '0' for default container
84 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
85 * @cfg: Configuration structure
86 * @obj_id: Returned object id; use in subsequent API calls
87 *
88 * Create the DPBP object, allocate required resources and
89 * perform required initialization.
90 *
91 * This function accepts an authentication token of a parent
92 * container that this object should be assigned to and returns
93 * an object id. This object_id will be used in all subsequent calls to
94 * this specific object.
95 *
96 * Return: '0' on Success; Error code otherwise.
97 */
dpbp_create(struct fsl_mc_io * mc_io,uint16_t dprc_token,uint32_t cmd_flags,const struct dpbp_cfg * cfg,uint32_t * obj_id)98 int dpbp_create(struct fsl_mc_io *mc_io,
99 uint16_t dprc_token,
100 uint32_t cmd_flags,
101 const struct dpbp_cfg *cfg,
102 uint32_t *obj_id)
103 {
104 struct mc_command cmd = { 0 };
105 int err;
106
107 (void)(cfg); /* unused */
108
109 /* prepare command */
110 cmd.header = mc_encode_cmd_header(DPBP_CMDID_CREATE,
111 cmd_flags, dprc_token);
112
113 /* send command to mc*/
114 err = mc_send_command(mc_io, &cmd);
115 if (err)
116 return err;
117
118 /* retrieve response parameters */
119 *obj_id = mc_cmd_read_object_id(&cmd);
120
121 return 0;
122 }
123
124 /**
125 * dpbp_destroy() - Destroy the DPBP object and release all its resources.
126 * @mc_io: Pointer to MC portal's I/O object
127 * @dprc_token: Parent container token; '0' for default container
128 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
129 * @obj_id: ID of DPBP object
130 *
131 * Return: '0' on Success; error code otherwise.
132 */
dpbp_destroy(struct fsl_mc_io * mc_io,uint16_t dprc_token,uint32_t cmd_flags,uint32_t obj_id)133 int dpbp_destroy(struct fsl_mc_io *mc_io,
134 uint16_t dprc_token,
135 uint32_t cmd_flags,
136 uint32_t obj_id)
137 {
138 struct dpbp_cmd_destroy *cmd_params;
139 struct mc_command cmd = { 0 };
140
141 /* prepare command */
142 cmd.header = mc_encode_cmd_header(DPBP_CMDID_DESTROY,
143 cmd_flags, dprc_token);
144
145 cmd_params = (struct dpbp_cmd_destroy *)cmd.params;
146 cmd_params->object_id = cpu_to_le32(obj_id);
147
148 /* send command to mc*/
149 return mc_send_command(mc_io, &cmd);
150 }
151
152 /**
153 * dpbp_enable() - Enable the DPBP.
154 * @mc_io: Pointer to MC portal's I/O object
155 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
156 * @token: Token of DPBP object
157 *
158 * Return: '0' on Success; Error code otherwise.
159 */
dpbp_enable(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token)160 int dpbp_enable(struct fsl_mc_io *mc_io,
161 uint32_t cmd_flags,
162 uint16_t token)
163 {
164 struct mc_command cmd = { 0 };
165
166 /* prepare command */
167 cmd.header = mc_encode_cmd_header(DPBP_CMDID_ENABLE, cmd_flags,
168 token);
169
170 /* send command to mc*/
171 return mc_send_command(mc_io, &cmd);
172 }
173
174 /**
175 * dpbp_disable() - Disable the DPBP.
176 * @mc_io: Pointer to MC portal's I/O object
177 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
178 * @token: Token of DPBP object
179 *
180 * Return: '0' on Success; Error code otherwise.
181 */
dpbp_disable(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token)182 int dpbp_disable(struct fsl_mc_io *mc_io,
183 uint32_t cmd_flags,
184 uint16_t token)
185 {
186 struct mc_command cmd = { 0 };
187
188 /* prepare command */
189 cmd.header = mc_encode_cmd_header(DPBP_CMDID_DISABLE,
190 cmd_flags, token);
191
192 /* send command to mc*/
193 return mc_send_command(mc_io, &cmd);
194 }
195
196 /**
197 * dpbp_is_enabled() - Check if the DPBP is enabled.
198 * @mc_io: Pointer to MC portal's I/O object
199 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
200 * @token: Token of DPBP object
201 * @en: Returns '1' if object is enabled; '0' otherwise
202 *
203 * Return: '0' on Success; Error code otherwise.
204 */
dpbp_is_enabled(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,int * en)205 int dpbp_is_enabled(struct fsl_mc_io *mc_io,
206 uint32_t cmd_flags,
207 uint16_t token,
208 int *en)
209 {
210 struct dpbp_rsp_is_enabled *rsp_params;
211 struct mc_command cmd = { 0 };
212 int err;
213
214 /* prepare command */
215 cmd.header = mc_encode_cmd_header(DPBP_CMDID_IS_ENABLED, cmd_flags,
216 token);
217
218 /* send command to mc*/
219 err = mc_send_command(mc_io, &cmd);
220 if (err)
221 return err;
222
223 /* retrieve response parameters */
224 rsp_params = (struct dpbp_rsp_is_enabled *)cmd.params;
225 *en = rsp_params->enabled & DPBP_ENABLE;
226
227 return 0;
228 }
229
230 /**
231 * dpbp_reset() - Reset the DPBP, returns the object to initial state.
232 * @mc_io: Pointer to MC portal's I/O object
233 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
234 * @token: Token of DPBP object
235 *
236 * Return: '0' on Success; Error code otherwise.
237 */
dpbp_reset(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token)238 int dpbp_reset(struct fsl_mc_io *mc_io,
239 uint32_t cmd_flags,
240 uint16_t token)
241 {
242 struct mc_command cmd = { 0 };
243
244 /* prepare command */
245 cmd.header = mc_encode_cmd_header(DPBP_CMDID_RESET,
246 cmd_flags, token);
247
248 /* send command to mc*/
249 return mc_send_command(mc_io, &cmd);
250 }
251 /**
252 * dpbp_get_attributes - Retrieve DPBP attributes.
253 *
254 * @mc_io: Pointer to MC portal's I/O object
255 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
256 * @token: Token of DPBP object
257 * @attr: Returned object's attributes
258 *
259 * Return: '0' on Success; Error code otherwise.
260 */
dpbp_get_attributes(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,struct dpbp_attr * attr)261 int dpbp_get_attributes(struct fsl_mc_io *mc_io,
262 uint32_t cmd_flags,
263 uint16_t token,
264 struct dpbp_attr *attr)
265 {
266 struct dpbp_rsp_get_attributes *rsp_params;
267 struct mc_command cmd = { 0 };
268 int err;
269
270 /* prepare command */
271 cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_ATTR,
272 cmd_flags, token);
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 rsp_params = (struct dpbp_rsp_get_attributes *)cmd.params;
281 attr->bpid = le16_to_cpu(rsp_params->bpid);
282 attr->id = le32_to_cpu(rsp_params->id);
283
284 return 0;
285 }
286
287 /**
288 * dpbp_get_api_version - Get Data Path Buffer Pool API version
289 * @mc_io: Pointer to Mc portal's I/O object
290 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
291 * @major_ver: Major version of Buffer Pool API
292 * @minor_ver: Minor version of Buffer Pool API
293 *
294 * Return: '0' on Success; Error code otherwise.
295 */
dpbp_get_api_version(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t * major_ver,uint16_t * minor_ver)296 int dpbp_get_api_version(struct fsl_mc_io *mc_io,
297 uint32_t cmd_flags,
298 uint16_t *major_ver,
299 uint16_t *minor_ver)
300 {
301 struct dpbp_rsp_get_api_version *rsp_params;
302 struct mc_command cmd = { 0 };
303 int err;
304
305 /* prepare command */
306 cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_API_VERSION,
307 cmd_flags, 0);
308
309 /* send command to mc */
310 err = mc_send_command(mc_io, &cmd);
311 if (err)
312 return err;
313
314 /* retrieve response parameters */
315 rsp_params = (struct dpbp_rsp_get_api_version *)cmd.params;
316 *major_ver = le16_to_cpu(rsp_params->major);
317 *minor_ver = le16_to_cpu(rsp_params->minor);
318
319 return 0;
320 }
321
322 /**
323 * dpbp_get_num_free_bufs() - Get number of free buffers in the buffer pool
324 * @mc_io: Pointer to MC portal's I/O object
325 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
326 * @token: Token of DPBP object
327 * @num_free_bufs: Number of free buffers
328 *
329 * Return: '0' on Success; Error code otherwise.
330 */
331
dpbp_get_num_free_bufs(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,uint32_t * num_free_bufs)332 int dpbp_get_num_free_bufs(struct fsl_mc_io *mc_io,
333 uint32_t cmd_flags,
334 uint16_t token,
335 uint32_t *num_free_bufs)
336 {
337 struct dpbp_rsp_get_num_free_bufs *rsp_params;
338 struct mc_command cmd = { 0 };
339 int err;
340
341 /* prepare command */
342 cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_FREE_BUFFERS_NUM,
343 cmd_flags,
344 token);
345
346 /* send command to mc*/
347 err = mc_send_command(mc_io, &cmd);
348 if (err)
349 return err;
350
351 /* retrieve response parameters */
352 rsp_params = (struct dpbp_rsp_get_num_free_bufs *)cmd.params;
353 *num_free_bufs = le32_to_cpu(rsp_params->num_free_bufs);
354
355 return 0;
356 }
357