home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / PInterfaces / Slots.p < prev    next >
Encoding:
Text File  |  1994-11-11  |  12.2 KB  |  384 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Slots.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a3  ETO #16, MPW prerelease.  Friday, November 11, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT Slots;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __SLOTS__}
  27. {$SETC __SLOTS__ := 1}
  28.  
  29. {$I+}
  30. {$SETC SlotsIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {    ConditionalMacros.p                                            }
  38.  
  39. {$IFC UNDEFINED __EVENTS__}
  40. {$I Events.p}
  41. {$ENDC}
  42. {    Quickdraw.p                                                    }
  43. {        MixedMode.p                                                }
  44. {        QuickdrawText.p                                            }
  45. {    OSUtils.p                                                    }
  46. {        Memory.p                                                }
  47.  
  48. {$IFC UNDEFINED __FILES__}
  49. {$I Files.p}
  50. {$ENDC}
  51.  
  52. {$PUSH}
  53. {$ALIGN MAC68K}
  54. {$LibExport+}
  55.  
  56. CONST
  57.     fCardIsChanged                = 1;                            {Card is Changed field in StatusFlags field of sInfoArray}
  58.     fCkForSame                    = 0;                            {For SearchSRT. Flag to check for SAME sResource in the table. }
  59.     fCkForNext                    = 1;                            {For SearchSRT. Flag to check for NEXT sResource in the table. }
  60.     fWarmStart                    = 2;                            {If this bit is set then warm start else cold start.}
  61.     stateNil                    = 0;                            {State}
  62.     stateSDMInit                = 1;                            {:Slot declaration manager Init}
  63.     statePRAMInit                = 2;                            {:sPRAM record init}
  64.     statePInit                    = 3;                            {:Primary init}
  65.     stateSInit                    = 4;                            {:Secondary init}
  66. { flags for spParamData }
  67.     fall                        = 0;                            { bit 0: set=search enabled/disabled sRsrc's }
  68.     foneslot                    = 1;                            {    1: set=search sRsrc's in given slot only }
  69.     fnext                        = 2;                            {    2: set=search for next sRsrc }
  70.  
  71. TYPE
  72.     {
  73.         SlotIntServiceProcPtr uses register based parameters on the 68k and cannot
  74.         be written in or called from a high-level language without the help of
  75.         mixed mode or assembly glue.
  76.  
  77.         In:
  78.          => sqParameter     A1.L
  79.         Out:
  80.          <= return value    D0.W
  81.     }
  82.     SlotIntServiceProcPtr = ProcPtr;  { FUNCTION SlotIntService(sqParameter: LONGINT): INTEGER; }
  83.     SlotIntServiceUPP = UniversalProcPtr;
  84.  
  85. CONST
  86.     uppSlotIntServiceProcInfo = $0000B822; { Register FUNCTION (4 bytes in A1): 2 bytes in D0; }
  87.  
  88. FUNCTION NewSlotIntServiceProc(userRoutine: SlotIntServiceProcPtr): SlotIntServiceUPP;
  89.     {$IFC NOT GENERATINGCFM }
  90.     INLINE $2E9F;
  91.     {$ENDC}
  92.  
  93. FUNCTION CallSlotIntServiceProc(sqParameter: LONGINT; userRoutine: SlotIntServiceUPP): INTEGER;
  94.     {$IFC NOT GENERATINGCFM}
  95.     {To be implemented:  Glue to move parameters into registers.}
  96.     {$ENDC}
  97.  
  98. TYPE
  99.     SlotIntQElement = RECORD
  100.         sqLink:                    Ptr;                                    {ptr to next element}
  101.         sqType:                    INTEGER;                                {queue type ID for validity}
  102.         sqPrio:                    INTEGER;                                {priority}
  103.         sqAddr:                    SlotIntServiceUPP;                        {interrupt service routine}
  104.         sqParm:                    LONGINT;                                {optional A1 parameter}
  105.     END;
  106.     SQElemPtr = ^SlotIntQElement;
  107.  
  108.     SpBlock = RECORD
  109.         spResult:                LONGINT;                                {FUNCTION Result}
  110.         spsPointer:                Ptr;                                    {structure pointer}
  111.         spSize:                    LONGINT;                                {size of structure}
  112.         spOffsetData:            LONGINT;                                {offset/data field used by sOffsetData}
  113.         spIOFileName:            Ptr;                                    {ptr to IOFile name for sDisDrvrName}
  114.         spsExecPBlk:            Ptr;                                    {pointer to sExec parameter block.}
  115.         spParamData:            LONGINT;                                {misc parameter data (formerly spStackPtr).}
  116.         spMisc:                    LONGINT;                                {misc field for SDM.}
  117.         spReserved:                LONGINT;                                {reserved for future expansion}
  118.         spIOReserved:            INTEGER;                                {Reserved field of Slot Resource Table}
  119.         spRefNum:                INTEGER;                                {RefNum}
  120.         spCategory:                INTEGER;                                {sType: Category}
  121.         spCType:                INTEGER;                                {Type}
  122.         spDrvrSW:                INTEGER;                                {DrvrSW}
  123.         spDrvrHW:                INTEGER;                                {DrvrHW}
  124.         spTBMask:                SInt8;                                    {type bit mask bits 0..3 mask words 0..3}
  125.         spSlot:                    SInt8;                                    {slot number}
  126.         spID:                    SInt8;                                    {structure ID}
  127.         spExtDev:                SInt8;                                    {ID of the external device}
  128.         spHwDev:                SInt8;                                    {Id of the hardware device.}
  129.         spByteLanes:            SInt8;                                    {bytelanes from card ROM format block}
  130.         spFlags:                SInt8;                                    {standard flags}
  131.         spKey:                    SInt8;                                    {Internal use only}
  132.     END;
  133.     SpBlockPtr = ^SpBlock;
  134.  
  135.     SInfoRecord = RECORD
  136.         siDirPtr:                Ptr;                                    {Pointer to directory}
  137.         siInitStatusA:            INTEGER;                                {initialization E}
  138.         siInitStatusV:            INTEGER;                                {status returned by vendor init code}
  139.         siState:                SInt8;                                    {initialization state}
  140.         siCPUByteLanes:            SInt8;                                    {0=[d0..d7] 1=[d8..d15]}
  141.         siTopOfROM:                SInt8;                                    {Top of ROM= $FssFFFFx: x is TopOfROM}
  142.         siStatusFlags:            SInt8;                                    {bit 0 - card is changed}
  143.         siTOConst:                INTEGER;                                {Time Out C for BusErr}
  144.         siReserved:                ARRAY [0..1] OF SInt8;                    {reserved}
  145.         siROMAddr:                Ptr;                                    { addr of top of ROM }
  146.         siSlot:                    SInt8;                                    { slot number }
  147.         siPadding:                ARRAY [0..2] OF SInt8;                    { reserved }
  148.     END;
  149.     SInfoRecPtr = ^SInfoRecord;
  150.  
  151.     SDMRecord = RECORD
  152.         sdBEVSave:                ProcPtr;                                {Save old BusErr vector}
  153.         sdBusErrProc:            ProcPtr;                                {Go here to determine if it is a BusErr}
  154.         sdErrorEntry:            ProcPtr;                                {Go here if BusErrProc finds real BusErr}
  155.         sdReserved:                LONGINT;                                {Reserved}
  156.     END;
  157.     FHeaderRec = RECORD
  158.         fhDirOffset:            LONGINT;                                {offset to directory}
  159.         fhLength:                LONGINT;                                {length of ROM}
  160.         fhCRC:                    LONGINT;                                {CRC}
  161.         fhROMRev:                SInt8;                                    {revision of ROM}
  162.         fhFormat:                SInt8;                                    {format - 2}
  163.         fhTstPat:                LONGINT;                                {test pattern}
  164.         fhReserved:                SInt8;                                    {reserved}
  165.         fhByteLanes:            SInt8;                                    {ByteLanes}
  166.     END;
  167.     FHeaderRecPtr = ^FHeaderRec;
  168.  
  169.     SEBlock = PACKED RECORD
  170.         seSlot:                    UInt8;                                    {Slot number.}
  171.         sesRsrcId:                UInt8;                                    {sResource Id.}
  172.         seStatus:                INTEGER;                                {Status of code executed by sExec.}
  173.         seFlags:                UInt8;                                    {Flags}
  174.         seFiller0:                UInt8;                                    {Filler, must be SignedByte to align on odd boundry}
  175.         seFiller1:                UInt8;                                    {Filler}
  176.         seFiller2:                UInt8;                                    {Filler}
  177.         seResult:                LONGINT;                                {Result of sLoad.}
  178.         seIOFileName:            LONGINT;                                {Pointer to IOFile name.}
  179.         seDevice:                UInt8;                                    {Which device to read from.}
  180.         sePartition:            UInt8;                                    {The partition.}
  181.         seOSType:                UInt8;                                    {Type of OS.}
  182.         seReserved:                UInt8;                                    {Reserved field.}
  183.         seRefNum:                UInt8;                                    {RefNum of the driver.}
  184.         seNumDevices:            UInt8;                                    { Number of devices to load.}
  185.         seBootState:            UInt8;                                    {State of StartBoot code.}
  186.     END;
  187. {  Principle  }
  188.  
  189. FUNCTION SReadByte(spBlkPtr: SpBlockPtr): OSErr;
  190.     {$IFC NOT GENERATINGCFM}
  191.     INLINE $205F, $7000, $A06E, $3E80;
  192.     {$ENDC}
  193. FUNCTION SReadWord(spBlkPtr: SpBlockPtr): OSErr;
  194.     {$IFC NOT GENERATINGCFM}
  195.     INLINE $205F, $7001, $A06E, $3E80;
  196.     {$ENDC}
  197. FUNCTION SReadLong(spBlkPtr: SpBlockPtr): OSErr;
  198.     {$IFC NOT GENERATINGCFM}
  199.     INLINE $205F, $7002, $A06E, $3E80;
  200.     {$ENDC}
  201. FUNCTION SGetCString(spBlkPtr: SpBlockPtr): OSErr;
  202.     {$IFC NOT GENERATINGCFM}
  203.     INLINE $205F, $7003, $A06E, $3E80;
  204.     {$ENDC}
  205. FUNCTION SGetBlock(spBlkPtr: SpBlockPtr): OSErr;
  206.     {$IFC NOT GENERATINGCFM}
  207.     INLINE $205F, $7005, $A06E, $3E80;
  208.     {$ENDC}
  209. FUNCTION SFindStruct(spBlkPtr: SpBlockPtr): OSErr;
  210.     {$IFC NOT GENERATINGCFM}
  211.     INLINE $205F, $7006, $A06E, $3E80;
  212.     {$ENDC}
  213. FUNCTION SReadStruct(spBlkPtr: SpBlockPtr): OSErr;
  214.     {$IFC NOT GENERATINGCFM}
  215.     INLINE $205F, $7007, $A06E, $3E80;
  216.     {$ENDC}
  217. {  Special  }
  218. FUNCTION SReadInfo(spBlkPtr: SpBlockPtr): OSErr;
  219.     {$IFC NOT GENERATINGCFM}
  220.     INLINE $205F, $7010, $A06E, $3E80;
  221.     {$ENDC}
  222. FUNCTION SReadPRAMRec(spBlkPtr: SpBlockPtr): OSErr;
  223.     {$IFC NOT GENERATINGCFM}
  224.     INLINE $205F, $7011, $A06E, $3E80;
  225.     {$ENDC}
  226. FUNCTION SPutPRAMRec(spBlkPtr: SpBlockPtr): OSErr;
  227.     {$IFC NOT GENERATINGCFM}
  228.     INLINE $205F, $7012, $A06E, $3E80;
  229.     {$ENDC}
  230. FUNCTION SReadFHeader(spBlkPtr: SpBlockPtr): OSErr;
  231.     {$IFC NOT GENERATINGCFM}
  232.     INLINE $205F, $7013, $A06E, $3E80;
  233.     {$ENDC}
  234. FUNCTION SNextSRsrc(spBlkPtr: SpBlockPtr): OSErr;
  235.     {$IFC NOT GENERATINGCFM}
  236.     INLINE $205F, $7014, $A06E, $3E80;
  237.     {$ENDC}
  238. FUNCTION SNextTypeSRsrc(spBlkPtr: SpBlockPtr): OSErr;
  239.     {$IFC NOT GENERATINGCFM}
  240.     INLINE $205F, $7015, $A06E, $3E80;
  241.     {$ENDC}
  242. FUNCTION SRsrcInfo(spBlkPtr: SpBlockPtr): OSErr;
  243.     {$IFC NOT GENERATINGCFM}
  244.     INLINE $205F, $7016, $A06E, $3E80;
  245.     {$ENDC}
  246. FUNCTION SCkCardStat(spBlkPtr: SpBlockPtr): OSErr;
  247.     {$IFC NOT GENERATINGCFM}
  248.     INLINE $205F, $7018, $A06E, $3E80;
  249.     {$ENDC}
  250. FUNCTION SReadDrvrName(spBlkPtr: SpBlockPtr): OSErr;
  251.     {$IFC NOT GENERATINGCFM}
  252.     INLINE $205F, $7019, $A06E, $3E80;
  253.     {$ENDC}
  254. FUNCTION SFindDevBase(spBlkPtr: SpBlockPtr): OSErr;
  255.     {$IFC NOT GENERATINGCFM}
  256.     INLINE $205F, $701B, $A06E, $3E80;
  257.     {$ENDC}
  258. FUNCTION SFindBigDevBase(spBlkPtr: SpBlockPtr): OSErr;
  259.     {$IFC NOT GENERATINGCFM}
  260.     INLINE $205F, $701C, $A06E, $3E80;
  261.     {$ENDC}
  262. {  Advanced  }
  263. FUNCTION InitSDeclMgr(spBlkPtr: SpBlockPtr): OSErr;
  264.     {$IFC NOT GENERATINGCFM}
  265.     INLINE $205F, $7020, $A06E, $3E80;
  266.     {$ENDC}
  267. FUNCTION SPrimaryInit(spBlkPtr: SpBlockPtr): OSErr;
  268.     {$IFC NOT GENERATINGCFM}
  269.     INLINE $205F, $7021, $A06E, $3E80;
  270.     {$ENDC}
  271. FUNCTION SCardChanged(spBlkPtr: SpBlockPtr): OSErr;
  272.     {$IFC NOT GENERATINGCFM}
  273.     INLINE $205F, $7022, $A06E, $3E80;
  274.     {$ENDC}
  275. FUNCTION SExec(spBlkPtr: SpBlockPtr): OSErr;
  276.     {$IFC NOT GENERATINGCFM}
  277.     INLINE $205F, $7023, $A06E, $3E80;
  278.     {$ENDC}
  279. FUNCTION SOffsetData(spBlkPtr: SpBlockPtr): OSErr;
  280.     {$IFC NOT GENERATINGCFM}
  281.     INLINE $205F, $7024, $A06E, $3E80;
  282.     {$ENDC}
  283. FUNCTION SInitPRAMRecs(spBlkPtr: SpBlockPtr): OSErr;
  284.     {$IFC NOT GENERATINGCFM}
  285.     INLINE $205F, $7025, $A06E, $3E80;
  286.     {$ENDC}
  287. FUNCTION SReadPBSize(spBlkPtr: SpBlockPtr): OSErr;
  288.     {$IFC NOT GENERATINGCFM}
  289.     INLINE $205F, $7026, $A06E, $3E80;
  290.     {$ENDC}
  291. FUNCTION SCalcStep(spBlkPtr: SpBlockPtr): OSErr;
  292.     {$IFC NOT GENERATINGCFM}
  293.     INLINE $205F, $7028, $A06E, $3E80;
  294.     {$ENDC}
  295. FUNCTION SInitSRsrcTable(spBlkPtr: SpBlockPtr): OSErr;
  296.     {$IFC NOT GENERATINGCFM}
  297.     INLINE $205F, $7029, $A06E, $3E80;
  298.     {$ENDC}
  299. FUNCTION SSearchSRT(spBlkPtr: SpBlockPtr): OSErr;
  300.     {$IFC NOT GENERATINGCFM}
  301.     INLINE $205F, $702A, $A06E, $3E80;
  302.     {$ENDC}
  303. FUNCTION SUpdateSRT(spBlkPtr: SpBlockPtr): OSErr;
  304.     {$IFC NOT GENERATINGCFM}
  305.     INLINE $205F, $702B, $A06E, $3E80;
  306.     {$ENDC}
  307. FUNCTION SCalcSPointer(spBlkPtr: SpBlockPtr): OSErr;
  308.     {$IFC NOT GENERATINGCFM}
  309.     INLINE $205F, $702C, $A06E, $3E80;
  310.     {$ENDC}
  311. FUNCTION SGetDriver(spBlkPtr: SpBlockPtr): OSErr;
  312.     {$IFC NOT GENERATINGCFM}
  313.     INLINE $205F, $702D, $A06E, $3E80;
  314.     {$ENDC}
  315. FUNCTION SPtrToSlot(spBlkPtr: SpBlockPtr): OSErr;
  316.     {$IFC NOT GENERATINGCFM}
  317.     INLINE $205F, $702E, $A06E, $3E80;
  318.     {$ENDC}
  319. FUNCTION SFindSInfoRecPtr(spBlkPtr: SpBlockPtr): OSErr;
  320.     {$IFC NOT GENERATINGCFM}
  321.     INLINE $205F, $702F, $A06E, $3E80;
  322.     {$ENDC}
  323. FUNCTION SFindSRsrcPtr(spBlkPtr: SpBlockPtr): OSErr;
  324.     {$IFC NOT GENERATINGCFM}
  325.     INLINE $205F, $7030, $A06E, $3E80;
  326.     {$ENDC}
  327. FUNCTION SDeleteSRTRec(spBlkPtr: SpBlockPtr): OSErr;
  328.     {$IFC NOT GENERATINGCFM}
  329.     INLINE $205F, $7031, $A06E, $3E80;
  330.     {$ENDC}
  331. FUNCTION OpenSlot(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  332. FUNCTION OpenSlotSync(paramBlock: ParmBlkPtr): OSErr;
  333.     {$IFC NOT GENERATINGCFM}
  334.     INLINE $205F, $A200, $3E80;
  335.     {$ENDC}
  336. FUNCTION OpenSlotAsync(paramBlock: ParmBlkPtr): OSErr;
  337.     {$IFC NOT GENERATINGCFM}
  338.     INLINE $205F, $A600, $3E80;
  339.     {$ENDC}
  340. {  Device Manager Slot Support  }
  341. FUNCTION SIntInstall(sIntQElemPtr: SQElemPtr; theSlot: INTEGER): OSErr;
  342.     {$IFC NOT GENERATINGCFM}
  343.     INLINE $301F, $205F, $A075, $3E80;
  344.     {$ENDC}
  345. FUNCTION SIntRemove(sIntQElemPtr: SQElemPtr; theSlot: INTEGER): OSErr;
  346.     {$IFC NOT GENERATINGCFM}
  347.     INLINE $301F, $205F, $A076, $3E80;
  348.     {$ENDC}
  349. FUNCTION SVersion(spBlkPtr: SpBlockPtr): OSErr;
  350.     {$IFC NOT GENERATINGCFM}
  351.     INLINE $205F, $7008, $A06E, $3E80;
  352.     {$ENDC}
  353. FUNCTION SetSRsrcState(spBlkPtr: SpBlockPtr): OSErr;
  354.     {$IFC NOT GENERATINGCFM}
  355.     INLINE $205F, $7009, $A06E, $3E80;
  356.     {$ENDC}
  357. FUNCTION InsertSRTRec(spBlkPtr: SpBlockPtr): OSErr;
  358.     {$IFC NOT GENERATINGCFM}
  359.     INLINE $205F, $700A, $A06E, $3E80;
  360.     {$ENDC}
  361. FUNCTION SGetSRsrc(spBlkPtr: SpBlockPtr): OSErr;
  362.     {$IFC NOT GENERATINGCFM}
  363.     INLINE $205F, $700B, $A06E, $3E80;
  364.     {$ENDC}
  365. FUNCTION SGetTypeSRsrc(spBlkPtr: SpBlockPtr): OSErr;
  366.     {$IFC NOT GENERATINGCFM}
  367.     INLINE $205F, $700C, $A06E, $3E80;
  368.     {$ENDC}
  369. FUNCTION SGetSRsrcPtr(spBlkPtr: SpBlockPtr): OSErr;
  370.     {$IFC NOT GENERATINGCFM}
  371.     INLINE $205F, $701D, $A06E, $3E80;
  372.     {$ENDC}
  373.  
  374. {$ALIGN RESET}
  375. {$POP}
  376.  
  377. {$SETC UsingIncludes := SlotsIncludes}
  378.  
  379. {$ENDC} {__SLOTS__}
  380.  
  381. {$IFC NOT UsingIncludes}
  382.  END.
  383. {$ENDC}
  384.