/* $NetBSD: podulebus.c,v 1.34 2022/05/30 09:56:02 andvar Exp $ */

/*
 * Copyright (c) 1994-1996 Mark Brinicombe.
 * Copyright (c) 1994 Brini.
 * 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.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by Brini.
 * 4. The name of the company nor the name of the author may be used to
 *    endorse or promote products derived from this software without specific
 *    prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY BRINI ``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 BRINI 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.
 *
 * RiscBSD kernel project
 *
 * podulebus.c
 *
 * Podule probe and configuration routines
 *
 * Created      : 07/11/94
 */

#include <sys/param.h>

__KERNEL_RCSID(0, "$NetBSD: podulebus.c,v 1.34 2022/05/30 09:56:02 andvar Exp $");

#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/conf.h>
#include <sys/kmem.h>
#include <sys/device.h>
#include <uvm/uvm_extern.h>
#include <machine/io.h>
#include <machine/intr.h>
#include <machine/bootconfig.h>
#include <machine/pmap.h>
#include <arm/iomd/iomdreg.h>
#include <arm/iomd/iomdvar.h>
#include <acorn32/podulebus/podulebus.h>
#include <dev/podulebus/podules.h>
#include <dev/podulebus/podule_data.h>

#include "locators.h"

#define WriteByte(a, b) \
    *((volatile unsigned char *)(a)) = (b)
#define ReadByte(a) \
    (*((volatile unsigned char *)(a)))

/* Array of podule structures, one per possible podule */

podule_t podules[MAX_PODULES + MAX_NETSLOTS];

extern struct bus_space podulebus_bs_tag;

/* Declare prototypes */

u_int poduleread(u_int, int);
int podulebusmatch(device_t, cfdata_t, void *);
void podulebusattach(device_t, device_t, void *);
int podulebusprint(void *, const char *);
int podulebussubmatch(device_t, cfdata_t, const int *, void *);
void podulechunkdirectory(podule_t *);
void podulescan(device_t);

/*
 * int podulebusmatch(device_t parent, void *match, void *aux)
 *
 * Probe for the podule bus. Currently all this does is return 1 to
 * indicate that the podule bus was found.
 */
 
int
podulebusmatch(device_t parent, cfdata_t cf, void *aux)
{
	switch (IOMD_ID) {
	case RPC600_IOMD_ID:
	case ARM7500_IOC_ID:
	case ARM7500FE_IOC_ID:
		return(1);
	}
	return (0);
}


int
podulebusprint(void *aux, const char *name)
{
	struct podule_attach_args *pa = aux;

	if (name)
		aprint_normal("podule at %s", name);
	if (pa->pa_podule->slottype == SLOT_POD)
		aprint_normal(" slot %d", pa->pa_podule_number);
	else if (pa->pa_podule->slottype == SLOT_NET)
		aprint_normal(" [ netslot %d ]",
		    pa->pa_podule_number - MAX_PODULES);
#ifdef DIAGNOSTIC
	else
		panic("Invalid slot type");
#endif

	return (UNCONF);
}


int
podulebussubmatch(device_t parent, cfdata_t cf, const int *ldesc, void *aux)
{
	struct podule_attach_args *pa = aux;

	/* Return priority 0 or 1 for wildcarded podule */

	if (cf->cf_loc[PODULEBUSCF_SLOT] == PODULEBUSCF_SLOT_DEFAULT)
		return(config_match(parent, cf, aux));

	/* Return higher priority if we match the specific podule */

	else if (cf->cf_loc[PODULEBUSCF_SLOT] == pa->pa_podule_number)
		return(config_match(parent, cf, aux) * 8);

	/* Fail */
	return(0);
}


#if 0
void
dump_podule(podule_t *podule)
{
	printf("podule%d: ", podule->podulenum);
	printf("flags0=%02x ", podule->flags0);
	printf("flags1=%02x ", podule->flags1);
	printf("reserved=%02x ", podule->reserved);
	printf("product=%02x ", podule->product);
	printf("manufacturer=%02x ", podule->manufacturer);
	printf("country=%02x ", podule->country);
	printf("irq_addr=%08x ", podule->irq_addr);
	printf("irq_mask=%02x ", podule->irq_mask);
	printf("fiq_addr=%08x ", podule->fiq_addr);
	printf("fiq_mask=%02x ", podule->fiq_mask);
	printf("fast_base=%08x ", podule->fast_base);
	printf("medium_base=%08x ", podule->medium_base);
	printf("slow_base=%08x ", podule->slow_base);
	printf("sync_base=%08x ", podule->sync_base);
	printf("mod_base=%08x ", podule->mod_base);
	printf("easi_base=%08x ", podule->easi_base);
	printf("attached=%d ", podule->attached);
	printf("slottype=%d ", podule->slottype);
	printf("podulenum=%d ", podule->podulenum);
	printf("description=%s ", podule->description);
	printf("\n");
}
#endif

