/* $NetBSD: acpi_i2c.c,v 1.23 2025/09/23 06:28:19 thorpej Exp $ */

/*-
 * Copyright (c) 2017, 2021, 2025 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Manuel Bouyer.
 *
 * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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 "iic.h"

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: acpi_i2c.c,v 1.23 2025/09/23 06:28:19 thorpej Exp $");

#include <sys/device.h>

#include <dev/acpi/acpireg.h>
#include <dev/acpi/acpivar.h>
#include <dev/acpi/acpi_i2c.h>
#include <external/bsd/acpica/dist/include/acinterp.h>
#include <external/bsd/acpica/dist/include/amlcode.h>

#include <dev/i2c/i2cvar.h>
#include <dev/i2c/i2c_calls.h>
#include <dev/i2c/i2c_enum.h>

#include <sys/kmem.h>

#define _COMPONENT	ACPI_BUS_COMPONENT
ACPI_MODULE_NAME	("acpi_i2c")

struct acpi_i2c_address_space_context {
	ACPI_CONNECTION_INFO conn_info;	/* must be first */
	i2c_tag_t tag;
};

static const struct device_compatible_entry hid_compat_data[] = {
	{ .compat = "PNP0C50" },
	DEVICE_COMPAT_EOL
};

#if NIIC > 0
struct acpi_i2c_context {
	uint16_t i2c_addr;
	struct acpi_devnode *res_src;
};
#endif

static struct acpi_devnode *
acpi_i2c_resource_find_source(ACPI_RESOURCE_SOURCE *rs)
{
	ACPI_STATUS rv;
	ACPI_HANDLE hdl;
	struct acpi_devnode *ad;

	if (rs->StringPtr == NULL) {
		return NULL;
	}

	rv = AcpiGetHandle(NULL, rs->StringPtr, &hdl);
	if (ACPI_FAILURE(rv)) {
		printf("%s: couldn't lookup '%s': %s\n", __func__,
		    rs->StringPtr, AcpiFormatException(rv));
		return NULL;
	}

	SIMPLEQ_FOREACH(ad, &acpi_softc->sc_head, ad_list) {
		if (ad->ad_handle == hdl) {
			return ad;
		}
	}

	printf("%s: no acpi devnode matching resource source '%s'\n",
	    __func__, rs->StringPtr);
	return NULL;
}

static ACPI_STATUS
acpi_i2c_resource_parse_callback(ACPI_RESOURCE *res, void *context)
{
	struct acpi_i2c_context *i2cc = context;

	switch (res->Type) {
	case ACPI_RESOURCE_TYPE_END_TAG:
		break;
	case ACPI_RESOURCE_TYPE_SERIAL_BUS:
		switch (res->Data.I2cSerialBus.Type) {
		case ACPI_RESOURCE_SERIAL_TYPE_I2C:
			i2cc->i2c_addr = res->Data.I2cSerialBus.SlaveAddress;
			i2cc->res_src = acpi_i2c_resource_find_source(
			    &res->Data.I2cSerialBus.ResourceSource);
			break;
		}
		break;
	case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
		break;
	default:
		break;
	}
	return_ACPI_STATUS(AE_OK);
}

static bool
acpi_i2c_enumerate_device(device_t dev, struct acpi_devnode *ad,
    struct i2c_enumerate_devices_args * const args)
{
	struct acpi_i2c_context i2cc;
	ACPI_STATUS rv;
	char *clist;
	size_t clist_size;
	bool cbrv;

	memset(&i2cc, 0, sizeof(i2cc));
	rv = AcpiWalkResources(ad->ad_handle, "_CRS",
	     acpi_i2c_resource_parse_callback, &i2cc);
	if (ACPI_FAILURE(rv)) {
		aprint_error_dev(dev,
		    "ACPI: unable to get resources for %s: %s\n",
		    ad->ad_name, AcpiFormatException(rv));
		return true;	/* keep enumerating */
	}
	if (i2cc.i2c_addr == 0) {
		return true;	/* keep enumerating */
	}

	clist = acpi_pack_compat_list(ad, &clist_size);
	if (clist == NULL) {
		aprint_error_dev(dev,
		    "ACPI: ignoring device %s (no _HID or _CID)\n",
		    ad->ad_name);
		return true;	/* keep enumerating */
	}

	cbrv = i2c_enumerate_device(dev, args, ad->ad_name,
	    clist, clist_size, i2cc.i2c_addr,
	    devhandle_from_acpi(device_handle(dev), ad->ad_handle));

	kmem_free(clist, clist_size);

	return cbrv;		/* callback decides if we keep enumerating */
}

