/*	$OpenBSD: htb.c,v 1.3 2017/05/10 15:21:02 visa Exp $	*/

/*
 * Copyright (c) 2016 Visa Hankala
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/*
 * PCI host bridge driver for Loongson 3A.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>

#include <machine/autoconf.h>
#include <machine/loongson3.h>

#include <dev/pci/pcidevs.h>
#include <dev/pci/pcireg.h>
#include <dev/pci/pcivar.h>
#include <dev/pci/ppbreg.h>

#include <loongson/dev/htbreg.h>
#include <loongson/dev/htbvar.h>

struct htb_softc {
	struct device		 sc_dev;
	struct mips_pci_chipset	 sc_pc;
	const struct htb_config	*sc_config;
};

int	 htb_match(struct device *, void *, void *);
void	 htb_attach(struct device *, struct device *, void *);
int	 htb_print(void *, const char *);

void	 htb_attach_hook(struct device *, struct device *,
	    struct pcibus_attach_args *pba);
int	 htb_bus_maxdevs(void *, int);
pcitag_t htb_make_tag(void *, int, int, int);
void	 htb_decompose_tag(void *, pcitag_t, int *, int *, int *);
int	 htb_conf_addr(const struct bonito_config *, pcitag_t, int,
	    u_int32_t *, u_int32_t *);
int	 htb_conf_size(void *, pcitag_t);
pcireg_t htb_conf_read(void *, pcitag_t, int);
void	 htb_conf_write(void *, pcitag_t, int, pcireg_t);
int	 htb_pci_intr_map(struct pci_attach_args *, pci_intr_handle_t *);
const char *
	 htb_pci_intr_string(void *, pci_intr_handle_t);
void	*htb_pci_intr_establish(void *, pci_intr_handle_t, int,
	    int (*)(void *), void *, char *);
void	 htb_pci_intr_disestablish(void *, void *);

bus_addr_t htb_pa_to_device(paddr_t);
paddr_t	 htb_device_to_pa(bus_addr_t);

int	 htb_io_map(bus_space_tag_t, bus_addr_t, bus_size_t, int,
	    bus_space_handle_t *);
int	 htb_mem_map(bus_space_tag_t, bus_addr_t, bus_size_t, int,
	    bus_space_handle_t *);
paddr_t	 htb_mem_mmap(bus_space_tag_t, bus_addr_t, off_t, int, int);

paddr_t	 htb_cfg_space_addr(pcitag_t, int);

pcireg_t htb_conf_read_early(pcitag_t, int);
pcitag_t htb_make_tag_early(int, int, int);

const struct cfattach htb_ca = {
	sizeof(struct htb_softc), htb_match, htb_attach
};

struct cfdriver htb_cd = {
	NULL, "htb", DV_DULL
};

struct machine_bus_dma_tag htb_bus_dma_tag = {
	._dmamap_create = _dmamap_create,
	._dmamap_destroy = _dmamap_destroy,
	._dmamap_load = _dmamap_load,
	._dmamap_load_mbuf = _dmamap_load_mbuf,
	._dmamap_load_uio = _dmamap_load_uio,
	._dmamap_load_raw = _dmamap_load_raw,
	._dmamap_load_buffer = _dmamap_load_buffer,
	._dmamap_unload = _dmamap_unload,
	._dmamap_sync = _dmamap_sync,
	._dmamem_alloc = _dmamem_alloc,
	._dmamem_free = _dmamem_free,
	._dmamem_map = _dmamem_map,
	._dmamem_unmap = _dmamem_unmap,
	._dmamem_mmap = _dmamem_mmap,

	._pa_to_device = htb_pa_to_device,
	._device_to_pa = htb_device_to_pa
};

struct mips_bus_space htb_pci_io_space_tag = {
	.bus_base = PHYS_TO_XKPHYS(HTB_IO_BASE, CCA_NC),
	._space_read_1 = generic_space_read_1,
	._space_write_1 = generic_space_write_1,
	._space_read_2 = generic_space_read_2,
	._space_write_2 = generic_space_write_2,
	._space_read_4 = generic_space_read_4,
	._space_write_4 = generic_space_write_4,
	._space_read_8 = generic_space_read_8,
	._space_write_8 = generic_space_write_8,
	._space_read_raw_2 = generic_space_read_raw_2,
	._space_write_raw_2 = generic_space_write_raw_2,
	._space_read_raw_4 = generic_space_read_raw_4,
	._space_write_raw_4 = generic_space_write_raw_4,
	._space_read_raw_8 = generic_space_read_raw_8,
	._space_write_raw_8 = generic_space_write_raw_8,
	._space_map = htb_io_map,
	._space_unmap = generic_space_unmap,
	._space_subregion = generic_space_region,
	._space_vaddr = generic_space_vaddr,
	._space_mmap = generic_space_mmap
};

struct mips_bus_space htb_pci_mem_space_tag = {
	.bus_base = PHYS_TO_XKPHYS(0, CCA_NC),
	._space_read_1 = generic_space_read_1,
	._space_write_1 = generic_space_write_1,
	._space_read_2 = generic_space_read_2,
	._space_write_2 = generic_space_write_2,
	._space_read_4 = generic_space_read_4,
	._space_write_4 = generic_space_write_4,
	._space_read_8 = generic_space_read_8,
	._space_write_8 = generic_space_write_8,
	._space_read_raw_2 = generic_space_read_raw_2,
	._space_write_raw_2 = generic_space_write_raw_2,
	._space_read_raw_4 = generic_space_read_raw_4,
	._space_write_raw_4 = generic_space_write_raw_4,
	._space_read_raw_8 = generic_space_read_raw_8,
	._space_write_raw_8 = generic_space_write_raw_8,
	._space_map = htb_mem_map,
	._space_unmap = generic_space_unmap,
	._space_subregion = generic_space_region,
	._space_vaddr = generic_space_vaddr,
	._space_mmap = htb_mem_mmap
};

int
htb_match(struct device *parent, void *match, void *aux)
{
	struct mainbus_attach_args *maa = aux;

	if (loongson_ver != 0x3a && loongson_ver != 0x3b)
		return 0;

	if (strcmp(maa->maa_name, htb_cd.cd_name) != 0)
		return 0;

	return 1;
}

void
htb_attach(struct device *parent, struct device *self, void *aux)
{
	struct pcibus_attach_args pba;
	struct htb_softc *sc = (struct htb_softc *)self;
	pci_chipset_tag_t pc = &sc->sc_pc;

	printf("\n");

	sc->sc_config = sys_platform->htb_config;

	pc->pc_conf_v = sc;
	pc->pc_attach_hook = htb_attach_hook;
	pc->pc_bus_maxdevs = htb_bus_maxdevs;
	pc->pc_make_tag = htb_make_tag;
	pc->pc_decompose_tag = htb_decompose_tag;
	pc->pc_conf_size = htb_conf_size;
	pc->pc_conf_read = htb_conf_read;
	pc->pc_conf_write = htb_conf_write;

	pc->pc_intr_v = sc;
	pc->pc_intr_map = htb_pci_intr_map;
	pc->pc_intr_string = htb_pci_intr_string;
	pc->pc_intr_establish = htb_pci_intr_establish;
	pc->pc_intr_disestablish = htb_pci_intr_disestablish;

	memset(&pba, 0, sizeof(pba));
	pba.pba_busname = "pci";
	pba.pba_iot = &htb_pci_io_space_tag;
	pba.pba_memt = &htb_pci_mem_space_tag;
	pba.pba_dmat = &htb_bus_dma_tag;
	pba.pba_pc = pc;
	pba.pba_ioex = extent_create("htb_io", 0, 0xffffffff, M_DEVBUF,
	    NULL, 0, EX_NOWAIT | EX_FILLED);
	if (pba.pba_ioex != NULL) {
		extent_free(pba.pba_ioex, 0, HTB_IO_SIZE, EX_NOWAIT);
	}
	pba.pba_memex = extent_create("htb_mem", 0, 0xffffffff, M_DEVBUF,
	    NULL, 0, EX_NOWAIT | EX_FILLED);
	if (pba.pba_memex != NULL) {
		extent_free(pba.pba_memex, HTB_MEM_BASE, HTB_MEM_SIZE,
		    EX_NOWAIT);
	}
	pba.pba_domain = pci_ndomains++;
	pba.pba_bus = 0;
	config_found(&sc->sc_dev, &pba, htb_print);
}

int
htb_print(void *aux, const char *pnp)
{
	struct pcibus_attach_args *pba = aux;

	if (pnp)
		printf("%s at %s", pba->pba_busname, pnp);
	printf(" bus %d", pba->pba_bus);

	return UNCONF;
}

void
htb_attach_hook(struct device *parent, struct device *self,
    struct pcibus_attach_args *pba)
{
	pci_chipset_tag_t pc = pba->pba_pc;
	struct htb_softc *sc = pc->pc_conf_v;
	const struct htb_config *hc = sc->sc_config;

	if (pba->pba_bus == 0)
		hc->hc_attach_hook(pc);
}

int
htb_bus_maxdevs(void *v, int busno)
{
	return 32;
}

pcitag_t
htb_make_tag(void *unused, int b, int d, int f)
{
	return (b << 16) | (d << 11) | (f << 8);
}

void
htb_decompose_tag(void *unused, pcitag_t tag, int *bp, int *dp, int *fp)
{
	if (bp != NULL)
		*bp = (tag >> 16) & 0xff;
	if (dp != NULL)
		*dp = (tag >> 11) & 0x1f;
	if (fp != NULL)
		*fp = (tag >> 8) & 0x7;
}

int
htb_conf_addr(const struct bonito_config *bc, pcitag_t tag, int offset,
    u_int32_t *cfgoff, u_int32_t *pcimap_cfg)
{
	return -1;
}

int
htb_conf_size(void *v, pcitag_t tag)
{
	return PCIE_CONFIG_SPACE_SIZE;
}

pcireg_t
htb_conf_read(void *v, pcitag_t tag, int offset)
{
	return REGVAL(htb_cfg_space_addr(tag, offset));
}

void
htb_conf_write(void *v, pcitag_t tag, int offset, pcireg_t data)
{
	REGVAL(htb_cfg_space_addr(tag, offset)) = data;
}

paddr_t
htb_cfg_space_addr(pcitag_t tag, int offset)
{
	paddr_t pa;
	int bus;

	htb_decompose_tag(NULL, tag, &bus, NULL, NULL);
	if (bus == 0)
		pa = HTB_CFG_TYPE0_BASE;
	else
		pa = HTB_CFG_TYPE1_BASE;
	return pa + tag + (offset & 0xfffc);
}

/*
 * PCI interrupt handling
 */

