/*      $NetBSD: if_smap.c,v 1.36 2023/11/05 21:50:27 andvar Exp $      */

/*-
 * Copyright (c) 2001 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by UCHIYAMA Yasushi.
 *
 * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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>
__KERNEL_RCSID(0, "$NetBSD: if_smap.c,v 1.36 2023/11/05 21:50:27 andvar Exp $");

#include "debug_playstation2.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/syslog.h>
#include <sys/mbuf.h>
#include <sys/ioctl.h>
#include <sys/rndsource.h>
#include <sys/socket.h>
#include <sys/kmem.h>

#include <playstation2/ee/eevar.h>

#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_types.h>
#include <net/if_ether.h>
#include <net/if_media.h>
#include <net/bpf.h>

#include <dev/mii/miivar.h>

#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/in_var.h>
#include <netinet/ip.h>
#include <netinet/if_inarp.h>

#include <playstation2/dev/spdvar.h>
#include <playstation2/dev/spdreg.h>
#include <playstation2/dev/emac3var.h>
#include <playstation2/dev/if_smapreg.h>

#ifdef SMAP_DEBUG
#include <playstation2/ee/gsvar.h>
int     smap_debug = 0;
#define DPRINTF(fmt, args...)                                           \
        if (smap_debug)                                                 \
                printf("%s: " fmt, __func__ , ##args)
#define DPRINTFN(n, arg)                                                \
        if (smap_debug > (n))                                           \
                printf("%s: " fmt, __func__ , ##args)
#define STATIC
struct smap_softc *__sc;
void __smap_status(int);
void __smap_lock_check(const char *, int);
#define FUNC_ENTER()    __smap_lock_check(__func__, 1)
#define FUNC_EXIT()     __smap_lock_check(__func__, 0)
#else
#define DPRINTF(arg...)         ((void)0)
#define DPRINTFN(n, arg...)     ((void)0)
#define STATIC                  static
#define FUNC_ENTER()            ((void)0)
#define FUNC_EXIT()             ((void)0)
#endif

struct smap_softc {
        struct emac3_softc emac3;
        struct ethercom ethercom;

        u_int32_t *tx_buf;
        u_int32_t *rx_buf;
        struct smap_desc *tx_desc;
        struct smap_desc *rx_desc;

#define SMAP_FIFO_ALIGN         4
        int tx_buf_freesize;    /* buffer usage */
        int tx_desc_cnt;        /* descriptor usage */
        u_int16_t tx_fifo_ptr;
        int tx_done_index, tx_start_index;
        int rx_done_index;

        krndsource_t rnd_source;
};

#define DEVNAME         (device_xname(sc->emac3.dev))
#define ROUND4(x)       (((x) + 3) & ~3)
#define ROUND16(x)      (((x) + 15) & ~15)

STATIC int smap_match(struct device *, struct cfdata *, void *);
STATIC void smap_attach(struct device *, struct device *, void *);

CFATTACH_DECL_NEW(smap, sizeof (struct smap_softc),
    smap_match, smap_attach, NULL, NULL);

STATIC int smap_intr(void *);
STATIC void smap_rxeof(void *);
STATIC void smap_txeof(void *);
STATIC void smap_start(struct ifnet *);
STATIC void smap_watchdog(struct ifnet *);
STATIC int smap_ioctl(struct ifnet *, u_long, void *);
STATIC int smap_init(struct ifnet *);
STATIC void smap_stop(struct ifnet *, int);

STATIC int smap_get_eaddr(struct smap_softc *, u_int8_t *);
STATIC int smap_fifo_init(struct smap_softc *);
STATIC int smap_fifo_reset(bus_addr_t);
STATIC void smap_desc_init(struct smap_softc *);

int
smap_match(struct device *parent, struct cfdata *cf, void *aux)
{
        struct spd_attach_args *spa = aux;

        if (spa->spa_slot != SPD_NIC)
                return (0);

        return (1);
}

