Power.h

Go to the documentation of this file.

 
#ifndef __POWER__
#define __POWER__
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __MIXEDMODE__
#include <MixedMode.h>
#endif
 
#ifndef __MULTIPROCESSING__
#include <Multiprocessing.h>
#endif
 
#ifndef __NAMEREGISTRY__
#include <NameRegistry.h>
#endif
 
#ifndef __MACERRORS__
#include <MacErrors.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
  enum
  {
    /* Bit positions for ModemByte */
    modemOnBit = 0,
    ringWakeUpBit = 2,
    modemInstalledBit = 3,
    ringDetectBit = 4,
    modemOnHookBit = 5
  };
 
  enum
  {
    /* masks for ModemByte */
    modemOnMask = 0x01,
    ringWakeUpMask = 0x04,
    modemInstalledMask = 0x08,
    ringDetectMask = 0x10,
    modemOnHookMask = 0x20
  };
 
  enum
  {
    /* bit positions for BatteryByte */
    chargerConnBit = 0,
    hiChargeBit = 1,
    chargeOverFlowBit = 2,
    batteryDeadBit = 3,
    batteryLowBit = 4,
    connChangedBit = 5
  };
 
  enum
  {
    /* masks for BatteryByte */
    chargerConnMask = 0x01,
    hiChargeMask = 0x02,
    chargeOverFlowMask = 0x04,
    batteryDeadMask = 0x08,
    batteryLowMask = 0x10,
    connChangedMask = 0x20
  };
 
  enum
  {
    /* bit positions for SoundMixerByte */
    MediaBaySndEnBit = 0,
    PCISndEnBit = 1,
    ZVSndEnBit = 2,
    PCCardSndEnBit = 3
  };
 
  enum
  {
    /* masks for SoundMixerByte */
    MediaBaySndEnMask = 0x01,
    PCISndEnMask = 0x02,
    ZVSndEnMask = 0x04,
    PCCardSndEnMask = 0x08
  };
 
  enum
  {
    /* commands to SleepQRec sleepQProc */
    kSleepRequest = 1,
    kSleepDemand = 2,
    kSleepWakeUp = 3,
    kSleepRevoke = 4,
    kSleepUnlock = 4,
    kSleepDeny = 5, /* A non-zero value clients can use to deny requests*/
    kSleepNow = 6,
    kDozeDemand = 7,
    kDozeWakeUp = 8,
    kDozeRequest = 9,   /* additional messages for Power Mgr 2.0*/
    kEnterStandby = 10, /* Idle Queue Only*/
    kEnterRun = 11,     /* Idle Queue Only*/
    kSuspendRequest = 12,
    kSuspendDemand = 13,
    kSuspendRevoke = 14,
    kSuspendWakeUp = 15,
    kGetPowerLevel = 16,
    kSetPowerLevel = 17,
    kDeviceInitiatedWake = 18,
    kWakeToDoze = 19,
    kDozeToFullWakeUp = 20,
    kGetPowerInfo = 21,
    kGetWakeOnNetInfo = 22,
    kSuspendWakeToDoze = 23,
    kEnterIdle = 24, /* Idle Queue Only*/
    kStillIdle = 25, /* Idle Queue Only*/
    kExitIdle = 26   /* Idle Queue Only*/
  };
 
  enum
  {
    /* depreciated commands to SleepQRec sleepQProc */
    sleepRequest = kSleepRequest,
    sleepDemand = kSleepDemand,
    sleepWakeUp = kSleepWakeUp,
    sleepRevoke = kSleepRevoke,
    sleepUnlock = kSleepUnlock,
    sleepDeny = kSleepDeny,
    sleepNow = kSleepNow,
    dozeDemand = kDozeDemand,
    dozeWakeUp = kDozeWakeUp,
    dozeRequest = kDozeRequest,
    enterStandby = kEnterStandby,
    enterRun = kEnterRun,
    suspendRequestMsg = kSuspendRequest,
    suspendDemandMsg = kSuspendDemand,
    suspendRevokeMsg = kSuspendRevoke,
    suspendWakeUpMsg = kSuspendWakeUp,
    getPowerLevel = kGetPowerLevel,
    setPowerLevel = kSetPowerLevel
  };
 
  /* Power Handler func messages */
  typedef UInt32 PowerLevel;
  /* Power levels corresponding to PCI Bus Power Management Interface Spec (PMIS)
   */
  enum
  {
    kPMDevicePowerLevel_On = 0, /* fully-powered 'On' state (D0 state)    */
    kPMDevicePowerLevel_D1 = 1, /* not used by Apple system SW         */
    kPMDevicePowerLevel_D2 = 2, /* not used by Apple system SW         */
    kPMDevicePowerLevel_Off = 3 /* main PCI bus power 'Off', but PCI standby power
                                   available (D3cold state) */
  };
 
  /* PowerHandlerProc definition */
  typedef CALLBACK_API(OSStatus, PowerHandlerProcPtr)(UInt32 message, void *param,
                                                      UInt32 refCon,
                                                      RegEntryID *regEntryID);
  typedef STACK_UPP_TYPE(PowerHandlerProcPtr) PowerHandlerUPP;