int
htb_pci_intr_map(struct pci_attach_args *pa, pci_intr_handle_t *ihp)
{
	int dev, pin;

	*ihp = (pci_intr_handle_t)-1;

	if (pa->pa_intrpin == 0)
		return 1;

	if (pa->pa_intrpin > PCI_INTERRUPT_PIN_MAX) {
		printf(": bad interrupt pin %d\n", pa->pa_intrpin);
		return 1;
	}

	pci_decompose_tag(pa->pa_pc, pa->pa_tag, NULL, &dev, NULL);
	if (pa->pa_bridgetag != NULL) {
		pin = PPB_INTERRUPT_SWIZZLE(pa->pa_rawintrpin, dev);
		if (pa->pa_bridgeih[pin - 1] != (pci_intr_handle_t)-1) {
			*ihp = pa->pa_bridgeih[pin - 1];
			return 0;
		}
	}

	if (pa->pa_intrline != 0) {
		*ihp = pa->pa_intrline;
		return 0;
	}

	return 1;
}

const char *
htb_pci_intr_string(void *cookie, pci_intr_handle_t ih)
{
	static char irqstr[16];

	snprintf(irqstr, sizeof(irqstr), "irq %lu", ih);
	return irqstr;
}

void *
htb_pci_intr_establish(void *cookie, pci_intr_handle_t ih, int level,
    int (*cb)(void *), void *cbarg, char *name)
{
	return loongson3_ht_intr_establish(ih, level, cb, cbarg, name);
}

