|
1 /* |
|
2 * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * ne1_tb\specific\powerresources.cpp |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 |
|
21 #include "resmanpsl.h" |
|
22 #include <naviengine_priv.h> |
|
23 |
|
24 /** Constructor for board power resource */ |
|
25 DNE1_TBBoardPowerResource::DNE1_TBBoardPowerResource():DStaticPowerResource(KBoardPower, E_ON) |
|
26 { |
|
27 iFlags = 0; //Binary synchronous single user positive sense resource |
|
28 } |
|
29 |
|
30 /** This function updates the resource information for board power resource. Call default implementation to update |
|
31 generic information about the resource. */ |
|
32 TInt DNE1_TBBoardPowerResource::GetInfo(TDes8* aInfo)const |
|
33 { |
|
34 DStaticPowerResource::GetInfo((TDes8*)aInfo); |
|
35 TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)aInfo; |
|
36 buf1->iMinLevel = E_OFF; |
|
37 buf1->iMaxLevel = E_ON; |
|
38 return KErrNone; |
|
39 } |
|
40 |
|
41 /** This function takes care of the requested resource operation (read / write) for board power resource. |
|
42 This is called from PIL on response to change or read resource state. |
|
43 */ |
|
44 TInt DNE1_TBBoardPowerResource::DoRequest(TPowerRequest& aRequest) |
|
45 { |
|
46 if(aRequest.ReqType() == TPowerRequest::EGet) |
|
47 { |
|
48 aRequest.Level() = E_ON; //should be ON |
|
49 } |
|
50 else if(aRequest.ReqType() == TPowerRequest::ESetDefaultLevel) |
|
51 { |
|
52 //Set to default level |
|
53 aRequest.Level() = iDefaultLevel; |
|
54 } |
|
55 else if(aRequest.ReqType() == TPowerRequest::EChange) |
|
56 { |
|
57 //Change to level specified. If the state is OFF then board will be switched off |
|
58 AsspRegister::Write32(KHwFPGABase+KHoSystemPowerDown, aRequest.Level()); |
|
59 } |
|
60 else |
|
61 { |
|
62 return KErrNotSupported; |
|
63 } |
|
64 return KErrNone; |
|
65 } |
|
66 |
|
67 /** Constructor for display DCLK resource */ |
|
68 DNE1_TBDisplayDclkResource::DNE1_TBDisplayDclkResource():DStaticPowerResource(KDisplayDclk, EDisplayDclk66500KHz) |
|
69 { |
|
70 iFlags = EMultilevel; //Multilevel instantaneous single user positive sense resource |
|
71 } |
|
72 |
|
73 /** This function updates the resource information for display DCLK resource. Call default implementation to |
|
74 update generic information about the resource. */ |
|
75 TInt DNE1_TBDisplayDclkResource::GetInfo(TDes8* aInfo)const |
|
76 { |
|
77 DStaticPowerResource::GetInfo((TDes8*)aInfo); |
|
78 TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)aInfo; |
|
79 buf1->iMinLevel = EDisplayDclk19950KHz; |
|
80 buf1->iMaxLevel = EDisplayDclk79800KHz; |
|
81 return KErrNone; |
|
82 } |
|
83 |
|
84 /** This function takes care of the requested resource operation (read /write) for display DCLK. |
|
85 This is called from PIL on response to change or read resource state. |
|
86 */ |
|
87 TInt DNE1_TBDisplayDclkResource::DoRequest(TPowerRequest& aRequest) |
|
88 { |
|
89 TInt level; |
|
90 if(aRequest.ReqType() == TPowerRequest::EGet) |
|
91 { |
|
92 level = AsspRegister::Read32(KHwSystemCtrlBase+KHoSCUDisplayDCLKCtrl); |
|
93 level = ~(level & 0xF); //Need to convert from divider setting to frequency |
|
94 } |
|
95 else if(aRequest.ReqType() == TPowerRequest::ESetDefaultLevel) |
|
96 { |
|
97 //Set the default level |
|
98 AsspRegister::Write32(KHwSystemCtrlBase+KHoSCUDisplayDCLKCtrl, ~iDefaultLevel); |
|
99 aRequest.Level() = iDefaultLevel; |
|
100 } |
|
101 else if(aRequest.ReqType() == TPowerRequest::EChange) |
|
102 { |
|
103 //Select internal clock |
|
104 AsspRegister::Write32(KHwSystemCtrlBase+KHoSCUDisplayDCLKCtrl, ~aRequest.Level()); |
|
105 } |
|
106 else |
|
107 { |
|
108 return KErrNotSupported; |
|
109 } |
|
110 return KErrNone; |
|
111 } |
|
112 |
|
113 /** Constructor for LCD power resource */ |
|
114 DNE1_TBLcdResource::DNE1_TBLcdResource():DStaticPowerResource(KLcdPower, E_ON) |
|
115 { |
|
116 iFlags = 0; //Binary instantaneous single user positive sense resource |
|
117 } |
|
118 |
|
119 /** This function updates the resource information for LCD power resource. Call default implementation to |
|
120 update generic information about the resource. */ |
|
121 TInt DNE1_TBLcdResource::GetInfo(TDes8* aInfo)const |
|
122 { |
|
123 DStaticPowerResource::GetInfo((TDes8*)aInfo); |
|
124 TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)aInfo; |
|
125 buf1->iMinLevel = E_OFF; |
|
126 buf1->iMaxLevel = E_ON; |
|
127 return KErrNone; |
|
128 } |
|
129 |
|
130 /** This function takes care of the requested resource operation (read / write) for LCD resource. |
|
131 This is called from PIL on response to change or read resource state. |
|
132 */ |
|
133 TInt DNE1_TBLcdResource::DoRequest(TPowerRequest& aRequest) |
|
134 { |
|
135 if(aRequest.ReqType() == TPowerRequest::EGet) |
|
136 { |
|
137 aRequest.Level() = AsspRegister::Read32(KHwFPGABase+KHoLCDControl) & 0x1; |
|
138 } |
|
139 else if(aRequest.ReqType() == TPowerRequest::ESetDefaultLevel) |
|
140 { |
|
141 AsspRegister::Modify32(KHwFPGABase+KHoLCDControl, KClearBit0, iDefaultLevel); |
|
142 aRequest.Level() = iDefaultLevel; |
|
143 } |
|
144 else if(aRequest.ReqType() == TPowerRequest::EChange) |
|
145 { |
|
146 //Set to requested level |
|
147 AsspRegister::Modify32(KHwFPGABase+KHoLCDControl, KClearBit0, aRequest.Level()); |
|
148 } |
|
149 else |
|
150 { |
|
151 return KErrNotSupported; |
|
152 } |
|
153 return KErrNone; |
|
154 } |
|
155 |
|
156 /** Constructor for CSI 0 clock resource */ |
|
157 DNE1_TBCSI0ClockResource::DNE1_TBCSI0ClockResource():DStaticPowerResource(KCSI0Clock, ECSIClkSck1) |
|
158 { |
|
159 iFlags = EMultilevel; //Mulitlevel instantaneous single user positive sense resource |
|
160 } |
|
161 |
|
162 /** This function updates the resource information for CSI 0 clock resource. Call default implementation to |
|
163 update generic information about the resource. |
|
164 */ |
|
165 TInt DNE1_TBCSI0ClockResource::GetInfo(TDes8* aInfo)const |
|
166 { |
|
167 DStaticPowerResource::GetInfo((TDes8*)aInfo); |
|
168 TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)aInfo; |
|
169 buf1->iMinLevel = ECSIClkSck1; |
|
170 buf1->iMaxLevel = ECSIClk16670KHz; |
|
171 return KErrNone; |
|
172 } |
|
173 |
|
174 /** This function takes care of the requested resource operation (read /write) for CSI 0 clock resource. |
|
175 This is called from PIL on response to change or read resource state. |
|
176 */ |
|
177 TInt DNE1_TBCSI0ClockResource::DoRequest(TPowerRequest& aRequest) |
|
178 { |
|
179 TUint level; |
|
180 if(aRequest.ReqType() == TPowerRequest::EGet) |
|
181 { |
|
182 level = AsspRegister::Read32(KHwBaseCSI0+KHoCSIClockSelect); |
|
183 aRequest.Level() = ~(level & 0x7); //Convert from divider to frequency |
|
184 return KErrNone; |
|
185 } |
|
186 //Check whether CSIRST is 1, if not return KErrNotsupported |
|
187 level = AsspRegister::Read32(KHwBaseCSI0+KHoCSIModeControl); |
|
188 if(level & CSI_UNIT_ENABLE) |
|
189 { |
|
190 return KErrNotSupported; |
|
191 } |
|
192 //Check whether CSIE is 0 , if not return KErrNotSupported |
|
193 level = AsspRegister::Read32(KHwBaseCSI0+KHoCSIControl); |
|
194 if(!(level & CSI_RESET)) |
|
195 { |
|
196 return KErrNotSupported; |
|
197 } |
|
198 if(aRequest.ReqType() == TPowerRequest::ESetDefaultLevel) |
|
199 { |
|
200 //Set to default level |
|
201 AsspRegister::Modify32(KHwBaseCSI0+KHoCSIClockSelect, KClearBit0_2, ~iDefaultLevel); |
|
202 aRequest.Level() = iDefaultLevel; |
|
203 } |
|
204 else if(aRequest.ReqType() == TPowerRequest::EChange) |
|
205 { |
|
206 AsspRegister::Modify32(KHwBaseCSI0+KHoCSIClockSelect, KClearBit0_2, ~aRequest.Level()); |
|
207 } |
|
208 else |
|
209 { |
|
210 return KErrNotSupported; |
|
211 } |
|
212 return KErrNone; |
|
213 } |
|
214 |
|
215 /** Constructor for CSI 1 clock resource */ |
|
216 DNE1_TBCSI1ClockResource::DNE1_TBCSI1ClockResource():DStaticPowerResource(KCSI1Clock, ECSIClkSck1) |
|
217 { |
|
218 iFlags = EMultilevel; //Multilevel instantaneous single user positive sense resource |
|
219 } |
|
220 |
|
221 /** This function updates the resource information for CSI 1 clock resource. Call default implementation to |
|
222 update generic information about the resource. |
|
223 */ |
|
224 TInt DNE1_TBCSI1ClockResource::GetInfo(TDes8* aInfo)const |
|
225 { |
|
226 DStaticPowerResource::GetInfo((TDes8*)aInfo); |
|
227 TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)aInfo; |
|
228 buf1->iMinLevel = ECSIClkSck1; |
|
229 buf1->iMaxLevel = ECSIClk16670KHz; |
|
230 return KErrNone; |
|
231 } |
|
232 |
|
233 /** This function takes care of the requested resource operation (read/write) for CSI 1 clock resource. |
|
234 This is called from PIL on response to change or read resource state. |
|
235 */ |
|
236 TInt DNE1_TBCSI1ClockResource::DoRequest(TPowerRequest& aRequest) |
|
237 { |
|
238 TUint level; |
|
239 if(aRequest.ReqType() == TPowerRequest::EGet) |
|
240 { |
|
241 level = AsspRegister::Read32(KHwBaseCSI1+KHoCSIClockSelect); |
|
242 level = ~(level & 0x7); |
|
243 return KErrNone; |
|
244 } |
|
245 //Check whether CSIRST is 1, if not return KErrNotsupported |
|
246 level = AsspRegister::Read32(KHwBaseCSI1+KHoCSIModeControl); |
|
247 if(level & CSI_UNIT_ENABLE) |
|
248 { |
|
249 return KErrNotSupported; |
|
250 } |
|
251 //Check whether CSIE is 0 , if not return KErrNotSupported |
|
252 level = AsspRegister::Read32(KHwBaseCSI1+KHoCSIControl); |
|
253 if(!(level & CSI_RESET)) |
|
254 { |
|
255 return KErrNotSupported; |
|
256 } |
|
257 if(aRequest.ReqType() == TPowerRequest::ESetDefaultLevel) |
|
258 { |
|
259 //Set to default level |
|
260 AsspRegister::Modify32(KHwBaseCSI1+KHoCSIClockSelect, KClearBit0_2, ~iDefaultLevel); |
|
261 aRequest.Level() = iDefaultLevel; |
|
262 } |
|
263 else if(aRequest.ReqType() == TPowerRequest::EChange) |
|
264 { |
|
265 //Change the resource to the requested level |
|
266 AsspRegister::Modify32(KHwBaseCSI1+KHoCSIClockSelect, KClearBit0_2, ~aRequest.Level()); |
|
267 } |
|
268 else |
|
269 { |
|
270 return KErrNotSupported; |
|
271 } |
|
272 return KErrNone; |
|
273 } |
|
274 |
|
275 /** Constructor for I2S 0 MCLK divider resource */ |
|
276 DNE1_TBI2S0MclkResource::DNE1_TBI2S0MclkResource():DStaticPowerResource(KI2S0Mclk, EI2SMclk36864KHz) |
|
277 { |
|
278 //This resource also takes care of masking the DCLK clock and therefore classified as multiproperty |
|
279 iFlags = EMultiProperty; |
|
280 } |
|
281 |
|
282 /** This function updates the resource information for I2S 0 clock resource. Call default implementation to |
|
283 update generic information about the resource |
|
284 */ |
|
285 TInt DNE1_TBI2S0MclkResource::GetInfo(TDes8* aInfo)const |
|
286 { |
|
287 DStaticPowerResource::GetInfo((TDes8*)aInfo); |
|
288 TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)aInfo; |
|
289 buf1->iMinLevel = EI2SMclkMask; |
|
290 buf1->iMaxLevel = EI2SMclk16934KHz; |
|
291 return KErrNone; |
|
292 } |
|
293 |
|
294 /** This function takes care of the requested resource operation (read / write) for I2S 0 MCLK resource. |
|
295 This is called from PIL on response to change or read resource state. |
|
296 */ |
|
297 TInt DNE1_TBI2S0MclkResource::DoRequest(TPowerRequest& aRequest) |
|
298 { |
|
299 if(aRequest.ReqType() == TPowerRequest::EGet) |
|
300 { |
|
301 aRequest.Level() = AsspRegister::Read32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl) & 0xF; |
|
302 } |
|
303 else if(aRequest.ReqType() == TPowerRequest::ESetDefaultLevel) |
|
304 { |
|
305 //Set to default level |
|
306 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl, KClearBit0_3, iDefaultLevel); |
|
307 aRequest.Level() = iDefaultLevel; |
|
308 } |
|
309 else if(aRequest.ReqType() == TPowerRequest::EChange) |
|
310 { |
|
311 if(aRequest.Level() == EI2SMclkMask) //Enable DCLK Mask |
|
312 { |
|
313 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUClockMaskCtrl, KClearBit18, KSetBit18); |
|
314 } |
|
315 else |
|
316 { |
|
317 //Set the request frequency |
|
318 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl, KClearBit0_3, aRequest.Level()); |
|
319 //Disable the clock mask |
|
320 TUint level = AsspRegister::Read32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl); |
|
321 if(!(level & KSetBit18)) |
|
322 { |
|
323 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl, KClearBit18, KClearBit18); |
|
324 } |
|
325 } |
|
326 } |
|
327 else |
|
328 { |
|
329 return KErrNotSupported; |
|
330 } |
|
331 return KErrNone; |
|
332 } |
|
333 |
|
334 /** Constructor for I2S 1 MCLK divider resource */ |
|
335 DNE1_TBI2S1MclkResource::DNE1_TBI2S1MclkResource():DStaticPowerResource(KI2S1Mclk, EI2SMclk36864KHz) |
|
336 { |
|
337 iFlags = EMultiProperty; |
|
338 } |
|
339 |
|
340 /** This function updates the resource information for I2S 1 clock resource. Call default implementation to |
|
341 update generic information about the resource |
|
342 */ |
|
343 TInt DNE1_TBI2S1MclkResource::GetInfo(TDes8* aInfo)const |
|
344 { |
|
345 DStaticPowerResource::GetInfo((TDes8*)aInfo); |
|
346 TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)aInfo; |
|
347 buf1->iMinLevel = EI2SMclkMask; |
|
348 buf1->iMaxLevel = EI2SMclk16934KHz; |
|
349 return KErrNone; |
|
350 } |
|
351 |
|
352 /** This function takes care of the requested resource operation (read / write) for I2S 1 MCLK clock resource. |
|
353 This is called from PIL on response to change or read resource state. |
|
354 */ |
|
355 TInt DNE1_TBI2S1MclkResource::DoRequest(TPowerRequest& aRequest) |
|
356 { |
|
357 TUint level; |
|
358 if(aRequest.ReqType() == TPowerRequest::EGet) |
|
359 { |
|
360 level = AsspRegister::Read32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl); |
|
361 aRequest.Level() = (level >> SHIFT_BY_8) & 0xF; |
|
362 } |
|
363 else if(aRequest.ReqType() == TPowerRequest::ESetDefaultLevel) |
|
364 { |
|
365 //Set to default level |
|
366 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl, KClearBit8_11, (iDefaultLevel << SHIFT_BY_8)); |
|
367 aRequest.Level() = iDefaultLevel; |
|
368 } |
|
369 else if(aRequest.ReqType() == TPowerRequest::EChange) |
|
370 { |
|
371 if(aRequest.Level() == EI2SMclkMask) //Enable DCLK Mask |
|
372 { |
|
373 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUClockMaskCtrl, KClearBit19, KSetBit19); |
|
374 } |
|
375 else |
|
376 { |
|
377 //Set the request frequency |
|
378 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl, KClearBit8_11, (aRequest.Level() << SHIFT_BY_8)); |
|
379 //Disable the clock mask |
|
380 level = AsspRegister::Read32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl); |
|
381 if(!(level & KSetBit19)) |
|
382 { |
|
383 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl, KClearBit19, KClearBit19); |
|
384 } |
|
385 } |
|
386 } |
|
387 else |
|
388 { |
|
389 return KErrNotSupported; |
|
390 } |
|
391 return KErrNone; |
|
392 } |
|
393 |
|
394 /** Constructor for I2S 2 MCLK divider resource */ |
|
395 DNE1_TBI2S2MclkResource::DNE1_TBI2S2MclkResource():DStaticPowerResource(KI2S2Mclk, EI2SMclk36864KHz) |
|
396 { |
|
397 iFlags = EMultiProperty; |
|
398 } |
|
399 |
|
400 /** This function updates the resource information for I2S 2 MCLK clock resource. Call default implementation to |
|
401 update generic information about the resource |
|
402 */ |
|
403 TInt DNE1_TBI2S2MclkResource::GetInfo(TDes8* aInfo)const |
|
404 { |
|
405 DStaticPowerResource::GetInfo((TDes8*)aInfo); |
|
406 TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)aInfo; |
|
407 buf1->iMinLevel = EI2SMclkMask; |
|
408 buf1->iMaxLevel = EI2SMclk16934KHz; |
|
409 return KErrNone; |
|
410 } |
|
411 |
|
412 /** This function takes care of the requested resource operation (read / write) for I2S 2 MCLK clock resource. |
|
413 This is called from PIL on response to change or read resource state. |
|
414 */ |
|
415 TInt DNE1_TBI2S2MclkResource::DoRequest(TPowerRequest& aRequest) |
|
416 { |
|
417 TUint level; |
|
418 if(aRequest.ReqType() == TPowerRequest::EGet) |
|
419 { |
|
420 level = AsspRegister::Read32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl); |
|
421 aRequest.Level() = (level >> SHIFT_BY_16) & 0xF; |
|
422 } |
|
423 else if(aRequest.ReqType() == TPowerRequest::ESetDefaultLevel) |
|
424 { |
|
425 //Set to default level |
|
426 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl, KClearBit16_19, (iDefaultLevel << SHIFT_BY_16)); |
|
427 aRequest.Level() = iDefaultLevel; |
|
428 } |
|
429 else if(aRequest.ReqType() == TPowerRequest::EChange) |
|
430 { |
|
431 if(aRequest.Level() == EI2SMclkMask) //Enable DCLK Mask |
|
432 { |
|
433 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUClockMaskCtrl, KClearBit20, KSetBit20); |
|
434 } |
|
435 else |
|
436 { |
|
437 //Set the request frequency |
|
438 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl, KClearBit16_19, |
|
439 (aRequest.Level() << SHIFT_BY_16)); |
|
440 //Disable the clock mask |
|
441 level = AsspRegister::Read32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl); |
|
442 if(!(level & KSetBit20)) |
|
443 { |
|
444 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl, KClearBit20, KClearBit20); |
|
445 } |
|
446 } |
|
447 } |
|
448 else |
|
449 { |
|
450 return KErrNotSupported; |
|
451 } |
|
452 return KErrNone; |
|
453 } |
|
454 |
|
455 /** Constructor for I2S 3 MCLK divider resource */ |
|
456 DNE1_TBI2S3MclkResource::DNE1_TBI2S3MclkResource():DStaticPowerResource(KI2S3Mclk, EI2SMclk36864KHz) |
|
457 { |
|
458 iFlags = EMultiProperty; |
|
459 } |
|
460 |
|
461 /** This function updates the resource information for I2S 3 MCLK clock resource. Call default implementation to |
|
462 update generic information about the resource |
|
463 */ |
|
464 TInt DNE1_TBI2S3MclkResource::GetInfo(TDes8* aInfo)const |
|
465 { |
|
466 DStaticPowerResource::GetInfo((TDes8*)aInfo); |
|
467 TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)aInfo; |
|
468 buf1->iMinLevel = EI2SMclkMask; |
|
469 buf1->iMaxLevel = EI2SMclk16934KHz; |
|
470 return KErrNone; |
|
471 } |
|
472 |
|
473 /** This function takes care of the requested resource operation (read / write) for I2S 3 MCLK clock resource. |
|
474 This is called from PIL on response to change or read resource state. |
|
475 */ |
|
476 TInt DNE1_TBI2S3MclkResource::DoRequest(TPowerRequest& aRequest) |
|
477 { |
|
478 TUint level; |
|
479 if(aRequest.ReqType() == TPowerRequest::EGet) |
|
480 { |
|
481 level = AsspRegister::Read32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl); |
|
482 aRequest.Level() = (level >> SHIFT_BY_24) & 0xF; |
|
483 } |
|
484 else if(aRequest.ReqType() == TPowerRequest::ESetDefaultLevel) |
|
485 { |
|
486 //Set to default level |
|
487 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl, KClearBit24_27, (iDefaultLevel << SHIFT_BY_24)); |
|
488 aRequest.Level() = iDefaultLevel; |
|
489 } |
|
490 else if(aRequest.ReqType() == TPowerRequest::EChange) |
|
491 { |
|
492 if(aRequest.Level() == EI2SMclkMask) //Enable DCLK Mask |
|
493 { |
|
494 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUClockMaskCtrl, KClearBit21, KSetBit21); |
|
495 } |
|
496 else |
|
497 { |
|
498 //Set the request frequency |
|
499 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl, KClearBit24_27, |
|
500 (aRequest.Level() << SHIFT_BY_24)); |
|
501 //Disable the clock mask |
|
502 level = AsspRegister::Read32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl); |
|
503 if(!(level & KSetBit21)) |
|
504 { |
|
505 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl, KClearBit21, KClearBit21); |
|
506 } |
|
507 } |
|
508 } |
|
509 else |
|
510 { |
|
511 return KErrNotSupported; |
|
512 } |
|
513 return KErrNone; |
|
514 } |
|
515 |
|
516 /** Constructor for I2S 0 SCLK resource */ |
|
517 DNE1_TBI2S0SclkResource::DNE1_TBI2S0SclkResource():DStaticPowerResource(KI2S0Sclk, EI2SSclk8000Hz) |
|
518 { |
|
519 iFlags = EMultilevel; |
|
520 } |
|
521 |
|
522 /** This function updates the resource information for I2S 0 SCLK clock resource. Call default implementation to |
|
523 update generic information about the resource |
|
524 */ |
|
525 TInt DNE1_TBI2S0SclkResource::GetInfo(TDes8* aInfo)const |
|
526 { |
|
527 DStaticPowerResource::GetInfo((TDes8*)aInfo); |
|
528 TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)aInfo; |
|
529 buf1->iMinLevel = EI2SSclk8000Hz; |
|
530 buf1->iMaxLevel = EI2SSclk44100Hz; |
|
531 return KErrNone; |
|
532 } |
|
533 |
|
534 /** This function takes care of the requested resource operation (read / write) for I2S 0 SCLK clock resource. |
|
535 This is called from PIL on response to change or read resource state. |
|
536 */ |
|
537 TInt DNE1_TBI2S0SclkResource::DoRequest(TPowerRequest& aRequest) |
|
538 { |
|
539 TUint level; |
|
540 if(aRequest.ReqType() == TPowerRequest::EGet) |
|
541 { |
|
542 level = AsspRegister::Read32(KHwBaseI2S0+KHoI2SCtrl); |
|
543 aRequest.Level() = (level >> SHIFT_BY_16) & 0xF; |
|
544 } |
|
545 else if(aRequest.ReqType() == TPowerRequest::ESetDefaultLevel) |
|
546 { |
|
547 //Set to default level |
|
548 AsspRegister::Modify32(KHwBaseI2S0+KHoI2SCtrl, KClearBit16_19, (iDefaultLevel << SHIFT_BY_16)); |
|
549 aRequest.Level() = iDefaultLevel; |
|
550 } |
|
551 else if(aRequest.ReqType() == TPowerRequest::EChange) |
|
552 { |
|
553 //Set to request frequency |
|
554 AsspRegister::Modify32(KHwBaseI2S0+KHoI2SCtrl, KClearBit16_19, (aRequest.Level() << SHIFT_BY_16)); |
|
555 } |
|
556 else |
|
557 { |
|
558 return KErrNotSupported; |
|
559 } |
|
560 return KErrNone; |
|
561 } |
|
562 |
|
563 /** Constructor for I2S 1 SCLK resource */ |
|
564 DNE1_TBI2S1SclkResource::DNE1_TBI2S1SclkResource():DStaticPowerResource(KI2S1Sclk, EI2SSclk8000Hz) |
|
565 { |
|
566 iFlags = EMultilevel; |
|
567 } |
|
568 |
|
569 /** This function updates the resource information for I2S 1 SCLK clock resource. Call default implementation to |
|
570 update generic information about the resource |
|
571 */ |
|
572 TInt DNE1_TBI2S1SclkResource::GetInfo(TDes8* aInfo)const |
|
573 { |
|
574 DStaticPowerResource::GetInfo((TDes8*)aInfo); |
|
575 TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)aInfo; |
|
576 buf1->iMinLevel = EI2SSclk8000Hz; |
|
577 buf1->iMaxLevel = EI2SSclk44100Hz; |
|
578 return KErrNone; |
|
579 } |
|
580 |
|
581 /** This function takes care of the requested resource operation (read / write) for I2S 1 SCLK clock resource. |
|
582 This is called from PIL on response to change or read resource state. |
|
583 */ |
|
584 TInt DNE1_TBI2S1SclkResource::DoRequest(TPowerRequest& aRequest) |
|
585 { |
|
586 TUint level; |
|
587 if(aRequest.ReqType() == TPowerRequest::EGet) |
|
588 { |
|
589 level = AsspRegister::Read32(KHwBaseI2S1+KHoI2SCtrl); |
|
590 aRequest.Level() = (level >> SHIFT_BY_16) & 0xF; |
|
591 } |
|
592 else if(aRequest.ReqType() == TPowerRequest::ESetDefaultLevel) |
|
593 { |
|
594 //Set to default level |
|
595 AsspRegister::Modify32(KHwBaseI2S1+KHoI2SCtrl, KClearBit16_19, (iDefaultLevel << SHIFT_BY_16)); |
|
596 aRequest.Level() = iDefaultLevel; |
|
597 } |
|
598 else if(aRequest.ReqType() == TPowerRequest::EChange) |
|
599 { |
|
600 //Set to request frequency |
|
601 AsspRegister::Modify32(KHwBaseI2S1+KHoI2SCtrl, KClearBit16_19, (aRequest.Level() << SHIFT_BY_16)); |
|
602 } |
|
603 else |
|
604 { |
|
605 return KErrNotSupported; |
|
606 } |
|
607 return KErrNone; |
|
608 } |
|
609 |
|
610 /** Constructor for I2S 2 SCLK resource */ |
|
611 DNE1_TBI2S2SclkResource::DNE1_TBI2S2SclkResource():DStaticPowerResource(KI2S2Sclk, EI2SSclk8000Hz) |
|
612 { |
|
613 iFlags = EMultilevel; |
|
614 } |
|
615 |
|
616 /** This function updates the resource information for I2S 2 SCLK clock resource. Call default implementation to |
|
617 update generic information about the resource |
|
618 */ |
|
619 TInt DNE1_TBI2S2SclkResource::GetInfo(TDes8* aInfo)const |
|
620 { |
|
621 DStaticPowerResource::GetInfo((TDes8*)aInfo); |
|
622 TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)aInfo; |
|
623 buf1->iMinLevel = EI2SSclk8000Hz; |
|
624 buf1->iMaxLevel = EI2SSclk44100Hz; |
|
625 return KErrNone; |
|
626 } |
|
627 |
|
628 /** This function takes care of the requested resource operation (read / write) for I2S 2 SCLK clock resource. |
|
629 This is called from PIL on response to change or read resource state. |
|
630 */ |
|
631 TInt DNE1_TBI2S2SclkResource::DoRequest(TPowerRequest& aRequest) |
|
632 { |
|
633 TUint level; |
|
634 if(aRequest.ReqType() == TPowerRequest::EGet) |
|
635 { |
|
636 level = AsspRegister::Read32(KHwBaseI2S2+KHoI2SCtrl); |
|
637 aRequest.Level() = (level >> SHIFT_BY_16) & 0xF; |
|
638 } |
|
639 else if(aRequest.ReqType() == TPowerRequest::ESetDefaultLevel) |
|
640 { |
|
641 //Set to default level |
|
642 AsspRegister::Modify32(KHwBaseI2S2+KHoI2SCtrl, KClearBit16_19, (iDefaultLevel << SHIFT_BY_16)); |
|
643 aRequest.Level() = iDefaultLevel; |
|
644 } |
|
645 else if(aRequest.ReqType() == TPowerRequest::EChange) |
|
646 { |
|
647 //Set to request frequency |
|
648 AsspRegister::Modify32(KHwBaseI2S2+KHoI2SCtrl, KClearBit16_19, (aRequest.Level() << SHIFT_BY_16)); |
|
649 } |
|
650 else |
|
651 { |
|
652 return KErrNotSupported; |
|
653 } |
|
654 return KErrNone; |
|
655 } |
|
656 |
|
657 /** Constructor for I2S 3 SCLK resource */ |
|
658 DNE1_TBI2S3SclkResource::DNE1_TBI2S3SclkResource():DStaticPowerResource(KI2S3Sclk, EI2SSclk8000Hz) |
|
659 { |
|
660 iFlags = EMultilevel; |
|
661 } |
|
662 |
|
663 /** This function updates the resource information for I2S 3 SCLK clock resource. Call default implementation to |
|
664 update generic information about the resource |
|
665 */ |
|
666 TInt DNE1_TBI2S3SclkResource::GetInfo(TDes8* aInfo)const |
|
667 { |
|
668 DStaticPowerResource::GetInfo((TDes8*)aInfo); |
|
669 TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)aInfo; |
|
670 buf1->iMinLevel = EI2SSclk8000Hz; |
|
671 buf1->iMaxLevel = EI2SSclk44100Hz; |
|
672 return KErrNone; |
|
673 } |
|
674 |
|
675 /** This function takes care of the requested resource operation (read / write) for I2S 3 SCLK clock resource. |
|
676 This is called from PIL on response to change or read resource state. |
|
677 */ |
|
678 TInt DNE1_TBI2S3SclkResource::DoRequest(TPowerRequest& aRequest) |
|
679 { |
|
680 TUint level; |
|
681 if(aRequest.ReqType() == TPowerRequest::EGet) |
|
682 { |
|
683 level = AsspRegister::Read32(KHwBaseI2S3+KHoI2SCtrl); |
|
684 aRequest.Level() = (level >> SHIFT_BY_16) & 0xF; |
|
685 } |
|
686 else if(aRequest.ReqType() == TPowerRequest::ESetDefaultLevel) |
|
687 { |
|
688 //Set to default level |
|
689 AsspRegister::Modify32(KHwBaseI2S3+KHoI2SCtrl, KClearBit16_19, (iDefaultLevel << SHIFT_BY_16)); |
|
690 aRequest.Level() = iDefaultLevel; |
|
691 } |
|
692 else if(aRequest.ReqType() == TPowerRequest::EChange) |
|
693 { |
|
694 //Set to request frequency |
|
695 AsspRegister::Modify32(KHwBaseI2S3+KHoI2SCtrl, KClearBit16_19, (aRequest.Level() << SHIFT_BY_16)); |
|
696 } |
|
697 else |
|
698 { |
|
699 return KErrNotSupported; |
|
700 } |
|
701 return KErrNone; |
|
702 } |
|
703 |
|
704 /** Constructor for PCI Clock resource */ |
|
705 DNE1_TBPCIClockResource::DNE1_TBPCIClockResource():DStaticPowerResource(KPCIClk, E_OFF) |
|
706 { |
|
707 iFlags = 0; |
|
708 } |
|
709 |
|
710 /** This function updates the resource information for PCI mask clock resource. Call default implementation to |
|
711 update generic information about the resource |
|
712 */ |
|
713 TInt DNE1_TBPCIClockResource::GetInfo(TDes8* aInfo)const |
|
714 { |
|
715 DStaticPowerResource::GetInfo((TDes8*)aInfo); |
|
716 TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)aInfo; |
|
717 buf1->iMinLevel = E_OFF; |
|
718 buf1->iMaxLevel = E_ON; |
|
719 return KErrNone; |
|
720 } |
|
721 |
|
722 /** This function takes care of the requested resource operation (read / write) for PCI clock resource. |
|
723 This is called from PIL on response to change or read resource state. |
|
724 */ |
|
725 TInt DNE1_TBPCIClockResource::DoRequest(TPowerRequest& aRequest) |
|
726 { |
|
727 TUint level; |
|
728 if(aRequest.ReqType() == TPowerRequest::EGet) |
|
729 { |
|
730 level = AsspRegister::Read32(KHwSystemCtrlBase+KHoSCUClockMaskCtrl); |
|
731 aRequest.Level() = (level >> SHIFT_BY_9) & 0x1; |
|
732 } |
|
733 else if(aRequest.ReqType() == TPowerRequest::ESetDefaultLevel) |
|
734 { |
|
735 //Set to default level |
|
736 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUDivideI2SCLKCtrl, KClearBit09, KSetBit09); |
|
737 aRequest.Level() = iDefaultLevel; |
|
738 } |
|
739 else if(aRequest.ReqType() == TPowerRequest::EChange) |
|
740 { |
|
741 if(aRequest.Level() == E_OFF) |
|
742 {//Mask the clock |
|
743 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUClockMaskCtrl, KClearBit09, KSetBit09); |
|
744 } |
|
745 else |
|
746 {//Enable the clock |
|
747 AsspRegister::Modify32(KHwSystemCtrlBase+KHoSCUClockMaskCtrl, KClearBit09, KClearBit09); |
|
748 } |
|
749 } |
|
750 else |
|
751 { |
|
752 return KErrNotSupported; |
|
753 } |
|
754 return KErrNone; |
|
755 } |
|
756 |
|
757 |
|
758 |
|
759 |
|
760 |
|
761 |
|
762 |