/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2011 Joyent, Inc.  All rights reserved.
 * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
 */
/*
 * Solaris x86 ACPI CA Embedded Controller operation region handler
 */

#include <sys/file.h>
#include <sys/errno.h>
#include <sys/conf.h>
#include <sys/modctl.h>
#include <sys/open.h>
#include <sys/stat.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/note.h>
#include <sys/atomic.h>

#include <sys/acpi/acpi.h>
#include <sys/acpica.h>

/*
 * EC status bits
 * Low to high
 *	Output buffer full?
 *	Input buffer full?
 *	<reserved>
 *	Data register is command byte?
 *	Burst mode enabled?
 *	SCI event?
 *	SMI event?
 *	<reserved>
 */
#define	EC_OBF	(0x01)
#define	EC_IBF	(0x02)
#define	EC_DRC	(0x08)
#define	EC_BME	(0x10)
#define	EC_SCI	(0x20)
#define	EC_SMI	(0x40)

/*
 * EC commands
 */
#define	EC_RD	(0x80)
#define	EC_WR	(0x81)
#define	EC_BE	(0x82)
#define	EC_BD	(0x83)
#define	EC_QR	(0x84)

#define	IO_PORT_DES (0x47)

/*
 * EC softstate
 */
static struct ec_softstate {
	uint8_t	 ec_ok;		/* != 0 if we have ec_base, ec_sc */
	uint16_t ec_base;	/* base of EC I/O port - data */
	uint16_t ec_sc;		/* EC status/command */
	ACPI_HANDLE ec_dev_hdl;	/* EC device handle */
	ACPI_HANDLE ec_gpe_hdl;	/* GPE info */
	ACPI_INTEGER ec_gpe_bit;
	kmutex_t    ec_mutex;	/* serialize access to EC */
} ec;

/* I/O port range descriptor */
typedef struct io_port_des {
	uint8_t type;
	uint8_t decode;
	uint8_t min_base_lo;
	uint8_t min_base_hi;
	uint8_t max_base_lo;
	uint8_t max_base_hi;
	uint8_t align;
	uint8_t len;
} io_port_des_t;

/*
 * Patchable to ignore an ECDT, in case using that
 * causes problems on someone's system.
 */
int ec_ignore_ecdt = 0;

/*
 * Patchable timeout values for EC input-buffer-full-clear
 * and output-buffer-full-set. These are in 10uS units and
 * default to 1 second.
 */
int ibf_clear_timeout = 100000;
int obf_set_timeout = 100000;

/*
 * ACPI CA EC address space handler support functions
 */

/*
 * Busy-wait for IBF to clear
 * return < 0 for time out, 0 for no error
 */
static int
ec_wait_ibf_clear(int sc_addr)
{
	int	cnt;

	cnt = ibf_clear_timeout;
	while (inb(sc_addr) & EC_IBF) {
		if (cnt-- <= 0)
			return (-1);
		drv_usecwait(10);
	}
	return (0);
}

/*
 * Busy-wait for OBF to set
 * return < 0 for time out, 0 for no error
 */
static int
ec_wait_obf_set(int sc_addr)
{
	int	cnt;

	cnt = obf_set_timeout;
	while (!(inb(sc_addr) & EC_OBF)) {
		if (cnt-- <= 0)
			return (-1);
		drv_usecwait(10);
	}
	return (0);
}

/*
 * Only called from ec_handler(), which validates ec_ok
 */
static int
ec_rd(int addr)
{
	int	cnt, rv;
	uint8_t sc;

	mutex_enter(&ec.ec_mutex);
	sc = inb(ec.ec_sc);

#ifdef	DEBUG
	if (sc & EC_IBF) {
		cmn_err(CE_NOTE, "!ec_rd: IBF already set");
	}

	if (sc & EC_OBF) {
		cmn_err(CE_NOTE, "!ec_rd: OBF already set");
	}
#endif

	outb(ec.ec_sc, EC_RD);	/* output a read command */
	if (ec_wait_ibf_clear(ec.ec_sc) < 0) {
		cmn_err(CE_NOTE, "!ec_rd:1: timed-out waiting "
		    "for IBF to clear");
		mutex_exit(&ec.ec_mutex);
		return (-1);
	}

	outb(ec.ec_base, addr);	/* output addr */
	if (ec_wait_ibf_clear(ec.ec_sc) < 0) {
		cmn_err(CE_NOTE, "!ec_rd:2: timed-out waiting "
		    "for IBF to clear");
		mutex_exit(&ec.ec_mutex);
		return (-1);
	}
	if (ec_wait_obf_set(ec.ec_sc) < 0) {
		cmn_err(CE_NOTE, "!ec_rd:1: timed-out waiting "
		    "for OBF to set");
		mutex_exit(&ec.ec_mutex);
		return (-1);
	}

	rv = inb(ec.ec_base);
	mutex_exit(&ec.ec_mutex);
	return (rv);
}

