Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-12-27 01:24:38 +00:00
Code Issues Projects Releases Packages Wiki Activity

Eric's beep driver and changes to support same

Browse source 
svn path=/trunk/; revision=285
This commit is contained in:
Rex Jolliff 1999-03-10 05:16:57 +00:00
parent 2e61a84b9d
commit 3a2897ef52
13 changed files with 739 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

290
reactos/drivers/dd/beep/beep.c Normal file
View file

@ -0,0 +1,290 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: services/dd/beep/beep.c
* PURPOSE: BEEP device driver
* PROGRAMMER: Eric Kohl (ekohl@abo.rhein-zeitung.de)
* UPDATE HISTORY:
* Created 30/01/99
*/
/* INCLUDES ****************************************************************/
#include <ddk/ntddk.h>
#include <ddk/ntddbeep.h>
#define NDEBUG
#include <internal/debug.h>
/* TYEPEDEFS ***************************************************************/
typedef struct _BEEP_DEVICE_EXTENSION
{
KDPC Dpc;
KTIMER Timer;
KEVENT Event;
DWORD BeepOn;
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;
/* FUNCTIONS ***************************************************************/
VOID BeepDPC(PKDPC Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
{
PDEVICE_EXTENSION pDeviceExtension = DeferredContext;
DPRINT("BeepDPC() called!\n");
HalMakeBeep (0);
InterlockedExchange (&(pDeviceExtension->BeepOn), 0);
KeSetEvent (&(pDeviceExtension->Event), 0, TRUE);
DPRINT("BeepDPC() finished!\n");
}
NTSTATUS BeepCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp)
/*
* FUNCTION: Handles user mode requests
* ARGUMENTS:
* DeviceObject = Device for request
* Irp = I/O request packet describing request
* RETURNS: Success or failure
*/
{
PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
NTSTATUS status;
if (Stack->MajorFunction == IRP_MJ_CREATE)
{
DPRINT ("BeepCreate() called!\n");
Irp->IoStatus.Information = 0;
status = STATUS_SUCCESS;
}
else
status = STATUS_NOT_IMPLEMENTED;
Irp->IoStatus.Status = status;
IoCompleteRequest(Irp,IO_NO_INCREMENT);
return(status);
}
NTSTATUS BeepClose(PDEVICE_OBJECT DeviceObject, PIRP Irp)
/*
* FUNCTION: Handles user mode requests
* ARGUMENTS:
* DeviceObject = Device for request
* Irp = I/O request packet describing request
* RETURNS: Success or failure
*/
{
PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
NTSTATUS status;
switch (Stack->MajorFunction)
{
case IRP_MJ_CLOSE:
DPRINT ("BeepClose() called!\n");
Irp->IoStatus.Information = 0;
status = STATUS_SUCCESS;
break;
default:
status = STATUS_NOT_IMPLEMENTED;
}
Irp->IoStatus.Status = status;
IoCompleteRequest(Irp,IO_NO_INCREMENT);
return(status);
}
NTSTATUS BeepCleanup(PDEVICE_OBJECT DeviceObject, PIRP Irp)
/*
* FUNCTION: Handles user mode requests
* ARGUMENTS:
* DeviceObject = Device for request
* Irp = I/O request packet describing request
* RETURNS: Success or failure
*/
{
PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
NTSTATUS status;
if (Stack->MajorFunction == IRP_MJ_CLEANUP)
{
DPRINT ("BeepCleanup() called!\n");
Irp->IoStatus.Information = 0;
status = STATUS_SUCCESS;
}
else
status = STATUS_NOT_IMPLEMENTED;
Irp->IoStatus.Status = status;
IoCompleteRequest(Irp,IO_NO_INCREMENT);
return(status);
}
NTSTATUS BeepDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
/*
* FUNCTION: Handles user mode requests
* ARGUMENTS:
* DeviceObject = Device for request
* Irp = I/O request packet describing request
* RETURNS: Success or failure
*/
{
PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
PDEVICE_EXTENSION pDeviceExtension;
PBEEP_SET_PARAMETERS pbsp;
NTSTATUS status;
pDeviceExtension = DeviceObject->DeviceExtension;
if (Stack->MajorFunction == IRP_MJ_DEVICE_CONTROL)
{
DPRINT("BeepDeviceControl() called!\n");
if (Stack->Parameters.DeviceIoControl.IoControlCode == IOCTL_BEEP_SET)
{
Irp->IoStatus.Information = 0;
if (Stack->Parameters.DeviceIoControl.InputBufferLength == sizeof(BEEP_SET_PARAMETERS))
{
pbsp = (PBEEP_SET_PARAMETERS)Irp->AssociatedIrp.SystemBuffer;
if (pbsp->Frequency >= BEEP_FREQUENCY_MINIMUM &&
pbsp->Frequency <= BEEP_FREQUENCY_MAXIMUM)
{
LARGE_INTEGER DueTime = 0;
/* do the beep!! */
DPRINT("Beep:\n Freq: %lu Hz\n Dur: %lu ms\n",
pbsp->Frequency, pbsp->Duration);
if (pbsp->Duration >= 0)
{
DueTime = (LARGE_INTEGER)pbsp->Duration * 10000;
KeSetTimer (&pDeviceExtension->Timer,
-DueTime,
&pDeviceExtension->Dpc);
HalMakeBeep (pbsp->Frequency);
InterlockedExchange(&(pDeviceExtension->BeepOn), TRUE);
KeWaitForSingleObject (&(pDeviceExtension->Event),
Executive,
KernelMode,
FALSE,
NULL);
}
else if (pbsp->Duration == (DWORD)-1)
{
if (pDeviceExtension->BeepOn)
{
HalMakeBeep(0);
InterlockedExchange(&(pDeviceExtension->BeepOn), FALSE);
}
else
{
HalMakeBeep(pbsp->Frequency);
InterlockedExchange(&(pDeviceExtension->BeepOn), TRUE);
}
}
DPRINT("Did the beep!\n");
status = STATUS_SUCCESS;
}
else
{
status = STATUS_INVALID_PARAMETER;
}
}
else
{
status = STATUS_INVALID_PARAMETER;
}
}
else
{
status = STATUS_NOT_IMPLEMENTED;
}
}
else
status = STATUS_NOT_IMPLEMENTED;
Irp->IoStatus.Status = status;
IoCompleteRequest(Irp,IO_NO_INCREMENT);
return(status);
}
NTSTATUS BeepUnload(PDRIVER_OBJECT DriverObject)
{
DPRINT("BeepUnload() called!\n");
return(STATUS_SUCCESS);
}
NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
/*
* FUNCTION: Called by the system to initalize the driver
* ARGUMENTS:
* DriverObject = object describing this driver
* RegistryPath = path to our configuration entries
* RETURNS: Success or failure
*/
{
PDEVICE_OBJECT pDeviceObject;
PDEVICE_EXTENSION pDeviceExtension;
NTSTATUS ret;
ANSI_STRING ansi_device_name;
UNICODE_STRING device_name;
ANSI_STRING asymlink_name;
UNICODE_STRING symlink_name;
DbgPrint("Beep Device Driver 0.0.1\n");
RtlInitAnsiString(&ansi_device_name,"\\Device\\Beep");
RtlAnsiStringToUnicodeString(&device_name,&ansi_device_name,TRUE);
ret = IoCreateDevice(DriverObject,
sizeof(DEVICE_EXTENSION),
&device_name,
FILE_DEVICE_BEEP,
0,
FALSE,
&pDeviceObject);
if (ret!=STATUS_SUCCESS)
{
return(ret);
}
/* prelininary */
RtlInitAnsiString(&asymlink_name,"\\??\\Beep");
RtlAnsiStringToUnicodeString(&symlink_name,&asymlink_name,TRUE);
IoCreateSymbolicLink(&symlink_name,&device_name);
DriverObject->MajorFunction[IRP_MJ_CREATE] = BeepCreate;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = BeepClose;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = BeepCleanup;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = BeepDeviceControl;
DriverObject->DriverUnload = BeepUnload;
/* set up device extension */
pDeviceObject->Flags |= DO_BUFFERED_IO;
pDeviceExtension = pDeviceObject->DeviceExtension;
pDeviceExtension->BeepOn = FALSE;
KeInitializeDpc (&(pDeviceExtension->Dpc),
BeepDPC,
pDeviceExtension);
KeInitializeTimer (&(pDeviceExtension->Timer));
KeInitializeEvent (&(pDeviceExtension->Event),
SynchronizationEvent,
FALSE);
return(STATUS_SUCCESS);
}

1
reactos/drivers/dd/beep/makefile Normal file
View file

@ -0,0 +1 @@
all: beep.o

5
reactos/include/ddk/ioctrl.h
View file

@ -4,6 +4,11 @@
#define CTL_CODE(Dev, Func, Meth, Acc) ( ((Dev)<<16) | ((Acc)<<14) | ((Func)<<2) | (Meth))
#define DEVICE_TYPE_FROM_CTL_CODE(ctlCode) (((ULONG)(ctlCode&0xffff0000))>>16)
#define IO_METHOD_FROM_CTL_CODE(ctlCode) (ctlCode&0x00000003)
// IOCTL Parameter buffering methods
#define METHOD_BUFFERED 0
#define METHOD_IN_DIRECT 1

1
reactos/include/internal/hal/ddk.h
View file

@ -113,5 +113,6 @@ BOOLEAN HalTranslateBusAddress(INTERFACE_TYPE InterfaceType,
PHYSICAL_ADDRESS BusAddress,
PULONG AddressSpace,
PPHYSICAL_ADDRESS TranslatedAddress);
BOOLEAN HalMakeBeep(ULONG Frequency);
VOID HalQueryRealTimeClock(PTIME_FIELDS pTime);
#endif /* __INCLUDE_INTERNAL_HAL_DDK_H */

38
reactos/lib/kernel32/misc/error.c
View file

@ -1,5 +1,6 @@
#include <windows.h>
#include <ddk/ntddk.h>
#include <ddk/ntddbeep.h>
static DWORD LastError;
@ -33,3 +34,40 @@ PVOID __ErrorReturnNull(ULONG ErrorCode)
{
return(NULL);
}
WINBOOL
STDCALL
Beep (DWORD dwFreq, DWORD dwDuration)
{
HANDLE hBeep;
BEEP_SET_PARAMETERS BeepSetParameters;
DWORD dwReturned;
hBeep = CreateFile("\\Beep",
FILE_GENERIC_READ | FILE_GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
0,
NULL);
if (!hBeep)
return FALSE;
/* Set beep data */
BeepSetParameters.Frequency = dwFreq;
BeepSetParameters.Duration = dwDuration;
DeviceIoControl(hBeep,
IOCTL_BEEP_SET,
&BeepSetParameters,
sizeof(BEEP_SET_PARAMETERS),
NULL,
0,
&dwReturned,
NULL);
CloseHandle (hBeep);
return TRUE;
}

13
reactos/lib/ntdll/string/ctype.c
View file

@ -17,6 +17,13 @@ char toupper(char c)
return(c);
}
char tolower(char c)
{
if (c>='A' && c <= 'Z')
return (c - upalpha);
return(c);
}
int islower(char c)
{
if ((c>='a') && (c<='z')) return 1;
@ -38,5 +45,11 @@ int isxdigit(char c)
return 0;
}
int iscntrl(char c)
{
if ((c >=0x00 && c <= 0x1f) || c == 0x7f);
return 1;
return 0;
}