#if CALL_NOT_IN_CARBON
  PowerHandlerUPP
  NewPowerHandlerUPP(PowerHandlerProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppPowerHandlerProcInfo = 0x00003FF0
  }; /* pascal 4_bytes Func(4_bytes, 4_bytes, 4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline PowerHandlerUPP NewPowerHandlerUPP(PowerHandlerProcPtr userRoutine)
  {
    return (PowerHandlerUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                 uppPowerHandlerProcInfo,
                                                 GetCurrentArchitecture());
  }
#else
#define NewPowerHandlerUPP(userRoutine)                                     \
  (PowerHandlerUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppPowerHandlerProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposePowerHandlerUPP(PowerHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposePowerHandlerUPP(PowerHandlerUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposePowerHandlerUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  OSStatus
  InvokePowerHandlerUPP(UInt32 message, void *param, UInt32 refCon,
                        RegEntryID *regEntryID, PowerHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSStatus InvokePowerHandlerUPP(UInt32 message, void *param,
                                        UInt32 refCon, RegEntryID *regEntryID,
                                        PowerHandlerUPP userUPP)
  {
    return (OSStatus)CALL_FOUR_PARAMETER_UPP(userUPP, uppPowerHandlerProcInfo,
                                             message, param, refCon, regEntryID);
  }
#else
#define InvokePowerHandlerUPP(message, param, refCon, regEntryID, userUPP)   \
  (OSStatus)                                                                 \
      CALL_FOUR_PARAMETER_UPP((userUPP), uppPowerHandlerProcInfo, (message), \
                              (param), (refCon), (regEntryID))
#endif
#endif
 
#endif /* CALL_NOT_IN_CARBON */
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
/* support for pre-Carbon UPP routines: New...Proc and Call...Proc */
#define NewPowerHandlerProc(userRoutine) NewPowerHandlerUPP(userRoutine)
#define CallPowerHandlerProc(userRoutine, message, param, refCon, regEntryID) \
  InvokePowerHandlerUPP(message, param, refCon, regEntryID, userRoutine)
#endif /* CALL_NOT_IN_CARBON */
 
