1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
2 /*
3 * Copyright 2013-2016 Freescale Semiconductor Inc.
4 * Copyright 2020 NXP
5 *
6 */
7 #include <linux/kernel.h>
8 #include <linux/fsl/mc.h>
9
10 #include "fsl-mc-private.h"
11
12 /*
13 * cache the DPRC version to reduce the number of commands
14 * towards the mc firmware
15 */
16 static u16 dprc_major_ver;
17 static u16 dprc_minor_ver;
18
19 /**
20 * dprc_open() - Open DPRC object for use
21 * @mc_io: Pointer to MC portal's I/O object
22 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
23 * @container_id: Container ID to open
24 * @token: Returned token of DPRC object
25 *
26 * Return: '0' on Success; Error code otherwise.
27 *
28 * @warning Required before any operation on the object.
29 */
dprc_open(struct fsl_mc_io * mc_io,u32 cmd_flags,int container_id,u16 * token)30 int dprc_open(struct fsl_mc_io *mc_io,
31 u32 cmd_flags,
32 int container_id,
33 u16 *token)
34 {
35 struct fsl_mc_command cmd = { 0 };
36 struct dprc_cmd_open *cmd_params;
37 int err;
38
39 /* prepare command */
40 cmd.header = mc_encode_cmd_header(DPRC_CMDID_OPEN, cmd_flags,
41 0);
42 cmd_params = (struct dprc_cmd_open *)cmd.params;
43 cmd_params->container_id = cpu_to_le32(container_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);
52
53 return 0;
54 }
55 EXPORT_SYMBOL_GPL(dprc_open);
56
57 /**
58 * dprc_close() - Close the control session of the object
59 * @mc_io: Pointer to MC portal's I/O object
60 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
61 * @token: Token of DPRC object
62 *
63 * After this function is called, no further operations are
64 * allowed on the object without opening a new control session.
65 *
66 * Return: '0' on Success; Error code otherwise.
67 */
dprc_close(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token)68 int dprc_close(struct fsl_mc_io *mc_io,
69 u32 cmd_flags,
70 u16 token)
71 {
72 struct fsl_mc_command cmd = { 0 };
73
74 /* prepare command */
75 cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLOSE, cmd_flags,
76 token);
77
78 /* send command to mc*/
79 return mc_send_command(mc_io, &cmd);
80 }
81 EXPORT_SYMBOL_GPL(dprc_close);
82
83 /**
84 * dprc_reset_container - Reset child container.
85 * @mc_io: Pointer to MC portal's I/O object
86 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
87 * @token: Token of DPRC object
88 * @child_container_id: ID of the container to reset
89 * @options: 32 bit options:
90 * - 0 (no bits set) - all the objects inside the container are
91 * reset. The child containers are entered recursively and the
92 * objects reset. All the objects (including the child containers)
93 * are closed.
94 * - bit 0 set - all the objects inside the container are reset.
95 * However the child containers are not entered recursively.
96 * This option is supported for API versions >= 6.5
97 * In case a software context crashes or becomes non-responsive, the parent
98 * may wish to reset its resources container before the software context is
99 * restarted.
100 *
101 * This routine informs all objects assigned to the child container that the
102 * container is being reset, so they may perform any cleanup operations that are
103 * needed. All objects handles that were owned by the child container shall be
104 * closed.
105 *
106 * Note that such request may be submitted even if the child software context
107 * has not crashed, but the resulting object cleanup operations will not be
108 * aware of that.
109 *
110 * Return: '0' on Success; Error code otherwise.
111 */
dprc_reset_container(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token,int child_container_id,u32 options)112 int dprc_reset_container(struct fsl_mc_io *mc_io,
113 u32 cmd_flags,
114 u16 token,
115 int child_container_id,
116 u32 options)
117 {
118 struct fsl_mc_command cmd = { 0 };
119 struct dprc_cmd_reset_container *cmd_params;
120 u32 cmdid = DPRC_CMDID_RESET_CONT;
121 int err;
122
123 /*
124 * If the DPRC object version was not yet cached, cache it now.
125 * Otherwise use the already cached value.
126 */
127 if (!dprc_major_ver && !dprc_minor_ver) {
128 err = dprc_get_api_version(mc_io, 0,
129 &dprc_major_ver,
130 &dprc_minor_ver);
131 if (err)
132 return err;
133 }
134
135 /*
136 * MC API 6.5 introduced a new field in the command used to pass
137 * some flags.
138 * Bit 0 indicates that the child containers are not recursively reset.
139 */
140 if (dprc_major_ver > 6 || (dprc_major_ver == 6 && dprc_minor_ver >= 5))
141 cmdid = DPRC_CMDID_RESET_CONT_V2;
142
143 /* prepare command */
144 cmd.header = mc_encode_cmd_header(cmdid, cmd_flags, token);
145 cmd_params = (struct dprc_cmd_reset_container *)cmd.params;
146 cmd_params->child_container_id = cpu_to_le32(child_container_id);
147 cmd_params->options = cpu_to_le32(options);
148
149 /* send command to mc*/
150 return mc_send_command(mc_io, &cmd);
151 }
152 EXPORT_SYMBOL_GPL(dprc_reset_container);
153
154 /**
155 * dprc_set_irq() - Set IRQ information for the DPRC to trigger an interrupt.
156 * @mc_io: Pointer to MC portal's I/O object
157 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
158 * @token: Token of DPRC object
159 * @irq_index: Identifies the interrupt index to configure
160 * @irq_cfg: IRQ configuration
161 *
162 * Return: '0' on Success; Error code otherwise.
163 */
dprc_set_irq(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token,u8 irq_index,struct dprc_irq_cfg * irq_cfg)164 int dprc_set_irq(struct fsl_mc_io *mc_io,
165 u32 cmd_flags,
166 u16 token,
167 u8 irq_index,
168 struct dprc_irq_cfg *irq_cfg)
169 {
170 struct fsl_mc_command cmd = { 0 };
171 struct dprc_cmd_set_irq *cmd_params;
172
173 /* prepare command */
174 cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_IRQ,
175 cmd_flags,
176 token);
177 cmd_params = (struct dprc_cmd_set_irq *)cmd.params;
178 cmd_params->irq_val = cpu_to_le32(irq_cfg->val);
179 cmd_params->irq_index = irq_index;
180 cmd_params->irq_addr = cpu_to_le64(irq_cfg->paddr);
181 cmd_params->irq_num = cpu_to_le32(irq_cfg->irq_num);
182
183 /* send command to mc*/
184 return mc_send_command(mc_io, &cmd);
185 }
186
187 /**
188 * dprc_set_irq_enable() - Set overall interrupt state.
189 * @mc_io: Pointer to MC portal's I/O object
190 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
191 * @token: Token of DPRC object
192 * @irq_index: The interrupt index to configure
193 * @en: Interrupt state - enable = 1, disable = 0
194 *
195 * Allows GPP software to control when interrupts are generated.
196 * Each interrupt can have up to 32 causes. The enable/disable control's the
197 * overall interrupt state. if the interrupt is disabled no causes will cause
198 * an interrupt.
199 *
200 * Return: '0' on Success; Error code otherwise.
201 */
dprc_set_irq_enable(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token,u8 irq_index,u8 en)202 int dprc_set_irq_enable(struct fsl_mc_io *mc_io,
203 u32 cmd_flags,
204 u16 token,
205 u8 irq_index,
206 u8 en)
207 {
208 struct fsl_mc_command cmd = { 0 };
209 struct dprc_cmd_set_irq_enable *cmd_params;
210
211 /* prepare command */
212 cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_IRQ_ENABLE,
213 cmd_flags, token);
214 cmd_params = (struct dprc_cmd_set_irq_enable *)cmd.params;
215 cmd_params->enable = en & DPRC_ENABLE;
216 cmd_params->irq_index = irq_index;
217
218 /* send command to mc*/
219 return mc_send_command(mc_io, &cmd);
220 }
221
222 /**
223 * dprc_set_irq_mask() - Set interrupt mask.
224 * @mc_io: Pointer to MC portal's I/O object
225 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
226 * @token: Token of DPRC object
227 * @irq_index: The interrupt index to configure
228 * @mask: event mask to trigger interrupt;
229 * each bit:
230 * 0 = ignore event
231 * 1 = consider event for asserting irq
232 *
233 * Every interrupt can have up to 32 causes and the interrupt model supports
234 * masking/unmasking each cause independently
235 *
236 * Return: '0' on Success; Error code otherwise.
237 */
dprc_set_irq_mask(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token,u8 irq_index,u32 mask)238 int dprc_set_irq_mask(struct fsl_mc_io *mc_io,
239 u32 cmd_flags,
240 u16 token,
241 u8 irq_index,
242 u32 mask)
243 {
244 struct fsl_mc_command cmd = { 0 };
245 struct dprc_cmd_set_irq_mask *cmd_params;
246
247 /* prepare command */
248 cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_IRQ_MASK,
249 cmd_flags, token);
250 cmd_params = (struct dprc_cmd_set_irq_mask *)cmd.params;
251 cmd_params->mask = cpu_to_le32(mask);
252 cmd_params->irq_index = irq_index;
253
254 /* send command to mc*/
255 return mc_send_command(mc_io, &cmd);
256 }
257
258 /**
259 * dprc_get_irq_status() - Get the current status of any pending interrupts.
260 * @mc_io: Pointer to MC portal's I/O object
261 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
262 * @token: Token of DPRC object
263 * @irq_index: The interrupt index to configure
264 * @status: Returned interrupts status - one bit per cause:
265 * 0 = no interrupt pending
266 * 1 = interrupt pending
267 *
268 * Return: '0' on Success; Error code otherwise.
269 */
dprc_get_irq_status(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token,u8 irq_index,u32 * status)270 int dprc_get_irq_status(struct fsl_mc_io *mc_io,
271 u32 cmd_flags,
272 u16 token,
273 u8 irq_index,
274 u32 *status)
275 {
276 struct fsl_mc_command cmd = { 0 };
277 struct dprc_cmd_get_irq_status *cmd_params;
278 struct dprc_rsp_get_irq_status *rsp_params;
279 int err;
280
281 /* prepare command */
282 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_IRQ_STATUS,
283 cmd_flags, token);
284 cmd_params = (struct dprc_cmd_get_irq_status *)cmd.params;
285 cmd_params->status = cpu_to_le32(*status);
286 cmd_params->irq_index = irq_index;
287
288 /* send command to mc*/
289 err = mc_send_command(mc_io, &cmd);
290 if (err)
291 return err;
292
293 /* retrieve response parameters */
294 rsp_params = (struct dprc_rsp_get_irq_status *)cmd.params;
295 *status = le32_to_cpu(rsp_params->status);
296
297 return 0;
298 }
299
300 /**
301 * dprc_clear_irq_status() - Clear a pending interrupt's status
302 * @mc_io: Pointer to MC portal's I/O object
303 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
304 * @token: Token of DPRC object
305 * @irq_index: The interrupt index to configure
306 * @status: bits to clear (W1C) - one bit per cause:
307 * 0 = don't change
308 * 1 = clear status bit
309 *
310 * Return: '0' on Success; Error code otherwise.
311 */
dprc_clear_irq_status(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token,u8 irq_index,u32 status)312 int dprc_clear_irq_status(struct fsl_mc_io *mc_io,
313 u32 cmd_flags,
314 u16 token,
315 u8 irq_index,
316 u32 status)
317 {
318 struct fsl_mc_command cmd = { 0 };
319 struct dprc_cmd_clear_irq_status *cmd_params;
320
321 /* prepare command */
322 cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLEAR_IRQ_STATUS,
323 cmd_flags, token);
324 cmd_params = (struct dprc_cmd_clear_irq_status *)cmd.params;
325 cmd_params->status = cpu_to_le32(status);
326 cmd_params->irq_index = irq_index;
327
328 /* send command to mc*/
329 return mc_send_command(mc_io, &cmd);
330 }
331
332 /**
333 * dprc_get_attributes() - Obtains container attributes
334 * @mc_io: Pointer to MC portal's I/O object
335 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
336 * @token: Token of DPRC object
337 * @attr: Returned container attributes
338 *
339 * Return: '0' on Success; Error code otherwise.
340 */
dprc_get_attributes(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token,struct dprc_attributes * attr)341 int dprc_get_attributes(struct fsl_mc_io *mc_io,
342 u32 cmd_flags,
343 u16 token,
344 struct dprc_attributes *attr)
345 {
346 struct fsl_mc_command cmd = { 0 };
347 struct dprc_rsp_get_attributes *rsp_params;
348 int err;
349
350 /* prepare command */
351 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_ATTR,
352 cmd_flags,
353 token);
354
355 /* send command to mc*/
356 err = mc_send_command(mc_io, &cmd);
357 if (err)
358 return err;
359
360 /* retrieve response parameters */
361 rsp_params = (struct dprc_rsp_get_attributes *)cmd.params;
362 attr->container_id = le32_to_cpu(rsp_params->container_id);
363 attr->icid = le32_to_cpu(rsp_params->icid);
364 attr->options = le32_to_cpu(rsp_params->options);
365 attr->portal_id = le32_to_cpu(rsp_params->portal_id);
366
367 return 0;
368 }
369
370 /**
371 * dprc_get_obj_count() - Obtains the number of objects in the DPRC
372 * @mc_io: Pointer to MC portal's I/O object
373 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
374 * @token: Token of DPRC object
375 * @obj_count: Number of objects assigned to the DPRC
376 *
377 * Return: '0' on Success; Error code otherwise.
378 */
dprc_get_obj_count(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token,int * obj_count)379 int dprc_get_obj_count(struct fsl_mc_io *mc_io,
380 u32 cmd_flags,
381 u16 token,
382 int *obj_count)
383 {
384 struct fsl_mc_command cmd = { 0 };
385 struct dprc_rsp_get_obj_count *rsp_params;
386 int err;
387
388 /* prepare command */
389 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_COUNT,
390 cmd_flags, token);
391
392 /* send command to mc*/
393 err = mc_send_command(mc_io, &cmd);
394 if (err)
395 return err;
396
397 /* retrieve response parameters */
398 rsp_params = (struct dprc_rsp_get_obj_count *)cmd.params;
399 *obj_count = le32_to_cpu(rsp_params->obj_count);
400
401 return 0;
402 }
403 EXPORT_SYMBOL_GPL(dprc_get_obj_count);
404
405 /**
406 * dprc_get_obj() - Get general information on an object
407 * @mc_io: Pointer to MC portal's I/O object
408 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
409 * @token: Token of DPRC object
410 * @obj_index: Index of the object to be queried (< obj_count)
411 * @obj_desc: Returns the requested object descriptor
412 *
413 * The object descriptors are retrieved one by one by incrementing
414 * obj_index up to (not including) the value of obj_count returned
415 * from dprc_get_obj_count(). dprc_get_obj_count() must
416 * be called prior to dprc_get_obj().
417 *
418 * Return: '0' on Success; Error code otherwise.
419 */
dprc_get_obj(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token,int obj_index,struct fsl_mc_obj_desc * obj_desc)420 int dprc_get_obj(struct fsl_mc_io *mc_io,
421 u32 cmd_flags,
422 u16 token,
423 int obj_index,
424 struct fsl_mc_obj_desc *obj_desc)
425 {
426 struct fsl_mc_command cmd = { 0 };
427 struct dprc_cmd_get_obj *cmd_params;
428 struct dprc_rsp_get_obj *rsp_params;
429 int err;
430
431 /* prepare command */
432 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ,
433 cmd_flags,
434 token);
435 cmd_params = (struct dprc_cmd_get_obj *)cmd.params;
436 cmd_params->obj_index = cpu_to_le32(obj_index);
437
438 /* send command to mc*/
439 err = mc_send_command(mc_io, &cmd);
440 if (err)
441 return err;
442
443 /* retrieve response parameters */
444 rsp_params = (struct dprc_rsp_get_obj *)cmd.params;
445 obj_desc->id = le32_to_cpu(rsp_params->id);
446 obj_desc->vendor = le16_to_cpu(rsp_params->vendor);
447 obj_desc->irq_count = rsp_params->irq_count;
448 obj_desc->region_count = rsp_params->region_count;
449 obj_desc->state = le32_to_cpu(rsp_params->state);
450 obj_desc->ver_major = le16_to_cpu(rsp_params->version_major);
451 obj_desc->ver_minor = le16_to_cpu(rsp_params->version_minor);
452 obj_desc->flags = le16_to_cpu(rsp_params->flags);
453 strscpy_pad(obj_desc->type, rsp_params->type, 16);
454 strscpy_pad(obj_desc->label, rsp_params->label, 16);
455 return 0;
456 }
457 EXPORT_SYMBOL_GPL(dprc_get_obj);
458
459 /**
460 * dprc_set_obj_irq() - Set IRQ information for object to trigger an interrupt.
461 * @mc_io: Pointer to MC portal's I/O object
462 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
463 * @token: Token of DPRC object
464 * @obj_type: Type of the object to set its IRQ
465 * @obj_id: ID of the object to set its IRQ
466 * @irq_index: The interrupt index to configure
467 * @irq_cfg: IRQ configuration
468 *
469 * Return: '0' on Success; Error code otherwise.
470 */
dprc_set_obj_irq(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token,char * obj_type,int obj_id,u8 irq_index,struct dprc_irq_cfg * irq_cfg)471 int dprc_set_obj_irq(struct fsl_mc_io *mc_io,
472 u32 cmd_flags,
473 u16 token,
474 char *obj_type,
475 int obj_id,
476 u8 irq_index,
477 struct dprc_irq_cfg *irq_cfg)
478 {
479 struct fsl_mc_command cmd = { 0 };
480 struct dprc_cmd_set_obj_irq *cmd_params;
481
482 /* prepare command */
483 cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_OBJ_IRQ,
484 cmd_flags,
485 token);
486 cmd_params = (struct dprc_cmd_set_obj_irq *)cmd.params;
487 cmd_params->irq_val = cpu_to_le32(irq_cfg->val);
488 cmd_params->irq_index = irq_index;
489 cmd_params->irq_addr = cpu_to_le64(irq_cfg->paddr);
490 cmd_params->irq_num = cpu_to_le32(irq_cfg->irq_num);
491 cmd_params->obj_id = cpu_to_le32(obj_id);
492 strscpy_pad(cmd_params->obj_type, obj_type, 16);
493
494 /* send command to mc*/
495 return mc_send_command(mc_io, &cmd);
496 }
497 EXPORT_SYMBOL_GPL(dprc_set_obj_irq);
498
499 /**
500 * dprc_get_obj_region() - Get region information for a specified object.
501 * @mc_io: Pointer to MC portal's I/O object
502 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
503 * @token: Token of DPRC object
504 * @obj_type: Object type as returned in dprc_get_obj()
505 * @obj_id: Unique object instance as returned in dprc_get_obj()
506 * @region_index: The specific region to query
507 * @region_desc: Returns the requested region descriptor
508 *
509 * Return: '0' on Success; Error code otherwise.
510 */
dprc_get_obj_region(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token,char * obj_type,int obj_id,u8 region_index,struct dprc_region_desc * region_desc)511 int dprc_get_obj_region(struct fsl_mc_io *mc_io,
512 u32 cmd_flags,
513 u16 token,
514 char *obj_type,
515 int obj_id,
516 u8 region_index,
517 struct dprc_region_desc *region_desc)
518 {
519 struct fsl_mc_command cmd = { 0 };
520 struct dprc_cmd_get_obj_region *cmd_params;
521 struct dprc_rsp_get_obj_region *rsp_params;
522 int err;
523
524 /*
525 * If the DPRC object version was not yet cached, cache it now.
526 * Otherwise use the already cached value.
527 */
528 if (!dprc_major_ver && !dprc_minor_ver) {
529 err = dprc_get_api_version(mc_io, 0,
530 &dprc_major_ver,
531 &dprc_minor_ver);
532 if (err)
533 return err;
534 }
535
536 if (dprc_major_ver > 6 || (dprc_major_ver == 6 && dprc_minor_ver >= 6)) {
537 /*
538 * MC API version 6.6 changed the size of the MC portals and software
539 * portals to 64K (as implemented by hardware). If older API is in use the
540 * size reported is less (64 bytes for mc portals and 4K for software
541 * portals).
542 */
543
544 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG_V3,
545 cmd_flags, token);
546
547 } else if (dprc_major_ver == 6 && dprc_minor_ver >= 3) {
548 /*
549 * MC API version 6.3 introduced a new field to the region
550 * descriptor: base_address. If the older API is in use then the base
551 * address is set to zero to indicate it needs to be obtained elsewhere
552 * (typically the device tree).
553 */
554 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG_V2,
555 cmd_flags, token);
556 } else {
557 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG,
558 cmd_flags, token);
559 }
560
561 cmd_params = (struct dprc_cmd_get_obj_region *)cmd.params;
562 cmd_params->obj_id = cpu_to_le32(obj_id);
563 cmd_params->region_index = region_index;
564 strscpy_pad(cmd_params->obj_type, obj_type, 16);
565
566 /* send command to mc*/
567 err = mc_send_command(mc_io, &cmd);
568 if (err)
569 return err;
570
571 /* retrieve response parameters */
572 rsp_params = (struct dprc_rsp_get_obj_region *)cmd.params;
573 region_desc->base_offset = le64_to_cpu(rsp_params->base_offset);
574 region_desc->size = le32_to_cpu(rsp_params->size);
575 region_desc->type = rsp_params->type;
576 region_desc->flags = le32_to_cpu(rsp_params->flags);
577 if (dprc_major_ver > 6 || (dprc_major_ver == 6 && dprc_minor_ver >= 3))
578 region_desc->base_address = le64_to_cpu(rsp_params->base_addr);
579 else
580 region_desc->base_address = 0;
581
582 return 0;
583 }
584 EXPORT_SYMBOL_GPL(dprc_get_obj_region);
585
586 /**
587 * dprc_get_api_version - Get Data Path Resource Container API version
588 * @mc_io: Pointer to Mc portal's I/O object
589 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
590 * @major_ver: Major version of Data Path Resource Container API
591 * @minor_ver: Minor version of Data Path Resource Container API
592 *
593 * Return: '0' on Success; Error code otherwise.
594 */
dprc_get_api_version(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 * major_ver,u16 * minor_ver)595 int dprc_get_api_version(struct fsl_mc_io *mc_io,
596 u32 cmd_flags,
597 u16 *major_ver,
598 u16 *minor_ver)
599 {
600 struct fsl_mc_command cmd = { 0 };
601 int err;
602
603 /* prepare command */
604 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_API_VERSION,
605 cmd_flags, 0);
606
607 /* send command to mc */
608 err = mc_send_command(mc_io, &cmd);
609 if (err)
610 return err;
611
612 /* retrieve response parameters */
613 mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
614
615 return 0;
616 }
617
618 /**
619 * dprc_get_container_id - Get container ID associated with a given portal.
620 * @mc_io: Pointer to Mc portal's I/O object
621 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
622 * @container_id: Requested container id
623 *
624 * Return: '0' on Success; Error code otherwise.
625 */
dprc_get_container_id(struct fsl_mc_io * mc_io,u32 cmd_flags,int * container_id)626 int dprc_get_container_id(struct fsl_mc_io *mc_io,
627 u32 cmd_flags,
628 int *container_id)
629 {
630 struct fsl_mc_command cmd = { 0 };
631 int err;
632
633 /* prepare command */
634 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONT_ID,
635 cmd_flags,
636 0);
637
638 /* send command to mc*/
639 err = mc_send_command(mc_io, &cmd);
640 if (err)
641 return err;
642
643 /* retrieve response parameters */
644 *container_id = (int)mc_cmd_read_object_id(&cmd);
645
646 return 0;
647 }
648
649 /**
650 * dprc_get_connection() - Get connected endpoint and link status if connection
651 * exists.
652 * @mc_io: Pointer to MC portal's I/O object
653 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
654 * @token: Token of DPRC object
655 * @endpoint1: Endpoint 1 configuration parameters
656 * @endpoint2: Returned endpoint 2 configuration parameters
657 * @state: Returned link state:
658 * 1 - link is up;
659 * 0 - link is down;
660 * -1 - no connection (endpoint2 information is irrelevant)
661 *
662 * Return: '0' on Success; -ENOTCONN if connection does not exist.
663 */
dprc_get_connection(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token,const struct dprc_endpoint * endpoint1,struct dprc_endpoint * endpoint2,int * state)664 int dprc_get_connection(struct fsl_mc_io *mc_io,
665 u32 cmd_flags,
666 u16 token,
667 const struct dprc_endpoint *endpoint1,
668 struct dprc_endpoint *endpoint2,
669 int *state)
670 {
671 struct dprc_cmd_get_connection *cmd_params;
672 struct dprc_rsp_get_connection *rsp_params;
673 struct fsl_mc_command cmd = { 0 };
674 int err, i;
675
676 /* prepare command */
677 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONNECTION,
678 cmd_flags,
679 token);
680 cmd_params = (struct dprc_cmd_get_connection *)cmd.params;
681 cmd_params->ep1_id = cpu_to_le32(endpoint1->id);
682 cmd_params->ep1_interface_id = cpu_to_le16(endpoint1->if_id);
683 for (i = 0; i < 16; i++)
684 cmd_params->ep1_type[i] = endpoint1->type[i];
685
686 /* send command to mc */
687 err = mc_send_command(mc_io, &cmd);
688 if (err)
689 return -ENOTCONN;
690
691 /* retrieve response parameters */
692 rsp_params = (struct dprc_rsp_get_connection *)cmd.params;
693 endpoint2->id = le32_to_cpu(rsp_params->ep2_id);
694 endpoint2->if_id = le16_to_cpu(rsp_params->ep2_interface_id);
695 *state = le32_to_cpu(rsp_params->state);
696 for (i = 0; i < 16; i++)
697 endpoint2->type[i] = rsp_params->ep2_type[i];
698
699 return 0;
700 }
701