2
reactos/lib/ntdll/stubs/stubs.c
View file

@ -541,7 +541,6 @@ STUB(cos)
STUB(fabs)
STUB(floor)
STUB(isalnum)
STUB(iscntrl)
STUB(isgraph)
STUB(isprint)
STUB(ispunct)
@ -576,4 +575,3 @@ STUB(strtol)
STUB(strtoul)
STUB(swprintf)
STUB(tan)
STUB(towlower)

1
reactos/ntoskrnl/exports.lst
View file

@ -97,6 +97,7 @@ HalGetBusData
HalGetBusDataByOffset
HalGetDmaAlignmentRequirement
HalGetInterruptVector
HalMakeBeep
HalQuerySystemInformation
HalReadDmaCounter
HalSetBusData

8
reactos/ntoskrnl/hal/x86/sources
View file

@ -1,5 +1,5 @@
HAL_OBJECTS = hal/x86/head.o hal/x86/irq.o hal/x86/exp.o hal/x86/isa.o \
hal/x86/pci.o hal/x86/irqhand.o hal/x86/page.o hal/x86/halinit.o \
hal/x86/irql.o hal/x86/bios32.o hal/x86/thread.o hal/x86/spinlock.o \
hal/x86/printk.o hal/x86/mp.o hal/x86/dma.o hal/x86/bus.o hal/x86/mbr.o \
hal/x86/sysinfo.o hal/x86/usercall.o hal/x86/time.o
hal/x86/pci.o hal/x86/irqhand.o hal/x86/page.o hal/x86/halinit.o \
hal/x86/irql.o hal/x86/bios32.o hal/x86/thread.o hal/x86/spinlock.o \
hal/x86/printk.o hal/x86/mp.o hal/x86/dma.o hal/x86/bus.o hal/x86/mbr.o \
hal/x86/sysinfo.o hal/x86/time.o hal/x86/usercall.o hal/x86/beep.o

