INT_PTR CALLBACK HexEditWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
ATOM
-STDCALL
+WINAPI
RegisterHexEditorClass(HINSTANCE hInstance)
{
WNDCLASSEX WndClass;
}
BOOL
-STDCALL
+WINAPI
UnregisterHexEditorClass(HINSTANCE hInstance)
{
return UnregisterClass(HEX_EDIT_CLASS_NAME, hInstance);
#define HEX_EDIT_CLASS_NAME _T("HexEdit32")
-ATOM STDCALL
+ATOM WINAPI
RegisterHexEditorClass(HINSTANCE hInstance);
-BOOL STDCALL
+BOOL WINAPI
UnregisterHexEditorClass(HINSTANCE hInstance);
/* styles */
DWORD * pEventTime);
/* logport.c */
-NTSTATUS STDCALL PortThreadRoutine(PVOID Param);
+NTSTATUS WINAPI PortThreadRoutine(PVOID Param);
NTSTATUS InitLogPort(VOID);
NTSTATUS ProcessPortMessage(VOID);
/* rpc.c */
-DWORD STDCALL RpcThreadRoutine(LPVOID lpParameter);
+DWORD WINAPI RpcThreadRoutine(LPVOID lpParameter);
#endif /* __EVENTLOG_H__ */
/* FUNCTIONS ****************************************************************/
-NTSTATUS STDCALL PortThreadRoutine(PVOID Param)
+NTSTATUS WINAPI PortThreadRoutine(PVOID Param)
{
NTSTATUS Status = STATUS_SUCCESS;
/* FUNCTIONS ****************************************************************/
-DWORD STDCALL RpcThreadRoutine(LPVOID lpParameter)
+DWORD WINAPI RpcThreadRoutine(LPVOID lpParameter)
{
RPC_STATUS Status;
#include <debug.h>
-typedef DWORD (STDCALL *PINSTALL_REACTOS)(HINSTANCE hInstance);
+typedef DWORD (WINAPI *PINSTALL_REACTOS)(HINSTANCE hInstance);
/* FUNCTIONS ****************************************************************/
FreeLibrary (hDll);
}
-int STDCALL
+int WINAPI
_tWinMain (HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
}
}
-static DWORD STDCALL
+static DWORD WINAPI
InstInstallationThread(LPVOID lpParameter)
{
HANDLE hThread;
// can interpret. If we wanted to halt the chkdsk we could return FALSE.
//
//----------------------------------------------------------------------
-BOOLEAN STDCALL
+BOOLEAN WINAPI
FormatExCallback (
CALLBACKCOMMAND Command,
ULONG Modifier,
}
-static NTSTATUS STDCALL
+static NTSTATUS WINAPI
CreateGroupOrderListRoutine(PWSTR ValueName,
ULONG ValueType,
PVOID ValueData,
}
-static NTSTATUS STDCALL
+static NTSTATUS WINAPI
CreateGroupListRoutine(PWSTR ValueName,
ULONG ValueType,
PVOID ValueData,
}
-int STDCALL
+int WINAPI
wWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPWSTR lpCmdLine,
*
* NOTE: call it holding SmpClientDirectory.Lock only
*/
-static INT STDCALL SmpGetFirstFreeClientEntry (VOID)
+static INT NTAPI SmpGetFirstFreeClientEntry (VOID)
{
INT ClientIndex = 0;
* WARNING
* SmpClientDirectory.Lock must be held by the caller.
*/
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
SmpDestroyClientObject (PSM_CLIENT_DATA Client, NTSTATUS DestroyReason)
{
DPRINT("SM:%s(%p,%08lx) called\n", __FUNCTION__, Client, DestroyReason);
* RETURN VALUES
* NTSTATUS
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
SmBeginClientInitialization (IN PSM_PORT_MESSAGE Request,
OUT PSM_CLIENT_DATA * ClientData)
{
* Lookup the subsystem server descriptor given the process ID
* of the subsystem server process.
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
SmCompleteClientInitialization (ULONG ProcessId)
{
NTSTATUS Status = STATUS_NOT_FOUND;
/**********************************************************************
* SmpDestroyClientByClientIndex/1 PRIVATE
*/
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
SmpDestroyClientByClientIndex (INT ClientIndex)
{
NTSTATUS Status = STATUS_SUCCESS;
* RETURN VALUE
* NONE.
*/
-static VOID STDCALL SmpTimeoutCandidateClient (PVOID x)
+static VOID NTAPI SmpTimeoutCandidateClient (PVOID x)
{
NTSTATUS Status = STATUS_SUCCESS;
HANDLE CandidateClientProcessHandle = (HANDLE) x;
*
*
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
SmCreateClient (PRTL_USER_PROCESS_INFORMATION ProcessInfo, PWSTR ProgramName)
{
NTSTATUS Status = STATUS_SUCCESS;
* 2. kill client process
* 3. release resources
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
SmDestroyClient (ULONG SubsystemId)
{
NTSTATUS Status = STATUS_SUCCESS;
/* FUNCTIONS *********************************************************/
-static VOID STDCALL
+static VOID NTAPI
DbgSsApiPortThread (PVOID dummy)
{
NTSTATUS Status = STATUS_SUCCESS;
NtTerminateThread(NtCurrentThread(),Status);
}
-static VOID STDCALL
+static VOID NTAPI
DbgUiApiPortThread (PVOID dummy)
{
NTSTATUS Status = STATUS_SUCCESS;
NtTerminateThread(NtCurrentThread(),Status);
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
SmpCreatePT (IN OUT PHANDLE hPort,
IN LPWSTR wcPortName,
IN ULONG ulMaxDataSize,
IN ULONG ulMaxMessageSize,
IN ULONG ulPoolCharge OPTIONAL,
- IN VOID (STDCALL * procServingThread)(PVOID) OPTIONAL,
+ IN VOID (NTAPI * procServingThread)(PVOID) OPTIONAL,
IN OUT PHANDLE phServingThread OPTIONAL)
{
NTSTATUS Status = STATUS_SUCCESS;
#define NDEBUG
#include <debug.h>
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
SmpDosDevicesQueryRoutine(PWSTR ValueName,
ULONG ValueType,
PVOID ValueData,
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
SmpEnvironmentQueryRoutine(IN PWSTR ValueName,
IN ULONG ValueType,
IN PVOID ValueData,
*
*
*--*/
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
SmpMoveFilesQueryRoutine(IN PWSTR ValueName,
IN ULONG ValueType,
IN PVOID ValueData,
#define NDEBUG
#include <debug.h>
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
SmpObjectDirectoryQueryRoutine(PWSTR ValueName,
ULONG ValueType,
PVOID ValueData,
#define GIGABYTE (1024 * 1024 * 1024) /* One Gigabyte */
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
SmpPagingFilesQueryRoutine(PWSTR ValueName,
ULONG ValueType,
PVOID ValueData,
/**********************************************************************
* SmpRunBootAppsQueryRoutine/6
*/
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
SmpRunBootAppsQueryRoutine(PWSTR ValueName,
ULONG ValueType,
PVOID ValueData,
* Register with itself for ImageSubsystemId
* (programmatically).
*/
-NTSTATUS STDCALL SmRegisterInternalSubsystem (LPWSTR PgmName,
+NTSTATUS NTAPI SmRegisterInternalSubsystem (LPWSTR PgmName,
USHORT ImageSubsystemId,
PHANDLE ApiPort)
{
#define NDEBUG
#include <debug.h>
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
SmpKnownDllsQueryRoutine(PWSTR ValueName,
ULONG ValueType,
PVOID ValueData,
#define NDEBUG
#include <debug.h>
-VOID STDCALL DisplayString(LPCWSTR lpwString)
+VOID NTAPI DisplayString(LPCWSTR lpwString)
{
UNICODE_STRING us;
NtDisplayString (&us);
}
-VOID STDCALL PrintString (char* fmt, ...)
+VOID NTAPI PrintString (char* fmt, ...)
{
char buffer[512];
va_list ap;
return (PSM_CONNECT_DATA)(PortMessage + 1);
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
SmpHandleConnectionRequest (PSM_PORT_MESSAGE Request);
/**********************************************************************
* DESCRIPTION
* Entry point for the listener thread of LPC port "\SmApiPort".
*/
-VOID STDCALL
+VOID NTAPI
SmpApiConnectedThread(PVOID pConnectedPort)
{
NTSTATUS Status = STATUS_SUCCESS;
* REMARKS
* Quoted in http://support.microsoft.com/kb/258060/EN-US/
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
SmpHandleConnectionRequest (PSM_PORT_MESSAGE Request)
{
PSM_CONNECT_DATA ConnectData = SmpGetConnectData (Request);
* necessary in NT LPC, because server side connected ports are
* never used to receive requests.
*/
-VOID STDCALL
+VOID NTAPI
SmpApiThread (HANDLE ListeningPort)
{
NTSTATUS Status = STATUS_SUCCESS;
* NTSTATUS:
*
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
SmCreateUserProcess (LPWSTR ImagePath,
LPWSTR CommandLine,
ULONG Flags,
NTSTATUS SmInitializeRegistry(VOID);
/* initss.c */
-NTSTATUS STDCALL SmRegisterInternalSubsystem(LPWSTR,USHORT,PHANDLE);
+NTSTATUS NTAPI SmRegisterInternalSubsystem(LPWSTR,USHORT,PHANDLE);
NTSTATUS SmLoadSubsystems(VOID);
/* smapi.c */
NTSTATUS FASTCALL n (PSM_PORT_MESSAGE Request)
PSM_CONNECT_DATA FASTCALL SmpGetConnectData (PSM_PORT_MESSAGE);
NTSTATUS SmCreateApiPort(VOID);
-VOID STDCALL SmpApiThread(PVOID);
+VOID NTAPI SmpApiThread(PVOID);
/* smapiexec.c */
#define SM_CREATE_FLAG_WAIT 0x01
#define SM_CREATE_FLAG_RESERVE_1MB 0x02
-NTSTATUS STDCALL SmCreateUserProcess(LPWSTR ImagePath,
+NTSTATUS NTAPI SmCreateUserProcess(LPWSTR ImagePath,
LPWSTR CommandLine,
ULONG Flags,
PLARGE_INTEGER Timeout OPTIONAL,
} SM_CLIENT_DATA, *PSM_CLIENT_DATA;
NTSTATUS SmInitializeClientManagement (VOID);
-NTSTATUS STDCALL SmCreateClient (PRTL_USER_PROCESS_INFORMATION,PWSTR);
-NTSTATUS STDCALL SmDestroyClient (ULONG);
-NTSTATUS STDCALL SmBeginClientInitialization (PSM_PORT_MESSAGE,PSM_CLIENT_DATA*);
-NTSTATUS STDCALL SmCompleteClientInitialization (ULONG);
+NTSTATUS NTAPI SmCreateClient (PRTL_USER_PROCESS_INFORMATION,PWSTR);
+NTSTATUS NTAPI SmDestroyClient (ULONG);
+NTSTATUS NTAPI SmBeginClientInitialization (PSM_PORT_MESSAGE,PSM_CLIENT_DATA*);
+NTSTATUS NTAPI SmCompleteClientInitialization (ULONG);
NTSTATUS FASTCALL SmGetClientBasicInformation (PSM_BASIC_INFORMATION);
NTSTATUS FASTCALL SmGetSubSystemInformation (PSM_SUBSYSTEM_INFORMATION);
NTSTATUS SmInitializeDbgSs(VOID);
/* print.c */
-VOID STDCALL DisplayString(LPCWSTR lpwString);
-VOID STDCALL PrintString (char* fmt, ...);
+VOID NTAPI DisplayString(LPCWSTR lpwString);
+VOID NTAPI PrintString (char* fmt, ...);
#endif /* _SMSS_H_INCLUDED_ */
#endif
PVOID
-STDCALL
+NTAPI
RtlpAllocateMemory(ULONG Bytes,
ULONG Tag)
{
VOID
-STDCALL
+NTAPI
RtlpFreeMemory(PVOID Mem,
ULONG Tag)
{
}
NTSTATUS
-STDCALL
+NTAPI
NullDispatch(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
}
NTSTATUS
-STDCALL
+NTAPI
DriverEntry(IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
#include <debug.h>
NTSTATUS
-STDCALL
+NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
NTSTATUS
-STDCALL
+NTAPI
ACPIDispatchDeviceControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
NTSTATUS
-STDCALL
+NTAPI
ACPIPnpControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
NTSTATUS
-STDCALL
+NTAPI
ACPIPowerControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
NTSTATUS
-STDCALL
+NTAPI
ACPIAddDevice(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PhysicalDeviceObject)
NTSTATUS
-STDCALL
+NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
/*** PUBLIC ******************************************************************/
NTSTATUS
-STDCALL
+NTAPI
FdoPnpControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
NTSTATUS
-STDCALL
+NTAPI
FdoPowerControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
/* fdo.c */
NTSTATUS
-STDCALL
+NTAPI
FdoPnpControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp);
NTSTATUS
-STDCALL
+NTAPI
FdoPowerControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp);
/* pdo.c */
NTSTATUS
-STDCALL
+NTAPI
PdoPnpControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp);
NTSTATUS
-STDCALL
+NTAPI
PdoPowerControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp);
static PVOID IVTVirtualAddress = NULL;
-VOID STDCALL
+VOID NTAPI
OslDpcStub(
IN PKDPC Dpc,
IN PVOID DeferredContext,
return AE_OK;
}
-BOOLEAN STDCALL
+BOOLEAN NTAPI
OslIsrStub(
PKINTERRUPT Interrupt,
PVOID ServiceContext)
/*** PUBLIC ******************************************************************/
NTSTATUS
-STDCALL
+NTAPI
PdoPnpControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
}
NTSTATUS
-STDCALL
+NTAPI
PdoPowerControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
static DRIVER_DISPATCH ISAPNPDispatchOpenClose;
static NTSTATUS
-STDCALL
+NTAPI
ISAPNPDispatchOpenClose(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
static DRIVER_DISPATCH ISAPNPDispatchReadWrite;
static NTSTATUS
-STDCALL
+NTAPI
ISAPNPDispatchReadWrite(
IN PDEVICE_OBJECT PhysicalDeviceObject,
IN PIRP Irp)
static DRIVER_DISPATCH ISAPNPDispatchDeviceControl;
static NTSTATUS
-STDCALL
+NTAPI
ISAPNPDispatchDeviceControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
static DRIVER_DISPATCH ISAPNPControl;
static NTSTATUS
-STDCALL
+NTAPI
ISAPNPControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
static NTSTATUS
-STDCALL
+NTAPI
ISAPNPAddDevice(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PhysicalDeviceObject)
NTSTATUS
-STDCALL
+NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
#include <ntddk.h>
-#ifdef _MSC_VER
- #define STDCALL
-#endif
-
#ifdef __cplusplus
extern "C" {
#endif
} ISAPNP_DEVICE_EXTENSION, *PISAPNP_DEVICE_EXTENSION;
NTSTATUS
-STDCALL
+NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath);
#include <debug.h>
static DRIVER_DISPATCH PciDispatchDeviceControl;
-static NTSTATUS STDCALL PciDispatchDeviceControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
+static NTSTATUS NTAPI PciDispatchDeviceControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
static DRIVER_ADD_DEVICE PciAddDevice;
-static NTSTATUS STDCALL PciAddDevice(IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PhysicalDeviceObject);
+static NTSTATUS NTAPI PciAddDevice(IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PhysicalDeviceObject);
static DRIVER_DISPATCH PciPowerControl;
-static NTSTATUS STDCALL PciPowerControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
+static NTSTATUS NTAPI PciPowerControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
static DRIVER_DISPATCH PciPnpControl;
-static NTSTATUS STDCALL PciPnpControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
+static NTSTATUS NTAPI PciPnpControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
#ifdef ALLOC_PRAGMA
/*** PRIVATE *****************************************************************/
static NTSTATUS
-STDCALL
+NTAPI
PciDispatchDeviceControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
static NTSTATUS
-STDCALL
+NTAPI
PciPnpControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
static NTSTATUS
-STDCALL
+NTAPI
PciPowerControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
static NTSTATUS
-STDCALL
+NTAPI
PciAddDevice(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PhysicalDeviceObject)
NTSTATUS
-STDCALL
+NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
#include <stdio.h>
#include <ntddk.h>
-#ifdef _MSC_VER
- #define STDCALL
-#endif
-
#define TAG(A, B, C, D) (ULONG)(((A)<<0) + ((B)<<8) + ((C)<<16) + ((D)<<24))
#define TAG_PCI TAG('P', 'C', 'I', '0')
PIRP Irp);
NTSTATUS
-STDCALL
+NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath);
extern PLARGE_INTEGER gpLockShortDelay;
/* Driver list export functions */
-DWORD STDCALL DxDxgGenericThunk(ULONG_PTR ulIndex, ULONG_PTR ulHandle, SIZE_T *pdwSizeOfPtr1, PVOID pvPtr1, SIZE_T *pdwSizeOfPtr2, PVOID pvPtr2);
-DWORD STDCALL DxDdIoctl(ULONG ulIoctl, PVOID pBuffer, ULONG ulBufferSize);
-PDD_SURFACE_LOCAL STDCALL DxDdLockDirectDrawSurface(HANDLE hDdSurface);
-BOOL STDCALL DxDdUnlockDirectDrawSurface(PDD_SURFACE_LOCAL pSurface);
+DWORD NTAPI DxDxgGenericThunk(ULONG_PTR ulIndex, ULONG_PTR ulHandle, SIZE_T *pdwSizeOfPtr1, PVOID pvPtr1, SIZE_T *pdwSizeOfPtr2, PVOID pvPtr2);
+DWORD NTAPI DxDdIoctl(ULONG ulIoctl, PVOID pBuffer, ULONG ulBufferSize);
+PDD_SURFACE_LOCAL NTAPI DxDdLockDirectDrawSurface(HANDLE hDdSurface);
+BOOL NTAPI DxDdUnlockDirectDrawSurface(PDD_SURFACE_LOCAL pSurface);
/* Internal functions */
BOOL FASTCALL VerifyObjectOwner(PDD_ENTRY pEntry);
PDD_SURFACE_LOCAL
-STDCALL
+NTAPI
DxDdLockDirectDrawSurface(HANDLE hDdSurface)
{
PEDD_SURFACE pEDDSurface = NULL;
}
BOOL
-STDCALL
+NTAPI
DxDdUnlockDirectDrawSurface(PDD_SURFACE_LOCAL pSurface)
{
BOOL retVal = FALSE;
*
*--*/
DWORD
-STDCALL
+NTAPI
DxDxgGenericThunk(ULONG_PTR ulIndex,
ULONG_PTR ulHandle,
SIZE_T *pdwSizeOfPtr1,
*
*--*/
DWORD
-STDCALL
+NTAPI
DxDdIoctl(ULONG ulIoctl,
PVOID pBuffer,
ULONG ulBufferSize)
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
MPU401Create(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
/*
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
MPU401Close(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
/*
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
MPU401Cleanup(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
/*
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
MPU401DeviceControl(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
/*
}
-static VOID STDCALL
+static VOID NTAPI
MPU401Unload(PDRIVER_OBJECT DriverObject)
{
DPRINT("MPU401Unload() called!\n");
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath)
/*
Prototypes for functions in settings.c :
*/
-NTSTATUS STDCALL EnumDeviceKeys(
+NTSTATUS NTAPI EnumDeviceKeys(
IN PUNICODE_STRING RegistryPath,
IN PWSTR SubKey,
IN PREGISTRY_CALLBACK_ROUTINE Callback,
IN PVOID Context);
-NTSTATUS STDCALL LoadSettings(
+NTSTATUS NTAPI LoadSettings(
IN PWSTR ValueName,
IN ULONG ValueType,
IN PVOID ValueData,
IN PVOID Context,
IN PVOID EntryContext);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath);
#endif
-NTSTATUS STDCALL EnumDeviceKeys(
+NTSTATUS NTAPI EnumDeviceKeys(
IN PUNICODE_STRING RegistryPath,
IN PWSTR SubKey,
IN PREGISTRY_CALLBACK_ROUTINE Callback,
-NTSTATUS STDCALL LoadSettings(
+NTSTATUS NTAPI LoadSettings(
IN PWSTR ValueName,
IN ULONG ValueType,
IN PVOID ValueData,
IRP DISPATCH ROUTINES
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
CreateSoundBlaster(
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
return STATUS_SUCCESS;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
CloseSoundBlaster(
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
return STATUS_SUCCESS;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
CleanupSoundBlaster(
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
return STATUS_SUCCESS;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
ControlSoundBlaster(
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
return STATUS_SUCCESS;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
WriteSoundBlaster(
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
return STATUS_SUCCESS;
}
-VOID STDCALL
+VOID NTAPI
UnloadSoundBlaster(
PDRIVER_OBJECT DriverObject)
{
DPRINT("Sound Blaster driver unload\n");
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
OpenSubkey(
PUNICODE_STRING RegistryPath,
PWSTR Subkey,
}
-PWSTR STDCALL
+PWSTR NTAPI
AllocateRegistryPathInfo(
PUNICODE_STRING BasePath,
PUNICODE_STRING ParametersPath,
#define TAG_REG_INFO TAG('I','g','e','R')
#define TAG_REG_NAME TAG('N','g','e','R')
-NTSTATUS STDCALL
+NTSTATUS NTAPI
EnumerateSubkey(
PUNICODE_STRING RegistryPath,
PWSTR Subkey,
return STATUS_SUCCESS;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
InitializeSoundBlaster(
PDRIVER_OBJECT DriverObject,
PWSTR RegistryPath)
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry(
PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath)
} SOUND_BLASTER_PARAMETERS, *PSOUND_BLASTER_PARAMETERS;
-typedef STDCALL NTSTATUS REGISTRY_CALLBACK_ROUTINE(PDRIVER_OBJECT DriverObject, PWSTR RegistryPath);
+typedef NTAPI NTSTATUS REGISTRY_CALLBACK_ROUTINE(PDRIVER_OBJECT DriverObject, PWSTR RegistryPath);
typedef REGISTRY_CALLBACK_ROUTINE *PREGISTRY_CALLBACK_ROUTINE;
#endif
-static IO_ALLOCATION_ACTION STDCALL SoundProgramDMA(
+static IO_ALLOCATION_ACTION NTAPI SoundProgramDMA(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID MapRegisterBase,
#endif
-NTSTATUS STDCALL EnumDeviceKeys(
+NTSTATUS NTAPI EnumDeviceKeys(
IN PUNICODE_STRING RegistryPath,
IN PWSTR SubKey,
IN PREGISTRY_CALLBACK_ROUTINE Callback,
-NTSTATUS STDCALL LoadSettings(
+NTSTATUS NTAPI LoadSettings(
IN PWSTR ValueName,
IN ULONG ValueType,
IN PVOID ValueData,
#include <ntddk.h>
#include "sndblst.h"
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath);
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
BlasterCreate(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
/*
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
BlasterClose(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
/*
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
BlasterCleanup(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
/*
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
BlasterWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
PIO_STACK_LOCATION Stack;
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
BlasterDeviceControl(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
/*
}
-static VOID STDCALL
+static VOID NTAPI
BlasterUnload(PDRIVER_OBJECT DriverObject)
{
DPRINT("BlasterUnload() called!\n");
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath)
/*
Prototypes for functions in settings.c :
*/
-NTSTATUS STDCALL EnumDeviceKeys(
+NTSTATUS NTAPI EnumDeviceKeys(
IN PUNICODE_STRING RegistryPath,
IN PWSTR SubKey,
IN PREGISTRY_CALLBACK_ROUTINE Callback,
IN PVOID Context);
-NTSTATUS STDCALL LoadSettings(
+NTSTATUS NTAPI LoadSettings(
IN PWSTR ValueName,
IN ULONG ValueType,
IN PVOID ValueData,
#include <ntddk.h>
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath);
#define NDEBUG
#include <debug.h>
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath)
/*
sb_status sb16_getenvironment(void);
#if 0
-static NTSTATUS STDCALL Dispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+static NTSTATUS NTAPI Dispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
/*
* FUNCTION: Handles user mode requests
* ARGUMENTS:
ULONG OldIRQ;
PKINTERRUPT IrqObject;
-static BOOLEAN STDCALL DMAOutputISR(PKINTERRUPT Interrupt, PVOID ServiceContext)
+static BOOLEAN NTAPI DMAOutputISR(PKINTERRUPT Interrupt, PVOID ServiceContext)
{
DPRINT1("interrupt\n");
return FALSE;
return Status;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
AfdBindSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp) {
NTSTATUS Status = STATUS_SUCCESS;
/* Return the socket object for ths request only if it is a connected or
stream type. */
-NTSTATUS STDCALL
+NTSTATUS NTAPI
AfdStreamSocketConnect(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp) {
NTSTATUS Status = STATUS_INVALID_PARAMETER;
#include "tdiconn.h"
#include "debug.h"
-NTSTATUS STDCALL
+NTSTATUS NTAPI
AfdGetContext( PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp ) {
NTSTATUS Status = STATUS_INVALID_PARAMETER;
return UnlockAndMaybeComplete( FCB, Status, Irp, 0, NULL );
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
AfdSetContext( PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp ) {
PFILE_OBJECT FileObject = IrpSp->FileObject;
#include "debug.h"
#include "pseh/pseh.h"
-NTSTATUS STDCALL
+NTSTATUS NTAPI
AfdGetInfo( PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp ) {
NTSTATUS Status = STATUS_SUCCESS;
return UnlockAndMaybeComplete( FCB, Status, Irp, 0, NULL );
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
AfdGetSockOrPeerName( PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp, BOOLEAN Local ) {
NTSTATUS Status = STATUS_SUCCESS;
/* FUNCTIONS */
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
AfdCreateSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp) {
PAFD_FCB FCB;
AFD_DbgPrint(MIN_TRACE,("Leaving\n"));
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
AfdCloseSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
return STATUS_SUCCESS;
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
AfdDisconnect(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp) {
PFILE_OBJECT FileObject = IrpSp->FileObject;
return UnlockAndMaybeComplete( FCB, Status, Irp, 0, NULL );
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
AfdDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
return (Status);
}
-static VOID STDCALL
+static VOID NTAPI
AfdUnload(PDRIVER_OBJECT DriverObject)
{
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
PDEVICE_OBJECT DeviceObject;
return STATUS_SUCCESS;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
AfdConnectedSocketReadData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp, BOOLEAN Short) {
NTSTATUS Status = STATUS_INVALID_PARAMETER;
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
SatisfyPacketRecvRequest( PAFD_FCB FCB, PIRP Irp,
PAFD_STORED_DATAGRAM DatagramRecv,
PUINT TotalBytesCopied ) {
return STATUS_SUCCESS;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
AfdPacketSocketReadData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp ) {
NTSTATUS Status = STATUS_SUCCESS;
AFD_DbgPrint(MID_TRACE,("Done\n"));
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
AfdSelect( PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp ) {
NTSTATUS Status = STATUS_NO_MEMORY;
return Status;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
AfdEventSelect( PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp ) {
PFILE_OBJECT FileObject = IrpSp->FileObject;
0, NULL );
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
AfdEnumEvents( PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp ) {
PFILE_OBJECT FileObject = IrpSp->FileObject;
return STATUS_SUCCESS;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
AfdConnectedSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp, BOOLEAN Short) {
NTSTATUS Status = STATUS_SUCCESS;
}
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
AfdPacketSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp) {
NTSTATUS Status = STATUS_SUCCESS;
NdisRawWritePortUchar((Adapter)->IOBase + PG0_IMR, (Adapter)->InterruptMask); \
}
-VOID STDCALL MiniportHandleInterrupt(
+VOID NTAPI MiniportHandleInterrupt(
IN NDIS_HANDLE MiniportAdapterContext);
#endif /* __8390_H */
}
-VOID STDCALL MiniportHandleInterrupt(
+VOID NTAPI MiniportHandleInterrupt(
IN NDIS_HANDLE MiniportAdapterContext)
/*
* FUNCTION: Handler for deferred processing of interrupts
NTSTATUS
#ifndef _MSC_VER
-STDCALL
+NTAPI
#endif
DriverEntry(
PDRIVER_OBJECT DriverObject,
NDIS_PHYSICAL_ADDRESS HighestAcceptableMax = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
-static BOOLEAN STDCALL MiniportCheckForHang(
+static BOOLEAN NTAPI MiniportCheckForHang(
IN NDIS_HANDLE MiniportAdapterContext)
/*
* FUNCTION: Examines if an adapter has hung
}
-static VOID STDCALL MiniportDisableInterrupt(
+static VOID NTAPI MiniportDisableInterrupt(
IN NDIS_HANDLE MiniportAdapterContext)
/*
* FUNCTION: Disables interrupts from an adapter
}
-static VOID STDCALL MiniportEnableInterrupt(
+static VOID NTAPI MiniportEnableInterrupt(
IN NDIS_HANDLE MiniportAdapterContext)
/*
* FUNCTION: Enables interrupts from an adapter
}
-static VOID STDCALL MiniportHalt(
+static VOID NTAPI MiniportHalt(
IN NDIS_HANDLE MiniportAdapterContext)
/*
* FUNCTION: Deallocates resources for and halts an adapter
}
-static VOID STDCALL MiQueryResources(
+static VOID NTAPI MiQueryResources(
OUT PNDIS_STATUS Status,
IN PNIC_ADAPTER Adapter,
IN NDIS_HANDLE WrapperConfigurationContext)
}
VOID
-STDCALL
+NTAPI
MiniportShutdown(PVOID Context)
{
#ifndef NOCARD
#endif
}
-static NDIS_STATUS STDCALL MiniportInitialize(
+static NDIS_STATUS NTAPI MiniportInitialize(
OUT PNDIS_STATUS OpenErrorStatus,
OUT PUINT SelectedMediumIndex,
IN PNDIS_MEDIUM MediumArray,
}
-static VOID STDCALL MiniportISR(
+static VOID NTAPI MiniportISR(
OUT PBOOLEAN InterruptRecognized,
OUT PBOOLEAN QueueMiniportHandleInterrupt,
IN NDIS_HANDLE MiniportAdapterContext)
}
-static NDIS_STATUS STDCALL MiniportQueryInformation(
+static NDIS_STATUS NTAPI MiniportQueryInformation(
IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
}
-static NDIS_STATUS STDCALL MiniportReconfigure(
+static NDIS_STATUS NTAPI MiniportReconfigure(
OUT PNDIS_STATUS OpenErrorStatus,
IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_HANDLE WrapperConfigurationContext)
-static NDIS_STATUS STDCALL MiniportReset(
+static NDIS_STATUS NTAPI MiniportReset(
OUT PBOOLEAN AddressingReset,
IN NDIS_HANDLE MiniportAdapterContext)
/*
}
-static NDIS_STATUS STDCALL MiniportSend(
+static NDIS_STATUS NTAPI MiniportSend(
IN NDIS_HANDLE MiniportAdapterContext,
IN PNDIS_PACKET Packet,
IN UINT Flags)
}
-static NDIS_STATUS STDCALL MiniportSetInformation(
+static NDIS_STATUS NTAPI MiniportSetInformation(
IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
}
-static NDIS_STATUS STDCALL MiniportTransferData(
+static NDIS_STATUS NTAPI MiniportTransferData(
OUT PNDIS_PACKET Packet,
OUT PUINT BytesTransferred,
IN NDIS_HANDLE MiniportAdapterContext,
NTSTATUS
#ifndef _MSC_VER
-STDCALL
+NTAPI
#endif
DriverEntry(
PDRIVER_OBJECT DriverObject,
#include <debug.h>
NTSTATUS
-STDCALL
+NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath);
static VOID
-STDCALL
+NTAPI
MiniportHandleInterrupt(
IN NDIS_HANDLE MiniportAdapterContext)
/*
}
static BOOLEAN
-STDCALL
+NTAPI
MiSyncStop(
IN PVOID SynchronizeContext)
/*
}
static VOID
-STDCALL
+NTAPI
MiniportHalt(
IN NDIS_HANDLE MiniportAdapterContext)
/*
}
static BOOLEAN
-STDCALL
+NTAPI
MiSyncMediaDetection(
IN PVOID SynchronizeContext)
/*
}
static VOID
-STDCALL
+NTAPI
MiniportMediaDetectionTimer(
IN PVOID SystemSpecific1,
IN PVOID FunctionContext,
#endif
VOID
-STDCALL
+NTAPI
MiniportShutdown( PVOID Context )
{
PADAPTER Adapter = Context;
}
static NDIS_STATUS
-STDCALL
+NTAPI
MiniportInitialize(
OUT PNDIS_STATUS OpenErrorStatus,
OUT PUINT SelectedMediumIndex,
}
static VOID
-STDCALL
+NTAPI
MiniportISR(
OUT PBOOLEAN InterruptRecognized,
OUT PBOOLEAN QueueMiniportHandleInterrupt,
}
static NDIS_STATUS
-STDCALL
+NTAPI
MiniportReset(
OUT PBOOLEAN AddressingReset,
IN NDIS_HANDLE MiniportAdapterContext)
}
static BOOLEAN
-STDCALL
+NTAPI
MiSyncStartTransmit(
IN PVOID SynchronizeContext)
/*
}
static NDIS_STATUS
-STDCALL
+NTAPI
MiniportSend(
IN NDIS_HANDLE MiniportAdapterContext,
IN PNDIS_PACKET Packet,
}
static ULONG
-STDCALL
+NTAPI
MiEthernetCrc(UCHAR *Address)
/*
* FUNCTION: Calculate Ethernet CRC32
}
NDIS_STATUS
-STDCALL
+NTAPI
MiSetMulticast(
PADAPTER Adapter,
UCHAR *Addresses,
}
NDIS_MEDIA_STATE
-STDCALL
+NTAPI
MiGetMediaState(PADAPTER Adapter)
/*
* FUNCTION: Determine the link state
}
NTSTATUS
-STDCALL
+NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
/* forward declarations */
NDIS_STATUS
-STDCALL
+NTAPI
MiniportQueryInformation(
IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_OID Oid,
OUT PULONG BytesNeeded);
NDIS_STATUS
-STDCALL
+NTAPI
MiniportSetInformation(
IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_OID Oid,
OUT PULONG BytesNeeded);
NDIS_STATUS
-STDCALL
+NTAPI
MiSetMulticast(
PADAPTER Adapter,
UCHAR *Addresses,
UINT AddressCount);
NDIS_MEDIA_STATE
-STDCALL
+NTAPI
MiGetMediaState(PADAPTER Adapter);
/* operational constants */
\f
NDIS_STATUS
-STDCALL
+NTAPI
MiniportQueryInformation(
IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_OID Oid,
}
NDIS_STATUS
-STDCALL
+NTAPI
MiniportSetInformation(
IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_OID Oid,
}
-VOID STDCALL ProtocolOpenAdapterComplete(
+VOID NTAPI ProtocolOpenAdapterComplete(
NDIS_HANDLE BindingContext,
NDIS_STATUS Status,
NDIS_STATUS OpenErrorStatus)
}
-VOID STDCALL ProtocolCloseAdapterComplete(
+VOID NTAPI ProtocolCloseAdapterComplete(
NDIS_HANDLE BindingContext,
NDIS_STATUS Status)
/*
}
-VOID STDCALL ProtocolResetComplete(
+VOID NTAPI ProtocolResetComplete(
NDIS_HANDLE BindingContext,
NDIS_STATUS Status)
/*
}
-VOID STDCALL ProtocolRequestComplete(
+VOID NTAPI ProtocolRequestComplete(
NDIS_HANDLE BindingContext,
PNDIS_REQUEST NdisRequest,
NDIS_STATUS Status)
}
-VOID STDCALL ProtocolSendComplete(
+VOID NTAPI ProtocolSendComplete(
NDIS_HANDLE BindingContext,
PNDIS_PACKET Packet,
NDIS_STATUS Status)
}
-VOID STDCALL ProtocolTransferDataComplete(
+VOID NTAPI ProtocolTransferDataComplete(
NDIS_HANDLE BindingContext,
PNDIS_PACKET Packet,
NDIS_STATUS Status,
}
-NDIS_STATUS STDCALL ProtocolReceive(
+NDIS_STATUS NTAPI ProtocolReceive(
NDIS_HANDLE BindingContext,
NDIS_HANDLE MacReceiveContext,
PVOID HeaderBuffer,
}
-VOID STDCALL ProtocolReceiveComplete(
+VOID NTAPI ProtocolReceiveComplete(
NDIS_HANDLE BindingContext)
/*
* FUNCTION: Called by NDIS when we're done receiving data
}
-VOID STDCALL ProtocolStatus(
+VOID NTAPI ProtocolStatus(
NDIS_HANDLE BindingContext,
NDIS_STATUS GenerelStatus,
PVOID StatusBuffer,
}
-VOID STDCALL ProtocolStatusComplete(
+VOID NTAPI ProtocolStatusComplete(
NDIS_HANDLE NdisBindingContext)
/*
* FUNCTION: Called by NDIS when a status-change has occurred
LA_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
}
-VOID STDCALL ProtocolBindAdapter(
+VOID NTAPI ProtocolBindAdapter(
OUT PNDIS_STATUS Status,
IN NDIS_HANDLE BindContext,
IN PNDIS_STRING DeviceName,
NdisDeregisterProtocol(&NdisStatus, DeviceExt->NdisProtocolHandle);
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
LanCreateProtocol( PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp ) {
PLAN_PROTOCOL Proto;
return STATUS_SUCCESS;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
LanCloseProtocol( PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp ) {
PLAN_DEVICE_EXT DeviceExt =
* |<- 16 >| |<-- variable ... -->|
* [indx] [addrtype] [addrlen ] [ptype] [packet-data ...]
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
LanWriteData( PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp ) {
PLAN_PACKET_HEADER ToWrite = Irp->AssociatedIrp.SystemBuffer;
return Status;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
LanReadData( PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp ) {
PLAN_DEVICE_EXT DeviceExt =
return STATUS_PENDING;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
LanEnumAdapters( PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp ) {
PLIST_ENTRY ListEntry;
return Status;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
LanAdapterInfo( PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp ) {
PLAN_DEVICE_EXT DeviceExt =
return Status;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
LanSetBufferedMode( PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp ) {
PLAN_DEVICE_EXT DeviceExt =
return Status;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
LanDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
}
/* Do i need a global here? I think i need to do this a different way XXX */
-VOID STDCALL LanUnload(PDRIVER_OBJECT DriverObject) {
+VOID NTAPI LanUnload(PDRIVER_OBJECT DriverObject) {
LANUnregisterProtocol();
CloseNdisPools();
}
-NTSTATUS STDCALL DriverEntry( PDRIVER_OBJECT DriverObject,
+NTSTATUS NTAPI DriverEntry( PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegsitryPath ) {
PDEVICE_OBJECT DeviceObject;
PLAN_DEVICE_EXT DeviceExt;
* DataSize: number of bytes in Data
* Data: binary dump data to help analyzing the event
* NOTES:
- * - STDCALL, not CDECL like WriteError...
+ * - NTAPI, not CDECL like WriteError...
* - FIXME Needs to use the real log interface, once there is one
*/
{
return Status;
}
-VOID STDCALL
+VOID NTAPI
MiniportHangDpc(
PKDPC Dpc,
PVOID DeferredContext,
VOID
-STDCALL
+NTAPI
ndisProcWorkItemHandler(PVOID pContext)
{
PNDIS_WORK_ITEM pNdisItem = (PNDIS_WORK_ITEM)pContext;
}
-VOID STDCALL ProtocolOpenAdapterComplete(
+VOID NTAPI ProtocolOpenAdapterComplete(
NDIS_HANDLE BindingContext,
NDIS_STATUS Status,
NDIS_STATUS OpenErrorStatus)
}
-VOID STDCALL ProtocolCloseAdapterComplete(
+VOID NTAPI ProtocolCloseAdapterComplete(
NDIS_HANDLE BindingContext,
NDIS_STATUS Status)
/*
}
-VOID STDCALL ProtocolResetComplete(
+VOID NTAPI ProtocolResetComplete(
NDIS_HANDLE BindingContext,
NDIS_STATUS Status)
/*
}
-VOID STDCALL ProtocolRequestComplete(
+VOID NTAPI ProtocolRequestComplete(
NDIS_HANDLE BindingContext,
PNDIS_REQUEST NdisRequest,
NDIS_STATUS Status)
}
-VOID STDCALL ProtocolSendComplete(
+VOID NTAPI ProtocolSendComplete(
NDIS_HANDLE BindingContext,
PNDIS_PACKET Packet,
NDIS_STATUS Status)
ASSERT(0);
}
-VOID STDCALL ProtocolTransferDataComplete(
+VOID NTAPI ProtocolTransferDataComplete(
NDIS_HANDLE BindingContext,
PNDIS_PACKET Packet,
NDIS_STATUS Status,
LanSubmitReceiveWork( BindingContext, Packet, Status, BytesTransferred );
}
-NDIS_STATUS STDCALL ProtocolReceive(
+NDIS_STATUS NTAPI ProtocolReceive(
NDIS_HANDLE BindingContext,
NDIS_HANDLE MacReceiveContext,
PVOID HeaderBuffer,
}
-VOID STDCALL ProtocolReceiveComplete(
+VOID NTAPI ProtocolReceiveComplete(
NDIS_HANDLE BindingContext)
/*
* FUNCTION: Called by NDIS when we're done receiving data
}
-VOID STDCALL ProtocolStatus(
+VOID NTAPI ProtocolStatus(
NDIS_HANDLE BindingContext,
NDIS_STATUS GeneralStatus,
PVOID StatusBuffer,
}
-VOID STDCALL ProtocolStatusComplete(
+VOID NTAPI ProtocolStatusComplete(
NDIS_HANDLE NdisBindingContext)
/*
* FUNCTION: Called by NDIS when a status-change has occurred
TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
}
-VOID STDCALL ProtocolBindAdapter(
+VOID NTAPI ProtocolBindAdapter(
OUT PNDIS_STATUS Status,
IN NDIS_HANDLE BindContext,
IN PNDIS_STRING DeviceName,
VOID IPUnregisterInterface(
PIP_INTERFACE IF);
-VOID STDCALL IPTimeout( PVOID Context );
+VOID NTAPI IPTimeout( PVOID Context );
VOID IPDispatchProtocol(
PIP_INTERFACE Interface,
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
TiDispatchOpenClose(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
}
-VOID STDCALL TiUnload(
+VOID NTAPI TiUnload(
PDRIVER_OBJECT DriverObject)
/*
* FUNCTION: Unloads the driver
TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
}
-VOID STDCALL IPTimeoutDpcFn(
+VOID NTAPI IPTimeoutDpcFn(
PKDPC Dpc,
PVOID DeferredContext,
PVOID SystemArgument1,
* @unimplemented
*/
BOOLEAN
-STDCALL
+NTAPI
CTEAllocateString (
ULONG Unknown0,
ULONG Unknown1
* @unimplemented
*/
BOOLEAN
-STDCALL
+NTAPI
CTEInitString (
ULONG Unknown0,
ULONG Unknown1
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
CTEBlock (
ULONG Unknown0
)
* @unimplemented
*/
VOID
-STDCALL
+NTAPI
CTEInitEvent (
ULONG Unknown0,
ULONG Unknown1
* @unimplemented
*/
VOID
-STDCALL
+NTAPI
CTEInitTimer (
ULONG Unknown0
)
* @unimplemented
*/
BOOLEAN
-STDCALL
+NTAPI
CTEInitialize (
VOID
)
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
CTELogEvent (
ULONG Unknown0,
ULONG Unknown1,
* @unimplemented
*/
BOOLEAN
-STDCALL
+NTAPI
CTEScheduleEvent (
ULONG Unknown0,
ULONG Unknown1
* @unimplemented
*/
LONG
-STDCALL
+NTAPI
CTESignal (
ULONG Unknown0,
ULONG Unknown1
* @unimplemented
*/
BOOLEAN
-STDCALL
+NTAPI
CTEStartTimer (
ULONG Unknown0,
ULONG Unknown1,
* @unimplemented
*/
ULONG
-STDCALL
+NTAPI
CTESystemUpTime (
VOID
)
#include <ntddk.h>
NTSTATUS
-STDCALL
+NTAPI
DriverEntry (
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
static
NTSTATUS
-STDCALL
+NTAPI
TdiDeRegister (
IN TDI_OBJECT_ACTION Action,
IN OUT PVOID Object
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiRegisterAddressChangeHandler (
ULONG Unknown0,
ULONG Unknown1,
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiDeregisterAddressChangeHandler (
IN PVOID AddressChangeHandler
)
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiRegisterDeviceObject (
ULONG Unknown0,
ULONG Unknown1
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiDeregisterDeviceObject (
IN PVOID DeviceObject
)
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiRegisterNetAddress (
ULONG Unknown0,
ULONG Unknown1
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiDeregisterNetAddress (
IN PVOID NetAddress
)
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiRegisterNotificationHandler (
ULONG Unknown0,
ULONG Unknown1,
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiDeregisterNotificationHandler (
IN PVOID NotificationHandler
)
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiDefaultChainedRcvDatagramHandler (
IN PVOID TdiEventContext,
IN LONG SourceAddressLength,
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiDefaultChainedRcvExpeditedHandler (
IN PVOID TdiEventContext,
IN CONNECTION_CONTEXT ConnectionContext,
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiDefaultChainedReceiveHandler (
IN PVOID TdiEventContext,
IN CONNECTION_CONTEXT ConnectionContext,
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiDefaultConnectHandler (
IN PVOID TdiEventContext,
IN LONG RemoteAddressLength,
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiDefaultDisconnectHandler (
IN PVOID TdiEventContext,
IN CONNECTION_CONTEXT ConnectionContext,
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiDefaultErrorHandler (
IN PVOID TdiEventContext,
IN NTSTATUS Status
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiDefaultRcvDatagramHandler (
IN PVOID TdiEventContext,
IN LONG SourceAddressLength,
* @unimplemented
*/
TDI_STATUS
-STDCALL
+NTAPI
TdiDefaultRcvExpeditedHandler (
IN PVOID TdiEventContext,
IN CONNECTION_CONTEXT ConnectionContext,
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiDefaultReceiveHandler (
IN PVOID TdiEventContext,
IN CONNECTION_CONTEXT ConnectionContext,
* @unimplemented
*/
TDI_STATUS
-STDCALL
+NTAPI
TdiDefaultSendPossibleHandler (
IN PVOID TdiEventContext,
IN PVOID ConnectionContext,
* @unimplemented
*/
VOID
-STDCALL
+NTAPI
TdiMapBuffer (
ULONG Unknown0
)
* @unimplemented
*/
VOID
-STDCALL
+NTAPI
TdiUnmapBuffer (
ULONG Unknown0
)
* @unimplemented
*/
VOID
-STDCALL
+NTAPI
TdiBuildNetbiosAddress (
IN PUCHAR NetbiosName,
IN BOOLEAN IsGroupName,
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiBuildNetbiosAddressEa (
IN PUCHAR Buffer,
IN BOOLEAN GroupName,
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiCopyBufferToMdl (
IN PVOID SourceBuffer,
IN ULONG SourceOffset,
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiCopyMdlToBuffer (
IN PMDL SourceMdlChain,
IN ULONG SourceOffset,
* @unimplemented
*/
VOID
-STDCALL
+NTAPI
TdiInitialize (
PVOID Unknown0
)
* @unimplemented
*/
NTSTATUS
-STDCALL
+NTAPI
TdiMapUserRequest (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
* @unimplemented
*/
VOID
-STDCALL
+NTAPI
TdiOpenNetbiosAddress (
ULONG Unknown0,
ULONG Unknown1,
* @unimplemented
*/
VOID
-STDCALL
+NTAPI
TdiReturnChainedReceives (
IN PVOID * TsduDescriptors,
IN ULONG NumberOfTsdus
#define LP_S (READ_PORT_UCHAR((PUCHAR)(LP_B+1)))
#define LP_C (LP_B+2)
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
static void Parallel_Reset(void)
}
static DRIVER_DISPATCH Dispatch;
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
Dispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
/*
* FUNCTION: Handles user mode requests
return(status);
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
/*
* FUNCTION: Called by the system to initalize the driver
DeviceExtension->ScanLines);
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
static DRIVER_DISPATCH ScrCreate;
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
ScrCreate(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
}
static DRIVER_DISPATCH ScrWrite;
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
ScrWrite(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
}
static DRIVER_DISPATCH ScrIoControl;
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
ScrIoControl(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
}
static DRIVER_DISPATCH ScrDispatch;
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
ScrDispatch(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
/*
* Module entry point
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
PDEVICE_OBJECT DeviceObject;
#endif
NTSTATUS
-STDCALL
+NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
);
BOOLEAN
-STDCALL
+NTAPI
ScsiCdRomFindDevices(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath,
);
NTSTATUS
-STDCALL
+NTAPI
ScsiCdRomOpenClose(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
NTSTATUS
-STDCALL
+NTAPI
ScsiCdRomReadVerification(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
NTSTATUS
-STDCALL
+NTAPI
ScsiCdRomSwitchMode(
IN PDEVICE_OBJECT DeviceObject,
IN ULONG SectorSize,
);
NTSTATUS
-STDCALL
+NTAPI
CdRomDeviceControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
IO_COMPLETION_ROUTINE CdRomDeviceControlCompletion;
NTSTATUS
-STDCALL
+NTAPI
CdRomDeviceControlCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IO_COMPLETION_ROUTINE CdRomSetVolumeIntermediateCompletion;
NTSTATUS
-STDCALL
+NTAPI
CdRomSetVolumeIntermediateCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IO_COMPLETION_ROUTINE CdRomSwitchModeCompletion;
NTSTATUS
-STDCALL
+NTAPI
CdRomSwitchModeCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IO_COMPLETION_ROUTINE CdRomXACompletion;
NTSTATUS
-STDCALL
+NTAPI
CdRomXACompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IO_COMPLETION_ROUTINE CdRomClassIoctlCompletion;
NTSTATUS
-STDCALL
+NTAPI
CdRomClassIoctlCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
);
VOID
-STDCALL
+NTAPI
ScsiCdRomStartIo(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
VOID
-STDCALL
+NTAPI
CdRomTickHandler(
IN PDEVICE_OBJECT DeviceObject,
IN PVOID Context
);
BOOLEAN
-STDCALL
+NTAPI
CdRomCheckRegistryForMediaChangeValue(
IN PUNICODE_STRING RegistryPath,
IN ULONG DeviceNumber
);
NTSTATUS
-STDCALL
+NTAPI
CdRomUpdateCapacity(
IN PDEVICE_EXTENSION DeviceExtension,
IN PIRP IrpToComplete,
);
NTSTATUS
-STDCALL
+NTAPI
CreateCdRomDeviceObject(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PortDeviceObject,
);
VOID
-STDCALL
+NTAPI
ScanForSpecial(
PDEVICE_OBJECT DeviceObject,
PINQUIRYDATA InquiryData,
);
BOOLEAN
-STDCALL
+NTAPI
CdRomIsPlayActive(
IN PDEVICE_OBJECT DeviceObject
);
VOID
-STDCALL
+NTAPI
HitachProcessError(
PDEVICE_OBJECT DeviceObject,
PSCSI_REQUEST_BLOCK Srb,
IO_COMPLETION_ROUTINE ToshibaProcessErrorCompletion;
VOID
-STDCALL
+NTAPI
ToshibaProcessError(
PDEVICE_OBJECT DeviceObject,
PSCSI_REQUEST_BLOCK Srb,
);
BOOLEAN
-STDCALL
+NTAPI
IsThisAnAtapiChanger(
IN PDEVICE_OBJECT DeviceObject,
OUT PULONG DiscsPresent
);
BOOLEAN
-STDCALL
+NTAPI
IsThisASanyo(
IN PDEVICE_OBJECT DeviceObject,
IN UCHAR PathId,
);
BOOLEAN
-STDCALL
+NTAPI
IsThisAMultiLunDevice(
IN PDEVICE_OBJECT DeviceObject,
IN PDEVICE_OBJECT PortDeviceObject
);
VOID
-STDCALL
+NTAPI
CdRomCreateNamedEvent(
IN PDEVICE_EXTENSION DeviceExtension,
IN ULONG DeviceNumber
ULONG NoLoad = 0;
NTSTATUS
-STDCALL
+NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
} // end DriverEntry()
BOOLEAN
-STDCALL
+NTAPI
ScsiCdRomFindDevices(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath,
} // end FindScsiCdRoms()
VOID
-STDCALL
+NTAPI
CdRomCreateNamedEvent(
IN PDEVICE_EXTENSION DeviceExtension,
IN ULONG DeviceNumber
}
NTSTATUS
-STDCALL
+NTAPI
CreateCdRomDeviceObject(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PortDeviceObject,
} // end CreateCdRomDeviceObject()
VOID
-STDCALL
+NTAPI
ScsiCdRomStartIo(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
NTSTATUS
-STDCALL
+NTAPI
ScsiCdRomReadVerification(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
NTSTATUS
-STDCALL
+NTAPI
CdRomDeviceControlCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
}
NTSTATUS
-STDCALL
+NTAPI
CdRomSetVolumeIntermediateCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
NTSTATUS
-STDCALL
+NTAPI
CdRomSwitchModeCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
}
NTSTATUS
-STDCALL
+NTAPI
CdRomXACompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
}
NTSTATUS
-STDCALL
+NTAPI
CdRomDeviceControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
} // end ScsiCdRomDeviceControl()
VOID
-STDCALL
+NTAPI
ScanForSpecial(
PDEVICE_OBJECT DeviceObject,
PINQUIRYDATA InquiryData,
}
VOID
-STDCALL
+NTAPI
HitachProcessError(
PDEVICE_OBJECT DeviceObject,
PSCSI_REQUEST_BLOCK Srb,
}
NTSTATUS
-STDCALL
+NTAPI
ToshibaProcessErrorCompletion(
PDEVICE_OBJECT DeviceObject,
PIRP Irp,
}
VOID
-STDCALL
+NTAPI
ToshibaProcessError(
PDEVICE_OBJECT DeviceObject,
PSCSI_REQUEST_BLOCK Srb,
}
BOOLEAN
-STDCALL
+NTAPI
CdRomIsPlayActive(
IN PDEVICE_OBJECT DeviceObject
)
IO_COMPLETION_ROUTINE CdRomMediaChangeCompletion;
NTSTATUS
-STDCALL
+NTAPI
CdRomMediaChangeCompletion(
PDEVICE_OBJECT DeviceObject,
PIRP Irp,
}
VOID
-STDCALL
+NTAPI
CdRomTickHandler(
IN PDEVICE_OBJECT DeviceObject,
IN PVOID Context
}
BOOLEAN
-STDCALL
+NTAPI
CdRomCheckRegistryForMediaChangeValue(
IN PUNICODE_STRING RegistryPath,
IN ULONG DeviceNumber
BOOLEAN
-STDCALL
+NTAPI
IsThisASanyo(
IN PDEVICE_OBJECT DeviceObject,
IN UCHAR PathId,
}
BOOLEAN
-STDCALL
+NTAPI
IsThisAnAtapiChanger(
IN PDEVICE_OBJECT DeviceObject,
OUT PULONG DiscsPresent
}
BOOLEAN
-STDCALL
+NTAPI
IsThisAMultiLunDevice(
IN PDEVICE_OBJECT DeviceObject,
IN PDEVICE_OBJECT PortDeviceObject
IO_COMPLETION_ROUTINE CdRomUpdateGeometryCompletion;
NTSTATUS
-STDCALL
+NTAPI
CdRomUpdateGeometryCompletion(
PDEVICE_OBJECT DeviceObject,
PIRP Irp,
}
NTSTATUS
-STDCALL
+NTAPI
CdRomUpdateCapacity(
IN PDEVICE_EXTENSION DeviceExtension,
IN PIRP IrpToComplete,
}
NTSTATUS
-STDCALL
+NTAPI
CdRomClassIoctlCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
#include <debug.h>\r
\r
NTSTATUS\r
-STDCALL\r
+NTAPI\r
FindScsiAdapter (\r
IN HANDLE KeyHandle,\r
IN UNICODE_STRING ScsiUnicodeString[],\r
\r
\f\r
NTSTATUS\r
-STDCALL\r
+NTAPI\r
FindScsiAdapter (\r
IN HANDLE KeyHandle,\r
IN UNICODE_STRING ScsiUnicodeString[],\r
#define START_UNIT_TIMEOUT 30
NTSTATUS
-STDCALL
+NTAPI
ScsiClassCreateClose(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
NTSTATUS
-STDCALL
+NTAPI
ScsiClassReadWrite(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
NTSTATUS
-STDCALL
+NTAPI
ScsiClassDeviceControlDispatch(
PDEVICE_OBJECT DeviceObject,
PIRP Irp
);
NTSTATUS
-STDCALL
+NTAPI
ScsiClassDeviceControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp
);
NTSTATUS
-STDCALL
+NTAPI
ScsiClassInternalIoControl (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
NTSTATUS
-STDCALL
+NTAPI
ScsiClassShutdownFlush(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
NTSTATUS
-STDCALL
+NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
VOID
-STDCALL
+NTAPI
RetryRequest(
PDEVICE_OBJECT DeviceObject,
PIRP Irp,
);
VOID
-STDCALL
+NTAPI
StartUnit(
IN PDEVICE_OBJECT DeviceObject
);
NTSTATUS
-STDCALL
+NTAPI
ClassIoCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
);
NTSTATUS
-STDCALL
+NTAPI
ClassCompletionRoutine(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Context);
NTSTATUS
-STDCALL
+NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
\f
ULONG
-STDCALL
+NTAPI
ScsiClassInitialize(
IN PVOID Argument1,
IN PVOID Argument2,
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiClassCreateClose(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiClassReadWrite(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiClassGetCapabilities(
IN PDEVICE_OBJECT PortDeviceObject,
OUT PIO_SCSI_CAPABILITIES *PortCapabilities
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiClassGetInquiryData(
IN PDEVICE_OBJECT PortDeviceObject,
OUT PSCSI_ADAPTER_BUS_INFO *ConfigInfo
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiClassReadDriveCapacity(
IN PDEVICE_OBJECT DeviceObject
)
\f
VOID
-STDCALL
+NTAPI
ScsiClassReleaseQueue(
IN PDEVICE_OBJECT DeviceObject
)
\f
VOID
-STDCALL
+NTAPI
StartUnit(
IN PDEVICE_OBJECT DeviceObject
)
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiClassAsynchronousCompletion(
PDEVICE_OBJECT DeviceObject,
PIRP Irp,
\f
VOID
-STDCALL
+NTAPI
ScsiClassSplitRequest(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiClassIoComplete(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiClassIoCompleteAssociated(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiClassSendSrbSynchronous(
PDEVICE_OBJECT DeviceObject,
PSCSI_REQUEST_BLOCK Srb,
\f
BOOLEAN
-STDCALL
+NTAPI
ScsiClassInterpretSenseInfo(
IN PDEVICE_OBJECT DeviceObject,
IN PSCSI_REQUEST_BLOCK Srb,
\f
VOID
-STDCALL
+NTAPI
RetryRequest(
PDEVICE_OBJECT DeviceObject,
PIRP Irp,
} // end RetryRequest()
\f
VOID
-STDCALL
+NTAPI
ScsiClassBuildRequest(
PDEVICE_OBJECT DeviceObject,
PIRP Irp
} // end ScsiClassBuildRequest()
\f
ULONG
-STDCALL
+NTAPI
ScsiClassModeSense(
IN PDEVICE_OBJECT DeviceObject,
IN PCHAR ModeSenseBuffer,
\f
PVOID
-STDCALL
+NTAPI
ScsiClassFindModePage(
IN PCHAR ModeSenseBuffer,
IN ULONG Length,
}
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiClassSendSrbAsynchronous(
PDEVICE_OBJECT DeviceObject,
PSCSI_REQUEST_BLOCK Srb,
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiClassDeviceControlDispatch(
PDEVICE_OBJECT DeviceObject,
PIRP Irp
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiClassDeviceControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiClassShutdownFlush(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
\f
ULONG
-STDCALL
+NTAPI
ScsiClassFindUnclaimedDevices(
IN PCLASS_INIT_DATA InitializationData,
IN PSCSI_ADAPTER_BUS_INFO AdapterInformation
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiClassCreateDeviceObject(
IN PDRIVER_OBJECT DriverObject,
IN PCCHAR ObjectNameBuffer,
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiClassClaimDevice(
IN PDEVICE_OBJECT PortDeviceObject,
IN PSCSI_INQUIRY_DATA LunInfo,
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiClassInternalIoControl (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
}
\f
NTSTATUS
-STDCALL
+NTAPI
ClassIoCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
\f
VOID
-STDCALL
+NTAPI
ScsiClassInitializeSrbLookasideList(
IN PDEVICE_EXTENSION DeviceExtension,
IN ULONG NumberElements
\f
ULONG
-STDCALL
+NTAPI
ScsiClassQueryTimeOutRegistryValue(
IN PUNICODE_STRING RegistryPath
)
}
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiClassCheckVerifyComplete(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
}
NTSTATUS
-STDCALL
+NTAPI
ClassCompletionRoutine(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Context)
\f
NTSTATUS
-STDCALL
+NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
);
BOOLEAN
-STDCALL
+NTAPI
ScsiDiskDeviceVerification(
IN PINQUIRYDATA InquiryData
);
BOOLEAN
-STDCALL
+NTAPI
FindScsiDisks(
IN PDRIVER_OBJECT DriveObject,
IN PUNICODE_STRING RegistryPath,
);
NTSTATUS
-STDCALL
+NTAPI
ScsiDiskCreateClose (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
NTSTATUS
-STDCALL
+NTAPI
ScsiDiskReadWriteVerification(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
NTSTATUS
-STDCALL
+NTAPI
ScsiDiskDeviceControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
VOID
-STDCALL
+NTAPI
ScsiDiskProcessError(
PDEVICE_OBJECT DeviceObject,
PSCSI_REQUEST_BLOCK Srb,
);
NTSTATUS
-STDCALL
+NTAPI
ScsiDiskShutdownFlush(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
VOID
-STDCALL
+NTAPI
DisableWriteCache(
IN PDEVICE_OBJECT DeviceObject,
IN PSCSI_INQUIRY_DATA LunInfo
);
BOOLEAN
-STDCALL
+NTAPI
ScsiDiskModeSelect(
IN PDEVICE_OBJECT DeviceObject,
IN PCHAR ModeSelectBuffer,
);
BOOLEAN
-STDCALL
+NTAPI
IsFloppyDevice(
IN PDEVICE_OBJECT DeviceObject
);
BOOLEAN
-STDCALL
+NTAPI
CalculateMbrCheckSum(
IN PDEVICE_EXTENSION DeviceExtension,
OUT PULONG Checksum
);
BOOLEAN
-STDCALL
+NTAPI
EnumerateBusKey(
IN PDEVICE_EXTENSION DeviceExtension,
HANDLE BusKey,
);
VOID
-STDCALL
+NTAPI
UpdateGeometry(
IN PDEVICE_EXTENSION DeviceExtension
);
NTSTATUS
-STDCALL
+NTAPI
UpdateRemovableGeometry (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
NTSTATUS
-STDCALL
+NTAPI
CreateDiskDeviceObject(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath,
);
NTSTATUS
-STDCALL
+NTAPI
CreatePartitionDeviceObjects(
IN PDEVICE_OBJECT PhysicalDeviceObject,
IN PUNICODE_STRING RegistryPath
);
VOID
-STDCALL
+NTAPI
UpdateDeviceObjects(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
VOID
-STDCALL
+NTAPI
ScanForSpecial(
PDEVICE_OBJECT DeviceObject,
PSCSI_INQUIRY_DATA LunInfo,
);
VOID
-STDCALL
+NTAPI
ResetScsiBus(
IN PDEVICE_OBJECT DeviceObject
);
\f
NTSTATUS
-STDCALL
+NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
\f
BOOLEAN
-STDCALL
+NTAPI
ScsiDiskDeviceVerification(
IN PINQUIRYDATA InquiryData
)
\f
BOOLEAN
-STDCALL
+NTAPI
FindScsiDisks(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath,
\f
NTSTATUS
-STDCALL
+NTAPI
CreateDiskDeviceObject(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath,
\f
NTSTATUS
-STDCALL
+NTAPI
CreatePartitionDeviceObjects(
IN PDEVICE_OBJECT PhysicalDeviceObject,
IN PUNICODE_STRING RegistryPath
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiDiskReadWriteVerification(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiDiskDeviceControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp
} // end ScsiDiskDeviceControl()
\f
NTSTATUS
-STDCALL
+NTAPI
ScsiDiskShutdownFlush (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
\f
BOOLEAN
-STDCALL
+NTAPI
IsFloppyDevice(
PDEVICE_OBJECT DeviceObject
)
\f
BOOLEAN
-STDCALL
+NTAPI
ScsiDiskModeSelect(
IN PDEVICE_OBJECT DeviceObject,
IN PCHAR ModeSelectBuffer,
\f
VOID
-STDCALL
+NTAPI
DisableWriteCache(
IN PDEVICE_OBJECT DeviceObject,
IN PSCSI_INQUIRY_DATA LunInfo
\f
BOOLEAN
-STDCALL
+NTAPI
CalculateMbrCheckSum(
IN PDEVICE_EXTENSION DeviceExtension,
OUT PULONG Checksum
\f
BOOLEAN
-STDCALL
+NTAPI
EnumerateBusKey(
IN PDEVICE_EXTENSION DeviceExtension,
HANDLE BusKey,
\f
VOID
-STDCALL
+NTAPI
UpdateGeometry(
IN PDEVICE_EXTENSION DeviceExtension
)
\f
NTSTATUS
-STDCALL
+NTAPI
UpdateRemovableGeometry (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
\f
VOID
-STDCALL
+NTAPI
ScsiDiskProcessError(
PDEVICE_OBJECT DeviceObject,
PSCSI_REQUEST_BLOCK Srb,
}
\f
VOID
-STDCALL
+NTAPI
ScanForSpecial(
PDEVICE_OBJECT DeviceObject,
PSCSI_INQUIRY_DATA LunInfo,
}
\f
VOID
-STDCALL
+NTAPI
ResetScsiBus(
IN PDEVICE_OBJECT DeviceObject
)
\f
VOID
-STDCALL
+NTAPI
UpdateDeviceObjects(
IN PDEVICE_OBJECT PhysicalDisk,
IN PIRP Irp
struct _CLASS_INIT_DATA;
typedef VOID
-(STDCALL *PCLASS_ERROR)(IN PDEVICE_OBJECT DeviceObject,
+(NTAPI *PCLASS_ERROR)(IN PDEVICE_OBJECT DeviceObject,
IN PSCSI_REQUEST_BLOCK Srb,
IN OUT NTSTATUS *Status,
IN OUT BOOLEAN *Retry);
typedef BOOLEAN
-(STDCALL *PCLASS_DEVICE_CALLBACK)(IN PINQUIRYDATA);
+(NTAPI *PCLASS_DEVICE_CALLBACK)(IN PINQUIRYDATA);
typedef NTSTATUS
-(STDCALL *PCLASS_READ_WRITE)(IN PDEVICE_OBJECT DeviceObject,
+(NTAPI *PCLASS_READ_WRITE)(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
typedef BOOLEAN
-(STDCALL *PCLASS_FIND_DEVICES)(IN PDRIVER_OBJECT DriverObject,
+(NTAPI *PCLASS_FIND_DEVICES)(IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath,
IN struct _CLASS_INIT_DATA *InitializationData,
IN PDEVICE_OBJECT PortDeviceObject,
IN ULONG PortNumber);
typedef NTSTATUS
-(STDCALL *PCLASS_DEVICE_CONTROL)(IN PDEVICE_OBJECT DeviceObject,
+(NTAPI *PCLASS_DEVICE_CONTROL)(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
typedef NTSTATUS
-(STDCALL *PCLASS_SHUTDOWN_FLUSH)(IN PDEVICE_OBJECT DeviceObject,
+(NTAPI *PCLASS_SHUTDOWN_FLUSH)(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
typedef NTSTATUS
-(STDCALL *PCLASS_CREATE_CLOSE)(IN PDEVICE_OBJECT DeviceObject,
+(NTAPI *PCLASS_CREATE_CLOSE)(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
/* FUNCTIONS ****************************************************************/
IO_COMPLETION_ROUTINE ScsiClassAsynchronousCompletion;
-NTSTATUS STDCALL
+NTSTATUS NTAPI
ScsiClassAsynchronousCompletion(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Context);
-VOID STDCALL
+VOID NTAPI
ScsiClassBuildRequest(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
ScsiClassClaimDevice(IN PDEVICE_OBJECT PortDeviceObject,
IN PSCSI_INQUIRY_DATA LunInfo,
IN BOOLEAN Release,
OUT PDEVICE_OBJECT *NewPortDeviceObject OPTIONAL);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
ScsiClassCreateDeviceObject(IN PDRIVER_OBJECT DriverObject,
IN PCCHAR ObjectNameBuffer,
IN PDEVICE_OBJECT PhysicalDeviceObject OPTIONAL,
IN OUT PDEVICE_OBJECT *DeviceObject,
IN PCLASS_INIT_DATA InitializationData);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
ScsiClassDeviceControl(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
-PVOID STDCALL
+PVOID NTAPI
ScsiClassFindModePage(IN PCHAR ModeSenseBuffer,
IN ULONG Length,
IN UCHAR PageMode,
IN BOOLEAN Use6Byte);
-ULONG STDCALL
+ULONG NTAPI
ScsiClassFindUnclaimedDevices(IN PCLASS_INIT_DATA InitializationData,
OUT PSCSI_ADAPTER_BUS_INFO AdapterInformation);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
ScsiClassGetCapabilities(IN PDEVICE_OBJECT PortDeviceObject,
OUT PIO_SCSI_CAPABILITIES *PortCapabilities);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
ScsiClassGetInquiryData(IN PDEVICE_OBJECT PortDeviceObject,
OUT PSCSI_ADAPTER_BUS_INFO *ConfigInfo);
-ULONG STDCALL
+ULONG NTAPI
ScsiClassInitialize(IN PVOID Argument1,
IN PVOID Argument2,
IN PCLASS_INIT_DATA InitializationData);
-VOID STDCALL
+VOID NTAPI
ScsiClassInitializeSrbLookasideList(IN PDEVICE_EXTENSION DeviceExtension,
IN ULONG NumberElements);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
ScsiClassInternalIoControl(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
-BOOLEAN STDCALL
+BOOLEAN NTAPI
ScsiClassInterpretSenseInfo(IN PDEVICE_OBJECT DeviceObject,
IN PSCSI_REQUEST_BLOCK Srb,
IN UCHAR MajorFunctionCode,
IN ULONG RetryCount,
OUT NTSTATUS *Status);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
ScsiClassIoComplete(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Context);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
ScsiClassIoCompleteAssociated(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Context);
-ULONG STDCALL
+ULONG NTAPI
ScsiClassModeSense(IN PDEVICE_OBJECT DeviceObject,
IN PCHAR ModeSenseBuffer,
IN ULONG Length,
IN UCHAR PageMode);
-ULONG STDCALL
+ULONG NTAPI
ScsiClassQueryTimeOutRegistryValue(IN PUNICODE_STRING RegistryPath);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
ScsiClassReadDriveCapacity(IN PDEVICE_OBJECT DeviceObject);
-VOID STDCALL
+VOID NTAPI
ScsiClassReleaseQueue(IN PDEVICE_OBJECT DeviceObject);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
ScsiClassSendSrbAsynchronous(PDEVICE_OBJECT DeviceObject,
PSCSI_REQUEST_BLOCK Srb,
PIRP Irp,
ULONG BufferLength,
BOOLEAN WriteToDevice);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
ScsiClassSendSrbSynchronous(PDEVICE_OBJECT DeviceObject,
PSCSI_REQUEST_BLOCK Srb,
PVOID BufferAddress,
ULONG BufferLength,
BOOLEAN WriteToDevice);
-VOID STDCALL
+VOID NTAPI
ScsiClassSplitRequest(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN ULONG MaximumBytes);
NTSTATUS
-STDCALL
+NTAPI
ScsiClassCheckVerifyComplete(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
} HW_LU_EXTENSION, *PHW_LU_EXTENSION;
PSCSI_REQUEST_BLOCK
-STDCALL
+NTAPI
BuildMechanismStatusSrb (
IN PVOID HwDeviceExtension,
IN ULONG PathId,
);
PSCSI_REQUEST_BLOCK
-STDCALL
+NTAPI
BuildRequestSenseSrb (
IN PVOID HwDeviceExtension,
IN ULONG PathId,
);
VOID
-STDCALL
+NTAPI
AtapiHwInitializeChanger (
IN PVOID HwDeviceExtension,
IN ULONG TargetId,
);
ULONG
-STDCALL
+NTAPI
AtapiSendCommand(
IN PVOID HwDeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb
);
VOID
-STDCALL
+NTAPI
AtapiZeroMemory(
IN PUCHAR Buffer,
IN ULONG Count
);
VOID
-STDCALL
+NTAPI
AtapiHexToString (
ULONG Value,
PCHAR *Buffer
);
LONG
-STDCALL
+NTAPI
AtapiStringCmp (
PCHAR FirstStr,
PCHAR SecondStr,
);
BOOLEAN
-STDCALL
+NTAPI
AtapiInterrupt(
IN PVOID HwDeviceExtension
);
BOOLEAN
-STDCALL
+NTAPI
AtapiHwInitialize(
IN PVOID HwDeviceExtension
);
ULONG
-STDCALL
+NTAPI
IdeBuildSenseBuffer(
IN PVOID HwDeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb
);
VOID
-STDCALL
+NTAPI
IdeMediaStatus(
IN BOOLEAN EnableMSN,
IN PVOID HwDeviceExtension,
\f
BOOLEAN
-STDCALL
+NTAPI
IssueIdentify(
IN PVOID HwDeviceExtension,
IN ULONG DeviceNumber,
\f
BOOLEAN
-STDCALL
+NTAPI
SetDriveParameters(
IN PVOID HwDeviceExtension,
IN ULONG DeviceNumber,
\f
BOOLEAN
-STDCALL
+NTAPI
AtapiResetController(
IN PVOID HwDeviceExtension,
IN ULONG PathId
\f
ULONG
-STDCALL
+NTAPI
MapError(
IN PVOID HwDeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb
BOOLEAN
-STDCALL
+NTAPI
AtapiHwInitialize(
IN PVOID HwDeviceExtension
)
VOID
-STDCALL
+NTAPI
AtapiHwInitializeChanger (
IN PVOID HwDeviceExtension,
IN ULONG TargetId,
\f
BOOLEAN
-STDCALL
+NTAPI
FindDevices(
IN PVOID HwDeviceExtension,
IN BOOLEAN AtapiOnly,
\f
ULONG
-STDCALL
+NTAPI
AtapiParseArgumentString(
IN PCHAR String,
IN PCHAR KeyWord
\f
ULONG
-STDCALL
+NTAPI
AtapiFindController(
IN PVOID HwDeviceExtension,
IN PVOID Context,
\f
BOOLEAN
-STDCALL
+NTAPI
FindBrokenController(
IN PVOID DeviceExtension,
IN PUCHAR VendorID,
\f
ULONG
-STDCALL
+NTAPI
AtapiFindNativeModeController(
IN PVOID HwDeviceExtension,
IN PVOID Context,
\f
ULONG
-STDCALL
+NTAPI
AtapiFindPCIController(
IN PVOID HwDeviceExtension,
IN PVOID Context,
\f
ULONG
-STDCALL
+NTAPI
Atapi2Scsi(
IN PSCSI_REQUEST_BLOCK Srb,
IN char *DataBuffer,
\f
VOID
-STDCALL
+NTAPI
AtapiCallBack(
IN PVOID HwDeviceExtension
)
\f
BOOLEAN
-STDCALL
+NTAPI
AtapiInterrupt(
IN PVOID HwDeviceExtension
)
\f
ULONG
-STDCALL
+NTAPI
IdeSendSmartCommand(
IN PVOID HwDeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb
\f
ULONG
-STDCALL
+NTAPI
IdeReadWrite(
IN PVOID HwDeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb
\f
ULONG
-STDCALL
+NTAPI
IdeVerify(
IN PVOID HwDeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb
\f
VOID
-STDCALL
+NTAPI
Scsi2Atapi(
IN PSCSI_REQUEST_BLOCK Srb
)
\f
ULONG
-STDCALL
+NTAPI
AtapiSendCommand(
IN PVOID HwDeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb
} // end AtapiSendCommand()
ULONG
-STDCALL
+NTAPI
IdeSendCommand(
IN PVOID HwDeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb
} // end IdeSendCommand()
VOID
-STDCALL
+NTAPI
IdeMediaStatus(
BOOLEAN EnableMSN,
IN PVOID HwDeviceExtension,
}
ULONG
-STDCALL
+NTAPI
IdeBuildSenseBuffer(
IN PVOID HwDeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb
\f
BOOLEAN
-STDCALL
+NTAPI
AtapiStartIo(
IN PVOID HwDeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb
\f
ULONG
-STDCALL
+NTAPI
DriverEntry(
IN PVOID DriverObject,
IN PVOID Argument2
\f
LONG
-STDCALL
+NTAPI
AtapiStringCmp (
PCHAR FirstStr,
PCHAR SecondStr,
\f
VOID
-STDCALL
+NTAPI
AtapiZeroMemory(
IN PUCHAR Buffer,
IN ULONG Count
\f
VOID
-STDCALL
+NTAPI
AtapiHexToString (
IN ULONG Value,
IN OUT PCHAR *Buffer
\f
PSCSI_REQUEST_BLOCK
-STDCALL
+NTAPI
BuildMechanismStatusSrb (
IN PVOID HwDeviceExtension,
IN ULONG PathId,
\f
PSCSI_REQUEST_BLOCK
-STDCALL
+NTAPI
BuildRequestSenseSrb (
IN PVOID HwDeviceExtension,
IN ULONG PathId,
#include "BusLogic958.h"
ULONG
-STDCALL
+NTAPI
DriverEntry(IN PVOID DriverObject,
IN PVOID Argument2
)
ULONG
-STDCALL
+NTAPI
BT958HwFindAdapter(IN PVOID HwDeviceExtension,
IN PVOID Context,
IN PVOID BusInformation,
}
BOOLEAN
-STDCALL
+NTAPI
BT958HwStartIO(IN PVOID HwDeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb
)
BOOLEAN
-STDCALL
+NTAPI
BT958HwInterrupt(IN PVOID HwDeviceExtension)
//_________________________________________________________________________
// Routine Description:
BOOLEAN
-STDCALL
+NTAPI
BT958HwResetBus(IN PVOID HwDeviceExtension,
IN ULONG PathId)
//_____________________________________________________________________________________
}
BOOLEAN
-STDCALL
+NTAPI
BT958HwInitialize(IN PVOID HwDeviceExtension)
//_______________________________________________________________________________
// Routine Description:
}// end BT958HwInitialize
SCSI_ADAPTER_CONTROL_STATUS
-STDCALL
+NTAPI
BT958HwAdapterControl(IN PVOID HwDeviceExtension,
IN SCSI_ADAPTER_CONTROL_TYPE ControlType,
IN PVOID Parameters)
// function declaractions
//_________________________________________________________________________________________
ULONG
-STDCALL
+NTAPI
DriverEntry(IN PVOID DriverObject,
IN PVOID Argument2
);
ULONG
-STDCALL
+NTAPI
BT958HwFindAdapter(IN PVOID HwDeviceExtension,
IN PVOID Context,
IN PVOID BusInformation,
);
BOOLEAN
-STDCALL
+NTAPI
BT958HwInitialize(IN PVOID HwDeviceExtension);
BOOLEAN
-STDCALL
+NTAPI
BT958HwStartIO(IN PVOID HwDeviceExtension,
IN PSCSI_REQUEST_BLOCK Srb
);
BOOLEAN
-STDCALL
+NTAPI
BT958HwInterrupt(IN PVOID HwDeviceExtension);
BOOLEAN
-STDCALL
+NTAPI
BT958HwResetBus(IN PVOID HwDeviceExtension,
IN ULONG PathId
);
SCSI_ADAPTER_CONTROL_STATUS
-STDCALL
+NTAPI
BT958HwAdapterControl(IN PVOID HwDeviceExtension,
IN SCSI_ADAPTER_CONTROL_TYPE ControlType,
IN PVOID Parameters
#undef KeGetCurrentIrql
/* PROTOTYPES ***************************************************************/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DiskDumpPrepare(PDEVICE_OBJECT DeviceObject, PDUMP_POINTERS DumpPointers);
VOID
DiskDumpScsiInvalid(VOID);
_DiskDumpScsiPortNotification(IN SCSI_NOTIFICATION_TYPE NotificationType,
IN PVOID HwDeviceExtension,
...);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DiskDumpInit(VOID);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DiskDumpFinish(VOID);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DiskDumpWrite(LARGE_INTEGER StartAddress, PMDL Mdl);
typedef VOID (*SCSIPORTNOTIFICATION)(IN SCSI_NOTIFICATION_TYPE NotificationType,
KeBugCheck(0);
}
-VOID STDCALL
+VOID NTAPI
DiskDumpBuildRequest(LARGE_INTEGER StartingOffset, PMDL Mdl)
{
LARGE_INTEGER StartingBlock;
/* Leave caching disabled. */
}
-BOOLEAN STDCALL
+BOOLEAN NTAPI
DiskDumpIsr(PKINTERRUPT Interrupt, PVOID ServiceContext)
{
if (!CoreDumpPortDeviceExtension->HwInterrupt(&CoreDumpPortDeviceExtension->MiniPortDeviceExtension))
return(TRUE);
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DiskDumpInit(VOID)
{
KIRQL CurrentIrql = KeGetCurrentIrql();
return(STATUS_SUCCESS);
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DiskDumpFinish(VOID)
{
return(STATUS_SUCCESS);
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DiskDumpWrite(LARGE_INTEGER Address, PMDL Mdl)
{
KIRQL OldIrql = 0, OldIrql2 = 0;
return(STATUS_SUCCESS);
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DiskDumpPrepare(PDEVICE_OBJECT DeviceObject, PDUMP_POINTERS DumpPointers)
{
PIMAGE_NT_HEADERS NtHeader;
* Status
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry(IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
#include <windows.h>
#include <usbdi.h>
-typedef ULONG STDCALL
+typedef ULONG NTAPI
(*USBD_GetInterfaceLengthTYPE)(
PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor,
PUCHAR BufferEnd
PUSBD_INTERFACE_INFORMATION Interface;
} USBD_INTERFACE_LIST_ENTRY, *PUSBD_INTERFACE_LIST_ENTRY;
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath)
{
/*
* @implemented
*/
-DWORD STDCALL
+DWORD NTAPI
DllInitialize(DWORD Unknown)
{
return 0;
/*
* @implemented
*/
-DWORD STDCALL
+DWORD NTAPI
DllUnload(VOID)
{
return 0;
/*
* @implemented
*/
-PVOID STDCALL
+PVOID NTAPI
USBD_Debug_GetHeap(DWORD Unknown1, POOL_TYPE PoolType, ULONG NumberOfBytes,
ULONG Tag)
{
/*
* @implemented
*/
-VOID STDCALL
+VOID NTAPI
USBD_Debug_RetHeap(PVOID Heap, DWORD Unknown2, DWORD Unknown3)
{
ExFreePool(Heap);
/*
* @implemented
*/
-VOID STDCALL
+VOID NTAPI
USBD_Debug_LogEntry(PCHAR Name, ULONG_PTR Info1, ULONG_PTR Info2,
ULONG_PTR Info3)
{
/*
* @implemented
*/
-PVOID STDCALL
+PVOID NTAPI
USBD_AllocateDeviceName(DWORD Unknown)
{
return NULL;
/*
* @implemented
*/
-DWORD STDCALL
+DWORD NTAPI
USBD_CalculateUsbBandwidth(
ULONG MaxPacketSize,
UCHAR EndpointType,
/*
* @implemented
*/
-DWORD STDCALL
+DWORD NTAPI
USBD_Dispatch(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3, DWORD Unknown4)
{
return 1;
/*
* @implemented
*/
-VOID STDCALL
+VOID NTAPI
USBD_FreeDeviceMutex(PVOID Unknown)
{
}
/*
* @implemented
*/
-VOID STDCALL
+VOID NTAPI
USBD_FreeDeviceName(PVOID Unknown)
{
}
/*
* @implemented
*/
-VOID STDCALL
+VOID NTAPI
USBD_WaitDeviceMutex(PVOID Unknown)
{
}
/*
* @implemented
*/
-DWORD STDCALL
+DWORD NTAPI
USBD_GetSuspendPowerState(DWORD Unknown1)
{
return 0;
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
USBD_InitializeDevice(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3,
DWORD Unknown4, DWORD Unknown5, DWORD Unknown6)
{
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
USBD_RegisterHostController(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3,
DWORD Unknown4, DWORD Unknown5, DWORD Unknown6, DWORD Unknown7,
DWORD Unknown8, DWORD Unknown9, DWORD Unknown10)
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
USBD_GetDeviceInformation(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3)
{
return STATUS_NOT_SUPPORTED;
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
USBD_CreateDevice(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3,
DWORD Unknown4, DWORD Unknown5)
{
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
USBD_RemoveDevice(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3)
{
return STATUS_NOT_SUPPORTED;
/*
* @implemented
*/
-VOID STDCALL
+VOID NTAPI
USBD_CompleteRequest(DWORD Unknown1, DWORD Unknown2)
{
}
/*
* @implemented
*/
-VOID STDCALL
+VOID NTAPI
USBD_RegisterHcFilter(
PDEVICE_OBJECT DeviceObject,
PDEVICE_OBJECT FilterDeviceObject
/*
* @implemented
*/
-VOID STDCALL
+VOID NTAPI
USBD_SetSuspendPowerState(DWORD Unknown1, DWORD Unknown2)
{
}
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
USBD_MakePdoName(DWORD Unknown1, DWORD Unknown2)
{
return STATUS_NOT_SUPPORTED;
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
USBD_QueryBusTime(
PDEVICE_OBJECT RootHubPdo,
PULONG CurrentFrame
/*
* @implemented
*/
-VOID STDCALL
+VOID NTAPI
USBD_GetUSBDIVersion(
PUSBD_VERSION_INFORMATION Version
)
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
USBD_RestoreDevice(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3)
{
return STATUS_NOT_SUPPORTED;
/*
* @implemented
*/
-VOID STDCALL
+VOID NTAPI
USBD_RegisterHcDeviceCapabilities(DWORD Unknown1, DWORD Unknown2,
DWORD Unknown3)
{
* FIXME: Test
*/
PURB
-STDCALL
+NTAPI
USBD_CreateConfigurationRequestEx(
PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor,
PUSBD_INTERFACE_LIST_ENTRY InterfaceList
/*
* @unimplemented
*/
-PURB STDCALL
+PURB NTAPI
USBD_CreateConfigurationRequest(
PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor,
PUSHORT Size
/*
* @unimplemented
*/
-ULONG STDCALL
+ULONG NTAPI
USBD_GetInterfaceLength(
PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor,
PUCHAR BufferEnd
/*
* @implemented
*/
-PUSB_COMMON_DESCRIPTOR STDCALL
+PUSB_COMMON_DESCRIPTOR NTAPI
USBD_ParseDescriptors(
PVOID DescriptorBuffer,
ULONG TotalLength,
/*
* @implemented
*/
-PUSB_INTERFACE_DESCRIPTOR STDCALL
+PUSB_INTERFACE_DESCRIPTOR NTAPI
USBD_ParseConfigurationDescriptorEx(
PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor,
PVOID StartPosition,
/*
* @implemented
*/
-PUSB_INTERFACE_DESCRIPTOR STDCALL
+PUSB_INTERFACE_DESCRIPTOR NTAPI
USBD_ParseConfigurationDescriptor(
PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor,
UCHAR InterfaceNumber,
/*
* @implemented
*/
-DWORD STDCALL
+DWORD NTAPI
USBD_GetPdoRegistryParameter(
PDEVICE_OBJECT PhysicalDeviceObject,
PVOID Parameter,
#define NDEBUG
#include "usbhub.h"
-NTSTATUS STDCALL
+NTSTATUS NTAPI
UsbhubCreate(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
return STATUS_SUCCESS;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
UsbhubClose(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
return STATUS_SUCCESS;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
UsbhubCleanup(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
return Status;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
UsbhubPnpFdo(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
#include "usbhub.h"
#include <stdarg.h>
-NTSTATUS STDCALL
+NTSTATUS NTAPI
ForwardIrpAndWaitCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
return Status;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
ForwardIrpAndForget(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
}
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
UsbhubPnpPdo(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
return Status;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
UsbhubAddDevice(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT Pdo)
return STATUS_SUCCESS;
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
IrpStub(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
return Status;
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
DispatchDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
if (((PHUB_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsFDO)
return IrpStub(DeviceObject, Irp);
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
DispatchInternalDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
if (((PHUB_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsFDO)
return UsbhubInternalDeviceControlPdo(DeviceObject, Irp);
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
DispatchPnp(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
if (((PHUB_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsFDO)
/*
* Standard DriverEntry method.
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
} HUB_DEVICE_EXTENSION, *PHUB_DEVICE_EXTENSION;
/* createclose.c */
-NTSTATUS STDCALL
+NTSTATUS NTAPI
UsbhubCreate(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
UsbhubClose(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
UsbhubCleanup(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
/* fdo.c */
-NTSTATUS STDCALL
+NTSTATUS NTAPI
UsbhubPnpFdo(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
ForwardIrpAndForget(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
... /* list of PCSZ */);
/* pdo.c */
-NTSTATUS STDCALL
+NTSTATUS NTAPI
UsbhubPnpPdo(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
/* PUBLIC AND PRIVATE FUNCTIONS **********************************************/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
IrpStub(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
return Status;
}
-NTSTATUS STDCALL
+NTSTATUS NTAPI
AddDevice(IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT pdo)
{
return STATUS_SUCCESS;
}
-VOID STDCALL
+VOID NTAPI
DriverUnload(PDRIVER_OBJECT DriverObject)
{
}
-VOID STDCALL
+VOID NTAPI
StartIo(PUSBSTOR_DEVICE_EXTENSION DeviceExtension,
PIRP Irp)
{
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
DispatchClose(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
Irp->IoStatus.Information = 0;
return STATUS_SUCCESS;
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
DispatchCleanup(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
return STATUS_SUCCESS;
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
DispatchDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
return STATUS_SUCCESS;
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
DispatchScsi(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
return STATUS_SUCCESS;
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
DispatchReadWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
return STATUS_SUCCESS;
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
DispatchSystemControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
return STATUS_SUCCESS;
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
DispatchPnp(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
return STATUS_SUCCESS;
}
-static NTSTATUS STDCALL
+static NTSTATUS NTAPI
DispatchPower(PDEVICE_OBJECT fido, PIRP Irp)
{
DPRINT1("USBSTOR: IRP_MJ_POWER unimplemented\n");
/*
* Standard DriverEntry method.
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegPath)
{
ULONG i;
#define USB_STOR_TAG TAG('u','s','b','s')
#define USB_MAXCHILDREN (16)
-NTSTATUS STDCALL
+NTSTATUS NTAPI
IoAttachDeviceToDeviceStackSafe(
IN PDEVICE_OBJECT SourceDevice,
IN PDEVICE_OBJECT TargetDevice,
/* cleanup.c */
-NTSTATUS STDCALL
+NTSTATUS NTAPI
UsbStorCleanup(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
/* fdo.c */
-NTSTATUS STDCALL
+NTSTATUS NTAPI
UsbStorPnpFdo(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
-NTSTATUS STDCALL
+NTSTATUS NTAPI
ForwardIrpAndForget(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
... /* list of PCSZ */);
/* pdo.c */
-NTSTATUS STDCALL
+NTSTATUS NTAPI
UsbStorPnpPdo(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
/* PUBLIC AND PRIVATE FUNCTIONS ***********************************************/
-VP_STATUS STDCALL
+VP_STATUS NTAPI
DriverEntry(IN PVOID Context1, IN PVOID Context2)
{
VIDEO_HW_INITIALIZATION_DATA InitData;
* so we always return NO_ERROR and do the real work in VBEInitialize.
*/
-VP_STATUS STDCALL
+VP_STATUS NTAPI
VBEFindAdapter(
IN PVOID HwDeviceExtension,
IN PVOID HwContext,
* the VBE.
*/
-BOOLEAN STDCALL
+BOOLEAN NTAPI
VBEInitialize(PVOID HwDeviceExtension)
{
INT10_BIOS_ARGUMENTS BiosRegisters;
* Processes the specified Video Request Packet.
*/
-BOOLEAN STDCALL
+BOOLEAN NTAPI
VBEStartIO(
PVOID HwDeviceExtension,
PVIDEO_REQUEST_PACKET RequestPacket)
* This function is called to reset the hardware to a known state.
*/
-BOOLEAN STDCALL
+BOOLEAN NTAPI
VBEResetHw(
PVOID DeviceExtension,
ULONG Columns,
* Queries whether the device can support the requested power state.
*/
-VP_STATUS STDCALL
+VP_STATUS NTAPI
VBEGetPowerState(
PVOID HwDeviceExtension,
ULONG HwId,
* Sets the power state of the specified device
*/
-VP_STATUS STDCALL
+VP_STATUS NTAPI
VBESetPowerState(
PVOID HwDeviceExtension,
ULONG HwId,
OUT PULONG pUnused);
/* vbemp.c */
-VP_STATUS STDCALL
+VP_STATUS NTAPI
VBEFindAdapter(
IN PVOID HwDeviceExtension,
IN PVOID HwContext,
IN OUT PVIDEO_PORT_CONFIG_INFO ConfigInfo,
OUT PUCHAR Again);
-BOOLEAN STDCALL
+BOOLEAN NTAPI
VBEInitialize(PVOID HwDeviceExtension);
-BOOLEAN STDCALL
+BOOLEAN NTAPI
VBEStartIO(
PVOID HwDeviceExtension,
PVIDEO_REQUEST_PACKET RequestPacket);
-BOOLEAN STDCALL
+BOOLEAN NTAPI
VBEResetHw(
PVOID DeviceExtension,
ULONG Columns,
ULONG Rows);
-VP_STATUS STDCALL
+VP_STATUS NTAPI
VBEGetPowerState(
PVOID HwDeviceExtension,
ULONG HwId,
PVIDEO_POWER_MANAGEMENT VideoPowerControl);
-VP_STATUS STDCALL
+VP_STATUS NTAPI
VBESetPowerState(
PVOID HwDeviceExtension,
ULONG HwId,
// RETURNS:
// VP_STATUS
-VP_STATUS STDCALL
+VP_STATUS NTAPI
DriverEntry(IN PVOID Context1,
IN PVOID Context2)
{
// RETURNS:
// VP_STATUS
-VP_STATUS STDCALL
+VP_STATUS NTAPI
VGAFindAdapter(PVOID DeviceExtension,
PVOID Context,
PWSTR ArgumentString,
// PVOID DeviceExtension
// RETURNS:
// BOOLEAN Success or failure
-BOOLEAN STDCALL
+BOOLEAN NTAPI
VGAInitialize(PVOID DeviceExtension)
{
return TRUE;
// BOOLEAN This function must return TRUE, and complete the work or
// set an error status in the VRP.
-BOOLEAN STDCALL
+BOOLEAN NTAPI
VGAStartIO(PVOID DeviceExtension,
PVIDEO_REQUEST_PACKET RequestPacket)
{
// RETURNS:
// BOOLEAN TRUE if the interrupt was handled by the routine
-static BOOLEAN STDCALL
+static BOOLEAN NTAPI
VGAInterrupt(PVOID DeviceExtension)
{
return(TRUE);
// BOOLEAN TRUE if no further action is necessary, FALSE if the system
// needs to still do a BIOS int 10 reset.
-BOOLEAN STDCALL
+BOOLEAN NTAPI
VGAResetHw(PVOID DeviceExtension,
ULONG Columns,
ULONG Rows)
// RETURNS:
// VOID
-static VOID STDCALL
+static VOID NTAPI
VGATimer(PVOID DeviceExtension)
{
}
void
InitVGAMode();
-VP_STATUS STDCALL
+VP_STATUS NTAPI
VGAFindAdapter(
PVOID DeviceExtension,
PVOID Context,
PVIDEO_PORT_CONFIG_INFO ConfigInfo,
PUCHAR Again);
-BOOLEAN STDCALL
+BOOLEAN NTAPI
VGAInitialize(
PVOID DeviceExtension);
-BOOLEAN STDCALL
+BOOLEAN NTAPI
VGAStartIO(
PVOID DeviceExtension,
PVIDEO_REQUEST_PACKET RequestPacket);
-/*static BOOLEAN STDCALL
+/*static BOOLEAN NTAPI
VGAInterrupt(PVOID DeviceExtension);*/
-BOOLEAN STDCALL
+BOOLEAN NTAPI
VGAResetHw(
PVOID DeviceExtension,
ULONG Columns,
ULONG Rows);
-/*static VOID STDCALL
+/*static VOID NTAPI
VGATimer(PVOID DeviceExtension);*/
/* Mandatory IoControl routines */
/* PUBLIC AND PRIVATE FUNCTIONS ***********************************************/
-VP_STATUS STDCALL
+VP_STATUS NTAPI
DriverEntry(IN PVOID Context1, IN PVOID Context2)
{
VIDEO_HW_INITIALIZATION_DATA InitData;
* Detects the Xbox Nvidia display adapter.
*/
-VP_STATUS STDCALL
+VP_STATUS NTAPI
XboxVmpFindAdapter(
IN PVOID HwDeviceExtension,
IN PVOID HwContext,
* up control of the video hardware to the video port driver.
*/
-BOOLEAN STDCALL
+BOOLEAN NTAPI
XboxVmpInitialize(PVOID HwDeviceExtension)
{
PXBOXVMP_DEVICE_EXTENSION XboxVmpDeviceExtension;
* Processes the specified Video Request Packet.
*/
-BOOLEAN STDCALL
+BOOLEAN NTAPI
XboxVmpStartIO(
PVOID HwDeviceExtension,
PVIDEO_REQUEST_PACKET RequestPacket)
* This function is called to reset the hardware to a known state.
*/
-BOOLEAN STDCALL
+BOOLEAN NTAPI
XboxVmpResetHw(
PVOID DeviceExtension,
ULONG Columns,
* Queries whether the device can support the requested power state.
*/
-VP_STATUS STDCALL
+VP_STATUS NTAPI
XboxVmpGetPowerState(
PVOID HwDeviceExtension,
ULONG HwId,
* Sets the power state of the specified device
*/
-VP_STATUS STDCALL
+VP_STATUS NTAPI
XboxVmpSetPowerState(
PVOID HwDeviceExtension,
ULONG HwId,
PHYSICAL_ADDRESS PhysFrameBufferStart;
} XBOXVMP_DEVICE_EXTENSION, *PXBOXVMP_DEVICE_EXTENSION;
-VP_STATUS STDCALL
+VP_STATUS NTAPI
XboxVmpFindAdapter(
IN PVOID HwDeviceExtension,
IN PVOID HwContext,
IN OUT PVIDEO_PORT_CONFIG_INFO ConfigInfo,
OUT PUCHAR Again);
-BOOLEAN STDCALL
+BOOLEAN NTAPI
XboxVmpInitialize(PVOID HwDeviceExtension);
-BOOLEAN STDCALL
+BOOLEAN NTAPI
XboxVmpStartIO(
PVOID HwDeviceExtension,
PVIDEO_REQUEST_PACKET RequestPacket);
-BOOLEAN STDCALL
+BOOLEAN NTAPI
XboxVmpResetHw(
PVOID DeviceExtension,
ULONG Columns,
ULONG Rows);
-VP_STATUS STDCALL
+VP_STATUS NTAPI
XboxVmpGetPowerState(
PVOID HwDeviceExtension,
ULONG HwId,
PVIDEO_POWER_MANAGEMENT VideoPowerControl);
-VP_STATUS STDCALL
+VP_STATUS NTAPI
XboxVmpSetPowerState(
PVOID HwDeviceExtension,
ULONG HwId,
/*
* @implemented
*/
-ULONG STDCALL
+ULONG NTAPI
DllInitialize(ULONG Unknown)
{
return 0;
/*
* @implemented
*/
-ULONG STDCALL
+ULONG NTAPI
DllUnload(VOID)
{
return 0;
-NTSTATUS STDCALL
+NTSTATUS NTAPI
DriverEntry(
IN PDRIVER_OBJECT driver,
IN PUNICODE_STRING registry_path
projects / reactos.git / commitdiff