xref: /src/sys/dev/marvell/mvxpbm.c

/*	$NetBSD: mvxpbm.c,v 1.4 2024/02/08 20:51:24 andvar Exp $	*/
/*
 * Copyright (c) 2015 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 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: mvxpbm.c,v 1.4 2024/02/08 20:51:24 andvar Exp $");

#include "opt_multiprocessor.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/mbuf.h>

#include <dev/marvell/marvellreg.h>
#include <dev/marvell/marvellvar.h>

#include "mvxpbmvar.h"

#ifdef DEBUG
#define STATIC /* nothing */
#define DPRINTF(fmt, ...) \
	do { \
		if (mvxpbm_debug >= 1) { \
			printf("%s: ", __func__); \
			printf((fmt), ##__VA_ARGS__); \
		} \
	} while (/*CONSTCOND*/0)
#define DPRINTFN(level , fmt, ...) \
	do { \
		if (mvxpbm_debug >= (level)) { \
			printf("%s: ", __func__); \
			printf((fmt), ##__VA_ARGS__); \
		} \
	} while (/*CONSTCOND*/0)
#define DPRINTDEV(dev, level, fmt, ...) \
	do { \
		if (mvxpbm_debug >= (level)) { \
			device_printf((dev), \
			    "%s: "fmt , __func__, ##__VA_ARGS__); \
		} \
	} while (/*CONSTCOND*/0)
#define DPRINTSC(sc, level, fmt, ...) \
	do { \
		device_t dev = (sc)->sc_dev; \
		if (mvxpbm_debug >= (level)) { \
			device_printf(dev, \
			    "%s: " fmt, __func__, ##__VA_ARGS__); \
		} \
	} while (/*CONSTCOND*/0)
#else
#define STATIC static
#define DPRINTF(fmt, ...)
#define DPRINTFN(level, fmt, ...)
#define DPRINTDEV(dev, level, fmt, ...)
#define DPRINTSC(sc, level, fmt, ...)
#endif

/* autoconf(9) */
STATIC int mvxpbm_match(device_t, cfdata_t, void *);
STATIC void mvxpbm_attach(device_t, device_t, void *);
STATIC int mvxpbm_evcnt_attach(struct mvxpbm_softc *);
CFATTACH_DECL_NEW(mvxpbm_mbus, sizeof(struct mvxpbm_softc),
    mvxpbm_match, mvxpbm_attach, NULL, NULL);

/* DMA buffers */
STATIC int mvxpbm_alloc_buffer(struct mvxpbm_softc *);

/* mbuf subroutines */
STATIC void mvxpbm_free_mbuf(struct mbuf *, void *, size_t, void *);

/* singleton device instance */
static struct mvxpbm_softc sc_emul;
static struct mvxpbm_softc *sc0;

/* debug level */
#ifdef DEBUG
static int mvxpbm_debug = 0;
#endif

/*
 * autoconf(9)
 */
STATIC int
mvxpbm_match(device_t parent, cfdata_t match, void *aux)
{
	struct marvell_attach_args *mva = aux;

	if (strcmp(mva->mva_name, match->cf_name) != 0)
		return 0;
	if (mva->mva_unit > MVXPBM_UNIT_MAX)
		return 0;
	if (sc0 != NULL)
		return 0;
	if (mva->mva_offset != MVA_OFFSET_DEFAULT) {
		/* Hardware BM is not supported yet. */
		return 0;
	}

	return 1;
}

STATIC void
mvxpbm_attach(device_t parnet, device_t self, void *aux)
{
	struct marvell_attach_args *mva = aux;
	struct mvxpbm_softc *sc = device_private(self);

	aprint_naive("\n");
	aprint_normal(": Marvell ARMADA Buffer Manager\n");
	memset(sc, 0, sizeof(*sc));
	sc->sc_dev = self;
	sc->sc_iot = mva->mva_iot;
	sc->sc_dmat = mva->mva_dmat;

	if (mva->mva_offset == MVA_OFFSET_DEFAULT) {
		aprint_normal_dev(sc->sc_dev, "Software emulation.\n");
		sc->sc_emul = 1;
	}

	mutex_init(&sc->sc_mtx, MUTEX_DEFAULT, IPL_NET);
	LIST_INIT(&sc->sc_free);
	LIST_INIT(&sc->sc_inuse);

	/* DMA buffers */
	if (mvxpbm_alloc_buffer(sc) != 0)
		return;

	/* event counters */
	mvxpbm_evcnt_attach(sc);

	sc0 = sc;
	return;

}

STATIC int
mvxpbm_evcnt_attach(struct mvxpbm_softc *sc)
{
	return 0;
}

/*
 * DMA buffers
 */
STATIC int
mvxpbm_alloc_buffer(struct mvxpbm_softc *sc)
{
	bus_dma_segment_t segs;
	char *kva, *ptr, *ptr_next, *ptr_data;
	char *bm_buf_end;
	uint32_t align, pad;
	int nsegs;
	int error;

	/*
	 * set default buffer sizes. this will changed to satisfy
	 * alignment restrictions.
	 */
	sc->sc_chunk_count = 0;
	sc->sc_chunk_size = MVXPBM_PACKET_SIZE;
	sc->sc_chunk_header_size = sizeof(struct mvxpbm_chunk);
	sc->sc_chunk_packet_offset = 64;

	/*
	 * adjust bm_chunk_size, bm_chunk_header_size, bm_slotsize
	 * to satisfy alignment restrictions.
	 *
	 *    <----------------  bm_slotsize [oct.] ------------------>
	 *                               <--- bm_chunk_size[oct.] ---->
	 *    <--- header_size[oct] ---> <-- MBXPE_BM_SIZE[oct.] --->
	 *   +-----------------+--------+---------+-----------------+--+
	 *   | bm_chunk hdr    |pad     |pkt_off  |   packet data   |  |
	 *   +-----------------+--------+---------+-----------------+--+
	 *   ^                          ^         ^                    ^
	 *   |                          |         |                    |
	 *   ptr                 ptr_data  DMA here         ptr_next
	 *
	 * Restrictions:
	 *   - total buffer size must be multiple of MVXPBM_BUF_ALIGN
	 *   - ptr must be aligned to MVXPBM_CHUNK_ALIGN
	 *   - ptr_data must be aligned to MVXPEBM_DATA_ALIGN
	 *   - bm_chunk_size must be multiple of 8[bytes].
	 */
	/* start calclation from  0x0000.0000 */
	ptr = (char *)0;

	/* align start of packet data */
	ptr_data = ptr + sc->sc_chunk_header_size;
	align = (unsigned long)ptr_data & MVXPBM_DATA_MASK;
	if (align != 0) {
		pad = MVXPBM_DATA_ALIGN - align;
		sc->sc_chunk_header_size += pad;
		DPRINTSC(sc, 1, "added padding to BM header, %u bytes\n", pad);
	}

	/* align size of packet data */
	ptr_data = ptr + sc->sc_chunk_header_size;
	ptr_next = ptr_data + MVXPBM_PACKET_SIZE;
	align = (unsigned long)ptr_next & MVXPBM_CHUNK_MASK;
	if (align != 0) {
		pad = MVXPBM_CHUNK_ALIGN - align;
		ptr_next += pad;
		DPRINTSC(sc, 1, "added padding to BM pktbuf, %u bytes\n", pad);
	}
	sc->sc_slotsize = ptr_next - ptr;
	sc->sc_chunk_size = ptr_next - ptr_data;
	KASSERT((sc->sc_chunk_size % MVXPBM_DATA_UNIT) == 0);

	/* align total buffer size to Mbus window boundary */
	sc->sc_buf_size = sc->sc_slotsize * MVXPBM_NUM_SLOTS;
	align = (unsigned long)sc->sc_buf_size & MVXPBM_BUF_MASK;
	if (align != 0) {
		pad = MVXPBM_BUF_ALIGN - align;
		sc->sc_buf_size += pad;
		DPRINTSC(sc, 1,
		    "expand buffer to fit page boundary, %u bytes\n", pad);
	}

	/*
	 * get the aligned buffer from busdma(9) framework
	 */
	if (bus_dmamem_alloc(sc->sc_dmat, sc->sc_buf_size, MVXPBM_BUF_ALIGN, 0,
	    &segs, 1, &nsegs, BUS_DMA_NOWAIT)) {
		aprint_error_dev(sc->sc_dev, "can't alloc BM buffers\n");
		return ENOBUFS;
	}
	if (bus_dmamem_map(sc->sc_dmat, &segs, nsegs, sc->sc_buf_size,
	    (void **)&kva, BUS_DMA_NOWAIT)) {
		aprint_error_dev(sc->sc_dev,
		    "can't map dma buffers (%zu bytes)\n", sc->sc_buf_size);
		error = ENOBUFS;
		goto fail1;
	}
	if (bus_dmamap_create(sc->sc_dmat, sc->sc_buf_size, 1, sc->sc_buf_size,
	    0, BUS_DMA_NOWAIT, &sc->sc_buf_map)) {
		aprint_error_dev(sc->sc_dev, "can't create dma map\n");
		error = ENOBUFS;
		goto fail2;
	}
	if (bus_dmamap_load(sc->sc_dmat, sc->sc_buf_map,
	    kva, sc->sc_buf_size, NULL, BUS_DMA_NOWAIT)) {
		aprint_error_dev(sc->sc_dev, "can't load dma map\n");
		error = ENOBUFS;
		goto fail3;
	}
	sc->sc_buf = (void *)kva;
	sc->sc_buf_pa = segs.ds_addr;
	bm_buf_end = (void *)(kva + sc->sc_buf_size);
	DPRINTSC(sc, 1, "memory pool at %p\n", sc->sc_buf);

	/* slice the buffer */
	mvxpbm_lock(sc);
	for (ptr = sc->sc_buf; ptr + sc->sc_slotsize <= bm_buf_end;
	    ptr += sc->sc_slotsize) {
		struct mvxpbm_chunk *chunk;

		/* initialize chunk */
		ptr_data = ptr + sc->sc_chunk_header_size;
		chunk = (struct mvxpbm_chunk *)ptr;
		chunk->m = NULL;
		chunk->sc = sc;
		chunk->off = (ptr - sc->sc_buf);
		chunk->pa = (paddr_t)(sc->sc_buf_pa + chunk->off);
		chunk->buf_off = (ptr_data - sc->sc_buf);
		chunk->buf_pa = (paddr_t)(sc->sc_buf_pa + chunk->buf_off);
		chunk->buf_va = (vaddr_t)(sc->sc_buf + chunk->buf_off);
		chunk->buf_size = sc->sc_chunk_size;

		/* add to free list (for software management) */
		LIST_INSERT_HEAD(&sc->sc_free, chunk, link);
		mvxpbm_dmamap_sync(chunk, BM_SYNC_ALL, BUS_DMASYNC_PREREAD);
		sc->sc_chunk_count++;

		DPRINTSC(sc, 9, "new chunk %p\n", (void *)chunk->buf_va);
	}
	mvxpbm_unlock(sc);
	return 0;

fail3:
	bus_dmamap_destroy(sc->sc_dmat, sc->sc_buf_map);
fail2:
	bus_dmamem_unmap(sc->sc_dmat, kva, sc->sc_buf_size);
fail1:
	bus_dmamem_free(sc->sc_dmat, &segs, nsegs);

	return error;
}

/*
 * mbuf subroutines
 */
STATIC void
mvxpbm_free_mbuf(struct mbuf *m, void *buf, size_t size, void *arg)
{
	struct mvxpbm_chunk *chunk = (struct mvxpbm_chunk *)arg;
	int s;

	KASSERT(m != NULL);
	KASSERT(arg != NULL);

	DPRINTFN(3, "free packet %p\n", m);

	chunk->m = NULL;
	s = splvm();
	pool_cache_put(mb_cache, m);
	splx(s);
	return mvxpbm_free_chunk(chunk);
}

/*
 * Exported APIs
 */
/* get mvxpbm device context */
struct mvxpbm_softc *
mvxpbm_device(struct marvell_attach_args *mva)
{
	struct mvxpbm_softc *sc;

	if (sc0 != NULL)
		return sc0;
	if (mva == NULL)
		return NULL;

	/* allocate software emulation context */
	sc = &sc_emul;
	memset(sc, 0, sizeof(*sc));
	sc->sc_emul = 1;
	sc->sc_iot = mva->mva_iot;
	sc->sc_dmat = mva->mva_dmat;

	mutex_init(&sc->sc_mtx, MUTEX_DEFAULT, IPL_NET);
	LIST_INIT(&sc->sc_free);
	LIST_INIT(&sc->sc_inuse);

	if (mvxpbm_alloc_buffer(sc) != 0)
		return NULL;
	mvxpbm_evcnt_attach(sc);
	sc0 = sc;
	return sc0;
}

/* allocate new memory chunk */
struct mvxpbm_chunk *
mvxpbm_alloc(struct mvxpbm_softc *sc)
{
	struct mvxpbm_chunk *chunk;

	mvxpbm_lock(sc);

	chunk = LIST_FIRST(&sc->sc_free);
	if (chunk == NULL) {
		mvxpbm_unlock(sc);
		return NULL;
	}

	LIST_REMOVE(chunk, link);
	LIST_INSERT_HEAD(&sc->sc_inuse, chunk, link);

	mvxpbm_unlock(sc);
	return chunk;
}

/* free memory chunk */
void
mvxpbm_free_chunk(struct mvxpbm_chunk *chunk)
{
	struct mvxpbm_softc *sc = chunk->sc;

	KASSERT(chunk->m == NULL);
	DPRINTFN(3, "bm chunk free\n");

	mvxpbm_lock(sc);

	LIST_REMOVE(chunk, link);
	LIST_INSERT_HEAD(&sc->sc_free, chunk, link);

	mvxpbm_unlock(sc);
}

/* prepare mbuf header after Rx */
int
mvxpbm_init_mbuf_hdr(struct mvxpbm_chunk *chunk)
{
	struct mvxpbm_softc *sc = chunk->sc;

	KASSERT(chunk->m == NULL);

	/* add new mbuf header */
	MGETHDR(chunk->m, M_DONTWAIT, MT_DATA);
	if (chunk->m == NULL) {
		aprint_error_dev(sc->sc_dev, "cannot get mbuf\n");
		return ENOBUFS;
	}
	MEXTADD(chunk->m, chunk->buf_va, chunk->buf_size, 0,
		mvxpbm_free_mbuf, chunk);
	chunk->m->m_flags |= M_EXT_RW;
	chunk->m->m_len = chunk->m->m_pkthdr.len = chunk->buf_size;
	if (sc->sc_chunk_packet_offset)
		m_adj(chunk->m, sc->sc_chunk_packet_offset);

	return 0;
}

/* sync DMA seguments */
void
mvxpbm_dmamap_sync(struct mvxpbm_chunk *chunk, size_t size, int ops)
{
	struct mvxpbm_softc *sc = chunk->sc;

	KASSERT(size <= chunk->buf_size);
	if (size == 0)
		size = chunk->buf_size;

	bus_dmamap_sync(sc->sc_dmat, sc->sc_buf_map, chunk->buf_off, size, ops);
}

/* lock */
void
mvxpbm_lock(struct mvxpbm_softc *sc)
{
	mutex_enter(&sc->sc_mtx);
}

void
mvxpbm_unlock(struct mvxpbm_softc *sc)
{
	mutex_exit(&sc->sc_mtx);
}

/* get params */
const char *
mvxpbm_xname(struct mvxpbm_softc *sc)
{
	if (sc->sc_emul) {
		return "software_bm";
	}
	return device_xname(sc->sc_dev);
}

size_t
mvxpbm_chunk_size(struct mvxpbm_softc *sc)
{
	return sc->sc_chunk_size;
}

uint32_t
mvxpbm_chunk_count(struct mvxpbm_softc *sc)
{
	return sc->sc_chunk_count;
}

off_t
mvxpbm_packet_offset(struct mvxpbm_softc *sc)
{
	return sc->sc_chunk_packet_offset;
}

paddr_t
mvxpbm_buf_pbase(struct mvxpbm_softc *sc)
{
	return sc->sc_buf_pa;
}

size_t
mvxpbm_buf_size(struct mvxpbm_softc *sc)
{
	return sc->sc_buf_size;
}