PCCard.h

Go to the documentation of this file.

 
#ifndef __PCCARD__
#define __PCCARD__
 
#ifndef __MACTYPES__
#include <MacTypes.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 = power
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
  enum
  {
    kServiceCategoryPCCard = FOUR_CHAR_CODE('pccd')
  };
 
  typedef UInt32 PCCardEvent;
  typedef UInt32 PCCardEventMask;
  typedef UInt32 PCCardClientID;
  typedef UInt32 PCCardTimerID;
  typedef UInt32 PCCardSocket;
  typedef UInt32 PCCardWindowID;
  typedef UInt32 PCCardWindowType;
  typedef UInt32 PCCardWindowSize;
  typedef UInt32 PCCardWindowOffset;
  typedef UInt32 PCCardWindowAlign;
  typedef OptionBits PCCardWindowState;
  typedef UInt32 PCCardAccessSpeed;
  typedef UInt32 PCCardWindowParam;
  typedef UInt32 PCCardPage;
  typedef UInt32 PCCardVoltage;
  /* Client notification bit flags */
  enum
  {
    kPCCardNullMessage =
        0x00000000, /* no messages pending (not sent to clients)*/
    kPCCardInsertionMessage =
        0x00000001,                     /* card has been inserted into the socket*/
    kPCCardRemovalMessage = 0x00000002, /* card has been removed from the socket-
                                           do not touch hardware!*/
    /* Lock and Unlock may be used for a hardware locking card-cage. */
    kPCCardLockMessage =
        0x00000004, /* card is locked into the socket with a mechanical latch */
    kPCCardUnlockMessage =
        0x00000008, /* card is no longer locked into the socket */
    /* Ready and Reset are holdovers from PC Card 2.x, but someone might be using
       them (!?) */
    kPCCardReadyMessage =
        0x00000010, /* card is ready to be accessed -- do not use! this event is
                       never sent! (use kPCCardInsertion instead) */
    kPCCardResetMessage =
        0x00000020, /* physical reset has completed -- do not use! this event is
                       never sent! (use kPCCardResetComplete instead) */
    /* InsertionRequest and InsertionComplete may be used with certain cages (??)
     */
    kPCCardInsertionRequestMessage =
        0x00000040, /* request to insert a card using insertion motor */
    kPCCardInsertionCompleteMessage =
        0x00000080, /* insertion motor has finished inserting a card */
    kPCCardEjectionRequestMessage =
        0x00000100, /* user or other client is requesting a card ejection*/
    kPCCardEjectionCompleteMessage =
        0x00000200, /* card ejection succeeded- do not touch hardware! */
    kPCCardEjectionFailedMessage =
        0x00000400,                       /* eject failure due to electrical/mechanical problems*/
    kPCCardPMResumeMessage = 0x00000800,  /* power management resume */
    kPCCardPMSuspendMessage = 0x00001000, /* power management suspend */
    kPCCardPMSuspendRequest = 0x00002000, /* power management sleep request */
    kPCCardPMSuspendRevoke = 0x00004000,  /* power management sleep revoke */
    kPCCardResetPhysicalMessage =
        0x00008000, /* physical reset is about to occur on this card -- this event
                       is never sent! */
    kPCCardResetRequestMessage =
        0x00010000, /* physical reset has been requested by a client*/
    kPCCardResetCompleteMessage =
        0x00020000, /* ResetCard() background reset has completed*/
    kPCCardBatteryDeadMessage =
        0x00040000, /* battery is no longer useable, data will be lost*/
    kPCCardBatteryLowMessage =
        0x00080000,                          /* battery is weak and should be replaced*/
    kPCCardWriteProtectMessage = 0x00100000, /* card is now write protected*/
    kPCCardWriteEnabledMessage = 0x00200000, /* card is now write enabled*/
    kPCCardDisplayEjectDSATMessage =
        0x00400000, /* about to display a DSAT for the user to re-insert a
                       manually ejected card */
    kPCCardUnexpectedRemovalMessage =
        0x02000000, /* card has unexpectedly been manually ejected */
    /* Unconfigured is a (currently unused) holdover from PC Card 2.x */
    kPCCardUnconfiguredMessage =
        0x04000000, /* a CARD_READY was delivered to all clients and no client */
    /*    requested a configuration for the socket -- this event is never sent
       under PCCard 3.0! */
    kPCCardStatusChangedMessage =
        0x08000000, /* status change for cards in I/O mode*/
    kPCCardTimerExpiredMessage =
        0x10000000, /* message sent when requested time has expired */
    kPCCardRequestAttentionMessage = 0x20000000,
    kPCCardEraseCompleteMessage = 0x40000000,
    kPCCardRegistrationCompleteMessage =
        (long)0x80000000, /* notifications available only in PCCard 3.1 and later
                           */
    kPCCardPMEnabledMessage =
        0x00800000 /* power management has been enabled by the user; if
                      appropriate, clients should call PCCardSetPowerLevel(off) */
  };
 
  typedef OptionBits PCCardWindowAttributes;
  /*  window state (values of PCCardWindowAttributes) */
  enum
  {
    kWSCommon = 0x0001,       /* common memory window */
    kWSAttribute = 0x0002,    /* attribute memory window*/
    kWSIO = 0x0004,           /* I/O window*/
    kWSCardBus = 0x0800,      /* CardBus bridge window */
    kWSTypeMask = 0x0807,     /* window type mask*/
    kWSEnabled = 0x0008,      /* window enabled*/
    kWS8bit = 0x0010,         /* 8-bit data width window*/
    kWS16bit = 0x0020,        /* 16-bit data width window*/
    kWS32bit = 0x0040,        /* 32-bit data width window*/
    kWSAutoSize = 0x0080,     /* auto-size data width window*/
    kWSWidthMask = 0x00F0,    /* window data width mask*/
    kWSProtected = 0x0100,    /* window write protected*/
    kWSPrefetchable = 0x0200, /* bridge window prefetchable*/
    kWSPageShared = 0x0400,   /* page register is shared*/
    kWSWindowSizeOffset = 0x4000,
    kWSChangeAccessSpeed = 0x8000 /* Used by CSModifyWindow only */
  };
 
  /* window speed (sample values of PCCardAccessSpeed) for use in
   * PCCardRequestWindow  */
  enum
  {
    kAccessSpeed600ns = 0x006A,
    kAccessSpeed500ns = 0x005A,
    kAccessSpeed400ns = 0x004A,
    kAccessSpeed300ns = 0x003A,
    kAccessSpeed250ns = 0x0001,
    kAccessSpeed200ns = 0x0002,
    kAccessSpeed150ns = 0x0003,
    kAccessSpeed100ns = 0x0004
  };
 
  typedef UInt32 PCCardInterfaceType;
  /* InterfaceType bit-mask (values of PCCardInterfaceType) */
  enum
  {
    kIFTypeMask = 0x03, /* IO & memory type mask*/
    kIFCardBus = 0x00,  /* if bits 0 & 1 are zero then cardbus interface*/
    kIFMemory = 0x01,   /* if bit 0 set memory IF*/
    kIFIO = 0x02,       /* if bit 1 set IO IF*/
    kIFReserved = 0x03, /* bits 0 and 1 set is reserved */
    kIFDMA = 0x08,      /* if bit 3 set DMA supported*/
    kIFVSKey = 0x10,    /* if bit 4 set supports low Voltage key*/
    kIF33VCC = 0x20,    /* if bit 5 set socket suports 3.3v*/
    kIFXXVCC = 0x40,    /* if bit 6 set socket supports X.X voltage*/
    kIFYYVCC = 0x80     /* if bit 7 set socket supports Y.Y voltage*/
  };
 
  typedef UInt32 PCCardCustomInterfaceID;
  /* Custom Interface Identifiers (values of PCCardCustomInterfaceID) */
  enum
  {
    kIFCustom_None = 0x00, /* no custom interface ID */
    kIFCustom_ZOOM = 0x41  /* ZOOM Video Mode custom interface identifier */
  };
 
  typedef OptionBits PCCardConfigOptions;
  /* Bit mask values for PCCardConfigOptions in the configuration calls */
  enum
  {
    kEnableIRQSteering = 0x0002,
    kIRQChangeValid = 0x0004,
    kVppChangeValid = 0x0010,
    kEnableDMAChannel = 0x0040,
    kDMAChangeValid = 0x0080,
    kVSOverride = 0x0200 /* Bits 10..31 reserved */
  };
 
  enum
  {
    kConfigOptionPresent = 0x00000001,
    kConfigStatusPresent = 0x00000002,
    kPinReplacePresent = 0x00000004,
    kSocketCopyPresent = 0x00000008,
    kExtendedStatusPresent = 0x00000010,
    kIOBase0Present = 0x00000020,
    kIOBase1Present = 0x00000040,
    kIOBase2Present = 0x00000080,
    kIOBase3Present = 0x00000100,
    kIOLimitPresent = 0x00000200
  };
 
  typedef UInt32 PCCardConfigPresentMask;
  typedef UInt32 PCCardConfigRegisterIndex;
  typedef UInt32 PCCardConfigRegisterOffset;
  struct PCCardFunctionConfigReg
  {
    Byte configOptionReg;
    Byte configStatusReg;
    Byte pinReplaceReg;
    Byte socketCopyReg;
    Byte extendedStatusReg;
    Byte ioBase0;
    Byte ioBase1;
    Byte ioBase2;
    Byte ioBase3;
    Byte ioLimit;
  };
  typedef struct PCCardFunctionConfigReg PCCardFunctionConfigReg;
 
  typedef OptionBits PCCardSocketStatus;
  /*  general socket status bits (values of PCCardSocketStatus) */
  enum
  {
    kSTBatteryDead = 0x0001,  /* battery dead*/
    kSTBatteryLow = 0x0002,   /* battery low*/
    kSTBatteryGood = 0x0004,  /* battery good*/
    kSTPower = 0x0008,        /* power is applied*/
    kST16bit = 0x0010,        /* 16-bit PC Card present*/
    kSTCardBus = 0x0020,      /* CardBus PC Card present*/
    kSTMemoryCard = 0x0040,   /* memory card present*/
    kSTIOCard = 0x0080,       /* I/O card present*/
    kSTNotACard = 0x0100,     /* unrecognizable PC Card detected*/
    kSTReady = 0x0200,        /* ready*/
    kSTWriteProtect = 0x0400, /* card is write-protected*/
    kSTDataLost = 0x0800,     /* data may have been lost due to card removal*/
    kSTRingIndicate = 0x1000, /* ring indicator is active*/
    kSTReserved = 0xE000
  };
 
  /* Bit mask for PCCardPowerOptions in the power management calls */
  typedef OptionBits PCCardPowerOptions;
  enum
  {
    kPCCardPowerOn = 0x00000001,
    kPCCardPowerOff = 0x00000002,
    kPCCardLowPower = 0x00000004
  };
 
  typedef OptionBits PCCardAdapterCapabilities;
  typedef UInt32 PCCardAdapterPowerState;
  typedef OptionBits PCCardSCEvents;
  typedef UInt32 PCCardWindow;
  typedef UInt32 PCCardIRQ;
  typedef UInt32 PCCardDMA;
  /* Selectors for PCCardGetGlobalOptions */
  /*  The type of the "value" parameter is provided for each selector. */
  typedef UInt32 PCCardOptionSelector;
  enum
  {
    kPCCardPowerManagementAttrib = 1 /* value = (Boolean*) enabled  */
  };
 
  /* Types and structures for accessing the PCCard Assigned-Address property.*/
 