void
smap_attach(struct device *parent, struct device *self, void *aux)
{
        struct spd_attach_args *spa = aux;
        struct smap_softc *sc = device_private(self);
        struct emac3_softc *emac3 = &sc->emac3;
        struct ifnet *ifp = &sc->ethercom.ec_if;
        struct mii_data *mii = &emac3->mii;
        void *txbuf, *rxbuf;
        u_int16_t r;

#ifdef SMAP_DEBUG
        __sc = sc;
#endif

        sc->emac3.dev = self;

        printf(": %s\n", spa->spa_product_name);

        /* SPD EEPROM */
        if (smap_get_eaddr(sc, emac3->eaddr) != 0)
                return;

        printf("%s: Ethernet address %s\n", DEVNAME,
            ether_sprintf(emac3->eaddr));

        /* disable interrupts */
        r = _reg_read_2(SPD_INTR_ENABLE_REG16);
        r &= ~(SPD_INTR_RXEND | SPD_INTR_TXEND | SPD_INTR_RXDNV |
            SPD_INTR_EMAC3);
        _reg_write_2(SPD_INTR_ENABLE_REG16, r);
        emac3_intr_disable();

        /* clear pending interrupts */
        _reg_write_2(SPD_INTR_CLEAR_REG16, SPD_INTR_RXEND | SPD_INTR_TXEND |
            SPD_INTR_RXDNV);
        emac3_intr_clear();

        /* buffer descriptor mode */
        _reg_write_1(SMAP_DESC_MODE_REG8, 0);

        if (smap_fifo_init(sc) != 0)
                return;

        if (emac3_init(&sc->emac3) != 0)
                return;
        emac3_intr_disable();
        emac3_disable();

        smap_desc_init(sc);

        /* allocate temporary buffer */
        txbuf = kmem_alloc(ETHER_MAX_LEN - ETHER_CRC_LEN + SMAP_FIFO_ALIGN + 16,
            KM_SLEEP);
        rxbuf = kmem_alloc(ETHER_MAX_LEN + SMAP_FIFO_ALIGN + 16, KM_SLEEP);
        sc->tx_buf = (u_int32_t *)ROUND16((vaddr_t)txbuf);
        sc->rx_buf = (u_int32_t *)ROUND16((vaddr_t)rxbuf);

        /*
         * setup MI layer
         */
        strcpy(ifp->if_xname, DEVNAME);
        ifp->if_softc   = sc;
        ifp->if_start   = smap_start;
        ifp->if_ioctl   = smap_ioctl;
        ifp->if_init    = smap_init;
        ifp->if_stop    = smap_stop;
        ifp->if_watchdog= smap_watchdog;
        ifp->if_flags   = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
        IFQ_SET_READY(&ifp->if_snd);

        /* ifmedia setup. */
        mii->mii_ifp            = ifp;
        mii->mii_readreg        = emac3_phy_readreg;
        mii->mii_writereg       = emac3_phy_writereg;
        mii->mii_statchg        = emac3_phy_statchg;
        sc->ethercom.ec_mii = mii;
        ifmedia_init(&mii->mii_media, 0, ether_mediachange, ether_mediastatus);
        mii_attach(emac3->dev, mii, 0xffffffff, MII_PHY_ANY,
            MII_OFFSET_ANY, 0);

        /* Choose a default media. */
        if (LIST_FIRST(&mii->mii_phys) == NULL) {
                ifmedia_add(&mii->mii_media, IFM_ETHER | IFM_NONE, 0, NULL);
                ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_NONE);
        } else {
                ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_AUTO);
        }

        if_attach(ifp);
        if_deferred_start_init(ifp, NULL);
        ether_ifattach(ifp, emac3->eaddr);

        spd_intr_establish(SPD_NIC, smap_intr, sc);

        rnd_attach_source(&sc->rnd_source, DEVNAME,
            RND_TYPE_NET, RND_FLAG_DEFAULT);
}

int
smap_ioctl(struct ifnet *ifp, u_long command, void *data)
{
        struct smap_softc *sc = ifp->if_softc;
        int error, s;

        s = splnet();

        error = ether_ioctl(ifp, command, data);

        if (error == ENETRESET) {
                if (ifp->if_flags & IFF_RUNNING)
                        emac3_setmulti(&sc->emac3, &sc->ethercom);
                error = 0;
        }

        splx(s);

        return (error);
}

