Gitiles
Code Review Sign In
gerrit.devboardsforandroid.linaro.org / platform / external / u-boot / a2a55e518f81900ab1538656e5df8d2759ccb1fb / . / drivers / net / fsl-mc / dpni.c
blob: b3844012955a7b8c9de218fb3b68042106f96b8e [file] [log] [blame]
Prabhakar Kushwahaa2a55e52015-03-19 09:20:45 -0700[diff] [blame^]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
11int 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
32int 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
44int 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
60int 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
72int 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
85int 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
97int 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
120int 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
142int 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
157int 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
179int 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
194int 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
216int 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
231int 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
252int 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
274int 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
298int 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
314int 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
329int 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
352int 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
367int 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
389int 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
404int 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
419int 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
443int 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
467int 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
484int 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}