stand/efiboot/eficons.c

/*	$NetBSD: eficons.c,v 1.18 2025/10/15 13:16:58 manu Exp $	*/

/*-
 * Copyright (c) 2016 Kimihiro Nonaka <nonaka (at) netbsd.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/param.h>
#include <sys/bitops.h>
#include <sys/stdint.h>

#include <comio_direct.h>

#include "efiboot.h"

#include "bootinfo.h"
#include "vbe.h"

#ifndef DEFAULT_GOP_MODE
#define DEFAULT_GOP_MODE	"1024x768"
#endif
#define FALLBACK_GOP_MODE	0

extern struct x86_boot_params boot_params;

struct btinfo_console btinfo_console;

static EFI_GRAPHICS_OUTPUT_PROTOCOL *efi_gop;
static int efi_gop_mode = -1;
static CHAR16 keybuf[16];
static int keybuf_read = 0;
static int keybuf_write = 0;

#define EISA_COM_COUNT 4
static SERIAL_IO_INTERFACE *serios[12]; /* 4 EISA com slots, 8 others */
static int default_comspeed =
#if defined(CONSPEED)
    CONSPEED;
#else
    9600;
#endif
static u_char serbuf[16];
static int serbuf_read = 0;
static int serbuf_write = 0;

static int raw_com_addr = 0;

static void eficons_init_video(void);
static void efi_switch_video_to_text_mode(void);

static int efi_cons_getc(void);
static int efi_cons_putc(int);
static int efi_cons_iskey(int);
static int efi_cons_waitforinputevent(uint64_t);

static int efi_com_consdev2unit(int);
static void efi_com_probe(void);
static bool efi_valid_com(int);
static int efi_com_init(int, int);
static int efi_com_getc(void);
static int efi_com_putc(int);
static int efi_com_status(int);
static int efi_com_waitforinputevent(uint64_t);

static int raw_com_init(int, int);
static int raw_com_getc(void);
static int raw_com_putc(int);
static int raw_com_status(int);
static int raw_com_waitforinputevent(uint64_t);

static int efi_find_gop_mode(char *);

static int com_unit = -1;
static int (*internal_getchar)(void) = efi_cons_getc;
static int (*internal_putchar)(int) = efi_cons_putc;
static int (*internal_iskey)(int) = efi_cons_iskey;
static int (*internal_waitforinputevent)(uint64_t) = efi_cons_waitforinputevent;

static int
getcomaddr(int idx)
{
	static const short comioport[4] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8 };

	if (idx < __arraycount(comioport))
		return comioport[idx];
	return 0;
}

/*
 * XXX only pass console parameters to kernel.
 */
