/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2026 Abdelkader Boudih <dragonflybsd@seuros.com>
 *
 * Ported from FreeBSD's asmc(4) driver.
 *
 * DragonFlyBSD port: adapted for kmalloc/kfree, lockmgr 2-arg form,
 * taskqueue_start_threads ncpu arg, sys/bus_resource.h, acpica paths.
 * Added MMIO (T2) backend support.
 */

/*
 * Apple SMC — ISA port I/O backend.
 *
 * Low-level read/write/wait functions that talk to port 0x300, plus fan,
 * temperature, Sudden Motion Sensor helpers, and sensor-discovery utilities
 * shared by attach and the sysctl layer.
 */

#include "smc.h"

static int
apple_smc_wait_ack(device_t dev, uint8_t val, int amount)
{
	struct apple_smc_softc *sc = device_get_softc(dev);
	u_int i;

	val = val & ASMC_STATUS_MASK;
	for (i = 0; i < amount; i++) {
		if ((ASMC_CMDPORT_READ(sc) & ASMC_STATUS_MASK) == val)
			return (0);
		DELAY(10);
	}
	return (ETIMEDOUT);
}

int
apple_smc_wait(device_t dev, uint8_t val)
{
	if (apple_smc_wait_ack(dev, val, 1000) == 0)
		return (0);
#ifdef APPLE_SMC_DEBUG
	{
		struct apple_smc_softc *sc = device_get_softc(dev);
		device_printf(dev, "%s failed: 0x%x, 0x%x\n", __func__,
		    val & ASMC_STATUS_MASK, ASMC_CMDPORT_READ(sc));
	}
#endif
	return (ETIMEDOUT);
}

int
apple_smc_command(device_t dev, uint8_t command)
{
	int i;
	struct apple_smc_softc *sc = device_get_softc(dev);

	for (i = 0; i < 10; i++) {
		ASMC_CMDPORT_WRITE(sc, command);
		if (apple_smc_wait_ack(dev, 0x0c, 100) == 0)
			return (0);
	}
	return (EIO);
}

int
apple_smc_key_read(device_t dev, const char *key, uint8_t *buf, uint8_t len)
{
	struct apple_smc_softc *sc = device_get_softc(dev);
	int i, error = EIO, try = 0;

	if (sc->sc_is_mmio)
		return (apple_smc_mmio_key_read(dev, key, buf, len));

	SMC_LOCK(sc);

begin:
	if (apple_smc_command(dev, ASMC_CMDREAD))
		goto out;
	for (i = 0; i < 4; i++) {
		ASMC_DATAPORT_WRITE(sc, key[i]);
		if (apple_smc_wait(dev, 0x04))
			goto out;
	}
	ASMC_DATAPORT_WRITE(sc, len);
	for (i = 0; i < len; i++) {
		if (apple_smc_wait(dev, 0x05))
			goto out;
		buf[i] = ASMC_DATAPORT_READ(sc);
	}
	error = 0;
out:
	if (error) {
		if (++try < 10)
			goto begin;
		device_printf(dev, "%s for key %s failed %d times\n",
		    __func__, key, try);
	}
	SMC_UNLOCK(sc);
	return (error);
}

int
apple_smc_key_write(device_t dev, const char *key, uint8_t *buf, uint8_t len)
{
	struct apple_smc_softc *sc = device_get_softc(dev);
	int i, error = EIO, try = 0;

	if (sc->sc_is_mmio)
		return (apple_smc_mmio_key_write(dev, key, buf, len));

	SMC_LOCK(sc);

begin:
	if (apple_smc_command(dev, ASMC_CMDWRITE))
		goto out;
	for (i = 0; i < 4; i++) {
		ASMC_DATAPORT_WRITE(sc, key[i]);
		if (apple_smc_wait(dev, 0x04))
			goto out;
	}
	ASMC_DATAPORT_WRITE(sc, len);
	for (i = 0; i < len; i++) {
		if (apple_smc_wait(dev, 0x04))
			goto out;
		ASMC_DATAPORT_WRITE(sc, buf[i]);
	}
	error = 0;
out:
	if (error) {
		if (++try < 10)
			goto begin;
		device_printf(dev, "%s for key %s failed %d times\n",
		    __func__, key, try);
	}
	SMC_UNLOCK(sc);
	return (error);
}

