/*      $NetBSD: pnpbus.c,v 1.15 2021/08/07 16:19:03 thorpej Exp $      */

/*-
 * Copyright (c) 1998 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Tim Rightnour
 *
 * 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 NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``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 FOUNDATION 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.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: pnpbus.c,v 1.15 2021/08/07 16:19:03 thorpej Exp $");

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

#include <sys/bus.h>
#include <machine/pio.h>
#include <machine/intr.h>
#include <machine/platform.h>
#include <machine/residual.h>
#include <machine/pnp.h>
#include <machine/isa_machdep.h>
#include <machine/chpidpnp.h>

#include <dev/isa/isareg.h>

#include <prep/pnpbus/pnpbusvar.h>

#include "isadma.h"

static int      pnpbus_match(device_t, cfdata_t, void *);
static void     pnpbus_attach(device_t, device_t, void *);
static int      pnpbus_print(void *, const char *);
static int      pnpbus_search(device_t, cfdata_t, const int *, void *);

CFATTACH_DECL_NEW(pnpbus, sizeof(struct pnpbus_softc),
    pnpbus_match, pnpbus_attach, NULL, NULL);

struct pnpbus_softc *pnpbus_softc;
extern struct cfdriver pnpbus_cd;

static int
pnpbus_match(device_t parent, cfdata_t cf, void *aux)
{
        struct pnpbus_attach_args *paa = aux;

        if (paa->paa_name != NULL && strcmp(paa->paa_name, "pnpbus") == 0)
                return 1;
        return 0;
}

static void
pnpbus_attach(device_t parent, device_t self, void *aux)
{
        struct pnpbus_softc *sc = device_private(self);
        struct pnpbus_attach_args *paa = aux;

        aprint_normal("\n");

        pnpbus_softc = sc;
        sc->sc_dev = self;
        sc->sc_ic = paa->paa_ic;
        sc->sc_iot = paa->paa_iot;
        sc->sc_memt = paa->paa_memt;
        sc->sc_dmat = paa->paa_dmat;

#if NISADMA > 0
        isa_dmainit(sc->sc_ic, sc->sc_iot, sc->sc_dmat, self);
#endif

        config_search(self, aux,
            CFARGS(.search = pnpbus_search));
}

static int
pnp_newirq(void *v, struct pnpresources *r, int size)
{
        struct _S4_Pack *p = v;
        struct pnpbus_irq *irq;

        irq = kmem_alloc(sizeof(struct pnpbus_irq), KM_SLEEP);

        irq->mask = le16dec(&p->IRQMask[0]);

        if (size > 2)
                irq->flags = p->IRQInfo;
        else
                irq->flags = 0x1;

        SIMPLEQ_INSERT_TAIL(&r->irq, irq, next);
        r->numirq++;

        return 0;
}

static int
pnp_newdma(void *v, struct pnpresources *r, int size)
{
        struct _S5_Pack *p = v;
        struct pnpbus_dma *dma;

        dma = kmem_alloc(sizeof(struct pnpbus_dma), KM_SLEEP);

        dma->mask = le16dec(&p->DMAMask);
        if (size > 2)
                dma->flags = p->DMAInfo;
        else
                dma->flags = 0x01;

        SIMPLEQ_INSERT_TAIL(&r->dma, dma, next);
        r->numdma++;

        return 0;
}

static int
pnp_newioport(void *v, struct pnpresources *r, int size)
{
        struct _S8_Pack *p = v;
        struct pnpbus_io *io;
        uint16_t mask;

        io = kmem_alloc(sizeof(struct pnpbus_io), KM_SLEEP);
        mask = p->IOInfo & ISAAddr16bit ? 0xffff : 0x03ff;
        io->minbase = (p->RangeMin[0] | (p->RangeMin[1] << 8)) & mask;
        io->maxbase = (p->RangeMax[0] | (p->RangeMax[1] << 8)) & mask;
        io->align = p->IOAlign;
        io->len = p->IONum;
        io->flags = p->IOInfo;

        SIMPLEQ_INSERT_TAIL(&r->io, io, next);
        r->numio++;

        return 0;
}

static int
pnp_newfixedioport(void *v, struct pnpresources *r, int size)
{
        struct _S9_Pack *p = v;
        struct pnpbus_io *io;

        io = kmem_alloc(sizeof(struct pnpbus_io), KM_SLEEP);
        io->minbase = (p->Range[0] | (p->Range[1] << 8)) & 0x3ff;
        io->len = p->IONum;
        io->maxbase = -1;
        io->flags = 0;
        io->align = 1;

        SIMPLEQ_INSERT_TAIL(&r->io, io, next);
        r->numio++;

        return 0;
}

static int
pnp_newiomem(void *v, struct pnpresources *r, int size)
{
        struct pnpbus_mem *mem;
        struct _L1_Pack *pack = v;

        if (pack->Count0 >= 0x9) {
                mem = kmem_alloc(sizeof(struct pnpbus_mem), KM_SLEEP);
                mem->minbase = (pack->Data[2] << 16) | (pack->Data[1] << 8);
                mem->maxbase = (pack->Data[4] << 16) | (pack->Data[3] << 8);
                mem->align = (pack->Data[6] << 8) | pack->Data[5];
                mem->len = (pack->Data[8] << 16) | (pack->Data[7] << 8);
                mem->flags = pack->Data[0];
                SIMPLEQ_INSERT_TAIL(&r->iomem, mem, next);
                r->numiomem++;
                return 0;
        }
        return -1;
}

static int
pnp_newaddr(void *v, struct pnpresources *r, int size)
{
        struct pnpbus_io *io;
        struct pnpbus_mem *mem;
        struct _L4_Pack *pack = v;
        struct _L4_PPCPack *p =  &pack->L4_Data.L4_PPCPack;

        if (p->PPCData[0] == 1) {/* type IO */
                io = kmem_alloc(sizeof(struct pnpbus_io), KM_SLEEP);
                io->minbase = (uint16_t)le64dec(&p->PPCData[4]);
                io->maxbase = -1;
                io->align = p->PPCData[1];
                io->len = (uint16_t)le64dec(&p->PPCData[12]);
                io->flags = 0;
                SIMPLEQ_INSERT_TAIL(&r->io, io, next);
                r->numio++;

                return 0;
        } else if (p->PPCData[0] == 2) {
                mem = kmem_alloc(sizeof(struct pnpbus_mem), KM_SLEEP);
                mem->minbase = (uint32_t)le64dec(&p->PPCData[4]);
                mem->maxbase = -1;
                mem->align = p->PPCData[1];
                mem->len = (uint32_t)le64dec(&p->PPCData[12]);
                mem->flags = 0;
                SIMPLEQ_INSERT_TAIL(&r->mem, mem, next);
                r->nummem++;

                return 0;
        } else 
                return -1;
}

