/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright (c) 2008 Atheros Communications Inc.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/param.h>
#include <sys/strsun.h>
#include <inet/common.h>
#include <inet/nd.h>
#include <inet/mi.h>
#include <inet/wifi_ioctl.h>

#include "arn_core.h"

/*
 * Associates the beacon frame buffer with a transmit descriptor.  Will set
 * up all required antenna switch parameters, rate codes, and channel flags.
 * Beacons are always sent out at the lowest rate, and are not retried.
 */
#ifdef ARN_IBSS
static void
arn_beacon_setup(struct arn_softc *sc, struct ath_buf *bf)
{
#define USE_SHPREAMBLE(_ic) \
        (((_ic)->ic_flags & (IEEE80211_F_SHPREAMBLE | IEEE80211_F_USEBARKER))\
            == IEEE80211_F_SHPREAMBLE)
        mblk_t *mp = bf->bf_m;
        struct ath_hal *ah = sc->sc_ah;
        struct ath_desc *ds;
        /* LINTED E_FUNC_SET_NOT_USED */
        int flags, antenna = 0;
        struct ath_rate_table *rt;
        uint8_t rix, rate;
        struct ath9k_11n_rate_series series[4];
        int ctsrate = 0;
        int ctsduration = 0;

        /* set up descriptors */
        ds = bf->bf_desc;

        flags = ATH9K_TXDESC_NOACK;
        if (sc->sc_ah->ah_opmode == ATH9K_M_IBSS &&
            (ah->ah_caps.hw_caps & ATH9K_HW_CAP_VEOL)) {
                ds->ds_link = bf->bf_daddr;     /* self-linked */
                flags |= ATH9K_TXDESC_VEOL;
                /*
                 * Let hardware handle antenna switching.
                 */
                antenna = 0;
        } else {
                ds->ds_link = 0;
                /*
                 * Switch antenna every 4 beacons.
                 * NB: assumes two antenna
                 */
                antenna = ((sc->ast_be_xmit / sc->sc_nbcnvaps) & 1 ? 2 : 1);
        }

        ds->ds_data = bf->bf_dma.cookie.dmac_address;
        /*
         * Calculate rate code.
         * XXX everything at min xmit rate
         */
        rix = 0;
        rt = sc->hw_rate_table[sc->sc_curmode];
        rate = rt->info[rix].ratecode;
        if (sc->sc_flags & SC_OP_PREAMBLE_SHORT)
                rate |= rt->info[rix].short_preamble;

        ath9k_hw_set11n_txdesc(ah, ds,
            MBLKL(mp) + IEEE80211_CRC_LEN, /* frame length */
            ATH9K_PKT_TYPE_BEACON,      /* Atheros packet type */
            MAX_RATE_POWER,             /* FIXME */
            ATH9K_TXKEYIX_INVALID,      /* no encryption */
            ATH9K_KEY_TYPE_CLEAR,       /* no encryption */
            flags);                     /* no ack, veol for beacons */

        /* NB: beacon's BufLen must be a multiple of 4 bytes */
        (void) ath9k_hw_filltxdesc(ah, ds,
            roundup(MBLKL(mp), 4),      /* buffer length */
            B_TRUE,                     /* first segment */
            B_TRUE,                     /* last segment */
            ds);                        /* first descriptor */

        (void) memset(series, 0, sizeof (struct ath9k_11n_rate_series) * 4);
        series[0].Tries = 1;
        series[0].Rate = rate;
        series[0].ChSel = sc->sc_tx_chainmask;
        series[0].RateFlags = (ctsrate) ? ATH9K_RATESERIES_RTS_CTS : 0;
        ath9k_hw_set11n_ratescenario(ah, ds, ds, 0,
            ctsrate, ctsduration, series, 4, 0);
#undef  USE_SHPREAMBLE
}
#endif

/*
 * Startup beacon transmission for adhoc mode when they are sent entirely
 * by the hardware using the self-linked descriptor + veol trick.
 */
#ifdef ARN_IBSS
static void
arn_beacon_start_adhoc(struct arn_softc *sc)
{
        struct ath_buf *bf = list_head(&sc->sc_bcbuf_list);
        struct ieee80211_node *in = bf->bf_in;
        struct ieee80211com *ic = in->in_ic;
        struct ath_hal *ah = sc->sc_ah;
        mblk_t *mp;

        mp = bf->bf_m;
        if (ieee80211_beacon_update(ic, bf->bf_in, &sc->asc_boff, mp, 0))
                bcopy(mp->b_rptr, bf->bf_dma.mem_va, MBLKL(mp));

        /* Construct tx descriptor. */
        arn_beacon_setup(sc, bf);

        /*
         * Stop any current dma and put the new frame on the queue.
         * This should never fail since we check above that no frames
         * are still pending on the queue.
         */
        if (!ath9k_hw_stoptxdma(ah, sc->sc_beaconq)) {
                arn_problem("ath: beacon queue %d did not stop?\n",
                    sc->sc_beaconq);
        }
        ARN_DMA_SYNC(bf->bf_dma, DDI_DMA_SYNC_FORDEV);

        /* NB: caller is known to have already stopped tx dma */
        (void) ath9k_hw_puttxbuf(ah, sc->sc_beaconq, bf->bf_daddr);
        (void) ath9k_hw_txstart(ah, sc->sc_beaconq);

        ARN_DBG((ARN_DBG_BEACON, "arn: arn_bstuck_process(): "
            "TXDP%u = %llx (%p)\n", sc->sc_beaconq,
            ito64(bf->bf_daddr), bf->bf_desc));
}
#endif /* ARN_IBSS */