#define kPCCardAssignedAddressProperty "assigned-addresses"
  enum
  {
    kPCCardNonRelocatableSpace = 0x80,
    kPCCardPrefetchableSpace = 0x40,
    kPCCard16BitSpace = 0x20,
    kPCCardAddressTypeCodeMask = 0x07,
    kPCCardConfigSpace = 0,
    kPCCardIOSpace = 1,
    kPCCardMemorySpace = 2,
    kPCCardAttributeMemorySpace = 4
  };
 
  typedef UInt8 PCCardAddressSpaceFlags;
  enum
  {
    kPCCardSocketNumberMask = 0xF8,
    kPCCardFunctionNumberMask = 0x07
  };
 
  typedef UInt8 PCCardSocketFunction;
  typedef UInt8 PCCardBusNumber;
  typedef UInt8 PCCardRegisterNumber;
  struct PCCardAssignedAddress
  {
    PCCardAddressSpaceFlags addressSpaceFlags;
    UInt8 reserved;
    PCCardSocketFunction socketFunctionNumber;
    PCCardRegisterNumber registerNumber;
    UInt32 address;
    UInt32 size;
  };
  typedef struct PCCardAssignedAddress PCCardAssignedAddress;
  typedef PCCardAssignedAddress *PCCardAssignedAddressPtr;
