/*-
 * 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/kthread.h>
#include <sys/module.h>
#include <sys/rman.h>
#include <sys/lock.h>
#include <sys/malloc.h>
#include <sys/mutex.h>
#include <sys/gpio.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/smp.h>
#include <sys/proc.h>
#include <sys/sched.h>
#include <sys/queue.h>
#include <sys/taskqueue.h>

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

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

#include <dev/gpio/gpiobusvar.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_rx.h>
#include <dev/qcom_ess_edma/qcom_ess_edma_tx.h>
#include <dev/qcom_ess_edma/qcom_ess_edma_debug.h>
#include <dev/qcom_ess_edma/qcom_ess_edma_gmac.h>

static int
qcom_ess_edma_gmac_mediachange(if_t ifp)
{
        struct qcom_ess_edma_gmac *gmac = if_getsoftc(ifp);
        struct qcom_ess_edma_softc *sc = gmac->sc;
        struct ifmedia *ifm = &gmac->ifm;
        struct ifmedia_entry *ife = ifm->ifm_cur;

        if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
        return (EINVAL);

        if (IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO) {
                device_printf(sc->sc_dev,
                    "AUTO is not supported this MAC");
                return (EINVAL);
        }

        /*
         * Ignore everything
         */
        return (0);
}

static void
qcom_ess_edma_gmac_mediastatus(if_t ifp, struct ifmediareq *ifmr)
{

        ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
        ifmr->ifm_active = IFM_ETHER | IFM_1000_T | IFM_FDX;
}

static int
qcom_ess_edma_gmac_ioctl(if_t ifp, u_long command, caddr_t data)
{
        struct qcom_ess_edma_gmac *gmac = if_getsoftc(ifp);
        struct qcom_ess_edma_softc *sc = gmac->sc;
        struct ifreq *ifr = (struct ifreq *) data;
        int error, mask;

        switch (command) {
        case SIOCSIFFLAGS:
                if ((if_getflags(ifp) & IFF_UP) != 0) {
                        /* up */
                        QCOM_ESS_EDMA_DPRINTF(sc, QCOM_ESS_EDMA_DBG_STATE,
                            "%s: gmac%d: IFF_UP\n",
                            __func__,
                            gmac->id);
                        if_setdrvflagbits(ifp, IFF_DRV_RUNNING,
                            IFF_DRV_OACTIVE);
                        if_link_state_change(ifp, LINK_STATE_UP);

                } else if ((if_getdrvflags(ifp) & IFF_DRV_RUNNING) != 0) {
                        /* down */
                        if_setdrvflagbits(ifp, 0, IFF_DRV_RUNNING);
                        QCOM_ESS_EDMA_DPRINTF(sc, QCOM_ESS_EDMA_DBG_STATE,
                            "%s: gmac%d: IF down\n",
                            __func__,
                            gmac->id);
                        if_link_state_change(ifp, LINK_STATE_DOWN);
                }
                error = 0;
                break;
        case SIOCGIFMEDIA:
        case SIOCSIFMEDIA:
                error = ifmedia_ioctl(ifp, ifr, &gmac->ifm, command);
                break;
        case SIOCSIFCAP:
                mask = ifr->ifr_reqcap ^ if_getcapenable(ifp);
                error = 0;

                if ((mask & IFCAP_RXCSUM) != 0 &&
                    (if_getcapabilities(ifp) & IFCAP_RXCSUM) != 0)
                        if_togglecapenable(ifp, IFCAP_RXCSUM);

                if ((mask & IFCAP_VLAN_HWTAGGING) != 0 &&
                    (if_getcapabilities(ifp) & IFCAP_VLAN_HWTAGGING) != 0)
                        if_togglecapenable(ifp, IFCAP_VLAN_HWTAGGING);

                VLAN_CAPABILITIES(ifp);
                break;
        default:
                error = ether_ioctl(ifp, command, data);
                break;
        }

        return (error);
}

static void
qcom_ess_edma_gmac_init(void *arg)
{
        struct qcom_ess_edma_gmac *gmac = arg;
        struct qcom_ess_edma_softc *sc = gmac->sc;

        QCOM_ESS_EDMA_DPRINTF(sc, QCOM_ESS_EDMA_DBG_STATE,
            "%s: gmac%d: called\n",
            __func__,
            gmac->id);

        if_setdrvflagbits(gmac->ifp, IFF_DRV_RUNNING, IFF_DRV_OACTIVE);
        if_link_state_change(gmac->ifp, LINK_STATE_UP);
}

