/*-
 * 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"

/* PCIe bridge for Thunderbolt */
#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/lock.h>
#include <sys/mutex.h>
#include <sys/malloc.h>
#include <sys/queue.h>
#include <sys/sbuf.h>
#include <sys/sysctl.h>
#include <sys/taskqueue.h>
#include <sys/gsb_crc32.h>
#include <sys/endian.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/tb_debug.h>

tb_string_t nhi_outmailcmd_opmode[] = {
	{ 0x000,	"Safe Mode" },
	{ 0x100,	"Authentication Mode" },
	{ 0x200,	"Endpoint Mode" },
	{ 0x300,	"Connection Manager Fully Functional" },
	{ 0, NULL }
};

tb_string_t nhi_frame_pdf[] = {
	{ 0x01, "PDF_READ" },
	{ 0x02, "PDF_WRITE" },
	{ 0x03, "PDF_NOTIFY" },
	{ 0x04, "PDF_NOTIFY_ACK" },
	{ 0x05, "PDF_HOTPLUG" },
	{ 0x06, "PDF_XDOMAIN_REQ" },
	{ 0x07, "PDF_XDOMAIN_RESP" },
	{ 0x0a, "PDF_CM_EVENT" },
	{ 0x0b, "PDF_CM_REQ" },
	{ 0x0c, "PDF_CM_RESP" },
	{ 0, NULL }
};

tb_string_t tb_security_level[] = {
	{ TBSEC_NONE,	"None" },
	{ TBSEC_USER,	"User" },
	{ TBSEC_SECURE,	"Secure Authorization" },
	{ TBSEC_DP,	"Display Port" },
	{ TBSEC_UNKNOWN,"Unknown" },
	{ 0, NULL }
};

tb_string_t tb_mbox_connmode[] = {
	{ INMAILCMD_SETMODE_CERT_TB_1ST_DEPTH, "Certified/1st" },
	{ INMAILCMD_SETMODE_ANY_TB_1ST_DEPTH,  "Any/1st"	},
	{ INMAILCMD_SETMODE_CERT_TB_ANY_DEPTH, "Certified/Any"	},
	{ INMAILCMD_SETMODE_ANY_TB_ANY_DEPTH,  "Any/Any"	},
	{ 0, NULL }
};

tb_string_t tb_device_power[] = {
	{ 0x0, "Self-powered" },
	{ 0x1, "Normal power" },
	{ 0x2, "High power" },
	{ 0x3, "Unknown power draw" },
	{ 0, NULL }
};

tb_string_t tb_notify_code[] = {
	{ 0x03, "DEVCONN" },
	{ 0x04, "DISCONN" },
	{ 0x05, "DPCONN" },
	{ 0x06, "DOMCONN" },
	{ 0x07, "DOMDISCONN" },
	{ 0x08, "DPCHANGE" },
	{ 0x09, "I2C" },
	{ 0x0a, "RTD3" },
	{ 0, NULL }
};

tb_string_t tb_adapter_type[] = {
	{ ADP_CS2_UNSUPPORTED, "Unsupported Adapter" },
	{ ADP_CS2_LANE, "Lane Adapter" },
	{ ADP_CS2_HOSTIF, "Host Interface Adapter" },
	{ ADP_CS2_PCIE_DFP, "Downstream PCIe Adapter" },
	{ ADP_CS2_PCIE_UFP, "Upstream PCIe Adapter" },
	{ ADP_CS2_DP_OUT, "DP OUT Adapter" },
	{ ADP_CS2_DP_IN, "DP IN Adapter" },
	{ ADP_CS2_USB3_DFP, "Downstream USB3 Adapter" },
	{ ADP_CS2_USB3_UFP, "Upstream USB3 Adapter" },
	{ 0, NULL }
};

tb_string_t tb_adapter_state[] = {
	{ CAP_LANE_STATE_DISABLE, "Disabled" },
	{ CAP_LANE_STATE_TRAINING, "Training" },
	{ CAP_LANE_STATE_CL0, "CL0" },
	{ CAP_LANE_STATE_TXCL0, "TX CL0s" },
	{ CAP_LANE_STATE_RXCL0, "RX CL0s" },
	{ CAP_LANE_STATE_CL1, "CL1" },
	{ CAP_LANE_STATE_CL2, "CL2" },
	{ CAP_LANE_STATE_CLD, "CLd" },
	{ 0, NULL }
};

tb_string_t tb_notify_event[] = {
	{ TB_CFG_ERR_CONN,	"Connection error" },
	{ TB_CFG_ERR_LINK,	"Link error" },
	{ TB_CFG_ERR_ADDR,	"Addressing error" },
	{ TB_CFG_ERR_ADP,	"Invalid adapter" },
	{ TB_CFG_ERR_ENUM,	"Enumeration error" },
	{ TB_CFG_ERR_NUA,	"Adapter not enumerated" },
	{ TB_CFG_ERR_LEN,	"Invalid request length" },
	{ TB_CFG_ERR_HEC,	"Invalid packet header" },
	{ TB_CFG_ERR_FC,	"Flow control error" },
	{ TB_CFG_ERR_PLUG,	"Hot plug error" },
	{ TB_CFG_ERR_LOCK,	"Adapter locked" },
	{ TB_CFG_HP_ACK,	"Hotplug acknowledgement" },
	{ TB_CFG_DP_BW,		"Display port bandwidth change" },
	{ 0, NULL }
};

