Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-02 05:45:50 +00:00
Code Issues Projects Releases Packages Wiki Activity

[BATTC] Fix indentation. No code changes!

Browse source
This commit is contained in:
Eric Kohl 2019-01-01 12:58:53 +01:00
parent f76a097a25
commit 04524fef3b
2 changed files with 246 additions and 244 deletions
Download patch file Download diff file Expand all files Collapse all files

473
drivers/battery/battc/battc.c
View file

@ -16,9 +16,9 @@ NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject, DriverEntry(PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath) PUNICODE_STRING RegistryPath)
{ {
DPRINT("Battery class driver initialized\n"); DPRINT("Battery class driver initialized\n");
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
BCLASSAPI BCLASSAPI
@ -26,20 +26,20 @@ NTSTATUS
NTAPI NTAPI
BatteryClassUnload(PVOID ClassData) BatteryClassUnload(PVOID ClassData)
{ {
PBATTERY_CLASS_DATA BattClass = ClassData; PBATTERY_CLASS_DATA BattClass = ClassData;
DPRINT("Battery 0x%x is being unloaded\n"); DPRINT("Battery 0x%x is being unloaded\n");
if (BattClass->InterfaceName.Length != 0) if (BattClass->InterfaceName.Length != 0)
{ {
IoSetDeviceInterfaceState(&BattClass->InterfaceName, FALSE); IoSetDeviceInterfaceState(&BattClass->InterfaceName, FALSE);
RtlFreeUnicodeString(&BattClass->InterfaceName); RtlFreeUnicodeString(&BattClass->InterfaceName);
} }
ExFreePoolWithTag(BattClass, ExFreePoolWithTag(BattClass,
BATTERY_CLASS_DATA_TAG); BATTERY_CLASS_DATA_TAG);
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
BCLASSAPI BCLASSAPI
@ -51,9 +51,9 @@ BatteryClassSystemControl(PVOID ClassData,
PIRP Irp, PIRP Irp,
PVOID Disposition) PVOID Disposition)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
return STATUS_WMI_GUID_NOT_FOUND; return STATUS_WMI_GUID_NOT_FOUND;
} }
BCLASSAPI BCLASSAPI
@ -67,9 +67,9 @@ BatteryClassQueryWmiDataBlock(PVOID ClassData,
ULONG OutBufferSize, ULONG OutBufferSize,
PUCHAR Buffer) PUCHAR Buffer)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
return STATUS_WMI_GUID_NOT_FOUND; return STATUS_WMI_GUID_NOT_FOUND;
} }
BCLASSAPI BCLASSAPI
@ -77,54 +77,54 @@ NTSTATUS
NTAPI NTAPI
BatteryClassStatusNotify(PVOID ClassData) BatteryClassStatusNotify(PVOID ClassData)
{ {
PBATTERY_CLASS_DATA BattClass = ClassData; PBATTERY_CLASS_DATA BattClass = ClassData;
PBATTERY_WAIT_STATUS BattWait = BattClass->EventTriggerContext; PBATTERY_WAIT_STATUS BattWait = BattClass->EventTriggerContext;
BATTERY_STATUS BattStatus; BATTERY_STATUS BattStatus;
NTSTATUS Status; NTSTATUS Status;
DPRINT("Received battery status notification from 0x%x\n", ClassData); DPRINT("Received battery status notification from 0x%x\n", ClassData);
ExAcquireFastMutex(&BattClass->Mutex); ExAcquireFastMutex(&BattClass->Mutex);
if (!BattClass->Waiting) if (!BattClass->Waiting)
{ {
ExReleaseFastMutex(&BattClass->Mutex); ExReleaseFastMutex(&BattClass->Mutex);
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
switch (BattClass->EventTrigger) switch (BattClass->EventTrigger)
{ {
case EVENT_BATTERY_TAG: case EVENT_BATTERY_TAG:
ExReleaseFastMutex(&BattClass->Mutex); ExReleaseFastMutex(&BattClass->Mutex);
DPRINT1("Waiting for battery is UNIMPLEMENTED!\n"); DPRINT1("Waiting for battery is UNIMPLEMENTED!\n");
break; break;
case EVENT_BATTERY_STATUS: case EVENT_BATTERY_STATUS:
ExReleaseFastMutex(&BattClass->Mutex); ExReleaseFastMutex(&BattClass->Mutex);
Status = BattClass->MiniportInfo.QueryStatus(BattClass->MiniportInfo.Context, Status = BattClass->MiniportInfo.QueryStatus(BattClass->MiniportInfo.Context,
BattWait->BatteryTag, BattWait->BatteryTag,
&BattStatus); &BattStatus);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
return Status; return Status;
ExAcquireFastMutex(&BattClass->Mutex); ExAcquireFastMutex(&BattClass->Mutex);
if (!(BattWait->PowerState & BattStatus.PowerState) || if (!(BattWait->PowerState & BattStatus.PowerState) ||
(BattWait->HighCapacity > BattStatus.Capacity) || (BattWait->HighCapacity > BattStatus.Capacity) ||
(BattWait->LowCapacity < BattStatus.Capacity)) (BattWait->LowCapacity < BattStatus.Capacity))
{ {
KeSetEvent(&BattClass->WaitEvent, IO_NO_INCREMENT, FALSE); KeSetEvent(&BattClass->WaitEvent, IO_NO_INCREMENT, FALSE);
} }
ExReleaseFastMutex(&BattClass->Mutex); ExReleaseFastMutex(&BattClass->Mutex);
break; break;
default: default:
ExReleaseFastMutex(&BattClass->Mutex); ExReleaseFastMutex(&BattClass->Mutex);
ASSERT(FALSE); ASSERT(FALSE);
break; break;
} }
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
BCLASSAPI BCLASSAPI
@ -133,49 +133,49 @@ NTAPI
BatteryClassInitializeDevice(PBATTERY_MINIPORT_INFO MiniportInfo, BatteryClassInitializeDevice(PBATTERY_MINIPORT_INFO MiniportInfo,
PVOID *ClassData) PVOID *ClassData)
{ {
NTSTATUS Status; NTSTATUS Status;
PBATTERY_CLASS_DATA BattClass = ExAllocatePoolWithTag(NonPagedPool, PBATTERY_CLASS_DATA BattClass = ExAllocatePoolWithTag(NonPagedPool,
sizeof(BATTERY_CLASS_DATA), sizeof(BATTERY_CLASS_DATA),
BATTERY_CLASS_DATA_TAG); BATTERY_CLASS_DATA_TAG);
if (!BattClass) if (!BattClass)
return STATUS_INSUFFICIENT_RESOURCES; return STATUS_INSUFFICIENT_RESOURCES;
RtlZeroMemory(BattClass, sizeof(BATTERY_CLASS_DATA)); RtlZeroMemory(BattClass, sizeof(BATTERY_CLASS_DATA));
RtlCopyMemory(&BattClass->MiniportInfo, RtlCopyMemory(&BattClass->MiniportInfo,
MiniportInfo, MiniportInfo,
sizeof(BattClass->MiniportInfo)); sizeof(BattClass->MiniportInfo));
KeInitializeEvent(&BattClass->WaitEvent, SynchronizationEvent, FALSE); KeInitializeEvent(&BattClass->WaitEvent, SynchronizationEvent, FALSE);
ExInitializeFastMutex(&BattClass->Mutex); ExInitializeFastMutex(&BattClass->Mutex);
if (MiniportInfo->Pdo != NULL) if (MiniportInfo->Pdo != NULL)
{
Status = IoRegisterDeviceInterface(MiniportInfo->Pdo,
&GUID_DEVICE_BATTERY,
NULL,
&BattClass->InterfaceName);
if (NT_SUCCESS(Status))
{ {
DPRINT("Initialized battery interface: %wZ\n", &BattClass->InterfaceName); Status = IoRegisterDeviceInterface(MiniportInfo->Pdo,
Status = IoSetDeviceInterfaceState(&BattClass->InterfaceName, TRUE); &GUID_DEVICE_BATTERY,
if (Status == STATUS_OBJECT_NAME_EXISTS) NULL,
&BattClass->InterfaceName);
if (NT_SUCCESS(Status))
{ {
DPRINT1("Got STATUS_OBJECT_NAME_EXISTS for SetDeviceInterfaceState\n"); DPRINT("Initialized battery interface: %wZ\n", &BattClass->InterfaceName);
Status = STATUS_SUCCESS; Status = IoSetDeviceInterfaceState(&BattClass->InterfaceName, TRUE);
if (Status == STATUS_OBJECT_NAME_EXISTS)
{
DPRINT1("Got STATUS_OBJECT_NAME_EXISTS for SetDeviceInterfaceState\n");
Status = STATUS_SUCCESS;
}
}
else
{
DPRINT1("IoRegisterDeviceInterface failed (0x%x)\n", Status);
} }
} }
else
{
DPRINT1("IoRegisterDeviceInterface failed (0x%x)\n", Status);
}
}
*ClassData = BattClass; *ClassData = BattClass;
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
BCLASSAPI BCLASSAPI
@ -184,183 +184,184 @@ NTAPI
BatteryClassIoctl(PVOID ClassData, BatteryClassIoctl(PVOID ClassData,
PIRP Irp) PIRP Irp)
{ {
PBATTERY_CLASS_DATA BattClass = ClassData; PBATTERY_CLASS_DATA BattClass = ClassData;
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp); PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
NTSTATUS Status; NTSTATUS Status;
ULONG WaitTime; ULONG WaitTime;
PBATTERY_WAIT_STATUS BattWait; PBATTERY_WAIT_STATUS BattWait;
PBATTERY_QUERY_INFORMATION BattQueryInfo; PBATTERY_QUERY_INFORMATION BattQueryInfo;
PBATTERY_SET_INFORMATION BattSetInfo; PBATTERY_SET_INFORMATION BattSetInfo;
LARGE_INTEGER Timeout; LARGE_INTEGER Timeout;
PBATTERY_STATUS BattStatus; PBATTERY_STATUS BattStatus;
BATTERY_NOTIFY BattNotify; BATTERY_NOTIFY BattNotify;
ULONG ReturnedLength; ULONG ReturnedLength;
Irp->IoStatus.Information = 0; Irp->IoStatus.Information = 0;
DPRINT("Received IOCTL %x for 0x%x\n", IrpSp->Parameters.DeviceIoControl.IoControlCode, DPRINT("Received IOCTL %x for 0x%x\n", IrpSp->Parameters.DeviceIoControl.IoControlCode,
ClassData); ClassData);
switch (IrpSp->Parameters.DeviceIoControl.IoControlCode) switch (IrpSp->Parameters.DeviceIoControl.IoControlCode)
{ {
case IOCTL_BATTERY_QUERY_TAG: case IOCTL_BATTERY_QUERY_TAG:
if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(ULONG) || if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(ULONG) ||
IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG)) IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG))
{ {
Status = STATUS_BUFFER_TOO_SMALL; Status = STATUS_BUFFER_TOO_SMALL;
break; break;
} }
WaitTime = *(PULONG)Irp->AssociatedIrp.SystemBuffer; WaitTime = *(PULONG)Irp->AssociatedIrp.SystemBuffer;
Timeout.QuadPart = Int32x32To64(WaitTime, -1000); Timeout.QuadPart = Int32x32To64(WaitTime, -1000);
Status = BattClass->MiniportInfo.QueryTag(BattClass->MiniportInfo.Context, Status = BattClass->MiniportInfo.QueryTag(BattClass->MiniportInfo.Context,
(PULONG)Irp->AssociatedIrp.SystemBuffer); (PULONG)Irp->AssociatedIrp.SystemBuffer);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
ExAcquireFastMutex(&BattClass->Mutex); ExAcquireFastMutex(&BattClass->Mutex);
BattClass->EventTrigger = EVENT_BATTERY_TAG; BattClass->EventTrigger = EVENT_BATTERY_TAG;
BattClass->Waiting = TRUE; BattClass->Waiting = TRUE;
ExReleaseFastMutex(&BattClass->Mutex); ExReleaseFastMutex(&BattClass->Mutex);
Status = KeWaitForSingleObject(&BattClass->WaitEvent, Status = KeWaitForSingleObject(&BattClass->WaitEvent,
Executive, Executive,
KernelMode, KernelMode,
FALSE, FALSE,
WaitTime != -1 ? &Timeout : NULL); WaitTime != -1 ? &Timeout : NULL);
ExAcquireFastMutex(&BattClass->Mutex); ExAcquireFastMutex(&BattClass->Mutex);
BattClass->Waiting = FALSE; BattClass->Waiting = FALSE;
ExReleaseFastMutex(&BattClass->Mutex); ExReleaseFastMutex(&BattClass->Mutex);
if (Status == STATUS_SUCCESS) if (Status == STATUS_SUCCESS)
{ {
Status = BattClass->MiniportInfo.QueryTag(BattClass->MiniportInfo.Context, Status = BattClass->MiniportInfo.QueryTag(BattClass->MiniportInfo.Context,
(PULONG)Irp->AssociatedIrp.SystemBuffer); (PULONG)Irp->AssociatedIrp.SystemBuffer);
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
Irp->IoStatus.Information = sizeof(ULONG); Irp->IoStatus.Information = sizeof(ULONG);
} }
else else
{ {
Status = STATUS_NO_SUCH_DEVICE; Status = STATUS_NO_SUCH_DEVICE;
} }
} }
else else
Irp->IoStatus.Information = sizeof(ULONG); Irp->IoStatus.Information = sizeof(ULONG);
break; break;
case IOCTL_BATTERY_QUERY_STATUS: case IOCTL_BATTERY_QUERY_STATUS:
if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(*BattWait) || if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(*BattWait) ||
IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(BATTERY_STATUS)) IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(BATTERY_STATUS))
{ {
Status = STATUS_BUFFER_TOO_SMALL; Status = STATUS_BUFFER_TOO_SMALL;
break; break;
} }
BattWait = Irp->AssociatedIrp.SystemBuffer; BattWait = Irp->AssociatedIrp.SystemBuffer;
Timeout.QuadPart = Int32x32To64(BattWait->Timeout, -1000); Timeout.QuadPart = Int32x32To64(BattWait->Timeout, -1000);
Status = BattClass->MiniportInfo.QueryStatus(BattClass->MiniportInfo.Context, Status = BattClass->MiniportInfo.QueryStatus(BattClass->MiniportInfo.Context,
BattWait->BatteryTag, BattWait->BatteryTag,
(PBATTERY_STATUS)Irp->AssociatedIrp.SystemBuffer); (PBATTERY_STATUS)Irp->AssociatedIrp.SystemBuffer);
BattStatus = Irp->AssociatedIrp.SystemBuffer; BattStatus = Irp->AssociatedIrp.SystemBuffer;
if (!NT_SUCCESS(Status) || if (!NT_SUCCESS(Status) ||
((BattWait->PowerState & BattStatus->PowerState) && ((BattWait->PowerState & BattStatus->PowerState) &&
(BattWait->HighCapacity <= BattStatus->Capacity) && (BattWait->HighCapacity <= BattStatus->Capacity) &&
(BattWait->LowCapacity >= BattStatus->Capacity))) (BattWait->LowCapacity >= BattStatus->Capacity)))
{ {
BattNotify.PowerState = BattWait->PowerState; BattNotify.PowerState = BattWait->PowerState;
BattNotify.HighCapacity = BattWait->HighCapacity; BattNotify.HighCapacity = BattWait->HighCapacity;
BattNotify.LowCapacity = BattWait->LowCapacity; BattNotify.LowCapacity = BattWait->LowCapacity;
BattClass->MiniportInfo.SetStatusNotify(BattClass->MiniportInfo.Context, BattClass->MiniportInfo.SetStatusNotify(BattClass->MiniportInfo.Context,
BattWait->BatteryTag, BattWait->BatteryTag,
&BattNotify); &BattNotify);
ExAcquireFastMutex(&BattClass->Mutex); ExAcquireFastMutex(&BattClass->Mutex);
BattClass->EventTrigger = EVENT_BATTERY_STATUS; BattClass->EventTrigger = EVENT_BATTERY_STATUS;
BattClass->EventTriggerContext = BattWait; BattClass->EventTriggerContext = BattWait;
BattClass->Waiting = TRUE; BattClass->Waiting = TRUE;
ExReleaseFastMutex(&BattClass->Mutex); ExReleaseFastMutex(&BattClass->Mutex);
Status = KeWaitForSingleObject(&BattClass->WaitEvent, Status = KeWaitForSingleObject(&BattClass->WaitEvent,
Executive, Executive,
KernelMode, KernelMode,
FALSE, FALSE,
BattWait->Timeout != -1 ? &Timeout : NULL); BattWait->Timeout != -1 ? &Timeout : NULL);
ExAcquireFastMutex(&BattClass->Mutex); ExAcquireFastMutex(&BattClass->Mutex);
BattClass->Waiting = FALSE; BattClass->Waiting = FALSE;
ExReleaseFastMutex(&BattClass->Mutex); ExReleaseFastMutex(&BattClass->Mutex);
BattClass->MiniportInfo.DisableStatusNotify(BattClass->MiniportInfo.Context); BattClass->MiniportInfo.DisableStatusNotify(BattClass->MiniportInfo.Context);
if (Status == STATUS_SUCCESS) if (Status == STATUS_SUCCESS)
{ {
Status = BattClass->MiniportInfo.QueryStatus(BattClass->MiniportInfo.Context, Status = BattClass->MiniportInfo.QueryStatus(BattClass->MiniportInfo.Context,
BattWait->BatteryTag, BattWait->BatteryTag,
(PBATTERY_STATUS)Irp->AssociatedIrp.SystemBuffer); (PBATTERY_STATUS)Irp->AssociatedIrp.SystemBuffer);
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
Irp->IoStatus.Information = sizeof(ULONG); Irp->IoStatus.Information = sizeof(ULONG);
} }
else else
{ {
Status = STATUS_NO_SUCH_DEVICE; Status = STATUS_NO_SUCH_DEVICE;
} }
} }
else else
Irp->IoStatus.Information = sizeof(BATTERY_STATUS); Irp->IoStatus.Information = sizeof(BATTERY_STATUS);
break; break;
case IOCTL_BATTERY_QUERY_INFORMATION: case IOCTL_BATTERY_QUERY_INFORMATION:
if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(*BattQueryInfo)) if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(*BattQueryInfo))
{ {
Status = STATUS_BUFFER_TOO_SMALL; Status = STATUS_BUFFER_TOO_SMALL;
break; break;
} }
BattQueryInfo = Irp->AssociatedIrp.SystemBuffer; BattQueryInfo = Irp->AssociatedIrp.SystemBuffer;
Status = BattClass->MiniportInfo.QueryInformation(BattClass->MiniportInfo.Context, Status = BattClass->MiniportInfo.QueryInformation(BattClass->MiniportInfo.Context,
BattQueryInfo->BatteryTag, BattQueryInfo->BatteryTag,
BattQueryInfo->InformationLevel, BattQueryInfo->InformationLevel,
BattQueryInfo->AtRate, BattQueryInfo->AtRate,
Irp->AssociatedIrp.SystemBuffer, Irp->AssociatedIrp.SystemBuffer,
IrpSp->Parameters.DeviceIoControl.OutputBufferLength, IrpSp->Parameters.DeviceIoControl.OutputBufferLength,
&ReturnedLength); &ReturnedLength);
Irp->IoStatus.Information = ReturnedLength; Irp->IoStatus.Information = ReturnedLength;
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
DPRINT1("QueryInformation failed (0x%x)\n", Status); DPRINT1("QueryInformation failed (0x%x)\n", Status);
break; break;
case IOCTL_BATTERY_SET_INFORMATION:
if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(*BattSetInfo))
{
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
BattSetInfo = Irp->AssociatedIrp.SystemBuffer; case IOCTL_BATTERY_SET_INFORMATION:
if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(*BattSetInfo))
{
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
Status = BattClass->MiniportInfo.SetInformation(BattClass->MiniportInfo.Context, BattSetInfo = Irp->AssociatedIrp.SystemBuffer;
BattSetInfo->BatteryTag,
BattSetInfo->InformationLevel,
BattSetInfo->Buffer);
if (!NT_SUCCESS(Status))
DPRINT1("SetInformation failed (0x%x)\n", Status);
break;
default: Status = BattClass->MiniportInfo.SetInformation(BattClass->MiniportInfo.Context,
DPRINT1("Received unsupported IRP %x\n", IrpSp->Parameters.DeviceIoControl.IoControlCode); BattSetInfo->BatteryTag,
/* Do NOT complete the irp */ BattSetInfo->InformationLevel,
return STATUS_NOT_SUPPORTED; BattSetInfo->Buffer);
} if (!NT_SUCCESS(Status))
DPRINT1("SetInformation failed (0x%x)\n", Status);
break;
Irp->IoStatus.Status = Status; default:
IoCompleteRequest(Irp, IO_NO_INCREMENT); DPRINT1("Received unsupported IRP %x\n", IrpSp->Parameters.DeviceIoControl.IoControlCode);
/* Do NOT complete the irp */
return STATUS_NOT_SUPPORTED;
}
return Status; Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
} }

17
drivers/battery/battc/battc.h
View file

@ -13,14 +13,15 @@
#include <initguid.h> #include <initguid.h>
#include <batclass.h> #include <batclass.h>
typedef struct _BATTERY_CLASS_DATA { typedef struct _BATTERY_CLASS_DATA
BATTERY_MINIPORT_INFO MiniportInfo; {
KEVENT WaitEvent; BATTERY_MINIPORT_INFO MiniportInfo;
BOOLEAN Waiting; KEVENT WaitEvent;
FAST_MUTEX Mutex; BOOLEAN Waiting;
UCHAR EventTrigger; FAST_MUTEX Mutex;
PVOID EventTriggerContext; UCHAR EventTrigger;
UNICODE_STRING InterfaceName; PVOID EventTriggerContext;
UNICODE_STRING InterfaceName;
} BATTERY_CLASS_DATA, *PBATTERY_CLASS_DATA; } BATTERY_CLASS_DATA, *PBATTERY_CLASS_DATA;
/* Memory tags */ /* Memory tags */