#define GetPCCardIsNonRelocatable(AssignedAddressPtr) \
  ((AssignedAddressPtr)->addressSpaceFlags & kPCCardNonRelocatableSpace)
#define GetPCCardIsPrefetchable(AssignedAddressPtr) \
  ((AssignedAddressPtr)->addressSpaceFlags & kPCCardPrefetchableSpace)
#define GetPCCardIs16BitSpace(AssignedAddressPtr) \
  ((AssignedAddressPtr)->addressSpaceFlags & kPCCard16BitSpace)
#define GetPCCardAddressSpaceType(AssignedAddressPtr) \
  ((AssignedAddressPtr)->addressSpaceFlags & kPCCardAddressTypeCodeMask)
#define GetPCCardSocketNumber(AssignedAddressPtr) \
  (((AssignedAddressPtr)->socketFunctionNumber & kPCCardSocketNumberMask) >> 3)
#define GetPCCardFunctionNumber(AssignedAddressPtr) \
  ((AssignedAddressPtr)->socketFunctionNumber & kPCCardFunctionNumberMask)
#define GetPCCardRegisterNumber(AssignedAddressPtr) \
  ((AssignedAddressPtr)->registerNumber)
  /*----------------------------------------------------------------------
      Client Support
  ----------------------------------------------------------------------*/
  /* Prototype for client callback */
  typedef CALLBACK_API_C(OSStatus,
                         PCCardEventHandler)(PCCardEvent theEvent,
                                             PCCardSocket vSocket, UInt32 device,
                                             UInt32 info, UInt32 MTDRequest,
                                             UInt32 *Buffer, UInt32 misc,
                                             UInt32 status, void *clientParam);
