/*      $NetBSD: zz9k_if.c,v 1.2 2024/02/05 21:46:05 andvar Exp $ */

/*
 * Copyright (c) 2020 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Alain Runa.
 *
 * 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: zz9k_if.c,v 1.2 2024/02/05 21:46:05 andvar Exp $");

/* miscellaneous */
#include <sys/types.h>                  /* size_t */
#include <sys/stdint.h>                 /* uintXX_t */
#include <sys/stdbool.h>                /* bool */
#include <sys/syslog.h>                 /* log(), LOG_ERR */

/* driver(9) */
#include <sys/param.h>                  /* NODEV */
#include <sys/device.h>                 /* CFATTACH_DECL_NEW(), device_priv() */
#include <sys/errno.h>                  /* EINVAL, ENODEV, EPASSTHROUGH */

/* bus_space(9) and zorro bus */
#include <sys/bus.h>                    /* bus_space_xxx(), bus_space_xxx_t */
#include <sys/cpu.h>                    /* kvtop() */
#include <sys/systm.h>                  /* aprint_xxx(), memcpy() */
#include <amiga/dev/zbusvar.h>          /* zbus_args */

/* arp(9) and mbuf(9) */
#include <net/if.h>                     /* if_oerrors */
#include <net/if_ether.h>               /* ethercom, ifnet, ether_ifattach() */
#include <net/if_dl.h>                  /* satosdl(), sockaddr_dl, dl_addr */
#include <net/bpf.h>                    /* bpf_mtap(), BPF_D_OUT */
#include <netinet/if_inarp.h>           /* arp_ifinit() */
#include <sys/mbuf.h>                   /* mbuf_xxx */
#include <sys/sockio.h>                 /* SIOXXX */

/* Interrupt related */
#include <sys/intr.h>                   /* splvm(), splx() */ 
#include <amiga/amiga/isr.h>            /* isr */

/* zz9k related */
#include <amiga/dev/zz9kvar.h>          /* zz9kbus_attach_args */
#include <amiga/dev/zz9kreg.h>          /* ZZ9000 registers */
#include "zz9k_if.h"                    /* NZZ9K_IF */


/* The allmighty softc structure */
struct zzif_softc {
        device_t sc_dev;
        struct bus_space_tag sc_bst;
        bus_space_tag_t sc_iot;
        bus_space_handle_t sc_regh;
        bus_space_handle_t sc_rxh;
        bus_space_handle_t sc_txh;
        
        struct ethercom sc_ethercom;
        struct isr sc_isr;
        void* sc_txbuffer;
        void* sc_rxbuffer;
        uint16_t sc_sequence;
};

/* rx buffer contents */
struct zzif_frame {
        uint16_t size;
        uint16_t serial;
        struct ether_header header;
        uint8_t payload[ETHER_MAX_LEN - ETHER_HDR_LEN];
};


/* ifnet related callbacks */
static void zzif_init(struct zzif_softc *sc);
static void zzif_stop(struct zzif_softc *sc);
static void zzif_start(struct ifnet *ifp);
static int zzif_intr(void *arg);
static int zzif_ioctl(struct ifnet *ifp, u_long cmd, void *data);

/* driver(9) essentials */
static int zzif_match(device_t parent, cfdata_t match, void *aux);
static void zzif_attach(device_t parent, device_t self, void *aux);
CFATTACH_DECL_NEW(
    zz9k_if, sizeof(struct zzif_softc), zzif_match, zzif_attach, NULL, NULL);


/* Oh my God, it's full of stars! */

static int
zzif_match(device_t parent, cfdata_t match, void *aux)
{
        struct zz9kbus_attach_args *bap = aux;

        if (strcmp(bap->zzaa_name, "zz9k_if") != 0)
                return 0;

        return 1;
}

