i8042prt.c File Reference

#include "i8042prt.h"
#include <debug.h>

Include dependency graph for i8042prt.c:

Go to the source code of this file.

Functions
	_Dispatch_type_ (IRP_MJ_DEVICE_CONTROL)
VOID NTAPI	i8042SendHookWorkItem (IN PDEVICE_OBJECT DeviceObject, IN PVOID Context)
static VOID NTAPI	i8042StartIo (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
static BOOLEAN	i8042PacketWrite (IN PPORT_DEVICE_EXTENSION DeviceExtension)
BOOLEAN	i8042PacketIsr (IN PPORT_DEVICE_EXTENSION DeviceExtension, IN UCHAR Output)
NTSTATUS	i8042StartPacket (IN PPORT_DEVICE_EXTENSION DeviceExtension, IN PFDO_DEVICE_EXTENSION FdoDeviceExtension, IN PUCHAR Bytes, IN ULONG ByteCount, IN PIRP Irp)
static NTSTATUS NTAPI	i8042DeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
static NTSTATUS NTAPI	i8042InternalDeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
static NTSTATUS NTAPI	i8042Power (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
static NTSTATUS NTAPI	i8042SystemControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)

Variables
static DRIVER_STARTIO	i8042StartIo

Function Documentation

_Dispatch_type_()

_Dispatch_type_

(

IRP_MJ_DEVICE_CONTROL

)

Definition at line 21 of file i8042prt.c.

{
    PI8042_DRIVER_EXTENSION DriverExtension;
    PFDO_DEVICE_EXTENSION DeviceExtension = NULL;
    PDEVICE_OBJECT Fdo = NULL;
    ULONG DeviceExtensionSize;
    NTSTATUS Status;

    TRACE_(I8042PRT, "i8042AddDevice(%p %p)\n", DriverObject, Pdo);

    DriverExtension = (PI8042_DRIVER_EXTENSION)IoGetDriverObjectExtension(DriverObject, DriverObject);

    if (Pdo == NULL)
    {
        /* We're getting a NULL Pdo at the first call as
         * we are a legacy driver. Ignore it */
        return STATUS_SUCCESS;
    }

    /* Create new device object. As we don't know if the device would be a keyboard
     * or a mouse, we have to allocate the biggest device extension. */
    DeviceExtensionSize = MAX(sizeof(I8042_KEYBOARD_EXTENSION), sizeof(I8042_MOUSE_EXTENSION));
    Status = IoCreateDevice(
        DriverObject,
        DeviceExtensionSize,
        NULL,
        Pdo->DeviceType,
        FILE_DEVICE_SECURE_OPEN,
        TRUE,
        &Fdo);
    if (!NT_SUCCESS(Status))
    {
        WARN_(I8042PRT, "IoCreateDevice() failed with status 0x%08lx\n", Status);
        goto cleanup;
    }

    DeviceExtension = (PFDO_DEVICE_EXTENSION)Fdo->DeviceExtension;
    RtlZeroMemory(DeviceExtension, DeviceExtensionSize);
    DeviceExtension->Type = Unknown;
    DeviceExtension->Fdo = Fdo;
    DeviceExtension->Pdo = Pdo;
    DeviceExtension->PortDeviceExtension = &DriverExtension->Port;
    Status = IoAttachDeviceToDeviceStackSafe(Fdo, Pdo, &DeviceExtension->LowerDevice);
    if (!NT_SUCCESS(Status))
    {
        WARN_(I8042PRT, "IoAttachDeviceToDeviceStackSafe() failed with status 0x%08lx\n", Status);
        goto cleanup;
    }

    ExInterlockedInsertTailList(
        &DriverExtension->DeviceListHead,
        &DeviceExtension->ListEntry,
        &DriverExtension->DeviceListLock);

    Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
    return STATUS_SUCCESS;

cleanup:
    if (DeviceExtension && DeviceExtension->LowerDevice)
        IoDetachDevice(DeviceExtension->LowerDevice);
    if (Fdo)
        IoDeleteDevice(Fdo);
    return Status;
}

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	IN PDRIVER_OBJECT	DriverObject,
		IN PUNICODE_STRING	RegistryPath
	)

