/* $NetBSD: fdt_iommu.c,v 1.1 2021/09/04 12:34:39 jmcneill Exp $ */

/*-
 * Copyright (c) 2021 Jared McNeill <jmcneill@invisible.ca>
 * 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 ``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 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 <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: fdt_iommu.c,v 1.1 2021/09/04 12:34:39 jmcneill Exp $");

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/kmem.h>
#include <sys/queue.h>

#include <libfdt.h>
#include <dev/fdt/fdtvar.h>

struct fdtbus_iommu {
	device_t			iommu_dev;
	int				iommu_phandle;
	const struct fdtbus_iommu_func	*iommu_funcs;
	u_int				iommu_cells;
	LIST_ENTRY(fdtbus_iommu)	iommu_next;
};

static LIST_HEAD(, fdtbus_iommu) fdtbus_iommus =
    LIST_HEAD_INITIALIZER(fdtbus_iommus);

/*
 * fdtbus_get_iommu --
 *
 *	Return the iommu registered with the specified node, or NULL if
 *	not found.
 */
static struct fdtbus_iommu *
fdtbus_get_iommu(int phandle)
{
	struct fdtbus_iommu *iommu;

	LIST_FOREACH(iommu, &fdtbus_iommus, iommu_next) {
		if (iommu->iommu_phandle == phandle) {
			return iommu;
		}
	}

	return NULL;
}

/*
 * fdtbus_register_iommu --
 *
 *	Register an IOMMU on the specified node.
 */
int
fdtbus_register_iommu(device_t dev, int phandle,
    const struct fdtbus_iommu_func *funcs)
{
	struct fdtbus_iommu *iommu;
	u_int cells;

	if (funcs == NULL || funcs->map == NULL) {
		return EINVAL;
	}

	if (of_getprop_uint32(phandle, "#iommu-cells", &cells) != 0) {
		return ENXIO;
	}

	if (fdtbus_get_iommu(phandle) != NULL) {
		return EEXIST;
	}

	iommu = kmem_alloc(sizeof(*iommu), KM_SLEEP);
	iommu->iommu_dev = dev;
	iommu->iommu_phandle = phandle;
	iommu->iommu_funcs = funcs;
	iommu->iommu_cells = cells;

	LIST_INSERT_HEAD(&fdtbus_iommus, iommu, iommu_next);

	return 0;
}

/*
 * fdtbus_iommu_map --
 *
 *	Get a bus dma tag that is translated by any iommus specified by
 *	the device tree. The `index` property refers to the N-th item
 *	in the list of IOMMUs specified in the "iommus" property. If an
 *	IOMMU is not found, the original bus dma tag is returned.
 */
bus_dma_tag_t
fdtbus_iommu_map(int phandle, u_int index, bus_dma_tag_t dmat)
{
	struct fdtbus_iommu *iommu;
	const u_int *p;
	u_int n, cells;
	int len, resid;

	p = fdtbus_get_prop(phandle, "iommus", &len);
	if (p == NULL) {
		return dmat;
	}

	for (n = 0, resid = len; resid > 0; n++) {
		const int iommu_phandle =
		    fdtbus_get_phandle_from_native(be32toh(p[0]));
		if (of_getprop_uint32(iommu_phandle, "#iommu-cells", &cells)) {
			break;
		}
		if (n == index) {
			iommu = fdtbus_get_iommu(iommu_phandle);
			if (iommu == NULL) {
				break;
			}
			return iommu->iommu_funcs->map(iommu->iommu_dev,
			    cells > 0 ? &p[1] : NULL, dmat);
		}
		resid -= (cells + 1) * 4;
		p += cells + 1;
	}

	return dmat;
}

/*
 * fdtbus_iommu_map_pci --
 *
 *	Get a bus dma tag that is translated by any iommus specified by
 *	the device tree for PCI devices. The `rid` param is the requester
 *	ID. Returns a (maybe translated) dma tag.
 */
bus_dma_tag_t
fdtbus_iommu_map_pci(int phandle, uint32_t rid, bus_dma_tag_t dmat)
{
	struct fdtbus_iommu *iommu;
	uint32_t map_mask;
	const u_int *p;
	u_int cells;
	int len;

	len = 0;
	p = fdtbus_get_prop(phandle, "iommu-map", &len);
	KASSERT(p != NULL || len == 0);

	if (of_getprop_uint32(phandle, "iommu-map-mask", &map_mask) == 0) {
		rid &= map_mask;
	}

	while (len >= 4) {
		const u_int rid_base = be32toh(*p++);
		const int iommu_phandle =
		    fdtbus_get_phandle_from_native(be32toh(*p++));
		const u_int iommu_base = be32toh(*p++);
		const u_int length = be32toh(*p++);
		len -= 4;

		if (iommu_phandle <= 0) {
			continue;
		}
		if (of_getprop_uint32(iommu_phandle, "#iommu-cells", &cells)) {
			continue;
		}
		if (cells != 1) {
			/*
			 * The pci-iommu bindings expect iommu references with
			 * exactly one specifier cell.
			 */
			continue;
		}
		iommu = fdtbus_get_iommu(iommu_phandle);
		if (iommu == NULL) {
			continue;
		}

		if (rid >= rid_base && rid < rid_base + length) {
			const uint32_t sid = rid - rid_base + iommu_base;
			return iommu->iommu_funcs->map(iommu->iommu_dev,
			    &sid, dmat);
		}
	}

	return dmat;
}