/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2022 Scott Long
 * All rights reserved.
 *
 * 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 AUTHOR 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 AUTHOR 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 "opt_thunderbolt.h"

/* Userspace control device for USB4 / TB3 */
#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/bus.h>
#include <sys/conf.h>
#include <sys/malloc.h>
#include <sys/queue.h>
#include <sys/sysctl.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#include <sys/nv.h>
#include <sys/taskqueue.h>
#include <sys/gsb_crc32.h>
#include <sys/endian.h>
#include <vm/vm.h>
#include <vm/pmap.h>

#include <machine/bus.h>
#include <machine/stdarg.h>

#include <dev/thunderbolt/nhi_reg.h>
#include <dev/thunderbolt/nhi_var.h>
#include <dev/thunderbolt/tb_reg.h>
#include <dev/thunderbolt/tb_var.h>
#include <dev/thunderbolt/tbcfg_reg.h>
#include <dev/thunderbolt/router_var.h>
#include <dev/thunderbolt/tb_debug.h>
#include <dev/thunderbolt/tb_dev.h>
#include <dev/thunderbolt/tb_ioctl.h>

struct tbdev_if;
struct tbdev_dm;
struct tbdev_rt;

struct tbdev_if {
	TAILQ_ENTRY(tbdev_if)	dev_next;
	char			name[SPECNAMELEN];
};

struct tbdev_dm {
	TAILQ_ENTRY(tbdev_dm)	dev_next;
	char			uid[16];
};

struct tbdev_rt {
	TAILQ_ENTRY(tbdev_rt)	dev_next;
	uint64_t		route;
};

static int tbdev_static_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *td);

static struct cdevsw tbdev_static_devsw = {
	.d_version = D_VERSION,
	.d_ioctl = tbdev_static_ioctl,
	.d_name = "tbt"
};
static struct cdev *tb_dev = NULL;

static TAILQ_HEAD(, tbdev_if) tbdev_head = TAILQ_HEAD_INITIALIZER(tbdev_head);
static TAILQ_HEAD(, tbdev_dm) tbdomain_head = TAILQ_HEAD_INITIALIZER(tbdomain_head);
static TAILQ_HEAD(, tbdev_rt) tbrouter_head = TAILQ_HEAD_INITIALIZER(tbrouter_head);

static struct mtx tbdev_mtx;
MTX_SYSINIT(tbdev_mtx, &tbdev_mtx, "TBT Device Mutex", MTX_DEF);

MALLOC_DEFINE(M_THUNDERBOLT, "thunderbolt", "memory for thunderbolt");

static void
tbdev_init(void *arg)
{

	tb_dev = make_dev(&tbdev_static_devsw, 0, UID_ROOT, GID_OPERATOR,
	    0644, TBT_DEVICE_NAME);
	if (tb_dev == NULL)
		printf("Cannot create Thunderbolt system device\n");

	return;
}

SYSINIT(tbdev_init, SI_SUB_KICK_SCHEDULER, SI_ORDER_FIRST, tbdev_init, NULL);

static void
tbdev_uninit(void *arg)
{
	if (tb_dev != NULL) {
		destroy_dev(tb_dev);
		tb_dev = NULL;
	}
}

SYSUNINIT(tbdev_uninit, SI_SUB_KICK_SCHEDULER, SI_ORDER_ANY, tbdev_uninit, NULL);

int
tbdev_add_interface(struct nhi_softc *nhi)
{
	struct tbdev_if *ifce;

	ifce = malloc(sizeof(struct tbdev_if), M_THUNDERBOLT, M_ZERO|M_NOWAIT);
	if (ifce == NULL)
		return (ENOMEM);

	strlcpy(ifce->name, device_get_nameunit(nhi->dev), SPECNAMELEN);
	mtx_lock(&tbdev_mtx);
	TAILQ_INSERT_TAIL(&tbdev_head, ifce, dev_next);
	mtx_unlock(&tbdev_mtx);

	return (0);
}

int
tbdev_remove_interface(struct nhi_softc *nhi)
{
	struct tbdev_if *ifce = NULL, *if_back;
	const char *name;

	name = device_get_nameunit(nhi->dev);
	mtx_lock(&tbdev_mtx);
	TAILQ_FOREACH_SAFE(ifce, &tbdev_head, dev_next, if_back) {
		if (strncmp(name, ifce->name, SPECNAMELEN) == 0) {
			TAILQ_REMOVE(&tbdev_head, ifce, dev_next);
			break;
		}
	}
	mtx_unlock(&tbdev_mtx);

	if (ifce != NULL)
		free(ifce, M_THUNDERBOLT);

	return (0);
}

int
tbdev_add_domain(void *domain)
{

	return (0);
}

int
tbdev_remove_domain(void *domain)
{

	return (0);
}

