1 /*
2 * Copyright (C) 2013-2015 Freescale Semiconductor
3 *
4 * SPDX-License-Identifier: GPL-2.0+
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_open(struct fsl_mc_io * mc_io,int dpni_id,uint16_t * token)11 int dpni_open(struct fsl_mc_io *mc_io, int dpni_id, uint16_t *token)
12 {
13 struct mc_command cmd = { 0 };
14 int err;
15
16 /* prepare command */
17 cmd.header = mc_encode_cmd_header(DPNI_CMDID_OPEN,
18 MC_CMD_PRI_LOW, 0);
19 DPNI_CMD_OPEN(cmd, dpni_id);
20
21 /* send command to mc*/
22 err = mc_send_command(mc_io, &cmd);
23 if (err)
24 return err;
25
26 /* retrieve response parameters */
27 *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
28
29 return 0;
30 }
31
dpni_close(struct fsl_mc_io * mc_io,uint16_t token)32 int dpni_close(struct fsl_mc_io *mc_io, uint16_t token)
33 {
34 struct mc_command cmd = { 0 };
35
36 /* prepare command */
37 cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLOSE,
38 MC_CMD_PRI_HIGH, token);
39
40 /* send command to mc*/
41 return mc_send_command(mc_io, &cmd);
42 }
43
dpni_set_pools(struct fsl_mc_io * mc_io,uint16_t token,const struct dpni_pools_cfg * cfg)44 int dpni_set_pools(struct fsl_mc_io *mc_io,
45 uint16_t token,
46 const struct dpni_pools_cfg *cfg)
47 {
48 struct mc_command cmd = { 0 };
49
50 /* prepare command */
51 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_POOLS,
52 MC_CMD_PRI_LOW,
53 token);
54 DPNI_CMD_SET_POOLS(cmd, cfg);
55
56 /* send command to mc*/
57 return mc_send_command(mc_io, &cmd);
58 }
59
dpni_enable(struct fsl_mc_io * mc_io,uint16_t token)60 int dpni_enable(struct fsl_mc_io *mc_io, uint16_t token)
61 {
62 struct mc_command cmd = { 0 };
63
64 /* prepare command */
65 cmd.header = mc_encode_cmd_header(DPNI_CMDID_ENABLE,
66 MC_CMD_PRI_LOW, token);
67
68 /* send command to mc*/
69 return mc_send_command(mc_io, &cmd);
70 }
71
dpni_disable(struct fsl_mc_io * mc_io,uint16_t token)72 int dpni_disable(struct fsl_mc_io *mc_io, uint16_t token)
73 {
74 struct mc_command cmd = { 0 };
75
76 /* prepare command */
77 cmd.header = mc_encode_cmd_header(DPNI_CMDID_DISABLE,
78 MC_CMD_PRI_LOW,
79 token);
80
81 /* send command to mc*/
82 return mc_send_command(mc_io, &cmd);
83 }
84
dpni_reset(struct fsl_mc_io * mc_io,uint16_t token)85 int dpni_reset(struct fsl_mc_io *mc_io, uint16_t token)
86 {
87 struct mc_command cmd = { 0 };
88
89 /* prepare command */
90 cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET,
91 MC_CMD_PRI_LOW, token);
92
93 /* send command to mc*/
94 return mc_send_command(mc_io, &cmd);
95 }
96
dpni_get_attributes(struct fsl_mc_io * mc_io,uint16_t token,struct dpni_attr * attr)97 int dpni_get_attributes(struct fsl_mc_io *mc_io,
98 uint16_t token,
99 struct dpni_attr *attr)
100 {
101 struct mc_command cmd = { 0 };
102 int err;
103
104 /* prepare command */
105 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_ATTR,
106 MC_CMD_PRI_LOW,
107 token);
108
109 /* send command to mc*/
110 err = mc_send_command(mc_io, &cmd);
111 if (err)
112 return err;
113
114 /* retrieve response parameters */
115 DPNI_RSP_GET_ATTR(cmd, attr);
116
117 return 0;
118 }
119
dpni_get_rx_buffer_layout(struct fsl_mc_io * mc_io,uint16_t token,struct dpni_buffer_layout * layout)120 int dpni_get_rx_buffer_layout(struct fsl_mc_io *mc_io,
121 uint16_t token,
122 struct dpni_buffer_layout *layout)
123 {
124 struct mc_command cmd = { 0 };
125 int err;
126
127 /* prepare command */
128 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_RX_BUFFER_LAYOUT,
129 MC_CMD_PRI_LOW, token);
130
131 /* send command to mc*/
132 err = mc_send_command(mc_io, &cmd);
133 if (err)
134 return err;
135
136 /* retrieve response parameters */
137 DPNI_RSP_GET_RX_BUFFER_LAYOUT(cmd, layout);
138
139 return 0;
140 }
141
dpni_set_rx_buffer_layout(struct fsl_mc_io * mc_io,uint16_t token,const struct dpni_buffer_layout * layout)142 int dpni_set_rx_buffer_layout(struct fsl_mc_io *mc_io,
143 uint16_t token,
144 const struct dpni_buffer_layout *layout)
145 {
146 struct mc_command cmd = { 0 };
147
148 /* prepare command */
149 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_BUFFER_LAYOUT,
150 MC_CMD_PRI_LOW, token);
151 DPNI_CMD_SET_RX_BUFFER_LAYOUT(cmd, layout);
152
153 /* send command to mc*/
154 return mc_send_command(mc_io, &cmd);
155 }
156
dpni_get_tx_buffer_layout(struct fsl_mc_io * mc_io,uint16_t token,struct dpni_buffer_layout * layout)157 int dpni_get_tx_buffer_layout(struct fsl_mc_io *mc_io,
158 uint16_t token,
159 struct dpni_buffer_layout *layout)
160 {
161 struct mc_command cmd = { 0 };
162 int err;
163
164 /* prepare command */
165 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_BUFFER_LAYOUT,
166 MC_CMD_PRI_LOW, token);
167
168 /* send command to mc*/
169 err = mc_send_command(mc_io, &cmd);
170 if (err)
171 return err;
172
173 /* retrieve response parameters */
174 DPNI_RSP_GET_TX_BUFFER_LAYOUT(cmd, layout);
175
176 return 0;
177 }
178
dpni_set_tx_buffer_layout(struct fsl_mc_io * mc_io,uint16_t token,const struct dpni_buffer_layout * layout)179 int dpni_set_tx_buffer_layout(struct fsl_mc_io *mc_io,
180 uint16_t token,
181 const struct dpni_buffer_layout *layout)
182 {
183 struct mc_command cmd = { 0 };
184
185 /* prepare command */
186 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_BUFFER_LAYOUT,
187 MC_CMD_PRI_LOW, token);
188 DPNI_CMD_SET_TX_BUFFER_LAYOUT(cmd, layout);
189
190 /* send command to mc*/
191 return mc_send_command(mc_io, &cmd);
192 }
193
dpni_get_tx_conf_buffer_layout(struct fsl_mc_io * mc_io,uint16_t token,struct dpni_buffer_layout * layout)194 int dpni_get_tx_conf_buffer_layout(struct fsl_mc_io *mc_io,
195 uint16_t token,
196 struct dpni_buffer_layout *layout)
197 {
198 struct mc_command cmd = { 0 };
199 int err;
200
201 /* prepare command */
202 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_CONF_BUFFER_LAYOUT,
203 MC_CMD_PRI_LOW, token);
204
205 /* send command to mc*/
206 err = mc_send_command(mc_io, &cmd);
207 if (err)
208 return err;
209
210 /* retrieve response parameters */
211 DPNI_RSP_GET_TX_CONF_BUFFER_LAYOUT(cmd, layout);
212
213 return 0;
214 }
215
dpni_set_tx_conf_buffer_layout(struct fsl_mc_io * mc_io,uint16_t token,const struct dpni_buffer_layout * layout)216 int dpni_set_tx_conf_buffer_layout(struct fsl_mc_io *mc_io,
217 uint16_t token,
218 const struct dpni_buffer_layout *layout)
219 {
220 struct mc_command cmd = { 0 };
221
222 /* prepare command */
223 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONF_BUFFER_LAYOUT,
224 MC_CMD_PRI_LOW, token);
225 DPNI_CMD_SET_TX_CONF_BUFFER_LAYOUT(cmd, layout);
226
227 /* send command to mc*/
228 return mc_send_command(mc_io, &cmd);
229 }
230
dpni_get_qdid(struct fsl_mc_io * mc_io,uint16_t token,uint16_t * qdid)231 int dpni_get_qdid(struct fsl_mc_io *mc_io, uint16_t token, uint16_t *qdid)
232 {
233 struct mc_command cmd = { 0 };
234 int err;
235
236 /* prepare command */
237 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QDID,
238 MC_CMD_PRI_LOW,
239 token);
240
241 /* send command to mc*/
242 err = mc_send_command(mc_io, &cmd);
243 if (err)
244 return err;
245
246 /* retrieve response parameters */
247 DPNI_RSP_GET_QDID(cmd, *qdid);
248
249 return 0;
250 }
251
dpni_get_tx_data_offset(struct fsl_mc_io * mc_io,uint16_t token,uint16_t * data_offset)252 int dpni_get_tx_data_offset(struct fsl_mc_io *mc_io,
253 uint16_t token,
254 uint16_t *data_offset)
255 {
256 struct mc_command cmd = { 0 };
257 int err;
258
259 /* prepare command */
260 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_DATA_OFFSET,
261 MC_CMD_PRI_LOW, token);
262
263 /* send command to mc*/
264 err = mc_send_command(mc_io, &cmd);
265 if (err)
266 return err;
267
268 /* retrieve response parameters */
269 DPNI_RSP_GET_TX_DATA_OFFSET(cmd, *data_offset);
270
271 return 0;
272 }
273
dpni_get_counter(struct fsl_mc_io * mc_io,uint16_t token,enum dpni_counter counter,uint64_t * value)274 int dpni_get_counter(struct fsl_mc_io *mc_io,
275 uint16_t token,
276 enum dpni_counter counter,
277 uint64_t *value)
278 {
279 struct mc_command cmd = { 0 };
280 int err;
281
282 /* prepare command */
283 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_COUNTER,
284 MC_CMD_PRI_LOW, token);
285 DPNI_CMD_GET_COUNTER(cmd, counter);
286
287 /* send command to mc*/
288 err = mc_send_command(mc_io, &cmd);
289 if (err)
290 return err;
291
292 /* retrieve response parameters */
293 DPNI_RSP_GET_COUNTER(cmd, *value);
294
295 return 0;
296 }
297
dpni_set_counter(struct fsl_mc_io * mc_io,uint16_t token,enum dpni_counter counter,uint64_t value)298 int dpni_set_counter(struct fsl_mc_io *mc_io,
299 uint16_t token,
300 enum dpni_counter counter,
301 uint64_t value)
302 {
303 struct mc_command cmd = { 0 };
304
305 /* prepare command */
306 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_COUNTER,
307 MC_CMD_PRI_LOW, token);
308 DPNI_CMD_SET_COUNTER(cmd, counter, value);
309
310 /* send command to mc*/
311 return mc_send_command(mc_io, &cmd);
312 }
313
dpni_set_link_cfg(struct fsl_mc_io * mc_io,uint16_t token,struct dpni_link_cfg * cfg)314 int dpni_set_link_cfg(struct fsl_mc_io *mc_io,
315 uint16_t token,
316 struct dpni_link_cfg *cfg)
317 {
318 struct mc_command cmd = { 0 };
319
320 /* prepare command */
321 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_LINK_CFG,
322 MC_CMD_PRI_LOW, token);
323 DPNI_CMD_SET_LINK_CFG(cmd, cfg);
324
325 /* send command to mc*/
326 return mc_send_command(mc_io, &cmd);
327 }
328
dpni_get_link_state(struct fsl_mc_io * mc_io,uint16_t token,struct dpni_link_state * state)329 int dpni_get_link_state(struct fsl_mc_io *mc_io,
330 uint16_t token,
331 struct dpni_link_state *state)
332 {
333 struct mc_command cmd = { 0 };
334 int err;
335
336 /* prepare command */
337 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_LINK_STATE,
338 MC_CMD_PRI_LOW, token);
339
340 /* send command to mc*/
341 err = mc_send_command(mc_io, &cmd);
342 if (err)
343 return err;
344
345 /* retrieve response parameters */
346 DPNI_RSP_GET_LINK_STATE(cmd, state);
347
348 return 0;
349 }
350
351
dpni_set_primary_mac_addr(struct fsl_mc_io * mc_io,uint16_t token,const uint8_t mac_addr[6])352 int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io,
353 uint16_t token,
354 const uint8_t mac_addr[6])
355 {
356 struct mc_command cmd = { 0 };
357
358 /* prepare command */
359 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_PRIM_MAC,
360 MC_CMD_PRI_LOW, token);
361 DPNI_CMD_SET_PRIMARY_MAC_ADDR(cmd, mac_addr);
362
363 /* send command to mc*/
364 return mc_send_command(mc_io, &cmd);
365 }
366
dpni_get_primary_mac_addr(struct fsl_mc_io * mc_io,uint16_t token,uint8_t mac_addr[6])367 int dpni_get_primary_mac_addr(struct fsl_mc_io *mc_io,
368 uint16_t token,
369 uint8_t mac_addr[6])
370 {
371 struct mc_command cmd = { 0 };
372 int err;
373
374 /* prepare command */
375 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_PRIM_MAC,
376 MC_CMD_PRI_LOW, token);
377
378 /* send command to mc*/
379 err = mc_send_command(mc_io, &cmd);
380 if (err)
381 return err;
382
383 /* retrieve response parameters */
384 DPNI_RSP_GET_PRIMARY_MAC_ADDR(cmd, mac_addr);
385
386 return 0;
387 }
388
dpni_add_mac_addr(struct fsl_mc_io * mc_io,uint16_t token,const uint8_t mac_addr[6])389 int dpni_add_mac_addr(struct fsl_mc_io *mc_io,
390 uint16_t token,
391 const uint8_t mac_addr[6])
392 {
393 struct mc_command cmd = { 0 };
394
395 /* prepare command */
396 cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_MAC_ADDR,
397 MC_CMD_PRI_LOW, token);
398 DPNI_CMD_ADD_MAC_ADDR(cmd, mac_addr);
399
400 /* send command to mc*/
401 return mc_send_command(mc_io, &cmd);
402 }
403
dpni_remove_mac_addr(struct fsl_mc_io * mc_io,uint16_t token,const uint8_t mac_addr[6])404 int dpni_remove_mac_addr(struct fsl_mc_io *mc_io,
405 uint16_t token,
406 const uint8_t mac_addr[6])
407 {
408 struct mc_command cmd = { 0 };
409
410 /* prepare command */
411 cmd.header = mc_encode_cmd_header(DPNI_CMDID_REMOVE_MAC_ADDR,
412 MC_CMD_PRI_LOW, token);
413 DPNI_CMD_REMOVE_MAC_ADDR(cmd, mac_addr);
414
415 /* send command to mc*/
416 return mc_send_command(mc_io, &cmd);
417 }
418
dpni_set_tx_flow(struct fsl_mc_io * mc_io,uint16_t token,uint16_t * flow_id,const struct dpni_tx_flow_cfg * cfg)419 int dpni_set_tx_flow(struct fsl_mc_io *mc_io,
420 uint16_t token,
421 uint16_t *flow_id,
422 const struct dpni_tx_flow_cfg *cfg)
423 {
424 struct mc_command cmd = { 0 };
425 int err;
426
427 /* prepare command */
428 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_FLOW,
429 MC_CMD_PRI_LOW, token);
430 DPNI_CMD_SET_TX_FLOW(cmd, *flow_id, cfg);
431
432 /* send command to mc*/
433 err = mc_send_command(mc_io, &cmd);
434 if (err)
435 return err;
436
437 /* retrieve response parameters */
438 DPNI_RSP_SET_TX_FLOW(cmd, *flow_id);
439
440 return 0;
441 }
442
dpni_get_tx_flow(struct fsl_mc_io * mc_io,uint16_t token,uint16_t flow_id,struct dpni_tx_flow_attr * attr)443 int dpni_get_tx_flow(struct fsl_mc_io *mc_io,
444 uint16_t token,
445 uint16_t flow_id,
446 struct dpni_tx_flow_attr *attr)
447 {
448 struct mc_command cmd = { 0 };
449 int err;
450
451 /* prepare command */
452 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_FLOW,
453 MC_CMD_PRI_LOW, token);
454 DPNI_CMD_GET_TX_FLOW(cmd, flow_id);
455
456 /* send command to mc*/
457 err = mc_send_command(mc_io, &cmd);
458 if (err)
459 return err;
460
461 /* retrieve response parameters */
462 DPNI_RSP_GET_TX_FLOW(cmd, attr);
463
464 return 0;
465 }
466
dpni_set_rx_flow(struct fsl_mc_io * mc_io,uint16_t token,uint8_t tc_id,uint16_t flow_id,const struct dpni_queue_cfg * cfg)467 int dpni_set_rx_flow(struct fsl_mc_io *mc_io,
468 uint16_t token,
469 uint8_t tc_id,
470 uint16_t flow_id,
471 const struct dpni_queue_cfg *cfg)
472 {
473 struct mc_command cmd = { 0 };
474
475 /* prepare command */
476 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_FLOW,
477 MC_CMD_PRI_LOW, token);
478 DPNI_CMD_SET_RX_FLOW(cmd, tc_id, flow_id, cfg);
479
480 /* send command to mc*/
481 return mc_send_command(mc_io, &cmd);
482 }
483
dpni_get_rx_flow(struct fsl_mc_io * mc_io,uint16_t token,uint8_t tc_id,uint16_t flow_id,struct dpni_queue_attr * attr)484 int dpni_get_rx_flow(struct fsl_mc_io *mc_io,
485 uint16_t token,
486 uint8_t tc_id,
487 uint16_t flow_id,
488 struct dpni_queue_attr *attr)
489 {
490 struct mc_command cmd = { 0 };
491 int err;
492 /* prepare command */
493 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_RX_FLOW,
494 MC_CMD_PRI_LOW, token);
495 DPNI_CMD_GET_RX_FLOW(cmd, tc_id, flow_id);
496
497 /* send command to mc*/
498 err = mc_send_command(mc_io, &cmd);
499 if (err)
500 return err;
501
502 /* retrieve response parameters */
503 DPNI_RSP_GET_RX_FLOW(cmd, attr);
504
505 return 0;
506 }
507