void
efi_consinit(int dev, int ioport, int unit, int speed, bool switchcons)
{
	int i;
	char *consname = NULL;

	btinfo_console.speed = default_comspeed;

	switch (dev) {
	case CONSDEV_AUTO:
		for (i = 0; i < __arraycount(serios); i++) {
			if (!efi_valid_com(i))
				continue;
			consname = "com";
			btinfo_console.addr = getcomaddr(i);

			/* switch to com for the test, regardless switchcons */
			com_unit = i;

			efi_cons_putc('0' + i);
			efi_com_init(btinfo_console.addr, btinfo_console.speed);
			/* check for:
			 *  1. successful output
			 *  2. optionally, keypress within 7s
			 */
			if (efi_com_putc(':') &&
			    efi_com_putc('-') &&
			    efi_com_putc('(') &&
			    awaitkey(7, 0))
				goto ok;
		}
		goto nocom;
ok:
		break;

	case CONSDEV_COM0:
	case CONSDEV_COM1:
	case CONSDEV_COM2:
	case CONSDEV_COM3:
	case CONSDEV_COM:
		consname = "com";
		btinfo_console.addr = ioport;
		if (btinfo_console.addr == 0)
			btinfo_console.addr = getcomaddr(unit);
		if (speed != 0)
			btinfo_console.speed = speed;

		if (switchcons) {
			com_unit = unit;
			efi_com_init(btinfo_console.addr, btinfo_console.speed);
		}
		break;

	case CONSDEV_COM0KBD:
	case CONSDEV_COM1KBD:
	case CONSDEV_COM2KBD:
	case CONSDEV_COM3KBD:
		consname = "com";
		btinfo_console.addr = getcomaddr(unit);

		if (!switchcons)
			goto kbd;

		com_unit = unit;

		efi_cons_putc('0' + unit); /* XXX if unit>=10 ?  */
		efi_com_init(btinfo_console.addr, btinfo_console.speed);
		/* check for:
		 *  1. successful output
		 *  2. optionally, keypress within 7s
		 */
		if (efi_com_putc(':') &&
		    efi_com_putc('-') &&
		    efi_com_putc('(') &&
		    awaitkey(7, 0))
			goto kbd;
		/*FALLTHROUGH*/
	case CONSDEV_PC:
		goto nocom;
	case CONSDEV_UCOM:
		consname = "ucom";
		btinfo_console.addr = unit; /* Used for unit number */
		if (speed != 0)
			btinfo_console.speed = speed;
		break;
	default:
nocom:
		consname = "pc";
		if (!switchcons)
			break;
		internal_putchar = efi_cons_putc;
kbd:
		if (!switchcons)
			break;
		if (unit != -1)
			com_unit = unit;
		internal_getchar = efi_cons_getc;
		internal_iskey = efi_cons_iskey;
		internal_waitforinputevent = efi_cons_waitforinputevent;
		memset(keybuf, 0, sizeof(keybuf));
		keybuf_read = keybuf_write = 0;
		break;
	}

	if (consname != NULL)
		strlcpy(btinfo_console.devname, consname, 16);
}

int
cninit(void)
{
	int unit;
	efi_switch_video_to_text_mode();
	eficons_init_video();

	/* console output is now possible */

	efi_com_probe();

	unit = efi_com_consdev2unit(boot_params.bp_consdev);
	efi_consinit(boot_params.bp_consdev, boot_params.bp_consaddr, unit,
	    boot_params.bp_conspeed, true);

	return 0;
}

void
efi_cons_show(void)
{
	const bool pc_is_console = strcmp(btinfo_console.devname, "pc") == 0;
	const bool com_is_console = strcmp(btinfo_console.devname, "com") == 0;
	bool first = true;
	bool found = false;
	int i;

	if (efi_gop != NULL) {
		printf("pc");
		if (pc_is_console)
			printf("*");
		first = false;
	}

	for (i = 0; i < __arraycount(serios); i++) {
		if (serios[i] != NULL) {
			if (!first)
				printf(" ");
			first = false;

			printf("com%d", i);
			if (com_is_console &&
			    btinfo_console.addr == getcomaddr(i)) {
				printf(",%d*", btinfo_console.speed);
				found = true;
			}
		}
	}
	if (!found && com_is_console) {
		if (!first)
			printf(" ");
		first = false;

		printf("com,0x%x,%d*", btinfo_console.addr,
		    btinfo_console.speed);
	}

	printf("\n");
}

static int
efi_cons_getc(void)
{
	EFI_STATUS status;
	EFI_INPUT_KEY key;
	int c;

	if (keybuf_read != keybuf_write) {
		c = keybuf[keybuf_read];
		keybuf_read = (keybuf_read + 1) % __arraycount(keybuf);
		return c;
	}

	status = uefi_call_wrapper(ST->ConIn->ReadKeyStroke, 2, ST->ConIn,
	    &key);
	while (status == EFI_NOT_READY) {
		WaitForSingleEvent(ST->ConIn->WaitForKey, 0);
		status = uefi_call_wrapper(ST->ConIn->ReadKeyStroke, 2,
		    ST->ConIn, &key);
	}
	return key.UnicodeChar;
}

static int
efi_cons_putc(int c)
{
	CHAR16 buf[2];

	buf[0] = c;
	buf[1] = 0;
	Output(buf);

	return 1;
}

/*ARGSUSED*/
static int
efi_cons_iskey(int intr)
{
	EFI_STATUS status;
	EFI_INPUT_KEY key;

	if (keybuf_read != keybuf_write)
		return 1;

	status = uefi_call_wrapper(ST->ConIn->ReadKeyStroke, 2, ST->ConIn,
	    &key);
	if (EFI_ERROR(status))
		return 0;

	keybuf[keybuf_write] = key.UnicodeChar;
	keybuf_write = (keybuf_write + 1) % __arraycount(keybuf);
	return 1;
}