int
tbdev_add_router(struct router_softc *rt)
{

	return (0);
}

int
tbdev_remove_router(struct router_softc *rt)
{

	return (0);
}

static int
tbdev_discover(caddr_t addr)
{
	nvlist_t	*nvl = NULL;
	struct tbt_ioc	*ioc = (struct tbt_ioc *)addr;
	struct tbdev_if *dev;
	struct tbdev_dm	*dm;
	struct tbdev_rt	*rt;
	void		*nvlpacked = NULL;
	const char	*cmd = NULL;
	int		error = 0;

	if ((ioc->data == NULL) || (ioc->size == 0)) {
		printf("data or size is 0\n");
		return (EINVAL);
	}

	if ((ioc->len == 0) || (ioc->len > TBT_IOCMAXLEN) ||
	    (ioc->len > ioc->size)) {
		printf("len is wrong\n");
		return (EINVAL);
	}

	nvlpacked = malloc(ioc->len, M_THUNDERBOLT, M_NOWAIT);
	if (nvlpacked == NULL) {
		printf("cannot allocate nvlpacked\n");
		return (ENOMEM);
	}

	error = copyin(ioc->data, nvlpacked, ioc->len);
	if (error) {
		free(nvlpacked, M_THUNDERBOLT);
		printf("error %d from copyin\n", error);
		return (error);
	}

	nvl = nvlist_unpack(nvlpacked, ioc->len, NV_FLAG_NO_UNIQUE);
	if (nvl == NULL) {
		free(nvlpacked, M_THUNDERBOLT);
		printf("cannot unpack nvlist\n");
		return (EINVAL);
	}
	free(nvlpacked, M_THUNDERBOLT);
	nvlpacked = NULL;

	if (nvlist_exists_string(nvl, TBT_DISCOVER_TYPE))
		cmd = nvlist_get_string(nvl, TBT_DISCOVER_TYPE);
	if (cmd == NULL) {
		printf("cannot find type string\n");
		error = EINVAL;
		goto out;
	}

	mtx_lock(&tbdev_mtx);
	if (strncmp(cmd, TBT_DISCOVER_IFACE, TBT_NAMLEN) == 0) {
		TAILQ_FOREACH(dev, &tbdev_head, dev_next)
			nvlist_add_string(nvl, TBT_DISCOVER_IFACE, dev->name);
	} else if (strncmp(cmd, TBT_DISCOVER_DOMAIN, TBT_NAMLEN) == 0) {
		TAILQ_FOREACH(dm, &tbdomain_head, dev_next)
			nvlist_add_string(nvl, TBT_DISCOVER_DOMAIN, dm->uid);
	} else if (strncmp(cmd, TBT_DISCOVER_ROUTER, TBT_NAMLEN) == 0) {
		TAILQ_FOREACH(rt, &tbrouter_head, dev_next)
			nvlist_add_number(nvl, TBT_DISCOVER_ROUTER, rt->route);
	} else {
		printf("cannot find supported tpye\n");
		error = EINVAL;
		goto out;
	}
	mtx_unlock(&tbdev_mtx);

	error = nvlist_error(nvl);
	if (error != 0) {
		printf("error %d state in nvlist\n", error);
		return (error);
	}

	nvlpacked = nvlist_pack(nvl, &ioc->len);
	if (nvlpacked == NULL) {
		printf("cannot allocate new packed buffer\n");
		return (ENOMEM);
	}
	if (ioc->size < ioc->len) {
		printf("packed buffer is too big to copyout\n");
		return (ENOSPC);
	}

	error = copyout(nvlpacked, ioc->data, ioc->len);
	if (error)
		printf("error %d on copyout\n", error);

out:
	if (nvlpacked != NULL)
		free(nvlpacked, M_NVLIST);
	if (nvl != NULL)
		nvlist_destroy(nvl);

	return (error);
}

static int
tbdev_request(caddr_t addr)
{
	struct tbt_ioc	*ioc = (struct tbt_ioc *)addr;
	nvlist_t	*nvl = NULL;
	void		*nvlpacked = NULL;
	int		error = 0;

	if ((ioc->data == NULL) || (ioc->size == 0))
		return (ENOMEM);

	nvlpacked = nvlist_pack(nvl, &ioc->len);
	if (nvlpacked == NULL)
		return (ENOMEM);
	if (ioc->size < ioc->len)
		return (ENOSPC);

	error = copyout(nvlpacked, ioc->data, ioc->len);
	return (error);
}

static int
tbdev_static_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flags,
    struct thread *td)
{
	int error = 0;

	switch (cmd) {
	case TBT_DISCOVER:
		error = tbdev_discover(addr);
		break;
	case TBT_REQUEST:
		error = tbdev_request(addr);
		break;
	default:
		error = EINVAL;
	}

	return (error);
}