void
podulechunkdirectory(podule_t *podule)
{
	u_int address;
	u_int id;
	u_int size;
	u_int addr;
	int loop;
	int done_f5;

	done_f5 = 0;	
	address = 0x40;

	do {
		id = podule->read_rom(podule->sync_base, address);
		size = podule->read_rom(podule->sync_base, address + 4);
		size |= (podule->read_rom(podule->sync_base, address + 8) << 8);
		size |= (podule->read_rom(podule->sync_base, address + 12) << 16);
		if (id == 0xf5) {
			addr = podule->read_rom(podule->sync_base, address + 16);
			addr |= (podule->read_rom(podule->sync_base, address + 20) << 8);
			addr |= (podule->read_rom(podule->sync_base, address + 24) << 16);
			addr |= (podule->read_rom(podule->sync_base, address + 28) << 24);
			if (addr < 0x800 && done_f5 == 0) {
				done_f5 = 1;
				for (loop = 0; loop < size; ++loop) {
					if (loop < PODULE_DESCRIPTION_LENGTH) {
						podule->description[loop] =
						    podule->read_rom(podule->sync_base, (addr + loop)*4);
						podule->description[loop + 1] = 0;
					}
				}
			}
		}
#ifdef DEBUG_CHUNK_DIR
		if (id == 0xf5 || id == 0xf1 || id == 0xf2 || id == 0xf3 || id == 0xf4 || id == 0xf6) {
			addr = podule->read_rom(podule->sync_base, address + 16);
			addr |= (podule->read_rom(podule->sync_base, address + 20) << 8);
			addr |= (podule->read_rom(podule->sync_base, address + 24) << 16);
			addr |= (podule->read_rom(podule->sync_base, address + 28) << 24);
			printf("<%04x.%04x.%04x.%04x>", id, address, addr, size);
			if (addr < 0x800) {
				for (loop = 0; loop < size; ++loop) {
					printf("%c", podule->read_rom(podule->sync_base, (addr + loop)*4));
				}
				printf("\\n\n");
			}
		}
#endif
		address += 32;
	} while (id != 0 && address < 0x800);
}


void
poduleexamine(podule_t *podule, device_t dev, int slottype)
{
	struct manufacturer_description *man_desc;
	struct podule_description *pod_desc;

	/* Test to see if the podule is present */

	if ((podule->flags0 & 0x02) == 0x00) {
		podule->slottype = slottype;
		if (slottype == SLOT_NET)
			printf("netslot%d at %s : ", podule->podulenum - MAX_PODULES,
			    device_xname(dev));
		else
			printf("podule%d  at %s : ", podule->podulenum,
			    device_xname(dev));

		/* Is it Acorn conformant ? */

		if (podule->flags0 & 0x80)
			printf("Non-Acorn conformant expansion card\n");
		else {
			int id;

			/* Is it a simple podule ? */

			id = (podule->flags0 >> 3) & 0x0f;
			if (id != 0)
				printf("Simple expansion card <%x>\n", id);
			else {
				/* Scan the chunk directory if present for tags we use */
				if (podule->flags1 & PODULE_FLAGS_CD)
					podulechunkdirectory(podule);

				/* Do we know this manufacturer ? */
				man_desc = known_manufacturers;
				while (man_desc->description) {
					if (man_desc->manufacturer_id ==
					    podule->manufacturer)
						break;
					++man_desc;
				}
				if (!man_desc->description)
					printf("man=%04x   : ", podule->manufacturer);
				else
					printf("%s : ", man_desc->description);

				/* Do we know this product ? */

				pod_desc = known_podules;
				while (pod_desc->description) {
					if (pod_desc->product_id == podule->product)
						break;
					++pod_desc;
				}
				if (!pod_desc->description)
					printf("prod=%04x : ",
					    podule->product);
				else
					printf("%s : ", pod_desc->description);
				printf("%s\n", podule->description);
			}
		}
	}
}


u_int
poduleread(u_int address, int offset)
{

	return(ReadByte(address + offset));
}