/*
 * Only called from ec_handler(), which validates ec_ok
 */
static int
ec_wr(int addr, uint8_t val)
{
	int	cnt;
	uint8_t sc;

	mutex_enter(&ec.ec_mutex);
	sc = inb(ec.ec_sc);

#ifdef	DEBUG
	if (sc & EC_IBF) {
		cmn_err(CE_NOTE, "!ec_wr: IBF already set");
	}

	if (sc & EC_OBF) {
		cmn_err(CE_NOTE, "!ec_wr: OBF already set");
	}
#endif

	outb(ec.ec_sc, EC_WR);	/* output a write command */
	if (ec_wait_ibf_clear(ec.ec_sc) < 0) {
		cmn_err(CE_NOTE, "!ec_wr:1: timed-out waiting "
		    "for IBF to clear");
		mutex_exit(&ec.ec_mutex);
		return (-1);
	}

	outb(ec.ec_base, addr);	/* output addr */
	if (ec_wait_ibf_clear(ec.ec_sc) < 0) {
		cmn_err(CE_NOTE, "!ec_wr:2: timed-out waiting "
		    "for IBF to clear");
		mutex_exit(&ec.ec_mutex);
		return (-1);
	}

	outb(ec.ec_base, val);	/* write data */
	if (ec_wait_ibf_clear(ec.ec_sc) < 0) {
		cmn_err(CE_NOTE, "!ec_wr:3: timed-out waiting "
		    "for IBF to clear");
		mutex_exit(&ec.ec_mutex);
		return (-1);
	}

	mutex_exit(&ec.ec_mutex);
	return (0);
}

/*
 * Only called from ec_gpe_callback(), which validates ec_ok
 */
static int
ec_query(void)
{
	int	cnt, rv;
	uint8_t	sc;

	mutex_enter(&ec.ec_mutex);
	outb(ec.ec_sc, EC_QR);	/* output a query command */
	if (ec_wait_ibf_clear(ec.ec_sc) < 0) {
		cmn_err(CE_NOTE, "!ec_query:1: timed-out waiting "
		    "for IBF to clear");
		mutex_exit(&ec.ec_mutex);
		return (-1);
	}

	if (ec_wait_obf_set(ec.ec_sc) < 0) {
		cmn_err(CE_NOTE, "!ec_query:1: timed-out waiting "
		    "for OBF to set");
		mutex_exit(&ec.ec_mutex);
		return (-1);
	}

	rv = inb(ec.ec_base);
	mutex_exit(&ec.ec_mutex);
	return (rv);
}

/*
 * ACPI CA EC address space handler
 * Requires: ec.ec_sc, ec.ec_base
 */
static ACPI_STATUS
ec_handler(UINT32 func, ACPI_PHYSICAL_ADDRESS addr, UINT32 width,
	UINT64 *val, void *context, void *regcontext)
{
	_NOTE(ARGUNUSED(context, regcontext))
	int i, tw, tmp;

	/* Guard against unexpected invocation */
	if (ec.ec_ok == 0)
		return (AE_ERROR);

	/*
	 * Add safety checks for BIOSes not strictly compliant
	 * with ACPI spec
	 */
	if ((width % 8) != 0) {
		cmn_err(CE_NOTE, "!ec_handler: invalid width %d", width);
		return (AE_BAD_PARAMETER);
	}
	if (val == NULL) {
		cmn_err(CE_NOTE, "!ec_handler: NULL value pointer");
		return (AE_BAD_PARAMETER);
	}

	while (width > 0) {

		/* One UINT64 *val at a time. */
		tw = min(width, 64);

		if (func == ACPI_READ)
			*val = 0;

		/* Do I/O of up to 64 bits */
		for (i = 0; i < tw; i += 8, addr++) {
			switch (func) {
			case ACPI_READ:
				tmp = ec_rd(addr);
				if (tmp < 0)
					return (AE_ERROR);
				*val |= ((UINT64)tmp) << i;
				break;
			case ACPI_WRITE:
				tmp = ((*val) >> i) & 0xFF;
				if (ec_wr(addr, (uint8_t)tmp) < 0)
					return (AE_ERROR);
				break;
			default:
				return (AE_ERROR);
			}
		}
		val++;
		width -= tw;
	}

	return (AE_OK);
}

