/*-
 * Copyright (c) 2016 Andriy Voskoboinyk <avos@FreeBSD.org>
 * 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 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>
#include "opt_wlan.h"

#include <sys/param.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#include <sys/mbuf.h>
#include <sys/kernel.h>
#include <sys/socket.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/queue.h>
#include <sys/taskqueue.h>
#include <sys/bus.h>
#include <sys/endian.h>
#include <sys/linker.h>

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

#include <net80211/ieee80211_var.h>
#include <net80211/ieee80211_radiotap.h>

#include <dev/rtwn/if_rtwnvar.h>
#include <dev/rtwn/if_rtwn_debug.h>

#include <dev/rtwn/usb/rtwn_usb_var.h>

#include <dev/rtwn/rtl8812a/r12a_var.h>

#include <dev/rtwn/rtl8821a/usb/r21au.h>
#include <dev/rtwn/rtl8821a/usb/r21au_reg.h>

#define R21AU_RADAR_CHECK_PERIOD        (2 * hz)

static void
r21au_dfs_radar_disable(struct rtwn_softc *sc)
{
        rtwn_bb_setbits(sc, 0x924, 0x00008000, 0);
}

static int
r21au_dfs_radar_is_enabled(struct rtwn_softc *sc)
{
        return !!(rtwn_bb_read(sc, 0x924) & 0x00008000);
}

static int
r21au_dfs_radar_reset(struct rtwn_softc *sc)
{
        int error;

        error = rtwn_bb_setbits(sc, 0x924, 0x00008000, 0);
        if (error != 0)
                return (error);

        return (rtwn_bb_setbits(sc, 0x924, 0, 0x00008000));
}

static int
r21au_dfs_radar_enable(struct rtwn_softc *sc)
{
#define RTWN_CHK(res) do {      \
        if (res != 0)           \
                return (EIO);   \
} while(0)

        RTWN_ASSERT_LOCKED(sc);

        RTWN_CHK(rtwn_bb_setbits(sc, 0x814, 0x3fffffff, 0x04cc4d10));
        RTWN_CHK(rtwn_bb_setbits(sc, R12A_BW_INDICATION, 0xff, 0x06));
        RTWN_CHK(rtwn_bb_write(sc, 0x918, 0x1c16ecdf));
        RTWN_CHK(rtwn_bb_write(sc, 0x924, 0x0152a400));
        RTWN_CHK(rtwn_bb_write(sc, 0x91c, 0x0fa21a20));
        RTWN_CHK(rtwn_bb_write(sc, 0x920, 0xe0f57204));

        return (r21au_dfs_radar_reset(sc));

#undef RTWN_CHK
}

static int
r21au_dfs_radar_is_detected(struct rtwn_softc *sc)
{
        return !!(rtwn_bb_read(sc, 0xf98) & 0x00020000);
}

void
r21au_chan_check(void *arg, int npending __unused)
{
        struct rtwn_softc *sc = arg;
        struct r12a_softc *rs = sc->sc_priv;
        struct ieee80211com *ic = &sc->sc_ic;

        RTWN_LOCK(sc);
#ifdef DIAGNOSTIC
        RTWN_DPRINTF(sc, RTWN_DEBUG_STATE,
            "%s: periodical radar detection task\n", __func__);
#endif

        if (!r21au_dfs_radar_is_enabled(sc)) {
                if (rs->rs_flags & R12A_RADAR_ENABLED) {
                        /* should not happen */
                        device_printf(sc->sc_dev,
                            "%s: radar detection was turned off "
                            "unexpectedly, resetting...\n", __func__);

                        /* XXX something more appropriate? */
                        ieee80211_restart_all(ic);
                }
                RTWN_UNLOCK(sc);
                return;
        }

        if (r21au_dfs_radar_is_detected(sc)) {
                r21au_dfs_radar_reset(sc);

                RTWN_DPRINTF(sc, RTWN_DEBUG_RADAR, "%s: got radar event\n",
                    __func__);

                RTWN_UNLOCK(sc);
                IEEE80211_LOCK(ic);

                ieee80211_dfs_notify_radar(ic, ic->ic_curchan);

                IEEE80211_UNLOCK(ic);
                RTWN_LOCK(sc);
        }

        if (rs->rs_flags & R12A_RADAR_ENABLED) {
                taskqueue_enqueue_timeout(taskqueue_thread,
                    &rs->rs_chan_check, R21AU_RADAR_CHECK_PERIOD);
        }
        RTWN_UNLOCK(sc);
}