const char *
tb_get_string(uintmax_t key, tb_string_t *table)
{

	if (table == NULL)
		return ("<null>");

	while (table->value != NULL) {
		if (table->key == key)
			return (table->value);
		table++;
	}

	return ("<unknown>");
}

static struct tb_debug_string {
	char *name;
	int flag;
} tb_debug_strings[] = {
	{"info", DBG_INFO},
	{"init", DBG_INIT},
	{"info", DBG_INFO},
	{"rxq", DBG_RXQ},
	{"txq", DBG_TXQ},
	{"intr", DBG_INTR},
	{"tb",	DBG_TB},
	{"mbox", DBG_MBOX},
	{"bridge", DBG_BRIDGE},
	{"cfg", DBG_CFG},
	{"router", DBG_ROUTER},
	{"port", DBG_PORT},
	{"hcm", DBG_HCM},
	{"extra", DBG_EXTRA},
	{"noisy", DBG_NOISY},
	{"full", DBG_FULL}
};

enum tb_debug_level_combiner {
	COMB_NONE,
	COMB_ADD,
	COMB_SUB
};

int
tb_debug_sysctl(SYSCTL_HANDLER_ARGS)
{
	struct sbuf *sbuf;
#if defined (THUNDERBOLT_DEBUG) && (THUNDERBOLT_DEBUG > 0)
	struct tb_debug_string *string;
	char *buffer;
	size_t sz;
	u_int *debug;
	int i, len;
#endif
	int error;

	error = sysctl_wire_old_buffer(req, 0);
	if (error != 0)
		return (error);

	sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req);

#if defined (THUNDERBOLT_DEBUG) && (THUNDERBOLT_DEBUG > 0)
	debug = (u_int *)arg1;

	sbuf_printf(sbuf, "%#x", *debug);

	sz = sizeof(tb_debug_strings) / sizeof(tb_debug_strings[0]);
	for (i = 0; i < sz; i++) {
		string = &tb_debug_strings[i];
		if (*debug & string->flag)
			sbuf_printf(sbuf, ",%s", string->name);
	}

	error = sbuf_finish(sbuf);
	sbuf_delete(sbuf);

	if (error || req->newptr == NULL)
		return (error);

	len = req->newlen - req->newidx;
	if (len == 0)
		return (0);

	buffer = malloc(len, M_THUNDERBOLT, M_ZERO|M_WAITOK);
	error = SYSCTL_IN(req, buffer, len);

	tb_parse_debug(debug, buffer);

	free(buffer, M_THUNDERBOLT);
#else
	sbuf_printf(sbuf, "debugging unavailable");
	error = sbuf_finish(sbuf);
	sbuf_delete(sbuf);
#endif

	return (error);
}

void
tb_parse_debug(u_int *debug, char *list)
{
	struct tb_debug_string *string;
	enum tb_debug_level_combiner op;
	char *token, *endtoken;
	size_t sz;
	int flags, i;

	if (list == NULL || *list == '\0')
		return;

	if (*list == '+') {
		op = COMB_ADD;
		list++;
	} else if (*list == '-') {
		op = COMB_SUB;
		list++;
	} else
		op = COMB_NONE;
	if (*list == '\0')
		return;

	flags = 0;
	sz = sizeof(tb_debug_strings) / sizeof(tb_debug_strings[0]);
	while ((token = strsep(&list, ":,")) != NULL) {

		/* Handle integer flags */
		flags |= strtol(token, &endtoken, 0);
		if (token != endtoken)
			continue;

		/* Handle text flags */
		for (i = 0; i < sz; i++) {
			string = &tb_debug_strings[i];
			if (strcasecmp(token, string->name) == 0) {
				flags |= string->flag;
				break;
			}
		}
	}

	switch (op) {
	case COMB_NONE:
		*debug = flags;
		break;
	case COMB_ADD:
		*debug |= flags;
		break;
	case COMB_SUB:
		*debug &= (~flags);
		break;
	}
	return;
}

void
tbdbg_dprintf(device_t dev, u_int debug, u_int val, const char *fmt, ...)
{
#if defined(THUNDERBOLT_DEBUG) && (THUNDERBOLT_DEBUG > 0)
	va_list ap;
	u_int lvl, dbg;

	lvl = debug & 0xc0000000;
	dbg = debug & 0x3fffffff;
	va_start(ap, fmt);
	if ((lvl >= (val & 0xc0000000)) &&
	    ((dbg & (val & 0x3fffffff)) != 0)) {
		device_printf(dev, "");
		vprintf(fmt, ap);
	}
	va_end(ap);
#endif
}