static void
acpi_i2c_enumerate_hid_devs(device_t dev, struct acpi_devnode *devnode,
    struct i2c_enumerate_devices_args * const args)
{
	struct acpi_devnode *ad;

	KASSERT(dev != NULL);

	SIMPLEQ_FOREACH(ad, &acpi_softc->sc_head, ad_list) {
		struct acpi_attach_args aa = {
			.aa_node = ad
		};
		struct acpi_i2c_context i2cc;
		ACPI_STATUS rv;

		if (!acpi_device_present(ad->ad_handle))
			continue;
		/*
		 * We don't know why the caller is enumerating, so
		 * in addition to checking of the node hasn't been
		 * claimed, we check to see if it's been claimed by
		 * ourselves already and let those through as well.
		 */
		if (ad->ad_device != NULL && ad->ad_device != dev)
			continue;
		if (acpi_compatible_match(&aa, hid_compat_data) == 0)
			continue;

		memset(&i2cc, 0, sizeof(i2cc));
		rv = AcpiWalkResources(ad->ad_handle, "_CRS",
		    acpi_i2c_resource_parse_callback, &i2cc);
		if (ACPI_SUCCESS(rv) &&
		    i2cc.i2c_addr != 0 &&
		    i2cc.res_src == devnode) {
			aprint_debug_dev(dev, "claiming %s\n", ad->ad_name);
			ad->ad_device = dev;
			acpi_claim_childdevs(dev, ad, NULL);
			if (!acpi_i2c_enumerate_device(dev, ad, args))
				break;
		}
	}
}

static int
acpi_i2c_enumerate_devices(device_t dev, devhandle_t call_handle, void *v)
{
	struct i2c_enumerate_devices_args *args = v;
	ACPI_HANDLE *hdl = devhandle_to_acpi(device_handle(dev));
	struct acpi_devnode *ad, *devnode = acpi_match_node(hdl);

	KASSERT(dev != NULL);

	if (devnode == NULL) {
		aprint_error_dev(dev, "%s: no devnode matching handle\n",
		    __func__);
		return 0;
	}

	SIMPLEQ_FOREACH(ad, &devnode->ad_child_head, ad_child_list) {
		if (ad->ad_devinfo->Type != ACPI_TYPE_DEVICE)
			continue;
		if (!acpi_device_present(ad->ad_handle))
			continue;
		if (!acpi_i2c_enumerate_device(dev, ad, args))
			break;
	}

	acpi_claim_childdevs(dev, devnode, "_CRS");
	acpi_claim_childdevs(dev, devnode, "_ADR");

	/*
	 * I2C HID devices might not be children of the controller in the
	 * ACPI device tree; go look for those separately.
	 */
	acpi_i2c_enumerate_hid_devs(dev, devnode, args);

	return 0;
}
ACPI_DEVICE_CALL_REGISTER(I2C_ENUMERATE_DEVICES_STR,
			  acpi_i2c_enumerate_devices)

#if NIIC > 0
static ACPI_STATUS
acpi_i2c_gsb_init(ACPI_HANDLE region_hdl, UINT32 function,
    void *handler_ctx, void **region_ctx)
{
	if (function == ACPI_REGION_DEACTIVATE) {
		*region_ctx = NULL;
	} else {
		*region_ctx = region_hdl;
	}
	return AE_OK;
}