#if CALL_NOT_IN_CARBON
  OSStatus
  PCCardRegisterClient(const RegEntryID *deviceRef, PCCardEventMask eventMask,
                       PCCardEventHandler clientCallBack, void *clientParam,
                       PCCardClientID *newClientID);
 
  OSStatus
  PCCardDeRegisterClient(PCCardClientID theClientID);
 
  OSStatus
  PCCardRegisterTimer(PCCardClientID registeredClientID,
                      PCCardTimerID *lpNewTimerID, long delay);
 
  void
  PCCardDeRegisterTimer(PCCardTimerID timerID);
 
  OSStatus
  PCCardSetEventMask(PCCardClientID theClientID, PCCardEventMask newEventMask);
 
  OSStatus
  PCCardGetEventMask(PCCardClientID theClientID, PCCardEventMask *newEventMask);
 
  OSStatus
  PCCardGetCardServicesInfo(ItemCount *socketCount, UInt32 *complianceLevel,
                            UInt32 *version);
 
  OSStatus
  PCCardGetSocketRef(PCCardSocket vSocket, RegEntryID *socketRef);
 
  OSStatus
  PCCardGetCardRef(PCCardSocket vSocket, RegEntryID *cardRef);
 
  OSStatus
  PCCardGetDeviceRef(PCCardSocket vSocket, UInt32 device, RegEntryID *deviceRef);
 
  OSStatus
  PCCardGetSocketAndDeviceFromDeviceRef(const RegEntryID *deviceRef,
                                        PCCardSocket *vSocket, UInt32 *device);
 
  OSStatus
  PCCardGetCardRefFromDeviceRef(const RegEntryID *deviceRef, RegEntryID *cardRef);
 
  /*----------------------------------------------------------------------
      Resource Management
  ----------------------------------------------------------------------*/
  OSStatus
  PCCardRequestWindow(const RegEntryID *deviceRef,
                      PCCardWindowAttributes windowAttributes,
                      LogicalAddress *windowBase, ByteCount *windowSize,
                      PCCardAccessSpeed *windowSpeed,
                      PCCardWindowOffset *windowOffset, PCCardWindowID *windowID);
 
  OSStatus
  PCCardModifyWindow(PCCardWindowID windowID,
                     PCCardWindowAttributes windowAttributes,
                     PCCardAccessSpeed windowSpeed,
                     PCCardWindowOffset windowOffset);
 
  OSStatus
  PCCardReleaseWindow(PCCardWindowID windowID);
 
  OSStatus
  PCCardInquireWindow(const RegEntryID *deviceRef, PCCardWindowID windowID,
                      PCCardWindowAttributes *windowAttributes,
                      LogicalAddress *windowBase, ByteCount *windowSize,
                      PCCardAccessSpeed *windowSpeed,
                      PCCardWindowOffset *windowOffset);
 
  OSStatus
  PCCardGetStatus(const RegEntryID *deviceRef, UInt32 *currentState,
                  UInt32 *changedState, PCCardVoltage *Vcc, PCCardVoltage *Vpp);
 
  OSStatus
  PCCardRequestConfiguration(const RegEntryID *deviceRef,
                             PCCardConfigOptions configOptions,
                             PCCardInterfaceType ifType,
                             PCCardCustomInterfaceID ifCustomType,
                             PCCardVoltage vcc, PCCardVoltage vpp,
                             LogicalAddress configRegistersBase,
                             PCCardConfigPresentMask configRegistersPresent,
                             PCCardFunctionConfigReg *configRegisterValues);
 
  OSStatus
  PCCardReleaseConfiguration(const RegEntryID *deviceRef);
 
  OSStatus
  PCCardModifyConfiguration(const RegEntryID *deviceRef,
                            PCCardConfigOptions configOptions, PCCardVoltage vpp);
 
  OSStatus
  PCCardReadConfigurationRegister(const RegEntryID *deviceRef,
                                  PCCardConfigRegisterIndex whichRegister,
                                  PCCardConfigRegisterOffset offset,
                                  UInt8 *value);
 
  OSStatus
  PCCardWriteConfigurationRegister(const RegEntryID *deviceRef,
                                   PCCardConfigRegisterIndex whichRegister,
                                   PCCardConfigRegisterOffset offset,
                                   UInt8 value);
 
  OSStatus
  PCCardResetFunction(const RegEntryID *deviceRef);
 