uint32_t
arn_beaconq_setup(struct ath_hal *ah)
{
        struct ath9k_tx_queue_info qi;

        (void) memset(&qi, 0, sizeof (qi));
        qi.tqi_aifs = 1;
        qi.tqi_cwmin = 0;
        qi.tqi_cwmax = 0;
        /* NB: don't enable any interrupts */
        return (ath9k_hw_setuptxqueue(ah, ATH9K_TX_QUEUE_BEACON, &qi));
}

int
arn_beacon_alloc(struct arn_softc *sc, struct ieee80211_node *in)
{
        ieee80211com_t  *ic = in->in_ic;
        struct ath_buf *bf;
        mblk_t *mp;

        mutex_enter(&sc->sc_bcbuflock);
        bf = list_head(&sc->sc_bcbuf_list);
        if (bf == NULL) {
                arn_problem("arn: arn_beacon_alloc():"
                    "no dma buffers");
                mutex_exit(&sc->sc_bcbuflock);
                return (ENOMEM);
        }

        mp = ieee80211_beacon_alloc(ic, in, &sc->asc_boff);
        if (mp == NULL) {
                arn_problem("ath: arn_beacon_alloc():"
                    "cannot get mbuf\n");
                mutex_exit(&sc->sc_bcbuflock);
                return (ENOMEM);
        }
        ASSERT(mp->b_cont == NULL);
        bf->bf_m = mp;
        bcopy(mp->b_rptr, bf->bf_dma.mem_va, MBLKL(mp));
        bf->bf_in = ieee80211_ref_node(in);
        mutex_exit(&sc->sc_bcbuflock);

        return (0);
}


void
arn_beacon_return(struct arn_softc *sc)
{
        struct ath_buf *bf;

        mutex_enter(&sc->sc_bcbuflock);
        bf = list_head(&sc->sc_bcbuf_list);
        while (bf != NULL) {
                if (bf->bf_m != NULL) {
                        freemsg(bf->bf_m);
                        bf->bf_m = NULL;
                }
                if (bf->bf_in != NULL) {
                        ieee80211_free_node(bf->bf_in);
                        bf->bf_in = NULL;
                }
                bf = list_next(&sc->sc_bcbuf_list, bf);
        }
        mutex_exit(&sc->sc_bcbuflock);
}

