kdbg.c

ReactOS是一些高手根据Windows XP的内核编写出的类XP。内核实现机理和API函数调用几乎相同。甚至可以兼容XP的程序。喜欢研究系统内核的人可以看一看。

						ComPortBase = (PUCHAR)BaseArray[PortInformation->ComPort];
						PortInformation->BaseAddress = (ULONG)ComPortBase;
#ifndef NDEBUG
						sprintf (buffer,
								 "\nSerial port COM%ld found at 0x%lx\n",
								 PortInformation->ComPort,
								 (ULONG)ComPortBase];
						HalDisplayString (buffer);
#endif /* NDEBUG */
				}
				else
				{
						sprintf (buffer,
								 "\nKernel Debugger: Serial port not found!!!\n\n");
						HalDisplayString (buffer);
						return FALSE;
				}
		}

        /*
         * set baud rate and data format (8N1)
         */

        /*  turn on DTR and RTS  */
        WRITE_PORT_UCHAR (SER_MCR(ComPortBase), SR_MCR_DTR | SR_MCR_RTS);

        /* set DLAB */
        lcr = READ_PORT_UCHAR (SER_LCR(ComPortBase)) | SR_LCR_DLAB;
        WRITE_PORT_UCHAR (SER_LCR(ComPortBase), lcr);

        /* set baud rate */
        divisor = 115200 / PortInformation->BaudRate;
        WRITE_PORT_UCHAR (SER_DLL(ComPortBase), (UCHAR)(divisor & 0xff));
        WRITE_PORT_UCHAR (SER_DLM(ComPortBase), (UCHAR)((divisor >> 8) & 0xff));

        /* reset DLAB and set 8N1 format */
        WRITE_PORT_UCHAR (SER_LCR(ComPortBase),
                          SR_LCR_CS8 | SR_LCR_ST1 | SR_LCR_PNO);

        /* read junk out of the RBR */
        lcr = READ_PORT_UCHAR (SER_RBR(ComPortBase));

#ifndef NDEBUG

        /*
         * print message to blue screen
         */
        sprintf (buffer,
                 "\nKernel Debugger: COM%ld (Port 0x%lx) BaudRate %ld\n\n",
                 PortInformation->ComPort,
                 (ULONG)ComPortBase,
                 PortInformation->BaudRate);

        HalDisplayString (buffer);

#endif /* NDEBUG */

        return TRUE;
}


/* HAL.KdPortGetByte */
BOOLEAN
STDCALL
KdPortGetByte (
	PUCHAR	ByteRecieved
	)
{
	if (PortInitialized == FALSE)
		return FALSE;

	if ((READ_PORT_UCHAR (SER_LSR(PortBase)) & SR_LSR_DR))
	{
		*ByteRecieved = READ_PORT_UCHAR (SER_RBR(PortBase));
		return TRUE;
	}

	return FALSE;
}


/* HAL.KdPortGetByteEx */
BOOLEAN
STDCALL
KdPortGetByteEx (
	PKD_PORT_INFORMATION	PortInformation,
	PUCHAR	ByteRecieved
	)
{
	PUCHAR ComPortBase = (PUCHAR)PortInformation->BaseAddress;

	if ((READ_PORT_UCHAR (SER_LSR(ComPortBase)) & SR_LSR_DR))
	{
		*ByteRecieved = READ_PORT_UCHAR (SER_RBR(ComPortBase));
		return TRUE;
	}

	return FALSE;
}


/* HAL.KdPortPollByte */
BOOLEAN
STDCALL
KdPortPollByte (
	PUCHAR	ByteRecieved
	)
{
	if (PortInitialized == FALSE)
		return FALSE;

	while ((READ_PORT_UCHAR (SER_LSR(PortBase)) & SR_LSR_DR) == 0)
		;

	*ByteRecieved = READ_PORT_UCHAR (SER_RBR(PortBase));

	return TRUE;
}


/* HAL.KdPortPollByteEx */
BOOLEAN
STDCALL
KdPortPollByteEx (
	PKD_PORT_INFORMATION	PortInformation,
	PUCHAR	ByteRecieved
	)
{
	PUCHAR ComPortBase = (PUCHAR)PortInformation->BaseAddress;

	while ((READ_PORT_UCHAR (SER_LSR(ComPortBase)) & SR_LSR_DR) == 0)
		;

	*ByteRecieved = READ_PORT_UCHAR (SER_RBR(ComPortBase));

	return TRUE;
}