int
r21au_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
{
        struct ieee80211com *ic = vap->iv_ic;
        struct rtwn_softc *sc = ic->ic_softc;
        struct rtwn_vap *rvp = RTWN_VAP(vap);
        struct r12a_softc *rs = sc->sc_priv;
        int error;

        KASSERT(rvp->id == 0 || rvp->id == 1,
            ("%s: unexpected vap id %d\n", __func__, rvp->id));

        IEEE80211_UNLOCK(ic);
        RTWN_LOCK(sc);

        error = 0;
        if (nstate == IEEE80211_S_CAC &&
            !(rs->rs_flags & R12A_RADAR_ENABLED)) {
                error = r21au_dfs_radar_enable(sc);
                if (error != 0) {
                        device_printf(sc->sc_dev,
                            "%s: cannot enable radar detection\n", __func__);
                        goto fail;
                }
                rs->rs_flags |= R12A_RADAR_ENABLED;

                RTWN_DPRINTF(sc, RTWN_DEBUG_RADAR,
                    "%s: radar detection was enabled\n", __func__);

                taskqueue_enqueue_timeout(taskqueue_thread,
                    &rs->rs_chan_check, R21AU_RADAR_CHECK_PERIOD);
        }

        if ((nstate < IEEE80211_S_CAC || nstate == IEEE80211_S_CSA) &&
            (rs->rs_flags & R12A_RADAR_ENABLED) &&
            (sc->vaps[!rvp->id] == NULL ||
            sc->vaps[!rvp->id]->vap.iv_state < IEEE80211_S_CAC ||
            sc->vaps[!rvp->id]->vap.iv_state == IEEE80211_S_CSA)) {
                taskqueue_cancel_timeout(taskqueue_thread, &rs->rs_chan_check,
                    NULL);

                rs->rs_flags &= ~R12A_RADAR_ENABLED;
                r21au_dfs_radar_disable(sc);

                RTWN_DPRINTF(sc, RTWN_DEBUG_RADAR,
                    "%s: radar detection was disabled\n", __func__);
        }

fail:
        RTWN_UNLOCK(sc);
        IEEE80211_LOCK(ic);

        if (error != 0)
                return (error);

        return (rs->rs_newstate[rvp->id](vap, nstate, arg));
}

void
r21au_scan_start(struct ieee80211com *ic)
{
        struct rtwn_softc *sc = ic->ic_softc;
        struct r12a_softc *rs = sc->sc_priv;

        RTWN_LOCK(sc);
        if (rs->rs_flags & R12A_RADAR_ENABLED) {
                RTWN_UNLOCK(sc);
                while (taskqueue_cancel_timeout(taskqueue_thread,
                    &rs->rs_chan_check, NULL) != 0) {
                        taskqueue_drain_timeout(taskqueue_thread,
                            &rs->rs_chan_check);
                }
                RTWN_LOCK(sc);

                r21au_dfs_radar_disable(sc);
                RTWN_DPRINTF(sc, RTWN_DEBUG_RADAR,
                    "%s: radar detection was (temporarily) disabled\n",
                    __func__);
        }
        RTWN_UNLOCK(sc);

        rs->rs_scan_start(ic);
}

void
r21au_scan_end(struct ieee80211com *ic)
{
        struct rtwn_softc *sc = ic->ic_softc;
        struct r12a_softc *rs = sc->sc_priv;
        int error;

        RTWN_LOCK(sc);
        if (rs->rs_flags & R12A_RADAR_ENABLED) {
                error = r21au_dfs_radar_enable(sc);
                if (error != 0) {
                        device_printf(sc->sc_dev,
                            "%s: cannot re-enable radar detection\n",
                            __func__);

                        /* XXX */
                        ieee80211_restart_all(ic);
                        RTWN_UNLOCK(sc);
                        return;
                }
                RTWN_DPRINTF(sc, RTWN_DEBUG_RADAR,
                    "%s: radar detection was re-enabled\n", __func__);

                taskqueue_enqueue_timeout(taskqueue_thread,
                    &rs->rs_chan_check, R21AU_RADAR_CHECK_PERIOD);
        }
        RTWN_UNLOCK(sc);

        rs->rs_scan_end(ic);
}