/* $NetBSD: vme.c,v 1.31 2024/04/24 02:27:33 thorpej Exp $ */

/*
 * Copyright (c) 1999
 *      Matthias Drochner.  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. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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: vme.c,v 1.31 2024/04/24 02:27:33 thorpej Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/malloc.h>
#include <sys/vmem.h>
#include <sys/bus.h>

#include <dev/vme/vmereg.h>
#include <dev/vme/vmevar.h>

static void vme_extractlocators(int*, struct vme_attach_args *);
static int vmeprint(struct vme_attach_args *, char *);
static int vmesubmatch1(device_t, cfdata_t, const int *, void *);
static int vmesubmatch(device_t, cfdata_t, const int *, void *);
int vmematch(device_t, cfdata_t, void *);
void vmeattach(device_t, device_t, void *);
static vmem_t *vme_select_map(struct vmebus_softc*, vme_am_t);

#define VME_SLAVE_DUMMYDRV "vme_slv"

#define VME_NUMCFRANGES 3 /* cf. "files.vme" */

CFATTACH_DECL_NEW(vme, sizeof(struct vmebus_softc),
    vmematch, vmeattach, NULL, NULL);

const struct cfattach vme_slv_ca = {
        0       /* never used */
};

static void
vme_extractlocators(int *loc, struct vme_attach_args *aa)
{
        int i = 0;

        /* XXX can't use constants in locators.h this way */

        while (i < VME_NUMCFRANGES && i < VME_MAXCFRANGES &&
               loc[i] != -1) {
                aa->r[i].offset = (vme_addr_t)loc[i];
                aa->r[i].size = (vme_size_t)loc[3 + i];
                aa->r[i].am = (vme_am_t)loc[6 + i];
                i++;
        }
        aa->numcfranges = i;
        aa->ilevel = loc[9];
        aa->ivector = loc[10];
}

static int
vmeprint(struct vme_attach_args *v, char *dummy)
{
        int i;

        for (i = 0; i < v->numcfranges; i++) {
                aprint_normal(" addr %x", v->r[i].offset);
                if (v->r[i].size != -1)
                        aprint_normal("-%x", v->r[i].offset + v->r[i].size - 1);
                if (v->r[i].am != -1)
                        aprint_normal(" am %02x", v->r[i].am);
        }
        if (v->ilevel != -1) {
                aprint_normal(" irq %d", v->ilevel);
                if (v->ivector != -1)
                        aprint_normal(" vector %x", v->ivector);
        }
        return (UNCONF);
}

/*
 * This looks for a (dummy) vme device "VME_SLAVE_DUMMYDRV".
 * A callback provided by the bus's parent is called for every such
 * entry in the config database.
 * This is a special hack allowing to communicate the address settings
 * of the VME master's slave side to its driver via the normal
 * configuration mechanism.
 * Needed in following cases:
 *  -DMA windows are hardware settable but not readable by software
 *   (driver gets offsets for DMA address calculations this way)
 *  -DMA windows are software settable, but not persistent
 *   (hardware is set up from config file entry)
 *  -other adapter VME slave ranges which should be kept track of
 *   for address space accounting
 * In any case, the adapter driver must get the data before VME
 * devices are attached.
 */
static int
vmesubmatch1(device_t bus, cfdata_t dev, const int *ldesc, void *aux)
{
        struct vmebus_softc *sc = device_private(bus);
        struct vme_attach_args v;

        if (strcmp(dev->cf_name, VME_SLAVE_DUMMYDRV))
                return (0);

        vme_extractlocators(dev->cf_loc, &v);

        v.va_vct = sc->sc_vct; /* for space allocation */

        (*sc->slaveconfig)(device_parent(bus), &v);
        return (0);
}

static int
vmesubmatch(device_t bus, cfdata_t dev, const int *ldesc, void *aux)
{
        struct vmebus_softc *sc = device_private(bus);
        struct vme_attach_args v;

        if (!strcmp(dev->cf_name, VME_SLAVE_DUMMYDRV))
                return (0);

        vme_extractlocators(dev->cf_loc, &v);

        v.va_vct = sc->sc_vct;
        v.va_bdt = sc->sc_bdt;

        if (config_probe(bus, dev, &v)) {
                config_attach(bus, dev, &v, (cfprint_t)vmeprint, CFARGS_NONE);
                return (1);
        }
        return (0);
}

int
vmematch(device_t parent, cfdata_t match, void *aux)
{
        return (1);
}

