1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Hardware Configuration Respoitory Platform Independent Layer (PIL)

    15 //

    16 

    17 // -- INCLUDES ----------------------------------------------------------------

    18 

    19 

    20 #include <nkern/nkern.h>

    21 #include <kernel/kernel.h>

    22 

    23 #ifdef HCRTEST_NO_EXPORT

    24 #undef EXPORT_C

    25 #undef IMPORT_C

    26 #define EXPORT_C

    27 #define IMPORT_C

    28 #endif // HCRTEST_NO_EXPORT

    29 

    30 #include <drivers/hcr.h>

    31 #include "hcr_debug.h"

    32 #include "hcr_pil.h"

    33 

    34 

    35 // -- FUNCTIONS ---------------------------------------------------------------

    36 

    37 #ifndef MAKE_DEF_FILE

    38 namespace HCR 

    39 {

    40 

    41 LOCAL_C TInt GetUValueWordSetting (const TSettingId& aId, 

    42                                     TSettingType aType, UValueWord& aValue)

    43     {

    44     HCR_FUNC("GetUValueWordSetting");

    45                  

    46     if (HCRNotReady)

    47         HCR_LOG_RETURN(KErrNotReady);

    48 

    49     TSettingRef sref(0,0);

    50     TInt err = 0;

    51     err = HCRSingleton->FindSetting(aId, aType, sref);

    52     if (err != KErrNone)

    53         HCR_LOG_RETURN(err);

    54 

    55     err = sref.iRep->GetValue(sref, aValue);

    56     if (err != KErrNone)

    57         HCR_LOG_RETURN(err);

    58     

    59     return KErrNone;	

    60     }

    61     

    62 LOCAL_C TInt GetUValueLargeSetting64 (const TSettingId& aId, 

    63                                     TSettingType aType, UValueLarge& aValue)

    64     {

    65     HCR_FUNC("GetUValueLargeSetting64");

    66                  

    67     if (HCRNotReady)

    68 		HCR_LOG_RETURN(KErrNotReady);

    69 

    70     TSettingRef sref(0,0);

    71     TInt err = 0;

    72     err = HCRSingleton->FindSetting(aId, aType, sref);

    73     if (err != KErrNone)

    74         HCR_LOG_RETURN(err);

    75 

    76     err = sref.iRep->GetLargeValue(sref, aValue);

    77     if (err != KErrNone)

    78         HCR_LOG_RETURN(err);

    79     

    80     return KErrNone;	

    81     }

    82     

    83 

    84 LOCAL_C TInt GetUValueLargeSettingTDes8 (const TSettingId& aId, 

    85                                         TSettingType aType, TDes8& aValue)

    86     {

    87     HCR_FUNC("GetUValueLargeSettingTDes8");

    88                  

    89     if (HCRNotReady)

    90 	    HCR_LOG_RETURN(KErrNotReady);

    91 

    92     TSettingRef sref(0,0);

    93     TInt err = 0;

    94     err = HCRSingleton->FindSetting(aId, aType, sref);

    95     if (err != KErrNone)

    96         HCR_LOG_RETURN(err);

    97 

    98     UValueLarge value;

    99     err = sref.iRep->GetLargeValue(sref, value);

   100     if (err != KErrNone)

   101         HCR_LOG_RETURN(err);

   102    

   103     TInt len = sref.iRep->GetLength(sref);

   104     if (len > aValue.MaxSize())

   105         HCR_LOG_RETURN(KErrTooBig);    

   106     

   107     if (aType == ETypeBinData)

   108         aValue.Copy(value.iData, len);

   109     else

   110         aValue.Copy(value.iString8, len);

   111     

   112     return KErrNone;	

   113     }

   114 

   115 LOCAL_C TInt GetUValueLargeSettingTUint8 (const TSettingId& aId, TSettingType aType, 

   116                                     TUint16 aMaxLen, TUint8* aValue, TUint16& aLen)

   117     {

   118     HCR_FUNC("GetUValueLargeSettingTUint8");

   119                  

   120     if (HCRNotReady)

   121 	    HCR_LOG_RETURN(KErrNotReady);

   122 

   123     TSettingRef sref(0,0);

   124     TInt err = 0;

   125     err = HCRSingleton->FindSetting(aId, aType, sref);

   126     if (err != KErrNone)

   127         HCR_LOG_RETURN(err);

   128 

   129     UValueLarge value;

   130     err = sref.iRep->GetLargeValue(sref, value);

   131 	    if (err != KErrNone)

   132         HCR_LOG_RETURN(err);

   133    

   134     aLen = sref.iRep->GetLength(sref);

   135     if (aLen > aMaxLen)

   136         HCR_LOG_RETURN(KErrTooBig);    

   137     

   138     if (aType == ETypeBinData)

   139         memcpy (aValue, value.iData, aLen);

   140     else

   141         memcpy (aValue, value.iString8, aLen);

   142     

   143     return KErrNone;	

   144     }

   145     

   146 LOCAL_C TInt GetUValueLargeSettingArray (const TSettingId& aId, TSettingType aType, 

   147                                     TUint16 aMaxLen, TUint32* aValue, TUint16& aLen)

   148     {

   149     HCR_FUNC("GetUValueLargeSettingArray");

   150                  

   151     if (HCRNotReady)

   152 	    HCR_LOG_RETURN(KErrNotReady);

   153 

   154     TSettingRef sref(0,0);

   155     TInt err = 0;

   156     err = HCRSingleton->FindSetting(aId, aType, sref);

   157     if (err != KErrNone)

   158         HCR_LOG_RETURN(err);

   159 

   160     UValueLarge value;

   161     err = sref.iRep->GetLargeValue(sref, value);

   162     if (err != KErrNone)

   163         HCR_LOG_RETURN(err);

   164    

   165     aLen = sref.iRep->GetLength(sref);

   166     if (aLen > aMaxLen)

   167         HCR_LOG_RETURN(KErrTooBig);    

   168     

   169     if (aType == ETypeArrayInt32)

   170         memcpy (aValue, value.iArrayInt32, aLen);

   171     else if (aType == ETypeArrayUInt32)

   172         memcpy (aValue, value.iArrayUInt32, aLen);

   173     else

   174     	HCR_LOG_RETURN(KErrGeneral);

   175     

   176     return KErrNone;	

   177     }

   178     

   179 }

   180 

   181 #endif // MAKE_DEF_FILE

   182 

   183 

   184 // -- SETTING GET -------------------------------------------------------------

   185 

   186 

   187 EXPORT_C TInt HCR::GetInt(const TSettingId& aId, TInt8& aValue)

   188     {

   189 #ifndef MAKE_DEF_FILE

   190     HCR_FUNC("HCR::GetInt8");

   191     

   192     UValueWord value;

   193     TInt err = GetUValueWordSetting(aId, ETypeInt8, value);

   194     if (err != KErrNone)

   195         HCR_LOG_RETURN(err);        

   196     

   197     aValue = value.iInt8;

   198     return KErrNone;    

   199 #else    

   200     return KErrNotSupported;

   201 #endif // MAKE_DEF_FILE

   202     }

   203     

   204     

   205 EXPORT_C TInt HCR::GetInt(const TSettingId& aId, TInt16& aValue) 

   206     {

   207 #ifndef MAKE_DEF_FILE

   208     HCR_FUNC("HCR::GetInt16");

   209     

   210     UValueWord value;

   211     TInt err = GetUValueWordSetting(aId, ETypeInt16, value);

   212     if (err != KErrNone)

   213         HCR_LOG_RETURN(err);        

   214     

   215     aValue = value.iInt16;

   216     return KErrNone;    

   217 #else    

   218     return KErrNotSupported;

   219 #endif // MAKE_DEF_FILE

   220     }

   221     

   222 

   223 EXPORT_C TInt HCR::GetInt(const TSettingId& aId, TInt32& aValue) 

   224     {

   225 #ifndef MAKE_DEF_FILE

   226     HCR_FUNC("HCR::GetInt32");

   227     

   228         UValueWord value;

   229     TInt err = GetUValueWordSetting(aId, ETypeInt32, value);

   230     if (err != KErrNone)

   231         HCR_LOG_RETURN(err);        

   232     

   233     aValue = value.iInt32;

   234     return KErrNone;    

   235 #else    

   236     return KErrNotSupported;

   237 #endif // MAKE_DEF_FILE

   238     }

   239     

   240     

   241 EXPORT_C TInt HCR::GetInt(const TSettingId& aId, TInt64& aValue) 

   242     {

   243 #ifndef MAKE_DEF_FILE

   244     HCR_FUNC("HCR::GetInt64");

   245     

   246     UValueLarge value;

   247     TInt err = GetUValueLargeSetting64(aId, ETypeInt64, value);

   248     if (err != KErrNone)

   249         HCR_LOG_RETURN(err);        

   250     

   251     aValue = *(value.iInt64);

   252     return KErrNone;    

   253 #else    

   254     return KErrNotSupported;

   255 #endif // MAKE_DEF_FILE

   256     }

   257     

   258 

   259 EXPORT_C TInt HCR::GetBool(const TSettingId& aId, TBool& aValue) 

   260     {

   261 #ifndef MAKE_DEF_FILE

   262     HCR_FUNC("HCR::GetBool");

   263                  

   264     UValueWord value;

   265     TInt err = GetUValueWordSetting(aId, ETypeBool, value);

   266     if (err != KErrNone)

   267         HCR_LOG_RETURN(err);        

   268     

   269     aValue = value.iBool;

   270     return KErrNone;    

   271 #else    

   272     return KErrNotSupported;

   273 #endif // MAKE_DEF_FILE

   274     }

   275     

   276 

   277 EXPORT_C TInt HCR::GetUInt(const TSettingId& aId, TUint8& aValue) 

   278     {

   279 #ifndef MAKE_DEF_FILE

   280     HCR_FUNC("HCR::GetUInt8");

   281                  

   282     UValueWord value;

   283     TInt err = GetUValueWordSetting(aId, ETypeUInt8, value);

   284     if (err != KErrNone)

   285         HCR_LOG_RETURN(err);        

   286     

   287     aValue = value.iUInt8;

   288     return KErrNone;    

   289 #else    

   290     return KErrNotSupported;

   291 #endif // MAKE_DEF_FILE

   292     }

   293     

   294     

   295 EXPORT_C TInt HCR::GetUInt(const TSettingId& aId, TUint16& aValue) 

   296     {

   297 #ifndef MAKE_DEF_FILE

   298     HCR_FUNC("HCR::GetUInt16");

   299     

   300     UValueWord value;

   301     TInt err = GetUValueWordSetting(aId, ETypeUInt16,value);

   302     if (err != KErrNone)

   303         HCR_LOG_RETURN(err);        

   304     

   305     aValue = value.iUInt16;

   306     return KErrNone;    

   307 #else    

   308     return KErrNotSupported;

   309 #endif // MAKE_DEF_FILE

   310     }

   311     

   312     

   313 EXPORT_C TInt HCR::GetUInt(const TSettingId& aId, TUint32& aValue) 

   314     {

   315 #ifndef MAKE_DEF_FILE

   316     HCR_FUNC("HCR::GetUInt32");

   317     

   318     UValueWord value;

   319     TInt err = GetUValueWordSetting(aId, ETypeUInt32, value);

   320     if (err != KErrNone)

   321         HCR_LOG_RETURN(err);        

   322     

   323     aValue = value.iUInt32;

   324     return KErrNone;    

   325 #else    

   326     return KErrNotSupported;

   327 #endif // MAKE_DEF_FILE

   328     }

   329     

   330     

   331 EXPORT_C TInt HCR::GetUInt(const TSettingId& aId, TUint64& aValue) 

   332     {

   333 #ifndef MAKE_DEF_FILE

   334     HCR_FUNC("HCR::GetUInt64");

   335     

   336     UValueLarge value;

   337     TInt err = GetUValueLargeSetting64(aId, ETypeUInt64, value);

   338     if (err != KErrNone)

   339         HCR_LOG_RETURN(err);        

   340     

   341     aValue = *(value.iUInt64);

   342     return KErrNone;    

   343 #else    

   344     return KErrNotSupported;

   345 #endif // MAKE_DEF_FILE

   346     }

   347 

   348     

   349 EXPORT_C TInt HCR::GetLinAddr(const TSettingId& aId, TLinAddr& aValue)

   350     {

   351 #ifndef MAKE_DEF_FILE

   352     HCR_FUNC("HCR::GetLinAddr");

   353     

   354     UValueWord value;

   355     TInt err = GetUValueWordSetting(aId, ETypeLinAddr, value);

   356     if (err != KErrNone)

   357         HCR_LOG_RETURN(err);        

   358     

   359     aValue = value.iAddress;

   360     return KErrNone;    

   361 #else    

   362     return KErrNotSupported;

   363 #endif // MAKE_DEF_FILE

   364     }

   365         

   366     

   367 EXPORT_C TInt HCR::GetData(const TSettingId& aId, TUint16 aMaxLen, 

   368                                 TUint8* aValue, TUint16& aLen)                             

   369     {

   370 #ifndef MAKE_DEF_FILE

   371     HCR_FUNC("HCR::GetDataTUint8");

   372     

   373     TInt err = GetUValueLargeSettingTUint8(aId, ETypeBinData, aMaxLen, aValue, aLen);

   374     if (err != KErrNone)

   375         HCR_LOG_RETURN(err);        

   376     

   377     return KErrNone;    

   378 #else    

   379     return KErrNotSupported;

   380 #endif // MAKE_DEF_FILE

   381     }

   382     

   383 

   384 EXPORT_C TInt HCR::GetData(const TSettingId& aId, TDes8& aValue)

   385     {

   386 #ifndef MAKE_DEF_FILE

   387     HCR_FUNC("HCR::GetDataTDes8");

   388     

   389     TInt err = GetUValueLargeSettingTDes8(aId, ETypeBinData, aValue);

   390     if (err != KErrNone)

   391         HCR_LOG_RETURN(err);  

   392              

   393     return KErrNone;    

   394 #else    

   395     return KErrNotSupported;

   396 #endif // MAKE_DEF_FILE

   397     }

   398     

   399     

   400 EXPORT_C TInt HCR::GetString(const TSettingId& aId, TUint16 aMaxLen, 

   401                                 TText8* aValue, TUint16& aLen)

   402     {

   403 #ifndef MAKE_DEF_FILE

   404     HCR_FUNC("HCR::GetStringTUint8");

   405     

   406     TInt err = GetUValueLargeSettingTUint8(aId, ETypeText8, aMaxLen, aValue, aLen);

   407     if (err != KErrNone)

   408         HCR_LOG_RETURN(err);        

   409     

   410     return KErrNone;    

   411 #else    

   412     return KErrNotSupported;

   413 #endif // MAKE_DEF_FILE

   414     }

   415     

   416     

   417 EXPORT_C TInt HCR::GetString(const TSettingId& aId, TDes8& aValue)

   418     {

   419 #ifndef MAKE_DEF_FILE

   420     HCR_FUNC("HCR::GetStringTUint8");

   421     

   422     TInt err = GetUValueLargeSettingTDes8(aId, ETypeText8, aValue);

   423     if (err != KErrNone)

   424         HCR_LOG_RETURN(err);        

   425     

   426     return KErrNone;    

   427 #else    

   428     return KErrNotSupported;

   429 #endif // MAKE_DEF_FILE

   430     }

   431       

   432 EXPORT_C TInt HCR::GetArray(const TSettingId& aId, TUint16 aMaxLen, 

   433                                 TInt32* aValue, TUint16& aLen)

   434     {

   435 #ifndef MAKE_DEF_FILE

   436     HCR_FUNC("HCR::GetArrayTInt32");

   437     

   438     TInt err = GetUValueLargeSettingArray(aId, ETypeArrayInt32, aMaxLen, (TUint32*)aValue, aLen);

   439     if (err != KErrNone)

   440         HCR_LOG_RETURN(err);        

   441     

   442     return KErrNone;    

   443 #else    

   444     return KErrNotSupported;

   445 #endif // MAKE_DEF_FILE

   446     }

   447 								       

   448 EXPORT_C TInt HCR::GetArray(const TSettingId& aId, TUint16 aMaxLen, 

   449                                 TUint32* aValue, TUint16& aLen)  

   450     {

   451 #ifndef MAKE_DEF_FILE

   452     HCR_FUNC("HCR::GetArrayTUInt32");

   453     

   454     TInt err = GetUValueLargeSettingArray(aId, ETypeArrayUInt32, aMaxLen, aValue, aLen);

   455     if (err != KErrNone)

   456         HCR_LOG_RETURN(err);        

   457     

   458     return KErrNone;    

   459 #else    

   460     return KErrNotSupported;

   461 #endif // MAKE_DEF_FILE

   462     }

   463 

   464 

   465 // -- MULTIPLE GETS -----------------------------------------------------------

   466   

   467 EXPORT_C TInt HCR::GetWordSettings(TInt /*aNum*/, const SSettingId /*aIds*/[],

   468         TInt32 /*aValues*/[], TSettingType /*aTypes*/[], TInt /*aErrors*/[])

   469     {

   470 #ifndef MAKE_DEF_FILE

   471 

   472     return KErrNotSupported;

   473 #else    

   474     return KErrNotSupported;

   475 #endif // MAKE_DEF_FILE

   476     }

   477 

   478 

   479 // -- SETTING PROPERTIES ------------------------------------------------------

   480 

   481 EXPORT_C TInt HCR::GetTypeAndSize(const TSettingId& /*aId*/, TSettingType& /*aType*/, 

   482                                         TUint16& /*aLen*/) 

   483     {

   484 #ifndef MAKE_DEF_FILE

   485 

   486     return KErrNotSupported;

   487 #else    

   488     return KErrNotSupported;

   489 #endif // MAKE_DEF_FILE

   490     }

   491  

   492 

   493 // -- SETTING SEARCHES --------------------------------------------------------

   494 

   495 EXPORT_C TInt HCR::FindNumSettingsInCategory (TCategoryUid /*aCatUid*/)

   496 	{

   497 #ifndef MAKE_DEF_FILE

   498 

   499     return KErrNotSupported;

   500 #else    

   501     return KErrNotSupported;

   502 #endif // MAKE_DEF_FILE

   503     }

   504 		

   505 EXPORT_C TInt HCR::FindSettings(TCategoryUid /*aCatUid*/, 

   506 					TInt /*aMaxNum*/, TUint32& /*aNumFound*/, 

   507 					TElementId* /*aElIds*/, TSettingType* /*aTypes*/, TUint16* /*aLens*/)

   508 	{

   509 #ifndef MAKE_DEF_FILE

   510 

   511     return KErrNotSupported;

   512 #else    

   513     return KErrNotSupported;

   514 #endif // MAKE_DEF_FILE

   515     }

   516 

   517 EXPORT_C TInt HCR::FindSettings(TCategoryUid /*aCat*/, 

   518 					TInt /*aMaxNum*/, TUint32 /*aAtId*/,

   519                     TUint32 /*aMask*/, TUint32 /*aPattern*/, TUint32& /*aNumFound*/,

   520                     TElementId* /*aElIds*/, TSettingType* /*aTypes*/, TUint16* /*aLens*/)

   521 	{

   522 #ifndef MAKE_DEF_FILE

   523 

   524     return KErrNotSupported;

   525 #else    

   526     return KErrNotSupported;

   527 #endif // MAKE_DEF_FILE

   528     }

   529 						

   530 

   531 // -- KERNEL ENTRY POINT ------------------------------------------------------

   532 

   533 

   534 #ifdef MAKE_DEF_FILE

   535 

   536 DECLARE_STANDARD_EXTENSION()

   537 	{

   538 	return KErrNone;

   539 	}

   540 	

   541 #endif // MAKE_DEF_FILE

   542