Add Govind's changes to pdk platform lib for new HSR4/interconnect boards
[processor-sdk/performance-audio-sr.git] / pdk_k2g_1_0_1 / packages / ti / platform / resource_mgr.h
2 /*
3  *   @file  resource_mgr.h
4  *
5  *   @brief
6  *      Resource Manager Common Definitions. The Resource Manager defines
7  *              a set of APIs and definitions for managing platform resources (e.g.
8  *              Interrupts) and initializing and using the PA, QMSS and CPPI
9  *              subsystems.
10  *
11  */
13 /****************************************************************************
14  * Copyright (c) 2011 Texas Instruments Incorporated - http://www.ti.com
15  *
16  *  Redistribution and use in source and binary forms, with or without
17  *  modification, are permitted provided that the following conditions
18  *  are met:
19  *    Redistributions of source code must retain the above copyright
20  *    notice, this list of conditions and the following disclaimer.
21  *
22  *    Redistributions in binary form must reproduce the above copyright
23  *    notice, this list of conditions and the following disclaimer in the
24  *    documentation and/or other materials provided with the
25  *    distribution.
26  *
27  *    Neither the name of Texas Instruments Incorporated nor the names of
28  *    its contributors may be used to endorse or promote products derived
29  *    from this software without specific prior written permission.
30  *
31  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
34  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
36  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
37  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
38  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
39  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
40  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
41  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42  *
43  *****************************************************************************/
46 #ifndef _RESOURCE_MGR_H
47 #define _RESOURCE_MGR_H  /* #defined if this .h file has been included */
49 /**
50  * @mainpage Resource Manager
51  The Resource Manager defines a set of APIs and definitions for managing platform resources (e.g. Interrupts) and
52  initializing and using the PA, QMSS and CPPI  subsystems. The main APIs are defined in the API functions under the Modules tab.
53  @remark Each application must implement the code for the functions that are defined here. They are either application callbacks or in the case
54  of the initialization functions expected to be created and called from the application. There are examples of doing this
55  in the MCSDK demo and example programs. See the files there called platform_osal.c and resourcemgr.c.
56  */
59 #include <stdio.h>
60 #include <string.h>
61 #include <stdlib.h>
62 #include <stdint.h>
64 #include "platform.h"
66 #include <ti/csl/tistdtypes.h>
68 /* CSL CHIP, SEM Functional layer includes */
69 #include <ti/csl/csl_chip.h>
70 #include <ti/csl/csl_semAux.h>
72 /* CSL Cache module includes */
73 #include <ti/csl/csl_cacheAux.h>
75 /* CPPI LLD include */
76 #include <ti/drv/cppi/cppi_drv.h>
77 #include <ti/drv/cppi/cppi_desc.h>
79 /* QMSS LLD include */
80 #include <ti/drv/qmss/qmss_drv.h>
82 /* PA LLD include */
83 //#include <ti/drv/pa/pa.h>
84 //#include <ti/drv/pa/nss_if.h>
86 #if ( !defined( _LITTLE_ENDIAN ) && !defined( _BIG_ENDIAN ) ) \
87 ||  ( defined(_LITTLE_ENDIAN ) && defined( _BIG_ENDIAN ) )
88 #error either _LITTLE_ENDIAN or _BIG_ENDIAN must be defined
89 #endif
91 /** @defgroup  Resource_Manager_Version  Resource Manager Version
92  *      Resource Manager Version
93  */
94 /*@{*/
95 #define RESOURCEMGR_VERSION     "1.00.01.00"    /**< */
96 /*@}*/  /* defgroup */
99 /** @defgroup  Platform_hardware_semaphore  Hardware Semaphores
100  *      Hardware semaphore IDs. Only those which are assigned appear here.
101  */
104 /*@{*/
105 #define PLATFORM_CPPI_HW_SEM        1           /**< CPPI Driver - Used by OSAL layer                                   */
106 #define PLATFORM_QMSS_HW_SEM        2           /**< QMSS Driver - Used by OSAL Layer                                   */
107 #define PLATFORM_SPI_HW_SEM                     3               /**< SPI BUS arbitration - Used by platform library     */
108 /*@}*/  /* defgroup */
112 /** @defgroup  Platform_interrupts  Interrupts
113  *  Interrupt and event IDs. Only those which are assigned appear here.
114  *
115  * We are currently combining all interrupts for the switch and they are set by the demo
116  * applications in their .cfg files:
117  * Ecm.eventGroupHwiNum[0] = 7;
118  * Ecm.eventGroupHwiNum[1] = 8;
119  * Ecm.eventGroupHwiNum[2] = 9;
120  * Ecm.eventGroupHwiNum[3] = 10;
121  */
122 /*@{*/
123 #define PLATFORM_ETH_EVENTID            48              /**< Ethernet Switch event - Used by NIMU library */
124 #define PLATFORM_ETH_INTERRUPT          7               /**< Ethernet Switch Interrupt - Used by NIMU library */
125 /*@}*/  /* defgroup */
128 /** @defgroup  Platform_dma  DMA
129  * Assgined DMA Channels.
130  */
131 /*@{*/
132 #define PRESOURCE_DMA_CHANNELS_GO_HERE  0
133 /*@}*/  /* defgroup */
137 /**********************************************************************
138  *********** Resoure Manager QMSS configuration Definitions ***********
139  **********************************************************************/
141 /** @defgroup  Qmss_Subsystem  QMSS Subsystem
142 * APIs and definitions for managing the QMSS subsystem.
143 */
144 /*@{*/
146 /**
147  *  @brief      Queue handler type for FDQ.
148  */
149 typedef enum {
150     QHANDLER_QPOP_FDQ_NO_ATTACHEDBUF,
151     QHANDLER_QPOP_FDQ_ATTACHEDBUF
152 } QHANDLER_TYPE;
156 #define NIMU_NUM_TX_DESC                16u /**< Maximum number of TX descriptors used by NIMU */
157 #define NIMU_NUM_RX_DESC                110u /**< Maximum number of RX descriptors used by NIMU */
158 #define NIMU_MAX_NUM_TX_CMD_DESC        2u  /**< Maximum number of TX Command descriptors used by NIMU */
160 #define MAX_NUM_NIMU_DESC   (NIMU_NUM_TX_DESC + NIMU_NUM_RX_DESC + NIMU_MAX_NUM_TX_CMD_DESC) /**< Maximum number of descriptors used by NIMU */
161 #define MAX_NUM_DESC        (MAX_NUM_NIMU_DESC)   /**< Maximum number of descriptors used by all the modules */
162 #define MAX_DESC_SIZE       128 /**< Maximum size of descriptor in bytes */
164 /**
165  * @brief
166  *  QMSS configuration information
167  *
168  * @details
169  *  This structure defines the QMSS configuration during the system initialization
170  */
171 typedef struct QMSS_CFG_Tag
173     /**
174      * @brief       Master core flag, 1: Master core; 0: non-master core.
175      */
176     uint32_t        master_core;
178     /**
179      * @brief       Maximum number of descriptors.
180      */
181     uint32_t        max_num_desc;
183     /**
184      * @brief       Size of descriptor in bytes.
185      */
186     uint32_t        desc_size;
188     /**
189      * @brief       Memory Region corresponding to the descriptor.
190      */
191     Qmss_MemRegion  mem_region;
193 } QMSS_CFG_T;
196 /**
197  *   @n@b res_mgr_qmss_freeq
198  *
199  *   @b Description
200  *   @n This API returns the handle to the global free queue for QMSS. The global free
201  *   queue maintains all usable descriptors for anyone using QMSS.
202  *
203  *
204  *   @return
205  *
206  */
207 Qmss_QueueHnd
208 res_mgr_qmss_get_freeq
210     void
211 );
214  /**
215  *   @n@b QMSS_QPOP
216  *
217  *   @b Description
218  *   @n This API implements a the queue pop logic with the Cache Management
219  *
220  *   @param[in]  handler
221  *        Queue handler
222  *   @param[in]  type
223  *        Queue handler type
224  *   @param[in]  pHostDescriptor
225  *       pointer to  descriptor
226  *
227  *   @return
228  *
229  */
230 int32_t
231 QMSS_QPOP
233     Qmss_QueueHnd           handler,
234     QHANDLER_TYPE           type,
235     Cppi_HostDesc**         pHostDescriptor
236 );
238 /**
239  *   @n@b QMSS_QPUSH
240  *
241  *   @b Description
242  *   @n This API implements a the queue push logic with the Cache Management
243  *
244  *   @param[in]  handler
245  *        Queue handler
246  *   @param[in]  descAddr
247  *        Descriptor address
248  *   @param[in]  packetSize
249  *        packet Size
250  *   @param[in]  descSize
251  *        descriptor Size
252  *   @param[in]  location
253  *        Qmss_Location location
254  *   @return
255  *
256  */
257 void
258 QMSS_QPUSH
260     Qmss_QueueHnd          handler,
261     void                   *descAddr,
262     uint32_t               packetSize,
263     uint32_t               descSize,
264     Qmss_Location          location
265 );
267 /**
268  *   @n@b QMSS_QPUSHDESCSIZE
269  *
270  *   @b Description
271  *   @n This API implements a the queue push logic with the Cache Management
272  *
273  *   @param[in]  handler
274  *        Queue handler
275  *   @param[in]  descAddr
276  *        Descriptor address
277  *   @param[in]  descSize
278  *        descriptor Size
279  *   @return
280  *
281  */
282 void
283 QMSS_QPUSHDESCSIZE
285     Qmss_QueueHnd          handler,
286     void                   *descAddr,
287     uint32_t               descSize
288 );
290 /**
291  *   @n@b res_mgr_init_qmss
292  *
293  *   @b Description
294  *   @n This API initializes the QMSS LLD.
295  *
296  *   @param[in]  *p_qmss_cfg Pointer to QMSS_CFG_T
297  *
298  *   @return    int32_t
299  *              -1      -   Error
300  *              0       -   Success
301  *
302  */
303 int32_t
304 res_mgr_init_qmss
306     QMSS_CFG_T      *p_qmss_cfg
307 );
309 /**
310  *   @n@b res_mgr_stop_qmss
311  *
312  *   @b Description
313  *   @n This API de-initializes the QMSS LLD.
314  *
315  *   @return    int32_t
316  *              -1      -   Error
317  *              0       -   Success
318  *
319  */
320 int32_t
321 res_mgr_stop_qmss
323     void
324 );
327 /**
328  *  @n@b Osal_qmssCsEnter
329  *
330  *  @b  brief
331  *  @n  This API ensures multi-core and multi-threaded
332  *      synchronization to the caller.
333  *
334  *      This is a BLOCKING API.
335  *
336  *      This API ensures multi-core synchronization between
337  *      multiple processes trying to access QMSS shared
338  *      library at the same time.
339  *
340  *
341  *  @return
342  *      Handle used to lock critical section
343  *
344  */
345 Ptr Osal_qmssCsEnter (void);
348 /**
349  *
350  *  @n@b Osal_qmssCsExit
351  *
352  *  @b  brief
353  *  @n  This API needs to be called to exit a previously
354  *      acquired critical section lock using @a Osal_cpswQmssCsEnter ()
355  *      API. It resets the multi-core and multi-threaded lock,
356  *      enabling another process/core to grab QMSS access.
357  *
358  *  @param[in]  CsHandle
359  *      Handle for unlocking critical section.
360  *
361  *  @return
362  *  @n None
363  *
364  */
365 void Osal_qmssCsExit (Ptr CsHandle);
368 /**
369  *
370  *  @n@b Osal_qmssMtCsEnter
371  *
372  *  @b  brief
373  *  @n  This API ensures ONLY multi-threaded
374  *      synchronization to the QMSS user.
375  *
376  *      This is a BLOCKING API.
377  *
378  *
379  *  @return
380  *       Handle used to lock critical section
381  *
382  */
383 Ptr Osal_qmssMtCsEnter (void);
386 /**
387  *
388  *  @n@b Osal_qmssMtCsExit
389  *
390  *  @b  brief
391  *  @n  This API needs to be called to exit a previously
392  *      acquired critical section lock using @a Osal_cpswQmssMtCsEnter ()
393  *      API. It resets the multi-threaded lock, enabling another process
394  *      on the current core to grab it.
395  *
396  *  @param[in]  CsHandle
397  *      Handle for unlocking critical section.
398  *
399  *  @return None
400  *
401  */
402 void Osal_qmssMtCsExit (Ptr CsHandle);
405 /**
406  *
407  *  @n@b Osal_qmssMalloc
408  *
409  *  @b  brief
410  *  @n  This API allocates a memory block of a given
411  *      size specified by input parameter 'num_bytes'.
412  *
413  *  @param[in]  num_bytes
414  *      Number of bytes to be allocated.
415  *
416  *  @return
417  *      Allocated block address
418  *
419  */
420 Ptr Osal_qmssMalloc (uint32_t num_bytes);
423 /**
424  *
425  *  @n@b Osal_qmssFree
426  *
427  *  @b  brief
428  *  @n  This API frees and restores a given memory location
429  *      pointer 'dataPtr' of size 'num_bytes' to its
430  *      original heap location. Frees up memory allocated using
431  *      @a Osal_qmssMalloc ()
432  *
433  *  @param[in]  dataPtr
434  *      Pointer to the memory block to be cleaned up.
435  *
436  *  @param[in]  num_bytes
437  *      Size of the memory block to be cleaned up.
438  *
439  *  @return  None
440  *
441  */
442 void Osal_qmssFree (Ptr dataPtr, uint32_t num_bytes);
445 /**
446  *  @b Description
447  *  @n
448  *      The function is used to indicate that a block of memory is
449  *      about to be accessed. If the memory block is cached then this
450  *      indicates that the application would need to ensure that the
451  *      cache is updated with the data from the actual memory.
452  *
453  *  @param[in]  blockPtr
454  *       Address of the block which is to be invalidated
455  *
456  *  @param[in]  size
457  *       Size of the block to be invalidated
459  *  @retval None
460  */
461 void Osal_qmssBeginMemAccess (void *blockPtr, uint32_t size);
464 /**
465  *  @b Description
466  *  @n
467  *      The function is used to indicate that the block of memory has
468  *      finished being accessed. If the memory block is cached then the
469  *      application would need to ensure that the contents of the cache
470  *      are updated immediately to the actual memory.
471  *
472  *  @param[in]  blockPtr
473  *       Address of the block which is to be written back
474  *
475  *  @param[in]  size
476  *       Size of the block to be written back
478  *  @retval None
479  */
480 void Osal_qmssEndMemAccess (void *blockPtr, uint32_t size);
483 /*@}*/  /* defgroup */
486 /**********************************************************************
487  *********** Resoure Manager PA configuration Definitions ***********
488  **********************************************************************/
490 /** @defgroup  PA_Subsystem  Packet Accelerator (PA) Subsystem
491 * APIs and definitions for managing the Packet Accelerator (PA) subsystem.
492 */
494 /*@{*/
496 /**
497  *  @brief Number of PA Tx queues available
498  */
499 #define         NUM_PA_TX_QUEUES            NSS_NUM_TX_QUEUES
501 /**
502  *  @brief Number of PA Rx queues available
503  */
504 #define         NUM_PA_RX_CHANNELS          NSS_NUM_RX_PKTDMA_CHANNELS
506 #ifdef NSS_GEN2
507 #define         TF_PA_Q_CONFIG_BASE             8
508 #endif
510 /**
511  *  @brief Maximum number of L2 handles
512  */
513 #define     MAX_NUM_L2_HANDLES          10
515 /**
516  *  @brief Maximum number of L3 handles
517  */
518 #define     MAX_NUM_L3_HANDLES          20
520 /**
521  *  @brief Maximum number of L4 handles
522  */
523 #define     MAX_NUM_L4_HANDLES          40
525 /*
526  *   @n@b res_mgr_init_pass
527  *
528  *   @b Description
529  *   @n This API initializes the PASS/PDSP.
530  *
531  *
532  *   @return    int32_t
533  *              -1      -   Error
534  *              0       -   Success
535  *
536  */
537 int32_t
538 res_mgr_init_pass
540     void
541 );
543 /**
544  *   @n@b res_mgr_cppi_get_passhandle
545  *
546  *   @b Description
547  *   @n This API returns the handle to the the CPPI DMA for the Packet Accelerator (PA).
548  *
549  *
550  *   @return  Cppi_Handle
551  *
552  */
553 Cppi_Handle
554 res_mgr_cppi_get_passhandle (void);
556 /**
557  *  @b Description
558  *  @n
559  *      The function is used to indicate that a block of memory is
560  *      about to be accessed. If the memory block is cached then this
561  *      indicates that the application would need to ensure that the
562  *      cache is updated with the data from the actual memory.
563  *
564  *  @param[in]  addr
565  *       Address of the block which is to be invalidated
566  *
567  *  @param[in]  size
568  *       Size of the block to be invalidated
570  *  @retval  None
571  */
572 void Osal_paBeginMemAccess (Ptr addr, uint32_t size);
575 /**
576  *  @b Description
577  *  @n
578  *      The function is used to indicate that the block of memory has
579  *      finished being accessed. If the memory block is cached then the
580  *      application would need to ensure that the contents of the cache
581  *      are updated immediately to the actual memory.
582  *
583  *  @param[in]  addr
584  *       Address of the block which is to be written back
585  *
586  *  @param[in]  size
587  *       Size of the block to be written back
589  *  @retval  None
590  */
591 void Osal_paEndMemAccess (Ptr addr, uint32_t size);
593 /*@}*/  /* defgroup */
596 /**********************************************************************
597  *********** Resoure Manager CPPI configuration Definitions ***********
598  **********************************************************************/
600 /** @defgroup  Cppi_Subsystem CPPI Subsystem
601 * APIs and definitions for managing the CPPI subsystem.
602 */
603 /*@{*/
606 /**
607  *  @brief CPPI configuration type.
608  */
609 typedef enum {
610     CPPI_CFG_PASS   = 0,
611     CPPI_CFG_SRIO
612 } CPPI_CFG_TYPE;
614 /**
615  *  @brief Maximum number of CPPI configuration
616  */
617 #define         MAX_CPPI_CFG                2
619 /**
620  * @brief
621  *  CPPI configuration information
622  *
623  * @details
624  *  This structure defines the CPPI configuration during the system initialization
625  */
626 typedef struct CPPI_CFG_Tag
628     /**
629      * @brief       Master core flag, 1: Master core; 0: non-master core.
630      */
631     uint32_t        master_core;
633     /**
634      * @brief       CPPI DMA number.
635      */
636     Cppi_CpDma      dma_num;
638     /**
639      * @brief       Maximum number of TX queues.
640      */
641     uint32_t        num_tx_queues;
643     /**
644      * @brief       Maximum number of RX channels.
645      */
646     uint32_t        num_rx_channels;
647 } CPPI_CFG_T;
649 /**
650  *   @n@b res_mgr_init_cppi
651  *
652  *   @b Description
653  *   @n This API initializes the CPPI LLD, opens the PDMA and opens up
654  *      the Tx, Rx channels required for data transfers.
655  *
656  *   @param[in]  *p_cppi_cfg  Pointer to CPPI_CFG_T
657  *
658  *   @return    int32_t
659  *              -1      -   Error
660  *              0       -   Success
661  *
662  */
663 int32_t
664 res_mgr_init_cppi
666     CPPI_CFG_T      *p_cppi_cfg
667 );
669 /**
670  *   @n@b res_mgr_stop_cppi
671  *
672  *   @b Description
673  *   @n This API stops the CPPI subsystem.
674  *
675  *   @param[in]  cfg_type  Configuration to stop, e.g. CPPI_CFG_PASS
676  *
677  *   @return    int32_t
678  *              -1      -   Error
679  *              0       -   Success
680  *
681  */
682 int32_t
683 res_mgr_stop_cppi
685     CPPI_CFG_TYPE       cfg_type
686 );
689 /**
690  *
691  *  @n@b Osal_cppiCsEnter
692  *
693  *  @b  brief
694  *  @n  This API ensures multi-core and multi-threaded
695  *      synchronization to the caller.
696  *
697  *      This is a BLOCKING API.
698  *
699  *      This API ensures multi-core synchronization between
700  *      multiple processes trying to access CPPI shared
701  *      library at the same time.
702  *
703  *
704  *  @return
705  *  @n  Handle used to lock critical section
706  *
707  */
708 Ptr Osal_cppiCsEnter (void);
711 /**
712  *
713  *  @n@b Osal_cppiCsExit
714  *
715  *  @b  brief
716  *  @n  This API needs to be called to exit a previously
717  *      acquired critical section lock using @a Osal_cppiCsEnter ()
718  *      API. It resets the multi-core and multi-threaded lock,
719  *      enabling another process/core to grab CPPI access.
720  *
721  *  @param[in]  CsHandle
722  *      Handle for unlocking critical section.
723  *
724  *  @return  None
725  *
726  */
727 void Osal_cppiCsExit (Ptr CsHandle);
731 /**
732  *
733  *  @n@b Osal_cppiMalloc
734  *
735  *  @b  brief
736  *  @n  This API allocates a memory block of a given
737  *      size specified by input parameter 'num_bytes'.
738  *
739  *      This API should allocate memory from shared memory if the test applications
740  *      are to be run on multiple cores.
741  *
742  *  @param[in]  num_bytes
743  *      Number of bytes to be allocated.
744  *
745  *  @return
746  *      Allocated block address
747  *
748  */
749 Ptr Osal_cppiMalloc (uint32_t num_bytes);
752 /**
753  *
754  *  @n@b Osal_cppiFree
755  *
756  *  @b  brief
757  *  @n  This API frees and restores a given memory location
758  *      pointer 'dataPtr' of size 'num_bytes' to its
759  *      original heap location. Frees up memory allocated using
760  *      @a Osal_cppiMalloc ()
761  *
762  *  @param[in]  dataPtr
763  *      Pointer to the memory block to be cleaned up.
764  *
765  *  @param[in]  num_bytes
766  *      Size of the memory block to be cleaned up.
767  *
768  *  @return  None
769  *
770  */
771 void Osal_cppiFree (Ptr dataPtr, uint32_t num_bytes);
774 /**
775  *  @b Description
776  *  @n
777  *      The function is used to indicate that a block of memory is
778  *      about to be accessed. If the memory block is cached then this
779  *      indicates that the application would need to ensure that the
780  *      cache is updated with the data from the actual memory.
781  *
782  *  @param[in]  blockPtr
783  *       Address of the block which is to be invalidated
784  *
785  *  @param[in]  size
786  *       Size of the block to be invalidated
788  *  @retval  None
789  */
790 void Osal_cppiBeginMemAccess (void *blockPtr, uint32_t size);
793 /**
794  *  @b Description
795  *  @n
796  *      The function is used to indicate that the block of memory has
797  *      finished being accessed. If the memory block is cached then the
798  *      application would need to ensure that the contents of the cache
799  *      are updated immediately to the actual memory.
800  *
801  *  @param[in]  blockPtr
802  *       Address of the block which is to be written back
803  *
804  *  @param[in]  size
805  *       Size of the block to be written back
807  *  @retval  None
808  */
809 void Osal_cppiEndMemAccess (void *blockPtr, uint32_t size);
812 /*@}*/  /* defgroup */
816 #endif /* _RESOURCE_MGR_H */