void
vmeattach(device_t parent, device_t self, void *aux)
{
        struct vmebus_softc *sc = device_private(self);

        struct vmebus_attach_args *aa = aux;

        sc->sc_vct = aa->va_vct;
        sc->sc_bdt = aa->va_bdt;

        /* the "bus" are we ourselves */
        sc->sc_vct->bus = sc;

        sc->slaveconfig = aa->va_slaveconfig;

        printf("\n");

        /*
         * set up address space accounting - assume incomplete decoding
         */
        sc->vme32_arena = vmem_create("vme32",
                                      0,                /* base */
        /* XXX loses last byte */     0xffffffff,       /* size */
                                      1,                /* quantum */
                                      NULL,             /* allocfn */
                                      NULL,             /* releasefn */
                                      NULL,             /* source */
                                      0,                /* qcache_max */
                                      VM_SLEEP,
                                      IPL_NONE);
        if (!sc->vme32_arena) {
                device_printf(self, "error creating A32 map\n");
                return;
        }

        sc->vme24_arena = vmem_create("vme24",
                                      0,                /* base */
                                      0x01000000,       /* size */
                                      1,                /* quantum */
                                      NULL,             /* allocfn */
                                      NULL,             /* releasefn */
                                      NULL,             /* source */
                                      0,                /* qcache_max */
                                      VM_SLEEP,
                                      IPL_NONE);
        if (!sc->vme24_arena) {
                device_printf(self, "error creating A24 map\n");
                return;
        }

        sc->vme16_arena = vmem_create("vme16",
                                      0,                /* base */
                                      0x00010000,       /* size */
                                      1,                /* quantum */
                                      NULL,             /* allocfn */
                                      NULL,             /* releasefn */
                                      NULL,             /* source */
                                      0,                /* qcache_max */
                                      VM_SLEEP,
                                      IPL_NONE);
        if (!sc->vme16_arena) {
                device_printf(self, "error creating A16 map\n");
                return;
        }

        if (sc->slaveconfig) {
                /* first get info about the bus master's slave side,
                 if present */
                config_search(self, NULL,
                    CFARGS(.search = vmesubmatch1));
        }
        config_search(self, NULL,
            CFARGS(.search = vmesubmatch));

#if 0   /* XXX VMEDEBUG */
        if (sc->vme32_arena)
                vmem_print(sc->vme32_arena);
        if (sc->vme24_arena)
                vmem_print(sc->vme24_arena);
        if (sc->vme16_arena)
                vmem_print(sc->vme16_arena);
#endif
}

#ifdef notyet
int
vmedetach(device_t dev)
{
        struct vmebus_softc *sc = device_private(dev);

        if (sc->slaveconfig) {
                /* allow bus master to free its bus resources */
                (*sc->slaveconfig)(device_parent(dev), 0);
        }

        /* extent maps should be empty now */

        if (sc->vme32_arena) {
#ifdef VMEDEBUG
                vmem_print(sc->vme32_arena);
#endif
                vmem_destroy(sc->vme32_arena);
        }
        if (sc->vme24_arena) {
#ifdef VMEDEBUG
                vmem_print(sc->vme24_arena);
#endif
                vmem_destroy(sc->vme24_arena);
        }
        if (sc->vme16_arena) {
#ifdef VMEDEBUG
                vmem_print(sc->vme16_arena);
#endif
                vmem_destroy(sc->vme16_arena);
        }

        return (0);
}
#endif

static vmem_t *
vme_select_map(struct vmebus_softc *sc, vme_am_t ams)
{
        if ((ams & VME_AM_ADRSIZEMASK) == VME_AM_A32)
                return (sc->vme32_arena);
        else if ((ams & VME_AM_ADRSIZEMASK) == VME_AM_A24)
                return (sc->vme24_arena);
        else if ((ams & VME_AM_ADRSIZEMASK) == VME_AM_A16)
                return (sc->vme16_arena);
        else
                return (0);
}

int
_vme_space_alloc(struct vmebus_softc *sc, vme_addr_t addr, vme_size_t len, vme_am_t ams)
{
        vmem_t *vm;

        vm = vme_select_map(sc, ams);
        if (!vm)
                return (EINVAL);

        return vmem_xalloc_addr(vm, addr, len, VM_NOSLEEP);
}

void
_vme_space_free(struct vmebus_softc *sc, vme_addr_t addr, vme_size_t len, vme_am_t ams)
{
        vmem_t *vm;

        vm = vme_select_map(sc, ams);
        if (!vm) {
                panic("vme_space_free: invalid am %x", ams);
                return;
        }

        vmem_xfree(vm, addr, len);
}

int
_vme_space_get(struct vmebus_softc *sc, vme_size_t len, vme_am_t ams, u_long align, vme_addr_t *addr)
{
        vmem_t *vm;
        vmem_addr_t help;
        int res;

        vm = vme_select_map(sc, ams);
        if (!vm)
                return (EINVAL);

        res = vmem_xalloc(vm, len,
                          align,                /* align */
                          0,                    /* phase */
                          0,                    /* nocross */
                          VMEM_ADDR_MIN,        /* minaddr */
                          VMEM_ADDR_MAX,        /* maxaddr */
                          VM_BESTFIT | VM_NOSLEEP,
                          &help);
        if (!res)
                *addr = help;
        return (res);
}