int
smap_intr(void *arg)
{
        struct smap_softc *sc = arg;
        struct ifnet *ifp;
        u_int16_t cause, disable, r;

        cause = _reg_read_2(SPD_INTR_STATUS_REG16) &
            _reg_read_2(SPD_INTR_ENABLE_REG16);

        disable = cause & (SPD_INTR_RXDNV | SPD_INTR_TXDNV);
        if (disable) {
                r = _reg_read_2(SPD_INTR_ENABLE_REG16);
                r &= ~disable;
                _reg_write_2(SPD_INTR_ENABLE_REG16, r);

                printf("%s: invalid descriptor. (%c%c)\n", DEVNAME,
                    disable & SPD_INTR_RXDNV ? 'R' : '_',
                    disable & SPD_INTR_TXDNV ? 'T' : '_');

                if (disable & SPD_INTR_RXDNV)
                        smap_rxeof(arg);

                _reg_write_2(SPD_INTR_CLEAR_REG16, disable);
        }

        if (cause & SPD_INTR_TXEND) {
                _reg_write_2(SPD_INTR_CLEAR_REG16, SPD_INTR_TXEND);
                if (_reg_read_1(SMAP_RXFIFO_FRAME_REG8) > 0)
                        cause |= SPD_INTR_RXEND;
                smap_txeof(arg);
        }

        if (cause & SPD_INTR_RXEND) {
                _reg_write_2(SPD_INTR_CLEAR_REG16, SPD_INTR_RXEND);
                smap_rxeof(arg);
                if (sc->tx_desc_cnt > 0 &&
                    sc->tx_desc_cnt > _reg_read_1(SMAP_TXFIFO_FRAME_REG8))
                        smap_txeof(arg);
        }

        if (cause & SPD_INTR_EMAC3)
                emac3_intr(arg);

        /* if transmission is pending, start here */
        ifp = &sc->ethercom.ec_if;
        if_schedule_deferred_start(ifp);
        rnd_add_uint32(&sc->rnd_source, cause | sc->tx_fifo_ptr << 16);

        return (1);
}

void
smap_rxeof(void *arg)
{
        struct smap_softc *sc = arg;
        struct smap_desc *d;
        struct ifnet *ifp = &sc->ethercom.ec_if;
        struct mbuf *m;
        u_int16_t r16, stat;
        u_int32_t *p;
        int i, j, sz, rxsz, cnt;

        FUNC_ENTER();

        i = sc->rx_done_index;

        for (cnt = 0;; cnt++, i = (i + 1) & 0x3f) {
                m = NULL;
                d = &sc->rx_desc[i];
                stat = d->stat;

                if ((stat & SMAP_RXDESC_EMPTY) != 0) {
                        break;
                } else if (stat & 0x7fff) {
                        if_statinc(ifp, if_ierrors);
                        goto next_packet;
                }

                sz = d->sz;
                rxsz = ROUND4(sz);

                KDASSERT(sz >= ETHER_ADDR_LEN * 2 + ETHER_TYPE_LEN);
                KDASSERT(sz <= ETHER_MAX_LEN);

                /* load data from FIFO */
                _reg_write_2(SMAP_RXFIFO_PTR_REG16, d->ptr & 0x3ffc);
                p = sc->rx_buf;
                for (j = 0; j < rxsz; j += sizeof(u_int32_t)) {
                        *p++ = _reg_read_4(SMAP_RXFIFO_DATA_REG);
                }

                /* put to mbuf */
                MGETHDR(m, M_DONTWAIT, MT_DATA);
                if (m == NULL) {
                        printf("%s: unable to allocate Rx mbuf\n", DEVNAME);
                        if_statinc(ifp, if_ierrors);
                        goto next_packet;
                }

                if (sz > (MHLEN - 2)) {
                        MCLGET(m, M_DONTWAIT);
                        if ((m->m_flags & M_EXT) == 0) {
                                printf("%s: unable to allocate Rx cluster\n",
                                    DEVNAME);
                                m_freem(m);
                                m = NULL;
                                if_statinc(ifp, if_ierrors);
                                goto next_packet;
                        }
                }

                m->m_data += 2; /* for alignment */
                m_set_rcvif(m, ifp);
                m->m_pkthdr.len = m->m_len = sz;
                memcpy(mtod(m, void *), (void *)sc->rx_buf, sz);

        next_packet:
                _reg_write_1(SMAP_RXFIFO_FRAME_DEC_REG8, 1);

                /* free descriptor */
                d->sz   = 0;
                d->ptr  = 0;
                d->stat = SMAP_RXDESC_EMPTY;
                _wbflush();

                if (m != NULL)
                        if_percpuq_enqueue(ifp->if_percpuq, m);
        }
        sc->rx_done_index = i;

        r16 = _reg_read_2(SPD_INTR_ENABLE_REG16);
        if (((r16 & SPD_INTR_RXDNV) == 0) && cnt > 0) {
                r16  |= SPD_INTR_RXDNV;
                _reg_write_2(SPD_INTR_ENABLE_REG16, r16);
        }

        FUNC_EXIT();
}