static int
efi_cons_waitforinputevent(uint64_t timeout)
{
	EFI_STATUS status;

	status = WaitForSingleEvent(ST->ConIn->WaitForKey, timeout);
	if (!EFI_ERROR(status))
		return 0;
	if (status == EFI_TIMEOUT)
		return ETIMEDOUT;
	return EINVAL;
}

int
getchar(void)
{

	return internal_getchar();
}

void
putchar(int c)
{

	if (c == '\n')
		internal_putchar('\r');
	internal_putchar(c);
}

int
iskey(int intr)
{

	return internal_iskey(intr);
}

char
awaitkey(int timeout, int tell)
{
	char c = 0;

	for (;;) {
		char numbuf[32];
		int len;

		if (tell && timeout) {
			len = snprintf(numbuf, sizeof(numbuf), "%d seconds. ",
			    timeout);
			if (len > 0 && len < sizeof(numbuf)) {
				char *p = numbuf;

				printf("%s", numbuf);
				while (*p)
					*p++ = '\b';
			}
		}
		if (iskey(1)) {
			/* flush input buffer */
			while (iskey(0))
				c = getchar();
			if (c == 0)
				c = -1;
			if (tell && timeout)
				printf("%s", numbuf);
			break;
		}
		if (timeout--) {
			/*
			 * UEFI spec 2.10 section 7.1.7
			 * EFI_BOOT_SERVICES.SetTimer() timeout in 100ns units
			 * but the implementation may be broken and faster:
			 * check date to make sure we are slow enough.
			 */
			EFI_TIME t1, t2;

			uefi_call_wrapper(RT->GetTime, 2, &t1, NULL);
			do {
				internal_waitforinputevent(10000000); /* 1s */
				uefi_call_wrapper(RT->GetTime, 2, &t2, NULL);
			} while (t1.Year == t2.Year &&
				 t1.Month == t2.Month &&
				 t1.Day == t2.Day &&
				 t1.Hour == t2.Hour &&
				 t1.Minute == t2.Minute &&
				 t1.Second == t2.Second);
		}
		else
			break;
		if (tell)
			printf("%s", numbuf);
	}

	if (tell)
		printf("0 seconds.     \n");

	return c;
}

void
clear_pc_screen(void)
{

	uefi_call_wrapper(ST->ConOut->ClearScreen, 1, ST->ConOut);
}

static uint8_t
getdepth(const EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *info)
{

	switch (info->PixelFormat) {
	case PixelBlueGreenRedReserved8BitPerColor:
	case PixelRedGreenBlueReserved8BitPerColor:
		return 32;

	case PixelBitMask:
		return fls32(info->PixelInformation.RedMask
		    | info->PixelInformation.GreenMask
		    | info->PixelInformation.BlueMask
		    | info->PixelInformation.ReservedMask);

	case PixelBltOnly:
	case PixelFormatMax:
		return 0;
	}
	return 0;
}

static void
setpixelformat(UINT32 mask, uint8_t *num, uint8_t *pos)
{
	uint8_t n, p;

	n = popcount32(mask);
	p = ffs32(mask);
	if (p > 0)
		p--;

	*num = n;
	*pos = p;
}

