bus/fslmc: fix mempool ops registration
[dpdk.git] / drivers / bus / fslmc / mc / dpci.c
1 /* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
2  *
3  * Copyright 2013-2016 Freescale Semiconductor Inc.
4  *
5  */
6 #include <fsl_mc_sys.h>
7 #include <fsl_mc_cmd.h>
8 #include <fsl_dpci.h>
9 #include <fsl_dpci_cmd.h>
10
11 /**
12  * dpci_open() - Open a control session for the specified object
13  * @mc_io:      Pointer to MC portal's I/O object
14  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
15  * @dpci_id:    DPCI unique ID
16  * @token:      Returned token; use in subsequent API calls
17  *
18  * This function can be used to open a control session for an
19  * already created object; an object may have been declared in
20  * the DPL or by calling the dpci_create() function.
21  * This function returns a unique authentication token,
22  * associated with the specific object ID and the specific MC
23  * portal; this token must be used in all subsequent commands for
24  * this specific object.
25  *
26  * Return:      '0' on Success; Error code otherwise.
27  */
28 int dpci_open(struct fsl_mc_io *mc_io,
29               uint32_t cmd_flags,
30               int dpci_id,
31               uint16_t *token)
32 {
33         struct dpci_cmd_open *cmd_params;
34         struct mc_command cmd = { 0 };
35         int err;
36
37         /* prepare command */
38         cmd.header = mc_encode_cmd_header(DPCI_CMDID_OPEN,
39                                           cmd_flags,
40                                           0);
41         cmd_params = (struct dpci_cmd_open *)cmd.params;
42         cmd_params->dpci_id = cpu_to_le32(dpci_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 0;
53 }
54
55 /**
56  * dpci_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 DPCI 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  */
66 int dpci_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(DPCI_CMDID_CLOSE,
74                                           cmd_flags,
75                                           token);
76
77         /* send command to mc*/
78         return mc_send_command(mc_io, &cmd);
79 }
80
81 /**
82  * dpci_create() - Create the DPCI object.
83  * @mc_io:      Pointer to MC portal's I/O object
84  * @dprc_token: Parent container token; '0' for default container
85  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
86  * @cfg:        Configuration structure
87  * @obj_id:     Returned object id
88  *
89  * Create the DPCI object, allocate required resources and perform required
90  * initialization.
91  *
92  * The object can be created either by declaring it in the
93  * DPL file, or by calling this function.
94  *
95  * The function accepts an authentication token of a parent
96  * container that this object should be assigned to. The token
97  * can be '0' so the object will be assigned to the default container.
98  * The newly created object can be opened with the returned
99  * object id and using the container's associated tokens and MC portals.
100  *
101  * Return:      '0' on Success; Error code otherwise.
102  */
103 int dpci_create(struct fsl_mc_io *mc_io,
104                 uint16_t dprc_token,
105                 uint32_t cmd_flags,
106                 const struct dpci_cfg *cfg,
107                 uint32_t *obj_id)
108 {
109         struct dpci_cmd_create *cmd_params;
110         struct mc_command cmd = { 0 };
111         int err;
112
113         /* prepare command */
114         cmd.header = mc_encode_cmd_header(DPCI_CMDID_CREATE,
115                                           cmd_flags,
116                                           dprc_token);
117         cmd_params = (struct dpci_cmd_create *)cmd.params;
118         cmd_params->num_of_priorities = cfg->num_of_priorities;
119
120         /* send command to mc*/
121         err = mc_send_command(mc_io, &cmd);
122         if (err)
123                 return err;
124
125         /* retrieve response parameters */
126         *obj_id = mc_cmd_read_object_id(&cmd);
127
128         return 0;
129 }
130
131 /**
132  * dpci_destroy() - Destroy the DPCI object and release all its resources.
133  * @mc_io:      Pointer to MC portal's I/O object
134  * @dprc_token: Parent container token; '0' for default container
135  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
136  * @object_id:  The object id; it must be a valid id within the container that
137  * created this object;
138  *
139  * The function accepts the authentication token of the parent container that
140  * created the object (not the one that currently owns the object). The object
141  * is searched within parent using the provided 'object_id'.
142  * All tokens to the object must be closed before calling destroy.
143  *
144  * Return:      '0' on Success; error code otherwise.
145  */
146 int dpci_destroy(struct fsl_mc_io *mc_io,
147                  uint16_t dprc_token,
148                  uint32_t cmd_flags,
149                  uint32_t object_id)
150 {
151         struct dpci_cmd_destroy *cmd_params;
152         struct mc_command cmd = { 0 };
153
154         /* prepare command */
155         cmd.header = mc_encode_cmd_header(DPCI_CMDID_DESTROY,
156                                           cmd_flags,
157                                           dprc_token);
158         cmd_params = (struct dpci_cmd_destroy *)cmd.params;
159         cmd_params->dpci_id = cpu_to_le32(object_id);
160
161         /* send command to mc*/
162         return mc_send_command(mc_io, &cmd);
163 }
164
165 /**
166  * dpci_enable() - Enable the DPCI, allow sending and receiving frames.
167  * @mc_io:      Pointer to MC portal's I/O object
168  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
169  * @token:      Token of DPCI object
170  *
171  * Return:      '0' on Success; Error code otherwise.
172  */
173 int dpci_enable(struct fsl_mc_io *mc_io,
174                 uint32_t cmd_flags,
175                 uint16_t token)
176 {
177         struct mc_command cmd = { 0 };
178
179         /* prepare command */
180         cmd.header = mc_encode_cmd_header(DPCI_CMDID_ENABLE,
181                                           cmd_flags,
182                                           token);
183
184         /* send command to mc*/
185         return mc_send_command(mc_io, &cmd);
186 }
187
188 /**
189  * dpci_disable() - Disable the DPCI, stop sending and receiving frames.
190  * @mc_io:      Pointer to MC portal's I/O object
191  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
192  * @token:      Token of DPCI object
193  *
194  * Return:      '0' on Success; Error code otherwise.
195  */
196 int dpci_disable(struct fsl_mc_io *mc_io,
197                  uint32_t cmd_flags,
198                  uint16_t token)
199 {
200         struct mc_command cmd = { 0 };
201
202         /* prepare command */
203         cmd.header = mc_encode_cmd_header(DPCI_CMDID_DISABLE,
204                                           cmd_flags,
205                                           token);
206
207         /* send command to mc*/
208         return mc_send_command(mc_io, &cmd);
209 }
210
211 /**
212  * dpci_is_enabled() - Check if the DPCI is enabled.
213  * @mc_io:      Pointer to MC portal's I/O object
214  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
215  * @token:      Token of DPCI object
216  * @en:         Returns '1' if object is enabled; '0' otherwise
217  *
218  * Return:      '0' on Success; Error code otherwise.
219  */
220 int dpci_is_enabled(struct fsl_mc_io *mc_io,
221                     uint32_t cmd_flags,
222                     uint16_t token,
223                     int *en)
224 {
225         struct dpci_rsp_is_enabled *rsp_params;
226         struct mc_command cmd = { 0 };
227         int err;
228
229         /* prepare command */
230         cmd.header = mc_encode_cmd_header(DPCI_CMDID_IS_ENABLED, cmd_flags,
231                                           token);
232
233         /* send command to mc*/
234         err = mc_send_command(mc_io, &cmd);
235         if (err)
236                 return err;
237
238         /* retrieve response parameters */
239         rsp_params = (struct dpci_rsp_is_enabled *)cmd.params;
240         *en = dpci_get_field(rsp_params->en, ENABLE);
241
242         return 0;
243 }
244
245 /**
246  * dpci_reset() - Reset the DPCI, returns the object to initial state.
247  * @mc_io:      Pointer to MC portal's I/O object
248  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
249  * @token:      Token of DPCI object
250  *
251  * Return:      '0' on Success; Error code otherwise.
252  */
253 int dpci_reset(struct fsl_mc_io *mc_io,
254                uint32_t cmd_flags,
255                uint16_t token)
256 {
257         struct mc_command cmd = { 0 };
258
259         /* prepare command */
260         cmd.header = mc_encode_cmd_header(DPCI_CMDID_RESET,
261                                           cmd_flags,
262                                           token);
263
264         /* send command to mc*/
265         return mc_send_command(mc_io, &cmd);
266 }
267
268 int dpci_get_attributes(struct fsl_mc_io *mc_io,
269                         uint32_t cmd_flags,
270                         uint16_t token,
271                         struct dpci_attr *attr)
272 {
273         struct dpci_rsp_get_attr *rsp_params;
274         struct mc_command cmd = { 0 };
275         int err;
276
277         /* prepare command */
278         cmd.header = mc_encode_cmd_header(DPCI_CMDID_GET_ATTR,
279                                           cmd_flags,
280                                           token);
281
282         /* send command to mc*/
283         err = mc_send_command(mc_io, &cmd);
284         if (err)
285                 return err;
286
287         /* retrieve response parameters */
288         rsp_params = (struct dpci_rsp_get_attr *)cmd.params;
289         attr->id = le32_to_cpu(rsp_params->id);
290         attr->num_of_priorities = rsp_params->num_of_priorities;
291
292         return 0;
293 }
294
295 int dpci_set_rx_queue(struct fsl_mc_io *mc_io,
296                       uint32_t cmd_flags,
297                       uint16_t token,
298                       uint8_t priority,
299                       const struct dpci_rx_queue_cfg *cfg)
300 {
301         struct dpci_cmd_set_rx_queue *cmd_params;
302         struct mc_command cmd = { 0 };
303
304         /* prepare command */
305         cmd.header = mc_encode_cmd_header(DPCI_CMDID_SET_RX_QUEUE,
306                                           cmd_flags,
307                                           token);
308         cmd_params = (struct dpci_cmd_set_rx_queue *)cmd.params;
309         cmd_params->dest_id = cpu_to_le32(cfg->dest_cfg.dest_id);
310         cmd_params->dest_priority = cfg->dest_cfg.priority;
311         cmd_params->priority = priority;
312         cmd_params->user_ctx = cpu_to_le64(cfg->user_ctx);
313         cmd_params->options = cpu_to_le32(cfg->options);
314         dpci_set_field(cmd_params->dest_type,
315                        DEST_TYPE,
316                        cfg->dest_cfg.dest_type);
317
318         /* send command to mc*/
319         return mc_send_command(mc_io, &cmd);
320 }
321
322 /**
323  * dpci_get_rx_queue() - Retrieve Rx queue attributes.
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 DPCI object
327  * @priority:   Select the queue relative to number of
328  *              priorities configured at DPCI creation
329  * @attr:       Returned Rx queue attributes
330  *
331  * Return:      '0' on Success; Error code otherwise.
332  */
333 int dpci_get_rx_queue(struct fsl_mc_io *mc_io,
334                       uint32_t cmd_flags,
335                       uint16_t token,
336                       uint8_t priority,
337                       struct dpci_rx_queue_attr *attr)
338 {
339         struct dpci_cmd_get_queue *cmd_params;
340         struct dpci_rsp_get_rx_queue *rsp_params;
341         struct mc_command cmd = { 0 };
342         int err;
343
344         /* prepare command */
345         cmd.header = mc_encode_cmd_header(DPCI_CMDID_GET_RX_QUEUE,
346                                           cmd_flags,
347                                           token);
348         cmd_params = (struct dpci_cmd_get_queue *)cmd.params;
349         cmd_params->priority = priority;
350
351         /* send command to mc*/
352         err = mc_send_command(mc_io, &cmd);
353         if (err)
354                 return err;
355
356         /* retrieve response parameters */
357         rsp_params = (struct dpci_rsp_get_rx_queue *)cmd.params;
358         attr->user_ctx = le64_to_cpu(rsp_params->user_ctx);
359         attr->fqid = le32_to_cpu(rsp_params->fqid);
360         attr->dest_cfg.dest_id = le32_to_cpu(rsp_params->dest_id);
361         attr->dest_cfg.priority = rsp_params->dest_priority;
362         attr->dest_cfg.dest_type = dpci_get_field(rsp_params->dest_type,
363                                                   DEST_TYPE);
364
365         return 0;
366 }
367
368 /**
369  * dpci_get_tx_queue() - Retrieve Tx queue attributes.
370  * @mc_io:      Pointer to MC portal's I/O object
371  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
372  * @token:      Token of DPCI object
373  * @priority:   Select the queue relative to number of
374  *              priorities of the peer DPCI object
375  * @attr:       Returned Tx queue attributes
376  *
377  * Return:      '0' on Success; Error code otherwise.
378  */
379 int dpci_get_tx_queue(struct fsl_mc_io *mc_io,
380                       uint32_t cmd_flags,
381                       uint16_t token,
382                       uint8_t priority,
383                       struct dpci_tx_queue_attr *attr)
384 {
385         struct dpci_cmd_get_queue *cmd_params;
386         struct dpci_rsp_get_tx_queue *rsp_params;
387         struct mc_command cmd = { 0 };
388         int err;
389
390         /* prepare command */
391         cmd.header = mc_encode_cmd_header(DPCI_CMDID_GET_TX_QUEUE,
392                                           cmd_flags,
393                                           token);
394         cmd_params = (struct dpci_cmd_get_queue *)cmd.params;
395         cmd_params->priority = priority;
396
397         /* send command to mc*/
398         err = mc_send_command(mc_io, &cmd);
399         if (err)
400                 return err;
401
402         /* retrieve response parameters */
403         rsp_params = (struct dpci_rsp_get_tx_queue *)cmd.params;
404         attr->fqid = le32_to_cpu(rsp_params->fqid);
405
406         return 0;
407 }
408
409 /**
410  * dpci_get_api_version() - Get communication interface API version
411  * @mc_io:      Pointer to MC portal's I/O object
412  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
413  * @major_ver:  Major version of data path communication interface API
414  * @minor_ver:  Minor version of data path communication interface API
415  *
416  * Return:  '0' on Success; Error code otherwise.
417  */
418 int dpci_get_api_version(struct fsl_mc_io *mc_io,
419                          uint32_t cmd_flags,
420                          uint16_t *major_ver,
421                          uint16_t *minor_ver)
422 {
423         struct dpci_rsp_get_api_version *rsp_params;
424         struct mc_command cmd = { 0 };
425         int err;
426
427         cmd.header = mc_encode_cmd_header(DPCI_CMDID_GET_API_VERSION,
428                                         cmd_flags,
429                                         0);
430
431         err = mc_send_command(mc_io, &cmd);
432         if (err)
433                 return err;
434
435         rsp_params = (struct dpci_rsp_get_api_version *)cmd.params;
436         *major_ver = le16_to_cpu(rsp_params->major);
437         *minor_ver = le16_to_cpu(rsp_params->minor);
438
439         return 0;
440 }