开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
Power.h
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：70k
源码类别：

多媒体编程

开发平台：

Visual C++

Power.h：源码内容
  1. /*
  2.      File:       Power.h
  3.  
  4.      Contains:   Power Manager Interfaces.
  5.  
  6.      Version:    Technology: Mac OS 9
  7.                  Release:    QuickTime 6.0.2
  8.  
  9.      Copyright:  (c) 1990-2001 by Apple Computer, Inc.  All rights reserved
  10.  
  11.      Bugs?:      For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. */
  17. #ifndef __POWER__
  18. #define __POWER__
  20. #ifndef __MACTYPES__
  21. #include "MacTypes.h"
  22. #endif
  24. #ifndef __MIXEDMODE__
  25. #include "MixedMode.h"
  26. #endif
  28. #ifndef __MULTIPROCESSING__
  29. #include "Multiprocessing.h"
  30. #endif
  32. #ifndef __NAMEREGISTRY__
  33. #include "NameRegistry.h"
  34. #endif
  36. #ifndef __MACERRORS__
  37. #include "MacErrors.h"
  38. #endif
  43. #if PRAGMA_ONCE
  44. #pragma once
  45. #endif
  47. #ifdef __cplusplus
  48. extern "C" {
  49. #endif
  51. #if PRAGMA_IMPORT
  52. #pragma import on
  53. #endif
  55. #if PRAGMA_STRUCT_ALIGN
  56.     #pragma options align=mac68k
  57. #elif PRAGMA_STRUCT_PACKPUSH
  58.     #pragma pack(push, 2)
  59. #elif PRAGMA_STRUCT_PACK
  60.     #pragma pack(2)
  61. #endif
  63. enum {
  64.                                                                 /* Bit positions for ModemByte */
  65.     modemOnBit                  = 0,
  66.     ringWakeUpBit               = 2,
  67.     modemInstalledBit           = 3,
  68.     ringDetectBit               = 4,
  69.     modemOnHookBit              = 5
  70. };
  72. enum {
  73.                                                                 /* masks for ModemByte */
  74.     modemOnMask                 = 0x01,
  75.     ringWakeUpMask              = 0x04,
  76.     modemInstalledMask          = 0x08,
  77.     ringDetectMask              = 0x10,
  78.     modemOnHookMask             = 0x20
  79. };
  81. enum {
  82.                                                                 /* bit positions for BatteryByte */
  83.     chargerConnBit              = 0,
  84.     hiChargeBit                 = 1,
  85.     chargeOverFlowBit           = 2,
  86.     batteryDeadBit              = 3,
  87.     batteryLowBit               = 4,
  88.     connChangedBit              = 5
  89. };
  91. enum {
  92.                                                                 /* masks for BatteryByte */
  93.     chargerConnMask             = 0x01,
  94.     hiChargeMask                = 0x02,
  95.     chargeOverFlowMask          = 0x04,
  96.     batteryDeadMask             = 0x08,
  97.     batteryLowMask              = 0x10,
  98.     connChangedMask             = 0x20
  99. };
  101. enum {
  102.                                                                 /* bit positions for SoundMixerByte */
  103.     MediaBaySndEnBit            = 0,
  104.     PCISndEnBit                 = 1,
  105.     ZVSndEnBit                  = 2,
  106.     PCCardSndEnBit              = 3
  107. };
  109. enum {
  110.                                                                 /* masks for SoundMixerByte */
  111.     MediaBaySndEnMask           = 0x01,
  112.     PCISndEnMask                = 0x02,
  113.     ZVSndEnMask                 = 0x04,
  114.     PCCardSndEnMask             = 0x08
  115. };
  117. enum {
  118.                                                                 /* commands to SleepQRec sleepQProc */
  119.     kSleepRequest               = 1,
  120.     kSleepDemand                = 2,
  121.     kSleepWakeUp                = 3,
  122.     kSleepRevoke                = 4,
  123.     kSleepUnlock                = 4,
  124.     kSleepDeny                  = 5,
  125.     kSleepNow                   = 6,
  126.     kDozeDemand                 = 7,
  127.     kDozeWakeUp                 = 8,
  128.     kDozeRequest                = 9,                            /* additional messages for Power Mgr 2.0*/
  129.     kEnterStandby               = 10,
  130.     kEnterRun                   = 11,
  131.     kSuspendRequest             = 12,
  132.     kSuspendDemand              = 13,
  133.     kSuspendRevoke              = 14,
  134.     kSuspendWakeUp              = 15,
  135.     kGetPowerLevel              = 16,
  136.     kSetPowerLevel              = 17,
  137.     kDeviceInitiatedWake        = 18,
  138.     kWakeToDoze                 = 19,
  139.     kDozeToFullWakeUp           = 20,
  140.     kGetPowerInfo               = 21,
  141.     kGetWakeOnNetInfo           = 22
  142. };
  144. enum {
  145.                                                                 /* depreciated commands to SleepQRec sleepQProc */
  146.     sleepRequest                = kSleepRequest,
  147.     sleepDemand                 = kSleepDemand,
  148.     sleepWakeUp                 = kSleepWakeUp,
  149.     sleepRevoke                 = kSleepRevoke,
  150.     sleepUnlock                 = kSleepUnlock,
  151.     sleepDeny                   = kSleepDeny,
  152.     sleepNow                    = kSleepNow,
  153.     dozeDemand                  = kDozeDemand,
  154.     dozeWakeUp                  = kDozeWakeUp,
  155.     dozeRequest                 = kDozeRequest,
  156.     enterStandby                = kEnterStandby,
  157.     enterRun                    = kEnterRun,
  158.     suspendRequestMsg           = kSuspendRequest,
  159.     suspendDemandMsg            = kSuspendDemand,
  160.     suspendRevokeMsg            = kSuspendRevoke,
  161.     suspendWakeUpMsg            = kSuspendWakeUp,
  162.     getPowerLevel               = kGetPowerLevel,
  163.     setPowerLevel               = kSetPowerLevel
  164. };
  166. /* Power Handler func messages */
  167. typedef UInt32                          PowerLevel;
  168. /* Power levels corresponding to PCI Bus Power Management Interface Spec (PMIS) */
  169. enum {
  170.     kPMDevicePowerLevel_On      = 0,                            /* fully-powered 'On' state (D0 state)    */
  171.     kPMDevicePowerLevel_D1      = 1,                            /* not used by Apple system SW         */
  172.     kPMDevicePowerLevel_D2      = 2,                            /* not used by Apple system SW         */
  173.     kPMDevicePowerLevel_Off     = 3                             /* main PCI bus power 'Off', but PCI standby power available (D3cold state) */
  174. };
  176. /* PowerHandlerProc definition */
  177. typedef CALLBACK_API( OSStatus , PowerHandlerProcPtr )(UInt32 message, void *param, UInt32 refCon, RegEntryID *regEntryID);
  178. typedef STACK_UPP_TYPE(PowerHandlerProcPtr)                     PowerHandlerUPP;
  179. #if OPAQUE_UPP_TYPES
  180. #if CALL_NOT_IN_CARBON
  181.     EXTERN_API(PowerHandlerUPP)
  182.     NewPowerHandlerUPP             (PowerHandlerProcPtr     userRoutine);
  184.     EXTERN_API(void)
  185.     DisposePowerHandlerUPP         (PowerHandlerUPP         userUPP);
  187.     EXTERN_API(OSStatus)
  188.     InvokePowerHandlerUPP          (UInt32                  message,
  189.                                     void *                  param,
  190.                                     UInt32                  refCon,
  191.                                     RegEntryID *            regEntryID,
  192.                                     PowerHandlerUPP         userUPP);
  194. #endif  /* CALL_NOT_IN_CARBON */
  196. #else
  197.     enum { uppPowerHandlerProcInfo = 0x00003FF0 };                  /* pascal 4_bytes Func(4_bytes, 4_bytes, 4_bytes, 4_bytes) */
  198.     #define NewPowerHandlerUPP(userRoutine)                         (PowerHandlerUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppPowerHandlerProcInfo, GetCurrentArchitecture())
  199.     #define DisposePowerHandlerUPP(userUPP)                         DisposeRoutineDescriptor(userUPP)
  200.     #define InvokePowerHandlerUPP(message, param, refCon, regEntryID, userUPP)  (OSStatus)CALL_FOUR_PARAMETER_UPP((userUPP), uppPowerHandlerProcInfo, (message), (param), (refCon), (regEntryID))
  201. #endif
  202. /* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
  203. #define NewPowerHandlerProc(userRoutine)                        NewPowerHandlerUPP(userRoutine)
  204. #define CallPowerHandlerProc(userRoutine, message, param, refCon, regEntryID) InvokePowerHandlerUPP(message, param, refCon, regEntryID, userRoutine)
  205. /* DriverPowerCapabilities struct */
  206. /*
  207.    The DriverPowerCapabilities structure is used only by PPC native drivers (ndrv).
  208.    A native driver will export this structure like it currently does now when
  209.    exporting a DriverDescription structure (e.g. TheDriverDescription).
  210.    The well-defined export that will be exported must be called: TheDriverPowerCapabilities
  211.    IMPORTANT NOTE:  ALL native drivers that match to their respective PCI
  212.                     slot devices MUST signify to the Power Manager that
  213.                     they can recover their device functionality after
  214.                     waking from Sleep with PCI bus power removed.
  215.                     If ANY PCI slot driver has not been updated and fails
  216.                     to indicate to the Power Manager that it can recover
  217.                     after PCI bus power is restored, then PCI bus power
  218.                     will NOT be removed during Sleep.  Without the ability
  219.                     to remove PCI bus power, the ability to switch the main
  220.                     power supply on some CPUs to a very-low power state
  221.                     will be unavailable to the System.
  222.    The PowerCapsFlags are used to determine:
  223.     - if a PCI slot device can recover from PCI power removal during Sleep.
  224.       Drivers should set the 'kDevicePowerCanBeRemovedForSleep' bit if true.
  225.         ***  ALL PCI slot device drivers must set this bit in order    ***
  226.         ***  that PCI bus power is allowed to be removed during Sleep. ***
  227.     - if the driver overrides the device's PCI Config space for determining
  228.       how much Standby (e.g. 3.3V Aux pin) power is used during Sleep.
  229.       Drivers should set the 'kDriverSpecifiesStandbyPower' bit only if the
  230.       device's PCI Config values are known to be corrupted or do not specify
  231.       the Standby power consumed during D3cold.
  232.         If 'kDriverSpecifiesStandbyPower' bit is set:
  233.           - the 'kDeviceCanGeneratePMEDuringSleep' bit should be set if
  234.             the PCI slot device is able to use standby (3.3V Aux) power
  235.             to assert the PME signal during Sleep..
  236.           - the 'powerCapsStandbyPowerMilliWatts' field is used to specify
  237.             how much Standby power is needed.  This value is only used
  238.             if both the 'kDriverSpecifiesStandbyPower' and
  239.             'kDeviceCanGeneratePMEDuringSleep' bits are set.
  240.     - the method of support chosen by the driver for implementing the Power
  241.       handler mechanism:
  242.         If 'kDriverPowerMgtAware' is set, then the driver supports the Power
  243.         Handler mechanism which exists in the new Power Manager (v2.0 and later).
  244.         If 'kDriverPowerMgtUnderExpertControl' is set, then the Power Manager
  245.         will assume that the driver's Expert/Manager will communicate with the
  246.         driver's Power handler and the 'kDriverHasPowerHandlerExport bit'
  247.         will be ignored.
  248.         If 'kDriverHasPowerHandlerExport' is set, then the driver must export
  249.         a well-defined Power handler entry point called:
  250.             DoDriverPowerManagement
  251.         If this bit is not set and the 'kDriverPowerMgtAware' is set, then the
  252.         device must support Power handling within its DoDriverIO entry point.
  253.         Drivers that implement a DoDriverIO entry point will receive
  254.         IO Control and Status selectors that are defined in Devices.h.
  255.         Drivers that elect to export a "DoDriverPowerManagement" entry point should
  256.         set up the entry point as follows:
  257.             OSStatus
  258.             DoDriverPowerManagement( UInt32             message,
  259.                                      PowerLevel             *powerLevel,
  260.                                      UInt32                 refCon,
  261.                                      RegEntryIDPtr      regEntryID);
  262.         "DoDriverPowerManagement" entry points have the same parameters and expected
  263.         behavior as a Power handler that has been explicitly registered via the
  264.         Driver Services API "AddDevicePowerHandler"; the difference is that,
  265.         during system startup, the Power Manager will automatically register the
  266.         "DoDriverPowerManagement" entry point found within each driver.
  267. */
  269. /* Used in DriverPowerCapabilities*/
  270. typedef UInt32                          PowerCapsVersion;
  271. enum {
  272.     kVersionOnePowerCapabilities = 1
  273. };
  275. typedef OptionBits                      PowerCapsFlags;
  276. enum {
  277.     kDevicePowerCanBeRemovedForSleep = 0x00000001,              /* only remove PCI power when every device has this bit set */
  278.     kDriverSpecifiesStandbyPower = 0x00000002,                  /* set when driver overrides PCI device Config values */
  279.     kDeviceCanGeneratePMEDuringSleep = 0x00000004,              /* 3.3V standby power can be used to assert the PME# */
  280.     kDriverPowerMgtAware        = 0x00000008,                   /* new Power handler mechanism is supported */
  281.     kDriverPowerMgtUnderExpertControl = 0x00000010,             /* Expert or Manager will call the driver's Power handler */
  282.     kDriverHasPowerHandlerExport = 0x00000020                   /* Type of Power handler entry point: only set this bit if the */
  283. };
  285. /*  driver exports a "DevicePowerManagement" entry point */
  286. /*
  287.    A device reliability issue arises when a device is subjected to shortened power
  288.    cycling intervals.  The new Power Manager allows a device to specify a minimum
  289.    value (in seconds) that a device must be powered on before being powered off.
  290.    The system has a default value of around 5 minutes (300 seconds).  If 5 minutes
  291.    is sufficient for a device, then use the following constant within DriverPowerCapabilities.
  292. */
  293. enum {
  294.     kUseDefaultWakeTime         = 0                             /* used when the system's default is sufficient */
  295. };
  297. /*
  298.    This structure describes a device's power capabilities as well as general Power Management support.
  299.     Note: powerCapsMinimumWakeTimeSeconds can be specified as kUseDefaultWakeTime
  300.     if the system's default time interval - 5 minutes - is sufficient.
  301. */
  303. struct DriverPowerCapabilities {
  304.     PowerCapsVersion                powerCapsVersion;           /* Version of this data structure */
  305.     PowerCapsFlags                  powerCapsFlags;             /* Power Management support characteristics */
  306.     UInt32                          powerCapsStandbyPowerMilliWatts; /* Power consumed during PCI bus sleep, 0 if none */
  307.     UInt32                          powerCapsMinimumWakeTimeSeconds; /* Safe time interval between removing and */
  308.                                                                 /*   restoring power to this device */
  309. };
  310. typedef struct DriverPowerCapabilities  DriverPowerCapabilities;
  311. typedef DriverPowerCapabilities *       DriverPowerCapabilitiesPtr;
  312. /* PCI power management support*/
  313. enum {
  314.     kUseDefaultMinimumWakeTime  = 0,                            /* Defaults to 5 minutes*/
  315.     kPowerSummaryVersion        = 1,                            /* Version of PowerSummary structure.*/
  316.     kDevicePowerInfoVersion     = 1                             /* Version of DevicePowerInfo structure.*/
  317. };
  319. enum {
  320.                                                                 /* PowerSummary flags*/
  321.     kPCIPowerOffAllowed         = (1L << 0)                     /* PCI power off is allowed.*/
  322. };
  324. enum {
  325.                                                                 /* DevicePowerInfo flags*/
  326.     kDevicePCIPowerOffAllowed   = (1L << 0),                    /* PCI power off is allowed for device.*/
  327.     kDeviceSupportsPMIS         = (1L << 1),                    /* Device supports Power Mgt Interface Spec.*/
  328.     kDeviceCanAssertPMEDuringSleep = (1L << 2),                 /* Device can assert PME# during sleep.*/
  329.     kDeviceUsesCommonLogicPower = (1L << 3),                    /* Device uses common-logic power*/
  330.     kDeviceDriverPresent        = (1L << 4),                    /* Driver present for device.*/
  331.     kDeviceDriverSupportsPowerMgt = (1L << 5)                   /* Driver installed a power handler.*/
  332. };
  335. struct DevicePowerInfo {
  336.     UInt32                          version;                    /* Version of this structure.*/
  337.     RegEntryID                      regID;                      /* RegEntryID for device.*/
  338.     OptionBits                      flags;                      /* Flags*/
  339.     UInt32                          minimumWakeTime;            /* Minimum seconds before sleeping again.*/
  340.     UInt32                          sleepPowerNeeded;           /* Milliwatts needed in the sleep state.*/
  341. };
  342. typedef struct DevicePowerInfo          DevicePowerInfo;
  344. struct PowerSummary {
  345.     UInt32                          version;                    /* Version of this structure.*/
  346.     OptionBits                      flags;                      /* Flags*/
  347.     UInt32                          sleepPowerAvailable;        /* Milliwatts available during sleep.*/
  348.     UInt32                          sleepPowerNeeded;           /* Milliwatts needed during sleep.*/
  349.     UInt32                          minimumWakeTime;            /* Minimum seconds before sleeping again.*/
  350.     ItemCount                       deviceCount;                /* Number of device power info records.*/
  351.     DevicePowerInfo                 devices[1];                 /* Array of device power info records.*/
  352. };
  353. typedef struct PowerSummary             PowerSummary;
  354. enum {
  355.                                                                 /* SleepQRec.sleepQFlags */
  356.     noCalls                     = 1,
  357.     noRequest                   = 2,
  358.     slpQType                    = 16,
  359.     sleepQType                  = 16
  360. };
  362. /* Power Mgt Apple Event types and errors */
  363. enum {
  364.                                                                 /* power mgt class*/
  365.     kAEMacPowerMgtEvt           = FOUR_CHAR_CODE('pmgt'),       /* event ids*/
  366.     kAEMacToWake                = FOUR_CHAR_CODE('wake'),
  367.     kAEMacLowPowerSaveData      = FOUR_CHAR_CODE('pmsd'),
  368.     kAEMacEmergencySleep        = FOUR_CHAR_CODE('emsl'),
  369.     kAEMacEmergencyShutdown     = FOUR_CHAR_CODE('emsd')
  370. };
  373. /*
  374.    These are result values returned by a Power Handler when queries
  375.    by the Power Mgr if the device which that Power Handler represents
  376.    woke the machine.
  377. */
  378. enum {
  379.     kDeviceDidNotWakeMachine    = 0,                            /* device did NOT wake machine*/
  380.     kDeviceRequestsFullWake     = 1,                            /* device did wake machine and requests full wakeup*/
  381.     kDeviceRequestsWakeToDoze   = 2                             /* device did wake machine and requests partial wakeup*/
  382. };
  384. /* bits in bitfield returned by PMFeatures */
  385. enum {
  386.     hasWakeupTimer              = 0,                            /* 1=wakeup timer is supported                    */
  387.     hasSharedModemPort          = 1,                            /* 1=modem port shared by SCC and internal modem       */
  388.     hasProcessorCycling         = 2,                            /* 1=processor cycling is supported                */
  389.     mustProcessorCycle          = 3,                            /* 1=processor cycling should not be turned off          */
  390.     hasReducedSpeed             = 4,                            /* 1=processor can be started up at reduced speed        */
  391.     dynamicSpeedChange          = 5,                            /* 1=processor speed can be switched dynamically       */
  392.     hasSCSIDiskMode             = 6,                            /* 1=SCSI Disk Mode is supported                 */
  393.     canGetBatteryTime           = 7,                            /* 1=battery time can be calculated                */
  394.     canWakeupOnRing             = 8,                            /* 1=can wakeup when the modem detects a ring          */
  395.     hasDimmingSupport           = 9,                            /* 1=has dimming support built in (DPMS standby by default)   */
  396.     hasStartupTimer             = 10,                           /* 1=startup timer is supported                    */
  397.     hasChargeNotification       = 11,                           /* 1=client can determine of charge connect status change notifications available */
  398.     hasDimSuspendSupport        = 12                            /* 1=supports dimming LCD and CRT to DPMS suspend state     */
  399. };
  401. /* more bits in bitfield returned by PMFeatures to be merged with above when time */
  402. enum {
  403.     hasWakeOnNetActivity        = 13,                           /* 1=hardware supports wake on network activity          */
  404.     hasWakeOnLid                = 14,                           /* 1=hardware can wake when opened                   */
  405.     canPowerOffPCIBus           = 15,                           /* 1=hardware can power off PCI bus during sleep if cards allow */
  406.     hasDeepSleep                = 16,                           /* 1=hardware supports deep sleep (hibernation) mode   */
  407.     hasSleep                    = 17                            /* 1=hardware supports normal (PowerBook-like) sleep   */
  408. };
  410. /* bits in bitfield returned by GetIntModemInfo and set by SetIntModemState */
  411. enum {
  412.     hasInternalModem            = 0,                            /* 1=internal modem installed               */
  413.     intModemRingDetect          = 1,                            /* 1=internal modem has detected a ring          */
  414.     intModemOffHook             = 2,                            /* 1=internal modem is off hook               */
  415.     intModemRingWakeEnb         = 3,                            /* 1=wakeup on ring is enabled                 */
  416.     extModemSelected            = 4,                            /* 1=external modem selected             */
  417.     modemSetBit                 = 15                            /* 1=set bit, 0=clear bit (SetIntModemState)   */
  418. };
  420. /* bits in BatteryInfo.flags                                    */
  421. /* ("chargerConnected" doesn't mean the charger is plugged in)  */
  422. enum {
  423.     batteryInstalled            = 7,                            /* 1=battery is currently connected             */
  424.     batteryCharging             = 6,                            /* 1=battery is being charged               */
  425.     chargerConnected            = 5                             /* 1=charger is connected to the PowerBook         */
  426. };
  428. enum {
  429.     HDPwrQType                  = 0x4844,                       /* 'HD' hard disk spindown queue element type     */
  430.     PMgrStateQType              = 0x504D                        /* 'PM' Power Manager state queue element type       */
  431. };
  433. /* client notification bits in PMgrQueueElement.pmNotifyBits */
  434. enum {
  435.     pmSleepTimeoutChanged       = 0,
  436.     pmSleepEnableChanged        = 1,
  437.     pmHardDiskTimeoutChanged    = 2,
  438.     pmHardDiskSpindownChanged   = 3,
  439.     pmDimmingTimeoutChanged     = 4,
  440.     pmDimmingEnableChanged      = 5,
  441.     pmDiskModeAddressChanged    = 6,
  442.     pmProcessorCyclingChanged   = 7,
  443.     pmProcessorSpeedChanged     = 8,
  444.     pmWakeupTimerChanged        = 9,
  445.     pmStartupTimerChanged       = 10,
  446.     pmHardDiskPowerRemovedbyUser = 11,
  447.     pmChargeStatusChanged       = 12,
  448.     pmPowerLevelChanged         = 13,
  449.     pmWakeOnNetActivityChanged  = 14
  450. };
  452. enum {
  453.     pmSleepTimeoutChangedMask   = (1 << pmSleepTimeoutChanged),
  454.     pmSleepEnableChangedMask    = (1 << pmSleepEnableChanged),
  455.     pmHardDiskTimeoutChangedMask = (1 << pmHardDiskTimeoutChanged),
  456.     pmHardDiskSpindownChangedMask = (1 << pmHardDiskSpindownChanged),
  457.     pmDimmingTimeoutChangedMask = (1 << pmDimmingTimeoutChanged),
  458.     pmDimmingEnableChangedMask  = (1 << pmDimmingEnableChanged),
  459.     pmDiskModeAddressChangedMask = (1 << pmDiskModeAddressChanged),
  460.     pmProcessorCyclingChangedMask = (1 << pmProcessorCyclingChanged),
  461.     pmProcessorSpeedChangedMask = (1 << pmProcessorSpeedChanged),
  462.     pmWakeupTimerChangedMask    = (1 << pmWakeupTimerChanged),
  463.     pmStartupTimerChangedMask   = (1 << pmStartupTimerChanged),
  464.     pmHardDiskPowerRemovedbyUserMask = (1 << pmHardDiskPowerRemovedbyUser),
  465.     pmChargeStatusChangedMask   = (1 << pmChargeStatusChanged),
  466.     pmPowerLevelChangedMask     = (1 << pmPowerLevelChanged),
  467.     pmWakeOnNetActivityChangedMask = (1 << pmWakeOnNetActivityChanged)
  468. };
  470. /* System Activity Selectors */
  471. enum {
  472.     OverallAct                  = 0,                            /* general type of activity                */
  473.     UsrActivity                 = 1,                            /* user specific type of activity           */
  474.     NetActivity                 = 2,                            /* network specific activity             */
  475.     HDActivity                  = 3                             /* Hard Drive activity                    */
  476. };
  478. /* Storage Media sleep mode defines */
  479. enum {
  480.     kMediaModeOn                = 0,                            /* Media active (Drive spinning and at full power)    */
  481.     kMediaModeStandBy           = 1,                            /* Media standby (not implemented)    */
  482.     kMediaModeSuspend           = 2,                            /* Media Idle (not implemented)   */
  483.     kMediaModeOff               = 3                             /* Media Sleep (Drive not spinning and at min power, max recovery time)   */
  484. };
  486. enum {
  487.     kMediaPowerCSCode           = 70
  488. };
  491. /* definitions for HDQueueElement.hdFlags   */
  492. enum {
  493.     kHDQueuePostBit             = 0,                            /* 1 = call this routine on the second pass     */
  494.     kHDQueuePostMask            = (1 << kHDQueuePostBit)
  495. };
  498. struct ActivityInfo {
  499.     short                           ActivityType;               /* Type of activity to be fetched.  Same as UpdateSystemActivity Selectors */
  500.     unsigned long                   ActivityTime;               /* Time of last activity (in ticks) of specified type. */
  501. };
  502. typedef struct ActivityInfo             ActivityInfo;
  503. /* information returned by GetScaledBatteryInfo */
  505. struct BatteryInfo {
  506.     UInt8                           flags;                      /* misc flags (see below)                  */
  507.     UInt8                           warningLevel;               /* scaled warning level (0-255)               */
  508.     UInt8                           reserved;                   /* reserved for internal use             */
  509.     UInt8                           batteryLevel;               /* scaled battery level (0-255)               */
  510. };
  511. typedef struct BatteryInfo              BatteryInfo;
  513. typedef SInt8                           ModemByte;
  514. typedef SInt8                           BatteryByte;
  515. typedef SInt8                           SoundMixerByte;
  516. typedef long                            PMResultCode;
  517. typedef struct SleepQRec                SleepQRec;
  518. typedef SleepQRec *                     SleepQRecPtr;
  519. typedef struct HDQueueElement           HDQueueElement;
  520. typedef struct PMgrQueueElement         PMgrQueueElement;
  521. typedef CALLBACK_API( long , SleepQProcPtr )(long message, SleepQRecPtr qRecPtr);
  522. /*
  523.     WARNING: SleepQProcPtr uses register based parameters under classic 68k
  524.              and cannot be written in a high-level language without 
  525.              the help of mixed mode or assembly glue.
  526. */
  527. typedef CALLBACK_API( void , HDSpindownProcPtr )(HDQueueElement *theElement);
  528. typedef CALLBACK_API( void , PMgrStateChangeProcPtr )(PMgrQueueElement *theElement, long stateBits);
  529. typedef REGISTER_UPP_TYPE(SleepQProcPtr)                        SleepQUPP;
  530. typedef STACK_UPP_TYPE(HDSpindownProcPtr)                       HDSpindownUPP;
  531. typedef STACK_UPP_TYPE(PMgrStateChangeProcPtr)                  PMgrStateChangeUPP;
  533. struct SleepQRec {
  534.     SleepQRecPtr                    sleepQLink;                 /* pointer to next queue element          */
  535.     short                           sleepQType;                 /* queue element type (must be SleepQType)       */
  536.     SleepQUPP                       sleepQProc;                 /* pointer to sleep universal proc ptr         */
  537.     short                           sleepQFlags;                /* flags                       */
  538. };
  541. struct HDQueueElement {
  542.     struct HDQueueElement *         hdQLink;                    /* pointer to next queue element          */
  543.     short                           hdQType;                    /* queue element type (must be HDPwrQType)       */
  544.     short                           hdFlags;                    /* miscellaneous flags                   */
  545.     HDSpindownUPP                   hdProc;                     /* pointer to routine to call           */
  546.     long                            hdUser;                     /* user-defined (variable storage, etc.)   */
  547. };
  550. struct PMgrQueueElement {
  551.     struct PMgrQueueElement *       pmQLink;                    /* pointer to next queue element          */
  552.     short                           pmQType;                    /* queue element type (must be PMgrStateQType)    */
  553.     short                           pmFlags;                    /* miscellaneous flags                   */
  554.     long                            pmNotifyBits;               /* bitmap of which changes to be notified for */
  555.     PMgrStateChangeUPP              pmProc;                     /* pointer to routine to call           */
  556.     long                            pmUser;                     /* user-defined (variable storage, etc.)   */
  557. };
  561. struct BatteryTimeRec {
  562.     unsigned long                   expectedBatteryTime;        /* estimated battery time remaining (seconds) */
  563.     unsigned long                   minimumBatteryTime;         /* minimum battery time remaining (seconds)     */
  564.     unsigned long                   maximumBatteryTime;         /* maximum battery time remaining (seconds)     */
  565.     unsigned long                   timeUntilCharged;           /* time until battery is fully charged (seconds)*/
  566. };
  567. typedef struct BatteryTimeRec           BatteryTimeRec;
  570. struct WakeupTime {
  571.     unsigned long                   wakeTime;                   /* wakeup time (same format as current time)   */
  572.     Boolean                         wakeEnabled;                /* 1=enable wakeup timer, 0=disable wakeup timer  */
  573.     SInt8                           filler;
  574. };
  575. typedef struct WakeupTime               WakeupTime;
  578. struct StartupTime {
  579.     unsigned long                   startTime;                  /* startup time (same format as current time)     */
  580.     Boolean                         startEnabled;               /* 1=enable startup timer, 0=disable startup timer    */
  581.     SInt8                           filler;
  582. };
  583. typedef struct StartupTime              StartupTime;
  584. /* PowerSource version*/
  585. enum {
  586.     kVersionOnePowerSource      = 1
  587. };
  589. /* PowerSourceAttrs bits*/
  591. enum {
  592.     bSourceIsBattery            = 0,                            /* power source is battery*/
  593.     bSourceIsAC                 = 1,                            /* power source is AC*/
  594.     bSourceCanBeCharged         = 2,                            /* power source can be charged*/
  595.     bSourceIsUPS                = 3,                            /* power source is UPS. NOTE: software should set bSourceIsBattery and bSourceIsAC also, as appropriate*/
  596.     kSourceIsBatteryMask        = (1 << bSourceIsBattery),
  597.     kSourceIsACMask             = (1 << bSourceIsAC),
  598.     kSourceCanBeChargedMask     = (1 << bSourceCanBeCharged),
  599.     kSourceIsUPSMask            = (1 << bSourceIsUPS)
  600. };
  602. /* PowerSourceFlags bits*/
  604. enum {
  605.     bSourceIsAvailable          = 0,                            /* power source is installed*/
  606.     bSourceIsCharging           = 1,                            /* power source being charged*/
  607.     bChargerIsAttached          = 2,                            /* a charger is connected*/
  608.     kSourceIsAvailableMask      = (1 << bSourceIsAvailable),
  609.     kSourceIsChargingMask       = (1 << bSourceIsCharging),
  610.     kChargerIsAttachedMask      = (1 << bChargerIsAttached)
  611. };
  613. /* Power Capacity Types*/
  615. enum {
  616.     kCapacityIsActual           = 0,                            /* current capacity is expessed as actual capacity in same units as max*/
  617.     kCapacityIsPercentOfMax     = 1                             /* current capacity is expressed as a percentage of maximumCapacity*/
  618. };
  620. /* Net Activity Wake Options*/
  621. enum {
  622.     kConfigSupportsWakeOnNetBit = 0,
  623.     kWakeOnNetAdminAccessesBit  = 1,
  624.     kWakeOnAllNetAccessesBit    = 2,
  625.     kUnmountServersBeforeSleepingBit = 3,
  626.     kConfigSupportsWakeOnNetMask = (1 << kConfigSupportsWakeOnNetBit),
  627.     kWakeOnNetAdminAccessesMask = (1 << kWakeOnNetAdminAccessesBit),
  628.     kWakeOnAllNetAccessesMask   = (1 << kWakeOnAllNetAccessesBit),
  629.     kUnmountServersBeforeSleepingMask = (1 << kUnmountServersBeforeSleepingBit)
  630. };
  632. /* Power Source capacity usage types*/
  633. enum {
  634.     kCurrentCapacityIsActualValue = 0,                          /* currentCapacity is a real value in same units as maxCapacity*/
  635.     kCurrentCapacityIsPercentOfMax = 1                          /* currentCapacity is expressed as a percentage of maxCapacity.*/
  636. };
  639. typedef SInt16                          PowerSourceID;
  641. struct PowerSourceParamBlock {
  642.     PowerSourceID                   sourceID;                   /* unique id assigned by Power Mgr*/
  643.     UInt16                          sourceCapacityUsage;        /* how currentCapacity is used*/
  644.     UInt32                          sourceVersion;              /* version of this record*/
  645.     OptionBits                      sourceAttr;                 /* attribute flags (see below)*/
  646.     OptionBits                      sourceState;                /* state flags (see below)*/
  647.     UInt32                          currentCapacity;            /* current capacity, in*/
  648.                                                                 /*   milliwatts*/
  649.     UInt32                          maxCapacity;                /* full capacity, in milliwatts*/
  650.     UInt32                          timeRemaining;              /* time left to deplete, */
  651.                                                                 /*   in milliwatt-hours*/
  652.     UInt32                          timeToFullCharge;           /* time to charge, */
  653.                                                                 /*   in milliwatt-hours*/
  654.     UInt32                          voltage;                    /* voltage in millivolts*/
  655.     SInt32                          current;                    /* current in milliamperes */
  656.                                                                 /*  (negative if consuming, */
  657.                                                                 /*   positive if charging)*/
  658. };
  659. typedef struct PowerSourceParamBlock    PowerSourceParamBlock;
  660. typedef PowerSourceParamBlock *         PowerSourceParamBlockPtr;
  661. EXTERN_API( OSErr )
  662. DisableWUTime                   (void);
  664. EXTERN_API( OSErr )
  665. SetWUTime                       (long                   wuTime);
  667. EXTERN_API( OSErr )
  668. GetWUTime                       (long *                 wuTime,
  669.                                  Byte *                 wuFlag);
  671. EXTERN_API( OSErr )
  672. BatteryStatus                   (Byte *                 status,
  673.                                  Byte *                 power);
  675. EXTERN_API( OSErr )
  676. ModemStatus                     (Byte *                 status);
  678.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  679.                                                                                             #pragma parameter __D0 IdleUpdate
  680.                                                                                             #endif
  681. EXTERN_API( long )
  682. IdleUpdate                      (void)                                                      ONEWORDINLINE(0xA285);
  684.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  685.                                                                                             #pragma parameter __D0 GetCPUSpeed
  686.                                                                                             #endif
  687. EXTERN_API( long )
  688. GetCPUSpeed                     (void)                                                      TWOWORDINLINE(0x70FF, 0xA485);
  690. EXTERN_API( void )
  691. EnableIdle                      (void)                                                      TWOWORDINLINE(0x7000, 0xA485);
  693. EXTERN_API( void )
  694. DisableIdle                     (void)                                                      TWOWORDINLINE(0x7001, 0xA485);
  696.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  697.                                                                                             #pragma parameter SleepQInstall(__A0)
  698.                                                                                             #endif
  699. EXTERN_API( void )
  700. SleepQInstall                   (SleepQRecPtr           qRecPtr)                            ONEWORDINLINE(0xA28A);
  702.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  703.                                                                                             #pragma parameter SleepQRemove(__A0)
  704.                                                                                             #endif
  705. EXTERN_API( void )
  706. SleepQRemove                    (SleepQRecPtr           qRecPtr)                            ONEWORDINLINE(0xA48A);
  708. EXTERN_API( void )
  709. AOn                             (void)                                                      TWOWORDINLINE(0x7004, 0xA685);
  711. EXTERN_API( void )
  712. AOnIgnoreModem                  (void)                                                      TWOWORDINLINE(0x7005, 0xA685);
  714. EXTERN_API( void )
  715. BOn                             (void)                                                      TWOWORDINLINE(0x7000, 0xA685);
  717. EXTERN_API( void )
  718. AOff                            (void)                                                      TWOWORDINLINE(0x7084, 0xA685);
  720. EXTERN_API( void )
  721. BOff                            (void)                                                      TWOWORDINLINE(0x7080, 0xA685);
  724. /* Public Power Management API  */
  725.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  726.                                                                                             #pragma parameter __D0 PMSelectorCount
  727.                                                                                             #endif
  728. EXTERN_API( short )
  729. PMSelectorCount                 (void)                                                      TWOWORDINLINE(0x7000, 0xA09E);
  731.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  732.                                                                                             #pragma parameter __D0 PMFeatures
  733.                                                                                             #endif
  734. EXTERN_API( UInt32 )
  735. PMFeatures                      (void)                                                      TWOWORDINLINE(0x7001, 0xA09E);
  737.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  738.                                                                                             #pragma parameter __D0 GetSleepTimeout
  739.                                                                                             #endif
  740. EXTERN_API( UInt8 )
  741. GetSleepTimeout                 (void)                                                      TWOWORDINLINE(0x7002, 0xA09E);
  743.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  744.                                                                                             #pragma parameter SetSleepTimeout(__D0)
  745.                                                                                             #endif
  746. EXTERN_API( void )
  747. SetSleepTimeout                 (UInt8                  timeout)                            FOURWORDINLINE(0x4840, 0x303C, 0x0003, 0xA09E);
  749.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  750.                                                                                             #pragma parameter __D0 GetHardDiskTimeout
  751.                                                                                             #endif
  752. EXTERN_API( UInt8 )
  753. GetHardDiskTimeout              (void)                                                      TWOWORDINLINE(0x7004, 0xA09E);
  755.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  756.                                                                                             #pragma parameter SetHardDiskTimeout(__D0)
  757.                                                                                             #endif
  758. EXTERN_API( void )
  759. SetHardDiskTimeout              (UInt8                  timeout)                            FOURWORDINLINE(0x4840, 0x303C, 0x0005, 0xA09E);
  761.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  762.                                                                                             #pragma parameter __D0 HardDiskPowered
  763.                                                                                             #endif
  764. EXTERN_API( Boolean )
  765. HardDiskPowered                 (void)                                                      TWOWORDINLINE(0x7006, 0xA09E);
  767.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  768.                                                                                             #pragma parameter SpinDownHardDisk
  769.                                                                                             #endif
  770. EXTERN_API( void )
  771. SpinDownHardDisk                (void)                                                      TWOWORDINLINE(0x7007, 0xA09E);
  773.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  774.                                                                                             #pragma parameter __D0 IsSpindownDisabled
  775.                                                                                             #endif
  776. EXTERN_API( Boolean )
  777. IsSpindownDisabled              (void)                                                      TWOWORDINLINE(0x7008, 0xA09E);
  779.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  780.                                                                                             #pragma parameter SetSpindownDisable(__D0)
  781.                                                                                             #endif
  782. EXTERN_API( void )
  783. SetSpindownDisable              (Boolean                setDisable)                         FOURWORDINLINE(0x4840, 0x303C, 0x0009, 0xA09E);
  785.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  786.                                                                                             #pragma parameter __D0 HardDiskQInstall(__A0)
  787.                                                                                             #endif
  788. EXTERN_API( OSErr )
  789. HardDiskQInstall                (HDQueueElement *       theElement)                         TWOWORDINLINE(0x700A, 0xA09E);
  791.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  792.                                                                                             #pragma parameter __D0 HardDiskQRemove(__A0)
  793.                                                                                             #endif
  794. EXTERN_API( OSErr )
  795. HardDiskQRemove                 (HDQueueElement *       theElement)                         TWOWORDINLINE(0x700B, 0xA09E);
  797.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  798.                                                                                             #pragma parameter GetScaledBatteryInfo(__D0, __A0)
  799.                                                                                             #endif
  800. EXTERN_API( void )
  801. GetScaledBatteryInfo            (short                  whichBattery,
  802.                                  BatteryInfo *          theInfo)                            FIVEWORDINLINE(0x4840, 0x303C, 0x000C, 0xA09E, 0x2080);
  804.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  805.                                                                                             #pragma parameter AutoSleepControl(__D0)
  806.                                                                                             #endif
  807. EXTERN_API( void )
  808. AutoSleepControl                (Boolean                enableSleep)                        FOURWORDINLINE(0x4840, 0x303C, 0x000D, 0xA09E);
  810.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  811.                                                                                             #pragma parameter __D0 GetIntModemInfo
  812.                                                                                             #endif
  813. EXTERN_API( UInt32 )
  814. GetIntModemInfo                 (void)                                                      TWOWORDINLINE(0x700E, 0xA09E);
  816.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  817.                                                                                             #pragma parameter SetIntModemState(__D0)
  818.                                                                                             #endif
  819. EXTERN_API( void )
  820. SetIntModemState                (short                  theState)                           FOURWORDINLINE(0x4840, 0x303C, 0x000F, 0xA09E);
  822.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  823.                                                                                             #pragma parameter __D0 MaximumProcessorSpeed
  824.                                                                                             #endif
  825. EXTERN_API( short )
  826. MaximumProcessorSpeed           (void)                                                      TWOWORDINLINE(0x7010, 0xA09E);
  828.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  829.                                                                                             #pragma parameter __D0 CurrentProcessorSpeed
  830.                                                                                             #endif
  831. EXTERN_API( short )
  832. CurrentProcessorSpeed           (void)                                                      TWOWORDINLINE(0x7011, 0xA09E);
  834.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  835.                                                                                             #pragma parameter __D0 FullProcessorSpeed
  836.                                                                                             #endif
  837. EXTERN_API( Boolean )
  838. FullProcessorSpeed              (void)                                                      TWOWORDINLINE(0x7012, 0xA09E);
  840.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  841.                                                                                             #pragma parameter __D0 SetProcessorSpeed(__D0)
  842.                                                                                             #endif
  843. EXTERN_API( Boolean )
  844. SetProcessorSpeed               (Boolean                fullSpeed)                          FOURWORDINLINE(0x4840, 0x303C, 0x0013, 0xA09E);
  846.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  847.                                                                                             #pragma parameter __D0 GetSCSIDiskModeAddress
  848.                                                                                             #endif
  849. EXTERN_API( short )
  850. GetSCSIDiskModeAddress          (void)                                                      TWOWORDINLINE(0x7014, 0xA09E);
  852.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  853.                                                                                             #pragma parameter SetSCSIDiskModeAddress(__D0)
  854.                                                                                             #endif
  855. EXTERN_API( void )
  856. SetSCSIDiskModeAddress          (short                  scsiAddress)                        FOURWORDINLINE(0x4840, 0x303C, 0x0015, 0xA09E);
  858.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  859.                                                                                             #pragma parameter GetWakeupTimer(__A0)
  860.                                                                                             #endif
  861. EXTERN_API( void )
  862. GetWakeupTimer                  (WakeupTime *           theTime)                            TWOWORDINLINE(0x7016, 0xA09E);
  864.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  865.                                                                                             #pragma parameter SetWakeupTimer(__A0)
  866.                                                                                             #endif
  867. EXTERN_API( void )
  868. SetWakeupTimer                  (WakeupTime *           theTime)                            TWOWORDINLINE(0x7017, 0xA09E);
  870.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  871.                                                                                             #pragma parameter __D0 IsProcessorCyclingEnabled
  872.                                                                                             #endif
  873. EXTERN_API( Boolean )
  874. IsProcessorCyclingEnabled       (void)                                                      TWOWORDINLINE(0x7018, 0xA09E);
  876.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  877.                                                                                             #pragma parameter EnableProcessorCycling(__D0)
  878.                                                                                             #endif
  879. EXTERN_API( void )
  880. EnableProcessorCycling          (Boolean                enable)                             FOURWORDINLINE(0x4840, 0x303C, 0x0019, 0xA09E);
  882.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  883.                                                                                             #pragma parameter __D0 BatteryCount
  884.                                                                                             #endif
  885. EXTERN_API( short )
  886. BatteryCount                    (void)                                                      TWOWORDINLINE(0x701A, 0xA09E);
  888.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  889.                                                                                             #pragma parameter __D0 GetBatteryVoltage(__D0)
  890.                                                                                             #endif
  891. EXTERN_API( Fixed )
  892. GetBatteryVoltage               (short                  whichBattery)                       FOURWORDINLINE(0x4840, 0x303C, 0x001B, 0xA09E);
  894.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  895.                                                                                             #pragma parameter GetBatteryTimes(__D0, __A0)
  896.                                                                                             #endif
  897. EXTERN_API( void )
  898. GetBatteryTimes                 (short                  whichBattery,
  899.                                  BatteryTimeRec *       theTimes)                           FOURWORDINLINE(0x4840, 0x303C, 0x001C, 0xA09E);
  901.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  902.                                                                                             #pragma parameter __D0 GetDimmingTimeout
  903.                                                                                             #endif
  904. EXTERN_API( UInt8 )
  905. GetDimmingTimeout               (void)                                                      TWOWORDINLINE(0x701D, 0xA09E);
  907.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  908.                                                                                             #pragma parameter SetDimmingTimeout(__D0)
  909.                                                                                             #endif
  910. EXTERN_API( void )
  911. SetDimmingTimeout               (UInt8                  timeout)                            FOURWORDINLINE(0x4840, 0x303C, 0x001E, 0xA09E);
  913.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  914.                                                                                             #pragma parameter DimmingControl(__D0)
  915.                                                                                             #endif
  916. EXTERN_API( void )
  917. DimmingControl                  (Boolean                enableSleep)                        FOURWORDINLINE(0x4840, 0x303C, 0x001F, 0xA09E);
  919.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  920.                                                                                             #pragma parameter __D0 IsDimmingControlDisabled
  921.                                                                                             #endif
  922. EXTERN_API( Boolean )
  923. IsDimmingControlDisabled        (void)                                                      TWOWORDINLINE(0x7020, 0xA09E);
  925.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  926.                                                                                             #pragma parameter __D0 IsAutoSlpControlDisabled
  927.                                                                                             #endif
  928. EXTERN_API( Boolean )
  929. IsAutoSlpControlDisabled        (void)                                                      TWOWORDINLINE(0x7021, 0xA09E);
  931.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  932.                                                                                             #pragma parameter __D0 PMgrStateQInstall(__A0)
  933.                                                                                             #endif
  934. EXTERN_API( OSErr )
  935. PMgrStateQInstall               (PMgrQueueElement *     theElement)                         TWOWORDINLINE(0x7022, 0xA09E);
  937.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  938.                                                                                             #pragma parameter __D0 PMgrStateQRemove(__A0)
  939.                                                                                             #endif
  940. EXTERN_API( OSErr )
  941. PMgrStateQRemove                (PMgrQueueElement *     theElement)                         TWOWORDINLINE(0x7023, 0xA09E);
  943.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  944.                                                                                             #pragma parameter __D0 UpdateSystemActivity(__D0)
  945.                                                                                             #endif
  946. EXTERN_API( OSErr )
  947. UpdateSystemActivity            (UInt8                  activity)                           FOURWORDINLINE(0x4840, 0x303C, 0x0024, 0xA09E);
  949.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  950.                                                                                             #pragma parameter __D0 DelaySystemIdle
  951.                                                                                             #endif
  952. EXTERN_API( OSErr )
  953. DelaySystemIdle                 (void)                                                      TWOWORDINLINE(0x7025, 0xA09E);
  955.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  956.                                                                                             #pragma parameter __D0 GetStartupTimer(__A0)
  957.                                                                                             #endif
  958. EXTERN_API( OSErr )
  959. GetStartupTimer                 (StartupTime *          theTime)                            TWOWORDINLINE(0x7026, 0xA09E);
  961.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  962.                                                                                             #pragma parameter __D0 SetStartupTimer(__A0)
  963.                                                                                             #endif
  964. EXTERN_API( OSErr )
  965. SetStartupTimer                 (StartupTime *          theTime)                            TWOWORDINLINE(0x7027, 0xA09E);
  967.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  968.                                                                                             #pragma parameter __D0 GetLastActivity(__A0)
  969.                                                                                             #endif
  970. EXTERN_API( OSErr )
  971. GetLastActivity                 (ActivityInfo *         theActivity)                        TWOWORDINLINE(0x7028, 0xA09E);
  973.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  974.                                                                                             #pragma parameter __D0 GetSoundMixerState(__A0)
  975.                                                                                             #endif
  976. EXTERN_API( OSErr )
  977. GetSoundMixerState              (SoundMixerByte *       theSoundMixerByte)                  TWOWORDINLINE(0x7029, 0xA09E);
  979.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  980.                                                                                             #pragma parameter __D0 SetSoundMixerState(__A0)
  981.                                                                                             #endif
  982. EXTERN_API( OSErr )
  983. SetSoundMixerState              (SoundMixerByte *       theSoundMixerByte)                  TWOWORDINLINE(0x702A, 0xA09E);
  985.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  986.                                                                                             #pragma parameter __D0 GetDimSuspendState
  987.                                                                                             #endif
  988. EXTERN_API( Boolean )
  989. GetDimSuspendState              (void)                                                      TWOWORDINLINE(0x702B, 0xA09E);
  991.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  992.                                                                                             #pragma parameter SetDimSuspendState(__D0)
  993.                                                                                             #endif
  994. EXTERN_API( void )
  995. SetDimSuspendState              (Boolean                dimSuspendState)                    FOURWORDINLINE(0x4840, 0x303C, 0x002C, 0xA09E);
  997. #if CALL_NOT_IN_CARBON
  998.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  999.                                                                                             #pragma parameter __D0 GetCoreProcessorTemperature(__A0)
  1000.                                                                                             #endif
  1001. EXTERN_API( SInt32 )
  1002. GetCoreProcessorTemperature     (MPCpuID                inCpuID)                            TWOWORDINLINE(0x702D, 0xA09E);
  1004.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  1005.                                                                                             #pragma parameter __D0 GetWakeOnNetworkOptions
  1006.                                                                                             #endif
  1007. EXTERN_API( OptionBits )
  1008. GetWakeOnNetworkOptions         (void)                                                      TWOWORDINLINE(0x702E, 0xA09E);
  1010.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  1011.                                                                                             #pragma parameter SetWakeOnNetworkOptions(__A0)
  1012.                                                                                             #endif
  1013. EXTERN_API( void )
  1014. SetWakeOnNetworkOptions         (OptionBits             inOptions)                          TWOWORDINLINE(0x702F, 0xA09E);
  1016.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  1017.                                                                                             #pragma parameter __D0 AddPowerSource(__A0)
  1018.                                                                                             #endif
  1019. EXTERN_API( OSStatus )
  1020. AddPowerSource                  (PowerSourceParamBlock * ioPowerSource)                     TWOWORDINLINE(0x7030, 0xA09E);
  1022.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  1023.                                                                                             #pragma parameter __D0 RemovePowerSource(__D0)
  1024.                                                                                             #endif
  1025. EXTERN_API( OSStatus )
  1026. RemovePowerSource               (PowerSourceID          inSourceID)                         FOURWORDINLINE(0x4840, 0x303C, 0x0031, 0xA09E);
  1028.                                                                                             #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  1029.                                                                                             #pragma parameter __D0 UpdatePowerSource(__A0)
  1030.                                                                                             #endif
  1031. EXTERN_API( OSStatus )
  1032. UpdatePowerSource               (PowerSourceParamBlock * ioSource)                          TWOWORDINLINE(0x7032, 0xA09E);
  1034. EXTERN_API( Boolean )
  1035. IsServerModeEnabled             (void)                                                      TWOWORDINLINE(0x7033, 0xA09E);
  1037. EXTERN_API( void )
  1038. EnableServerMode                (Boolean                inEnable)                           FOURWORDINLINE(0x4840, 0x303C, 0x0034, 0xA09E);
  1040. /* Power Handler Management */
  1041. EXTERN_API_C( Boolean )
  1042. IsPCIPowerOffDisabled           (void);
  1044. EXTERN_API_C( void )
  1045. EnablePCIPowerOff               (Boolean                inEnable);
  1047. EXTERN_API_C( OSStatus )
  1048. AddDevicePowerHandler           (RegEntryIDPtr          regEntryID,
  1049.                                  PowerHandlerProcPtr    handler,
  1050.                                  UInt32                 refCon,
  1051.                                  char *                 deviceType);
  1053. EXTERN_API_C( OSStatus )
  1054. RemoveDevicePowerHandler        (RegEntryIDPtr          regEntryID);
  1056. EXTERN_API_C( OSStatus )
  1057. RemoveDevicePowerHandlerForProc (PowerHandlerProcPtr    proc);
  1059. EXTERN_API_C( OSStatus )
  1060. GetDevicePowerLevel             (RegEntryIDPtr          regEntryID,
  1061.                                  PowerLevel *           devicePowerLevel);
  1063. EXTERN_API_C( OSStatus )
  1064. SetDevicePowerLevel             (RegEntryIDPtr          regEntryID,
  1065.                                  PowerLevel             devicePowerLevel);
  1068. #endif  /* CALL_NOT_IN_CARBON */
  1070. #if OPAQUE_UPP_TYPES
  1071.     EXTERN_API(SleepQUPP)
  1072.     NewSleepQUPP                   (SleepQProcPtr           userRoutine);
  1074.     EXTERN_API(HDSpindownUPP)
  1075.     NewHDSpindownUPP               (HDSpindownProcPtr       userRoutine);
  1077.     EXTERN_API(PMgrStateChangeUPP)
  1078.     NewPMgrStateChangeUPP          (PMgrStateChangeProcPtr  userRoutine);
  1080.     EXTERN_API(void)
  1081.     DisposeSleepQUPP               (SleepQUPP               userUPP);
  1083.     EXTERN_API(void)
  1084.     DisposeHDSpindownUPP           (HDSpindownUPP           userUPP);
  1086.     EXTERN_API(void)
  1087.     DisposePMgrStateChangeUPP      (PMgrStateChangeUPP      userUPP);
  1089.     EXTERN_API(long)
  1090.     InvokeSleepQUPP                (long                    message,
  1091.                                     SleepQRecPtr            qRecPtr,
  1092.                                     SleepQUPP               userUPP);
  1094.     EXTERN_API(void)
  1095.     InvokeHDSpindownUPP            (HDQueueElement *        theElement,
  1096.                                     HDSpindownUPP           userUPP);
  1098.     EXTERN_API(void)
  1099.     InvokePMgrStateChangeUPP       (PMgrQueueElement *      theElement,
  1100.                                     long                    stateBits,
  1101.                                     PMgrStateChangeUPP      userUPP);
  1103. #else
  1104.     enum { uppSleepQProcInfo = 0x00131832 };                        /* register 4_bytes:D0 Func(4_bytes:D0, 4_bytes:A0) */
  1105.     enum { uppHDSpindownProcInfo = 0x000000C0 };                    /* pascal no_return_value Func(4_bytes) */
  1106.     enum { uppPMgrStateChangeProcInfo = 0x000003C0 };               /* pascal no_return_value Func(4_bytes, 4_bytes) */
  1107.     #define NewSleepQUPP(userRoutine)                               (SleepQUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppSleepQProcInfo, GetCurrentArchitecture())
  1108.     #define NewHDSpindownUPP(userRoutine)                           (HDSpindownUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppHDSpindownProcInfo, GetCurrentArchitecture())
  1109.     #define NewPMgrStateChangeUPP(userRoutine)                      (PMgrStateChangeUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppPMgrStateChangeProcInfo, GetCurrentArchitecture())
  1110.     #define DisposeSleepQUPP(userUPP)                               DisposeRoutineDescriptor(userUPP)
  1111.     #define DisposeHDSpindownUPP(userUPP)                           DisposeRoutineDescriptor(userUPP)
  1112.     #define DisposePMgrStateChangeUPP(userUPP)                      DisposeRoutineDescriptor(userUPP)
  1113.     #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  1114.     #pragma parameter __D0 InvokeSleepQUPP(__D0, __A0, __A1)
  1115.     long InvokeSleepQUPP(long message, SleepQRecPtr qRecPtr, SleepQUPP userUPP) = 0x4E91;
  1116.     #else
  1117.         #define InvokeSleepQUPP(message, qRecPtr, userUPP)              (long)CALL_TWO_PARAMETER_UPP((userUPP), uppSleepQProcInfo, (message), (qRecPtr))
  1118.     #endif
  1119.     #define InvokeHDSpindownUPP(theElement, userUPP)                CALL_ONE_PARAMETER_UPP((userUPP), uppHDSpindownProcInfo, (theElement))
  1120.     #define InvokePMgrStateChangeUPP(theElement, stateBits, userUPP)  CALL_TWO_PARAMETER_UPP((userUPP), uppPMgrStateChangeProcInfo, (theElement), (stateBits))
  1121. #endif
  1122. /* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
  1123. #define NewSleepQProc(userRoutine)                              NewSleepQUPP(userRoutine)
  1124. #define NewHDSpindownProc(userRoutine)                          NewHDSpindownUPP(userRoutine)
  1125. #define NewPMgrStateChangeProc(userRoutine)                     NewPMgrStateChangeUPP(userRoutine)
  1126. #define CallSleepQProc(userRoutine, message, qRecPtr)           InvokeSleepQUPP(message, qRecPtr, userRoutine)
  1127. #define CallHDSpindownProc(userRoutine, theElement)             InvokeHDSpindownUPP(theElement, userRoutine)
  1128. #define CallPMgrStateChangeProc(userRoutine, theElement, stateBits) InvokePMgrStateChangeUPP(theElement, stateBits, userRoutine)
  1131. #if PRAGMA_STRUCT_ALIGN
  1132.     #pragma options align=reset
  1133. #elif PRAGMA_STRUCT_PACKPUSH
  1134.     #pragma pack(pop)
  1135. #elif PRAGMA_STRUCT_PACK
  1136.     #pragma pack()
  1137. #endif
  1139. #ifdef PRAGMA_IMPORT_OFF
  1140. #pragma import off
  1141. #elif PRAGMA_IMPORT
  1142. #pragma import reset
  1143. #endif
  1145. #ifdef __cplusplus
  1146. }
  1147. #endif
  1149. #endif /* __POWER__ */