DriverServices.h

Go to the documentation of this file.

 
#ifndef __DRIVERSERVICES__
#define __DRIVERSERVICES__
 
#ifndef __CONDITIONALMACROS__
#include <ConditionalMacros.h>
#endif
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __MACERRORS__
#include <MacErrors.h>
#endif
 
#ifndef __MACHINEEXCEPTIONS__
#include <MachineExceptions.h>
#endif
 
#ifndef __DEVICES__
#include <Devices.h>
#endif
 
#ifndef __DRIVERSYNCHRONIZATION__
#include <DriverSynchronization.h>
#endif
 
#ifndef __NAMEREGISTRY__
#include <NameRegistry.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 = power
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
  /*******************************************************************
   *
   *      Previously in Kernel.h
   *
   ******************************************************************/
  typedef struct OpaqueIOPreparationID *IOPreparationID;
  typedef struct OpaqueSoftwareInterruptID *SoftwareInterruptID;
  typedef struct OpaqueTaskID *TaskID;
  typedef struct OpaqueTimerID *TimerID;
  typedef UInt32 ExecutionLevel;
  enum
  {
    kTaskLevel = 0,
    kSoftwareInterruptLevel = 1,
    kAcceptFunctionLevel = 2,
    kKernelLevel = 3,
    kSIHAcceptFunctionLevel = 4,
    kSecondaryInterruptLevel = 5,
    kHardwareInterruptLevel = 6,
    kMPTaskLevel = 7
  };
 
  typedef CALLBACK_API_C(void, SoftwareInterruptHandler)(void *p1, void *p2);
  typedef CALLBACK_API_C(OSStatus, SecondaryInterruptHandler2)(void *p1,
                                                               void *p2);
#define kCurrentAddressSpaceID ((AddressSpaceID)-1)
  struct LogicalAddressRange
  {
    LogicalAddress address;
    ByteCount count;
  };
  typedef struct LogicalAddressRange LogicalAddressRange;
  typedef LogicalAddressRange *LogicalAddressRangePtr;
  struct PhysicalAddressRange
  {
    PhysicalAddress address;
    ByteCount count;
  };
  typedef struct PhysicalAddressRange PhysicalAddressRange;
  typedef PhysicalAddressRange *PhysicalAddressRangePtr;
  typedef OptionBits IOPreparationOptions;
  enum
  {
    kIOMultipleRanges = 0x00000001,
    kIOLogicalRanges = 0x00000002,
    kIOMinimalLogicalMapping = 0x00000004,
    kIOShareMappingTables = 0x00000008,
    kIOIsInput = 0x00000010,
    kIOIsOutput = 0x00000020,
    kIOCoherentDataPath = 0x00000040,
    kIOTransferIsLogical = 0x00000080,
    kIOClientIsUserMode = 0x00000080
  };
 
  typedef OptionBits IOPreparationState;
  enum
  {
    kIOStateDone = 0x00000001
  };
 
  enum
  {
    kInvalidPageAddress = (-1)
  };
 
  struct AddressRange
  {
    void *base;
    ByteCount length;
  };
  typedef struct AddressRange AddressRange;
  typedef LogicalAddress *LogicalMappingTablePtr;
  typedef PhysicalAddress *PhysicalMappingTablePtr;
  typedef AddressRange *AddressRangeTablePtr;
  struct MultipleAddressRange
  {
    ItemCount entryCount;
    AddressRangeTablePtr rangeTable;
  };
  typedef struct MultipleAddressRange MultipleAddressRange;
  struct IOPreparationTable
  {
    IOPreparationOptions options;
    IOPreparationState state;
    IOPreparationID preparationID;
    AddressSpaceID addressSpace;
    ByteCount granularity;
    ByteCount firstPrepared;
    ByteCount lengthPrepared;
    ItemCount mappingEntryCount;
    LogicalMappingTablePtr logicalMapping;
    PhysicalMappingTablePtr physicalMapping;
    union
    {
      AddressRange range;
      MultipleAddressRange multipleRanges;
    } rangeInfo;
  };
  typedef struct IOPreparationTable IOPreparationTable;
 
  typedef OptionBits IOCheckpointOptions;
  enum
  {
    kNextIOIsInput = 0x00000001,
    kNextIOIsOutput = 0x00000002,
    kMoreIOTransfers = 0x00000004
  };
 
  typedef UInt32 ProcessorCacheMode;
  enum
  {
    kProcessorCacheModeDefault = 0,
    kProcessorCacheModeInhibited = 1,
    kProcessorCacheModeWriteThrough = 2,
    kProcessorCacheModeCopyBack = 3
  };
 
  enum
  {
    kPageInformationVersion = 1
  };
 
  typedef UInt32 PageStateInformation;
  enum
  {
    kPageIsProtected = 0x00000001,
    kPageIsProtectedPrivileged = 0x00000002,
    kPageIsModified = 0x00000004,
    kPageIsReferenced = 0x00000008,
    kPageIsLockedResident = 0x00000010, 
    kPageIsInMemory = 0x00000020,
    kPageIsShared = 0x00000040,
    kPageIsWriteThroughCached = 0x00000080,
    kPageIsCopyBackCached = 0x00000100,
    kPageIsHeldResident =
        0x00000200,                        
    kPageIsLocked = kPageIsLockedResident, 
    kPageIsResident = kPageIsInMemory      
  };
 
  struct PageInformation
  {
    AreaID area;
    ItemCount count;
    PageStateInformation information[1];
  };
  typedef struct PageInformation PageInformation;
  typedef PageInformation *PageInformationPtr;
 
