source: svn/trunk/newcon3bcm2_21bu/magnum/basemodules/chp/7552/bchp_pwr_impl.c

Last change on this file was 2, checked in by phkim, 11 years ago

1.phkim

  1. revision copy newcon3sk r27
  • Property svn:executable set to *
File size: 23.4 KB
Line 
1/***************************************************************
2*
3* This file maps the power resource control to register writes.
4* The templates are auto-generated by generate_chp_pwr.pl,
5* but must be filled-in manually.
6*
7***************************************************************/
8
9#include "bchp.h"
10#include "bchp_priv.h"
11#include "bdbg.h"
12#include "bkni.h"
13
14#include "bchp_clkgen.h"
15#include "bchp_hdmi_tx_phy.h"
16#include "bchp_aio_misc.h"
17
18BDBG_MODULE(BCHP_PWR_IMPL);
19
20void BCHP_PWR_P_HW_AVD0_CLK_Control(BCHP_Handle handle, bool activate)
21{
22    uint32_t mask;
23    BDBG_MSG(("HW_AVD0: %s", activate?"on":"off"));
24
25    if (activate) {                           
26        /* AVD Core, CPU, SCB, 108M clock */
27        mask = (BCHP_CLKGEN_AVD0_TOP_CLOCK_ENABLE_SVD_AVD_CLOCK_ENABLE_MASK |
28                BCHP_CLKGEN_AVD0_TOP_CLOCK_ENABLE_SVD_CPU_CLOCK_ENABLE_MASK |
29                BCHP_CLKGEN_AVD0_TOP_CLOCK_ENABLE_SVD_SCB_CLOCK_ENABLE_MASK |
30                BCHP_CLKGEN_AVD0_TOP_CLOCK_ENABLE_SVD_108_CLOCK_ENABLE_MASK);
31        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_AVD0_TOP_CLOCK_ENABLE, mask, mask);
32    }
33    else {
34        /* AVD Core, CPU, SCB, 108M clock */
35        mask = (BCHP_CLKGEN_AVD0_TOP_CLOCK_ENABLE_SVD_AVD_CLOCK_ENABLE_MASK |
36                BCHP_CLKGEN_AVD0_TOP_CLOCK_ENABLE_SVD_CPU_CLOCK_ENABLE_MASK |
37                BCHP_CLKGEN_AVD0_TOP_CLOCK_ENABLE_SVD_SCB_CLOCK_ENABLE_MASK |
38                BCHP_CLKGEN_AVD0_TOP_CLOCK_ENABLE_SVD_108_CLOCK_ENABLE_MASK);
39        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_AVD0_TOP_CLOCK_ENABLE, mask, 0);     
40    }   
41
42}
43
44void BCHP_PWR_P_HW_AVD0_PWR_Control(BCHP_Handle handle, bool activate)
45{   
46    uint32_t mask;
47   
48    BSTD_UNUSED(handle);
49    BSTD_UNUSED(mask);
50
51    BDBG_MSG(("HW_AVD0_PWR: %s", activate?"on":"off"));
52
53    mask = BCHP_CLKGEN_AVD0_TOP_POWER_SWITCH_MEMORY_SVD_POWER_SWITCH_MEMORY_MASK;
54   
55    if(activate) { 
56    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_AVD0_TOP_POWER_SWITCH_MEMORY, mask, 2);
57    BKNI_Sleep(1); 
58        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_AVD0_TOP_POWER_SWITCH_MEMORY, mask, 1);
59    BKNI_Sleep(1); 
60    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_AVD0_TOP_POWER_SWITCH_MEMORY, mask, 0);
61    BKNI_Sleep(1);
62    } else {   
63    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_AVD0_TOP_POWER_SWITCH_MEMORY, mask, mask);
64    }
65
66}
67
68void BCHP_PWR_P_HW_VEC_AIO_Control(BCHP_Handle handle, bool activate)
69{
70    uint32_t mask;
71
72    BDBG_MSG(("HW_VEC_AIO: %s", activate?"on":"off"));
73
74    mask = (BCHP_CLKGEN_VEC_AIO_TOP_CLOCK_ENABLE_VEC_ALTERNATE_SCB_CLOCK_ENABLE_MASK |
75            BCHP_CLKGEN_VEC_AIO_TOP_CLOCK_ENABLE_VEC_ALTERNATE_216_CLOCK_ENABLE_MASK |
76            BCHP_CLKGEN_VEC_AIO_TOP_CLOCK_ENABLE_VEC_ALTERNATE_108_CLOCK_ENABLE_MASK |
77            BCHP_CLKGEN_VEC_AIO_TOP_CLOCK_ENABLE_VEC_ALTERNATE2_108_CLOCK_ENABLE_MASK |
78            BCHP_CLKGEN_VEC_AIO_TOP_CLOCK_ENABLE_VEC_SCB_CLOCK_ENABLE_MASK |
79            BCHP_CLKGEN_VEC_AIO_TOP_CLOCK_ENABLE_VEC_216_CLOCK_ENABLE_MASK |
80            BCHP_CLKGEN_VEC_AIO_TOP_CLOCK_ENABLE_VEC_108_CLOCK_ENABLE_MASK);
81   
82    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_VEC_AIO_TOP_CLOCK_ENABLE, mask, activate?mask:0); 
83
84}
85
86void BCHP_PWR_P_HW_RAAGA_Control(BCHP_Handle handle, bool activate)
87{
88    uint32_t mask;
89
90    BDBG_MSG(("HW_RAAGA: %s", activate?"on":"off"));
91   
92    mask = (BCHP_CLKGEN_RAAGA_DSP_TOP_CLOCK_ENABLE_RAAGA_SCB_CLOCK_ENABLE_MASK |
93            BCHP_CLKGEN_RAAGA_DSP_TOP_CLOCK_ENABLE_RAAGA_DSP_CLOCK_ENABLE_MASK |
94            BCHP_CLKGEN_RAAGA_DSP_TOP_CLOCK_ENABLE_RAAGA_108_CLOCK_ENABLE_MASK);
95   
96    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_RAAGA_DSP_TOP_CLOCK_ENABLE, mask, activate?mask:0);   
97
98}
99
100void BCHP_PWR_P_HW_AUD_PLL0_Control(BCHP_Handle handle, bool activate)
101{
102    uint32_t mask;
103
104    BDBG_MSG(("HW_AUD_PLL0: %s", activate?"on":"off"));
105
106    if(activate) {
107        mask = (BCHP_CLKGEN_PLL_AUDIO0_PLL_RESET_RESETD_MASK |
108                BCHP_CLKGEN_PLL_AUDIO0_PLL_RESET_RESETA_MASK);
109        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_AUDIO0_PLL_RESET, mask, 0);
110
111        mask = BCHP_CLKGEN_PLL_AUDIO0_PLL_PWRDN_PWRDN_PLL_MASK;
112        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_AUDIO0_PLL_PWRDN, mask, 0);     
113    } else {
114        mask = BCHP_CLKGEN_PLL_AUDIO0_PLL_PWRDN_PWRDN_PLL_MASK;
115        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_AUDIO0_PLL_PWRDN, mask, mask);
116
117        mask = (BCHP_CLKGEN_PLL_AUDIO0_PLL_RESET_RESETD_MASK |
118                BCHP_CLKGEN_PLL_AUDIO0_PLL_RESET_RESETA_MASK);
119        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_AUDIO0_PLL_RESET, mask, mask);
120    }
121
122}
123
124void BCHP_PWR_P_HW_AUD_PLL1_Control(BCHP_Handle handle, bool activate)
125{
126    uint32_t mask;
127
128    BDBG_MSG(("HW_AUD_PLL1: %s", activate?"on":"off"));
129
130    if(activate) {
131        mask = (BCHP_CLKGEN_PLL_AUDIO1_PLL_RESET_RESETD_MASK |
132                BCHP_CLKGEN_PLL_AUDIO1_PLL_RESET_RESETA_MASK);
133        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_AUDIO1_PLL_RESET, mask, 0);
134
135        mask = BCHP_CLKGEN_PLL_AUDIO1_PLL_PWRDN_PWRDN_PLL_MASK;
136        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_AUDIO1_PLL_PWRDN, mask, 0);     
137    } else {
138        mask = BCHP_CLKGEN_PLL_AUDIO1_PLL_PWRDN_PWRDN_PLL_MASK;
139        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_AUDIO1_PLL_PWRDN, mask, mask);
140
141        mask = (BCHP_CLKGEN_PLL_AUDIO1_PLL_RESET_RESETD_MASK |
142                BCHP_CLKGEN_PLL_AUDIO1_PLL_RESET_RESETA_MASK);
143        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_AUDIO1_PLL_RESET, mask, mask);
144    }
145
146}
147
148void BCHP_PWR_P_HW_RAAGA_SRAM_Control(BCHP_Handle handle, bool activate)
149{
150    uint32_t mask;
151
152    BDBG_MSG(("HW_RAAGA_SRAM: %s", activate?"on":"off"));
153
154    mask = BCHP_CLKGEN_RAAGA_DSP_TOP_POWER_SWITCH_MEMORY_RAAGA_POWER_SWITCH_MEMORY_MASK;
155
156    if(activate) { 
157    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_RAAGA_DSP_TOP_POWER_SWITCH_MEMORY, mask, 2);
158    BKNI_Sleep(1); 
159        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_RAAGA_DSP_TOP_POWER_SWITCH_MEMORY, mask, 1);
160    BKNI_Sleep(1); 
161    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_RAAGA_DSP_TOP_POWER_SWITCH_MEMORY, mask, 0);
162    BKNI_Sleep(1);
163    } else {   
164    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_RAAGA_DSP_TOP_POWER_SWITCH_MEMORY, mask, mask);
165    }
166}
167
168void BCHP_PWR_P_HW_BVN_Control(BCHP_Handle handle, bool activate)
169{
170    uint32_t mask;
171
172    BDBG_MSG(("HW_BVN: %s", activate?"on":"off"));
173   
174    mask = BCHP_CLKGEN_BVN_TOP_ENABLE_BVN_SCB_CLOCK_ENABLE_MASK;
175   
176    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_BVN_TOP_ENABLE, mask, activate?mask:0);
177}
178
179void BCHP_PWR_P_HW_BVN_108M_Control(BCHP_Handle handle, bool activate)
180{
181    uint32_t mask;
182
183    BDBG_MSG(("HW_BVN_108M: %s", activate?"on":"off"));
184
185     mask = (BCHP_CLKGEN_BVN_TOP_ENABLE_BVN_216_CLK_ENABLE_MASK | 
186             BCHP_CLKGEN_BVN_TOP_ENABLE_BVN_108_CLK_ENABLE_MASK);
187   
188    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_BVN_TOP_ENABLE, mask, activate?mask:0);
189}
190
191void BCHP_PWR_P_HW_BVN_SRAM_Control(BCHP_Handle handle, bool activate)
192{
193    uint32_t mask;
194
195    BDBG_MSG(("HW_BVN_SRAM: %s", activate?"on":"off"));
196
197    mask = BCHP_CLKGEN_BVN_TOP_POWER_SWITCH_MEMORY_BVN_POWER_SWITCH_MEMORY_MASK;
198
199    if(activate) {     
200        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_BVN_TOP_POWER_SWITCH_MEMORY, mask, 2);
201        BKNI_Sleep(1);
202        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_BVN_TOP_POWER_SWITCH_MEMORY, mask, 1);
203        BKNI_Sleep(1);
204    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_BVN_TOP_POWER_SWITCH_MEMORY, mask, 0);
205        BKNI_Sleep(1); 
206    } else {   
207        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_BVN_TOP_POWER_SWITCH_MEMORY, mask, mask);
208    }
209}
210
211void BCHP_PWR_P_HW_VDC_DAC_Control(BCHP_Handle handle, bool activate)
212{
213    uint32_t mask;
214
215    BDBG_MSG(("HW_VDC_DAC: %s", activate?"on":"off"));
216
217    mask = BCHP_CLKGEN_VEC_AIO_TOP_CLOCK_DISABLE_DISABLE_VEC_DACADC_CLOCK_MASK; 
218    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_VEC_AIO_TOP_CLOCK_DISABLE, mask, activate?0:mask);
219}
220
221void BCHP_PWR_P_HW_VEC_SRAM_Control(BCHP_Handle handle, bool activate)
222{
223    uint32_t mask;
224
225    BDBG_MSG(("HW_VEC_SRAM: %s", activate?"on":"off"));
226   
227    mask = BCHP_CLKGEN_VEC_AIO_TOP_POWER_SWITCH_MEMORY_A_VEC_POWER_SWITCH_MEMORY_A_MASK;
228
229    if(activate) {     
230        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_VEC_AIO_TOP_POWER_SWITCH_MEMORY_A, mask, 2);
231        BKNI_Sleep(1);
232        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_VEC_AIO_TOP_POWER_SWITCH_MEMORY_A, mask, 1);
233        BKNI_Sleep(1);
234    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_VEC_AIO_TOP_POWER_SWITCH_MEMORY_A, mask, 0);
235        BKNI_Sleep(1); 
236    } else {   
237        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_VEC_AIO_TOP_POWER_SWITCH_MEMORY_A, mask, mask);
238    }
239}
240
241void BCHP_PWR_P_HW_XPT_108M_Control(BCHP_Handle handle, bool activate)
242{
243    uint32_t mask;
244
245    BDBG_MSG(("HW_XPT_108M: %s", activate?"on":"off"));
246   
247    mask = BCHP_CLKGEN_CORE_XPT_CLOCK_ENABLE_XPT_108_CLOCK_ENABLE_MASK;
248    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_CORE_XPT_CLOCK_ENABLE, mask, activate?mask:0);
249}
250
251void BCHP_PWR_P_HW_XPT_XMEMIF_Control(BCHP_Handle handle, bool activate)
252{
253   uint32_t mask;
254    BDBG_MSG(("HW_XPT_XMEMIF: %s", activate?"on":"off"));
255   
256    mask = (BCHP_CLKGEN_CORE_XPT_CLOCK_ENABLE_XPT_216_CLOCK_ENABLE_MASK |
257            BCHP_CLKGEN_CORE_XPT_CLOCK_ENABLE_XPT_SCB_CLOCK_ENABLE_MASK);
258    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_CORE_XPT_CLOCK_ENABLE, mask, activate?mask:0);
259}
260
261void BCHP_PWR_P_HW_XPT_RMX_Control(BCHP_Handle handle, bool activate)
262{
263    uint32_t mask;
264    BDBG_MSG(("HW_XPT_RMX: %s", activate?"on":"off"));
265   
266    mask = (BCHP_CLKGEN_CORE_XPT_CLOCK_DISABLE_DISABLE_XPT_20P25_CLOCK_MASK |
267            BCHP_CLKGEN_CORE_XPT_CLOCK_DISABLE_DISABLE_XPT_27_CLOCK_MASK |
268            BCHP_CLKGEN_CORE_XPT_CLOCK_DISABLE_DISABLE_XPT_40P5_CLOCK_MASK |
269            BCHP_CLKGEN_CORE_XPT_CLOCK_DISABLE_DISABLE_XPT_54_CLOCK_MASK |
270            BCHP_CLKGEN_CORE_XPT_CLOCK_DISABLE_DISABLE_XPT_81_CLOCK_MASK);
271    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_CORE_XPT_CLOCK_DISABLE, mask, activate?0:mask);
272}
273
274void BCHP_PWR_P_HW_XPT_SRAM_Control(BCHP_Handle handle, bool activate)
275{
276    uint32_t mask;
277
278    BDBG_MSG(("HW_XPT_SRAM: %s", activate?"on":"off"));
279
280    mask = BCHP_CLKGEN_CORE_XPT_POWER_SWITCH_MEMORY_XPT_POWER_SWITCH_MEMORY_MASK;
281
282    if(activate) { 
283    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_CORE_XPT_POWER_SWITCH_MEMORY, mask, 2);
284    BKNI_Sleep(1); 
285        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_CORE_XPT_POWER_SWITCH_MEMORY, mask, 1);
286    BKNI_Sleep(1); 
287    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_CORE_XPT_POWER_SWITCH_MEMORY, mask, 0);
288    BKNI_Sleep(1); 
289    } else {   
290    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_CORE_XPT_POWER_SWITCH_MEMORY, mask, mask);
291    }
292}
293
294void BCHP_PWR_P_HW_HDMI_TX_CLK_Control(BCHP_Handle handle, bool activate)
295{
296    uint32_t mask, val;
297
298    BDBG_MSG(("HW_HDMI_TX_CLK: %s", activate?"on":"off"));
299 
300    mask = BCHP_CLKGEN_DVP_HT_ENABLE_DVPHT_CLK_MAX_ENABLE_MASK;
301    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_DVP_HT_ENABLE, mask, activate?mask:0);
302   
303    mask =  BCHP_CLKGEN_DVP_HT_CLOCK_ENABLE_DVPHT_ALTERNATE_216_CLOCK_ENABLE_MASK;
304    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_DVP_HT_CLOCK_ENABLE, mask, activate?mask:0);   
305   
306    val = BREG_Read32(handle->regHandle, BCHP_HDMI_TX_PHY_RESET_CTL);
307    mask = (BCHP_HDMI_TX_PHY_RESET_CTL_PLL_RESETB_MASK |
308            BCHP_HDMI_TX_PHY_RESET_CTL_PLLDIV_RSTB_MASK );       
309    if (activate) {
310        val |= mask;
311    }
312    else {
313        val &= ~mask;
314    }
315    BREG_Write32(handle->regHandle, BCHP_HDMI_TX_PHY_RESET_CTL, val);   
316}
317
318void BCHP_PWR_P_HW_HDMI_TX_SRAM_Control(BCHP_Handle handle, bool activate)
319{
320    uint32_t mask;
321
322    BDBG_MSG(("HW_HDMI_TX_SRAM: %s", activate?"on":"off"));
323
324    mask = BCHP_CLKGEN_DVP_HT_POWER_SWITCH_MEMORY_DVPHT_POWER_SWITCH_MEMORY_MASK;
325
326    if(activate) { 
327    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_DVP_HT_POWER_SWITCH_MEMORY, mask, 2);
328    BKNI_Sleep(1); 
329    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_DVP_HT_POWER_SWITCH_MEMORY, mask, 0);
330    BKNI_Sleep(1);
331    } else {   
332    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_DVP_HT_POWER_SWITCH_MEMORY, mask, mask);
333    }
334}
335
336void BCHP_PWR_P_HW_HDMI_TX_108M_Control(BCHP_Handle handle, bool activate)
337{
338    uint32_t mask;
339
340    BDBG_MSG(("HW_HDMI_TX_108M: %s", activate?"on":"off"));
341   
342    mask = (BCHP_CLKGEN_DVP_HT_CLOCK_ENABLE_DVPHT_216_CLOCK_ENABLE_MASK |
343        BCHP_CLKGEN_DVP_HT_CLOCK_ENABLE_DVPHT_108_CLOCK_ENABLE_MASK );
344    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_DVP_HT_CLOCK_ENABLE, mask, activate?mask:0);
345}
346
347void BCHP_PWR_P_HW_HDMI_TX_CEC_Control(BCHP_Handle handle, bool activate)
348{
349    BDBG_MSG(("HW_HDMI_TX_CEC_HOTPLUG: %s", activate?"on":"off"));
350
351    BSTD_UNUSED(handle);
352
353#if 0 /* Edit the register read/modify/write below */
354    BREG_AtomicUpdate32(handle->regHandle, BCHP_REGISTERNAME,
355        BCHP_REGISTERNAME_HDMI_TX_CEC_HOTPLUG_MASK,
356        activate ? 0 : 0xFFFFFFFFFF);
357#endif
358}
359
360void BCHP_PWR_P_HW_HDMI_TX_TMDS_Control(BCHP_Handle handle, bool activate)
361{
362    uint32_t mask, val;
363
364    BDBG_MSG(("HW_HDMI_TX_TMDS: %s", activate?"on":"off"));
365       
366    val = BREG_Read32(handle->regHandle, BCHP_HDMI_TX_PHY_POWERDOWN_CTL);
367    mask = (BCHP_HDMI_TX_PHY_POWERDOWN_CTL_TX_0_PWRDN_MASK |
368            BCHP_HDMI_TX_PHY_POWERDOWN_CTL_TX_1_PWRDN_MASK |
369            BCHP_HDMI_TX_PHY_POWERDOWN_CTL_TX_2_PWRDN_MASK |
370            BCHP_HDMI_TX_PHY_POWERDOWN_CTL_TX_CK_PWRDN_MASK);
371    if (activate) {
372        val &= ~mask;
373    }
374    else {
375        val |= mask;
376    }
377    BREG_Write32(handle->regHandle, BCHP_HDMI_TX_PHY_POWERDOWN_CTL, val);
378   
379    val = BREG_Read32(handle->regHandle, BCHP_HDMI_TX_PHY_RESET_CTL);
380    mask = (BCHP_HDMI_TX_PHY_RESET_CTL_TX_0_RESET_MASK |
381            BCHP_HDMI_TX_PHY_RESET_CTL_TX_1_RESET_MASK |
382            BCHP_HDMI_TX_PHY_RESET_CTL_TX_2_RESET_MASK |
383            BCHP_HDMI_TX_PHY_RESET_CTL_TX_CK_RESET_MASK);
384    if (activate) {
385        val &= ~mask;
386    }
387    else {
388        val |= mask;
389    }
390    BREG_Write32(handle->regHandle, BCHP_HDMI_TX_PHY_RESET_CTL, val);
391}
392
393void BCHP_PWR_P_HW_M2MC_Control(BCHP_Handle handle, bool activate)
394{
395    uint32_t mask;
396       
397    BDBG_MSG(("HW_M2MC: %s", activate?"on":"off"));
398
399    mask = BCHP_CLKGEN_GRAPHICS_CLOCK_ENABLE_GFX_M2MC_CLOCK_ENABLE_MASK;
400    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_GRAPHICS_CLOCK_ENABLE, mask, activate ? mask : 0);
401   
402    mask = BCHP_CLKGEN_GRAPHICS_CLOCK_DISABLE_DISABLE_GFX_M2MC_CORE_CLOCK_MASK;
403    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_GRAPHICS_CLOCK_DISABLE, mask, activate ? 0: mask);
404
405}
406
407void BCHP_PWR_P_HW_GFX_SRAM_Control(BCHP_Handle handle, bool activate)
408{
409    uint32_t mask;
410       
411    BDBG_MSG(("HW_GFX_SRAM: %s", activate?"on":"off"));
412
413    mask = BCHP_CLKGEN_GRAPHICS_POWER_SWITCH_MEMORY_GFX_POWER_SWITCH_MEMORY_MASK;
414
415    if(activate) {     
416        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_GRAPHICS_POWER_SWITCH_MEMORY, mask, 2);
417        BKNI_Sleep(1);
418        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_GRAPHICS_POWER_SWITCH_MEMORY, mask, 1);
419        BKNI_Sleep(1);
420    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_GRAPHICS_POWER_SWITCH_MEMORY, mask, 0);
421        BKNI_Sleep(1); 
422    } else {   
423        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_GRAPHICS_POWER_SWITCH_MEMORY, mask, mask);
424    }
425       
426}
427
428void BCHP_PWR_P_HW_GFX_108M_Control(BCHP_Handle handle, bool activate)
429{
430    uint32_t mask;
431               
432    BDBG_MSG(("HW_GFX_108M: %s", activate?"on":"off"));
433   
434    mask = (BCHP_CLKGEN_GRAPHICS_CLOCK_ENABLE_GFX_108_CLOCK_ENABLE_MASK | 
435            BCHP_CLKGEN_GRAPHICS_CLOCK_ENABLE_GFX_SCB_CLOCK_ENABLE_MASK);
436    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_GRAPHICS_CLOCK_ENABLE, mask, activate ? mask : 0);
437       
438}
439
440void BCHP_PWR_P_HW_DMA_Control(BCHP_Handle handle, bool activate)
441{
442    uint32_t mask;
443
444    BDBG_MSG(("HW_DMA: %s", activate?"on":"off"));
445   
446    mask = BCHP_CLKGEN_SECTOP_INST_CLOCK_ENABLE_SEC_ALTERNATE_SCB_CLOCK_ENABLE_MASK;
447
448    BREG_AtomicUpdate32(handle->regHandle,  BCHP_CLKGEN_SECTOP_INST_CLOCK_ENABLE, mask, activate?mask:0);
449}
450
451void BCHP_PWR_P_HW_SCD0_Control(BCHP_Handle handle, bool activate)
452{
453    uint32_t mask;
454
455    BDBG_MSG(("HW_SCD0: %s", activate?"on":"off"));       
456   
457    mask = BCHP_CLKGEN_SYS_CTRL_CLOCK_DISABLE_DISABLE_SC0_CLOCK_MASK;
458    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_SYS_CTRL_CLOCK_DISABLE, mask, activate?0:mask);
459}
460
461void BCHP_PWR_P_HW_PLL_SCD_CH0_Control(BCHP_Handle handle, bool activate)
462{
463    uint32_t mask;
464
465    BDBG_MSG(("HW_PLL_SCD_CH0: %s", activate?"on":"off"));
466
467    mask = BCHP_CLKGEN_PLL_SC_PLL_CHANNEL_CTRL_CH_0_CLOCK_DIS_CH0_MASK;
468    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_SC_PLL_CHANNEL_CTRL_CH_0, mask, activate?0:mask);
469}
470
471void BCHP_PWR_P_HW_SCD1_Control(BCHP_Handle handle, bool activate)
472{
473    uint32_t mask;
474
475    BDBG_MSG(("HW_SCD1: %s", activate?"on":"off"));       
476   
477    mask = BCHP_CLKGEN_SYS_CTRL_CLOCK_DISABLE_DISABLE_SC1_CLOCK_MASK;
478    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_SYS_CTRL_CLOCK_DISABLE, mask, activate?0:mask);
479}
480
481void BCHP_PWR_P_HW_PLL_SCD_CH1_Control(BCHP_Handle handle, bool activate)
482{
483    uint32_t mask;
484
485    BDBG_MSG(("HW_PLL_SCD_CH1: %s", activate?"on":"off"));
486
487    mask = BCHP_CLKGEN_PLL_SC_PLL_CHANNEL_CTRL_CH_1_CLOCK_DIS_CH1_MASK;
488    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_SC_PLL_CHANNEL_CTRL_CH_1, mask, activate?0:mask);
489}
490
491void BCHP_PWR_P_HW_MDM_Control(BCHP_Handle handle, bool activate)
492{
493    BDBG_MSG(("HW_MDM: %s", activate?"on":"off"));
494
495    BSTD_UNUSED(handle);
496
497#if 0 /* Edit the register read/modify/write below */
498    BREG_AtomicUpdate32(handle->regHandle, BCHP_REGISTERNAME,
499        BCHP_REGISTERNAME_MDM_MASK,
500        activate ? 0 : 0xFFFFFFFFFF);
501#endif
502}
503
504void BCHP_PWR_P_HW_RFM_Control(BCHP_Handle handle, bool activate)
505{
506        uint32_t mask;
507    BDBG_MSG(("HW_RFM: %s", activate?"on":"off"));
508
509    if (activate) {                           
510        /* RFM 108M clock */
511        mask = BCHP_CLKGEN_RFM_TOP_CLOCK_ENABLE_RFM_108_CLOCK_ENABLE_MASK;
512                BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_RFM_TOP_CLOCK_ENABLE, mask, mask);
513    }
514    else {
515                /* RFM 108M clock */
516                mask = BCHP_CLKGEN_RFM_TOP_CLOCK_ENABLE_RFM_108_CLOCK_ENABLE_MASK;
517                BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_RFM_TOP_CLOCK_ENABLE, mask, 0);     
518    }
519}
520
521void BCHP_PWR_P_HW_RFM_SRAM_Control(BCHP_Handle handle, bool activate)
522{
523    uint32_t mask;
524   
525    BDBG_MSG(("HW_RFM_SRAM: %s", activate?"on":"off"));
526   
527    BSTD_UNUSED(handle);
528    BSTD_UNUSED(mask);
529
530    mask = BCHP_CLKGEN_RFM_TOP_POWER_SWITCH_MEMORY_RFM_POWER_SWITCH_MEMORY_MASK;
531   
532    if(activate) { 
533    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_RFM_TOP_POWER_SWITCH_MEMORY, mask, 2);
534    BKNI_Sleep(1); 
535        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_RFM_TOP_POWER_SWITCH_MEMORY, mask, 1);
536    BKNI_Sleep(1); 
537    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_RFM_TOP_POWER_SWITCH_MEMORY, mask, 0);
538    BKNI_Sleep(1);
539    } else {   
540    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_RFM_TOP_POWER_SWITCH_MEMORY, mask, mask);
541    }
542
543        mask = BCHP_CLKGEN_RFM_TOP_MEMORY_STANDBY_ENABLE_RFMA_MEMORY_STANDBY_ENABLE_MASK;
544
545        if(activate) { 
546    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_RFM_TOP_MEMORY_STANDBY_ENABLE, mask, mask);
547    } else {   
548    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_RFM_TOP_MEMORY_STANDBY_ENABLE, mask, 0);
549    }
550
551}
552void BCHP_PWR_P_HW_PLL_AVD_CH0_Control(BCHP_Handle handle, bool activate)
553{
554    uint32_t mask;
555
556    BDBG_MSG(("HW_PLL_AVD_CH0: %s", activate?"on":"off"));
557#if 0
558    mask = BCHP_CLKGEN_PLL_AVD_MIPS_PLL_CHANNEL_CTRL_CH_0_CLOCK_DIS_CH0_MASK;
559    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_AVD_MIPS_PLL_CHANNEL_CTRL_CH_0, mask, activate?0:mask);
560#else
561    BSTD_UNUSED(mask);
562    BSTD_UNUSED(handle);
563#endif
564}
565
566void BCHP_PWR_P_HW_PLL_AVD_CH1_Control(BCHP_Handle handle, bool activate)
567{
568    uint32_t mask;
569
570    BDBG_MSG(("HW_PLL_AVD_CH1: %s", activate?"on":"off"));
571
572    mask = BCHP_CLKGEN_PLL_AVD_MIPS_PLL_CHANNEL_CTRL_CH_1_CLOCK_DIS_CH1_MASK;
573    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_AVD_MIPS_PLL_CHANNEL_CTRL_CH_1, mask, activate?0:mask);
574
575}
576
577void BCHP_PWR_P_HW_PLL_AVD_CH2_Control(BCHP_Handle handle, bool activate)
578{
579    uint32_t mask;
580
581    BDBG_MSG(("HW_PLL_AVD_CH2: %s", activate?"on":"off"));
582
583    mask = BCHP_CLKGEN_PLL_AVD_MIPS_PLL_CHANNEL_CTRL_CH_2_CLOCK_DIS_CH2_MASK;
584    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_AVD_MIPS_PLL_CHANNEL_CTRL_CH_2, mask, activate?0:mask);
585
586}
587
588void BCHP_PWR_P_HW_PLL_AVD_CH3_Control(BCHP_Handle handle, bool activate)
589{
590    uint32_t mask;
591
592    BDBG_MSG(("HW_PLL_AVD_CH3: %s", activate?"on":"off"));
593
594    mask = BCHP_CLKGEN_PLL_AVD_MIPS_PLL_CHANNEL_CTRL_CH_3_CLOCK_DIS_CH3_MASK;
595    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_AVD_MIPS_PLL_CHANNEL_CTRL_CH_3, mask, activate?0:mask);
596
597}
598
599void BCHP_PWR_P_HW_PLL_AVD_Control(BCHP_Handle handle, bool activate)
600{
601    uint32_t mask;
602
603    BDBG_MSG(("HW_PLL_AVD: %s", activate?"on":"off"));
604#if 0
605    if (activate) {
606    uint32_t reg, cnt=50;
607        /* power up PLL_AVD */
608        mask = BCHP_CLKGEN_PLL_AVD_MIPS_PLL_PWRDN_PWRDN_PLL_MASK;
609        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_AVD_MIPS_PLL_PWRDN , mask, 0);
610
611    /* Check for PLL lock */
612    while(cnt--) {
613        BKNI_Delay(10);
614        reg = BREG_Read32(handle->regHandle, BCHP_CLKGEN_PLL_AVD_MIPS_PLL_LOCK_STATUS);
615        if (BCHP_GET_FIELD_DATA(reg, CLKGEN_PLL_AVD_MIPS_PLL_LOCK_STATUS, LOCK))         
616        break;     
617    }   
618    } else {
619        /* power down PLL_AVD */       
620        mask = BCHP_CLKGEN_PLL_AVD_MIPS_PLL_PWRDN_PWRDN_PLL_MASK;
621        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_AVD_MIPS_PLL_PWRDN , mask, mask);
622    }
623#else
624    BSTD_UNUSED(mask);
625    BSTD_UNUSED(handle);
626#endif
627}
628
629void BCHP_PWR_P_HW_PLL_VCXO_CH0_Control(BCHP_Handle handle, bool activate)
630{
631    uint32_t mask;
632
633    BDBG_MSG(("HW_PLL_VCXO_CH0: %s", activate?"on":"off"));
634
635    mask = BCHP_CLKGEN_PLL_VCXO_PLL_CHANNEL_CTRL_CH_0_CLOCK_DIS_CH0_MASK;
636    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_VCXO_PLL_CHANNEL_CTRL_CH_0, mask, activate?0:mask);
637
638}
639
640void BCHP_PWR_P_HW_PLL_SCD_Control(BCHP_Handle handle, bool activate)
641{
642    uint32_t mask;
643
644    BDBG_MSG(("HW_SCD_PLL: %s", activate?"on":"off"));
645   
646    if(activate) {
647        mask = (BCHP_CLKGEN_PLL_SC_PLL_RESET_RESETD_MASK |
648                BCHP_CLKGEN_PLL_SC_PLL_RESET_RESETA_MASK);
649        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_SC_PLL_RESET, mask, 0);
650
651        mask = BCHP_CLKGEN_PLL_SC_PLL_PWRDN_PWRDN_PLL_MASK;
652        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_SC_PLL_PWRDN, mask, 0); 
653    } else {
654        mask = BCHP_CLKGEN_PLL_SC_PLL_PWRDN_PWRDN_PLL_MASK;
655        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_SC_PLL_PWRDN, mask, mask);
656
657        mask = (BCHP_CLKGEN_PLL_SC_PLL_RESET_RESETD_MASK |
658                BCHP_CLKGEN_PLL_SC_PLL_RESET_RESETA_MASK);
659        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_SC_PLL_RESET, mask, mask);
660    }
661}
662
663void BCHP_PWR_P_HW_PLL_VCXO_CH2_Control(BCHP_Handle handle, bool activate)
664{
665    uint32_t mask;
666
667    BDBG_MSG(("HW_PLL_VCXO_CH2: %s", activate?"on":"off"));
668
669    mask = BCHP_CLKGEN_PLL_VCXO_PLL_CHANNEL_CTRL_CH_2_CLOCK_DIS_CH2_MASK;
670    BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_VCXO_PLL_CHANNEL_CTRL_CH_2, mask, activate?0:mask);
671
672}
673
674void BCHP_PWR_P_HW_PLL_VCXO_Control(BCHP_Handle handle, bool activate)
675{
676    uint32_t mask;
677
678    BDBG_MSG(("HW_PLL_VCXO: %s", activate?"on":"off"));
679
680    if(activate) {
681        mask = (BCHP_CLKGEN_PLL_VCXO_PLL_RESET_RESETD_MASK |
682                BCHP_CLKGEN_PLL_VCXO_PLL_RESET_RESETA_MASK);
683        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_VCXO_PLL_RESET, mask, 0);
684
685        mask = BCHP_CLKGEN_PLL_VCXO_PLL_PWRDN_PWRDN_PLL_MASK;
686        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_VCXO_PLL_PWRDN, mask, 0);       
687    } else {
688        mask = BCHP_CLKGEN_PLL_VCXO_PLL_PWRDN_PWRDN_PLL_MASK;
689        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_VCXO_PLL_PWRDN, mask, mask);
690
691        mask = (BCHP_CLKGEN_PLL_VCXO_PLL_RESET_RESETD_MASK |
692                BCHP_CLKGEN_PLL_VCXO_PLL_RESET_RESETA_MASK);
693        BREG_AtomicUpdate32(handle->regHandle, BCHP_CLKGEN_PLL_VCXO_PLL_RESET, mask, mask);
694    }
695
696}
697
Note: See TracBrowser for help on using the repository browser.