/*
 * Called via taskq entry enqueued by ec_gpe_handler,
 * which validates ec_ok
 */
static void
ec_gpe_callback(void *ctx)
{
	_NOTE(ARGUNUSED(ctx))
	char		query_str[5];
	int		query;

	if (!(inb(ec.ec_sc) & EC_SCI))
		goto out;

	query = ec_query();
	if (query < 0)
		goto out;

	(void) snprintf(query_str, 5, "_Q%02X", (uint8_t)query);
	(void) AcpiEvaluateObject(ec.ec_dev_hdl, query_str, NULL, NULL);

out:
	AcpiFinishGpe(ec.ec_gpe_hdl, ec.ec_gpe_bit);
}

static UINT32
ec_gpe_handler(ACPI_HANDLE GpeDevice, UINT32 GpeNumber, void *ctx)
{
	_NOTE(ARGUNUSED(GpeDevice))
	_NOTE(ARGUNUSED(GpeNumber))
	_NOTE(ARGUNUSED(ctx))

	/*
	 * With ec_ok==0, we will not install a GPE handler,
	 * so this is just paranoia.  But if this were to
	 * happen somehow, don't add the taskq entry, and
	 * tell the caller we're done with this GPE call.
	 */
	if (ec.ec_ok == 0)
		return (ACPI_REENABLE_GPE);

	AcpiOsExecute(OSL_GPE_HANDLER, ec_gpe_callback, NULL);

	/*
	 * Returning zero tells the ACPI system that we will
	 * handle this event asynchronously.
	 */
	return (0);
}

/*
 * Some systems describe the EC using an "ECDT" (table).
 * If we find one use it (unless ec_ignore_ecdt is set).
 * Modern systems don't provide an ECDT.
 */
static ACPI_STATUS
ec_probe_ecdt(void)
{
	ACPI_TABLE_HEADER *th;
	ACPI_TABLE_ECDT *ecdt;
	ACPI_HANDLE	dev_hdl;
	ACPI_STATUS	status;

	status = AcpiGetTable(ACPI_SIG_ECDT, 1, &th);
#ifndef DEBUG
	if (status == AE_NOT_FOUND)
		return (status);
#endif
	if (ACPI_FAILURE(status)) {
		cmn_err(CE_NOTE, "!acpica: ECDT not found");
		return (status);
	}
	if (ec_ignore_ecdt) {
		/* pretend it was not found */
		cmn_err(CE_NOTE, "!acpica: ECDT ignored");
		return (AE_NOT_FOUND);
	}

	ecdt = (ACPI_TABLE_ECDT *)th;
	if (ecdt->Control.BitWidth != 8 ||
	    ecdt->Data.BitWidth != 8) {
		cmn_err(CE_NOTE, "!acpica: bad ECDT I/O width");
		return (AE_BAD_VALUE);
	}
	status = AcpiGetHandle(NULL, (char *)ecdt->Id, &dev_hdl);
	if (ACPI_FAILURE(status)) {
		cmn_err(CE_NOTE, "!acpica: no ECDT device handle");
		return (status);
	}

	/*
	 * Success.  Save info for attach.
	 */
	ec.ec_base = ecdt->Data.Address;
	ec.ec_sc = ecdt->Control.Address;
	ec.ec_dev_hdl = dev_hdl;
	ec.ec_gpe_hdl = NULL;
	ec.ec_gpe_bit = ecdt->Gpe;
	ec.ec_ok = 1;

#ifdef DEBUG
	cmn_err(CE_NOTE, "!acpica:ec_probe_ecdt: success");
#endif
	return (0);
}

/*
 * Called from AcpiWalkDevices() when an EC device is found
 */
static ACPI_STATUS
ec_find(ACPI_HANDLE obj, UINT32 nest, void *context, void **rv)
{
	_NOTE(ARGUNUSED(nest, rv))

	*((ACPI_HANDLE *)context) = obj;
	return (AE_OK);
}

/*
 * Normal way to get the details about the EC,
 * by searching the name space.
 */
