dab0536bf2b7ecd0830deb0a00c43768abf6b3ed
[ipc/ipcdev.git] / qnx / src / ipc3x_dev / ti / syslink / family / common / ClockOps.c
1 /*
2  *  @file   ClockOps.c
3  *
4  *  @brief      Generic clock module interface across platforms and OS
5  *
6  *
7  *  ============================================================================
8  *
9  *  Copyright (c) 2008-2012, Texas Instruments Incorporated
10  *
11  *  Redistribution and use in source and binary forms, with or without
12  *  modification, are permitted provided that the following conditions
13  *  are met:
14  *
15  *  *  Redistributions of source code must retain the above copyright
16  *     notice, this list of conditions and the following disclaimer.
17  *
18  *  *  Redistributions in binary form must reproduce the above copyright
19  *     notice, this list of conditions and the following disclaimer in the
20  *     documentation and/or other materials provided with the distribution.
21  *
22  *  *  Neither the name of Texas Instruments Incorporated nor the names of
23  *     its contributors may be used to endorse or promote products derived
24  *     from this software without specific prior written permission.
25  *
26  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
27  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
28  *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29  *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
30  *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31  *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32  *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
33  *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
34  *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
35  *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
36  *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37  *  Contact information for paper mail:
38  *  Texas Instruments
39  *  Post Office Box 655303
40  *  Dallas, Texas 75265
41  *  Contact information:
42  *  http://www-k.ext.ti.com/sc/technical-support/product-information-centers.htm?
43  *  DCMP=TIHomeTracking&HQS=Other+OT+home_d_contact
44  *  ============================================================================
45  *
46  */
49 /* Standard headers */
50 #include <ti/syslink/Std.h>
51 /* Module level headers */
52 #include <ti/syslink/inc/ClockOps.h>
54 /* standard include for reg access */
55 #include <stdint.h>
56 #include <sys/mman.h>
57 #include <hw/inout.h>
59 #include <ti/syslink/inc/Dm8168Clock.h>
60 //#include <ti/syslink/inc/ClockOps.h>
61 #include <ti/syslink/utils/Trace.h>
62 #include <ti/syslink/utils/String.h>
65 #if defined (__cplusplus)
66 extern "C" {
67 #endif
69 /*Function Prototypes */
70 void prcm_enable(UInt32 clkstctrl, UInt32 clkctrl, UInt32 regVal1, UInt32 regVal2, UInt32 cmpVal1, UInt32 cmpVal2, UInt32 wait1, UInt32 wait2);
71 void GEMSSClkEnable(void);
72 void GEMSSClkDisable(void);;
73 void DucatiClkEnable(void) ;
74 void DucatiClkDisable(void) ;
75 void prcm_disable_spinbox(void);
76 void prcm_disable_mailbox(void);
77 void prcm_disable_gptimer4(void);
81 #define LAST_CORE 1
83 String handleArray[] = {
85 "spinbox_ick",
86 "mailbox_ick",
87 "gpt4_ick",
88 "gpt4_fck",
89 "mmu_ick",
90 "mmu_cfg_ick",
91 "gem_ick" /* dsp_ick string is changed in latest linux release to gem_ick*/
92 };
94 typedef enum {
95     SPINBOX=1,
96     MAILBOX=2,
97     IGPTIMER4=3,
98     FGPTIMER4=4,
99     MMU=5,
100     MMUCFG=6,
101     DSP=7,
102     DUCATI=8
103 }clkType;
105 /* =============================================================================
106  *  Macros and types
107  * =============================================================================
108  */
109 #define PRCM_BASE_ADDR              0x48180000
110 #define PRCM_SIZE                   0x00003000
111 #define PM_ACTIVE_PWRSTST           0x00000A04
113 #define CM_MMU_CLKSTCTRL            0x0000140C
114 #define CM_ALWON_MMUDATA_CLKCTRL    0x0000159C
115 #define CM_MMUCFG_CLKSTCTRL         0x00001410
116 #define CM_ALWON_MMUCFG_CLKCTRL     0x000015A8
118 #define GEM_L2RAM_BASE_ADDR         0x40800000
119 #define GEM_L2RAM_SIZE              0x00040000
120 #define DSPMEM_SLEEP                0x00000650
122 #define OSC_0                       20
123 #define OSC_1                       20
124 #define PLL_BASE_ADDRESS            0x481C5000
125 #define DSP_PLL_BASE                (PLL_BASE_ADDRESS+0x080)
126 #define DSPBOOTADDR                 0x00000048
127 #define CM_ALWON_SPINBOX_CLKCTRL    0x00001598
128 #define CM_ALWON_MAILBOX_CLKCTRL    0x00001594
129 #define CM_ALWON_L3_SLOW_CLKSTCTRL  0x00001400
130 #define CM_ALWON_TIMER_4_CLKCTRL    0x0000157C
131 #define CTRL_MODULE_BASE_ADDR       0x48140000
133 #define RM_DEFAULT_RSTCTRL          0x00000B10
134 #define RM_DEFAULT_RSTST            0x00000B14
135 #define CM_DEFAULT_DUCATI_CLKSTCTRL 0x00000518
136 #define CM_DEFAULT_DUCATI_CLKCTRL   0x00000574
138 /* for gptimer4 fck */
139 #define CM_SYSCLK18_CLKSEL          0x00000378
140 #define CM_DMTIMER_CLKSRC           0x000002E0
141 #define CM_SYSCLK18_CLKSRC          0x000002F0
142 #define CM_DPLL_SYSCLK18_CLKSEL     (PRCM_BASE_ADDR+CM_SYSCLK18_CLKSEL)
143 #define SYSCLK18_CLKSRC             (PLL_BASE_ADDRESS+CM_SYSCLK18_CLKSRC)
144 #define DMTIMER_CLKSRC              (PLL_BASE_ADDRESS+CM_DMTIMER_CLKSRC)
146 #define ADPLLJ_CLKCRTL_HS2    0x00000801 //HS2 Mode,TINTZ =1  --used by all PLL's except HDMI
148 /* ISS PLL releated defines */
149 #define ISS_PLL_BASE            (PLL_BASE_ADDRESS+0x140)
152 //ADPLL intrnal Offset Registers
153 #define CLKCTRL                                 0x4
154 #define TENABLE                                 0x8
155 #define TENABLEDIV                              0xC
156 #define M2NDIV                                  0x10
157 #define MN2DIV                                  0x14
158 #define STATUS                                  0x24
160 /*!
161  *  @brief  PRM address for GEM
162  */
163 #define CM_GEM_CLKSTCTRL                0x400
164 /*!
165  *  @brief  Clock mgmt for GEM
166  */
167 #define CM_ACTIVE_GEM_CLKCTRL           0x420
168 /*!
169  *  @brief  Reset control for GEM
170  */
171 #define RM_ACTIVE_RSTCTRL               0xA10
172 /*!
173  *  @brief  Reset status for GEM
174  */
175 #define RM_ACTIVE_RSTST                 0xA14
177 #define REMAP(x)             (mmap_device_io(4,x))
178 #define UNMAP(x)             (munmap_device_io(x,4))
179 #define REGWR(x,y)           (out32(x,y))
180 #define REGRD(x)             (in32(x))
181 #define REGRDMWR(x, mask, val) REGWR(x,((REGRD(x) & mask) | val))
183 /* =============================================================================
184  * Static globals
185  * =============================================================================
186  */
187 UInt32 refSpinCount = 0;
188 UInt32 refMboxCount = 0;
189 UInt32 refGptimer4ick = 0;
190 UInt32 refGptimer4fck = 0;
191 UInt32 refDSP = 0;
192 UInt32 refDucati = 0;
194 /* =============================================================================
195  * APIs called by DM8168VIDEOM3PROC module
196  * =============================================================================
197  */
198 /*!
199  *  @brief      Function returns the clock handle .
200  *
201  *  @clkHandle   clk handle returned to corresponding clk name
202  *  @clkname     name of clk for which handle is to be obtained
203  *
204  *  @sa         DM8168CLOCK_put
205  */
206 Ptr
207 ClockOps_get (ClockOps_Handle handle, String clkName)
209     clkType ctype = SPINBOX;
211     if (!String_cmp(clkName,"spinbox_ick")) {
212         ctype = SPINBOX;
213     }
214     else if (!String_cmp(clkName,"mailbox_ick")) {
215         ctype = MAILBOX;
216     }
217     else if (!String_cmp(clkName,"gpt4_ick")) {
218         ctype = IGPTIMER4;
219     }
220     else if (!String_cmp(clkName,"gpt4_fck")) {
221         ctype = FGPTIMER4;
222     }
223     else if (!String_cmp(clkName,"mmu_ick")) {
224         ctype = MMU;
225     }
226     else if (!String_cmp(clkName,"mmu_cfg_ick")) {
227         ctype = MMUCFG;
228     }
229 /* dsp_ick string is changed in latest linux release to gem_ick*/
230     else if (!String_cmp(clkName,"gem_ick")) {
231         ctype = DSP;
232     }
233     else if (!String_cmp(clkName,"ducati_ick")) {
234         ctype = DUCATI;
235     }
236     else {
237         /* should not come here */
238     }
240     return ((Ptr)ctype);
243 /*!
244  *  @brief      Function returns the clock handle .
245  *
246  *  @clkHandle   clk handle returned to corresponding clk name
247  *  @clkname     name of clk for which handle is to be obtained
248  *
249  *  @sa         DM8168CLOCK_put
250  */
251 Void
252 ClockOps_put(ClockOps_Handle handle, Ptr clkHandle)
254     //clk_put((struct clk *)clkHandle);
256 /*!
257  *  @brief      Function returns the clock handle .
258  *
259  *  @clkHandle   clk handle returned to corresponding clk name
260  *  @clkname     name of clk for which handle is to be obtained
261  *
262  *  @sa         ClockOps_put
263  */
264 Int32
265 ClockOps_enable(ClockOps_Handle handle, Ptr clkHandle)
267 #if defined(SYSLINK_PLATFORM_TI81XX)
268     switch ((UInt32)clkHandle){
270             case SPINBOX:
271                 if (refSpinCount == 0) {
272                     /*Enable Clock to SPIN box*/
273                     prcm_enable(0, PRCM_BASE_ADDR+CM_ALWON_SPINBOX_CLKCTRL, 0 , 2, 0x0, 0x100, TRUE, FALSE);
274                     refSpinCount++;
275                 }
276                 else if(refSpinCount > 0) {
277                     refSpinCount++;
278                 }
279                 else {
280                     /* refSpinCount should not be less than zero */
281                 }
282                 break;
283             case MAILBOX:
284                 if (refMboxCount == 0) {
285                     /*Enable Clock to mail box*/
286                     prcm_enable(0, PRCM_BASE_ADDR+CM_ALWON_MAILBOX_CLKCTRL, 0 , 2, 0x0, 0x100, TRUE, FALSE);
287                     refMboxCount++;
288                 }
289                 else if(refMboxCount > 0) {
290                     refMboxCount++;
291                 }
292                 else {
293                     /* refMboxCount should not be less than zero */
294                 }
295                 break;
296             case IGPTIMER4:
297                 if (refGptimer4ick == 0) {
298                     prcm_enable(PRCM_BASE_ADDR+CM_ALWON_L3_SLOW_CLKSTCTRL , PRCM_BASE_ADDR+CM_ALWON_TIMER_4_CLKCTRL, 2, 2, 0x0, 0x100, TRUE, TRUE);
299                     refGptimer4ick++;
300                 }
301                 else if(refGptimer4ick > 0) {
302                     refGptimer4ick++;
303                 }
304                 else {
305                     /* refGptimer4ick should not be less than zero */
306                 }
307                 break;
308             case FGPTIMER4:
309                 if (refGptimer4fck == 0) {
310 #ifdef CLOCK_FIX
311                     uintptr_t sysclk18ClksrcPtr = REMAP(SYSCLK18_CLKSRC);
312                     uintptr_t clkselPtr = REMAP(CM_DPLL_SYSCLK18_CLKSEL);
313                     uintptr_t dmtimerClksrcPtr = REMAP(DMTIMER_CLKSRC);
315                     /* CLKIN32/RTCDIVIDER multiplexor */
316                     REGRDMWR(sysclk18ClksrcPtr, 0xFFFFFFFE, 0);
318                     /* sysclk18 */
319                     REGRDMWR(clkselPtr, 0xFFFFFFFE, 0);
321                     /* timer4 */
322                     REGRDMWR(dmtimerClksrcPtr, 0xFFF8FFFF, 0);
324                     UNMAP(sysclk18ClksrcPtr);
325                     UNMAP(clkselPtr);
326                     UNMAP(dmtimerClksrcPtr);
327 #endif
328                     refGptimer4fck++;
329                 }
330                 else if(refGptimer4fck > 0) {
331                     refGptimer4fck++;
332                 }
333                 else {
334                     /* refGptimer4fck should not be less than zero */
335                 }
336                 break;
337             case MMU:
338                 /* required config is done as a part of the case DSP */
339                 break;
340             case MMUCFG:
341                 /* required config is done as a part of the case DSP */
342                 break;
343             case DSP:
344                 if (refDSP == 0) {
345                     GEMSSClkEnable();
346                     refDSP++;
347                 }
348                 break;
349             case DUCATI:
350                 if (refDucati == 0) {
351                     DucatiClkEnable();
352                     refDucati++;
353                 }
354                 break;
355             default:
356                 break;
358             }
359 #endif
360     return 1;
362 /*!
363  *  @brief      Function returns the clock handle .
364  *
365  *  @clkHandle   clk handle returned to corresponding clk name
366  *  @clkname     name of clk for which handle is to be obtained
367  *
368  *  @sa         ClockOps_put
369  */
370 Void
371 ClockOps_disable(ClockOps_Handle handle, Ptr clkHandle)
373 #if defined(SYSLINK_PLATFORM_TI81XX)
374    switch ((UInt32)clkHandle){
376             case SPINBOX:
377                 /*disable Clock to SPIN box*/
378                 if (refSpinCount == LAST_CORE) {
379                     prcm_disable_spinbox();
380                     refSpinCount = 0;
381                 }
382                 else if(refSpinCount > LAST_CORE) {
383                     refSpinCount--;
384                 }
385                 else {
386                     /* refSpinCount is less that or equal to zero */
387                 }
388                 break;
389             case MAILBOX:
390                 /*disable Clock to MAIL box*/
391                 if (refMboxCount == LAST_CORE) {
392                     prcm_disable_mailbox();
393                     refMboxCount = 0;
394                 }
395                 else if(refMboxCount > LAST_CORE) {
396                     refMboxCount--;
397                 }
398                 else {
399                     /* refMboxCount is less that or equal to zero */
400                 }
401                 break;
402             case IGPTIMER4:
403                 if ( refGptimer4ick == LAST_CORE) {
404                     prcm_disable_gptimer4();
405                     refGptimer4ick = 0;
406                     refGptimer4fck = 0;
407                 }
408                 else if(refGptimer4ick > LAST_CORE) {
409                     refGptimer4ick--;
410                 }
411                 else {
412                     /* refGptimer4ick is less that or equal to zero */
413                 }
414                 break;
415             case FGPTIMER4:
416                 break;
417             case MMU:
418                 break;
419             case MMUCFG:
420                 break;
421             case DSP:
422                 if (refDSP > 0 ) {
423                     GEMSSClkDisable();
424                     refDSP = 0;
425                 }
426                 break;
427             case DUCATI:
428                 if (refDucati > 0) {
429                     DucatiClkDisable();
430                     refDucati = 0;
431                 }
432                 break;
433             default:
434                 break;
436             }
437 #endif
440 /*!
441  *  @brief      Function returns the clock handle .
442  *
443  *  @clkHandle   clk handle returned to corresponding clk name
444  *  @clkname     name of clk for which handle is to be obtained
445  *
446  *  @sa         ClockOps_put
447  */
448 ULong
449 ClockOps_getRate(ClockOps_Handle handle, Ptr clkHandle)
451     //return(clk_get_rate((struct clk *)clkHandle));
452     return 1;
455 /*!
456  *  @brief      Function returns the clock handle .
457  *
458  *  @clkHandle   clk handle returned to corresponding clk name
459  *  @clkname     name of clk for which handle is to be obtained
460  *
461  *  @sa         ClockOps_put
462  */
463 Int32
464 ClockOps_setRate(ClockOps_Handle handle, Ptr clkHandle, ULong rate)
466     //return (clk_set_rate((struct clk *)clkHandle, rate));
467     return 1;
470 void PLL_Clocks_Config(UInt32 Base_Address,UInt32 OSC_FREQ,UInt32 N,UInt32 M,UInt32 M2,UInt32 CLKCTRL_VAL)
472 #if defined(SYSLINK_PLATFORM_TI81XX)
473     UInt32 m2nval,mn2val,read_clkctrl;
474     Int32 i = 0;
476     uintptr_t m2ndivPtr = REMAP(Base_Address+M2NDIV);
477     uintptr_t mn2divPtr = REMAP(Base_Address+MN2DIV);
478     uintptr_t tenabledivPtr = REMAP(Base_Address+TENABLEDIV);
479     uintptr_t tenablePtr = REMAP(Base_Address+TENABLE);
480     uintptr_t clkctrlPtr = REMAP(Base_Address+CLKCTRL);
481     uintptr_t statusPtr = REMAP(Base_Address+STATUS);
483     m2nval = (M2<<16) | N;
484     mn2val =  M;
486     REGWR(m2ndivPtr, m2nval);
487     REGWR(mn2divPtr, mn2val);
488     REGWR(tenabledivPtr, 0x1);
489     REGWR(tenabledivPtr, 0x0);
490     REGWR(tenablePtr, 0x1);
491     REGWR(tenablePtr, 0x0);
493     read_clkctrl = REGRD(clkctrlPtr);
495     //configure the TINITZ(bit0) and CLKDCO BITS IF REQUIRED
496     REGWR(clkctrlPtr, ((read_clkctrl & 0xff7fe3ff) | CLKCTRL_VAL));
498     read_clkctrl = REGRD(clkctrlPtr);
500     // poll for the freq,phase lock to occur
501     while ((REGRD(statusPtr) & 0x00000600) != 0x00000600);
503     //wait fot the clocks to get stabized
504     for (i = 0; i <1000; i++)
505     {
506         ;
507     }
509     UNMAP(m2ndivPtr);
510     UNMAP(mn2divPtr);
511     UNMAP(tenabledivPtr);
512     UNMAP(tenablePtr);
513     UNMAP(clkctrlPtr);
514     UNMAP(statusPtr);
515 #endif
518 #if defined(SYSLINK_PLATFORM_TI81XX)
519 void prcm_enable(UInt32 clkstctrl, UInt32 clkctrl, UInt32 regVal1, UInt32 regVal2, UInt32 cmpVal1, UInt32 cmpVal2, UInt32 wait1, UInt32 wait2){
520     uintptr_t clkstctrlPtr = REMAP(PRCM_BASE_ADDR+CM_GEM_CLKSTCTRL);
522     if (clkstctrl != 0) {
523         uintptr_t clkstctrlArgPtr = REMAP(clkstctrl);
525         /*reg write using out */
526         REGWR(clkstctrlArgPtr, regVal1);
528         UNMAP(clkstctrlArgPtr);
529     }
531     if (clkstctrl == REGRD(clkstctrlPtr)) {
532         uintptr_t pwrststPtr = REMAP(PRCM_BASE_ADDR+PM_ACTIVE_PWRSTST);
533         while (REGRD(pwrststPtr)!= 0x37);    /*Check Power is ON*/
534         UNMAP(pwrststPtr);
535     }
536     UNMAP(clkstctrlPtr);
538     if (clkctrl != 0) {
539         /*reg write using out */
540         uintptr_t clkctrlArgPtr = REMAP(clkctrl);
541         REGWR(clkctrlArgPtr, regVal2);
542         UNMAP(clkctrlArgPtr);
543     }
545     if (wait1) {
546         uintptr_t clkctrlArgPtr = REMAP(clkctrl);
547         while ((REGRD(clkctrlArgPtr)&cmpVal1)!=cmpVal1);
548         UNMAP(clkctrlArgPtr);
549     }
551     if (wait2) {
552         uintptr_t clkstctrlArgPtr = REMAP(clkstctrl);
553         while ((REGRD(clkstctrlArgPtr)&cmpVal2)!=cmpVal2);
554         UNMAP(clkstctrlArgPtr);
555     }
558 void prcm_disable_spinbox(void){
559     uintptr_t clkctrlPtr = REMAP(PRCM_BASE_ADDR+CM_ALWON_SPINBOX_CLKCTRL);
560     REGRDMWR(clkctrlPtr, 0xFFFFFFFD, 0);
561     UNMAP(clkctrlPtr);
564 void prcm_disable_mailbox(void){
565     uintptr_t clkctrlPtr = REMAP(PRCM_BASE_ADDR+CM_ALWON_MAILBOX_CLKCTRL);
566     REGRDMWR(clkctrlPtr, 0xFFFFFFFD, 0);
567     UNMAP(clkctrlPtr);
570 void prcm_disable_gptimer4(void){
571     uintptr_t clkctrlPtr = REMAP(PRCM_BASE_ADDR+CM_ALWON_TIMER_4_CLKCTRL);
572     uintptr_t clkstctrlPtr = REMAP(PRCM_BASE_ADDR+CM_ALWON_L3_SLOW_CLKSTCTRL);
574     REGRDMWR(clkctrlPtr, 0xFFFFFFFD, 0);
576     REGRDMWR(clkstctrlPtr, 0xFFFFFFFD, 0);
577     UNMAP(clkctrlPtr);
578     UNMAP(clkstctrlPtr);
581 void prcm_disable_gem(void){
582     uintptr_t clkctrlPtr = REMAP(PRCM_BASE_ADDR+CM_ACTIVE_GEM_CLKCTRL);
583     uintptr_t clkstctrlPtr = REMAP(PRCM_BASE_ADDR+CM_GEM_CLKSTCTRL);
585     REGRDMWR(clkctrlPtr, 0xFFFFFFFD, 0);
587     REGRDMWR(clkstctrlPtr, 0xFFFFFFFD, 0);
588     UNMAP(clkctrlPtr);
589     UNMAP(clkstctrlPtr);
592 void prcm_disable_mmu(void){
593     uintptr_t clkctrlPtr = REMAP(PRCM_BASE_ADDR+CM_ALWON_MMUDATA_CLKCTRL);
594     uintptr_t clkstctrlPtr = REMAP(PRCM_BASE_ADDR+CM_MMU_CLKSTCTRL);
596     REGRDMWR(clkctrlPtr, 0xFFFFFFFD, 0);
598     REGRDMWR(clkstctrlPtr, 0xFFFFFFFD, 0);
599     UNMAP(clkctrlPtr);
600     UNMAP(clkstctrlPtr);
603 void prcm_disable_mmuconfig(void){
604     uintptr_t clkctrlPtr = REMAP(PRCM_BASE_ADDR+CM_ALWON_MMUCFG_CLKCTRL);
605     uintptr_t clkstctrlPtr = REMAP(PRCM_BASE_ADDR+CM_MMUCFG_CLKSTCTRL);
607     REGRDMWR(clkctrlPtr, 0xFFFFFFFD, 0);
609     REGRDMWR(clkstctrlPtr, 0xFFFFFFFD, 0);
610     UNMAP(clkctrlPtr);
611     UNMAP(clkstctrlPtr);
615 void DucatiClkEnable(void)
617     UInt32 val;
618     uintptr_t rstctrlPtr = REMAP(PRCM_BASE_ADDR+RM_DEFAULT_RSTCTRL);
619     uintptr_t clkstctrlPtr = REMAP(PRCM_BASE_ADDR+CM_DEFAULT_DUCATI_CLKSTCTRL);
620     uintptr_t clkctrlPtr = REMAP(PRCM_BASE_ADDR+CM_DEFAULT_DUCATI_CLKCTRL);
622 #ifdef CLOCK_FIX
623     /* set the ISS PLL before the clock enable */
624     PLL_Clocks_Config(ISS_PLL_BASE, OSC_0, 19, 800, 2, ADPLLJ_CLKCRTL_HS2);
625 #endif
627     /* enable the ducati logic */
628     val = REGRD(rstctrlPtr);
629     val &= (~(0x1 << 4));
630     REGWR(rstctrlPtr,   val);
632     /* enable power domain transition */
633     REGWR(clkstctrlPtr, 2);
635     /* enable ducati clocks */
636     REGWR(clkctrlPtr,   2);
638     /* wait for clocks CLKIN200TR and CLKINTR to become active */
639     do {
640         val = REGRD(clkstctrlPtr);
641     } while ((val & 0x300) != 0x300);
643     /* wait for module to be fully functional */
644     do {
645         val = REGRD(clkctrlPtr);
646     } while ((val & 0x30000) != 0);
648     UNMAP(rstctrlPtr);
649     UNMAP(clkstctrlPtr);
650     UNMAP(clkctrlPtr);
654 void DucatiClkDisable(void)
656     uintptr_t rstctrlPtr = REMAP(PRCM_BASE_ADDR+RM_DEFAULT_RSTCTRL);
657     uintptr_t clkctrlPtr = REMAP(PRCM_BASE_ADDR+CM_DEFAULT_DUCATI_CLKCTRL);
658     uintptr_t clkstctrlPtr = REMAP(PRCM_BASE_ADDR+CM_DEFAULT_DUCATI_CLKSTCTRL);
659     UInt32 val;
661     /* assert reset for cores m3_0 and m3_1 */
662     val = REGRD(rstctrlPtr);
663     val |= (0x3 << 2);
664     REGWR(rstctrlPtr, val);
666     /* disable ducati clocks */
667     REGWR(clkctrlPtr, 0);
669     /* disable power domain transition */
670     REGWR(clkstctrlPtr, 0);
672     /* disable the ducati logic */
673     val = REGRD(rstctrlPtr);
674     val |= (0x1 << 4);
675     REGWR(rstctrlPtr, val);
677     /* ensure posted write has completed */
678     do {
679         val = REGRD(rstctrlPtr);
680     } while ((val & (0x1 << 4)) == 0);
682     UNMAP(rstctrlPtr);
683     UNMAP(clkctrlPtr);
684     UNMAP(clkstctrlPtr);
688 void GEMSSClkEnable(void)
691     /* set the DSP PLL before clock enable */
692     PLL_Clocks_Config(DSP_PLL_BASE,OSC_0,19,500,1,ADPLLJ_CLKCRTL_HS2);
694     /*Enable Clock to MMU CFG*/
695     prcm_enable(PRCM_BASE_ADDR+CM_MMUCFG_CLKSTCTRL, PRCM_BASE_ADDR+CM_ALWON_MMUCFG_CLKCTRL, 2 , 2, 0x0, 0x100, TRUE, TRUE);
697     /*Enable Clock to Data*/
698     prcm_enable(PRCM_BASE_ADDR+CM_MMU_CLKSTCTRL, PRCM_BASE_ADDR+CM_ALWON_MMUDATA_CLKCTRL, 2 , 2, 0x0, 0x100, TRUE, TRUE);
700     /*Enable Clock to GEMSS*/
701     prcm_enable(PRCM_BASE_ADDR+CM_GEM_CLKSTCTRL, PRCM_BASE_ADDR+CM_ACTIVE_GEM_CLKCTRL, 2 , 2, 0x0, 0x700, FALSE, TRUE);
705 void GEMSSClkDisable(void)
707     prcm_disable_gem();
708     prcm_disable_mmu();
709     prcm_disable_mmuconfig();
711 #endif
713 #if defined (__cplusplus)
716 #endif