#define kIdleQueueDeviceType "idle-queue"
  /* PCI power management support*/
 
  enum
  {
    kUseDefaultMinimumWakeTime = 0, /* Defaults to 5 minutes*/
    kPowerSummaryVersion = 1,       /* Version of PowerSummary structure.*/
    kDevicePowerInfoVersion = 1     /* Version of DevicePowerInfo structure.*/
  };
 
  enum
  {
    /* PowerSummary flags*/
    kPCIPowerOffAllowed = (1L << 0) /* PCI power off is allowed.*/
  };
 
  enum
  {
    /* DevicePowerInfo flags*/
    kDevicePCIPowerOffAllowed =
        (1L << 0), /* PCI power off is allowed for device.*/
    kDeviceSupportsPMIS =
        (1L << 1), /* Device supports Power Mgt Interface Spec.*/
    kDeviceCanAssertPMEDuringSleep =
        (1L << 2),                           /* Device can assert PME# during sleep.*/
    kDeviceUsesCommonLogicPower = (1L << 3), /* Device uses common-logic power*/
    kDeviceDriverPresent = (1L << 4),        /* Driver present for device.*/
    kDeviceDriverSupportsPowerMgt =
        (1L << 5) /* Driver installed a power handler.*/
  };
 
  struct DevicePowerInfo
  {
    UInt32 version;          /* Version of this structure.*/
    RegEntryID regID;        /* RegEntryID for device.*/
    OptionBits flags;        /* Flags*/
    UInt32 minimumWakeTime;  /* Minimum seconds before sleeping again.*/
    UInt32 sleepPowerNeeded; /* Milliwatts needed in the sleep state.*/
  };
  typedef struct DevicePowerInfo DevicePowerInfo;
  struct PowerSummary
  {
    UInt32 version;             /* Version of this structure.*/
    OptionBits flags;           /* Flags*/
    UInt32 sleepPowerAvailable; /* Milliwatts available during sleep.*/
    UInt32 sleepPowerNeeded;    /* Milliwatts needed during sleep.*/
    UInt32 minimumWakeTime;     /* Minimum seconds before sleeping again.*/
    ItemCount deviceCount;      /* Number of device power info records.*/
    DevicePowerInfo devices[1]; /* Array of device power info records.*/
  };
  typedef struct PowerSummary PowerSummary;
  enum
  {
    /* SleepQRec.sleepQFlags */
    noCalls = 1,
    noRequest = 2,
    slpQType = 16,
    sleepQType = 16
  };
 
  /* Power Mgt Apple Event types and errors */
  enum
  {
    /* power mgt class*/
    kAEMacPowerMgtEvt = FOUR_CHAR_CODE('pmgt'), /* event ids*/
    kAEMacToWake = FOUR_CHAR_CODE('wake'),
    kAEMacLowPowerSaveData = FOUR_CHAR_CODE('pmsd'),
    kAEMacEmergencySleep = FOUR_CHAR_CODE('emsl'),
    kAEMacEmergencyShutdown = FOUR_CHAR_CODE('emsd')
  };
 
  enum
  {
    kDeviceDidNotWakeMachine = 0, /* device did NOT wake machine*/
    kDeviceRequestsFullWake =
        1, /* device did wake machine and requests full wakeup*/
    kDeviceRequestsWakeToDoze =
        2 /* device did wake machine and requests partial wakeup*/
  };
 
  /* bits in bitfield returned by PMFeatures */
  enum
  {
    hasWakeupTimer = 0,      /* 1=wakeup timer is supported                    */
    hasSharedModemPort = 1,  /* 1=modem port shared by SCC and internal modem  */
    hasProcessorCycling = 2, /* 1=processor cycling is supported                */
    mustProcessorCycle = 3,  /* 1=processor cycling should not be turned off  */
    hasReducedSpeed = 4,     /* 1=processor can be started up at reduced speed     */
    dynamicSpeedChange = 5,  /* 1=processor speed can be switched dynamically  */
    hasSCSIDiskMode = 6,     /* 1=SCSI Disk Mode is supported                 */
    canGetBatteryTime = 7,   /* 1=battery time can be calculated                */
    canWakeupOnRing = 8,     /* 1=can wakeup when the modem detects a ring          */
    hasDimmingSupport =
        9,                      /* 1=has dimming support built in (DPMS standby by default)   */
    hasStartupTimer = 10,       /* 1=startup timer is supported                    */
    hasChargeNotification = 11, /* 1=client can determine of charge connect status
                                   change notifications available */
    hasDimSuspendSupport =
        12,                    /* 1=supports dimming LCD and CRT to DPMS suspend state     */
    hasWakeOnNetActivity = 13, /* 1=hardware supports wake on network activity */
    hasWakeOnLid = 14,         /* 1=hardware can wake when opened                   */
    canPowerOffPCIBus =
        15,            /* 1=hardware can power off PCI bus during sleep if cards allow */
    hasDeepSleep = 16, /* 1=hardware supports deep sleep (hibernation) mode   */
    hasSleep = 17,     /* 1=hardware supports normal (PowerBook-like) sleep   */
    supportsServerModeAPIs =
        18, /* 1=hardware supports server mode API routines          */
    supportsUPSIntegration =
        19, /* 1=hardware support UPS integration and reporting      */
    hasAggressiveIdling =
        20,                /* 1=Power Manager only resets OverallAct on UsrActvity     */
    supportsIdleQueue = 21 /* 1=Power Manager supports the idle queue */
  };
 
  /* bits in bitfield returned by GetIntModemInfo and set by SetIntModemState */
  enum
  {
    hasInternalModem = 0,    /* 1=internal modem installed               */
    intModemRingDetect = 1,  /* 1=internal modem has detected a ring          */
    intModemOffHook = 2,     /* 1=internal modem is off hook               */
    intModemRingWakeEnb = 3, /* 1=wakeup on ring is enabled                 */
    extModemSelected = 4,    /* 1=external modem selected             */
    modemSetBit = 15         /* 1=set bit, 0=clear bit (SetIntModemState)   */
  };
 
  /* bits in BatteryInfo.flags                                    */
  /* ("chargerConnected" doesn't mean the charger is plugged in)  */
  enum
  {
    batteryInstalled = 7, /* 1=battery is currently connected             */
    batteryCharging = 6,  /* 1=battery is being charged               */
    chargerConnected = 5, /* 1=charger is connected to the PowerBook         */
    upsConnected = 4,     /* 1=there is a UPS connected               */
    upsIsPowerSource = 3  /* 1=UPS is source of power                */
  };
 
  enum
  {
    HDPwrQType = 0x4844,    /* 'HD' hard disk spindown queue element type     */
    PMgrStateQType = 0x504D /* 'PM' Power Manager state queue element type */
  };
 
  /* client notification bits in PMgrQueueElement.pmNotifyBits */
  enum
  {
    pmSleepTimeoutChanged = 0,
    pmSleepEnableChanged = 1,
    pmHardDiskTimeoutChanged = 2,
    pmHardDiskSpindownChanged = 3,
    pmDimmingTimeoutChanged = 4,
    pmDimmingEnableChanged = 5,
    pmDiskModeAddressChanged = 6,
    pmProcessorCyclingChanged = 7,
    pmProcessorSpeedChanged = 8,
    pmWakeupTimerChanged = 9,
    pmStartupTimerChanged = 10,
    pmHardDiskPowerRemovedbyUser = 11,
    pmChargeStatusChanged = 12,
    pmPowerLevelChanged = 13,
    pmWakeOnNetActivityChanged = 14
  };
 
  enum
  {
    pmSleepTimeoutChangedMask = (1 << pmSleepTimeoutChanged),
    pmSleepEnableChangedMask = (1 << pmSleepEnableChanged),
    pmHardDiskTimeoutChangedMask = (1 << pmHardDiskTimeoutChanged),
    pmHardDiskSpindownChangedMask = (1 << pmHardDiskSpindownChanged),
    pmDimmingTimeoutChangedMask = (1 << pmDimmingTimeoutChanged),
    pmDimmingEnableChangedMask = (1 << pmDimmingEnableChanged),
    pmDiskModeAddressChangedMask = (1 << pmDiskModeAddressChanged),
    pmProcessorCyclingChangedMask = (1 << pmProcessorCyclingChanged),
    pmProcessorSpeedChangedMask = (1 << pmProcessorSpeedChanged),
    pmWakeupTimerChangedMask = (1 << pmWakeupTimerChanged),
    pmStartupTimerChangedMask = (1 << pmStartupTimerChanged),
    pmHardDiskPowerRemovedbyUserMask = (1 << pmHardDiskPowerRemovedbyUser),
    pmChargeStatusChangedMask = (1 << pmChargeStatusChanged),
    pmPowerLevelChangedMask = (1 << pmPowerLevelChanged),
    pmWakeOnNetActivityChangedMask = (1 << pmWakeOnNetActivityChanged)
  };
 
  /* System Activity Selectors */
  /* Notes:  The IdleActivity selector is not available unless the
   * hasAggressiveIdling PMFeatures bit is set. */
  /*         Use IdleActivity where you used to use OverallAct if necessary.
   * OverallAct will only            */
  /*         delay power cycling if it's enabled, and will delay sleep by a small
   * amount when                 */
  /*         hasAggressiveIdling is set.  Don't use IdleActivity unless
   * hasAggressiveIdling is set; when      */
  /*         hasAggressiveIdling is not set, the use of IdleActivity is undefined,
   * and well do different      */
  /*         things depending on which Power Manager is currently running. */
  enum
  {
    OverallAct = 0,  /* Delays idle sleep by small amount                 */
    UsrActivity = 1, /* Delays idle sleep and dimming by timeout time          */
    NetActivity = 2, /* Delays idle sleep and power cycling by small amount */
    HDActivity =
        3,           /* Delays hard drive spindown and idle sleep by small amount  */
    IdleActivity = 4 /* Delays idle sleep by timeout time                 */
  };
 
  /* Storage Media sleep mode defines */
  enum
  {
    kMediaModeOn = 0,      /* Media active (Drive spinning and at full power)    */
    kMediaModeStandBy = 1, /* Media standby (not implemented)    */
    kMediaModeSuspend = 2, /* Media Idle (not implemented)   */
    kMediaModeOff = 3      /* Media Sleep (Drive not spinning and at min power, max
                              recovery time)   */
  };
 
  enum
  {
    kMediaPowerCSCode = 70
  };
 
  /* definitions for HDQueueElement.hdFlags   */
  enum
  {
    kHDQueuePostBit = 0, /* 1 = call this routine on the second pass     */
    kHDQueuePostMask = (1 << kHDQueuePostBit)
  };
 
  struct ActivityInfo
  {
    short ActivityType; /* Type of activity to be fetched.  Same as
                           UpdateSystemActivity Selectors */
    unsigned long
        ActivityTime; /* Time of last activity (in ticks) of specified type. */
  };
  typedef struct ActivityInfo ActivityInfo;
  /* information returned by GetScaledBatteryInfo */
  struct BatteryInfo
  {
    UInt8 flags;        /* misc flags (see below)                  */
    UInt8 warningLevel; /* scaled warning level (0-255)               */
    UInt8 reserved;     /* reserved for internal use             */
    UInt8 batteryLevel; /* scaled battery level (0-255)               */
  };
  typedef struct BatteryInfo BatteryInfo;
 
  typedef SInt8 ModemByte;
  typedef SInt8 BatteryByte;
  typedef SInt8 SoundMixerByte;
  typedef long PMResultCode;
  typedef struct SleepQRec SleepQRec;
  typedef SleepQRec *SleepQRecPtr;
  typedef struct HDQueueElement HDQueueElement;
  typedef struct PMgrQueueElement PMgrQueueElement;
  typedef CALLBACK_API_REGISTER68K(long, SleepQProcPtr,
                                   (long message, SleepQRecPtr qRecPtr));
  typedef CALLBACK_API(void, HDSpindownProcPtr)(HDQueueElement *theElement);
  typedef CALLBACK_API(void, PMgrStateChangeProcPtr)(PMgrQueueElement *theElement,
                                                     long stateBits);
  typedef REGISTER_UPP_TYPE(SleepQProcPtr) SleepQUPP;
  typedef STACK_UPP_TYPE(HDSpindownProcPtr) HDSpindownUPP;
  typedef STACK_UPP_TYPE(PMgrStateChangeProcPtr) PMgrStateChangeUPP;
  struct SleepQRec
  {
    SleepQRecPtr sleepQLink; /* pointer to next queue element          */
    short sleepQType;        /* queue element type (must be SleepQType)       */
    SleepQUPP sleepQProc;    /* pointer to sleep universal proc ptr         */
    short sleepQFlags;       /* flags                       */
  };
 
  struct HDQueueElement
  {
    struct HDQueueElement *hdQLink; /* pointer to next queue element          */
    short hdQType;                  /* queue element type (must be HDPwrQType)       */
    short hdFlags;                  /* miscellaneous flags                   */
    HDSpindownUPP hdProc;           /* pointer to routine to call           */
    long hdUser;                    /* user-defined (variable storage, etc.)   */
  };
 
  struct PMgrQueueElement
  {
    struct PMgrQueueElement *pmQLink; /* pointer to next queue element          */
    short pmQType;                    /* queue element type (must be PMgrStateQType)    */
    short pmFlags;                    /* miscellaneous flags                   */
    long pmNotifyBits;                /* bitmap of which changes to be notified for */
    PMgrStateChangeUPP pmProc;        /* pointer to routine to call           */
    long pmUser;                      /* user-defined (variable storage, etc.)   */
  };
 
  struct BatteryTimeRec
  {
    unsigned long
        expectedBatteryTime; /* estimated battery time remaining (seconds) */
    unsigned long
        minimumBatteryTime; /* minimum battery time remaining (seconds)     */
    unsigned long
        maximumBatteryTime; /* maximum battery time remaining (seconds)     */
    unsigned long
        timeUntilCharged; /* time until battery is fully charged (seconds)*/
  };
  typedef struct BatteryTimeRec BatteryTimeRec;
 
  struct WakeupTime
  {
    unsigned long wakeTime; /* wakeup time (same format as current time)   */
    Boolean wakeEnabled;    /* 1=enable wakeup timer, 0=disable wakeup timer  */
    SInt8 filler;
  };
  typedef struct WakeupTime WakeupTime;
 
  struct StartupTime
  {
    unsigned long startTime; /* startup time (same format as current time)     */
    Boolean startEnabled;    /* 1=enable startup timer, 0=disable startup timer    */
    SInt8 filler;
  };
  typedef struct StartupTime StartupTime;
  /* PowerSource version*/
  enum
  {
    kVersionOnePowerSource = 1,
    kVersionTwoPowerSource = 2,
    kCurrentPowerSourceVersion = kVersionTwoPowerSource
  };
 
  /* PowerSourceAttrs bits*/
 
  enum
  {
    bSourceIsBattery = 0,    /* power source is battery*/
    bSourceIsAC = 1,         /* power source is AC*/
    bSourceCanBeCharged = 2, /* power source can be charged*/
    bSourceIsUPS = 3,        /* power source is UPS. NOTE: software should set
                                bSourceIsBattery and bSourceIsAC also, as appropriate*/
    bSourceProvidesWarnLevels =
        4, /* power source provides low power and dead battery warning levels*/
    kSourceIsBatteryMask = (1 << bSourceIsBattery),
    kSourceIsACMask = (1 << bSourceIsAC),
    kSourceCanBeChargedMask = (1 << bSourceCanBeCharged),
    kSourceIsUPSMask = (1 << bSourceIsUPS),
    kSourceProvidesWarnLevelsMask = (1 << bSourceProvidesWarnLevels)
  };
 
  /* PowerSourceFlags bits*/
 
  enum
  {
    bSourceIsAvailable = 0, /* power source is installed*/
    bSourceIsCharging = 1,  /* power source being charged*/
    bChargerIsAttached = 2, /* a charger is connected*/
    kSourceIsAvailableMask = (1 << bSourceIsAvailable),
    kSourceIsChargingMask = (1 << bSourceIsCharging),
    kChargerIsAttachedMask = (1 << bChargerIsAttached)
  };
 
  /* Power Capacity Types*/
 
  enum
  {
    kCapacityIsActual = 0, /* current capacity is expessed as actual capacity in
                              same units as max*/
    kCapacityIsPercentOfMax =
        1 /* current capacity is expressed as a percentage of maximumCapacity*/
  };
 
  /* Net Activity Wake Options*/
  enum
  {
    kConfigSupportsWakeOnNetBit = 0,
    kWakeOnNetAdminAccessesBit = 1,
    kWakeOnAllNetAccessesBit = 2,
    kUnmountServersBeforeSleepingBit = 3,
    kConfigSupportsWakeOnNetMask = (1 << kConfigSupportsWakeOnNetBit),
    kWakeOnNetAdminAccessesMask = (1 << kWakeOnNetAdminAccessesBit),
    kWakeOnAllNetAccessesMask = (1 << kWakeOnAllNetAccessesBit),
    kUnmountServersBeforeSleepingMask = (1 << kUnmountServersBeforeSleepingBit)
  };
 
  /* Power Source capacity usage types*/
  enum
  {
    kCurrentCapacityIsActualValue =
        0, /* currentCapacity is a real value in same units as maxCapacity*/
    kCurrentCapacityIsPercentOfMax =
        1 /* currentCapacity is expressed as a percentage of maxCapacity.*/
  };
 
  typedef SInt16 PowerSourceID;
  struct PowerSourceParamBlock
  {
    PowerSourceID sourceID;     /* unique id assigned by Power Mgr*/
    UInt16 sourceCapacityUsage; /* how currentCapacity is used*/
    UInt32 sourceVersion;       /* version of this record*/
    OptionBits sourceAttr;      /* attribute flags (see below)*/
    OptionBits sourceState;     /* state flags (see below)*/
    UInt32 currentCapacity;     /* current capacity, in*/
                                /*   milliwatts or %*/
    UInt32 maxCapacity;         /* full capacity, in milliwatts*/
    UInt32 timeRemaining;       /* time left to deplete, */
                                /*   in milliwatt-hours*/
    UInt32 timeToFullCharge;    /* time to charge, */
                                /*   in milliwatt-hours*/
    UInt32 voltage;             /* voltage in millivolts*/
    SInt32 current;             /* current in milliamperes */
                                /*  (negative if consuming, */
                                /*   positive if charging)*/
    UInt32 lowWarnLevel;        /* low warning level in milliwatts (or % if
                                   sourceCapacityUsage is %)*/
    UInt32 deadWarnLevel;       /* dead warning level in milliwatts (or % if
                                   sourceCapacityUsage is %)*/
    UInt32 reserved[16];        /* for future expansion*/
  };
  typedef struct PowerSourceParamBlock PowerSourceParamBlock;
  typedef PowerSourceParamBlock *PowerSourceParamBlockPtr;
 
  OSErr
  DisableWUTime(void);
 
  OSErr
  SetWUTime(long wuTime);
 
  OSErr
  GetWUTime(long *wuTime, Byte *wuFlag);
 
  OSErr
  BatteryStatus(Byte *status, Byte *power);
 
  OSErr
  ModemStatus(Byte *status);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 IdleUpdate
