xref: /freebsd/sys/dev/thunderbolt/hcm.c (revision 2ed9833791f28e14843ac813f90cb030e45948dc)

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

/* Host Configuration Manager (HCM) for USB4 and later 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/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/tb_debug.h>
#include <dev/thunderbolt/tbcfg_reg.h>
#include <dev/thunderbolt/router_var.h>
#include <dev/thunderbolt/hcm_var.h>

static void hcm_cfg_task(void *, int);

int
hcm_attach(struct nhi_softc *nsc)
{
	struct hcm_softc *hcm;

	tb_debug(nsc, DBG_HCM|DBG_EXTRA, "hcm_attach called\n");

	hcm = malloc(sizeof(struct hcm_softc), M_THUNDERBOLT, M_NOWAIT|M_ZERO);
	if (hcm == NULL) {
		tb_debug(nsc, DBG_HCM, "Cannot allocate hcm object\n");
		return (ENOMEM);
	}

	hcm->dev = nsc->dev;
	hcm->nsc = nsc;
	nsc->hcm = hcm;

	hcm->taskqueue = taskqueue_create("hcm_event", M_NOWAIT,
	    taskqueue_thread_enqueue, &hcm->taskqueue);
	if (hcm->taskqueue == NULL)
		return (ENOMEM);
	taskqueue_start_threads(&hcm->taskqueue, 1, PI_DISK, "tbhcm%d_tq",
	    device_get_unit(nsc->dev));
	TASK_INIT(&hcm->cfg_task, 0, hcm_cfg_task, hcm);

	return (0);
}

int
hcm_detach(struct nhi_softc *nsc)
{
	struct hcm_softc *hcm;

	hcm = nsc->hcm;
	if (hcm->taskqueue)
		taskqueue_free(hcm->taskqueue);

	return (0);
}

int
hcm_router_discover(struct hcm_softc *hcm)
{

	taskqueue_enqueue(hcm->taskqueue, &hcm->cfg_task);

	return (0);
}

static void
hcm_cfg_task(void *arg, int pending)
{
	struct hcm_softc *hcm;
	struct router_softc *rsc;
	struct router_cfg_cap cap;
	struct tb_cfg_router *cfg;
	struct tb_cfg_adapter *adp;
	struct tb_cfg_cap_lane *lane;
	uint32_t *buf;
	uint8_t *u;
	u_int error, i, offset;

	hcm = (struct hcm_softc *)arg;

	tb_debug(hcm, DBG_HCM|DBG_EXTRA, "hcm_cfg_task called\n");

	buf = malloc(8 * 4, M_THUNDERBOLT, M_NOWAIT|M_ZERO);
	if (buf == NULL) {
		tb_debug(hcm, DBG_HCM, "Cannot alloc memory for discovery\n");
		return;
	}

	rsc = hcm->nsc->root_rsc;
	error = tb_config_router_read(rsc, 0, 5, buf);
	if (error != 0) {
		free(buf, M_NHI);
		return;
	}

	cfg = (struct tb_cfg_router *)buf;

	cap.space = TB_CFG_CS_ROUTER;
	cap.adap = 0;
	cap.next_cap = GET_ROUTER_CS_NEXT_CAP(cfg);
	while (cap.next_cap != 0) {
		error = tb_config_next_cap(rsc, &cap);
		if (error != 0)
			break;

		if ((cap.cap_id == TB_CFG_CAP_VSEC) && (cap.vsc_len == 0)) {
			tb_debug(hcm, DBG_HCM, "Router Cap= %d, vsec= %d, "
			    "len= %d, next_cap= %d\n", cap.cap_id,
			    cap.vsc_id, cap.vsec_len, cap.next_cap);
		} else if (cap.cap_id == TB_CFG_CAP_VSC) {
			tb_debug(hcm, DBG_HCM, "Router cap= %d, vsc= %d, "
			    "len= %d, next_cap= %d\n", cap.cap_id,
			    cap.vsc_id, cap.vsc_len, cap.next_cap);
		} else
			tb_debug(hcm, DBG_HCM, "Router cap= %d, "
			    "next_cap= %d\n", cap.cap_id, cap.next_cap);
		if (cap.next_cap > TB_CFG_CAP_OFFSET_MAX)
			cap.next_cap = 0;
	}

	u = (uint8_t *)buf;
	error = tb_config_get_lc_uuid(rsc, u);
	if (error == 0) {
		tb_debug(hcm, DBG_HCM, "Router LC UUID: %02x%02x%02x%02x-"
		    "%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n",
		    u[0], u[1], u[2], u[3], u[4], u[5], u[6], u[7], u[8],
		    u[9], u[10], u[11], u[12], u[13], u[14], u[15]);
	} else
		tb_printf(hcm, "Error finding LC registers: %d\n", error);

	for (i = 1; i <= rsc->max_adap; i++) {
		error = tb_config_adapter_read(rsc, i, 0, 8, buf);
		if (error != 0) {
			tb_debug(hcm, DBG_HCM, "Adapter %d: no adapter\n", i);
			continue;
		}
		adp = (struct tb_cfg_adapter *)buf;
		tb_debug(hcm, DBG_HCM, "Adapter %d: %s, max_counters= 0x%08x,"
		    " adapter_num= %d\n", i,
		    tb_get_string(GET_ADP_CS_TYPE(adp), tb_adapter_type),
		    GET_ADP_CS_MAX_COUNTERS(adp), GET_ADP_CS_ADP_NUM(adp));

		if (GET_ADP_CS_TYPE(adp) != ADP_CS2_LANE)
			continue;

		error = tb_config_find_adapter_cap(rsc, i, TB_CFG_CAP_LANE,
		    &offset);
		if (error)
			continue;

		error = tb_config_adapter_read(rsc, i, offset, 3, buf);
		if (error)
			continue;

		lane = (struct tb_cfg_cap_lane *)buf;
		tb_debug(hcm, DBG_HCM, "Lane Adapter State= %s %s\n",
		    tb_get_string((lane->current_lws & CAP_LANE_STATE_MASK),
		    tb_adapter_state), (lane->targ_lwp & CAP_LANE_DISABLE) ?
		    "disabled" : "enabled");

		if ((lane->current_lws & CAP_LANE_STATE_MASK) ==
		    CAP_LANE_STATE_CL0) {
			tb_route_t newr;

			newr.hi = rsc->route.hi;
			newr.lo = rsc->route.lo | (i << rsc->depth * 8);

			tb_printf(hcm, "want to add router at 0x%08x%08x\n",
			    newr.hi, newr.lo);
			error = tb_router_attach(rsc, newr);
			tb_printf(rsc, "tb_router_attach returned %d\n", error);
		}
	}

	free(buf, M_THUNDERBOLT);
}