#ifndef __IONDRVLIBRARIES__
#define __IONDRVLIBRARIES__
#include <libkern/OSByteOrder.h>
#include <libkern/OSAtomic.h>
#include <IOKit/ndrvsupport/IOMacOSTypes.h>
#include <IOKit/graphics/IOGraphicsTypes.h>
#ifdef __cplusplus
extern "C" {
#endif
enum {
nrLockedErr = -2536,
nrNotEnoughMemoryErr = -2537,
nrInvalidNodeErr = -2538,
nrNotFoundErr = -2539,
nrNotCreatedErr = -2540,
nrNameErr = -2541,
nrNotSlotDeviceErr = -2542,
nrDataTruncatedErr = -2543,
nrPowerErr = -2544,
nrPowerSwitchAbortErr = -2545,
nrTypeMismatchErr = -2546,
nrNotModifiedErr = -2547,
nrOverrunErr = -2548,
nrResultCodeBase = -2549,
nrPathNotFound = -2550,
nrPathBufferTooSmall = -2551,
nrInvalidEntryIterationOp = -2552,
nrPropertyAlreadyExists = -2553,
nrIterationDone = -2554,
nrExitedIteratorScope = -2555,
nrTransactionAborted = -2556,
gestaltUndefSelectorErr = -5551
};
enum {
kNVRAMProperty = 0x00000020L, };
#ifndef __IONDRV__
enum {
kIONDRVOpenCommand = 128 + 0,
kIONDRVCloseCommand = 128 + 1,
kIONDRVReadCommand = 128 + 2,
kIONDRVWriteCommand = 128 + 3,
kIONDRVControlCommand = 128 + 4,
kIONDRVStatusCommand = 128 + 5,
kIONDRVKillIOCommand = 128 + 6,
kIONDRVInitializeCommand = 128 + 7,
kIONDRVFinalizeCommand = 128 + 8,
kIONDRVReplaceCommand = 128 + 9,
kIONDRVSupersededCommand = 128 + 10
};
enum {
kIONDRVSynchronousIOCommandKind = 0x00000001,
kIONDRVAsynchronousIOCommandKind = 0x00000002,
kIONDRVImmediateIOCommandKind = 0x00000004
};
struct RegEntryID
{
void * opaque[4];
};
typedef struct RegEntryID RegEntryID;
struct IONDRVControlParameters {
UInt8 __reservedA[0x1a];
UInt16 code;
void * params;
UInt8 __reservedB[0x12];
};
struct CntrlParam {
UInt8 __reservedA[0x1a];
short csCode;
short csParam[11];
};
typedef struct CntrlParam CntrlParam;
#endif
typedef RegEntryID * RegEntryIDPtr;
#ifndef __IONDRV__
IOReturn _IONDRVLibrariesInitialize( void * provider );
IOReturn _IONDRVLibrariesFinalize( void * provider );
#endif
#ifndef kAAPLRegEntryIDKey
#define kAAPLRegEntryIDKey "AAPL,RegEntryID"
#endif
UInt32 EndianSwap32Bit( UInt32 data );
UInt16 EndianSwap16Bit( UInt16 data );
void SynchronizeIO(void);
OSErr ExpMgrConfigReadLong(
RegEntryIDPtr node,
LogicalAddress configAddr,
UInt32 * valuePtr);
OSErr ExpMgrConfigWriteLong(
RegEntryIDPtr node,
LogicalAddress configAddr,
UInt32 value);
OSErr ExpMgrConfigReadWord(
RegEntryIDPtr node,
LogicalAddress configAddr,
UInt16 * valuePtr);
OSErr ExpMgrConfigWriteWord(
RegEntryIDPtr node,
LogicalAddress configAddr,
UInt16 value);
OSErr ExpMgrConfigReadByte(
RegEntryIDPtr node,
LogicalAddress configAddr,
UInt8 * valuePtr);
OSErr ExpMgrConfigWriteByte(
RegEntryIDPtr node,
LogicalAddress configAddr,
UInt8 value);
OSErr ExpMgrIOReadLong(
RegEntryIDPtr node,
LogicalAddress ioAddr,
UInt32 * valuePtr);
OSErr ExpMgrIOWriteLong(
RegEntryIDPtr node,
LogicalAddress ioAddr,
UInt32 value);
OSErr ExpMgrIOReadWord(
RegEntryIDPtr node,
LogicalAddress ioAddr,
UInt16 * valuePtr);
OSErr ExpMgrIOWriteWord(
RegEntryIDPtr node,
LogicalAddress ioAddr,
UInt16 value);
OSErr ExpMgrIOReadByte(
RegEntryIDPtr node,
LogicalAddress ioAddr,
UInt8 * valuePtr);
OSErr ExpMgrIOWriteByte(
RegEntryIDPtr node,
LogicalAddress ioAddr,
UInt8 value);
typedef void * RegPropertyValue;
typedef UInt32 RegPropertyValueSize;
enum {
kRegCStrMaxEntryNameLength = 47
};
typedef char RegCStrEntryName;
typedef char * RegCStrEntryNamePtr;
typedef char RegCStrEntryNameBuf[48];
typedef char RegCStrPathName;
typedef UInt32 RegPathNameSize;
enum {
kRegPathNameSeparator = ':',
kRegEntryNameTerminator = 0x00,
kRegPathNameTerminator = 0x00
};
enum {
kRegMaximumPropertyNameLength = 31,
kRegPropertyNameTerminator = 0x00
};
typedef char RegPropertyNameBuf[32];
typedef char RegPropertyName;
typedef char * RegPropertyNamePtr;
enum {
kRegMaxPropertyNameLength = kRegMaximumPropertyNameLength
};
typedef UInt32 RegIterationOp;
typedef RegIterationOp RegEntryIterationOp;
enum {
kRegIterRoot = 0x00000002,
kRegIterParents = 0x00000003,
kRegIterChildren = 0x00000004,
kRegIterSubTrees = 0x00000005,
kRegIterDescendants = 0x00000005,
kRegIterSibling = 0x00000006,
kRegIterContinue = 0x00000001
};
typedef UInt32 RegModifiers;
typedef RegModifiers RegEntryModifiers;
typedef RegModifiers RegPropertyModifiers;
enum {
kRegNoModifiers = 0x00000000,
kRegUniversalModifierMask = 0x0000FFFF,
kRegNameSpaceModifierMask = 0x00FF0000,
kRegModifierMask = (long)0xFF000000
};
enum {
kRegPropertyValueIsSavedToNVRAM = 0x00000020,
kRegPropertyValueIsSavedToDisk = 0x00000040
};
typedef long Size;
#ifndef __IONDRV__
typedef struct _RegEntryIter * RegEntryIter;
typedef struct _RegPropertyIter * RegPropertyIter;
#else
typedef class IORegistryIterator * RegEntryIter;
typedef class OSIterator * RegPropertyIter;
#endif
OSStatus RegistryEntryIDCopy( const RegEntryID * entryID, RegEntryID * to );
OSStatus RegistryEntryIDInit( RegEntryID * entryID );
Boolean RegistryEntryIDCompare( const RegEntryID * id1, const RegEntryID * id2);
OSStatus RegistryPropertyGetSize(
const RegEntryID * entryID,
const RegPropertyName * propertyName,
RegPropertyValueSize * propertySize);
OSStatus RegistryPropertyGet(
const RegEntryID * entryID,
const RegPropertyName * propertyName,
void * propertyValue,
RegPropertyValueSize * propertySize);
OSStatus RegistryPropertyCreate(
const RegEntryID * entryID,
const RegPropertyName * propertyName,
const void * propertyValue,
RegPropertyValueSize propertySize);
OSStatus RegistryPropertyDelete(
const RegEntryID * entryID,
const RegPropertyName * propertyName);
OSStatus RegistryPropertySet(
const RegEntryID * entryID,
const RegPropertyName * propertyName,
const void * propertyValue,
RegPropertyValueSize propertySize);
OSStatus RegistryPropertyGetMod(
const RegEntryID * entry,
const RegPropertyName * name,
RegPropertyModifiers * modifiers);
OSStatus RegistryPropertySetMod(
const RegEntryID * entry,
const RegPropertyName * name,
RegPropertyModifiers modifiers);
OSStatus RegistryPropertyIterateCreate(
const RegEntryID * entry,
RegPropertyIter * cookie);
OSStatus RegistryPropertyIterateDispose( RegPropertyIter * cookie);
OSStatus RegistryPropertyIterate(
RegPropertyIter * cookie,
RegPropertyName * foundProperty,
Boolean * done);
OSStatus RegistryEntryIterateCreate( RegEntryIter * cookie);
OSStatus RegistryEntryIterateDispose( RegEntryIter * cookie);
OSStatus RegistryEntryIterateSet( RegEntryIter * cookie,
const RegEntryID * startEntryID);
OSStatus RegistryEntryIterate( RegEntryIter * cookie,
RegEntryIterationOp relationship,
RegEntryID * foundEntry,
Boolean * done);
OSStatus RegistryCStrEntryToName( const RegEntryID * entryID,
RegEntryID * parentEntry,
RegCStrEntryName * nameComponent,
Boolean * done );
OSStatus RegistryCStrEntryLookup( const RegEntryID * parentEntry,
const RegCStrPathName * path,
RegEntryID * newEntry);
OSStatus RegistryCStrEntryCreate( const RegEntryID * parentEntry,
const RegCStrPathName * name,
RegEntryID * newEntry);
OSStatus RegistryEntryDelete(const RegEntryID * entryID);
OSStatus RegistryEntryIDDispose(RegEntryID * entryID);
OSStatus RegistryEntryCopy(
RegEntryID * parentEntryID,
RegEntryID * sourceDevice,
RegEntryID * destDevice);
OSStatus RegistryEntrySearch(
RegEntryIter * cookie,
RegEntryIterationOp relationship,
RegEntryID * foundEntry,
Boolean * done,
const RegPropertyName * propertyName,
const void * propertyValue,
RegPropertyValueSize propertySize);
OSStatus RegistryEntryToPathSize(
const RegEntryID * entryID,
RegPathNameSize * pathSize);
OSStatus RegistryCStrEntryToPath(
const RegEntryID * entryID,
RegCStrPathName * pathName,
RegPathNameSize pathSize);
OSStatus RegistryPropertyRename(
const RegEntryID * entry,
const RegPropertyName * oldName,
const RegPropertyName * newName);
OSStatus RegistryEntryGetMod(
const RegEntryID * entry,
RegEntryModifiers * modifiers);
OSStatus RegistryEntrySetMod(
const RegEntryID * entry,
RegEntryModifiers modifiers);
OSStatus RegistryEntryMod(
RegEntryIter * cookie,
RegEntryIterationOp relationship,
RegEntryID * foundEntry,
Boolean * done,
RegEntryModifiers matchingModifiers);
OSStatus RegistryEntryPropertyMod(
RegEntryIter * cookie,
RegEntryIterationOp relationship,
RegEntryID * foundEntry,
Boolean * done,
RegPropertyModifiers matchingModifiers);
void SynchronizeIO(void);
Boolean CompareAndSwap(
UInt32 oldVvalue,
UInt32 newValue,
UInt32 * OldValueAdr);
UInt32 CStrLen(const char * src);
char * CStrCopy( char * dst, const char * src);
SInt16 CStrCmp(
const char * s1,
const char * s2);
char * CStrCat(
char * dst,
const char * src);
char * CStrNCopy(
char * dst,
const char * src,
UInt32 max);
SInt16 CStrNCmp(
const char * s1,
const char * s2,
UInt32 max);
char * CStrNCat(
char * dst,
const char * src,
UInt32 max);
void BlockCopy(
const void * srcPtr,
void * destPtr,
Size byteCount);
void BlockMove(
const void * srcPtr,
void * destPtr,
Size byteCount);
void BlockMoveData(
const void * srcPtr,
void * destPtr,
Size byteCount);
void BlockMoveDataUncached(
const void * srcPtr,
void * destPtr,
Size byteCount);
void BlockMoveUncached(
const void * srcPtr,
void * destPtr,
Size byteCount);
void BlockZero(
const void * srcPtr,
Size byteCount);
void BlockZeroUncached(
const void * srcPtr,
Size byteCount);
char * PStrCopy( char *to, const char *from );
void PStrToCStr( char *to, const char *from );
void CStrToPStr( char *to, const char *from );
LogicalAddress PoolAllocateResident(ByteCount byteSize, Boolean clear);
OSStatus PoolDeallocate( LogicalAddress address );
UInt32 CurrentExecutionLevel(void);
UnsignedWide UpTime( void );
UnsignedWide AddAbsoluteToAbsolute(UnsignedWide left, UnsignedWide right);
UnsignedWide SubAbsoluteFromAbsolute(UnsignedWide left, UnsignedWide right);
UnsignedWide DurationToAbsolute( Duration theDuration);
UnsignedWide AddDurationToAbsolute( Duration duration, UnsignedWide absolute );
UnsignedWide NanosecondsToAbsolute ( UnsignedWide theNanoseconds);
UnsignedWide AbsoluteToNanoseconds( UnsignedWide absolute );
Duration AbsoluteDeltaToDuration( UnsignedWide left, UnsignedWide right );
Duration AbsoluteToDuration( UnsignedWide result );
OSStatus DelayForHardware( UnsignedWide time );
OSStatus DelayUntil( UnsignedWide time );
OSStatus DelayFor( Duration theDuration );
void SysDebugStr( const char * from );
void SysDebug( void );
enum {
paramErr = -50,
noHardwareErr = -200,
notEnoughHardwareErr = -201,
userCanceledErr = -128,
qErr = -1,
vTypErr = -2,
corErr = -3,
unimpErr = -4,
SlpTypeErr = -5,
seNoDB = -8,
controlErr = -17,
statusErr = -18,
readErr = -19,
writErr = -20,
badUnitErr = -21,
unitEmptyErr = -22,
openErr = -23,
closErr = -24,
dRemovErr = -25,
dInstErr = -26,
badCksmErr = -69,
};
enum {
durationMicrosecond = -1L,
durationMillisecond = 1L,
durationSecond = 1000L,
durationMinute = 60000L,
durationHour = 3600000L,
durationDay = 86400000L,
durationNoWait = 0L,
durationForever = 0x7FFFFFFF
};
#ifndef NULL
#if !defined(__cplusplus) && (defined(__SC__) || defined(THINK_C))
#define NULL ((void *) 0)
#else
#define NULL 0L
#endif
#endif
#ifndef nil
#define nil NULL
#endif
typedef ResType VSLGestaltType;
typedef ResType InterruptServiceType;
typedef struct ColorSpec ColorSpec;
typedef ColorSpec * ColorSpecPtr;
typedef ColorSpec CSpecArray[1];
struct ColorTable {
long ctSeed;
short ctFlags;
short ctSize;
CSpecArray ctTable;
};
typedef struct ColorTable ColorTable;
typedef ColorTable * CTabPtr;
enum {
clutType = 0,
fixedType = 1,
directType = 2,
RGBDirect = 16
};
typedef UInt32 * UInt32Ptr;
#ifndef _IOKIT_IOFRAMEBUFFER_H
enum {
kHardwareCursorInfoMajorVersion = 0x0001,
kHardwareCursorInfoMinorVersion = 0x0000
};
struct HardwareCursorDescriptorRec {
UInt16 majorVersion;
UInt16 minorVersion;
UInt32 height;
UInt32 width;
UInt32 bitDepth;
UInt32 maskBitDepth;
UInt32 numColors;
UInt32Ptr colorEncodings;
UInt32 flags;
UInt32 supportedSpecialEncodings;
UInt32 specialEncodings[16];
};
typedef struct HardwareCursorDescriptorRec HardwareCursorDescriptorRec;
#else
typedef struct IOHardwareCursorDescriptor HardwareCursorDescriptorRec;
#endif
typedef HardwareCursorDescriptorRec * HardwareCursorDescriptorPtr;
#ifndef _IOKIT_IOFRAMEBUFFER_H
struct HardwareCursorInfoRec {
UInt16 majorVersion;
UInt16 minorVersion;
UInt32 cursorHeight;
UInt32 cursorWidth;
CTabPtr colorMap;
Ptr hardwareCursor;
UInt16 cursorHotSpotX;
UInt16 cursorHotSpotY;
UInt32 reserved[5];
};
typedef struct HardwareCursorInfoRec HardwareCursorInfoRec;
#else
typedef struct IOHardwareCursorInfo HardwareCursorInfoRec;
#endif
typedef HardwareCursorInfoRec * HardwareCursorInfoPtr;
typedef ResType InterruptServiceType;
#ifndef __IONDRV__
typedef UInt32 InterruptServiceIDType;
#else
typedef struct _VSLService * InterruptServiceIDType;
#endif
typedef InterruptServiceIDType * InterruptServiceIDPtr;
enum {
kVBLInterruptServiceType = 'vbl ',
kHBLInterruptServiceType = 'hbl ',
kFrameInterruptServiceType = 'fram',
kConnectInterruptServiceType = 'dci ',
kFBConnectInterruptServiceType = kConnectInterruptServiceType,
kFBChangedInterruptServiceType = 'chng',
kFBOfflineInterruptServiceType = 'remv',
kFBOnlineInterruptServiceType = 'add '
};
enum {
kVSLClamshellStateGestaltType = 'clam',
};
OSStatus
VSLGestalt( VSLGestaltType selector, UInt32 * response );
OSStatus
VSLSetDisplayConfiguration(RegEntryID * entryID,
char * propertyName,
void * configData,
long configDataSize);
OSErr
VSLNewInterruptService(
RegEntryID * serviceDevice,
InterruptServiceType serviceType,
InterruptServiceIDPtr serviceID);
OSErr
VSLWaitOnInterruptService(
InterruptServiceIDType serviceID,
Duration timeout);
OSErr
VSLDisposeInterruptService(InterruptServiceIDType serviceID);
OSErr
VSLDoInterruptService(InterruptServiceIDType serviceID);
Boolean
VSLPrepareCursorForHardwareCursor(
void * cursorRef,
HardwareCursorDescriptorPtr hardwareDescriptor,
HardwareCursorInfoPtr hwCursorInfo);
typedef UnsignedWide Nanoseconds;
enum {
developStage = 0x20,
alphaStage = 0x40,
betaStage = 0x60,
finalStage = 0x80
};
typedef struct OpaqueIOCommandID* IOCommandID;
typedef SInt16 DriverRefNum;
typedef UInt32 IOCommandKind;
typedef UInt32 IOCommandCode;
#ifndef __IONDRV__
enum {
kSynchronousIOCommandKind = 0x00000001,
kAsynchronousIOCommandKind = 0x00000002,
kImmediateIOCommandKind = 0x00000004
};
enum {
kOpenCommand = 0,
kCloseCommand = 1,
kReadCommand = 2,
kWriteCommand = 3,
kControlCommand = 4,
kStatusCommand = 5,
kKillIOCommand = 6,
kInitializeCommand = 7, kFinalizeCommand = 8, kReplaceCommand = 9, kSupersededCommand = 10, kSuspendCommand = 11, kResumeCommand = 12 };
struct DriverInitInfo {
DriverRefNum refNum;
RegEntryID deviceEntry;
};
typedef struct DriverInitInfo DriverInitInfo;
#endif
typedef DriverInitInfo * DriverInitInfoPtr;
typedef DriverInitInfo DriverReplaceInfo;
typedef DriverInitInfo * DriverReplaceInfoPtr;
struct DriverFinalInfo {
DriverRefNum refNum;
RegEntryID deviceEntry;
};
typedef struct DriverFinalInfo DriverFinalInfo;
typedef DriverFinalInfo * DriverFinalInfoPtr;
typedef DriverFinalInfo DriverSupersededInfo;
typedef DriverFinalInfo * DriverSupersededInfoPtr;
union ParamBlockRec;
typedef union ParamBlockRec ParamBlockRec;
typedef ParamBlockRec *ParmBlkPtr;
union IOCommandContents {
ParmBlkPtr pb;
DriverInitInfoPtr initialInfo;
DriverFinalInfoPtr finalInfo;
DriverReplaceInfoPtr replaceInfo;
DriverSupersededInfoPtr supersededInfo;
};
typedef union IOCommandContents IOCommandContents;
OSErr IOCommandIsComplete( IOCommandID commandID, OSErr result);
#ifndef __IONDRV__
typedef struct OpaqueInterruptSetID* InterruptSetID;
#else
typedef class IONDRVInterruptSet * InterruptSetID;
#endif
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 InterruptMemberNumber (*InterruptHandler) (InterruptSetMember ISTmember, void *refCon, UInt32 theIntCount);
typedef void (*InterruptEnabler) (InterruptSetMember ISTmember, void *refCon);
typedef InterruptSourceState (*InterruptDisabler)(InterruptSetMember ISTmember, void *refCon);
enum {
kReturnToParentWhenComplete = 0x00000001,
kReturnToParentWhenNotComplete = 0x00000002
};
typedef OptionBits InterruptSetOptions;
OSStatus GetInterruptFunctions(
InterruptSetID setID,
InterruptMemberNumber member,
void ** refCon,
InterruptHandler * handlerFunction,
InterruptEnabler * enableFunction,
InterruptDisabler * disableFunction);
OSStatus InstallInterruptFunctions(
InterruptSetID setID,
InterruptMemberNumber member,
void * refCon,
InterruptHandler handlerFunction,
InterruptEnabler enableFunction,
InterruptDisabler disableFunction);
OSStatus CreateInterruptSet(
InterruptSetID parentSet,
InterruptMemberNumber parentMember,
InterruptMemberNumber setSize,
InterruptSetID * setID,
InterruptSetOptions options);
OSStatus DeleteInterruptSet( InterruptSetID setID );
#ifdef __cplusplus
}
#endif
#endif