void
podulescan(device_t dev)
{
	int loop;
	podule_t *podule;
	u_char *address;
	u_int offset = 0;

	/* Loop round all the podules */

	for (loop = 0; loop < MAX_PODULES; ++loop, offset += SIMPLE_PODULE_SIZE) {
		podule = &podules[loop];
		podule->podulenum = loop;
		podule->attached = 0;
		podule->slottype = SLOT_NONE;
		podule->interrupt = IRQ_PODULE;
		podule->read_rom = poduleread;
		podule->dma_channel = -1;
		podule->dma_interrupt = -1;
		podule->description[0] = 0;

		if (loop == 4) offset += PODULE_GAP;
		address = ((u_char *)SYNC_PODULE_BASE) + offset;
        
		if ((address[0] & 0x02) == 0x00) {
			podule->fast_base = FAST_PODULE_BASE + offset;
			podule->medium_base = MEDIUM_PODULE_BASE + offset;
			podule->slow_base = SLOW_PODULE_BASE + offset;
			podule->sync_base = SYNC_PODULE_BASE + offset;
			podule->mod_base = MOD_PODULE_BASE + offset;
			podule->easi_base = EASI_BASE + loop * EASI_SIZE;
		} else {
			address = ((u_char *)EASI_BASE) + loop * EASI_SIZE;
			if ((address[0] & 0x02) != 0x00)
				continue;

			podule->fast_base = 0;
			podule->medium_base = 0;
			podule->slow_base = 0;
			podule->sync_base = 0;
			podule->mod_base = 0;
			podule->easi_base = EASI_BASE + loop * EASI_SIZE;
		}

		/* XXX - Really needs to be linked to a DMA manager */
		if (IOMD_ID == RPC600_IOMD_ID) {
			switch (loop) {
			case 0:
				podule->dma_channel = 2;
				podule->dma_interrupt = IRQ_DMACH2;
				break;
			case 1:
				podule->dma_channel = 3;
				podule->dma_interrupt = IRQ_DMACH3;
				break;
			}
		}

		/* Get information from the podule header */

		podule->flags0 = address[0];
		if ((podule->flags0 & 0x78) == 0) {
			podule->flags1 = address[4];
			podule->reserved = address[8];
			podule->product = address[12] + (address[16] << 8);
			podule->manufacturer = address[20] + (address[24] << 8);
			podule->country = address[28];
			if (podule->flags1 & PODULE_FLAGS_IS) {
				podule->irq_addr = address[52] + (address[56] << 8) + (address[60] << 16);
				podule->irq_addr += podule->slow_base;
				podule->irq_mask = address[48];
				if (podule->irq_mask == 0)
					podule->irq_mask = 0x01;
				podule->fiq_addr = address[36] + (address[40] << 8) + (address[44] << 16);
				podule->fiq_addr += podule->slow_base;
				podule->fiq_mask = address[32];
				if (podule->fiq_mask == 0)
					podule->fiq_mask = 0x04;
			} else {
				podule->irq_addr = podule->slow_base;
				podule->irq_mask = 0x01;
				podule->fiq_addr = podule->slow_base;
				podule->fiq_mask = 0x04;
			}
		}

		poduleexamine(podule, dev, SLOT_POD);
	}
}


/*
 * void podulebusattach(device_t parent, device_t dev, void *aux)
 *
 * Attach podulebus.
 * This probes all the podules and sets up the podules array with
 * information found in the podule headers.
 * After identifying all the podules, all the children of the podulebus
 * are probed and attached.
 */
  