static int
qcom_ess_edma_gmac_transmit(if_t ifp, struct mbuf *m)
{
        struct qcom_ess_edma_gmac *gmac = if_getsoftc(ifp);
        struct qcom_ess_edma_softc *sc = gmac->sc;
        struct qcom_ess_edma_tx_state *txs;
        int ret;
        int q;

        /* Make sure our CPU doesn't change whilst we're running */
        sched_pin();

        /*
         * Map flowid / curcpu to a given transmit queue.
         *
         * Since we're running on a platform with either two
         * or four CPUs, we want to distribute the load to a set
         * of TX queues that won't clash with any other CPU TX queue
         * use.
         */
        if (M_HASHTYPE_GET(m) != M_HASHTYPE_NONE) {
                /* Map flowid to a queue */
                q = m->m_pkthdr.flowid % sc->sc_config.num_tx_queue_per_cpu;

                /* Now, map the queue to a set of unique queues per CPU */
                q = q << (mp_ncpus * curcpu);

                /* And ensure we're not overflowing */
                q = q % QCOM_ESS_EDMA_NUM_TX_RINGS;
        } else {
                /*
                 * Use the first TXQ in each CPU group, so we don't
                 * hit lock contention with traffic that has flowids.
                 */
                q = (mp_ncpus * curcpu) % QCOM_ESS_EDMA_NUM_TX_RINGS;
        }

        /* Attempt to enqueue in the buf_ring. */
        /*
         * XXX TODO: maybe move this into *tx.c so gmac.c doesn't
         * need to reach into the tx_state stuff?
         */
        txs = &sc->sc_tx_state[q];

        /* XXX TODO: add an mbuf tag instead? for the transmit gmac/ifp ? */
        m->m_pkthdr.rcvif = ifp;

        ret = buf_ring_enqueue(txs->br, m);

        if (ret == 0) {
                if (atomic_cmpset_int(&txs->enqueue_is_running, 0, 1) == 1) {
                        taskqueue_enqueue(txs->completion_tq, &txs->xmit_task);
                }
        }

        sched_unpin();

        /* Don't consume mbuf; if_transmit caller will if needed */
        return (ret);
}

static void
qcom_ess_edma_gmac_qflush(if_t ifp)
{
        struct qcom_ess_edma_gmac *gmac = if_getsoftc(ifp);
        struct qcom_ess_edma_softc *sc = gmac->sc;

        /* XXX TODO */
        device_printf(sc->sc_dev, "%s: gmac%d: called\n",
            __func__,
            gmac->id);

        /*
         * Flushing the ifnet would, sigh, require walking each buf_ring
         * and then removing /only/ the entries matching that ifnet.
         * Which is a complete pain to do right now.
         */
}

int
qcom_ess_edma_gmac_parse(struct qcom_ess_edma_softc *sc, int gmac_id)
{
        struct qcom_ess_edma_gmac *gmac;
        char gmac_name[10];
        uint32_t vlan_tag[2];
        phandle_t p;
        int len;

        sprintf(gmac_name, "gmac%d", gmac_id);

        gmac = &sc->sc_gmac[gmac_id];

        /* Find our sub-device */
        p = ofw_bus_find_child(ofw_bus_get_node(sc->sc_dev), gmac_name);
        if (p <= 0) {
                device_printf(sc->sc_dev,
                    "%s: couldn't find %s\n", __func__,
                    gmac_name);
                return (ENOENT);
        }

        /* local-mac-address */
        len = OF_getprop(p, "local-mac-address", (void *) &gmac->eaddr,
            sizeof(struct ether_addr));
        if (len != sizeof(struct ether_addr)) {
                device_printf(sc->sc_dev,
                    "gmac%d: Couldn't parse local-mac-address\n",
                    gmac_id);
                memset(&gmac->eaddr, 0, sizeof(gmac->eaddr));
        }

        /* vlan-tag - <id portmask> tuple */
        len = OF_getproplen(p, "vlan_tag");
        if (len != sizeof(vlan_tag)) {
                device_printf(sc->sc_dev,
                    "gmac%d: no vlan_tag field or invalid size/values\n",
                    gmac_id);
                return (EINVAL);
        }
        len = OF_getencprop(p, "vlan_tag", (void *) &vlan_tag,
            sizeof(vlan_tag));
        if (len != sizeof(vlan_tag)) {
                device_printf(sc->sc_dev,
                    "gmac%d: couldn't parse vlan_tag field\n", gmac_id);
                return (EINVAL);
        }

        /*
         * Setup the given gmac entry.
         */
        gmac->sc = sc;
        gmac->id = gmac_id;
        gmac->enabled = true;
        gmac->vlan_id = vlan_tag[0];
        gmac->port_mask = vlan_tag[1];

        device_printf(sc->sc_dev,
            "gmac%d: MAC=%6D, vlan id=%d, port_mask=0x%04x\n",
            gmac_id,
            &gmac->eaddr, ":",
            gmac->vlan_id,
            gmac->port_mask);

        return (0);
}

