/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2025 Oxide Computer Company
 */

/*
 * i2cadm scan -- scan a single port for devices. By default all devices are
 * scanned under the port, unless a specific set of devices is specified.
 */

#include <err.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <sys/sysmacros.h>
#include <ofmt.h>

#include "i2cadm.h"

void
i2cadm_scan_usage(FILE *f)
{
	(void) fprintf(f, "\ti2cadm scan [-d dev] [-o field,[...] [-H] [-p]] "
	    "<port>\n");
}

static void
i2cadm_scan_help(const char *fmt, ...)
{
	if (fmt != NULL) {
		va_list ap;

		va_start(ap, fmt);
		vwarnx(fmt, ap);
		va_end(ap);
	}

	(void) fprintf(stderr, "Usage:  i2cadm scan [-d dev] [-o field,[...] "
	    "[-H] [-p]] <port>\n");
	(void) fprintf(stderr, "\nScan for I2C devices\n\n"
	    "\t-d dev\t\tonly scan device address dev, can be specified "
	    "multiple\n\t\t\ttimes\n"
	    "\t-H\t\tomit the column header (requires -o)\n"
	    "\t-o field\toutput fields to print\n"
	    "\t-p\t\tparseable output (requires -o)\n");
	(void) fprintf(stderr, "\nThe following fields are supported when "
	    "using -o:\n"
	    "\taddr\t\tthe I2C address\n"
	    "\tresult\t\tthe address scan result\n"
	    "\terror\t\tthe error message if an error occurred\n");
}

typedef enum {
	I2CADM_BUS_SCAN_UNKNOWN = 0,
	I2CADM_BUS_SCAN_FOUND,
	I2CADM_BUS_SCAN_NO_DEV,
	I2CADM_BUS_SCAN_RESERVED,
	I2CADM_BUS_SCAN_TIMEOUT,
	I2CADM_BUS_SCAN_ERROR,
	I2CADM_BUS_SCAN_SKIPPED
} i2cadm_scan_result_t;

typedef struct {
	i2c_addr_t scan_addr;
	i2cadm_scan_result_t scan_res;
	char *scan_error;
} i2cadm_scan_t;

static void
i2cadm_scan_error(i2c_hdl_t *hdl, i2cadm_scan_t *scan)
{
	i2c_err_t err = i2c_err(hdl);
	if (err != I2C_ERR_CONTROLLER) {
		scan->scan_res = I2CADM_BUS_SCAN_ERROR;
		scan->scan_error = strdup(i2c_errmsg(hdl));
		if (scan->scan_error == NULL) {
			scan->scan_error = "libi2c error; but failed to "
			    "duplicate libi2c error message";
		}
		return;
	}

	switch (i2c_ctrl_err(hdl)) {
	case I2C_CTRL_E_ADDR_NACK:
	case I2C_CTRL_E_DATA_NACK:
	case I2C_CTRL_E_NACK:
		scan->scan_res = I2CADM_BUS_SCAN_NO_DEV;
		break;
	case I2C_CTRL_E_REQ_TO:
		scan->scan_res = I2CADM_BUS_SCAN_TIMEOUT;
		break;
	default:
		scan->scan_res = I2CADM_BUS_SCAN_ERROR;
		scan->scan_error = strdup(i2c_errmsg(hdl));
		if (scan->scan_error == NULL) {
			scan->scan_error = "i2c controller error; but "
			    "failed to duplicate libi2c error message";
		}
		break;
	}
}

/*
 * One does not simply scan an i2c device. In essence, we're trying to perform
 * some I/O such that it will ack an address, but without causing the device to
 * wreak havoc. Given the plethora of devices that are out there, this may not
 * be possible. Safety cannot be guaranteed by construction.
 *
 * We basically do a one byte read from the device. Most devices will respond to
 * this. The alternative that some other tools have done is to try to perform an
 * SMBus Quick action.
 */
static void
i2cadm_scan_one(i2c_hdl_t *hdl, i2c_port_t *port, i2cadm_scan_t *scan)
{
	i2c_io_req_t *req;
	uint8_t data = 0x77;

	if (!i2c_io_req_init(port, &req)) {
		i2cadm_fatal("failed to initialize I/O request");
	}

	if (!i2c_io_req_set_addr(req, &scan->scan_addr)) {
		i2cadm_fatal("failed to set scan address");
	}

	if (!i2c_io_req_set_receive_buf(req, &data, sizeof (data))) {
		i2cadm_fatal("failed to set receive buffer");
	}

	if (i2c_io_req_exec(req)) {
		scan->scan_res = I2CADM_BUS_SCAN_FOUND;
	} else {
		i2cadm_scan_error(hdl, scan);
	}

	i2c_io_req_fini(req);
}

