/*
 * Copyright (c) 1998 Michael Smith (msmith@freebsd.org)
 *
 * 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 AUTHOR 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 AUTHOR 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/cdefs.h>

#include <stand.h>
#include <sys/errno.h>
#include <sys/param.h>
#include <bootstrap.h>
#include <stdbool.h>

#include <efi.h>
#include <efilib.h>
#include <efidevp.h>
#include <Protocol/IsaIo.h>
#include <dev/ic/ns16550.h>
#include <uuid.h>

#ifdef MDE_CPU_X64
#include <machine/cpufunc.h>
#endif

EFI_GUID  gEfiIsaIoProtocolGuid = EFI_ISA_IO_PROTOCOL_GUID;

#define	COMC_TXWAIT	0x40000		/* transmit timeout */
#define	COMC_BPS(x)	(115200 / (x))	/* speed to DLAB divisor */
#define	COMC_DIV2BPS(x)	(115200 / (x))	/* DLAB divisor to speed */

#ifndef COMSPEED
#define	COMSPEED	9600
#endif

#define	COM1_IOADDR	0x3f8
#define	COM2_IOADDR	0x2f8
#define	COM3_IOADDR	0x3e8
#define	COM4_IOADDR	0x2e8

#ifdef MDE_CPU_X64
static uint_t io_ports[] = {
	COM1_IOADDR, COM2_IOADDR, COM3_IOADDR, COM4_IOADDR
};
#endif

#define	STOP1		0x00
#define	STOP2		0x04

#define	PARODD		0x00
#define	PAREN		0x08
#define	PAREVN		0x10
#define	PARMARK		0x20

#define	BITS5		0x00	/* 5 bits per char */
#define	BITS6		0x01	/* 6 bits per char */
#define	BITS7		0x02	/* 7 bits per char */
#define	BITS8		0x03	/* 8 bits per char */

#define	PNP0501		0x501		/* 16550A-compatible COM port */

static void	efi_isa_probe(struct console *);
static int	efi_isa_init(struct console *, int);
static void	efi_isa_putchar(struct console *, int);
static int	efi_isa_getchar(struct console *);
static int	efi_isa_ischar(struct console *);
static int	efi_isa_ioctl(struct console *, int, void *);
static void	efi_isa_devinfo(struct console *);
static bool	efi_isa_setup(struct console *);
static char	*efi_isa_asprint_mode(struct serial *);
static int	efi_isa_parse_mode(struct serial *, const char *);
static int	efi_isa_mode_set(struct env_var *, int, const void *);
static int	efi_isa_cd_set(struct env_var *, int, const void *);
static int	efi_isa_rtsdtr_set(struct env_var *, int, const void *);

extern struct console efi_console;

static bool
efi_isa_port_is_present(struct serial *sp)
{
	EFI_STATUS status;
#define	COMC_TEST	0xbb
	uint8_t test = COMC_TEST;

	/*
	 * Write byte to scratch register and read it out.
	 */
	status = sp->io.isa->Io.Write(sp->io.isa,
	    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT,
	    sp->ioaddr + com_scr, 1, &test);
	test = 0;
	if (status == EFI_SUCCESS) {
		status = sp->io.isa->Io.Read(sp->io.isa,
		    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT, sp->ioaddr + com_scr,
		    1, &test);
	}
	return (test == COMC_TEST);
#undef COMC_TEST
}

static bool
efi_isa_should_append(const char *name, struct serial *port)
{
	EFI_DEVICE_PATH *node, *dev;
	EFI_STATUS status;
	char *buf;
	size_t sz;
	bool rv = true;

	if (port->currdev == NULL)
		return (rv);

	buf = NULL;
	sz = 0;
	status = efi_global_getenv(name, buf, &sz);
	if (status == EFI_BUFFER_TOO_SMALL) {
		buf = malloc(sz);
		if (buf == NULL)
			return (rv);
		status = efi_global_getenv(name, buf, &sz);
	}
	if (EFI_ERROR(status)) {
		free(buf);
		return (rv);
	}

	dev = efi_lookup_devpath(port->currdev);
	if (dev == NULL) {
		free(buf);
		return (rv);
	}

	node = (EFI_DEVICE_PATH *)buf;
	/*
	 * We only need to know if this port is first in list.
	 * This is only important when "os_console" is not set.
	 */
	if (!IsDevicePathEnd(node) && efi_devpath_is_prefix(dev, node))
		rv = false;

	efi_close_devpath(dev);
	free(buf);
	return (rv);
}

