/*
 * Copyright (c) 2016 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Imre Vadász <imre@vdsz.com>
 *
 * 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.
 * 3. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
 * COPYRIGHT HOLDERS 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.
 */

/* Register SMBUS device with ACPICA for ACPI-5.0 GPIO functionality */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/errno.h>
#include <sys/lock.h>
#include <sys/bus.h>

#include "opt_acpi.h"
#include "acpi.h"
#include <dev/acpica/acpivar.h>
#include <contrib/dev/acpica/source/include/amlcode.h>

#include <bus/smbus/smbconf.h>

#include "smbus_if.h"

struct gsb_buffer {
	UINT8 status;
	UINT8 len;
	UINT8 data[];
} __packed;

struct acpi_i2c_handler_data {
	struct acpi_connection_info info;
	device_t dev;
};

struct smbus_acpi_softc {
	device_t dev;
	device_t parent;
	struct acpi_i2c_handler_data space_handler_data;
};

static int	smbus_acpi_probe(device_t dev);
static int	smbus_acpi_attach(device_t dev);
static int	smbus_acpi_detach(device_t dev);

/* SMBUS Address Space Handler */
static void		smbus_acpi_install_address_space_handler(
			    struct smbus_acpi_softc *sc);
static void		smbus_acpi_remove_address_space_handler(
			    struct smbus_acpi_softc *sc);
static ACPI_STATUS	smbus_acpi_space_handler(UINT32 Function,
			    ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth,
			    UINT64 *Value, void *HandlerContext,
			    void *RegionContext);

/*
 * SMBUS Address space handler
 */

static void
smbus_acpi_install_address_space_handler(struct smbus_acpi_softc *sc)
{
	ACPI_HANDLE handle;
	ACPI_STATUS s;

	handle = acpi_get_handle(sc->parent);
	sc->space_handler_data.dev = sc->parent;
	s = AcpiInstallAddressSpaceHandler(handle, ACPI_ADR_SPACE_GSBUS,
	    &smbus_acpi_space_handler, NULL, &sc->space_handler_data);
	if (ACPI_FAILURE(s)) {
		device_printf(sc->dev,
		    "Failed to install GSBUS Address Space Handler in ACPI\n");
	}
}

static void
smbus_acpi_remove_address_space_handler(struct smbus_acpi_softc *sc)
{
	ACPI_HANDLE handle;
	ACPI_STATUS s;

	handle = acpi_get_handle(sc->parent);
	s = AcpiRemoveAddressSpaceHandler(handle, ACPI_ADR_SPACE_GSBUS,
	    &smbus_acpi_space_handler);
	if (ACPI_FAILURE(s)) {
		device_printf(sc->dev,
		    "Failed to remove GSBUS Address Space Handler from ACPI\n");
	}
}