static void
bi_framebuffer(void)
{
	EFI_STATUS status;
	EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *info;
	struct btinfo_framebuffer fb;
	INT32 bestmode;
	UINTN sz;

	if (efi_gop == NULL)
		goto nofb;

	if (efi_gop_mode >= 0) {
		bestmode = efi_gop_mode;
	} else {
		/* If a mode has not been selected, choose a default */
		bestmode = efi_find_gop_mode(DEFAULT_GOP_MODE);
		if (bestmode == -1)
			bestmode = FALLBACK_GOP_MODE;
	}

	status = uefi_call_wrapper(efi_gop->SetMode, 2, efi_gop,
	    bestmode);
	if (EFI_ERROR(status) || efi_gop->Mode->Mode != bestmode) {
		printf("GOP setmode failed: %" PRIxMAX "\n",
		    (uintmax_t)status);
		goto nofb;
	}

	status = uefi_call_wrapper(efi_gop->QueryMode, 4,
	    efi_gop, bestmode, &sz, &info);
	if (EFI_ERROR(status)) {
		printf("GOP querymode failed: %" PRIxMAX "\n",
		    (uintmax_t)status);
		goto nofb;
	}

	memset(&fb, 0, sizeof(fb));
	fb.physaddr = efi_gop->Mode->FrameBufferBase;
	fb.flags = 0;
	fb.width = info->HorizontalResolution;
	fb.height = info->VerticalResolution;
	fb.depth = getdepth(info);
	fb.stride = info->PixelsPerScanLine * ((fb.depth + 7) / 8);
	fb.vbemode = 0;	/* XXX */

	switch (info->PixelFormat) {
	case PixelBlueGreenRedReserved8BitPerColor:
		fb.rnum = 8;
		fb.gnum = 8;
		fb.bnum = 8;
		fb.rpos = 16;
		fb.gpos = 8;
		fb.bpos = 0;
		break;

	case PixelRedGreenBlueReserved8BitPerColor:
		fb.rnum = 8;
		fb.gnum = 8;
		fb.bnum = 8;
		fb.rpos = 0;
		fb.gpos = 8;
		fb.bpos = 16;
		break;

	case PixelBitMask:
		setpixelformat(info->PixelInformation.RedMask,
		    &fb.rnum, &fb.rpos);
		setpixelformat(info->PixelInformation.GreenMask,
		    &fb.gnum, &fb.gpos);
		setpixelformat(info->PixelInformation.BlueMask,
		    &fb.bnum, &fb.bpos);
		break;

	case PixelBltOnly:
	case PixelFormatMax:
		panic("Error: invalid pixel format (%d)", info->PixelFormat);
		break;
	}

	framebuffer_configure(&fb);
	return;

nofb:
	framebuffer_configure(NULL);
}

int
vbe_commit(void)
{

	bi_framebuffer();
	return 0;
}

static void
print_text_modes(void)
{
	EFI_STATUS status;
	UINTN cols, rows;
	INT32 i, curmode;

	curmode = ST->ConOut->Mode->Mode;
	for (i = 0; i < ST->ConOut->Mode->MaxMode; i++) {
		status = uefi_call_wrapper(ST->ConOut->QueryMode, 4,
		    ST->ConOut, i, &cols, &rows);
		if (EFI_ERROR(status))
			continue;
		printf("%c%d: %" PRIxMAX "x%" PRIxMAX "\n",
		    i == curmode ? '*' : ' ', i, (uintmax_t)cols, (uintmax_t)rows);
	}
}

static int
efi_find_text_mode(char *arg)
{
	EFI_STATUS status;
	UINTN cols, rows;
	INT32 i;
	char mode[32];

	for (i = 0; i < ST->ConOut->Mode->MaxMode; i++) {
		status = uefi_call_wrapper(ST->ConOut->QueryMode, 4,
		    ST->ConOut, i, &cols, &rows);
		if (EFI_ERROR(status))
			continue;
		snprintf(mode, sizeof(mode), "%" PRIuMAX "x%" PRIuMAX,
		    (uintmax_t)cols, (uintmax_t)rows);
		if (strcmp(arg, mode) == 0)
			return i;
	}
	return -1;
}

void
command_text(char *arg)
{
	EFI_STATUS status;
	INT32 modenum;

	if (*arg == '\0' || strcmp(arg, "list") == 0) {
		print_text_modes();
		return;
	}

	if (strchr(arg, 'x') != NULL) {
		modenum = efi_find_text_mode(arg);
		if (modenum == -1) {
			printf("mode %s not supported by firmware\n", arg);
			return;
		}
	} else {
		modenum = strtoul(arg, NULL, 0);
	}

	status = uefi_call_wrapper(ST->ConOut->SetMode, 2, ST->ConOut, modenum);
	if (!EFI_ERROR(status))
		return;

	printf("invalid flag, must be 'list', a display mode, "
	    "or a mode number\n");
}