static ACPI_STATUS
ec_probe_ns(void)
{
	ACPI_HANDLE dev_hdl;
	ACPI_BUFFER buf, crs;
	ACPI_OBJECT *gpe_obj;
	ACPI_HANDLE gpe_hdl;
	ACPI_INTEGER gpe_bit;
	ACPI_STATUS status;
	int i, io_port_cnt;
	uint16_t ec_sc, ec_base;

	dev_hdl = NULL;
	(void) AcpiGetDevices("PNP0C09", &ec_find, (void *)&dev_hdl, NULL);
	if (dev_hdl == NULL) {
#ifdef DEBUG
		/* Not an error, just no EC on this machine. */
		cmn_err(CE_WARN, "!acpica:ec_probe_ns: "
		    "PNP0C09 not found");
#endif
		return (AE_NOT_FOUND);
	}

	/*
	 * Find ec_base and ec_sc addresses
	 */
	crs.Length = ACPI_ALLOCATE_BUFFER;
	status = AcpiEvaluateObjectTyped(dev_hdl, "_CRS", NULL, &crs,
	    ACPI_TYPE_BUFFER);
	if (ACPI_FAILURE(status)) {
		cmn_err(CE_WARN, "!acpica:ec_probe_ns: "
		    "_CRS object evaluate failed");
		return (status);
	}

	for (i = 0, io_port_cnt = 0;
	    i < ((ACPI_OBJECT *)crs.Pointer)->Buffer.Length; i++) {
		io_port_des_t *io_port;
		uint8_t *tmp;

		tmp = ((ACPI_OBJECT *)crs.Pointer)->Buffer.Pointer + i;
		if (*tmp != IO_PORT_DES)
			continue;
		io_port = (io_port_des_t *)tmp;
		/*
		 * first port is ec_base and second is ec_sc
		 */
		if (io_port_cnt == 0)
			ec_base = (io_port->min_base_hi << 8) |
			    io_port->min_base_lo;
		if (io_port_cnt == 1)
			ec_sc = (io_port->min_base_hi << 8) |
			    io_port->min_base_lo;

		io_port_cnt++;
		/*
		 * Increment ahead to next struct.
		 */
		i += 7;
	}
	AcpiOsFree(crs.Pointer);
	if (io_port_cnt < 2) {
		cmn_err(CE_WARN, "!acpica:ec_probe_ns: "
		    "_CRS parse failed");
		return (AE_BAD_VALUE);
	}

	/*
	 * Get the GPE info.
	 */
	buf.Length = ACPI_ALLOCATE_BUFFER;
	status = AcpiEvaluateObject(dev_hdl, "_GPE", NULL, &buf);
	if (ACPI_FAILURE(status)) {
		cmn_err(CE_WARN, "!acpica:ec_probe_ns: "
		    "_GPE object evaluate");
		return (status);
	}
	gpe_obj = (ACPI_OBJECT *)buf.Pointer;
	/*
	 * process the GPE description
	 */
	switch (gpe_obj->Type) {
	case ACPI_TYPE_INTEGER:
		gpe_hdl = NULL;
		gpe_bit = gpe_obj->Integer.Value;
		break;
	case ACPI_TYPE_PACKAGE:
		if (gpe_obj->Package.Count != 2)
			goto bad_gpe;
		gpe_obj = gpe_obj->Package.Elements;
		if (gpe_obj[1].Type != ACPI_TYPE_INTEGER)
			goto bad_gpe;
		gpe_hdl = gpe_obj[0].Reference.Handle;
		gpe_bit = gpe_obj[1].Integer.Value;
		break;
	bad_gpe:
	default:
		status = AE_BAD_VALUE;
		break;
	}
	AcpiOsFree(buf.Pointer);
	if (ACPI_FAILURE(status)) {
		cmn_err(CE_WARN, "!acpica:ec_probe_ns: "
		    "_GPE parse failed");
		return (status);
	}

	/*
	 * Success.  Save info for attach.
	 */
	ec.ec_base = ec_base;
	ec.ec_sc = ec_sc;
	ec.ec_dev_hdl = dev_hdl;
	ec.ec_gpe_hdl = gpe_hdl;
	ec.ec_gpe_bit = gpe_bit;
	ec.ec_ok = 1;

#ifdef DEBUG
	cmn_err(CE_NOTE, "!acpica:ec_probe_ns: success");
#endif
	return (0);
}

/*
 * Setup the Embedded Controller (EC) address space handler.
 * Entered only if one of the EC probe methods found an EC.
 */