#if CALL_NOT_IN_CARBON
  ExecutionLevel
  CurrentExecutionLevel(void);
 
  TaskID
  CurrentTaskID(void);
 
  OSStatus
  DelayFor(Duration delayDuration);
 
  Boolean
  InPrivilegedMode(void);
 
  OSStatus
  CreateSoftwareInterrupt(SoftwareInterruptHandler handler, TaskID task, void *p1,
                          Boolean persistent,
                          SoftwareInterruptID *theSoftwareInterrupt);
 
  OSStatus
  SendSoftwareInterrupt(SoftwareInterruptID theSoftwareInterrupt, void *p2);
 
  OSStatus
  DeleteSoftwareInterrupt(SoftwareInterruptID theSoftwareInterrupt);
 
#endif 
#if TARGET_OS_MAC
#if CALL_NOT_IN_CARBON
  OSStatus
  CallSecondaryInterruptHandler2(SecondaryInterruptHandler2 theHandler,
                                 ExceptionHandler exceptionHandler, void *p1,
                                 void *p2);
 
  OSStatus
  QueueSecondaryInterruptHandler(SecondaryInterruptHandler2 theHandler,
                                 ExceptionHandler exceptionHandler, void *p1,
                                 void *p2);
 
#endif 
#endif 
#if CALL_NOT_IN_CARBON
  OSStatus
  SetInterruptTimer(const AbsoluteTime *expirationTime,
                    SecondaryInterruptHandler2 handler, void *p1,
                    TimerID *theTimer);
 
  OSStatus
  SetPersistentTimer(Duration frequency, SecondaryInterruptHandler2 theHandler,
                     void *p1, TimerID *theTimer);
 
  OSStatus
  CancelTimer(TimerID theTimer, AbsoluteTime *timeRemaining);
 
  OSStatus
  PrepareMemoryForIO(IOPreparationTable *theIOPreparationTable);
 
  OSStatus
  CheckpointIO(IOPreparationID theIOPreparation, IOCheckpointOptions options);
 
  OSStatus
  GetPageInformation(AddressSpaceID addressSpace, ConstLogicalAddress base,
                     ByteCount length, PBVersion version,
                     PageInformation *thePageInfo);
 
  OSStatus
  SetProcessorCacheMode(AddressSpaceID addressSpace, ConstLogicalAddress base,
                        ByteCount length, ProcessorCacheMode cacheMode);
 
/*******************************************************************
 *
 *      Was in DriverSupport.h or DriverServices.h
 *
 ******************************************************************/
#define kAAPLDeviceLogicalAddress "AAPL,address"
#endif 
  typedef LogicalAddress *DeviceLogicalAddressPtr;
  enum
  {
    durationMicrosecond = -1L,   
    durationMillisecond = 1L,    
    durationSecond = 1000L,      
    durationMinute = 60000L,     
    durationHour = 3600000L,     
    durationDay = 86400000L,     
    durationNoWait = 0L,         
    durationForever = 0x7FFFFFFF 
  };
 
  enum
  {
    k8BitAccess = 0,  
    k16BitAccess = 1, 
    k32BitAccess = 2  
  };
 
  typedef UnsignedWide Nanoseconds;
 
