green.h File Reference

#include <ntddk.h>
#include <ntifs.h>
#include <ntndk.h>
#include <windef.h>
#include <ntddser.h>
#include <kbdmou.h>
#include <wincon.h>
#include <drivers/blue/ntddblue.h>

Include dependency graph for green.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_COMMON_DEVICE_EXTENSION
struct	_COMMON_FDO_DEVICE_EXTENSION
struct	_KEYBOARD_DEVICE_EXTENSION
struct	_SCREEN_DEVICE_EXTENSION
struct	_GREEN_DEVICE_EXTENSION
struct	_GREEN_DRIVER_EXTENSION

Macros
#define	WINBASEAPI
#define	RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE   1
#define	RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING   2
#define	INFINITE   -1
#define	KEYBOARD_BUFFER_SIZE   100

Typedefs
typedef struct _SECURITY_ATTRIBUTES	SECURITY_ATTRIBUTES
typedef struct _SECURITY_ATTRIBUTES *	PSECURITY_ATTRIBUTES
typedef struct _COMMON_DEVICE_EXTENSION	COMMON_DEVICE_EXTENSION
typedef struct _COMMON_DEVICE_EXTENSION *	PCOMMON_DEVICE_EXTENSION
typedef struct _COMMON_FDO_DEVICE_EXTENSION	COMMON_FDO_DEVICE_EXTENSION
typedef struct _COMMON_FDO_DEVICE_EXTENSION *	PCOMMON_FDO_DEVICE_EXTENSION
typedef struct _KEYBOARD_DEVICE_EXTENSION	KEYBOARD_DEVICE_EXTENSION
typedef struct _KEYBOARD_DEVICE_EXTENSION *	PKEYBOARD_DEVICE_EXTENSION
typedef struct _SCREEN_DEVICE_EXTENSION	SCREEN_DEVICE_EXTENSION
typedef struct _SCREEN_DEVICE_EXTENSION *	PSCREEN_DEVICE_EXTENSION
typedef struct _GREEN_DEVICE_EXTENSION	GREEN_DEVICE_EXTENSION
typedef struct _GREEN_DEVICE_EXTENSION *	PGREEN_DEVICE_EXTENSION
typedef struct _GREEN_DRIVER_EXTENSION	GREEN_DRIVER_EXTENSION
typedef struct _GREEN_DRIVER_EXTENSION *	PGREEN_DRIVER_EXTENSION

Enumerations
enum	GREEN_DEVICE_TYPE {   GreenPDO , ScreenPDO , KeyboardPDO , GreenFDO ,   ScreenFDO , KeyboardFDO , PassThroughFDO }

