a801bfafa987233c7a386f027cc2a70176355545
[ipc/ipcdev.git] / qnx / src / ipc3x_dev / ti / syslink / family / common / vayu / vayudsp / VAYUDspPwr.c
1 /*
2  *  @file   VAYUDspPwr.c
3  *
4  *  @brief      PwrMgr implementation for VAYUDSP.
5  *
6  *              This module is responsible for handling power requests for
7  *              the ProcMgr. The implementation is specific to VAYUDSP.
8  *
9  *
10  *  ============================================================================
11  *
12  *  Copyright (c) 2013, Texas Instruments Incorporated
13  *
14  *  Redistribution and use in source and binary forms, with or without
15  *  modification, are permitted provided that the following conditions
16  *  are met:
17  *
18  *  *  Redistributions of source code must retain the above copyright
19  *     notice, this list of conditions and the following disclaimer.
20  *
21  *  *  Redistributions in binary form must reproduce the above copyright
22  *     notice, this list of conditions and the following disclaimer in the
23  *     documentation and/or other materials provided with the distribution.
24  *
25  *  *  Neither the name of Texas Instruments Incorporated nor the names of
26  *     its contributors may be used to endorse or promote products derived
27  *     from this software without specific prior written permission.
28  *
29  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
30  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
31  *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
32  *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
33  *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
34  *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
35  *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
36  *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
37  *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
38  *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
39  *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40  *  Contact information for paper mail:
41  *  Texas Instruments
42  *  Post Office Box 655303
43  *  Dallas, Texas 75265
44  *  Contact information:
45  *  http://www-k.ext.ti.com/sc/technical-support/product-information-centers.htm?
46  *  DCMP=TIHomeTracking&HQS=Other+OT+home_d_contact
47  *  ============================================================================
48  *
49  */
53 /* Standard headers */
54 #if defined(SYSLINK_BUILD_RTOS)
55 #include <xdc/std.h>
56 #include <string.h>
57 #include <xdc/runtime/Error.h>
58 #include <xdc/runtime/Memory.h>
59 #include <xdc/runtime/System.h>
60 #include <xdc/runtime/IGateProvider.h>
61 #include <ti/sysbios/gates/GateMutex.h>
62 #include <ti/syslink/utils/_Memory.h>
63 #include <ti/syslink/inc/VAYUClock.h>
64 #endif /* #if defined(SYSLINK_BUILD_RTOS) */
66 #if defined(SYSLINK_BUILD_HLOS)
67 #include <ti/syslink/Std.h>
68 /* OSAL & Utils headers */
69 #include <ti/syslink/utils/String.h>
70 #include <ti/syslink/utils/IGateProvider.h>
71 #include <ti/syslink/utils/GateMutex.h>
72 #include <ti/syslink/utils/Memory.h>
73 #include <_MultiProc.h>
74 #if defined(__KERNEL__)
75 #include <linux/string.h>
76 #else
77 #include <string.h>
78 #endif
79 #if defined (SYSLINK_BUILDOS_LINUX)
80 #include <ti/syslink/inc/knl/Linux/LinuxClock.h>
81 #endif /* #if defined(SYSLINK_BUILDOS_LINUX) */
82 #endif /* #if defined(SYSLINK_BUILD_HLOS) */
83 #include <ti/syslink/utils/Trace.h>
84 #include <Bitops.h>
86 /* Module level headers */
87 #include <ti/ipc/MultiProc.h>
88 #include <ti/syslink/inc/_MultiProc.h>
89 #include <ti/syslink/inc/knl/PwrDefs.h>
90 #include <ti/syslink/inc/knl/PwrMgr.h>
91 #include <ti/syslink/inc/knl/VAYUDspPwr.h>
92 #include <ti/syslink/inc/knl/_VAYUDspPwr.h>
93 #include <ti/syslink/inc/ClockOps.h>
97 #if defined (__cplusplus)
98 extern "C" {
99 #endif
102 /* =============================================================================
103  *  Macros and types
104  * =============================================================================
105  */
106 /*!
107  *  @brief  VAYUDSP module and mmr addresses (physical)
108  */
109 #define PRCM_BASE_ADDR              0x48180000
110 #define PRCM_SIZE                   0x00003000
111 #define PM_ACTIVE_PWRSTST           0x00000A04
112 #define CM_ACTIVE_GEM_CLKCTRL       0x00000420
115 #define CM_MMU_CLKSTCTRL            0x0000140C
116 #define CM_ALWON_MMUDATA_CLKCTRL    0x0000159C
117 #define CM_MMUCFG_CLKSTCTRL         0x00001410
118 #define CM_ALWON_MMUCFG_CLKCTRL     0x000015A8
121 #define RM_ACTIVE_RSTCTRL           0x00000A10
122 #define RM_ACTIVE_RSTST             0x00000A14
124 #define GEM_L2RAM_BASE_ADDR         0x40800000
125 #define GEM_L2RAM_SIZE              0x00040000
127 #define CTRL_MODULE_BASE_ADDR       0x48140000
128 #define CTRL_MODULE_SIZE            0x00020000
129 #define DSPMEM_SLEEP                0x00000650
131 #define DSP_IDLE_CFG                0x0000061c
133 #define REG(x)              *((volatile UInt32 *) (x))
134 #define MEM(x)              *((volatile UInt32 *) (x))
136 /*!
137  *  @brief  VAYUDSPPWR Module state object
138  */
139 typedef struct VAYUDSPPWR_ModuleObject_tag {
140     UInt32                configSize;
141     /*!< Size of configuration structure */
142     VAYUDSPPWR_Config       cfg;
143     /*!< VAYUDSPPWR configuration structure */
144     VAYUDSPPWR_Config       defCfg;
145     /*!< Default module configuration */
146     Bool                  isSetup;
147     /*!< Indicates whether the VAYUDSPPWR module is setup. */
148     VAYUDSPPWR_Handle       pwrHandles [MultiProc_MAXPROCESSORS];
149     /*!< PwrMgr handle array. */
150     IGateProvider_Handle           gateHandle;
151     /*!< Handle of gate to be used for local thread safety */
152 } VAYUDSPPWR_ModuleObject;
154 /*!
155  *  @brief  VAYUDSPPWR instance object.
156  */
157 struct VAYUDSPPWR_Object_tag {
158     VAYUDSPPWR_Params params;
159     /*!< Instance parameters (configuration values) */
160     UInt32             prcmVA;
161     /*!< Virtual address for prcm module */
162     UInt32             controlVA;
163     /*!< Virtual address for control module */
164     UInt32             l2baseVA;
165     /*!< Virtual address for control module */
166     Ptr                dspClkHandle;
167     /*!< dsp clk handle */
168     Ptr                dspMmuClkHandle;
169     /*!< dsp clk handle */
170     Ptr                dspMmuCfgClkHandle;
171     /*!< dsp clk handle */
172     Ptr                dspSpinlockHandle;
173     /*!< dsp Spinlock handle */
174     Ptr                dspMailboxHandle;
175     /*!< dsp Mailbox handle */
176     Ptr                dspTimerIclkHandle;
177     /*!< dsp Timer4 handle */
178     Ptr                dspTimerFclkHandle;
179     /*!< dsp Timer4 handle */
180     ClockOps_Handle    clockHandle;
181     /*!< Pointer to the Clock object. */
183 };
185 /* Defines the VAYUDSPPWR object type. */
186 typedef struct VAYUDSPPWR_Object_tag VAYUDSPPWR_Object;
189 /* =============================================================================
190  *  Globals
191  * =============================================================================
192  */
193 /*!
194  *  @var    VAYUDSPPWR_state
195  *
196  *  @brief  VAYUDSPPWR state object variable
197  */
198 #if !defined(SYSLINK_BUILD_DEBUG)
199 static
200 #endif /* if !defined(SYSLINK_BUILD_DEBUG) */
201 VAYUDSPPWR_ModuleObject VAYUDSPPWR_state =
203     .isSetup = FALSE,
204     .configSize = sizeof (VAYUDSPPWR_Config),
205     .defCfg.reserved = 0,
206     .gateHandle = NULL,
207 };
210 /* =============================================================================
211  * APIs directly called by applications
212  * =============================================================================
213  */
214 /*!
215  *  @brief      Function to get the default configuration for the VAYUDSPPWR
216  *              module.
217  *
218  *              This function can be called by the application to get their
219  *              configuration parameter to VAYUDSPPWR_setup filled in by the
220  *              VAYUDSPPWR module with the default parameters. If the user does
221  *              not wish to make any change in the default parameters, this API
222  *              is not required to be called.
223  *
224  *  @param      cfg        Pointer to the VAYUDSPPWR module configuration
225  *                         structure in which the default config is to be
226  *                         returned.
227  *
228  *  @sa         VAYUDSPPWR_setup
229  */
230 Void
231 VAYUDSPPWR_getConfig (VAYUDSPPWR_Config * cfg)
233     GT_1trace (curTrace, GT_ENTER, "VAYUDSPPWR_getConfig", cfg);
235     GT_assert (curTrace, (cfg != NULL));
237 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
238     if (cfg == NULL) {
239         GT_setFailureReason (curTrace,
240                              GT_4CLASS,
241                              "VAYUDSPPWR_getConfig",
242                              PWRMGR_E_INVALIDARG,
243                              "Argument of type (VAYUDSPPWR_Config *) passed "
244                              "is null!");
245     }
246     else {
247 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
248         memcpy (cfg,
249                      &VAYUDSPPWR_state.defCfg,
250                      sizeof (VAYUDSPPWR_Config));
251 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
252     }
253 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
255     GT_0trace (curTrace, GT_LEAVE, "VAYUDSPPWR_getConfig");
259 /*!
260  *  @brief      Function to setup the VAYUDSPPWR module.
261  *
262  *              This function sets up the VAYUDSPPWR module. This function must
263  *              be called before any other instance-level APIs can be invoked.
264  *              Module-level configuration needs to be provided to this
265  *              function. If the user wishes to change some specific config
266  *              parameters, then VAYUDSPPWR_getConfig can be called to get the
267  *              configuration filled with the default values. After this, only
268  *              the required configuration values can be changed. If the user
269  *              does not wish to make any change in the default parameters, the
270  *              application can simply call VAYUDSPPWR_setup with NULL
271  *              parameters. The default parameters would get automatically used.
272  *
273  *  @param      cfg   Optional VAYUDSPPWR module configuration. If provided as
274  *                    NULL, default configuration is used.
275  *
276  *  @sa         VAYUDSPPWR_destroy
277  *              GateMutex_create
278  */
279 Int
280 VAYUDSPPWR_setup (VAYUDSPPWR_Config * cfg)
282     Int               status = PWRMGR_SUCCESS;
283     VAYUDSPPWR_Config tmpCfg;
284     Error_Block eb;
286     Error_init(&eb);
288     GT_1trace (curTrace, GT_ENTER, "VAYUDSPPWR_setup", cfg);
290     if (cfg == NULL) {
291         VAYUDSPPWR_getConfig (&tmpCfg);
292         cfg = &tmpCfg;
293     }
295     /* Create a default gate handle for local module protection. */
296     VAYUDSPPWR_state.gateHandle = (IGateProvider_Handle)
297                              GateMutex_create ((GateMutex_Params*)NULL, &eb);
298 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
299     if (VAYUDSPPWR_state.gateHandle == NULL) {
300         /*! @retval PWRMGR_E_FAIL Failed to create GateMutex! */
301         status = PWRMGR_E_FAIL;
302         GT_setFailureReason (curTrace,
303                              GT_4CLASS,
304                              "VAYUDSPPWR_setup",
305                              status,
306                              "Failed to create GateMutex!");
307     }
308     else {
309 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
310         /* Copy the user provided values into the state object. */
311         Memory_copy (&VAYUDSPPWR_state.cfg,
312                      cfg,
313                      sizeof (VAYUDSPPWR_Config));
315         /* Initialize the name to handles mapping array. */
316         Memory_set (&VAYUDSPPWR_state.pwrHandles,
317                     0,
318                     (sizeof (VAYUDSPPWR_Handle) * MultiProc_MAXPROCESSORS));
319         VAYUDSPPWR_state.isSetup = TRUE;
320 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
321     }
322 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
324     GT_1trace (curTrace, GT_LEAVE, "VAYUDSPPWR_setup", status);
326     /*! @retval PWRMGR_SUCCESS Operation successful */
327     return (status);
331 /*!
332  *  @brief      Function to destroy the VAYUDSPPWR module.
333  *
334  *              Once this function is called, other VAYUDSPPWR module APIs, except
335  *              for the VAYUDSPPWR_getConfig API cannot be called anymore.
336  *
337  *  @sa         VAYUDSPPWR_setup
338  *              GateMutex_delete
339  */
340 Int
341 VAYUDSPPWR_destroy (Void)
343     Int    status = PWRMGR_SUCCESS;
344     UInt16 i;
346     GT_0trace (curTrace, GT_ENTER, "VAYUDSPPWR_destroy");
348     /* Check if any VAYUDSPPWR instances have not been deleted so far. If not,
349      * delete them.
350      */
351     for (i = 0 ; i < MultiProc_MAXPROCESSORS ; i++) {
352         GT_assert (curTrace, (VAYUDSPPWR_state.pwrHandles [i] == NULL));
353         if (VAYUDSPPWR_state.pwrHandles [i] != NULL) {
354             VAYUDSPPWR_delete (&(VAYUDSPPWR_state.pwrHandles [i]));
355         }
356     }
358     if (VAYUDSPPWR_state.gateHandle != NULL) {
359         GateMutex_delete ((GateMutex_Handle *)
360                                 &(VAYUDSPPWR_state.gateHandle));
361     }
363     VAYUDSPPWR_state.isSetup = FALSE;
365     GT_1trace (curTrace, GT_LEAVE, "VAYUDSPPWR_destroy", status);
367     /*! @retval PWRMGR_SUCCESS Operation successful */
368     return (status);
372 /*!
373  *  @brief      Function to initialize the parameters for this PwrMgr instance.
374  *
375  *  @param      params  Configuration parameters.
376  *
377  *  @sa         VAYUDSPPWR_create
378  */
379 Void
380 VAYUDSPPWR_Params_init (VAYUDSPPWR_Params * params)
382     GT_1trace (curTrace, GT_ENTER, "VAYUDSPPWR_Params_init",params);
384     GT_assert (curTrace, (params != NULL));
386 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
387     if (params == NULL) {
388         GT_setFailureReason (curTrace,
389                              GT_4CLASS,
390                              "VAYUDSPPWR_Params_init",
391                              PWRMGR_E_INVALIDARG,
392                              "Argument of type (VAYUDSPPWR_Params *) "
393                              "passed is null!");
394     }
395     else {
396 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
397         /* Return updated VAYUDSPPWR instance specific parameters. */
398         params->reserved = 0;
399 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
400     }
401 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
403     GT_0trace (curTrace, GT_LEAVE, "VAYUDSPPWR_Params_init");
406 /*!
407  *  @brief      Function to create an instance of this PwrMgr.
408  *
409  *  @param      procId  Processor ID addressed by this PwrMgr instance.
410  *  @param      params  Configuration parameters.
411  *
412  *  @sa         VAYUDSPPWR_delete
413  */
414 VAYUDSPPWR_Handle
415 VAYUDSPPWR_create (      UInt16               procId,
416                     const VAYUDSPPWR_Params * params)
418     Int                  status = PWRMGR_SUCCESS;
419     PwrMgr_Object *      handle = NULL;
420     IArg                 key;
422     GT_2trace (curTrace, GT_ENTER, "VAYUDSPPWR_create", procId, params);
424     GT_assert (curTrace, IS_VALID_PROCID (procId));
425     GT_assert (curTrace, (params != NULL));
427 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
428     if (!IS_VALID_PROCID (procId)) {
429         status = PWRMGR_E_INVALIDARG;
430         GT_setFailureReason (curTrace,
431                              GT_4CLASS,
432                              "VAYUDSPPWR_create",
433                              status,
434                              "Invalid procId specified");
435     }
436     else if (params == NULL) {
437         status = PWRMGR_E_INVALIDARG;
438         GT_setFailureReason (curTrace,
439                              GT_4CLASS,
440                              "VAYUDSPPWR_create",
441                              status,
442                              "params passed is null!");
443     }
444     else {
445 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
446         /* Enter critical section protection. */
447         key = IGateProvider_enter (VAYUDSPPWR_state.gateHandle);
448 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
449         /* Check if the PwrMgr already exists for specified procId. */
450         if (VAYUDSPPWR_state.pwrHandles [procId] != NULL) {
451             status = PWRMGR_E_ALREADYEXIST;
452             GT_setFailureReason (curTrace,
453                                  GT_4CLASS,
454                                  "VAYUDSPPWR_create",
455                                  status,
456                                  "PwrMgr already exists for specified procId!");
457         }
458         else {
459 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
460             /* Allocate memory for the handle */
461             handle = (PwrMgr_Object *) Memory_calloc (NULL,
462                                                       sizeof (PwrMgr_Object),
463                                                       0,
464                                                       NULL);
465             if (handle == NULL) {
466                 status = PWRMGR_E_MEMORY;
467                 GT_setFailureReason (curTrace,
468                                      GT_4CLASS,
469                                      "VAYUDSPPWR_create",
470                                      status,
471                                      "Memory allocation failed for handle!");
472             }
473             else {
474                 /* Populate the handle fields */
475                 handle->pwrFxnTable.attach = &VAYUDSPPWR_attach;
476                 handle->pwrFxnTable.detach = &VAYUDSPPWR_detach;
477                 handle->pwrFxnTable.on     = &VAYUDSPPWR_on;
478                 handle->pwrFxnTable.off    = &VAYUDSPPWR_off;
479                 /* TBD: Other functions */
481                 /* Allocate memory for the VAYUDSPPWR handle */
482                 handle->object = Memory_calloc (NULL,
483                                                 sizeof (VAYUDSPPWR_Object),
484                                                 0,
485                                                 NULL);
486                 if (handle->object == NULL) {
487                     status = PWRMGR_E_MEMORY;
488                     GT_setFailureReason (curTrace,
489                                         GT_4CLASS,
490                                         "VAYUDSPPWR_create",
491                                         status,
492                                         "Memory allocation failed for handle!");
493                 }
494                 else {
495 #if defined (SYSLINK_BUILDOS_LINUX)
496                     ((VAYUDSPPWR_Object *)(handle->object))->clockHandle
497                                        = (ClockOps_Handle) LinuxClock_create();
498 #endif/* #if defined (SYSLINK_BUILDOS_LINUX) */
499 #if defined (SYSLINK_BUILD_RTOS)
500                     ((VAYUDSPPWR_Object *)(handle->object))->clockHandle
501                                        = (ClockOps_Handle) VAYUCLOCK_create();
502 #endif/* #if defined (SYSLINK_BUILD_RTOS) */
503                     handle->procId = procId;
504                     VAYUDSPPWR_state.pwrHandles [procId] =
505                                                 (VAYUDSPPWR_Handle) handle;
506                 }
507             }
508 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
509         }
510 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
511         /* Leave critical section protection. */
512         IGateProvider_leave (VAYUDSPPWR_state.gateHandle, key);
513 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
514     }
515 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
517     if (status < 0) {
518         if (handle !=  NULL) {
519             if (handle->object != NULL) {
520                 Memory_free (NULL, handle->object, sizeof (VAYUDSPPWR_Object));
521             }
522             Memory_free (NULL, handle, sizeof (PwrMgr_Object));
523         }
524         /*! @retval NULL Function failed */
525         handle = NULL;
526     }
528     GT_1trace (curTrace, GT_LEAVE, "VAYUDSPPWR_create", handle);
530     /*! @retval Valid-Handle Operation successful */
531     return (VAYUDSPPWR_Handle) handle;
535 /*!
536  *  @brief      Function to delete an instance of this PwrMgr.
537  *
538  *              The user provided pointer to the handle is reset after
539  *              successful completion of this function.
540  *
541  *  @param      handlePtr  Pointer to Handle to the PwrMgr instance
542  *
543  *  @sa         VAYUDSPPWR_create
544  */
545 Int
546 VAYUDSPPWR_delete (VAYUDSPPWR_Handle * handlePtr)
548     Int                  status = PWRMGR_SUCCESS;
549     VAYUDSPPWR_Object * object = NULL;
550     PwrMgr_Object *      handle;
551     IArg                 key;
553     GT_1trace (curTrace, GT_ENTER, "VAYUDSPPWR_delete", handlePtr);
555     GT_assert (curTrace, (handlePtr != NULL));
556     GT_assert (curTrace, ((handlePtr != NULL) && (*handlePtr != NULL)));
558 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
559     if (handlePtr == NULL) {
560         /*! @retval PWRMGR_E_INVALIDARG Invalid NULL handlePtr specified*/
561         status = PWRMGR_E_INVALIDARG;
562         GT_setFailureReason (curTrace,
563                              GT_4CLASS,
564                              "VAYUDSPPWR_delete",
565                              status,
566                              "Invalid NULL handlePtr specified");
567     }
568     else if (*handlePtr == NULL) {
569         /*! @retval PWRMGR_E_HANDLE Invalid NULL *handlePtr specified */
570         status = PWRMGR_E_HANDLE;
571         GT_setFailureReason (curTrace,
572                              GT_4CLASS,
573                              "VAYUDSPPWR_delete",
574                              status,
575                              "Invalid NULL *handlePtr specified");
576     }
577     else {
578 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
579         handle = (PwrMgr_Object *) (*handlePtr);
580         /* Enter critical section protection. */
581         key = IGateProvider_enter (VAYUDSPPWR_state.gateHandle);
583         /* Reset handle in PwrMgr handle array. */
584         GT_assert (curTrace, IS_VALID_PROCID (handle->procId));
585         VAYUDSPPWR_state.pwrHandles [handle->procId] = NULL;
587         object = (VAYUDSPPWR_Object *) handle->object;
588         /* Free memory used for the VAYUDSPPWR object. */
589         if (handle->object != NULL) {
590             /* Free memory used for the clock handle */
591 #if defined (SYSLINK_BUILDOS_LINUX)
592             LinuxClock_delete(((VAYUDSPPWR_Object *)(handle->object))->clockHandle);
593 #endif /* #if defined (SYSLINK_BUILDOS_LINUX) */
594 #if defined (SYSLINK_BUILD_RTOS)
595             VAYUCLOCK_delete(((VAYUDSPPWR_Object *)(handle->object))->clockHandle);
596 #endif /* #if defined (SYSLINK_BUILD_RTOS) */
597             Memory_free (NULL,
598                          object,
599                          sizeof (VAYUDSPPWR_Object));
600             handle->object = NULL;
601         }
603         /* Free memory used for the PwrMgr object. */
604         Memory_free (NULL, handle, sizeof (PwrMgr_Object));
605         *handlePtr = NULL;
607         /* Leave critical section protection. */
608         IGateProvider_leave (VAYUDSPPWR_state.gateHandle, key);
609 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
610     }
611 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
613     GT_1trace (curTrace, GT_LEAVE, "VAYUDSPPWR_delete", status);
615     /*! @retval PWRMGR_SUCCESS Operation successful */
616     return (status);
620 /*!
621  *  @brief      Function to open a handle to an instance of this PwrMgr. This
622  *              function is called when access to the PwrMgr is required from
623  *              a different process.
624  *
625  *  @param      handlePtr   Handle to the PwrMgr instance
626  *  @param      procId      Processor ID addressed by this PwrMgr instance.
627  *
628  *  @sa         VAYUDSPPWR_close
629  */
630 Int
631 VAYUDSPPWR_open (VAYUDSPPWR_Handle * handlePtr, UInt16 procId)
633     Int status = PWRMGR_SUCCESS;
635     GT_2trace (curTrace, GT_ENTER, "VAYUDSPPWR_open", handlePtr, procId);
637     GT_assert (curTrace, (handlePtr != NULL));
638     GT_assert (curTrace, IS_VALID_PROCID (procId));
640 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
641     if (handlePtr == NULL) {
642         /*! @retval PWRMGR_E_HANDLE Invalid NULL handlePtr specified */
643         status = PWRMGR_E_HANDLE;
644         GT_setFailureReason (curTrace,
645                              GT_4CLASS,
646                              "VAYUDSPPWR_open",
647                              status,
648                              "Invalid NULL handlePtr specified");
649     }
650     else if (!IS_VALID_PROCID (procId)) {
651         /*! @retval PWRMGR_E_INVALIDARG Invalid procId specified */
652         status = PWRMGR_E_INVALIDARG;
653         GT_setFailureReason (curTrace,
654                              GT_4CLASS,
655                              "VAYUDSPPWR_open",
656                              status,
657                              "Invalid procId specified");
658     }
659     else {
660 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
661         /* Initialize return parameter handle. */
662         *handlePtr = NULL;
664         /* Check if the PwrMgr exists and return the handle if found. */
665         if (VAYUDSPPWR_state.pwrHandles [procId] == NULL) {
666             /*! @retval PWRMGR_E_NOTFOUND Specified instance not found */
667             status = PWRMGR_E_NOTFOUND;
668             GT_setFailureReason (curTrace,
669                               GT_4CLASS,
670                               "VAYUDSPPWR_open",
671                               status,
672                               "Specified VAYUDSPPWR instance does not exist!");
673         }
674         else {
675             *handlePtr = VAYUDSPPWR_state.pwrHandles [procId];
676         }
677 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
678     }
679 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
681     GT_1trace (curTrace, GT_LEAVE, "VAYUDSPPWR_open", status);
683     /*! @retval PWRMGR_SUCCESS Operation successful */
684     return status;
688 /*!
689  *  @brief      Function to close a handle to an instance of this PwrMgr.
690  *
691  *  @param      handlePtr  Pointer to Handle to the PwrMgr instance
692  *
693  *  @sa         VAYUDSPPWR_open
694  */
695 Int
696 VAYUDSPPWR_close (VAYUDSPPWR_Handle * handlePtr)
698     Int status = PWRMGR_SUCCESS;
700     GT_1trace (curTrace, GT_ENTER, "VAYUDSPPWR_close", handlePtr);
702     GT_assert (curTrace, (handlePtr != NULL));
703     GT_assert (curTrace, ((handlePtr != NULL) && (*handlePtr != NULL)));
705 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
706     if (handlePtr == NULL) {
707         /*! @retval PWRMGR_E_INVALIDARG Invalid NULL handlePtr pointer
708                                          specified*/
709         status = PWRMGR_E_INVALIDARG;
710         GT_setFailureReason (curTrace,
711                              GT_4CLASS,
712                              "VAYUDSPPWR_close",
713                              status,
714                              "Invalid NULL handlePtr pointer specified");
715     }
716     else if (*handlePtr == NULL) {
717         /*! @retval PWRMGR_E_HANDLE Invalid NULL *handlePtr specified */
718         status = PWRMGR_E_HANDLE;
719         GT_setFailureReason (curTrace,
720                              GT_4CLASS,
721                              "VAYUDSPPWR_close",
722                              status,
723                              "Invalid NULL *handlePtr specified");
724     }
725     else {
726 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
727         /* Nothing to be done for close. */
728         *handlePtr = NULL;
729 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
730     }
731 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
733     GT_1trace (curTrace, GT_LEAVE, "VAYUDSPPWR_close", status);
735     /*! @retval PWRMGR_SUCCESS Operation successful */
736     return status;
740 /* =============================================================================
741  * APIs called by PwrMgr module (part of function table interface)
742  * =============================================================================
743  */
744 /*!
745  *  @brief      Function to attach to the PwrMgr.
746  *
747  *  @param      handle  Handle to the PwrMgr instance
748  *  @param      params  Attach parameters
749  *
750  *  @sa         VAYUDSPPWR_detach
751  */
752 Int
753 VAYUDSPPWR_attach (PwrMgr_Handle handle, PwrMgr_AttachParams * params)
755     Int status                        = PWRMGR_SUCCESS;
756     PwrMgr_Object *      pwrMgrHandle = (PwrMgr_Object *) handle;
757     VAYUDSPPWR_Object *  object    = NULL;
758     Memory_MapInfo       mapInfo;
759     /* Mapping for prcm base is done in VAYUVIDEOM3_phyShmemInit */
761     GT_2trace (curTrace, GT_ENTER, "VAYUDSPPWR_attach", handle, params);
763     GT_assert (curTrace, (handle != NULL));
764     GT_assert (curTrace, (params != NULL));
766 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
767     if (handle == NULL) {
768         /*! @retval PWRMGR_E_HANDLE Invalid argument */
769         status = PWRMGR_E_HANDLE;
770         GT_setFailureReason (curTrace,
771                              GT_4CLASS,
772                              "VAYUDSPPWR_attach",
773                              status,
774                              "Invalid handle specified");
775     }
776     else {
777 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
778         object = (VAYUDSPPWR_Object *) pwrMgrHandle->object;
779         GT_assert (curTrace, (object != NULL));
780         /* Map and get the virtual address for system control module */
781         mapInfo.src      = PRCM_BASE_ADDR;
782         mapInfo.size     = PRCM_SIZE;
783         mapInfo.isCached = FALSE;
784         status = Memory_map (&mapInfo);
785 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
786         if (status < 0) {
787             status = VAYUDSPPWR_E_FAIL;
788             GT_setFailureReason (curTrace,
789                                  GT_4CLASS,
790                                  "VAYUDSPPWR_attach",
791                                  status,
792                                  "Failure in mapping prcm module");
793         }
794         else {
795 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
796             object->prcmVA = mapInfo.dst;
798             /* Map and get the virtual address for system control module */
799             mapInfo.src      = CTRL_MODULE_BASE_ADDR;
800             mapInfo.size     = CTRL_MODULE_SIZE;
801             mapInfo.isCached = FALSE;
802             status = Memory_map (&mapInfo);
803 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
804             if (status < 0) {
805                 status = VAYUDSPPWR_E_FAIL;
806                 GT_setFailureReason (curTrace,
807                                      GT_4CLASS,
808                                      "VAYUDSPPWR_attach",
809                                      status,
810                                      "Failure in mapping prcm module");
811             }
812             else {
813 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
814                 object->controlVA = mapInfo.dst;
816                 /* Map and get the virtual address for system l2 ram */
817                 mapInfo.src      = GEM_L2RAM_BASE_ADDR;
818                 mapInfo.size     = GEM_L2RAM_SIZE;
819                 mapInfo.isCached = FALSE;
820                 status = Memory_map (&mapInfo);
821 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
822                 if (status < 0) {
823                     status = VAYUDSPPWR_E_FAIL;
824                     GT_setFailureReason (curTrace,
825                                          GT_4CLASS,
826                                          "VAYUDSPPWR_attach",
827                                          status,
828                                          "Failure in mapping prcm module");
829                 }
830                 else {
831 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
832                 object->l2baseVA = mapInfo.dst;
833 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
834                 }
835             }
836         }
837     }
838 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
839     /*! @retval PWRMGR_SUCCESS Operation successful */
840     GT_1trace (curTrace, GT_LEAVE, "VAYUDSPPWR_attach", status);
841     return (status);
846 /*!
847  *  @brief      Function to detach from the PwrMgr.
848  *
849  *  @param      handle  Handle to the PwrMgr instance
850  *
851  *  @sa         VAYUDSPPWR_attach
852  */
853 Int
854 VAYUDSPPWR_detach (PwrMgr_Handle handle)
857     Int status                     = PWRMGR_SUCCESS;
858     PwrMgr_Object * pwrMgrHandle   = (PwrMgr_Object *) handle;
859     VAYUDSPPWR_Object * object = NULL;
860     Memory_UnmapInfo     unmapInfo;
863     /* Mapping for prcm base is done in VAYUVIDEOM3_phyShmemInit */
865     GT_1trace (curTrace, GT_ENTER, "VAYUDSPPWR_detach", handle);
867     GT_assert (curTrace, (handle != NULL));
869 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
870     if (handle == NULL) {
871         /*! @retval PWRMGR_E_HANDLE Invalid argument */
872         status = PWRMGR_E_HANDLE;
873         GT_setFailureReason (curTrace,
874                              GT_4CLASS,
875                              "VAYUDSPPWR_detach",
876                              status,
877                              "Invalid handle specified");
878     }
879     else {
880 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
881         object = (VAYUDSPPWR_Object *) pwrMgrHandle->object;
882         GT_assert (curTrace, (object != NULL));
884         if (object->controlVA != 0x0) {
885             /* Unmap the virtual address for control module */
886             unmapInfo.addr = object->controlVA;
887             unmapInfo.size = CTRL_MODULE_SIZE;
888             unmapInfo.isCached = FALSE;
889             if (unmapInfo.addr != 0) {
890                 status = Memory_unmap (&unmapInfo);
891 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
892                 if (status < 0) {
893                     status = VAYUDSPPWR_E_FAIL;
894                     GT_setFailureReason (curTrace,
895                                          GT_4CLASS,
896                                          "VAYUDSPPWR_detach",
897                                          status,
898                                          "Failure in mapping prcm module");
899                 }
900 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
901             }
902         }
903         if (object->prcmVA != 0x0) {
904             /* Unmap the virtual address for prcm module */
905             unmapInfo.addr = object->prcmVA;
906             unmapInfo.size = PRCM_SIZE;
907             unmapInfo.isCached = FALSE;
908             if (unmapInfo.addr != 0) {
909                 status = Memory_unmap (&unmapInfo);
910 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
911                 if (status < 0) {
912                     status = VAYUDSPPWR_E_FAIL;
913                     GT_setFailureReason (curTrace,
914                                          GT_4CLASS,
915                                          "VAYUDSPPWR_detach",
916                                          status,
917                                          "Failure in mapping prcm module");
918                 }
919 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
920             }
921         }
922         if (object->l2baseVA != 0x0) {
923             /* Unmap the virtual address for prcm module */
924             unmapInfo.addr = object->l2baseVA;
925             unmapInfo.size = GEM_L2RAM_SIZE;
926             unmapInfo.isCached = FALSE;
927             if (unmapInfo.addr != 0) {
928                 status = Memory_unmap (&unmapInfo);
929 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
930                 if (status < 0) {
931                     status = VAYUDSPPWR_E_FAIL;
932                     GT_setFailureReason (curTrace,
933                                          GT_4CLASS,
934                                          "VAYUDSPPWR_detach",
935                                          status,
936                                          "Failure in mapping prcm module");
937                 }
938 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
939             }
940         }
941 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
942     }
943 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
945     GT_1trace (curTrace, GT_LEAVE, "VAYUDSPPWR_detach", status);
946     /*! @retval PWRMGR_SUCCESS Operation successful */
947     return (status);
952 /*!
953  *  @brief      Function to power on the slave processor.
954  *
955  *              Power on the IVA subsystem, hold the DSP and SEQ in reset, and
956  *              release IVA2_RST. This is a hostile reset of the IVA. If the IVA
957  *              is already powered on, then it must be powered off in order to
958  *              terminate all current activity and initiate a power-on-reset
959  *              transition to bring the IVA to a know good state.
960  *
961  *  @param      handle    Handle to the PwrMgr instance
962  *
963  *  @sa         VAYUDSPPWR_off
964  */
965 Int
966 VAYUDSPPWR_on (PwrMgr_Handle handle)
969     Int                  status       = PWRMGR_SUCCESS ;
971 #if !defined (NETRA_SIMULATOR) /* Commented for simulator */
972     PwrMgr_Object *      pwrMgrHandle = (PwrMgr_Object *) handle;
973     VAYUDSPPWR_Object * object   = NULL;
975     GT_1trace (curTrace, GT_ENTER, "VAYUDSPPWR_on", handle);
977     GT_assert (curTrace, (handle != NULL));
979 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
980     if (handle == NULL) {
981         /*! @retval PWRMGR_E_HANDLE Invalid argument */
982         status = PWRMGR_E_HANDLE;
983         GT_setFailureReason (curTrace,
984                              GT_4CLASS,
985                              "VAYUDSPPWR_on",
986                              status,
987                              "Invalid handle specified");
988     }
989     else {
990 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
991         object = (VAYUDSPPWR_Object *) pwrMgrHandle->object;
992         GT_assert (curTrace, (object != NULL));
994         /* Enable spinlocks, mailbox and timers before powering on dsp */
995         object->dspSpinlockHandle = ClockOps_get(object->clockHandle, "spinbox_ick");
997         /* Do not put this check under SYSLINK_BUILD_OPTIMIZE */
998         GT_assert (curTrace, (object->dspSpinlockHandle != NULL));
999         status = ClockOps_enable(object->clockHandle, object->dspSpinlockHandle);
1000         if (status < 0) {
1001             /*! @retval PWRMGR_E_HANDLE Invalid argument */
1002             status = PWRMGR_E_FAIL;
1003             GT_setFailureReason (curTrace,
1004                                  GT_4CLASS,
1005                                  "VAYUDSPPWR_on",
1006                                  status,
1007                                  "ClockOps_enable failed");
1008         }
1009         object->dspMailboxHandle = ClockOps_get(object->clockHandle, "mailbox_ick");
1010         /* Do not put this check under SYSLINK_BUILD_OPTIMIZE */
1011         GT_assert (curTrace, (object->dspMailboxHandle != NULL));
1012         status = ClockOps_enable(object->clockHandle, object->dspMailboxHandle);
1013         GT_assert (curTrace, (status >= 0));
1015         /* GP timer4 is actually timer 3 for bios it will be enabled from bios
1016          * Here we are enabling the gptimer 4 clk module
1017          */
1019         object->dspTimerIclkHandle = ClockOps_get(object->clockHandle, "gpt4_ick");
1020         /* Do not put this check under SYSLINK_BUILD_OPTIMIZE */
1021         GT_assert (curTrace, (object->dspTimerIclkHandle != NULL));
1022         status = ClockOps_enable(object->clockHandle, object->dspTimerIclkHandle);
1023         GT_assert (curTrace, (status >= 0));
1025         object->dspTimerFclkHandle = ClockOps_get(object->clockHandle, "gpt4_fck");
1026         /* Do not put this check under SYSLINK_BUILD_OPTIMIZE */
1027         GT_assert (curTrace, (object->dspTimerFclkHandle != NULL));
1028         status = ClockOps_enable(object->clockHandle, object->dspTimerFclkHandle);
1029         GT_assert (curTrace, (status >= 0));
1031         /* Enable Dsp MMU clocks */
1033         object->dspMmuCfgClkHandle = ClockOps_get(object->clockHandle, "mmu_cfg_ick");
1034         /* Do not put this check under SYSLINK_BUILD_OPTIMIZE */
1035         GT_assert (curTrace, (object->dspMmuCfgClkHandle != NULL));
1036         status = ClockOps_enable(object->clockHandle, object->dspMmuCfgClkHandle);
1037         GT_assert (curTrace, (status >= 0));
1039         object->dspMmuClkHandle = ClockOps_get(object->clockHandle, "mmu_ick");
1040         /* Do not put this check under SYSLINK_BUILD_OPTIMIZE */
1041         GT_assert (curTrace, (object->dspMmuClkHandle != NULL));
1042         status = ClockOps_enable(object->clockHandle, object->dspMmuClkHandle);
1043         GT_assert (curTrace, (status >= 0));
1044         object->dspClkHandle = ClockOps_get(object->clockHandle, "gem_ick");
1046         GT_assert (curTrace, (object->dspClkHandle != NULL));
1047         status = ClockOps_enable(object->clockHandle, object->dspClkHandle);
1048         GT_assert (curTrace, (status >= 0));
1050                 /* Warm Reset to  access Internal RAM of DSP - to access internal RAM */
1051 //              REG((object->prcmVA) + RM_ACTIVE_RSTCTRL) = 0x01;
1053 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
1054     }
1055 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
1056     GT_1trace (curTrace, GT_LEAVE, "VAYUDSPPWR_on", status);
1057     /*! @retval PWRMGR_SUCCESS Operation successful */
1058 #endif /*#if !defined (NETRA_SIMULATOR)*/
1059     return (status);
1063 /*!
1064  *  @brief      Function to power off the slave processor.
1065  *
1066  *              Turn the IVA power domain off. To ensure a clean power-off
1067  *              transition, the IVA subsystem must first be turned on so that
1068  *              the DSP can initiate an autonomous power-off transition.
1069  *
1070  *  @param      handle    Handle to the PwrMgr instance
1071  *  @param      force     Indicates whether power-off is to be forced
1072  *
1073  *  @sa         VAYUDSPPWR_on
1074  */
1075 Int
1076 VAYUDSPPWR_off (PwrMgr_Handle handle, Bool force)
1078     Int                  status       = PWRMGR_SUCCESS ;
1079     PwrMgr_Object *      pwrMgrHandle = (PwrMgr_Object *) handle;
1080     VAYUDSPPWR_Object * object   = NULL;
1082     GT_1trace (curTrace, GT_ENTER, "VAYUDSPPWR_off", handle);
1084     GT_assert (curTrace, (handle != NULL));
1086 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
1087     if (handle == NULL) {
1088         /*! @retval PWRMGR_E_HANDLE Invalid argument */
1089         status = PWRMGR_E_HANDLE;
1090         GT_setFailureReason (curTrace,
1091                              GT_4CLASS,
1092                              "VAYUDSPPWR_off",
1093                              status,
1094                              "Invalid handle specified");
1095     }
1096     else {
1097 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
1098         object = (VAYUDSPPWR_Object *) pwrMgrHandle->object;
1099         GT_assert (curTrace, (object != NULL));
1102         /* Disable Dsp mmu clocks */
1103         if(object->dspMmuClkHandle) {
1104             ClockOps_disable(object->clockHandle, object->dspMmuClkHandle);
1105             ClockOps_put(object->clockHandle, object->dspMmuClkHandle);
1106         }
1107         /* Disable Dsp mmu cfg clocks */
1108         if(object->dspMmuCfgClkHandle) {
1109             ClockOps_disable(object->clockHandle, object->dspMmuCfgClkHandle);
1110             ClockOps_put(object->clockHandle, object->dspMmuCfgClkHandle);
1111         }
1113         /* assert DSP standby, removed to fix DSP internal memory load, -rams */
1114 //      REG(object->controlVA + DSP_IDLE_CFG) |= 0x8000;
1116         /* Disable GEM clocks */
1117         if(object->dspClkHandle) {
1118             ClockOps_disable(object->clockHandle, object->dspClkHandle);
1119             ClockOps_put(object->clockHandle, object->dspClkHandle);
1120         }
1122         /* Disable  Timer4 functional clocks */
1123         if(object->dspTimerFclkHandle) {
1124             ClockOps_disable(object->clockHandle, object->dspTimerFclkHandle);
1125             ClockOps_put(object->clockHandle, object->dspTimerFclkHandle);
1126         }
1127         /* Disable Timer4 interface clocks */
1128         if(object->dspTimerIclkHandle) {
1129             ClockOps_disable(object->clockHandle, object->dspTimerIclkHandle);
1130             ClockOps_put(object->clockHandle, object->dspTimerIclkHandle);
1131         }
1132         /* Disable Mailbox clocks */
1133         if(object->dspMailboxHandle) {
1134             ClockOps_disable(object->clockHandle, object->dspMailboxHandle);
1135             ClockOps_put(object->clockHandle, object->dspMailboxHandle);
1136         }
1137         /* Disable Spinlock clocks */
1138         if(object->dspSpinlockHandle) {
1139             ClockOps_disable(object->clockHandle, object->dspSpinlockHandle);
1140             ClockOps_put(object->clockHandle, object->dspSpinlockHandle);
1141         }
1143 #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
1144     }
1145 #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
1146     GT_1trace (curTrace, GT_LEAVE, "VAYUDSPPWR_off", status);
1147     /*! @retval PWRMGR_SUCCESS Operation successful */
1148     return (status);
1152 #if defined (__cplusplus)
1154 #endif /* defined (__cplusplus) */