void
smap_txeof(void *arg)
{
        struct smap_softc *sc = arg;
        struct ifnet *ifp = &sc->ethercom.ec_if;
        struct smap_desc *d;
        int i;

        FUNC_ENTER();

        /* clear the timeout timer. */
        ifp->if_timer = 0;

        /* garbage collect */
        for (i = sc->tx_done_index;; i = (i + 1) & 0x3f) {
                u_int16_t stat;

                d = &sc->tx_desc[i];
                stat = d->stat;
                if (stat & SMAP_TXDESC_READY) {
                        /* all descriptor processed. */
                        break;
                } else if (stat & 0x7fff) {
                        if (stat & (SMAP_TXDESC_ECOLL | SMAP_TXDESC_LCOLL |
                            SMAP_TXDESC_MCOLL | SMAP_TXDESC_SCOLL))
                                if_statinc(ifp, if_collisions);
                        else
                                if_statinc(ifp, if_oerrors);
                } else {
                        if_statinc(ifp, if_opackets);
                }

                if (sc->tx_desc_cnt == 0)
                        break;

                sc->tx_buf_freesize += ROUND4(d->sz);
                sc->tx_desc_cnt--;

                d->sz = 0;
                d->ptr = 0;
                d->stat = 0;
                _wbflush();
        }
        sc->tx_done_index = i;

        FUNC_EXIT();
}

void
smap_start(struct ifnet *ifp)
{
        struct smap_softc *sc = ifp->if_softc;
        struct smap_desc *d;
        struct mbuf *m0, *m;
        u_int8_t *p, *q;
        u_int32_t *r;
        int i, sz, pktsz;
        u_int16_t fifop;
        u_int16_t r16;

        KDASSERT(ifp->if_flags & IFF_RUNNING);
        FUNC_ENTER();

        while (1) {
                IFQ_POLL(&ifp->if_snd, m0);
                if (m0 == NULL)
                        goto end;

                pktsz = m0->m_pkthdr.len;
                KDASSERT(pktsz <= ETHER_MAX_LEN - ETHER_CRC_LEN);
                sz = ROUND4(pktsz);

                if (sz > sc->tx_buf_freesize ||
                    sc->tx_desc_cnt >= SMAP_DESC_MAX ||
                    emac3_tx_done() != 0) {
                        goto end;
                }

                IFQ_DEQUEUE(&ifp->if_snd, m0);
                KDASSERT(m0 != NULL);
                bpf_mtap(ifp, m0, BPF_D_OUT);

                p = (u_int8_t *)sc->tx_buf;
                q = p + sz;
                /* copy to temporary buffer area */
                for (m = m0; m != 0; m = m->m_next) {
                        memcpy(p, mtod(m, void *), m->m_len);
                        p += m->m_len;
                }
                m_freem(m0);

                /* zero padding area */
                for (; p < q; p++)
                        *p = 0;

                /* put to FIFO */
                fifop = sc->tx_fifo_ptr;
                KDASSERT((fifop & 3) == 0);
                _reg_write_2(SMAP_TXFIFO_PTR_REG16, fifop);
                sc->tx_fifo_ptr = (fifop + sz) & 0xfff;

                r = sc->tx_buf;
                for (i = 0; i < sz; i += sizeof(u_int32_t))
                        *(volatile u_int32_t *)SMAP_TXFIFO_DATA_REG = *r++;
                _wbflush();

                /* put FIFO to EMAC3 */
                d = &sc->tx_desc[sc->tx_start_index];
                KDASSERT((d->stat & SMAP_TXDESC_READY) == 0);

                d->sz = pktsz;
                d->ptr = fifop + SMAP_TXBUF_BASE;
                d->stat = SMAP_TXDESC_READY | SMAP_TXDESC_GENFCS |
                    SMAP_TXDESC_GENPAD;
                _wbflush();

                sc->tx_buf_freesize -= sz;
                sc->tx_desc_cnt++;
                sc->tx_start_index = (sc->tx_start_index + 1) & 0x3f;
                _reg_write_1(SMAP_TXFIFO_FRAME_INC_REG8, 1);

                emac3_tx_kick();
                r16 = _reg_read_2(SPD_INTR_ENABLE_REG16);
                if ((r16 & SPD_INTR_TXDNV) == 0) {
                        r16 |= SPD_INTR_TXDNV;
                        _reg_write_2(SPD_INTR_ENABLE_REG16, r16);
                }
        }
 end:
        /* set watchdog timer */
        ifp->if_timer = 5;

        FUNC_EXIT();
}

void
smap_watchdog(struct ifnet *ifp)
{
        struct smap_softc *sc = ifp->if_softc;

        printf("%s: watchdog timeout\n", DEVNAME);
        if_statinc(ifp, if_oerrors);

        smap_fifo_init(sc);
        smap_desc_init(sc);
        emac3_reset(&sc->emac3);
}

