1 /*
2 * Copyright (C) 2018-2019 Texas Instruments Incorporated
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *
11 * Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the
14 * distribution.
15 *
16 * Neither the name of Texas Instruments Incorporated nor the names of
17 * its contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 *
32 */
33 /**
34 * \ingroup DRV_SCICLIENT_MODULE
35 * \defgroup SCICLIENT_FMW_RM_IF Sciclient RM API Interface
36 *
37 * The DMSC firmware Resource Management (RM) (sub) system manages SoC shared
38 * resources. RM manages access and configuration of shared resources amongst
39 * SoC processing entities. RM provides a set of interfaces over which SoC
40 * processing entities can allocate, configure, and free shared resources.
41 *
42 *
43 * @{
44 */
45 /**
46 * \file sciclient_rm.h
47 *
48 * \brief This file contains the definition of all the message IDs, message
49 * formats to be able to interact with the System Controller firmware
50 * for resource management.
51 */
53 #ifndef SCICLIENT_RM_H_
54 #define SCICLIENT_RM_H_
56 /* ========================================================================== */
57 /* Include Files */
58 /* ========================================================================== */
60 #include <stdint.h>
62 #ifdef __cplusplus
63 extern "C" {
64 #endif
66 /* ========================================================================== */
67 /* Macros & Typedefs */
68 /* ========================================================================== */
70 /* None */
72 /* ========================================================================== */
73 /* Structure Declarations */
74 /* ========================================================================== */
76 /* None */
78 /* ========================================================================== */
79 /* Function Declarations */
80 /* ========================================================================== */
82 /**
83 * \brief Retrieves a host's assigned range for a resource
84 *
85 * Returns the range for a unique resource type assigned to the specified host,
86 * or secondary host. The unique resource type is formed by combining the
87 * 10 LSB of type and the 6 LSB of subtype.
88 *
89 * Unique types which do not map to an SoC resource will not be NACK'd. Instead
90 * the tisci_msg_rm_get_resource_range_resp range_start and range_num values are
91 * zeroed. This provides a known response mechanism across varied SoCs.
92 *
93 * \n<b>Message</b>: #TISCI_MSG_RM_GET_RESOURCE_RANGE
94 * \n<b>Request</b>: #tisci_msg_rm_get_resource_range_req
95 * \n<b>Response</b>: #tisci_msg_rm_get_resource_range_resp
96 *
97 * \param req Pointer to resource range get payload
98 *
99 * \param resp Pointer to resource range response payload
100 *
101 * \param timeout Gives a sense of how long to wait for the operation.
102 * Refer \ref Sciclient_ServiceOperationTimeout.
103 *
104 * \return CSL_PASS on success, else failure
105 */
106 int32_t Sciclient_rmGetResourceRange(
107 const struct tisci_msg_rm_get_resource_range_req *req,
108 struct tisci_msg_rm_get_resource_range_resp *resp,
109 uint32_t timeout);
111 /**
112 * \brief Configures a peripheral to processor IRQ
113 *
114 * Configures an interrupt route between the peripheral and host processor
115 * specified within the #tisci_msg_rm_irq_set_req payload. The interrupt destination
116 * is either the processor sending the request, or the secondary host if it's
117 * defined as a valid host. The shortest route between the peripheral and the
118 * host processor is programmed. Interrupts are not configured on the host
119 * processor. Information received from the tisci_msg_rm_irq_set_resp
120 * message must be used by the host to complete hookup of the irq.
121 *
122 * \n<b>Message</b>: #TISCI_MSG_RM_IRQ_SET
123 * \n<b>Request</b>: #tisci_msg_rm_irq_set_req
124 * \n<b>Response</b>: #tisci_msg_rm_irq_set_resp
125 *
126 * \param req Pointer to interrupt route set payload
127 *
128 * \param resp Pointer to interrupt route set response payload
129 *
130 * \param timeout Gives a sense of how long to wait for the operation.
131 * Refer \ref Sciclient_ServiceOperationTimeout.
132 *
133 * \return CSL_PASS on success, else failure
134 */
135 int32_t Sciclient_rmIrqSet(const struct tisci_msg_rm_irq_set_req *req,
136 const struct tisci_msg_rm_irq_set_resp *resp,
137 uint32_t timeout);
139 /**
140 * \brief Releases a peripheral to processor IRQ
141 *
142 * Releases a previously configured interrupt route between a peripheral and
143 * host processor. The interrupt destination is either the processor sending
144 * the request, or the secondary host if it's defined as a valid host.
145 *
146 * \n<b>Message</b>: #TISCI_MSG_RM_IRQ_RELEASE
147 * \n<b>Request</b>: #tisci_msg_rm_irq_release_req
148 *
149 * \param req Pointer to interrupt route release payload
150 *
151 * \param timeout Gives a sense of how long to wait for the operation.
152 * Refer \ref Sciclient_ServiceOperationTimeout.
153 *
154 * \return CSL_PASS on success, else failure
155 */
156 int32_t Sciclient_rmIrqRelease(const struct tisci_msg_rm_irq_release_req *req,
157 uint32_t timeout);
159 /**
160 * \brief Configures a Navigator Subsystem ring
161 *
162 * Configures the non-real-time registers of a Navigator Subsystem ring.
163 * The ring index must be assigned to the host defined in the TISCI header via
164 * the RM board configuration resource assignment range list.
165 *
166 * \n<b>Message</b>: #TISCI_MSG_RM_RING_CFG
167 * \n<b>Request</b>: #tisci_msg_rm_ring_cfg_req
168 * \n<b>Response</b>: #tisci_msg_rm_ring_cfg_resp
169 *
170 * \param req Pointer to Ring Accelerator configure payload
171 *
172 * \param resp Pointer to Ring Accelerator configure response
173 * payload
174 *
175 * \param timeout Gives a sense of how long to wait for the operation.
176 * Refer \ref Sciclient_ServiceOperationTimeout.
177 *
178 * \return CSL_PASS on success, else failure
179 */
180 int32_t Sciclient_rmRingCfg(const struct tisci_msg_rm_ring_cfg_req *req,
181 const struct tisci_msg_rm_ring_cfg_resp *resp,
182 uint32_t timeout);
184 /**
185 * \brief Get Navigator Subsystem ring's non-real-time register configuration
186 *
187 * Gets the configuration of the non-real-time register fields of a ring. The
188 * host, or a supervisor of the host, who owns the ring must be the requesting
189 * host. The values of the non-real-time registers are returned in
190 * #tisci_msg_rm_ring_get_cfg_resp. The reset_cfg parameter is used to
191 * request either the existing non-real-time register values or the hardware
192 * reset values for the ring's register fields.
193 *
194 * \n<b>Message</b>: #TISCI_MSG_RM_RING_GET_CFG
195 * \n<b>Request</b>: #tisci_msg_rm_ring_get_cfg_req
196 * \n<b>Response</b>: #tisci_msg_rm_ring_get_cfg_resp
197 *
198 * \param req Pointer to Ring Accelerator get config payload
199 *
200 * \param resp Pointer to Ring Accelerator get config response
201 * payload
202 *
203 * \param timeout Gives a sense of how long to wait for the operation.
204 * Refer \ref Sciclient_ServiceOperationTimeout.
205 *
206 * \return CSL_PASS on success, else failure
207 */
208 int32_t Sciclient_rmRingGetCfg(const struct tisci_msg_rm_ring_get_cfg_req *req,
209 struct tisci_msg_rm_ring_get_cfg_resp *resp,
210 uint32_t timeout);
212 /**
213 * \brief Configures a Navigator Subsystem ring monitor
214 *
215 * Configures the non-real-time registers of a Navigator Subsystem ring
216 * monitor.
217 * The ring monitor index must be assigned to the host defined in the
218 * TISCI header via the RM board configuration resource assignment range list.
219 * Also, the ring being monitored must be assigned to the same host as
220 * the ring monitor
221 *
222 * \n<b>Message</b>: #TISCI_MSG_RM_RING_MON_CFG
223 * \n<b>Request</b>: #tisci_msg_rm_ring_mon_cfg_req
224 * \n<b>Response</b>: #tisci_msg_rm_ring_mon_cfg_resp
225 *
226 * \param req Pointer to Ring monitor configure payload
227 *
228 * \param resp Pointer to Ring monitor configure response
229 * payload
230 *
231 * \param timeout Gives a sense of how long to wait for the operation.
232 * Refer \ref Sciclient_ServiceOperationTimeout.
233 *
234 * \return CSL_PASS on success, else failure
235 */
236 int32_t Sciclient_rmRingMonCfg(const struct tisci_msg_rm_ring_mon_cfg_req *req,
237 const struct tisci_msg_rm_ring_mon_cfg_resp *resp,
238 uint32_t timeout);
240 /**
241 * \brief Configures Navigator Subsystem UDMAP GCFG region
242 *
243 * Configures a Navigator Subsystem UDMAP global configuration region.
244 * Configures the non-real-time registers of a Navigator Subsystem UDMAP
245 * global configuration region. The register fields specified as valid for
246 * programming must be assigned to the host defined in the TISCI header via the
247 * RM board configuration resource assignment array.
248 *
249 * \n<b>Message</b>: #TISCI_MSG_RM_UDMAP_GCFG_CFG
250 * \n<b>Request</b>: #tisci_msg_rm_udmap_gcfg_cfg_req
251 * \n<b>Response</b>: #tisci_msg_rm_udmap_gcfg_cfg_resp
252 *
253 * \param req Pointer to UDMAP GCFG configure payload
254 *
255 * \param resp Pointer to UDMAP GCFG configure response
256 * payload
257 *
258 * \param timeout Gives a sense of how long to wait for the operation.
259 * Refer \ref Sciclient_ServiceOperationTimeout.
260 *
261 * \return CSL_PASS on success, else failure
262 */
263 int32_t Sciclient_rmUdmapGcfgCfg(
264 const struct tisci_msg_rm_udmap_gcfg_cfg_req *req,
265 const struct tisci_msg_rm_udmap_gcfg_cfg_resp *resp,
266 uint32_t timeout);
268 /**
269 * \brief Get Navigator Subsystem UDMAP GCFG non-real-time
270 * register configuration
271 *
272 * Get Navigator Subsystem UDMAP global configuration's non-real-time
273 * register configuration. Gets the configuration of the non-real-time register
274 * fields of a UDMAP's global configuration. The host, or a supervisor of the
275 * host, who owns the gcfg region must be the requesting host. The values of
276 * the non-real-time registers are returned in
277 * \ref tisci_msg_rm_udmap_gcfg_get_cfg_resp. The reset_cfg parameter is used
278 * to request either the existing non-real-time register values or the hardware
279 * reset values for the UDMAP's global configuration register fields.
280 *
281 * \n<b>Message</b>: #TISCI_MSG_RM_UDMAP_GCFG_GET_CFG
282 * \n<b>Request</b>: #tisci_msg_rm_udmap_gcfg_get_cfg_req
283 * \n<b>Response</b>: #tisci_msg_rm_udmap_gcfg_get_cfg_resp
284 *
285 * \param req Pointer to UDMAP GCFG get config payload
286 *
287 * \param resp Pointer to UDMAP GCFG get config response
288 * payload
289 *
290 * \param timeout Gives a sense of how long to wait for the operation.
291 * Refer \ref Sciclient_ServiceOperationTimeout.
292 *
293 * \return CSL_PASS on success, else failure
294 */
295 int32_t Sciclient_rmUdmapGcfgGetCfg(
296 const struct tisci_msg_rm_udmap_gcfg_get_cfg_req *req,
297 struct tisci_msg_rm_udmap_gcfg_get_cfg_resp *resp,
298 uint32_t timeout);
300 /**
301 * \brief Configures a Navigator Subsystem UDMAP transmit channel
302 *
303 * Configures the non-real-time registers of a Navigator Subsystem UDMAP
304 * transmit channel. The channel index must be assigned to the host defined
305 * in the TISCI header via the RM board configuration resource assignment
306 * range list.
307 *
308 * \n<b>Message</b>: #TISCI_MSG_RM_UDMAP_TX_CH_CFG
309 * \n<b>Request</b>: #tisci_msg_rm_udmap_tx_ch_cfg_req
310 * \n<b>Response</b>: #tisci_msg_rm_udmap_tx_ch_cfg_resp
311 *
312 * \param req Pointer to UDMAP Tx channel configure payload
313 *
314 * \param resp Pointer to UDMAP Tx channel configure response
315 * payload
316 *
317 * \param timeout Gives a sense of how long to wait for the operation.
318 * Refer \ref Sciclient_ServiceOperationTimeout.
319 *
320 * \return CSL_PASS on success, else failure
321 */
322 int32_t Sciclient_rmUdmapTxChCfg(
323 const struct tisci_msg_rm_udmap_tx_ch_cfg_req *req,
324 const struct tisci_msg_rm_udmap_tx_ch_cfg_resp *resp,
325 uint32_t timeout);
327 /**
328 * \brief Get Navigator Subsystem UDMAP transmit channel's non-real-time
329 * register configuration
330 *
331 * Gets the configuration of the non-real-time register fields of a UDMAP
332 * transmit channel. The host, or a supervisor of the host, who owns the
333 * channel must be the requesting host. The values of the non-real-time
334 * registers are returned in #tisci_msg_rm_udmap_tx_ch_get_cfg_resp.
335 * The reset_cfg parameter is used to request either the existing
336 * non-real-time register values or the hardware reset values for the UDMAP
337 * transmit channel's register fields.
338 *
339 * \n<b>Message</b>: #TISCI_MSG_RM_UDMAP_TX_CH_GET_CFG
340 * \n<b>Request</b>: #tisci_msg_rm_udmap_tx_ch_get_cfg_req
341 * \n<b>Response</b>: #tisci_msg_rm_udmap_tx_ch_get_cfg_resp
342 *
343 * \param req Pointer to UDMAP Tx channel get config payload
344 *
345 * \param resp Pointer to UDMAP Tx channel get config response
346 * payload
347 *
348 * \param timeout Gives a sense of how long to wait for the operation.
349 * Refer \ref Sciclient_ServiceOperationTimeout.
350 *
351 * \return CSL_PASS on success, else failure
352 */
353 int32_t Sciclient_rmUdmapTxChGetCfg(
354 const struct tisci_msg_rm_udmap_tx_ch_get_cfg_req *req,
355 struct tisci_msg_rm_udmap_tx_ch_get_cfg_resp *resp,
356 uint32_t timeout);
358 /**
359 * \brief Configures a Navigator Subsystem UDMAP receive channel
360 *
361 * Configures the non-real-time registers of a Navigator Subsystem UDMAP
362 * receive channel. The channel index must be assigned to the host defined
363 * in the TISCI header via the RM board configuration resource assignment
364 * range list.
365 *
366 * \n<b>Message</b>: #TISCI_MSG_RM_UDMAP_RX_CH_CFG
367 * \n<b>Request</b>: #tisci_msg_rm_udmap_rx_ch_cfg_req
368 * \n<b>Response</b>: #tisci_msg_rm_udmap_rx_ch_cfg_resp
369 *
370 * \param req Pointer to UDMAP Rx channel configure payload
371 *
372 * \param resp Pointer to UDMAP Rx channel configure response
373 * payload
374 *
375 * \param timeout Gives a sense of how long to wait for the operation.
376 * Refer \ref Sciclient_ServiceOperationTimeout.
377 *
378 * \return CSL_PASS on success, else failure
379 */
380 int32_t Sciclient_rmUdmapRxChCfg(
381 const struct tisci_msg_rm_udmap_rx_ch_cfg_req *req,
382 const struct tisci_msg_rm_udmap_rx_ch_cfg_resp *resp,
383 uint32_t timeout);
385 /**
386 * \brief Get Navigator Subsystem UDMAP receive channel's non-real-time
387 * register configuration
388 *
389 * Gets the configuration of the non-real-time register fields of a UDMAP
390 * receive channel. The host, or a supervisor of the host, who owns the
391 * channel must be the requesting host. The values of the non-real-time
392 * registers are returned in #tisci_msg_rm_udmap_rx_ch_get_cfg_resp.
393 * The reset_cfg parameter is used to request either the existing
394 * non-real-time register values or the hardware reset values for the UDMAP
395 * receive channel's register fields.
396 *
397 * \n<b>Message</b>: #TISCI_MSG_RM_UDMAP_RX_CH_GET_CFG
398 * \n<b>Request</b>: #tisci_msg_rm_udmap_rx_ch_get_cfg_req
399 * \n<b>Response</b>: #tisci_msg_rm_udmap_rx_ch_get_cfg_resp
400 *
401 * \param req Pointer to UDMAP Rx channel get config payload
402 *
403 * \param resp Pointer to UDMAP Rx channel get config response
404 * payload
405 *
406 * \param timeout Gives a sense of how long to wait for the operation.
407 * Refer \ref Sciclient_ServiceOperationTimeout.
408 *
409 * \return CSL_PASS on success, else failure
410 */
411 int32_t Sciclient_rmUdmapRxChGetCfg(
412 const struct tisci_msg_rm_udmap_rx_ch_get_cfg_req *req,
413 struct tisci_msg_rm_udmap_rx_ch_get_cfg_resp *resp,
414 uint32_t timeout);
416 /**
417 * \brief Configures a Navigator Subsystem UDMAP receive flow
418 *
419 * Configures a Navigator Subsystem UDMAP receive flow's registers.
420 * Configuration does not include the flow registers which handle size-based
421 * free descriptor queue routing. The
422 * #tisci_msg_rm_udmap_flow_size_thresh_cfg_req message is used to
423 * configure register fields related to size based free descriptor queues.
424 *
425 * The flow index must be assigned to the host defined in the TISCI header via
426 * the RM board configuration resource assignment range list.
427 *
428 * It's the user's responsibility to make sure any receive channels using the
429 * flow are disabled when changing the receive flow configuration. Otherwise,
430 * unknown operation may occur.
431 *
432 * \n<b>Message</b>: #TISCI_MSG_RM_UDMAP_FLOW_CFG
433 * \n<b>Request</b>: #tisci_msg_rm_udmap_flow_cfg_req
434 * \n<b>Response</b>: #tisci_msg_rm_udmap_flow_cfg_resp
435 *
436 * \param req Pointer to UDMAP Rx flow configure payload
437 *
438 * \param resp Pointer to UDMAP Rx flow configure response
439 * payload
440 *
441 * \param timeout Gives a sense of how long to wait for the operation.
442 * Refer \ref Sciclient_ServiceOperationTimeout.
443 *
444 * \return CSL_PASS on success, else failure
445 */
446 int32_t Sciclient_rmUdmapFlowCfg(
447 const struct tisci_msg_rm_udmap_flow_cfg_req *req,
448 const struct tisci_msg_rm_udmap_flow_cfg_resp *resp,
449 uint32_t timeout);
451 /**
452 * \brief UDMAP receive flow get configuration response message
453 *
454 * Response received by host processor after RM has handled
455 * #tisci_msg_rm_udmap_flow_get_cfg_req. The response contains
456 * the receive flow's register values.
457 *
458 * \n<b>Message</b>: #TISCI_MSG_RM_UDMAP_FLOW_GET_CFG
459 * \n<b>Request</b>: #tisci_msg_rm_udmap_flow_get_cfg_req
460 * \n<b>Response</b>: #tisci_msg_rm_udmap_flow_get_cfg_resp
461 *
462 * \param req Pointer to UDMAP Rx flow get config payload
463 *
464 * \param resp Pointer to UDMAP Rx flow get config response
465 * payload
466 *
467 * \param timeout Gives a sense of how long to wait for the operation.
468 * Refer \ref Sciclient_ServiceOperationTimeout.
469 *
470 * \return CSL_PASS on success, else failure
471 */
472 int32_t Sciclient_rmUdmapFlowGetCfg(
473 const struct tisci_msg_rm_udmap_flow_get_cfg_req *req,
474 struct tisci_msg_rm_udmap_flow_get_cfg_resp *resp,
475 uint32_t timeout);
477 /**
478 * \brief Configures a Navigator Subsystem UDMAP receive flow's size threshold
479 * fields.
480 *
481 * Configures a Navigator Subsystem UDMAP receive flow's size threshold fields
482 *
483 * The flow index must be assigned to the host defined in the TISCI header via
484 * the RM board configuration resource assignment range list.
485 *
486 * It's the user's responsibility to make sure any receive channels using the
487 * flow are disabled when changing the receive flow configuration. Otherwise,
488 * unknown operation may occur.
489 *
490 * \n<b>Message</b>: #TISCI_MSG_RM_UDMAP_FLOW_SIZE_THRESH_CFG
491 * \n<b>Request</b>: #tisci_msg_rm_udmap_flow_size_thresh_cfg_req
492 * \n<b>Response</b>: #tisci_msg_rm_udmap_flow_size_thresh_cfg_resp
493 *
494 * \param req Pointer to UDMAP Rx flow size threshold based free
495 * queue routing configure payload
496 *
497 * \param resp Pointer to UDMAP Rx flow size threshold based free
498 * queue routing configure response payload
499 *
500 * \param timeout Gives a sense of how long to wait for the operation.
501 * Refer \ref Sciclient_ServiceOperationTimeout.
502 *
503 * \return CSL_PASS on success, else failure
504 */
505 int32_t Sciclient_rmUdmapFlowSizeThreshCfg(
506 const struct tisci_msg_rm_udmap_flow_size_thresh_cfg_req *req,
507 const struct tisci_msg_rm_udmap_flow_size_thresh_cfg_resp *resp,
508 uint32_t timeout);
510 /**
511 * \brief Get Navigator Subsystem UDMAP receive flow's non-real-time
512 * size threshold based queue routing register configuration
513 *
514 * Gets the configuration of the non-real-time register fields of a UDMAP
515 * receive flow's size threshold routing registers. The host, or a supervisor
516 * of the host, who owns the flow must be the requesting host. The values of
517 * the non-real-time registers are returned in
518 * #tisci_msg_rm_udmap_flow_size_thresh_get_cfg_resp.
519 * The reset_cfg parameter is used to request either the existing
520 * non-real-time register values or the hardware reset values for the UDMAP
521 * flow's register fields.
522 *
523 * \n<b>Message</b>: #TISCI_MSG_RM_UDMAP_FLOW_SIZE_THRESH_GET_CFG
524 * \n<b>Request</b>: #tisci_msg_rm_udmap_flow_size_thresh_get_cfg_req
525 * \n<b>Response</b>: #tisci_msg_rm_udmap_flow_size_thresh_get_cfg_resp
526 *
527 * \param req Pointer to UDMAP Rx flow size threshold based free
528 * queue routing get config payload
529 *
530 * \param resp Pointer to UDMAP Rx flow size threshold based free
531 * queue routing get config response payload
532 *
533 * \param timeout Gives a sense of how long to wait for the operation.
534 * Refer \ref Sciclient_ServiceOperationTimeout.
535 *
536 * \return CSL_PASS on success, else failure
537 */
538 int32_t Sciclient_rmUdmapFlowSizeThreshGetCfg(
539 const struct tisci_msg_rm_udmap_flow_size_thresh_get_cfg_req *req,
540 struct tisci_msg_rm_udmap_flow_size_thresh_get_cfg_resp *resp,
541 uint32_t timeout);
543 /**
544 * \brief Pairs a PSI-L source thread and destination threads
545 *
546 * Pairs a PSI-L source thread to a PSI-L destination thread. The pairing
547 * occurs only if both threads are unpaired at the time of the pairing request.
548 * The source thread's width and credit count parameters are set to the
549 * destination thread's capabilities. Both the source and destination threads
550 * are non-real-time enabled on successful pairing.
551 *
552 * The PSI-L configuration proxy used to pair the source and destination
553 * threads is based on the Navigator Subsystem specified by #tisci_msg_rm_psil_pair_req::nav_id
554 *
555 * \n<b>Message</b>: #TISCI_MSG_RM_PSIL_PAIR
556 * \n<b>Request</b>: #tisci_msg_rm_psil_pair_req
557 *
558 * \param req Pointer to PSI-L thread pair payload
559 *
560 * \param timeout Gives a sense of how long to wait for the operation.
561 * Refer \ref Sciclient_ServiceOperationTimeout.
562 *
563 * \return CSL_PASS on success, else failure
564 */
565 int32_t Sciclient_rmPsilPair(const struct tisci_msg_rm_psil_pair_req *req,
566 uint32_t timeout);
568 /**
569 * \brief Unpairs a PSI-L source thread and destination thread
570 *
571 * Unpairs a PSI-L source thread from a PSI-L destination thread. The
572 * source thread's width and credit count parameters are cleared. Both the
573 * source and destination threads are non-real-time disabled on successful
574 * unpairing.
575 *
576 * \n<b>Message</b>: #TISCI_MSG_RM_PSIL_UNPAIR
577 * \n<b>Request</b>: #tisci_msg_rm_psil_unpair_req
578 *
579 * \param req Pointer to PSI-L thread unpair payload
580 *
581 * \param timeout Gives a sense of how long to wait for the operation.
582 * Refer \ref Sciclient_ServiceOperationTimeout.
583 *
584 * \return CSL_PASS on success, else failure
585 */
586 int32_t Sciclient_rmPsilUnpair(const struct tisci_msg_rm_psil_unpair_req *req,
587 uint32_t timeout);
589 /**
590 * \brief Reads a PSI-L thread real-time register
591 *
592 * Reads the specified thread real-time configuration register from a
593 * specified PSI-L thread using the PSI-L configuration proxy.
594 *
595 * \n<b>Message</b>: #TISCI_MSG_RM_PSIL_READ
596 * \n<b>Request</b>: #tisci_msg_rm_psil_read_req
597 *
598 * \param req Pointer to PSI-L thread read payload
599 *
600 * \param resp Pointer to PSI-L thread read response payload
601 *
602 * \param timeout Gives a sense of how long to wait for the operation.
603 * Refer \ref Sciclient_ServiceOperationTimeout.
604 *
605 * \return CSL_PASS on success, else failure
606 */
607 int32_t Sciclient_rmPsilRead(const struct tisci_msg_rm_psil_read_req *req,
608 struct tisci_msg_rm_psil_read_resp *resp,
609 uint32_t timeout);
611 /**
612 * \brief Writes a PSI-L thread real-time register
613 *
614 * Writes the specified thread real-time configuration register to a
615 * specified PSI-L thread using the PSI-L configuration proxy.
616 *
617 * \n<b>Message</b>: #TISCI_MSG_RM_PSIL_WRITE
618 * \n<b>Request</b>: #tisci_msg_rm_psil_write_req
619 *
620 * \param req Pointer to PSI-L thread write payload
621 *
622 * \param timeout Gives a sense of how long to wait for the operation.
623 * Refer \ref Sciclient_ServiceOperationTimeout.
624 *
625 * \return CSL_PASS on success, else failure
626 */
627 int32_t Sciclient_rmPsilWrite(const struct tisci_msg_rm_psil_write_req *req,
628 uint32_t timeout);
630 #ifdef __cplusplus
631 }
632 #endif
634 #endif /* #ifndef SCICLIENT_RM_H_ */
636 /* @} */