/*----------------------------------------------------------------------
    Client Utilities
----------------------------------------------------------------------*/
#endif /* CALL_NOT_IN_CARBON */
 
  typedef UInt8 PCCardTupleKind;
  typedef struct OpaquePCCardTupleIterator *PCCardTupleIterator;
#if CALL_NOT_IN_CARBON
  PCCardTupleIterator
  PCCardNewTupleIterator(void);
 
  OSStatus
  PCCardDisposeTupleIterator(PCCardTupleIterator tupleIterator);
 
  OSStatus
  PCCardGetFirstTuple(const RegEntryID *deviceID, PCCardTupleKind desiredTuple,
                      PCCardTupleIterator tupleIterator, void *dataBuffer,
                      UInt32 *dataBufferSize, PCCardTupleKind *foundTuple,
                      UInt32 *foundTupleDataSize);
 
  OSStatus
  PCCardGetNextTuple(const RegEntryID *deviceRef, PCCardTupleKind desiredTuple,
                     PCCardTupleIterator tupleIterator, void *dataBuffer,
                     UInt32 *dataBufferSize, PCCardTupleKind *foundTuple,
                     UInt32 *foundTupleDataSize);
 
  /*----------------------------------------------------------------------
      Miscellaneous
  ----------------------------------------------------------------------*/
  OSStatus
  PCCardEject(const RegEntryID *cardRef);
 
  OSStatus
  PCCardEnableModemSound(const RegEntryID *cardRef, Boolean enableSound);
 
  OSStatus
  PCCardEnableZoomedVideo(const RegEntryID *cardRef, Boolean enableZoomedVideo);
 
  OSStatus
  PCCardEnableZoomedVideoSound(const RegEntryID *cardRef, Boolean enableSound);
 
  OSStatus
  PCCardSetPowerLevel(const RegEntryID *deviceRef, PCCardPowerOptions powerLevel);
 
  OSStatus
  PCCardSetRingIndicate(const RegEntryID *deviceRef, Boolean setRingIndicate);
 
  OSStatus
  PCCardGetGlobalOptions(PCCardOptionSelector selector, void *value);
 