void
podulebusattach(device_t parent, device_t self, void *aux)
{
	int loop;
	struct podule_attach_args pa;
#if 0
	int easi_time;
	int bit;
#endif
	unsigned int value;
	char argstring[20];

#if 0
	easi_time = IOMD_READ_BYTE(IOMD_ECTCR);
	printf(": easi timings=");
	for (bit = 0x01; bit < 0x100; bit = bit << 1)
		if (easi_time & bit)
			printf("C");
		else
			printf("A");
#endif
	printf("\n");


#if 0 /* XXXJRT */
	/* Ok we need to map in the podulebus */
	/* with the new pmap mappings have to be done when the L1 tables
	 * are built during initarm
	 */
	/* Map the FAST and SYNC simple podules */
	pmap_map_section((vaddr_t)pmap_kernel()->pm_pdir,
	    SYNC_PODULE_BASE & 0xfff00000, SYNC_PODULE_HW_BASE & 0xfff00000,
	    VM_PROT_READ|VM_PROT_WRITE, PTE_NOCACHE);
	cpu_tlb_flushD();
	/* Now map the EASI space */

	for (loop = 0; loop < MAX_PODULES; ++loop) {
		int loop1;
        
		for (loop1 = loop * EASI_SIZE; loop1 < ((loop + 1) * EASI_SIZE);
		    loop1 += L1_S_SIZE)
		pmap_map_section((vaddr_t)pmap_kernel()->pm_pdir,
		    EASI_BASE + loop1, EASI_HW_BASE + loop1,
		    VM_PROT_READ|VM_PROT_WRITE, PTE_NOCACHE);
	}
	cpu_tlb_flushD();
#endif
	/*
	 * The MEDIUM and SLOW simple podules and the module space will have been
	 * mapped when the IOMD and COMBO we mapped in for the RPC
	 */

	/* Find out what hardware is bolted on */

	podulescan(self); 
	netslotscan(self);

	/* Look for drivers to attach */

	for (loop = 0; loop < MAX_PODULES+MAX_NETSLOTS; ++loop) {
#if 1
		/* Provide backwards compat for a while */
		snprintf(argstring, sizeof(argstring), "podule%d.disable", loop);
		if (get_bootconf_option(boot_args, argstring,
		    BOOTOPT_TYPE_BOOLEAN, &value)) {
			if (value) {
				if (podules[loop].slottype != SLOT_NONE)
					printf("podule%d: Disabled\n", loop);
				continue;
			}
 		}
#endif
 		snprintf(argstring, sizeof(argstring), "podule%d=", loop);
 		if (get_bootconf_option(boot_args, argstring,
 		    BOOTOPT_TYPE_HEXINT, &value)) {
			/* Override the ID */
			podules[loop].manufacturer = value >> 16;
 			podules[loop].product = value & 0xffff;
			/* Any old description is now wrong */
			podules[loop].description[0] = 0;
			if (value != 0xffff) {
				printf("podule%d: ID overridden man=%04x prod=%04x\n",
				    loop, podules[loop].manufacturer,
				    podules[loop].product);
				podules[loop].slottype = SLOT_POD;
				pa.pa_podule_number = loop;
				pa.pa_ih = pa.pa_podule_number;
				pa.pa_podule = &podules[loop];
				pa.pa_iot = &podulebus_bs_tag;
				config_found(self, &pa, podulebusprint,
				    CFARGS(.submatch = podulebussubmatch));
				continue;
			}
			if (value == 0xffff) {
				printf("podule%d: Disabled\n", loop);
				continue;
			}
		}
		
		if (podules[loop].slottype != SLOT_NONE) {
			pa.pa_podule_number = loop;
			pa.pa_ih = pa.pa_podule_number;
			pa.pa_podule = &podules[loop];
			pa.pa_iot = &podulebus_bs_tag;
			config_found(self, &pa, podulebusprint,
			    CFARGS(.submatch = podulebussubmatch));
		}
	}
}


CFATTACH_DECL_NEW(podulebus, 0,
	podulebusmatch, podulebusattach, NULL, NULL);

/* Useful functions that drivers may share */

/*
 * Match a podule structure with the specified parameters
 * Returns 0 if the match failed
 * The required_slot is not used at the moment.
 */

int
matchpodule(struct podule_attach_args *pa, int manufacturer, int product, int required_slot)
{
	if (pa->pa_podule->attached)
		panic("podulebus: Podule already attached");

	if (IS_PODULE(pa, manufacturer, product))
		return(1);

	return(0);
}

void *
podulebus_irq_establish(podulebus_intr_handle_t ih,
	int ipl, int (*func)(void *), void *arg, struct evcnt *ev)
{

	/* XXX We don't actually use the evcnt supplied, just its name. */
	return intr_claim(podules[ih].interrupt, ipl, ev->ev_group, func,
	    arg);
}

/*
 * Generate a bus_space_tag_t with the specified address-bus shift.
 */
void
podulebus_shift_tag(bus_space_tag_t tag, u_int shift, bus_space_tag_t *tagp)
{

	/*
	 * For the podulebus, the bus tag cookie is the shift to apply
	 * to registers, so duplicate the bus space tag and change the
	 * cookie.
	 */

	/* XXX never freed, but podules are never detached anyway. */
        *tagp = kmem_alloc(sizeof(struct bus_space), KM_SLEEP);
	**tagp = *tag;
	(*tagp)->bs_cookie = (void *)shift;
}

int
podulebus_initloader(struct podulebus_attach_args *pa)
{

	/* No loader support at present on arm32, so always fail. */
	return -1;
}

int
podloader_readbyte(struct podulebus_attach_args *pa, u_int addr)
{

	panic("podloader_readbyte");
}

void
podloader_writebyte(struct podulebus_attach_args *pa, u_int addr, int val)
{

	panic("podloader_writebyte");
}

void
podloader_reset(struct podulebus_attach_args *pa)
{

	panic("podloader_reset");
}

int
podloader_callloader(struct podulebus_attach_args *pa, u_int r0, u_int r1)
{

	panic("podloader_callloader");
}

/* End of podulebus.c */