/*-
 * Copyright (c) 2009 Clemens Zeidler
 * Copyright (c) 2003-2007 Nate Lawson
 * Copyright (c) 2000 Michael Smith
 * Copyright (c) 2000 BSDi
 * 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 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.
 */
#ifndef ACPI_EMBEDDED_CONTROLLER_H
#define ACPI_EMBEDDED_CONTROLLER_H


#include <ctype.h>

#include <ACPI.h>
#include <condition_variable.h>

#include <Drivers.h>
#include <KernelExport.h>
#include <lock.h>

extern "C" {
#	include "acpi.h"
#	include "accommon.h"
#	include "acnamesp.h"
#	include "actypes.h"
#	include "ACPIPrivate.h"
}


// #define TRACE_EMBEDDED_CONTROLLER
#ifdef TRACE_EMBEDDED_CONTROLLER
#	define TRACE(x...) dprintf("EC: " x)
#else
#	define TRACE(x...)
#endif

#define ERROR(x...) dprintf("EC: " x)


typedef uint8							EC_COMMAND;

#define EC_COMMAND_UNKNOWN				((EC_COMMAND) 0x00)
#define EC_COMMAND_READ					((EC_COMMAND) 0x80)
#define EC_COMMAND_WRITE				((EC_COMMAND) 0x81)
#define EC_COMMAND_BURST_ENABLE			((EC_COMMAND) 0x82)
#define EC_COMMAND_BURST_DISABLE		((EC_COMMAND) 0x83)
#define EC_COMMAND_QUERY				((EC_COMMAND) 0x84)

/*
 * EC_STATUS:
 * ----------
 * The encoding of the EC status register is illustrated below.
 * Note that a set bit (1) indicates the property is TRUE
 * (e.g. if bit 0 is set then the output buffer is full).
 * +-+-+-+-+-+-+-+-+
 * |7|6|5|4|3|2|1|0|
 * +-+-+-+-+-+-+-+-+
 *  | | | | | | | |
 *  | | | | | | | +- Output Buffer Full?
 *  | | | | | | +--- Input Buffer Full?
 *  | | | | | +----- <reserved>
 *  | | | | +------- Data Register is Command Byte?
 *  | | | +--------- Burst Mode Enabled?
 *  | | +----------- SCI Event?
 *  | +------------- SMI Event?
 *  +--------------- <reserved>
 *
 */

typedef uint8							EC_STATUS;

#define EC_FLAG_OUTPUT_BUFFER			((EC_STATUS) 0x01)
#define EC_FLAG_INPUT_BUFFER			((EC_STATUS) 0x02)
#define EC_FLAG_DATA_IS_CMD				((EC_STATUS) 0x08)
#define EC_FLAG_BURST_MODE				((EC_STATUS) 0x10)

/*
 * EC_EVENT:
 * ---------
 */
typedef uint8							EC_EVENT;

#define EC_EVENT_UNKNOWN				((EC_EVENT) 0x00)
#define EC_EVENT_OUTPUT_BUFFER_FULL		((EC_EVENT) 0x01)
#define EC_EVENT_INPUT_BUFFER_EMPTY		((EC_EVENT) 0x02)
#define EC_EVENT_SCI					((EC_EVENT) 0x20)
#define EC_EVENT_SMI					((EC_EVENT) 0x40)

/* Data byte returned after burst enable indicating it was successful. */
#define EC_BURST_ACK					0x90


/*
 * Register access primitives
 */
#define EC_GET_DATA(sc) \
		bus_space_read_1((sc)->ec_data_pci_address)

#define EC_SET_DATA(sc, v) \
		bus_space_write_1((sc)->ec_data_pci_address, (v))

#define EC_GET_CSR(sc) \
		bus_space_read_1((sc)->ec_csr_pci_address)

#define EC_SET_CSR(sc, v) \
		bus_space_write_1((sc)->ec_csr_pci_address, (v))

#define ACPI_PKG_VALID(pkg, size) \
		((pkg) != NULL && (pkg)->object_type == ACPI_TYPE_PACKAGE && \
		(pkg)->package.count >= (size))


/*
 * Driver cookie.
 */
struct acpi_ec_cookie {
	device_node*				ec_dev;
	acpi_module_info*			ec_acpi_module;
	acpi_device_module_info* 	ec_acpi;
	acpi_device					ec_handle;
	int							ec_uid;
	acpi_handle					ec_gpehandle;
	uint8						ec_gpebit;

	int							ec_data_pci_address;
	int							ec_csr_pci_address;

	int							ec_glk;
	uint32						ec_glkhandle;
	mutex						ec_lock;
	int							ec_burstactive;
	int32						ec_sci_pending;
	int32						ec_gencount;
	ConditionVariable			ec_condition_var;
	int							ec_suspending;
};


/*
 * XXX njl
 * I couldn't find it in the spec but other implementations also use a
 * value of 1 ms for the time to acquire global lock.
 */
#define EC_LOCK_TIMEOUT 1000

/* Default delay in microseconds between each run of the status polling loop. */
#define EC_POLL_DELAY	50

/* Total time in ms spent waiting for a response from EC. */
#define EC_TIMEOUT		750

#define EVENT_READY(event, status) \
		(((event) == EC_EVENT_OUTPUT_BUFFER_FULL && \
		((status) & EC_FLAG_OUTPUT_BUFFER) != 0) || \
		((event) == EC_EVENT_INPUT_BUFFER_EMPTY && \
		((status) & EC_FLAG_INPUT_BUFFER) == 0))



static bool		ec_burst_mode = true;
static bool		ec_polled_mode = false;

static int		ec_timeout = EC_TIMEOUT;


static status_t
EcLock(struct acpi_ec_cookie *sc)
{
	/* If _GLK is non-zero, acquire the global lock. */
	if (sc->ec_glk) {
		status_t status = sc->ec_acpi_module->acquire_global_lock(EC_LOCK_TIMEOUT,
			&sc->ec_glkhandle);
		if (status != B_OK)
			return status;
	}
	return mutex_lock(&sc->ec_lock);
}


static void
EcUnlock(struct acpi_ec_cookie *sc)
{
	mutex_unlock(&sc->ec_lock);
	if (sc->ec_glk)
		sc->ec_acpi_module->release_global_lock(sc->ec_glkhandle);
}


static uint32			EcGpeHandler(acpi_handle gpeDevice, uint32 gpeNumber,
							void *context);

static acpi_status		EcSpaceSetup(acpi_handle region, uint32 function,
							void *context, void **return_Context);
static acpi_status		EcSpaceHandler(uint32 function,
							acpi_physical_address address,
							uint32 width, int *value,
							void *context, void *regionContext);
static acpi_status		EcWaitEvent(struct acpi_ec_cookie *sc, EC_EVENT event,
							int32 gen_count);
static acpi_status		EcCommand(struct acpi_ec_cookie *sc, EC_COMMAND cmd);
static acpi_status		EcRead(struct acpi_ec_cookie *sc, uint8 address,
							uint8 *readData);
static acpi_status		EcWrite(struct acpi_ec_cookie *sc, uint8 address,
							uint8 writeData);


#endif	// ACPI_EMBEDDED_CONTROLLER_H