void
htb_pci_intr_disestablish(void *cookie, void *ihp)
{
	loongson3_ht_intr_disestablish(ihp);
}

bus_addr_t
htb_pa_to_device(paddr_t pa)
{
	return pa ^ loongson_dma_base;
}

paddr_t
htb_device_to_pa(bus_addr_t addr)
{
	return addr ^ loongson_dma_base;
}

/*
 * bus_space(9) mapping routines
 */

int
htb_io_map(bus_space_tag_t t, bus_addr_t offs, bus_size_t size, int flags,
    bus_space_handle_t *bshp)
{
	const struct legacy_io_range *r;
	bus_addr_t end;

	if (offs >= HTB_IO_SIZE)
		return EINVAL;

	if (offs < HTB_IO_LEGACY) {
		end = offs + size - 1;
		if ((r = sys_platform->legacy_io_ranges) == NULL)
			return ENXIO;
		for ( ; r->start != 0; r++) {
			if (offs >= r->start && end <= r->end)
				break;
		}
		if (r->end == 0)
			return ENXIO;
	}

	*bshp = t->bus_base + offs;
	return 0;
}

int
htb_mem_map(bus_space_tag_t t, bus_addr_t offs, bus_size_t size, int flags,
    bus_space_handle_t *bshp)
{
	if (offs < HTB_MEM_BASE || offs + size > HTB_MEM_BASE + HTB_MEM_SIZE)
		return EINVAL;

	*bshp = t->bus_base + offs;
	return 0;
}

paddr_t
htb_mem_mmap(bus_space_tag_t t, bus_addr_t addr, off_t off, int prot,
    int flags)
{
	return addr + off;
}

/*
 * Functions for system setup
 */

void
htb_early_setup(void)
{
	pci_make_tag_early = htb_make_tag_early;
	pci_conf_read_early = htb_conf_read_early;

	early_mem_t = &htb_pci_mem_space_tag;
	early_io_t = &htb_pci_io_space_tag;
}

pcitag_t
htb_make_tag_early(int b, int d, int f)
{
	return htb_make_tag(NULL, b, d, f);
}

pcireg_t
htb_conf_read_early(pcitag_t tag, int reg)
{
	return htb_conf_read(NULL, tag, reg);
}