static int
print_gop_modes(void)
{
	EFI_STATUS status;
	EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *info;
	UINTN sz;
	UINT32 i;
	uint8_t depth;

	if (efi_gop == NULL)
		return 1;

	for (i = 0; i < efi_gop->Mode->MaxMode; i++) {
		status = uefi_call_wrapper(efi_gop->QueryMode, 4, efi_gop, i,
		    &sz, &info);
		if (EFI_ERROR(status) && status == EFI_NOT_STARTED) {
			status = uefi_call_wrapper(efi_gop->SetMode, 2,
			    efi_gop, efi_gop->Mode->Mode);
			status = uefi_call_wrapper(efi_gop->QueryMode, 4,
			    efi_gop, i, &sz, &info);
		}
		if (EFI_ERROR(status))
			continue;

		printf("%c%d: %dx%d ",
		    memcmp(info, efi_gop->Mode->Info, sizeof(*info)) == 0 ?
		      '*' : ' ',
		      i, info->HorizontalResolution, info->VerticalResolution);
		switch (info->PixelFormat) {
		case PixelRedGreenBlueReserved8BitPerColor:
			printf("RGBR");
			break;
		case PixelBlueGreenRedReserved8BitPerColor:
			printf("BGRR");
			break;
		case PixelBitMask:
			printf("R:%08x G:%08x B:%08x X:%08x",
			    info->PixelInformation.RedMask,
			    info->PixelInformation.GreenMask,
			    info->PixelInformation.BlueMask,
			    info->PixelInformation.ReservedMask);
			break;
		case PixelBltOnly:
			printf("(blt only)");
			break;
		default:
			printf("(Invalid pixel format)");
			break;
		}
		printf(" pitch %d", info->PixelsPerScanLine);
		depth = getdepth(info);
		if (depth > 0)
			printf(" bpp %d", depth);
		printf("\n");
	}

	return 0;
}

static int
efi_find_gop_mode(char *arg)
{
	EFI_STATUS status;
	EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *info;
	UINTN sz;
	UINT32 i;
	char mode[32];
	uint8_t depth;

	for (i = 0; i < efi_gop->Mode->MaxMode; i++) {
		status = uefi_call_wrapper(efi_gop->QueryMode, 4, efi_gop, i,
		    &sz, &info);
		if (EFI_ERROR(status))
			continue;

		depth = getdepth(info);
		if (depth == 0)
			continue;

		snprintf(mode, sizeof(mode), "%lux%lux%u",
		    (long)info->HorizontalResolution,
		    (long)info->VerticalResolution,
		    depth);
		if (strcmp(arg, mode) == 0)
			return i;

		snprintf(mode, sizeof(mode), "%lux%lu",
		    (long)info->HorizontalResolution,
		    (long)info->VerticalResolution);
		if (strcmp(arg, mode) == 0)
			return i;
	}
	return -1;
}

void
command_gop(char *arg)
{
	EFI_STATUS status;
	INT32 modenum;

	if (efi_gop == NULL) {
		printf("GOP not supported by firmware\n");
		return;
	}

	if (*arg == '\0' || strcmp(arg, "list") == 0) {
		print_gop_modes();
		return;
	}

	if (strchr(arg, 'x') != NULL) {
		modenum = efi_find_gop_mode(arg);
		if (modenum == -1) {
			printf("mode %s not supported by firmware\n", arg);
			return;
		}
	} else {
		modenum = strtoul(arg, NULL, 0);
	}

	status = uefi_call_wrapper(efi_gop->SetMode, 2, efi_gop, modenum);
	if (!EFI_ERROR(status) && efi_gop->Mode->Mode == modenum) {
		efi_gop_mode = modenum;
		return;
	}

	printf("invalid flag, must be 'list', a display mode, "
	    "or a mode number\n");
}

