/* $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);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.