int
apple_smc_key_getinfo(device_t dev, const char *key, uint8_t *len, char *type)
{
	struct apple_smc_softc *sc = device_get_softc(dev);
	uint8_t info[ASMC_KEYINFO_RESPLEN];
	int i, error = EIO, try = 0;

	if (sc->sc_is_mmio)
		return (apple_smc_mmio_key_getinfo(dev, key, len, type));

	SMC_LOCK(sc);

begin:
	if (apple_smc_command(dev, ASMC_CMDGETINFO))
		goto out;
	for (i = 0; i < ASMC_KEYLEN; i++) {
		ASMC_DATAPORT_WRITE(sc, key[i]);
		if (apple_smc_wait(dev, ASMC_STATUS_AWAIT_DATA))
			goto out;
	}
	ASMC_DATAPORT_WRITE(sc, ASMC_KEYINFO_RESPLEN);
	for (i = 0; i < ASMC_KEYINFO_RESPLEN; i++) {
		if (apple_smc_wait(dev, ASMC_STATUS_DATA_READY))
			goto out;
		info[i] = ASMC_DATAPORT_READ(sc);
	}
	error = 0;
out:
	if (error && ++try < ASMC_MAXRETRIES)
		goto begin;
	SMC_UNLOCK(sc);

	if (error == 0) {
		if (len != NULL)
			*len = info[0];
		if (type != NULL) {
			for (i = 0; i < ASMC_TYPELEN; i++)
				type[i] = info[i + 1];
			type[ASMC_TYPELEN] = '\0';
		}
	}
	return (error);
}

int
apple_smc_key_dump_by_index(device_t dev, int index, char *key_out,
    char *type_out, uint8_t *len_out)
{
	struct apple_smc_softc *sc = device_get_softc(dev);
	uint8_t index_buf[ASMC_KEYLEN];
	uint8_t key_buf[ASMC_KEYLEN];
	uint8_t info_buf[ASMC_KEYINFO_RESPLEN];
	int error = ENXIO, try = 0;
	int i;

	if (sc->sc_is_mmio) {
		error = apple_smc_mmio_key_getbyindex(dev, index, key_out);
		if (error != 0)
			return (error);
		return (apple_smc_mmio_key_getinfo(dev, key_out,
		    len_out, type_out));
	}

	SMC_LOCK(sc);

	index_buf[0] = (index >> 24) & 0xff;
	index_buf[1] = (index >> 16) & 0xff;
	index_buf[2] = (index >> 8) & 0xff;
	index_buf[3] = index & 0xff;

begin:
	if (apple_smc_command(dev, ASMC_CMDGETBYINDEX))
		goto out;
	for (i = 0; i < ASMC_KEYLEN; i++) {
		ASMC_DATAPORT_WRITE(sc, index_buf[i]);
		if (apple_smc_wait(dev, ASMC_STATUS_AWAIT_DATA))
			goto out;
	}
	ASMC_DATAPORT_WRITE(sc, ASMC_KEYLEN);
	for (i = 0; i < ASMC_KEYLEN; i++) {
		if (apple_smc_wait(dev, ASMC_STATUS_DATA_READY))
			goto out;
		key_buf[i] = ASMC_DATAPORT_READ(sc);
	}
	if (apple_smc_command(dev, ASMC_CMDGETINFO))
		goto out;
	for (i = 0; i < ASMC_KEYLEN; i++) {
		ASMC_DATAPORT_WRITE(sc, key_buf[i]);
		if (apple_smc_wait(dev, ASMC_STATUS_AWAIT_DATA))
			goto out;
	}
	ASMC_DATAPORT_WRITE(sc, ASMC_KEYINFO_RESPLEN);
	for (i = 0; i < ASMC_KEYINFO_RESPLEN; i++) {
		if (apple_smc_wait(dev, ASMC_STATUS_DATA_READY))
			goto out;
		info_buf[i] = ASMC_DATAPORT_READ(sc);
	}
	memcpy(key_out, key_buf, ASMC_KEYLEN);
	key_out[ASMC_KEYLEN] = '\0';
	if (len_out != NULL)
		*len_out = info_buf[0];
	if (type_out != NULL) {
		memcpy(type_out, &info_buf[1], ASMC_TYPELEN);
		type_out[ASMC_TYPELEN] = '\0';
	}
	error = 0;
out:
	if (error && ++try < ASMC_MAXRETRIES)
		goto begin;
	SMC_UNLOCK(sc);
	return (error);
}