Definition at line 482 of file i8042prt.c.

{
    PI8042_DRIVER_EXTENSION DriverExtension;
    NTSTATUS Status;

    Status = IoAllocateDriverObjectExtension(
        DriverObject,
        DriverObject,
        sizeof(I8042_DRIVER_EXTENSION),
        (PVOID*)&DriverExtension);
    if (!NT_SUCCESS(Status))
    {
        WARN_(I8042PRT, "IoAllocateDriverObjectExtension() failed with status 0x%08lx\n", Status);
        return Status;
    }
    RtlZeroMemory(DriverExtension, sizeof(I8042_DRIVER_EXTENSION));
    KeInitializeSpinLock(&DriverExtension->Port.SpinLock);
    InitializeListHead(&DriverExtension->DeviceListHead);
    KeInitializeSpinLock(&DriverExtension->DeviceListLock);

    Status = DuplicateUnicodeString(
        RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
        RegistryPath,
        &DriverExtension->RegistryPath);
    if (!NT_SUCCESS(Status))
    {
        WARN_(I8042PRT, "DuplicateUnicodeString() failed with status 0x%08lx\n", Status);
        return Status;
    }

    Status = ReadRegistryEntries(RegistryPath, &DriverExtension->Port.Settings);
    if (!NT_SUCCESS(Status))
    {
        WARN_(I8042PRT, "ReadRegistryEntries() failed with status 0x%08lx\n", Status);
        return Status;
    }

    DriverObject->DriverExtension->AddDevice = i8042AddDevice;
    DriverObject->DriverStartIo = i8042StartIo;

    DriverObject->MajorFunction[IRP_MJ_CREATE]  = i8042Create;
    DriverObject->MajorFunction[IRP_MJ_CLEANUP] = i8042Cleanup;
    DriverObject->MajorFunction[IRP_MJ_CLOSE]   = i8042Close;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = i8042DeviceControl;
    DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = i8042InternalDeviceControl;
    DriverObject->MajorFunction[IRP_MJ_POWER]   = i8042Power;
    DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = i8042SystemControl;
    DriverObject->MajorFunction[IRP_MJ_PNP]     = i8042Pnp;

    i8042InitializeHwHacks();

    return STATUS_SUCCESS;
}

i8042DeviceControl()

static NTSTATUS NTAPI i8042DeviceControl ( IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp  )

static

Definition at line 390 of file i8042prt.c.

{
    PFDO_DEVICE_EXTENSION DeviceExtension;

    TRACE_(I8042PRT, "i8042DeviceControl(%p %p)\n", DeviceObject, Irp);
    DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;

    switch (DeviceExtension->Type)
    {
        case Keyboard:
            return i8042KbdDeviceControl(DeviceObject, Irp);
        default:
            Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return STATUS_INVALID_DEVICE_REQUEST;
    }
}

Referenced by DriverEntry().

i8042InternalDeviceControl()

static NTSTATUS NTAPI i8042InternalDeviceControl ( IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp  )

static

Definition at line 411 of file i8042prt.c.