#if CALL_NOT_IN_CARBON
  OSErr
  IOCommandIsComplete(IOCommandID theID, OSErr theResult);
 
  OSErr
  GetIOCommandInfo(IOCommandID theID, IOCommandContents *theContents,
                   IOCommandCode *theCommand, IOCommandKind *theKind);
 
  void
  UpdateDeviceActivity(RegEntryID *deviceEntry);
 
  void
  BlockCopy(const void *srcPtr, void *destPtr, Size byteCount);
 
  LogicalAddress
  PoolAllocateResident(ByteCount byteSize, Boolean clear);
 
  OSStatus
  PoolDeallocate(LogicalAddress address);
 
  ByteCount
  GetLogicalPageSize(void);
 
  ByteCount
  GetDataCacheLineSize(void);
 
  OSStatus
  FlushProcessorCache(AddressSpaceID spaceID, LogicalAddress base,
                      ByteCount length);
 
  LogicalAddress
  MemAllocatePhysicallyContiguous(ByteCount byteSize, Boolean clear);
 
  OSStatus
  MemDeallocatePhysicallyContiguous(LogicalAddress address);
 
#endif 
  AbsoluteTime
  UpTime(void);
 
#if CALL_NOT_IN_CARBON
  void
  GetTimeBaseInfo(UInt32 *minAbsoluteTimeDelta,
                  UInt32 *theAbsoluteTimeToNanosecondNumerator,
                  UInt32 *theAbsoluteTimeToNanosecondDenominator,
                  UInt32 *theProcessorToAbsoluteTimeNumerator,
                  UInt32 *theProcessorToAbsoluteTimeDenominator);
 
#endif 
  Nanoseconds
  AbsoluteToNanoseconds(AbsoluteTime absoluteTime);
 
  Duration
  AbsoluteToDuration(AbsoluteTime absoluteTime);
 
  AbsoluteTime
  NanosecondsToAbsolute(Nanoseconds nanoseconds);
 
  AbsoluteTime
  DurationToAbsolute(Duration duration);
 
  AbsoluteTime
  AddAbsoluteToAbsolute(AbsoluteTime absoluteTime1, AbsoluteTime absoluteTime2);
 
  AbsoluteTime
  SubAbsoluteFromAbsolute(AbsoluteTime leftAbsoluteTime,
                          AbsoluteTime rightAbsoluteTime);
 
  AbsoluteTime
  AddNanosecondsToAbsolute(Nanoseconds nanoseconds, AbsoluteTime absoluteTime);
 
  AbsoluteTime
  AddDurationToAbsolute(Duration duration, AbsoluteTime absoluteTime);
 
  AbsoluteTime
  SubNanosecondsFromAbsolute(Nanoseconds nanoseconds, AbsoluteTime absoluteTime);
 
  AbsoluteTime
  SubDurationFromAbsolute(Duration duration, AbsoluteTime absoluteTime);
 
  Nanoseconds
  AbsoluteDeltaToNanoseconds(AbsoluteTime leftAbsoluteTime,
                             AbsoluteTime rightAbsoluteTime);
 
  Duration
  AbsoluteDeltaToDuration(AbsoluteTime leftAbsoluteTime,
                          AbsoluteTime rightAbsoluteTime);
 
  Nanoseconds
  DurationToNanoseconds(Duration theDuration);
 
  Duration
  NanosecondsToDuration(Nanoseconds theNanoseconds);
 
