/*
 * Copyright (c) 2015 Qualcomm Atheros, 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 <net/mac80211.h>

#include "core.h"
#include "debug.h"
#include "hif.h"
#include "mac.h"
#include "wmi-ops.h"
#include "wmi.h"

static const struct wiphy_wowlan_support ath10k_wowlan_support = {
    .flags = WIPHY_WOWLAN_DISCONNECT | WIPHY_WOWLAN_MAGIC_PKT,
    .pattern_min_len = WOW_MIN_PATTERN_SIZE,
    .pattern_max_len = WOW_MAX_PATTERN_SIZE,
    .max_pkt_offset = WOW_MAX_PKT_OFFSET,
};

static int ath10k_wow_vif_cleanup(struct ath10k_vif* arvif) {
    struct ath10k* ar = arvif->ar;
    int i, ret;

    for (i = 0; i < WOW_EVENT_MAX; i++) {
        ret = ath10k_wmi_wow_add_wakeup_event(ar, arvif->vdev_id, i, 0);
        if (ret) {
            ath10k_warn("failed to issue wow wakeup for event %s on vdev %i: %d\n",
                        wow_wakeup_event(i), arvif->vdev_id, ret);
            return ret;
        }
    }

    for (i = 0; i < ar->wow.max_num_patterns; i++) {
        ret = ath10k_wmi_wow_del_pattern(ar, arvif->vdev_id, i);
        if (ret) {
            ath10k_warn("failed to delete wow pattern %d for vdev %i: %d\n", i, arvif->vdev_id,
                        ret);
            return ret;
        }
    }

    return 0;
}

static int ath10k_wow_cleanup(struct ath10k* ar) {
    struct ath10k_vif* arvif;
    int ret;

    ASSERT_MTX_HELD(&ar->conf_mutex);

    list_for_each_entry(arvif, &ar->arvifs, list) {
        ret = ath10k_wow_vif_cleanup(arvif);
        if (ret) {
            ath10k_warn("failed to clean wow wakeups on vdev %i: %d\n", arvif->vdev_id, ret);
            return ret;
        }
    }

    return 0;
}

static int ath10k_vif_wow_set_wakeups(struct ath10k_vif* arvif, struct cfg80211_wowlan* wowlan) {
    int ret, i;
    BITARR(wow_mask, WOW_EVENT_MAX) = {0};
    struct ath10k* ar = arvif->ar;
    const struct cfg80211_pkt_pattern* patterns = wowlan->patterns;
    int pattern_id = 0;

    /* Setup requested WOW features */
    switch (arvif->vdev_type) {
    case WMI_VDEV_TYPE_IBSS:
        BITARR_SET(&wow_mask, WOW_BEACON_EVENT);
    /* fall through */
    case WMI_VDEV_TYPE_AP:
        BITARR_SET(&wow_mask, WOW_DEAUTH_RECVD_EVENT);
        BITARR_SET(&wow_mask, WOW_DISASSOC_RECVD_EVENT);
        BITARR_SET(&wow_mask, WOW_PROBE_REQ_WPS_IE_EVENT);
        BITARR_SET(&wow_mask, WOW_AUTH_REQ_EVENT);
        BITARR_SET(&wow_mask, WOW_ASSOC_REQ_EVENT);
        BITARR_SET(&wow_mask, WOW_HTT_EVENT);
        BITARR_SET(&wow_mask, WOW_RA_MATCH_EVENT);
        break;
    case WMI_VDEV_TYPE_STA:
        if (wowlan->disconnect) {
            BITARR_SET(&wow_mask, WOW_DEAUTH_RECVD_EVENT);
            BITARR_SET(&wow_mask, WOW_DISASSOC_RECVD_EVENT);
            BITARR_SET(&wow_mask, WOW_BMISS_EVENT);
            BITARR_SET(&wow_mask, WOW_CSA_IE_EVENT);
        }

        if (wowlan->magic_pkt) { BITARR_SET(&wow_mask, WOW_MAGIC_PKT_RECVD_EVENT); }
        break;
    default:
        break;
    }

    for (i = 0; i < wowlan->n_patterns; i++) {
        uint8_t bitmask[WOW_MAX_PATTERN_SIZE] = {};
        int j;

        if (patterns[i].pattern_len > WOW_MAX_PATTERN_SIZE) { continue; }

        /* convert bytemask to bitmask */
        for (j = 0; j < patterns[i].pattern_len; j++)
            if (patterns[i].mask[j / 8] & BIT(j % 8)) { bitmask[j] = 0xff; }

        ret = ath10k_wmi_wow_add_pattern(ar, arvif->vdev_id, pattern_id, patterns[i].pattern,
                                         bitmask, patterns[i].pattern_len, patterns[i].pkt_offset);
        if (ret) {
            ath10k_warn("failed to add pattern %i to vdev %i: %d\n", pattern_id, arvif->vdev_id,
                        ret);
            return ret;
        }

        pattern_id++;
        BITARR_SET(&wow_mask, WOW_PATTERN_MATCH_EVENT);
    }

    for (i = 0; i < WOW_EVENT_MAX; i++) {
        if (!BITARR_TEST(&wow_mask, i)) { continue; }
        ret = ath10k_wmi_wow_add_wakeup_event(ar, arvif->vdev_id, i, 1);
        if (ret) {
            ath10k_warn("failed to enable wakeup event %s on vdev %i: %d\n", wow_wakeup_event(i),
                        arvif->vdev_id, ret);
            return ret;
        }
    }

    return 0;
}