static void
zzif_attach(device_t parent, device_t self, void *aux)
{
        struct zz9kbus_attach_args *bap = aux;
        struct zzif_softc *sc = device_private(self);
        struct zz9k_softc *psc = device_private(parent);
        struct ifnet *ifp = &sc->sc_ethercom.ec_if;
        uint8_t lla[ETHER_ADDR_LEN];

        sc->sc_dev = self;
        sc->sc_bst.base = bap->zzaa_base;
        sc->sc_bst.absm = &amiga_bus_stride_1;
        sc->sc_iot = &sc->sc_bst;
        sc->sc_regh = psc->sc_regh;

        if (bus_space_map(sc->sc_iot, ZZ9K_RX_BASE, ZZ9K_RX_SIZE,
            BUS_SPACE_MAP_LINEAR, &sc->sc_rxh)) {
                aprint_error(": Failed to map MNT ZZ9000 eth rx buffer.\n");
                return;
        }

        if (bus_space_map(sc->sc_iot, ZZ9K_TX_BASE, ZZ9K_TX_SIZE,
            BUS_SPACE_MAP_LINEAR, &sc->sc_txh)) {
                aprint_error(": Failed to map MNT ZZ9000 eth tx buffer.\n");
                return;
        }

        /* get MAC from NIC */
        uint16_t macHI = ZZREG_R(ZZ9K_ETH_MAC_HI);
        uint16_t macMD = ZZREG_R(ZZ9K_ETH_MAC_MD);
        uint16_t macLO = ZZREG_R(ZZ9K_ETH_MAC_LO);
        lla[0] = macHI >> 8;
        lla[1] = macHI & 0xff;
        lla[2] = macMD >> 8;
        lla[3] = macMD & 0xff;
        lla[4] = macLO >> 8;
        lla[5] = macLO & 0xff;

#if 0
        aprint_normal(": Ethernet address %s  "
            "(10BASE-T, 100BASE-TX, AUTO)\n", ether_sprintf(lla));
#endif

        aprint_debug_dev(sc->sc_dev, "[DEBUG] registers at %p/%p (pa/va), "
            "rx buffer at %p/%p (pa/va), tx buffer at %p/%p (pa/va)\n",
            (void *)kvtop((void *)sc->sc_regh),
            bus_space_vaddr(sc->sc_iot, sc->sc_regh),
            (void *)kvtop((void *)sc->sc_rxh),
            bus_space_vaddr(sc->sc_iot, sc->sc_rxh),
            (void *)kvtop((void *)sc->sc_txh),
            bus_space_vaddr(sc->sc_iot, sc->sc_txh));

        /* set rx/tx buffers */
        sc->sc_txbuffer = bus_space_vaddr(sc->sc_iot, sc->sc_txh);
        sc->sc_rxbuffer = bus_space_vaddr(sc->sc_iot, sc->sc_rxh);

        /* configure the network interface */
        memcpy(ifp->if_xname, device_xname(sc->sc_dev), IFNAMSIZ);
        ifp->if_softc = sc;
        ifp->if_ioctl = zzif_ioctl;
        ifp->if_start = zzif_start;
        ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX;
        ifp->if_mtu   = ETHERMTU;

        /* attach the network interface. */
        if_attach(ifp);
        if_deferred_start_init(ifp, NULL);
        ether_ifattach(ifp, lla);

        aprint_normal(": Ethernet address %s\n", ether_sprintf(lla));

        /* setup the (receiving) interrupt service routine on int6 (default) */
        sc->sc_isr.isr_intr = zzif_intr;
        sc->sc_isr.isr_arg  = sc;
        sc->sc_isr.isr_ipl  = 6;
        add_isr(&sc->sc_isr);
}

static void
zzif_init(struct zzif_softc *sc)
{
        struct ifnet *ifp = &sc->sc_ethercom.ec_if;
        int s = splvm();

        ZZREG_W(ZZ9K_CONFIG, ZZREG_R(ZZ9K_CONFIG) | ZZ9K_CONFIG_INT_ETH);
        ifp->if_flags |= IFF_RUNNING;
        ifp->if_flags &= ~IFF_OACTIVE;
        if_schedule_deferred_start(ifp);
        splx(s);
}

static void
zzif_stop(struct zzif_softc *sc)
{
        struct ifnet *ifp = &sc->sc_ethercom.ec_if;
        int s = splvm();

        ZZREG_W(ZZ9K_CONFIG, ZZREG_R(ZZ9K_CONFIG) & ~ZZ9K_CONFIG_INT_ETH);
        ifp->if_flags &= ~IFF_RUNNING;
        splx(s);
}

static void
zzif_start(struct ifnet *ifp)
{
        struct zzif_softc *sc = ifp->if_softc;
        uint8_t *frame= (uint8_t *)sc->sc_txbuffer;
        struct mbuf *m;
        int size;

        if ((ifp->if_flags & IFF_RUNNING) == 0)
                return;

        ifp->if_flags |= IFF_OACTIVE;

        for (;;) {
                IF_DEQUEUE(&ifp->if_snd, m);
                if (m == NULL)
                        break;

                /* this should never happen, otherwise there's no help */
                if ((m->m_flags & M_PKTHDR) == 0)
                        panic("zzif_start: no packet header mbuf");
                
                size = m->m_pkthdr.len;
                if (size == 0)
                        panic("zzif_start: header mbuf with 0 len");

                if ((size < (ETHER_HDR_LEN)) ||
                    (size > (ETHER_MAX_LEN-ETHER_CRC_LEN))) {
                        aprint_error_dev(sc->sc_dev,
                            ": abnormal tx frame size of %i bytes\n", size);
                        m_freem(m);
                        break;
                }

                /* make bpf happy */
                bpf_mtap(ifp, m, BPF_D_OUT);
                
                /* copy dequeued mbuf data to transmit buffer of the ZZ9000 */
                for (struct mbuf *n = m; n != NULL; n = n->m_next) {
                        memcpy(frame, n->m_data, n->m_len);
                        frame += n->m_len;
                }

                m_freem(m);     /* we don't need it anymore */

                /* tell ZZ9000 to transmit packet with size and check result */ 
                ZZREG_W(ZZ9K_ETH_TX, size);
                size = ZZREG_R(ZZ9K_ETH_TX);
                if (size == 0) {
                        if_statinc(ifp, if_opackets);
                } else {
                        if_statinc(ifp, if_oerrors);
                }
        }

        ifp->if_flags &= ~IFF_OACTIVE;
}