static void
eficons_init_video(void)
{
	EFI_STATUS status;
	UINTN cols, rows;
	INT32 i, best, mode80x25, mode100x31;

	/*
	 * Setup text mode
	 */
	uefi_call_wrapper(ST->ConOut->Reset, 2, ST->ConOut, TRUE);

	mode80x25 = mode100x31 = -1;
	for (i = 0; i < ST->ConOut->Mode->MaxMode; i++) {
		status = uefi_call_wrapper(ST->ConOut->QueryMode, 4,
		    ST->ConOut, i, &cols, &rows);
		if (EFI_ERROR(status))
			continue;

		if (mode80x25 < 0 && cols == 80 && rows == 25)
			mode80x25 = i;
		else if (mode100x31 < 0 && cols == 100 && rows == 31)
			mode100x31 = i;
	}
	best = mode100x31 >= 0 ? mode100x31 : mode80x25 >= 0 ? mode80x25 : -1;
	if (best >= 0)
		uefi_call_wrapper(ST->ConOut->SetMode, 2, ST->ConOut, best);
	uefi_call_wrapper(ST->ConOut->EnableCursor, 2, ST->ConOut, TRUE);
	uefi_call_wrapper(ST->ConOut->ClearScreen, 1, ST->ConOut);

	LibLocateProtocol(&GraphicsOutputProtocol, (void **)&efi_gop);
}

/*
 * for Apple EFI
 */
#define	CONSOLE_CONTROL_PROTOCOL \
	{0xf42f7782, 0x12e, 0x4c12, {0x99, 0x56, 0x49, 0xf9, 0x43, 0x4, 0xf7, 0x21}}
static EFI_GUID ConsoleControlProtocol = CONSOLE_CONTROL_PROTOCOL;

struct _EFI_CONSOLE_CONTROL_INTERFACE;
typedef struct _EFI_CONSOLE_CONTROL_INTERFACE EFI_CONSOLE_CONTROL_INTERFACE;
typedef enum { EfiConsoleControlScreenText } EFI_CONSOLE_CONTROL_SCREEN_MODE;
typedef EFI_STATUS (EFIAPI *EFI_CONSOLE_CONTROL_PROTOCOL_SET_MODE) (
	IN EFI_CONSOLE_CONTROL_INTERFACE *This,
	IN EFI_CONSOLE_CONTROL_SCREEN_MODE Mode
);
struct _EFI_CONSOLE_CONTROL_INTERFACE {
	VOID *GetMode;
	EFI_CONSOLE_CONTROL_PROTOCOL_SET_MODE SetMode;
	VOID *LockStdIn;
};

static void
efi_switch_video_to_text_mode(void)
{
	EFI_STATUS status;
	EFI_CONSOLE_CONTROL_INTERFACE *cci;

	/* Set up the console, so printf works. */
	status = LibLocateProtocol(&ConsoleControlProtocol, (void **)&cci);
	if (!EFI_ERROR(status)) {
		uefi_call_wrapper(cci->SetMode, 2, cci,
		    EfiConsoleControlScreenText);
	}
}

static int
efi_com_consdev2unit(int dev)
{
	int unit = -1;

	if (dev >= CONSDEV_COM0 && unit <= CONSDEV_COM3)
		unit = dev - CONSDEV_COM0;

	if (dev >= CONSDEV_COM0KBD && unit <= CONSDEV_COM3KBD)
		unit = dev - CONSDEV_COM0KBD;

	if (dev == CONSDEV_COM)
		unit = 0;

	if (dev == CONSDEV_UCOM)
		unit = 0;

	return unit;
}


/*
 * serial port
 */