static void
efi_isa_setup_env(struct console *tty)
{
	struct serial *port = tty->c_private;
	char name[20];
	char value[20];
	char *env;

	(void) snprintf(name, sizeof (name), "%s-mode", tty->c_name);
	env = getenv(name);
	if (env != NULL)
		(void) efi_isa_parse_mode(port, env);
	env = efi_isa_asprint_mode(port);
	if (env != NULL) {
		(void) unsetenv(name);
		(void) env_setenv(name, EV_VOLATILE, env, efi_isa_mode_set,
		    env_nounset);
		if (port->is_efi_console) {
			(void) snprintf(name, sizeof (name), "%s-spcr-mode",
			    tty->c_name);
			(void) setenv(name, env, 1);
			free(env);

			/* Add us to console list. */
			(void) snprintf(name, sizeof (name), "console");
			env = getenv(name);
			if (env == NULL) {
				(void) setenv(name, tty->c_name, 1);
			} else {
				char *ptr;
				int rv;

				/*
				 * we have "text" already in place,
				 * consult ConOut if we need to add
				 * serial console before or after.
				 */
				if (efi_isa_should_append("ConOut", port))
					rv = asprintf(&ptr, "%s,%s", env,
					    tty->c_name);
				else
					rv = asprintf(&ptr, "%s,%s",
					    tty->c_name, env);
				if (rv > 0) {
					(void) setenv(name, ptr, 1);
					free(ptr);
				} else {
					printf("%s: %s\n", __func__,
					    strerror(ENOMEM));
				}
			}
		} else {
			free(env);
		}
	}

	(void) snprintf(name, sizeof (name), "%s-ignore-cd", tty->c_name);
	env = getenv(name);
	if (env != NULL) {
		if (strcmp(env, "true") == 0)
			port->ignore_cd = 1;
		else if (strcmp(env, "false") == 0)
			port->ignore_cd = 0;
	}

	(void) snprintf(value, sizeof (value), "%s",
	    port->ignore_cd? "true" : "false");
	(void) unsetenv(name);
	(void) env_setenv(name, EV_VOLATILE, value, efi_isa_cd_set,
	    env_nounset);

	(void) snprintf(name, sizeof (name), "%s-rts-dtr-off", tty->c_name);
	env = getenv(name);
	if (env != NULL) {
		if (strcmp(env, "true") == 0)
			port->rtsdtr_off = 1;
		else if (strcmp(env, "false") == 0)
			port->rtsdtr_off = 0;
	}

	(void) snprintf(value, sizeof (value), "%s",
	    port->rtsdtr_off? "true" : "false");
	(void) unsetenv(name);
	(void) env_setenv(name, EV_VOLATILE, value, efi_isa_rtsdtr_set,
	    env_nounset);
}

static void
efi_check_and_set_condev(struct serial *port, const char *name)
{
	EFI_DEVICE_PATH *node, *dev;
	EFI_STATUS status;
	char *buf;
	size_t sz;

	if (port->currdev == NULL)
		return;

	buf = NULL;
	sz = 0;
	status = efi_global_getenv(name, buf, &sz);
	if (status == EFI_BUFFER_TOO_SMALL) {
		buf = malloc(sz);
		if (buf == NULL)
			return;
		status = efi_global_getenv(name, buf, &sz);
	}
	if (EFI_ERROR(status)) {
		free(buf);
		return;
	}

	dev = efi_lookup_devpath(port->currdev);
	if (dev == NULL) {
		free(buf);
		return;
	}

	node = (EFI_DEVICE_PATH *)buf;
	while (!IsDevicePathEnd(node)) {
		/* Sanity check the node before moving to the next node. */
		if (DevicePathNodeLength(node) < sizeof (*node))
			break;

		if (efi_devpath_is_prefix(dev, node)) {
			port->is_efi_console = true;
			break;
		}

		node = efi_devpath_next_instance(node);
	}

	efi_close_devpath(dev);
	free(buf);
}