#if CALL_NOT_IN_CARBON
  OSErr
  PBQueueInit(QHdrPtr qHeader);
 
  OSErr
  PBQueueCreate(QHdrPtr *qHeader);
 
  OSErr
  PBQueueDelete(QHdrPtr qHeader);
 
  void
  PBEnqueue(QElemPtr qElement, QHdrPtr qHeader);
 
  OSErr
  PBEnqueueLast(QElemPtr qElement, QHdrPtr qHeader);
 
  OSErr
  PBDequeue(QElemPtr qElement, QHdrPtr qHeader);
 
  OSErr
  PBDequeueFirst(QHdrPtr qHeader, QElemPtr *theFirstqElem);
 
  OSErr
  PBDequeueLast(QHdrPtr qHeader, QElemPtr *theLastqElem);
 
  char *
  CStrCopy(char *dst, const char *src);
 
  StringPtr
  PStrCopy(StringPtr dst, ConstStr255Param src);
 
  char *
  CStrNCopy(char *dst, const char *src, UInt32 max);
 
  StringPtr
  PStrNCopy(StringPtr dst, ConstStr255Param src, UInt32 max);
 
  char *
  CStrCat(char *dst, const char *src);
 
  StringPtr
  PStrCat(StringPtr dst, ConstStr255Param src);
 
  char *
  CStrNCat(char *dst, const char *src, UInt32 max);
 
  StringPtr
  PStrNCat(StringPtr dst, ConstStr255Param src, UInt32 max);
 
  void
  PStrToCStr(char *dst, ConstStr255Param src);
 
  void
  CStrToPStr(Str255 dst, const char *src);
 
  SInt16
  CStrCmp(const char *s1, const char *s2);
 
  SInt16
  PStrCmp(ConstStr255Param str1, ConstStr255Param str2);
 
  SInt16
  CStrNCmp(const char *s1, const char *s2, UInt32 max);
 
  SInt16
  PStrNCmp(ConstStr255Param str1, ConstStr255Param str2, UInt32 max);
 
  UInt32
  CStrLen(const char *src);
 
  UInt32
  PStrLen(ConstStr255Param src);
 
  OSStatus
  DeviceProbe(void *theSrc, void *theDest, UInt32 AccessType);
 
  OSStatus
  DelayForHardware(AbsoluteTime absoluteTime);
 
/*******************************************************************
 *
 *      Was in Interrupts.h
 *
 ******************************************************************/
#endif 
  typedef struct OpaqueInterruptSetID *InterruptSetID;
  typedef long InterruptMemberNumber;
  struct InterruptSetMember
  {
    InterruptSetID setID;
    InterruptMemberNumber member;
  };
  typedef struct InterruptSetMember InterruptSetMember;
  enum
  {
    kISTChipInterruptSource = 0,
    kISTOutputDMAInterruptSource = 1,
    kISTInputDMAInterruptSource = 2,
    kISTPropertyMemberCount = 3
  };
 
  typedef InterruptSetMember ISTProperty[3];
#define kISTPropertyName "driver-ist"
 
  typedef long InterruptReturnValue;
  enum
  {
    kFirstMemberNumber = 1,
    kIsrIsComplete = 0,
    kIsrIsNotComplete = -1,
    kMemberNumberParent = -2
  };
 
  typedef Boolean InterruptSourceState;
  enum
  {
    kSourceWasEnabled = true,
    kSourceWasDisabled = false
  };
 
  typedef CALLBACK_API_C(InterruptMemberNumber,
                         InterruptHandler)(InterruptSetMember ISTmember,
                                           void *refCon, UInt32 theIntCount);
  typedef CALLBACK_API_C(void, InterruptEnabler)(InterruptSetMember ISTmember,
                                                 void *refCon);
  typedef CALLBACK_API_C(InterruptSourceState,
                         InterruptDisabler)(InterruptSetMember ISTmember,
                                            void *refCon);
  enum
  {
    kReturnToParentWhenComplete = 0x00000001,
    kReturnToParentWhenNotComplete = 0x00000002
  };
 
  typedef OptionBits InterruptSetOptions;
#if CALL_NOT_IN_CARBON
  OSStatus
  CreateInterruptSet(InterruptSetID parentSet, InterruptMemberNumber parentMember,
                     InterruptMemberNumber setSize, InterruptSetID *setID,
                     InterruptSetOptions options);
 
  OSStatus
  InstallInterruptFunctions(InterruptSetID setID, InterruptMemberNumber member,
                            void *refCon, InterruptHandler handlerFunction,
                            InterruptEnabler enableFunction,
                            InterruptDisabler disableFunction);
 
  OSStatus
  GetInterruptFunctions(InterruptSetID setID, InterruptMemberNumber member,
                        void **refCon, InterruptHandler *handlerFunction,
                        InterruptEnabler *enableFunction,
                        InterruptDisabler *disableFunction);
 
  OSStatus
  ChangeInterruptSetOptions(InterruptSetID setID, InterruptSetOptions options);
 
  OSStatus
  GetInterruptSetOptions(InterruptSetID setID, InterruptSetOptions *options);
 
#endif 
#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