Changeset 302


Ignore:
Timestamp:
Sep 2, 2017, 9:18:21 PM (3 years ago)
Author:
Valery V. Sedletski
Message:

change IBM's DDK headers to our own ones.

Location:
trunk/src
Files:
7 deleted
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/ifs/ifsachk.c

    r274 r302  
    44#include <os2.h>
    55
    6 #include "extboot.h"
    76#include "portable.h"
    87#include "fat32def.h"
  • trunk/src/ifs/ifslog.c

    r296 r302  
    1313#include "portable.h"
    1414#include "fat32ifs.h"
    15 
    16 #include "infoseg.h"
    1715
    1816#define LOGBUF_SIZE 8192
  • trunk/src/ifs/ifsmount.c

    r298 r302  
    1212#include "portable.h"
    1313#include "fat32ifs.h"
    14 
    15 #include "devhdr.h"
    16 #include "devcmd.h"
    17 #include "sas.h"
    1814
    1915/*
  • trunk/src/include/devhelp.h

    r97 r302  
    1 /* DEVHELP.H - DevHelp header file for Watcom-based device drivers
    2 */
    3 
    4 #ifndef DEVHELP_INCLUDED
    5 #define DEVHELP_INCLUDED
    6 
    7 #ifdef __WATCOMC__
    8 
    9 #ifndef OS2_INCLUDED
    10 #define INCL_NOPMAPI
    11 #include <os2.h>
    12 #endif
    13 
    14 #ifdef __cplusplus
    15 extern "C" {
    16 #endif
    17 
    18 #ifdef __WATCOMC__
    19 typedef VOID    FAR *PVOID;
    20 typedef PVOID   FAR *PPVOID;
    21 #endif
    22 
    23 
    24 typedef ULONG   LIN;               // 32-Bit Linear Addess
    25 typedef ULONG   __far *PLIN;       // 16:16 Ptr to a 32-Bit Linear Addess
    26 
    27 typedef struct _PAGELIST {
    28   ULONG    PhysAddr;
    29   ULONG    Size;
    30 } PAGELIST, __near *NPPAGELIST, __far *PPAGELIST;
    31 
    32 extern ULONG Device_Help;
    33 extern USHORT DGROUP;
    34 
    35 #define DEVHELP_CALL \
    36    "call dword ptr ds:[Device_Help]" \
    37    "jc   error" \
    38    "sub  ax,ax" \
    39    "error:" \
    40    value [ax]
    41 
    42 USHORT DevHelp_ABIOSCall(USHORT Lid, NPBYTE ReqBlk, USHORT Entry_Type);
    43 #pragma aux DevHelp_ABIOSCall = \
    44    "mov  dl,36h" \
    45    DEVHELP_CALL \
    46    parm caller [ax] [si] [dh] \
    47    modify exact [ax dl];
    48 
    49 USHORT DevHelp_ABIOSCommonEntry(NPBYTE ReqBlk, USHORT Entry_Type);
    50 #pragma aux DevHelp_ABIOSCommonEntry = \
    51    "mov  dl,37h" \
    52    DEVHELP_CALL \
    53    parm caller [si] [dh] \
    54    modify exact [ax dl];
    55 
    56 USHORT DevHelp_AllocateCtxHook(NPFN HookHandler, PULONG HookHandle);
    57 #pragma aux DevHelp_AllocateCtxHook = \
    58    ".386p" \
    59    "push bx" \
    60    "movzx   eax,ax" \
    61    "mov  ebx,-1" \
    62    "mov  dl,63h" \
    63    "call dword ptr ds:[Device_Help]" \
    64    "pop  bx" \
    65    "jc   error" \
    66    "mov  es:[bx],eax" \
    67    "sub  ax,ax" \
    68    "error:" \
    69    value [ax] \
    70    parm caller nomemory [ax] [es bx] \
    71    modify exact [ax bx dl es];
    72 
    73 USHORT DevHelp_AllocGDTSelector(PSEL Selectors, USHORT Count);
    74 #pragma aux DevHelp_AllocGDTSelector = \
    75    "mov  dl,2Dh" \
    76    DEVHELP_CALL \
    77    parm caller [es di] [cx] \
    78    modify nomemory exact [ax dl];
    79 
    80 #define MEMTYPE_ABOVE_1M   0
    81 #define MEMTYPE_BELOW_1M   1
    82 
    83 USHORT DevHelp_AllocPhys(ULONG lSize, USHORT MemType, PULONG PhysAddr);
    84 #pragma aux DevHelp_AllocPhys = \
    85    "xchg ax,bx" \
    86    "mov  dl,18h" \
    87    "call dword ptr ds:[Device_Help]" \
    88    "jc   error" \
    89    "mov  es:[di],bx" \
    90    "mov  es:[di+2],ax" \
    91    "sub  ax,ax" \
    92    "error:" \
    93    value [ax] \
    94    parm caller nomemory [ax bx] [dh] [es di] \
    95    modify exact [ax bx dx];
    96 
    97 #define WAIT_NOT_ALLOWED 0
    98 #define WAIT_IS_ALLOWED  1
    99 
    100 USHORT DevHelp_AllocReqPacket(USHORT WaitFlag, PBYTE __far *ReqPktAddr);
    101 #pragma aux DevHelp_AllocReqPacket = \
    102    "mov  dl,0Dh", \
    103    "call dword ptr ds:[Device_Help]" \
    104    "jc   error" \
    105    "push es" \
    106    "push bx" \
    107    "mov  bx,sp" \
    108    "les  bx,ss:[bx]" \
    109    "pop  es:[bx]" \
    110    "pop  es:[bx+2]" \
    111    "error:" \
    112    "mov  ax,0" \
    113    "sbb  ax,0" \
    114    value [ax] \
    115    parm caller [dh] [] \
    116    modify exact [ax bx dl es];
    117 
    118 USHORT DevHelp_ArmCtxHook(ULONG HookData, ULONG HookHandle);
    119 #pragma aux DevHelp_ArmCtxHook = \
    120    ".386p" \
    121    "mov  bx,sp" \
    122    "mov  dl,65h", \
    123    "mov  eax,ss:[bx]" \
    124    "mov  ecx,-1" \
    125    "mov  ebx,ss:[bx+4]" \
    126    DEVHELP_CALL \
    127    parm caller nomemory [] \
    128    modify nomemory exact [ax bx cx dl];
    129 
    130 typedef struct _IDCTABLE {
    131   USHORT   Reserved[3];
    132   VOID     (__far *ProtIDCEntry) (VOID);
    133   USHORT   ProtIDC_DS;
    134 } IDCTABLE, __near *NPIDCTABLE;
    135 
    136 USHORT DevHelp_AttachDD(NPSZ DDName, NPBYTE DDTable);
    137 #pragma aux DevHelp_AttachDD = \
    138    "mov  dl,2Ah" \
    139    "call dword ptr ds:[Device_Help]" \
    140    "mov  ax,0" \
    141    "sbb  ax,0" \
    142    value [ax] \
    143    parm caller [bx] [di] \
    144    modify exact [ax dl];
    145 
    146 USHORT DevHelp_Beep(USHORT Frequency, USHORT DurationMS);
    147 #pragma aux DevHelp_Beep = \
    148    "mov  dl,52h" \
    149    DEVHELP_CALL \
    150    parm caller nomemory [bx] [cx] \
    151    modify nomemory exact [ax dx];
    152 
    153 USHORT DevHelp_CloseEventSem(ULONG hEvent);
    154 #pragma aux DevHelp_CloseEventSem = \
    155    ".386p" \
    156    "movzx   esp,sp" \
    157    "mov  dl,68h" \
    158    "mov  eax,[esp]" \
    159    DEVHELP_CALL \
    160    parm caller nomemory [] \
    161    modify nomemory exact [ax dl];
    162 
    163 USHORT DevHelp_DeRegister(USHORT MonitorPID, USHORT MonitorHandle, PUSHORT MonitorsLeft);
    164 #pragma aux DevHelp_DeRegister = \
    165    "mov  dl,21h" \
    166    "call dword ptr ds:[Device_Help]" \
    167    "jc   error" \
    168    "mov  es:[di],ax" \
    169    "sub  ax,ax" \
    170    "error:" \
    171    value [ax] \
    172    parm caller nomemory [bx] [ax] [es di] \
    173    modify exact [ax dl];
    174 
    175 USHORT DevHelp_DevDone(PBYTE ReqPktAddr);
    176 #pragma aux DevHelp_DevDone = \
    177    "mov  dl,1" \
    178    DEVHELP_CALL \
    179    parm caller [es bx] \
    180    modify exact [ax dl];
    181 
    182 #define DYNAPI_CALLGATE16       0x0001   /* 16:16 CallGate     */
    183 #define DYNAPI_CALLGATE32       0x0000   /*  0:32 CallGate     */
    184 
    185 #define DYNAPI_ROUTINE16        0x0002   /* 16:16 Routine Addr */
    186 #define DYNAPI_ROUTINE32        0x0000   /*  0:32 Routine Addr */
    187 
    188 USHORT DevHelp_DynamicAPI(PVOID  RoutineAddress, USHORT ParmCount, USHORT Flags, PSEL CallGateSel);
    189 #pragma aux DevHelp_DynamicAPI = \
    190    "mov  dl,6Ch" \
    191    "xchg ax,bx" \
    192    "call dword ptr ds:[Device_Help]" \
    193    "jc   error" \
    194    "mov  es:[si],di" \
    195    "sub  ax,ax" \
    196    "error:" \
    197    value [ax] \
    198    parm caller [ax bx] [cx] [dh] [es si] \
    199    modify exact [ax bx di dl];
    200 
    201 USHORT DevHelp_EOI(USHORT IRQLevel);
    202 #pragma aux DevHelp_EOI = \
    203    "mov  dl,31h" \
    204    "call dword ptr ds:[Device_Help]" \
    205    "sub  ax,ax" \
    206    value [ax] \
    207    parm caller nomemory [al] \
    208    modify nomemory exact [ax dl];
    209 
    210 USHORT DevHelp_FreeCtxHook(ULONG HookHandle);
    211 #pragma aux DevHelp_FreeCtxHook = \
    212    ".386p" \
    213    "movzx   esp,sp" \
    214    "mov  dl,64h", \
    215    "mov  eax,[esp]" \
    216    DEVHELP_CALL \
    217    parm caller nomemory [] \
    218    modify nomemory exact [ax dl];
    219 
    220 USHORT DevHelp_FreeGDTSelector(SEL Selector);
    221 #pragma aux DevHelp_FreeGDTSelector = \
    222    "mov  dl,53h" \
    223    DEVHELP_CALL \
    224    parm caller nomemory [ax] \
    225    modify nomemory exact [ax dl];
    226 
    227 USHORT DevHelp_FreeLIDEntry(USHORT LIDNumber);
    228 #pragma aux DevHelp_FreeLIDEntry = \
    229    "mov  dl,35h" \
    230    DEVHELP_CALL \
    231    parm caller nomemory [ax] \
    232    modify nomemory exact [ax dl];
    233 
    234 USHORT DevHelp_FreePhys(ULONG PhysAddr);
    235 #pragma aux DevHelp_FreePhys = \
    236    "xchg ax,bx" \
    237    "mov  dl,19h" \
    238    "call dword ptr ds:[Device_Help]" \
    239    "mov  ax,0" \
    240    "sbb  ax,0" \
    241    value [ax] \
    242    parm caller nomemory [ax bx] \
    243    modify exact [ax bx dl];
    244 
    245 USHORT DevHelp_FreeReqPacket(PBYTE ReqPktAddr);
    246 #pragma aux DevHelp_FreeReqPacket = \
    247    "mov  dl,0Eh", \
    248    "call dword ptr ds:[Device_Help]" \
    249    "sub  ax,ax" \
    250    value [ax] \
    251    parm caller [es bx] \
    252    modify exact [ax dl];
    253 
    254 typedef struct _SELDESCINFO {
    255   UCHAR    Type;                       
    256   UCHAR    Granularity;                 
    257   LIN      BaseAddr;                   
    258   ULONG    Limit;                       
    259 } SELDESCINFO, __far *PSELDESCINFO; 
     1 #ifndef __DEVHELP_H__
     2 #define __DEVHELP_H__
     3
     4 #ifdef __cplusplus
     5 extern "C" {
     6 #endif
     7
     8 #define MSG_MEMORY_ALLOCATION_FAILED 0x00
     9 #define ERROR_LID_ALREADY_OWNED      0x01
     10 #define ERROR_LID_DOES_NOT_EXIST     0x02
     11 #define ERROR_ABIOS_NOT_PRESENT      0x03
     12 #define ERROR_NOT_YOUR_LID           0x04
     13 #define ERROR_INVALID_ENTRY_POINT    0x05
     14
     15 #ifdef __WATCOMC__
     16
     17 #ifndef OS2_INCLUDED
     18 # define INCL_NOPMAPI
     19 # include <os2.h>
     20 #endif
     21
     22 typedef VOID  FAR   *PVOID;
     23 typedef PVOID FAR   *PPVOID;
     24
     25 typedef ULONG LIN;
     26 typedef ULONG FAR   *PLIN;
     27
     28 extern ULONG Device_Help;
     29 extern USHORT DGROUP;
     30
     31 #define DEVICE_HELP \
     32    "call    dword ptr ds:[Device_Help]" \
     33    "jc      error" \
     34    "sub     ax, ax" \
     35    "error:" \
     36    value [ax]
     37
     38 //
     39 // memory operations (alloc/free/etc)
     40 //
     41
     42 APIRET DevHelp_AllocGDTSelector(
     43    PSEL pSels,
     44    USHORT cbSels
     45 );
     46
     47 #pragma aux DevHelp_AllocGDTSelector = \
     48    "mov     dl, 2Dh" \
     49    DEVICE_HELP \
     50    parm caller [es di] [cx] \
     51    modify nomemory exact [ax dl];
     52
     53 #define MEMTYPE_ABOVE_1M   0
     54 #define MEMTYPE_BELOW_1M   1
     55
     56 APIRET DevHelp_AllocPhys(
     57    ULONG ulSize,
     58    USHORT usMemType,
     59    PULONG pPhysAddr
     60 );
     61
     62 #pragma aux DevHelp_AllocPhys = \
     63    "mov     dl, 18h" \
     64    "xchg    ax, bx" \
     65    "call    dword ptr ds:[Device_Help]" \
     66    "jc      error" \
     67    "mov     es:[di], bx" \
     68    "mov     es:[di+2], ax" \
     69    "sub     ax, ax" \
     70    "error:" \
     71    value [ax] \
     72    parm caller nomemory [ax bx] [dh] [es di] \
     73    modify exact [ax bx dx];
     74
     75 APIRET DevHelp_FreePhys(
     76    ULONG pPhysAddr
     77 );
     78
     79 #pragma aux DevHelp_FreePhys = \
     80    "mov     dl, 19h" \
     81    "xchg    ax, bx" \
     82    "call    dword ptr ds:[Device_Help]" \
     83    "mov     ax, 0" \
     84    "sbb     ax, 0" \
     85    value [ax] \
     86    parm caller nomemory [ax bx] \
     87    modify exact [ax bx dl];
     88
     89 APIRET DevHelp_PhysToGDTSelector(
     90    ULONG pPhysAddr,
     91    USHORT usSize,
     92    SEL Sel
     93 );
     94
     95 #pragma aux DevHelp_PhysToGDTSelector = \
     96    "mov     dl, 2Eh" \
     97    "xchg    ax, bx" \
     98    DEVICE_HELP \
     99    parm nomemory [ax bx] [cx] [si] \
     100    modify nomemory exact [ax bx dl];
     101
     102 APIRET DevHelp_PhysToGDTSel(
     103    ULONG pPhysAddr,
     104    ULONG ulSize,
     105    SEL Sel,
     106    UCHAR cAccess
     107 );
     108
     109 #pragma aux DevHelp_PhysToGDTSel = \
     110    ".386p" \
     111    "push    bp" \
     112    "mov     dl, 54h" \
     113    "mov     bp, sp" \
     114    "mov     si, [bp+10]" \
     115    "mov     dh, [bp+12]" \
     116    "mov     ecx, [bp+6]" \
     117    "mov     eax, [bp+2]" \
     118    "call    dword ptr ds:[Device_Help]" \
     119    "jc      error" \
     120    "xor     ax, ax" \
     121    "error:" \
     122    "pop     bp" \
     123    value [ax] \
     124    parm caller nomemory [] \
     125    modify nomemory exact [ax cx dx si];
     126
     127 APIRET DevHelp_PhysToVirt(
     128    ULONG pPhysAddr,
     129    USHORT usLen,
     130    PVOID SelOffset,
     131    PUSHORT pusModeFlag
     132 );
     133
     134 #pragma aux DevHelp_PhysToVirt = \
     135    "xchg    ax, bx" \
     136    "mov     dx, 15h" \
     137    "push    ds" \
     138    "call    dword ptr ds:[Device_Help]" \
     139    "jc      error" \
     140    "sub     ax, ax" \
     141    "mov     es:[di], si" \
     142    "mov     es:[di+2], ds" \
     143    "error:" \
     144    "pop     ds" \
     145    value [ax] \
     146    parm caller nomemory [bx ax] [cx] [es di] [] \
     147    modify exact [ax bx dx si];
     148
     149 APIRET DevHelp_VirtToPhys(
     150    PVOID SelOffset,
     151    PULONG pPhysAddr
     152 );
     153
     154 #pragma aux DevHelp_VirtToPhys = \
     155    "push    ds" \
     156    "push    es" \
     157    "mov     dl, 16h" \
     158    "mov     si, ds" \
     159    "mov     es, si" \
     160    "mov     ds, bx" \
     161    "mov     si, ax" \
     162    "call    dword ptr ds:[Device_Help]" \
     163    "pop     es" \
     164    "mov     es:[di], bx" \
     165    "mov     es:[di+2], ax" \
     166    "pop     ds" \
     167    "xor     ax, ax" \
     168    value [ax] \
     169    parm caller nomemory [ax bx] [es di] \
     170    modify exact [ax bx dl es si];
     171
     172 #define SELTYPE_R3CODE    0
     173 #define SELTYPE_R3DATA    1
     174 #define SELTYPE_FREE      2
     175 #define SELTYPE_R2CODE    3
     176 #define SELTYPE_R2DATA    4
     177 #define SELTYPE_R3VIDEO   5
     178
     179 APIRET DevHelp_PhysToUVirt(
     180    ULONG pPhysAddr,
     181    USHORT usLen,
     182    USHORT usFlags,
     183    USHORT usTagType,
     184    PVOID SelOffset
     185 );
     186
     187 #pragma aux DevHelp_PhysToUVirt = \
     188    "mov     dl, 17h" \
     189    "xchg    ax, bx" \
     190    "call    dword ptr ds:[Device_Help]" \
     191    "jc      error" \
     192    "push    bx" \
     193    "push    es" \
     194    "mov     bx, sp" \
     195    "les     bx, ss:[bx+4]" \
     196    "pop     es:[bx+2]" \
     197    "pop     es:[bx]" \
     198    "xor     ax, ax" \
     199    "error:" \
     200    value [ax] \
     201    parm caller nomemory [bx ax] [cx] [dh] [si] [] \
     202    modify exact [ax bx dl es];
     203
     204 #define LOCKTYPE_SHORT_ANYMEM 0x00
     205 #define LOCKTYPE_LONG_ANYMEM  0x01
     206 #define LOCKTYPE_LONG_HIGHMEM 0x03
     207 #define LOCKTYPE_SHORT_VERIFY 0x04
     208
     209 APIRET DevHelp_Lock(
     210    SEL Sel,
     211    USHORT usLockType,
     212    USHORT WusaitFlag,
     213    PULONG hLock
     214 );
     215
     216 #pragma aux DevHelp_Lock = \
     217    "mov     dl, 13h" \
     218    "call    dword ptr ds:[Device_Help]" \
     219    "jc      error" \
     220    "mov     es:[di], bx" \
     221    "mov     es:[di+2], ax" \
     222    "xor     ax, ax" \
     223    "error:" \
     224    value [ax] \
     225    parm caller [ax] [bh] [bl] [es di] \
     226    modify exact [ax dl];
     227
     228 APIRET DevHelp_UnLock(
     229    ULONG hLock
     230 );
     231
     232 #pragma aux DevHelp_UnLock = \
     233    "mov     dl, 14h" \
     234    "xchg    ax, bx" \
     235    DEVICE_HELP \
     236    parm nomemory [ax bx] \
     237    modify nomemory exact [ax bx dl];
     238
     239 #define VERIFY_READONLY  0
     240 #define VERIFY_READWRITE 1
     241
     242 APIRET DevHelp_VerifyAccess(
     243    SEL Sel,
     244    USHORT usLen,
     245    USHORT usMemOffset,
     246    UCHAR ucAccessFlag
     247 );
     248
     249 #pragma aux DevHelp_VerifyAccess = \
     250    "mov     dl, 27h" \
     251    DEVICE_HELP \
     252    parm caller nomemory [ax] [cx] [di] [dh] \
     253    modify nomemory exact [ax dl];
     254
     255 #define VMDHA_16M          0x0001
     256 #define VMDHA_FIXED        0x0002
     257 #define VMDHA_SWAP         0x0004
     258 #define VMDHA_CONTIG       0x0008
     259 #define VMDHA_PHYS         0x0010
     260 #define VMDHA_PROCESS      0x0020
     261 #define VMDHA_SGSCONT      0x0040
     262 #define VMDHA_RESERVE      0x0100
     263 #define VMDHA_USEHIGHMEM   0x0800
     264 
     265 APIRET DevHelp_VMAlloc(
     266    ULONG ulFlags,
     267    ULONG ulSize,
     268    ULONG pPhysAddr,
     269    PLIN pLinearAddr,
     270    PPVOID SelOffset
     271 );
     272
     273 #pragma aux DevHelp_VMAlloc = \
     274    ".386p" \
     275    "mov     dl, 57h" \
     276    "movzx   esp, sp" \
     277    "mov     eax, [esp]" \
     278    "mov     ecx, [esp+4]" \
     279    "mov     edi, [esp+8]" \
     280    "call    dword ptr ds:[Device_Help]" \
     281    "jc      error" \
     282    "les     di, [esp+16]" \
     283    "mov     es:[di], ecx" \
     284    "les     di, [esp+12]" \
     285    "mov     es:[di], eax" \
     286    "xor     ax, ax" \
     287    "error:" \
     288    value [ax] \
     289    parm caller nomemory [] \
     290    modify exact [ax cx di dl es];
     291
     292 APIRET DevHelp_VMFree(
     293    LIN LinAddr
     294 );
     295
     296 #pragma aux DevHelp_VMFree = \
     297    ".386p" \
     298    "mov     dl, 58h" \
     299    "movzx   esp, sp" \
     300    "mov     eax, [esp]" \
     301    DEVICE_HELP \
     302    parm caller nomemory [] \
     303    modify nomemory exact [ax dl];
     304
     305 #define VMDHL_NOBLOCK        0x0001
     306 #define VMDHL_CONTIGUOUS     0x0002
     307 #define VMDHL_16M            0x0004
     308 #define VMDHL_WRITE          0x0008
     309 #define VMDHL_LONG           0x0010
     310 #define VMDHL_VERIFY         0x0020
     311
     312 APIRET DevHelp_VMLock(
     313    ULONG ulFlags,
     314    LIN LinAddr,
     315    ULONG ulLen,
     316    LIN pPagelist,
     317    LIN pLockHandle,
     318    PULONG pulPageListCnt
     319 );
     320
     321 #pragma aux DevHelp_VMLock = \
     322    ".386p" \
     323    "mov     dl, 55h" \
     324    "mov     eax, [esp]" \
     325    "mov     edi, [esp+12]" \
     326    "mov     esi, [esp+16]" \
     327    "mov     ebx, [esp+4]" \
     328    "mov     ecx, [esp+8]" \
     329    "call    dword ptr ds:[Device_Help]" \
     330    "jc      error" \
     331    "les     bx, [esp+20]" \
     332    "mov     es:[bx], eax" \
     333    "xor     ax, ax" \
     334    "error:" \
     335    value [ax] \
     336    parm caller nomemory [] \
     337    modify exact [ax bx cx dl si di es];
     338
     339 APIRET DevHelp_VMUnLock(
     340    LIN phLock
     341 );
     342
     343 #pragma aux DevHelp_VMUnLock = \
     344    ".386p" \
     345    "mov     dl, 56h" \
     346    "mov     esi, [esp]" \
     347    DEVICE_HELP \
     348    parm caller [] \
     349    modify exact [ax si dl];
     350
     351 #define VMDHPG_READONLY     0x0000
     352 #define VMDHPG_WRITE        0x0001
     353
     354 APIRET DevHelp_VMProcessToGlobal(
     355    ULONG ulFlags,
     356    LIN LinAddr,
     357    ULONG ulLen,
     358    PLIN pGlobLinAddr
     359 );
     360
     361 #pragma aux DevHelp_ProcessToGlobal = \
     362    ".386p" \
     363    "mov     dl, 59h" \
     364    "mov     eax, [esp]" \
     365    "mov     ecx, [esp+8]" \
     366    "mov     ebx, [esp+4]" \
     367    "call    dword ptr ds:[Device_Help]" \
     368    "jc      error" \
     369    "les     bx, [esp+12]" \
     370    "mov     es:[bx], eax" \
     371    "xor    ax, ax" \
     372    "error:" \
     373    value [ax] \
     374    parm caller nomemory [] \
     375    modify exact [ax bx cx dl es];
     376
     377 #define VMDHGP_WRITE       0x0001
     378 #define VMDHGP_SELMAP      0x0002
     379 #define VMDHGP_SGSCONTROL  0x0004
     380 #define VMDHGP_4MEG        0x0008
     381
     382 APIRET DevHelp_VMGlobalToProcess(
     383    ULONG ulFlags,
     384    LIN LinAddr,
     385    ULONG ulLen,
     386    PLIN pProcLinAddr
     387 );
     388
     389 #pragma aux DevHelp_VMGlobalToProcess = \
     390    ".386p" \
     391    "mov     dl, 5ah" \
     392    "mov     eax, [esp]" \
     393    "mov     ecx, [esp+8]" \
     394    "mov     ebx, [esp+4]" \
     395    "call    dword ptr ds:[Device_Help]" \
     396    "jc      error" \
     397    "les     bx, [esp+12]" \
     398    "mov     es:[bx], eax" \
     399    "xor     ax, ax" \
     400    "error:" \
     401    value [ax] \
     402    parm caller nomemory [] \
     403    modify exact [ax bx cx dl es];
     404
     405 APIRET DevHelp_VirtToLin(
     406    SEL Sel,
     407    ULONG ulOffset,
     408    PLIN pLinAddr
     409 );
     410
     411 #pragma aux DevHelp_VirtToLin = \
     412    ".386p" \
     413    "mov     dl, 5bh" \
     414    "movzx   esp, sp" \
     415    "mov     esi, [esp]" \
     416    "call    dword ptr ds:[Device_Help]" \
     417    "jc      error" \
     418    "les     bx, [esp+4]" \
     419    "mov     es:[bx], eax" \
     420    "xor     ax, ax" \
     421    "error:" \
     422    value [ax] \
     423    parm caller nomemory [ax] [] \
     424    modify exact [ax si es bx dl];
     425
     426 APIRET DevHelp_LinToGDTSelector(
     427    SEL Sel,
     428    LIN LinAddr,
     429    ULONG ulSize
     430 );
     431
     432 #pragma aux DevHelp_LinToGDTSelector = \
     433    ".386p" \
     434    "mov     dl, 5ch" \
     435    "mov     bx, sp" \
     436    "mov     ebx, ss:[bx]" \
     437    "mov     ecx, ss:[bx+4]" \
     438    "call    dword ptr ds:[Device_Help]" \
     439    "jc      error" \
     440    "xor     ax, ax" \
     441    "error:" \
     442    value [ax] \
     443    parm caller nomemory [ax] [] \
     444    modify nomemory exact [ax bx cx dl];
     445
     446 typedef struct _SELDESCINFO
     447 {
     448    UCHAR Type;
     449    UCHAR Granularity;
     450    LIN BaseAddr;
     451    ULONG Limit;
     452 } SELDESCINFO, FAR *PSELDESCINFO; 
    260453                                       
    261 typedef struct _GATEDESCINFO {         
    262   UCHAR    Type;                       
    263   UCHAR    ParmCount;                   
    264   SEL      Selector;                   
    265   USHORT   Reserved_1;                 
    266   ULONG    Offset;                     
    267 } GATEDESCINFO, __far *PGATEDESCINFO;
    268 
    269 USHORT DevHelp_GetDescInfo(SEL Selector, PBYTE SelInfo);
    270 #pragma aux DevHelp_GetDescInfo = \
    271    ".386p" \
    272    "mov  dl,5Dh" \
    273    "call dword ptr ds:[Device_Help]" \
    274    "jc   error" \
    275    "mov  es:[bx],ax" \
    276    "mov  es:[bx+2],ecx" \
    277    "mov  es:[bx+6],edx" \
    278    "sub  ax,ax" \
    279    "error:" \
    280    value [ax] \
    281    parm caller nomemory [ax] [es bx] \
    282    modify exact [ax cx dx];
    283 
    284 USHORT DevHelp_GetDeviceBlock(USHORT Lid, PPVOID DeviceBlockPtr);
    285 #pragma aux DevHelp_GetDeviceBlock = \
    286    "mov  dl,38h" \
    287    "call dword ptr ds:[Device_Help]" \
    288    "jc   error" \
    289    "mov  es:[si],dx" \
    290    "mov  es:[si+2],cx" \
    291    "sub  ax,ax" \
    292    "error:" \
    293    value [ax] \
    294    parm caller nomemory [ax] [es si] \
    295    modify exact [ax bx cx dx];
    296 
    297 #define DHGETDOSV_SYSINFOSEG            1
    298 #define DHGETDOSV_LOCINFOSEG            2
    299 #define DHGETDOSV_VECTORSDF             4
    300 #define DHGETDOSV_VECTORREBOOT          5
    301 #define DHGETDOSV_YIELDFLAG             7                            /*@V76282*/
    302 #define DHGETDOSV_TCYIELDFLAG           8                            /*@V76282*/
    303 #define DHGETDOSV_DOSCODEPAGE           11                           /*@V76282*/
    304 #define DHGETDOSV_INTERRUPTLEV          13
    305 #define DHGETDOSV_DEVICECLASSTABLE      14                           /*@V76282*/
    306 #define DHGETDOSV_DMQSSELECTOR          15                           /*@V76282*/
    307 #define DHGETDOSV_APMINFO               16                           /*@V76282*/
    308 
    309 USHORT DevHelp_GetDOSVar(USHORT VarNumber, USHORT VarMember, PPVOID KernalVar);
    310 #pragma aux DevHelp_GetDOSVar = \
    311    "mov  dl,24h" \
    312    "call dword ptr ds:[Device_Help]" \
    313    "mov  es:[di],bx" \
    314    "mov  es:[di+2],ax" \
    315    "sub  ax,ax" \
    316    value [ax] \
    317    parm caller nomemory [al] [cx] [es di] \
    318    modify exact [ax bx dl];
    319 
    320 USHORT DevHelp_GetLIDEntry(USHORT DeviceType, SHORT LIDIndex, USHORT Type, PUSHORT LID);
    321 #pragma aux DevHelp_GetLIDEntry = \
    322    "mov  dl,34h" \
    323    "call dword ptr ds:[Device_Help]" \
    324    "jc   error" \
    325    "mov  es:[di],ax" \
    326    "sub  ax,ax" \
    327    "error:" \
    328    value [ax] \
    329    parm caller nomemory [al] [bl] [dh] [es di] \
    330    modify exact [ax dl];
    331 
    332 USHORT DevHelp_InternalError(PSZ MsgText, USHORT MsgLength );
    333 #pragma aux DevHelp_InternalError aborts = \
    334    "push ds" \
    335    "push es" \
    336    "pop  ds" \
    337    "pop  es" \
    338    "mov  dl,2Bh" \
    339    "jmp dword ptr ds:[Device_Help]" \
    340    parm [es si] [di] \
    341    modify nomemory exact [];
    342 
    343 USHORT DevHelp_LinToGDTSelector(SEL Selector, LIN LinearAddr, ULONG Size);
    344 #pragma aux DevHelp_LinToGDTSelector = \
    345    ".386p" \
    346    "mov  bx,sp" \
    347    "mov  dl,5Ch" \
    348    "mov  ecx,ss:[bx+4]" \
    349    "mov  ebx,ss:[bx]" \
    350    "call dword ptr ds:[Device_Help]" \
    351    "jc   error" \
    352    "sub  ax,ax" \
    353    "error:" \
    354    value [ax] \
    355    parm caller nomemory [ax] [] \
    356    modify nomemory exact [ax bx cx dl];
    357 
    358 #define LOCKTYPE_SHORT_ANYMEM    0x00
    359 #define LOCKTYPE_LONG_ANYMEM     0x01
    360 #define LOCKTYPE_LONG_HIGHMEM    0x03
    361 #define LOCKTYPE_SHORT_VERIFY    0x04
    362 
    363 USHORT DevHelp_Lock(SEL Segment, USHORT LockType, USHORT WaitFlag, PULONG LockHandle);
    364 #pragma aux DevHelp_Lock = \
    365    "mov  dl,13h" \
    366    "call dword ptr ds:[Device_Help]" \
    367    "jc   error" \
    368    "mov  es:[di],bx" \
    369    "mov  es:[di+2],ax" \
    370    "sub  ax,ax" \
    371    "error:" \
    372    value [ax] \
    373    parm caller [ax] [bh] [bl] [es di] \
    374    modify exact [ax dl];
    375 
    376 USHORT DevHelp_MonFlush(USHORT MonitorHandle);
    377 #pragma aux DevHelp_MonFlush = \
    378    "mov  dl,23h" \
    379    DEVHELP_CALL \
    380    parm caller [ax] \
    381    modify exact [ax dl];
    382 
    383 USHORT DevHelp_MonitorCreate(USHORT MonitorHandle, PBYTE FinalBuffer, NPFN NotifyRtn, PUSHORT MonitorChainHandle);
    384 #pragma aux DevHelp_MonitorCreate = \
    385    ".386p" \
    386    "mov  dl,1Fh" \
    387    "call dword ptr ds:[Device_Help]" \
    388    "jc   error" \
    389    "mov  si,[esp]" \
    390    "mov  es,[esp+2]" \
    391    "mov  es:[si],ax" \
    392    "sub  ax,ax" \
    393    "error:" \
    394    value [ax] \
    395    parm caller [ax] [es si] [di] [] \
    396    modify exact [ax dl es si];
    397 
    398 /* DevHelp_MonWrite has one change compared to the original specification.
    399    The DataRecord parameter was originally a far (16:16) pointer.  It has
    400    been changed to a near pointer because DS must point to the default data
    401    segment and therefore the DataRecord parameter must be near.  This
    402    allows the compiler to catch the error.
    403 */
    404 
    405 USHORT DevHelp_MonWrite(USHORT MonitorHandle, NPBYTE DataRecord, USHORT Count, ULONG TimeStampMS, USHORT WaitFlag);
    406 #pragma aux DevHelp_MonWrite = \
    407    "mov  dl,22h" \
    408    DEVHELP_CALL \
    409    parm caller [ax] [si] [cx] [di bx] [dh] \
    410    modify exact [ax dl];
    411 
    412 USHORT DevHelp_OpenEventSem(ULONG hEvent);
    413 #pragma aux DevHelp_OpenEventSem = \
    414    ".386p" \
    415    "mov  eax,[esp]" \
    416    "mov  dl,67h" \
    417    DEVHELP_CALL \
    418    parm caller nomemory [] \
    419    modify nomemory exact [ax dl];
    420 
    421 #define GDTSEL_R3CODE           0x0000                               /*@V76282*/
    422 #define GDTSEL_R3DATA           0x0001                               /*@V76282*/
    423 #define GDTSEL_R2CODE           0x0003                               /*@V76282*/
    424 #define GDTSEL_R2DATA           0x0004                               /*@V76282*/
    425 #define GDTSEL_R0CODE           0x0005                               /*@V76282*/
    426 #define GDTSEL_R0DATA           0x0006                               /*@V76282*/
    427 
    428 /* GDTSEL_ADDR32 may be OR'd with above defines */                   /*@V76282*/
    429 #define GDTSEL_ADDR32           0x0080                               /*@V76282*/
    430 
    431 USHORT DevHelp_PageListToGDTSelector(SEL Selector, ULONG Size, USHORT Access, LIN pPageList);
    432 #pragma aux DevHelp_PageListToGDTSelector = \
    433    ".386p" \
    434    "mov  ecx,[esp]" \
    435    "mov  dh,[esp+4]" \
    436    "mov  edi,[esp+6]" \
    437    "mov  dl,60h" \
    438    "call dword ptr ds:[Device_Help]" \
    439    "jc   error" \
    440    "sub  ax,ax" \
    441    "error:" \
    442    value [ax] \
    443    parm caller [] \
    444    modify nomemory exact [ax cx dx di];
    445 
    446 USHORT DevHelp_PageListToLin(ULONG Size, LIN pPageList, PLIN LinearAddr);
    447 #pragma aux DevHelp_PageListToLin = \
    448    ".386p" \
    449    "mov  ecx,[esp]" \
    450    "mov  edi,[esp+4]" \
    451    "mov  dl,5Fh" \
    452    "call dword ptr ds:[Device_Help]" \
    453    "jc   error" \
    454    "les  di,[esp+8]" \
    455    "mov  es:[di],eax" \
    456    "sub  ax,ax" \
    457    "error:" \
    458    value [ax] \
    459    parm caller nomemory [] \
    460    modify exact [ax cx dx di];
    461 
    462 
    463 USHORT DevHelp_LinToPageList( LIN    LinearAddr,
    464                                        ULONG  Size,
    465                                        LIN    pPageList,
    466                                        PULONG PageListCount );
    467 #pragma aux DevHelp_LinToPageList = \
    468   ".386p" \
    469   "mov  eax,[esp]" \
    470   "mov  ecx,[esp+4]" \
    471   "mov  edi,[esp+8]" \
    472   "mov  dl, 5Eh" \
    473   "call dword ptr ds:[Device_Help]" \
    474   "jc   error" \
    475   "mov  [esp+8],edi" \
    476   "mov  di, [esp+12]" \
    477   "mov  ss:[di],eax" \
    478   "sub  eax,eax" \
    479   "error:" \
    480    value [ax] \
    481    parm caller [] \
    482    modify exact [ax cx di dx];
    483 
    484 /* NOTE: After the DevHelp call, SI contains the modified selector. However,
    485    the C interface has no provisions for returning this value to the caller.
    486    You can, however, use the _SI() inline function defined in include.h.
    487 */
    488 
    489 USHORT DevHelp_PhysToGDTSel(ULONG PhysAddr, ULONG Count, SEL Selector, UCHAR Access);
    490 #pragma aux DevHelp_PhysToGDTSel = \
    491    ".386p" \
    492    "push bp" \
    493    "mov  dl,54h" \
    494    "mov  bp,sp" \
    495    "mov  eax,[bp+2]" \
    496    "mov  ecx,[bp+6]" \
    497    "mov  si,[bp+10]" \
    498    "mov  dh,[bp+12]" \
    499    "call dword ptr ds:[Device_Help]" \
    500    "jc   error" \
    501    "sub  ax,ax" \
    502    "error:" \
    503    "pop  bp" \
    504    value [ax] \
    505    parm caller nomemory [] \
    506    modify nomemory exact [ax cx dx si];
    507 
    508 USHORT DevHelp_PhysToGDTSelector(ULONG PhysAddr, USHORT Count, SEL Selector);
    509 #pragma aux DevHelp_PhysToGDTSelector = \
    510    "xchg ax,bx" \
    511    "mov  dl,2Eh" \
    512    DEVHELP_CALL \
    513    parm nomemory [ax bx] [cx] [si] \
    514    modify nomemory exact [ax bx dl];
    515 
    516 #define SELTYPE_R3CODE  0
    517 #define SELTYPE_R3DATA  1
    518 #define SELTYPE_FREE    2
    519 #define SELTYPE_R2CODE  3
    520 #define SELTYPE_R2DATA  4
    521 #define SELTYPE_R3VIDEO 5
    522 
    523 USHORT DevHelp_PhysToUVirt(ULONG PhysAddr, USHORT Length, USHORT flags, USHORT TagType, PVOID SelOffset);
    524 #pragma aux DevHelp_PhysToUVirt = \
    525    "xchg ax,bx" \
    526    "mov  dl,17h" \
    527    "call dword ptr ds:[Device_Help]" \
    528    "jc   error" \
    529    "push es" \
    530    "push bx" \
    531    "mov  bx,sp" \
    532    "les  bx,ss:[bx+4]" \
    533    "pop  es:[bx]" \
    534    "pop  es:[bx+2]" \
    535    "sub  ax,ax" \
    536    "error:" \
    537    value [ax] \
    538    parm caller nomemory [bx ax] [cx] [dh] [si] [] \
    539    modify exact [ax bx dl es];
    540 
    541 USHORT DevHelp_PhysToVirt(ULONG PhysAddr, USHORT usLength, PVOID SelOffset, PUSHORT ModeFlag);
    542 #pragma aux DevHelp_PhysToVirt = \
    543    "xchg ax,bx" \
    544    "mov  dx,15h" \
    545    "push ds" \
    546    "call dword ptr ds:[Device_Help]" \
    547    "jc   error" \
    548    "sub  ax,ax" \
    549    "mov  es:[di],si" \
    550    "mov  es:[di+2],ds" \
    551    "error:" \
    552    "pop  ds" \
    553    value [ax] \
    554    parm caller nomemory [bx ax] [cx] [es di] [] \
    555    modify exact [ax bx dx si];
    556 
    557 USHORT DevHelp_PostEventSem(ULONG hEvent);
    558 #pragma aux DevHelp_PostEventSem = \
    559    ".386p" \
    560    "mov  eax,[esp]" \
    561    "mov  dl,69h" \
    562    DEVHELP_CALL \
    563    parm caller nomemory [] \
    564    modify nomemory exact [ax dl];
    565 
    566 #define WAIT_IS_INTERRUPTABLE      0
    567 #define WAIT_IS_NOT_INTERRUPTABLE  1
    568 
    569 #define WAIT_INTERRUPTED           0x8003
    570 #define WAIT_TIMED_OUT             0x8001
    571 
    572 USHORT DevHelp_ProcBlock(ULONG EventId, ULONG WaitTime, USHORT IntWaitFlag);
    573 #pragma aux DevHelp_ProcBlock = \
    574    "mov  dl,4" \
    575    "xchg ax,bx" \
    576    "xchg cx,di" \
    577    "call dword ptr ds:[Device_Help]" \
    578    "jc   error" \
    579    "mov  ax,0"       /* doesn't affect zero flag like sub ax,ax does */ \
    580    "error:" \
    581    value [ax] \
    582    parm caller nomemory [ax bx] [di cx] [dh] \
    583    modify nomemory exact [ax bx cx dl di];
    584 
    585 USHORT DevHelp_ProcRun(ULONG EventId, PUSHORT AwakeCount);
    586 #pragma aux DevHelp_ProcRun = \
    587    "mov  dl,5" \
    588    "xchg ax,bx" \
    589    "call dword ptr ds:[Device_Help]" \
    590    "mov  es:[si],ax" \
    591    "sub  ax,ax" \
    592    value [ax] \
    593    parm caller nomemory [ax bx] [es si] \
    594    modify exact [ax bx dl];
    595 
    596 USHORT DevHelp_PullParticular(NPBYTE Queue, PBYTE ReqPktAddr);
    597 #pragma aux DevHelp_PullParticular= \
    598    "mov  dl,0Bh" \
    599    DEVHELP_CALL \
    600    parm [si] [es bx] \
    601    modify exact [ax dl];
    602 
    603 USHORT DevHelp_PullRequest(NPBYTE Queue, PBYTE __far *ReqPktAddr);
    604 #pragma aux DevHelp_PullRequest = \
    605    ".386p" \
    606    "push es" \
    607    "mov  dl,0Ah" \
    608    "call dword ptr ds:[Device_Help]" \
    609    "jc   error" \
    610    "movzx   esp,sp" \
    611    "push es" \
    612    "push bx" \
    613    "mov  bx,sp" \
    614    "les  bx,[esp]" \
    615    "pop  es:[bx]" \
    616    "pop  es:[bx+2]" \
    617    "sub  ax,ax" \
    618    "error:" \
    619    value [ax] \
    620    parm [si] [] \
    621    modify exact [ax bx dl es];
    622 
    623 USHORT DevHelp_PushRequest(NPBYTE Queue, PBYTE ReqPktddr);
    624 #pragma aux DevHelp_PushRequest = \
    625    "mov  dl,09h" \
    626    "call dword ptr ds:[Device_Help]" \
    627    "sub  ax,ax" \
    628    value [ax] \
    629    parm [si] [es bx] \
    630    modify exact [ax dl];
    631 
    632 USHORT DevHelp_QueueFlush(NPBYTE Queue);
    633 #pragma aux DevHelp_QueueFlush = \
    634    "mov  dl,10h" \
    635    "call dword ptr ds:[Device_Help]" \
    636    "sub  ax,ax" \
    637    value [ax] \
    638    parm [bx] \
    639    modify exact [ax dl];
    640 
    641 typedef struct _QUEUEHDR  {
    642   USHORT   QSize;
    643   USHORT   QChrOut;
    644   USHORT   QCount;
    645   BYTE     Queue[1];
    646 } QUEUEHDR, __far *PQUEUEHDR;
    647 
    648 USHORT DevHelp_QueueInit(NPBYTE Queue);
    649 #pragma aux DevHelp_QueueInit = \
    650    "mov  dl,0Fh" \
    651    "call dword ptr ds:[Device_Help]" \
    652    "sub  ax,ax" \
    653    value [ax] \
    654    parm [bx] \
    655    modify exact [ax dl];
    656 
    657 USHORT DevHelp_QueueRead(NPBYTE Queue, PBYTE Char);
    658 #pragma aux DevHelp_QueueRead = \
    659    "mov  dl,12h" \
    660    "call dword ptr ds:[Device_Help]" \
    661    "jc   error" \
    662    "mov  es:[di],al" \
    663    "sub  ax,ax" \
    664    "error:" \
    665    value [ax] \
    666    parm [bx] [es di] \
    667    modify exact [ax dl];
    668 
    669 USHORT DevHelp_QueueWrite(NPBYTE Queue, UCHAR Char);
    670 #pragma aux DevHelp_QueueWrite = \
    671    "mov  dl,11h" \
    672    DEVHELP_CALL \
    673    parm [bx] [al] \
    674    modify exact [ax dl];
    675 
    676 USHORT DevHelp_RAS(USHORT Major, USHORT Minor, USHORT Size, PBYTE Data);
    677 #pragma aux DevHelp_RAS = \
    678    "push ds" \
    679    "push es" \
    680    "pop  ds" \
    681    "pop  es" \
    682    "mov  dl,28h" \
    683    "call dword ptr ds:[Device_Help]" \
    684    "push es" \
    685    "pop  ds" \
    686    "mov  ax,0" \
    687    "sbb  ax,0" \
    688    value [ax] \
    689    parm [ax] [cx] [bx] [es si] \
    690    modify nomemory exact [ax dl es];
    691 
    692 #define CHAIN_AT_TOP    0
    693 #define CHAIN_AT_BOTTOM 1
    694 
    695 USHORT DevHelp_Register(USHORT MonitorHandle, USHORT MonitorPID, PBYTE InputBuffer, NPBYTE OutputBuffer, USHORT ChainFlag);
    696 #pragma aux DevHelp_Register = \
    697    "mov  dl,20h" \
    698    DEVHELP_CALL \
    699    parm caller nomemory [ax] [cx] [es si] [di] [dh] \
    700    modify nomemory exact [ax dl];
    701 
    702 USHORT DevHelp_RegisterBeep(PFN BeepHandler);
    703 #pragma aux DevHelp_RegisterBeep = \
    704    "mov  dl,51h" \
    705    "call dword ptr ds:[Device_Help]" \
    706    "sub  ax,ax" \
    707    value [ax] \
    708    parm caller nomemory [cx di] \
    709    modify nomemory exact [ax dl];
    710 
    711 #define DEVICECLASS_ADDDM       1                                    /*@V74979*/
    712 #define DEVICECLASS_MOUSE       2                                    /*@V74979*/
    713 
    714 USHORT DevHelp_RegisterDeviceClass(NPSZ DeviceString, PFN DriverEP, USHORT DeviceFlags, USHORT DeviceClass, PUSHORT DeviceHandle);
    715 #pragma aux DevHelp_RegisterDeviceClass = \
    716    ".386p" \
    717    "mov  dl,43h" \
    718    "xchg ax,bx" \
    719    "call dword ptr ds:[Device_Help]" \
    720    "jc   error" \
    721    "les  bx,[esp]" \
    722    "mov  es:[bx],ax" \
    723    "sub  ax,ax" \
    724    "error:" \
    725    value [ax] \
    726    parm [si] [ax bx] [di] [cx] [] \
    727    modify exact [ax bx dl es];
    728 
    729 USHORT DevHelp_RegisterPDD(NPSZ PhysDevName, PFN HandlerRoutine);
    730 #pragma aux DevHelp_RegisterPDD = \
    731    "mov  dl,50h" \
    732    DEVHELP_CALL \
    733    parm caller [si] [es di] \
    734    modify nomemory exact [ax dl];
    735 
    736 typedef struct _STACKUSAGEDATA {
    737    USHORT Size;
    738    USHORT Flags;
    739    USHORT IRQLevel;
    740    USHORT CLIStack;
    741    USHORT STIStack;
    742    USHORT EOIStack;
    743    USHORT NestingLevel;
    744 } STACKUSAGEDATA;
    745 
    746 USHORT DevHelp_RegisterStackUsage(PVOID StackUsageData);
    747 #pragma aux DevHelp_RegisterStackUsage = \
    748    "mov  dl,3Ah" \
    749    "call dword ptr ds:[Device_Help]" \
    750    "mov  ax,0" \
    751    "sbb  ax,0" \
    752    value [ax] \
    753    parm caller [bx] \
    754    modify nomemory exact [ax dl];
    755 
    756 USHORT DevHelp_RegisterTmrDD(NPFN TimerEntry, PULONG TmrRollover, PULONG Tmr);
    757 #pragma aux DevHelp_RegisterTmrDD = \
    758    ".386p" \
    759    "mov  dl,61h" \
    760    "call dword ptr ds:[Device_Help]" \
    761    "mov  ax,bx" \
    762    "les  bx,[esp]" \
    763    "mov  es:[bx],ax" \
    764    "mov  es:[bx+2],di" \
    765    "les  bx,[esp+4]" \
    766    "mov  es:[bx],cx" \
    767    "mov  es:[bx+2],di" \
    768    "sub  ax,ax" \
    769    value [ax] \
    770    parm caller nomemory [di] [] \
    771    modify exact [ax bx cx di dl es];
    772 
    773 USHORT DevHlp_ResetEventSem(ULONG hEvent, PULONG pNumPosts);
    774 #pragma aux DevHelp_ResetEventSem = \
    775    ".386p" \
    776    "mov  eax,[esp]" \
    777    "mov  edi,[esp+4]" \
    778    "mov  dl,6Ah" \
    779    DEVHELP_CALL \
    780    parm caller nomemory [] \
    781    modify exact [ax di dl];
    782 
    783 USHORT DevHelp_ResetTimer(NPFN TimerHandler);
    784 #pragma aux DevHelp_ResetTimer = \
    785    "mov  dl,1Eh" \
    786    DEVHELP_CALL \
    787    parm caller nomemory [ax] \
    788    modify nomemory exact [ax dl];
    789 
    790 typedef struct _MSGTABLE {
    791   USHORT   MsgId;                       /* Message Id #                  */
    792   USHORT   cMsgStrings;                 /* # of (%) substitution strings */
    793   PSZ      MsgStrings[1];               /* Substitution string pointers  */
    794 } MSGTABLE, __near *NPMSGTABLE;
    795 
    796 USHORT DevHelp_Save_Message(NPBYTE MsgTable);
    797 #pragma aux DevHelp_Save_Message = \
    798    "sub  bx,bx" \
    799    "mov  dl,3Dh" \
    800    DEVHELP_CALL \
    801    parm caller [si] \
    802    modify nomemory exact [ax bx dl];
    803 
    804 USHORT DevHelp_SchedClock(PFN NEAR *SchedRoutineAddr);
    805 #pragma aux DevHelp_SchedClock = \
    806    "mov  dl,0h" \
    807    "call dword ptr ds:[Device_Help]" \
    808    "sub  ax,ax" \
    809    value [ax] \
    810    parm caller [ax] \
    811    modify nomemory exact [ax dl];
    812 
    813 USHORT DevHelp_SemClear(ULONG SemHandle);
    814 #pragma aux DevHelp_SemClear = \
    815    "xchg ax,bx" \
    816    "mov  dl,7h" \
    817    DEVHELP_CALL \
    818    parm nomemory [ax bx] \
    819    modify nomemory exact [ax bx dl];
    820 
    821 #define SEMUSEFLAG_IN_USE       0
    822 #define SEMUSEFLAG_NOT_IN_USE   1
    823 
    824 USHORT DevHelp_SemHandle(ULONG SemKey, USHORT SemUseFlag, PULONG SemHandle);
    825 #pragma aux DevHelp_SemHandle = \
    826    "xchg ax,bx" \
    827    "mov  dl,8h" \
    828    "call dword ptr ds:[Device_Help]" \
    829    "jc   error" \
    830    "mov  es:[si],bx" \
    831    "mov  es:[si+2],ax" \
    832    "sub  ax,ax" \
    833    "error:" \
    834    value [ax] \
    835    parm nomemory [ax bx] [dh] [es si] \
    836    modify exact [ax bx dl];
    837 
    838 USHORT DevHelp_SemRequest(ULONG SemHandle, ULONG SemTimeout);
    839 #pragma aux DevHelp_SemRequest = \
    840    "xchg ax,bx" \
    841    "xchg di,cx" \
    842    "mov  dl,06h" \
    843    DEVHELP_CALL \
    844    parm nomemory [ax bx] [cx di] \
    845    modify nomemory exact [ax bx cx di dl];
    846 
    847 #define EVENT_MOUSEHOTKEY   0
    848 #define EVENT_CTRLBREAK     1
    849 #define EVENT_CTRLC         2
    850 #define EVENT_CTRLNUMLOCK   3
    851 #define EVENT_CTRLPRTSC     4
    852 #define EVENT_SHIFTPRTSC    5
    853 #define EVENT_KBDHOTKEY     6
    854 #define EVENT_KBDREBOOT     7
    855 
    856 USHORT DevHelp_SendEvent(USHORT EventType, USHORT Parm);
    857 #pragma aux DevHelp_SendEvent = \
    858    "mov  dl,25h" \
    859    "call dword ptr ds:[Device_Help]" \
    860    "mov  ax,0" \
    861    "sbb  ax,0" \
    862    value [ax] \
    863    parm nomemory [ah] [bx] \
    864    modify nomemory exact [ax dl];
    865 
    866 USHORT DevHelp_SetIRQ(NPFN IRQHandler, USHORT IRQLevel, USHORT SharedFlag);
    867 #pragma aux DevHelp_SetIRQ = \
    868    "mov  dl,1Bh" \
    869    DEVHELP_CALL \
    870    parm caller nomemory [ax] [bx] [dh] \
    871    modify nomemory exact [ax dl];
    872 
    873 USHORT DevHelp_SetTimer(NPFN TimerHandler);
    874 #pragma aux DevHelp_SetTimer = \
    875    "mov  dl,1Dh" \
    876    DEVHELP_CALL \
    877    parm caller nomemory [ax] \
    878    modify nomemory exact [ax dl];
    879 
    880 USHORT DevHelp_SortRequest(NPBYTE Queue, PBYTE ReqPktAddr);
    881 #pragma aux DevHelp_SortRequest = \
    882    "mov  dl,0Ch" \
    883    "call dword ptr ds:[Device_Help]" \
    884    "sub  ax,ax" \
    885    value [ax] \
    886    parm [si] [es bx] \
    887    modify exact [ax dl];
    888 
    889 USHORT DevHelp_TCYield(void);
    890 #pragma aux DevHelp_TCYield = \
    891    "mov  dl,3" \
    892    "call dword ptr ds:[Device_Help]" \
    893    "sub  ax,ax" \
    894    value [ax] \
    895    parm caller nomemory [] \
    896    modify nomemory exact [ax dl];
    897 
    898 USHORT DevHelp_TickCount(NPFN TimerHandler, USHORT TickCount);
    899 #pragma aux DevHelp_TickCount = \
    900    "mov  dl,33h" \
    901    DEVHELP_CALL \
    902    parm caller nomemory [ax] [bx] \
    903    modify nomemory exact [ax dl];
    904 
    905 USHORT DevHelp_UnLock(ULONG LockHandle);
    906 #pragma aux DevHelp_UnLock = \
    907    "xchg ax,bx" \
    908    "mov  dl,14h" \
    909    DEVHELP_CALL \
    910    parm nomemory [ax bx] \
    911    modify nomemory exact [ax bx dl];
    912 
    913 USHORT DevHelp_UnSetIRQ(USHORT IRQLevel);
    914 #pragma aux DevHelp_UnSetIRQ = \
    915    "mov  dl,1Ch" \
    916    DEVHELP_CALL \
    917    parm caller nomemory [bx] \
    918    modify nomemory exact [ax dl];
    919 
    920 #define VERIFY_READONLY    0
    921 #define VERIFY_READWRITE   1
    922 
    923 USHORT DevHelp_VerifyAccess(SEL MemSelector, USHORT Length, USHORT MemOffset, UCHAR AccessFlag);
    924 #pragma aux DevHelp_VerifyAccess = \
    925    "mov  dl,27h" \
    926    DEVHELP_CALL \
    927    parm caller nomemory [ax] [cx] [di] [dh] \
    928    modify nomemory exact [ax dl];
    929 
    930 #define VIDEO_PAUSE_OFF            0
    931 #define VIDEO_PAUSE_ON             1
    932 
    933 USHORT DevHelp_VideoPause(USHORT OnOff);
    934 #pragma aux DevHelp_VideoPause = \
    935    "mov  dl,3Ch" \
    936    "call dword ptr ds:[Device_Help]" \
    937    "mov  ax,0" \
    938    "sbb  ax,0" \
    939    value [ax] \
    940    parm nomemory [al] \
    941    modify nomemory exact [ax dl];
    942 
    943 USHORT DevHelp_VirtToLin(SEL Selector, ULONG Offset, PLIN LinearAddr);
    944 #pragma aux DevHelp_VirtToLin = \
    945    ".386p" \
    946    "movzx   esp,sp" \
    947    "mov  esi,[esp]" \
    948    "mov  dl,5bh" \
    949    "call dword ptr ds:[Device_Help]" \
    950    "jc   error" \
    951    "les  bx,[esp+4]" \
    952    "mov  es:[bx],eax" \
    953    "sub  ax,ax" \
    954    "error:" \
    955    value [ax] \
    956    parm caller nomemory [ax] [] \
    957    modify exact [ax si es bx dl];
    958 
    959 USHORT DevHelp_VirtToPhys(PVOID SelOffset, PULONG PhysAddr);
    960 #pragma aux DevHelp_VirtToPhys = \
    961    "push ds" \
    962    "mov  dl,16h" \
    963    "push es" \
    964    "mov  si,ds" \
    965    "mov  es,si" \
    966    "mov  ds,bx" \
    967    "mov  si,ax" \
    968    "call dword ptr ds:[Device_Help]" \
    969    "pop  es" \
    970    "mov  es:[di],bx" \
    971    "mov  es:[di+2],ax" \
    972    "pop  ds" \
    973    "sub  ax,ax" \
    974    value [ax] \
    975    parm caller nomemory [ax bx] [es di] \
    976    modify exact [ax bx dl es si];
    977 
    978 #define VMDHA_16M               0x0001                               /*@V76282*/
    979 #define VMDHA_FIXED             0x0002                               /*@V76282*/
    980 #define VMDHA_SWAP              0x0004                               /*@V76282*/
    981 #define VMDHA_CONTIG            0x0008                               /*@V76282*/
    982 #define VMDHA_PHYS              0x0010                               /*@V76282*/
    983 #define VMDHA_PROCESS           0x0020                               /*@V76282*/
    984 #define VMDHA_SGSCONT           0x0040                               /*@V76282*/
    985 #define VMDHA_RESERVE           0x0100                               /*@V76282*/
    986 #define VMDHA_USEHIGHMEM        0x0800                               /*@V76282*/
     454 typedef struct _GATEDESCINFO
     455 {
     456    UCHAR Type;                       
     457    UCHAR ParmCount;                   
     458    SEL Selector;                   
     459    USHORT Reserved_1;                 
     460    ULONG Offset;                     
     461 } GATEDESCINFO, FAR *PGATEDESCINFO;
     462
     463 APIRET DevHelp_GetDescInfo(
     464    SEL Sel,
     465    PBYTE pSelInfo
     466 );
     467
     468 #pragma aux DevHelp_GetDescInfo = \
     469    ".386p" \
     470    "mov     dl, 5dh" \
     471    "call    dword ptr ds:[Device_Help]" \
     472    "jc      error" \
     473    "mov     es:[bx], ax" \
     474    "mov     es:[bx+6], edx" \
     475    "mov     es:[bx+2], ecx" \
     476    "xor     ax, ax" \
     477    "error:" \
     478    value [ax] \
     479    parm caller nomemory [ax] [es bx] \
     480    modify exact [ax cx dx];
     481
     482 APIRET DevHelp_PageListToLin(
     483    ULONG ulSize,
     484    LIN pPageList,
     485    PLIN pLinAddr
     486 );
     487
     488 #pragma aux DevHelp_PageListToLin = \
     489    ".386p" \
     490    "mov     dl, 5fh" \
     491    "mov     edi, [esp+4]" \
     492    "mov     ecx, [esp]" \
     493    "call    dword ptr ds:[Device_Help]" \
     494    "jc      error" \
     495    "les     di, [esp+8]" \
     496    "mov     es:[di], eax" \
     497    "xor     ax, ax" \
     498    "error:" \
     499    value [ax] \
     500    parm caller nomemory [] \
     501    modify exact [ax cx dx di];
     502
     503 APIRET DevHelp_LinToPageList(
     504    LIN LinAddr,
     505    ULONG ulSize,
     506    LIN pPageList,
     507    PULONG pulPageListCnt
     508 );
     509
     510 #pragma aux DevHelp_LinToPageList = \
     511    ".386p" \
     512    "mov     dl, 5eh" \
     513    "mov     edi, [esp+8]" \
     514    "mov     eax, [esp]" \
     515    "mov     ecx, [esp+4]" \
     516    "call    dword ptr ds:[Device_Help]" \
     517    "jc      error" \
     518    "mov     [esp+8], edi" \
     519    "mov     di, [esp+12]" \
     520    "mov     ss:[di], eax" \
     521    "xor     eax, eax" \
     522    "error:" \
     523    value [ax] \
     524    parm caller [] \
     525    modify exact [ax cx di dx];
     526
     527 #define GDTSEL_R3CODE   0x0000
     528 #define GDTSEL_R3DATA   0x0001
     529 #define GDTSEL_R2CODE   0x0003
     530 #define GDTSEL_R2DATA   0x0004
     531 #define GDTSEL_R0CODE   0x0005
     532 #define GDTSEL_R0DATA   0x0006
     533
     534 #define GDTSEL_ADDR32   0x0080
     535
     536 APIRET DevHelp_PageListToGDTSelector(
     537    SEL Sel,
     538    ULONG ulSize,
     539    USHORT usAccess,
     540    LIN pPageList
     541 );
     542
     543 #pragma aux DevHelp_PageListToGDTSelector = \
     544    ".386p" \
     545    "mov     dl, 60h" \
     546    "mov     dh, [esp+4]" \
     547    "mov     ecx, [esp]" \
     548    "mov     edi, [esp+6]" \
     549    "call    dword ptr ds:[Device_Help]" \
     550    "jc      error" \
     551    "xor     ax, ax" \
     552    "error:" \
     553    value [ax] \
     554    parm caller [] \
     555    modify nomemory exact [ax cx dx di];
     556
     557 #define VMDHS_DECOMMIT        0x0001
     558 #define VMDHS_RESIDENT        0x0002
     559 #define VMDHS_SWAP            0x0004
     560
     561 typedef struct _PAGELIST
     562 {
     563    ULONG PhysAddr;
     564    ULONG Size;
     565 } PAGELIST, NEAR *NPPAGELIST, FAR *PPAGELIST;
     566
     567 APIRET DevHelp_VMSetMem(
     568    LIN LinAddr,
     569    ULONG ulSize,
     570    ULONG ulFlags
     571 );
     572
     573 #pragma aux DevHelp_VMSetMem = \
     574    ".386p" \
     575    "mov     dl, 66h" \
     576    "mov     eax, [esp+8]" \
     577    "mov     ebx, [esp]" \
     578    "mov     ecx, [esp+4]" \
     579    DEVICE_HELP \
     580    parm caller nomemory [] \
     581    modify nomemory exact [ax bx cx dl];
     582
     583 APIRET DevHelp_FreeGDTSelector(
     584    SEL Sel
     585 );
     586
     587 #pragma aux DevHelp_FreeGDTSelector = \
     588    "mov     dl, 53h" \
     589    DEVICE_HELP \
     590    parm caller nomemory [ax] \
     591    modify nomemory exact [ax dl];
     592
     593 //
     594 // Working with request packets
     595 //
     596
     597 #define WAIT_NOT_ALLOWED 0
     598 #define WAIT_IS_ALLOWED  1
     599
     600 APIRET DevHelp_AllocReqPacket(
     601    USHORT usWaitFlag,
     602    PBYTE FAR *pRPAddr
     603 );
     604
     605 #pragma aux DevHelp_AllocReqPacket = \
     606    "mov     dl, 0dh", \
     607    "call    dword ptr ds:[Device_Help]" \
     608    "jc      error" \
     609    "push    bx" \
     610    "push    es" \
     611    "mov     bx, sp" \
     612    "les     bx, ss:[bx]" \
     613    "pop     es:[bx+2]" \
     614    "pop     es:[bx]" \
     615    "error:" \
     616    "mov     ax, 0" \
     617    "sbb     ax, 0" \
     618    value [ax] \
     619    parm caller [dh] [] \
     620    modify exact [ax bx dl es];
     621
     622 APIRET DevHelp_FreeReqPacket(
     623    PBYTE pRPAddr
     624 );
     625
     626 #pragma aux DevHelp_FreeReqPacket = \
     627    "mov     dl, 0eh", \
     628    "call    dword ptr ds:[Device_Help]" \
     629    "xor     ax, ax" \
     630    value [ax] \
     631    parm caller [es bx] \
     632    modify exact [ax dl];
     633
     634 APIRET DevHelp_PullParticular(
     635    NPBYTE pQueue,
     636    PBYTE pRPAddr
     637 );
     638
     639 #pragma aux DevHelp_PullParticular= \
     640    "mov     dl, 0bh" \
     641    DEVICE_HELP \
     642    parm [si] [es bx] \
     643    modify exact [ax dl];
     644
     645 APIRET DevHelp_PullRequest(
     646    NPBYTE pQueue,
     647    PBYTE FAR *pRPAddr
     648 );
     649
     650 #pragma aux DevHelp_PullRequest = \
     651    ".386p" \
     652    "mov     dl, 0ah" \
     653    "push    es" \
     654    "call    dword ptr ds:[Device_Help]" \
     655    "jc      error" \
     656    "movzx   esp, sp" \
     657    "push    bx" \
     658    "push    es" \
     659    "mov     bx, sp" \
     660    "les     bx, [esp]" \
     661    "pop     es:[bx+2]" \
     662    "pop     es:[bx]" \
     663    "xor     ax, ax" \
     664    "error:" \
     665    value [ax] \
     666    parm [si] [] \
     667    modify exact [ax bx dl es];
     668
     669 APIRET DevHelp_PushRequest(
     670    NPBYTE pQueue,
     671    PBYTE pRPAddr
     672 );
     673
     674 #pragma aux DevHelp_PushRequest = \
     675    "mov     dl, 09h" \
     676    "call    dword ptr ds:[Device_Help]" \
     677    "xor     ax, ax" \
     678    value [ax] \
     679    parm [si] [es bx] \
     680    modify exact [ax dl];
     681
     682 APIRET DevHelp_SortRequest(
     683    NPBYTE pQueue,
     684    PBYTE pRPAddr
     685 );
     686
     687 #pragma aux DevHelp_SortRequest = \
     688    "mov     dl, 0ch" \
     689    "call    dword ptr ds:[Device_Help]" \
     690    "xor     ax, ax" \
     691    value [ax] \
     692    parm [si] [es bx] \
     693    modify exact [ax dl];
     694
     695 //
     696 // IDC and other functions
     697 //
     698
     699 APIRET DevHelp_InternalError(
     700    PSZ pMsg,
     701    USHORT cbMsg
     702 );
     703
     704 #pragma aux DevHelp_InternalError aborts = \
     705    "mov     dl, 2bh" \
     706    "push    ds" \
     707    "push    es" \
     708    "pop     ds" \
     709    "pop     es" \
     710    "call    dword ptr ds:[Device_Help]" \
     711    parm [es si] [di] \
     712    modify nomemory exact [];
     713
     714 APIRET DevHelp_RAS(
     715    USHORT usMajor,
     716    USHORT usMinor,
     717    USHORT usSize,
     718    PBYTE pData
     719 );
     720
     721 #pragma aux DevHelp_RAS = \
     722    "mov     dl, 28h" \
     723    "push    ds" \
     724    "push    es" \
     725    "pop     ds" \
     726    "pop     es" \
     727    "call    dword ptr ds:[Device_Help]" \
     728    "push    es" \
     729    "pop     ds" \
     730    "mov     ax, 0" \
     731    "sbb     ax, 0" \
     732    value [ax] \
     733    parm [ax] [cx] [bx] [es si] \
     734    modify nomemory exact [ax dl es];
     735
     736 APIRET APIENTRY DevHelp_RegisterPerfCtrs(
     737    NPBYTE pData,
     738    NPBYTE pText,
     739    USHORT usFlags
     740 );
     741
     742 #define DHGETDOSV_SYSINFOSEG       1
     743 #define DHGETDOSV_LOCINFOSEG       2
     744 #define DHGETDOSV_VECTORSDF        4
     745 #define DHGETDOSV_VECTORREBOOT     5
     746 #define DHGETDOSV_YIELDFLAG        7
     747 #define DHGETDOSV_TCYIELDFLAG      8
     748 #define DHGETDOSV_DOSCODEPAGE      11
     749 #define DHGETDOSV_INTERRUPTLEV     13
     750 #define DHGETDOSV_DEVICECLASSTABLE 14
     751 #define DHGETDOSV_DMQSSELECTOR     15
     752 #define DHGETDOSV_APMINFO          16
     753
     754 APIRET DevHelp_GetDOSVar(
     755    USHORT usVarNum,
     756    USHORT usVarMember,
     757    PPVOID pVar
     758 );
     759
     760 #pragma aux DevHelp_GetDOSVar = \
     761    "mov     dl, 24h" \
     762    "call    dword ptr ds:[Device_Help]" \
     763    "mov     es:[di], bx" \
     764    "mov     es:[di+2], ax" \
     765    "xor     ax, ax" \
     766    value [ax] \
     767    parm caller nomemory [al] [cx] [es di] \
     768    modify exact [ax bx dl];
     769
     770 typedef struct _IDCTABLE
     771 {
     772    USHORT Reserved[3];
     773    VOID (FAR *ProtIDCEntry) (VOID);
     774    USHORT ProtIDC_DS;
     775 } IDCTABLE, NEAR *NPIDCTABLE;
     776
     777 APIRET DevHelp_AttachDD(
     778    NPSZ pDDName,
     779    NPBYTE pDDTable
     780 );
     781
     782 #pragma aux DevHelp_AttachDD = \
     783    "mov     dl, 2ah" \
     784    "call    dword ptr ds:[Device_Help]" \
     785    "mov     ax, 0" \
     786    "sbb     ax, 0" \
     787    value [ax] \
     788    parm caller [bx] [di] \
     789    modify exact [ax dl];
     790
     791 typedef struct _MSGTABLE
     792 {
     793    USHORT MsgId;
     794    USHORT cMsgStrings;
     795    PSZ MsgStrings[1];
     796 } MSGTABLE, NEAR *NPMSGTABLE;
     797
     798 APIRET DevHelp_Save_Message(
     799    NPBYTE pMsgTbl
     800 );
     801
     802 #pragma aux DevHelp_Save_Message = \
     803    "mov     dl, 3dh" \
     804    "xor     bx, bx" \
     805    DEVICE_HELP \
     806    parm caller [si] \
     807    modify nomemory exact [ax bx dl];
     808
     809 USHORT APIENTRY DevHelp_LogEntry(
     810    PVOID,
     811    USHORT
     812 );
     813
     814 //
     815 // ADD / DMD interaction
     816 //
     817
     818 #define DEVICECLASS_ADDDM 1
     819 #define DEVICECLASS_MOUSE 2
     820
     821 APIRET DevHelp_RegisterDeviceClass(
     822    NPSZ pDevStr,
     823    PFN pfnDrvEP,
     824    USHORT usDevFlags,
     825    USHORT usDevClass,
     826    PUSHORT hDev
     827 );
     828
     829 #pragma aux DevHelp_RegisterDeviceClass = \
     830    ".386p" \
     831    "mov     dl, 43h" \
     832    "xchg    bx, ax" \
     833    "call    dword ptr ds:[Device_Help]" \
     834    "jc      error" \
     835    "les     bx, [esp]" \
     836    "mov     es:[bx], ax" \
     837    "xor     ax, ax" \
     838    "error:" \
     839    value [ax] \
     840    parm [si] [ax bx] [di] [cx] [] \
     841    modify exact [ax bx dl es];
     842
     843 USHORT APIENTRY DevHelp_CreateInt13VDM(
     844    PBYTE pVDMInt13CtrlBlk
     845 );
     846
     847 //
     848 // Interrupt/Thread Management
     849 //
     850
     851 APIRET DevHelp_SetIRQ(
     852    NPFN pIRQHndlr,
     853    USHORT usIRQL,
     854    USHORT usShrFlag
     855 );
     856
     857 #pragma aux DevHelp_SetIRQ = \
     858    "mov     dl, 1bh" \
     859    DEVICE_HELP \
     860    parm caller nomemory [ax] [bx] [dh] \
     861    modify nomemory exact [ax dl];
     862
     863 APIRET DevHelp_UnSetIRQ(
     864    USHORT usIRQL
     865 );
     866
     867 #pragma aux DevHelp_UnSetIRQ = \
     868    "mov     dl, 1ch" \
     869    DEVICE_HELP \
     870    parm caller nomemory [bx] \
     871    modify nomemory exact [ax dl];
     872
     873 APIRET DevHelp_EOI(
     874    USHORT usIrqL
     875 );
     876
     877 #pragma aux DevHelp_EOI = \
     878    "mov     dl, 31h" \
     879    "call    dword ptr ds:[Device_Help]" \
     880    "xor     ax, ax" \
     881    value [ax] \
     882    parm caller nomemory [al] \
     883    modify nomemory exact [ax dl];
     884
     885 typedef struct _STACKUSAGEDATA
     886 {
     887    USHORT Size;
     888    USHORT Flags;
     889    USHORT IRQLevel;
     890    USHORT CLIStack;
     891    USHORT STIStack;
     892    USHORT EOIStack;
     893    USHORT NestingLevel;
     894 } STACKUSAGEDATA;
     895
     896 APIRET DevHelp_RegisterStackUsage(
     897    PVOID pData
     898 );
     899
     900 #pragma aux DevHelp_RegisterStackUsage = \
     901    "mov     dl, 3ah" \
     902    "call    dword ptr ds:[Device_Help]" \
     903    "mov     ax, 0" \
     904    "sbb     ax, 0" \
     905    value [ax] \
     906    parm caller [bx] \
     907    modify nomemory exact [ax dl];
     908
     909 APIRET DevHelp_Yield(void);
     910
     911 #pragma aux DevHelp_Yield = \
     912    "mov     dl, 2" \
     913    "call    dword ptr ds:[Device_Help]" \
     914    "xor     ax, ax" \
     915    value [ax] \
     916    parm caller nomemory [] \
     917    modify nomemory exact [ax dl];
     918
     919 APIRET DevHelp_TCYield(void);
     920
     921 #pragma aux DevHelp_TCYield = \
     922    "mov     dl, 3" \
     923    "call    dword ptr ds:[Device_Help]" \
     924    "xor     ax, ax" \
     925    value [ax] \
     926    parm caller nomemory [] \
     927    modify nomemory exact [ax dl];
     928
     929 APIRET DevHelp_ProcRun(
     930    ULONG ulEvId,
     931    PUSHORT pusAwakeCnt
     932 );
     933
     934 #pragma aux DevHelp_ProcRun = \
     935    "mov     dl, 5" \
     936    "xchg    bx, ax" \
     937    "call    dword ptr ds:[Device_Help]" \
     938    "mov     es:[si], ax" \
     939    "xor     ax, ax" \
     940    value [ax] \
     941    parm caller nomemory [ax bx] [es si] \
     942    modify exact [ax bx dl];
     943
     944 #define WAIT_INTERRUPTED             0x8003
     945 #define WAIT_TIMED_OUT               0x8001
     946
     947 #define WAIT_IS_INTERRUPTABLE        0
     948 #define WAIT_IS_NOT_INTERRUPTABLE    1
     949
     950 APIRET DevHelp_ProcBlock(
     951    ULONG ulEvId,
     952    ULONG ulWaitTime,
     953    USHORT usIntWaitFlag
     954 );
     955
     956 #pragma aux DevHelp_ProcBlock = \
     957    "mov     dl, 4" \
     958    "xchg    di, cx" \
     959    "xchg    ax, bx" \
     960    "call    dword ptr ds:[Device_Help]" \
     961    "jc      error" \
     962    "xor     ax, ax" \
     963    "error:" \
     964    value [ax] \
     965    parm caller nomemory [ax bx] [di cx] [dh] \
     966    modify nomemory exact [ax bx cx dl di];
     967
     968 APIRET DevHelp_DevDone(
     969    PBYTE pReqPktAddr
     970 );
     971
     972 #pragma aux DevHelp_DevDone = \
     973    "mov     dl, 1" \
     974    DEVICE_HELP \
     975    parm caller [es bx] \
     976    modify exact [ax dl];
     977
     978 #define VIDEO_PAUSE_OFF  0
     979 #define VIDEO_PAUSE_ON   1
     980
     981 APIRET DevHelp_VideoPause(
     982    USHORT usOnOff
     983 );
     984
     985 #pragma aux DevHelp_VideoPause = \
     986    "mov     dl, 3ch" \
     987    "call    dword ptr ds:[Device_Help]" \
     988    "xor     ax, ax" \
     989    "sbb     ax, 0" \
     990    value [ax] \
     991    parm nomemory [al] \
     992    modify nomemory exact [ax dl];
     993
     994 //
     995 // Semaphores
     996 //
     997
     998 APIRET DevHelp_OpenEventSem(
     999    ULONG hEvent
     1000 );
    9871001 
    988 USHORT DevHelp_VMAlloc(ULONG Flags, ULONG Size, ULONG PhysAddr, PLIN LinearAddr, PPVOID SelOffset);
    989 #pragma aux DevHelp_VMAlloc = \
    990    ".386p" \
    991    "movzx   esp,sp" \
    992    "mov  eax,[esp]" \
    993    "mov  ecx,[esp+4]" \
    994    "mov  edi,[esp+8]" \
    995    "mov  dl,57h" \
    996    "call dword ptr ds:[Device_Help]" \
    997    "jc   error" \
    998    "les  di,[esp+12]" \
    999    "mov  es:[di],eax" \
    1000    "les  di,[esp+16]" \
    1001    "mov  es:[di],ecx" \
    1002    "sub  ax,ax" \
    1003    "error:" \
    1004    value [ax] \
    1005    parm caller nomemory [] \
    1006    modify exact [ax cx di dl es];
    1007 
    1008 USHORT DevHelp_VMFree(LIN LinearAddr);
    1009 #pragma aux DevHelp_VMFree = \
    1010    ".386p" \
    1011    "movzx   esp,sp" \
    1012    "mov  dl,58h" \
    1013    "mov  eax,[esp]" \
    1014    DEVHELP_CALL \
    1015    parm caller nomemory [] \
    1016    modify nomemory exact [ax dl];
    1017 
    1018 #define VMDHGP_WRITE            0x0001                               /*@V76282*/
    1019 #define VMDHGP_SELMAP           0x0002                               /*@V76282*/
    1020 #define VMDHGP_SGSCONTROL       0x0004                               /*@V76282*/
    1021 #define VMDHGP_4MEG             0x0008                               /*@V76282*/
    1022 
    1023 USHORT DevHelp_VMGlobalToProcess(ULONG Flags, LIN LinearAddr, ULONG Length, PLIN ProcessLinearAddr);
    1024 #pragma aux DevHelp_VMGlobalToProcess = \
    1025    ".386p" \
    1026    "mov  dl,5Ah" \
    1027    "mov  eax,[esp]" \
    1028    "mov  ebx,[esp+4]" \
    1029    "mov  ecx,[esp+8]" \
    1030    "call dword ptr ds:[Device_Help]" \
    1031    "jc   error" \
    1032    "les  bx,[esp+12]" \
    1033    "mov  es:[bx],eax" \
    1034    "sub  ax,ax" \
    1035    "error:" \
    1036    value [ax] \
    1037    parm caller nomemory [] \
    1038    modify exact [ax bx cx dl es];
    1039 
    1040 #define VMDHL_NOBLOCK           0x0001
    1041 #define VMDHL_CONTIGUOUS        0x0002
    1042 #define VMDHL_16M               0x0004
    1043 #define VMDHL_WRITE             0x0008
    1044 #define VMDHL_LONG              0x0010
    1045 #define VMDHL_VERIFY            0x0020
    1046 
    1047 USHORT DevHelp_VMLock(ULONG Flags, LIN LinearAddr, ULONG Length, LIN pPagelist, LIN pLockHandle, PULONG PageListCount);
    1048 #pragma aux DevHelp_VMLock = \
    1049    ".386p" \
    1050    "mov  dl,55h" \
    1051    "mov  eax,[esp]" \
    1052    "mov  ebx,[esp+4]" \
    1053    "mov  ecx,[esp+8]" \
    1054    "mov  edi,[esp+12]" \
    1055    "mov  esi,[esp+16]" \
    1056    "call dword ptr ds:[Device_Help]" \
    1057    "jc   error" \
    1058    "les  bx,[esp+20]" \
    1059    "mov  es:[bx],eax" \
    1060    "sub  ax,ax" \
    1061    "error:" \
    1062    value [ax] \
    1063    parm caller nomemory [] \
    1064    modify exact [ax bx cx dl si di es];
    1065 
    1066 #define VMDHPG_READONLY         0x0000                               /*@V76282*/
    1067 #define VMDHPG_WRITE            0x0001                               /*@V76282*/
    1068 
    1069 USHORT DevHelp_VMProcessToGlobal(ULONG Flags, LIN LinearAddr, ULONG Length, PLIN GlobalLinearAddr);
    1070 #pragma aux DevHelp_ProcessToGlobal = \
    1071    ".386p" \
    1072    "mov  dl,59h" \
    1073    "mov  eax,[esp]" \
    1074    "mov  ebx,[esp+4]" \
    1075    "mov  ecx,[esp+8]" \
    1076    "call dword ptr ds:[Device_Help]" \
    1077    "jc   error" \
    1078    "les  bx,[esp+12]" \
    1079    "mov  es:[bx],eax" \
    1080    "sub  ax,ax" \
    1081    "error:" \
    1082    value [ax] \
    1083    parm caller nomemory [] \
    1084    modify exact [ax bx cx dl es];
    1085 
    1086 #define VMDHS_DECOMMIT          0x0001                               /*@V76282*/
    1087 #define VMDHS_RESIDENT          0x0002                               /*@V76282*/
    1088 #define VMDHS_SWAP              0x0004                               /*@V76282*/
    1089 
    1090 USHORT DevHelp_VMSetMem(LIN LinearAddr, ULONG Size, ULONG Flags);
    1091 #pragma aux DevHelp_VMSetMem = \
    1092    ".386p" \
    1093    "mov  dl,66h" \
    1094    "mov  ebx,[esp]" \
    1095    "mov  ecx,[esp+4]" \
    1096    "mov  eax,[esp+8]" \
    1097    DEVHELP_CALL \
    1098    parm caller nomemory [] \
    1099    modify nomemory exact [ax bx cx dl];
    1100 
    1101 USHORT DevHelp_VMUnLock(LIN pLockHandle);
    1102 #pragma aux DevHelp_VMUnLock = \
    1103    ".386p" \
    1104    "mov  dl,56h" \
    1105    "mov  esi,[esp]" \
    1106    DEVHELP_CALL \
    1107    parm caller [] \
    1108    modify exact [ax si dl];
    1109 
    1110 USHORT DevHelp_Yield(void);
    1111 #pragma aux DevHelp_Yield = \
    1112    "mov  dl,2" \
    1113    "call dword ptr ds:[Device_Help]" \
    1114    "sub  ax,ax" \
    1115    value [ax] \
    1116    parm caller nomemory [] \
    1117    modify nomemory exact [ax dl];
    1118 
    1119 /*
    1120 ** DevHlp Error Codes  (from ABERROR.INC)
    1121 */
    1122 
    1123 #define MSG_MEMORY_ALLOCATION_FAILED    0x00
    1124 #define ERROR_LID_ALREADY_OWNED         0x01
    1125 #define ERROR_LID_DOES_NOT_EXIST        0x02
    1126 #define ERROR_ABIOS_NOT_PRESENT         0x03
    1127 #define ERROR_NOT_YOUR_LID              0x04
    1128 #define ERROR_INVALID_ENTRY_POINT       0x05
    1129 
    1130 #ifdef __cplusplus
    1131 }
    1132 #endif
    1133 
    1134 #endif
    1135 #endif
     1002 #pragma aux DevHelp_OpenEventSem = \
     1003    ".386p" \
     1004    "mov     dl, 67h" \
     1005    "mov     eax, [esp]" \
     1006    DEVICE_HELP \
     1007    parm caller nomemory [] \
     1008    modify nomemory exact [ax dl];
     1009
     1010 APIRET DevHelp_CloseEventSem(
     1011    ULONG hEvent
     1012 );
     1013
     1014 #pragma aux DevHelp_CloseEventSem = \
     1015    ".386p" \
     1016    "mov     dl, 68h" \
     1017    "movzx   esp, sp" \
     1018    "mov     eax, [esp]" \
     1019    DEVICE_HELP \
     1020    parm caller nomemory [] \
     1021    modify nomemory exact [ax dl];
     1022
     1023 APIRET DevHelp_PostEventSem(
     1024    ULONG hEvent
     1025 );
     1026
     1027 #pragma aux DevHelp_PostEventSem = \
     1028    ".386p" \
     1029    "mov     dl, 69h" \
     1030    "mov     eax, [esp]" \
     1031    DEVICE_HELP \
     1032    parm caller nomemory [] \
     1033    modify nomemory exact [ax dl];
     1034
     1035 APIRET DevHlp_ResetEventSem(
     1036    ULONG hEvent,
     1037    PULONG pNumPosts
     1038 );
     1039
     1040 #pragma aux DevHelp_ResetEventSem = \
     1041    ".386p" \
     1042    "mov     dl, 6ah" \
     1043    "mov     eax, [esp]" \
     1044    "mov     edi, [esp+4]" \
     1045    DEVICE_HELP \
     1046    parm caller nomemory [] \
     1047    modify exact [ax di dl];
     1048
     1049 #define SEMUSEFLAG_IN_USE     0
     1050 #define SEMUSEFLAG_NOT_IN_USE 1
     1051
     1052 APIRET DevHelp_SemHandle(
     1053    ULONG ulSemKey,
     1054    USHORT usSemUseFlag,
     1055    PULONG pSemHandle
     1056 );
     1057
     1058 #pragma aux DevHelp_SemHandle = \
     1059    "mov     dl, 8" \
     1060    "xchg    bx, ax" \
     1061    "call    dword ptr ds:[Device_Help]" \
     1062    "jc      error" \
     1063    "mov     es:[si+2], ax" \
     1064    "mov     es:[si], bx" \
     1065    "xor     ax, ax" \
     1066    "error:" \
     1067    value [ax] \
     1068    parm nomemory [ax bx] [dh] [es si] \
     1069    modify exact [ax bx dl];
     1070
     1071 APIRET DevHelp_SemRequest(
     1072    ULONG hSem,
     1073    ULONG ulTimeout
     1074 );
     1075
     1076 #pragma aux DevHelp_SemRequest = \
     1077    "mov     dl, 6" \
     1078    "xchg    ax, bx" \
     1079    "xchg    cx, di" \
     1080    DEVICE_HELP \
     1081    parm nomemory [ax bx] [cx di] \
     1082    modify nomemory exact [ax bx cx di dl];
     1083
     1084 APIRET DevHelp_SemClear(
     1085    ULONG hSem
     1086 );
     1087
     1088 #pragma aux DevHelp_SemClear = \
     1089    "mov     dl, 7" \
     1090    "xchg    bx, ax" \
     1091    DEVICE_HELP \
     1092    parm nomemory [ax bx] \
     1093    modify nomemory exact [ax bx dl];
     1094
     1095 #define EVENT_MOUSEHOTKEY 0
     1096 #define EVENT_CTRLBREAK   1
     1097 #define EVENT_CTRLC       2
     1098 #define EVENT_CTRLNUMLOCK 3
     1099 #define EVENT_CTRLPRTSC   4
     1100 #define EVENT_SHIFTPRTSC  5
     1101 #define EVENT_KBDHOTKEY   6
     1102 #define EVENT_KBDREBOOT   7
     1103
     1104 APIRET DevHelp_SendEvent(
     1105    USHORT usEvType,
     1106    USHORT usParm
     1107 );
     1108
     1109 #pragma aux DevHelp_SendEvent = \
     1110    "mov     dl, 25h" \
     1111    "call    dword ptr ds:[Device_Help]" \
     1112    "xor     ax, ax" \
     1113    "sbb     ax, 0" \
     1114    value [ax] \
     1115    parm nomemory [ah] [bx] \
     1116    modify nomemory exact [ax dl];
     1117
     1118 //
     1119 // Timers
     1120 //
     1121
     1122 APIRET DevHelp_SetTimer(
     1123    NPFN pTmrHndlr
     1124 );
     1125
     1126 #pragma aux DevHelp_SetTimer = \
     1127    "mov     dl, 1dh" \
     1128    DEVICE_HELP \
     1129    parm caller nomemory [ax] \
     1130    modify nomemory exact [ax dl];
     1131
     1132 APIRET DevHelp_ResetTimer(
     1133    NPFN pTmrHndlr
     1134 );
     1135
     1136 #pragma aux DevHelp_ResetTimer = \
     1137    "mov     dl, 1eh" \
     1138    DEVICE_HELP \
     1139    parm caller nomemory [ax] \
     1140    modify nomemory exact [ax dl];
     1141
     1142 APIRET DevHelp_TickCount(
     1143    NPFN pTmrHndlr,
     1144    USHORT usTickCnt
     1145 );
     1146
     1147 #pragma aux DevHelp_TickCount = \
     1148    "mov     dl, 33h" \
     1149    DEVICE_HELP \
     1150    parm caller nomemory [ax] [bx] \
     1151    modify nomemory exact [ax dl];
     1152
     1153 APIRET DevHelp_SchedClock(
     1154    PFN NEAR *pSchedRtnAddr
     1155 );
     1156
     1157 #pragma aux DevHelp_SchedClock = \
     1158    "mov     dl, 0" \
     1159    "call    dword ptr ds:[Device_Help]" \
     1160    "xor     ax, ax" \
     1161    value [ax] \
     1162    parm caller [ax] \
     1163    modify nomemory exact [ax dl];
     1164
     1165 APIRET DevHelp_RegisterTmrDD(
     1166    NPFN pTmrEntry,
     1167    PULONG pulTmrRollover,
     1168    PULONG pulTmr
     1169 );
     1170
     1171 #pragma aux DevHelp_RegisterTmrDD = \
     1172    ".386p" \
     1173    "mov     dl, 61h" \
     1174    "call    dword ptr ds:[Device_Help]" \
     1175    "mov     ax, bx" \
     1176    "les     bx, [esp]" \
     1177    "mov     es:[bx+2], di" \
     1178    "mov     es:[bx], ax" \
     1179    "les     bx, [esp+4]" \
     1180    "mov     es:[bx+2], di" \
     1181    "mov     es:[bx], cx" \
     1182    "xor     ax, ax" \
     1183    value [ax] \
     1184    parm caller nomemory [di] [] \
     1185    modify exact [ax bx cx di dl es];
     1186
     1187 //
     1188 // Device Monitors
     1189 //
     1190
     1191 APIRET DevHelp_MonitorCreate(
     1192    USHORT hMon,
     1193    PBYTE pFinalBuf,
     1194    NPFN pfnNotifyRtn,
     1195    PUSHORT hMonChain
     1196 );
     1197
     1198 #pragma aux DevHelp_MonitorCreate = \
     1199    ".386p" \
     1200    "mov     dl, 1fh" \
     1201    "call    dword ptr ds:[Device_Help]" \
     1202    "jc      error" \
     1203    "mov     si, [esp]" \
     1204    "mov     es, [esp+2]" \
     1205    "mov     es:[si], ax" \
     1206    "xor     ax, ax" \
     1207    "error:" \
     1208    value [ax] \
     1209    parm caller [ax] [es si] [di] [] \
     1210    modify exact [ax dl es si];
     1211
     1212 #define CHAIN_AT_TOP       0
     1213 #define CHAIN_AT_BOTTOM    1
     1214
     1215 APIRET DevHelp_Register(
     1216    USHORT hMon,
     1217    USHORT usMonPID,
     1218    PBYTE pInputBuf,
     1219    NPBYTE pOutputBuf,
     1220    USHORT usChainFlag
     1221 );
     1222
     1223 #pragma aux DevHelp_Register = \
     1224    "mov     dl, 20h" \
     1225    DEVICE_HELP \
     1226    parm caller nomemory [ax] [cx] [es si] [di] [dh] \
     1227    modify nomemory exact [ax dl];
     1228
     1229 APIRET DevHelp_DeRegister(
     1230    USHORT usMonPID,
     1231    USHORT hMon,
     1232    PUSHORT pusMonsLeft
     1233 );
     1234
     1235 #pragma aux DevHelp_DeRegister = \
     1236    "mov     dl, 21h" \
     1237    "call    dword ptr ds:[Device_Help]" \
     1238    "jc      error" \
     1239    "mov     es:[di], ax" \
     1240    "xor     ax, ax" \
     1241    "error:" \
     1242    value [ax] \
     1243    parm caller nomemory [bx] [ax] [es di] \
     1244    modify exact [ax dl];
     1245
     1246 APIRET DevHelp_MonFlush(
     1247    USHORT hMon
     1248 );
     1249
     1250 #pragma aux DevHelp_MonFlush = \
     1251    "mov     dl, 23h" \
     1252    DEVICE_HELP \
     1253    parm caller [ax] \
     1254    modify exact [ax dl];
     1255
     1256 APIRET DevHelp_MonWrite(
     1257    USHORT hMon,
     1258    NPBYTE pDataRec,
     1259    USHORT usCnt,
     1260    ULONG ulTimeStamp,
     1261    USHORT usWaitFlag
     1262 );
     1263
     1264 #pragma aux DevHelp_MonWrite = \
     1265    "mov     dl, 22h" \
     1266    DEVICE_HELP \
     1267    parm caller [ax] [si] [cx] [di bx] [dh] \
     1268    modify exact [ax dl];
     1269
     1270 //
     1271 // Character queues
     1272 //
     1273
     1274 typedef struct _QUEUEHDR
     1275 {
     1276    USHORT QSize;
     1277    USHORT QChrOut;
     1278    USHORT QCount;
     1279    BYTE Queue[1];
     1280 } QUEUEHDR, FAR *PQUEUEHDR;
     1281
     1282 APIRET DevHelp_QueueInit(
     1283    NPBYTE pQue
     1284 );
     1285
     1286 #pragma aux DevHelp_QueueInit = \
     1287    "mov     dl, 0fh" \
     1288    "call    dword ptr ds:[Device_Help]" \
     1289    "mov     ax, 0" \
     1290    value [ax] \
     1291    parm [bx] \
     1292    modify exact [ax dl];
     1293
     1294 APIRET DevHelp_QueueRead(
     1295    NPBYTE pQue,
     1296    PBYTE pChar
     1297 );
     1298
     1299 #pragma aux DevHelp_QueueRead = \
     1300    "mov     dl, 12h" \
     1301    "call    dword ptr ds:[Device_Help]" \
     1302    "jc      error" \
     1303    "mov     es:[di], al" \
     1304    "xor     ax, ax" \
     1305    "error:" \
     1306    value [ax] \
     1307    parm [bx] [es di] \
     1308    modify exact [ax dl];
     1309
     1310 APIRET DevHelp_QueueWrite(
     1311    NPBYTE pQue,
     1312    UCHAR Char
     1313 );
     1314
     1315 #pragma aux DevHelp_QueueWrite = \
     1316    "mov     dl, 11h" \
     1317    DEVICE_HELP \
     1318    parm [bx] [al] \
     1319    modify exact [ax dl];
     1320
     1321 APIRET DevHelp_QueueFlush(
     1322    NPBYTE pQue
     1323 );
     1324
     1325 #pragma aux DevHelp_QueueFlush = \
     1326    "mov     dl, 10h" \
     1327    "call    dword ptr ds:[Device_Help]" \
     1328    "xor     ax, ax" \
     1329    value [ax] \
     1330    parm [bx] \
     1331    modify exact [ax dl];
     1332
     1333 //
     1334 // Context Hooks
     1335 //
     1336
     1337 APIRET DevHelp_AllocateCtxHook(
     1338    NPFN pfnHookHndlr,
     1339    PULONG hHook
     1340 );
     1341
     1342 #pragma aux DevHelp_AllocateCtxHook = \
     1343    ".386p" \
     1344    "mov     dl, 63h" \
     1345    "movzx   eax, ax" \
     1346    "push    bx" \
     1347    "mov     ebx, -1" \
     1348    "call    dword ptr ds:[Device_Help]" \
     1349    "pop     bx" \
     1350    "jc      error" \
     1351    "mov     es:[bx], eax" \
     1352    "xor     ax, ax" \
     1353    "error:" \
     1354    value [ax] \
     1355    parm caller nomemory [ax] [es bx] \
     1356    modify exact [ax bx dl es];
     1357
     1358 APIRET DevHelp_FreeCtxHook(
     1359    ULONG hHook
     1360 );
     1361
     1362 #pragma aux DevHelp_FreeCtxHook = \
     1363    ".386p" \
     1364    "mov     dl, 64h", \
     1365    "movzx   esp,sp" \
     1366    "mov     eax, [esp]" \
     1367    DEVICE_HELP \
     1368    parm caller nomemory [] \
     1369    modify nomemory exact [ax dl];
     1370
     1371 APIRET DevHelp_ArmCtxHook(
     1372    ULONG ulHookData,
     1373    ULONG hHook
     1374 );
     1375
     1376 #pragma aux DevHelp_ArmCtxHook = \
     1377    ".386p" \
     1378    "mov     dl, 65h", \
     1379    "mov     bx, sp" \
     1380    "mov     eax, ss:[bx]" \
     1381    "mov     ebx, ss:[bx+4]" \
     1382    "mov     ecx, -1" \
     1383    DEVICE_HELP \
     1384    parm caller nomemory [] \
     1385    modify nomemory exact [ax bx cx dl];
     1386
     1387 //
     1388 // Mode Switching / Real Mode
     1389 //
     1390
     1391 APIRET APIENTRY DevHelp_RealToProt(void);
     1392 
     1393 APIRET APIENTRY DevHelp_ProtToReal(void);
     1394
     1395 APIRET APIENTRY DevHelp_ROMCritSection(
     1396    USHORT usEnterExit
     1397 );
     1398
     1399 APIRET APIENTRY DevHelp_SetROMVector(
     1400    NPFN pfnIntHandler,
     1401    USHORT usINTNum,
     1402    USHORT usSaveDSLoc,
     1403    PULONG pulLastHdr
     1404 );
     1405
     1406 //
     1407 // File System access (basedev init time only)
     1408 //
     1409
     1410 typedef struct FOPEN
     1411 {
     1412    PSZ   FileName;
     1413    ULONG FileSize;
     1414 } FILEOPEN;
     1415
     1416 typedef struct FREAD
     1417 {
     1418    PBYTE Buffer;
     1419    ULONG ReadSize;
     1420 } FILEREAD;
     1421
     1422 typedef struct FREADAT
     1423 {
     1424    PBYTE Buffer;
     1425    ULONG ReadSize;
     1426    ULONG StartPosition;
     1427 } FILEREADAT;
     1428
     1429 typedef struct FCLOSE
     1430 {
     1431    USHORT Reserved;
     1432 } FILECLOSE;
     1433
     1434 typedef union FILEIOOP
     1435 {
     1436    struct FOPEN FileOpen;
     1437    struct FCLOSE FileClose;
     1438    struct FREAD FileRead;
     1439    struct FREADAT FileReadAt;
     1440 } FILEIOOP;
     1441
     1442 typedef struct _DDFileIo
     1443 {
     1444    USHORT   Length;
     1445    FILEIOOP Data;
     1446 } FILEIOINFO, FAR * PFILEIOINFO;
     1447
     1448 APIRET APIENTRY DevHelp_OpenFile(
     1449    PFILEIOINFO pFileOpen
     1450 );
     1451
     1452 APIRET APIENTRY DevHelp_CloseFile(
     1453    PFILEIOINFO pFileClose
     1454 );
     1455
     1456 APIRET APIENTRY DevHelp_ReadFile(
     1457    PFILEIOINFO pFileRead
     1458 );
     1459
     1460 APIRET APIENTRY DevHelp_ReadFileAt(
     1461    PFILEIOINFO pFileReadAT
     1462 );
     1463
     1464 //
     1465 // ABIOS ops
     1466 //
     1467
     1468 APIRET DevHelp_ABIOSCall(
     1469    USHORT usLid,
     1470    NPBYTE pReqBlk,
     1471    USHORT usEntryType
     1472 );
     1473
     1474 #pragma aux DevHelp_ABIOSCall = \
     1475    "mov     dl, 36h" \
     1476    DEVICE_HELP \
     1477    parm caller [ax] [si] [dh] \
     1478    modify exact [ax dl];
     1479
     1480 APIRET DevHelp_ABIOSCommonEntry(
     1481    NPBYTE pReqBlk,
     1482    USHORT usEntryType
     1483 );
     1484
     1485 #pragma aux DevHelp_ABIOSCommonEntry = \
     1486    "mov     dl, 37h" \
     1487    DEVICE_HELP \
     1488    parm caller [si] [dh] \
     1489    modify exact [ax dl];
     1490
     1491 APIRET APIENTRY DevHelp_ABIOSGetParms(
     1492    USHORT usLid,
     1493    NPBYTE pParmsBlk
     1494 );
     1495
     1496 APIRET DevHelp_FreeLIDEntry(
     1497    USHORT usLID
     1498 );
     1499
     1500 #pragma aux DevHelp_FreeLIDEntry = \
     1501    "mov     dl, 35h" \
     1502    DEVICE_HELP \
     1503    parm caller nomemory [ax] \
     1504    modify nomemory exact [ax dl];
     1505
     1506 APIRET DevHelp_GetLIDEntry(
     1507    USHORT usDeviceType,
     1508    SHORT sLIDIndex,
     1509    USHORT usType,
     1510    PUSHORT pusLID
     1511 );
     1512
     1513 #pragma aux DevHelp_GetLIDEntry = \
     1514    "mov     dl, 34h" \
     1515    "call    dword ptr ds:[Device_Help]" \
     1516    "jc      error" \
     1517    "mov     es:[di], ax" \
     1518    "xor     ax, ax" \
     1519    "error:" \
     1520    value [ax] \
     1521    parm caller nomemory [al] [bl] [dh] [es di] \
     1522    modify exact [ax dl];
     1523
     1524 APIRET DevHelp_GetDeviceBlock(
     1525    USHORT usLid,
     1526    PPVOID pDeviceBlock
     1527 );
     1528
     1529 #pragma aux DevHelp_GetDeviceBlock = \
     1530    "mov     dl, 38h" \
     1531    "call    dword ptr ds:[Device_Help]" \
     1532    "jc      error" \
     1533    "mov     es:[si+2], cx" \
     1534    "mov     es:[si], dx" \
     1535    "xor     ax, ax" \
     1536    "error:" \
     1537    value [ax] \
     1538    parm caller nomemory [ax] [es si] \
     1539    modify exact [ax bx cx dx];
     1540
     1541 //
     1542 // Other
     1543 //
     1544
     1545 APIRET DevHelp_RegisterBeep(
     1546    PFN pfnBeepHndlr
     1547 );
     1548
     1549 #pragma aux DevHelp_RegisterBeep = \
     1550    "mov     dl, 51h" \
     1551    "call    dword ptr ds:[Device_Help]" \
     1552    "xor     ax, ax" \
     1553    value [ax] \
     1554    parm caller nomemory [cx di] \
     1555    modify nomemory exact [ax dl];
     1556
     1557 APIRET DevHelp_Beep(
     1558    USHORT usFreq,
     1559    USHORT usTime
     1560 );
     1561
     1562 #pragma aux DevHelp_Beep = \
     1563    "mov     dl, 52h" \
     1564    DEVICE_HELP \
     1565    parm caller nomemory [bx] [cx] \
     1566    modify nomemory exact [ax dx];
     1567
     1568 APIRET DevHelp_RegisterPDD(
     1569    NPSZ pszPhysDevName,
     1570    PFN pfnHndlrRtn
     1571 );
     1572
     1573 #pragma aux DevHelp_RegisterPDD = \
     1574    "mov     dl, 50h" \
     1575    DEVICE_HELP \
     1576    parm caller [si] [es di] \
     1577    modify nomemory exact [ax dl];
     1578
     1579 #define DYNAPI_ROUTINE16        0x0002
     1580 #define DYNAPI_ROUTINE32        0x0000
     1581 #define DYNAPI_CALLGATE16       0x0001
     1582 #define DYNAPI_CALLGATE32       0x0000
     1583
     1584 APIRET DevHelp_DynamicAPI(
     1585    PVOID pRoutineAddress,
     1586    USHORT cbParm,
     1587    USHORT usFlags,
     1588    PSEL pCallGateSel
     1589 );
     1590
     1591 #pragma aux DevHelp_DynamicAPI = \
     1592    "mov     dl, 6ch" \
     1593    "xchg    bx, ax" \
     1594    "call    dword ptr ds:[Device_Help]" \
     1595    "jc      error" \
     1596    "mov     es:[si], di" \
     1597    "xor     ax, ax" \
     1598    "error:" \
     1599    value [ax] \
     1600    parm caller [ax bx] [cx] [dh] [es si] \
     1601    modify exact [ax bx di dl];
     1602
     1603 #ifdef __cplusplus
     1604   }
     1605 #endif
     1606
     1607 #endif
     1608
     1609 #endif /* __DEVHELP_H__ */
  • trunk/src/include/dhcalls.h

    r103 r302  
    1 /* SCCSID = %w% %e% */
    2 /**************************************************************************
    3  *
    4  * SOURCE FILE NAME =  DHCALLS.H
    5  *
    6  * DESCRIPTIVE NAME =  ADD/DM include file
    7  *                     C Function Prototypes services in DHCALLS.LIB
    8  *
    9  * Copyright : COPYRIGHT IBM CORPORATION, 1991, 1992
    10  *             LICENSED MATERIAL - PROGRAM PROPERTY OF IBM
    11  *             REFER TO COPYRIGHT INSTRUCTION FORM#G120-2083
    12  *             RESTRICTED MATERIALS OF IBM
    13  *             IBM CONFIDENTIAL
    14  *
    15  * VERSION = V2.0
    16  *
    17  * DATE
    18  *
    19  * DESCRIPTION :
    20  *
    21  * Purpose:    DHCALLS.LIB provides a C-Callable interface to OS/2
    22  *             Device Help (DevHelp) services.
    23  *
    24  *             DevHelp services provide memory/interrupt/semaphore
    25  *             management services for ADDs and Device Managers.
    26  *
    27  *
    28  * FUNCTIONS  :
    29  *
    30  *
    31  *
    32  * NOTES
    33  *
    34  *
    35  * STRUCTURES
    36  *
    37  * EXTERNAL REFERENCES
    38  *
    39  *
    40  *
    41  * EXTERNAL FUNCTIONS
    42  *
    43  * CHANGE ACTIVITY =
    44  *   DATE      FLAG        APAR   CHANGE DESCRIPTION
    45  *   --------  ----------  -----  --------------------------------------
    46  *   10/22/93  @V74979     74979  Change DevHelp return codes from BOOL
    47  *                                to USHORT
    48  *
    49  *   10/22/93  @V74979     74979  Fix prototype DevHelp_DeRegister
    50  *                                              DevHelp_VMSetMem
    51  *                                              DevHelp_Beep
    52  *                                              DevHelp_RegisterBeep
    53  *
    54  *   10/22/93  @V74979     74979  Add DEVICECLASS_* equates for
    55  *                                DevHelp_RegisterDeviceClass.
    56  *
    57  *   12/02/93  @V76282     76282  Add defines for flags on various
    58  *                                DevHelps based on review of PDD Book
    59  *
    60  *   12/02/93  @V76282     76282  Fix prototype DevHelp_MonWrite
    61  *                                              DevHelp_SchedClock
    62  *
    63  *   12/02/93  @V76282     76282  Add prototype DevHelp_RegisterTmrDD
    64  *                                              DevHelp_DynamicAPI
    65  *
    66  *   05/31/94  @V85056     85056  Add DDTABLE type for DevHelp_AttachDD
    67  *
    68  *   02/06/95  @V111573   111573  Add prototype DevHelp_LogEntry
    69  *
    70  ****************************************************************************/
    71 
    72 
    73 /*
    74 ** DevHelp Library Calls
    75 */
    76 
    77 typedef USHORT NEAR *NPUSHORT;
    78 typedef VOID   NEAR *NPVOID;
    79 
    80 // -- typedef _far * _far *PPVOID;
    81 
    82 typedef VOID    FAR *PVOID;
    83 typedef PVOID   FAR *PPVOID;
    84 
    85 /*
    86 ** ABIOS Related
    87 */
    88 
    89 USHORT APIENTRY DevHelp_GetLIDEntry ( USHORT  DeviceType,
    90                                       USHORT  LIDIndex,
    91                                       USHORT  LIDType,
    92                                       PUSHORT LID);
    93 
    94 USHORT APIENTRY DevHelp_FreeLIDEntry( USHORT LIDNumber );
    95 
    96 USHORT APIENTRY DevHelp_ABIOSCall( USHORT Lid,
    97                                    NPBYTE ReqBlk,
    98                                    USHORT Entry_Type );
    99 
    100 USHORT APIENTRY DevHelp_ABIOSCommonEntry( NPBYTE ReqBlk,
    101                                           USHORT Entry_Type );
    102 
    103 USHORT APIENTRY DevHelp_ABIOSGetParms( USHORT Lid,
    104                                        NPBYTE ParmsBlk);
    105 
    106 USHORT APIENTRY DevHelp_GetDeviceBlock( USHORT Lid,
    107                                         PPVOID DeviceBlockPtr );
    108 
    109 
    110 /*
    111 ** Memory Management
    112 */
    113 
    114 USHORT APIENTRY DevHelp_AllocGDTSelector( PSEL   Selectors,
    115                                           USHORT Count );
    116 
    117 USHORT APIENTRY DevHelp_PhysToGDTSelector( ULONG  PhysAddr,
    118                                            USHORT Count,
    119                                            SEL    Selector );
    120 
    121 USHORT APIENTRY DevHelp_PhysToGDTSel( ULONG PhysAddr,
    122                                       ULONG Count,
    123                                       SEL   Selector,
    124                                       UCHAR Access );
    125 
    126 USHORT APIENTRY DevHelp_AllocPhys( ULONG  lSize,
    127                                    USHORT MemType,
    128                                    PULONG PhysAddr);
    129 
    130 USHORT APIENTRY DevHelp_PhysToUVirt( ULONG  PhysAddr,
    131                                      USHORT Length,
    132                                      USHORT Flags,
    133                                      USHORT TagType,
    134                                      PVOID  SelOffset);
    135 
    136 USHORT APIENTRY DevHelp_PhysToVirt( ULONG   PhysAddr,
    137                                     USHORT  usLength,
    138                                     PVOID   SelOffset,
    139                                     PUSHORT ModeFlag );
    140 
    141 USHORT APIENTRY DevHelp_UnPhysToVirt( PUSHORT ModeFlag );
    142 
    143 USHORT APIENTRY DevHelp_FreePhys( ULONG PhysAddr );
    144 
    145 USHORT APIENTRY DevHelp_VirtToPhys( PVOID  SelOffset,
    146                                     PULONG PhysAddr );
    147 
    148 USHORT APIENTRY DevHelp_Lock( SEL    Segment,
    149                               USHORT LockType,
    150                               USHORT WaitFlag,
    151                               PULONG LockHandle );
    152 
    153 USHORT APIENTRY DevHelp_UnLock( ULONG LockHandle );
    154 
    155 USHORT APIENTRY DevHelp_VerifyAccess( SEL    MemSelector,
    156                                       USHORT Length,
    157                                       USHORT MemOffset,
    158                                       UCHAR  AccessFlag);
    159 
    160 /* DevHelp_AllocPhys */
    161 #define MEMTYPE_ABOVE_1M 0
    162 #define MEMTYPE_BELOW_1M 1
    163 
    164 /* DevHelp_Lock */
    165 
    166 #define LOCKTYPE_SHORT_ANYMEM 0x00
    167 #define LOCKTYPE_LONG_ANYMEM  0x01
    168 #define LOCKTYPE_LONG_HIGHMEM 0x03
    169 #define LOCKTYPE_SHORT_VERIFY 0x04
    170 
    171 /* DevHelp_PhysToUVirt */
    172 
    173 #define SELTYPE_R3CODE  0
    174 #define SELTYPE_R3DATA  1
    175 #define SELTYPE_FREE    2
    176 #define SELTYPE_R2CODE  3
    177 #define SELTYPE_R2DATA  4
    178 #define SELTYPE_R3VIDEO 5
    179 
    180 
    181 /* DevHelp_VerifyAccess */
    182 
    183 #define VERIFY_READONLY    0
    184 #define VERIFY_READWRITE   1
    185 
    186 /*
    187 ** Request Packet Management
    188 */
    189 
    190 USHORT APIENTRY DevHelp_AllocReqPacket( USHORT    WaitFlag,
    191                                         PBYTE FAR *ReqPktAddr );
    192 
    193 USHORT APIENTRY DevHelp_FreeReqPacket( PBYTE ReqPktAddr );
    194 
    195 USHORT APIENTRY DevHelp_PullParticular( NPBYTE Queue,
    196                                         PBYTE  ReqPktAddr );
    197 
    198 USHORT APIENTRY DevHelp_PullRequest( NPBYTE    Queue,
    199                                      PBYTE FAR *ReqPktAddr );
    200 
    201 USHORT APIENTRY DevHelp_PushRequest( NPBYTE Queue,
    202                                      PBYTE  ReqPktAddr );
    203 
    204 USHORT APIENTRY DevHelp_SortRequest( NPBYTE Queue,
    205                                      PBYTE  ReqPktAddr );
    206 
    207 
    208 /* DevHelp_AllocRequestPacket */
    209 
    210 #define WAIT_NOT_ALLOWED 0
    211 #define WAIT_IS_ALLOWED  1
    212 
    213 /*
    214 ** Character Queue Management
    215 */
    216 
    217 USHORT APIENTRY DevHelp_QueueInit( NPBYTE Queue );
    218 
    219 USHORT APIENTRY DevHelp_QueueRead( NPBYTE Queue,
    220                                    PBYTE  Char );
    221 
    222 USHORT APIENTRY DevHelp_QueueWrite( NPBYTE Queue,
    223                                     UCHAR  Char );
    224 
    225 USHORT APIENTRY DevHelp_QueueFlush( NPBYTE Queue );
    226 
    227 
    228 /* DevHelp_QueueInit */
    229 
    230 typedef struct _QUEUEHDR  {             /* DHQH */
    231 
    232   USHORT   QSize;
    233   USHORT   QChrOut;
    234   USHORT   QCount;
    235   BYTE     Queue[1];
    236 } QUEUEHDR;
    237 
    238 typedef QUEUEHDR FAR *PQUEUEHDR;                                     /*@V76282*/
    239 
    240 
    241 
    242 /*
    243 ** Inter-Device Driver Communications & Kernel Functions
    244 */
    245 
    246 USHORT APIENTRY DevHelp_ProtToReal();
    247 
    248 USHORT APIENTRY DevHelp_RealToProt();
    249 
    250 USHORT APIENTRY DevHelp_InternalError( PSZ    MsgText,
    251                                        USHORT MsgLength );
    252 
    253 USHORT APIENTRY DevHelp_RAS( USHORT Major,
    254                              USHORT Minor,
    255                              USHORT Size,
    256                              PBYTE Data);
    257 
    258 USHORT APIENTRY DevHelp_RegisterPerfCtrs( NPBYTE pDataBlock,
    259                                           NPBYTE pTextBlock,
    260                                           USHORT Flags);
    261 
    262 USHORT APIENTRY DevHelp_AttachDD( NPSZ   DDName,
    263                                   NPBYTE IDCTable );
    264 
    265 typedef struct _IDCTABLE {               /* DHID */                  /*@V85056*/
    266                                                                      /*@V85056*/
    267   USHORT        Reserved[3];                                         /*@V85056*/
    268   VOID          (FAR *ProtIDCEntry)(VOID);                           /*@V85056*/
    269   USHORT        ProtIDC_DS;                                          /*@V85056*/
    270                                                                      /*@V85056*/
    271 } IDCTABLE;                                                          /*@V85056*/
    272                                                                      /*@V85056*/
    273 typedef IDCTABLE NEAR *NPIDCTABLE;                                   /*@V85056*/
    274 
    275 
    276 USHORT APIENTRY DevHelp_GetDOSVar( USHORT VarNumber,
    277                                    USHORT VarMember,
    278                                    PPVOID KernelVar );
    279 
    280 #define DHGETDOSV_SYSINFOSEG            1
    281 #define DHGETDOSV_LOCINFOSEG            2
    282 #define DHGETDOSV_VECTORSDF             4
    283 #define DHGETDOSV_VECTORREBOOT          5
    284 #define DHGETDOSV_YIELDFLAG             7                            /*@V76282*/
    285 #define DHGETDOSV_TCYIELDFLAG           8                            /*@V76282*/
    286 #define DHGETDOSV_DOSCODEPAGE           11                           /*@V76282*/
    287 #define DHGETDOSV_INTERRUPTLEV          13
    288 #define DHGETDOSV_DEVICECLASSTABLE      14                           /*@V76282*/
    289 #define DHGETDOSV_DMQSSELECTOR          15                           /*@V76282*/
    290 #define DHGETDOSV_APMINFO               16                           /*@V76282*/
    291 
    292 USHORT APIENTRY DevHelp_Save_Message( NPBYTE MsgTable );
    293 
    294 typedef struct _MSGTABLE {              /* DHMT */
    295 
    296   USHORT   MsgId;                       /* Message Id #                  */
    297   USHORT   cMsgStrings;                 /* # of (%) substitution strings */
    298   PSZ      MsgStrings[1];               /* Substitution string pointers  */
    299 } MSGTABLE;
    300 
    301 typedef MSGTABLE NEAR *NPMSGTABLE;                                   /*@V76282*/
    302 
    303 
    304 USHORT APIENTRY DevHelp_LogEntry (PVOID, USHORT);  /* @V111573 */
    305 
    306 
    307 /*
    308 ** Interrupt/Thread Management
    309 */
    310 
    311 USHORT APIENTRY DevHelp_RegisterStackUsage( PVOID StackUsageData );
    312 
    313 USHORT APIENTRY DevHelp_SetIRQ( NPFN   IRQHandler,
    314                                 USHORT IRQLevel,
    315                                 USHORT SharedFlag );
    316 
    317 USHORT APIENTRY DevHelp_UnSetIRQ( USHORT IRQLevel );
    318 
    319 USHORT APIENTRY DevHelp_EOI( USHORT IRQLevel );
    320 
    321 USHORT APIENTRY DevHelp_ProcBlock( ULONG  EventId,
    322                                    ULONG  WaitTime,
    323                                    USHORT IntWaitFlag );
    324 
    325 USHORT APIENTRY DevHelp_ProcRun( ULONG   EventId,
    326                                  PUSHORT AwakeCount);
    327 
    328 USHORT APIENTRY DevHelp_DevDone( PBYTE ReqPktAddr );
    329 
    330 USHORT APIENTRY DevHelp_TCYield(void);
    331 
    332 USHORT APIENTRY DevHelp_Yield(void);
    333 
    334 USHORT APIENTRY DevHelp_VideoPause( USHORT OnOff );
    335 
    336 /* DevHelp_RegisterStackUsage */
    337 
    338 typedef struct _STACKUSAGEDATA  {       /* DHRS */
    339 
    340   USHORT  Size;
    341   USHORT  Flags;
    342   USHORT  IRQLevel;
    343   USHORT  CLIStack;
    344   USHORT  STIStack;
    345   USHORT  EOIStack;
    346   USHORT  NestingLevel;
    347 } STACKUSAGEDATA;
    348 
    349 /* DevHelp_Block */
    350 
    351 #define WAIT_IS_INTERRUPTABLE      0
    352 #define WAIT_IS_NOT_INTERRUPTABLE  1
    353 
    354 #define WAIT_INTERRUPTED           0x8003
    355 #define WAIT_TIMED_OUT             0x8001
    356 
    357 /* DevHelp_VideoPause */
    358 
    359 #define VIDEO_PAUSE_OFF            0
    360 #define VIDEO_PAUSE_ON             1
    361 
    362 
    363 /*
    364 ** Semaphore Management
    365 */
    366 
    367 USHORT APIENTRY DevHelp_SemHandle( ULONG  SemKey,
    368                                    USHORT SemUseFlag,
    369                                    PULONG SemHandle );
    370 
    371 USHORT APIENTRY DevHelp_SemClear( ULONG SemHandle );
    372 
    373 USHORT APIENTRY DevHelp_SemRequest( ULONG SemHandle,
    374                                     ULONG SemTimeout );
    375 
    376 USHORT APIENTRY DevHelp_SendEvent( USHORT EventType,
    377                                    USHORT Parm );
    378 
    379 USHORT APIENTRY DevHelp_OpenEventSem( ULONG hEvent );
    380 
    381 USHORT APIENTRY DevHelp_CloseEventSem( ULONG hEvent );
    382 
    383 USHORT APIENTRY DevHelp_PostEventSem( ULONG hEvent );
    384 
    385 USHORT APIENTRY DevHlp_ResetEventSem( ULONG hEvent,
    386                                       PULONG pNumPosts );
    387 
    388 /* DevHelp_SemHandle */
    389 
    390 #define SEMUSEFLAG_IN_USE       0
    391 #define SEMUSEFLAG_NOT_IN_USE   1
    392 
    393 /* DevHelp_SemHandle */
    394 
    395 #define EVENT_MOUSEHOTKEY   0
    396 #define EVENT_CTRLBREAK     1
    397 #define EVENT_CTRLC         2
    398 #define EVENT_CTRLNUMLOCK   3
    399 #define EVENT_CTRLPRTSC     4
    400 #define EVENT_SHIFTPRTSC    5
    401 #define EVENT_KBDHOTKEY     6
    402 #define EVENT_KBDREBOOT     7
    403 
    404 /*
    405 ** Timer Management
    406 */
    407 
    408 USHORT APIENTRY DevHelp_ResetTimer( NPFN TimerHandler );
    409 
    410 USHORT APIENTRY DevHelp_SchedClock( PFN NEAR *SchedRoutineAddr );    /*@V76282*/
    411 
    412 USHORT APIENTRY DevHelp_SetTimer( NPFN TimerHandler );
    413 
    414 USHORT APIENTRY DevHelp_TickCount( NPFN   TimerHandler,
    415                                    USHORT TickCount );
    416 
    417 USHORT APIENTRY DevHelp_RegisterTmrDD( NPFN   TimerEntry,            /*@V76282*/
    418                                        PULONG TmrRollover,           /*@V76282*/
    419                                        PULONG Tmr          );        /*@V76282*/
    420 
    421 
    422 
    423 /*
    424 ** Real Mode Helpers
    425 */
    426 
    427 USHORT APIENTRY DevHelp_ProtToReal();
    428 
    429 USHORT APIENTRY DevHelp_RealToProt();
    430 
    431 USHORT APIENTRY DevHelp_ROMCritSection( USHORT EnterExit);
    432 
    433 USHORT APIENTRY DevHelp_SetROMVector( NPFN   IntHandler,
    434                                       USHORT INTNum,
    435                                       USHORT SaveDSLoc,
    436                                       PULONG LastHeader );
    437 
    438 
    439 
    440 /*
    441 ** Monitors
    442 */
    443 
    444 USHORT APIENTRY DevHelp_MonFlush( USHORT MonitorHandle );
    445 
    446 USHORT APIENTRY DevHelp_Register( USHORT MonitorHandle,
    447                                   USHORT MonitorPID,
    448                                   PBYTE  InputBuffer,
    449                                   NPBYTE OutputBuffer,
    450                                   USHORT ChainFlag );
    451 
    452 USHORT APIENTRY DevHelp_MonitorCreate( USHORT  MonitorHandle,
    453                                        PBYTE   FinalBuffer,
    454                                        NPFN    NotifyRtn,
    455                                        PUSHORT MonitorChainHandle);
    456 
    457 USHORT APIENTRY DevHelp_DeRegister( USHORT  MonitorPID,              /*@V74979*/
    458                                     USHORT  MonitorHandle,           /*@V74979*/
    459                                     PUSHORT MonitorsLeft);
    460 
    461 USHORT APIENTRY DevHelp_MonWrite( USHORT MonitorHandle,
    462                                   PBYTE  DataRecord,
    463                                   USHORT Count,
    464                                   ULONG  TimeStampMS,                /*@V76282*/
    465                                   USHORT WaitFlag );
    466 
    467 /* DevHelp_Register */
    468 
    469 #define CHAIN_AT_TOP    0
    470 #define CHAIN_AT_BOTTOM 1
    471 
    472 
    473 
    474 /*
    475 ** OS/2 2.x Only
    476 **
    477 ** Note: These DeviceHelps are not available on OS/2 1.x systems
    478 **
    479 */
    480 
    481 /*
    482 ** 32-Bit Memory Management
    483 */
    484 
    485 typedef ULONG   LIN;                /* 32-Bit Linear Addess              */
    486 typedef ULONG   _far *PLIN;         /* 16:16 Ptr to 32-Bit Linear Addess */
    487 
    488 USHORT APIENTRY DevHelp_VMLock( ULONG  Flags,
    489                                 LIN    LinearAddr,
    490                                 ULONG  Length,
    491                                 LIN    pPagelist,
    492                                 LIN    pLockHandle,
    493                                 PULONG PageListCount );
    494 
    495 USHORT APIENTRY DevHelp_VMUnLock( LIN pLockHandle );
    496 
    497 USHORT APIENTRY DevHelp_VMAlloc( ULONG  Flags,
    498                                  ULONG  Size,
    499                                  ULONG  PhysAddr,
    500                                  PLIN   LinearAddr,
    501                                  PPVOID SelOffset );
    502 
    503 USHORT APIENTRY DevHelp_VMFree( LIN LinearAddr );
    504 
    505 USHORT APIENTRY DevHelp_VMProcessToGlobal( ULONG Flags,
    506                                            LIN   LinearAddr,
    507                                            ULONG Length,
    508                                            PLIN  GlobalLinearAddr );
    509 
    510 USHORT APIENTRY DevHelp_VMGlobalToProcess( ULONG Flags,
    511                                            LIN   LinearAddr,
    512                                            ULONG Length,
    513                                            PLIN  ProcessLinearAddr );
    514 
    515 USHORT APIENTRY DevHelp_VirtToLin( SEL   Selector,
    516                                    ULONG Offset,
    517                                    PLIN  LinearAddr );
    518 
    519 USHORT APIENTRY DevHelp_LinToGDTSelector( SEL   Selector,
    520                                           LIN   LinearAddr,
    521                                           ULONG Size );
    522 
    523 USHORT APIENTRY DevHelp_GetDescInfo( SEL Selector,
    524                                      PBYTE SelInfo );
    525 
    526 USHORT APIENTRY DevHelp_PageListToLin( ULONG Size,
    527                                        LIN   pPageList,
    528                                        PLIN  LinearAddr );
    529 
    530 USHORT APIENTRY DevHelp_LinToPageList( LIN    LinearAddr,
    531                                        ULONG  Size,
    532                                        LIN    pPageList,
    533                                        PULONG PageListCount );
    534 
    535 USHORT APIENTRY DevHelp_PageListToGDTSelector( SEL    Selector,
    536                                                ULONG  Size,
    537                                                USHORT Access,
    538                                                LIN    pPageList );
    539 
    540 USHORT APIENTRY DevHelp_VMSetMem( LIN LinearAddr,                    /*@V74979*/
    541                                   ULONG Size,                        /*@V74979*/
    542                                   ULONG Flags );                     /*@V74979*/
    543 
    544 USHORT APIENTRY DevHelp_FreeGDTSelector( SEL Selector );
    545 
    546 
    547 /* DevHelp_VMLock */
    548 
    549 #define VMDHL_NOBLOCK           0x0001
    550 #define VMDHL_CONTIGUOUS        0x0002
    551 #define VMDHL_16M               0x0004
    552 #define VMDHL_WRITE             0x0008
    553 #define VMDHL_LONG              0x0010
    554 #define VMDHL_VERIFY            0x0020
    555 /* if request would involve wating for short term locks, then give up and lock non-contiguously */
    556 #define VMDHL_TRY_CONTIG        0x8000                               /* os2ddprog, message 2465 */
    557 
    558 /* DevHelp_VMAlloc */                                                /*@V76282*/
    559                                                                      /*@V76282*/
    560 #define VMDHA_16M               0x0001                               /*@V76282*/
    561 #define VMDHA_FIXED             0x0002                               /*@V76282*/
    562 #define VMDHA_SWAP              0x0004                               /*@V76282*/
    563 #define VMDHA_CONTIG            0x0008                               /*@V76282*/
    564 #define VMDHA_PHYS              0x0010                               /*@V76282*/
    565 #define VMDHA_PROCESS           0x0020                               /*@V76282*/
    566 #define VMDHA_SGSCONT           0x0040                               /*@V76282*/
    567 /* Provide selector mapping and return 16:16 address in ECX (or SelOffset for that matter) */
    568 #define VMDHA_SELMAP            0x0080                               /* os2ddprog, message 2465 */
    569 #define VMDHA_RESERVE           0x0100                               /*@V76282*/
    570 /* Allocate shared memory object. This flag is only supported for mapping a physical address */
    571 /* to non-system memory into the shared arena. VMDHA_PHYS must be specified */
    572 #define VMDHA_SHARED            0x0400                               /* os2ddprog, message 2465 */
    573 #define VMDHA_USEHIGHMEM        0x0800                               /*@V76282*/
    574 /* align on a 64k boundary */
    575 #define VMDHA_ALIGN64K          0x1000                               /* os2ddprog, message 2465 */
    576 /* Like OBJ_ANY for DosAllocMem -- use above 512mb line if possible */
    577 #define VMDHA_USEHMA            0x2000                               /* os2ddprog, message 2465 */
    578 
    579 /* DevHelp_VMGlobalToProcess */                                      /*@V76282*/
    580                                                                      /*@V76282*/
    581 #define VMDHGP_WRITE            0x0001                               /*@V76282*/
    582 #define VMDHGP_SELMAP           0x0002                               /*@V76282*/
    583 #define VMDHGP_SGSCONTROL       0x0004                               /*@V76282*/
    584 #define VMDHGP_4MEG             0x0008                               /*@V76282*/
    585  /* map to process memory address space above 512 MB if possible, for newer kernels */
    586 #define VMDHGP_HMA              0x0020                               /* os2ddprog, message 993 */
    587 
    588 /* DevHelp_VMProcessToGlobal */                                      /*@V76282*/
    589                                                                      /*@V76282*/
    590 #define VMDHPG_READONLY         0x0000                               /*@V76282*/
    591 #define VMDHPG_WRITE            0x0001                               /*@V76282*/
    592 
    593 /* DevHelp_GetDescInfo */                                            /*@V76282*/
    594                                                                      /*@V76282*/
    595 typedef struct _SELDESCINFO {           /* DHSI */                   /*@V76282*/
    596                                                                      /*@V76282*/
    597   UCHAR    Type;                                                     /*@V76282*/
    598   UCHAR    Granularity;                                              /*@V76282*/
    599   LIN      BaseAddr;                                                 /*@V76282*/
    600   ULONG    Limit;                                                    /*@V76282*/
    601                                                                      /*@V76282*/
    602 } SELDESCINFO;                                                       /*@V76282*/
    603                                                                      /*@V76282*/
    604 typedef SELDESCINFO FAR *PSELDESCINFO;                               /*@V76282*/
    605                                                                      /*@V76282*/
    606 typedef struct _GATEDESCINFO {          /* DHGI */                   /*@V76282*/
    607                                                                      /*@V76282*/
    608   UCHAR    Type;                                                     /*@V76282*/
    609   UCHAR    ParmCount;                                                /*@V76282*/
    610   SEL      Selector;                                                 /*@V76282*/
    611   USHORT   Reserved_1;                                               /*@V76282*/
    612   ULONG    Offset;                                                   /*@V76282*/
    613                                                                      /*@V76282*/
    614 } GATEDESCINFO;                                                      /*@V76282*/
    615                                                                      /*@V76282*/
    616 typedef GATEDESCINFO FAR *PGATEDESCINFO;                             /*@V76282*/
    617 
    618 /* DevHelp_PageListToGDTSelector */                                  /*@V76282*/
    619 /* DevHelp_PageListToGDTSel      */                                  /*@V76282*/
    620                                                                      /*@V76282*/
    621 #define GDTSEL_R3CODE           0x0000                               /*@V76282*/
    622 #define GDTSEL_R3DATA           0x0001                               /*@V76282*/
    623 #define GDTSEL_R2CODE           0x0003                               /*@V76282*/
    624 #define GDTSEL_R2DATA           0x0004                               /*@V76282*/
    625 #define GDTSEL_R0CODE           0x0005                               /*@V76282*/
    626 #define GDTSEL_R0DATA           0x0006                               /*@V76282*/
    627 
    628 /* GDTSEL_ADDR32 may be OR'd with above defines */                   /*@V76282*/
    629 #define GDTSEL_ADDR32           0x0080                               /*@V76282*/
    630 
    631 /* DevHelp_VMSetMem */                                               /*@V76282*/
    632                                                                      /*@V76282*/
    633 #define VMDHS_DECOMMIT          0x0001                               /*@V76282*/
    634 #define VMDHS_RESIDENT          0x0002                               /*@V76282*/
    635 #define VMDHS_SWAP              0x0004                               /*@V76282*/
    636 
    637 /* PageList structure */                                             /*@V76282*/
    638                                                                      /*@V76282*/
    639 typedef struct _PAGELIST {      /* DHPL */                           /*@V76282*/
    640                                                                      /*@V76282*/
    641   ULONG    PhysAddr;                                                 /*@V76282*/
    642   ULONG    Size;                                                     /*@V76282*/
    643                                                                      /*@V76282*/
    644 } PAGELIST;                                                          /*@V76282*/
    645                                                                      /*@V76282*/
    646 typedef PAGELIST NEAR *NPPAGELIST;                                   /*@V76282*/
    647 typedef PAGELIST FAR  *PPAGELIST;                                    /*@V76282*/
    648 
    649 
    650 /*
    651 ** 32-Bit Context Hooks
    652 */
    653 
    654 USHORT APIENTRY DevHelp_AllocateCtxHook( NPFN   HookHandler,
    655                                          PULONG HookHandle );
    656 
    657 USHORT APIENTRY DevHelp_FreeCtxHook( ULONG HookHandle );
    658 
    659 USHORT APIENTRY DevHelp_ArmCtxHook( ULONG HookData,
    660                                     ULONG HookHandle );
    661 
    662 
    663 /*
    664 ** Adapter Device Drivers / Device Managers
    665 */
    666 
    667 USHORT APIENTRY DevHelp_RegisterDeviceClass( NPSZ    DeviceString,
    668                                              PFN     DriverEP,
    669                                              USHORT  DeviceFlags,
    670                                              USHORT  DeviceClass,
    671                                              PUSHORT DeviceHandle);
    672 
    673 USHORT APIENTRY DevHelp_CreateInt13VDM( PBYTE VDMInt13CtrlBlk );
    674 
    675 /* DevHelp_RegisterDeviceClass */                                    /*@V74979*/
    676                                                                      /*@V74979*/
    677 #define DEVICECLASS_ADDDM       1                                    /*@V74979*/
    678 #define DEVICECLASS_MOUSE       2                                    /*@V74979*/
    679 
    680 /*
    681 ** Miscellaneous
    682 */
    683 
    684 USHORT APIENTRY DevHelp_RegisterBeep( PFN BeepHandler );             /*@V74979*/
    685 
    686 USHORT APIENTRY DevHelp_Beep( USHORT Frequency,                      /*@V74979*/
    687                               USHORT DurationMS );                   /*@V74979*/
    688 
    689 USHORT APIENTRY DevHelp_RegisterPDD( NPSZ PhysDevName,
    690                                      PFN  HandlerRoutine );
    691 
    692 USHORT APIENTRY DevHelp_DynamicAPI( PVOID  RoutineAddress,           /*@V76282*/
    693                                     USHORT ParmCount,                /*@V76282*/
    694                                     USHORT Flags,                    /*@V76282*/
    695                                     PSEL   CallGateSel );            /*@V76282*/
    696                                                                      /*@V76282*/
    697                                                                      /*@V76282*/
    698 /* DevHelp_DynamicAPI */                                             /*@V76282*/
    699 #define DYNAPI_CALLGATE16       0x0001   /* 16:16 CallGate     */    /*@V76282*/
    700 #define DYNAPI_CALLGATE32       0x0000   /*  0:32 CallGate     */    /*@V76282*/
    701                                                                      /*@V76282*/
    702 #define DYNAPI_ROUTINE16        0x0002   /* 16:16 Routine Addr */    /*@V76282*/
    703 #define DYNAPI_ROUTINE32        0x0000   /*  0:32 Routine Addr */    /*@V76282*/
    704 
    705 
    706 /* File Systems DevHelp routines for BaseDev Init Time Only    */
    707 
    708 typedef struct FOPEN {           /* DHFSO */
    709         PSZ   FileName;
    710         ULONG FileSize;
    711 } FILEOPEN;
    712 
    713 
    714 typedef struct FCLOSE {          /* DHFSC */
    715         USHORT Reserved;
    716 } FILECLOSE;
    717 
    718 typedef struct FREAD  {          /* DHFSR */
    719         PBYTE Buffer;
    720         ULONG ReadSize;
    721 } FILEREAD;
    722 
    723 typedef struct FREADAT {         /* DHFSA */
    724         PBYTE Buffer;
    725         ULONG ReadSize;
    726         ULONG StartPosition;
    727 } FILEREADAT;
    728 
    729 typedef union FILEIOOP {            /* DHFOP */
    730                struct FOPEN FileOpen;
    731                struct FCLOSE FileClose;
    732                struct FREAD FileRead;
    733                struct FREADAT FileReadAt;
    734 } FILEIOOP;
    735 
    736 typedef struct _DDFileIo {       /* DHFSIO */
    737         USHORT   Length;
    738         FILEIOOP Data;
    739 } FILEIOINFO, FAR * PFILEIOINFO;
    740 
    741 USHORT APIENTRY DevHelp_OpenFile( PFILEIOINFO pFileOpen);
    742 USHORT APIENTRY DevHelp_CloseFile( PFILEIOINFO pFileClose );
    743 USHORT APIENTRY DevHelp_ReadFile( PFILEIOINFO pFileRead );
    744 USHORT APIENTRY DevHelp_ReadFileAt( PFILEIOINFO pFileReadAT );
    745 
    746 
    747 /*
    748 ** DevHlp Error Codes  (from ABERROR.INC)
    749 */
    750 
    751 #define MSG_MEMORY_ALLOCATION_FAILED    0x00
    752 #define ERROR_LID_ALREADY_OWNED         0x01
    753 #define ERROR_LID_DOES_NOT_EXIST        0x02
    754 #define ERROR_ABIOS_NOT_PRESENT         0x03
    755 #define ERROR_NOT_YOUR_LID              0x04
    756 #define ERROR_INVALID_ENTRY_POINT       0x05
    757 
    758 
     1 #ifndef __DHCALLS_H__
     2 #define __DHCALLS_H__
     3
     4 typedef VOID   NEAR    *NPVOID;
     5 typedef VOID   FAR     *PVOID;
     6 typedef PVOID  FAR     *PPVOID;
     7 typedef USHORT NEAR    *NPUSHORT;
     8
     9 typedef ULONG          LIN;
     10 typedef ULON   FAR     *PLIN;
     11
     12 #define MSG_MEMORY_ALLOCATION_FAILED 0x00
     13 #define ERROR_LID_ALREADY_OWNED      0x01
     14 #define ERROR_LID_DOES_NOT_EXIST     0x02
     15 #define ERROR_ABIOS_NOT_PRESENT      0x03
     16 #define ERROR_NOT_YOUR_LID           0x04
     17 #define ERROR_INVALID_ENTRY_POINT    0x05
     18
     19 //
     20 // memory operations (alloc/free/etc)
     21 //
     22
     23 USHORT APIENTRY DevHelp_AllocGDTSelector(
     24    PSEL   Selectors,
     25    USHORT Count
     26 );
     27
     28 #define MEMTYPE_ABOVE_1M      0
     29 #define MEMTYPE_BELOW_1M      1
     30
     31 USHORT APIENTRY DevHelp_AllocPhys(
     32    ULONG  lSize,
     33    USHORT MemType,
     34    PULONG PhysAddr
     35 );
     36
     37 USHORT APIENTRY DevHelp_FreePhys(
     38    ULONG PhysAddr
     39 );
     40
     41 USHORT APIENTRY DevHelp_PhysToGDTSelector(
     42    ULONG  PhysAddr,
     43    USHORT Count,
     44    SEL    Selector
     45 );
     46
     47 USHORT APIENTRY DevHelp_PhysToGDTSel(
     48    ULONG PhysAddr,
     49    ULONG Count,
     50    SEL   Selector,
     51    UCHAR Access
     52 );
     53
     54 USHORT APIENTRY DevHelp_PhysToVirt(
     55    ULONG   PhysAddr,
     56    USHORT  usLength,
     57    PVOID   SelOffset,
     58    PUSHORT ModeFlag
     59 );
     60
     61 USHORT APIENTRY DevHelp_UnPhysToVirt(
     62    PUSHORT ModeFlag
     63 );
     64
     65 #define SELTYPE_R3CODE        0
     66 #define SELTYPE_R3DATA        1
     67 #define SELTYPE_FREE          2
     68 #define SELTYPE_R2CODE        3
     69 #define SELTYPE_R2DATA        4
     70 #define SELTYPE_R3VIDEO       5
     71
     72 USHORT APIENTRY DevHelp_PhysToUVirt(
     73    ULONG  PhysAddr,
     74    USHORT Length,
     75    USHORT Flags,
     76    USHORT TagType,
     77    PVOID  SelOffset
     78 );
     79
     80 USHORT APIENTRY DevHelp_VirtToPhys(
     81    PVOID  SelOffset,
     82    PULONG PhysAddr
     83 );
     84
     85 #define LOCKTYPE_SHORT_ANYMEM 0x00
     86 #define LOCKTYPE_LONG_ANYMEM  0x01
     87 #define LOCKTYPE_LONG_HIGHMEM 0x03
     88 #define LOCKTYPE_SHORT_VERIFY 0x04
     89
     90 USHORT APIENTRY DevHelp_Lock(
     91    SEL    Segment,
     92    USHORT LockType,
     93    USHORT WaitFlag,
     94    PULONG LockHandle
     95 );
     96
     97 USHORT APIENTRY DevHelp_UnLock(
     98    ULONG LockHandle
     99 );
     100
     101 #define VERIFY_READONLY       0
     102 #define VERIFY_READWRITE      1
     103
     104 USHORT APIENTRY DevHelp_VerifyAccess(
     105    SEL    MemSelector,
     106    USHORT Length,
     107    USHORT MemOffset,
     108    UCHAR  AccessFlag
     109 );
     110
     111 #define VMDHA_16M             0x0001
     112 #define VMDHA_FIXED           0x0002
     113 #define VMDHA_SWAP            0x0004
     114 #define VMDHA_CONTIG          0x0008
     115 #define VMDHA_PHYS            0x0010
     116 #define VMDHA_PROCESS         0x0020
     117 #define VMDHA_SGSCONT         0x0040
     118 #define VMDHA_SELMAP          0x0080
     119 #define VMDHA_RESERVE         0x0100
     120 #define VMDHA_SHARED          0x0400
     121 #define VMDHA_USEHIGHMEM      0x0800
     122 #define VMDHA_ALIGN64K        0x1000
     123 #define VMDHA_USEHMA          0x2000
     124
     125 USHORT APIENTRY DevHelp_VMAlloc(
     126    ULONG  Flags,
     127    ULONG  Size,
     128    ULONG  PhysAddr,
     129    PLIN   LinearAddr,
     130    PPVOID SelOffset
     131 );
     132
     133 USHORT APIENTRY DevHelp_VMFree(
     134    LIN LinearAddr
     135 );
     136
     137 #define VMDHL_NOBLOCK        0x0001
     138 #define VMDHL_CONTIGUOUS     0x0002
     139 #define VMDHL_16M            0x0004
     140 #define VMDHL_WRITE          0x0008
     141 #define VMDHL_LONG           0x0010
     142 #define VMDHL_VERIFY         0x0020
     143 #define VMDHL_TRY_CONTIG     0x8000
     144
     145 USHORT APIENTRY DevHelp_VMLock(
     146    ULONG  Flags,
     147    LIN    LinearAddr,
     148    ULONG  Length,
     149    LIN    pPagelist,
     150    LIN    pLockHandle,
     151    PULONG PageListCount
     152 );
     153
     154 USHORT APIENTRY DevHelp_VMUnLock(
     155    LIN pLockHandle
     156 );
     157
     158 #define VMDHPG_READONLY            0x0000
     159 #define VMDHPG_WRITE               0x0001
     160
     161 USHORT APIENTRY DevHelp_VMProcessToGlobal(
     162    ULONG Flags,
     163    LIN   LinearAddr,
     164    ULONG Length,
     165    PLIN  GlobalLinearAddr
     166 );
     167
     168 #define VMDHGP_WRITE               0x0001
     169 #define VMDHGP_SELMAP              0x0002
     170 #define VMDHGP_SGSCONTROL          0x0004
     171 #define VMDHGP_4MEG                0x0008
     172 #define VMDHGP_HMA                 0x0020
     173
     174 USHORT APIENTRY DevHelp_VMGlobalToProcess(
     175    ULONG Flags,
     176    LIN   LinearAddr,
     177    ULONG Length,
     178    PLIN  ProcessLinearAddr
     179 );
     180
     181 USHORT APIENTRY DevHelp_VirtToLin(
     182    SEL   Selector,
     183    ULONG Offset,
     184    PLIN  LinearAddr
     185 );
     186
     187 USHORT APIENTRY DevHelp_LinToGDTSelector(
     188    SEL   Selector,
     189    LIN   LinearAddr,
     190    ULONG Size
     191 );
     192
     193 typedef struct _SELDESCINFO
     194 {
     195    UCHAR  Type;
     196    UCHAR  Granularity;
     197    LIN    BaseAddr;
     198    ULONG  Limit;
     199 } SELDESCINFO, FAR *PSELDESCINFO;
     200
     201 typedef struct _GATEDESCINFO
     202 {
     203    UCHAR  Type;
     204    UCHAR  ParmCount;
     205    SEL    Selector;
     206    USHORT Reserved_1;
     207    ULONG  Offset;
     208 } GATEDESCINFO, FAR *PGATEDESCINFO;
     209
     210 USHORT APIENTRY DevHelp_GetDescInfo(
     211    SEL Selector,
     212    PBYTE SelInfo
     213 );
     214
     215 USHORT APIENTRY DevHelp_PageListToLin(
     216    ULONG Size,
     217    LIN   pPageList,
     218    PLIN  LinearAddr
     219 );
     220
     221 USHORT APIENTRY DevHelp_LinToPageList(
     222    LIN    LinearAddr,
     223    ULONG  Size,
     224    LIN    pPageList,
     225    PULONG PageListCount
     226 );
     227
     228 #define GDTSEL_R3CODE          0x0000
     229 #define GDTSEL_R3DATA          0x0001
     230 #define GDTSEL_R2CODE          0x0003
     231 #define GDTSEL_R2DATA          0x0004
     232 #define GDTSEL_R0CODE          0x0005
     233 #define GDTSEL_R0DATA          0x0006
     234
     235 #define GDTSEL_ADDR32          0x0080
     236
     237 USHORT APIENTRY DevHelp_PageListToGDTSelector(
     238    SEL    Selector,
     239    ULONG  Size,
     240    USHORT Access,
     241    LIN    pPageList
     242 );
     243
     244 #define VMDHS_DECOMMIT         0x0001
     245 #define VMDHS_RESIDENT         0x0002
     246 #define VMDHS_SWAP             0x0004
     247
     248 typedef struct _PAGELIST
     249 {
     250    ULONG PhysAddr;
     251    ULONG Size;
     252 } PAGELIST, NEAR *NPPAGELIST, FAR  *PPAGELIST;
     253
     254 USHORT APIENTRY DevHelp_VMSetMem(
     255    LIN LinearAddr,
     256    ULONG Size,
     257    ULONG Flags
     258 );
     259
     260 USHORT APIENTRY DevHelp_FreeGDTSelector(
     261    SEL Selector
     262 );
     263
     264 //
     265 // Working with request packets
     266 //
     267
     268 #define WAIT_NOT_ALLOWED    0
     269 #define WAIT_IS_ALLOWED     1
     270
     271 USHORT APIENTRY DevHelp_AllocReqPacket(
     272    USHORT    WaitFlag,
     273    PBYTE FAR *ReqPktAddr
     274 );
     275
     276 USHORT APIENTRY DevHelp_FreeReqPacket(
     277    PBYTE ReqPktAddr
     278 );
     279
     280 USHORT APIENTRY DevHelp_PullParticular(
     281    NPBYTE Queue,
     282    PBYTE  ReqPktAddr
     283 );
     284
     285 USHORT APIENTRY DevHelp_PullRequest(
     286    NPBYTE    Queue,
     287    PBYTE FAR *ReqPktAddr);
     288
     289 USHORT APIENTRY DevHelp_PushRequest(
     290    NPBYTE Queue,
     291    PBYTE  ReqPktAddr
     292 );
     293
     294 USHORT APIENTRY DevHelp_SortRequest(
     295    NPBYTE Queue,
     296    PBYTE  ReqPktAddr
     297 );
     298
     299 //
     300 // IDC and other functions
     301 //
     302
     303 USHORT APIENTRY DevHelp_RealToProt();
     304
     305 USHORT APIENTRY DevHelp_ProtToReal();
     306
     307 USHORT APIENTRY DevHelp_InternalError(
     308    PSZ    MsgText,
     309    USHORT MsgLength
     310 );
     311
     312 USHORT APIENTRY DevHelp_RAS(
     313    USHORT Major,
     314    USHORT Minor,
     315    USHORT Size,
     316    PBYTE Data
     317 );
     318
     319 USHORT APIENTRY DevHelp_RegisterPerfCtrs(
     320    NPBYTE pDataBlock,
     321    NPBYTE pTextBlock,
     322    USHORT Flags
     323 );
     324
     325 #define DHGETDOSV_SYSINFOSEG         1
     326 #define DHGETDOSV_LOCINFOSEG         2
     327 #define DHGETDOSV_VECTORSDF          4
     328 #define DHGETDOSV_VECTORREBOOT       5
     329 #define DHGETDOSV_YIELDFLAG          7
     330 #define DHGETDOSV_TCYIELDFLAG        8
     331 #define DHGETDOSV_DOSCODEPAGE        11
     332 #define DHGETDOSV_INTERRUPTLEV       13
     333 #define DHGETDOSV_DEVICECLASSTABLE   14
     334 #define DHGETDOSV_DMQSSELECTOR       15
     335 #define DHGETDOSV_APMINFO            16
     336
     337 USHORT APIENTRY DevHelp_GetDOSVar(
     338    USHORT VarNumber,
     339    USHORT VarMember,
     340    PPVOID KernelVar
     341 );
     342
     343 typedef struct _IDCTABLE
     344 {
     345    USHORT        Reserved[3];
     346    VOID          (FAR *ProtIDCEntry)(VOID);
     347    USHORT        ProtIDC_DS;
     348 } IDCTABLE, NEAR *NPIDCTABLE;
     349
     350 USHORT APIENTRY DevHelp_AttachDD(
     351    NPSZ   DDName,
     352    NPBYTE IDCTable
     353 );
     354
     355 typedef struct _MSGTABLE
     356 {
     357    USHORT   MsgId;
     358    USHORT   cMsgStrings;
     359    PSZ      MsgStrings[1];
     360 } MSGTABLE, NEAR *NPMSGTABLE;
     361
     362 USHORT APIENTRY DevHelp_Save_Message( NPBYTE MsgTable );
     363
     364 USHORT APIENTRY DevHelp_LogEntry(
     365     PVOID,
     366     USHORT
     367 );
     368
     369 //
     370 // ADD / DMD interaction
     371 //
     372
     373 #define DEVICECLASS_ADDDM          1
     374 #define DEVICECLASS_MOUSE          2
     375
     376 USHORT APIENTRY DevHelp_RegisterDeviceClass(
     377    NPSZ    DeviceString,
     378    PFN     DriverEP,
     379    USHORT  DeviceFlags,
     380    USHORT  DeviceClass,
     381    PUSHORT DeviceHandle
     382 );
     383
     384 USHORT APIENTRY DevHelp_CreateInt13VDM(
     385    PBYTE VDMInt13CtrlBlk
     386 );
     387
     388 //
     389 // Interrupt/Thread Management
     390 //
     391
     392 USHORT APIENTRY DevHelp_SetIRQ(
     393    NPFN   IRQHandler,
     394    USHORT IRQLevel,
     395    USHORT SharedFlag
     396 );
     397
     398 USHORT APIENTRY DevHelp_UnSetIRQ(
     399    USHORT IRQLevel
     400 );
     401
     402 USHORT APIENTRY DevHelp_EOI( USHORT IRQLevel );
     403
     404 typedef struct _STACKUSAGEDATA
     405 {
     406    USHORT Size;
     407    USHORT Flags;
     408    USHORT IRQLevel;
     409    USHORT CLIStack;
     410    USHORT STIStack;
     411    USHORT EOIStack;
     412    USHORT NestingLevel;
     413 } STACKUSAGEDATA;
     414
     415 USHORT APIENTRY DevHelp_RegisterStackUsage(
     416    PVOID StackUsageData
     417 );
     418
     419 USHORT APIENTRY DevHelp_Yield(void);
     420
     421 USHORT APIENTRY DevHelp_TCYield(void);
     422
     423 USHORT APIENTRY DevHelp_ProcRun(
     424    ULONG   EventId,
     425    PUSHORT AwakeCount
     426 );
     427
     428 #define WAIT_IS_INTERRUPTABLE      0
     429 #define WAIT_IS_NOT_INTERRUPTABLE  1
     430
     431 #define WAIT_INTERRUPTED           0x8003
     432 #define WAIT_TIMED_OUT             0x8001
     433
     434 USHORT APIENTRY DevHelp_ProcBlock(
     435    ULONG  EventId,
     436    ULONG  WaitTime,
     437    USHORT IntWaitFlag
     438 );
     439
     440 USHORT APIENTRY DevHelp_DevDone(
     441    PBYTE ReqPktAddr
     442 );
     443
     444 #define VIDEO_PAUSE_OFF            0
     445 #define VIDEO_PAUSE_ON             1
     446
     447 USHORT APIENTRY DevHelp_VideoPause(
     448    USHORT OnOff
     449 );
     450
     451 //
     452 // Semaphores
     453 //
     454
     455 USHORT APIENTRY DevHelp_OpenEventSem(
     456    ULONG hEvent
     457 );
     458
     459 USHORT APIENTRY DevHelp_CloseEventSem(
     460    ULONG hEvent
     461 );
     462
     463 USHORT APIENTRY DevHelp_PostEventSem(
     464    ULONG hEvent
     465 );
     466
     467 USHORT APIENTRY DevHlp_ResetEventSem(
     468    ULONG hEvent,
     469    PULONG pNumPosts
     470 );
     471
     472 #define SEMUSEFLAG_IN_USE       0
     473 #define SEMUSEFLAG_NOT_IN_USE   1
     474
     475 USHORT APIENTRY DevHelp_SemHandle(
     476    ULONG  SemKey,
     477    USHORT SemUseFlag,
     478    PULONG SemHandle
     479 );
     480
     481 USHORT APIENTRY DevHelp_SemRequest(
     482    ULONG SemHandle,
     483    ULONG SemTimeout
     484 );
     485
     486 USHORT APIENTRY DevHelp_SemClear(
     487    ULONG SemHandle
     488 );
     489
     490 #define EVENT_MOUSEHOTKEY      0
     491 #define EVENT_CTRLBREAK        1
     492 #define EVENT_CTRLC            2
     493 #define EVENT_CTRLNUMLOCK      3
     494 #define EVENT_CTRLPRTSC        4
     495 #define EVENT_SHIFTPRTSC       5
     496 #define EVENT_KBDHOTKEY        6
     497 #define EVENT_KBDREBOOT        7
     498
     499 USHORT APIENTRY DevHelp_SendEvent(
     500    USHORT EventType,
     501    USHORT Parm
     502 );
     503
     504 //
     505 // Timers
     506 //
     507
     508 USHORT APIENTRY DevHelp_SetTimer(
     509    NPFN TimerHandler
     510 );
     511
     512 USHORT APIENTRY DevHelp_ResetTimer(
     513    NPFN TimerHandler
     514 );
     515
     516 USHORT APIENTRY DevHelp_TickCount(
     517    NPFN   TimerHandler,
     518    USHORT TickCount
     519 );
     520
     521 USHORT APIENTRY DevHelp_SchedClock(
     522    PFN NEAR *SchedRoutineAddr
     523 );
     524
     525 USHORT APIENTRY DevHelp_RegisterTmrDD(
     526    NPFN   TimerEntry,
     527    PULONG TmrRollover,
     528    PULONG Tmr
     529 );
     530
     531 //
     532 // Device Monitors
     533 //
     534
     535 USHORT APIENTRY DevHelp_MonitorCreate(
     536    USHORT  MonitorHandle,
     537    PBYTE   FinalBuffer,
     538    NPFN    NotifyRtn,
     539    PUSHORT MonitorChainHandle
     540 );
     541
     542 #define CHAIN_AT_TOP    0
     543 #define CHAIN_AT_BOTTOM 1
     544
     545 USHORT APIENTRY DevHelp_Register(
     546    USHORT MonitorHandle,
     547    USHORT MonitorPID,
     548    PBYTE  InputBuffer,
     549    NPBYTE OutputBuffer,
     550    USHORT ChainFlag
     551 );
     552
     553 USHORT APIENTRY DevHelp_DeRegister(
     554    USHORT  MonitorPID,
     555    USHORT  MonitorHandle,
     556    PUSHORT MonitorsLeft
     557 );
     558
     559 USHORT APIENTRY DevHelp_MonFlush(
     560    USHORT MonitorHandle
     561 );
     562
     563 USHORT APIENTRY DevHelp_MonWrite(
     564    USHORT MonitorHandle,
     565    PBYTE  DataRecord,
     566    USHORT Count,
     567    ULONG  TimeStampMS,
     568    USHORT WaitFlag
     569 );
     570
     571 //
     572 // Character queues
     573 //
     574
     575 typedef struct _QUEUEHDR
     576 {
     577    USHORT QSize;
     578    USHORT QChrOut;
     579    USHORT Count;
     580    BYTE   Queue[1];
     581 } QUEUEHDR, FAR *PQUEUEHDR;
     582
     583 USHORT APIENTRY DevHelp_QueueInit(
     584   NPBYTE Queue
     585 );
     586
     587 USHORT APIENTRY DevHelp_QueueRead(
     588    NPBYTE Queue,
     589    PBYTE  Char
     590 );
     591
     592 USHORT APIENTRY DevHelp_QueueWrite(
     593    NPBYTE Queue,
     594    UCHAR  Char
     595 );
     596
     597 USHORT APIENTRY DevHelp_QueueFlush(
     598    NPBYTE Queue
     599 );
     600
     601 //
     602 // Context Hooks
     603 //
     604
     605 USHORT APIENTRY DevHelp_AllocateCtxHook(
     606    NPFN   HookHandler,
     607    PULONG HookHandle
     608 );
     609
     610 USHORT APIENTRY DevHelp_FreeCtxHook(
     611    ULONG HookHandle
     612 );
     613
     614 USHORT APIENTRY DevHelp_ArmCtxHook(
     615    ULONG HookData,
     616    ULONG HookHandle
     617 );
     618
     619 //
     620 // Mode Switching / Real Mode
     621 //
     622
     623 USHORT APIENTRY DevHelp_RealToProt();
     624 
     625 USHORT APIENTRY DevHelp_ProtToReal();
     626
     627 USHORT APIENTRY DevHelp_ROMCritSection(
     628    USHORT EnterExit
     629 );
     630
     631 USHORT APIENTRY DevHelp_SetROMVector(
     632    NPFN   IntHandler,
     633    USHORT INTNum,
     634    USHORT SaveDSLoc,
     635    PULONG LastHeader
     636 );
     637
     638 //
     639 // File System access (basedev init time only)
     640 //
     641
     642 typedef struct FOPEN
     643 {
     644    PSZ   FileName;
     645    ULONG FileSize;
     646 } FILEOPEN;
     647
     648 typedef struct FREAD
     649 {
     650    PBYTE Buffer;
     651    ULONG ReadSize;
     652 } FILEREAD;
     653
     654 typedef struct FREADAT
     655 {
     656    PBYTE Buffer;
     657    ULONG ReadSize;
     658    ULONG StartPosition;
     659 } FILEREADAT;
     660
     661 typedef struct FCLOSE
     662 {
     663    USHORT Reserved;
     664 } FILECLOSE;
     665
     666 typedef struct _DDFileIo
     667 {
     668    USHORT   Length;
     669    FILEIOOP Data;
     670 } FILEIOINFO, FAR * PFILEIOINFO;
     671
     672 typedef union FILEIOOP
     673 {
     674    struct FOPEN FileOpen;
     675    struct FCLOSE FileClose;
     676    struct FREAD FileRead;
     677    struct FREADAT FileReadAt;
     678 } FILEIOOP;
     679
     680 USHORT APIENTRY DevHelp_OpenFile(
     681    PFILEIOINFO pFileOpen
     682 );
     683
     684 USHORT APIENTRY DevHelp_CloseFile(
     685    PFILEIOINFO pFileClose
     686 );
     687
     688 USHORT APIENTRY DevHelp_ReadFile(
     689    PFILEIOINFO pFileRead
     690 );
     691
     692 USHORT APIENTRY DevHelp_ReadFileAt(
     693    PFILEIOINFO pFileReadAT
     694 );
     695
     696 //
     697 // ABIOS ops
     698 //
     699
     700 USHORT APIENTRY DevHelp_ABIOSCall(
     701    USHORT Lid,
     702    NPBYTE ReqBlk,
     703    USHORT Entry_Type
     704 );
     705
     706 USHORT APIENTRY DevHelp_ABIOSCommonEntry(
     707    NPBYTE ReqBlk,
     708    USHORT Entry_Type
     709 );
     710
     711 USHORT APIENTRY DevHelp_ABIOSGetParms(
     712    USHORT Lid,
     713    NPBYTE ParmsBlk
     714 );
     715
     716 USHORT APIENTRY DevHelp_FreeLIDEntry(
     717    USHORT LIDNumber
     718 );
     719
     720 USHORT APIENTRY DevHelp_GetLIDEntry(
     721    USHORT  DeviceType,
     722    USHORT  LIDIndex,
     723    USHORT  LIDType,
     724    PUSHORT LID
     725 );
     726
     727 USHORT APIENTRY DevHelp_GetDeviceBlock(
     728    USHORT Lid,
     729    PPVOID DeviceBlockPtr
     730 );
     731
     732 //
     733 // Other
     734 //
     735
     736 USHORT APIENTRY DevHelp_RegisterBeep(
     737    PFN BeepHandler
     738 );
     739
     740 USHORT APIENTRY DevHelp_Beep(
     741    USHORT Frequency,
     742    USHORT DurationMS
     743 );
     744
     745 USHORT APIENTRY DevHelp_RegisterPDD(
     746    NPSZ PhysDevName,
     747    PFN  HandlerRoutine
     748 );
     749
     750 #define DYNAPI_ROUTINE16     0x0002
     751 #define DYNAPI_ROUTINE32     0x0000
     752 #define DYNAPI_CALLGATE16    0x0001
     753 #define DYNAPI_CALLGATE32    0x0000
     754
     755 USHORT APIENTRY DevHelp_DynamicAPI(
     756    PVOID  RoutineAddress,
     757    USHORT ParmCount,
     758    USHORT Flags,
     759    PSEL   CallGateSel
     760 );
     761
     762 #endif /* __DHCALLS_H__ */
  • trunk/src/include/fsd.h

    r295 r302  
    1 /*static char *SCCSID = "@(#)fsd.h      6.5 91/12/16";*/
    2 /*  fsd.h   - File system driver entry point declarations */
    3 
    4 /*  FS_ATTRIBUTE bit field values */
    5 
    6 #define FSA_REMOTE  0x00000001  /* Set if REMOTE FSD                  */
    7 #define FSA_UNC     0x00000002  /* Set if FSD implements UNC support  */
    8 #define FSA_LOCK    0x00000004  /* Set if FSD needs lock notification */
    9 #define FSA_LVL7    0x00000008  /* Set if FSD will accept Level 7     */
    10      /* DosQueryPathInfo requests - These are requests for the case-  */
    11      /* perserved "path" of the input file/path name.                 */
    12 #define FSA_PSVR    0x00000010  /* Set if FSD manages Remote NmPipes  */
    13 #define FSA_LARGEFILE 0x00000020 /* Support of files > 2 GB           */
    14 
    15 #define CDDWORKAREASIZE 8
    16 #define SFDWORKAREASIZE 30
    17 #define VPDWORKAREASIZE 36
    18 
    19 
    20 /* Volume Parameter structures */
    21 
    22 #define VPBTEXTLEN 12
    23 
    24 struct  vpfsi {
    25     unsigned long   vpi_vid;                /* 32 bit volume ID */
    26     unsigned long   vpi_hDEV;               /* handle to device driver */
    27     unsigned short  vpi_bsize;              /* sector size in bytes */
    28     unsigned long   vpi_totsec;             /* total number of sectors */
    29     unsigned short  vpi_trksec;             /* sectors / track */
    30     unsigned short  vpi_nhead;              /* number of heads */
    31     char            vpi_text[VPBTEXTLEN];   /* volume name */
    32     void far *      vpi_pDCS;               /* device capability struc */
    33     void far *      vpi_pVCS;               /* volume characteristics struc */
    34     unsigned char   vpi_drive;              /* drive (0=A) */
    35     unsigned char   vpi_unit;               /* unit code */
    36 };  /* vpfsi */
    37 
    38 /*
    39  * Predefined volume IDs: [note - keep this list in sync with list in
    40  * dos/dosinc/vpb.inc!]
    41  */
    42 /* Unique ID for vpb_ID field for unreadable media. */
    43 #define UNREAD_ID  0x534E4A52L          /* Stored as (bytes) 0x52,4A,4E,53. */
    44 
    45 /*
    46  * Unique ID for vpb_ID field for damaged volume (recognized by IFS but cannot
    47  * be normally mounted).
    48  */
    49 #define DAMAGED_ID 0x0L                 /* Stored as (bytes) 0,0,0,0. */
    50 
    51 /* file system dependent - volume params */
    52 struct  vpfsd {
    53     char    vpd_work[VPDWORKAREASIZE];      /* work area */
    54 };  /* vpfsd */
    55 
    56 
    57 /* Current Directory structures */
    58 
    59 struct cdfsi {
    60     unsigned short  cdi_hVPB;           /* VPB handle for associated device */
    61     unsigned short  cdi_end;            /* end of root portion of curdir */
    62     char            cdi_flags;          /* flags indicating state of cdfsd */
    63     char            cdi_curdir[CCHMAXPATH]; /* text of current directory */
    64 };  /* cdfsi */
    65 
    66 /* bit values for cdi_flags (state of cdfsd structure */
    67 
    68 #define CDI_ISVALID 0x80                /* format is known */
    69 #define CDI_ISROOT  0x40                /* cur dir == root */
    70 #define CDI_ISCURRENT   0x20
    71 
    72 struct  cdfsd {
    73     char    cdd_work[CDDWORKAREASIZE];      /* work area */
    74 };  /* cdfsd */
    75 
    76 
    77 /* Per open-instance (System File) structures */
    78 
    79 struct  sffsi {
    80     unsigned long   sfi_mode;       /* access/sharing mode */
    81     unsigned short  sfi_hVPB;       /* volume info. */
    82     unsigned short  sfi_ctime;      /* file creation time */
    83     unsigned short  sfi_cdate;      /* file creation date */
    84     unsigned short  sfi_atime;      /* file access time */
    85     unsigned short  sfi_adate;      /* file access date */
    86     unsigned short  sfi_mtime;      /* file modification time */
    87     unsigned short  sfi_mdate;      /* file modification date */
    88     unsigned long   sfi_size;       /* size of file */
    89     unsigned long   sfi_position;   /* read/write pointer */
    90 /* the following may be of use in sharing checks */
    91     unsigned short  sfi_UID;        /* user ID of initial opener */
    92     unsigned short  sfi_PID;        /* process ID of initial opener */
    93     unsigned short  sfi_PDB;        /* PDB (in 3.x box) of initial opener */
    94     unsigned short  sfi_selfsfn;    /* system file number of file instance */
    95     unsigned char   sfi_tstamp;     /* update/propagate time stamp flags */
    96                                     /* use with ST_Sxxx and ST_Pxxx */
    97     unsigned short  sfi_type;       /* use with STYPE_ */
    98     unsigned long   sfi_pPVDBFil;   /* performance counter data block pointer */
    99     unsigned char   sfi_DOSattr;    /* DOS file attributes  D/S/A/H/R  */
    100     LONGLONG        sfi_sizel;      /* size of file */
    101     LONGLONG        sfi_positionl;  /* read/write pointer */
    102 };  /* sffsi */
    103 
    104 /* sfi_tstamps flags */
    105 #define ST_SCREAT  1    /* stamp creation time */
    106 #define ST_PCREAT  2    /* propagate creation time */
    107 #define ST_SWRITE  4    /* stamp last write time */
    108 #define ST_PWRITE  8    /* propagate last write time */
    109 #define ST_SREAD  16    /* stamp last read time */
    110 #define ST_PREAD  32    /* propagate last read time */
    111 
    112 /* sfi_type flags */
    113 #define STYPE_FILE      0       /* file */
    114 #define STYPE_DEVICE    1       /* device */
    115 #define STYPE_NMPIPE    2       /* named pipe */
    116 #define STYPE_FCB       4       /* fcb sft */
    117 
    118 /* file system dependent - file instance */
    119 struct  sffsd {
    120     char    sfd_work[SFDWORKAREASIZE];      /* work area */
    121 };  /* sffsd */
    122 
    123 
    124 /* file system independent - file search parameters */
    125 struct fsfsi {
    126         unsigned short  fsi_hVPB;       /* volume info. */
    127 };  /* fsfsi */
    128 
    129 /* file system dependent - file search parameters */
    130 #define FSFSD_WORK_SIZE     24
    131 struct fsfsd {
    132         char            fsd_work[FSFSD_WORK_SIZE];      /* work area */
    133 };  /* fsfsd */
    134 
    135 /* file system dependent - device information */
    136 struct devfsd {
    137         unsigned long   FSDRef; /* Reference obtained from FSD during ATTACH */
    138 };  /* devfsd */
    139 
    140 /*****
    141  *
    142  * union and structures for FS_FSCTL
    143  */
    144 /* pArgType == 1, FileHandle directed case */
    145 /* XLATOFF */
    146 struct SF {
    147         struct sffsi far * psffsi;
    148         struct sffsd far * psffsd;
    149 };  /* SF */
    150 /* XLATON */
    151 
    152 /* pArgType == 2, PathName directed case */
    153 struct CD {
    154         struct cdfsi far * pcdfsi;
    155         struct cdfsd far * pcdfsd;
    156         char far *         pPath;
    157         unsigned short     iCurDirEnd;
    158 };  /* CD */
    159 
    160 /* XLATOFF */
    161 union argdat {
    162     /* pArgType == 1, FileHandle directed case */
    163     struct SF sf;
    164 
    165     /* pArgType == 2, PathName directed case */
    166     struct CD cd;
    167 
    168     /* pArgType == 3, FSD Name directed case */
    169     /* nothing */
    170 };  /* argdat */
    171 /* XLATON */
    172 
    173 
    174 /*****
    175  *
    176  * Union and structures for FS_NMPIPE
    177  *
    178  */
    179 
    180     /* Get/SetPHandState parameter block */
    181     struct      phs_param {
    182         short   phs_len;
    183         short   phs_dlen;
    184         short   phs_pmode;      /* pipe mode set or returned */
    185     };
    186 
    187 
    188     /* DosQNmPipeInfo parameter block,
    189      * data is info. buffer addr */
    190     struct      npi_param {
    191         short   npi_len;
    192         short   npi_dlen;
    193         short   npi_level;      /* information level desired */
    194     };
    195 
    196 
    197     /* DosRawReadNmPipe parameters,
    198      * data is buffer addr */
    199     struct      npr_param {
    200         short   npr_len;
    201         short   npr_dlen;
    202         short   npr_nbyt;       /* number of bytes read */
    203     };
    204 
    205     /* DosRawWriteNmPipe parameters,
    206      * data is buffer addr */
    207     struct      npw_param {
    208         short   npw_len;
    209         short   npw_dlen;
    210         short   npw_nbyt;       /* number of bytes written */
    211     };
    212 
    213     /* NPipeWait parameters */
    214     struct      npq_param {
    215         short   npq_len;
    216         short   npq_dlen;
    217         long    npq_timeo;      /* timeout in milliseconds */
    218         short   npq_prio;       /* priority of caller */
    219     };
    220 
    221     /* DosCallNmPipe parameters,
    222      * data is in-buffer addr */
    223     struct      npx_param {
    224         short           npx_len;
    225         unsigned short  npx_ilen;   /* length of in-buffer */
    226         char far        *npx_obuf;  /* pointer to out-buffer */
    227         unsigned short  npx_olen;   /* length of out-buffer */
    228         unsigned short  npx_nbyt;   /* number of bytes read */
    229         long            npx_timeo;  /* timeout in milliseconds */
    230     };
    231 
    232     /* PeekPipe parameters, data is buffer addr */
    233     struct      npp_param {
    234         short           npp_len;
    235         unsigned short  npp_dlen;
    236         unsigned short  npp_nbyt;   /* number of bytes read */
    237         unsigned short  npp_avl0;   /* bytes left in pipe */
    238         unsigned short  npp_avl1;   /* bytes left in current msg */
    239         unsigned short  npp_state;  /* pipe state */
    240     };
    241 
    242     /* DosTransactNmPipe parameters,
    243      * data is in-buffer addr */
    244     struct      npt_param {
    245         short           npt_len;
    246         unsigned short  npt_ilen;   /* length of in-buffer */
    247         char far        *npt_obuf;  /* pointer to out-buffer */
    248         unsigned short  npt_olen;   /* length of out-buffer */
    249         unsigned short  npt_nbyt;   /* number of bytes read */
    250     };
    251 
    252     /* QNmpipeSemState parameter block,
    253      * data is user data buffer */
    254     struct      qnps_param {
    255         unsigned short  qnps_len;   /* length of parameter block */
    256         unsigned short  qnps_dlen;  /* length of supplied data block */
    257         long            qnps_semh;  /* system semaphore handle */
    258         unsigned short  qnps_nbyt;  /* number of bytes returned */
    259     };
    260 
    261     /* ConnectPipe parameter block, no data block */
    262     struct      npc_param {
    263         unsigned short  npc_len;    /* length of parameter block */
    264         unsigned short  npc_dlen;   /* length of data block */
    265     };
    266 
    267     /* DisconnectPipe parameter block, no data block */
    268     struct      npd_param {
    269         unsigned short  npd_len;    /* length of parameter block */
    270         unsigned short  npd_dlen;   /* length of data block */
    271     };
    272 
    273     /* XLATOFF */
    274     union npoper {
    275         struct phs_param    phs;
    276         struct npi_param    npi;
    277         struct npr_param    npr;
    278         struct npw_param    npw;
    279         struct npq_param    npq;
    280         struct npx_param    npx;
    281         struct npp_param    npp;
    282         struct npt_param    npt;
    283         struct qnps_param   qnps;
    284         struct npc_param    npc;
    285         struct npd_param    npd;
    286     };  /* npoper */
    287 /* XLATON */
    288 
    289 
    290 /*****
    291  *
    292  * Declarations for FS_DOPAGEIO entry point.
    293  *
    294  */
    295 
    296     struct PageCmd {
    297         unsigned char Cmd;          /* Cmd code for Read, Write, WriteVerify */
    298         unsigned char Priority;     /* Same values as for request packets */
    299         unsigned char Status;       /* Status byte */
    300         unsigned char Error;        /* I24 error code */
    301         unsigned long Addr;         /* Physical (32 bit) or Virtual (16:16) */
    302         unsigned long FileOffset;   /* Byte offset in page file */
    303                                     /* (on page boundary) */
    304     };
    305 
    306     /* XLATOFF */
    307     struct PageCmdHeader {
    308         unsigned char InFlags;          /* Input flags */
    309         unsigned char OutFlags;         /* Output flags - must be 0 on entry */
    310         unsigned char OpCount;          /* Number of operations */
    311         unsigned char Pad;              /* Preserve DWORD alignment */
    312         unsigned long Reserved1;        /* unused */
    313         unsigned long Reserved2;        /* unused */
    314         unsigned long Reserved3;        /* unused */
    315         struct PageCmd PageCmdList [1]; /* The actual commands */
    316     };
    317     /* XLATON */
    318 
    319     /* FSD_DoPageIO InFlags values */
    320     #define PGIO_FI_ORDER   0x01    /* Force Order of operations */
    321 
    322     /* FSD_DoPageIO OutFlags values */
    323     #define PGIO_FO_DONE    0x01    /* Operation done */
    324     #define PGIO_FO_ERROR   0x02    /* Operation failed */
    325 
    326     /* FSD_DoPageIO Status values */
    327     #define PGIO_ATTEMPTED  0x0f    /* Operation attempted */
    328     #define PGIO_FAILED     0xf0    /* Operation failed */
    329 
    330 /*****
    331  *
    332  * Declarations for the FSD entry points.
    333  *
    334  */
    335 
    336 /* bit values for the IOflag parameter in various FS_ entry points */
    337 #define IOFL_WRITETHRU      0x10        /* Write through bit    */
    338 #define IOFL_NOCACHE        0x20        /* No Cache bit         */
    339 
    340 
    341 /* XLATOFF */
    342 int far pascal _loadds
    343 FS_ALLOCATEPAGESPACE(
    344     struct sffsi far *psffsi,       /* ptr to fs independent SFT */
    345     struct sffsd far *psffsd,       /* ptr to fs dependent SFT   */
    346     unsigned long     lSize,        /* new size                  */
    347     unsigned long     lWantContig   /* contiguous chunk size     */
    348 );
    349 
    350 int far pascal _loadds FS_ATTACH(
    351     unsigned short usFlag,      /* flag         */
    352     char far * pDev,            /* pDev         */
    353     void far * pvpfsd,          /* if remote drive struct vpfsd far * else if remote device null ptr (0L)    */
    354     void far * pdevfsd,         /* if remote drive struct cdfsd far * else struct devfsd far * */
    355     char far * pParm,           /* pParm        */
    356     unsigned short far * pLen   /* pLen         */
    357 );
    358 /* XLATON */
    359 
    360 /* values for flag in FS_ATTACH */
    361 #define FSA_ATTACH              0x00
    362 #define FSA_DETACH              0x01
    363 #define FSA_ATTACH_INFO         0x02
    364 
    365 /* XLATOFF */
    366 int far pascal _loadds
    367 FS_CANCELLOCKREQUEST(
    368     struct sffsi far *,         /* psffsi       */
    369     struct sffsd far *,         /* psffsd       */
    370     void far *                  /* pLockRang    */
    371 );
    372 
    373 int far pascal _loadds
    374 FS_CHDIR(
    375     unsigned short,             /* flag         */
    376     struct cdfsi far *,         /* pcdfsi       */
    377     struct cdfsd far *,         /* pcdfsd       */
    378     char far *,                 /* pDir         */
    379     unsigned short              /* iCurDirEnd   */
    380 );
    381 /* XLATON */
    382 
    383 /* values for flag in FS_CHDIR */
    384 #define CD_EXPLICIT             0x00
    385 #define CD_VERIFY               0x01
    386 #define CD_FREE                 0x02
    387 
    388 /* XLATOFF */
    389 int far pascal _loadds
    390 FS_CHGFILEPTRL(
    391     struct sffsi far *,         /* psffsi       */
    392     struct sffsd far *,         /* psffsd       */
    393     LONGLONG,                   /* offset       */
    394     unsigned short,             /* type         */
    395     unsigned short              /* IOflag       */
    396 );
    397 
    398 /* XLATOFF */
    399 int far pascal _loadds
    400 FS_CHGFILEPTR(
    401     struct sffsi far *,         /* psffsi       */
    402     struct sffsd far *,         /* psffsd       */
    403     long,                       /* offset       */
    404     unsigned short,             /* type         */
    405     unsigned short              /* IOflag       */
    406 );
    407 
    408 /* values for type in FS_CHGFILEPTR */
    409 #define CFP_RELBEGIN            0x00
    410 #define CFP_RELCUR              0x01
    411 #define CFP_RELEND              0x02
    412 
    413 int far pascal _loadds
    414 FS_CLOSE(
    415     unsigned short,             /* close type   */
    416     unsigned short,             /* IOflag       */
    417     struct sffsi far *,         /* psffsi       */
    418     struct sffsd far *          /* psffsd       */
    419 );
    420 /* XLATON */
    421 
    422 #define FS_CL_ORDINARY  0
    423                 /* ordinary close of file */
    424 #define FS_CL_FORPROC   1
    425                 /* final close of file for the process */
    426 #define FS_CL_FORSYS    2
    427                 /* final close of file for the system (for all processes) */
    428 
    429 /* XLATOFF */
    430 int far pascal _loadds
    431 FS_COMMIT(
    432     unsigned short,             /* commit type  */
    433     unsigned short,             /* IOflag       */
    434     struct sffsi far *,         /* psffsi       */
    435     struct sffsd far *          /* psffsd       */
    436 );
    437 /* XLATON */
    438 
    439 /* values for commit type */
    440 #define FS_COMMIT_ONE   1
    441         /* commit for a single file */
    442 #define FS_COMMIT_ALL   2
    443         /* commit due to buf reset - for all files */
    444 
    445 /* XLATOFF */
    446 int far pascal _loadds
    447 FS_COPY(
    448     unsigned short,             /* copy mode    */
    449     struct cdfsi far *,         /* pcdfsi       */
    450     struct cdfsd far *,         /* pcdfsd       */
    451     char far *,                 /* source name  */
    452     unsigned short,             /* iSrcCurrDirEnd       */
    453     char far *,                 /* pDst         */
    454     unsigned short,             /* iDstCurrDirEnd       */
    455     unsigned short              /* nameType (flags)     */
    456 );
    457 
    458 int far pascal _loadds
    459 FS_DELETE(
    460     struct cdfsi far *,         /* pcdfsi       */
    461     struct cdfsd far *,         /* pcdfsd       */
    462     char far *,                 /* pFile        */
    463     unsigned short              /* iCurDirEnd   */
    464 );
    465 
    466 int far pascal _loadds
    467 FS_DOPAGEIO(
    468     struct sffsi far *         psffsi,      /* ptr to fs independent SFT    */
    469     struct sffsd far *         psffsd,      /* ptr to fs dependent SFT      */
    470     struct PageCmdHeader far * pPageCmdList /* ptr to list of page commands */
    471 );
    472 
    473 void far pascal _loadds
    474 FS_EXIT(
    475     unsigned short,             /* uid          */
    476     unsigned short,             /* pid          */
    477     unsigned short              /* pdb          */
    478 );
    479 
    480 int far pascal _loadds
    481 FS_FILEATTRIBUTE(
    482     unsigned short,             /* flag         */
    483     struct cdfsi far *,         /* pcdfsi       */
    484     struct cdfsd far *,         /* pcdfsd       */
    485     char far *,                 /* pName        */
    486     unsigned short,             /* iCurDirEnd   */
    487     unsigned short far *        /* pAttr        */
    488 );
    489 /* XLATON */
    490 
    491 /* values for flag in FS_FILEATTRIBUTE */
    492 #define FA_RETRIEVE             0x00
    493 #define FA_SET                  0x01
    494 
    495 /* XLATOFF */
    496 int far pascal _loadds
    497 FS_FILEINFO(
    498     unsigned short,             /* flag         */
    499     struct sffsi far *,         /* psffsi       */
    500     struct sffsd far *,         /* psffsd       */
    501     unsigned short,             /* level        */
    502     char far *,                 /* pData        */
    503     unsigned short,             /* cbData       */
    504     unsigned short              /* IOflag       */
    505 );
    506 /* XLATON */
    507 
    508 /* values for flag in FS_FILEINFO */
    509 #define FI_RETRIEVE             0x00
    510 #define FI_SET                  0x01
    511 
    512 /* XLATOFF */
    513 int far pascal _loadds
    514 FS_FILEIO(
    515     struct sffsi far *,         /* psffsi       */
    516     struct sffsd far *,         /* psffsd       */
    517     char far *,                 /* cbCmdList    */
    518     unsigned short,             /* pCmdLen      */
    519     unsigned short far *,       /* poError      */
    520     unsigned short              /* IOflag       */
    521 );
    522 
    523 /* FILEIO DEFINES */
    524 #define FILEIO_LOCK    0
    525 #define FILEIO_UNLOCK  1
    526 #define FILEIO_SEEK    2
    527 #define FILEIO_READ    3
    528 #define FILEIO_WRITE   4
    529 
    530 #pragma pack(1)
    531 
    532 struct CmdLock
    533 {
    534     USHORT Cmd;           /* 0 for Lock */
    535     USHORT LockCnt;       /* number of locks that follow */
    536     ULONG  TimeOut;       /* timeout in ms               */
    537 };
    538 
    539 struct CmdUnLock
    540 {
    541     USHORT Cmd;           /* 1 for UnLock */
    542     USHORT UnlockCnt;       /* number of locks that follow */
    543 };
    544 
    545 struct CmdSeek
    546 {
    547     USHORT Cmd;           /* 2 for seek                 */
     1 #ifndef __FSD_H_
     2 #define __FSD_H_
     3
     4 #define FSA_REMOTE         0x00000001  /* remote FSD                   */
     5 #define FSA_UNC            0x00000002  /* FSD supports UNC pathnames   */
     6 #define FSA_LOCK           0x00000004  /* FSD needs lock notifications */
     7 #define FSA_LVL7           0x00000008  /* FSD supports level 7         */
     8 #define FSA_PSVR           0x00000010  /* FSD supports remote named pipes */
     9 #define FSA_LARGEFILE      0x00000020  /* FSD supports files > 2 GB    */
     10
     11 #define CDDWORKAREASIZE    8
     12 #define SFDWORKAREASIZE    30
     13 #define VPDWORKAREASIZE    36
     14
     15 #define VPBTEXTLEN         12
     16
     17 struct vpfsi
     18 {
     19    unsigned long     vpi_vid;                      /* volume serial number */
     20    unsigned long     vpi_hDEV;                     /* device driver handle */
     21    unsigned short    vpi_bsize;                    /* sector size          */
     22    unsigned long     vpi_totsec;                   /* total sectors        */
     23    unsigned short    vpi_trksec;                   /* sectors per track    */
     24    unsigned short    vpi_nhead;                    /* heads                */
     25    char              vpi_text[VPBTEXTLEN];         /* volume label         */
     26    void far *        vpi_pDCS;                     /* device capabilities structure    */
     27    void far *        vpi_pVCS;                     /* volume characteristics structure */
     28    unsigned char     vpi_drive;                    /* drive letter         */
     29    unsigned char     vpi_unit;                     /* unit number          */
     30 };
     31
     32 struct vpfsd
     33 {
     34    char    vpd_work[VPDWORKAREASIZE];              /* work area            */
     35 };
     36
     37 #define CDI_ISVALID      0x80                      /* structure is valid   */
     38 #define CDI_ISROOT       0x40                      /* it is a root dir     */
     39 #define CDI_ISCURRENT    0x20
     40
     41 struct cdfsi
     42 {
     43    unsigned short    cdi_hVPB;                     /* VPB handle           */
     44    unsigned short    cdi_end;                      /* curdir end           */
     45    char              cdi_flags;                    /* flags                */
     46    char              cdi_curdir[CCHMAXPATH];       /* current directory    */
     47 };
     48
     49 struct cdfsd
     50 {
     51    char cdd_work[CDDWORKAREASIZE];                 /* work area            */
     52 };
     53
     54 // sfi_tstamps
     55 #define ST_SCREAT      1                           /* stamp ctime          */
     56 #define ST_PCREAT      2                           /* propagate ctime      */
     57 #define ST_SWRITE      4                           /* stamp mtime          */
     58 #define ST_PWRITE      8                           /* propagate mtime      */
     59 #define ST_SREAD      16                           /* stamp atime          */
     60 #define ST_PREAD      32                           /* propagate atime      */
     61
     62 // sfi_type
     63 #define STYPE_FILE     0                           /* file                 */
     64 #define STYPE_DEVICE   1                           /* device               */
     65 #define STYPE_NMPIPE   2                           /* named pipe           */
     66 #define STYPE_FCB      4                           /* fcb                  */
     67
     68 struct sffsi
     69 {
     70    unsigned long   sfi_mode;                       /* access and sharing mode  */
     71    unsigned short  sfi_hVPB;                       /* VPB handle               */
     72    unsigned short  sfi_ctime;                      /* creation time            */
     73    unsigned short  sfi_cdate;                      /* creation date            */
     74    unsigned short  sfi_atime;                      /* access time              */
     75    unsigned short  sfi_adate;                      /* access date              */
     76    unsigned short  sfi_mtime;                      /* modification time        */
     77    unsigned short  sfi_mdate;                      /* modification date        */
     78    unsigned long   sfi_size;                       /* file size                */
     79    unsigned long   sfi_position;                   /* file pointer             */
     80    unsigned short  sfi_UID;                        /* user ID                  */
     81    unsigned short  sfi_PID;                        /* PID                      */
     82    unsigned short  sfi_PDB;                        /* VDM PDB                  */
     83    unsigned short  sfi_selfsfn;                    /* SFN                      */
     84    unsigned char   sfi_tstamp;                     /* time stamp flags         */
     85    unsigned short  sfi_type;                       /* file type                */
     86    unsigned long   sfi_pPVDBFil;
     87    unsigned char   sfi_DOSattr;   /* DOS attr (hidden/system/readonly/archive) */
     88    LONGLONG        sfi_sizel;     /* 64-bit file size                          */
     89    LONGLONG        sfi_positionl; /* 64-bit file pointer                       */
     90 };
     91
     92 struct sffsd
     93 {
     94    char sfd_work[SFDWORKAREASIZE];               /* work area                  */
     95 };
     96
     97 struct fsfsi
     98 {
     99    unsigned short fsi_hVPB;                      /* VPB handle                 */
     100 };
     101
     102 #define FSFSD_WORK_SIZE    24
     103
     104 struct fsfsd {
     105    char fsd_work[FSFSD_WORK_SIZE];               /* work area                  */
     106 };
     107
     108 struct devfsd {
     109    unsigned long FSDRef;                         /* FSD ref. got from ATTACH   */
     110 };
     111
     112
     113 #define IOFL_WRITETHRU     0x10
     114 #define IOFL_NOCACHE       0x20
     115
     116 int far pascal _loadds FS_ALLOCATEPAGESPACE(
     117    struct sffsi far *psffsi,
     118    struct sffsd far *psffsd,
     119    unsigned long     lSize,
     120    unsigned long     lWantContig
     121 );
     122
     123 #define FSA_ATTACH         0x00
     124 #define FSA_DETACH         0x01
     125 #define FSA_ATTACH_INFO    0x02
     126
     127 int far pascal _loadds FS_ATTACH(
     128    unsigned short usFlag,
     129    char far *pDev,
     130    void far *pvpfsd,
     131    void far *pdevfsd,
     132    char far *pParm,
     133    unsigned short far *pLen
     134 );
     135
     136 int far pascal _loadds FS_CANCELLOCKREQUEST(
     137    struct sffsi far *psffsi,
     138    struct sffsd far *psffsd,
     139    void far *pLockRang
     140 );
     141
     142 #define CD_EXPLICIT        0x00
     143 #define CD_VERIFY          0x01
     144 #define CD_FREE            0x02
     145
     146 int far pascal _loadds FS_CHDIR(
     147    unsigned short flag,
     148    struct cdfsi far *pcdfsi,
     149    struct cdfsd far *pcdfsd,
     150    char far *pszDir,
     151    unsigned short iCurDirEnd
     152 );
     153
     154 int far pascal _loadds FS_CHGFILEPTRL(
     155    struct sffsi far *psffsi,
     156    struct sffsd far *psffsd,
     157    LONGLONG llOffset,
     158    unsigned short usType,
     159    unsigned short IOflag
     160 );
     161
     162 #define CFP_RELBEGIN        0x00
     163 #define CFP_RELCUR          0x01
     164 #define CFP_RELEND          0x02
     165
     166 int far pascal _loadds FS_CHGFILEPTR(
     167    struct sffsi far *psffsi,
     168    struct sffsd far *psffsd,
     169    long lOffset,
     170    unsigned short usType,
     171    unsigned short IOflag
     172 );
     173
     174 #define FS_CL_ORDINARY      0
     175 #define FS_CL_FORPROC       1
     176 #define FS_CL_FORSYS        2
     177
     178 int far pascal _loadds FS_CLOSE(
     179    unsigned short usType,
     180    unsigned short IOflag,
     181    struct sffsi far *psffsi,
     182    struct sffsd far *psffsd
     183 );
     184
     185 #define FS_COMMIT_ONE       1
     186 #define FS_COMMIT_ALL       2
     187
     188 int far pascal _loadds FS_COMMIT(
     189    unsigned short usType,
     190    unsigned short IOflag,
     191    struct sffsi far *psffsi,
     192    struct sffsd far *psffsd
     193 );
     194
     195 int far pascal _loadds FS_COPY(
     196    unsigned short usMode,
     197    struct cdfsi far *pcdfsi,
     198    struct cdfsd far *pcdfsd,
     199    char far *pszSrcName,
     200    unsigned short iSrcCurrDirEnd,
     201    char far *pszDstName,
     202    unsigned short iDstCurrDirEnd,
     203    unsigned short flags
     204 );
     205
     206 int far pascal _loadds FS_DELETE(
     207    struct cdfsi far *pcdfsi,
     208    struct cdfsd far *pcdfsd,
     209    char far *pFile,
     210    unsigned short iCurDirEnd
     211 );
     212
     213 #define PGIO_FI_ORDER   0x01       /* force ops order      */
     214
     215 #define PGIO_FO_DONE    0x01       /* op done              */
     216 #define PGIO_FO_ERROR   0x02       /* op returned an error */
     217
     218 #define PGIO_ATTEMPTED  0x0f       /* op attempted         */
     219 #define PGIO_FAILED     0xf0       /* op failed            */
     220
     221 struct PageCmd
     222 {
     223    unsigned char Cmd;              /* command code Read/Write/WriteVerify     */
     224    unsigned char Priority;         /* the same codes like for request packets */
     225    unsigned char Status;           /* status                                  */
     226    unsigned char Error;            /* error code                              */
     227    unsigned long Addr;             /* phys. or virt.                          */
     228    unsigned long FileOffset;       /* offset from the beginning of swap file  */
     229 };
     230
     231 struct PageCmdHeader
     232 {
     233    unsigned char InFlags;          /* input flags                             */
     234    unsigned char OutFlags;         /* output flags - should be 0 on entry     */
     235    unsigned char OpCount;          /* operations count                        */
     236    unsigned char Pad;              /* align on DWORD boundary                 */
     237    unsigned long Reserved1;
     238    unsigned long Reserved2;
     239    unsigned long Reserved3;
     240    struct PageCmd PageCmdList[1];  /* commands list                           */
     241 };
     242
     243 int far pascal _loadds FS_DOPAGEIO(
     244    struct sffsi far *psffsi,
     245    struct sffsd far *psffsd,
     246    struct PageCmdHeader far *pPageCmdList
     247 );
     248
     249 void far pascal _loadds FS_EXIT(
     250    unsigned short uid,
     251    unsigned short pid,
     252    unsigned short pdb
     253 );
     254
     255 #define FA_RETRIEVE       0x00
     256 #define FA_SET            0x01
     257
     258 int far pascal _loadds FS_FILEATTRIBUTE(
     259    unsigned short flag,
     260    struct cdfsi far *pcdfsi,
     261    struct cdfsd far *pcdfsd,
     262    char far *pszName,
     263    unsigned short iCurDirEnd,
     264    unsigned short far *pAttr
     265 );
     266
     267 #define FI_RETRIEVE       0x00
     268 #define FI_SET            0x01
     269
     270 int far pascal _loadds FS_FILEINFO(
     271    unsigned short flag,
     272    struct sffsi far *psffsi,
     273    struct sffsd far *psffsd,
     274    unsigned short level,
     275    char far * pszData,
     276    unsigned short cbData,
     277    unsigned short IOflag
     278 );
     279
     280 #define FILEIO_LOCK       0
     281 #define FILEIO_UNLOCK     1
     282 #define FILEIO_SEEK       2
     283 #define FILEIO_READ       3
     284 #define FILEIO_WRITE      4
     285
     286 #pragma pack(1)
     287
     288 struct CmdLock
     289 {
     290    USHORT Cmd;           /* 0                  */
     291    USHORT LockCnt;       /* locks count        */
     292    ULONG  TimeOut;       /* millisecon timeout */
     293 };
     294
     295 struct CmdUnLock
     296 {
     297    USHORT Cmd;           /* 1                  */
     298    USHORT UnlockCnt;     /* unlocks count      */
     299 };
     300
     301 struct CmdSeek
     302 {
     303    USHORT Cmd;           /* 2                  */
    548304    USHORT Method;        /* 0 for absolute             */
    549                           /* 1 for relative to current  */
     305                          /* 1 for self-relative        */
    550306                          /* 2 for relative to EOF      */
    551     LONG  Position;       /* position or delta          */
    552     LONG  Actual;         /* actual position seeked to  */
    553 };
    554 
    555 struct CmdSeekL
    556 {
    557     USHORT Cmd;           /* 2 for seek                 */
     307    LONG   Position;      /* position                   */
     308    LONG   Actual;        /* actual position            */
     309 };
     310
     311 struct CmdSeekL
     312 {
     313    USHORT Cmd;           /* 2                          */
    558314    USHORT Method;        /* 0 for absolute             */
    559                           /* 1 for relative to current  */
     315                          /* 1 for self-relative        */
    560316                          /* 2 for relative to EOF      */
    561     LONGLONG Position;    /* position or delta          */
    562     LONGLONG Actual;      /* actual position seeked to  */
    563 };
    564 
    565 struct CmdIO
    566 {
    567     USHORT Cmd;           /* 3 for read 4 for write     */
    568     void * _Seg16 Buffer; /* data buffer                */
     317    LONGLONG Position;    /* position                   */
     318    LONGLONG Actual;      /* actual position            */
     319 };
     320
     321 struct CmdIO
     322 {
     323    USHORT Cmd;           /* 3 for read, 4 for write    */
     324    void * _Seg16 Buffer; /* buffer                     */
    569325    USHORT BufferLen;     /* buffer length              */
    570326    USHORT Actual;        /* actual bytes transferred   */
    571327
    572 };
    573 
    574 /* lock structure to be passed into jfs_filelock function */
    575 struct Lock {
    576   USHORT  Share;            /* on if lock is shared, else off */
    577   ULONG   Start;            /* start offset of lock           */
    578   ULONG   Length;           /* count of bytes to be locked    */
    579 };
    580 
    581 /* unlock structure to be passed into jfs_lock function */
    582 struct UnLock {
    583   ULONG   Start;            /* start offset of lock           */
    584   ULONG   Length;           /* count of bytes to be locked    */
    585 };
    586 
    587 /* longlong lock structure to be passed into jfs_filelock function */
    588 struct LockL {
    589   USHORT  Share;            /* on if lock is shared, else off */
    590   USHORT  Pad;              /* pad to 4 bytes */
    591   ULONGLONG Start;          /* start offset of lock           */
    592   ULONGLONG Length;         /* count of bytes to be locked    */
    593 };
    594 
    595 /* longlong unlock structure to be passed into jfs_lock function */
    596 struct UnLockL {
    597   ULONGLONG Start;          /* start offset of lock           */
    598   ULONGLONG Length;         /* count of bytes to be locked    */
    599 };
    600 
    601 #pragma pack()
    602 
    603 int far pascal _loadds
    604 FS_FILELOCKS(
    605     struct sffsi far *,         /* psffsi       */
    606     struct sffsd far *,         /* psffsd       */
    607     void far *,                 /* pUnLockRange */
    608     void far *,                 /* pLockRange   */
    609     unsigned long,              /* timeout      */
    610     unsigned long               /* flags        */
    611 );
    612 
    613 /* lock defines */
    614 #define LOCK_EXPIRED   0x0L
    615 #define LOCK_WAKEUP    0x1L
    616 #define LOCK_CANCELED  0x2L
    617 
    618 struct filelock {
    619     long FileOffset;   /* offset where the lock/unlock begins  */
    620     long RangeLength;  /* length of region locked/unlocked     */
    621 };
    622 
    623 struct filelockl {
    624     long long FileOffset;   /* offset where the lock/unlock begins  */
    625     long long RangeLength;  /* length of region locked/unlocked     */
    626 };
    627 
    628 int far pascal _loadds
    629 FS_FINDCLOSE(
    630     struct fsfsi far *,         /* pfsfsi       */
    631     struct fsfsd far *          /* pfsfsd       */
    632 );
    633 /* XLATON */
    634 
    635 /* values for flag in FS_FindFirst, FS_FindFromName, FS_FindNext */
    636 #define     FF_NOPOS            0x00
    637 #define     FF_GETPOS           0X01
    638 
    639 
    640 /* XLATOFF */
    641 int far pascal _loadds
    642 FS_FINDFIRST(
    643     struct cdfsi far *,         /* pcdfsi       */
    644     struct cdfsd far *,         /* pcdfsd       */
    645     char far *,                 /* pName        */
    646     unsigned short,             /* iCurDirEnd   */
    647     unsigned short,             /* attr         */
    648     struct fsfsi far *,         /* pfsfsi       */
    649     struct fsfsd far *,         /* pfsfsd       */
    650     char far *,                 /* pData        */
    651     unsigned short,             /* cbData       */
    652     unsigned short far *,       /* pcMatch      */
    653     unsigned short,             /* level        */
    654     unsigned short              /* flags        */
    655 );
    656 
    657 int far pascal _loadds
    658 FS_FINDFROMNAME(
    659     struct fsfsi far *,         /* pfsfsi       */
    660     struct fsfsd far *,         /* pfsfsd       */
    661     char far *,                 /* pData        */
    662     unsigned short,             /* cbData       */
    663     unsigned short far *,       /* pcMatch      */
    664     unsigned short,             /* level        */
    665     unsigned long,              /* position     */
    666     char far *,                 /* pName        */
    667     unsigned short              /* flags        */
    668 );
    669 
    670 int far pascal _loadds
    671 FS_FINDNEXT(
    672     struct fsfsi far *,         /* pfsfsi       */
    673     struct fsfsd far *,         /* pfsfsd       */
    674     char far *,                 /* pData        */
    675     unsigned short,             /* cbData       */
    676     unsigned short far *,       /* pcMatch      */
    677     unsigned short,             /* level        */
    678     unsigned short              /* flag         */
    679 );
    680 
    681 int far pascal _loadds
    682 FS_FINDNOTIFYCLOSE(
    683     unsigned short              /* handle       */
    684 );
    685 
    686 int far pascal _loadds
    687 FS_FINDNOTIFYFIRST(
    688     struct cdfsi far *,         /* pcdfsi       */
    689     struct cdfsd far *,         /* pcdfsd       */
    690     char far *,                 /* pName        */
    691     unsigned short,             /* iCurDirEnd   */
    692     unsigned short,             /* attr         */
    693     unsigned short far *,       /* pHandle      */
    694     char far *,                 /* pData        */
    695     unsigned short,             /* cbData       */
    696     unsigned short far *,       /* pcMatch      */
    697     unsigned short,             /* level        */
    698     unsigned long               /* timeout      */
    699 );
    700 
    701 int far pascal _loadds
    702 FS_FINDNOTIFYNEXT(
    703     unsigned short,             /* handle       */
    704     char far *,                 /* pData        */
    705     unsigned short,             /* cbData       */
    706     unsigned short far *,       /* pcMatch      */
    707     unsigned short,             /* infolevel    */
    708     unsigned long               /* timeout      */
    709 );
    710 
    711 int far pascal _loadds
    712 FS_FLUSHBUF(
    713     unsigned short,             /* hVPB         */
    714     unsigned short              /* flag         */
    715 );
    716 /* XLATON */
    717 
    718 /* values for flag in FS_FLUSH */
    719 #define FLUSH_RETAIN            0x00
    720 #define FLUSH_DISCARD           0x01
    721 
    722 /* XLATOFF */
    723 int far pascal _loadds
    724 FS_FSCTL(
    725     union argdat far *,         /* pArgdat      */
    726     unsigned short,             /* iArgType     */
    727     unsigned short,             /* func         */
    728     char far *,                 /* pParm        */
    729     unsigned short,             /* lenParm      */
    730     unsigned short far *,       /* plenParmOut  */
    731     char far *,                 /* pData        */
    732     unsigned short,             /* lenData      */
    733     unsigned short far *        /* plenDataOut  */
    734 );
    735 /* XLATON */
    736 
    737 /* values for iArgType in FS_FSCTL */
    738 #define FSCTL_ARG_FILEINSTANCE  0x01
    739 #define FSCTL_ARG_CURDIR        0x02
    740 #define FSCTL_ARG_NULL          0x03
    741 
    742 /* values for func in FS_FSCTL */
    743 #define FSCTL_FUNC_NONE         0x00
    744 #define FSCTL_FUNC_NEW_INFO     0x01
    745 #define FSCTL_FUNC_EASIZE       0x02
    746 
    747 /* XLATOFF */
    748 int far pascal _loadds
    749 FS_FSINFO(
    750     unsigned short,             /* flag         */
    751     unsigned short,             /* hVPB         */
    752     char far *,                 /* pData        */
    753     unsigned short,             /* cbData       */
    754     unsigned short              /* level        */
    755 );
    756 /* XLATON */
    757 
    758 /* values for flag in FS_FSINFO */
    759 #define INFO_RETRIEVE           0x00
    760 #define INFO_SET                0x01
    761 
    762 /* XLATOFF */
    763 int far pascal _loadds
    764 FS_INIT(
    765     char far *,                 /* szParm       */
    766     unsigned long,              /* pDevHlp      */
    767     unsigned long far *         /* pMiniFSD     */
    768 );
    769 
    770 int far pascal _loadds
    771 FS_IOCTL(
    772     struct sffsi far *,         /* psffsi       */
    773     struct sffsd far *,         /* psffsd       */
    774     unsigned short,             /* cat          */
    775     unsigned short,             /* func         */
    776     char far *,                 /* pParm        */
    777     unsigned short,             /* lenParm      */
    778     unsigned far *,             /* pParmLenInOut */
    779     char far *,                 /* pData        */
    780     unsigned short,             /* lenData      */
    781     unsigned far *              /* pDataLenInOut */
    782 );
    783 
    784 int far pascal _loadds
    785 FS_MKDIR(
    786     struct cdfsi far *,         /* pcdfsi       */
    787     struct cdfsd far *,         /* pcdfsd       */
    788     char far *,                 /* pName        */
    789     unsigned short,             /* iCurDirEnd   */
    790     char far *,                 /* pEABuf       */
    791     unsigned short              /* flags        */
    792 );
    793 
    794 int far pascal _loadds
    795 FS_MOUNT(
    796     unsigned short,             /* flag         */
    797     struct vpfsi far *,         /* pvpfsi       */
    798     struct vpfsd far *,         /* pvpfsd       */
    799     unsigned short,             /* hVPB         */
    800     char far *                  /* pBoot        */
    801 );
    802 /* XLATON */
    803 
    804 /* values for flag in FS_MOUNT */
    805 #define MOUNT_MOUNT             0x00
    806 #define MOUNT_VOL_REMOVED       0x01
    807 #define MOUNT_RELEASE           0x02
    808 #define MOUNT_ACCEPT            0x03
    809 
    810 /* XLATOFF */
    811 int far pascal _loadds
    812 FS_MOVE(
    813     struct cdfsi far *,         /* pcdfsi       */
    814     struct cdfsd far *,         /* pcdfsd       */
    815     char far *,                 /* pSrc         */
    816     unsigned short,             /* iSrcCurDirEnd*/
    817     char far *,                 /* pDst         */
    818     unsigned short,             /* iDstCurDirEnd*/
    819     unsigned short              /* flags        */
    820 );
    821 
    822 int far pascal _loadds
    823 FS_NEWSIZEL(
    824     struct sffsi far *,         /* psffsi       */
    825     struct sffsd far *,         /* psffsd       */
    826     ULONGLONG,                  /* len          */
    827     unsigned short              /* IOflag       */
    828 );
    829 
    830 int far pascal _loadds
    831 FS_NEWSIZE(
    832     struct sffsi far *,         /* psffsi       */
    833     struct sffsd far *,         /* psffsd       */
    834     unsigned long,              /* len          */
    835     unsigned short              /* IOflag       */
    836 );
    837 
    838 
    839 int far pascal _loadds
    840 FS_NMPIPE(
    841     struct sffsi far *,         /* psffsi       */
    842     struct sffsd far *,         /* psffsd       */
    843     unsigned short,             /* OpType       */
    844     union npoper far *,         /* pOpRec       */
    845     char far *,                 /* pData        */
    846     char far *                  /* pName        */
    847 );
    848 /* XLATON */
    849 
    850 /* Values for OpType in FS_NMPIPE   */
    851 
    852 #define     NMP_GetPHandState       0x21
    853 #define     NMP_SetPHandState       0x01
    854 #define     NMP_PipeQInfo           0x22
    855 #define     NMP_PeekPipe            0x23
    856 #define     NMP_ConnectPipe         0x24
    857 #define     NMP_DisconnectPipe      0x25
    858 #define     NMP_TransactPipe        0x26
    859 #define     NMP_READRAW             0x11
    860 #define     NMP_WRITERAW            0x31
    861 #define     NMP_WAITPIPE            0x53
    862 #define     NMP_CALLPIPE            0x54
    863 #define     NMP_QNmPipeSemState     0x58
    864 
    865 
    866 /* XLATOFF */
    867 int far pascal _loadds
    868 FS_OPENCREATE(
    869     struct cdfsi far *,         /* pcdfsi               */
    870     void far *,                 /* if remote device
     328 };
     329
     330 int far pascal _loadds FS_FILEIO(
     331    struct sffsi far *psffsi,
     332    struct sffsd far *psffsd,
     333    char far *cbCmdList,
     334    unsigned short pCmdLen,
     335    unsigned short far *poError,
     336    unsigned short IOPflag
     337 );
     338
     339 struct Lock
     340 {
     341    USHORT Share;            /* whether the lock is shared     */
     342    ULONG  Start;            /* start offset of lock           */
     343    ULONG  Length;           /* bytes to be locked             */
     344 };
     345
     346 struct UnLock
     347 {
     348    ULONG Start;             /* start offset of lock           */
     349    ULONG Length;            /* bytes to be locked             */
     350 };
     351
     352 struct LockL
     353 {
     354    USHORT Share;            /* whether the lock is shared     */
     355    USHORT Pad;              /* 4 bytes pad                    */
     356    ULONGLONG Start;         /* start offset of lock           */
     357    ULONGLONG Length;        /* bytes to be locked             */
     358 };
     359
     360 struct UnLockL
     361 {
     362    ULONGLONG Start;          /* start offset of lock          */
     363    ULONGLONG Length;         /* bytes to be locked            */
     364 };
     365
     366 #pragma pack()
     367
     368 #define LOCK_EXPIRED        0x0L
     369 #define LOCK_WAKEUP         0x1L
     370 #define LOCK_CANCELED       0x2L
     371
     372 struct filelock
     373 {
     374    long FileOffset;   /* start offset of lock/unlock          */
     375    long RangeLength;  /* length of locked/unlocked are        */
     376 };
     377
     378 struct filelockl
     379 {
     380    long long FileOffset;   /* start offset of lock/unlock     */
     381    long long RangeLength;  /* length of locked/unlocked area  */
     382 };
     383
     384 int far pascal _loadds FS_FILELOCKS(
     385    struct sffsi far *psffsi,
     386    struct sffsd far *psffsd,
     387    void far *pUnLockRange,
     388    void far *pLockRange,
     389    unsigned long timeout,
     390    unsigned long flags
     391 );
     392
     393 #define FF_NOPOS          0x00
     394 #define FF_GETPOS         0X01
     395
     396 int far pascal _loadds FS_FINDFIRST(
     397    struct cdfsi far *pcdfsi,
     398    struct cdfsd far *pcdfsd,
     399    char far *pName,
     400    unsigned short iCurDirEnd,
     401    unsigned short Attr,
     402    struct fsfsi far *pfsfsi,
     403    struct fsfsd far *pfsfsd,
     404    char far *pData,
     405    unsigned short cbData,
     406    unsigned short far *pcMatch,
     407    unsigned short level,
     408    unsigned short flags
     409 );
     410
     411 int far pascal _loadds FS_FINDNEXT(
     412    struct fsfsi far *pfsfsi,
     413    struct fsfsd far *pfsfsd,
     414    char far *pData,
     415    unsigned short cbData,
     416    unsigned short far *pcMatch,
     417    unsigned short level,
     418    unsigned short flag
     419 );
     420
     421 int far pascal _loadds FS_FINDCLOSE(
     422    struct fsfsi far *pfsfsi,
     423    struct fsfsd far *pfsfsd
     424 );
     425
     426 int far pascal _loadds FS_FINDFROMNAME(
     427    struct fsfsi far *pfsfsi,
     428    struct fsfsd far *pfsfsd,
     429    char far *pData,
     430    unsigned short cbData,
     431    unsigned short far *pcMatch,
     432    unsigned short level,
     433    unsigned long position,
     434    char far *pName,
     435    unsigned short flags
     436 );
     437
     438 int far pascal _loadds FS_FINDNOTIFYFIRST(
     439    struct cdfsi far *pcdfsi,
     440    struct cdfsd far *pcdfsd,
     441    char far *pName,
     442    unsigned short iCurDirEnd,
     443    unsigned short Attr,
     444    unsigned short far *pHandle,
     445    char far *pData,
     446    unsigned short cbData,
     447    unsigned short far *pcMatch,
     448    unsigned short level,
     449    unsigned long timeout
     450 );
     451
     452 int far pascal _loadds FS_FINDNOTIFYNEXT(
     453    unsigned short handle,
     454    char far *pData,
     455    unsigned short cbData,
     456    unsigned short far *pcMatch,
     457    unsigned short infolevel,
     458    unsigned long timeout
     459 );
     460
     461 int far pascal _loadds FS_FINDNOTIFYCLOSE(
     462    unsigned short handle
     463 );
     464
     465 #define FLUSH_RETAIN           0x00
     466 #define FLUSH_DISCARD          0x01
     467
     468 int far pascal _loadds FS_FLUSHBUF(
     469    unsigned short hVPB,
     470    unsigned short flag
     471 );
     472
     473 #define FSCTL_ARG_FILEINSTANCE 0x01
     474 #define FSCTL_ARG_CURDIR       0x02
     475 #define FSCTL_ARG_NULL         0x03
     476
     477 #define FSCTL_FUNC_NONE        0x00
     478 #define FSCTL_FUNC_NEW_INFO    0x01
     479 #define FSCTL_FUNC_EASIZE      0x02
     480
     481 struct SF
     482 {
     483    struct sffsi far *psffsi;
     484    struct sffsd far *psffsd;
     485 };
     486
     487 struct CD
     488 {
     489    struct cdfsi far *pcdfsi;
     490    struct cdfsd far *pcdfsd;
     491    char far *pPath;
     492    unsigned short iCurDirEnd;
     493 };
     494
     495 union argdat
     496 {
     497    struct SF sf;
     498    struct CD cd;
     499 };
     500
     501 int far pascal _loadds FS_FSCTL(
     502    union argdat far *pArgdat,
     503    unsigned short iArgType,
     504    unsigned short func,
     505    char far *pParm,
     506    unsigned short cbParm,
     507    unsigned short far *cbParmOut,
     508    char far *pData,
     509    unsigned short cbData,
     510    unsigned short far *plenDataOut
     511 );
     512
     513 #define INFO_RETRIEVE          0x00
     514 #define INFO_SET               0x01
     515
     516 int far pascal _loadds FS_FSINFO(
     517    unsigned short flag,
     518    unsigned short hVPB,
     519    char far *pData,
     520    unsigned short cbData,
     521    unsigned short level
     522 );
     523
     524 int far pascal _loadds FS_INIT(
     525    char far *szParm,
     526    unsigned long pDevHelp,
     527    unsigned long far *pMiniFSD
     528 );
     529
     530 int far pascal _loadds FS_IOCTL(
     531    struct sffsi far *psffsi,
     532    struct sffsd far *psffsd,
     533    unsigned short usCat,
     534    unsigned short usFunc,
     535    char far *pParm,
     536    unsigned short cbParm,
     537    unsigned far *pParmLenInOut,
     538    char far *pData,
     539    unsigned short cbData,
     540    unsigned far *pDataLenInOut
     541 );
     542
     543 int far pascal _loadds FS_MKDIR(
     544    struct cdfsi far *pcdfsi,
     545    struct cdfsd far *pcdfsd,
     546    char far *pName,
     547    unsigned short iCurDirEnd,
     548    char far *pEABuf,
     549    unsigned short flags
     550 );
     551
     552 #define MOUNT_MOUNT           0x00
     553 #define MOUNT_VOL_REMOVED     0x01
     554 #define MOUNT_RELEASE         0x02
     555 #define MOUNT_ACCEPT          0x03
     556
     557 int far pascal _loadds FS_MOUNT(
     558    unsigned short flag,
     559    struct vpfsi far *pvpfsi,
     560    struct vpfsd far *pvpfsd,
     561    unsigned short hVPB,
     562    char far *pBoot
     563 );
     564
     565 int far pascal _loadds FS_MOVE(
     566    struct cdfsi far *pcdfsi,
     567    struct cdfsd far *pcdfsd,
     568    char far *pSrc,
     569    unsigned short iSrcCurDirEnd,
     570    char far *pDst,
     571    unsigned short iDstCurDirEnd,
     572    unsigned short flags
     573 );
     574
     575 int far pascal _loadds FS_NEWSIZEL(
     576    struct sffsi far *psffsi,
     577    struct sffsd far *psffsd,
     578    ULONGLONG cbLen,
     579    unsigned short IOflag
     580 );
     581
     582 int far pascal _loadds FS_NEWSIZE(
     583    struct sffsi far *psffsi,
     584    struct sffsd far *psffsd,
     585    unsigned long cbLen,
     586    unsigned short IOflag
     587 );
     588
     589 #define NMP_GetPHandState   0x21
     590 #define NMP_SetPHandState   0x01
     591 #define NMP_PipeQInfo       0x22
     592 #define NMP_PeekPipe        0x23
     593 #define NMP_ConnectPipe     0x24
     594 #define NMP_DisconnectPipe  0x25
     595 #define NMP_TransactPipe    0x26
     596 #define NMP_READRAW         0x11
     597 #define NMP_WRITERAW        0x31
     598 #define NMP_WAITPIPE        0x53
     599 #define NMP_CALLPIPE        0x54
     600 #define NMP_QNmPipeSemState 0x58
     601
     602 struct phs_param
     603 {
     604    short phs_len;
     605    short phs_dlen;
     606    short phs_pmode;
     607 };
     608
     609 struct npi_param
     610 {
     611    short npi_len;
     612    short npi_dlen;
     613    short npi_level;
     614 };
     615
     616 struct npr_param
     617 {
     618    short npr_len;
     619    short npr_dlen;
     620    short npr_nbyt;
     621 };
     622
     623 struct npw_param
     624 {
     625    short npw_len;
     626    short npw_dlen;
     627    short npw_nbyt;
     628 };
     629
     630 struct npq_param
     631 {
     632    short npq_len;
     633    short npq_dlen;
     634    long  npq_timeo;
     635    short npq_prio;
     636 };
     637
     638 struct npx_param
     639 {
     640    short               npx_len;
     641    unsigned short      npx_ilen;
     642    char far            *npx_obuf;
     643    unsigned short      npx_olen;
     644    unsigned short      npx_nbyt;
     645    long                npx_timeo;
     646 };
     647
     648 struct npp_param
     649 {
     650    short               npp_len;
     651    unsigned short      npp_dlen;
     652    unsigned short      npp_nbyt;
     653    unsigned short      npp_avl0;
     654    unsigned short      npp_avl1;
     655    unsigned short      npp_state;
     656 };
     657
     658 struct npt_param
     659 {
     660    short               npt_len;
     661    unsigned short      npt_ilen;
     662    char far            *npt_obuf;
     663    unsigned short      npt_olen;
     664    unsigned short      npt_nbyt;
     665 };
     666
     667 struct qnps_param
     668 {
     669    unsigned short      qnps_len;
     670    unsigned short      qnps_dlen;
     671    long                qnps_semh;
     672    unsigned short      qnps_nbyt;
     673 };
     674
     675 struct npc_param
     676 {
     677    unsigned short      npc_len;
     678    unsigned short      npc_dlen;
     679 };
     680
     681 struct npd_param
     682 {
     683    unsigned short      npd_len;
     684    unsigned short      npd_dlen;
     685 };
     686
     687 union npoper
     688 {
     689    struct phs_param    phs;
     690    struct npi_param    npi;
     691    struct npr_param    npr;
     692    struct npw_param    npw;
     693    struct npq_param    npq;
     694    struct npx_param    npx;
     695    struct npp_param    npp;
     696    struct npt_param    npt;
     697    struct qnps_param   qnps;
     698    struct npc_param    npc;
     699    struct npd_param    npd;
     700 };
     701
     702 int far pascal _loadds FS_NMPIPE(
     703    struct sffsi far *psffsi,
     704    struct sffsd far *psffsd,
     705    unsigned short OpType,
     706    union npoper far *pOpRec,
     707    char far *pData,
     708    char far *pName
     709 );
     710
     711#define FOC_NEEDEAS      0x1
     712
     713 int far pascal _loadds FS_OPENCREATE(
     714    struct cdfsi far *pcdfsi,
     715    void far *,                 /* for remote devices:
    871716                                     struct devfsd far *
    872                                    else
     717                                   for local devices:
    873718                                     struct cdfsd far * */
    874     char far *,                 /* pName                */
    875     unsigned short,             /* iCurDirEnd           */
    876     struct sffsi far *,         /* psffsi               */
    877     struct sffsd far *,         /* psffsd               */
    878     unsigned long,              /* fhandflag/openmode   */
    879     unsigned short,             /* openflag             */
    880     unsigned short far *,       /* pAction              */
    881     unsigned short,             /* attr                 */
    882     char far *,                 /* pEABuf               */
    883     unsigned short far *        /* pfgenFlag            */
    884 );
    885 /* XLATON */
    886 
    887 #define FOC_NEEDEAS     0x1     /*there are need eas for this file */
    888 
    889 /* XLATOFF */
    890 int far pascal _loadds
    891 FS_OPENPAGEFILE (
    892     unsigned long far *pFlags,      /* pointer to Flags               */
    893     unsigned long far *pcMaxReq,    /* max # of reqs packed in list   */
    894     char far *         pName,       /* name of paging file            */
    895     struct sffsi far * psffsi,      /* ptr to fs independent SFT      */
    896     struct sffsd far * psffsd,      /* ptr to fs dependent SFT        */
    897     unsigned short     OpenMode,    /* sharing, ...                   */
    898     unsigned short     OpenFlag,    /* open flag for action           */
    899     unsigned short     Attr,        /* file attribute                 */
    900     unsigned long      Reserved     /* reserved, must be zero         */
    901 );
    902 /* XLATON */
    903 
    904 /* values for *pFlags in FS_OPENPAGEFILE */
    905 #define PGIO_FIRSTOPEN 0x00000001   /* first open of page file        */
    906 #define PGIO_PADDR     0x00004000   /* physical addresses required    */
    907 #define PGIO_VADDR     0x00008000   /* 16:16 virtual address required */
    908 
    909 /* XLATOFF */
    910 int far pascal _loadds
    911 FS_PATHINFO(
    912     unsigned short,             /* flag         */
    913     struct cdfsi far *,         /* pcdfsi       */
    914     struct cdfsd far *,         /* pcdfsd       */
    915     char far *,                 /* pName        */
    916     unsigned short,             /* iCurDirEnd   */
    917     unsigned short,             /* level        */
    918     char far *,                 /* pData        */
    919     unsigned short              /* cbData       */
    920 );
    921 /* XLATON */
    922 
    923 /* values for flag in FS_PATHINFO */
    924 #define PI_RETRIEVE             0x00
    925 #define PI_SET                  0x01
    926 
    927 /* XLATOFF */
    928 int far pascal _loadds
    929 FS_PROCESSNAME(
    930     char far *                  /* pNameBuf     */
    931 );
    932 
    933 int far pascal _loadds
    934 FS_READ(
    935     struct sffsi far *,         /* psffsi       */
    936     struct sffsd far *,         /* psffsd       */
    937     char far *,                 /* pData        */
    938     unsigned short far *,       /* pLen         */
    939     unsigned short              /* IOflag       */
    940 );
    941 
    942 int far pascal _loadds
    943 FS_RMDIR(
    944     struct cdfsi far *,         /* pcdfsi       */
    945     struct cdfsd far *,         /* pcdfsd       */
    946     char far *,                 /* pName        */
    947     unsigned short              /* iCurDirEnd   */
    948 );
    949 
    950 int far pascal _loadds
    951 FS_SETSWAP(
    952     struct sffsi far *,         /* psffsi       */
    953     struct sffsd far *          /* psffsd       */
    954 );
    955 
    956 int far pascal _loadds
    957 FS_SHUTDOWN(
    958     unsigned short,             /* usType       */
    959     unsigned long               /* ulReserved   */
    960 );
    961 /* XLATON */
    962 
    963 /* values for usType in FS_SHUTDOWN */
    964 #define SD_BEGIN                0x00
    965 #define SD_COMPLETE             0x01
    966 
    967 /* XLATOFF */
    968 
    969 int far pascal _loadds
    970 FS_VERIFYUNCNAME(
    971     unsigned short,             /* flag         */
    972     char far *                  /* pName        */
    973 );
    974 
    975 
    976 /* XLATON */
    977 /* values for flag in FS_PATHINFO */
    978 /* These values depend on code in GetUNCFSDFromPath */
    979 /* Don't change values without also changing code */
    980 #define VUN_PASS1                0x0000
    981 #define VUN_PASS2                0x0001
    982 #define ERROR_UNC_PATH_NOT_FOUND 0x0003   /* equals ERROR_PATH_NOT_FOUND */
    983 
    984 /* XLATOFF */
    985 
    986 int far pascal _loadds
    987 FS_WRITE(
    988     struct sffsi far *,         /* psffsi       */
    989     struct sffsd far *,         /* psffsd       */
    990     char far *,                 /* pData        */
    991     unsigned short far *,       /* pLen         */
    992     unsigned short              /* IOflag       */
    993 );
    994 
    995 int far pascal _loadds
    996 MFS_CHGFILEPTR(
    997     unsigned long,              /* offset       */
    998     unsigned short              /* type         */
    999 );
    1000 
    1001 int far pascal _loadds
    1002 MFS_CLOSE(
    1003     void
    1004 );
    1005 
    1006 
    1007 int far pascal _loadds
    1008 MFS_INIT(
    1009     void far *,                 /* bootdata     */
    1010     char far *,                 /* number io    */
    1011     long far *,                 /* vectorripl   */
    1012     void far *,                 /* bpb          */
    1013     unsigned long far *,        /* pMiniFSD     */
    1014     unsigned long far *         /* dump address */
    1015 );
    1016 
    1017 int far pascal _loadds
    1018 MFS_OPEN(
    1019     char far *,                 /* name         */
    1020     unsigned long far *         /* size         */
    1021 );
    1022 
    1023 int far pascal _loadds
    1024 MFS_READ(
    1025     char far *,                 /* data         */
    1026     unsigned short far *        /* length       */
    1027 );
    1028 
    1029 int far pascal _loadds
    1030 MFS_TERM(
    1031     void
    1032 );
    1033 /* XLATON */
     719    char far *pName,
     720    unsigned short iCurDirEnd,
     721    struct sffsi far *psffsi,
     722    struct sffsd far *psffsd,
     723    unsigned long ulOpenMode,   /* or fHandFlag         */
     724    unsigned short usOpenFlag,
     725    unsigned short far *pusAction,
     726    unsigned short usAttr,
     727    char far *pEABuf,
     728    unsigned short far *pfgenFlag
     729 );
     730
     731 #define PGIO_FIRSTOPEN 0x00000001
     732 #define PGIO_PADDR     0x00004000
     733 #define PGIO_VADDR     0x00008000
     734
     735 int far pascal _loadds FS_OPENPAGEFILE (
     736    unsigned long far *pFlags,
     737    unsigned long far *pcMaxReq,
     738    char far          *pName,
     739    struct sffsi far  *psffsi,
     740    struct sffsd far  *psffsd,
     741    unsigned short    OpenMode,
     742    unsigned short    OpenFlag,
     743    unsigned short    Attr,
     744    unsigned long     Reserved
     745 );
     746
     747 #define PI_RETRIEVE    0x00
     748 #define PI_SET         0x01
     749
     750 #define VUN_PASS1      0x0000
     751 #define VUN_PASS2      0x0001
     752 #define ERROR_UNC_PATH_NOT_FOUND 0x0003
     753
     754 int far pascal _loadds FS_PATHINFO(
     755    unsigned short flag,
     756    struct cdfsi far *pcdfsi,
     757    struct cdfsd far *pcdfsd,
     758    char far *pName,
     759    unsigned short iCurDirEnd,
     760    unsigned short level,
     761    char far *pData,
     762    unsigned short cbData
     763 );
     764
     765 int far pascal _loadds FS_PROCESSNAME(
     766    char far *pNameBuf
     767 );
     768
     769 int far pascal _loadds FS_READ(
     770    struct sffsi far *psffsi,
     771    struct sffsd far *psffsd,
     772    char far *pData,
     773    unsigned short far *pcbLen,
     774    unsigned short IOflag
     775 );
     776
     777 int far pascal _loadds FS_RMDIR(
     778    struct cdfsi far *pcdfsi,
     779    struct cdfsd far *pcdfsd,
     780    char far *pName,
     781    unsigned short iCurDirEnd
     782 );
     783
     784 int far pascal _loadds FS_SETSWAP(
     785    struct sffsi far *psffsi,
     786    struct sffsd far *psffsd
     787 );
     788
     789 #define SD_BEGIN            0x00
     790 #define SD_COMPLETE         0x01
     791
     792 int far pascal _loadds FS_SHUTDOWN(
     793    unsigned short usType,
     794    unsigned long ulReserved
     795 );
     796
     797 int far pascal _loadds FS_VERIFYUNCNAME(
     798    unsigned short flag,
     799    char far *pName
     800 );
     801
     802 int far pascal _loadds FS_WRITE(
     803    struct sffsi far *psffsi,
     804    struct sffsd far *psffsd,
     805    char far *pData,
     806    unsigned short far *pcbLen,
     807    unsigned short IOflag
     808 );
     809
     810 int far pascal _loadds MFS_CHGFILEPTR(
     811    unsigned long offset,
     812    unsigned short type
     813 );
     814
     815 int far pascal _loadds MFS_CLOSE(void);
     816
     817 int far pascal _loadds MFS_INIT(
     818    void far *pBootData,
     819    char far *cbIO,
     820    long far *pVectorRIPL,
     821    void far *pBPB,
     822    unsigned long far *pMiniFSD,
     823    unsigned long far *pDump
     824 );
     825
     826 int far pascal _loadds MFS_OPEN(
     827    char far *pName,
     828    unsigned long far *pcbSize
     829 );
     830
     831 int far pascal _loadds MFS_READ(
     832    char far *pData,
     833    unsigned short far *pcbLen
     834 );
     835
     836 int far pascal _loadds MFS_TERM(void);
     837
     838 #endif /* __FSD_H_ */
  • trunk/src/include/fsh.h

    r97 r302  
    1 #ifndef __FSH_H
    2 #define __FSH_H
    3 
    4 /*  fsh.h   - FSH_ = fshelper interface declarations */
    5 
    6 /*
    7  *  FSH_DOVOLIO2 omits flag definition
    8  *
    9  *  Since we are using C5.1, the function prototypes should be made to
    10  *  conform with true ANSI standards.  I have converted FSH_ADDSHARE
    11  *  as an example.
    12  *
    13  */
    14 
    15 /* XLATOFF */
    16 #if 1
    17 int far pascal
    18 FSH_ADDSHARE(
    19     char far *,                 /* pName        */
    20     unsigned short,             /* mode         */
    21     unsigned short,             /* hVPB         */
    22     unsigned long far *         /* phShare      */
    23 );
    24 #else
    25 USHORT far pascal
    26 FSH_ADDSHARE(
    27     PSZ     pName,
    28     USHORT  mode,
    29     SHANDLE hVPB,
    30     LHANDLE phShare
    31 );
    32 #endif
    33 
    34 int far pascal
    35 FSH_CANONICALIZE(
    36     char far *,                 /* pPathName    */
    37     unsigned short,             /* cbPathBuf    */
    38     char far *,         /* pPathBuf     */
    39     char far *                  /* pFlags */
    40 );
    41 
    42 int far pascal
    43 FSH_CHECKEANAME(
    44     unsigned short,             /* level        */
    45     unsigned long,              /* len of name  */
    46     char far *                  /* pEAName      */
    47 );
    48 
    49 int far pascal
    50 FSH_CRITERROR(
    51     int,                        /* cbMessage    */
    52     char far *,                 /* pMessage     */
    53     int,                        /* nSubs        */
    54     char far *,                 /* pSubs        */
    55     unsigned short              /* fAllowed     */
    56 );
    57 /* XLATON */
    58 
    59 /*  Flags for fAllowed
    60  */
    61 #define CE_ALLFAIL      0x0001          /*  FAIL allowed                      */
    62 #define CE_ALLABORT     0x0002          /*  ABORT allowed                     */
    63 #define CE_ALLRETRY     0x0004          /*  RETRY allowed                     */
    64 #define CE_ALLIGNORE    0x0008          /*  IGNORE allowed                    */
    65 #define CE_ALLACK       0x0010          /*  ACK allowed                       */
    66 
    67 /*  Return values from FSH_CRITERR
    68  */
    69 #define CE_RETIGNORE    0x0000          /*  User said IGNORE                  */
    70 #define CE_RETRETRY     0x0001          /*  User said RETRY                   */
    71 #define CE_RETFAIL      0x0003          /*  User said FAIL/ABORT              */
    72 #define CE_RETACK       0x0004          /*  User said continue                */
    73 
    74 /* XLATOFF */
    75 int far pascal
    76 FSH_DEVIOCTL(
    77     unsigned short,             /* FSDRaisedFlag */
    78     unsigned long,              /* hDev         */
    79     unsigned short,             /* sfn          */
    80     unsigned short,             /* cat          */
    81     unsigned short,             /* func         */
    82     char far *,                 /* pParm        */
    83     unsigned short,             /* cbParm       */
    84     char far *,                 /* pData        */
    85     unsigned short              /* cbData       */
    86 );
    87 
    88 int far pascal
    89 FSH_DOVOLIO(
    90     unsigned short,             /* operation    */
    91     unsigned short,             /* fAllowed     */
    92     unsigned short,             /* hVPB         */
    93     char far *,                 /* pData        */
    94     unsigned short far *,       /* pcSec        */
    95     unsigned long               /* iSec         */
    96 );
    97 /* XLATON */
    98 
    99 /*  Flags for operation
    100  */
    101 #define DVIO_OPREAD     0x0000          /*  no bit on => readi                */
    102 #define DVIO_OPWRITE    0x0001          /*  ON => write else read             */
    103 #define DVIO_OPBYPASS   0x0002          /*  ON => cache bypass else no bypass */
    104 #define DVIO_OPVERIFY   0x0004          /*  ON => verify after write          */
    105 #define DVIO_OPHARDERR  0x0008          /*  ON => return hard errors directly */
    106 #define DVIO_OPWRTHRU   0x0010          /*  ON => write thru                  */
    107 #define DVIO_OPNCACHE   0x0020          /*  ON => don't cache data            */
    108 #define DVIO_OPRESMEM   0x0040          /*  ON => don't lock this memory      */
    109 
    110 /*  Flags for fAllowed
    111  */
    112 #define DVIO_ALLFAIL    0x0001          /*  FAIL allowed                      */
    113 #define DVIO_ALLABORT   0x0002          /*  ABORT allowed                     */
    114 #define DVIO_ALLRETRY   0x0004          /*  RETRY allowed                     */
    115 #define DVIO_ALLIGNORE  0x0008          /*  IGNORE allowed                    */
    116 #define DVIO_ALLACK     0x0010          /*  ACK allowed                       */
    117 
    118 /* XLATOFF */
    119 int far pascal
    120 FSH_DOVOLIO2(
    121     unsigned long,              /* hDev         */
    122     unsigned short,             /* sfn          */
    123     unsigned short,             /* cat          */
    124     unsigned short,             /* func         */
    125     char far *,                 /* pParm        */
    126     unsigned short,             /* cbParm       */
    127     char far *,                 /* pData        */
    128     unsigned short              /* cbData       */
    129 );
    130 
    131 int far pascal
    132 FSH_FINDCHAR(
    133     unsigned short,             /* nChars       */
    134     char far *,                 /* pChars       */
    135     char far * far *            /* ppStr        */
    136 );
    137 
    138 int far pascal
    139 FSH_FINDDUPHVPB(
    140     unsigned short,             /* hVPB         */
    141     unsigned short far *        /* pHVPB        */
    142 );
    143 
    144 int far pascal
    145 FSH_FLUSHBUF(
    146     unsigned short,             /* hVPB         */
    147     unsigned short              /* fDiscard     */
    148 );
    149 /* XLATON */
    150 
    151 /*  fDiscard values
    152  */
    153 #define FB_DISCNONE     0x0000          /*  Do not discard buffers            */
    154 #define FB_DISCCLEAN    0x0001          /*  Discard clean buffers             */
    155 
    156 /* XLATOFF */
    157 int far pascal
    158 FSH_FORCENOSWAP(
    159     unsigned short              /* sel          */
    160 );
    161 
    162 int far pascal FSH_EXTENDTIMESLICE(void);
    163 
    164 int far pascal FSH_GETPRIORITY(void);
    165 
    166 int far pascal FSH_IOBOOST(void);
    167 
    168 /* XLATON */
    169 
    170 /*  Flags for fPreRead
    171  */
    172 #define GB_PRNOREAD     0x0001          /*  ON => no preread occurs           */
    173 
    174 /* XLATOFF */
    175 int far pascal
    176 FSH_GETOVERLAPBUF(
    177     unsigned short,             /* hVPB         */
    178     unsigned long,              /* iSec         */
    179     unsigned long,              /* iSec         */
    180     unsigned long far *,        /* pisecBuf     */
    181     char far * far *            /* ppBuf        */
    182 );
    183 
    184 int far pascal
    185 FSH_GETVOLPARM(
    186     unsigned short,             /* hVPB         */
    187     struct vpfsi far * far *,   /* ppVPBfsi     */
    188     struct vpfsd far * far *    /* ppVPBfsd     */
    189 );
    190 
    191 int far pascal
    192 FSH_INTERR(
    193     char far *,                 /* pMsg         */
    194     unsigned short              /* cbMsg        */
    195 );
    196 
    197 int far pascal
    198 FSH_ISCURDIRPREFIX(
    199     char far *                  /* pName        */
    200 );
    201 
    202 void far pascal
    203 FSH_LOADCHAR(
    204     char far * far *,           /* ppStr        */
    205     unsigned short far *        /* pChar        */
    206 );
    207 
    208 void far pascal
    209 FSH_PREVCHAR(
    210     char far *,                 /* pBeg         */
    211     char far * far *            /* ppStr        */
    212 );
    213 
    214 int far pascal
    215 FSH_PROBEBUF(
    216     unsigned short,             /* operation    */
    217     char far *,                 /* pData        */
    218     unsigned short              /* cbData       */
    219 );
    220 /* XLATON */
    221 
    222 /*  Values for operation
    223  */
    224 #define PB_OPREAD   0x0000              /*  Check for read access             */
    225 #define PB_OPWRITE  0x0001              /*  Check for write access            */
    226 
    227 /* XLATOFF */
    228 
    229 int far pascal
    230 FSH_QUERYSERVERTHREAD( );
    231 
    232 int far pascal
    233 FSH_QUERYOPLOCK( );
    234 
    235 int far pascal
    236 FSH_QSYSINFO(
    237     unsigned short,             /* index        */
    238     char far *,                 /* pData        */
    239     unsigned short              /* cbData       */
    240 );
    241 /* XLATON */
    242 
    243 /* Values for index
    244  */
    245 #define QSI_SECSIZE     1       /* index to query max sector size */
    246 #define QSI_PROCID      2       /* index to query PID,UserID and Currentpdb */
    247 #define QSI_THREADNO    3       /* index to query abs.thread no */
    248 #define QSI_VERIFY      4       /* index to query per-process verify */
    249 
    250 /* XLATOFF */
    251 int far pascal
    252 FSH_NAMEFROMSFN(
    253     unsigned short,             /* sfn          */
    254     char far *,                 /* pName        */
    255     unsigned short far *        /* pcbName      */
    256 );
    257 
    258 int far pascal
    259 FSH_REGISTERPERFCTRS(
    260     char far *,                 /* pDataBlk     */
    261     char far *,                 /* pTextBlk     */
    262     unsigned short              /* fsFlags      */
    263 );
    264 /* XLATON */
    265 
    266 /*  Flags for fsFlags
    267  */
    268 #define RPC_16BIT       0x0000          /*  16-bit FSH interface              */
    269 #define RPC_32BIT       0x0001          /*  32-bit FSH interface              */
    270 
    271 /* XLATOFF */
    272 
    273 int far pascal
    274 FSH_REMOVESHARE(
    275     unsigned long               /* hShare       */
    276 );
    277 
    278 int far pascal
    279 FSH_SEGALLOC(
    280     unsigned short,             /* flags        */
    281     unsigned long,              /* cbSeg        */
    282     unsigned short far *        /* pSel         */
    283 );
    284 /* XLATON */
    285 
    286 /*  Fields for flags
    287  */
    288 #define SA_FLDT         0x0001          /*  ON => alloc LDT else GDT          */
    289 #define SA_FSWAP        0x0002          /*  ON => swappable memory            */
    290 
    291 #define SA_FRINGMASK    0x6000          /*  mask for isolating ring           */
    292 #define SA_FRING0       0x0000          /*  ring 0                            */
    293 #define SA_FRING1       0x2000          /*  ring 1                            */
    294 #define SA_FRING2       0x4000          /*  ring 2                            */
    295 #define SA_FRING3       0x6000          /*  ring 3                            */
    296 
    297 
    298 /* XLATOFF */
    299 int far pascal
    300 FSH_SEGFREE(
    301     unsigned short              /* sel          */
    302 );
    303 
    304 int far pascal
    305 FSH_SEGREALLOC(
    306     unsigned short,             /* sel          */
    307     unsigned long               /* cbSeg        */
    308 );
    309 /* XLATON */
    310 
    311 
    312 /*  Timeout equates for all semaphore operations
    313  */
    314 #define TO_INFINITE     0xFFFFFFFFL
    315 #define TO_NOWAIT       0x00000000L
    316 
    317 /* XLATOFF */
    318 int far pascal
    319 FSH_SEMCLEAR(
    320     void far *                  /* pSem         */
    321 );
    322 
    323 /* XLATOFF */
    324 int far pascal
    325 FSH_IOSEMCLEAR(
    326     void far *                  /* pSem         */
    327 );
    328 
    329 int far pascal
    330 FSH_SEMREQUEST(
    331     void far *,                 /* pSem         */
    332     unsigned long               /* cmsTimeout   */
    333 );
    334 
    335 int far pascal
    336 FSH_SEMSET(
    337     void far *                  /* pSem         */
    338 );
    339 
    340 int far pascal
    341 FSH_SEMSETWAIT(
    342     void far *,                 /* pSem         */
    343     unsigned long               /* cmsTimeout   */
    344 );
    345 
    346 int far pascal
    347 FSH_SEMWAIT(
    348     void far *,                 /* pSem         */
    349     unsigned long               /* cmsTimeout   */
    350 );
    351 
    352 int far pascal
    353 FSH_SETVOLUME(
    354     unsigned short,             /* hVPB         */
    355     unsigned long               /* fControl     */
    356 );
    357 
    358 int far pascal
    359 FSH_STORECHAR(
    360     unsigned short,             /* chDBCS       */
    361     char far * far *            /* ppStr        */
    362 );
    363 
    364 int far pascal
    365 FSH_UPPERCASE(
    366     char far *,                 /* pName        */
    367     unsigned short,             /* cbPathBuf    */
    368     char far *                  /* pPathBuf     */
    369 );
    370 
    371 int far pascal
    372 FSH_WILDMATCH(
    373     char far *,                 /* pPat         */
    374     char far *                  /* pStr         */
    375 );
    376 
    377 int far pascal
    378 FSH_YIELD(void);
    379 
    380 int far pascal
    381 FSH_CALLDRIVER(
    382     void far *,                 /* pPkt         */
    383     unsigned short,             /* hVPB         */
    384     unsigned short              /* fControl     */
    385 );
    386 
    387 int far pascal
    388 MFSH_DOVOLIO(
    389     char far *,                 /* Data         */
    390     unsigned short far *,       /* cSec         */
    391     unsigned long               /* iSec         */
    392 );
    393 
    394 int far pascal
    395 MFSH_INTERR(
    396     char far *,                 /* Msg          */
    397     unsigned short              /* cbMsg        */
    398 );
    399 
    400 int far pascal
    401 MFSH_SEGALLOC(
    402     unsigned short,             /* Flag         */
    403     unsigned long,              /* cbSeg        */
    404     unsigned sho