/* HAL.KdPortPutByte */
VOID
STDCALL
KdPortPutByte (
	UCHAR ByteToSend
	)
{
	if (PortInitialized == FALSE)
		return;

	while ((READ_PORT_UCHAR (SER_LSR(PortBase)) & SR_LSR_TBE) == 0)
		;

	WRITE_PORT_UCHAR (SER_THR(PortBase), ByteToSend);
}

/* HAL.KdPortPutByteEx */
VOID
STDCALL
KdPortPutByteEx (
	PKD_PORT_INFORMATION	PortInformation,
	UCHAR ByteToSend
	)
{
	PUCHAR ComPortBase = (PUCHAR)PortInformation->BaseAddress;

	while ((READ_PORT_UCHAR (SER_LSR(ComPortBase)) & SR_LSR_TBE) == 0)
		;

	WRITE_PORT_UCHAR (SER_THR(ComPortBase), ByteToSend);
}


/* HAL.KdPortRestore */
VOID
STDCALL
KdPortRestore (
	VOID
	)
{
}


/* HAL.KdPortSave */
VOID
STDCALL
KdPortSave (
	VOID
	)
{
}


/* HAL.KdPortDisableInterrupts */
BOOLEAN
STDCALL
KdPortDisableInterrupts()
{
  UCHAR ch;

	if (PortInitialized == FALSE)
		return FALSE;

	ch = READ_PORT_UCHAR (SER_MCR (PortBase));
  ch &= (~(SR_MCR_OUT1 | SR_MCR_OUT2));
	WRITE_PORT_UCHAR (SER_MCR (PortBase), ch);

	ch = READ_PORT_UCHAR (SER_IER (PortBase));
  ch &= (~SR_IER_ALL);
	WRITE_PORT_UCHAR (SER_IER (PortBase), ch);

	return TRUE;
}


/* HAL.KdPortEnableInterrupts */
BOOLEAN
STDCALL
KdPortEnableInterrupts()
{
  UCHAR ch;

	if (PortInitialized == FALSE)
		return FALSE;

	ch = READ_PORT_UCHAR (SER_IER (PortBase));
  ch &= (~SR_IER_ALL);
  ch |= SR_IER_ERDA;
	WRITE_PORT_UCHAR (SER_IER (PortBase), ch);

	ch = READ_PORT_UCHAR (SER_MCR (PortBase));
  ch &= (~SR_MCR_LOOP);
  ch |= (SR_MCR_OUT1 | SR_MCR_OUT2);
	WRITE_PORT_UCHAR (SER_MCR (PortBase), ch);

	return TRUE;
}

/*
 * @unimplemented
 */
NTSTATUS
NTAPI
KdDebuggerInitialize0(IN PLOADER_PARAMETER_BLOCK LoaderBlock OPTIONAL)
{
    /* FIXME: TODO */
    return STATUS_UNSUCCESSFUL;
}

/*
 * @unimplemented
 */
NTSTATUS
NTAPI
KdDebuggerInitialize1(IN PLOADER_PARAMETER_BLOCK LoaderBlock OPTIONAL)
{
    /* FIXME: TODO */
    return STATUS_UNSUCCESSFUL;
}

/*
 * @implemented
 */
NTSTATUS
NTAPI
KdSave(IN BOOLEAN SleepTransition)
{
    /* Nothing to do on COM ports */
    return STATUS_SUCCESS;
}

/*
 * @implemented
 */
NTSTATUS
NTAPI
KdRestore(IN BOOLEAN SleepTransition)
{
    /* Nothing to do on COM ports */
    return STATUS_SUCCESS;
}

/*
 * @unimplemented
 */
VOID
NTAPI
KdSendPacket(IN USHORT PacketType,
             IN PSTRING Header,
             IN PSTRING Data OPTIONAL,
             OUT PKD_CONTEXT Context)
{
    /* FIXME: TODO */
    return;
}

/*
 * @unimplemented
 */
ULONG
NTAPI
KdReceivePacket(IN USHORT PacketType,
                OUT PSTRING Header,
                OUT PSTRING Data,
                OUT PUSHORT DataSize,
                OUT PKD_CONTEXT Context OPTIONAL)
{
    /* FIXME: TODO */
    return 0;
}

/* EOF */