typedef enum {
	I2CADM_SCAN_ADDR,
	I2CADM_SCAN_RESULT,
	I2CADM_SCAN_ERROR
} i2cadm_scan_otype_t;

static boolean_t
i2cadm_scan_ofmt_cb(ofmt_arg_t *ofarg, char *buf, uint_t buflen)
{
	const i2cadm_scan_t *scan = ofarg->ofmt_cbarg;
	const char *str;
	size_t len;

	switch (ofarg->ofmt_id) {
	case I2CADM_SCAN_ADDR:
		len = snprintf(buf, buflen, "0x%x", scan->scan_addr.ia_addr);
		break;
	case I2CADM_SCAN_RESULT:
		switch (scan->scan_res) {
		case I2CADM_BUS_SCAN_FOUND:
			str = "found";
			break;
		case I2CADM_BUS_SCAN_NO_DEV:
			str = "missing";
			break;
		case I2CADM_BUS_SCAN_RESERVED:
			str = "reserved";
			break;
		case I2CADM_BUS_SCAN_TIMEOUT:
			str = "timeout";
			break;
		case I2CADM_BUS_SCAN_ERROR:
			str = "error";
			break;
		case I2CADM_BUS_SCAN_SKIPPED:
			str = "skipped";
			break;
		default:
			str = "unknown";
			break;
		}
		len = strlcpy(buf, str, buflen);
		break;
	case I2CADM_SCAN_ERROR:
		if (scan->scan_error != NULL) {
			len = strlcpy(buf, scan->scan_error, buflen);
		} else {
			len = strlcpy(buf, "-", buflen);
		}
		break;
	default:
		return (B_FALSE);
	}

	return (len < buflen);
}

static const ofmt_field_t i2cadm_scan_ofmt[] = {
	{ "ADDR", 8, I2CADM_SCAN_ADDR, i2cadm_scan_ofmt_cb },
	{ "RESULT", 16, I2CADM_SCAN_RESULT, i2cadm_scan_ofmt_cb },
	{ "ERROR", 40, I2CADM_SCAN_ERROR, i2cadm_scan_ofmt_cb },
	{ NULL, 0, 0, NULL }
};

/*
 * We can fit 16 devices on a line.
 */
#define	SCAN_DEVS_PER_LINE	0x10

static const char *key = ""
"\t- = No Device      @ = Device Found\n"
"\tR = Reserved       S = Skipped\n"
"\tX = Timed Out    Err = Error\n";

static bool
i2cadm_scan_table_cb(void *arg, uint16_t i)
{
	const i2cadm_scan_t *results = arg;
	const char *msgs[] = { "???", "@", "-", "R", "X", "Err", "S" };

	(void) printf("%3s", msgs[results[i].scan_res]);

	return (results[i].scan_res == I2CADM_BUS_SCAN_ERROR);
}

static void
i2cadm_scan_table_post(void *arg, uint16_t max_addr)
{
	const i2cadm_scan_t *results = arg;
	(void) printf("\nErrors\n");
	for (uint16_t i = 0; i < max_addr; i++) {
		if (results[i].scan_res != I2CADM_BUS_SCAN_ERROR)
			continue;

		if (max_addr > UINT8_MAX) {
			(void) printf("0x%03x: %s\n", i, results[i].scan_error);
		} else {
			(void) printf("0x%02x: %s\n", i, results[i].scan_error);
		}
	}
}