200
reactos/ntoskrnl/io/buildirp.c
View file

@ -6,6 +6,7 @@
* PROGRAMMER: David Welch (welch@mcmail.com)
* UPDATE HISTORY:
* Created 22/05/98
* Fixed IO method handling 04/03/99
*/
/* INCLUDES *****************************************************************/
@ -31,31 +32,31 @@ NTSTATUS IoPrepareIrpBuffer(PIRP Irp,
{
DPRINT("Doing buffer i/o\n");
Irp->AssociatedIrp.SystemBuffer = (PVOID)
ExAllocatePool(NonPagedPool,Length);
ExAllocatePool(NonPagedPool,Length);
if (Irp->AssociatedIrp.SystemBuffer==NULL)
{
IoFreeIrp(Irp);
return(STATUS_NOT_IMPLEMENTED);
}
/* FIXME: should copy buffer in on other ops */
if (MajorFunction == IRP_MJ_WRITE)
{
RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, Buffer, Length);
}
/* FIXME: should copy buffer in on other ops */
if (MajorFunction == IRP_MJ_WRITE)
{
RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, Buffer, Length);
}
}
if (DeviceObject->Flags & DO_DIRECT_IO)
{
DPRINT("Doing direct i/o\n");
Irp->MdlAddress = MmCreateMdl(NULL,Buffer,Length);
if (MajorFunction == IRP_MJ_READ)
{
MmProbeAndLockPages(Irp->MdlAddress,UserMode,IoWriteAccess);
}
else
{
MmProbeAndLockPages(Irp->MdlAddress,UserMode,IoReadAccess);
}
if (MajorFunction == IRP_MJ_READ)
{
MmProbeAndLockPages(Irp->MdlAddress,UserMode,IoWriteAccess);
}
else
{
MmProbeAndLockPages(Irp->MdlAddress,UserMode,IoReadAccess);
}
Irp->UserBuffer = NULL;
Irp->AssociatedIrp.SystemBuffer = NULL;
}
@ -75,7 +76,7 @@ PIRP IoBuildFilesystemControlRequest(ULONG MinorFunction,
* UserEvent = Event used to notify the caller of completion
* IoStatusBlock (OUT) = Used to return the status of the operation
* DeviceToMount = Device to mount (for the IRP_MN_MOUNT_DEVICE
* request)
* request)
*/
{
PIRP Irp;
@ -192,7 +193,7 @@ PIRP IoBuildAsynchronousFsdRequest(ULONG MajorFunction,
{
SET_LARGE_INTEGER_LOW_PART(StackPtr->Parameters.Write.ByteOffset, 0);
SET_LARGE_INTEGER_HIGH_PART(StackPtr->Parameters.Write.ByteOffset, 0);
}
}
}
Irp->UserIosb = IoStatusBlock;
@ -209,8 +210,145 @@ PIRP IoBuildDeviceIoControlRequest(ULONG IoControlCode,
BOOLEAN InternalDeviceIoControl,
PKEVENT Event,
PIO_STATUS_BLOCK IoStatusBlock)
/*
* FUNCTION: Allocates and sets up an IRP to be sent to drivers
* ARGUMENTS:
* IoControlCode = Device io control code
* DeviceObject = Device object to send the irp to
* InputBuffer = Buffer from which data will be read by the driver
* InputBufferLength = Length in bytes of the input buffer
* OutputBuffer = Buffer into which data will be written by the driver
* OutputBufferLength = Length in bytes of the output buffer
* InternalDeviceIoControl = Determines weather
* IRP_MJ_INTERNAL_DEVICE_CONTROL or
* IRP_MJ_DEVICE_CONTROL will be used
* Event = Event used to notify the caller of completion
* IoStatusBlock (OUT) = Storage for the result of the operation
* RETURNS: The IRP allocated on success, or
* NULL on failure
*/
{
UNIMPLEMENTED;
PIRP Irp;
PIO_STACK_LOCATION StackPtr;
DPRINT("IoBuildDeviceIoRequest(IoControlCode %x, DeviceObject %x, "
"InputBuffer %x, InputBufferLength %x, OutputBuffer %x, "
"OutputBufferLength %x, InternalDeviceIoControl %x "
"Event %x, IoStatusBlock %x\n",IoControlCode,DeviceObject,
InputBuffer,InputBufferLength,OutputBuffer,OutputBufferLength,
InternalDeviceIoControl,Event,IoStatusBlock);
Irp = IoAllocateIrp(DeviceObject->StackSize,TRUE);
if (Irp==NULL)
{
return(NULL);
}
Irp->UserEvent = Event;
Irp->UserIosb = IoStatusBlock;
StackPtr = IoGetNextIrpStackLocation(Irp);
StackPtr->MajorFunction = InternalDeviceIoControl ? IRP_MJ_INTERNAL_DEVICE_CONTROL : IRP_MJ_DEVICE_CONTROL;
StackPtr->MinorFunction = 0;
StackPtr->Flags = 0;
StackPtr->Control = 0;
StackPtr->DeviceObject = DeviceObject;
StackPtr->FileObject = NULL;
StackPtr->CompletionRoutine = NULL;
StackPtr->Parameters.DeviceIoControl.IoControlCode = IoControlCode;
StackPtr->Parameters.DeviceIoControl.InputBufferLength = InputBufferLength;
StackPtr->Parameters.DeviceIoControl.OutputBufferLength = OutputBufferLength;
if (IO_METHOD_FROM_CTL_CODE(IoControlCode) == METHOD_BUFFERED)
{
ULONG BufferLength;
DPRINT("Using METHOD_BUFFERED!\n");
BufferLength = (InputBufferLength>OutputBufferLength)?InputBufferLength:OutputBufferLength;
if (BufferLength)
{
Irp->AssociatedIrp.SystemBuffer = (PVOID)
ExAllocatePool(NonPagedPool,BufferLength);
if (Irp->AssociatedIrp.SystemBuffer==NULL)
{
IoFreeIrp(Irp);
return(NULL);
}
}
if (InputBuffer && InputBufferLength)
{
RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
InputBuffer,
InputBufferLength);
}
}
else if (IO_METHOD_FROM_CTL_CODE(IoControlCode) == METHOD_IN_DIRECT)
{
DPRINT("Using METHOD_IN_DIRECT!\n");
/* build input buffer (control buffer) */
if (InputBuffer && InputBufferLength)
{
Irp->AssociatedIrp.SystemBuffer = (PVOID)
ExAllocatePool(NonPagedPool,InputBufferLength);
if (Irp->AssociatedIrp.SystemBuffer==NULL)
{
IoFreeIrp(Irp);
return(NULL);
}
RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
InputBuffer,
InputBufferLength);
}
/* build output buffer (data transfer buffer) */
if (OutputBuffer && OutputBufferLength)
{
PMDL Mdl = IoAllocateMdl (OutputBuffer,OutputBufferLength, FALSE, FALSE, Irp);
MmProbeAndLockPages (Mdl, UserMode,IoReadAccess);
}
}
else if (IO_METHOD_FROM_CTL_CODE(IoControlCode) == METHOD_OUT_DIRECT)
{
DPRINT("Using METHOD_OUT_DIRECT!\n");
/* build input buffer (control buffer) */
if (InputBuffer && InputBufferLength)
{
Irp->AssociatedIrp.SystemBuffer = (PVOID)
ExAllocatePool(NonPagedPool,InputBufferLength);
if (Irp->AssociatedIrp.SystemBuffer==NULL)
{
IoFreeIrp(Irp);
return(NULL);
}
RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
InputBuffer,
InputBufferLength);
}
/* build output buffer (data transfer buffer) */
if (OutputBuffer && OutputBufferLength)
{
PMDL Mdl = IoAllocateMdl (OutputBuffer,OutputBufferLength, FALSE, FALSE, Irp);
MmProbeAndLockPages (Mdl, UserMode,IoWriteAccess);
}
}
else if (IO_METHOD_FROM_CTL_CODE(IoControlCode) == METHOD_NEITHER)
{
DPRINT("Using METHOD_NEITHER!\n");
Irp->UserBuffer = OutputBuffer;
StackPtr->Parameters.DeviceIoControl.Type3InputBuffer = InputBuffer;
}
return(Irp);
}
PIRP IoBuildSynchronousFsdRequest(ULONG MajorFunction,
@ -274,31 +412,31 @@ PIRP IoBuildSynchronousFsdRequest(ULONG MajorFunction,
if (MajorFunction == IRP_MJ_READ)
{
if (StartingOffset != NULL)
{
StackPtr->Parameters.Read.ByteOffset = *StartingOffset;
}
{
StackPtr->Parameters.Read.ByteOffset = *StartingOffset;
}
else
{
SET_LARGE_INTEGER_LOW_PART(StackPtr->Parameters.Read.ByteOffset,
{
SET_LARGE_INTEGER_LOW_PART(StackPtr->Parameters.Read.ByteOffset,
0);
SET_LARGE_INTEGER_HIGH_PART(StackPtr->Parameters.Read.ByteOffset,
SET_LARGE_INTEGER_HIGH_PART(StackPtr->Parameters.Read.ByteOffset,
0);
}
}
StackPtr->Parameters.Read.Length = Length;
}
else
{
if (StartingOffset!=NULL)
{
StackPtr->Parameters.Write.ByteOffset = *StartingOffset;
}
{
StackPtr->Parameters.Write.ByteOffset = *StartingOffset;
}
else
{
SET_LARGE_INTEGER_LOW_PART(StackPtr->Parameters.Write.ByteOffset,
{
SET_LARGE_INTEGER_LOW_PART(StackPtr->Parameters.Write.ByteOffset,
0);
SET_LARGE_INTEGER_HIGH_PART(StackPtr->Parameters.Write.ByteOffset,
SET_LARGE_INTEGER_HIGH_PART(StackPtr->Parameters.Write.ByteOffset,
0);
}
}
StackPtr->Parameters.Write.Length = Length;
}

169
reactos/ntoskrnl/io/ioctrl.c
View file

@ -1,17 +1,21 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: kernel/base/bug.c
* PURPOSE: Graceful system shutdown if a bug is detected
* FILE: ntoskrnl/io/ioctrl.c
* PURPOSE: Device IO control
* PROGRAMMER: David Welch (welch@mcmail.com)
* Eric Kohl (ekohl@abo.rhein-zeitung.de)
* UPDATE HISTORY:
* Created 22/05/98
* Filled in ZwDeviceIoControlFile 22/02/99
* Fixed IO method handling 08/03/99
*/
/* INCLUDES *****************************************************************/
#include <ddk/ntddk.h>
#define NDEBUG
#include <internal/debug.h>
/* FUNCTIONS *****************************************************************/
@ -24,33 +28,150 @@ ULONG IoGetFunctionCodeFromCtlCode(ULONG ControlCode)
NTSTATUS
STDCALL
NtDeviceIoControlFile(
IN HANDLE DeviceHandle,
IN HANDLE Event OPTIONAL,
IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL,
IN PVOID UserApcContext OPTIONAL,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN ULONG IoControlCode,
IN PVOID InputBuffer,
IN ULONG InputBufferSize,
OUT PVOID OutputBuffer,
IN ULONG OutputBufferSize
)
IN HANDLE DeviceHandle,
IN HANDLE Event OPTIONAL,
IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL,
IN PVOID UserApcContext OPTIONAL,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN ULONG IoControlCode,
IN PVOID InputBuffer,
IN ULONG InputBufferSize,
OUT PVOID OutputBuffer,
IN ULONG OutputBufferSize
)
{
return(ZwDeviceIoControlFile(DeviceHandle,
Event,
UserApcRoutine,
UserApcContext,
IoStatusBlock,
IoControlCode,
InputBuffer,
InputBufferSize,
OutputBuffer,
OutputBufferSize));
}
/*
* NOTES: No apc support yet!
*/
NTSTATUS
STDCALL
ZwDeviceIoControlFile(
IN HANDLE DeviceHandle,
IN HANDLE Event OPTIONAL,
IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL,
IN PVOID UserApcContext OPTIONAL,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN ULONG IoControlCode,
IN PVOID InputBuffer,
IN ULONG InputBufferSize,
OUT PVOID OutputBuffer,
IN ULONG OutputBufferSize
)
IN HANDLE DeviceHandle,
IN HANDLE Event OPTIONAL,
IN PIO_APC_ROUTINE UserApcRoutine OPTIONAL,
IN PVOID UserApcContext OPTIONAL,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN ULONG IoControlCode,
IN PVOID InputBuffer,
IN ULONG InputBufferSize,
OUT PVOID OutputBuffer,
IN ULONG OutputBufferSize
)
{
NTSTATUS Status;
PFILE_OBJECT FileObject;
PDEVICE_OBJECT DeviceObject;
PIRP Irp;
PIO_STACK_LOCATION StackPtr;
KEVENT KEvent;
assert(KeGetCurrentIrql()==PASSIVE_LEVEL);
DPRINT("ZwDeviceIoControlFile(DeviceHandle %x Event %x UserApcRoutine %x "
"UserApcContext %x IoStatusBlock %x InputBuffer %x "
"InputBufferSize %x OutputBuffer %x OutputBufferSize %x)\n",
DeviceHandle,Event,UserApcRoutine,UserApcContext,IoStatusBlock,
InputBuffer,InputBufferSize,OutputBuffer,OutputBufferSize);
Status = ObReferenceObjectByHandle(DeviceHandle,
FILE_READ_DATA | FILE_WRITE_DATA,
NULL,
KernelMode,
(PVOID *) &FileObject,
NULL);
if (Status != STATUS_SUCCESS)
{
return(Status);
}
DeviceObject = FileObject->DeviceObject;
assert(DeviceObject != NULL);
KeInitializeEvent(&KEvent,NotificationEvent,TRUE);
Irp = IoBuildDeviceIoControlRequest(IoControlCode,
DeviceObject,
InputBuffer,
InputBufferSize,
OutputBuffer,
OutputBufferSize,
FALSE,
&KEvent,
IoStatusBlock);
StackPtr = IoGetNextIrpStackLocation(Irp);
StackPtr->DeviceObject = DeviceObject;
StackPtr->Parameters.DeviceIoControl.InputBufferLength = InputBufferSize;
StackPtr->Parameters.DeviceIoControl.OutputBufferLength = OutputBufferSize;
Status = IoCallDriver(DeviceObject,Irp);
if (Status == STATUS_PENDING && (FileObject->Flags & FO_SYNCHRONOUS_IO))
{
KeWaitForSingleObject(&KEvent,Executive,KernelMode,FALSE,NULL);
return(IoStatusBlock->Status);
}
if (IO_METHOD_FROM_CTL_CODE(IoControlCode) == METHOD_BUFFERED)
{
DPRINT ("Using METHOD_BUFFERED!\n");
/* copy output buffer back and free it */
if (Irp->AssociatedIrp.SystemBuffer)
{
if (OutputBuffer && OutputBufferSize)
{
RtlCopyMemory(OutputBuffer,
Irp->AssociatedIrp.SystemBuffer,
OutputBufferSize);
}
ExFreePool (Irp->AssociatedIrp.SystemBuffer);
}
}
else if (IO_METHOD_FROM_CTL_CODE(IoControlCode) == METHOD_IN_DIRECT)
{
DPRINT ("Using METHOD_IN_DIRECT!\n");
/* free input buffer (control buffer) */
if (Irp->AssociatedIrp.SystemBuffer)
ExFreePool (Irp->AssociatedIrp.SystemBuffer);
/* free output buffer (data transfer buffer) */
if (Irp->MdlAddress)
IoFreeMdl (Irp->MdlAddress);
}
else if (IO_METHOD_FROM_CTL_CODE(IoControlCode) == METHOD_OUT_DIRECT)
{
DPRINT ("Using METHOD_OUT_DIRECT!\n");
/* free input buffer (control buffer) */
if (Irp->AssociatedIrp.SystemBuffer)
ExFreePool (Irp->AssociatedIrp.SystemBuffer);
/* free output buffer (data transfer buffer) */
if (Irp->MdlAddress)
IoFreeMdl (Irp->MdlAddress);
}
else if (IO_METHOD_FROM_CTL_CODE(IoControlCode) == METHOD_NEITHER)
{
DPRINT ("Using METHOD_NEITHER!\n");
/* nothing to do */
}
return(Status);
}

3
reactos/ntoskrnl/io/resource.c
View file

@ -16,7 +16,8 @@
/* GLOBALS *******************************************************************/
static CONFIGURATION_INFORMATION SystemConfigurationInformation = {0,};
static CONFIGURATION_INFORMATION SystemConfigurationInformation =
{0, 0, 0, 0, 0, 0, 0, FALSE, FALSE};
/* FUNCTIONS *****************************************************************/

71
reactos/ntoskrnl/tst/test.c
View file

@ -18,6 +18,8 @@
#include <internal/i386/segment.h>
#include <internal/ps.h>
#include <ddk/ntddbeep.h>
#define NDEBUG
#include <internal/debug.h>
@ -393,8 +395,75 @@ void TstIDERead(void)
}
}
void TstBegin()
NTSTATUS TstBeepDriver(DWORD dwFreq, DWORD dwDuration)
{
NTSTATUS Status;
HANDLE hBeep;
ANSI_STRING AnsiDeviceName;
UNICODE_STRING UnicodeDeviceName;
OBJECT_ATTRIBUTES ObjectAttributes;
IO_STATUS_BLOCK IoStatusBlock;
BEEP_SET_PARAMETERS BeepSetParameters;
RtlInitAnsiString(&AnsiDeviceName, "\\Device\\Beep");
RtlAnsiStringToUnicodeString(&UnicodeDeviceName,
&AnsiDeviceName, TRUE);
InitializeObjectAttributes(&ObjectAttributes,
&UnicodeDeviceName,
0,
NULL,
NULL);
Status = ZwCreateFile(&hBeep,
FILE_GENERIC_WRITE,
&ObjectAttributes,
&IoStatusBlock,
0,
FILE_ATTRIBUTE_NORMAL,
0,
FILE_OPEN,
0,
NULL,
0);
if (!NT_SUCCESS(Status))
{
return Status;
}
/* Set beep data */
BeepSetParameters.Frequency = dwFreq;
BeepSetParameters.Duration = dwDuration;
Status = ZwDeviceIoControlFile(hBeep,
NULL,
NULL,
NULL,
&IoStatusBlock,
IOCTL_BEEP_SET,
&BeepSetParameters,
sizeof(BEEP_SET_PARAMETERS),
NULL,
0);
if (!NT_SUCCESS(Status))
{
ZwClose (hBeep);
return Status;
}
ZwClose(hBeep);
return STATUS_SUCCESS;
}
void TstBegin(void)
{
// TstBeepDriver(440, 100);
// TstBeepDriver(880, 200);
// TstBeepDriver(440, 100);
ExExecuteShell();
}