static void
efi_com_probe(void)
{
	EFI_STATUS status;
	UINTN i, nhandles;
	EFI_HANDLE *handles;
	EFI_DEVICE_PATH	*dp, *dp0;
	EFI_DEV_PATH_PTR dpp;
	SERIAL_IO_INTERFACE *serio;
	int unit = -1;
	int high_unit = EISA_COM_COUNT;

	/*
	 * We could want to dynamically allocate serios[] to cope
	 * with an aritrary count of serial ports, but we cannot yet
	 * call alloc(), because efi_heap_init() was not yet called.
	 * We could swap cninit() and efi_heap_init() order in
	 * efi_main(), but then efi_heap_init() could not display
	 * a failure message. Let us keep static it for now for the
	 * sake of reliability.
	 */
	for (i = 0; i < __arraycount(serios); i++)
		serios[i] = NULL;

	status = LibLocateHandle(ByProtocol, &SerialIoProtocol, NULL,
	    &nhandles, &handles);
	if (EFI_ERROR(status))
		return;

	for (i = 0; i < nhandles; i++) {
		/*
		 * Identify port number of the handle.  This assumes ACPI
		 * UID 0-3 map to legacy COM[1-4] and they use the legacy
		 * port address.
		 */
		status = uefi_call_wrapper(BS->HandleProtocol, 3, handles[i],
		    &DevicePathProtocol, (void **)&dp0);
		if (EFI_ERROR(status))
			continue;

		unit = -1;
		for (dp = dp0; !IsDevicePathEnd(dp);
		     dp = NextDevicePathNode(dp)) {

			if (DevicePathType(dp) == ACPI_DEVICE_PATH &&
			    DevicePathSubType(dp) == ACPI_DP) {
				dpp = (EFI_DEV_PATH_PTR)dp;
				if (dpp.Acpi->HID == EISA_PNP_ID(0x0501)) {
					unit = dpp.Acpi->UID;
					break;
				}
			}
		}

		if (unit == -1)
			unit = high_unit++;

		if (unit < 0 || __arraycount(serios) <= unit)
			continue;

		/* Prepare SERIAL_IO_INTERFACE */
		status = uefi_call_wrapper(BS->HandleProtocol, 3, handles[i],
		    &SerialIoProtocol, (void **)&serio);
		if (EFI_ERROR(status))
			continue;

		serios[unit] = serio;
	}

	FreePool(handles);

}

static bool
efi_valid_com(int unit)
{
	return (unit >= 0 &&unit < __arraycount(serios) &&
	    serios[unit] != NULL);
}

static int
efi_com_init(int addr, int speed)
{
	EFI_STATUS status;
	SERIAL_IO_INTERFACE *serio;

	if (speed <= 0)
		return 0;

	if (!efi_valid_com(com_unit))
		return raw_com_init(addr, speed);

	serio = serios[com_unit];

	if (serio->Mode->BaudRate != btinfo_console.speed) {
		status = uefi_call_wrapper(serio->SetAttributes, 7, serio,
		    speed, serio->Mode->ReceiveFifoDepth,
		    serio->Mode->Timeout, serio->Mode->Parity,
		    serio->Mode->DataBits, serio->Mode->StopBits);
		if (EFI_ERROR(status)) {
			printf("com%d: SetAttribute() failed with status=%" PRIxMAX
			    "\n", com_unit, (uintmax_t)status);
			return 0;
		}
	}

	raw_com_addr = 0;
	default_comspeed = speed;
	internal_getchar = efi_com_getc;
	internal_putchar = efi_com_putc;
	internal_iskey = efi_com_status;
	internal_waitforinputevent = efi_com_waitforinputevent;
	memset(serbuf, 0, sizeof(serbuf));
	serbuf_read = serbuf_write = 0;

	return speed;
}

static int
efi_com_getc(void)
{
	EFI_STATUS status;
	SERIAL_IO_INTERFACE *serio;
	UINTN sz;
	u_char c;

	if (!efi_valid_com(com_unit))
		panic("Invalid serial port: unit=%d", com_unit);

	if (serbuf_read != serbuf_write) {
		c = serbuf[serbuf_read];
		serbuf_read = (serbuf_read + 1) % __arraycount(serbuf);
		return c;
	}

	serio = serios[com_unit];

	for (;;) {
		sz = 1;
		status = uefi_call_wrapper(serio->Read, 3, serio, &sz, &c);
		if (!EFI_ERROR(status) && sz > 0)
			break;
		if (status != EFI_TIMEOUT && EFI_ERROR(status))
			panic("Error reading from serial status=%"PRIxMAX,
			    (uintmax_t)status);
	}
	return c;
}

static int
efi_com_putc(int c)
{
	EFI_STATUS status;
	SERIAL_IO_INTERFACE *serio;
	UINTN sz = 1;
	u_char buf;

	if (!efi_valid_com(com_unit))
		return 0;

	serio = serios[com_unit];
	buf = c;
	status = uefi_call_wrapper(serio->Write, 3, serio, &sz, &buf);
	if (EFI_ERROR(status) || sz < 1)
		return 0;
	return 1;
}

