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 strncpy(obj_desc->type, rsp_params->type, 16);
454 obj_desc->type[15] = '\0';
455 strncpy(obj_desc->label, rsp_params->label, 16);
456 obj_desc->label[15] = '\0';
457 return 0;
458 }
459 EXPORT_SYMBOL_GPL(dprc_get_obj);
460
461 /**
462 * dprc_set_obj_irq() - Set IRQ information for object to trigger an interrupt.
463 * @mc_io: Pointer to MC portal's I/O object
464 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
465 * @token: Token of DPRC object
466 * @obj_type: Type of the object to set its IRQ
467 * @obj_id: ID of the object to set its IRQ
468 * @irq_index: The interrupt index to configure
469 * @irq_cfg: IRQ configuration
470 *
471 * Return: '0' on Success; Error code otherwise.
472 */
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)473 int dprc_set_obj_irq(struct fsl_mc_io *mc_io,
474 u32 cmd_flags,
475 u16 token,
476 char *obj_type,
477 int obj_id,
478 u8 irq_index,
479 struct dprc_irq_cfg *irq_cfg)
480 {
481 struct fsl_mc_command cmd = { 0 };
482 struct dprc_cmd_set_obj_irq *cmd_params;
483
484 /* prepare command */
485 cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_OBJ_IRQ,
486 cmd_flags,
487 token);
488 cmd_params = (struct dprc_cmd_set_obj_irq *)cmd.params;
489 cmd_params->irq_val = cpu_to_le32(irq_cfg->val);
490 cmd_params->irq_index = irq_index;
491 cmd_params->irq_addr = cpu_to_le64(irq_cfg->paddr);
492 cmd_params->irq_num = cpu_to_le32(irq_cfg->irq_num);
493 cmd_params->obj_id = cpu_to_le32(obj_id);
494 strncpy(cmd_params->obj_type, obj_type, 16);
495 cmd_params->obj_type[15] = '\0';
496
497 /* send command to mc*/
498 return mc_send_command(mc_io, &cmd);
499 }
500 EXPORT_SYMBOL_GPL(dprc_set_obj_irq);
501
502 /**
503 * dprc_get_obj_region() - Get region information for a specified object.
504 * @mc_io: Pointer to MC portal's I/O object
505 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
506 * @token: Token of DPRC object
507 * @obj_type: Object type as returned in dprc_get_obj()
508 * @obj_id: Unique object instance as returned in dprc_get_obj()
509 * @region_index: The specific region to query
510 * @region_desc: Returns the requested region descriptor
511 *
512 * Return: '0' on Success; Error code otherwise.
513 */
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)514 int dprc_get_obj_region(struct fsl_mc_io *mc_io,
515 u32 cmd_flags,
516 u16 token,
517 char *obj_type,
518 int obj_id,
519 u8 region_index,
520 struct dprc_region_desc *region_desc)
521 {
522 struct fsl_mc_command cmd = { 0 };
523 struct dprc_cmd_get_obj_region *cmd_params;
524 struct dprc_rsp_get_obj_region *rsp_params;
525 int err;
526
527 /*
528 * If the DPRC object version was not yet cached, cache it now.
529 * Otherwise use the already cached value.
530 */
531 if (!dprc_major_ver && !dprc_minor_ver) {
532 err = dprc_get_api_version(mc_io, 0,
533 &dprc_major_ver,
534 &dprc_minor_ver);
535 if (err)
536 return err;
537 }
538
539 if (dprc_major_ver > 6 || (dprc_major_ver == 6 && dprc_minor_ver >= 6)) {
540 /*
541 * MC API version 6.6 changed the size of the MC portals and software
542 * portals to 64K (as implemented by hardware). If older API is in use the
543 * size reported is less (64 bytes for mc portals and 4K for software
544 * portals).
545 */
546
547 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG_V3,
548 cmd_flags, token);
549
550 } else if (dprc_major_ver == 6 && dprc_minor_ver >= 3) {
551 /*
552 * MC API version 6.3 introduced a new field to the region
553 * descriptor: base_address. If the older API is in use then the base
554 * address is set to zero to indicate it needs to be obtained elsewhere
555 * (typically the device tree).
556 */
557 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG_V2,
558 cmd_flags, token);
559 } else {
560 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG,
561 cmd_flags, token);
562 }
563
564 cmd_params = (struct dprc_cmd_get_obj_region *)cmd.params;
565 cmd_params->obj_id = cpu_to_le32(obj_id);
566 cmd_params->region_index = region_index;
567 strncpy(cmd_params->obj_type, obj_type, 16);
568 cmd_params->obj_type[15] = '\0';
569
570 /* send command to mc*/
571 err = mc_send_command(mc_io, &cmd);
572 if (err)
573 return err;
574
575 /* retrieve response parameters */
576 rsp_params = (struct dprc_rsp_get_obj_region *)cmd.params;
577 region_desc->base_offset = le64_to_cpu(rsp_params->base_offset);
578 region_desc->size = le32_to_cpu(rsp_params->size);
579 region_desc->type = rsp_params->type;
580 region_desc->flags = le32_to_cpu(rsp_params->flags);
581 if (dprc_major_ver > 6 || (dprc_major_ver == 6 && dprc_minor_ver >= 3))
582 region_desc->base_address = le64_to_cpu(rsp_params->base_addr);
583 else
584 region_desc->base_address = 0;
585
586 return 0;
587 }
588 EXPORT_SYMBOL_GPL(dprc_get_obj_region);
589
590 /**
591 * dprc_get_api_version - Get Data Path Resource Container API version
592 * @mc_io: Pointer to Mc portal's I/O object
593 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
594 * @major_ver: Major version of Data Path Resource Container API
595 * @minor_ver: Minor version of Data Path Resource Container API
596 *
597 * Return: '0' on Success; Error code otherwise.
598 */
dprc_get_api_version(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 * major_ver,u16 * minor_ver)599 int dprc_get_api_version(struct fsl_mc_io *mc_io,
600 u32 cmd_flags,
601 u16 *major_ver,
602 u16 *minor_ver)
603 {
604 struct fsl_mc_command cmd = { 0 };
605 int err;
606
607 /* prepare command */
608 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_API_VERSION,
609 cmd_flags, 0);
610
611 /* send command to mc */
612 err = mc_send_command(mc_io, &cmd);
613 if (err)
614 return err;
615
616 /* retrieve response parameters */
617 mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
618
619 return 0;
620 }
621
622 /**
623 * dprc_get_container_id - Get container ID associated with a given portal.
624 * @mc_io: Pointer to Mc portal's I/O object
625 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
626 * @container_id: Requested container id
627 *
628 * Return: '0' on Success; Error code otherwise.
629 */
dprc_get_container_id(struct fsl_mc_io * mc_io,u32 cmd_flags,int * container_id)630 int dprc_get_container_id(struct fsl_mc_io *mc_io,
631 u32 cmd_flags,
632 int *container_id)
633 {
634 struct fsl_mc_command cmd = { 0 };
635 int err;
636
637 /* prepare command */
638 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONT_ID,
639 cmd_flags,
640 0);
641
642 /* send command to mc*/
643 err = mc_send_command(mc_io, &cmd);
644 if (err)
645 return err;
646
647 /* retrieve response parameters */
648 *container_id = (int)mc_cmd_read_object_id(&cmd);
649
650 return 0;
651 }
652
653 /**
654 * dprc_get_connection() - Get connected endpoint and link status if connection
655 * exists.
656 * @mc_io: Pointer to MC portal's I/O object
657 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
658 * @token: Token of DPRC object
659 * @endpoint1: Endpoint 1 configuration parameters
660 * @endpoint2: Returned endpoint 2 configuration parameters
661 * @state: Returned link state:
662 * 1 - link is up;
663 * 0 - link is down;
664 * -1 - no connection (endpoint2 information is irrelevant)
665 *
666 * Return: '0' on Success; -ENOTCONN if connection does not exist.
667 */
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)668 int dprc_get_connection(struct fsl_mc_io *mc_io,
669 u32 cmd_flags,
670 u16 token,
671 const struct dprc_endpoint *endpoint1,
672 struct dprc_endpoint *endpoint2,
673 int *state)
674 {
675 struct dprc_cmd_get_connection *cmd_params;
676 struct dprc_rsp_get_connection *rsp_params;
677 struct fsl_mc_command cmd = { 0 };
678 int err, i;
679
680 /* prepare command */
681 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONNECTION,
682 cmd_flags,
683 token);
684 cmd_params = (struct dprc_cmd_get_connection *)cmd.params;
685 cmd_params->ep1_id = cpu_to_le32(endpoint1->id);
686 cmd_params->ep1_interface_id = cpu_to_le16(endpoint1->if_id);
687 for (i = 0; i < 16; i++)
688 cmd_params->ep1_type[i] = endpoint1->type[i];
689
690 /* send command to mc */
691 err = mc_send_command(mc_io, &cmd);
692 if (err)
693 return -ENOTCONN;
694
695 /* retrieve response parameters */
696 rsp_params = (struct dprc_rsp_get_connection *)cmd.params;
697 endpoint2->id = le32_to_cpu(rsp_params->ep2_id);
698 endpoint2->if_id = le16_to_cpu(rsp_params->ep2_interface_id);
699 *state = le32_to_cpu(rsp_params->state);
700 for (i = 0; i < 16; i++)
701 endpoint2->type[i] = rsp_params->ep2_type[i];
702
703 return 0;
704 }
705