/*
 * Retrieve key attributes byte (KEYINFO byte 5).
 */
int
apple_smc_key_getattrs(device_t dev, const char *key, uint8_t *attrs)
{
	struct apple_smc_softc *sc = device_get_softc(dev);
	uint8_t info[ASMC_KEYINFO_RESPLEN];
	int i, error = EIO, try = 0;

	if (sc->sc_is_mmio) {
		/* MMIO does not expose attrs; assume writable. */
		if (attrs != NULL)
			*attrs = ASMC_ATTR_WRITABLE;
		return (0);
	}

	SMC_LOCK(sc);

begin:
	if (apple_smc_command(dev, ASMC_CMDGETINFO))
		goto out;
	for (i = 0; i < ASMC_KEYLEN; i++) {
		ASMC_DATAPORT_WRITE(sc, key[i]);
		if (apple_smc_wait(dev, ASMC_STATUS_AWAIT_DATA))
			goto out;
	}
	ASMC_DATAPORT_WRITE(sc, ASMC_KEYINFO_RESPLEN);
	for (i = 0; i < ASMC_KEYINFO_RESPLEN; i++) {
		if (apple_smc_wait(dev, ASMC_STATUS_DATA_READY))
			goto out;
		info[i] = ASMC_DATAPORT_READ(sc);
	}
	error = 0;
out:
	if (error && ++try < ASMC_MAXRETRIES)
		goto begin;
	SMC_UNLOCK(sc);

	if (error == 0 && attrs != NULL)
		*attrs = info[5];	/* byte 5 is the attribute/flags byte */
	return (error);
}

int
apple_smc_key_search(device_t dev, const char *prefix, unsigned int *idx)
{
	struct apple_smc_softc *sc = device_get_softc(dev);
	unsigned int lo, hi, mid;
	char key[ASMC_KEYLEN + 1];
	char type[ASMC_TYPELEN + 1];
	uint8_t len;
	int error;

	lo = 0;
	hi = sc->sc_nkeys;
	while (lo < hi) {
		mid = lo + (hi - lo) / 2;
		error = apple_smc_key_dump_by_index(dev, mid, key, type, &len);
		if (error != 0)
			return (error);
		if (strncmp(key, prefix, ASMC_KEYLEN) < 0)
			lo = mid + 1;
		else
			hi = mid;
	}
	*idx = lo;
	return (0);
}

int
apple_smc_sensor_type_supported(const char *type)
{
	return (strncmp(type, "sp78", 4) == 0 ||
	    strncmp(type, "sp87", 4) == 0 ||
	    strncmp(type, "sp4b", 4) == 0 ||
	    strncmp(type, "sp5a", 4) == 0 ||
	    strncmp(type, "sp69", 4) == 0 ||
	    strncmp(type, "sp96", 4) == 0 ||
	    strncmp(type, "sp2d", 4) == 0 ||
	    strncmp(type, "ui16", 4) == 0);
}

int
apple_smc_sensor_read(device_t dev, const char *key, int *millivalue)
{
	uint8_t buf[2];
	char type[ASMC_TYPELEN + 1];
	uint8_t len;
	int error;
	int16_t sv;

	error = apple_smc_key_getinfo(dev, key, &len, type);
	if (error != 0 || len != 2)
		return (error ? error : ENXIO);

	error = apple_smc_key_read(dev, key, buf, sizeof(buf));
	if (error != 0)
		return (error);

	sv = (int16_t)be16dec(buf);

	if (strncmp(type, "sp78", 4) == 0)
		*millivalue = ((int)sv * 1000) / 256;
	else if (strncmp(type, "sp87", 4) == 0)
		*millivalue = ((int)sv * 1000) / 128;
	else if (strncmp(type, "sp4b", 4) == 0)
		*millivalue = ((int)sv * 1000) / 2048;
	else if (strncmp(type, "sp5a", 4) == 0)
		*millivalue = ((int)sv * 1000) / 1024;
	else if (strncmp(type, "sp69", 4) == 0)
		*millivalue = ((int)sv * 1000) / 512;
	else if (strncmp(type, "sp96", 4) == 0)
		*millivalue = ((int)sv * 1000) / 64;
	else if (strncmp(type, "sp2d", 4) == 0)
		*millivalue = ((int)sv * 1000) / 8192;
	else if (strncmp(type, "ui16", 4) == 0)
		*millivalue = be16dec(buf);
	else
		return (ENXIO);

	return (0);
}

