kernel/eka/include/e32hal.h
changeset 0 a41df078684a
child 291 206a6eaaeb71
equal deleted inserted replaced
-1:000000000000 0:a41df078684a
       
     1 // Copyright (c) 1995-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 // e32\include\e32hal.h
       
    15 // 
       
    16 //
       
    17 
       
    18 #ifndef __E32HAL_H__
       
    19 #define __E32HAL_H__
       
    20 #include <e32cmn.h>
       
    21 #include <e32cmn_private.h>
       
    22 
       
    23 /**
       
    24 @publishedPartner
       
    25 @deprecated No replacement.
       
    26 */ 
       
    27 const TInt KMaxRomDevices=8;
       
    28 
       
    29 
       
    30 
       
    31 
       
    32 /**
       
    33 @publishedPartner
       
    34 @released
       
    35 
       
    36 Defines the calibration settings that can be restored by 
       
    37 the digitiser's implementation of DDigitiser::RestoreXYInputCalibration.
       
    38 
       
    39 See the digitiser template port in:
       
    40 @code
       
    41 ...\template\template_variant\specific\xyin.cpp
       
    42 @endcode
       
    43 
       
    44 @see DDigitiser::RestoreXYInputCalibration()
       
    45 */ 
       
    46 enum TDigitizerCalibrationType
       
    47     {
       
    48     EFactory, /**< Restore to factory settings. */
       
    49     ESaved    /**< Restore to saved settings.   */
       
    50     };
       
    51 
       
    52 
       
    53 
       
    54 
       
    55 /**
       
    56 @publishedPartner
       
    57 @released
       
    58 
       
    59 Defines the screen coordinates of the point touched during calibration.
       
    60 
       
    61 An object of this type is passed, via a TPckgBuf, to the HAL handler
       
    62 that deals with the HAL group function-id pair:
       
    63 - EHalGroupDigitiser, EDigitiserHalSetXYInputCalibration
       
    64 - EHalGroupDigitiser, EDigitiserHalCalibrationPoints
       
    65 - EHalGroupDigitiser, EDigitiserHalRestoreXYInputCalibration
       
    66 
       
    67 @see EDigitiserHalSetXYInputCalibration
       
    68 @see EDigitiserHalCalibrationPoints
       
    69 @see EDigitiserHalRestoreXYInputCalibration
       
    70 @see TDigitiserHalFunction
       
    71 @see EHalGroupDigitiser
       
    72 @see TPckgBuf
       
    73 */ 
       
    74 class TDigitizerCalibration
       
    75     {
       
    76 public:
       
    77     TPoint iTl;  /**< Top left point.*/
       
    78     TPoint iBl;  /**< Bottom left point. */
       
    79     TPoint iTr;  /**< Top right point.*/
       
    80     TPoint iBr;  /**< Bottom right point.*/
       
    81     };
       
    82 
       
    83 
       
    84 
       
    85 
       
    86 /**
       
    87 @publishedPartner
       
    88 @released
       
    89 
       
    90 An enum that identifies the full set of keyboard types.
       
    91 
       
    92 A variable of this type is defined and used in the TKeyboardInfoV01 struct. 
       
    93 
       
    94 @see TKeyboardInfoV01::iKeyboardType.
       
    95 */ 
       
    96 enum TKeyboard
       
    97 	{
       
    98 	EKeyboard_Keypad=1, /**< Keypad type*/
       
    99 	EKeyboard_Full=2,   /**< Full keyboard type*/
       
   100 	};
       
   101 
       
   102 
       
   103 
       
   104 
       
   105 /**
       
   106 @publishedPartner
       
   107 @released
       
   108 
       
   109 Encapsulates information about the keyboard.
       
   110 
       
   111 NOTE that the information represented here is not used by Symbian OS, 
       
   112 and exists to maintain binary compatibilty with older versions.
       
   113 
       
   114 However, keyboard drivers that implement the HAL handler for
       
   115 the EHalGroupKeyboard group still need to return a default object
       
   116 of this type.
       
   117 See the template port.
       
   118 
       
   119 An object of this type is passed, via a TPckgBuf, to the HAL handler
       
   120 that deals with the HAL group function-id pair:
       
   121 - EHalGroupKeyboard, EKeyboardHalKeyboardInfo;
       
   122 
       
   123 @see EKeyboardHalKeyboardInfo
       
   124 @see TKeyboardHalFunction
       
   125 @see EHalGroupKeyboard
       
   126 @see TPckgBuf
       
   127 */ 
       
   128 class TKeyboardInfoV01
       
   129 	{
       
   130 public:
       
   131     /**
       
   132     The number of device keys.
       
   133     
       
   134     NOTE that the information represented by this variable is not
       
   135     used by Symbian OS, and exists to maintain binary compatibility
       
   136     with older versions. 
       
   137     */
       
   138 	TInt iDeviceKeys;
       
   139 	
       
   140 	
       
   141 	/**
       
   142 	The number of application keys.
       
   143 	
       
   144 	NOTE that the information represented by this variable is not
       
   145     used by Symbian OS, and exists to maintain binary compatibility
       
   146     with older versions. 
       
   147 	*/
       
   148     TInt iAppsKeys;
       
   149     
       
   150     
       
   151     /**
       
   152     Defines the type of keyboard available as enumerated by
       
   153     the TKeyboard enum.
       
   154         
       
   155     NOTE that the information represented by this variable is not
       
   156     used by Symbian OS, and exists to maintain binary compatibility
       
   157     with older versions. 
       
   158             
       
   159     @see TKeyboard
       
   160     */
       
   161 	TKeyboard iKeyboardType;
       
   162     };
       
   163     
       
   164     
       
   165     
       
   166     
       
   167 /**
       
   168 @publishedPartner
       
   169 @released
       
   170 
       
   171 Package buffer for a TKeyboardInfoV01 object.
       
   172 
       
   173 @see TKeyboardInfoV01
       
   174 */ 
       
   175 typedef TPckgBuf<TKeyboardInfoV01> TKeyboardInfoV01Buf;
       
   176 
       
   177 
       
   178 
       
   179 
       
   180 /**
       
   181 @publishedPartner
       
   182 @released
       
   183 
       
   184 Encapsulates information about the digitiser.
       
   185 
       
   186 An object of this type is passed, via a TPckgBuf, to the HAL handler
       
   187 that deals with the HAL group function-id pair:
       
   188 - EHalGroupDigitiser, EDigitiserHalXYInfo;
       
   189 
       
   190 @see EDigitiserHalXYInfo
       
   191 @see TDigitiserHalFunction
       
   192 @see EHalGroupDigitiser
       
   193 @see TPckgBuf
       
   194 */ 
       
   195 class TDigitiserInfoV01
       
   196 	{
       
   197 public:
       
   198 	TPoint iOffsetToDisplay;/**< The offset in pixels from the digitiser usable area to the display area. */
       
   199 	TSize iDigitiserSize;   /**< The width/height of the display in pixels as used by digitiser.*/
       
   200 	};
       
   201 	
       
   202 	
       
   203 /**
       
   204 @publishedPartner
       
   205 @released
       
   206 Encapsulates extra information required by 3 dimensional pointing devices.
       
   207 */ 
       
   208 class TDigitiserInfoV02 : public TDigitiserInfoV01
       
   209 	{	
       
   210 public :
       
   211 	TInt iZRange;			/**< The maximum distance to screen a pointing device will be detected (settable).*/
       
   212 	TUint8 iThetaSupported;	/**< A Boolean value that indicates if Theta polar angle detection (tilt) is supported.*/
       
   213 	TUint8 iPhiSupported;	/**< A Boolean value that indicates if Phi polar angle detection (tilt) is supported.*/
       
   214 	TUint8 iAlphaSupported;	/**< A Boolean value that indicates if rotation of the pointing device along its main axis is supported.*/
       
   215 	TUint8 iPressureSupported; /**< A Boolean value that indicates if pressure applied on screen is supported.*/
       
   216 	TInt iProximityStep;    /**<proximity resolution, e.g. proximity readings change in steps of 1, 5, 10, ... */
       
   217 	TInt iMaxPressure;      /**< maximum pressure reading*/
       
   218 	TInt iPressureStep;     /**< pressure resolution, */	
       
   219 	TUint8 iMaxPointers;    /**< max number of multi-touch pointers supported by hardware/driver.*/ 
       
   220 	TUint8 iNumberOfPointers;/**< Number of pointers it supports (settable).*/
       
   221 	};
       
   222 
       
   223 
       
   224 /**
       
   225 @publishedPartner
       
   226 @released
       
   227 
       
   228 Package buffer for a TDigitiserInfoV01 object.
       
   229 
       
   230 @see TDigitiserInfoV01
       
   231 */ 
       
   232 typedef TPckgBuf<TDigitiserInfoV01> TDigitiserInfoV01Buf;
       
   233 
       
   234 /**
       
   235 @publishedPartner
       
   236 @prototype
       
   237 
       
   238 Package buffer for a TDigitiserInfoV02 object.
       
   239 
       
   240 @see TDigitiserInfoV02
       
   241 */ 
       
   242 typedef TPckgBuf<TDigitiserInfoV02> TDigitiserInfoV02Buf;
       
   243 
       
   244 /**
       
   245 @publishedPartner
       
   246 @released
       
   247 
       
   248 Encapsulates information about the mouse display characteristics.
       
   249 
       
   250 An object of this type is passed, via a TPckgBuf, to the HAL handler
       
   251 that deals with the HAL group function-id pair:
       
   252 - EHalGroupMouse, EMouseHalMouseInfo;
       
   253 
       
   254 @see EMouseHalMouseInfo
       
   255 @see TMouseHalFunction
       
   256 @see EHalGroupMouse
       
   257 @see TPckgBuf
       
   258 */ 
       
   259 class TMouseInfoV01
       
   260 	{
       
   261 public:
       
   262 	TInt iMouseButtons;      /**< The number of mouse buttons.*/
       
   263 	TPoint iOffsetToDisplay; /**< The offset in pixels from the mouse usable area to the display area.*/
       
   264 	TSize iMouseAreaSize;    /**< The width/height of the display in pixels as used by the mouse.     */
       
   265 	};
       
   266 	
       
   267 	
       
   268 	
       
   269 	
       
   270 /**
       
   271 @publishedPartner
       
   272 @released
       
   273 
       
   274 Package buffer for a TMouseInfoV01 object.
       
   275 
       
   276 @see TMouseInfoV01
       
   277 */ 
       
   278 typedef TPckgBuf<TMouseInfoV01> TMouseInfoV01Buf;
       
   279 
       
   280 
       
   281 
       
   282 /**
       
   283 @publishedPartner
       
   284 @released
       
   285 
       
   286 Encapsulates Variant specific information.
       
   287 
       
   288 An object of this type is passed, via a TPckgBuf, to the HAL handler
       
   289 that deals with the HAL group function-id pair:
       
   290 - EHalGroupVariant, EVariantHalVariantInfo;
       
   291 
       
   292 @see EVariantHalVariantInfo
       
   293 @see TVariantHalFunction
       
   294 @see EHalGroupVariant
       
   295 @see TPckgBuf
       
   296 */ 
       
   297 class TVariantInfoV01
       
   298 	{
       
   299 public:
       
   300     /**
       
   301     The ROM version.
       
   302     */
       
   303 	TVersion iRomVersion;
       
   304 	
       
   305 	/**
       
   306 	The Id that uniquely identifies the device.
       
   307 	*/
       
   308 	SInt64 iMachineUniqueId;
       
   309 	
       
   310 	/**
       
   311 	The bits that represent the LED capabilities.
       
   312 	
       
   313 	NB capabilities in this context does not mean security capabilities.
       
   314 	*/
       
   315     TUint iLedCapabilities;
       
   316     
       
   317     /**
       
   318     The processor clock speed.
       
   319     */
       
   320     TInt iProcessorClockInKHz;
       
   321     
       
   322     /**
       
   323     The speed factor. 
       
   324     */
       
   325     TInt iSpeedFactor;
       
   326     };
       
   327     
       
   328     
       
   329     
       
   330     
       
   331 /**
       
   332 @publishedPartner
       
   333 @released
       
   334 
       
   335 Package buffer for a TVariantInfoV01 object.
       
   336 
       
   337 @see TVariantInfoV01
       
   338 */ 
       
   339 typedef TPckgBuf<TVariantInfoV01> TVariantInfoV01Buf;
       
   340 
       
   341 
       
   342 
       
   343 
       
   344 /**
       
   345 @publishedPartner
       
   346 @deprecated Use HAL::Get() from the HAL library instead with attributes ESystemStartupReason.
       
   347 
       
   348 The reason that the device last reset
       
   349 
       
   350 Note that not all reasons can occur on all devices.
       
   351 */
       
   352 enum TMachineStartupType
       
   353 	{
       
   354 	EStartupCold,EStartupColdReset,EStartupNewOs,
       
   355 	EStartupPowerFail,EStartupWarmReset,EStartupKernelFault,
       
   356 	EStartupSafeReset
       
   357 	};
       
   358 
       
   359 
       
   360 
       
   361 
       
   362 /**
       
   363 @publishedPartner
       
   364 @deprecated Use HAL::Get() from the HAL library instead with attributes  EPen or EMouse.
       
   365 
       
   366 The XY input method supported
       
   367 */
       
   368 enum TXYInputType
       
   369 	{
       
   370 	EXYInputNone,
       
   371 	EXYInputPointer,
       
   372 	EXYInputMouse,
       
   373 	EXYInputDeltaMouse
       
   374 	};
       
   375 
       
   376 
       
   377 
       
   378 /**
       
   379 @publishedPartner
       
   380 @deprecated Use HAL::Get() from the HAL library instead.
       
   381 
       
   382 Miscellaneous machine info.
       
   383 */
       
   384 class TMachineInfoV1
       
   385 	{
       
   386 public:
       
   387 	TVersion iRomVersion;
       
   388 	TXYInputType iXYInputType;
       
   389 	TBool iKeyboardPresent;
       
   390 	TBool iBacklightPresent;
       
   391     TSize iDisplaySizeInPixels;
       
   392     TSize iXYInputSizeInPixels;
       
   393     TSize iPhysicalScreenSize;
       
   394 	TPoint iOffsetToDisplayInPixels;
       
   395 	TInt iKeyboardId;
       
   396 	TInt iDisplayId;
       
   397 	SInt64 iMachineUniqueId;
       
   398     TUint iLedCapabilities;
       
   399     TInt iProcessorClockInKHz;
       
   400     TInt iSpeedFactor;
       
   401     TInt iMaximumDisplayColors;
       
   402 	};
       
   403 /**
       
   404 @publishedPartner
       
   405 @deprecated
       
   406 */
       
   407 typedef TPckgBuf<TMachineInfoV1> TMachineInfoV1Buf;
       
   408 
       
   409 
       
   410 
       
   411 
       
   412 /**
       
   413 @publishedPartner
       
   414 @deprecated Use HAL::Get() from the HAL library instead with attributes ELanguageIndex or EKeyboardIndex.
       
   415 
       
   416 Miscellaneous locale info.
       
   417 */
       
   418 class TMachineInfoV2 : public TMachineInfoV1
       
   419 	{
       
   420 public:
       
   421 	TInt iLanguageIndex;
       
   422     TInt iKeyboardIndex;
       
   423     };
       
   424 /**
       
   425 @publishedPartner
       
   426 @deprecated
       
   427 */
       
   428 typedef TPckgBuf<TMachineInfoV2> TMachineInfoV2Buf;
       
   429 
       
   430 
       
   431 
       
   432 
       
   433 /**
       
   434 @publishedPartner
       
   435 @deprecated Use HAL::Get() from the HAL library instead with attributes EMemoryRAM, EMemoryRAMFree or EMemoryROM.
       
   436 
       
   437 Miscellaneous memory info.
       
   438 */ 
       
   439 class TMemoryInfoV1
       
   440     {
       
   441 public:
       
   442     TInt iTotalRamInBytes;
       
   443     TInt iTotalRomInBytes;
       
   444     TInt iMaxFreeRamInBytes;
       
   445     TInt iFreeRamInBytes;
       
   446     TInt iInternalDiskRamInBytes;
       
   447     TBool iRomIsReprogrammable;
       
   448     };
       
   449 /**
       
   450 @publishedPartner
       
   451 @deprecated
       
   452 */
       
   453 typedef TPckgBuf<TMemoryInfoV1> TMemoryInfoV1Buf;
       
   454 
       
   455 
       
   456 
       
   457 
       
   458 /**
       
   459 @publishedPartner
       
   460 @deprecated No replacement.
       
   461 
       
   462 Miscellaneous ROM info.
       
   463 */ 
       
   464 class TRomInfoEntryV1
       
   465 	{
       
   466 public:
       
   467     enum TRomTypeV1
       
   468     	{
       
   469     	ERomTypeRom=0,
       
   470     	ERomTypeFlash=1
       
   471     	};
       
   472 	TInt iSize;		    // size of ROM in bytes, 0=no ROM present
       
   473 	TInt iWidth;		// bus width in bits
       
   474 	TInt iSpeed;		// number of wait states
       
   475 	TRomTypeV1 iType;	// 0=ROM, 1=FLASH
       
   476 	};
       
   477 
       
   478 
       
   479 
       
   480 
       
   481 /**
       
   482 @publishedPartner
       
   483 @deprecated No replacement.
       
   484 
       
   485 Miscellaneous ROM info.
       
   486 */ 
       
   487 class TRomInfoV1
       
   488 	{
       
   489 public:
       
   490 	TRomInfoEntryV1	iEntry[KMaxRomDevices];
       
   491 	};
       
   492 /**
       
   493 @publishedPartner
       
   494 @deprecated
       
   495 */
       
   496 typedef TPckgBuf<TRomInfoV1> TRomInfoV1Buf;
       
   497 
       
   498 /**
       
   499 @publishedPartner
       
   500 @released
       
   501 */
       
   502 const TUint KRuggedFileSystem=0x01;
       
   503 
       
   504 /**
       
   505 @publishedPartner
       
   506 @released
       
   507 */
       
   508 class TDriveInfoV1
       
   509     {
       
   510 public:
       
   511 	TInt iTotalSupportedDrives;
       
   512 	TInfoName iDriveName[KMaxLocalDrives];
       
   513 	TInt iTotalSockets;
       
   514 	TInfoName iSocketName[KMaxPBusSockets];
       
   515 	TInt iRuggedFileSystem;
       
   516 	TUint iRegisteredDriveBitmask;
       
   517 	};
       
   518 /**
       
   519 @publishedPartner
       
   520 @released
       
   521 */
       
   522 typedef TPckgBuf<TDriveInfoV1> TDriveInfoV1Buf;
       
   523 
       
   524 #if defined(_UNICODE) && !defined(__KERNEL_MODE__)
       
   525 /**
       
   526 @publishedPartner
       
   527 @released
       
   528 */
       
   529 class TDriveInfoV18
       
   530     {
       
   531 public:
       
   532 	TInt iTotalSupportedDrives;
       
   533 	TBuf8<KMaxInfoName> iDriveName[KMaxLocalDrives]; //TInfoName
       
   534 	TInt iTotalSockets;
       
   535 	TBuf8<KMaxInfoName> iSocketName[KMaxPBusSockets]; //TInfoName
       
   536 	TInt iRuggedFileSystem;
       
   537 	TUint iRegisteredDriveBitmask;
       
   538 	};
       
   539 /**
       
   540 @publishedPartner
       
   541 @released
       
   542 */
       
   543 typedef TPckgBuf<TDriveInfoV18> TDriveInfoV1Buf8;
       
   544 #else
       
   545 typedef TDriveInfoV1 TDriveInfoV18;
       
   546 typedef TDriveInfoV1Buf TDriveInfoV1Buf8;
       
   547 #endif
       
   548 
       
   549 /**
       
   550 @publishedPartner
       
   551 @released
       
   552 */
       
   553 class TExcInfo
       
   554 	{
       
   555 public:
       
   556 	TAny *iCodeAddress;
       
   557 	TAny *iDataAddress;
       
   558 	TInt iExtraData;
       
   559 	};
       
   560 
       
   561 #ifndef __KERNEL_MODE__
       
   562 #include <e32std.h>
       
   563 
       
   564 
       
   565 
       
   566 
       
   567 /**
       
   568 @publishedPartner
       
   569 @released
       
   570 
       
   571 A set of user side utility functions for acessing hardware related
       
   572 information.
       
   573 
       
   574 Four of these functions are DEPRECATED and should NOT be used; some of
       
   575 these functions have replacements, but others do not; see the description of
       
   576 the individual functions.
       
   577 
       
   578 The following functions are not deprecated, but are only used by Symbian
       
   579 OS as part of its internal implementation:
       
   580 -  UserHal::FaultReason()
       
   581 -  UserHal::ExceptionId()
       
   582 -  UserHal::ExceptionInfo()
       
   583 -  UserHal::PageSizeInBytes()
       
   584 -  UserHal::TickPeriod()
       
   585 -  UserHal::DriveInfo()
       
   586 -  UserHal::SwitchOff()
       
   587 -  UserHal::SetXYInputCalibration()
       
   588 -  UserHal::CalibrationPoints()
       
   589 -  UserHal::SaveXYInputCalibration()
       
   590 -  UserHal::RestoreXYInputCalibration()
       
   591 */
       
   592 class UserHal
       
   593 	{
       
   594 public:
       
   595 	// kernel group
       
   596 	IMPORT_C static TInt MemoryInfo(TDes8& anInfo);
       
   597 	IMPORT_C static TInt RomInfo(TDes8& anInfo);
       
   598 	IMPORT_C static TInt StartupReason(TMachineStartupType& aReason);
       
   599 	IMPORT_C static TInt FaultReason(TInt &aReason);
       
   600 	IMPORT_C static TInt ExceptionId(TInt &anId);
       
   601 	IMPORT_C static TInt ExceptionInfo(TExcInfo &aInfo);
       
   602 	IMPORT_C static TInt PageSizeInBytes(TInt& aSize);
       
   603 
       
   604 	// variant group
       
   605 	IMPORT_C static TInt MachineInfo(TDes8& anInfo);
       
   606 	IMPORT_C static TInt TickPeriod(TTimeIntervalMicroSeconds32& aPeriod);
       
   607 
       
   608 	// media group
       
   609 	IMPORT_C static TInt DriveInfo(TDes8& anInfo);
       
   610 
       
   611 	// power group
       
   612    	IMPORT_C static TInt SwitchOff();
       
   613 
       
   614 	// digitiser group
       
   615 	IMPORT_C static TInt SetXYInputCalibration(const TDigitizerCalibration& aCalibration);
       
   616 	IMPORT_C static TInt CalibrationPoints(TDigitizerCalibration& aCalibration);
       
   617 	IMPORT_C static TInt SaveXYInputCalibration();
       
   618 	IMPORT_C static TInt RestoreXYInputCalibration(TDigitizerCalibrationType aType);
       
   619 	};
       
   620 #endif
       
   621 #endif
       
   622