{
    PFDO_DEVICE_EXTENSION DeviceExtension;
    ULONG ControlCode;
    NTSTATUS Status;

    TRACE_(I8042PRT, "i8042InternalDeviceControl(%p %p)\n", DeviceObject, Irp);
    DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;

    switch (DeviceExtension->Type)
    {
        case Unknown:
        {
            ControlCode = IoGetCurrentIrpStackLocation(Irp)->Parameters.DeviceIoControl.IoControlCode;
            switch (ControlCode)
            {
                case IOCTL_INTERNAL_KEYBOARD_CONNECT:
                    Status = i8042KbdInternalDeviceControl(DeviceObject, Irp);
                    break;
                case IOCTL_INTERNAL_MOUSE_CONNECT:
                    Status = i8042MouInternalDeviceControl(DeviceObject, Irp);
                    break;
                default:
                    ERR_(I8042PRT, "Unknown IO control code 0x%lx\n", ControlCode);
                    ASSERT(FALSE);
                    Status = STATUS_INVALID_DEVICE_REQUEST;
                    break;
            }
            break;
        }
        case Keyboard:
            Status = i8042KbdInternalDeviceControl(DeviceObject, Irp);
            break;
        case Mouse:
            Status = i8042MouInternalDeviceControl(DeviceObject, Irp);
            break;
        default:
            ERR_(I8042PRT, "Unknown FDO type %u\n", DeviceExtension->Type);
            ASSERT(FALSE);
            Status = STATUS_INTERNAL_ERROR;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            break;
    }

    return Status;
}

Referenced by DriverEntry().

i8042PacketIsr()

BOOLEAN i8042PacketIsr	(	IN PPORT_DEVICE_EXTENSION	DeviceExtension,
		IN UCHAR	Output
	)

Definition at line 271 of file i8042prt.c.

{
    if (DeviceExtension->Packet.State == Idle)
        return FALSE;

    switch (Output)
    {
        case KBD_RESEND:
            DeviceExtension->PacketResends++;
            if (DeviceExtension->PacketResends > DeviceExtension->Settings.ResendIterations)
            {
                DeviceExtension->Packet.State = Idle;
                DeviceExtension->PacketComplete = TRUE;
                DeviceExtension->PacketResult = STATUS_IO_TIMEOUT;
                DeviceExtension->PacketResends = 0;
                return TRUE;
            }
            DeviceExtension->Packet.CurrentByte--;
            break;

        case KBD_NACK:
            DeviceExtension->Packet.State = Idle;
            DeviceExtension->PacketComplete = TRUE;
            DeviceExtension->PacketResult = STATUS_UNEXPECTED_IO_ERROR;
            DeviceExtension->PacketResends = 0;
            return TRUE;

        default:
            DeviceExtension->PacketResends = 0;
    }

    if (DeviceExtension->Packet.CurrentByte >= DeviceExtension->Packet.ByteCount)
    {
        DeviceExtension->Packet.State = Idle;
        DeviceExtension->PacketComplete = TRUE;
        DeviceExtension->PacketResult = STATUS_SUCCESS;
        return TRUE;
    }

    if (!i8042PacketWrite(DeviceExtension))
    {
        DeviceExtension->Packet.State = Idle;
        DeviceExtension->PacketComplete = TRUE;
        DeviceExtension->PacketResult = STATUS_IO_TIMEOUT;
        return TRUE;
    }
    DeviceExtension->Packet.CurrentByte++;

    return TRUE;
}

Referenced by i8042KbdInterruptService(), and i8042MouInterruptService().

i8042PacketWrite()

static BOOLEAN i8042PacketWrite ( IN PPORT_DEVICE_EXTENSION  DeviceExtension )

static

Definition at line 248 of file i8042prt.c.

{
    UCHAR Port = DeviceExtension->PacketPort;

    if (Port)
    {
        if (!i8042Write(DeviceExtension,
                        DeviceExtension->ControlPort,
                        Port))
        {
            /* something is really wrong! */
            WARN_(I8042PRT, "Failed to send packet byte!\n");
            return FALSE;
        }
    }

    return i8042Write(DeviceExtension,
                      DeviceExtension->DataPort,
                      DeviceExtension->Packet.Bytes[DeviceExtension->Packet.CurrentByte]);
}

Referenced by i8042PacketIsr(), and i8042StartPacket().

i8042Power()

static NTSTATUS NTAPI i8042Power ( IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp  )

static

Definition at line 461 of file i8042prt.c.

{
    PFDO_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
    PDEVICE_OBJECT LowerDevice = DeviceExtension->LowerDevice;

    PoStartNextPowerIrp(Irp);
    IoSkipCurrentIrpStackLocation(Irp);
    return PoCallDriver(LowerDevice, Irp);
}