#endif
  long
  IdleUpdate(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 GetCPUSpeed
#endif
  long
  GetCPUSpeed(void);
 
  void
  EnableIdle(void);
 
  void
  DisableIdle(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter SleepQInstall(__A0)
#endif
  void
  SleepQInstall(SleepQRecPtr qRecPtr);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter SleepQRemove(__A0)
#endif
  void
  SleepQRemove(SleepQRecPtr qRecPtr);
 
  void
  AOn(void);
 
  void
  AOnIgnoreModem(void);
 
  void
  BOn(void);
 
  void
  AOff(void);
 
  void
  BOff(void);
 
/* Public Power Management API  */
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PMSelectorCount
#endif
  short
  PMSelectorCount(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PMFeatures
#endif
  UInt32
  PMFeatures(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 GetSleepTimeout
#endif
  UInt8
  GetSleepTimeout(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter SetSleepTimeout(__D0)
#endif
  void
  SetSleepTimeout(UInt8 timeout);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 GetHardDiskTimeout
#endif
  UInt8
  GetHardDiskTimeout(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter SetHardDiskTimeout(__D0)
#endif
  void
  SetHardDiskTimeout(UInt8 timeout);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 HardDiskPowered
#endif
  Boolean
  HardDiskPowered(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter SpinDownHardDisk
#endif
  void
  SpinDownHardDisk(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 IsSpindownDisabled
#endif
  Boolean
  IsSpindownDisabled(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter SetSpindownDisable(__D0)
#endif
  void
  SetSpindownDisable(Boolean setDisable);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 HardDiskQInstall(__A0)
#endif
  OSErr
  HardDiskQInstall(HDQueueElement *theElement);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 HardDiskQRemove(__A0)
#endif
  OSErr
  HardDiskQRemove(HDQueueElement *theElement);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter GetScaledBatteryInfo(__D0, __A0)
#endif
  void
  GetScaledBatteryInfo(short whichBattery, BatteryInfo *theInfo);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter AutoSleepControl(__D0)
#endif
  void
  AutoSleepControl(Boolean enableSleep);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 GetIntModemInfo
#endif
  UInt32
  GetIntModemInfo(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter SetIntModemState(__D0)
#endif
  void
  SetIntModemState(short theState);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 MaximumProcessorSpeed
#endif
  short
  MaximumProcessorSpeed(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 MinimumProcessorSpeed
#endif
  short
  MinimumProcessorSpeed(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 CurrentProcessorSpeed
#endif
  short
  CurrentProcessorSpeed(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 FullProcessorSpeed
#endif
  Boolean
  FullProcessorSpeed(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 SetProcessorSpeed(__D0)
#endif
  Boolean
  SetProcessorSpeed(Boolean fullSpeed);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 GetSCSIDiskModeAddress
#endif
  short
  GetSCSIDiskModeAddress(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter SetSCSIDiskModeAddress(__D0)
#endif
  void
  SetSCSIDiskModeAddress(short scsiAddress);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter GetWakeupTimer(__A0)
#endif
  void
  GetWakeupTimer(WakeupTime *theTime);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter SetWakeupTimer(__A0)
#endif
  void
  SetWakeupTimer(WakeupTime *theTime);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 IsProcessorCyclingEnabled
#endif
  Boolean
  IsProcessorCyclingEnabled(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter EnableProcessorCycling(__D0)
#endif
  void
  EnableProcessorCycling(Boolean enable);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 BatteryCount
#endif
  short
  BatteryCount(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 GetBatteryVoltage(__D0)
#endif
  Fixed
  GetBatteryVoltage(short whichBattery);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter GetBatteryTimes(__D0, __A0)
#endif
  void
  GetBatteryTimes(short whichBattery, BatteryTimeRec *theTimes);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 GetDimmingTimeout
#endif
  UInt8
  GetDimmingTimeout(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter SetDimmingTimeout(__D0)
#endif
  void
  SetDimmingTimeout(UInt8 timeout);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter DimmingControl(__D0)
#endif
  void
  DimmingControl(Boolean enableSleep);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 IsDimmingControlDisabled
#endif
  Boolean
  IsDimmingControlDisabled(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 IsAutoSlpControlDisabled
#endif
  Boolean
  IsAutoSlpControlDisabled(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PMgrStateQInstall(__A0)
#endif
  OSErr
  PMgrStateQInstall(PMgrQueueElement *theElement);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PMgrStateQRemove(__A0)
#endif
  OSErr
  PMgrStateQRemove(PMgrQueueElement *theElement);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 UpdateSystemActivity(__D0)
#endif
  OSErr
  UpdateSystemActivity(UInt8 activity);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 DelaySystemIdle
#endif
  OSErr
  DelaySystemIdle(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 GetStartupTimer(__A0)
#endif
  OSErr
  GetStartupTimer(StartupTime *theTime);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 SetStartupTimer(__A0)
#endif
  OSErr
  SetStartupTimer(StartupTime *theTime);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 GetLastActivity(__A0)
#endif
  OSErr
  GetLastActivity(ActivityInfo *theActivity);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 GetSoundMixerState(__A0)
#endif
  OSErr
  GetSoundMixerState(SoundMixerByte *theSoundMixerByte);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 SetSoundMixerState(__A0)
#endif
  OSErr
  SetSoundMixerState(SoundMixerByte *theSoundMixerByte);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 GetDimSuspendState
#endif
  Boolean
  GetDimSuspendState(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter SetDimSuspendState(__D0)
#endif
  void
  SetDimSuspendState(Boolean dimSuspendState);
 
#if CALL_NOT_IN_CARBON
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 GetCoreProcessorTemperature(__A0)
#endif
  SInt32
  GetCoreProcessorTemperature(MPCpuID inCpuID);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 GetWakeOnNetworkOptions
#endif
  OptionBits
  GetWakeOnNetworkOptions(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter SetWakeOnNetworkOptions(__A0)
#endif
  void
  SetWakeOnNetworkOptions(OptionBits inOptions);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 AddPowerSource(__A0)
#endif
  OSStatus
  AddPowerSource(PowerSourceParamBlock *ioPowerSource);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 RemovePowerSource(__D0)
#endif
  OSStatus
  RemovePowerSource(PowerSourceID inSourceID);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 UpdatePowerSource(__A0)
#endif
  OSStatus
  UpdatePowerSource(PowerSourceParamBlock *ioSource);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 IsServerModeEnabled
#endif
  Boolean
  IsServerModeEnabled(void);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter EnableServerMode(__D0)
#endif
  void
  EnableServerMode(Boolean inEnable);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 NumBatteriesInstalled
#endif
  UInt32
  NumBatteriesInstalled(void);
 
  /* Power Handler Management */
  Boolean
  IsPCIPowerOffDisabled(void);
 
  void
  EnablePCIPowerOff(Boolean inEnable);
 
  OSStatus
  AddDevicePowerHandler(RegEntryIDPtr regEntryID, PowerHandlerProcPtr handler,
                        UInt32 refCon, char *deviceType);
 
  OSStatus
  RemoveDevicePowerHandler(RegEntryIDPtr regEntryID);
 
  OSStatus
  RemoveDevicePowerHandlerForProc(PowerHandlerProcPtr proc);
 
  OSStatus
  GetDevicePowerLevel(RegEntryIDPtr regEntryID, PowerLevel *devicePowerLevel);
 
  OSStatus
  SetDevicePowerLevel(RegEntryIDPtr regEntryID, PowerLevel devicePowerLevel);
 
#endif /* CALL_NOT_IN_CARBON */
 
  SleepQUPP
  NewSleepQUPP(SleepQProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppSleepQProcInfo = 0x00131832
  }; /* register 4_bytes:D0 Func(4_bytes:D0, 4_bytes:A0) */
#ifdef __cplusplus
  inline SleepQUPP NewSleepQUPP(SleepQProcPtr userRoutine)
  {
    return (SleepQUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppSleepQProcInfo, GetCurrentArchitecture());
  }
#else
#define NewSleepQUPP(userRoutine)                                             \
  (SleepQUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppSleepQProcInfo, \
                                   GetCurrentArchitecture())
#endif
#endif
 
  HDSpindownUPP
  NewHDSpindownUPP(HDSpindownProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppHDSpindownProcInfo = 0x000000C0
  }; /* pascal no_return_value Func(4_bytes) */
#ifdef __cplusplus
  inline HDSpindownUPP NewHDSpindownUPP(HDSpindownProcPtr userRoutine)
  {
    return (HDSpindownUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppHDSpindownProcInfo, GetCurrentArchitecture());
  }
#else
#define NewHDSpindownUPP(userRoutine)   \
  (HDSpindownUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppHDSpindownProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  PMgrStateChangeUPP
  NewPMgrStateChangeUPP(PMgrStateChangeProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppPMgrStateChangeProcInfo = 0x000003C0
  }; /* pascal no_return_value Func(4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline PMgrStateChangeUPP
  NewPMgrStateChangeUPP(PMgrStateChangeProcPtr userRoutine)
  {
    return (PMgrStateChangeUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                    uppPMgrStateChangeProcInfo,
                                                    GetCurrentArchitecture());
  }
#else
#define NewPMgrStateChangeUPP(userRoutine)                                     \
  (PMgrStateChangeUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppPMgrStateChangeProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeSleepQUPP(SleepQUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeSleepQUPP(SleepQUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeSleepQUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeHDSpindownUPP(HDSpindownUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeHDSpindownUPP(HDSpindownUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeHDSpindownUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposePMgrStateChangeUPP(PMgrStateChangeUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposePMgrStateChangeUPP(PMgrStateChangeUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposePMgrStateChangeUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 InvokeSleepQUPP(__D0, __A0, __A1)
#endif
  long
  InvokeSleepQUPP(long message, SleepQRecPtr qRecPtr, SleepQUPP userUPP);
#if !OPAQUE_UPP_TYPES && \
    (!TARGET_OS_MAC || !TARGET_CPU_68K || TARGET_RT_MAC_CFM)
#ifdef __cplusplus
  inline long InvokeSleepQUPP(long message, SleepQRecPtr qRecPtr,
                              SleepQUPP userUPP)
  {
    return (long)CALL_TWO_PARAMETER_UPP(userUPP, uppSleepQProcInfo, message,
                                        qRecPtr);
  }
#else
#define InvokeSleepQUPP(message, qRecPtr, userUPP)                      \
  (long)CALL_TWO_PARAMETER_UPP((userUPP), uppSleepQProcInfo, (message), \
                               (qRecPtr))
#endif
#endif
 
  void
  InvokeHDSpindownUPP(HDQueueElement *theElement, HDSpindownUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeHDSpindownUPP(HDQueueElement *theElement,
                                  HDSpindownUPP userUPP)
  {
    CALL_ONE_PARAMETER_UPP(userUPP, uppHDSpindownProcInfo, theElement);
  }
#else
#define InvokeHDSpindownUPP(theElement, userUPP) \
  CALL_ONE_PARAMETER_UPP((userUPP), uppHDSpindownProcInfo, (theElement))
#endif
#endif
 
  void
  InvokePMgrStateChangeUPP(PMgrQueueElement *theElement, long stateBits,
                           PMgrStateChangeUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokePMgrStateChangeUPP(PMgrQueueElement *theElement,
                                       long stateBits,
                                       PMgrStateChangeUPP userUPP)
  {
    CALL_TWO_PARAMETER_UPP(userUPP, uppPMgrStateChangeProcInfo, theElement,
                           stateBits);
  }
#else
#define InvokePMgrStateChangeUPP(theElement, stateBits, userUPP)              \
  CALL_TWO_PARAMETER_UPP((userUPP), uppPMgrStateChangeProcInfo, (theElement), \
                         (stateBits))
#endif
#endif
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
/* support for pre-Carbon UPP routines: New...Proc and Call...Proc */
#define NewSleepQProc(userRoutine) NewSleepQUPP(userRoutine)
#define NewHDSpindownProc(userRoutine) NewHDSpindownUPP(userRoutine)
#define NewPMgrStateChangeProc(userRoutine) NewPMgrStateChangeUPP(userRoutine)
#define CallSleepQProc(userRoutine, message, qRecPtr) \
  InvokeSleepQUPP(message, qRecPtr, userRoutine)
#define CallHDSpindownProc(userRoutine, theElement) \
  InvokeHDSpindownUPP(theElement, userRoutine)
#define CallPMgrStateChangeProc(userRoutine, theElement, stateBits) \
  InvokePMgrStateChangeUPP(theElement, stateBits, userRoutine)
#endif /* CALL_NOT_IN_CARBON */
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* __POWER__ */