static int
zzif_intr(void *arg)
{
        struct zzif_softc *sc = arg;

        uint16_t conf = ZZREG_R(ZZ9K_CONFIG);
        if ((conf & ZZ9K_CONFIG_INT_ETH) == 0)
                return 0;

        ZZREG_W(ZZ9K_CONFIG, conf & ~ZZ9K_CONFIG_INT_ETH);  /* disable INT */
        ZZREG_W(ZZ9K_CONFIG, ZZ9K_CONFIG_INT_ACK | ZZ9K_CONFIG_INT_ACK_ETH);

        struct zzif_frame *frame = (struct zzif_frame *)sc->sc_rxbuffer;
        struct ifnet *ifp = &sc->sc_ethercom.ec_if;
        struct mbuf *m;

        /* check if interrupt was due to new packet arrival */
        if (frame->serial == sc->sc_sequence) {
                ZZREG_W(ZZ9K_ETH_RX, 1);        /* discard packet */
                ZZREG_W(ZZ9K_CONFIG, conf);     /* restore interrupt */
                return 0;       /* nope, something else triggered it */
        }

        sc->sc_sequence = frame->serial;

        if ((frame->size < (ETHER_MIN_LEN-ETHER_CRC_LEN)) ||
            (frame->size > ETHER_MAX_LEN)) {
                aprint_error_dev(sc->sc_dev,
                    ": abnormal rx frame size of %i bytes\n", frame->size);
                ZZREG_W(ZZ9K_ETH_RX, 1);        /* discard packet */
                ZZREG_W(ZZ9K_CONFIG, conf);     /* restore interrupt */
                return 0;
        }

        int s = splvm();
        m = m_devget((char *)&frame->header, frame->size, 0, ifp);
        if_percpuq_enqueue(ifp->if_percpuq, m);
        splx(s);
        ZZREG_W(ZZ9K_ETH_RX, 1);        /* packet served */
        ZZREG_W(ZZ9K_CONFIG, conf);     /* restore interrupt */

        return 1;
}

static int
zzif_ioctl(struct ifnet *ifp, u_long cmd, void *data)
{
        struct zzif_softc *sc = ifp->if_softc;
        struct ifaddr *ifa;
        struct if_laddrreq *lar;
        const struct sockaddr_dl *sdl;
        int retval = 0;

        int s = splvm();

        switch (cmd) {
        case SIOCINITIFADDR:
                ifa = (struct ifaddr *)data;
                zzif_stop(sc);
                zzif_init(sc);
                switch (ifa->ifa_addr->sa_family) {
                case AF_INET:
                        arp_ifinit(ifp, ifa);
                        break;
                default:
                        break;
                }
                break;
        case SIOCSIFFLAGS:
                retval = ifioctl_common(ifp, cmd, data);
                if (retval != 0)
                        break;

                switch (ifp->if_flags & (IFF_UP | IFF_RUNNING)) {
                case IFF_RUNNING: /* and not UP */
                        zzif_stop(sc);
                        break;
                case IFF_UP: /* and not RUNNING */
                        zzif_init(sc);
                        break;
                case (IFF_UP | IFF_RUNNING):
                        zzif_stop(sc);
                        zzif_init(sc);
                        break;
                default:
                        break;
                }
                break;
        case SIOCADDMULTI:
        case SIOCDELMULTI:
                retval = EINVAL;
                break;
        case SIOCALIFADDR:
                lar = (struct if_laddrreq *)data;
                sdl = satocsdl(&lar->addr);
                uint8_t *mac = (uint8_t *)&sdl->sdl_addr.dl_data;

                if ((lar->flags==IFLR_ACTIVE) && (sdl->sdl_family==AF_LINK)) {
                        ZZREG_W(ZZ9K_ETH_MAC_HI, (mac[0] << 8) | mac[1]);
                        ZZREG_W(ZZ9K_ETH_MAC_MD, (mac[2] << 8) | mac[3]);
                        ZZREG_W(ZZ9K_ETH_MAC_LO, (mac[4] << 8) | mac[5]);
                }
                aprint_normal(": Ethernet address %s", ether_sprintf(mac));
                retval = ether_ioctl(ifp, cmd, data);
                break;
        default:
                retval = ether_ioctl(ifp, cmd, data);
                break;
        }

        splx(s);
        
        return retval;
}