/*	$NetBSD: umcpmio_subr.c,v 1.4 2025/11/29 18:39:15 brad Exp $	*/

/*
 * Copyright (c) 2024 Brad Spencer <brad@anduin.eldar.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: umcpmio_subr.c,v 1.4 2025/11/29 18:39:15 brad Exp $");

#ifdef _KERNEL_OPT
#include "opt_usb.h"
#endif

#include <sys/param.h>
#include <sys/types.h>

#include <sys/conf.h>
#include <sys/device.h>
#include <sys/file.h>
#include <sys/kauth.h>
#include <sys/kernel.h>
#include <sys/kmem.h>
#include <sys/lwp.h>
#include <sys/sysctl.h>
#include <sys/systm.h>
#include <sys/tty.h>
#include <sys/vnode.h>

#include <dev/usb/umcpmio.h>
#include <dev/usb/umcpmio_transport.h>
#include <dev/usb/umcpmio_subr.h>
#include <dev/usb/umcpmio_hid_reports.h>

#define UMCPMIO_DEBUG 1
#ifdef UMCPMIO_DEBUG
#define DPRINTF(x)	do { if (umcpmiodebug) printf x; } while (0)
#define DPRINTFN(n, x)	do { if (umcpmiodebug > (n)) printf x; } while (0)
extern int umcpmiodebug;
#else
#define DPRINTF(x)	__nothing
#define DPRINTFN(n,x)	__nothing
#endif

/* Handy functions that do a bunch of things, very often they
 * don't fit anywhere else.
 */

void
WAITMS(int ms)
{
	if (ms > 0)
		delay(ms * 1000);
}

void
umcpmio_dump_buffer(bool enabled, uint8_t *buf, u_int len, const char *name)
{
	int i;

	if (enabled) {
		DPRINTF(("%s:", name));
		for (i = 0; i < len; i++) {
			DPRINTF((" %02x", buf[i]));
		}
		DPRINTF(("\n"));
	}
}


int
mcp2210_decode_errors(uint8_t request, int err, uint8_t general_result)
{
	int r = 0;

	if (err)
		return err;

	switch (general_result) {
	case MCP2210_CMD_COMPLETE_OK:
		break;
	case MCP2210_CMD_UNKNOWN:
		r = EINVAL;
		break;
	case MCP2210_CMD_ACCESS_REJECTED:
	case MCP2210_CMD_ACCESS_DENIED:
	case MCP2210_CMD_EEPROM_LOCKED:
		r = EPERM;
		break;
	case MCP2210_CMD_SPI_BUS_UNAVAIL:
	case MCP2210_CMD_USB_TRANSFER_IP:
		r = EBUSY;
		break;
	case MCP2210_CMD_EEPROM_FAIL:
	default:
		r = EIO;
	}

	return r;
}

int
mcp2221_get_status(struct umcpmio_softc *sc,
    struct mcp2221_status_res *res)
{
	struct mcp2221_status_req req;
	int err = 0;

	KASSERT(mutex_owned(&sc->sc_action_mutex));

	memset(&req, 0, MCP2221_REQ_BUFFER_SIZE);
	req.cmd = MCP2221_CMD_STATUS;

	err = umcpmio_send_report(sc,
	    (uint8_t *) & req, MCP2221_REQ_BUFFER_SIZE,
	    (uint8_t *) res, sc->sc_cv_wait);

	return err;
}

int
mcp2210_get_status(struct umcpmio_softc *sc,
    struct mcp2210_status_res *res)
{
	struct mcp2210_status_req req;
	int err = 0;

	KASSERT(mutex_owned(&sc->sc_action_mutex));

	memset(&req, 0, MCP2210_REQ_BUFFER_SIZE);
	req.cmd = MCP2210_CMD_STATUS;

	err = umcpmio_send_report(sc,
	    (uint8_t *) & req, MCP2210_REQ_BUFFER_SIZE,
	    (uint8_t *) res, sc->sc_cv_wait);

	err = mcp2210_decode_errors(req.cmd, err, res->completion);

	return err;
}

int
mcp2221_put_status(struct umcpmio_softc *sc,
    struct mcp2221_status_req *req, struct mcp2221_status_res *res)
{
	int err = 0;

	KASSERT(mutex_owned(&sc->sc_action_mutex));

	req->cmd = MCP2221_CMD_STATUS;

	err = umcpmio_send_report(sc,
	    (uint8_t *) req, MCP2221_REQ_BUFFER_SIZE,
	    (uint8_t *) res, sc->sc_cv_wait);

	return err;
}

int
mcp2221_get_sram(struct umcpmio_softc *sc,
    struct mcp2221_get_sram_res *res)
{
	struct mcp2221_get_sram_req req;
	int err = 0;

	KASSERT(mutex_owned(&sc->sc_action_mutex));

	memset(&req, 0, MCP2221_REQ_BUFFER_SIZE);
	req.cmd = MCP2221_CMD_GET_SRAM;

	err = umcpmio_send_report(sc,
	    (uint8_t *) & req, MCP2221_REQ_BUFFER_SIZE,
	    (uint8_t *) res, sc->sc_cv_wait);

	return err;
}

int
mcp2221_put_sram(struct umcpmio_softc *sc,
    struct mcp2221_set_sram_req *req, struct mcp2221_set_sram_res *res)
{
	int err = 0;

	KASSERT(mutex_owned(&sc->sc_action_mutex));

