/*-
 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
 *
 * Copyright (c) 2021 Adrian Chadd <adrian@FreeBSD.org>
 *
 * 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 unmodified, 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 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 AUTHOR 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>
__FBSDID("$FreeBSD$");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/bus.h>

#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/rman.h>
#include <sys/lock.h>
#include <sys/malloc.h>
#include <sys/mutex.h>
#include <sys/socket.h>
#include <sys/sockio.h>

#include <net/if.h>
#include <net/if_var.h>
#include <net/if_media.h>
#include <net/ethernet.h>

#include <machine/bus.h>
#include <machine/resource.h>

#include <dev/fdt/fdt_common.h>
#include <dev/ofw/ofw_bus.h>
#include <dev/ofw/ofw_bus_subr.h>

#include <dev/qcom_ess_edma/qcom_ess_edma_var.h>
#include <dev/qcom_ess_edma/qcom_ess_edma_reg.h>
#include <dev/qcom_ess_edma/qcom_ess_edma_hw.h>
#include <dev/qcom_ess_edma/qcom_ess_edma_desc.h>
#include <dev/qcom_ess_edma/qcom_ess_edma_debug.h>

static void
qcom_ess_edma_desc_map_addr(void *arg, bus_dma_segment_t *segs, int nsegs,
    int error)
{
	if (error != 0)
		return;
	KASSERT(nsegs == 1, ("too many DMA segments, %d should be 1", nsegs));
	*(bus_addr_t *)arg = segs[0].ds_addr;
}

/*
 * Initialise the given descriptor ring.
 */
