/*
 * Copyright (C) 2020, Red Hat Inc, Eric Auger <eric.auger@redhat.com>
 *
 * This work is licensed under the terms of the GNU LGPL, version 2.
 */
#include <asm/gic.h>
#include <alloc_page.h>

void its_parse_typer(void)
{
	u64 typer = readq(gicv3_its_base() + GITS_TYPER);
	struct its_typer *t = &its_data.typer;

	t->ite_size = ((typer & GITS_TYPER_ITT_ENTRY_SIZE) >> GITS_TYPER_ITT_ENTRY_SIZE_SHIFT) + 1;
	t->pta = typer & GITS_TYPER_PTA;
	t->eventid_bits = ((typer & GITS_TYPER_IDBITS) >> GITS_TYPER_IDBITS_SHIFT) + 1;
	t->deviceid_bits = ((typer & GITS_TYPER_DEVBITS) >> GITS_TYPER_DEVBITS_SHIFT) + 1;

	if (typer & GITS_TYPER_CIL)
		t->collid_bits = ((typer & GITS_TYPER_CIDBITS) >> GITS_TYPER_CIDBITS_SHIFT) + 1;
	else
		t->collid_bits = 16;

	t->virt_lpi = typer & GITS_TYPER_VLPIS;
	t->phys_lpi = typer & GITS_TYPER_PLPIS;
}

int its_baser_lookup(int type, struct its_baser *baser)
{
	int i;

	for (i = 0; i < GITS_BASER_NR_REGS; i++) {
		void *reg_addr = gicv3_its_base() + GITS_BASER + i * 8;
		u64 val = readq(reg_addr);

		if (GITS_BASER_TYPE(val) == type) {
			assert((val & GITS_BASER_PAGE_SIZE_MASK) == GITS_BASER_PAGE_SIZE_64K);
			baser->esz = GITS_BASER_ENTRY_SIZE(val);
			baser->indirect = val & GITS_BASER_INDIRECT;
			baser->index = i;
			return 0;
		}
	}
	return -1;
}

/*
 * Allocate the BASER table (a single page of size @baser->psz)
 * and set the BASER valid
 */
static void its_baser_alloc_table(struct its_baser *baser, size_t size)
{
	unsigned long order = get_order(size >> PAGE_SHIFT);
	void *reg_addr = gicv3_its_base() + GITS_BASER + baser->index * 8;
	u64 val = readq(reg_addr);

	baser->table_addr = alloc_pages(order);

	val |= virt_to_phys(baser->table_addr) | GITS_BASER_VALID;

	writeq(val, reg_addr);
}

/*
 * init_cmd_queue - Allocate the command queue and initialize
 * CBASER, CWRITER
 */
static void its_cmd_queue_init(void)
{
	unsigned long order = get_order(SZ_64K >> PAGE_SHIFT);
	u64 cbaser;

	its_data.cmd_base = alloc_pages(order);

	cbaser = virt_to_phys(its_data.cmd_base) | (SZ_64K / SZ_4K - 1) | GITS_CBASER_VALID;

	writeq(cbaser, its_data.base + GITS_CBASER);

	its_data.cmd_write = its_data.cmd_base;
	writeq(0, its_data.base + GITS_CWRITER);
}

void its_init(void)
{
	if (!its_data.base)
		return;

	its_parse_typer();

	assert(!its_baser_lookup(GITS_BASER_TYPE_DEVICE, &its_data.device_baser));
	assert(!its_baser_lookup(GITS_BASER_TYPE_COLLECTION, &its_data.coll_baser));

	its_baser_alloc_table(&its_data.device_baser, SZ_64K);
	its_baser_alloc_table(&its_data.coll_baser, SZ_64K);

	its_cmd_queue_init();
}

/* must be called after gicv3_enable_defaults */
void its_enable_defaults(void)
{
	int cpu;

	/* Allocate LPI config and pending tables */
	gicv3_lpi_alloc_tables();

	for_each_present_cpu(cpu)
		gicv3_lpi_rdist_enable(cpu);

	writel(GITS_CTLR_ENABLE, its_data.base + GITS_CTLR);
}

struct its_device *its_create_device(u32 device_id, int nr_ites)
{
	struct its_device *new;
	unsigned long n;

	assert(its_data.nr_devices < GITS_MAX_DEVICES);

	new = &its_data.devices[its_data.nr_devices];

	new->device_id = device_id;
	new->nr_ites = nr_ites;

	n = (its_data.typer.ite_size * nr_ites) >> PAGE_SHIFT;
	new->itt = alloc_pages(get_order(n));

	its_data.nr_devices++;
	return new;
}

struct its_collection *its_create_collection(u16 col_id, u32 pe)
{
	struct its_collection *new;

	assert(its_data.nr_collections < GITS_MAX_COLLECTIONS);

	new = &its_data.collections[its_data.nr_collections];

	new->col_id = col_id;

	if (its_data.typer.pta)
		new->target_address = (u64)gicv3_data.redist_base[pe];
	else
		new->target_address = pe << 16;

	its_data.nr_collections++;
	return new;
}

struct its_device *its_get_device(u32 id)
{
	int i;

	for (i = 0; i < GITS_MAX_DEVICES; i++) {
		if (its_data.devices[i].device_id == id)
			return &its_data.devices[i];
	}
	assert(0);
}

struct its_collection *its_get_collection(u32 id)
{
	int i;

	for (i = 0; i < GITS_MAX_COLLECTIONS; i++) {
		if (its_data.collections[i].col_id == id)
			return &its_data.collections[i];
	}
	assert(0);
}