Referenced by DriverEntry().

i8042SendHookWorkItem()

VOID NTAPI i8042SendHookWorkItem	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PVOID	Context
	)

Definition at line 100 of file i8042prt.c.

{
    PI8042_HOOK_WORKITEM WorkItemData;
    PFDO_DEVICE_EXTENSION FdoDeviceExtension;
    PPORT_DEVICE_EXTENSION PortDeviceExtension;
    PDEVICE_OBJECT TopOfStack = NULL;
    ULONG IoControlCode;
    PVOID InputBuffer;
    ULONG InputBufferLength;
    IO_STATUS_BLOCK IoStatus;
    KEVENT Event;
    PIRP NewIrp;
    NTSTATUS Status;

    TRACE_(I8042PRT, "i8042SendHookWorkItem(%p %p)\n", DeviceObject, Context);

    WorkItemData = (PI8042_HOOK_WORKITEM)Context;
    FdoDeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PortDeviceExtension = FdoDeviceExtension->PortDeviceExtension;

    switch (FdoDeviceExtension->Type)
    {
        case Keyboard:
        {
            PI8042_KEYBOARD_EXTENSION DeviceExtension;
            DeviceExtension = (PI8042_KEYBOARD_EXTENSION)FdoDeviceExtension;
            IoControlCode = IOCTL_INTERNAL_I8042_HOOK_KEYBOARD;
            InputBuffer = &DeviceExtension->KeyboardHook;
            InputBufferLength = sizeof(INTERNAL_I8042_HOOK_KEYBOARD);
            break;
        }
        case Mouse:
        {
            PI8042_MOUSE_EXTENSION DeviceExtension;
            DeviceExtension = (PI8042_MOUSE_EXTENSION)FdoDeviceExtension;
            IoControlCode = IOCTL_INTERNAL_I8042_HOOK_MOUSE;
            InputBuffer = &DeviceExtension->MouseHook;
            InputBufferLength = sizeof(INTERNAL_I8042_HOOK_MOUSE);
            break;
        }
        default:
        {
            ERR_(I8042PRT, "Unknown FDO type %u\n", FdoDeviceExtension->Type);
            ASSERT(FALSE);
            WorkItemData->Irp->IoStatus.Status = STATUS_INTERNAL_ERROR;
            goto cleanup;
        }
    }

    KeInitializeEvent(&Event, NotificationEvent, FALSE);
    TopOfStack = IoGetAttachedDeviceReference(DeviceObject);

    NewIrp = IoBuildDeviceIoControlRequest(
        IoControlCode,
        TopOfStack,
        InputBuffer,
        InputBufferLength,
        NULL,
        0,
        TRUE,
        &Event,
        &IoStatus);

    if (!NewIrp)
    {
        WARN_(I8042PRT, "IoBuildDeviceIoControlRequest() failed\n");
        WorkItemData->Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
        goto cleanup;
    }

    Status = IoCallDriver(TopOfStack, NewIrp);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(
            &Event,
            Executive,
            KernelMode,
            FALSE,
            NULL);
        Status = IoStatus.Status;
    }
    if (!NT_SUCCESS(Status))
    {
        WARN_(I8042PRT, "IoCallDriver() failed with status 0x%08lx\n", Status);
        goto cleanup;
    }

    if (FdoDeviceExtension->Type == Keyboard)
    {
        PI8042_KEYBOARD_EXTENSION DeviceExtension;

        DeviceExtension = (PI8042_KEYBOARD_EXTENSION)FdoDeviceExtension;
        /* Call the hooked initialization if it exists */
        if (DeviceExtension->KeyboardHook.InitializationRoutine)
        {
            Status = DeviceExtension->KeyboardHook.InitializationRoutine(
                DeviceExtension->KeyboardHook.Context,
                PortDeviceExtension,
                i8042SynchReadPort,
                i8042SynchWritePortKbd,
                FALSE);
            if (!NT_SUCCESS(Status))
            {
                WARN_(I8042PRT, "KeyboardHook.InitializationRoutine() failed with status 0x%08lx\n", Status);
                WorkItemData->Irp->IoStatus.Status = Status;
                goto cleanup;
            }
        }
    }

    WorkItemData->Irp->IoStatus.Status = STATUS_SUCCESS;