#endif /* CALL_NOT_IN_CARBON */
 
  typedef UInt32 PCCardDevType;
  typedef UInt32 PCCardSubType;
  /* values for PCCardType and PCCardSubType*/
  enum
  {
    kPCCardUnknownType = 0,
    kPCCardMultiFunctionType = 1,
    kPCCardMemoryType = 2,
    kPCCardNullSubType = 0, /* Memory sub types */
    kPCCardRomSubType = 1,
    kPCCardOTPromSubType = 2,
    kPCCardEpromSubType = 3,
    kPCCardEEpromSubType = 4,
    kPCCardFlashSubType = 5,
    kPCCardSramSubType = 6,
    kPCCardDramSubType = 7,
    kPCCardSerialPortType = 3,
    kPCCardSerialOnlySubType = 0,
    kPCCardDataModemSubType = 1,
    kPCCardFaxModemSubType = 2,
    kPCCardFaxAndDataModemMask =
        (kPCCardDataModemSubType | kPCCardFaxModemSubType),
    kPCCardVoiceEncodingSubType = 4,
    kPCCardParallelPortType = 4,
    kPCCardFixedDiskType = 5,
    kPCCardUnknownFixedDiskType = 0,
    kPCCardATAInterfaceDiskSubType = 1,
    kPCCardRotatingDeviceSubType = (0 << 7),
    kPCCardSiliconDevice = (1 << 7),
    kPCCardVideoAdaptorType = 6,
    kPCCardNetworkAdaptorType = 7,
    kPCCardArcNetSubType = 1, /* network sub types */
    kPCCardEthernetSubType = 2,
    kPCCardTokenRingSubType = 3,
    kPCCardLocalTalkSubType = 4,
    kPCCardFDDI_CDDISubType = 5,
    kPCCardATMSubType = 6,
    kPCCardWirelessSubType = 7,
    kPCCardAIMSType = 8,
    kPCCardSCSIType = 9,
    kPCCardSerialBusType = 10,
    kPCCardUSBBusSubType = 1,
    kPCCardFirewireBusSubType = 2
  };
 
#if CALL_NOT_IN_CARBON
  OSStatus
  PCCardGetCardInfo(const RegEntryID *cardRef, PCCardDevType *cardType,
                    PCCardSubType *cardSubType, StringPtr cardName,
                    StringPtr vendorName);
 
#endif /* CALL_NOT_IN_CARBON */
 
  enum
  {
    kPCCard16HardwareType = FOUR_CHAR_CODE('pc16'),
    kCardBusHardwareType = FOUR_CHAR_CODE('cdbs')
  };
 
  typedef UInt32 PCCardHardwareType;
#if CALL_NOT_IN_CARBON
  OSStatus
  PCCardGetCardType(const RegEntryID *socketRef, PCCardHardwareType *cardType);
 
#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 /* __PCCARD__ */