reactos/rosapps/drivers/green/screen.c

/*
 * PROJECT:     ReactOS VT100 emulator
 * LICENSE:     GPL - See COPYING in the top level directory
 * FILE:        drivers/base/green/screen.c
 * PURPOSE:     IRP_MJ_PNP operations
 * PROGRAMMERS: Copyright 2005 Eric Kohl (ekohl@abo.rhein-zeitung.de)
 *              Copyright 2005 Art Yerkes
 *              Copyright 2005-2006 Hervé Poussineau (hpoussin@reactos.org)
 */

#include "green.h"

#define NDEBUG
#include <debug.h>

#define ESC       ((UCHAR)0x1b)

/* Force a move of the cursor on each printer char.
 * Very useful for debug, but it is very slow...
 */
//#define FORCE_POSITION

/* UCHAR is promoted to int when passed through '...',
 * so we get int with va_arg and cast them back to UCHAR.
 */
static VOID
AddToSendBuffer(
	IN PSCREEN_DEVICE_EXTENSION DeviceExtension,
	IN ULONG NumberOfChars,
	... /* IN int */)
{
	PIRP Irp;
	IO_STATUS_BLOCK ioStatus;
	va_list args;
	PDEVICE_OBJECT SerialDevice;
	ULONG SizeLeft;
	int CurrentInt;
	UCHAR CurrentChar;
	NTSTATUS Status;
	LARGE_INTEGER ZeroOffset;

	ZeroOffset.QuadPart = 0;

	SizeLeft = sizeof(DeviceExtension->SendBuffer) - DeviceExtension->SendBufferPosition;
	if (SizeLeft < NumberOfChars * 2 || NumberOfChars == 0)
	{
		SerialDevice = ((PGREEN_DEVICE_EXTENSION)DeviceExtension->Green->DeviceExtension)->Serial;
		Irp = IoBuildSynchronousFsdRequest(
			IRP_MJ_WRITE,
			SerialDevice,
			DeviceExtension->SendBuffer, DeviceExtension->SendBufferPosition,
			&ZeroOffset,
			NULL, /* Event */
			&ioStatus);
		if (!Irp)
		{
			DPRINT1("IoBuildSynchronousFsdRequest() failed. Unable to flush output buffer\n");
			return;
		}

		Status = IoCallDriver(SerialDevice, Irp);

		if (!NT_SUCCESS(Status) && Status != STATUS_PENDING)
		{
			DPRINT1("IoCallDriver() failed. Status = 0x%08lx\n", Status);
			return;
		}
		DeviceExtension->SendBufferPosition = 0;
		SizeLeft = sizeof(DeviceExtension->SendBuffer);
	}

	va_start(args, NumberOfChars);
	while (NumberOfChars-- > 0)
	{
		CurrentInt = va_arg(args, int);

		if (CurrentInt > 0)
		{
			CurrentChar = (UCHAR)CurrentInt;

			/* Why 0xff chars are printed on a 'dir' ? */
			if (CurrentChar == 0xff) CurrentChar = ' ';

			DeviceExtension->SendBuffer[DeviceExtension->SendBufferPosition++] = CurrentChar;
			SizeLeft--;
		}
		else if (CurrentInt == 0)
		{
			DeviceExtension->SendBuffer[DeviceExtension->SendBufferPosition++] = '0';
			SizeLeft--;
		}
		else
		{
			CurrentInt = -CurrentInt;
			ASSERT(CurrentInt < 100);
			if (CurrentInt >= 10)
			{
				DeviceExtension->SendBuffer[DeviceExtension->SendBufferPosition++] =
					(CurrentInt / 10) % 10 + '0';
				SizeLeft--;
			}
			DeviceExtension->SendBuffer[DeviceExtension->SendBufferPosition++] =
				CurrentInt % 10 + '0';
			SizeLeft--;
		}
	}
	va_end(args);
}

NTSTATUS
ScreenAddDevice(
	IN PDRIVER_OBJECT DriverObject,
	IN PDEVICE_OBJECT Pdo)
{
	/* 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;
}

NTSTATUS
ScreenWrite(
	IN PDEVICE_OBJECT DeviceObject,
	IN PIRP Irp)
{
	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);
}

NTSTATUS
ScreenDeviceControl(
	IN PDEVICE_OBJECT DeviceObject,
	IN PIRP Irp)
{
	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);
	}
}