void
apple_smc_scan_sensor_range(device_t dev, unsigned int start,
    unsigned int end, char prefix, int *countp, char **sensors, int maxcount)
{
	char key[ASMC_KEYLEN + 1];
	char type[ASMC_TYPELEN + 1];
	uint8_t len;
	unsigned int i;
	char *sensor_key;

	for (i = start; i < end; i++) {
		if (apple_smc_key_dump_by_index(dev, i, key, type, &len))
			continue;
		if (key[0] != prefix || len != 2)
			continue;
		if (!apple_smc_sensor_type_supported(type))
			continue;
		if (*countp >= maxcount)
			break;
		sensor_key = kmalloc(ASMC_KEYLEN + 1, M_DEVBUF, M_WAITOK);
		memcpy(sensor_key, key, ASMC_KEYLEN + 1);
		sensors[(*countp)++] = sensor_key;
	}
}

/* Fan */

int
apple_smc_fan_count(device_t dev)
{
	uint8_t buf[1];

	if (apple_smc_key_read(dev, ASMC_KEY_FANCOUNT, buf, sizeof(buf)) != 0)
		return (-1);
	return (buf[0]);
}

static uint32_t
apple_smc_float_to_u32(uint32_t d)
{
	int32_t exp;
	uint32_t fr;

	/*
	 * Sign bit set means negative RPM, which is physically impossible.
	 * Clamp to 0 rather than returning a garbage large value.
	 */
	if (d == 0 || (d >> 31) != 0)
		return (0);
	exp = (int32_t)((d >> 23) & 0xff) - 0x7f;
	fr = d & 0x7fffff;
	if (exp < 0) return (0);
	if (exp > 23) {
		if (exp > 30) return (0xffffffffu);
		return ((1u << exp) | (fr << (exp - 23)));
	}
	return ((1u << exp) + (fr >> (23 - exp)));
}

static uint32_t
apple_smc_u32_to_float(uint32_t d)
{
	uint32_t dc, bc, exp;

	if (d == 0) return (0);
	dc = d; bc = 0;
	while (dc >>= 1) ++bc;
	if (bc > 30) bc = 30;
	exp = 0x7f + bc;
	if (bc >= 23)
		return ((exp << 23) | ((d >> (bc - 23)) & 0x7fffff));
	else
		return ((exp << 23) | ((d << (23 - bc)) & 0x7fffff));
}

int
apple_smc_fan_getvalue(device_t dev, const char *key, int fan)
{
	struct apple_smc_softc *sc = device_get_softc(dev);
	uint8_t buf[4];
	char fankey[5];
	char type[ASMC_TYPELEN + 1];

	ksnprintf(fankey, sizeof(fankey), key, fan);

	if (sc->sc_is_t2 &&
	    apple_smc_key_getinfo(dev, fankey, NULL, type) == 0 &&
	    strncmp(type, "flt ", 4) == 0) {
		if (apple_smc_key_read(dev, fankey, buf, 4) != 0)
			return (-1);
		return ((int)apple_smc_float_to_u32(le32dec(buf)));
	}
	if (apple_smc_key_read(dev, fankey, buf, 2) != 0)
		return (-1);
	return ((buf[0] << 6) | (buf[1] >> 2));
}

/*
 * ASMC_FAN_NAME_OFFSET: the FxID key payload is an 8-byte struct where the
 * first 4 bytes are the key name echoed back (e.g. "F0ID") and bytes 4-7
 * hold the NUL-terminated fan model string.  Callers pass buflen >= 8.
 */