Functions
NTSTATUS	GreenCreate (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	GreenClose (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	GreenDispatch (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	KeyboardAddDevice (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT Pdo)
NTSTATUS	KeyboardInternalDeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	GreenDeviceIoControl (IN PDEVICE_OBJECT DeviceObject, IN ULONG CtlCode, IN PVOID InputBuffer OPTIONAL, IN ULONG InputBufferSize, IN OUT PVOID OutputBuffer OPTIONAL, IN OUT PULONG OutputBufferSize)
NTSTATUS	ReadRegistryEntries (IN PUNICODE_STRING RegistryPath, IN PGREEN_DRIVER_EXTENSION DriverExtension)
NTSTATUS NTAPI	GreenAddDevice (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT Pdo)
NTSTATUS	GreenPnp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	GreenPower (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	ScreenAddDevice (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT Pdo)
NTSTATUS	ScreenWrite (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	ScreenDeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	GreenDuplicateUnicodeString (IN ULONG Flags, IN PCUNICODE_STRING SourceString, OUT PUNICODE_STRING DestinationString)

Macro Definition Documentation

INFINITE

#define INFINITE   -1

Definition at line 18 of file green.h.

KEYBOARD_BUFFER_SIZE

#define KEYBOARD_BUFFER_SIZE   100

Definition at line 19 of file green.h.

RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING

#define RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING   2

Definition at line 16 of file green.h.

RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE

#define RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE   1

Definition at line 15 of file green.h.

WINBASEAPI

#define WINBASEAPI

Definition at line 8 of file green.h.

Typedef Documentation

COMMON_DEVICE_EXTENSION

typedef struct _COMMON_DEVICE_EXTENSION COMMON_DEVICE_EXTENSION

COMMON_FDO_DEVICE_EXTENSION

typedef struct _COMMON_FDO_DEVICE_EXTENSION COMMON_FDO_DEVICE_EXTENSION

GREEN_DEVICE_EXTENSION

typedef struct _GREEN_DEVICE_EXTENSION GREEN_DEVICE_EXTENSION

GREEN_DRIVER_EXTENSION

typedef struct _GREEN_DRIVER_EXTENSION GREEN_DRIVER_EXTENSION

KEYBOARD_DEVICE_EXTENSION

typedef struct _KEYBOARD_DEVICE_EXTENSION KEYBOARD_DEVICE_EXTENSION

PCOMMON_DEVICE_EXTENSION

typedef struct _COMMON_DEVICE_EXTENSION * PCOMMON_DEVICE_EXTENSION

PCOMMON_FDO_DEVICE_EXTENSION

typedef struct _COMMON_FDO_DEVICE_EXTENSION * PCOMMON_FDO_DEVICE_EXTENSION

PGREEN_DEVICE_EXTENSION

typedef struct _GREEN_DEVICE_EXTENSION * PGREEN_DEVICE_EXTENSION

PGREEN_DRIVER_EXTENSION

typedef struct _GREEN_DRIVER_EXTENSION * PGREEN_DRIVER_EXTENSION

PKEYBOARD_DEVICE_EXTENSION

typedef struct _KEYBOARD_DEVICE_EXTENSION * PKEYBOARD_DEVICE_EXTENSION

PSCREEN_DEVICE_EXTENSION

typedef struct _SCREEN_DEVICE_EXTENSION * PSCREEN_DEVICE_EXTENSION

PSECURITY_ATTRIBUTES

typedef struct _SECURITY_ATTRIBUTES * PSECURITY_ATTRIBUTES

Definition at line 9 of file green.h.

SCREEN_DEVICE_EXTENSION

typedef struct _SCREEN_DEVICE_EXTENSION SCREEN_DEVICE_EXTENSION

SECURITY_ATTRIBUTES

typedef struct _SECURITY_ATTRIBUTES SECURITY_ATTRIBUTES

Definition at line 9 of file green.h.

Enumeration Type Documentation

GREEN_DEVICE_TYPE

enum GREEN_DEVICE_TYPE

Enumerator
GreenPDO
ScreenPDO
KeyboardPDO
GreenFDO
ScreenFDO
KeyboardFDO
PassThroughFDO

Definition at line 21 of file green.h.

{
    GreenPDO,
    ScreenPDO,
    KeyboardPDO,
    GreenFDO,
    ScreenFDO,
    KeyboardFDO,
    PassThroughFDO,
} GREEN_DEVICE_TYPE;

Function Documentation

GreenAddDevice()

NTSTATUS NTAPI GreenAddDevice	(	IN PDRIVER_OBJECT	DriverObject,
		IN PDEVICE_OBJECT	Pdo
	)

Definition at line 179 of file pnp.c.

{
    PGREEN_DRIVER_EXTENSION DriverExtension;
 
    DPRINT("AddDevice(DriverObject %p, Pdo %p)\n", DriverObject, Pdo);
 
    DriverExtension = IoGetDriverObjectExtension(DriverObject, DriverObject);
 
    if (Pdo == NULL)
    {
        if (DriverExtension->DeviceReported)
            /* Green Pdo has already been reported during a previous boot.
             * We will get another AddDevice call soon.
             */
            return STATUS_SUCCESS;
        else
            return ReportGreenPdo(DriverObject, DriverExtension);
    }
    else if (DriverExtension->GreenMainDO == NULL)
    {
        return CreateGreenFdo(DriverObject, Pdo);
    }
    else
    {
        PGREEN_DEVICE_EXTENSION GreenDeviceExtension;
 
        GreenDeviceExtension = (PGREEN_DEVICE_EXTENSION)DriverExtension->GreenMainDO->DeviceExtension;
        if (Pdo == GreenDeviceExtension->KeyboardPdo)
            return KeyboardAddDevice(DriverObject, Pdo);
        else if (Pdo == GreenDeviceExtension->ScreenPdo)
            return ScreenAddDevice(DriverObject, Pdo);
        else
            /* Strange PDO. We don't know it */
            ASSERT(FALSE);
            return STATUS_UNSUCCESSFUL;
    }
}

Referenced by DriverEntry().

GreenClose()

NTSTATUS GreenClose	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 28 of file createclose.c.

{
    DPRINT("IRP_MJ_CLOSE\n");
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return STATUS_SUCCESS;
}

Referenced by GreenDispatch().

GreenCreate()

NTSTATUS GreenCreate	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 15 of file createclose.c.

{
    DPRINT("IRP_MJ_CREATE\n");
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return STATUS_SUCCESS;
}

Referenced by GreenDispatch().

GreenDeviceIoControl()

NTSTATUS GreenDeviceIoControl	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	CtlCode,
		IN PVOID InputBuffer	OPTIONAL,
		IN ULONG	InputBufferSize,
		IN OUT PVOID OutputBuffer	OPTIONAL,
		IN OUT PULONG	OutputBufferSize
	)

Definition at line 15 of file misc.c.

{
    KEVENT Event;
    PIRP Irp;
    IO_STATUS_BLOCK IoStatus;
    NTSTATUS Status;
 
    KeInitializeEvent (&Event, NotificationEvent, FALSE);
 
    Irp = IoBuildDeviceIoControlRequest(CtlCode,
        DeviceObject,
        InputBuffer,
        InputBufferSize,
        OutputBuffer,
        (OutputBufferSize) ? *OutputBufferSize : 0,
        FALSE,
        &Event,
        &IoStatus);
    if (Irp == NULL)
    {
        DPRINT("IoBuildDeviceIoControlRequest() failed\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = IoCallDriver(DeviceObject, Irp);
 
    if (Status == STATUS_PENDING)
    {
        DPRINT("Operation pending\n");
        KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
        Status = IoStatus.Status;
    }
 
    if (OutputBufferSize)
    {
        *OutputBufferSize = IoStatus.Information;
    }
 
    return Status;
}

Referenced by CreateGreenFdo().

GreenDispatch()

NTSTATUS NTAPI GreenDispatch	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 15 of file dispatch.c.

{
    ULONG MajorFunction;
    GREEN_DEVICE_TYPE DeviceType;
    ULONG_PTR Information;
    NTSTATUS Status;
 
    MajorFunction = IoGetCurrentIrpStackLocation(Irp)->MajorFunction;
    DeviceType = ((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->Type;
 
    Information = Irp->IoStatus.Information;
    Status = Irp->IoStatus.Status;
 
    DPRINT("Dispatching major function 0x%lx, DeviceType %u\n",
        MajorFunction, DeviceType);
 
    if (DeviceType == PassThroughFDO)
    {
        IoSkipCurrentIrpStackLocation(Irp);
        return IoCallDriver(((PCOMMON_FDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->LowerDevice, Irp);
    }
    else if (MajorFunction == IRP_MJ_CREATE && (DeviceType == GreenFDO || DeviceType == KeyboardPDO || DeviceType == ScreenPDO))
        return GreenCreate(DeviceObject, Irp);
    else if (MajorFunction == IRP_MJ_CLOSE && (DeviceType == GreenFDO || DeviceType == KeyboardPDO || DeviceType == ScreenPDO))
        return GreenClose(DeviceObject, Irp);
    else if ((MajorFunction == IRP_MJ_CREATE || MajorFunction == IRP_MJ_CLOSE || MajorFunction == IRP_MJ_CLEANUP)
        && (DeviceType == KeyboardFDO || DeviceType == ScreenFDO))
    {
        IoSkipCurrentIrpStackLocation(Irp);
        return IoCallDriver(((PCOMMON_FDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->LowerDevice, Irp);
    }
    else if (MajorFunction == IRP_MJ_INTERNAL_DEVICE_CONTROL && DeviceType == GreenFDO)
    {
        return KeyboardInternalDeviceControl(
            ((PGREEN_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->KeyboardFdo,
            Irp);
    }
    else if (MajorFunction == IRP_MJ_INTERNAL_DEVICE_CONTROL && DeviceType == KeyboardFDO)
        return KeyboardInternalDeviceControl(DeviceObject, Irp);
    else if (MajorFunction == IRP_MJ_DEVICE_CONTROL && DeviceType == GreenFDO)
    {
        return ScreenDeviceControl(
            ((PGREEN_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->ScreenFdo,
            Irp);
    }
    else if (MajorFunction == IRP_MJ_DEVICE_CONTROL && DeviceType == ScreenFDO)
        return ScreenDeviceControl(DeviceObject, Irp);
    else if (MajorFunction == IRP_MJ_WRITE && DeviceType == ScreenFDO)
        return ScreenWrite(DeviceObject, Irp);
    else if (MajorFunction == IRP_MJ_PNP && (DeviceType == KeyboardFDO || DeviceType == ScreenFDO))
    {
        IoSkipCurrentIrpStackLocation(Irp);
        return IoCallDriver(((PCOMMON_FDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->LowerDevice, Irp);
    }
    else if (MajorFunction == IRP_MJ_PNP && (DeviceType == GreenFDO || DeviceType == KeyboardPDO || DeviceType == ScreenPDO))
        return GreenPnp(DeviceObject, Irp);
    else if (MajorFunction == IRP_MJ_POWER && DeviceType == GreenFDO)
        return GreenPower(DeviceObject, Irp);
    else
    {
        DPRINT1("Unknown combination: MajorFunction 0x%lx, DeviceType %d\n",
            MajorFunction, DeviceType);
        switch (DeviceType)
        {
            case KeyboardFDO:
            case ScreenFDO:
            {
                IoSkipCurrentIrpStackLocation(Irp);
                return IoCallDriver(((PCOMMON_FDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->LowerDevice, Irp);
            }
            case GreenFDO:
            {
                PDRIVER_OBJECT DriverObject;
                PGREEN_DRIVER_EXTENSION DriverExtension;
                DriverObject = DeviceObject->DriverObject;
                DriverExtension = IoGetDriverObjectExtension(DriverObject, DriverObject);
                IoSkipCurrentIrpStackLocation(Irp);
                return IoCallDriver(DriverExtension->LowerDevice, Irp);
            }
            default:
                ASSERT(FALSE);
        }
    }
 
    Irp->IoStatus.Information = Information;
    Irp->IoStatus.Status = Status;
    IoCompleteRequest (Irp, IO_NO_INCREMENT);
    return Status;
}

Referenced by DriverEntry().

GreenDuplicateUnicodeString()

NTSTATUS GreenDuplicateUnicodeString	(	IN ULONG	Flags,
		IN PCUNICODE_STRING	SourceString,
		OUT PUNICODE_STRING	DestinationString
	)

Definition at line 71 of file green.c.

{
    if (SourceString == NULL || DestinationString == NULL
     || SourceString->Length > SourceString->MaximumLength
     || (SourceString->Length == 0 && SourceString->MaximumLength > 0 && SourceString->Buffer == NULL)
     || Flags == RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING || Flags >= 4)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
 
    if ((SourceString->Length == 0)
     && (Flags != (RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE |
                   RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING)))
    {
        DestinationString->Length = 0;
        DestinationString->MaximumLength = 0;
        DestinationString->Buffer = NULL;
    }
    else
    {
        USHORT DestMaxLength = SourceString->Length;
 
        if (Flags & RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE)
            DestMaxLength += sizeof(UNICODE_NULL);
 
        DestinationString->Buffer = ExAllocatePool(PagedPool, DestMaxLength);
        if (DestinationString->Buffer == NULL)
            return STATUS_NO_MEMORY;
 
        RtlCopyMemory(DestinationString->Buffer, SourceString->Buffer, SourceString->Length);
        DestinationString->Length = SourceString->Length;
        DestinationString->MaximumLength = DestMaxLength;
 
        if (Flags & RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE)
            DestinationString->Buffer[DestinationString->Length / sizeof(WCHAR)] = 0;
    }
 
    return STATUS_SUCCESS;
}

Referenced by DriverEntry(), and GreenQueryId().

GreenPnp()

NTSTATUS GreenPnp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 408 of file pnp.c.

{
    GREEN_DEVICE_TYPE Type;
    PIO_STACK_LOCATION Stack;
    ULONG_PTR Information = Irp->IoStatus.Information;
    NTSTATUS Status = Irp->IoStatus.Status;
 
    Type = ((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->Type;
    Stack = IoGetCurrentIrpStackLocation(Irp);
 
    switch (Stack->MinorFunction)
    {
        case IRP_MN_START_DEVICE: /* 0x00 */
        {
            DPRINT("IRP_MJ_PNP / IRP_MN_START_DEVICE\n");
            if (Type == GreenFDO || Type == KeyboardPDO || Type == ScreenPDO)
                Status = STATUS_SUCCESS;
            else
            {
                DPRINT1("IRP_MJ_PNP / IRP_MN_START_DEVICE / Unknown type 0x%lx\n",
                    Type);
                ASSERT(FALSE);
            }
            break;
        }
        case IRP_MN_QUERY_DEVICE_RELATIONS: /* 0x07 */
        {
            DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS\n");
            switch (Stack->Parameters.QueryDeviceRelations.Type)
            {
                case BusRelations:
                {
                    if (Type == GreenFDO)
                    {
                        PDEVICE_RELATIONS DeviceRelations = NULL;
                        Status = GreenQueryBusRelations(DeviceObject, &DeviceRelations);
                        Information = (ULONG_PTR)DeviceRelations;
                    }
                    else if (Type == KeyboardPDO || Type == ScreenPDO)
                    {
                        PDEVICE_RELATIONS DeviceRelations = NULL;
                        DeviceRelations = ExAllocatePool(PagedPool, FIELD_OFFSET(DEVICE_RELATIONS, Objects));
                        if (!DeviceRelations)
                            Status = STATUS_INSUFFICIENT_RESOURCES;
                        else
                        {
                            DeviceRelations->Count = 0;
                            Status = STATUS_SUCCESS;
                            Information = (ULONG_PTR)DeviceRelations;
                        }
                    }
                    else
                    {
                        DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / BusRelations / Unknown type 0x%lx\n",
                            Type);
                        ASSERT(FALSE);
                    }
                    break;
                }
                default:
                {
                    DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / Unknown type 0x%lx\n",
                        Stack->Parameters.QueryDeviceRelations.Type);
                    break;
                }
            }
            break;
        }
        case IRP_MN_QUERY_RESOURCES: /* 0x0a */
        {
            DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_RESOURCES\n");
            /* We don't need resources */
            break;
        }
        case IRP_MN_QUERY_RESOURCE_REQUIREMENTS: /* 0x0b */
        {
            DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n");
            /* We don't need resources */
            break;
        }
        case IRP_MN_QUERY_DEVICE_TEXT: /* 0x0c */
        {
            DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_TEXT\n");
            switch (Stack->Parameters.QueryDeviceText.DeviceTextType)
            {
                case DeviceTextDescription:
                {
                    LPCWSTR Description = NULL;
                    if (Type == GreenFDO)
                        Description = L"Green device";
                    else if (Type == ScreenPDO)
                        Description = L"Green screen";
                    else if (Type == KeyboardPDO)
                        Description = L"Green keyboard";
 
                    if (Description != NULL)
                    {
                        LPWSTR Destination = ExAllocatePool(PagedPool, wcslen(Description) * sizeof(WCHAR) + sizeof(UNICODE_NULL));
                        if (!Destination)
                            Status = STATUS_INSUFFICIENT_RESOURCES;
                        else
                        {
                            wcscpy(Destination, Description);
                            Information = (ULONG_PTR)Description;
                            Status = STATUS_SUCCESS;
                        }
                    }
                    else
                    {
                        DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_TEXT / DeviceTextDescription / Unknown type 0x%lx\n",
                            Type);
                        ASSERT(FALSE);
                    }
                    break;
                }
                case DeviceTextLocationInformation:
                {
                    /* We don't have any text location to report,
                     * and this query is optional, so ignore it.
                     */
                    break;
                }
                default:
                {
                    DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_TEXT / unknown type 0x%lx\n",
                        Stack->Parameters.QueryDeviceText.DeviceTextType);
                    ASSERT(FALSE);
                    break;
                }
            }
            break;
        }
        case IRP_MN_QUERY_ID: /* 0x13 */
        {
            DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_ID\n");
            Status = GreenQueryId(DeviceObject, Irp, &Information);
            break;
        }
        default:
        {
            DPRINT1("IRP_MJ_PNP / unknown minor function 0x%lx\n", Stack->MinorFunction);
            break;
        }
    }
 
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = Information;
    if (Status != STATUS_PENDING)
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

Referenced by GreenDispatch().

GreenPower()

NTSTATUS GreenPower	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 15 of file power.c.

{
    GREEN_DEVICE_TYPE Type;
    PIO_STACK_LOCATION Stack;
    ULONG_PTR Information = Irp->IoStatus.Information;
    NTSTATUS Status = Irp->IoStatus.Status;
 
    Type = ((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->Type;
    Stack = IoGetCurrentIrpStackLocation(Irp);
 
    switch (Stack->MinorFunction)
    {
        case IRP_MN_SET_POWER: /* 0x02 */
        {
            DPRINT("IRP_MJ_POWER / IRP_MN_SET_POWER\n");
            if (Type == GreenFDO)
            {
                PoStartNextPowerIrp(Irp);
                Status = STATUS_SUCCESS;
            }
            else
            {
                DPRINT1("IRP_MJ_POWER / IRP_MN_SET_POWER / Unknown type 0x%lx\n",
                    Type);
                ASSERT(FALSE);
            }
            break;
        }
        default:
        {
            DPRINT1("IRP_MJ_POWER / unknown minor function 0x%lx\n", Stack->MinorFunction);
            break;
        }
    }
 
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = Information;
    if (Status != STATUS_PENDING)
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

Referenced by GreenDispatch().

KeyboardAddDevice()

NTSTATUS KeyboardAddDevice	(	IN PDRIVER_OBJECT	DriverObject,
		IN PDEVICE_OBJECT	Pdo
	)

Definition at line 109 of file keyboard.c.

{
    PDEVICE_OBJECT Fdo;
    PKEYBOARD_DEVICE_EXTENSION DeviceExtension;
    NTSTATUS Status;
 
    DPRINT("KeyboardInitialize() called\n");
 
    Status = IoCreateDevice(DriverObject,
        sizeof(KEYBOARD_DEVICE_EXTENSION),
        NULL,
        FILE_DEVICE_KEYBOARD,
        FILE_DEVICE_SECURE_OPEN,
        TRUE,
        &Fdo);
    if (!NT_SUCCESS(Status))
        return Status;
 
    DeviceExtension = (PKEYBOARD_DEVICE_EXTENSION)Fdo->DeviceExtension;
    RtlZeroMemory(DeviceExtension, sizeof(KEYBOARD_DEVICE_EXTENSION));
    DeviceExtension->Common.Type = KeyboardFDO;
    DeviceExtension->Common.LowerDevice = IoAttachDeviceToDeviceStack(Fdo, Pdo);
    DeviceExtension->Green = ((PGREEN_DRIVER_EXTENSION)IoGetDriverObjectExtension(DriverObject, DriverObject))->GreenMainDO;
    ((PGREEN_DEVICE_EXTENSION)DeviceExtension->Green->DeviceExtension)->KeyboardFdo = Fdo;
    Fdo->Flags |= DO_POWER_PAGABLE | DO_BUFFERED_IO;
    Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
 
    return STATUS_SUCCESS;
}

Referenced by GreenAddDevice().

KeyboardInternalDeviceControl()

NTSTATUS KeyboardInternalDeviceControl	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 272 of file keyboard.c.

{
    PIO_STACK_LOCATION Stack;
    PKEYBOARD_DEVICE_EXTENSION DeviceExtension;
    NTSTATUS Status;
 
    Stack = IoGetCurrentIrpStackLocation(Irp);
    Irp->IoStatus.Information = 0;
    DeviceExtension = (PKEYBOARD_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    switch (Stack->Parameters.DeviceIoControl.IoControlCode)
    {
        case IOCTL_INTERNAL_KEYBOARD_CONNECT:
        {
            DPRINT("IRP_MJ_INTERNAL_DEVICE_CONTROL / IOCTL_INTERNAL_KEYBOARD_CONNECT\n");
            if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(CONNECT_DATA))
            {
                Status = STATUS_INVALID_PARAMETER;
                break;
            }
 
            DeviceExtension->ClassInformation =
                *((PCONNECT_DATA)Stack->Parameters.DeviceIoControl.Type3InputBuffer);
 
            /* Start read loop */
            Status = PsCreateSystemThread(
                &DeviceExtension->WorkerThreadHandle,
                (ACCESS_MASK)0L,
                NULL,
                NULL,
                NULL,
                KeyboardDeviceWorker,
                DeviceObject);
            break;
        }
        default:
        {
            DPRINT("IRP_MJ_INTERNAL_DEVICE_CONTROL / unknown ioctl code 0x%lx\n",
                Stack->Parameters.DeviceIoControl.IoControlCode);
            Status = STATUS_INVALID_DEVICE_REQUEST;
        }
    }
 
    Irp->IoStatus.Status = Status;
    IoCompleteRequest (Irp, IO_NO_INCREMENT);
    return Status;
}

Referenced by GreenDispatch().

ReadRegistryEntries()

NTSTATUS ReadRegistryEntries	(	IN PUNICODE_STRING	RegistryPath,
		IN PGREEN_DRIVER_EXTENSION	DriverExtension
	)

Definition at line 63 of file misc.c.

{
    UNICODE_STRING ParametersRegistryKey;
    RTL_QUERY_REGISTRY_TABLE Parameters[4];
    NTSTATUS Status;
 
    ULONG DefaultDeviceReported = 0;
    ULONG DefaultSampleRate = 1200;
 
    ParametersRegistryKey.Length = 0;
    ParametersRegistryKey.MaximumLength = RegistryPath->Length + sizeof(L"\\Parameters") + sizeof(UNICODE_NULL);
    ParametersRegistryKey.Buffer = ExAllocatePool(PagedPool, ParametersRegistryKey.MaximumLength);
    if (!ParametersRegistryKey.Buffer)
    {
        DPRINT("ExAllocatePool() failed\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    RtlCopyUnicodeString(&ParametersRegistryKey, RegistryPath);
    RtlAppendUnicodeToString(&ParametersRegistryKey, L"\\Parameters");
    ParametersRegistryKey.Buffer[ParametersRegistryKey.Length / sizeof(WCHAR)] = UNICODE_NULL;
 
    RtlZeroMemory(Parameters, sizeof(Parameters));
 
    Parameters[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
    Parameters[0].Name = L"AttachedDevice";
    Parameters[0].EntryContext = &DriverExtension->AttachedDeviceName;
 
    Parameters[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
    Parameters[1].Name = L"DeviceReported";
    Parameters[1].EntryContext = &DriverExtension->DeviceReported;
    Parameters[1].DefaultType = REG_DWORD;
    Parameters[1].DefaultData = &DefaultDeviceReported;
    Parameters[1].DefaultLength = sizeof(ULONG);
 
    Parameters[2].Flags = RTL_QUERY_REGISTRY_DIRECT;
    Parameters[2].Name = L"SampleRate";
    Parameters[2].EntryContext = &DriverExtension->SampleRate;
    Parameters[2].DefaultType = REG_DWORD;
    Parameters[2].DefaultData = &DefaultSampleRate;
    Parameters[2].DefaultLength = sizeof(ULONG);
 
    Status = RtlQueryRegistryValues(
        RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
        ParametersRegistryKey.Buffer,
        Parameters,
        NULL,
        NULL);
 
    return Status;
}

ScreenAddDevice()

NTSTATUS ScreenAddDevice	(	IN PDRIVER_OBJECT	DriverObject,
		IN PDEVICE_OBJECT	Pdo
	)

Definition at line 111 of file screen.c.

{
    /* We want to be an upper filter of Blue, if it is existing.
     * We also *have to* create a Fdo on top of the given Pdo.
     * Hence, we have 2 cases:
     * - Blue doesn't exist -> Create a unique Fdo (named Blue) at
     *   the top of the given Pdo
     * - Blue does exist -> Create a Fdo at the top of the existing
     *   DO, and create a "pass to Green" FDO at the top of the Pdo
     */
    PDEVICE_OBJECT Fdo = NULL;
    PDEVICE_OBJECT PassThroughFdo = NULL;
    PDEVICE_OBJECT LowerDevice = NULL;
    PDEVICE_OBJECT PreviousBlue = NULL;
    PSCREEN_DEVICE_EXTENSION DeviceExtension = NULL;
    UNICODE_STRING BlueScreenName = RTL_CONSTANT_STRING(L"\\Device\\BlueScreen");
    NTSTATUS Status;
 
    DPRINT("ScreenInitialize() called\n");
 
    /* Try to create a unique Fdo */
    Status = IoCreateDevice(
        DriverObject,
        sizeof(SCREEN_DEVICE_EXTENSION),
        &BlueScreenName,
        FILE_DEVICE_SCREEN,
        FILE_DEVICE_SECURE_OPEN,
        TRUE,
        &Fdo);
 
    if (Status == STATUS_OBJECT_NAME_COLLISION)
    {
        DPRINT("Attaching to old blue\n");
 
        /* Suggested by hpoussin .. Hide previous blue device
         * This makes us able to coexist with blue, and install
         * when loaded */
        Status = IoCreateDevice(
            DriverObject,
            sizeof(SCREEN_DEVICE_EXTENSION),
            NULL,
            FILE_DEVICE_SCREEN,
            FILE_DEVICE_SECURE_OPEN,
            TRUE,
            &Fdo);
        if (!NT_SUCCESS(Status))
        {
            DPRINT("IoCreateDevice() failed with status 0x%08lx\n", Status);
            goto cleanup;
        }
 
        /* Initialize some fields, as IoAttachDevice will trigger the
         * sending of IRP_MJ_CLEANUP/IRP_MJ_CLOSE. We have to know where to
         * dispatch these IRPs... */
        ((PSCREEN_DEVICE_EXTENSION)Fdo->DeviceExtension)->Common.Type = ScreenPDO;
        Status = IoAttachDevice(
            Fdo,
            &BlueScreenName,
            &LowerDevice);
        if (!NT_SUCCESS(Status))
        {
            DPRINT("IoAttachDevice() failed with status 0x%08lx\n", Status);
            goto cleanup;
        }
        PreviousBlue = LowerDevice;
 
        /* Attach a faked FDO to PDO */
        Status = IoCreateDevice(
            DriverObject,
            sizeof(COMMON_FDO_DEVICE_EXTENSION),
            NULL,
            FILE_DEVICE_SCREEN,
            FILE_DEVICE_SECURE_OPEN,
            TRUE,
            &PassThroughFdo);
        if (!NT_SUCCESS(Status))
        {
            DPRINT("IoCreateDevice() failed with status 0x%08lx\n", Status);
            goto cleanup;
        }
        ((PCOMMON_FDO_DEVICE_EXTENSION)PassThroughFdo->DeviceExtension)->Type = PassThroughFDO;
        ((PCOMMON_FDO_DEVICE_EXTENSION)PassThroughFdo->DeviceExtension)->LowerDevice = Fdo;
        PassThroughFdo->StackSize = Fdo->StackSize + 1;
    }
    else if (NT_SUCCESS(Status))
    {
        /* Attach the named Fdo on top of Pdo */
        LowerDevice = IoAttachDeviceToDeviceStack(Fdo, Pdo);
    }
    else
    {
        DPRINT("IoCreateDevice() failed with status 0x%08lx\n", Status);
        return Status;
    }
 
    /* We definately have a device object. PreviousBlue may or may
     * not be null */
    DeviceExtension = (PSCREEN_DEVICE_EXTENSION)Fdo->DeviceExtension;
    RtlZeroMemory(DeviceExtension, sizeof(SCREEN_DEVICE_EXTENSION));
    DeviceExtension->Common.Type = ScreenFDO;
    DeviceExtension->Common.LowerDevice = LowerDevice;
    DeviceExtension->Green = ((PGREEN_DRIVER_EXTENSION)IoGetDriverObjectExtension(DriverObject, DriverObject))->GreenMainDO;
    ((PGREEN_DEVICE_EXTENSION)DeviceExtension->Green->DeviceExtension)->ScreenFdo = Fdo;
    DeviceExtension->PreviousBlue = PreviousBlue;
    IoAttachDeviceToDeviceStack(PassThroughFdo ? PassThroughFdo : Fdo, Pdo);
 
    /* initialize screen */
    DeviceExtension->Columns = 80;
    DeviceExtension->Rows = 25;
    DeviceExtension->ScanLines = 16;
    DeviceExtension->VideoMemory = (PUCHAR)ExAllocatePool(
        PagedPool,
        2 * DeviceExtension->Columns * DeviceExtension->Rows * sizeof(UCHAR));
    if (!DeviceExtension->VideoMemory)
    {
        DPRINT("ExAllocatePool() failed\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto cleanup;
    }
    DeviceExtension->TabWidth = 8;
 
    /* more initialization */
    DeviceExtension->Mode = ENABLE_PROCESSED_OUTPUT |
        ENABLE_WRAP_AT_EOL_OUTPUT;
 
    /* initialize screen at next write */
    AddToSendBuffer(DeviceExtension, 2, ESC, 'c'); /* reset device */
    AddToSendBuffer(DeviceExtension, 4, ESC, '[', '7', 'l'); /* disable line wrap */
    AddToSendBuffer(DeviceExtension, 4, ESC, '[', '3', 'g'); /* clear all tabs */
 
    Fdo->Flags |= DO_POWER_PAGABLE;
    Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
 
    Status = STATUS_SUCCESS;
 
cleanup:
    if (!NT_SUCCESS(Status))
    {
        if (DeviceExtension)
            ExFreePool(DeviceExtension->VideoMemory);
        if (LowerDevice)
            IoDetachDevice(LowerDevice);
        if (Fdo)
            IoDeleteDevice(Fdo);
        if (PassThroughFdo)
            IoDeleteDevice(PassThroughFdo);
    }
 
    return Status;
}

Referenced by GreenAddDevice().

ScreenDeviceControl()

NTSTATUS ScreenDeviceControl	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 408 of file screen.c.

{
    PIO_STACK_LOCATION Stack;
    PSCREEN_DEVICE_EXTENSION DeviceExtension;
    PDEVICE_OBJECT SerialDevice;
    NTSTATUS Status;
 
    Stack = IoGetCurrentIrpStackLocation(Irp);
    DeviceExtension = (PSCREEN_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    SerialDevice = ((PGREEN_DEVICE_EXTENSION)DeviceExtension->Green->DeviceExtension)->Serial;
    if (!SerialDevice)
    {
        DPRINT1("Calling blue\n");
        IoSkipCurrentIrpStackLocation(Irp);
        return IoCallDriver(DeviceExtension->PreviousBlue, Irp);
    }
 
    switch (Stack->Parameters.DeviceIoControl.IoControlCode)
    {
#if 0
        case IOCTL_CONSOLE_GET_SCREEN_BUFFER_INFO:
        {
            PCONSOLE_SCREEN_BUFFER_INFO pcsbi;
            DPRINT("IRP_MJ_DEVICE_CONTROL / IOCTL_CONSOLE_GET_SCREEN_BUFFER_INFO\n");
 
            pcsbi = (PCONSOLE_SCREEN_BUFFER_INFO)Irp->AssociatedIrp.SystemBuffer;
 
            pcsbi->dwSize.X = DeviceExtension->Columns;
            pcsbi->dwSize.Y = DeviceExtension->Rows;
 
            pcsbi->dwCursorPosition.X = (SHORT)(DeviceExtension->LogicalOffset % DeviceExtension->Columns);
            pcsbi->dwCursorPosition.Y = (SHORT)(DeviceExtension->LogicalOffset / DeviceExtension->Columns);
 
            pcsbi->wAttributes = DeviceExtension->CharAttribute;
 
            pcsbi->srWindow.Left   = 1;
            pcsbi->srWindow.Right  = DeviceExtension->Columns;
            pcsbi->srWindow.Top    = 1;
            pcsbi->srWindow.Bottom = DeviceExtension->Rows;
 
            pcsbi->dwMaximumWindowSize.X = DeviceExtension->Columns;
            pcsbi->dwMaximumWindowSize.Y = DeviceExtension->Rows;
 
            Irp->IoStatus.Information = sizeof(CONSOLE_SCREEN_BUFFER_INFO);
            Status = STATUS_SUCCESS;
            break;
        }
        case IOCTL_CONSOLE_SET_SCREEN_BUFFER_INFO:
        {
            PCONSOLE_SCREEN_BUFFER_INFO pcsbi;
            DPRINT("IRP_MJ_DEVICE_CONTROL / IOCTL_CONSOLE_SET_SCREEN_BUFFER_INFO\n");
 
            pcsbi = (PCONSOLE_SCREEN_BUFFER_INFO)Irp->AssociatedIrp.SystemBuffer;
            /* FIXME: remove */ { pcsbi->dwCursorPosition.X++; }
            /* FIXME: remove */ { pcsbi->dwCursorPosition.Y++; }
            ASSERT(pcsbi->dwCursorPosition.X >= 1);
            ASSERT(pcsbi->dwCursorPosition.Y >= 1);
            ASSERT(pcsbi->dwCursorPosition.X <= DeviceExtension->Columns);
            ASSERT(pcsbi->dwCursorPosition.Y <= DeviceExtension->Rows);
 
            DeviceExtension->LogicalOffset = (
                (pcsbi->dwCursorPosition.Y-1) * DeviceExtension->Columns +
                (pcsbi->dwCursorPosition.X-1)) * 2;
            AddToSendBuffer(DeviceExtension, 6, ESC, '[',
                -(int)pcsbi->dwCursorPosition.Y, ';',
                -(int)pcsbi->dwCursorPosition.X, 'H');
 
            /* flush buffer */
            AddToSendBuffer(DeviceExtension, 0);
 
            DeviceExtension->CharAttribute = pcsbi->wAttributes;
 
            Irp->IoStatus.Information = 0;
            Status = STATUS_SUCCESS;
            break;
        }
        case IOCTL_CONSOLE_GET_CURSOR_INFO:
        {
            PCONSOLE_CURSOR_INFO pcci = (PCONSOLE_CURSOR_INFO)Irp->AssociatedIrp.SystemBuffer;
            DPRINT("IRP_MJ_DEVICE_CONTROL / IOCTL_CONSOLE_GET_CURSOR_INFO\n");
 
            pcci->dwSize = 1;
            pcci->bVisible = TRUE;
 
            Irp->IoStatus.Information = sizeof (CONSOLE_CURSOR_INFO);
            Status = STATUS_SUCCESS;
            break;
        }
        case IOCTL_CONSOLE_GET_MODE:
        {
            PCONSOLE_MODE pcm = (PCONSOLE_MODE)Irp->AssociatedIrp.SystemBuffer;
            DPRINT("IRP_MJ_DEVICE_CONTROL / IOCTL_CONSOLE_GET_MODE\n");
 
            pcm->dwMode = DeviceExtension->Mode;
 
            Irp->IoStatus.Information = sizeof(CONSOLE_MODE);
            Status = STATUS_SUCCESS;
            break;
        }
        case IOCTL_CONSOLE_SET_MODE:
        {
            PCONSOLE_MODE pcm = (PCONSOLE_MODE)Irp->AssociatedIrp.SystemBuffer;
            DPRINT("IRP_MJ_DEVICE_CONTROL / IOCTL_CONSOLE_SET_MODE\n");
 
            DeviceExtension->Mode = pcm->dwMode;
 
            Irp->IoStatus.Information = 0;
            Status = STATUS_SUCCESS;
            break;
        }
        case IOCTL_CONSOLE_FILL_OUTPUT_ATTRIBUTE:
        {
            DPRINT1("IRP_MJ_DEVICE_CONTROL / IOCTL_CONSOLE_FILL_OUTPUT_ATTRIBUTE\n");
            Status = STATUS_NOT_IMPLEMENTED; /* FIXME: IOCTL_CONSOLE_FILL_OUTPUT_ATTRIBUTE */
            break;
        }
        case IOCTL_CONSOLE_READ_OUTPUT_ATTRIBUTE:
        {
            DPRINT1("IRP_MJ_DEVICE_CONTROL / IOCTL_CONSOLE_READ_OUTPUT_ATTRIBUTE\n");
            Status = STATUS_NOT_IMPLEMENTED; /* FIXME: IOCTL_CONSOLE_READ_OUTPUT_ATTRIBUTE */
            break;
        }
        case IOCTL_CONSOLE_WRITE_OUTPUT_ATTRIBUTE:
        {
            DPRINT1("IRP_MJ_DEVICE_CONTROL / IOCTL_CONSOLE_WRITE_OUTPUT_ATTRIBUTE\n");
            Status = STATUS_NOT_IMPLEMENTED; /* FIXME: IOCTL_CONSOLE_WRITE_OUTPUT_ATTRIBUTE */
            break;
        }
        case IOCTL_CONSOLE_SET_TEXT_ATTRIBUTE:
        {
            DPRINT("IRP_MJ_DEVICE_CONTROL / IOCTL_CONSOLE_SET_TEXT_ATTRIBUTE\n");
 
            DeviceExtension->CharAttribute = (WORD)*(PWORD)Irp->AssociatedIrp.SystemBuffer;
            Irp->IoStatus.Information = 0;
            Status = STATUS_SUCCESS;
            break;
        }
        case IOCTL_CONSOLE_FILL_OUTPUT_CHARACTER:
        {
            DPRINT1("IRP_MJ_DEVICE_CONTROL / IOCTL_CONSOLE_FILL_OUTPUT_CHARACTER\n");
            Status = STATUS_NOT_IMPLEMENTED; /* FIXME:IOCTL_CONSOLE_FILL_OUTPUT_CHARACTER */
            break;
        }
        case IOCTL_CONSOLE_READ_OUTPUT_CHARACTER:
        {
            DPRINT1("IRP_MJ_DEVICE_CONTROL / IOCTL_CONSOLE_READ_OUTPUT_CHARACTER\n");
            Status = STATUS_NOT_IMPLEMENTED; /* FIXME: IOCTL_CONSOLE_READ_OUTPUT_CHARACTER */
            break;
        }
        case IOCTL_CONSOLE_WRITE_OUTPUT_CHARACTER:
        {
            DPRINT1("IRP_MJ_DEVICE_CONTROL / IOCTL_CONSOLE_WRITE_OUTPUT_CHARACTER\n");
            Status = STATUS_NOT_IMPLEMENTED; /* FIXME: IOCTL_CONSOLE_WRITE_OUTPUT_CHARACTER */
            break;
        }
        case IOCTL_CONSOLE_DRAW:
        {
            PCONSOLE_DRAW ConsoleDraw;
            PUCHAR Video;
            ULONG x, y;
            BOOLEAN DoOptimization = FALSE;
            DPRINT("IRP_MJ_DEVICE_CONTROL / IOCTL_CONSOLE_DRAW\n");
 
            ConsoleDraw = (PCONSOLE_DRAW)MmGetSystemAddressForMdl(Irp->MdlAddress);
            /* FIXME: remove */ { ConsoleDraw->X++; ConsoleDraw->CursorX++; }
            /* FIXME: remove */ { ConsoleDraw->Y++; ConsoleDraw->CursorY++; }
            DPRINT1("%lu %lu %lu %lu\n",
                ConsoleDraw->X, ConsoleDraw->Y,
                ConsoleDraw->SizeX, ConsoleDraw->SizeY);
            ASSERT(ConsoleDraw->X >= 1);
            ASSERT(ConsoleDraw->Y >= 1);
            ASSERT(ConsoleDraw->X <= DeviceExtension->Columns);
            ASSERT(ConsoleDraw->Y <= DeviceExtension->Rows);
            ASSERT(ConsoleDraw->X + ConsoleDraw->SizeX >= 1);
            ASSERT(ConsoleDraw->Y + ConsoleDraw->SizeY >= 1);
            ASSERT(ConsoleDraw->X + ConsoleDraw->SizeX - 1 <= DeviceExtension->Columns);
            ASSERT(ConsoleDraw->Y + ConsoleDraw->SizeY - 1 <= DeviceExtension->Rows);
            ASSERT(ConsoleDraw->CursorX >= 1);
            ASSERT(ConsoleDraw->CursorY >= 1);
            ASSERT(ConsoleDraw->CursorX <= DeviceExtension->Columns);
            ASSERT(ConsoleDraw->CursorY <= DeviceExtension->Rows);
 
#if 0
            if (ConsoleDraw->X == 1
                && ConsoleDraw->Y == 1
                && ConsoleDraw->SizeX == DeviceExtension->Columns
                && ConsoleDraw->SizeY == DeviceExtension->Rows)
            {
                /* search if we need to clear all screen */
                DoOptimization = TRUE;
                Video = (PUCHAR)(ConsoleDraw + 1);
                x = 0;
                while (DoOptimization && x < DeviceExtension->Columns * DeviceExtension->Rows)
                {
                    if (Video[x++] != ' ')
                    {
                        DoOptimization = FALSE;
                    }
                    /*if (Video[x++] != DeviceExtension->CharAttribute) DoOptimization = FALSE; */
                }
                if (DoOptimization)
                {
                    AddToSendBuffer(DeviceExtension, 4, ESC, '[', '2', 'J');
                }
            }
#endif
            /* add here more optimizations if needed */
 
            if (!DoOptimization)
            {
                for (y = 0; y < ConsoleDraw->SizeY; y++)
                {
                    AddToSendBuffer(DeviceExtension, 6, ESC, '[',
                        -(int)(ConsoleDraw->Y + y), ';',
                        -(int)(ConsoleDraw->X), 'H');
                    Video = (PUCHAR)(ConsoleDraw + 1);
                    Video = &Video[((ConsoleDraw->Y + y) * /*DeviceExtension->Columns +*/ ConsoleDraw->X) * 2];
                    for (x = 0; x < ConsoleDraw->SizeX; x++)
                    {
                        AddToSendBuffer(DeviceExtension, 1, Video[x * 2]);
                    }
                }
            }
 
            DeviceExtension->LogicalOffset = (
                (ConsoleDraw->CursorY-1) * DeviceExtension->Columns +
                (ConsoleDraw->CursorX-1)) * 2;
            AddToSendBuffer(DeviceExtension, 6, ESC, '[',
                -(int)(ConsoleDraw->CursorY), ';',
                -(int)(ConsoleDraw->CursorX), 'H');
 
            /* flush buffer */
            AddToSendBuffer(DeviceExtension, 0);
 
            Irp->IoStatus.Information = 0;
            Status = STATUS_SUCCESS;
            break;
        }
#endif
        default:
        {
            DPRINT1("IRP_MJ_DEVICE_CONTROL / unknown ioctl code 0x%lx\n",
                Stack->Parameters.DeviceIoControl.IoControlCode);
            /* Call lower driver */
            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(DeviceExtension->Common.LowerDevice, Irp);
        }
    }
 
    if (!NT_SUCCESS(Status))
    {
        /* Don't call blue (if any), as we encountered an error */
        Irp->IoStatus.Status = Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }
    else
    {
        /* Call lower driver */
        IoSkipCurrentIrpStackLocation(Irp);
        return IoCallDriver(DeviceExtension->Common.LowerDevice, Irp);
    }
}

Referenced by GreenDispatch().

ScreenWrite()

NTSTATUS ScreenWrite	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 265 of file screen.c.

{
    PIO_STACK_LOCATION Stack;
    PUCHAR Buffer;
    PSCREEN_DEVICE_EXTENSION DeviceExtension;
    PDEVICE_OBJECT SerialDevice;
    PUCHAR VideoMemory; /* FIXME: is it useful? */
    ULONG VideoMemorySize; /* FIXME: is it useful? */
 
    ULONG Columns, Rows;
    ULONG CursorX, CursorY;
    ULONG i, j;
    DBG_UNREFERENCED_LOCAL_VARIABLE(VideoMemory);
    DBG_UNREFERENCED_LOCAL_VARIABLE(VideoMemorySize);
 
    DPRINT("ScreenWrite() called\n");
 
    Stack = IoGetCurrentIrpStackLocation (Irp);
    Buffer = Irp->UserBuffer;
    DeviceExtension = (PSCREEN_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    VideoMemory = DeviceExtension->VideoMemory;
 
    SerialDevice = ((PGREEN_DEVICE_EXTENSION)DeviceExtension->Green->DeviceExtension)->Serial;
    if (!SerialDevice)
    {
        DPRINT1("Calling blue\n");
        IoSkipCurrentIrpStackLocation(Irp);
        return IoCallDriver(DeviceExtension->PreviousBlue, Irp);
    }
 
    Columns = DeviceExtension->Columns;
    Rows = DeviceExtension->Rows;
    CursorX = (DeviceExtension->LogicalOffset / 2) % Columns + 1;
    CursorY = (DeviceExtension->LogicalOffset / 2) / Columns + 1;
    VideoMemorySize = Columns * Rows * 2 * sizeof(UCHAR);
 
    if (!(DeviceExtension->Mode & ENABLE_PROCESSED_OUTPUT))
    {
        /* raw output mode */
        Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
        IoCompleteRequest (Irp, IO_NO_INCREMENT);
 
        return STATUS_NOT_SUPPORTED;
    }
    else
    {
        for (i = 0; i < Stack->Parameters.Write.Length; i++, Buffer++)
        {
            switch (*Buffer)
            {
                case '\b':
                {
                    if (CursorX > 1)
                    {
                        CursorX--;
                        AddToSendBuffer(DeviceExtension, 6, ESC, '[', -(int)CursorY, ';', -(int)CursorX, 'H');
                        AddToSendBuffer(DeviceExtension, 1, ' ');
                        AddToSendBuffer(DeviceExtension, 6, ESC, '[', -(int)CursorY, ';', -(int)CursorX, 'H');
                    }
                    else if (CursorY > 1)
                    {
                        CursorX = Columns;
                        CursorY--;
                        AddToSendBuffer(DeviceExtension, 6, ESC, '[', -(int)CursorY, ';', -(int)CursorX, 'H');
                    }
                    break;
                }
                case '\n':
                {
                    CursorY++;
                    CursorX = 1;
                    AddToSendBuffer(DeviceExtension, 1, '\n');
                    AddToSendBuffer(DeviceExtension, 6, ESC, '[', -(int)CursorY, ';', '1', 'H');
                    break;
                }
                case '\r':
                {
                    if (CursorX > 1)
                    {
                        AddToSendBuffer(DeviceExtension, 4, ESC, '[', -(int)(CursorX-1), 'D');
                        CursorX = 1;
                    }
                    break;
                }
                case '\t':
                {
                    ULONG Offset = DeviceExtension->TabWidth - (CursorX % DeviceExtension->TabWidth);
                    for (j = 0; j < Offset; j++)
                    {
#ifdef FORCE_POSITION
                        AddToSendBuffer(DeviceExtension, 6, ESC, '[', -(int)CursorY, ';', -(int)CursorX, 'H');
#endif
                        AddToSendBuffer(DeviceExtension, 1, ' ');
                        CursorX++;
                        if (CursorX > Columns)
                        {
                            CursorX = 1;
                            CursorY++;
                        }
                    }
                    break;
                }
                default:
                {
#ifdef FORCE_POSITION
                    AddToSendBuffer(DeviceExtension, 6, ESC, '[', -(int)CursorY, ';', -(int)CursorX, 'H');
#endif
                    AddToSendBuffer(DeviceExtension, 1, *Buffer);
                    CursorX++;
                    if (CursorX > Columns)
                    {
                        CursorX = 1;
                        DPRINT("Y: %lu -> %lu\n", CursorY, CursorY + 1);
                        CursorY++;
                        AddToSendBuffer(DeviceExtension, 6, ESC, '[', -(int)CursorY, ';', '1', 'H');
 
                    }
                }
            }
            if (CursorY >= Rows)
            {
                DPRINT("Y: %lu -> %lu\n", CursorY, CursorY - 1);
                CursorY--;
                AddToSendBuffer(DeviceExtension, 6, ESC, '[', -(int)1, ';', -(int)(Rows), 'r');
                AddToSendBuffer(DeviceExtension, 2, ESC, 'D');
                AddToSendBuffer(DeviceExtension, 6, ESC, '[', -(int)CursorY, ';', -(int)CursorX, 'H');
            }
        }
    }
 
    DeviceExtension->LogicalOffset = ((CursorX-1) + (CursorY-1) * Columns) * 2;
 
    /* flush output buffer */
    AddToSendBuffer(DeviceExtension, 0);
 
    /* Call lower driver */
    IoSkipCurrentIrpStackLocation(Irp);
    return IoCallDriver(DeviceExtension->Common.LowerDevice, Irp);
}

Referenced by GreenDispatch().