static ACPI_STATUS
smbus_acpi_space_handler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address,
    UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
{
	struct gsb_buffer *gsb = (struct gsb_buffer *)Value;
	struct acpi_i2c_handler_data *data = HandlerContext;
	device_t dev = data->dev;
	struct acpi_connection_info *info = &data->info;
	struct acpi_resource_i2c_serialbus *sb;
	ACPI_RESOURCE *Resource;
	UINT32 accessor_type = Function >> 16;
	UINT8 action = Function & ACPI_IO_MASK;
	ACPI_STATUS s = AE_OK;
	int cnt, val = 0;
	uint16_t *wdata;
	short word;
	char byte;
	char buf[32];
	u_char count;

	if (Value == NULL)
		return (AE_BAD_PARAMETER);

	s = AcpiBufferToResource(info->Connection, info->Length,
	    &Resource);
	if (ACPI_FAILURE(s))
		return s;
	if (Resource->Type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
		s = AE_BAD_PARAMETER;
		goto err;
	}

	sb = &Resource->Data.I2cSerialBus;
	if (sb->Type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
		s = AE_BAD_PARAMETER;
		goto err;
	}

	/* XXX Ignore 10bit addressing for now */
	if (sb->AccessMode == ACPI_I2C_10BIT_MODE) {
		s = AE_BAD_PARAMETER;
		goto err;
	}

	switch (accessor_type) {
	case AML_FIELD_ATTRIB_SEND_RECEIVE:
		if (action == ACPI_READ) {
			val = SMBUS_RECVB(dev, sb->SlaveAddress, &byte);
			if (val == 0)
				gsb->data[0] = byte;
		} else {
			val = SMBUS_SENDB(dev, sb->SlaveAddress,
			    gsb->data[0]);
		}
		break;
	case AML_FIELD_ATTRIB_BYTE:
		if (action == ACPI_READ) {
			val = SMBUS_READB(dev, sb->SlaveAddress, Address,
			    &byte);
			if (val == 0)
				gsb->data[0] = byte;
		} else {
			val = SMBUS_WRITEB(dev, sb->SlaveAddress, Address,
			    gsb->data[0]);
		}
		break;
	case AML_FIELD_ATTRIB_WORD:
		wdata = (uint16_t *)gsb->data;
		if (action == ACPI_READ) {
			val = SMBUS_READW(dev, sb->SlaveAddress, Address,
			    &word);
			if (val == 0)
				wdata[0] = word;
		} else {
			val = SMBUS_WRITEW(dev, sb->SlaveAddress, Address,
			    wdata[0]);
		}
		break;
	case AML_FIELD_ATTRIB_BLOCK:
		if (action == ACPI_READ) {
			count = 32;
			val = SMBUS_BREAD(dev, sb->SlaveAddress, Address,
			    &count, buf);
			if (val == 0) {
				gsb->len = count;
				memcpy(gsb->data, buf, count);
			}
		} else {
			memcpy(buf, gsb->data, gsb->len);
			count = gsb->len;
			val = SMBUS_BWRITE(dev, sb->SlaveAddress, Address,
			    count, buf);
		}
		break;
	case AML_FIELD_ATTRIB_BYTES:
		if (action == ACPI_READ) {
			cnt = 0;
			val = SMBUS_TRANS(dev, sb->SlaveAddress, Address,
			    SMB_TRANS_NOCNT | SMB_TRANS_7BIT, NULL, 0,
			    buf, info->AccessLength, &cnt);
			if (val == 0)
				memcpy(gsb->data, buf, cnt);
		} else {
			memcpy(buf, gsb->data, info->AccessLength);
			val = SMBUS_TRANS(dev, sb->SlaveAddress, Address,
			    SMB_TRANS_NOCNT | SMB_TRANS_7BIT,
			    buf, info->AccessLength, NULL, 0, NULL);
		}
		break;
	default:
		device_printf(dev, "protocol(0x%02x) is not supported.\n",
		    accessor_type);
		s = AE_BAD_PARAMETER;
		goto err;
	}

	gsb->status = val;

err:
	ACPI_FREE(Resource);

	return (s);
}

static int
smbus_acpi_probe(device_t dev)
{
	if (acpi_get_handle(device_get_parent(dev)) == NULL)
		return (ENXIO);

	device_set_desc(dev, "ACPI I2cSerialBus backend");

	return (0);
}

static int
smbus_acpi_attach(device_t dev)
{
	struct smbus_acpi_softc *sc = device_get_softc(dev);

	sc->dev = dev;
	sc->parent = device_get_parent(dev);

	smbus_acpi_install_address_space_handler(sc);

	return (0);
}

static int
smbus_acpi_detach(device_t dev)
{
	struct smbus_acpi_softc *sc = device_get_softc(dev);

	smbus_acpi_remove_address_space_handler(sc);

	return (0);
}

static device_method_t smbacpi_methods[] = {
	/* Device interface */
	DEVMETHOD(device_probe, smbus_acpi_probe),
	DEVMETHOD(device_attach, smbus_acpi_attach),
	DEVMETHOD(device_detach, smbus_acpi_detach),

	DEVMETHOD_END
};

static driver_t smbacpi_driver = {
	"smbacpi",
	smbacpi_methods,
	sizeof(struct smbus_acpi_softc)
};

static devclass_t smbacpi_devclass;

DRIVER_MODULE(smbacpi, ig4iic, smbacpi_driver, smbacpi_devclass,
    NULL, NULL);
MODULE_DEPEND(smbacpi, acpi, 1, 1, 1);
MODULE_DEPEND(smbacpi, smbus, 1, 1, 1);
MODULE_VERSION(smbacpi, 1);