/*
 * Return number of ports created (0 or 1).
 */
static uint_t
efi_isa_create_port(EFI_HANDLE handle)
{
	struct serial *port;
	EFI_ISA_IO_PROTOCOL *io;
	EFI_STATUS status;

	status = BS->OpenProtocol(handle, &gEfiIsaIoProtocolGuid,
	    (void**)&io, IH, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
	if (EFI_ERROR(status)) {
		return (0);
	}

	/* Is this serial port? */
	if (io->ResourceList->Device.HID != EISA_PNP_ID(PNP0501))
		return (0);

	/* We assume I/O port */
	if (io->ResourceList->ResourceItem->Type != EfiIsaAcpiResourceIo)
		return (0);

	port = calloc(1, sizeof (*port));
	if (port == NULL) {
		return (0);
	}

	/* Set up port descriptor */
	port->ignore_cd = true;
	port->currdev = handle;
	port->ioaddr = 0;
	for (uint_t i = 0; io->ResourceList->ResourceItem[i].Type !=
	    EfiIsaAcpiResourceEndOfList; i++) {
		if (io->ResourceList->ResourceItem[i].Type ==
		    EfiIsaAcpiResourceIo) {
			port->ioaddr =
			    io->ResourceList->ResourceItem[i].StartRange;
			break;
		}
	}
	port->guid = &gEfiIsaIoProtocolGuid;
	port->io.isa = io;
	/* Use 8,n,1 for defaults */
	port->databits = 8;
	port->parity = NoParity;
	port->stopbits = OneStopBit;

	STAILQ_INSERT_TAIL(&serials, port, next);
	return (1);
}

#ifdef MDE_CPU_X64
static EFI_STATUS
efi_isa_create_io(EFI_ISA_IO_PROTOCOL **iop)
{
	EFI_ISA_IO_PROTOCOL *io;

	io = calloc(1, sizeof (*io));
	if (io == NULL) {
		return (EFI_OUT_OF_RESOURCES);
	}
	io->ResourceList = malloc(sizeof (*io->ResourceList));
	if (io->ResourceList == NULL) {
		free(io);
		return (EFI_OUT_OF_RESOURCES);
	}
	io->ResourceList->ResourceItem =
	    calloc(2, sizeof (*io->ResourceList->ResourceItem));
	if (io->ResourceList == NULL) {
		free(io->ResourceList);
		free(io);
		return (EFI_OUT_OF_RESOURCES);
	}

	*iop = io;
	return (EFI_SUCCESS);
}

static EFI_STATUS EFIAPI
_Read(EFI_ISA_IO_PROTOCOL *this __unused,
    EFI_ISA_IO_PROTOCOL_WIDTH Width __unused,
    UINT32 Offset, UINTN Count, VOID *Buffer)
{
	uint8_t *buf = (uint8_t *)Buffer;

	while ((Count--) != 0) {
		*buf++ = inb(Offset);
	}

	return (EFI_SUCCESS);
}

static EFI_STATUS EFIAPI
_Write(EFI_ISA_IO_PROTOCOL *this __unused,
    EFI_ISA_IO_PROTOCOL_WIDTH Width __unused,
    UINT32 Offset, UINTN Count, VOID *Buffer)
{
	uint8_t *buf = (uint8_t *)Buffer;

	while ((Count--) != 0) {
		outb(Offset, *buf++);
	}
	return (EFI_SUCCESS);
}

static EFI_STATUS
efi_isa_create_io_ports(void)
{
	struct serial *port;
	EFI_ISA_IO_PROTOCOL *io;
	EFI_STATUS status = EFI_SUCCESS;

	port = NULL;
	for (uint_t i = 0; i < nitems(io_ports); i++) {
		if (port == NULL) {
			status = efi_isa_create_io(&io);
			if (EFI_ERROR(status))
				return (status);
			io->Io.Read = _Read;
			io->Io.Write = _Write;
			io->ResourceList->Device.HID = EISA_PNP_ID(PNP0501);
			io->ResourceList->ResourceItem[0].Type =
			    EfiIsaAcpiResourceIo;
			io->ResourceList->ResourceItem[1].Type =
			    EfiIsaAcpiResourceEndOfList;

			port = calloc(1, sizeof (*port));
			if (port == NULL) {
				free(io->ResourceList->ResourceItem);
				free(io->ResourceList);
				free(io);
				return (EFI_OUT_OF_RESOURCES);
			}
			/* Set up port descriptor */
			port->io.isa = io;
			/* Use 8,n,1 for defaults */
			port->databits = 8;
			port->parity = NoParity;
			port->stopbits = OneStopBit;
			port->ignore_cd = true;
			port->guid = &gEfiIsaIoProtocolGuid;
		}
		io->ResourceList->Device.UID = i;
		io->ResourceList->ResourceItem[0].StartRange = io_ports[i];
		port->ioaddr = io_ports[i];
		if (efi_isa_port_is_present(port)) {
			STAILQ_INSERT_TAIL(&serials, port, next);
			port = NULL;
		}
	}

	if (port != NULL) {
		free(io->ResourceList->ResourceItem);
		free(io->ResourceList);
		free(io);
		free(port);
	}
	return (status);
}
#endif	/* MDE_CPU_X64 */

/*
 * Get IsaIo protocol handles and build port list for us.
 * returns EFI_SUCCESS or EFI_NOT_FOUND.
 */
static EFI_STATUS
efi_isa_probe_ports(void)
{
	EFI_STATUS status;
	EFI_HANDLE *handles;
	struct serial *port;
	uint_t count, nhandles, index;

	count = 0;
	nhandles = 0;
	handles = NULL;
	status = efi_get_protocol_handles(&gEfiIsaIoProtocolGuid,
	    &nhandles, &handles);
	if (!EFI_ERROR(status)) {
		for (index = 0; index < nhandles; index++) {
			/* skip if we are iodev for serialio port */
			STAILQ_FOREACH(port, &serials, next) {
				if (port->iodev == handles[index])
					break;
			}
			if (port == NULL)
				count += efi_isa_create_port(handles[index]);
		}
		free(handles);
		if (count == 0)
			status = EFI_NOT_FOUND;
	}
	return (status);
}

/*
 * Set up list of possible serial consoles.
 * This function is run very early, so we do not expect to
 * run out of memory, and on error, we can not print output.
 *
 * isaio protocols can include serial ports, parallel ports,
 * keyboard, mouse. We walk protocol handles, create list of
 * serial ports, then create console descriptors.
 */
void
efi_isa_ini(void)
{
	EFI_STATUS status;
	uint_t c, n;
	struct console **tmp;
	struct console *tty;
	struct serial *port;

	status = efi_isa_probe_ports();
#ifdef MDE_CPU_X64
	if (status == EFI_NOT_FOUND) {
		/*
		 * We have no IsaIo serial ports. But, as this implementation
		 * is very similar to one used in BIOS comconsole driver,
		 * and in order to avoid using comconsole as last resort
		 * fallback on x86 platform, we implement fake IsaIo.
		 */
		if (STAILQ_EMPTY(&serials))
			status = efi_isa_create_io_ports();
	}
#endif
	if (EFI_ERROR(status))
		return;

	n = 0;
	/* Count ports we have */
	STAILQ_FOREACH(port, &serials, next) {
		if (uuid_equal((uuid_t *)port->guid,
		    (uuid_t *)&gEfiIsaIoProtocolGuid, NULL) == 1)
			n++;
	}

	if (n == 0)
		return;		/* no serial ports here */

	c = cons_array_size();
	if (c == 0)
		n++;	/* For NULL pointer */

	tmp = realloc(consoles, (c + n) * sizeof (*consoles));
	if (tmp == NULL) {
		return;
	}
	consoles = tmp;
	if (c > 0)
		c--;

	STAILQ_FOREACH(port, &serials, next) {
		char id;

		if (uuid_equal((uuid_t *)port->guid,
		    (uuid_t *)&gEfiIsaIoProtocolGuid, NULL) == 0) {
			continue;
		}

		tty = calloc(1, sizeof (*tty));
		if (tty == NULL) {
			/* Out of memory?! */
			continue;
		}
		switch (port->ioaddr) {
		case 0:	/* bad ioaddr */
			continue;
		case COM1_IOADDR:
			id = 'a';
			break;
		case COM2_IOADDR:
			id = 'b';
			break;
		case COM3_IOADDR:
			id = 'c';
			break;
		case COM4_IOADDR:
			id = 'd';
			break;
		default:
			/*
			 * We should not see this happening, but assigning
			 * this id would let us help to identify unexpected
			 * configuration.
			 */
			id = '0';
		}
		/* Set up serial device descriptor */
		(void) asprintf(&tty->c_name, "tty%c", id);
		(void) asprintf(&tty->c_desc, "serial port %c", id);
		tty->c_flags = C_PRESENTIN | C_PRESENTOUT;
		tty->c_probe = efi_isa_probe;
		tty->c_init = efi_isa_init;
		tty->c_out = efi_isa_putchar;
		tty->c_in = efi_isa_getchar;
		tty->c_ready = efi_isa_ischar;
		tty->c_ioctl = efi_isa_ioctl;
		tty->c_devinfo = efi_isa_devinfo;
		tty->c_private = port;
		consoles[c++] = tty;

		/* Reset terminal to initial normal settings with ESC [ 0 m */
		efi_isa_putchar(tty, 0x1b);
		efi_isa_putchar(tty, '[');
		efi_isa_putchar(tty, '0');
		efi_isa_putchar(tty, 'm');
		/* drain input from random data */
		while (efi_isa_getchar(tty) != -1)
			;
	}
	consoles[c] = NULL;
}

static EFI_STATUS
efi_isa_getspeed(struct serial *sp)
{
	EFI_STATUS status;
	uint_t  divisor;
	uchar_t dlbh;
	uchar_t dlbl;
	uchar_t cfcr;
	uchar_t c;

	status = sp->io.isa->Io.Read(sp->io.isa,
	    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT, sp->ioaddr + com_cfcr, 1, &cfcr);
	if (EFI_ERROR(status))
		return (status);
	c = CFCR_DLAB | cfcr;
	status = sp->io.isa->Io.Write(sp->io.isa,
	    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT, sp->ioaddr + com_cfcr, 1, &c);
	if (EFI_ERROR(status))
		return (status);

	status = sp->io.isa->Io.Read(sp->io.isa,
	    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT, sp->ioaddr + com_dlbl, 1, &dlbl);
	if (EFI_ERROR(status))
		return (status);
	status = sp->io.isa->Io.Read(sp->io.isa,
	    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT, sp->ioaddr + com_dlbh, 1, &dlbh);
	if (EFI_ERROR(status))
		return (status);

	status = sp->io.isa->Io.Write(sp->io.isa,
	    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT, sp->ioaddr + com_cfcr, 1, &cfcr);
	if (EFI_ERROR(status))
		return (status);

	divisor = dlbh << 8 | dlbl;

	if (divisor == 0)
		return (EFI_DEVICE_ERROR);

	sp->baudrate = COMC_DIV2BPS(divisor);
	return (EFI_SUCCESS);
}

static void
efi_isa_probe(struct console *cp)
{
	struct serial *sp = cp->c_private;
	EFI_STATUS status;
	uint8_t lcr;

	if (!efi_isa_port_is_present(sp)) {
		return;
	}

	status = efi_isa_getspeed(sp);
	if (EFI_ERROR(status)) {
		/* Use fallback value. */
		sp->baudrate = COMSPEED;
	}
	status = sp->io.isa->Io.Read(sp->io.isa,
	    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT, sp->ioaddr + com_lcr,
	    1, &lcr);
	if (EFI_ERROR(status)) {
		return;
	}

	sp->databits = (lcr & BITS8) == BITS8? 8:7;
	sp->stopbits = (lcr & STOP2) == STOP2? TwoStopBits:OneStopBit;
	if ((lcr & (PAREN|PAREVN)) == (PAREN|PAREVN))
		sp->parity = EvenParity;
	else if ((lcr & PAREN) == PAREN)
		sp->parity = OddParity;
	else
		sp->parity = NoParity;

	/* check if we are listed in ConIn */
	efi_check_and_set_condev(sp, "ConIn");
	efi_isa_setup_env(cp);
	if (!efi_isa_setup(cp))
		printf("Failed to set up %s\n", cp->c_name);
}

static int
efi_isa_init(struct console *cp, int arg __unused)
{

	if (efi_isa_setup(cp))
		return (CMD_OK);

	cp->c_flags = 0;
	return (CMD_ERROR);
}

static void
efi_isa_putchar(struct console *cp, int c)
{
	int wait;
	EFI_STATUS status;
	UINTN bufsz = 1;
	char control, cb = c;
	struct serial *sp = cp->c_private;

	for (wait = COMC_TXWAIT; wait > 0; wait--) {
		status = sp->io.isa->Io.Read(sp->io.isa,
		    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT, sp->ioaddr + com_lsr,
		    bufsz, &control);
		if (EFI_ERROR(status))
			continue;

		if ((control & LSR_TXRDY) != LSR_TXRDY)
			continue;

		status = sp->io.isa->Io.Write(sp->io.isa,
		    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT, sp->ioaddr + com_data,
		    bufsz, &cb);
		if (status != EFI_TIMEOUT)
			break;
	}
}

static int
efi_isa_getchar(struct console *cp)
{
	EFI_STATUS status;
	UINTN bufsz = 1;
	char c;
	struct serial *sp = cp->c_private;

	/*
	 * if this device is also used as ConIn, some firmwares
	 * fail to return all input via SIO protocol.
	 */
	if (sp->is_efi_console) {
		return (efi_console.c_in(&efi_console));
	}

	if (!efi_isa_ischar(cp))
		return (-1);

	status = sp->io.isa->Io.Read(sp->io.isa,
	    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT,
	    sp->ioaddr + com_data, bufsz, &c);
	if (EFI_ERROR(status))
		return (-1);

	return (c);
}

static int
efi_isa_ischar(struct console *cp)
{
	EFI_STATUS status;
	uint8_t control;
	struct serial *sp = cp->c_private;

	/*
	 * if this device is also used as ConIn, some firmwares
	 * fail to return all input via SIO protocol.
	 */
	if (sp->is_efi_console) {
		return (efi_console.c_ready(&efi_console));
	}

	status = sp->io.isa->Io.Read(sp->io.isa,
	    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT,
	    sp->ioaddr + com_lsr, 1, &control);
	if (EFI_ERROR(status))
		return (0);

	return (control & LSR_RXRDY);
}

static int
efi_isa_ioctl(struct console *cp __unused, int cmd __unused,
    void *data __unused)
{
	return (ENOTTY);
}

static void
efi_isa_devinfo(struct console *cp)
{
	struct serial *port = cp->c_private;
	EFI_DEVICE_PATH *dp;
	CHAR16 *text;

	if (port->currdev != NULL) {
		dp = efi_lookup_devpath(port->currdev);
		if (dp == NULL)
			return;

		text = efi_devpath_name(dp);
		if (text == NULL)
			return;

		printf("\tISA IO device %S", text);
		efi_free_devpath_name(text);
		efi_close_devpath(port->currdev);
		return;
	}

	if (port->ioaddr != 0) {
		printf("\tISA IO port %#x", port->ioaddr);
	}
}

static char *
efi_isa_asprint_mode(struct serial *sp)
{
	char par, *buf, *stop;

	if (sp == NULL)
		return (NULL);

	switch (sp->parity) {
	case NoParity:
		par = 'n';
		break;
	case EvenParity:
		par = 'e';
		break;
	case OddParity:
		par = 'o';
		break;
	case MarkParity:
		par = 'm';
		break;
	case SpaceParity:
		par = 's';
		break;
	default:
		par = 'n';
		break;
	}

	switch (sp->stopbits) {
	case OneStopBit:
		stop = "1";
		break;
	case TwoStopBits:
		stop = "2";
		break;
	case OneFiveStopBits:
		stop = "1.5";
		break;
	default:
		stop = "1";
		break;
	}

	(void) asprintf(&buf, "%ju,%d,%c,%s,-", sp->baudrate,
	    sp->databits, par, stop);
	return (buf);
}

static int
efi_isa_parse_mode(struct serial *sp, const char *value)
{
	unsigned long n;
	uint64_t baudrate;
	uint8_t databits;
	EFI_PARITY_TYPE parity;
	EFI_STOP_BITS_TYPE stopbits;
	char *ep;

	if (value == NULL || *value == '\0')
		return (CMD_ERROR);

	errno = 0;
	n = strtoul(value, &ep, 10);
	if (errno != 0 || *ep != ',')
		return (CMD_ERROR);
	baudrate = n;

	ep++;
	n = strtoul(ep, &ep, 10);
	if (errno != 0 || *ep != ',')
		return (CMD_ERROR);

	switch (n) {
	case 5:
		databits = 5;
		break;
	case 6:
		databits = 6;
		break;
	case 7:
		databits = 7;
		break;
	case 8:
		databits = 8;
		break;
	default:
		return (CMD_ERROR);
	}

	ep++;
	switch (*ep++) {
	case 'n':
		parity = NoParity;
		break;
	case 'e':
		parity = EvenParity;
		break;
	case 'o':
		parity = OddParity;
		break;
	default:
		return (CMD_ERROR);
	}

	if (*ep == ',')
		ep++;
	else
		return (CMD_ERROR);

	switch (*ep++) {
	case '1':
		stopbits = OneStopBit;
		break;
	case '2':
		stopbits = TwoStopBits;
		break;
	default:
		return (CMD_ERROR);
	}

	/* handshake is ignored, but we check syntax anyhow */
	if (*ep == ',')
		ep++;
	else
		return (CMD_ERROR);

	switch (*ep++) {
	case '-':
	case 'h':
	case 's':
		break;
	default:
		return (CMD_ERROR);
	}

	if (*ep != '\0')
		return (CMD_ERROR);

	sp->baudrate = baudrate;
	sp->databits = databits;
	sp->parity = parity;
	sp->stopbits = stopbits;
	return (CMD_OK);
}

/*
 * CMD_ERROR will cause set/setenv/setprop command to fail,
 * when used in loader scripts (forth), this will cause processing
 * of boot scripts to fail, rendering bootloading impossible.
 * To prevent such unfortunate situation, we return CMD_OK when
 * there is no such port, or there is invalid value in mode line.
 */
static int
efi_isa_mode_set(struct env_var *ev, int flags, const void *value)
{
	struct console *cp;
	char name[15];

	if (value == NULL)
		return (CMD_ERROR);

	if ((cp = cons_get_console(ev->ev_name)) == NULL)
		return (CMD_OK);

	/* Do not override serial setup if port is listed in ConIn */
	(void) snprintf(name, sizeof (name), "%s-spcr-mode", cp->c_name);
	if (getenv(name) == NULL) {
		if (efi_isa_parse_mode(cp->c_private, value) == CMD_ERROR) {
			printf("%s: invalid mode: %s\n", ev->ev_name,
			    (char *)value);
			return (CMD_OK);
		}

		(void) efi_isa_setup(cp);
		(void) env_setenv(ev->ev_name, flags | EV_NOHOOK, value,
		    NULL, NULL);
	}

	return (CMD_OK);
}

/*
 * CMD_ERROR will cause set/setenv/setprop command to fail,
 * when used in loader scripts (forth), this will cause processing
 * of boot scripts to fail, rendering bootloading impossible.
 * To prevent such unfortunate situation, we return CMD_OK when
 * there is no such port or invalid value was used.
 */
static int
efi_isa_cd_set(struct env_var *ev, int flags, const void *value)
{
	struct console *cp;
	struct serial *sp;

	if (value == NULL)
		return (CMD_OK);

	if ((cp = cons_get_console(ev->ev_name)) == NULL)
		return (CMD_OK);

	sp = cp->c_private;
	if (strcmp(value, "true") == 0) {
		sp->ignore_cd = 1;
	} else if (strcmp(value, "false") == 0) {
		sp->ignore_cd = 0;
	} else {
		printf("%s: invalid value: %s\n", ev->ev_name,
		    (char *)value);
		return (CMD_OK);
	}

	(void) efi_isa_setup(cp);

	(void) env_setenv(ev->ev_name, flags | EV_NOHOOK, value, NULL, NULL);

	return (CMD_OK);
}

/*
 * CMD_ERROR will cause set/setenv/setprop command to fail,
 * when used in loader scripts (forth), this will cause processing
 * of boot scripts to fail, rendering bootloading impossible.
 * To prevent such unfortunate situation, we return CMD_OK when
 * there is no such port, or invalid value was used.
 */
static int
efi_isa_rtsdtr_set(struct env_var *ev, int flags, const void *value)
{
	struct console *cp;
	struct serial *sp;

	if (value == NULL)
		return (CMD_OK);

	if ((cp = cons_get_console(ev->ev_name)) == NULL)
		return (CMD_OK);

	sp = cp->c_private;
	if (strcmp(value, "true") == 0) {
		sp->rtsdtr_off = 1;
	} else if (strcmp(value, "false") == 0) {
		sp->rtsdtr_off = 0;
	} else {
		printf("%s: invalid value: %s\n", ev->ev_name,
		    (char *)value);
		return (CMD_OK);
	}

	(void) efi_isa_setup(cp);

	(void) env_setenv(ev->ev_name, flags | EV_NOHOOK, value, NULL, NULL);

	return (CMD_OK);
}

/*
 * In case of error, we also reset ACTIVE flags, so the console
 * framefork will try alternate consoles.
 */
static bool
efi_isa_setup(struct console *cp)
{
	EFI_STATUS status;
	uint8_t data, lcr;
	struct serial *sp = cp->c_private;
	uint_t tries, try_count = 1000000;

	if (sp->baudrate == 0)
		return (false);

	switch (sp->databits) {
	case 8:
		lcr = BITS8;
		break;
	case 7:
		lcr = BITS7;
		break;
	case 6:
		lcr = BITS6;
		break;
	case 5:
		lcr = BITS5;
		break;
	default:
		lcr = BITS8;
		break;
	}

	switch (sp->parity) {
	case NoParity:
		break;
	case OddParity:
		lcr |= PAREN|PARODD;
		break;
	case EvenParity:
		lcr |= PAREN|PAREVN;
		break;
	default:
		break;
	}

	switch (sp->stopbits) {
	case OneStopBit:
		break;
	case TwoStopBits:
		lcr |= STOP2;
		break;
	default:
		break;
	}

	data = CFCR_DLAB | lcr;
	status = sp->io.isa->Io.Write(sp->io.isa,
	    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT,
	    sp->ioaddr + com_cfcr, 1, &data);
	if (EFI_ERROR(status))
		return (false);
	data = COMC_BPS(sp->baudrate) & 0xff;
	status = sp->io.isa->Io.Write(sp->io.isa,
	    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT,
	    sp->ioaddr + com_dlbl, 1, &data);
	if (EFI_ERROR(status))
		return (false);
	data = COMC_BPS(sp->baudrate) >> 8;
	status = sp->io.isa->Io.Write(sp->io.isa,
	    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT,
	    sp->ioaddr + com_dlbh, 1, &data);
	if (EFI_ERROR(status))
		return (false);
	status = sp->io.isa->Io.Write(sp->io.isa,
	    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT,
	    sp->ioaddr + com_cfcr, 1, &lcr);
	if (EFI_ERROR(status))
		return (false);
	data = sp->rtsdtr_off? ~(MCR_RTS | MCR_DTR) : MCR_RTS | MCR_DTR;
	status = sp->io.isa->Io.Write(sp->io.isa,
	    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT,
	    sp->ioaddr + com_mcr, 1, &data);
	if (EFI_ERROR(status))
		return (false);

	tries = 0;
	do {
		status = sp->io.isa->Io.Read(sp->io.isa,
		    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT,
		    sp->ioaddr + com_data, 1, &data);
		status = sp->io.isa->Io.Read(sp->io.isa,
		    EFI_ISA_ACPI_MEMORY_WIDTH_8_BIT,
		    sp->ioaddr + com_lsr, 1, &data);
	} while (data & LSR_RXRDY && ++tries < try_count);

	if (tries == try_count)
		return (false);

	/* Mark this port usable. */
	cp->c_flags |= (C_PRESENTIN | C_PRESENTOUT);
	return (true);
}