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

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

多媒体编程

开发平台：

Visual C++

CardServices.h：源码内容
  1. /*
  2.      File:       CardServices.h
  3.  
  4.      Contains:   The client interface to Card and Socket Services.
  5.  
  6.      Version:    Technology: System 7.5
  7.                  Release:    QuickTime 6.0.2
  8.  
  9.      Copyright:  (c) 1994-2001 by Apple Computer, Inc. All rights reserved.
  10.  
  11.      Bugs?:      For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. */
  17. #ifndef __CARDSERVICES__
  18. #define __CARDSERVICES__
  20. #ifndef __MACTYPES__
  21. #include "MacTypes.h"
  22. #endif
  24. #ifndef __PCCARDTUPLES__
  25. #include "PCCardTuples.h"
  26. #endif
  28. #ifndef __MIXEDMODE__
  29. #include "MixedMode.h"
  30. #endif
  35. #if PRAGMA_ONCE
  36. #pragma once
  37. #endif
  39. #ifdef __cplusplus
  40. extern "C" {
  41. #endif
  43. #if PRAGMA_IMPORT
  44. #pragma import on
  45. #endif
  47. #if PRAGMA_STRUCT_ALIGN
  48.     #pragma options align=mac68k
  49. #elif PRAGMA_STRUCT_PACKPUSH
  50.     #pragma pack(push, 2)
  51. #elif PRAGMA_STRUCT_PACK
  52.     #pragma pack(2)
  53. #endif
  55. /*  miscellaneous*/
  57. enum {
  58.     CS_MAX_SOCKETS              = 32                            /* a long is used as a socket bitmap*/
  59. };
  62. /* Will move to <Traps.h>*/
  63. enum {
  64.     _PCCardDispatch             = 0xAAF0                        /* Card Services entry trap*/
  65. };
  67. /* Will move to <Errors.h>*/
  69. /*  result codes*/
  71. enum {
  72.     kCSBadAdapterErr            = -9050,                        /* invalid adapter number*/
  73.     kCSBadAttributeErr          = -9051,                        /* specified attributes field value is invalid*/
  74.     kCSBadBaseErr               = -9052,                        /* specified base system memory address is invalid*/
  75.     kCSBadEDCErr                = -9053,                        /* specified EDC generator specified is invalid*/
  76.     kCSBadIRQErr                = -9054,                        /* specified IRQ level is invalid*/
  77.     kCSBadOffsetErr             = -9055,                        /* specified PC card memory array offset is invalid*/
  78.     kCSBadPageErr               = -9056,                        /* specified page is invalid*/
  79.     kCSBadSizeErr               = -9057,                        /* specified size is invalid*/
  80.     kCSBadSocketErr             = -9058,                        /* specified logical or physical socket number is invalid*/
  81.     kCSBadTypeErr               = -9059,                        /* specified window or interface type is invalid*/
  82.     kCSBadVccErr                = -9060,                        /* specified Vcc power level index is invalid*/
  83.     kCSBadVppErr                = -9061,                        /* specified Vpp1 or Vpp2 power level index is invalid*/
  84.     kCSBadWindowErr             = -9062,                        /* specified window is invalid*/
  85.     kCSBadArgLengthErr          = -9063,                        /* ArgLength argument is invalid*/
  86.     kCSBadArgsErr               = -9064,                        /* values in argument packet are invalid*/
  87.     kCSBadHandleErr             = -9065,                        /* clientHandle is invalid*/
  88.     kCSBadCISErr                = -9066,                        /* CIS on card is invalid*/
  89.     kCSBadSpeedErr              = -9067,                        /* specified speed is unavailable*/
  90.     kCSReadFailureErr           = -9068,                        /* unable to complete read request*/
  91.     kCSWriteFailureErr          = -9069,                        /* unable to complete write request*/
  92.     kCSGeneralFailureErr        = -9070,                        /* an undefined error has occurred*/
  93.     kCSNoCardErr                = -9071,                        /* no PC card in the socket*/
  94.     kCSUnsupportedFunctionErr   = -9072,                        /* function is not supported by this implementation*/
  95.     kCSUnsupportedModeErr       = -9073,                        /* mode is not supported*/
  96.     kCSBusyErr                  = -9074,                        /* unable to process request at this time - try later*/
  97.     kCSWriteProtectedErr        = -9075,                        /* media is write-protected*/
  98.     kCSConfigurationLockedErr   = -9076,                        /* a configuration has already been locked*/
  99.     kCSInUseErr                 = -9077,                        /* requested resource is being used by a client*/
  100.     kCSNoMoreItemsErr           = -9078,                        /* there are no more of the requested item*/
  101.     kCSOutOfResourceErr         = -9079                         /* Card Services has exhausted the resource*/
  102. };
  106. /*  messages sent to client's event handler*/
  108. enum {
  109.     kCSNullMessage              = 0x00,                         /* no messages pending (not sent to clients)*/
  110.     kCSCardInsertionMessage     = 0x01,                         /* card has been inserted into the socket*/
  111.     kCSCardRemovalMessage       = 0x02,                         /* card has been removed from the socket*/
  112.     kCSCardLockMessage          = 0x03,                         /* card is locked into the socket with a mechanical latch*/
  113.     kCSCardUnlockMessage        = 0x04,                         /* card is no longer locked into the socket*/
  114.     kCSCardReadyMessage         = 0x05,                         /* card is ready to be accessed*/
  115.     kCSCardResetMessage         = 0x06,                         /* physical reset has completed*/
  116.     kCSInsertionRequestMessage  = 0x07,                         /* request to insert a card using insertion motor*/
  117.     kCSInsertionCompleteMessage = 0x08,                         /* insertion motor has finished inserting a card*/
  118.     kCSEjectionRequestMessage   = 0x09,                         /* user or other client is requesting a card ejection*/
  119.     kCSEjectionFailedMessage    = 0x0A,                         /* eject failure due to electrical/mechanical problems*/
  120.     kCSPMResumeMessage          = 0x0B,                         /* power management resume (TBD)*/
  121.     kCSPMSuspendMessage         = 0x0C,                         /* power management suspend (TBD)*/
  122.     kCSResetPhysicalMessage     = 0x0D,                         /* physical reset is about to occur on this card*/
  123.     kCSResetRequestMessage      = 0x0E,                         /* physical reset has been requested by a client*/
  124.     kCSResetCompleteMessage     = 0x0F,                         /* ResetCard() background reset has completed*/
  125.     kCSBatteryDeadMessage       = 0x10,                         /* battery is no longer useable, data will be lost*/
  126.     kCSBatteryLowMessage        = 0x11,                         /* battery is weak and should be replaced*/
  127.     kCSWriteProtectMessage      = 0x12,                         /* card is now write protected*/
  128.     kCSWriteEnabledMessage      = 0x13,                         /* card is now write enabled*/
  129.     kCSClientInfoMessage        = 0x14,                         /* client is to return client information*/
  130.     kCSSSUpdatedMessage         = 0x15,                         /* AddSocketServices/ReplaceSocket services has changed SS support*/
  131.     kCSFunctionInterruptMessage = 0x16,                         /* card function interrupt*/
  132.     kCSAccessErrorMessage       = 0x17,                         /* client bus errored on access to socket*/
  133.     kCSCardUnconfiguredMessage  = 0x18,                         /* a CARD_READY was delivered to all clients and no client */
  134.                                                                 /*    requested a configuration for the socket*/
  135.     kCSStatusChangedMessage     = 0x19                          /* status change for cards in I/O mode*/
  136. };
  138. /*
  139.     The following is a mapping of the PCMCIA name space to the Macintosh name space.
  140.     These two enum lists will be removed and given to developers as a separate file.
  141. */
  142. enum {
  143.     SUCCESS                     = noErr,
  144.     BAD_ADAPTER                 = kCSBadAdapterErr,
  145.     BAD_ATTRIBUTE               = kCSBadAttributeErr,
  146.     BAD_BASE                    = kCSBadBaseErr,
  147.     BAD_EDC                     = kCSBadEDCErr,
  148.     BAD_IRQ                     = kCSBadIRQErr,
  149.     BAD_OFFSET                  = kCSBadOffsetErr,
  150.     BAD_PAGE                    = kCSBadPageErr,
  151.     BAD_SIZE                    = kCSBadSizeErr,
  152.     BAD_SOCKET                  = kCSBadSocketErr,
  153.     BAD_TYPE                    = kCSBadTypeErr,
  154.     BAD_VCC                     = kCSBadVccErr,
  155.     BAD_VPP                     = kCSBadVppErr,
  156.     BAD_WINDOW                  = kCSBadWindowErr,
  157.     BAD_ARG_LENGTH              = kCSBadArgLengthErr,
  158.     BAD_ARGS                    = kCSBadArgsErr,
  159.     BAD_HANDLE                  = kCSBadHandleErr,
  160.     BAD_CIS                     = kCSBadCISErr,
  161.     BAD_SPEED                   = kCSBadSpeedErr,
  162.     READ_FAILURE                = kCSReadFailureErr,
  163.     WRITE_FAILURE               = kCSWriteFailureErr,
  164.     GENERAL_FAILURE             = kCSGeneralFailureErr,
  165.     NO_CARD                     = kCSNoCardErr,
  166.     UNSUPPORTED_FUNCTION        = kCSUnsupportedFunctionErr,
  167.     UNSUPPORTED_MODE            = kCSUnsupportedModeErr,
  168.     BUSY                        = kCSBusyErr,
  169.     WRITE_PROTECTED             = kCSWriteProtectedErr,
  170.     CONFIGURATION_LOCKED        = kCSConfigurationLockedErr,
  171.     IN_USE                      = kCSInUseErr,
  172.     NO_MORE_ITEMS               = kCSNoMoreItemsErr,
  173.     OUT_OF_RESOURCE             = kCSOutOfResourceErr
  174. };
  177. /*  messages sent to client's event handler*/
  179. enum {
  180.     NULL_MESSAGE                = kCSNullMessage,
  181.     CARD_INSERTION              = kCSCardInsertionMessage,
  182.     CARD_REMOVAL                = kCSCardRemovalMessage,
  183.     CARD_LOCK                   = kCSCardLockMessage,
  184.     CARD_UNLOCK                 = kCSCardUnlockMessage,
  185.     CARD_READY                  = kCSCardReadyMessage,
  186.     CARD_RESET                  = kCSCardResetMessage,
  187.     INSERTION_REQUEST           = kCSInsertionRequestMessage,
  188.     INSERTION_COMPLETE          = kCSInsertionCompleteMessage,
  189.     EJECTION_REQUEST            = kCSEjectionRequestMessage,
  190.     EJECTION_FAILED             = kCSEjectionFailedMessage,
  191.     PM_RESUME                   = kCSPMResumeMessage,
  192.     PM_SUSPEND                  = kCSPMSuspendMessage,
  193.     RESET_PHYSICAL              = kCSResetPhysicalMessage,
  194.     RESET_REQUEST               = kCSResetRequestMessage,
  195.     RESET_COMPLETE              = kCSResetCompleteMessage,
  196.     BATTERY_DEAD                = kCSBatteryDeadMessage,
  197.     BATTERY_LOW                 = kCSBatteryLowMessage,
  198.     WRITE_PROTECT               = kCSWriteProtectMessage,
  199.     WRITE_ENABLED               = kCSWriteEnabledMessage,
  200.     CLIENT_INFO                 = kCSClientInfoMessage,
  201.     SS_UPDATED                  = kCSSSUpdatedMessage,
  202.     FUNCTION_INTERRUPT          = kCSFunctionInterruptMessage,
  203.     ACCESS_ERROR                = kCSAccessErrorMessage,
  204.     CARD_UNCONFIGURED           = kCSCardUnconfiguredMessage,
  205.     STATUS_CHANGED              = kCSStatusChangedMessage
  206. };
  209. /*----------------      CSAccessConfigurationRegister   ----------------*/
  212. struct AccessConfigurationRegisterPB {
  213.     UInt16                          socket;                     /*  -> global socket number*/
  214.     UInt8                           action;                     /*  -> read/write*/
  215.     UInt8                           offset;                     /*  -> offset from config register base*/
  216.     UInt8                           value;                      /* <-> value to read/write*/
  217.     UInt8                           padding[1];                 /* */
  218. };
  219. typedef struct AccessConfigurationRegisterPB AccessConfigurationRegisterPB;
  220. /*  'action' field values*/
  222. enum {
  223.     kCSReadConfigRegister       = 0x00,
  224.     kCSWriteConfigRegister      = 0x01
  225. };
  228. /*----------------      CSGetCardServicesInfo           ----------------*/
  231. struct GetCardServicesInfoPB {
  232.     UInt8                           signature[2];               /* <-  two ascii chars 'CS'*/
  233.     UInt16                          count;                      /* <-  total number of sockets installed*/
  234.     UInt16                          revision;                   /* <-  BCD*/
  235.     UInt16                          csLevel;                    /* <-  BCD*/
  236.     UInt16                          reserved;                   /*  -> zero*/
  237.     UInt16                          vStrLen;                    /* <-> in: client's buffer size, out: vendor string length*/
  238.     UInt8 *                         vendorString;               /* <-> in: pointer to buffer to hold CS vendor string (zero-terminated)*/
  239.                                                                 /*    out: CS vendor string copied to buffer*/
  240. };
  241. typedef struct GetCardServicesInfoPB    GetCardServicesInfoPB;
  242. /*----------------      CSGetClientInfo                 ----------------*/
  245. /* upper byte of attributes is kCSClientInfoSubfunction*/
  247. struct ClientInfoParam {
  248.     UInt32                          clientHandle;               /*  -> clientHandle returned by RegisterClient*/
  249.     UInt16                          attributes;                 /* <-> subfunction + bitmapped client attributes*/
  250.     UInt16                          revision;                   /* <-  BCD value of client's revision*/
  251.     UInt16                          csLevel;                    /* <-  BCD value of CS release*/
  252.     UInt16                          revDate;                    /* <-  revision date: y[15-9], m[8-5], d[4-0]*/
  253.     SInt16                          nameLen;                    /* <-> in: max length of client name string, out: actual length*/
  254.     SInt16                          vStringLen;                 /* <-> in: max length of vendor string, out: actual length*/
  255.     UInt8 *                         nameString;                 /* <-  pointer to client name string (zero-terminated)*/
  256.     UInt8 *                         vendorString;               /* <-  pointer to vendor string (zero-terminated)*/
  257. };
  258. typedef struct ClientInfoParam          ClientInfoParam;
  259. /*
  260.    upper byte of attributes is kCSCardNameSubfunction,
  261.                                kCSCardTypeSubfunction,
  262.                                kCSHelpStringSubfunction
  263. */
  265. struct AlternateTextStringParam {
  266.     UInt32                          clientHandle;               /*  -> clientHandle returned by RegisterClient*/
  267.     UInt16                          attributes;                 /* <-> subfunction + bitmapped client attributes*/
  268.     UInt16                          socket;                     /*  -> logical socket number*/
  269.     UInt16                          reserved;                   /*  -> zero*/
  270.     SInt16                          length;                     /* <-> in: max length of string, out: actual length*/
  271.     UInt8 *                         text;                       /* <-  pointer to string (zero-terminated)*/
  272. };
  273. typedef struct AlternateTextStringParam AlternateTextStringParam;
  274. /* upper byte of attributes is kCSCardIconSubfunction*/
  276. struct AlternateCardIconParam {
  277.     UInt32                          clientHandle;               /*  -> clientHandle returned by RegisterClient*/
  278.     UInt16                          attributes;                 /* <-> subfunction + bitmapped client attributes*/
  279.     UInt16                          socket;                     /*  -> logical socket number*/
  280.     Handle                          iconSuite;                  /* <-  handle to icon suite containing all icons*/
  281. };
  282. typedef struct AlternateCardIconParam   AlternateCardIconParam;
  283. /* upper byte of attributes is kCSActionProcSubfunction*/
  285. struct CustomActionProcParam {
  286.     UInt32                          clientHandle;               /*  -> clientHandle returned by RegisterClient*/
  287.     UInt16                          attributes;                 /* <-> subfunction + bitmapped client attributes*/
  288.     UInt16                          socket;                     /*  -> logical socket number*/
  289. };
  290. typedef struct CustomActionProcParam    CustomActionProcParam;
  292. struct GetClientInfoPB {
  293.     union {
  294.         ClientInfoParam                 clientInfo;
  295.         AlternateTextStringParam        alternateTextString;
  296.         AlternateCardIconParam          alternateIcon;
  297.         CustomActionProcParam           customActionProc;
  298.     }                                 u;
  299. };
  300. typedef struct GetClientInfoPB          GetClientInfoPB;
  301. /*  'attributes' field values*/
  302. enum {
  303.     kCSMemoryClient             = 0x0001,
  304.     kCSIOClient                 = 0x0004,
  305.     kCSClientTypeMask           = 0x0007,
  306.     kCSShareableCardInsertEvents = 0x0008,
  307.     kCSExclusiveCardInsertEvents = 0x0010,
  308.     kCSInfoSubfunctionMask      = 0xFF00,
  309.     kCSClientInfoSubfunction    = 0x0000,
  310.     kCSCardNameSubfunction      = 0x8000,
  311.     kCSCardTypeSubfunction      = 0x8100,
  312.     kCSHelpStringSubfunction    = 0x8200,
  313.     kCSCardIconSubfunction      = 0x8300,
  314.     kCSActionProcSubfunction    = 0x8400
  315. };
  318. /*
  319.   ----------------      CSGetConfigurationInfo          ----------------
  320.   ----------------      CSModifyConfiguration           ----------------
  321.   ----------------      CSRequestConfiguration          ----------------
  322. */
  325. struct GetModRequestConfigInfoPB {
  326.     UInt32                          clientHandle;               /*  -> clientHandle returned by RegisterClient*/
  327.     UInt16                          socket;                     /*  -> logical socket number*/
  328.     UInt16                          attributes;                 /* <-> bitmap of configuration attributes*/
  329.     UInt8                           vcc;                        /* <-> Vcc setting*/
  330.     UInt8                           vpp1;                       /* <-> Vpp1 setting*/
  331.     UInt8                           vpp2;                       /* <-> Vpp2 setting*/
  332.     UInt8                           intType;                    /* <-> interface type (memory or memory+I/O)*/
  333.     UInt32                          configBase;                 /* <-> card base address of configuration registers*/
  334.     UInt8                           status;                     /* <-> card status register setting, if present*/
  335.     UInt8                           pin;                        /* <-> card pin register setting, if present*/
  336.     UInt8                           copy;                       /* <-> card socket/copy register setting, if present*/
  337.     UInt8                           configIndex;                /* <-> card option register setting, if present*/
  338.     UInt8                           present;                    /* <-> bitmap of which configuration registers are present*/
  339.     UInt8                           firstDevType;               /* <-  from DeviceID tuple*/
  340.     UInt8                           funcCode;                   /* <-  from FuncID tuple*/
  341.     UInt8                           sysInitMask;                /* <-  from FuncID tuple*/
  342.     UInt16                          manufCode;                  /* <-  from ManufacturerID tuple*/
  343.     UInt16                          manufInfo;                  /* <-  from ManufacturerID tuple*/
  344.     UInt8                           cardValues;                 /* <-  valid card register values*/
  345.     UInt8                           padding[1];                 /* */
  346. };
  347. typedef struct GetModRequestConfigInfoPB GetModRequestConfigInfoPB;
  348. /*  'attributes' field values*/
  349. enum {
  350.     kCSExclusivelyUsed          = 0x0001,
  351.     kCSEnableIREQs              = 0x0002,
  352.     kCSVccChangeValid           = 0x0004,
  353.     kCSVpp1ChangeValid          = 0x0008,
  354.     kCSVpp2ChangeValid          = 0x0010,
  355.     kCSValidClient              = 0x0020,
  356.     kCSSleepPower               = 0x0040,                       /* request that power be applied to socket during Sleep*/
  357.     kCSLockSocket               = 0x0080,
  358.     kCSTurnOnInUse              = 0x0100
  359. };
  361. /*  'intType' field values*/
  363. enum {
  364.     kCSMemoryInterface          = 0x01,
  365.     kCSMemory_And_IO_Interface  = 0x02
  366. };
  368. /*  'present' field values*/
  370. enum {
  371.     kCSOptionRegisterPresent    = 0x01,
  372.     kCSStatusRegisterPresent    = 0x02,
  373.     kCSPinReplacementRegisterPresent = 0x04,
  374.     kCSCopyRegisterPresent      = 0x08
  375. };
  377. /*  'cardValues' field values*/
  379. enum {
  380.     kCSOptionValueValid         = 0x01,
  381.     kCSStatusValueValid         = 0x02,
  382.     kCSPinReplacementValueValid = 0x04,
  383.     kCSCopyValueValid           = 0x08
  384. };
  387. /*
  388.   ----------------      CSGetClientEventMask            ----------------
  389.   ----------------      CSSetClientEventMask            ----------------
  390. */
  393. struct GetSetClientEventMaskPB {
  394.     UInt32                          clientHandle;               /*  -> clientHandle returned by RegisterClient*/
  395.     UInt16                          attributes;                 /* <-> bitmap of attributes*/
  396.     UInt16                          eventMask;                  /* <-> bitmap of events to be passed to client for this socket*/
  397.     UInt16                          socket;                     /*  -> logical socket number*/
  398. };
  399. typedef struct GetSetClientEventMaskPB  GetSetClientEventMaskPB;
  400. /*  'attributes' field values*/
  401. enum {
  402.     kCSEventMaskThisSocketOnly  = 0x0001
  403. };
  405. /*  'eventMask' field values*/
  407. enum {
  408.     kCSWriteProtectEvent        = 0x0001,
  409.     kCSCardLockChangeEvent      = 0x0002,
  410.     kCSEjectRequestEvent        = 0x0004,
  411.     kCSInsertRequestEvent       = 0x0008,
  412.     kCSBatteryDeadEvent         = 0x0010,
  413.     kCSBatteryLowEvent          = 0x0020,
  414.     kCSReadyChangeEvent         = 0x0040,
  415.     kCSCardDetectChangeEvent    = 0x0080,
  416.     kCSPMChangeEvent            = 0x0100,
  417.     kCSResetEvent               = 0x0200,
  418.     kCSSSUpdateEvent            = 0x0400,
  419.     kCSFunctionInterrupt        = 0x0800,
  420.     kCSAllEvents                = 0xFFFF
  421. };
  424. /*
  425.   ----------------      CSGetFirstClient                ----------------
  426.   ----------------      CSGetNextClient                 ----------------
  427. */
  430. struct GetClientPB {
  431.     UInt32                          clientHandle;               /* <-  clientHandle for this client*/
  432.     UInt16                          socket;                     /*  -> logical socket number*/
  433.     UInt16                          attributes;                 /*  -> bitmap of attributes*/
  434. };
  435. typedef struct GetClientPB              GetClientPB;
  436. /*  'attributes' field values*/
  437. enum {
  438.     kCSClientsForAllSockets     = 0x0000,
  439.     kCSClientsThisSocketOnly    = 0x0001
  440. };
  443. /*
  444.   ----------------      CSGetFirstTuple                 ----------------
  445.   ----------------      CSGetNextTuple                  ----------------
  446.   ----------------      CSGetTupleData                  ----------------
  447. */
  450. struct GetTuplePB {
  451.     UInt16                          socket;                     /*  -> logical socket number*/
  452.     UInt16                          attributes;                 /*  -> bitmap of attributes*/
  453.     UInt8                           desiredTuple;               /*  -> desired tuple code value, or $FF for all*/
  454.     UInt8                           tupleOffset;                /*  -> offset into tuple from link byte*/
  455.     UInt16                          flags;                      /* <-> internal use*/
  456.     UInt32                          linkOffset;                 /* <-> internal use*/
  457.     UInt32                          cisOffset;                  /* <-> internal use*/
  459.     union {
  460.         struct {
  461.             UInt8                           tupleCode;          /* <-  tuple code found*/
  462.             UInt8                           tupleLink;          /* <-  link value for tuple found*/
  463.         }                                 TuplePB;
  465.         struct {
  466.             UInt16                          tupleDataMax;       /*  -> maximum size of tuple data area*/
  467.             UInt16                          tupleDataLen;       /* <-  number of bytes in tuple body*/
  468.             TupleBody                       tupleData;          /* <-  tuple data*/
  469.         }                                 TupleDataPB;
  470.     }                                 u;
  471. };
  472. typedef struct GetTuplePB               GetTuplePB;
  473. /*  'attributes' field values*/
  474. enum {
  475.     kCSReturnLinkTuples         = 0x0001
  476. };
  479. /*
  480.   ----------------      CSRequestSocketMask             ----------------
  481.   ----------------      CSReleaseSocketMask             ----------------
  482. */
  485. struct ReqRelSocketMaskPB {
  486.     UInt32                          clientHandle;               /*  -> clientHandle returned by RegisterClient*/
  487.     UInt16                          socket;                     /*  -> logical socket*/
  488.     UInt16                          eventMask;                  /*  -> bitmap of events to be passed to client for this socket*/
  489. };
  490. typedef struct ReqRelSocketMaskPB       ReqRelSocketMaskPB;
  491. /*  'eventMask' field values (see above for Get/SetClientEventMask*/
  493. /*----------------      CSGetStatus                     ----------------*/
  496. struct GetStatusPB {
  497.     UInt16                          socket;                     /*  -> logical socket number*/
  498.     UInt16                          cardState;                  /* <-  current state of installed card*/
  499.     UInt16                          socketState;                /* <-  current state of the socket*/
  500. };
  501. typedef struct GetStatusPB              GetStatusPB;
  502. /*  'cardState' field values*/
  503. enum {
  504.     kCSWriteProtected           = 0x0001,
  505.     kCSCardLocked               = 0x0002,
  506.     kCSEjectRequest             = 0x0004,
  507.     kCSInsertRequest            = 0x0008,
  508.     kCSBatteryDead              = 0x0010,
  509.     kCSBatteryLow               = 0x0020,
  510.     kCSReady                    = 0x0040,
  511.     kCSCardDetected             = 0x0080
  512. };
  514. /*  'socketState' field values*/
  516. enum {
  517.     kCSWriteProtectChanged      = 0x0001,
  518.     kCSCardLockChanged          = 0x0002,
  519.     kCSEjectRequestPending      = 0x0004,
  520.     kCSInsertRequestPending     = 0x0008,
  521.     kCSBatteryDeadChanged       = 0x0010,
  522.     kCSBatteryLowChanged        = 0x0020,
  523.     kCSReadyChanged             = 0x0040,
  524.     kCSCardDetectChanged        = 0x0080
  525. };
  528. /*
  529.   ----------------      CSModifyWindow                  ----------------
  530.   ----------------      CSReleaseWindow                 ----------------
  531.   ----------------      CSRequestWindow                 ----------------
  532. */
  535. struct ReqModRelWindowPB {
  536.     UInt32                          clientHandle;               /*  -> clientHandle returned by RegisterClient*/
  537.     UInt32                          windowHandle;               /* <-> window descriptor*/
  538.     UInt16                          socket;                     /*  -> logical socket number*/
  539.     UInt16                          attributes;                 /*  -> window attributes (bitmap)*/
  540.     UInt32                          base;                       /* <-> system base address*/
  541.     UInt32                          size;                       /* <-> memory window size*/
  542.     UInt8                           accessSpeed;                /*  -> window access speed (bitmap)*/
  543.                                                                 /*       (not applicable for I/O mode)*/
  544.     UInt8                           padding[1];                 /* */
  545. };
  546. typedef struct ReqModRelWindowPB        ReqModRelWindowPB;
  547. /*  'attributes' field values*/
  548. enum {
  549.     kCSMemoryWindow             = 0x0001,
  550.     kCSIOWindow                 = 0x0002,
  551.     kCSAttributeWindow          = 0x0004,                       /* not normally used by Card Services clients*/
  552.     kCSWindowTypeMask           = 0x0007,
  553.     kCSEnableWindow             = 0x0008,
  554.     kCSAccessSpeedValid         = 0x0010,
  555.     kCSLittleEndian             = 0x0020,                       /* configure socket for little endianess*/
  556.     kCS16BitDataPath            = 0x0040,
  557.     kCSWindowPaged              = 0x0080,                       /* */
  558.     kCSWindowShared             = 0x0100,
  559.     kCSWindowFirstShared        = 0x0200,                       /* */
  560.     kCSWindowProgrammable       = 0x0400                        /* */
  561. };
  563. /*  'accessSpeed' field values*/
  565. enum {
  566.     kCSDeviceSpeedCodeMask      = 0x07,
  567.     kCSSpeedExponentMask        = 0x07,
  568.     kCSSpeedMantissaMask        = 0x78,
  569.     kCSUseWait                  = 0x80,
  570.     kCSAccessSpeed250nsec       = 0x01,
  571.     kCSAccessSpeed200nsec       = 0x02,
  572.     kCSAccessSpeed150nsec       = 0x03,
  573.     kCSAccessSpeed100nsec       = 0x04,
  574.     kCSExtAccSpeedMant1pt0      = 0x01,
  575.     kCSExtAccSpeedMant1pt2      = 0x02,
  576.     kCSExtAccSpeedMant1pt3      = 0x03,
  577.     kCSExtAccSpeedMant1pt5      = 0x04,
  578.     kCSExtAccSpeedMant2pt0      = 0x05,
  579.     kCSExtAccSpeedMant2pt5      = 0x06,
  580.     kCSExtAccSpeedMant3pt0      = 0x07,
  581.     kCSExtAccSpeedMant3pt5      = 0x08,
  582.     kCSExtAccSpeedMant4pt0      = 0x09,
  583.     kCSExtAccSpeedMant4pt5      = 0x0A,
  584.     kCSExtAccSpeedMant5pt0      = 0x0B,
  585.     kCSExtAccSpeedMant5pt5      = 0x0C,
  586.     kCSExtAccSpeedMant6pt0      = 0x0D,
  587.     kCSExtAccSpeedMant7pt0      = 0x0E,
  588.     kCSExtAccSpeedMant8pt0      = 0x0F,
  589.     kCSExtAccSpeedExp1ns        = 0x00,
  590.     kCSExtAccSpeedExp10ns       = 0x01,
  591.     kCSExtAccSpeedExp100ns      = 0x02,
  592.     kCSExtAccSpeedExp1us        = 0x03,
  593.     kCSExtAccSpeedExp10us       = 0x04,
  594.     kCSExtAccSpeedExp100us      = 0x05,
  595.     kCSExtAccSpeedExp1ms        = 0x06,
  596.     kCSExtAccSpeedExp10ms       = 0x07
  597. };
  600. /*
  601.   ----------------      CSRegisterClient                ----------------
  602.   ----------------      CSDeregisterClient              ----------------
  603. */
  606. struct ClientCallbackPB {
  607.     UInt16                          message;                    /*  -> which event this is*/
  608.     UInt16                          socket;                     /*  -> logical socket number*/
  609.     UInt16                          info;                       /*  -> function-specific*/
  610.     UInt16                          misc;                       /*  -> function-specific*/
  611.     Ptr                             reserved;                   /*  -> pointer to MTD request block*/
  612.     Ptr                             buffer;                     /*  -> function-specific*/
  613.     Ptr                             clientData;                 /*  -> pointer to client's data (from RegisterClient)*/
  614. };
  615. typedef struct ClientCallbackPB         ClientCallbackPB;
  616. typedef ClientCallbackPB *              ClientCallbackPBPtr;
  617. typedef CALLBACK_API( UInt16 , PCCardCSClientProcPtr )(ClientCallbackPBPtr ccPBPtr);
  618. typedef STACK_UPP_TYPE(PCCardCSClientProcPtr)                   PCCardCSClientUPP;
  619. #if OPAQUE_UPP_TYPES
  620. #if CALL_NOT_IN_CARBON
  621.     EXTERN_API(PCCardCSClientUPP)
  622.     NewPCCardCSClientUPP           (PCCardCSClientProcPtr   userRoutine);
  624.     EXTERN_API(void)
  625.     DisposePCCardCSClientUPP       (PCCardCSClientUPP       userUPP);
  627.     EXTERN_API(UInt16)
  628.     InvokePCCardCSClientUPP        (ClientCallbackPBPtr     ccPBPtr,
  629.                                     PCCardCSClientUPP       userUPP);
  631. #endif  /* CALL_NOT_IN_CARBON */
  633. #else
  634.     enum { uppPCCardCSClientProcInfo = 0x000000E0 };                /* pascal 2_bytes Func(4_bytes) */
  635.     #define NewPCCardCSClientUPP(userRoutine)                       (PCCardCSClientUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppPCCardCSClientProcInfo, GetCurrentArchitecture())
  636.     #define DisposePCCardCSClientUPP(userUPP)                       DisposeRoutineDescriptor(userUPP)
  637.     #define InvokePCCardCSClientUPP(ccPBPtr, userUPP)               (UInt16)CALL_ONE_PARAMETER_UPP((userUPP), uppPCCardCSClientProcInfo, (ccPBPtr))
  638. #endif
  639. /* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
  640. #define NewPCCardCSClientProc(userRoutine)                      NewPCCardCSClientUPP(userRoutine)
  641. #define CallPCCardCSClientProc(userRoutine, ccPBPtr)            InvokePCCardCSClientUPP(ccPBPtr, userRoutine)
  643. struct RegisterClientPB {
  644.     UInt32                          clientHandle;               /* <-  client descriptor*/
  645.     PCCardCSClientUPP               clientEntry;                /*  -> universal procPtr to client's event handler*/
  646.     UInt16                          attributes;                 /*  -> bitmap of client attributes*/
  647.     UInt16                          eventMask;                  /*  -> bitmap of events to notify client*/
  648.     Ptr                             clientData;                 /*  -> pointer to client's data*/
  649.     UInt16                          version;                    /*  -> Card Services version this client expects*/
  650. };
  651. typedef struct RegisterClientPB         RegisterClientPB;
  652. /*  'attributes' field values (see GetClientInfo)*/
  653. /*
  654.     kCSMemoryClient                 = 0x0001,
  655.     kCSIOClient                     = 0x0004,
  656.     kCSShareableCardInsertEvents    = 0x0008,
  657.     kCSExclusiveCardInsertEvents    = 0x0010
  658. */
  661. /*----------------      CSReleaseConfiguration          ----------------*/
  664. struct ReleaseConfigurationPB {
  665.     UInt32                          clientHandle;               /*  -> clientHandle returned by RegisterClient*/
  666.     UInt16                          socket;                     /*  -> */
  667. };
  668. typedef struct ReleaseConfigurationPB   ReleaseConfigurationPB;
  669. /*----------------      CSResetCard                     ----------------*/
  672. struct ResetCardPB {
  673.     UInt32                          clientHandle;               /*  -> clientHandle returned by RegisterClient*/
  674.     UInt16                          socket;                     /*  -> */
  675.     UInt16                          attributes;                 /*  -> xxx*/
  676. };
  677. typedef struct ResetCardPB              ResetCardPB;
  678. /*----------------      CSValidateCIS                   ----------------*/
  681. struct ValidateCISPB {
  682.     UInt16                          socket;                     /*  -> */
  683.     UInt16                          chains;                     /*  -> whether link/null tuples should be included*/
  684. };
  685. typedef struct ValidateCISPB            ValidateCISPB;
  686. /*
  687.   ----------------      CSRequestIO                     ----------------
  688.   ----------------      CSReleaseIO                     ----------------
  689. */
  692. struct ReqRelIOPB {
  693.     UInt32                          clientHandle;               /*  -> clientHandle returned by RegisterClient*/
  694.     UInt16                          socket;                     /*  -> socket number*/
  695.     UInt16                          reserved;
  696.     UInt16                          basePort1;                  /*    -> base I/O port for range*/
  697.     UInt8                           numPorts1;                  /*    -> number of ports (e.g., bytes).*/
  698.     UInt8                           attributes1;                /*    -> attributes*/
  700.     UInt16                          basePort2;                  /*    -> base I/O port for range*/
  701.     UInt8                           numPorts2;                  /*    -> number of ports*/
  702.     UInt8                           attributes2;                /*    -> attributes*/
  704.     UInt8                           ioAddrLines;                /*    -> number of I/O lines decoded by card*/
  705.     UInt8                           reserved1;
  706. };
  707. typedef struct ReqRelIOPB               ReqRelIOPB;
  708. /*----------------      CSVendorSpecific                ----------------*/
  710. struct VendorSpecificPB {
  711.     UInt32                          clientHandle;               /*  -> clientHandle returned by RegisterClient*/
  712.     UInt16                          vsCode;
  713.     UInt16                          socket;
  714.     UInt32                          dataLen;                    /*  -> length of buffer pointed to by vsDataPtr*/
  715.     UInt8 *                         vsDataPtr;                  /*  -> Card Services version this client expects*/
  716. };
  717. typedef struct VendorSpecificPB         VendorSpecificPB;
  718. /*  'vsCode' field values*/
  720. enum {
  721.     vsAppleReserved             = 0x0000,
  722.     vsEjectCard                 = 0x0001,
  723.     vsGetCardInfo               = 0x0002,
  724.     vsEnableSocketEvents        = 0x0003,
  725.     vsGetCardLocationIcon       = 0x0004,
  726.     vsGetCardLocationText       = 0x0005,
  727.     vsGetAdapterInfo            = 0x0006
  728. };
  730. /*
  731.   ///////////////////////////////////////////////////////////////////////////////////////
  732.     GetAdapterInfo parameter block (vendor-specific call #6)
  733. */
  736. struct GetAdapterInfoPB {
  737.     UInt32                          attributes;                 /* <-  capabilties of socket's adapter*/
  738.     UInt16                          revision;                   /* <-  id of adapter*/
  739.     UInt16                          reserved;                   /* */
  740.     UInt16                          numVoltEntries;             /* <-  number of valid voltage values*/
  741.     UInt8 *                         voltages;                   /* <-> array of BCD voltage values*/
  742. };
  743. typedef struct GetAdapterInfoPB         GetAdapterInfoPB;
  744. /*  'attributes' field values*/
  745. enum {
  746.     kCSLevelModeInterrupts      = 0x00000001,
  747.     kCSPulseModeInterrupts      = 0x00000002,
  748.     kCSProgrammableWindowAddr   = 0x00000004,
  749.     kCSProgrammableWindowSize   = 0x00000008,
  750.     kCSSocketSleepPower         = 0x00000010,
  751.     kCSSoftwareEject            = 0x00000020,
  752.     kCSLockableSocket           = 0x00000040,
  753.     kCSInUseIndicator           = 0x00000080
  754. };
  756. /*
  757.   ///////////////////////////////////////////////////////////////////////////////////////
  758.     GetCardInfo parameter block (vendor-specific call #2)
  759. */
  762. struct GetCardInfoPB {
  763.     UInt8                           cardType;                   /* <-  type of card in this socket (defined at top of file)*/
  764.     UInt8                           subType;                    /* <-  more detailed card type (defined at top of file)*/
  765.     UInt16                          reserved;                   /* <-> reserved (should be set to zero)*/
  766.     UInt16                          cardNameLen;                /*  -> maximum length of card name to be returned*/
  767.     UInt16                          vendorNameLen;              /*  -> maximum length of vendor name to be returned*/
  768.     UInt8 *                         cardName;                   /*  -> pointer to card name string (read from CIS), or nil*/
  769.     UInt8 *                         vendorName;                 /*  -> pointer to vendor name string (read from CIS), or nil*/
  770. };
  771. typedef struct GetCardInfoPB            GetCardInfoPB;
  772. /*  GetCardInfo card types*/
  773. enum {
  774.     kCSUnknownCardType          = 0,
  775.     kCSMultiFunctionCardType    = 1,
  776.     kCSMemoryCardType           = 2,
  777.     kCSSerialPortCardType       = 3,
  778.     kCSSerialOnlyType           = 0,
  779.     kCSDataModemType            = 1,
  780.     kCSFaxModemType             = 2,
  781.     kCSFaxAndDataModemMask      = (kCSDataModemType | kCSFaxModemType),
  782.     kCSVoiceEncodingType        = 4,
  783.     kCSParallelPortCardType     = 4,
  784.     kCSFixedDiskCardType        = 5,
  785.     kCSUnknownFixedDiskType     = 0,
  786.     kCSATAInterface             = 1,
  787.     kCSRotatingDevice           = (0 << 7),
  788.     kCSSiliconDevice            = (1 << 7),
  789.     kCSVideoAdaptorCardType     = 6,
  790.     kCSNetworkAdaptorCardType   = 7,
  791.     kCSAIMSCardType             = 8,
  792.     kCSNumCardTypes             = 9
  793. };
  796. #ifndef __PCCARDENABLERPLUGIN__
  797. /*
  798.     NOTE: These prototypes conflict with PCCardEnablerPlugin.*
  799.           You cannot use both PCCardEnablerPlugin.h and CardServices.h
  800.           
  801. */
  802. #if CALL_NOT_IN_CARBON
  803. EXTERN_API( OSErr )
  804. CSVendorSpecific                (VendorSpecificPB *     pb)                                 TWOWORDINLINE(0x7000, 0xAAF0);
  806. EXTERN_API( OSErr )
  807. CSRegisterClient                (RegisterClientPB *     pb)                                 TWOWORDINLINE(0x7001, 0xAAF0);
  809. EXTERN_API( OSErr )
  810. CSDeregisterClient              (RegisterClientPB *     pb)                                 TWOWORDINLINE(0x7002, 0xAAF0);
  812. EXTERN_API( OSErr )
  813. CSGetFirstTuple                 (GetTuplePB *           pb)                                 TWOWORDINLINE(0x7003, 0xAAF0);
  815. EXTERN_API( OSErr )
  816. CSGetNextTuple                  (GetTuplePB *           pb)                                 TWOWORDINLINE(0x7004, 0xAAF0);
  818. EXTERN_API( OSErr )
  819. CSGetTupleData                  (GetTuplePB *           pb)                                 TWOWORDINLINE(0x7005, 0xAAF0);
  821. EXTERN_API( OSErr )
  822. CSGetConfigurationInfo          (GetModRequestConfigInfoPB * pb)                            TWOWORDINLINE(0x7006, 0xAAF0);
  824. EXTERN_API( OSErr )
  825. CSGetCardServicesInfo           (GetCardServicesInfoPB * pb)                                TWOWORDINLINE(0x7007, 0xAAF0);
  827. EXTERN_API( OSErr )
  828. CSGetStatus                     (GetStatusPB *          pb)                                 TWOWORDINLINE(0x7008, 0xAAF0);
  830. EXTERN_API( OSErr )
  831. CSValidateCIS                   (ValidateCISPB *        pb)                                 TWOWORDINLINE(0x7009, 0xAAF0);
  833. EXTERN_API( OSErr )
  834. CSGetFirstClient                (GetClientPB *          pb)                                 TWOWORDINLINE(0x700F, 0xAAF0);
  836. EXTERN_API( OSErr )
  837. CSGetNextClient                 (GetClientPB *          pb)                                 TWOWORDINLINE(0x7010, 0xAAF0);
  839. EXTERN_API( OSErr )
  840. CSGetClientInfo                 (GetClientInfoPB *      pb)                                 TWOWORDINLINE(0x7011, 0xAAF0);
  842. EXTERN_API( OSErr )
  843. CSResetCard                     (ResetCardPB *          pb)                                 TWOWORDINLINE(0x7012, 0xAAF0);
  845. EXTERN_API( OSErr )
  846. CSRequestWindow                 (ReqModRelWindowPB *    pb)                                 TWOWORDINLINE(0x7013, 0xAAF0);
  848. EXTERN_API( OSErr )
  849. CSModifyWindow                  (ReqModRelWindowPB *    pb)                                 TWOWORDINLINE(0x7014, 0xAAF0);
  851. EXTERN_API( OSErr )
  852. CSReleaseWindow                 (ReqModRelWindowPB *    pb)                                 TWOWORDINLINE(0x7015, 0xAAF0);
  854. EXTERN_API( OSErr )
  855. CSRequestConfiguration          (GetModRequestConfigInfoPB * pb)                            TWOWORDINLINE(0x701B, 0xAAF0);
  857. EXTERN_API( OSErr )
  858. CSModifyConfiguration           (GetModRequestConfigInfoPB * pb)                            TWOWORDINLINE(0x701C, 0xAAF0);
  860. EXTERN_API( OSErr )
  861. CSAccessConfigurationRegister   (AccessConfigurationRegisterPB * pb)                        TWOWORDINLINE(0x701D, 0xAAF0);
  863. EXTERN_API( OSErr )
  864. CSReleaseConfiguration          (ReleaseConfigurationPB * pb)                               TWOWORDINLINE(0x701E, 0xAAF0);
  866. EXTERN_API( OSErr )
  867. CSGetClientEventMask            (GetSetClientEventMaskPB * pb)                              TWOWORDINLINE(0x701F, 0xAAF0);
  869. EXTERN_API( OSErr )
  870. CSSetClientEventMask            (GetSetClientEventMaskPB * pb)                              TWOWORDINLINE(0x7020, 0xAAF0);
  872. EXTERN_API( OSErr )
  873. CSRequestSocketMask             (ReqRelSocketMaskPB *   pb)                                 TWOWORDINLINE(0x7021, 0xAAF0);
  875. EXTERN_API( OSErr )
  876. CSReleaseSocketMask             (ReqRelSocketMaskPB *   pb)                                 TWOWORDINLINE(0x7022, 0xAAF0);
  879. /*
  880.     Additional calls which are required for all I/O clients when running on
  881.     systems which do not reserve dedicated I/O-spaces for each PC Card.
  882. */
  884. EXTERN_API( OSErr )
  885. CSRequestIO                     (ReqRelIOPB *           pb)                                 TWOWORDINLINE(0x7025, 0xAAF0);
  887. EXTERN_API( OSErr )
  888. CSReleaseIO                     (ReqRelIOPB *           pb)                                 TWOWORDINLINE(0x7026, 0xAAF0);
  890. #endif  /* CALL_NOT_IN_CARBON */
  892. #endif  /* !defined(__PCCARDENABLERPLUGIN__) */
  895. #if PRAGMA_STRUCT_ALIGN
  896.     #pragma options align=reset
  897. #elif PRAGMA_STRUCT_PACKPUSH
  898.     #pragma pack(pop)
  899. #elif PRAGMA_STRUCT_PACK
  900.     #pragma pack()
  901. #endif
  903. #ifdef PRAGMA_IMPORT_OFF
  904. #pragma import off
  905. #elif PRAGMA_IMPORT
  906. #pragma import reset
  907. #endif
  909. #ifdef __cplusplus
  910. }
  911. #endif
  913. #endif /* __CARDSERVICES__ */