int
qcom_ess_edma_desc_ring_setup(struct qcom_ess_edma_softc *sc,
    struct qcom_ess_edma_desc_ring *ring,
    char *label,
    int count,
    int sw_desc_size,
    int hw_desc_size,
    int num_segments,
    int buffer_align)
{
	int error;
	int hw_ring_size;

	ring->label = strdup(label, M_TEMP);
	if (ring->label == NULL) {
		device_printf(sc->sc_dev,
		    "ERROR: failed to strdup label\n");
		error = ENOMEM;
		goto error;
	}

	mtx_init(&ring->mtx, ring->label, NULL, MTX_DEF);

	hw_ring_size = count * hw_desc_size;

	/*
	 * Round the hardware ring size up to a cacheline
	 * so we don't end up with partial cacheline sizes
	 * causing bounce buffers to be used.
	 */
	hw_ring_size = ((hw_ring_size + PAGE_SIZE) / PAGE_SIZE) * PAGE_SIZE;

	/*
	 * For now set it to 4 byte alignment, no max size.
	 */
	ring->ring_align = EDMA_DESC_RING_ALIGN;
	error = bus_dma_tag_create(
	    sc->sc_dma_tag,		/* parent */
	    EDMA_DESC_RING_ALIGN, 0,	/* alignment, boundary */
	    BUS_SPACE_MAXADDR,		/* lowaddr */
	    BUS_SPACE_MAXADDR,		/* highaddr */
	    NULL, NULL,			/* filter, filterarg */
	    hw_ring_size,		/* maxsize */
	    1,				/* nsegments */
	    hw_ring_size,		/* maxsegsize */
	    0,				/* flags */
	    NULL, NULL,			/* lockfunc, lockarg */
	    &ring->hw_ring_dma_tag);
	if (error != 0) {
		device_printf(sc->sc_dev,
		    "ERROR: failed to create descriptor DMA tag (%d)\n",
		    error);
		goto error;
	}

	/*
	 * Buffer ring - used passed in value
	 */
	ring->buffer_align = buffer_align;
	error = bus_dma_tag_create(
	    sc->sc_dma_tag,		/* parent */
	    buffer_align, 0,		/* alignment, boundary */
	    BUS_SPACE_MAXADDR,		/* lowaddr */
	    BUS_SPACE_MAXADDR,		/* highaddr */
	    NULL, NULL,			/* filter, filterarg */
	    EDMA_DESC_MAX_BUFFER_SIZE * num_segments,	/* maxsize */
	    num_segments,			/* nsegments */
	    EDMA_DESC_MAX_BUFFER_SIZE,	/* maxsegsize */
	    0,				/* flags */
	    NULL, NULL,			/* lockfunc, lockarg */
	    &ring->buffer_dma_tag);
	if (error != 0) {
		device_printf(sc->sc_dev,
		    "ERROR: failed to create buffer DMA tag (%d)\n",
		    error);
		goto error;
	}

	/*
	 * Allocate software descriptors
	 */
	ring->sw_desc = mallocarray(count, sw_desc_size, M_TEMP,
	    M_NOWAIT | M_ZERO);
	if (ring->sw_desc == NULL) {
		device_printf(sc->sc_dev,
		    "ERROR: failed to allocate sw_desc\n");
		goto error;
	}

	/*
	 * Allocate hardware descriptors, initialise map, get
	 * physical address.
	 */
	error = bus_dmamem_alloc(ring->hw_ring_dma_tag,
	    (void **)&ring->hw_desc,
	     BUS_DMA_WAITOK | BUS_DMA_COHERENT | BUS_DMA_ZERO,
	    &ring->hw_desc_map);
	if (error != 0) {
		device_printf(sc->sc_dev,
		    "failed to allocate DMA'able memory for hw_desc ring\n");
		goto error;
	}
	ring->hw_desc_paddr = 0;
	error = bus_dmamap_load(ring->hw_ring_dma_tag, ring->hw_desc_map,
	    ring->hw_desc, hw_ring_size, qcom_ess_edma_desc_map_addr,
	    &ring->hw_desc_paddr, BUS_DMA_NOWAIT);
	bus_dmamap_sync(ring->hw_ring_dma_tag, ring->hw_desc_map,
	    BUS_DMASYNC_PREWRITE);
	QCOM_ESS_EDMA_DPRINTF(sc, QCOM_ESS_EDMA_DBG_DESCRIPTOR_SETUP,
	    "%s: PADDR=0x%08lx\n", __func__, ring->hw_desc_paddr);

	/*
	 * All done, initialise state.
	 */
	ring->hw_entry_size = hw_desc_size;
	ring->sw_entry_size = sw_desc_size;
	ring->ring_count = count;

	return (0);
error:
	mtx_destroy(&ring->mtx);
	if (ring->label != NULL)
		free(ring->label, M_TEMP);
	if (ring->hw_desc != NULL) {
		bus_dmamap_sync(ring->hw_ring_dma_tag, ring->hw_desc_map,
		    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
		bus_dmamap_unload(ring->hw_ring_dma_tag, ring->hw_desc_map);
		bus_dmamem_free(ring->hw_ring_dma_tag, ring->hw_desc,
		    ring->hw_desc_map);
		ring->hw_desc = NULL;
	}
	if (ring->sw_desc != NULL) {
		free(ring->sw_desc, M_TEMP);
		ring->sw_desc = NULL;
	}
	if (ring->hw_ring_dma_tag != NULL) {
		bus_dma_tag_destroy(ring->hw_ring_dma_tag);
		ring->hw_ring_dma_tag = NULL;
	}
	if (ring->buffer_dma_tag != NULL) {
		bus_dma_tag_destroy(ring->buffer_dma_tag);
		ring->buffer_dma_tag = NULL;
	}

	return (error);
}

/*
 * Free/clean the given descriptor ring.
 *
 * The ring itself right now is static; so we don't free it.
 * We just free the resources it has.
 */
int
qcom_ess_edma_desc_ring_free(struct qcom_ess_edma_softc *sc,
    struct qcom_ess_edma_desc_ring *ring)
{

	mtx_destroy(&ring->mtx);
	if (ring->label != NULL)
		free(ring->label, M_TEMP);

	if (ring->hw_desc != NULL) {
		bus_dmamap_sync(ring->hw_ring_dma_tag, ring->hw_desc_map,
		    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
		bus_dmamap_unload(ring->hw_ring_dma_tag, ring->hw_desc_map);
		bus_dmamem_free(ring->hw_ring_dma_tag, ring->hw_desc,
		    ring->hw_desc_map);
		ring->hw_desc = NULL;
	}

	if (ring->sw_desc != NULL) {
		free(ring->sw_desc, M_TEMP);
		ring->sw_desc = NULL;
	}

	if (ring->hw_ring_dma_tag != NULL) {
		bus_dma_tag_destroy(ring->hw_ring_dma_tag);
		ring->hw_ring_dma_tag = NULL;
	}
	if (ring->buffer_dma_tag != NULL) {
		bus_dma_tag_destroy(ring->buffer_dma_tag);
		ring->buffer_dma_tag = NULL;
	}

	return (0);
}

/*
 * Fetch the given software descriptor pointer by index.
 *
 * Returns NULL if the index is out of bounds.
 */
void *
qcom_ess_edma_desc_ring_get_sw_desc(struct qcom_ess_edma_softc *sc,
    struct qcom_ess_edma_desc_ring *ring, uint16_t index)
{
	char *p;

	if (index >= ring->ring_count)
		return (NULL);

	p = (char *) ring->sw_desc;

	return (void *) (p + (ring->sw_entry_size * index));
}

/*
 * Fetch the given hardware descriptor pointer by index.
 *
 * Returns NULL if the index is out of bounds.
 */
void *
qcom_ess_edma_desc_ring_get_hw_desc(struct qcom_ess_edma_softc *sc,
    struct qcom_ess_edma_desc_ring *ring, uint16_t index)
{
	char *p;

	if (index >= ring->ring_count)
		return (NULL);

	p = (char *) ring->hw_desc;

	return (void *) (p + (ring->hw_entry_size * index));
}

/*
 * Flush the hardware ring after a write, before the hardware
 * gets to it.
 */
int
qcom_ess_edma_desc_ring_flush_preupdate(struct qcom_ess_edma_softc *sc,
    struct qcom_ess_edma_desc_ring *ring)
{

	bus_dmamap_sync(ring->hw_ring_dma_tag, ring->hw_desc_map,
	    BUS_DMASYNC_PREWRITE);

	return (0);
}


/*
 * Flush the hardware ring after the hardware writes into it,
 * before a read.
 */
int
qcom_ess_edma_desc_ring_flush_postupdate(struct qcom_ess_edma_softc *sc,
    struct qcom_ess_edma_desc_ring *ring)
{

	bus_dmamap_sync(ring->hw_ring_dma_tag, ring->hw_desc_map,
	    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);

	return (0);
}

/*
 * Get how many descriptor slots are available.
 */
int
qcom_ess_edma_desc_ring_get_num_available(struct qcom_ess_edma_softc *sc,
    struct qcom_ess_edma_desc_ring *ring)
{
	uint16_t sw_next_to_fill;
	uint16_t sw_next_to_clean;
	uint16_t count = 0;

	sw_next_to_clean = ring->next_to_clean;
	sw_next_to_fill = ring->next_to_fill;

	if (sw_next_to_clean <= sw_next_to_fill)
		count = ring->ring_count;

	return (count + sw_next_to_clean - sw_next_to_fill - 1);
}