static int ath10k_wow_set_wakeups(struct ath10k* ar, struct cfg80211_wowlan* wowlan) {
    struct ath10k_vif* arvif;
    int ret;

    ASSERT_MTX_HELD(&ar->conf_mutex);

    list_for_each_entry(arvif, &ar->arvifs, list) {
        ret = ath10k_vif_wow_set_wakeups(arvif, wowlan);
        if (ret) {
            ath10k_warn("failed to set wow wakeups on vdev %i: %d\n", arvif->vdev_id, ret);
            return ret;
        }
    }

    return 0;
}

static int ath10k_wow_enable(struct ath10k* ar) {
    int ret;

    ASSERT_MTX_HELD(&ar->conf_mutex);

    sync_completion_reset(&ar->target_suspend);

    ret = ath10k_wmi_wow_enable(ar);
    if (ret) {
        ath10k_warn("failed to issue wow enable: %d\n", ret);
        return ret;
    }

    if (sync_completion_wait(&ar->target_suspend, ZX_SEC(3)) == ZX_ERR_TIMED_OUT) {
        ath10k_warn("timed out while waiting for suspend completion\n");
        return -ETIMEDOUT;
    }

    return 0;
}

static int ath10k_wow_wakeup(struct ath10k* ar) {
    int ret;

    ASSERT_MTX_HELD(&ar->conf_mutex);

    sync_completion_reset(&ar->wow.wakeup_completed);

    ret = ath10k_wmi_wow_host_wakeup_ind(ar);
    if (ret) {
        ath10k_warn("failed to send wow wakeup indication: %d\n", ret);
        return ret;
    }

    if (sync_completion_wait(&ar->wow.wakeup_completed, ZX_SEC(3)) == ZX_ERR_TIMED_OUT) {
        ath10k_warn("timed out while waiting for wow wakeup completion\n");
        return -ETIMEDOUT;
    }

    return 0;
}

int ath10k_wow_op_suspend(struct ieee80211_hw* hw, struct cfg80211_wowlan* wowlan) {
    struct ath10k* ar = hw->priv;
    int ret;

    mtx_lock(&ar->conf_mutex);

    if (COND_WARN(
            !BITARR_TEST(ar->running_fw->fw_file.fw_features, ATH10K_FW_FEATURE_WOWLAN_SUPPORT))) {
        ret = 1;
        goto exit;
    }

    ret = ath10k_wow_cleanup(ar);
    if (ret) {
        ath10k_warn("failed to clear wow wakeup events: %d\n", ret);
        goto exit;
    }

    ret = ath10k_wow_set_wakeups(ar, wowlan);
    if (ret) {
        ath10k_warn("failed to set wow wakeup events: %d\n", ret);
        goto cleanup;
    }

    ret = ath10k_wow_enable(ar);
    if (ret) {
        ath10k_warn("failed to start wow: %d\n", ret);
        goto cleanup;
    }

    ret = ath10k_hif_suspend(ar);
    if (ret) {
        ath10k_warn("failed to suspend hif: %d\n", ret);
        goto wakeup;
    }

    goto exit;

wakeup:
    ath10k_wow_wakeup(ar);

cleanup:
    ath10k_wow_cleanup(ar);

exit:
    mtx_unlock(&ar->conf_mutex);
    return ret ? 1 : 0;
}

int ath10k_wow_op_resume(struct ieee80211_hw* hw) {
    struct ath10k* ar = hw->priv;
    int ret;

    mtx_lock(&ar->conf_mutex);

    if (COND_WARN(
            !BITARR_TEST(ar->running_fw->fw_file.fw_features, ATH10K_FW_FEATURE_WOWLAN_SUPPORT))) {
        ret = 1;
        goto exit;
    }

    ret = ath10k_hif_resume(ar);
    if (ret) {
        ath10k_warn("failed to resume hif: %d\n", ret);
        goto exit;
    }

    ret = ath10k_wow_wakeup(ar);
    if (ret) { ath10k_warn("failed to wakeup from wow: %d\n", ret); }

exit:
    if (ret) {
        switch (ar->state) {
        case ATH10K_STATE_ON:
            ar->state = ATH10K_STATE_RESTARTING;
            ret = 1;
            break;
        case ATH10K_STATE_OFF:
        case ATH10K_STATE_RESTARTING:
        case ATH10K_STATE_RESTARTED:
        case ATH10K_STATE_UTF:
        case ATH10K_STATE_WEDGED:
            ath10k_warn("encountered unexpected device state %d on resume, cannot recover\n",
                        ar->state);
            ret = -EIO;
            break;
        }
    }

    mtx_unlock(&ar->conf_mutex);
    return ret;
}

int ath10k_wow_init(struct ath10k* ar) {
    if (!BITARR_TEST(ar->running_fw->fw_file.fw_features, ATH10K_FW_FEATURE_WOWLAN_SUPPORT)) {
        return 0;
    }

    if (COND_WARN(!BITARR_TEST(ar->wmi.svc_map, WMI_SERVICE_WOW))) { return -EINVAL; }

    ar->wow.wowlan_support = ath10k_wowlan_support;
    ar->wow.wowlan_support.n_patterns = ar->wow.max_num_patterns;
    ar->hw->wiphy->wowlan = &ar->wow.wowlan_support;

    return 0;
}