#define ASMC_FAN_NAME_OFFSET	4

char *
apple_smc_fan_getstring(device_t dev, const char *key, int fan,
    uint8_t *buf, uint8_t buflen)
{
	char fankey[5];

	ksnprintf(fankey, sizeof(fankey), key, fan);
	if (apple_smc_key_read(dev, fankey, buf, buflen) != 0)
		return (NULL);
	/* Skip the 4-byte key-name prefix embedded in the FxID payload. */
	return ((char *)buf + ASMC_FAN_NAME_OFFSET);
}

int
apple_smc_fan_setvalue(device_t dev, const char *key, int fan, int speed)
{
	struct apple_smc_softc *sc = device_get_softc(dev);
	uint8_t buf[4];
	char fankey[5];
	char type[ASMC_TYPELEN + 1];

	ksnprintf(fankey, sizeof(fankey), key, fan);

	if (sc->sc_is_t2 &&
	    apple_smc_key_getinfo(dev, fankey, NULL, type) == 0 &&
	    strncmp(type, "flt ", 4) == 0) {
		uint32_t fval;
		if (speed < 0) speed = 0;
		if (speed > 65535) speed = 65535;
		fval = apple_smc_u32_to_float((uint32_t)speed);
		le32enc(buf, fval);
		return (apple_smc_key_write(dev, fankey, buf, 4));
	}
	speed *= 4;
	buf[0] = speed >> 8;
	buf[1] = speed;
	return (apple_smc_key_write(dev, fankey, buf, 2));
}

/*
 * Read a temperature key and return millidegrees Celsius.  Delegate to the
 * generic sensor decoder so temperature sysctls and generic sensor sysctls
 * stay bit-for-bit consistent for sp78 and any future supported format.
 *
 * Returns -1 on read/decode failure (legacy callers already treat negative as
 * error).
 */
int
apple_smc_temp_getvalue(device_t dev, const char *key)
{
	int millivalue;
	int error;

	error = apple_smc_sensor_read(dev, key, &millivalue);
	if (error != 0)
		return (-1);
	return (millivalue);
}

/* Sudden Motion Sensor */

int
apple_smc_sms_read(device_t dev, const char *key, int16_t *val)
{
	uint8_t buf[2];
	int error;

	switch (key[3]) {
	case 'X': case 'Y': case 'Z':
		error = apple_smc_key_read(dev, key, buf, sizeof(buf));
		break;
	default:
		device_printf(dev, "%s called with invalid key %s\n",
		    __func__, key);
		return (EINVAL);
	}
	if (error == 0)
		*val = ((int16_t)buf[0] << 8) | buf[1];
	return (error);
}

void
apple_smc_sms_calibrate(device_t dev)
{
	struct apple_smc_softc *sc = device_get_softc(dev);

	apple_smc_sms_read(dev, ASMC_KEY_SMS_X, &sc->sms_rest_x);
	apple_smc_sms_read(dev, ASMC_KEY_SMS_Y, &sc->sms_rest_y);
	apple_smc_sms_read(dev, ASMC_KEY_SMS_Z, &sc->sms_rest_z);
}

