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