static ACPI_STATUS
acpi_i2c_gsb_handler(UINT32 function, ACPI_PHYSICAL_ADDRESS address,
    UINT32 bit_width, UINT64 *value, void *handler_ctx,
    void *region_ctx)
{
	ACPI_OPERAND_OBJECT *region_obj = region_ctx;
	struct acpi_i2c_address_space_context *context = handler_ctx;
	UINT8 *buf = ACPI_CAST_PTR(uint8_t, value);
	ACPI_PHYSICAL_ADDRESS base_address;
	ACPI_RESOURCE *res;
	ACPI_STATUS rv;
	ACPI_CONNECTION_INFO *conn_info = &context->conn_info;
	i2c_tag_t tag = context->tag;
	i2c_addr_t i2c_addr;
	i2c_op_t op;
	union {
		uint8_t cmd8;
		uint16_t cmd16;
		uint32_t cmd32;
	} cmd;
	size_t buflen;
	size_t cmdlen;
	bool do_xfer = true;

	if (region_obj->Region.Type != ACPI_TYPE_REGION) {
		return AE_OK;
	}

	base_address = region_obj->Region.Address;
	KASSERT(region_obj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS);

	rv = AcpiBufferToResource(conn_info->Connection, conn_info->Length,
	    &res);
	if (ACPI_FAILURE(rv)) {
		return rv;
	}
	if (res->Type != ACPI_RESOURCE_TYPE_SERIAL_BUS ||
	    res->Data.CommonSerialBus.Type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
		return AE_TYPE;
	}

	i2c_addr = res->Data.I2cSerialBus.SlaveAddress;
	if ((function & ACPI_IO_MASK) != 0) {
		op = I2C_OP_WRITE_WITH_STOP;
	} else {
		op = I2C_OP_READ_WITH_STOP;
	}

#ifdef ACPI_I2C_DEBUG
	UINT32 length;
	rv = AcpiExGetProtocolBufferLength(function >> 16, &length);
	if (ACPI_FAILURE(rv)) {
		printf("%s AcpiExGetProtocolBufferLength failed: %s\n",
		    __func__, AcpiFormatException(rv));
		length = UINT32_MAX;
	}
	printf("%s %s: %s Attr %X Addr %.4X BaseAddr %.4X Length %.2X BitWidth %X BufLen %X",
	       __func__, AcpiUtGetRegionName(region_obj->Region.SpaceId),
	       (function & ACPI_IO_MASK) ? "Write" : "Read ",
	       (UINT32) (function >> 16),
	       (UINT32) address, (UINT32) base_address,
	       length, bit_width, buf[1]);
	printf(" [AccessLength %.2X Connection %p]\n",
	       conn_info->AccessLength, conn_info->Connection);
#endif

	switch ((UINT32)(function >> 16)) {
	case AML_FIELD_ATTRIB_QUICK:
		cmdlen = 0;
		buflen = 0;
		break;
	case AML_FIELD_ATTRIB_SEND_RECEIVE:
		cmdlen = 0;
		buflen = 1;
		break;
	case AML_FIELD_ATTRIB_BYTE:
		cmdlen = bit_width / NBBY;
		buflen = 1;
		break;
	case AML_FIELD_ATTRIB_WORD:
		cmdlen = bit_width / NBBY;
		buflen = 2;
		break;
	case AML_FIELD_ATTRIB_BYTES:
		cmdlen = bit_width / NBBY;
		buflen = buf[1];
		break;
	case AML_FIELD_ATTRIB_BLOCK:
		cmdlen = bit_width / NBBY;
		buflen = buf[1];
		op |= I2C_OPMASK_BLKMODE;
		break;
	case AML_FIELD_ATTRIB_RAW_BYTES:
	case AML_FIELD_ATTRIB_RAW_PROCESS_BYTES:
	case AML_FIELD_ATTRIB_PROCESS_CALL:
	default:
		cmdlen = 0;
		do_xfer = false;
#ifdef ACPI_I2C_DEBUG
		printf("field attrib 0x%x not supported\n",
		    (UINT32)(function >> 16));
#endif
		break;
	}

	switch (cmdlen) {
	case 0:
	case 1:
		cmd.cmd8 = (uint8_t)(base_address + address);
		break;
	case 2:
		cmd.cmd16 = (uint16_t)(base_address + address);
		break;
	case 4:
		cmd.cmd32 = (uint32_t)(base_address + address);
		break;
	default:
		do_xfer = false;
#ifdef ACPI_I2C_DEBUG
		printf("cmdlen %zu not supported\n", cmdlen);
#endif
		break;
	}

	if (!do_xfer) {
		buf[0] = EINVAL;
	} else {
		const int flags = I2C_F_POLL;
		iic_acquire_bus(tag, flags);
		buf[0] = iic_exec(tag, op, i2c_addr,
				  &cmd, cmdlen, &buf[2], buflen, flags);
		iic_release_bus(tag, flags);
		if (buf[0] == 0) {
			buf[1] = buflen;
		}
#ifdef ACPI_I2C_DEBUG
		printf("%s iic_exec op %u addr 0x%x len %zu/%zu returned %d\n",
		    __func__, op, res->Data.I2cSerialBus.SlaveAddress, cmdlen,
		    buflen, buf[0]);
#endif
	}

	ACPI_FREE(res);

	return AE_OK;
}
#endif

void
acpi_i2c_register(device_t dev, i2c_tag_t tag)
{
#if NIIC > 0
	ACPI_HANDLE hdl = devhandle_to_acpi(device_handle(dev));
	struct acpi_i2c_address_space_context *context;
	ACPI_STATUS rv;

	context = kmem_zalloc(sizeof(*context), KM_SLEEP);
	context->tag = tag;

	rv = AcpiInstallAddressSpaceHandler(hdl,
	    ACPI_ADR_SPACE_GSBUS, acpi_i2c_gsb_handler, acpi_i2c_gsb_init,
	    context);
	if (ACPI_FAILURE(rv)) {
		aprint_error_dev(dev,
		    "couldn't install address space handler: %s",
		    AcpiFormatException(rv));
	}
#endif
}