void
apple_smc_sms_init(device_t dev)
{
	struct apple_smc_softc *sc = device_get_softc(dev);
	uint8_t buf[2];
	int i;
	int retry_ticks;
	int error;

	buf[0] = 0x01;
	error = apple_smc_key_write(dev, ASMC_KEY_INTOK, buf, 1);
	if (error != 0) {
		device_printf(dev, "sms init: INTOK write failed: %d\n", error);
	}
	DELAY(50);

	buf[0] = 20;
	error = apple_smc_key_write(dev, ASMC_KEY_SMS_LOW_INT, buf, 1);
	if (error != 0) {
		device_printf(dev, "sms init: MOLD write failed: %d\n", error);
	}
	DELAY(200);

	buf[0] = 20;
	error = apple_smc_key_write(dev, ASMC_KEY_SMS_HIGH_INT, buf, 1);
	if (error != 0) {
		device_printf(dev, "sms init: MOHD write failed: %d\n", error);
	}
	DELAY(200);

	buf[0] = 0x00;
	buf[1] = 0x60;
	error = apple_smc_key_write(dev, ASMC_KEY_SMS_LOW, buf, 2);
	if (error != 0) {
		device_printf(dev, "sms init: MOLT write failed: %d\n", error);
	}
	DELAY(200);

	buf[0] = 0x01;
	buf[1] = 0xc0;
	error = apple_smc_key_write(dev, ASMC_KEY_SMS_HIGH, buf, 2);
	if (error != 0) {
		device_printf(dev, "sms init: MOHT write failed: %d\n", error);
	}
	DELAY(200);

	buf[0] = 0x01;
	error = apple_smc_key_write(dev, ASMC_KEY_SMS_FLAG, buf, 1);
	if (error != 0) {
		device_printf(dev, "sms init: MSDW write failed: %d\n", error);
	}
	DELAY(100);

	retry_ticks = hz / 100;
	if (retry_ticks < 1) {
		retry_ticks = 1;
	}
	sc->sc_sms_intr_works = 0;
	for (i = 0; i < 5; i++) {
		if (apple_smc_key_read(dev, ASMC_KEY_SMS, buf, 2) == 0 &&
		    buf[0] == ASMC_SMS_INIT1 && buf[1] == ASMC_SMS_INIT2) {
			sc->sc_sms_intr_works = 1;
			goto done;
		}
		buf[0] = ASMC_SMS_INIT1;
		buf[1] = ASMC_SMS_INIT2;
		error = apple_smc_key_write(dev, ASMC_KEY_SMS, buf, 2);
		if (error != 0) {
			device_printf(dev, "sms init: MOCN write failed: %d\n",
			    error);
		}
		/*
		 * The old code busy-spun for 50 ms in attach.  Sleep instead:
		 * 5 retries at ~10 ms each on hz=100 preserves the same total
		 * wait budget without burning the CPU in early boot/attach.
		 */
		tsleep(sc, 0, "smsini", retry_ticks);
	}
	device_printf(dev, "WARNING: Sudden Motion Sensor not initialized!\n");
done:
	apple_smc_sms_calibrate(dev);
}

void
apple_smc_sms_intr(void *arg)
{
	device_t dev = (device_t)arg;
	struct apple_smc_softc *sc = device_get_softc(dev);
	uint8_t type;

	if (!sc->sc_sms_intr_works)
		return;

	SMC_LOCK(sc);
	type = ASMC_INTPORT_READ(sc);
	sc->sc_sms_intrtype = type;
	SMC_UNLOCK(sc);

	apple_smc_sms_printintr(dev, type);

	if (type == ASMC_ALSL_INT2A && sc->sc_has_alsl)
		return;

	taskqueue_enqueue(sc->sc_sms_tq, &sc->sc_sms_task);
}

void
apple_smc_sms_printintr(device_t dev, uint8_t type)
{
	struct apple_smc_softc *sc = device_get_softc(dev);

	switch (type) {
	case ASMC_SMS_INTFF:
		device_printf(dev, "WARNING: possible free fall!\n");
		break;
	case ASMC_SMS_INTHA:
		device_printf(dev, "WARNING: high acceleration detected!\n");
		break;
	case ASMC_SMS_INTSH:
		device_printf(dev, "WARNING: possible shock!\n");
		break;
	case ASMC_ALSL_INT2A:
		if (sc->sc_has_alsl)
			break;
		/* FALLTHROUGH */
	default:
		device_printf(dev, "unknown interrupt: 0x%x\n", type);
	}
}

void
apple_smc_sms_task(void *arg, int pending)
{
	struct apple_smc_softc *sc = (struct apple_smc_softc *)arg;
	char notify[16];
	int type;
	uint8_t intrtype;

	SMC_LOCK(sc);
	intrtype = sc->sc_sms_intrtype;
	SMC_UNLOCK(sc);

	switch (intrtype) {
	case ASMC_SMS_INTFF: type = 2; break;
	case ASMC_SMS_INTHA: type = 1; break;
	case ASMC_SMS_INTSH: type = 0; break;
	default:             type = 255; break;
	}
	ksnprintf(notify, sizeof(notify), " notify=0x%x", type);
	devctl_notify("ACPI", "apple_smc", "SMS", notify);
}