int
qcom_ess_edma_gmac_create_ifnet(struct qcom_ess_edma_softc *sc, int gmac_id)
{
        struct qcom_ess_edma_gmac *gmac;
        char gmac_name[10];

        sprintf(gmac_name, "gmac%d", gmac_id);

        gmac = &sc->sc_gmac[gmac_id];

        /* Skip non-setup gmacs */
        if (gmac->enabled == false)
                return (0);

        gmac->ifp = if_alloc(IFT_ETHER);
        if (gmac->ifp == NULL) {
                device_printf(sc->sc_dev, "gmac%d: couldn't allocate ifnet\n",
                    gmac_id);
                return (ENOSPC);
        }

        if_setsoftc(gmac->ifp, gmac);

        if_initname(gmac->ifp, "gmac", gmac_id);

        if (ETHER_IS_ZERO(gmac->eaddr.octet)) {
                device_printf(sc->sc_dev, "gmac%d: generating random MAC\n",
                    gmac_id);
                ether_gen_addr(gmac->ifp, (void *) &gmac->eaddr.octet);
        }

        if_setflags(gmac->ifp, IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST);

        if_setioctlfn(gmac->ifp, qcom_ess_edma_gmac_ioctl);
        if_setinitfn(gmac->ifp, qcom_ess_edma_gmac_init);
        if_settransmitfn(gmac->ifp, qcom_ess_edma_gmac_transmit);
        if_setqflushfn(gmac->ifp, qcom_ess_edma_gmac_qflush);

        if_setcapabilitiesbit(gmac->ifp, IFCAP_VLAN_MTU |
            IFCAP_VLAN_HWTAGGING, 0);

        if_setcapabilitiesbit(gmac->ifp, IFCAP_RXCSUM, 0);

        /* CSUM_TCP | CSUM_UDP for TX checksum offload */
        if_clearhwassist(gmac->ifp);

        /* Configure a hard-coded media */
        ifmedia_init(&gmac->ifm, 0, qcom_ess_edma_gmac_mediachange,
            qcom_ess_edma_gmac_mediastatus);
        ifmedia_add(&gmac->ifm, IFM_ETHER | IFM_1000_T | IFM_FDX, 0, NULL);
        ifmedia_set(&gmac->ifm, IFM_ETHER | IFM_1000_T | IFM_FDX);

        ether_ifattach(gmac->ifp, (char *) &gmac->eaddr);

        if_setcapenable(gmac->ifp, if_getcapabilities(gmac->ifp));

        return (0);
}

/*
 * Setup the port mapping for the given GMAC.
 *
 * This populates sc->sc_gmac_port_map[] to point the given port
 * entry to this gmac index.  The receive path code can then use
 * this to figure out which gmac ifp to push a receive frame into.
 */
int
qcom_ess_edma_gmac_setup_port_mapping(struct qcom_ess_edma_softc *sc,
    int gmac_id)
{
        struct qcom_ess_edma_gmac *gmac;
        int i;

        gmac = &sc->sc_gmac[gmac_id];

        /* Skip non-setup gmacs */
        if (gmac->enabled == false)
                return (0);

        for (i = 0; i < QCOM_ESS_EDMA_MAX_NUM_PORTS; i++) {
                if ((gmac->port_mask & (1U << i)) == 0)
                        continue;
                if (sc->sc_gmac_port_map[i] != -1) {
                        device_printf(sc->sc_dev,
                            "DUPLICATE GMAC port map (port %d)\n",
                            i);
                        return (ENXIO);
                }

                sc->sc_gmac_port_map[i] = gmac_id;

                if (bootverbose)
                        device_printf(sc->sc_dev,
                            "ESS port %d maps to gmac%d\n",
                            i, gmac_id);
        }

        return (0);
}

/*
 * Receive frames to into the network stack.
 *
 * This takes a list of mbufs in the mbufq and receives them
 * up into the appopriate ifnet context.  It takes care of
 * the network epoch as well.
 *
 * This must be called with no locks held.
 */
int
qcom_ess_edma_gmac_receive_frames(struct qcom_ess_edma_softc *sc,
    int rx_queue, struct mbufq *mq)
{
        struct qcom_ess_edma_desc_ring *ring;
        struct epoch_tracker et;
        struct mbuf *m;
        if_t ifp;

        ring = &sc->sc_rx_ring[rx_queue];

        NET_EPOCH_ENTER(et);
        while ((m = mbufq_dequeue(mq)) != NULL) {
                if (m->m_pkthdr.rcvif == NULL) {
                        ring->stats.num_rx_no_gmac++;
                        m_freem(m);
                } else {
                        ring->stats.num_rx_ok++;
                        ifp = m->m_pkthdr.rcvif;
                        if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
                        if_input(ifp, m);
                }
        }
        NET_EPOCH_EXIT(et);
        return (0);
}