cleanup:
    if (TopOfStack != NULL)
        ObDereferenceObject(TopOfStack);
    WorkItemData->Irp->IoStatus.Information = 0;
    IoCompleteRequest(WorkItemData->Irp, IO_NO_INCREMENT);

    IoFreeWorkItem(WorkItemData->WorkItem);
    ExFreePoolWithTag(WorkItemData, I8042PRT_TAG);
}

i8042StartIo()

static VOID NTAPI i8042StartIo ( IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp  )

static

Definition at line 225 of file i8042prt.c.

{
    PFDO_DEVICE_EXTENSION DeviceExtension;

    DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    switch (DeviceExtension->Type)
    {
        case Keyboard:
            i8042KbdStartIo(DeviceObject, Irp);
            break;
        default:
            ERR_(I8042PRT, "Unknown FDO type %u\n", DeviceExtension->Type);
            ASSERT(FALSE);
            break;
    }
}

i8042StartPacket()

NTSTATUS i8042StartPacket	(	IN PPORT_DEVICE_EXTENSION	DeviceExtension,
		IN PFDO_DEVICE_EXTENSION	FdoDeviceExtension,
		IN PUCHAR	Bytes,
		IN ULONG	ByteCount,
		IN PIRP	Irp
	)

Definition at line 329 of file i8042prt.c.

{
    KIRQL Irql;
    NTSTATUS Status;

    Irql = KeAcquireInterruptSpinLock(DeviceExtension->HighestDIRQLInterrupt);

    if (DeviceExtension->Packet.State != Idle)
    {
        Status = STATUS_DEVICE_BUSY;
        goto done;
    }

    switch (FdoDeviceExtension->Type)
    {
        case Keyboard: DeviceExtension->PacketPort = 0; break;
        case Mouse: DeviceExtension->PacketPort = CTRL_WRITE_MOUSE; break;
        default:
            ERR_(I8042PRT, "Unknown FDO type %u\n", FdoDeviceExtension->Type);
            ASSERT(FALSE);
            Status = STATUS_INTERNAL_ERROR;
            goto done;
    }

    DeviceExtension->Packet.Bytes = Bytes;
    DeviceExtension->Packet.CurrentByte = 0;
    DeviceExtension->Packet.ByteCount = ByteCount;
    DeviceExtension->Packet.State = SendingBytes;
    DeviceExtension->PacketResult = Status = STATUS_PENDING;
    DeviceExtension->CurrentIrp = Irp;
    DeviceExtension->CurrentIrpDevice = FdoDeviceExtension->Fdo;

    if (!i8042PacketWrite(DeviceExtension))
    {
        Status = STATUS_IO_TIMEOUT;
        DeviceExtension->Packet.State = Idle;
        DeviceExtension->PacketResult = STATUS_ABANDONED;
        goto done;
    }

    DeviceExtension->Packet.CurrentByte++;

done:
    KeReleaseInterruptSpinLock(DeviceExtension->HighestDIRQLInterrupt, Irql);

    if (Status != STATUS_PENDING)
    {
        DeviceExtension->CurrentIrp = NULL;
        DeviceExtension->CurrentIrpDevice = NULL;
        Irp->IoStatus.Status = Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
    return Status;
}

Referenced by i8042KbdStartIo().

i8042SystemControl()

static NTSTATUS NTAPI i8042SystemControl ( IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp  )

static

Definition at line 474 of file i8042prt.c.

{
    return ForwardIrpAndForget(DeviceObject, Irp);
}

Referenced by DriverEntry().

Variable Documentation

i8042StartIo

DRIVER_STARTIO i8042StartIo

static

Definition at line 20 of file i8042prt.c.

Referenced by DriverEntry().