/*      $NetBSD: octeon_fpa.c,v 1.10 2021/03/24 08:10:14 simonb Exp $   */

/*
* Copyright (c) 2007 Internet Initiative Japan, Inc.
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*/

#undef  FPADEBUG

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: octeon_fpa.c,v 1.10 2021/03/24 08:10:14 simonb Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/types.h>
#include <sys/kmem.h>

#include <sys/bus.h>
#include <machine/locore.h>
#include <machine/vmparam.h>

#include <mips/cavium/octeonvar.h>
#include <mips/cavium/include/iobusvar.h>
#include <mips/cavium/dev/octeon_fpareg.h>
#include <mips/cavium/dev/octeon_fpavar.h>

#ifdef FPADEBUG
#define DPRINTF(x)      printf x
#else
#define DPRINTF(x)
#endif

#define _DMA_NSEGS      1
#define _DMA_BUFLEN     0x01000000

struct octfpa_softc {
       int                     sc_initialized;

       bus_space_tag_t         sc_regt;
       bus_space_handle_t      sc_regh;

       bus_space_tag_t         sc_opst;
       bus_space_handle_t      sc_opsh;

       bus_dma_tag_t           sc_dmat;
};

void                    octfpa_bootstrap(struct octeon_config *);
void                    octfpa_reset(void);
void                    octfpa_int_enable(struct octfpa_softc *, int);
void                    octfpa_buf_dma_alloc(struct octfpa_buf *);

static void             octfpa_init(struct octfpa_softc *);
#ifdef notyet
static uint64_t         octfpa_iobdma(struct octfpa_softc *, int, int);
#endif

static struct octfpa_softc      octfpa_softc;

/* ---- global functions */

void
octfpa_bootstrap(struct octeon_config *mcp)
{
       struct octfpa_softc *sc = &octfpa_softc;

       sc->sc_regt = &mcp->mc_iobus_bust;
       sc->sc_opst = &mcp->mc_iobus_bust;
       sc->sc_dmat = &mcp->mc_iobus_dmat;

       octfpa_init(sc);
}

void
octfpa_reset(void)
{
       /* XXX */
}

int
octfpa_buf_init(int poolno, size_t size, size_t nelems, struct octfpa_buf **rfb)
{
       struct octfpa_softc *sc = &octfpa_softc;
       struct octfpa_buf *fb;
       int nsegs;
       paddr_t paddr;

       nsegs = 1/* XXX */;
       fb = kmem_zalloc(sizeof(*fb) + sizeof(*fb->fb_dma_segs) * nsegs,
           KM_SLEEP);
       fb->fb_poolno = poolno;
       fb->fb_size = size;
       fb->fb_nelems = nelems;
       fb->fb_len = size * nelems;
       fb->fb_dmat = sc->sc_dmat;
       fb->fb_dma_segs = (void *)(fb + 1);
       fb->fb_dma_nsegs = nsegs;

       octfpa_buf_dma_alloc(fb);

       for (paddr = fb->fb_paddr; paddr < fb->fb_paddr + fb->fb_len;
           paddr += fb->fb_size)
               octfpa_buf_put_paddr(fb, paddr);

       *rfb = fb;

       return 0;
}

void *
octfpa_buf_get(struct octfpa_buf *fb)
{
       paddr_t paddr;
       vaddr_t addr;

       paddr = octfpa_buf_get_paddr(fb);
       if (paddr == 0)
               addr = 0;
       else
               addr = fb->fb_addr + (vaddr_t/* XXX */)(paddr - fb->fb_paddr);
       return (void *)addr;
}