static int
pnp_newcompatid(void *v, struct pnpresources *r, int size)
{
        struct _S3_Pack *p = v;
        struct pnpbus_compatid *id;
        uint32_t cid;

        id = kmem_alloc(sizeof(*id), KM_SLEEP);
        cid = le32dec(p->CompatId);
        pnp_devid_to_string(cid, id->idstr);
        id->next = r->compatids;
        r->compatids = id;

        return 0;
}

/*
 * Call if match succeeds.  This way we don't allocate lots of ram
 * for structures we never use if the device isn't attached.
 */

int
pnpbus_scan(struct pnpbus_dev_attach_args *pna, PPC_DEVICE *dev)
{
        struct pnpresources *r = &pna->pna_res;
        uint32_t l;
        uint8_t *p, *q;
        void *v;
        int tag, size, item;

        l = be32toh(dev->AllocatedOffset);
        p = res->DevicePnPHeap + l;

        if (p == NULL)
                return -1;

        for (; p[0] != END_TAG; p += size) {
                tag = *p;
                v = p;
                if (tag_type(p[0]) == PNP_SMALL) {
                        size = tag_small_count(tag) + 1;
                        item = tag_small_item_name(tag);
                        switch (item) {
                        case IRQFormat:
                                pnp_newirq(v, r, size);
                                break;
                        case DMAFormat:
                                pnp_newdma(v, r, size);
                                break;
                        case IOPort:
                                pnp_newioport(v, r, size);
                                break;
                        case FixedIOPort:
                                pnp_newfixedioport(v, r, size);
                                break;
                        }
                } else {
                        struct _L4_Pack *pack = v;
                        struct _L4_PPCPack *pa = &pack->L4_Data.L4_PPCPack;

                        q = p;
                        size = (q[1] | (q[2] << 8)) + 3 /* tag + length */;
                        item = tag_large_item_name(tag);
                        if (item == LargeVendorItem &&
                            pa->Type == LV_GenericAddress)
                                pnp_newaddr(v, r, size);
                        else if (item == MemoryRange)
                                pnp_newiomem(v, r, size);
                }
        }

        /* scan for compatid's */

        l = be32toh(dev->CompatibleOffset);
        p = res->DevicePnPHeap + l;

        if (p == NULL)
                return -1;

        for (; p[0] != END_TAG; p += size) {
                tag = *p;
                v = p;
                if (tag_type(p[0]) == PNP_SMALL) {
                        size = tag_small_count(tag) + 1;
                        item = tag_small_item_name(tag);
                        switch (item) {
                        case CompatibleDevice:
                                pnp_newcompatid(v, r, size);
                                break;
                        }
                } else {
                        q = p;
                        size = (q[1] | (q[2] << 8)) + 3 /* tag + length */;
                }
        }
        return 0;
}