void
arn_beacon_config(struct arn_softc *sc)
{
        struct ath_beacon_config conf;
        ieee80211com_t *ic = (ieee80211com_t *)sc;
        struct ieee80211_node *in = ic->ic_bss;

        /* New added */
        struct ath9k_beacon_state bs;
        int dtimperiod, dtimcount, sleepduration;
        int cfpperiod, cfpcount;
        uint32_t nexttbtt = 0, intval, tsftu;
        uint64_t tsf;

        (void) memset(&conf, 0, sizeof (struct ath_beacon_config));

        /* XXX fix me */
        conf.beacon_interval = in->in_intval ?
            in->in_intval : ATH_DEFAULT_BINTVAL;
        ARN_DBG((ARN_DBG_BEACON, "arn: arn_beacon_config():"
            "conf.beacon_interval = %d\n", conf.beacon_interval));
        conf.listen_interval = 1;
        conf.dtim_period = conf.beacon_interval;
        conf.dtim_count = 1;
        conf.bmiss_timeout = ATH_DEFAULT_BMISS_LIMIT * conf.beacon_interval;

        (void) memset(&bs, 0, sizeof (bs));
        intval = conf.beacon_interval & ATH9K_BEACON_PERIOD;

        /*
         * Setup dtim and cfp parameters according to
         * last beacon we received (which may be none).
         */
        dtimperiod = conf.dtim_period;
        if (dtimperiod <= 0)            /* NB: 0 if not known */
                dtimperiod = 1;
        dtimcount = conf.dtim_count;
        if (dtimcount >= dtimperiod)    /* NB: sanity check */
                dtimcount = 0;
        cfpperiod = 1;                  /* NB: no PCF support yet */
        cfpcount = 0;

        sleepduration = conf.listen_interval * intval;
        if (sleepduration <= 0)
                sleepduration = intval;

        /*
         * Pull nexttbtt forward to reflect the current
         * TSF and calculate dtim+cfp state for the result.
         */
        tsf = ath9k_hw_gettsf64(sc->sc_ah);
        tsftu = TSF_TO_TU(tsf>>32, tsf) + FUDGE;
        do {
                nexttbtt += intval;
                if (--dtimcount < 0) {
                        dtimcount = dtimperiod - 1;
                        if (--cfpcount < 0)
                                cfpcount = cfpperiod - 1;
                }
        } while (nexttbtt < tsftu);

        bs.bs_intval = intval;
        bs.bs_nexttbtt = nexttbtt;
        bs.bs_dtimperiod = dtimperiod*intval;
        bs.bs_nextdtim = bs.bs_nexttbtt + dtimcount*intval;
        bs.bs_cfpperiod = cfpperiod*bs.bs_dtimperiod;
        bs.bs_cfpnext = bs.bs_nextdtim + cfpcount*bs.bs_dtimperiod;
        bs.bs_cfpmaxduration = 0;

        /*
         * Calculate the number of consecutive beacons to miss* before taking
         * a BMISS interrupt. The configuration is specified in TU so we only
         * need calculate based on the beacon interval.  Note that we clamp the
         * result to at most 15 beacons.
         */
        if (sleepduration > intval) {
                bs.bs_bmissthreshold = conf.listen_interval *
                    ATH_DEFAULT_BMISS_LIMIT / 2;
        } else {
                bs.bs_bmissthreshold = DIV_ROUND_UP(conf.bmiss_timeout, intval);
                if (bs.bs_bmissthreshold > 15)
                        bs.bs_bmissthreshold = 15;
                else if (bs.bs_bmissthreshold == 0)
                        bs.bs_bmissthreshold = 1;
        }

        /*
         * Calculate sleep duration. The configuration is given in ms.
         * We ensure a multiple of the beacon period is used. Also, if the sleep
         * duration is greater than the DTIM period then it makes senses
         * to make it a multiple of that.
         *
         * XXX fixed at 100ms
         */

        bs.bs_sleepduration = roundup(IEEE80211_MS_TO_TU(100), sleepduration);
        if (bs.bs_sleepduration > bs.bs_dtimperiod)
                bs.bs_sleepduration = bs.bs_dtimperiod;

        /* TSF out of range threshold fixed at 1 second */
        bs.bs_tsfoor_threshold = ATH9K_TSFOOR_THRESHOLD;

        ARN_DBG((ARN_DBG_BEACON, "arn: arn_beacon_config(): "
            "tsf %llu "
            "tsf:tu %u "
            "intval %u "
            "nexttbtt %u "
            "dtim %u "
            "nextdtim %u "
            "bmiss %u "
            "sleep %u "
            "cfp:period %u "
            "maxdur %u "
            "next %u "
            "timoffset %u\n",
            (unsigned long long)tsf, tsftu,
            bs.bs_intval,
            bs.bs_nexttbtt,
            bs.bs_dtimperiod,
            bs.bs_nextdtim,
            bs.bs_bmissthreshold,
            bs.bs_sleepduration,
            bs.bs_cfpperiod,
            bs.bs_cfpmaxduration,
            bs.bs_cfpnext,
            bs.bs_timoffset));

        /* Set the computed STA beacon timers */

        (void) ath9k_hw_set_interrupts(sc->sc_ah, 0);
        ath9k_hw_set_sta_beacon_timers(sc->sc_ah, &bs);
        sc->sc_imask |= ATH9K_INT_BMISS;
        (void) ath9k_hw_set_interrupts(sc->sc_ah, sc->sc_imask);
}

void
ath_beacon_sync(struct arn_softc *sc)
{
        /*
         * Resync beacon timers using the tsf of the
         * beacon frame we just received.
         */
        arn_beacon_config(sc);
        sc->sc_flags |= SC_OP_BEACONS;
}

void
arn_bmiss_proc(void *arg)
{
        struct arn_softc *sc = (struct arn_softc *)arg;
        ieee80211com_t *ic = (ieee80211com_t *)sc;
        uint64_t tsf, lastrx;
        uint_t  bmisstimeout;

        if (ic->ic_opmode != IEEE80211_M_STA ||
            ic->ic_state != IEEE80211_S_RUN) {
                return;
        }

        ARN_LOCK(sc);
        lastrx = sc->sc_lastrx;
        tsf = ath9k_hw_gettsf64(sc->sc_ah);
        bmisstimeout = ic->ic_bmissthreshold * ic->ic_bss->in_intval * 1024;

        ARN_DBG((ARN_DBG_BEACON, "arn_bmiss_proc():"
            " tsf %llu, lastrx %llu (%lld), bmiss %u\n",
            (unsigned long long)tsf, (unsigned long long)sc->sc_lastrx,
            (long long)(tsf - lastrx), bmisstimeout));
        ARN_UNLOCK(sc);

        /* temp workaround */
        if ((tsf - lastrx) > bmisstimeout)
                ieee80211_beacon_miss(ic);
}