int
i2cadm_scan(int argc, char *argv[])
{
	int c;
	i2c_port_t *port;
	bool ten_bit = false;
	uint16_t max_addr = 1 << 7;
	i2cadm_scan_t *results;
	uint16_t *dev_addrs = NULL;
	size_t naddrs = 0, nalloc = 0;
	boolean_t parse = B_FALSE;
	uint_t flags = 0;
	const char *fields = NULL;
	ofmt_status_t oferr;
	ofmt_handle_t ofmt;

	/*
	 * In the future we should consider -T for 10-bit addressing.
	 */
	while ((c = getopt(argc, argv, ":d:Ho:p")) != -1) {
		switch (c) {
		case 'd': {
			if (naddrs == nalloc) {
				nalloc += 8;
				dev_addrs = recallocarray(dev_addrs, naddrs,
				    nalloc, sizeof (uint16_t));
				if (dev_addrs == NULL) {
					err(EXIT_FAILURE, "failed to allocate "
					    "memory for %zu I2C addresses",
					    nalloc);
				}
			}

			const char *err;
			long long l = strtonumx(optarg, 0, max_addr - 1, &err,
			    0);
			if (err != NULL) {
				errx(EXIT_FAILURE, "invalid device address %s: "
				    "address is %s", optarg, err);
			}
			dev_addrs[naddrs] = (uint16_t)l;
			naddrs++;
			break;
		}
		case 'H':
			flags |= OFMT_NOHEADER;
			break;
		case 'o':
			fields = optarg;
			break;
		case 'p':
			parse = B_TRUE;
			flags |= OFMT_PARSABLE;
			break;
		case ':':
			i2cadm_scan_help("option -%c requires an argument",
			    optopt);
			exit(EXIT_USAGE);
		case '?':
			i2cadm_scan_help("unknown option: -%c", optopt);
			exit(EXIT_USAGE);
		}
	}

	argv += optind;
	argc -= optind;
	if (argc == 0) {
		errx(EXIT_USAGE, "missing required port to scan");
	} else if (argc > 1) {
		errx(EXIT_USAGE, "encountered extraneous arguments starting "
		    "with %s", argv[1]);
	}

	if (parse && fields == NULL) {
		errx(EXIT_USAGE, "-p requires fields specified with -o");
	}

	if (flags != 0 && fields == NULL) {
		errx(EXIT_USAGE, "-H can only be used with -o");
	}

	if (fields != NULL) {
		if (!parse) {
			flags |= OFMT_WRAP;
		}

		oferr = ofmt_open(fields, i2cadm_scan_ofmt, flags, 0,
		    &ofmt);
		ofmt_check(oferr, parse, ofmt, i2cadm_ofmt_errx, warnx);
	}

	if (!i2c_port_init_by_path(i2cadm.i2c_hdl, argv[0], &port)) {
		i2cadm_fatal("failed to parse port path %s", argv[0]);
	}

	results = calloc(max_addr, sizeof (i2cadm_scan_t));
	if (results == NULL) {
		err(EXIT_FAILURE, "failed to allocate scan results tracking "
		    "structure");
	}

	/*
	 * If we have a specific device list, then mark everything skipped and
	 * come back and mark the specific instances we care about as things to
	 * check.
	 */
	if (dev_addrs != NULL) {
		for (uint16_t i = 0; i < max_addr; i++) {
			results[i].scan_res = I2CADM_BUS_SCAN_SKIPPED;
		}

		for (uint16_t i = 0; i < naddrs; i++) {
			results[dev_addrs[i]].scan_res =
			    I2CADM_BUS_SCAN_UNKNOWN;
		}
	}

	for (uint16_t i = 0; i < max_addr; i++) {
		i2cadm_scan_t *scan = &results[i];

		scan->scan_addr.ia_type = ten_bit ? I2C_ADDR_10BIT :
		    I2C_ADDR_7BIT;
		scan->scan_addr.ia_addr = i;

		if (scan->scan_res == I2CADM_BUS_SCAN_SKIPPED)
			continue;

		/*
		 * Determine if this is a reserved address or not.
		 */
		if (i2c_addr_reserved(&scan->scan_addr)) {
			scan->scan_res = I2CADM_BUS_SCAN_RESERVED;
			continue;
		}

		i2cadm_scan_one(i2cadm.i2c_hdl, port, scan);
	}

	if (fields == NULL) {
		i2cadm_table_t table = {
			.table_port = argv[0],
			.table_key = key,
			.table_msg = "Device scan on",
			.table_max = max_addr,
			.table_cb = i2cadm_scan_table_cb,
			.table_post = i2cadm_scan_table_post
		};
		i2cadm_print_table(&table, results);
	} else {
		for (uint16_t i = 0; i < max_addr; i++) {
			ofmt_print(ofmt, &results[i]);
		}
		ofmt_close(ofmt);
	}

	for (uint16_t i = 0; i < max_addr; i++) {
		free(results[i].scan_error);
	}
	free(results);
	i2c_port_fini(port);
	return (EXIT_SUCCESS);
}