void
octfpa_buf_dma_alloc(struct octfpa_buf *fb)
{
       int status;
       int nsegs;
       void *va;

       status = bus_dmamap_create(fb->fb_dmat, fb->fb_len,
           fb->fb_len / PAGE_SIZE,     /* # of segments */
           fb->fb_len,                 /* we don't use s/g for FPA buf */
           PAGE_SIZE,                  /* OCTEON hates >PAGE_SIZE boundary */
           0, &fb->fb_dmah);
       if (status != 0)
               panic("%s failed", "bus_dmamap_create");

       status = bus_dmamem_alloc(fb->fb_dmat, fb->fb_len, 128, 0,
           fb->fb_dma_segs, fb->fb_dma_nsegs, &nsegs, 0);
       if (status != 0 || fb->fb_dma_nsegs != nsegs)
               panic("%s failed", "bus_dmamem_alloc");

       status = bus_dmamem_map(fb->fb_dmat, fb->fb_dma_segs, fb->fb_dma_nsegs,
           fb->fb_len, &va, 0);
       if (status != 0)
               panic("%s failed", "bus_dmamem_map");

       status = bus_dmamap_load(fb->fb_dmat, fb->fb_dmah, va, fb->fb_len,
           NULL,               /* kernel */
           0);
       if (status != 0)
               panic("%s failed", "bus_dmamap_load");

       fb->fb_addr = (vaddr_t)va;
       fb->fb_paddr = fb->fb_dma_segs[0].ds_addr;
}

uint64_t
octfpa_query(int poolno)
{
       struct octfpa_softc *sc = &octfpa_softc;

       return bus_space_read_8(sc->sc_regt, sc->sc_regh,
           FPA_QUE0_AVAILABLE_OFFSET + sizeof(uint64_t) * poolno);
}

/* ---- local functions */

static inline void      octfpa_init_bus(struct octfpa_softc *);
static inline void      octfpa_init_bus_space(struct octfpa_softc *);
static inline void      octfpa_init_regs(struct octfpa_softc *);

void
octfpa_init(struct octfpa_softc *sc)
{
       if (sc->sc_initialized != 0)
               panic("%s: already initialized", __func__);
       sc->sc_initialized = 1;

       octfpa_init_bus(sc);
       octfpa_init_regs(sc);
}

void
octfpa_init_bus(struct octfpa_softc *sc)
{

       octfpa_init_bus_space(sc);
}

void
octfpa_init_bus_space(struct octfpa_softc *sc)
{
       int status;

       status = bus_space_map(sc->sc_regt, FPA_BASE, FPA_SIZE, 0, &sc->sc_regh);
       if (status != 0)
               panic("can't map %s space", "register");

       status = bus_space_map(sc->sc_opst,
           0x0001180028000000ULL/* XXX */, 0x0200/* XXX */, 0, &sc->sc_opsh);
       if (status != 0)
               panic("can't map %s space", "operations");
}

void
octfpa_init_regs(struct octfpa_softc *sc)
{

       bus_space_write_8(sc->sc_regt, sc->sc_regh, FPA_CTL_STATUS_OFFSET,
           FPA_CTL_STATUS_ENB);
}

int
octfpa_available_fpa_pool(int *available, int pool_no) {
       struct octfpa_softc *sc = &octfpa_softc;
       size_t offset;
       uint64_t tmp;

       switch (pool_no) {
       case OCTEON_POOL_NO_PKT:
               offset = FPA_QUE0_AVAILABLE_OFFSET;
               break;
       case OCTEON_POOL_NO_WQE:
               offset = FPA_QUE1_AVAILABLE_OFFSET;
               break;
       case OCTEON_POOL_NO_CMD:
               offset = FPA_QUE2_AVAILABLE_OFFSET;
               break;
       case OCTEON_POOL_NO_SG:
               offset = FPA_QUE3_AVAILABLE_OFFSET;
               break;
       case OCTEON_POOL_NO_XXX_4:
               offset = FPA_QUE4_AVAILABLE_OFFSET;
               break;
       case OCTEON_POOL_NO_XXX_5:
               offset = FPA_QUE5_AVAILABLE_OFFSET;
               break;
       case OCTEON_POOL_NO_XXX_6:
               offset = FPA_QUE6_AVAILABLE_OFFSET;
               break;
       case OCTEON_POOL_NO_DUMP:
               offset = FPA_QUE7_AVAILABLE_OFFSET;
               break;
       default:
               return EINVAL;
       }
       tmp = bus_space_read_8(sc->sc_regt, sc->sc_regh, offset);
       if (available) {
               *available = (int)(tmp & FPA_QUEX_AVAILABLE_QUE_SIZ);
       }

       return 0;
}

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.