	req->cmd = MCP2221_CMD_SET_SRAM;

	err = umcpmio_send_report(sc,
	    (uint8_t *) req, MCP2221_REQ_BUFFER_SIZE,
	    (uint8_t *) res, sc->sc_cv_wait);

	return err;
}

int
mcp2210_get_nvram(struct umcpmio_softc *sc, uint8_t subcode,
    struct mcp2210_get_nvram_res *res)
{
	struct mcp2210_get_nvram_req req;
	int err = 0;

	KASSERT(mutex_owned(&sc->sc_action_mutex));

	memset(&req, 0, MCP2210_REQ_BUFFER_SIZE);
	req.cmd = MCP2210_CMD_GET_NVRAM;

	if (subcode < MCP2210_NVRAM_SUBCODE_SPI ||
	    subcode > MCP2210_NVRAM_SUBCODE_USBMAN)
		return EINVAL;

	req.subcode = subcode;

	err = umcpmio_send_report(sc,
	    (uint8_t *) & req, MCP2210_REQ_BUFFER_SIZE,
	    (uint8_t *) res, sc->sc_cv_wait);

	err = mcp2210_decode_errors(req.cmd, err, res->completion);

	return err;
}

int
mcp2210_set_nvram(struct umcpmio_softc *sc, struct mcp2210_set_nvram_req *req,
    struct mcp2210_set_nvram_res *res)
{
	int err = 0;

	KASSERT(mutex_owned(&sc->sc_action_mutex));

	req->cmd = MCP2210_CMD_SET_NVRAM;

	if (req->subcode < MCP2210_NVRAM_SUBCODE_SPI ||
	    req->subcode > MCP2210_NVRAM_SUBCODE_USBMAN) {
		DPRINTF(("mcp2210_set_nvram: subcode out of range:"
		    " subcode=%d\n",
		    req->subcode));
		return EINVAL;
	}
	err = umcpmio_send_report(sc,
	    (uint8_t *) req, MCP2210_REQ_BUFFER_SIZE,
	    (uint8_t *) res, sc->sc_cv_wait);

	err = mcp2210_decode_errors(req->cmd, err, res->completion);

	return err;
}

int
mcp2221_get_flash(struct umcpmio_softc *sc, uint8_t subcode,
    struct mcp2221_get_flash_res *res)
{
	struct mcp2221_get_flash_req req;
	int err = 0;

	KASSERT(mutex_owned(&sc->sc_action_mutex));

	memset(&req, 0, MCP2221_REQ_BUFFER_SIZE);
	req.cmd = MCP2221_CMD_GET_FLASH;

	if (subcode < MCP2221_FLASH_SUBCODE_CS ||
	    subcode > MCP2221_FLASH_SUBCODE_CHIPSN)
		return EINVAL;

	req.subcode = subcode;

	err = umcpmio_send_report(sc,
	    (uint8_t *) & req, MCP2221_REQ_BUFFER_SIZE,
	    (uint8_t *) res, sc->sc_cv_wait);

	return err;
}

int
mcp2221_put_flash(struct umcpmio_softc *sc, struct mcp2221_put_flash_req *req,
    struct mcp2221_put_flash_res *res)
{
	int err = 0;

	KASSERT(mutex_owned(&sc->sc_action_mutex));

	req->cmd = MCP2221_CMD_SET_FLASH;

	if (req->subcode < MCP2221_FLASH_SUBCODE_CS ||
	    req->subcode > MCP2221_FLASH_SUBCODE_CHIPSN) {
		DPRINTF(("mcp2221_put_flash: subcode out of range:"
		    " subcode=%d\n",
		    req->subcode));
		return EINVAL;
	}
	err = umcpmio_send_report(sc,
	    (uint8_t *) req, MCP2221_REQ_BUFFER_SIZE,
	    (uint8_t *) res, sc->sc_cv_wait);

	return err;
}

int
mcp2210_read_eeprom(struct umcpmio_softc *sc, uint8_t addr, uint8_t *buf)
{
	struct mcp2210_read_eeprom_req req;
	struct mcp2210_read_eeprom_res res;
	int err = 0;

	req.cmd = MCP2210_CMD_READ_EEPROM;
	req.addr = addr;

	mutex_enter(&sc->sc_action_mutex);
	err = umcpmio_send_report(sc,
	    (uint8_t *) & req, MCP2210_REQ_BUFFER_SIZE,
	    (uint8_t *) & res, sc->sc_cv_wait);
	mutex_exit(&sc->sc_action_mutex);

	err = mcp2210_decode_errors(req.cmd, err, res.completion);

	if (!err)
		*buf = res.value;

	return err;
}

int
mcp2210_write_eeprom(struct umcpmio_softc *sc, uint8_t addr, uint8_t buf)
{
	struct mcp2210_write_eeprom_req req;
	struct mcp2210_write_eeprom_res res;
	int err = 0;

	req.cmd = MCP2210_CMD_WRITE_EEPROM;
	req.addr = addr;
	req.value = buf;

	mutex_enter(&sc->sc_action_mutex);
	err = umcpmio_send_report(sc,
	    (uint8_t *) & req, MCP2210_REQ_BUFFER_SIZE,
	    (uint8_t *) & res, sc->sc_cv_wait);
	mutex_exit(&sc->sc_action_mutex);

	err = mcp2210_decode_errors(req.cmd, err, res.completion);

	return err;
}