static void
ec_init(void)
{
	ACPI_STATUS rc;
	int x;

	/* paranoia */
	if (ec.ec_ok == 0)
		return;

	/*
	 * Drain the EC data register if something is left over from
	 * legacy mode
	 */
	if (inb(ec.ec_sc) & EC_OBF) {
		x = inb(ec.ec_base);	/* read and discard value */
#ifdef	DEBUG
		cmn_err(CE_NOTE, "!EC had something: 0x%x", x);
#endif
	}

	/*
	 * Install an "EC address space" handler.
	 *
	 * This call does a name space walk under the passed
	 * object looking for child objects with an EC space
	 * region for which to install this handler.  Using
	 * the ROOT object makes sure we find them all.
	 *
	 * XXX: Some systems return an error from this call
	 * after a partial success, i.e. where the NS walk
	 * installs on some nodes and fails on other nodes.
	 * In such cases, disabling the EC and GPE handlers
	 * makes things worse, so just report the error and
	 * leave the EC handler enabled.
	 *
	 * At one point, it seemed that doing this part of
	 * EC setup earlier may help, which is why this is
	 * now a separate function from ec_attach.  Someone
	 * needs to figure our why some systems give us an
	 * error return from this call.  (TODO)
	 */
	rc = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
	    ACPI_ADR_SPACE_EC, &ec_handler, NULL, NULL);
	if (rc != AE_OK) {
		cmn_err(CE_WARN, "!acpica:ec_init: "
		    "install AS handler, rc=0x%x", rc);
		return;
	}
#ifdef DEBUG
	cmn_err(CE_NOTE, "!acpica:ec_init: success");
#endif
}

/*
 * Attach the EC General-Purpose Event (GPE) handler.
 */
static void
ec_attach(void)
{
	ACPI_STATUS rc;

	/*
	 * Guard against call without probe results.
	 */
	if (ec.ec_ok == 0) {
		cmn_err(CE_WARN, "!acpica:ec_attach: "
		    "no EC device found");
		return;
	}

	/*
	 * Install the GPE handler and enable it.
	 */
	rc = AcpiInstallGpeHandler(ec.ec_gpe_hdl, ec.ec_gpe_bit,
	    ACPI_GPE_EDGE_TRIGGERED, ec_gpe_handler, NULL);
	if (rc != AE_OK) {
		cmn_err(CE_WARN, "!acpica:ec_attach: "
		    "install GPE handler, rc=0x%x", rc);
		goto errout;
	}

	rc = AcpiEnableGpe(ec.ec_gpe_hdl, ec.ec_gpe_bit);
	if (rc != AE_OK) {
		cmn_err(CE_WARN, "!acpica:ec_attach: "
		    "enable GPE handler, rc=0x%x", rc);
		goto errout;
	}

#ifdef DEBUG
	cmn_err(CE_NOTE, "!acpica:ec_attach: success");
#endif
	return;

errout:
	AcpiRemoveGpeHandler(ec.ec_gpe_hdl, ec.ec_gpe_bit,
	    ec_gpe_handler);
}

/*
 * System Management Bus Controller (SMBC)
 * These also go through the EC.
 * (not yet supported)
 */
static void
smbus_attach(void)
{
#ifdef	DEBUG
	ACPI_HANDLE obj;

	obj = NULL;
	(void) AcpiGetDevices("ACPI0001", &ec_find, (void *)&obj, NULL);
	if (obj != NULL) {
		cmn_err(CE_NOTE, "!acpica: found an SMBC Version 1.0");
	}

	obj = NULL;
	(void) AcpiGetDevices("ACPI0005", &ec_find, (void *)&obj, NULL);
	if (obj != NULL) {
		cmn_err(CE_NOTE, "!acpica: found an SMBC Version 2.0");
	}
#endif	/* DEBUG */
}

/*
 * Initialize the EC, if present.
 */
void
acpica_ec_init(void)
{
	ACPI_STATUS rc;

	/*
	 * Initialize EC mutex here
	 */
	mutex_init(&ec.ec_mutex, NULL, MUTEX_DRIVER, NULL);

	/*
	 * First search the ACPI tables for an ECDT, and
	 * if not found, search the name space for it.
	 */
	rc = ec_probe_ecdt();
	if (ACPI_FAILURE(rc))
		rc = ec_probe_ns();
	if (ACPI_SUCCESS(rc)) {
		ec_init();
		ec_attach();
	}
	smbus_attach();
}