/*ARGSUSED*/
static int
efi_com_status(int intr)
{
	EFI_STATUS status;
	SERIAL_IO_INTERFACE *serio;
	UINTN sz;
	u_char c;

	if (!efi_valid_com(com_unit))
		panic("Invalid serial port: unit = %d", com_unit);

	if (serbuf_read != serbuf_write)
		return 1;

	serio = serios[com_unit];
	sz = 1;
	status = uefi_call_wrapper(serio->Read, 3, serio, &sz, &c);
	if (EFI_ERROR(status) || sz < 1)
		return 0;

	serbuf[serbuf_write] = c;
	serbuf_write = (serbuf_write + 1) % __arraycount(serbuf);
	return 1;
}

static void
efi_com_periodic_event(EFI_EVENT event, void *ctx)
{
	EFI_EVENT timer = ctx;

	if (efi_com_status(0)) {
		uefi_call_wrapper(BS->SetTimer, 3, event, TimerCancel, 0);
		uefi_call_wrapper(BS->SignalEvent, 1, timer);
	}
}

static int
efi_com_waitforinputevent(uint64_t timeout)
{
	EFI_STATUS status;
	EFI_EVENT timer, periodic;

	status = uefi_call_wrapper(BS->CreateEvent, 5, EVT_TIMER, 0, NULL, NULL,
	    &timer);
	if (EFI_ERROR(status))
		return EINVAL;

        status = uefi_call_wrapper(BS->CreateEvent, 5,
	    EVT_TIMER | EVT_NOTIFY_SIGNAL, TPL_CALLBACK, efi_com_periodic_event,
	    timer, &periodic);
	if (EFI_ERROR(status)) {
		uefi_call_wrapper(BS->CloseEvent, 1, timer);
		return EINVAL;
	}

	status = uefi_call_wrapper(BS->SetTimer, 3, periodic, TimerPeriodic,
	    1000000);	/* 100ms */
	if (EFI_ERROR(status)) {
		uefi_call_wrapper(BS->CloseEvent, 1, periodic);
		uefi_call_wrapper(BS->CloseEvent, 1, timer);
		return EINVAL;
	}
	status = WaitForSingleEvent(&timer, timeout);
	uefi_call_wrapper(BS->SetTimer, 3, periodic, TimerCancel, 0);
	uefi_call_wrapper(BS->CloseEvent, 1, periodic);
	uefi_call_wrapper(BS->CloseEvent, 1, timer);
	if (!EFI_ERROR(status))
		return 0;
	if (status == EFI_TIMEOUT)
		return ETIMEDOUT;
	return EINVAL;
}

static int
raw_com_init(int addr, int speed)
{

	if (addr == 0 || speed <= 0)
		return 0;

	speed = cominit_d(addr, speed);

	raw_com_addr = addr;
	default_comspeed = speed;
	internal_getchar = raw_com_getc;
	internal_putchar = raw_com_putc;
	internal_iskey = raw_com_status;
	internal_waitforinputevent = raw_com_waitforinputevent;

	return speed;
}

static int
raw_com_getc(void)
{

	if (raw_com_addr == 0)
		panic("%s: Invalid serial port", __func__);
	return comgetc_d(raw_com_addr);
}

static int
raw_com_putc(int c)
{

	if (raw_com_addr == 0)
		panic("%s: Invalid serial port", __func__);
	return computc_d(c, raw_com_addr);
}

static int
raw_com_status(int intr)
{

	if (raw_com_addr == 0)
		panic("%s: Invalid serial port", __func__);
	return comstatus_d(raw_com_addr);
}

static int
raw_com_waitforinputevent(uint64_t timeout /* in 0.1 usec */)
{
	uint64_t ms;

	if (raw_com_addr == 0)
		panic("%s: Invalid serial port", __func__);

	for (ms = howmany(timeout, 10 * 1000); ms != 0; ms--) {
		if (raw_com_status(0))
			return 0;
		uefi_call_wrapper(BS->Stall, 1, 1000);
	}
	return ETIMEDOUT;
}