/*
 * Setup the basic pna structure.
 */

static void
pnp_getpna(struct pnpbus_dev_attach_args *pna, struct pnpbus_attach_args *paa,
        PPC_DEVICE *dev)
{
        DEVICE_ID *id = &dev->DeviceId;
        struct pnpresources *r = &pna->pna_res;
        ChipIDPack *pack;
        uint32_t l;
        uint8_t *p;
        void *v;
        int tag, size, item;

        l = be32toh(dev->AllocatedOffset);
        p = res->DevicePnPHeap + l;

        pna->pna_iot = paa->paa_iot;
        pna->pna_memt = paa->paa_memt;
        pna->pna_ic = paa->paa_ic;
        pna->pna_dmat = paa->paa_dmat;
        pnp_devid_to_string(id->DevId, pna->pna_devid);
        pna->basetype = id->BaseType;
        pna->subtype = id->SubType;
        pna->interface = id->Interface;
        pna->pna_ppc_dev = dev;
        memset(r, 0, sizeof(*r));
        SIMPLEQ_INIT(&r->mem);
        SIMPLEQ_INIT(&r->io);
        SIMPLEQ_INIT(&r->irq);
        SIMPLEQ_INIT(&r->dma);
        SIMPLEQ_INIT(&r->iomem);
        if (p == NULL)
                return;
        /* otherwise, we start looking for chipid's */
        for (; p[0] != END_TAG; p += size) {
                tag = *p;
                v = p;
                if (tag_type(p[0]) == PNP_SMALL) {
                        size = tag_small_count(tag) + 1;
                        item = tag_small_item_name(tag);
                        if (item != SmallVendorItem || p[1] != 1)
                                continue;
                        pack = v;
                        pna->chipid = le16dec(&pack->Name[0]);
                        pna->chipmfg0 = pack->VendorID0;
                        pna->chipmfg1 = pack->VendorID1;
                        break;
                } else {
                        /* Large */
                        size = (p[1] | (p[2] << 8)) + 3 /* tag + length */;
                }
        }
}

