/*
 * Copyright (c) 2015 South Silicon Valley Microelectronics Inc.
 * Copyright (c) 2015 iComm Corporation
 *
 * This program is free software: you can redistribute it and/or modify 
 * it under the terms of the GNU General Public License as published by 
 * the Free Software Foundation, either version 3 of the License, or 
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License 
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef _DEV_H_
#define _DEV_H_ 
#include <linux/version.h>
#include <linux/device.h>
#include <linux/interrupt.h>
#ifdef CONFIG_SSV_SUPPORT_ANDROID
#include <linux/wakelock.h>
#ifdef CONFIG_HAS_EARLYSUSPEND
#include <linux/earlysuspend.h>
#endif
#endif
#include <net/mac80211.h>
#include "ampdu.h"
#include "ssv_rc_common.h"
#include "drv_comm.h"
#include "sec.h"
#include "p2p.h"
#include <linux/kthread.h>
#define SSV6200_MAX_HW_MAC_ADDR 2
#define SSV6200_MAX_VIF 2
#define SSV6200_RX_BA_MAX_SESSIONS 1
#define SSV6200_OPMODE_STA 0
#define SSV6200_OPMODE_AP 1
#define SSV6200_OPMODE_IBSS 2
#define SSV6200_OPMODE_WDS 3
#define SSV6200_USE_HW_WSID(_sta_idx) ((_sta_idx == 0) || (_sta_idx == 1))
#define HW_MAX_RATE_TRIES 7
#define MAC_DECITBL1_SIZE 16
#define MAC_DECITBL2_SIZE 9
#define RX_11B_CCA_IN_SCAN 0x20230050
//#define WATCHDOG_TIMEOUT (10*HZ)
#define WATCHDOG_TIMEOUT (99999*HZ)
#ifndef USE_GENERIC_DECI_TBL
extern u16 ap_deci_tbl[];
extern u16 sta_deci_tbl[];
#else
extern u16 generic_deci_tbl[];
#define ap_deci_tbl generic_deci_tbl
#define sta_deci_tbl generic_deci_tbl
#endif
#define HT_SIGNAL_EXT 6
#define HT_SIFS_TIME 10
#define BITS_PER_BYTE 8
#define HT_RC_2_STREAMS(_rc) ((((_rc) & 0x78) >> 3) + 1)
#define ACK_LEN (14)
#define BA_LEN (32)
#define RTS_LEN (20)
#define CTS_LEN (14)
#define L_STF 8
#define L_LTF 8
#define L_SIG 4
#define HT_SIG 8
#define HT_STF 4
#define HT_LTF(_ns) (4 * (_ns))
#define SYMBOL_TIME(_ns) ((_ns) << 2)
#define SYMBOL_TIME_HALFGI(_ns) (((_ns) * 18 + 4) / 5)
#define CCK_SIFS_TIME 10
#define CCK_PREAMBLE_BITS 144
#define CCK_PLCP_BITS 48
#define OFDM_SIFS_TIME 16
#define OFDM_PREAMBLE_TIME 20
#define OFDM_PLCP_BITS 22
#define OFDM_SYMBOL_TIME 4
#define WMM_AC_VO 0
#define WMM_AC_VI 1
#define WMM_AC_BE 2
#define WMM_AC_BK 3
#define WMM_NUM_AC 4
#define WMM_TID_NUM 8
#define TXQ_EDCA_0 0x01
#define TXQ_EDCA_1 0x02
#define TXQ_EDCA_2 0x04
#define TXQ_EDCA_3 0x08
#define TXQ_MGMT 0x10
#define IS_SSV_HT(dsc) ((dsc)->rate_idx >= 15)
#define IS_SSV_SHORT_GI(dsc) ((dsc)->rate_idx>=23 && (dsc)->rate_idx<=30)
#define IS_SSV_HT_GF(dsc) ((dsc)->rate_idx >= 31)
#define IS_SSV_SHORT_PRE(dsc) ((dsc)->rate_idx>=4 && (dsc)->rate_idx<=14)
#define SMAC_REG_WRITE(_s,_r,_v) \
        (_s)->hci.hci_ops->hci_write_word(_r,_v)
#define SMAC_REG_READ(_s,_r,_v) \
        (_s)->hci.hci_ops->hci_read_word(_r, _v)
#define SMAC_LOAD_FW(_s,_r,_v) \
        (_s)->hci.hci_ops->hci_load_fw(_r, _v)
#define SMAC_IFC_RESET(_s) (_s)->hci.hci_ops->hci_interface_reset()
#define SMAC_REG_CONFIRM(_s,_r,_v) \
{ \
    u32 _regval; \
    SMAC_REG_READ(_s, _r, &_regval); \
    if (_regval != (_v)) { \
        printk("ERROR!!Please check interface!\n"); \
        printk("[0x%08x]: 0x%08x!=0x%08x\n", \
        (_r), (_v), _regval); \
        printk("SOS!SOS!\n"); \
        return -1; \
    } \
}
#define SMAC_REG_SET_BITS(_sh,_reg,_set,_clr) \
({ \
    int ret; \
    u32 _regval; \
    ret = SMAC_REG_READ(_sh, _reg, &_regval); \
    _regval &= ~(_clr); \
    _regval |= (_set); \
    if (ret == 0) \
        ret = SMAC_REG_WRITE(_sh, _reg, _regval); \
    ret; \
})
#define HCI_START(_sh) \
    (_sh)->hci.hci_ops->hci_start()
#define HCI_STOP(_sh) \
    (_sh)->hci.hci_ops->hci_stop()
#define HCI_SEND(_sh,_sk,_q) \
    (_sh)->hci.hci_ops->hci_tx(_sk, _q, 0)
#define HCI_PAUSE(_sh,_mk) \
    (_sh)->hci.hci_ops->hci_tx_pause(_mk)
#define HCI_RESUME(_sh,_mk) \
    (_sh)->hci.hci_ops->hci_tx_resume(_mk)
#define HCI_TXQ_FLUSH(_sh,_mk) \
    (_sh)->hci.hci_ops->hci_txq_flush(_mk)
#define HCI_TXQ_FLUSH_BY_STA(_sh,_aid) \
  (_sh)->hci.hci_ops->hci_txq_flush_by_sta(_aid)
#define HCI_TXQ_EMPTY(_sh,_txqid) \
  (_sh)->hci.hci_ops->hci_txq_empty(_txqid)
#define HCI_WAKEUP_PMU(_sh) \
    (_sh)->hci.hci_ops->hci_pmu_wakeup()
#define HCI_SEND_CMD(_sh,_sk) \
        (_sh)->hci.hci_ops->hci_send_cmd(_sk)
#define SSV6XXX_SET_HW_TABLE(sh_,tbl_) \
({ \
    int ret = 0; \
    u32 i=0; \
    for(; i<sizeof(tbl_)/sizeof(struct ssv6xxx_dev_table); i++) { \
        ret = SMAC_REG_WRITE(sh_, tbl_[i].address, tbl_[i].data); \
        if (ret) break; \
    } \
    ret; \
})
#define SSV6XXX_USE_HW_DECRYPT(_priv) (_priv->has_hw_decrypt)
#define SSV6XXX_USE_SW_DECRYPT(_priv) (SSV6XXX_USE_LOCAL_SW_DECRYPT(_priv) || SSV6XXX_USE_MAC80211_DECRYPT(_priv))
#define SSV6XXX_USE_LOCAL_SW_DECRYPT(_priv) (_priv->need_sw_decrypt)
#define SSV6XXX_USE_MAC80211_DECRYPT(_priv) (_priv->use_mac80211_decrypt)
struct ssv_softc;
#ifdef CONFIG_P2P_NOA
struct ssv_p2p_noa;
#endif
#define SSV6200_HT_TX_STREAMS 1
#define SSV6200_HT_RX_STREAMS 1
#define SSV6200_RX_HIGHEST_RATE 72
enum PWRSV_STATUS{
    PWRSV_DISABLE,
    PWRSV_ENABLE,
    PWRSV_PREPARE,
};
#ifdef CONFIG_SSV_RSSI
struct rssi_res_st {
    struct list_head rssi_list;
    unsigned long cache_jiffies;
    s32 rssi;
    s32 timeout;
    u8 bssid[ETH_ALEN];
};
#endif
struct ssv_hw {
    struct ssv_softc *sc;
    struct ssv6xxx_platform_data *priv;
    struct ssv6xxx_hci_info hci;
    char chip_id[24];
    u64 chip_tag;
    u32 tx_desc_len;
    u32 rx_desc_len;
    u32 rx_pinfo_pad;
    u32 tx_page_available;
    u32 ampdu_divider;
    u8 page_count[SSV6200_ID_NUMBER];
#ifdef SSV6200_ECO
    u32 hw_buf_ptr[SSV_RC_MAX_STA];
    u32 hw_sec_key[SSV_RC_MAX_STA];
#else
    u32 hw_buf_ptr;
    u32 hw_sec_key;
#endif
    u32 hw_pinfo;
    struct ssv6xxx_cfg cfg;
    u32 n_addresses;
    struct mac_address maddr[SSV6200_MAX_HW_MAC_ADDR];
#if defined CONFIG_SSV_CABRIO_E
    u8 ipd_channel_touch;
    struct ssv6xxx_ch_cfg *p_ch_cfg;
    u32 ch_cfg_size;
#endif
};
struct ssv_tx {
    u16 seq_no;
    int hw_txqid[WMM_NUM_AC];
    int ac_txqid[WMM_NUM_AC];
    u32 flow_ctrl_status;
    u32 tx_pkt[SSV_HW_TXQ_NUM];
    u32 tx_frag[SSV_HW_TXQ_NUM];
    struct list_head ampdu_tx_que;
    spinlock_t ampdu_tx_que_lock;
    u16 ampdu_tx_group_id;
};
struct ssv_rx {
    struct sk_buff *rx_buf;
    spinlock_t rxq_lock;
    struct sk_buff_head rxq_head;
    u32 rxq_count;
};
#ifdef MULTI_THREAD_ENCRYPT
struct ssv_encrypt_task_list {
    struct task_struct* encrypt_task;
    wait_queue_head_t encrypt_wait_q;
    volatile int started;
    volatile int running;
    volatile int paused;
    volatile int cpu_offline;
    u32 cpu_no;
    struct list_head list;
};
#endif
#define SSV6XXX_GET_STA_INFO(_sc,_s) \
    &(_sc)->sta_info[((struct ssv_sta_priv_data *)((_s)->drv_priv))->sta_idx]
#define STA_FLAG_VALID 0x00001
#define STA_FLAG_QOS 0x00002
#define STA_FLAG_AMPDU 0x00004
#define STA_FLAG_ENCRYPT 0x00008
struct ssv_sta_info {
    u16 aid;
    u16 s_flags;
    int hw_wsid;
    struct ieee80211_sta *sta;
    struct ieee80211_vif *vif;
    bool sleeping;
    bool tim_set;
    #if 0
    struct ssv_crypto_ops *crypt;
    void *crypt_priv;
    u32 KeySelect;
    bool ampdu_ccmp_encrypt;
    #endif
    #ifdef CONFIG_SSV6XXX_DEBUGFS
    struct dentry *debugfs_dir;
 #endif
};
struct ssv_vif_info {
    struct ieee80211_vif *vif;
    struct ssv_vif_priv_data *vif_priv;
    enum nl80211_iftype if_type;
    struct ssv6xxx_hw_sec sramKey;
    #ifdef CONFIG_SSV6XXX_DEBUGFS
    struct dentry *debugfs_dir;
    #endif
};
struct ssv_sta_priv_data {
    int sta_idx;
    int rc_idx;
    int rx_data_rate;
    struct ssv_sta_info *sta_info;
    struct list_head list;
    u32 ampdu_mib_total_BA_counter;
    AMPDU_TID ampdu_tid[WMM_TID_NUM];
    bool has_hw_encrypt;
    bool need_sw_encrypt;
    bool has_hw_decrypt;
    bool need_sw_decrypt;
    bool use_mac80211_decrypt;
    u8 group_key_idx;
    #ifdef USE_LOCAL_CRYPTO
    struct ssv_crypto_data crypto_data;
    #endif
    u32 beacon_rssi;
};
struct ssv_vif_priv_data {
    int vif_idx;
    struct list_head sta_list;
    u32 sta_asleep_mask;
    u32 pair_cipher;
    u32 group_cipher;
    bool is_security_valid;
    bool has_hw_encrypt;
    bool need_sw_encrypt;
    bool has_hw_decrypt;
    bool need_sw_decrypt;
    bool use_mac80211_decrypt;
    bool force_sw_encrypt;
    u8 group_key_idx;
    #ifdef USE_LOCAL_CRYPTO
    struct ssv_crypto_data crypto_data;
    #endif
};
#define SC_OP_INVALID 0x00000001
#define SC_OP_HW_RESET 0x00000002
#define SC_OP_OFFCHAN 0x00000004
#define SC_OP_FIXED_RATE 0x00000008
#define SC_OP_SHORT_PREAMBLE 0x00000010
struct ssv6xxx_beacon_info {
 u32 pubf_addr;
 u16 len;
 u8 tim_offset;
 u8 tim_cnt;
};
#define SSV6200_MAX_BCAST_QUEUE_LEN 16
struct ssv6xxx_bcast_txq {
    spinlock_t txq_lock;
    struct sk_buff_head qhead;
    int cur_qsize;
};
#ifdef DEBUG_AMPDU_FLUSH
typedef struct AMPDU_TID_st AMPDU_TID;
#define MAX_TID (24)
#endif
struct ssv_softc {
    struct ieee80211_hw *hw;
    struct device *dev;
    u32 restart_counter;
    bool force_triger_reset;
    unsigned long sdio_throughput_timestamp;
    unsigned long sdio_rx_evt_size;
#if LINUX_VERSION_CODE < KERNEL_VERSION(4,7,0)
    struct ieee80211_supported_band sbands[IEEE80211_NUM_BANDS];
#else
    struct ieee80211_supported_band sbands[NUM_NL80211_BANDS];
#endif
    struct ieee80211_channel *cur_channel;
    u16 hw_chan;
    struct mutex mutex;
    struct ssv_hw *sh;
    struct ssv_tx tx;
    struct ssv_rx rx;
    struct ssv_vif_info vif_info[SSV_NUM_VIF];
    struct ssv_sta_info sta_info[SSV_NUM_STA];
    struct ieee80211_vif *ap_vif;
    u8 nvif;
    u32 sc_flags;
    void *rc;
    int max_rate_idx;
    struct workqueue_struct *rc_sample_workqueue;
    struct sk_buff_head rc_report_queue;
    struct work_struct rc_sample_work;
    #ifdef DEBUG_AMPDU_FLUSH
    struct AMPDU_TID_st *tid[MAX_TID];
    #endif
    u16 rc_sample_sechedule;
    u16 *mac_deci_tbl;
    struct workqueue_struct *config_wq;
    bool bq4_dtim;
    struct work_struct set_tim_work;
    u8 enable_beacon;
    u8 beacon_interval;
    u8 beacon_dtim_cnt;
    u8 beacon_usage;
    struct ssv6xxx_beacon_info beacon_info[2];
    struct sk_buff *beacon_buf;
    struct work_struct bcast_start_work;
    struct delayed_work bcast_stop_work;
    struct delayed_work bcast_tx_work;
    struct delayed_work thermal_monitor_work;
    struct workqueue_struct *thermal_wq;
    int is_sar_enabled;
    bool aid0_bit_set;
    u8 hw_mng_used;
    struct ssv6xxx_bcast_txq bcast_txq;
    int bcast_interval;
    u8 bssid[6];
    struct mutex mem_mutex;
    spinlock_t ps_state_lock;
    u8 hw_wsid_bit;
    #if 0
    struct work_struct ampdu_tx_encry_work;
    bool ampdu_encry_work_scheduled;
    bool ampdu_ccmp_encrypt;
    struct work_struct sync_hwkey_work;
    bool sync_hwkey_write;
    struct ssv_sta_info *key_sync_sta_info;
    AMPDU_REKEY_PAUSE_STATE ampdu_rekey_pause;
    #endif
    int rx_ba_session_count;
    struct ieee80211_sta *rx_ba_sta;
    u8 rx_ba_bitmap;
    u8 ba_ra_addr[ETH_ALEN];
    u16 ba_tid;
    u16 ba_ssn;
    struct work_struct set_ampdu_rx_add_work;
 struct work_struct set_ampdu_rx_del_work;
    bool isAssoc;
    u16 channel_center_freq;
//#if LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0)
    bool bScanning;
//#endif
    int ps_status;
    u16 ps_aid;
#ifdef CONFIG_SSV_SUPPORT_ANDROID
#ifdef CONFIG_HAS_EARLYSUSPEND
    struct early_suspend early_suspend;
#endif
#ifdef CONFIG_HAS_WAKELOCK
    struct wake_lock ssv_wake_lock_;
#endif
#endif
    u16 tx_wait_q_woken;
    wait_queue_head_t tx_wait_q;
    struct sk_buff_head tx_skb_q;
#ifdef CONFIG_SSV6XXX_DEBUGFS
    u32 max_tx_skb_q_len;
#endif
    struct task_struct *tx_task;
    bool tx_q_empty;
    struct sk_buff_head tx_done_q;
    u16 rx_wait_q_woken;
    wait_queue_head_t rx_wait_q;
    struct sk_buff_head rx_skb_q;
    struct task_struct *rx_task;
#ifdef MULTI_THREAD_ENCRYPT
    struct list_head encrypt_task_head;
    struct notifier_block cpu_nfb;
    struct sk_buff_head preprocess_q;
    struct sk_buff_head crypted_q;
    spinlock_t crypt_st_lock;
#ifdef CONFIG_SSV6XXX_DEBUGFS
    u32 max_preprocess_q_len;
    u32 max_crypted_q_len;
#endif
#endif
    bool dbg_rx_frame;
    bool dbg_tx_frame;
#ifdef CONFIG_SSV6XXX_DEBUGFS
    struct dentry *debugfs_dir;
#endif
#ifdef CONFIG_P2P_NOA
    struct ssv_p2p_noa p2p_noa;
#endif
    struct timer_list watchdog_timeout;
    u32 watchdog_flag;
    wait_queue_head_t fw_wait_q;
    u32 iq_cali_done;
    u32 sr_bhvr;
};
enum {
    IQ_CALI_RUNNING,
    IQ_CALI_OK,
    IQ_CALI_FAILED
};
enum {
    WD_SLEEP,
    WD_BARKING,
    WD_KICKED,
    WD_MAX
};
void ssv6xxx_txbuf_free_skb(struct sk_buff *skb , void *args);
void ssv6200_rx_process(struct work_struct *work);
#if !defined(USE_THREAD_RX) || defined(USE_BATCH_RX)
int ssv6200_rx(struct sk_buff_head *rx_skb_q, void *args);
#else
int ssv6200_rx(struct sk_buff *rx_skb, void *args);
#endif
void ssv6xxx_tx_cb(struct sk_buff_head *skb_head, void *args);
#ifdef RATE_CONTROL_REALTIME_UPDATA
void ssv6xxx_tx_rate_update(struct sk_buff *skb, void *args);
#endif
int ssv6200_tx_flow_control(void *dev, int hw_txqid, bool fc_en, int debug);
void ssv6xxx_tx_q_empty_cb (u32 txq_no, void *);
int ssv6xxx_rf_disable(struct ssv_hw *sh);
int ssv6xxx_rf_enable(struct ssv_hw *sh);
int ssv6xxx_set_channel(struct ssv_softc *sc, int ch);
#ifdef CONFIG_SSV_SMARTLINK
int ssv6xxx_get_channel(struct ssv_softc *sc, int *pch);
int ssv6xxx_set_promisc(struct ssv_softc *sc, int accept);
int ssv6xxx_get_promisc(struct ssv_softc *sc, int *paccept);
#endif
int ssv6xxx_tx_task (void *data);
int ssv6xxx_rx_task (void *data);
u32 ssv6xxx_pbuf_alloc(struct ssv_softc *sc, int size, int type);
bool ssv6xxx_pbuf_free(struct ssv_softc *sc, u32 pbuf_addr);
void ssv6xxx_add_txinfo(struct ssv_softc *sc, struct sk_buff *skb);
void ssv6xxx_update_txinfo (struct ssv_softc *sc, struct sk_buff *skb);
int ssv6xxx_update_decision_table(struct ssv_softc *sc);
void ssv6xxx_ps_callback_func(unsigned long data);
void ssv6xxx_enable_ps(struct ssv_softc *sc);
void ssv6xxx_disable_ps(struct ssv_softc *sc);
int ssv6xxx_watchdog_controller(struct ssv_hw *sh ,u8 flag);
int ssv6xxx_skb_encrypt(struct sk_buff *mpdu,struct ssv_softc *sc);
int ssv6xxx_skb_decrypt(struct sk_buff *mpdu, struct ieee80211_sta *sta,struct ssv_softc *sc);
void ssv6200_sync_hw_key_sequence(struct ssv_softc *sc, struct ssv_sta_info* sta_info, bool bWrite);
struct ieee80211_sta *ssv6xxx_find_sta_by_rx_skb (struct ssv_softc *sc, struct sk_buff *skb);
struct ieee80211_sta *ssv6xxx_find_sta_by_addr (struct ssv_softc *sc, u8 addr[6]);
void ssv6xxx_foreach_sta (struct ssv_softc *sc,
                          void (*sta_func)(struct ssv_softc *,
                                           struct ssv_sta_info *,
                                           void *),
                          void *param);
void ssv6xxx_foreach_vif_sta (struct ssv_softc *sc,
                              struct ssv_vif_info *vif_info,
                              void (*sta_func)(struct ssv_softc *,
                                               struct ssv_vif_info *,
                                               struct ssv_sta_info *,
                                               void *),
                              void *param);
#ifdef CONFIG_SSV_SUPPORT_ANDROID
#ifdef CONFIG_HAS_EARLYSUSPEND
void ssv6xxx_early_suspend(struct early_suspend *h);
void ssv6xxx_late_resume(struct early_suspend *h);
#endif
#endif
#ifdef USE_LOCAL_CRYPTO
#ifdef MULTI_THREAD_ENCRYPT
struct ssv_crypto_data *ssv6xxx_skb_get_tx_cryptops(struct sk_buff *mpdu);
struct ssv_crypto_data *ssv6xxx_skb_get_rx_cryptops(struct ssv_softc *sc,
                                                    struct ieee80211_sta *sta,
                                                    struct sk_buff *mpdu);
int ssv6xxx_skb_pre_encrypt(struct sk_buff *mpdu, struct ssv_softc *sc);
int ssv6xxx_skb_pre_decrypt(struct sk_buff *mpdu, struct ieee80211_sta *sta, struct ssv_softc *sc);
int ssv6xxx_encrypt_task (void *data);
#endif
#ifdef HAS_CRYPTO_LOCK
    #define INIT_WRITE_CRYPTO_DATA(data, init) \
        struct ssv_crypto_data *data = (init); \
        unsigned long data##_flags;
    #define START_WRITE_CRYPTO_DATA(data) \
        do { \
            write_lock_irqsave(&(data)->lock, data##_flags); \
        } while (0)
    #define END_WRITE_CRYPTO_DATA(data) \
        do { \
            write_unlock_irqrestore(&(data)->lock, data##_flags); \
        } while (0)
    #define START_READ_CRYPTO_DATA(data) \
        do { \
            read_lock(&(data)->lock); \
        } while (0)
    #define END_READ_CRYPTO_DATA(data) \
        do { \
            read_unlock(&(data)->lock); \
        } while (0)
#else
    #define INIT_WRITE_CRYPTO_DATA(data, init) \
        struct ssv_crypto_data *data = (init);
    #define START_WRITE_CRYPTO_DATA(data) do { } while (0)
    #define END_WRITE_CRYPTO_DATA(data) do { } while (0)
    #define START_READ_CRYPTO_DATA(data) do { } while (0)
    #define END_READ_CRYPTO_DATA(data) do { } while (0)
#endif
#endif
#ifdef CONFIG_SSV6XXX_DEBUGFS
ssize_t ssv6xxx_tx_queue_status_dump (struct ssv_softc *sc, char *status_buf,
                                      ssize_t buf_size);
#endif
#endif