ACPI_OPERAND_OBJECT *obj_desc;
ACPI_PARSE_OBJECT *parent_op;
u16 opcode;
- u32 flags;
+ u32 flags = 0;
OPERATING_MODE interpreter_mode;
*
******************************************************************************/
-void
+static void
acpi_aml_link_mutex (
ACPI_OPERAND_OBJECT *obj_desc,
ACPI_OPERAND_OBJECT *list_head)
*
******************************************************************************/
-ACPI_STATUS
+static ACPI_STATUS
acpi_aml_check_object_type (
ACPI_OBJECT_TYPE type_needed,
ACPI_OBJECT_TYPE this_type,
return READ_PORT_UCHAR(IsaPnPReadPort);
}
-UCHAR ReadUchar(UCHAR Index)
+static UCHAR ReadUchar(UCHAR Index)
{
WriteAddress(Index);
return ReadData();
}
-USHORT ReadUshort(UCHAR Index)
+#if 0
+static USHORT ReadUshort(UCHAR Index)
{
USHORT Value;
return Value;
}
-ULONG ReadUlong(UCHAR Index)
+static ULONG ReadUlong(UCHAR Index)
{
ULONG Value;
Value = (Value << 8) + ReadUchar(Index + 3);
return Value;
}
+#endif
-VOID WriteUchar(UCHAR Index, UCHAR Value)
+static VOID WriteUchar(UCHAR Index, UCHAR Value)
{
WriteAddress(Index);
WriteData(Value);
}
-VOID WriteUshort(UCHAR Index, USHORT Value)
+#if 0
+static VOID WriteUshort(UCHAR Index, USHORT Value)
{
WriteUchar(Index, Value >> 8);
WriteUchar(Index + 1, Value);
}
-VOID WriteUlong(UCHAR Index, ULONG Value)
+static VOID WriteUlong(UCHAR Index, ULONG Value)
{
WriteUchar(Index, Value >> 24);
WriteUchar(Index + 1, Value >> 16);
WriteUchar(Index + 2, Value >> 8);
WriteUchar(Index + 3, Value);
}
+#endif
static inline VOID SetReadDataPort(ULONG Port)
{
WriteUchar(0x02, 0x02);
}
-VOID SendWake(UCHAR csn)
+static VOID SendWake(UCHAR csn)
{
WriteUchar(ISAPNP_CARD_WAKECSN, csn);
}
-VOID SelectLogicalDevice(UCHAR LogicalDevice)
+#if 0
+static VOID SelectLogicalDevice(UCHAR LogicalDevice)
{
WriteUchar(ISAPNP_CARD_LOG_DEVICE_NUM, LogicalDevice);
}
-VOID ActivateLogicalDevice(UCHAR LogicalDevice)
+static VOID ActivateLogicalDevice(UCHAR LogicalDevice)
{
SelectLogicalDevice(LogicalDevice);
WriteUchar(ISAPNP_CONTROL_ACTIVATE, 0x1);
KeStallExecutionProcessor(250);
}
-VOID DeactivateLogicalDevice(UCHAR LogicalDevice)
+static VOID DeactivateLogicalDevice(UCHAR LogicalDevice)
{
SelectLogicalDevice(LogicalDevice);
WriteUchar(ISAPNP_CONTROL_ACTIVATE, 0x0);
KeStallExecutionProcessor(500);
}
+#endif
#define READ_DATA_PORT_STEP 32 /* Minimum is 4 */
}
-VOID Peek(PUCHAR Data, ULONG Count)
+static VOID Peek(PUCHAR Data, ULONG Count)
{
ULONG i, j;
UCHAR d = 0;
}
-NTSTATUS
+static NTSTATUS
ISAPNPQueryBusRelations(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
}
-NTSTATUS
+static NTSTATUS
ISAPNPQueryDeviceRelations(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
}
-NTSTATUS
+static NTSTATUS
ISAPNPStartDevice(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
}
-NTSTATUS
+static NTSTATUS
ISAPNPStopDevice(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
}
-NTSTATUS
+static NTSTATUS
STDCALL
ISAPNPDispatchOpenClose(
IN PDEVICE_OBJECT DeviceObject,
}
-NTSTATUS
+static NTSTATUS
STDCALL
ISAPNPDispatchReadWrite(
IN PDEVICE_OBJECT PhysicalDeviceObject,
}
-NTSTATUS
+static NTSTATUS
STDCALL
ISAPNPDispatchDeviceControl(
IN PDEVICE_OBJECT DeviceObject,
}
-NTSTATUS
+static NTSTATUS
STDCALL
ISAPNPControl(
IN PDEVICE_OBJECT DeviceObject,
}
-NTSTATUS
+static NTSTATUS
STDCALL
ISAPNPAddDevice(
IN PDRIVER_OBJECT DriverObject,
ISAPNP_DEVICE_STATE State;
} ISAPNP_DEVICE_EXTENSION, *PISAPNP_DEVICE_EXTENSION;
+NTSTATUS
+STDCALL
+DriverEntry(
+ IN PDRIVER_OBJECT DriverObject,
+ IN PUNICODE_STRING RegistryPath);
+
#ifdef __cplusplus
}
#endif
*/
#include <ddk/ntddk.h>
+#include <ddk/ntifs.h>
#include <stdio.h>
#include "pcidef.h"
/*** PRIVATE *****************************************************************/
-NTSTATUS
+static NTSTATUS
STDCALL
PciDispatchDeviceControl(
IN PDEVICE_OBJECT DeviceObject,
}
-NTSTATUS
+static NTSTATUS
STDCALL
PciPnpControl(
IN PDEVICE_OBJECT DeviceObject,
}
-NTSTATUS
+static NTSTATUS
STDCALL
PciPowerControl(
IN PDEVICE_OBJECT DeviceObject,
}
-NTSTATUS
+static NTSTATUS
STDCALL
PciAddDevice(
IN PDRIVER_OBJECT DriverObject,
}
-BOOLEAN
-PciCreateUnicodeString(
- PUNICODE_STRING Destination,
- PWSTR Source,
- POOL_TYPE PoolType)
-{
- ULONG Length;
-
- if (!Source)
- {
- RtlInitUnicodeString(Destination, NULL);
- return TRUE;
- }
-
- Length = (wcslen(Source) + 1) * sizeof(WCHAR);
-
- Destination->Buffer = ExAllocatePool(PoolType, Length);
-
- if (Destination->Buffer == NULL)
- {
- return FALSE;
- }
-
- RtlCopyMemory(Destination->Buffer, Source, Length);
-
- Destination->MaximumLength = Length;
-
- Destination->Length = Length - sizeof(WCHAR);
-
- return TRUE;
-}
-
-
-NTSTATUS
-PciDuplicateUnicodeString(
- PUNICODE_STRING Destination,
- PUNICODE_STRING Source,
- POOL_TYPE PoolType)
-{
- if (Source == NULL)
- {
- RtlInitUnicodeString(Destination, NULL);
- return STATUS_SUCCESS;
- }
-
- Destination->Buffer = ExAllocatePool(PoolType, Source->MaximumLength);
- if (Destination->Buffer == NULL)
- {
- return STATUS_INSUFFICIENT_RESOURCES;
- }
-
- Destination->MaximumLength = Source->MaximumLength;
- Destination->Length = Source->Length;
- RtlCopyMemory(Destination->Buffer, Source->Buffer, Source->MaximumLength);
-
- return STATUS_SUCCESS;
-}
-
-
BOOLEAN
PciCreateDeviceIDString(PUNICODE_STRING DeviceID,
PPCI_DEVICE Device)
Device->PciConfig.u.type0.SubVendorID,
Device->PciConfig.RevisionID);
- if (!PciCreateUnicodeString(DeviceID, Buffer, PagedPool))
+ if (!RtlCreateUnicodeString(DeviceID, Buffer))
{
return FALSE;
}
{
//DPRINT("xbox ohci controler found at bus 0x%lX, dev num %d, func num %d\n", Device->BusNumber, Device->SlotNumber.u.bits.DeviceNumber, Device->SlotNumber.u.bits.FunctionNumber);
if (Device->SlotNumber.u.bits.DeviceNumber == 2)
- return PciCreateUnicodeString(InstanceID, L"0000", PagedPool);
+ return RtlCreateUnicodeString(InstanceID, L"0000");
else
- return PciCreateUnicodeString(InstanceID, L"0001", PagedPool);
+ return RtlCreateUnicodeString(InstanceID, L"0001");
}
else
- return PciCreateUnicodeString(InstanceID, L"0000", PagedPool);
+ return RtlCreateUnicodeString(InstanceID, L"0000");
}
PWSTR Source,
POOL_TYPE PoolType);
-NTSTATUS
-PciDuplicateUnicodeString(
- PUNICODE_STRING Destination,
- PUNICODE_STRING Source,
- POOL_TYPE PoolType);
-
BOOLEAN
PciCreateDeviceIDString(
PUNICODE_STRING DeviceID,
PDEVICE_OBJECT DeviceObject,
PIRP Irp);
+NTSTATUS
+STDCALL
+DriverEntry(
+ IN PDRIVER_OBJECT DriverObject,
+ IN PUNICODE_STRING RegistryPath);
+
#endif /* __PCI_H */
*/
#include <ddk/ntddk.h>
+#include <ddk/ntifs.h>
#include <initguid.h>
#include <ddk/wdmguid.h>
#include "pcidef.h"
switch (IrpSp->Parameters.QueryId.IdType) {
case BusQueryDeviceID:
- Status = PciDuplicateUnicodeString(
- &String,
+ Status = RtlDuplicateUnicodeString(
+ RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
&DeviceExtension->DeviceID,
- PagedPool);
+ &String);
DPRINT("DeviceID: %S\n", String.Buffer);
break;
case BusQueryHardwareIDs:
- Status = PciDuplicateUnicodeString(
- &String,
+ Status = RtlDuplicateUnicodeString(
+ RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
&DeviceExtension->HardwareIDs,
- PagedPool);
+ &String);
Irp->IoStatus.Information = (ULONG_PTR)String.Buffer;
break;
case BusQueryCompatibleIDs:
- Status = PciDuplicateUnicodeString(
- &String,
+ Status = RtlDuplicateUnicodeString(
+ RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
&DeviceExtension->CompatibleIDs,
- PagedPool);
+ &String);
Irp->IoStatus.Information = (ULONG_PTR)String.Buffer;
break;
case BusQueryInstanceID:
- Status = PciDuplicateUnicodeString(
- &String,
+ Status = RtlDuplicateUnicodeString(
+ RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
&DeviceExtension->InstanceID,
- PagedPool);
+ &String);
DPRINT("InstanceID: %S\n", String.Buffer);
FdoDeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
RtlZeroMemory(PdoDeviceExtension, sizeof(PDO_DEVICE_EXTENSION));
PdoDeviceExtension->Common.IsFDO = FALSE;
- Status = SerenumDuplicateUnicodeString(&PdoDeviceExtension->DeviceDescription, DeviceDescription, PagedPool);
+ Status = RtlDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE, DeviceDescription, &PdoDeviceExtension->DeviceDescription);
if (!NT_SUCCESS(Status)) goto ByeBye;
- Status = SerenumDuplicateUnicodeString(&PdoDeviceExtension->DeviceId, DeviceId, PagedPool);
+ Status = RtlDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE, DeviceId, &PdoDeviceExtension->DeviceId);
if (!NT_SUCCESS(Status)) goto ByeBye;
- Status = SerenumDuplicateUnicodeString(&PdoDeviceExtension->InstanceId, InstanceId, PagedPool);
+ Status = RtlDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE, InstanceId, &PdoDeviceExtension->InstanceId);
if (!NT_SUCCESS(Status)) goto ByeBye;
- Status = SerenumDuplicateUnicodeString(&PdoDeviceExtension->HardwareIds, HardwareIds, PagedPool);
+ Status = RtlDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE, HardwareIds, &PdoDeviceExtension->HardwareIds);
if (!NT_SUCCESS(Status)) goto ByeBye;
- Status = SerenumDuplicateUnicodeString(&PdoDeviceExtension->CompatibleIds, CompatibleIds, PagedPool);
+ Status = RtlDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE, CompatibleIds, &PdoDeviceExtension->CompatibleIds);
if (!NT_SUCCESS(Status)) goto ByeBye;
/* Device attached to serial port (Pdo) may delegate work to
return STATUS_SUCCESS;
}
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
SerenumFdoStartDevice(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
return STATUS_SUCCESS;
}
-NTSTATUS
+static NTSTATUS
SerenumFdoQueryBusRelations(
IN PDEVICE_OBJECT DeviceObject,
OUT PDEVICE_RELATIONS* pDeviceRelations)
#include "serenum.h"
#include <stdarg.h>
-NTSTATUS
-SerenumDuplicateUnicodeString(
- OUT PUNICODE_STRING Destination,
- IN PUNICODE_STRING Source,
- IN POOL_TYPE PoolType)
-{
- ASSERT(Destination);
-
- if (Source == NULL)
- {
- RtlInitUnicodeString(Destination, NULL);
- return STATUS_SUCCESS;
- }
-
- Destination->Buffer = ExAllocatePoolWithTag(PoolType, Source->MaximumLength, SERENUM_TAG);
- if (Destination->Buffer == NULL)
- {
- return STATUS_INSUFFICIENT_RESOURCES;
- }
-
- Destination->MaximumLength = Source->MaximumLength;
- Destination->Length = Source->Length;
- RtlCopyMemory(Destination->Buffer, Source->Buffer, Source->MaximumLength);
-
- return STATUS_SUCCESS;
-}
-
/* I really want PCSZ strings as last arguments because
* PnP ids are ANSI-encoded in PnP device string
* identification */
return Status;
}
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
ForwardIrpAndWaitCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
return STATUS_NOT_SUPPORTED;
}
- Status = SerenumDuplicateUnicodeString(
- &String,
+ Status = RtlDuplicateUnicodeString(
+ RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
SourceString,
- PagedPool);
+ &String);
*Information = (ULONG_PTR)String.Buffer;
return Status;
}
#define INITGUID
#include "serenum.h"
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
SerenumPnp(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
return SerenumPdoPnp(DeviceObject, Irp);
}
-VOID STDCALL
+static VOID STDCALL
DriverUnload(IN PDRIVER_OBJECT DriverObject)
{
// nothing to do here yet
}
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
IrpStub(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
*/
#include <ntddk.h>
+#include <ntifs.h>
#include <ntddser.h>
#include <stdio.h>
/************************************ misc.c */
-NTSTATUS
-SerenumDuplicateUnicodeString(
- OUT PUNICODE_STRING Destination,
- IN PUNICODE_STRING Source,
- IN POOL_TYPE PoolType);
-
NTSTATUS
SerenumInitMultiSzString(
OUT PUNICODE_STRING Destination,
SerenumPdoPnp(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
+
+/************************************ serenum.c */
+
+NTSTATUS STDCALL
+DriverEntry(
+ IN PDRIVER_OBJECT DriverObject,
+ IN PUNICODE_STRING RegPath);
#define NDEBUG
#include <debug.h>
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject,
+ PUNICODE_STRING RegistryPath);
+
/* TYEPEDEFS ***************************************************************/
typedef struct _BEEP_DEVICE_EXTENSION
/* FUNCTIONS **************************************************************/
NTSTATUS STDCALL
+DriverEntry (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
+
+static NTSTATUS STDCALL
ScrCreate(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
}
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
ScrWrite(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
}
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
ScrIoControl(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
}
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
ScrDispatch(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
}
-BOOL STDCALL
+static BOOL STDCALL
VidResetDisplay(VOID)
{
/*
}
-VOID STDCALL
+static VOID STDCALL
VidCleanUp(VOID)
{
InbvUnmapVideoMemory();
}
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
VidDispatch(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
PIO_STACK_LOCATION IrpSp;
extern VOID
InbvPutPixels(int x, int y, unsigned long c);
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
+
#endif /* _BOOTVID_H */
/* INCLUDES */
#include <ddk/ntddk.h>
-/* FUNCTIONS */
NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
+
+/* FUNCTIONS */
+static NTSTATUS STDCALL
DebugOutDispatch(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
PIO_STACK_LOCATION piosStack = IoGetCurrentIrpStackLocation(Irp);
return nErrCode;
}
-VOID STDCALL
+static VOID STDCALL
DebugOutUnload(PDRIVER_OBJECT DriverObject)
{
}
/* FUNCTIONS ***************************************************************/
-NTSTATUS InitDevice(
+static NTSTATUS InitDevice(
IN PUNICODE_STRING RegistryPath,
IN PVOID Context)
{
IN PVOID Context,
IN PVOID EntryContext);
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject,
+ PUNICODE_STRING RegistryPath);
+
#endif
#include <debug.h>
#include "sbdebug.h" // our own debug helper
-
-NTSTATUS
+#if 0
+static NTSTATUS
OpenDevicesKey(
IN PWSTR RegistryPath,
OUT PHANDLE Key)
return s;
}
-
+#endif
NTSTATUS STDCALL EnumDeviceKeys(
}
-
-NTSTATUS SaveSettings(
+#if 0
+static NTSTATUS SaveSettings(
IN PWSTR RegistryPath,
IN ULONG Port,
IN ULONG IRQ,
return STATUS_SUCCESS;
}
+#endif
+
static const NULL_EXTENSION nxZero = NullZeroStream;
/* FUNCTIONS */
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
NullDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
PIO_STACK_LOCATION piosStack = IoGetCurrentIrpStackLocation(Irp);
return (nErrCode);
}
-VOID STDCALL
+static VOID STDCALL
NullUnload(PDRIVER_OBJECT DriverObject)
{
}
#define NULL_DEVICE_TYPE(__DEVICE__) (*((PNULL_EXTENSION)((__DEVICE__)->DeviceExtension)))
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
+
/* EOF */
#define LP_S (READ_PORT_UCHAR((PUCHAR)(LP_B+1)))
#define LP_C (LP_B+2)
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
+
static void Parallel_Reset(void)
/*
* FUNCTION: Resets the device attached to the parallel port
WRITE_PORT_UCHAR((PUCHAR)LP_C, LP_PSELECP | LP_PINITP);
}
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
Dispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
/*
* FUNCTION: Handles user mode requests
#include <debug.h>
#include "../../lib/bzip2/bzlib.h"
-NTSTATUS STDCALL RamdrvDispatchDeviceControl(PDEVICE_OBJECT DeviceObject,
+static NTSTATUS STDCALL RamdrvDispatchDeviceControl(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
PIO_STACK_LOCATION IrpStack;
return Status;
}
-NTSTATUS STDCALL RamdrvDispatchReadWrite(PDEVICE_OBJECT DeviceObject,
+static NTSTATUS STDCALL RamdrvDispatchReadWrite(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
PRAMDRV_DEVICE_EXTENSION devext = (PRAMDRV_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
return STATUS_SUCCESS;
}
-NTSTATUS STDCALL RamdrvDispatchOpenClose(PDEVICE_OBJECT DeviceObject,
+static NTSTATUS STDCALL RamdrvDispatchOpenClose(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
DPRINT("RamdrvDispatchOpenClose\n");
unsigned long Size;
} RAMDRV_DEVICE_EXTENSION, *PRAMDRV_DEVICE_EXTENSION;
+NTSTATUS STDCALL DriverEntry(IN PDRIVER_OBJECT DriverObject,
+ IN PUNICODE_STRING RegistryPath);
+
return Status;
}
-BOOLEAN
+static BOOLEAN
SerialClearPerfStats(
IN PSERIAL_DEVICE_EXTENSION DeviceExtension)
{
return TRUE;
}
-BOOLEAN
+static BOOLEAN
SerialGetPerfStats(IN PIRP pIrp)
{
PSERIAL_DEVICE_EXTENSION pDeviceExtension;
return TRUE;
}
-NTSTATUS
+static NTSTATUS
SerialGetCommProp(
OUT PSERIAL_COMMPROP pCommProp,
IN PSERIAL_DEVICE_EXTENSION DeviceExtension)
return STATUS_SUCCESS;
}
-NTSTATUS
+static NTSTATUS
SerialGetCommStatus(
OUT PSERIAL_STATUS pSerialStatus,
IN PSERIAL_DEVICE_EXTENSION DeviceExtension)
#define NDEBUG
#include "serial.h"
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
ForwardIrpAndWaitCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
//#define NDEBUG
#include "serial.h"
-VOID STDCALL
+static VOID STDCALL
DriverUnload(IN PDRIVER_OBJECT DriverObject)
{
// nothing to do here yet
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
+/************************************ serial.c */
+
+NTSTATUS STDCALL
+DriverEntry(
+ IN PDRIVER_OBJECT DriverObject,
+ IN PUNICODE_STRING RegPath);
#include <ddk/ntddk.h>
#include "sndblst.h"
-
+#if 0
BOOLEAN CheckDMA(PDEVICE_EXTENSION Device)
{
// Don't forget to check for Compaq machines (they can't be configured
return FALSE;
}
+#endif
-IO_ALLOCATION_ACTION STDCALL SoundProgramDMA(
+static IO_ALLOCATION_ACTION STDCALL SoundProgramDMA(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID MapRegisterBase,
// DeviceObject); // Context
return TRUE;
}
+
#include <ddk/ntddk.h>
#include "sndblst.h"
-
+#if 0
BOOLEAN CheckIRQ(PDEVICE_EXTENSION Parameters)
{
static CONST ULONG ValidIRQs[] = VALID_IRQS;
return Status == STATUS_INVALID_PARAMETER ?
STATUS_DEVICE_CONFIGURATION_ERROR : Status;
}
+#endif
+
#include "sbdebug.h" // our own debug helper
+#if 0
NTSTATUS
OpenDevicesKey(
IN PWSTR RegistryPath,
return s;
}
-
+#endif
NTSTATUS STDCALL EnumDeviceKeys(
}
-
+#if 0
NTSTATUS SaveSettings(
IN PWSTR RegistryPath,
IN ULONG Port,
return STATUS_SUCCESS;
}
+#endif
#include <ddk/ntddk.h>
#include "sndblst.h"
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject,
+ PUNICODE_STRING RegistryPath);
/* INTERNAL VARIABLES ******************************************************/
/* FUNCTIONS ***************************************************************/
-NTSTATUS InitDevice(
+static NTSTATUS InitDevice(
IN PWSTR RegistryPath,
IN PVOID Context)
{
#include <ddk/ntddk.h>
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject,
+ PUNICODE_STRING RegistryPath);
+
#define NDEBUG
#include <debug.h>
+#if 0
void write_wave()
{
}
+#endif
SB16 sb16;
sb_status sb16_getenvironment(void);
-NTSTATUS STDCALL Dispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+#if 0
+static NTSTATUS STDCALL Dispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
/*
* FUNCTION: Handles user mode requests
* ARGUMENTS:
#endif
return(STATUS_SUCCESS);
}
+#endif
sb_status sb16_getenvironment(void)
{
ULONG OldIRQ;
PKINTERRUPT IrqObject;
-BOOLEAN STDCALL DMAOutputISR(PKINTERRUPT Interrupt, PVOID ServiceContext)
+
+static BOOLEAN STDCALL DMAOutputISR(PKINTERRUPT Interrupt, PVOID ServiceContext)
{
DPRINT1("interrupt\n");
return FALSE;
CdfsSetVolumeInformation(PDEVICE_OBJECT DeviceObject,
PIRP Irp);
+/* cdfs.c */
+
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject,
+ PUNICODE_STRING RegistryPath);
+
#endif //CDFS_H
/* FUNCTIONS ****************************************************************/
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
FsRecCreate(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
}
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
FsRecClose(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
}
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
FsRecFsControl(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
}
-VOID STDCALL
+static VOID STDCALL
FsRecUnload(IN PDRIVER_OBJECT DriverObject)
{
PDEVICE_OBJECT NextDevice;
FsRecUdfsFsControl(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
+/* fs_rec.c */
+
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject,
+ PUNICODE_STRING RegistryPath);
+
/* EOF */
NTSTATUS DEFAULTAPI MsfsFileSystemControl(PDEVICE_OBJECT DeviceObject, PIRP Irp);
+NTSTATUS NTAPI
+DriverEntry(PDRIVER_OBJECT DriverObject,
+ PUNICODE_STRING RegistryPath);
+
#endif /* __SERVICES_FS_NP_NPFS_H */
MupCreate(PDEVICE_OBJECT DeviceObject,
PIRP Irp);
+/* mup.c */
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject,
+ PUNICODE_STRING RegistryPath);
#endif /* MUP_H */
NTSTATUS STDCALL NpfsQueryVolumeInformation (PDEVICE_OBJECT DeviceObject, PIRP Irp);
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject,
+ PUNICODE_STRING RegistryPath);
+
#endif /* __DRIVERS_FS_NP_NPFS_H */
-ULONG
+static ULONG
RunLength(PUCHAR run)
{
return(*run & 0x0f) + ((*run >> 4) & 0x0f) + 1;
}
-LONGLONG
+static LONGLONG
RunLCN(PUCHAR run)
{
UCHAR n1 = *run & 0x0f;
-ULONGLONG
+static ULONGLONG
RunCount(PUCHAR run)
{
UCHAR n = *run & 0xf;
}
-NTSTATUS
+static NTSTATUS
NtfsDirFindFile(PDEVICE_EXTENSION DeviceExt,
PFCB DirectoryFcb,
PWSTR FileToFind,
}
+#if 0
BOOL bitset(PUCHAR bitmap, ULONG i)
{
return (bitmap[i>>3] & (1 << (i & 7))) !=0;
}
+#endif
VOID FixupUpdateSequenceArray(PFILE_RECORD_HEADER file)
ULONG
AttributeDataLength(PATTRIBUTE attr);
+ULONG
+AttributeAllocatedLength (PATTRIBUTE Attribute);
+
NTSTATUS
ReadFileRecord (PDEVICE_EXTENSION Vcb,
ULONG index,
NtfsSetVolumeInformation(PDEVICE_OBJECT DeviceObject,
PIRP Irp);
+/* ntfs.c */
+
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject,
+ PUNICODE_STRING RegistryPath);
+
#endif /* NTFS_H */
return Status;
}
-NTSTATUS
+static NTSTATUS
VfatCreateFile (PDEVICE_OBJECT DeviceObject, PIRP Irp)
/*
* FUNCTION: Create or open a file
#define ULONG_ROUND_UP(x) ROUND_UP((x), (sizeof(ULONG)))
-NTSTATUS
+static NTSTATUS
VfatGetFileNameInformation (PVFAT_DIRENTRY_CONTEXT DirContext,
PFILE_NAMES_INFORMATION pInfo, ULONG BufferLength)
{
return STATUS_SUCCESS;
}
-NTSTATUS
+static NTSTATUS
VfatGetFileDirectoryInformation (PVFAT_DIRENTRY_CONTEXT DirContext,
PDEVICE_EXTENSION DeviceExt,
PFILE_DIRECTORY_INFORMATION pInfo,
return STATUS_SUCCESS;
}
-NTSTATUS
+static NTSTATUS
VfatGetFileFullDirectoryInformation (PVFAT_DIRENTRY_CONTEXT DirContext,
PDEVICE_EXTENSION DeviceExt,
PFILE_FULL_DIR_INFORMATION pInfo,
return STATUS_SUCCESS;
}
-NTSTATUS
+static NTSTATUS
VfatGetFileBothInformation (PVFAT_DIRENTRY_CONTEXT DirContext,
PDEVICE_EXTENSION DeviceExt,
PFILE_BOTH_DIR_INFORMATION pInfo,
return STATUS_SUCCESS;
}
-NTSTATUS DoQuery (PVFAT_IRP_CONTEXT IrpContext)
+static NTSTATUS DoQuery (PVFAT_IRP_CONTEXT IrpContext)
{
NTSTATUS RC = STATUS_SUCCESS;
long BufferLength = 0;
return cluster;
}
-BOOLEAN FATIsDirectoryEmpty(PVFATFCB Fcb)
+static BOOLEAN FATIsDirectoryEmpty(PVFATFCB Fcb)
{
LARGE_INTEGER FileOffset;
PVOID Context = NULL;
return TRUE;
}
-BOOLEAN FATXIsDirectoryEmpty(PVFATFCB Fcb)
+static BOOLEAN FATXIsDirectoryEmpty(PVFATFCB Fcb)
{
LARGE_INTEGER FileOffset;
PVOID Context = NULL;
return TRUE;
}
-NTSTATUS
+static NTSTATUS
FATAddEntry (PDEVICE_EXTENSION DeviceExt,
PUNICODE_STRING NameU,
PVFATFCB* Fcb,
return STATUS_SUCCESS;
}
-NTSTATUS
+static NTSTATUS
FATXAddEntry (PDEVICE_EXTENSION DeviceExt,
PUNICODE_STRING NameU,
PVFATFCB* Fcb,
return FATAddEntry(DeviceExt, NameU, Fcb, ParentFcb, RequestedOptions, ReqAttr);
}
-NTSTATUS
+static NTSTATUS
FATDelEntry (PDEVICE_EXTENSION DeviceExt, PVFATFCB pFcb)
/*
* deleting an existing FAT entry
return STATUS_SUCCESS;
}
-NTSTATUS
+static NTSTATUS
FATXDelEntry (PDEVICE_EXTENSION DeviceExt, PVFATFCB pFcb)
/*
* deleting an existing FAT entry
#define NDEBUG
#include "vfat.h"
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatFastIoCheckIfPossible(IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN ULONG Lenght,
return FALSE;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatFastIoRead(IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN ULONG Length,
return FALSE;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatFastIoWrite(IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN ULONG Length,
return FALSE;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatFastIoQueryBasicInfo(IN PFILE_OBJECT FileObject,
IN BOOLEAN Wait,
OUT PFILE_BASIC_INFORMATION Buffer,
return FALSE;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatFastIoQueryStandardInfo(IN PFILE_OBJECT FileObject,
IN BOOLEAN Wait,
OUT PFILE_STANDARD_INFORMATION Buffer,
return FALSE;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatFastIoLock(IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN PLARGE_INTEGER Length,
return FALSE;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatFastIoUnlockSingle(IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN PLARGE_INTEGER Length,
return FALSE;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatFastIoUnlockAll(IN PFILE_OBJECT FileObject,
PEPROCESS ProcessId,
OUT PIO_STATUS_BLOCK IoStatus,
return FALSE;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatFastIoUnlockAllByKey(IN PFILE_OBJECT FileObject,
PEPROCESS ProcessId,
ULONG Key,
return FALSE;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatFastIoDeviceControl(IN PFILE_OBJECT FileObject,
IN BOOLEAN Wait,
IN PVOID InputBuffer OPTIONAL,
return FALSE;
}
-VOID NTAPI
+static VOID NTAPI
VfatAcquireFileForNtCreateSection(IN PFILE_OBJECT FileObject)
{
DPRINT("VfatAcquireFileForNtCreateSection\n");
}
-VOID NTAPI
+static VOID NTAPI
VfatReleaseFileForNtCreateSection(IN PFILE_OBJECT FileObject)
{
DPRINT("VfatReleaseFileForNtCreateSection\n");
}
-VOID NTAPI
+static VOID NTAPI
VfatFastIoDetachDevice(IN PDEVICE_OBJECT SourceDevice,
IN PDEVICE_OBJECT TargetDevice)
{
DPRINT("VfatFastIoDetachDevice\n");
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatFastIoQueryNetworkOpenInfo(IN PFILE_OBJECT FileObject,
IN BOOLEAN Wait,
OUT PFILE_NETWORK_OPEN_INFORMATION Buffer,
return FALSE;
}
-NTSTATUS NTAPI
+static NTSTATUS NTAPI
VfatAcquireForModWrite(IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER EndingOffset,
OUT PERESOURCE* ResourceToRelease,
return STATUS_UNSUCCESSFUL;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatMdlRead(IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN ULONG Length,
return FALSE;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatMdlReadComplete(IN PFILE_OBJECT FileObject,
IN PMDL MdlChain,
IN PDEVICE_OBJECT DeviceObject)
return FALSE;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatPrepareMdlWrite(IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN ULONG Length,
return FALSE;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatMdlWriteComplete(IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN PMDL MdlChain,
return FALSE;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatFastIoReadCompressed(IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN ULONG Length,
return FALSE;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatFastIoWriteCompressed(IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN ULONG Length,
return FALSE;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatMdlReadCompleteCompressed(IN PFILE_OBJECT FileObject,
IN PMDL MdlChain,
IN PDEVICE_OBJECT DeviceObject)
return FALSE;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatMdlWriteCompleteCompressed(IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN PMDL MdlChain,
return FALSE;
}
-BOOLEAN NTAPI
+static BOOLEAN NTAPI
VfatFastIoQueryOpen(IN PIRP Irp,
OUT PFILE_NETWORK_OPEN_INFORMATION NetworkInformation,
IN PDEVICE_OBJECT DeviceObject)
return FALSE;
}
-NTSTATUS NTAPI
+static NTSTATUS NTAPI
VfatReleaseForModWrite(IN PFILE_OBJECT FileObject,
IN PERESOURCE ResourceToRelease,
IN PDEVICE_OBJECT DeviceObject)
return STATUS_UNSUCCESSFUL;
}
-NTSTATUS NTAPI
+static NTSTATUS NTAPI
VfatAcquireForCcFlush(IN PFILE_OBJECT FileObject,
IN PDEVICE_OBJECT DeviceObject)
{
return STATUS_UNSUCCESSFUL;
}
-NTSTATUS NTAPI
+static NTSTATUS NTAPI
VfatReleaseForCcFlush(IN PFILE_OBJECT FileObject,
IN PDEVICE_OBJECT DeviceObject)
{
return (STATUS_DISK_FULL);
}
-NTSTATUS
+static NTSTATUS
FAT12CountAvailableClusters(PDEVICE_EXTENSION DeviceExt)
/*
* FUNCTION: Counts free cluster in a FAT12 table
}
-NTSTATUS
+static NTSTATUS
FAT16CountAvailableClusters(PDEVICE_EXTENSION DeviceExt)
/*
* FUNCTION: Counts free clusters in a FAT16 table
}
-NTSTATUS
+static NTSTATUS
FAT32CountAvailableClusters(PDEVICE_EXTENSION DeviceExt)
/*
* FUNCTION: Counts free clusters in a FAT32 table
/* -------------------------------------------------------- PUBLICS */
-ULONG vfatNameHash(ULONG hash, PUNICODE_STRING NameU)
+static ULONG vfatNameHash(ULONG hash, PUNICODE_STRING NameU)
{
PWCHAR last;
PWCHAR curr;
}
}
-VOID
+static VOID
vfatInitFcb(PVFATFCB Fcb, PUNICODE_STRING NameU)
{
USHORT PathNameBufferLength;
return NULL;
}
-NTSTATUS
+static NTSTATUS
vfatFCBInitializeCacheFromVolume (PVCB vcb, PVFATFCB fcb)
{
#ifdef USE_ROS_CC_AND_FS
return STATUS_SUCCESS;
}
-VOID UpdateFileSize(PFILE_OBJECT FileObject, PVFATFCB Fcb, ULONG Size, ULONG ClusterSize)
+static VOID UpdateFileSize(PFILE_OBJECT FileObject, PVFATFCB Fcb, ULONG Size, ULONG ClusterSize)
{
if (Size > 0)
{
/* FUNCTIONS ****************************************************************/
-NTSTATUS VfatFlushFile(PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb)
+static NTSTATUS VfatFlushFile(PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb)
{
IO_STATUS_BLOCK IoStatus;
NTSTATUS Status;
static LONG QueueCount = 0;
-NTSTATUS VfatLockControl(
+static NTSTATUS VfatLockControl(
IN PVFAT_IRP_CONTEXT IrpContext
)
{
return Status;
}
-NTSTATUS
+static NTSTATUS
VfatDispatchRequest (IN PVFAT_IRP_CONTEXT IrpContext)
{
DPRINT ("VfatDispatchRequest (IrpContext %x), is called for %s\n", IrpContext,
return IrpContext;
}
-VOID NTAPI VfatDoRequest (PVOID IrpContext)
+static VOID NTAPI VfatDoRequest (PVOID IrpContext)
{
InterlockedDecrement(&QueueCount);
DPRINT ("VfatDoRequest (IrpContext %x), MajorFunction %x, %d\n", IrpContext, ((PVFAT_IRP_CONTEXT)IrpContext)->MajorFunction, QueueCount);
}
}
-NTSTATUS
+static NTSTATUS
VfatReadFileData (PVFAT_IRP_CONTEXT IrpContext,
ULONG Length,
LARGE_INTEGER ReadOffset,
return Status;
}
-NTSTATUS
+static NTSTATUS
VfatWriteFileData(PVFAT_IRP_CONTEXT IrpContext,
ULONG Length,
LARGE_INTEGER WriteOffset)
/* FUNCTIONS ****************************************************************/
-NTSTATUS
+static NTSTATUS
VfatDiskShutDown(PVCB Vcb)
{
PIRP Irp;
DPRINT("HookWorkItem done\n");
}
-VOID STDCALL I8042StartIo(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+static VOID STDCALL I8042StartIo(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
if (!I8042StartIoKbd(DeviceObject, Irp)) {
DPRINT1("Unhandled StartIo!\n");
}
}
-NTSTATUS STDCALL I8042InternalDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+static NTSTATUS STDCALL I8042InternalDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
NTSTATUS Status = STATUS_INVALID_DEVICE_REQUEST;
PFDO_DEVICE_EXTENSION FdoDevExt = DeviceObject->DeviceExtension;
return Status;
}
-NTSTATUS STDCALL I8042CreateDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+static NTSTATUS STDCALL I8042CreateDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
NTSTATUS Status;
BOOLEAN I8042Write(PDEVICE_EXTENSION DevExt, PUCHAR addr, UCHAR data);
+NTSTATUS STDCALL DriverEntry(PDRIVER_OBJECT DriverObject,
+ PUNICODE_STRING RegistryPath);
+
/* keyboard.c */
VOID STDCALL I8042IsrWritePortKbd(PVOID Context,
UCHAR Value);
return TRUE;
}
-BOOLEAN STDCALL I8042KeyboardDefaultsAndDisable(PDEVICE_EXTENSION DevExt)
+static BOOLEAN STDCALL I8042KeyboardDefaultsAndDisable(PDEVICE_EXTENSION DevExt)
{
DPRINT("Disabling keyboard\n");
if (STATUS_SUCCESS != I8042SynchWritePort(DevExt,
* These functions are callbacks for filter driver custom interrupt
* service routines.
*/
-VOID STDCALL I8042IsrWritePortMouse(PVOID Context,
- UCHAR Value)
+static VOID STDCALL I8042IsrWritePortMouse(PVOID Context,
+ UCHAR Value)
{
I8042IsrWritePort(Context, Value, 0xD4);
}
-NTSTATUS STDCALL I8042SynchWritePortMouse(PVOID Context,
- UCHAR Value,
- BOOLEAN WaitForAck)
+#if 0
+static NTSTATUS STDCALL I8042SynchWritePortMouse(PVOID Context,
+ UCHAR Value,
+ BOOLEAN WaitForAck)
{
return I8042SynchWritePort((PDEVICE_EXTENSION)Context,
0xD4,
Value,
WaitForAck);
}
+#endif
/* Test if packets are taking too long to come in. If they do, we
* might have gotten out of sync and should just drop what we have.
* we should return (indicating to the system wether someone else
* should try to handle the interrupt)
*/
-BOOLEAN STDCALL I8042MouseCallIsrHook(PDEVICE_EXTENSION DevExt,
- UCHAR Status,
- PUCHAR Input,
- PBOOLEAN ToReturn)
+static BOOLEAN STDCALL I8042MouseCallIsrHook(PDEVICE_EXTENSION DevExt,
+ UCHAR Status,
+ PUCHAR Input,
+ PBOOLEAN ToReturn)
{
BOOLEAN HookReturn, HookContinue;
return FALSE;
}
-BOOLEAN STDCALL I8042MouseResetIsr(PDEVICE_EXTENSION DevExt,
- UCHAR Status,
- PUCHAR Value)
+static BOOLEAN STDCALL I8042MouseResetIsr(PDEVICE_EXTENSION DevExt,
+ UCHAR Status,
+ PUCHAR Value)
{
BOOLEAN ToReturn = FALSE;
* returns FALSE if it doesn't understand the
* call so someone else can handle it.
*/
-BOOLEAN STDCALL I8042StartIoMouse(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+#if 0
+static BOOLEAN STDCALL I8042StartIoMouse(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
PIO_STACK_LOCATION Stk;
PFDO_DEVICE_EXTENSION FdoDevExt = DeviceObject->DeviceExtension;
return TRUE;
}
+#endif
/*
* Runs the mouse IOCTL_INTERNAL dispatch.
/* GLOBALS *******************************************************************/
+NTSTATUS STDCALL DriverEntry(PDRIVER_OBJECT DriverObject,
+ PUNICODE_STRING RegistryPath);
+
/*
* Driver data
*/
}
}
-VOID STDCALL KbdStartIo(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+static VOID STDCALL KbdStartIo(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
/* We only do this for read irps */
DPRINT("KeyboardStartIo(DeviceObject %x Irp %x)\n",DeviceObject,Irp);
* These are just passed down the stack but we must change the IOCTL to be
* INTERNAL. MSDN says there might be more...
*/
-NTSTATUS STDCALL KbdDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+static NTSTATUS STDCALL KbdDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
PDEVICE_EXTENSION DevExt = DeviceObject->DeviceExtension;
PIO_STACK_LOCATION Stk = IoGetCurrentIrpStackLocation(Irp);
#define NDEBUG
#include <debug.h>
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
+
PDEVICE_OBJECT MouclassDeviceObject;
-BOOLEAN MouseClassCallBack(
+static BOOLEAN MouseClassCallBack(
PDEVICE_OBJECT ClassDeviceObject, PMOUSE_INPUT_DATA MouseDataStart,
PMOUSE_INPUT_DATA MouseDataEnd, PULONG ConsumedCount)
{
return TRUE;
}
-NTSTATUS ConnectMousePortDriver(PDEVICE_OBJECT ClassDeviceObject)
+static NTSTATUS ConnectMousePortDriver(PDEVICE_OBJECT ClassDeviceObject)
{
PDEVICE_OBJECT PortDeviceObject = NULL;
PFILE_OBJECT FileObject = NULL;
return ioStatus.Status;
}
-NTSTATUS STDCALL MouseClassDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+static NTSTATUS STDCALL MouseClassDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
NTSTATUS Status;
return Status;
}
-VOID STDCALL
+static VOID STDCALL
MouseClassStartIo(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
* Functions
*/
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
+
/* Waits until the mouse calms down but also quits out after a while
* in case some destructive user wants to keep moving the mouse
* before we're done */
-VOID ClearMouse(ULONG Port)
+static VOID ClearMouse(ULONG Port)
{
ULONG Restarts = 0;
ULONG i;
}
}
-BOOLEAN STDCALL
+static BOOLEAN STDCALL
SerialMouseInterruptService(IN PKINTERRUPT Interrupt, PVOID ServiceContext)
{
PDEVICE_OBJECT DeviceObject = (PDEVICE_OBJECT)ServiceContext;
return TRUE;
}
-VOID
+static VOID
SerialMouseInitializeDataQueue(PVOID Context)
{
}
-BOOLEAN STDCALL
+static BOOLEAN STDCALL
MouseSynchronizeRoutine(PVOID Context)
{
return TRUE;
}
-VOID STDCALL
+static VOID STDCALL
SerialMouseStartIo(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
}
}
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
SerialMouseInternalDeviceControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
return Status;
}
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
SerialMouseDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
return Status;
}
-VOID SerialMouseIsrDpc(PKDPC Dpc, PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
+static VOID SerialMouseIsrDpc(PKDPC Dpc, PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
{
PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
ULONG Queue;
DeviceExtension->InputDataCount[Queue] = 0;
}
-VOID InitializeSerialPort(ULONG Port)
+static VOID InitializeSerialPort(ULONG Port)
{
/* DLAB off */
WRITE_PORT_UCHAR((PUCHAR)Port + 3, 0);
WRITE_PORT_UCHAR((PUCHAR)Port + 3, 2);
}
-BOOLEAN UARTReadChar(ULONG Port, CHAR *Value, ULONG Timeout)
+static BOOLEAN UARTReadChar(ULONG Port, CHAR *Value, ULONG Timeout)
{
ULONG i, j;
return FALSE;
}
-ULONG DetectMicrosoftMouse(ULONG Port)
+static ULONG DetectMicrosoftMouse(ULONG Port)
{
CHAR Buffer[8];
ULONG Count, i;
return MOUSE_TYPE_NONE;
}
-PDEVICE_OBJECT
+static PDEVICE_OBJECT
AllocatePointerDevice(PDRIVER_OBJECT DriverObject)
{
PDEVICE_OBJECT DeviceObject;
return DeviceObject;
}
-BOOLEAN
+static BOOLEAN
InitializeMouse(ULONG Port, ULONG Irq, PDRIVER_OBJECT DriverObject)
{
PDEVICE_EXTENSION DeviceExtension;
#ifdef BZ_DECOMPRESS_ONLY
+int _stdcall DriverEntry( void *a, void *b );
int _stdcall DriverEntry( void *a, void *b )
{
return 1;
}
#endif
+void bz_internal_error ( int errcode );
+
void bz_internal_error ( int errcode )
{
return;
return Status;
}
-NTSTATUS DDKAPI StreamSocketConnectComplete
+static NTSTATUS DDKAPI StreamSocketConnectComplete
( PDEVICE_OBJECT DeviceObject,
PIRP Irp,
PVOID Context ) {
#include "tdiconn.h"
#include "debug.h"
-VOID SatisfyAccept( PAFD_DEVICE_EXTENSION DeviceExt,
- PIRP Irp,
- PFILE_OBJECT NewFileObject,
- PAFD_TDI_OBJECT_QELT Qelt ) {
+static VOID SatisfyAccept( PAFD_DEVICE_EXTENSION DeviceExt,
+ PIRP Irp,
+ PFILE_OBJECT NewFileObject,
+ PAFD_TDI_OBJECT_QELT Qelt ) {
PAFD_FCB FCB = NewFileObject->FsContext;
if( !SocketAcquireStateLock( FCB ) ) return;
SocketStateUnlock( FCB );
}
-VOID SatisfyPreAccept( PIRP Irp, PAFD_TDI_OBJECT_QELT Qelt ) {
+static VOID SatisfyPreAccept( PIRP Irp, PAFD_TDI_OBJECT_QELT Qelt ) {
PAFD_RECEIVED_ACCEPT_DATA ListenReceive =
(PAFD_RECEIVED_ACCEPT_DATA)Irp->AssociatedIrp.SystemBuffer;
PTA_IP_ADDRESS IPAddr;
IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
}
-NTSTATUS DDKAPI ListenComplete
+static NTSTATUS DDKAPI ListenComplete
( PDEVICE_OBJECT DeviceObject,
PIRP Irp,
PVOID Context ) {
/* FUNCTIONS */
NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
+
+static NTSTATUS STDCALL
AfdCreateSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp) {
PAFD_FCB FCB;
AFD_DbgPrint(MIN_TRACE,("Leaving\n"));
}
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
AfdCloseSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
return STATUS_SUCCESS;
}
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
AfdDisconnect(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp) {
PFILE_OBJECT FileObject = IrpSp->FileObject;
return UnlockAndMaybeComplete( FCB, Status, Irp, 0, NULL, TRUE );
}
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
AfdDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
return (Status);
}
-VOID STDCALL
+static VOID STDCALL
AfdUnload(PDRIVER_OBJECT DriverObject)
{
}
#include "tdiconn.h"
#include "debug.h"
-BOOLEAN CantReadMore( PAFD_FCB FCB ) {
+static BOOLEAN CantReadMore( PAFD_FCB FCB ) {
UINT BytesAvailable = FCB->Recv.Content - FCB->Recv.BytesUsed;
return !BytesAvailable &&
(FCB->PollState & (AFD_EVENT_CLOSE | AFD_EVENT_DISCONNECT));
}
-VOID HandleEOFOnIrp( PAFD_FCB FCB, NTSTATUS Status, UINT Information ) {
+static VOID HandleEOFOnIrp( PAFD_FCB FCB, NTSTATUS Status, UINT Information ) {
if( Status == STATUS_SUCCESS && Information == 0 ) {
AFD_DbgPrint(MID_TRACE,("Looks like an EOF\n"));
FCB->PollState |= AFD_EVENT_DISCONNECT;
}
}
-NTSTATUS TryToSatisfyRecvRequestFromBuffer( PAFD_FCB FCB,
+static NTSTATUS TryToSatisfyRecvRequestFromBuffer( PAFD_FCB FCB,
PAFD_RECV_INFO RecvReq,
PUINT TotalBytesCopied ) {
UINT i, BytesToCopy = 0,
return STATUS_SUCCESS;
}
-NTSTATUS ReceiveActivity( PAFD_FCB FCB, PIRP Irp ) {
+static NTSTATUS ReceiveActivity( PAFD_FCB FCB, PIRP Irp ) {
PLIST_ENTRY NextIrpEntry;
PIRP NextIrp;
PIO_STACK_LOCATION NextIrpSp;
}
-NTSTATUS STDCALL
+static NTSTATUS STDCALL
SatisfyPacketRecvRequest( PAFD_FCB FCB, PIRP Irp,
PAFD_STORED_DATAGRAM DatagramRecv,
PUINT TotalBytesCopied ) {
#include "tdiconn.h"
#include "debug.h"
-VOID PrintEvents( ULONG Events ) {
+static VOID PrintEvents( ULONG Events ) {
#if DBG
char *events_list[] = { "AFD_EVENT_RECEIVE",
"AFD_EVENT_OOB_RECEIVE",
#endif
}
-VOID CopyBackStatus( PAFD_HANDLE HandleArray,
+static VOID CopyBackStatus( PAFD_HANDLE HandleArray,
UINT HandleCount ) {
UINT i;
}
}
-VOID ZeroEvents( PAFD_HANDLE HandleArray,
+static VOID ZeroEvents( PAFD_HANDLE HandleArray,
UINT HandleCount ) {
UINT i;
HandleArray[i].Status = 0;
}
-VOID RemoveSelect( PAFD_ACTIVE_POLL Poll ) {
+static VOID RemoveSelect( PAFD_ACTIVE_POLL Poll ) {
AFD_DbgPrint(MID_TRACE,("Called\n"));
RemoveEntryList( &Poll->ListEntry );
AFD_DbgPrint(MID_TRACE,("Done\n"));
}
-VOID SignalSocket( PAFD_ACTIVE_POLL Poll, PAFD_POLL_INFO PollReq,
+static VOID SignalSocket( PAFD_ACTIVE_POLL Poll, PAFD_POLL_INFO PollReq,
NTSTATUS Status ) {
UINT i;
PIRP Irp = Poll->Irp;
AFD_DbgPrint(MID_TRACE,("Done\n"));
}
-VOID SelectTimeout( PKDPC Dpc,
+static VOID SelectTimeout( PKDPC Dpc,
PVOID DeferredContext,
PVOID SystemArgument1,
PVOID SystemArgument2 ) {
}
/* * * NOTE ALWAYS CALLED AT DISPATCH_LEVEL * * */
-BOOLEAN UpdatePollWithFCB( PAFD_ACTIVE_POLL Poll, PFILE_OBJECT FileObject ) {
+static BOOLEAN UpdatePollWithFCB( PAFD_ACTIVE_POLL Poll, PFILE_OBJECT FileObject ) {
UINT i;
PAFD_FCB FCB;
UINT Signalled = 0;
#endif
#include "debug.h"
#include "tdiconn.h"
+#include "tdi_proto.h"
#ifdef DBG
-VOID DisplayBuffer(
+#if 0
+static VOID DisplayBuffer(
PVOID Buffer,
ULONG Size)
{
}
DbgPrint("\n");
}
+#endif
#endif /* DBG */
-NTSTATUS TdiCall(
+static NTSTATUS TdiCall(
PIRP Irp,
PDEVICE_OBJECT DeviceObject,
PKEVENT Event,
}
-NTSTATUS TdiOpenDevice(
+static NTSTATUS TdiOpenDevice(
PUNICODE_STRING DeviceName,
ULONG EaLength,
PFILE_FULL_EA_INFORMATION EaInfo,
return A;
}
-NTSTATUS TdiBuildNullConnectionInfoInPlace
+static NTSTATUS TdiBuildNullConnectionInfoInPlace
( PTDI_CONNECTION_INFORMATION ConnInfo,
ULONG Type )
/*
#include "tdiconn.h"
#include "debug.h"
-NTSTATUS DDKAPI SendComplete
+static NTSTATUS DDKAPI SendComplete
( PDEVICE_OBJECT DeviceObject,
PIRP Irp,
PVOID Context ) {
return STATUS_SUCCESS;
}
-NTSTATUS DDKAPI PacketSocketSendComplete
+static NTSTATUS DDKAPI PacketSocketSendComplete
( PDEVICE_OBJECT DeviceObject,
PIRP Irp,
PVOID Context ) {
LONG QueryType,
PMDL MdlBuffer);
+NTSTATUS TdiSetEventHandler(
+ PFILE_OBJECT FileObject,
+ LONG EventType,
+ PVOID Handler,
+ PVOID Context);
+
+NTSTATUS TdiQueryDeviceControl(
+ PFILE_OBJECT FileObject,
+ ULONG IoControlCode,
+ PVOID InputBuffer,
+ ULONG InputBufferLength,
+ PVOID OutputBuffer,
+ ULONG OutputBufferLength,
+ PULONG Return);
+
#endif/*_TDI_PROTO_H*/
/* Null-terminated array of ports to probe. This is "semi-risky" (Don Becker). */
ULONG ProbeAddressList[] = { 0x280, 0x300, 0x320, 0x340, 0x360, 0x380, 0 };
-BOOLEAN ProbeAddressForNIC(
+static BOOLEAN ProbeAddressForNIC(
ULONG address)
/*
* FUNCTION: Probes an address for a NIC
}
-BOOLEAN NICTestAddress(
+static BOOLEAN NICTestAddress(
PNIC_ADAPTER Adapter,
ULONG Address)
/*
}
-BOOLEAN NICTestRAM(
+static BOOLEAN NICTestRAM(
PNIC_ADAPTER Adapter)
/*
* FUNCTION: Finds out how much RAM a NIC has
}
-VOID NICSetPhysicalAddress(
+static VOID NICSetPhysicalAddress(
PNIC_ADAPTER Adapter)
/*
* FUNCTION: Initializes the physical address on the NIC
}
-VOID NICSetMulticastAddressMask(
+static VOID NICSetMulticastAddressMask(
PNIC_ADAPTER Adapter)
/*
* FUNCTION: Initializes the multicast address mask on the NIC
}
-BOOLEAN NICReadSAPROM(
+static BOOLEAN NICReadSAPROM(
PNIC_ADAPTER Adapter)
/*
* FUNCTION: Reads the Station Address PROM data from the NIC
}
-VOID NICStartTransmit(
+static VOID NICStartTransmit(
PNIC_ADAPTER Adapter)
/*
* FUNCTION: Starts transmitting a packet
}
-VOID NICSetBoundaryPage(
+static VOID NICSetBoundaryPage(
PNIC_ADAPTER Adapter)
/*
* FUNCTION: Sets the boundary page on the adapter to be one less than NextPacket
}
-VOID NICGetCurrentPage(
+static VOID NICGetCurrentPage(
PNIC_ADAPTER Adapter)
/*
* FUNCTION: Retrieves the current page from the adapter
}
-VOID NICIndicatePacket(
+static VOID NICIndicatePacket(
PNIC_ADAPTER Adapter)
/*
* FUNCTION: Indicates a packet to the wrapper
}
-VOID NICReadPacket(
+static VOID NICReadPacket(
PNIC_ADAPTER Adapter)
/*
* FUNCTION: Reads a full packet from the receive buffer ring
}
-VOID NICWritePacket(
+static VOID NICWritePacket(
PNIC_ADAPTER Adapter)
/*
* FUNCTION: Writes a full packet to the transmit buffer ring
}
-BOOLEAN NICPrepareForTransmit(
+static BOOLEAN NICPrepareForTransmit(
PNIC_ADAPTER Adapter)
/*
* FUNCTION: Prepares a packet for transmission
}
-VOID HandleReceive(
+static VOID HandleReceive(
PNIC_ADAPTER Adapter)
/*
* FUNCTION: Handles reception of a packet
}
-VOID HandleTransmit(
+static VOID HandleTransmit(
PNIC_ADAPTER Adapter)
/*
* FUNCTION: Handles transmission of a packet
#include <ne2000.h>
#include <debug.h>
+NTSTATUS
+#ifndef _MSC_VER
+STDCALL
+#endif
+DriverEntry(
+ PDRIVER_OBJECT DriverObject,
+ PUNICODE_STRING RegistryPath);
+
#ifdef DBG
NDIS_PHYSICAL_ADDRESS HighestAcceptableMax = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
-BOOLEAN MiniportCheckForHang(
+#if 0
+static BOOLEAN MiniportCheckForHang(
IN NDIS_HANDLE MiniportAdapterContext)
/*
* FUNCTION: Examines if an adapter has hung
return FALSE;
}
+#endif
-VOID STDCALL MiniportDisableInterrupt(
+static VOID STDCALL MiniportDisableInterrupt(
IN NDIS_HANDLE MiniportAdapterContext)
/*
* FUNCTION: Disables interrupts from an adapter
}
-VOID STDCALL MiniportEnableInterrupt(
+static VOID STDCALL MiniportEnableInterrupt(
IN NDIS_HANDLE MiniportAdapterContext)
/*
* FUNCTION: Enables interrupts from an adapter
}
-VOID STDCALL MiniportHalt(
+static VOID STDCALL MiniportHalt(
IN NDIS_HANDLE MiniportAdapterContext)
/*
* FUNCTION: Deallocates resources for and halts an adapter
}
-NDIS_STATUS STDCALL MiniportInitialize(
+static NDIS_STATUS STDCALL MiniportInitialize(
OUT PNDIS_STATUS OpenErrorStatus,
OUT PUINT SelectedMediumIndex,
IN PNDIS_MEDIUM MediumArray,
}
-VOID STDCALL MiniportISR(
+static VOID STDCALL MiniportISR(
OUT PBOOLEAN InterruptRecognized,
OUT PBOOLEAN QueueMiniportHandleInterrupt,
IN NDIS_HANDLE MiniportAdapterContext)
}
-NDIS_STATUS STDCALL MiniportQueryInformation(
+static NDIS_STATUS STDCALL MiniportQueryInformation(
IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
}
-NDIS_STATUS STDCALL MiniportReconfigure(
+static NDIS_STATUS STDCALL MiniportReconfigure(
OUT PNDIS_STATUS OpenErrorStatus,
IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_HANDLE WrapperConfigurationContext)
-NDIS_STATUS STDCALL MiniportReset(
+static NDIS_STATUS STDCALL MiniportReset(
OUT PBOOLEAN AddressingReset,
IN NDIS_HANDLE MiniportAdapterContext)
/*
}
-NDIS_STATUS STDCALL MiniportSend(
+static NDIS_STATUS STDCALL MiniportSend(
IN NDIS_HANDLE MiniportAdapterContext,
IN PNDIS_PACKET Packet,
IN UINT Flags)
}
-NDIS_STATUS STDCALL MiniportSetInformation(
+static NDIS_STATUS STDCALL MiniportSetInformation(
IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
}
-NDIS_STATUS STDCALL MiniportTransferData(
+static NDIS_STATUS STDCALL MiniportTransferData(
OUT PNDIS_PACKET Packet,
OUT PUINT BytesTransferred,
IN NDIS_HANDLE MiniportAdapterContext,
#define NDEBUG
#include <debug.h>
-VOID
+NTSTATUS
+STDCALL
+DriverEntry(
+ IN PDRIVER_OBJECT DriverObject,
+ IN PUNICODE_STRING RegistryPath);
+
+static VOID
STDCALL
MiniportHandleInterrupt(
IN NDIS_HANDLE MiniportAdapterContext)
NdisDprReleaseSpinLock(&Adapter->Lock);
}
-NDIS_STATUS
+static NDIS_STATUS
MiQueryCard(
IN PADAPTER Adapter)
/*
return NDIS_STATUS_SUCCESS;
}
-NDIS_STATUS
+static NDIS_STATUS
MiAllocateSharedMemory(
PADAPTER Adapter)
/*
return NDIS_STATUS_SUCCESS;
}
-VOID
+static VOID
MiPrepareInitializationBlock(
PADAPTER Adapter)
/*
Adapter->InitializationBlockVirt->TLEN = (LOG_NUMBER_OF_BUFFERS << 4) & 0xf0;
}
-VOID
+static VOID
MiFreeSharedMemory(
PADAPTER Adapter)
/*
}
}
-BOOLEAN
+static BOOLEAN
STDCALL
MiSyncStop(
IN PVOID SynchronizeContext)
return TRUE;
}
-VOID
+static VOID
STDCALL
MiniportHalt(
IN NDIS_HANDLE MiniportAdapterContext)
NdisFreeMemory(Adapter, 0, 0);
}
-BOOLEAN
+static BOOLEAN
STDCALL
MiSyncMediaDetection(
IN PVOID SynchronizeContext)
return FALSE;
}
-VOID
+static VOID
STDCALL
MiniportMediaDetectionTimer(
IN PVOID SystemSpecific1,
}
}
-VOID
+static VOID
MiInitChip(
PADAPTER Adapter)
/*
Adapter->Flags &= ~RESET_IN_PROGRESS;
}
-BOOLEAN
+static BOOLEAN
MiTestCard(
PADAPTER Adapter)
/*
return TRUE;
}
-NDIS_STATUS
+static NDIS_STATUS
STDCALL
MiniportInitialize(
OUT PNDIS_STATUS OpenErrorStatus,
return Status;
}
-VOID
+static VOID
STDCALL
MiniportISR(
OUT PBOOLEAN InterruptRecognized,
NdisRawWritePortUshort(Adapter->PortOffset + RAP, Rap);
}
-NDIS_STATUS
+static NDIS_STATUS
STDCALL
MiniportReset(
OUT PBOOLEAN AddressingReset,
return NDIS_STATUS_SUCCESS;
}
-BOOLEAN
+static BOOLEAN
STDCALL
MiSyncStartTransmit(
IN PVOID SynchronizeContext)
return TRUE;
}
-NDIS_STATUS
+static NDIS_STATUS
STDCALL
MiniportSend(
IN NDIS_HANDLE MiniportAdapterContext,
return NDIS_STATUS_SUCCESS;
}
-ULONG
+static ULONG
STDCALL
MiEthernetCrc(UCHAR *Address)
/*
extern void __stdcall RtlUnwind(void *, void *, void *, void *);
void const * _SEHRtlUnwind = RtlUnwind;
-void __stdcall _SEHLocalUnwind
+static void __stdcall _SEHLocalUnwind
(
_SEHPortableFrame_t * frame,
_SEHPortableTryLevel_t * dsttrylevel
}
}
-void __cdecl _SEHCallHandler
+static void __cdecl _SEHCallHandler
(
_SEHPortableFrame_t * frame,
_SEHPortableTryLevel_t * trylevel
frame->SPF_Handler(trylevel);
}
-int __cdecl _SEHFrameHandler
+static int __cdecl _SEHFrameHandler
(
struct _EXCEPTION_RECORD * ExceptionRecord,
void * EstablisherFrame,
RtlDestroyAtomTable@4
RtlDestroyHeap@4
RtlDowncaseUnicodeString@12
+RtlDuplicateUnicodeString@12
RtlEmptyAtomTable@8
RtlEnlargedIntegerMultiply@8
RtlEnlargedUnsignedDivide@16
IN PSID Source
);
+NTSYSAPI
+BOOLEAN
+NTAPI
+RtlCreateUnicodeString(
+ PUNICODE_STRING DestinationString,
+ PCWSTR SourceString
+);
+
NTSYSAPI
NTSTATUS
NTAPI
IN BOOLEAN AllocateDestinationString
);
+NTSYSAPI
+NTSTATUS
+NTAPI
+RtlDuplicateUnicodeString(
+ IN ULONG Flags,
+ IN PCUNICODE_STRING SourceString,
+ OUT PUNICODE_STRING DestinationString
+);
+
NTSYSAPI
BOOLEAN
NTAPI
projects / reactos.git / commitdiff