static int
pnpbus_search(device_t parent, cfdata_t cf, const int *ldesc, void *aux)
{
        struct pnpbus_dev_attach_args pna;
        struct pnpbus_attach_args *paa = aux;
        PPC_DEVICE *ppc_dev;
        int i;
        uint32_t ndev;

        ndev = be32toh(res->ActualNumDevices);
        ppc_dev = res->Devices;

        for (i = 0; i < ((ndev > MAX_DEVICES) ? MAX_DEVICES : ndev); i++) {
                pnp_getpna(&pna, paa, &ppc_dev[i]);
                if (config_probe(parent, cf, &pna))
                        config_attach(parent, cf, &pna, pnpbus_print,
                            CFARGS_NONE);
        }

        return 0;
}

static void
pnpbus_printres(struct pnpresources *r)
{
        struct pnpbus_io *io;
        struct pnpbus_mem *mem;
        struct pnpbus_irq *irq;
        struct pnpbus_dma *dma;
        int p = 0;

        if (!SIMPLEQ_EMPTY(&r->mem)) {
                aprint_normal("mem");
                SIMPLEQ_FOREACH(mem, &r->mem, next) {
                        aprint_normal(" 0x%x", mem->minbase);
                        if (mem->len > 1)
                                aprint_normal("-0x%x",
                                    mem->minbase + mem->len - 1);
                }
                p++;
        }
        if (!SIMPLEQ_EMPTY(&r->io)) {
                if (p++)
                        aprint_normal(", ");
                aprint_normal("port");
                SIMPLEQ_FOREACH(io, &r->io, next) {
                        aprint_normal(" 0x%x", io->minbase);
                        if (io->len > 1)
                                aprint_normal("-0x%x",
                                    io->minbase + io->len - 1);
                }
        }
        if (!SIMPLEQ_EMPTY(&r->iomem)) {
                if (p++)
                        aprint_normal(", ");
                aprint_normal("iomem");
                SIMPLEQ_FOREACH(mem, &r->iomem, next) {
                        aprint_normal(" 0x%x", mem->minbase);
                        if (mem->len > 1)
                                aprint_normal("-0x%x",
                                    mem->minbase + mem->len - 1);
                }
                p++;
        }
        if (!SIMPLEQ_EMPTY(&r->irq)) {
                if (p++)
                        aprint_normal(", ");
                aprint_normal("irq");
                SIMPLEQ_FOREACH(irq, &r->irq, next) {
                        aprint_normal(" %d", ffs(irq->mask) - 1);
                }
        }
        if (!SIMPLEQ_EMPTY(&r->dma)) {
                if (p++)
                        aprint_normal(", ");
                aprint_normal("DMA");
                SIMPLEQ_FOREACH(dma, &r->dma, next) {
                        aprint_normal(" %d", ffs(dma->mask) - 1);
                }
        }
}

void
pnpbus_print_devres(struct pnpbus_dev_attach_args *pna)
{
        aprint_normal(": ");
        pnpbus_printres(&pna->pna_res);
}

static int
pnpbus_print(void *args, const char *name)
{
        struct pnpbus_dev_attach_args *pna = args;

        pnpbus_print_devres(pna);       
        return (UNCONF);
}

/*
 * Set up an interrupt handler to start being called.
 */
void *
pnpbus_intr_establish(int idx, int level, int tover, int (*ih_fun)(void *),
    void *ih_arg, struct pnpresources *r)
{
        struct pnpbus_irq *irq;
        int irqnum, type;

        if (idx >= r->numirq)
                return 0;

        irq = SIMPLEQ_FIRST(&r->irq);
        while (idx--)
                irq = SIMPLEQ_NEXT(irq, next);

        irqnum = ffs(irq->mask) - 1;
        type = (irq->flags & 0x0c) ? IST_LEVEL : IST_EDGE;
        if (tover != IST_PNP)
                type = tover;

        return (void *)intr_establish(irqnum, type, level, ih_fun, ih_arg);
}

/*
 * Deregister an interrupt handler.
 */
void
pnpbus_intr_disestablish(void *arg)
{

        intr_disestablish(arg);
}

