1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright 2013-2016 Freescale Semiconductor, Inc.
4 * Copyright 2017 NXP
5 */
6
7 #include <fsl-mc/fsl_mc_sys.h>
8 #include <fsl-mc/fsl_mc_cmd.h>
9 #include <fsl-mc/fsl_dpni.h>
10
dpni_prepare_cfg(const struct dpni_cfg * cfg,uint8_t * cfg_buf)11 int dpni_prepare_cfg(const struct dpni_cfg *cfg,
12 uint8_t *cfg_buf)
13 {
14 uint64_t *params = (uint64_t *)cfg_buf;
15
16 DPNI_PREP_CFG(params, cfg);
17
18 return 0;
19 }
20
dpni_extract_cfg(struct dpni_cfg * cfg,const uint8_t * cfg_buf)21 int dpni_extract_cfg(struct dpni_cfg *cfg,
22 const uint8_t *cfg_buf)
23 {
24 uint64_t *params = (uint64_t *)cfg_buf;
25
26 DPNI_EXT_CFG(params, cfg);
27
28 return 0;
29 }
30
dpni_open(struct fsl_mc_io * mc_io,uint32_t cmd_flags,int dpni_id,uint16_t * token)31 int dpni_open(struct fsl_mc_io *mc_io,
32 uint32_t cmd_flags,
33 int dpni_id,
34 uint16_t *token)
35 {
36 struct mc_command cmd = { 0 };
37 int err;
38
39 /* prepare command */
40 cmd.header = mc_encode_cmd_header(DPNI_CMDID_OPEN,
41 cmd_flags,
42 0);
43 DPNI_CMD_OPEN(cmd, dpni_id);
44
45 /* send command to mc*/
46 err = mc_send_command(mc_io, &cmd);
47 if (err)
48 return err;
49
50 /* retrieve response parameters */
51 *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
52
53 return 0;
54 }
55
dpni_close(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token)56 int dpni_close(struct fsl_mc_io *mc_io,
57 uint32_t cmd_flags,
58 uint16_t token)
59 {
60 struct mc_command cmd = { 0 };
61
62 /* prepare command */
63 cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLOSE,
64 cmd_flags,
65 token);
66
67 /* send command to mc*/
68 return mc_send_command(mc_io, &cmd);
69 }
70
dpni_create(struct fsl_mc_io * mc_io,uint16_t dprc_token,uint32_t cmd_flags,const struct dpni_cfg * cfg,uint32_t * obj_id)71 int dpni_create(struct fsl_mc_io *mc_io,
72 uint16_t dprc_token,
73 uint32_t cmd_flags,
74 const struct dpni_cfg *cfg,
75 uint32_t *obj_id)
76 {
77 struct mc_command cmd = { 0 };
78 int err;
79
80 /* prepare command */
81 cmd.header = mc_encode_cmd_header(DPNI_CMDID_CREATE,
82 cmd_flags,
83 dprc_token);
84 DPNI_CMD_CREATE(cmd, cfg);
85
86 /* send command to mc*/
87 err = mc_send_command(mc_io, &cmd);
88 if (err)
89 return err;
90
91 /* retrieve response parameters */
92 MC_CMD_READ_OBJ_ID(cmd, *obj_id);
93
94 return 0;
95 }
96
dpni_destroy(struct fsl_mc_io * mc_io,uint16_t dprc_token,uint32_t cmd_flags,uint32_t obj_id)97 int dpni_destroy(struct fsl_mc_io *mc_io,
98 uint16_t dprc_token,
99 uint32_t cmd_flags,
100 uint32_t obj_id)
101 {
102 struct mc_command cmd = { 0 };
103
104 /* prepare command */
105 cmd.header = mc_encode_cmd_header(DPNI_CMDID_DESTROY,
106 cmd_flags,
107 dprc_token);
108
109 /* set object id to destroy */
110 CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, obj_id);
111
112 /* send command to mc*/
113 return mc_send_command(mc_io, &cmd);
114 }
115
dpni_set_pools(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,const struct dpni_pools_cfg * cfg)116 int dpni_set_pools(struct fsl_mc_io *mc_io,
117 uint32_t cmd_flags,
118 uint16_t token,
119 const struct dpni_pools_cfg *cfg)
120 {
121 struct mc_command cmd = { 0 };
122
123 /* prepare command */
124 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_POOLS,
125 cmd_flags,
126 token);
127 DPNI_CMD_SET_POOLS(cmd, cfg);
128
129 /* send command to mc*/
130 return mc_send_command(mc_io, &cmd);
131 }
132
dpni_enable(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token)133 int dpni_enable(struct fsl_mc_io *mc_io,
134 uint32_t cmd_flags,
135 uint16_t token)
136 {
137 struct mc_command cmd = { 0 };
138
139 /* prepare command */
140 cmd.header = mc_encode_cmd_header(DPNI_CMDID_ENABLE,
141 cmd_flags,
142 token);
143
144 /* send command to mc*/
145 return mc_send_command(mc_io, &cmd);
146 }
147
dpni_disable(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token)148 int dpni_disable(struct fsl_mc_io *mc_io,
149 uint32_t cmd_flags,
150 uint16_t token)
151 {
152 struct mc_command cmd = { 0 };
153
154 /* prepare command */
155 cmd.header = mc_encode_cmd_header(DPNI_CMDID_DISABLE,
156 cmd_flags,
157 token);
158
159 /* send command to mc*/
160 return mc_send_command(mc_io, &cmd);
161 }
162
dpni_reset(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token)163 int dpni_reset(struct fsl_mc_io *mc_io,
164 uint32_t cmd_flags,
165 uint16_t token)
166 {
167 struct mc_command cmd = { 0 };
168
169 /* prepare command */
170 cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET,
171 cmd_flags,
172 token);
173
174 /* send command to mc*/
175 return mc_send_command(mc_io, &cmd);
176 }
177
dpni_get_attributes(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,struct dpni_attr * attr)178 int dpni_get_attributes(struct fsl_mc_io *mc_io,
179 uint32_t cmd_flags,
180 uint16_t token,
181 struct dpni_attr *attr)
182 {
183 struct mc_command cmd = { 0 };
184 int err;
185
186 /* prepare command */
187 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_ATTR,
188 cmd_flags,
189 token);
190 /* send command to mc*/
191 err = mc_send_command(mc_io, &cmd);
192 if (err)
193 return err;
194
195 /* retrieve response parameters */
196 DPNI_RSP_GET_ATTR(cmd, attr);
197
198 return 0;
199 }
200
dpni_set_errors_behavior(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,struct dpni_error_cfg * cfg)201 int dpni_set_errors_behavior(struct fsl_mc_io *mc_io,
202 uint32_t cmd_flags,
203 uint16_t token,
204 struct dpni_error_cfg *cfg)
205 {
206 struct mc_command cmd = { 0 };
207
208 /* prepare command */
209 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_ERRORS_BEHAVIOR,
210 cmd_flags,
211 token);
212 DPNI_CMD_SET_ERRORS_BEHAVIOR(cmd, cfg);
213
214 /* send command to mc*/
215 return mc_send_command(mc_io, &cmd);
216 }
217
dpni_set_buffer_layout(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,const struct dpni_buffer_layout * layout,enum dpni_queue_type type)218 int dpni_set_buffer_layout(struct fsl_mc_io *mc_io,
219 uint32_t cmd_flags,
220 uint16_t token,
221 const struct dpni_buffer_layout *layout,
222 enum dpni_queue_type type)
223 {
224 struct mc_command cmd = { 0 };
225
226 /* prepare command */
227 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_BUFFER_LAYOUT,
228 cmd_flags,
229 token);
230 DPNI_CMD_SET_BUFFER_LAYOUT(cmd, layout, type);
231
232 /* send command to mc*/
233 return mc_send_command(mc_io, &cmd);
234 }
235
dpni_get_qdid(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,uint16_t * qdid)236 int dpni_get_qdid(struct fsl_mc_io *mc_io,
237 uint32_t cmd_flags,
238 uint16_t token,
239 uint16_t *qdid)
240 {
241 struct mc_command cmd = { 0 };
242 int err;
243
244 /* prepare command */
245 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QDID,
246 cmd_flags,
247 token);
248
249 /* send command to mc*/
250 err = mc_send_command(mc_io, &cmd);
251 if (err)
252 return err;
253
254 /* retrieve response parameters */
255 DPNI_RSP_GET_QDID(cmd, *qdid);
256
257 return 0;
258 }
259
dpni_get_tx_data_offset(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,uint16_t * data_offset)260 int dpni_get_tx_data_offset(struct fsl_mc_io *mc_io,
261 uint32_t cmd_flags,
262 uint16_t token,
263 uint16_t *data_offset)
264 {
265 struct mc_command cmd = { 0 };
266 int err;
267
268 /* prepare command */
269 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_DATA_OFFSET,
270 cmd_flags,
271 token);
272
273 /* send command to mc*/
274 err = mc_send_command(mc_io, &cmd);
275 if (err)
276 return err;
277
278 /* retrieve response parameters */
279 DPNI_RSP_GET_TX_DATA_OFFSET(cmd, *data_offset);
280
281 return 0;
282 }
283
dpni_set_link_cfg(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,const struct dpni_link_cfg * cfg)284 int dpni_set_link_cfg(struct fsl_mc_io *mc_io,
285 uint32_t cmd_flags,
286 uint16_t token,
287 const struct dpni_link_cfg *cfg)
288 {
289 struct mc_command cmd = { 0 };
290
291 /* prepare command */
292 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_LINK_CFG,
293 cmd_flags,
294 token);
295 DPNI_CMD_SET_LINK_CFG(cmd, cfg);
296
297 /* send command to mc*/
298 return mc_send_command(mc_io, &cmd);
299 }
300
dpni_get_link_state(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,struct dpni_link_state * state)301 int dpni_get_link_state(struct fsl_mc_io *mc_io,
302 uint32_t cmd_flags,
303 uint16_t token,
304 struct dpni_link_state *state)
305 {
306 struct mc_command cmd = { 0 };
307 int err;
308
309 /* prepare command */
310 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_LINK_STATE,
311 cmd_flags,
312 token);
313
314 /* send command to mc*/
315 err = mc_send_command(mc_io, &cmd);
316 if (err)
317 return err;
318
319 /* retrieve response parameters */
320 DPNI_RSP_GET_LINK_STATE(cmd, state);
321
322 return 0;
323 }
324
325
dpni_set_primary_mac_addr(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,const uint8_t mac_addr[6])326 int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io,
327 uint32_t cmd_flags,
328 uint16_t token,
329 const uint8_t mac_addr[6])
330 {
331 struct mc_command cmd = { 0 };
332
333 /* prepare command */
334 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_PRIM_MAC,
335 cmd_flags,
336 token);
337 DPNI_CMD_SET_PRIMARY_MAC_ADDR(cmd, mac_addr);
338
339 /* send command to mc*/
340 return mc_send_command(mc_io, &cmd);
341 }
342
dpni_get_primary_mac_addr(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,uint8_t mac_addr[6])343 int dpni_get_primary_mac_addr(struct fsl_mc_io *mc_io,
344 uint32_t cmd_flags,
345 uint16_t token,
346 uint8_t mac_addr[6])
347 {
348 struct mc_command cmd = { 0 };
349 int err;
350
351 /* prepare command */
352 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_PRIM_MAC,
353 cmd_flags,
354 token);
355
356 /* send command to mc*/
357 err = mc_send_command(mc_io, &cmd);
358 if (err)
359 return err;
360
361 /* retrieve response parameters */
362 DPNI_RSP_GET_PRIMARY_MAC_ADDR(cmd, mac_addr);
363
364 return 0;
365 }
366
dpni_add_mac_addr(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,const uint8_t mac_addr[6])367 int dpni_add_mac_addr(struct fsl_mc_io *mc_io,
368 uint32_t cmd_flags,
369 uint16_t token,
370 const uint8_t mac_addr[6])
371 {
372 struct mc_command cmd = { 0 };
373
374 /* prepare command */
375 cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_MAC_ADDR,
376 cmd_flags,
377 token);
378 DPNI_CMD_ADD_MAC_ADDR(cmd, mac_addr);
379
380 /* send command to mc*/
381 return mc_send_command(mc_io, &cmd);
382 }
383
dpni_remove_mac_addr(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,const uint8_t mac_addr[6])384 int dpni_remove_mac_addr(struct fsl_mc_io *mc_io,
385 uint32_t cmd_flags,
386 uint16_t token,
387 const uint8_t mac_addr[6])
388 {
389 struct mc_command cmd = { 0 };
390
391 /* prepare command */
392 cmd.header = mc_encode_cmd_header(DPNI_CMDID_REMOVE_MAC_ADDR,
393 cmd_flags,
394 token);
395 DPNI_CMD_REMOVE_MAC_ADDR(cmd, mac_addr);
396
397 /* send command to mc*/
398 return mc_send_command(mc_io, &cmd);
399 }
400
dpni_get_api_version(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 * major_ver,u16 * minor_ver)401 int dpni_get_api_version(struct fsl_mc_io *mc_io,
402 u32 cmd_flags,
403 u16 *major_ver,
404 u16 *minor_ver)
405 {
406 struct mc_command cmd = { 0 };
407 int err;
408
409 /* prepare command */
410 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_API_VERSION,
411 cmd_flags, 0);
412
413 /* send command to mc */
414 err = mc_send_command(mc_io, &cmd);
415 if (err)
416 return err;
417
418 /* retrieve response parameters */
419 mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
420
421 return 0;
422 }
423
dpni_set_queue(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,enum dpni_queue_type type,uint8_t tc,uint8_t index,const struct dpni_queue * queue)424 int dpni_set_queue(struct fsl_mc_io *mc_io,
425 uint32_t cmd_flags,
426 uint16_t token,
427 enum dpni_queue_type type,
428 uint8_t tc,
429 uint8_t index,
430 const struct dpni_queue *queue)
431 {
432 struct mc_command cmd = { 0 };
433 /* prepare command */
434 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_QUEUE,
435 cmd_flags,
436 token);
437 DPNI_CMD_SET_QUEUE(cmd, type, tc, index, queue);
438
439 /* send command to mc*/
440 return mc_send_command(mc_io, &cmd);
441 }
442
dpni_get_queue(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,enum dpni_queue_type type,uint8_t tc,uint8_t index,struct dpni_queue * queue)443 int dpni_get_queue(struct fsl_mc_io *mc_io,
444 uint32_t cmd_flags,
445 uint16_t token,
446 enum dpni_queue_type type,
447 uint8_t tc,
448 uint8_t index,
449 struct dpni_queue *queue)
450 {
451 struct mc_command cmd = { 0 };
452 int err;
453
454 /* prepare command */
455 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QUEUE,
456 cmd_flags,
457 token);
458 DPNI_CMD_GET_QUEUE(cmd, type, tc, index);
459
460 /* send command to mc*/
461 err = mc_send_command(mc_io, &cmd);
462 if (err)
463 return err;
464
465 /* retrieve response parameters */
466 DPNI_RSP_GET_QUEUE(cmd, queue);
467 return 0;
468 }
469
dpni_set_tx_confirmation_mode(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,enum dpni_confirmation_mode mode)470 int dpni_set_tx_confirmation_mode(struct fsl_mc_io *mc_io,
471 uint32_t cmd_flags,
472 uint16_t token,
473 enum dpni_confirmation_mode mode)
474 {
475 struct dpni_tx_confirmation_mode *cmd_params;
476 struct mc_command cmd = { 0 };
477
478 /* prepare command */
479 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONFIRMATION_MODE,
480 cmd_flags,
481 token);
482
483 cmd_params = (struct dpni_tx_confirmation_mode *)cmd.params;
484 cmd_params->confirmation_mode = mode;
485
486 /* send command to mc*/
487 return mc_send_command(mc_io, &cmd);
488 }
489
dpni_get_statistics(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token,uint8_t page,struct dpni_statistics * stat)490 int dpni_get_statistics(struct fsl_mc_io *mc_io,
491 uint32_t cmd_flags,
492 uint16_t token,
493 uint8_t page,
494 struct dpni_statistics *stat)
495 {
496 struct mc_command cmd = { 0 };
497 int err;
498
499 /* prepare command */
500 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_STATISTICS,
501 cmd_flags, token);
502 DPNI_CMD_GET_STATISTICS(cmd, page);
503
504 /* send command to mc*/
505 err = mc_send_command(mc_io, &cmd);
506 if (err)
507 return err;
508
509 /* retrieve response parameters */
510 DPNI_RSP_GET_STATISTICS(cmd, stat);
511
512 return 0;
513 }
514
dpni_reset_statistics(struct fsl_mc_io * mc_io,uint32_t cmd_flags,uint16_t token)515 int dpni_reset_statistics(struct fsl_mc_io *mc_io,
516 uint32_t cmd_flags,
517 uint16_t token)
518 {
519 struct mc_command cmd = { 0 };
520
521 /* prepare command */
522 cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET_STATISTICS,
523 cmd_flags, token);
524
525 /* send command to mc*/
526 return mc_send_command(mc_io, &cmd);
527 }
528
529