int
smap_init(struct ifnet *ifp)
{
        struct smap_softc *sc = ifp->if_softc;
        u_int16_t r16;
        int rc;

        smap_fifo_init(sc);
        emac3_reset(&sc->emac3);
        smap_desc_init(sc);

        _reg_write_2(SPD_INTR_CLEAR_REG16, SPD_INTR_RXEND | SPD_INTR_TXEND |
            SPD_INTR_RXDNV);
        emac3_intr_clear();

        r16 = _reg_read_2(SPD_INTR_ENABLE_REG16);
        r16 |=  SPD_INTR_EMAC3 | SPD_INTR_RXEND | SPD_INTR_TXEND |
            SPD_INTR_RXDNV;
        _reg_write_2(SPD_INTR_ENABLE_REG16, r16);
        emac3_intr_enable();

        emac3_enable();

        /* Program the multicast filter, if necessary. */
        emac3_setmulti(&sc->emac3, &sc->ethercom);

        /* Set current media. */
        if ((rc = mii_mediachg(&sc->emac3.mii)) == ENXIO)
                rc = 0;
        else if (rc != 0)
                return rc;

        ifp->if_flags |= IFF_RUNNING;

        return (0);
}

void
smap_stop(struct ifnet *ifp, int disable)
{
        struct smap_softc *sc = ifp->if_softc;

        mii_down(&sc->emac3.mii);

        ifp->if_flags &= ~IFF_RUNNING;

        if (disable)
                emac3_disable();
}

/*
 * FIFO
 */
int
smap_fifo_init(struct smap_softc *sc)
{

        if (smap_fifo_reset(SMAP_TXFIFO_CTRL_REG8) != 0)
                goto error;

        if (smap_fifo_reset(SMAP_RXFIFO_CTRL_REG8) != 0)
                goto error;

        return (0);
error:
        printf("%s: FIFO reset not complete.\n", DEVNAME);

        return (1);
}

int
smap_fifo_reset(bus_addr_t a)
{
        int retry = 10000;

        _reg_write_1(a, SMAP_FIFO_RESET);

        while ((_reg_read_1(a) & SMAP_FIFO_RESET) && --retry > 0)
                ;

        return (retry == 0);
}

/*
 * Buffer descriptor
 */
void
smap_desc_init(struct smap_softc *sc)
{
        struct smap_desc *d;
        int i;

        sc->tx_desc = (void *)SMAP_TXDESC_BASE;
        sc->rx_desc = (void *)SMAP_RXDESC_BASE;

        sc->tx_buf_freesize = SMAP_TXBUF_SIZE;
        sc->tx_fifo_ptr = 0;
        sc->tx_start_index = 0;
        sc->tx_done_index = 0;
        sc->rx_done_index = 0;

        /* initialize entry */
        d = sc->tx_desc;
        for (i = 0; i < SMAP_DESC_MAX; i++, d++) {
                d->stat = 0;
                d->__reserved = 0;
                d->sz = 0;
                d->ptr = 0;
        }

        d = sc->rx_desc;
        for (i = 0; i < SMAP_DESC_MAX; i++, d++) {
                d->stat = SMAP_RXDESC_EMPTY;
                d->__reserved = 0;
                d->sz = 0;
                d->ptr = 0;
        }
        _wbflush();
}


/*
 * EEPROM
 */
int
smap_get_eaddr(struct smap_softc *sc, u_int8_t *eaddr)
{
        u_int16_t checksum, *p = (u_int16_t *)eaddr;

        spd_eeprom_read(0, p, 3);
        spd_eeprom_read(3, &checksum, 1);

        if (checksum != (u_int16_t)(p[0] + p[1] + p[2])) {
                printf("%s: Ethernet address checksum error.(%s)\n",
                    DEVNAME, ether_sprintf(eaddr));
                return (1);
        }

        return (0);
}

#ifdef SMAP_DEBUG
#include <mips/locore.h>
void
__smap_lock_check(const char *func, int enter)
{
        static int cnt;
        static const char *last;

        cnt += enter ? 1 : -1;

        if (cnt < 0 || cnt > 1)
                panic("%s cnt=%d last=%s", func, cnt, last);

        last = func;
}

void
__smap_status(int msg)
{
        static int cnt;
        DPRINTF("%d: tx=%d rx=%d txcnt=%d free=%d cnt=%d\n", msg,
            _reg_read_1(SMAP_TXFIFO_FRAME_REG8),
            _reg_read_1(SMAP_RXFIFO_FRAME_REG8), __sc->tx_desc_cnt,
            __sc->tx_buf_freesize, cnt++);
}
#endif /* SMAP_DEBUG */