int
pnpbus_getirqnum(struct pnpresources *r, int idx, int *irqp, int *istp)
{
        struct pnpbus_irq *irq;

        if (idx >= r->numirq)
                return EINVAL;

        irq = SIMPLEQ_FIRST(&r->irq);
        while (idx--)
                irq = SIMPLEQ_NEXT(irq, next);

        if (irqp != NULL)
                *irqp = ffs(irq->mask) - 1;
        if (istp != NULL)
                *istp = (irq->flags &0x0c) ? IST_LEVEL : IST_EDGE;
        return 0;
}

int
pnpbus_getdmachan(struct pnpresources *r, int idx, int *chanp)
{
        struct pnpbus_dma *dma;

        if (idx >= r->numdma)
                return EINVAL;

        dma = SIMPLEQ_FIRST(&r->dma);
        while (idx--)
                dma = SIMPLEQ_NEXT(dma, next);

        if (chanp != NULL)
                *chanp = ffs(dma->mask) - 1;
        return 0;
}

int
pnpbus_getioport(struct pnpresources *r, int idx, int *basep, int *sizep)
{
        struct pnpbus_io *io;

        if (idx >= r->numio)
                return EINVAL;

        io = SIMPLEQ_FIRST(&r->io);
        while (idx--)
                io = SIMPLEQ_NEXT(io, next);

        if (basep)
                *basep = io->minbase;
        if (sizep)
                *sizep = io->len;
        return 0;
}

int
pnpbus_io_map(struct pnpresources *r, int idx, bus_space_tag_t *tagp,
    bus_space_handle_t *hdlp)
{
        struct pnpbus_io *io;

        if (idx >= r->numio)
                return EINVAL;

        io = SIMPLEQ_FIRST(&r->io);
        while (idx--)
                io = SIMPLEQ_NEXT(io, next);

        *tagp = &genppc_isa_io_space_tag;
        return (bus_space_map(&genppc_isa_io_space_tag, io->minbase, io->len,
            0, hdlp));
}

void
pnpbus_io_unmap(struct pnpresources *r, int idx, bus_space_tag_t tag,
    bus_space_handle_t hdl)
{
        struct pnpbus_io *io;

        if (idx >= r->numio)
                return;

        io = SIMPLEQ_FIRST(&r->io);
        while (idx--)
                io = SIMPLEQ_NEXT(io, next);

        bus_space_unmap(tag, hdl, io->len);
}

int
pnpbus_getiomem(struct pnpresources *r, int idx, int *basep, int *sizep)
{
        struct pnpbus_mem *mem;

        if (idx >= r->numiomem)
                return EINVAL;

        mem = SIMPLEQ_FIRST(&r->iomem);
        while (idx--)
                mem = SIMPLEQ_NEXT(mem, next);

        if (basep)
                *basep = mem->minbase;
        if (sizep)
                *sizep = mem->len;
        return 0;
}

int
pnpbus_iomem_map(struct pnpresources *r, int idx, bus_space_tag_t *tagp,
    bus_space_handle_t *hdlp)
{
        struct pnpbus_mem *mem;

        if (idx >= r->numiomem)
                return EINVAL;

        mem = SIMPLEQ_FIRST(&r->iomem);
        while (idx--)
                mem = SIMPLEQ_NEXT(mem, next);

        *tagp = &genppc_isa_mem_space_tag;
        return (bus_space_map(&genppc_isa_mem_space_tag, mem->minbase, mem->len,
            0, hdlp));
}

void
pnpbus_iomem_unmap(struct pnpresources *r, int idx, bus_space_tag_t tag,
    bus_space_handle_t hdl)
{
        struct pnpbus_mem *mem;

        if (idx >= r->numiomem)
                return;

        mem = SIMPLEQ_FIRST(&r->mem);
        while (idx--)
                mem = SIMPLEQ_NEXT(mem, next);

        bus_space_unmap(tag, hdl, mem->len);
}