blob: 050237b14fbf2efa17805144d47dd6df5638add8 [file] [log] [blame]
/******************************************************************************
*
* This file is provided under a dual license. When you use or
* distribute this software, you may choose to be licensed under
* version 2 of the GNU General Public License ("GPLv2 License")
* or BSD License.
*
* GPLv2 License
*
* Copyright(C) 2016 MediaTek Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* 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 http://www.gnu.org/licenses/gpl-2.0.html for more details.
*
* BSD LICENSE
*
* Copyright(C) 2016 MediaTek Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * 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.
* * Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT
* HOLDER 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.
*
*****************************************************************************/
/*
** Id: //Department/DaVinci/BRANCHES/MT6620_WIFI_DRIVER_V2_3/os/linux/include/gl_kal.h#2
*/
/*! \file gl_kal.h
* \brief Declaration of KAL functions - kal*() which is provided by GLUE Layer.
*
* Any definitions in this file will be shared among GLUE Layer and internal Driver Stack.
*/
#ifndef _GL_KAL_H
#define _GL_KAL_H
/*******************************************************************************
* C O M P I L E R F L A G S
********************************************************************************
*/
/*******************************************************************************
* E X T E R N A L R E F E R E N C E S
********************************************************************************
*/
#include "config.h"
#include "gl_typedef.h"
#include "gl_os.h"
#include "gl_wext_priv.h"
#include "link.h"
#include "nic/mac.h"
#include "nic/wlan_def.h"
#include "wlan_lib.h"
#include "wlan_oid.h"
#if CFG_ENABLE_BT_OVER_WIFI
#include "nic/bow.h"
#endif
#include "linux/kallsyms.h"
/*#include <linux/ftrace_event.h>*/
#if DBG
extern int allocatedMemSize;
#endif
extern struct semaphore g_halt_sem;
extern int g_u4HaltFlag;
extern struct delayed_work sched_workq;
/*******************************************************************************
* C O N S T A N T S
********************************************************************************
*/
/* Define how many concurrent operation networks. */
#define KAL_BSS_NUM 4
#if CFG_DUAL_P2PLIKE_INTERFACE
#define KAL_P2P_NUM 2
#else
#define KAL_P2P_NUM 1
#endif
#if CFG_SUPPORT_MULTITHREAD
#define GLUE_FLAG_MAIN_PROCESS \
(GLUE_FLAG_HALT | GLUE_FLAG_SUB_MOD_MULTICAST | GLUE_FLAG_TX_CMD_DONE | GLUE_FLAG_TXREQ | \
GLUE_FLAG_TIMEOUT | GLUE_FLAG_FRAME_FILTER | GLUE_FLAG_OID | GLUE_FLAG_RX)
#define GLUE_FLAG_HIF_PROCESS \
(GLUE_FLAG_HALT | GLUE_FLAG_INT | GLUE_FLAG_HIF_TX | GLUE_FLAG_HIF_TX_CMD | GLUE_FLAG_HIF_FW_OWN)
#define GLUE_FLAG_RX_PROCESS (GLUE_FLAG_HALT | GLUE_FLAG_RX_TO_OS)
#else
/* All flags for single thread driver */
#define GLUE_FLAG_TX_PROCESS 0xFFFFFFFF
#endif
#if CFG_SUPPORT_SNIFFER
#define RADIOTAP_FIELD_TSFT BIT(0)
#define RADIOTAP_FIELD_FLAGS BIT(1)
#define RADIOTAP_FIELD_RATE BIT(2)
#define RADIOTAP_FIELD_CHANNEL BIT(3)
#define RADIOTAP_FIELD_ANT_SIGNAL BIT(5)
#define RADIOTAP_FIELD_ANT_NOISE BIT(6)
#define RADIOTAP_FIELD_ANT BIT(11)
#define RADIOTAP_FIELD_MCS BIT(19)
#define RADIOTAP_FIELD_AMPDU BIT(20)
#define RADIOTAP_FIELD_VHT BIT(21)
#define RADIOTAP_FIELD_VENDOR BIT(30)
#define RADIOTAP_LEN_VHT 48
#define RADIOTAP_FIELDS_VHT (RADIOTAP_FIELD_TSFT | \
RADIOTAP_FIELD_FLAGS | \
RADIOTAP_FIELD_RATE | \
RADIOTAP_FIELD_CHANNEL | \
RADIOTAP_FIELD_ANT_SIGNAL | \
RADIOTAP_FIELD_ANT_NOISE | \
RADIOTAP_FIELD_ANT | \
RADIOTAP_FIELD_AMPDU | \
RADIOTAP_FIELD_VHT | \
RADIOTAP_FIELD_VENDOR)
#define RADIOTAP_LEN_HT 36
#define RADIOTAP_FIELDS_HT (RADIOTAP_FIELD_TSFT | \
RADIOTAP_FIELD_FLAGS | \
RADIOTAP_FIELD_RATE | \
RADIOTAP_FIELD_CHANNEL | \
RADIOTAP_FIELD_ANT_SIGNAL | \
RADIOTAP_FIELD_ANT_NOISE | \
RADIOTAP_FIELD_ANT | \
RADIOTAP_FIELD_MCS | \
RADIOTAP_FIELD_AMPDU | \
RADIOTAP_FIELD_VENDOR)
#define RADIOTAP_LEN_LEGACY 26
#define RADIOTAP_FIELDS_LEGACY (RADIOTAP_FIELD_TSFT | \
RADIOTAP_FIELD_FLAGS | \
RADIOTAP_FIELD_RATE | \
RADIOTAP_FIELD_CHANNEL | \
RADIOTAP_FIELD_ANT_SIGNAL | \
RADIOTAP_FIELD_ANT_NOISE | \
RADIOTAP_FIELD_ANT | \
RADIOTAP_FIELD_VENDOR)
#endif
/*******************************************************************************
* D A T A T Y P E S
********************************************************************************
*/
typedef enum _ENUM_SPIN_LOCK_CATEGORY_E {
SPIN_LOCK_FSM = 0,
#if CFG_SUPPORT_MULTITHREAD
SPIN_LOCK_TX_PORT_QUE,
SPIN_LOCK_TX_CMD_QUE,
SPIN_LOCK_TX_CMD_DONE_QUE,
SPIN_LOCK_TC_RESOURCE,
SPIN_LOCK_RX_TO_OS_QUE,
#endif
/* FIX ME */
SPIN_LOCK_RX_QUE,
SPIN_LOCK_RX_FREE_QUE,
SPIN_LOCK_TX_QUE,
SPIN_LOCK_CMD_QUE,
SPIN_LOCK_TX_RESOURCE,
SPIN_LOCK_CMD_RESOURCE,
SPIN_LOCK_QM_TX_QUEUE,
SPIN_LOCK_CMD_PENDING,
SPIN_LOCK_CMD_SEQ_NUM,
SPIN_LOCK_TX_MSDU_INFO_LIST,
SPIN_LOCK_TXING_MGMT_LIST,
SPIN_LOCK_TX_SEQ_NUM,
SPIN_LOCK_TX_COUNT,
SPIN_LOCK_TXS_COUNT,
/* end */
SPIN_LOCK_TX,
/* TX/RX Direct : BEGIN */
SPIN_LOCK_TX_DIRECT,
SPIN_LOCK_RX_DIRECT,
SPIN_LOCK_RX_DIRECT_REORDER,
/* TX/RX Direct : END */
SPIN_LOCK_IO_REQ,
SPIN_LOCK_INT,
SPIN_LOCK_MGT_BUF,
SPIN_LOCK_MSG_BUF,
SPIN_LOCK_STA_REC,
SPIN_LOCK_MAILBOX,
SPIN_LOCK_TIMER,
SPIN_LOCK_BOW_TABLE,
SPIN_LOCK_EHPI_BUS, /* only for EHPI */
SPIN_LOCK_NET_DEV,
SPIN_LOCK_NUM
} ENUM_SPIN_LOCK_CATEGORY_E;
typedef enum _ENUM_MUTEX_CATEGORY_E {
MUTEX_TX_CMD_CLEAR,
MUTEX_TX_DATA_DONE_QUE,
MUTEX_DEL_INF,
MUTEX_CHIP_RST,
MUTEX_NUM
} ENUM_MUTEX_CATEGORY_E;
/* event for assoc information update */
typedef struct _EVENT_ASSOC_INFO {
UINT_8 ucAssocReq; /* 1 for assoc req, 0 for assoc rsp */
UINT_8 ucReassoc; /* 0 for assoc, 1 for reassoc */
UINT_16 u2Length;
PUINT_8 pucIe;
} EVENT_ASSOC_INFO, *P_EVENT_ASSOC_INFO;
typedef enum _ENUM_KAL_NETWORK_TYPE_INDEX_T {
KAL_NETWORK_TYPE_AIS_INDEX = 0,
#if CFG_ENABLE_WIFI_DIRECT
KAL_NETWORK_TYPE_P2P_INDEX,
#endif
#if CFG_ENABLE_BT_OVER_WIFI
KAL_NETWORK_TYPE_BOW_INDEX,
#endif
KAL_NETWORK_TYPE_INDEX_NUM
} ENUM_KAL_NETWORK_TYPE_INDEX_T;
typedef enum _ENUM_KAL_MEM_ALLOCATION_TYPE_E {
PHY_MEM_TYPE, /* physically continuous */
VIR_MEM_TYPE, /* virtually continuous */
MEM_TYPE_NUM
} ENUM_KAL_MEM_ALLOCATION_TYPE;
#ifdef CONFIG_ANDROID /* Defined in Android kernel source */
typedef struct wake_lock KAL_WAKE_LOCK_T, *P_KAL_WAKE_LOCK_T;
#else
typedef UINT_32 KAL_WAKE_LOCK_T, *P_KAL_WAKE_LOCK_T;
#endif
#if CFG_SUPPORT_AGPS_ASSIST
typedef enum _ENUM_MTK_AGPS_ATTR {
MTK_ATTR_AGPS_INVALID,
MTK_ATTR_AGPS_CMD,
MTK_ATTR_AGPS_DATA,
MTK_ATTR_AGPS_IFINDEX,
MTK_ATTR_AGPS_IFNAME,
MTK_ATTR_AGPS_MAX
} ENUM_MTK_CCX_ATTR;
typedef enum _ENUM_AGPS_EVENT {
AGPS_EVENT_WLAN_ON,
AGPS_EVENT_WLAN_OFF,
AGPS_EVENT_WLAN_AP_LIST,
} ENUM_CCX_EVENT;
BOOLEAN kalIndicateAgpsNotify(P_ADAPTER_T prAdapter, UINT_8 cmd, PUINT_8 data, UINT_16 dataLen);
#endif /* CFG_SUPPORT_AGPS_ASSIST */
#if CFG_SUPPORT_SNIFFER
/* Vendor Namespace
* Bit Number 30
* Required Alignment 2 bytes
*/
typedef struct _RADIOTAP_FIELD_VENDOR_T {
UINT_8 aucOUI[3];
UINT_8 ucSubNamespace;
UINT_16 u2DataLen;
UINT_8 ucData;
} __packed RADIOTAP_FIELD_VENDOR_T, *P_RADIOTAP_FIELD_VENDOR_T;
typedef struct _MONITOR_RADIOTAP_T {
/* radiotap header */
UINT_8 ucItVersion; /* set to 0 */
UINT_8 ucItPad;
UINT_16 u2ItLen; /* entire length */
UINT_32 u4ItPresent; /* fields present */
/* TSFT
* Bit Number 0
* Required Alignment 8 bytes
* Unit microseconds
*/
UINT_64 u8MacTime;
/* Flags
* Bit Number 1
*/
UINT_8 ucFlags;
/* Rate
* Bit Number 2
* Unit 500 Kbps
*/
UINT_8 ucRate;
/* Channel
* Bit Number 3
* Required Alignment 2 bytes
*/
UINT_16 u2ChFrequency;
UINT_16 u2ChFlags;
/* Antenna signal
* Bit Number 5
* Unit dBm
*/
UINT_8 ucAntennaSignal;
/* Antenna noise
* Bit Number 6
* Unit dBm
*/
UINT_8 ucAntennaNoise;
/* Antenna
* Bit Number 11
* Unit antenna index
*/
UINT_8 ucAntenna;
/* MCS
* Bit Number 19
* Required Alignment 1 byte
*/
UINT_8 ucMcsKnown;
UINT_8 ucMcsFlags;
UINT_8 ucMcsMcs;
/* A-MPDU status
* Bit Number 20
* Required Alignment 4 bytes
*/
UINT_32 u4AmpduRefNum;
UINT_16 u2AmpduFlags;
UINT_8 ucAmpduDelimiterCRC;
UINT_8 ucAmpduReserved;
/* VHT
* Bit Number 21
* Required Alignment 2 bytes
*/
UINT_16 u2VhtKnown;
UINT_8 ucVhtFlags;
UINT_8 ucVhtBandwidth;
UINT_8 aucVhtMcsNss[4];
UINT_8 ucVhtCoding;
UINT_8 ucVhtGroupId;
UINT_16 u2VhtPartialAid;
/* extension space */
UINT_8 aucReserve[12];
} __packed MONITOR_RADIOTAP_T, *P_MONITOR_RADIOTAP_T;
#endif
/*******************************************************************************
* P U B L I C D A T A
********************************************************************************
*/
/*******************************************************************************
* P R I V A T E D A T A
********************************************************************************
*/
/*******************************************************************************
* M A C R O S
********************************************************************************
*/
/*----------------------------------------------------------------------------*/
/* Macros of getting current thread id */
/*----------------------------------------------------------------------------*/
#define KAL_GET_CURRENT_THREAD_ID() (current->pid)
#define KAL_GET_CURRENT_THREAD_NAME() (current->comm)
/*----------------------------------------------------------------------------*/
/* Macros of SPIN LOCK operations for using in Driver Layer */
/*----------------------------------------------------------------------------*/
#define KAL_SPIN_LOCK_DECLARATION() unsigned long __ulFlags
#define KAL_ACQUIRE_SPIN_LOCK(_prAdapter, _rLockCategory) \
kalAcquireSpinLock(((P_ADAPTER_T)_prAdapter)->prGlueInfo, _rLockCategory, &__ulFlags)
#define KAL_RELEASE_SPIN_LOCK(_prAdapter, _rLockCategory) \
kalReleaseSpinLock(((P_ADAPTER_T)_prAdapter)->prGlueInfo, _rLockCategory, __ulFlags)
/*----------------------------------------------------------------------------*/
/* Macros of MUTEX operations for using in Driver Layer */
/*----------------------------------------------------------------------------*/
#define KAL_ACQUIRE_MUTEX(_prAdapter, _rLockCategory) \
kalAcquireMutex(((P_ADAPTER_T)_prAdapter)->prGlueInfo, _rLockCategory)
#define KAL_RELEASE_MUTEX(_prAdapter, _rLockCategory) \
kalReleaseMutex(((P_ADAPTER_T)_prAdapter)->prGlueInfo, _rLockCategory)
/*----------------------------------------------------------------------------*/
/* Macros for accessing Reserved Fields of native packet */
/*----------------------------------------------------------------------------*/
#define KAL_GET_PKT_QUEUE_ENTRY(_p) GLUE_GET_PKT_QUEUE_ENTRY(_p)
#define KAL_GET_PKT_DESCRIPTOR(_prQueueEntry) GLUE_GET_PKT_DESCRIPTOR(_prQueueEntry)
#define KAL_GET_PKT_TID(_p) GLUE_GET_PKT_TID(_p)
#define KAL_GET_PKT_IS1X(_p) GLUE_GET_PKT_IS1X(_p)
#define KAL_GET_PKT_HEADER_LEN(_p) GLUE_GET_PKT_HEADER_LEN(_p)
#define KAL_GET_PKT_PAYLOAD_LEN(_p) GLUE_GET_PKT_PAYLOAD_LEN(_p)
#define KAL_GET_PKT_ARRIVAL_TIME(_p) GLUE_GET_PKT_ARRIVAL_TIME(_p)
/*----------------------------------------------------------------------------*/
/* Macros for kernel related defines */
/*----------------------------------------------------------------------------*/
#if KERNEL_VERSION(3, 14, 0) > CFG80211_VERSION_CODE
#define IEEE80211_CHAN_PASSIVE_FLAG IEEE80211_CHAN_PASSIVE_SCAN
#define IEEE80211_CHAN_PASSIVE_STR "PASSIVE"
#else
#define IEEE80211_CHAN_PASSIVE_FLAG IEEE80211_CHAN_NO_IR
#define IEEE80211_CHAN_PASSIVE_STR "NO_IR"
#endif
#if KERNEL_VERSION(4, 7, 0) <= CFG80211_VERSION_CODE
/**
* enum nl80211_band - Frequency band
* @NL80211_BAND_2GHZ: 2.4 GHz ISM band
* @NL80211_BAND_5GHZ: around 5 GHz band (4.9 - 5.7 GHz)
* @NL80211_BAND_60GHZ: around 60 GHz band (58.32 - 64.80 GHz)
* @NUM_NL80211_BANDS: number of bands, avoid using this in userspace
* since newer kernel versions may support more bands
*/
#define KAL_BAND_2GHZ NL80211_BAND_2GHZ
#define KAL_BAND_5GHZ NL80211_BAND_5GHZ
#define KAL_NUM_BANDS NUM_NL80211_BANDS
#else
#define KAL_BAND_2GHZ IEEE80211_BAND_2GHZ
#define KAL_BAND_5GHZ IEEE80211_BAND_5GHZ
#define KAL_NUM_BANDS IEEE80211_NUM_BANDS
#endif
/**
* enum nl80211_reg_rule_flags - regulatory rule flags
* @NL80211_RRF_NO_OFDM: OFDM modulation not allowed
* @NL80211_RRF_AUTO_BW: maximum available bandwidth should be calculated
* base on contiguous rules and wider channels will be allowed to cross
* multiple contiguous/overlapping frequency ranges.
* @NL80211_RRF_DFS: DFS support is required to be used
*/
#define KAL_RRF_NO_OFDM NL80211_RRF_NO_OFDM
#define KAL_RRF_DFS NL80211_RRF_DFS
#if KERNEL_VERSION(3, 15, 0) > CFG80211_VERSION_CODE
#define KAL_RRF_AUTO_BW 0
#else
#define KAL_RRF_AUTO_BW NL80211_RRF_AUTO_BW
#endif
/**
* kalCfg80211ToMtkBand - Band translation helper
*
* @band: cfg80211_band
*
* Translates cfg80211 band into internal band definition
*/
#if CFG_SCAN_CHANNEL_SPECIFIED
#define kalCfg80211ToMtkBand(cfg80211_band) \
(cfg80211_band == KAL_BAND_2GHZ ? BAND_2G4 : \
cfg80211_band == KAL_BAND_5GHZ ? BAND_5G : BAND_NULL)
#endif
/**
* kalCfg80211ScanDone - abstraction of cfg80211_scan_done
*
* @request: the corresponding scan request (sanity checked by callers!)
* @aborted: set to true if the scan was aborted for any reason,
* userspace will be notified of that
*
* Since linux-4.8.y the 2nd parameter is changed from bool to
* struct cfg80211_scan_info, but we don't use all fields yet.
*/
#if KERNEL_VERSION(4, 8, 0) <= CFG80211_VERSION_CODE
static inline void kalCfg80211ScanDone(struct cfg80211_scan_request *request,
bool aborted)
{
struct cfg80211_scan_info info = { .aborted = aborted };
cfg80211_scan_done(request, &info);
}
#else
static inline void kalCfg80211ScanDone(struct cfg80211_scan_request *request,
bool aborted)
{
cfg80211_scan_done(request, aborted);
}
#endif
/* Consider on some Android platform, using request_firmware_direct()
* may cause system failed to load firmware. So we still use
* request_firmware().
*/
#define REQUEST_FIRMWARE(_fw, _name, _dev) \
request_firmware(_fw, _name, _dev)
#define RELEASE_FIRMWARE(_fw) \
do { \
release_firmware(_fw); \
_fw = NULL; \
} while (0)
/*----------------------------------------------------------------------------*/
/* Macros of wake_lock operations for using in Driver Layer */
/*----------------------------------------------------------------------------*/
#if defined(CONFIG_ANDROID) && (CFG_ENABLE_WAKE_LOCK)
/* CONFIG_ANDROID is defined in Android kernel source */
#define KAL_WAKE_LOCK_INIT(_prAdapter, _prWakeLock, _pcName) \
wake_lock_init(_prWakeLock, WAKE_LOCK_SUSPEND, _pcName)
#define KAL_WAKE_LOCK_DESTROY(_prAdapter, _prWakeLock) \
wake_lock_destroy(_prWakeLock)
#define KAL_WAKE_LOCK(_prAdapter, _prWakeLock) \
wake_lock(_prWakeLock)
#define KAL_WAKE_LOCK_TIMEOUT(_prAdapter, _prWakeLock, _u4Timeout) \
wake_lock_timeout(_prWakeLock, _u4Timeout)
#define KAL_WAKE_UNLOCK(_prAdapter, _prWakeLock) \
wake_unlock(_prWakeLock)
#define KAL_WAKE_LOCK_ACTIVE(_prAdapter, _prWakeLock) \
wake_lock_active(_prWakeLock)
#else
#define KAL_WAKE_LOCK_INIT(_prAdapter, _prWakeLock, _pcName)
#define KAL_WAKE_LOCK_DESTROY(_prAdapter, _prWakeLock)
#define KAL_WAKE_LOCK(_prAdapter, _prWakeLock)
#define KAL_WAKE_LOCK_TIMEOUT(_prAdapter, _prWakeLock, _u4Timeout)
#define KAL_WAKE_UNLOCK(_prAdapter, _prWakeLock)
#define KAL_WAKE_LOCK_ACTIVE(_prAdapter, _prWakeLock)
#endif
/*----------------------------------------------------------------------------*/
/*!
* \brief Cache memory allocation
*
* \param[in] u4Size Required memory size.
* \param[in] eMemType Memory allocation type
*
* \return Pointer to allocated memory
* or NULL
*/
/*----------------------------------------------------------------------------*/
#if DBG
#define kalMemAlloc(u4Size, eMemType) ({ \
void *pvAddr; \
if (eMemType == PHY_MEM_TYPE) { \
if (in_interrupt()) \
pvAddr = kmalloc(u4Size, GFP_ATOMIC); \
else \
pvAddr = kmalloc(u4Size, GFP_KERNEL); \
} \
else { \
pvAddr = vmalloc(u4Size); \
} \
if (pvAddr) { \
allocatedMemSize += u4Size; \
DBGLOG(INIT, INFO, "0x%p(%ld) allocated (%s:%s)\n", \
pvAddr, (UINT_32)u4Size, __FILE__, __func__); \
} \
pvAddr; \
})
#else
#define kalMemAlloc(u4Size, eMemType) ({ \
void *pvAddr; \
if (eMemType == PHY_MEM_TYPE) { \
if (in_interrupt()) \
pvAddr = kmalloc(u4Size, GFP_ATOMIC); \
else \
pvAddr = kmalloc(u4Size, GFP_KERNEL); \
} \
else { \
pvAddr = vmalloc(u4Size); \
} \
pvAddr; \
})
#endif
/*----------------------------------------------------------------------------*/
/*!
* \brief Free allocated cache memory
*
* \param[in] pvAddr Required memory size.
* \param[in] eMemType Memory allocation type
* \param[in] u4Size Allocated memory size.
*
* \return -
*/
/*----------------------------------------------------------------------------*/
#if DBG
#define kalMemFree(pvAddr, eMemType, u4Size) \
{ \
if (pvAddr) { \
allocatedMemSize -= u4Size; \
DBGLOG(INIT, INFO, "0x%p(%ld) freed (%s:%s)\n", \
pvAddr, (UINT_32)u4Size, __FILE__, __func__); \
} \
if (eMemType == PHY_MEM_TYPE) { \
kfree(pvAddr); \
} \
else { \
vfree(pvAddr); \
} \
}
#else
#define kalMemFree(pvAddr, eMemType, u4Size) \
{ \
if (eMemType == PHY_MEM_TYPE) { \
kfree(pvAddr); \
} \
else { \
vfree(pvAddr); \
} \
}
#endif
#define kalUdelay(u4USec) udelay(u4USec)
#define kalMdelay(u4MSec) mdelay(u4MSec)
#define kalMsleep(u4MSec) msleep(u4MSec)
/* Copy memory from user space to kernel space */
#define kalMemCopyFromUser(_pvTo, _pvFrom, _u4N) copy_from_user(_pvTo, _pvFrom, _u4N)
/* Copy memory from kernel space to user space */
#define kalMemCopyToUser(_pvTo, _pvFrom, _u4N) copy_to_user(_pvTo, _pvFrom, _u4N)
/* Copy memory block with specific size */
#define kalMemCopy(pvDst, pvSrc, u4Size) memcpy(pvDst, pvSrc, u4Size)
/* Set memory block with specific pattern */
#define kalMemSet(pvAddr, ucPattern, u4Size) memset(pvAddr, ucPattern, u4Size)
/* Compare two memory block with specific length.
* Return zero if they are the same.
*/
#define kalMemCmp(pvAddr1, pvAddr2, u4Size) memcmp(pvAddr1, pvAddr2, u4Size)
/* Zero specific memory block */
#define kalMemZero(pvAddr, u4Size) memset(pvAddr, 0, u4Size)
/* Move memory block with specific size */
#define kalMemMove(pvDst, pvSrc, u4Size) memmove(pvDst, pvSrc, u4Size)
#if KERNEL_VERSION(4, 0, 0) <= LINUX_VERSION_CODE
#define strnicmp(s1, s2, n) strncasecmp(s1, s2, n)
#endif
/* string operation */
#define kalStrCpy(dest, src) strcpy(dest, src)
#define kalStrnCpy(dest, src, n) strncpy(dest, src, n)
#define kalStrCmp(ct, cs) strcmp(ct, cs)
#define kalStrnCmp(ct, cs, n) strncmp(ct, cs, n)
#define kalStrChr(s, c) strchr(s, c)
#define kalStrrChr(s, c) strrchr(s, c)
#define kalStrnChr(s, n, c) strnchr(s, n, c)
#define kalStrLen(s) strlen(s)
#define kalStrnLen(s, b) strnlen(s, b)
/* #define kalStrniCmp(s, n) strnicmp(s, n) */
/* #define kalStrtoul(cp, endp, base) simple_strtoul(cp, endp, base) */
/* #define kalStrtol(cp, endp, base) simple_strtol(cp, endp, base) */
#define kalkStrtou8(cp, base, resp) kstrtou8(cp, base, resp)
#define kalkStrtou16(cp, base, resp) kstrtou16(cp, base, resp)
#define kalkStrtou32(cp, base, resp) kstrtou32(cp, base, resp)
#define kalkStrtos32(cp, base, resp) kstrtos32(cp, base, resp)
#define kalSnprintf(buf, size, fmt, ...) snprintf(buf, size, fmt, ##__VA_ARGS__)
#define kalScnprintf(buf, size, fmt, ...) scnprintf(buf, size, fmt, ##__VA_ARGS__)
#define kalSprintf(buf, fmt, ...) sprintf(buf, fmt, __VA_ARGS__)
/* remove for AOSP */
/* #define kalSScanf(buf, fmt, ...) sscanf(buf, fmt, __VA_ARGS__) */
#define kalStrStr(ct, cs) strstr(ct, cs)
#define kalStrSep(s, ct) strsep(s, ct)
#define kalStrCat(dest, src) strcat(dest, src)
#define kalIsXdigit(c) isxdigit(c)
/* defined for wince sdio driver only */
#if defined(_HIF_SDIO)
#define kalDevSetPowerState(prGlueInfo, ePowerMode) glSetPowerState(prGlueInfo, ePowerMode)
#else
#define kalDevSetPowerState(prGlueInfo, ePowerMode)
#endif
/*----------------------------------------------------------------------------*/
/*!
* \brief Notify OS with SendComplete event of the specific packet. Linux should
* free packets here.
*
* \param[in] prGlueInfo Pointer of GLUE Data Structure
* \param[in] pvPacket Pointer of Packet Handle
* \param[in] status Status Code for OS upper layer
*
* \return -
*/
/*----------------------------------------------------------------------------*/
#define kalSendComplete(prGlueInfo, pvPacket, status) \
kalSendCompleteAndAwakeQueue(prGlueInfo, pvPacket)
/*----------------------------------------------------------------------------*/
/*!
* \brief This function is used to locate the starting address of incoming ethernet
* frame for skb.
*
* \param[in] prGlueInfo Pointer of GLUE Data Structure
* \param[in] pvPacket Pointer of Packet Handle
*
* \return starting address of ethernet frame buffer.
*/
/*----------------------------------------------------------------------------*/
#define kalQueryBufferPointer(prGlueInfo, pvPacket) \
((PUINT_8)((struct sk_buff *)pvPacket)->data)
/*----------------------------------------------------------------------------*/
/*!
* \brief This function is used to query the length of valid buffer which is accessible during
* port read/write.
*
* \param[in] prGlueInfo Pointer of GLUE Data Structure
* \param[in] pvPacket Pointer of Packet Handle
*
* \return starting address of ethernet frame buffer.
*/
/*----------------------------------------------------------------------------*/
#define kalQueryValidBufferLength(prGlueInfo, pvPacket) \
((UINT_32)((struct sk_buff *)pvPacket)->end - \
(UINT_32)((struct sk_buff *)pvPacket)->data)
/*----------------------------------------------------------------------------*/
/*!
* \brief This function is used to copy the entire frame from skb to the destination
* address in the input parameter.
*
* \param[in] prGlueInfo Pointer of GLUE Data Structure
* \param[in] pvPacket Pointer of Packet Handle
* \param[in] pucDestBuffer Destination Address
*
* \return -
*/
/*----------------------------------------------------------------------------*/
#define kalCopyFrame(prGlueInfo, pvPacket, pucDestBuffer) \
do {struct sk_buff *skb = (struct sk_buff *)pvPacket; \
memcpy(pucDestBuffer, skb->data, skb->len); } while (0)
#define kalGetTimeTick() jiffies_to_msecs(jiffies)
#define WLAN_TAG "[wlan]"
#define kalPrint(_Fmt...) printk(WLAN_TAG _Fmt)
#define kalBreakPoint() \
do { \
WARN_ON(1); \
panic("Oops"); \
} while (0)
#if CFG_ENABLE_AEE_MSG
#define kalSendAeeException aee_kernel_exception
#define kalSendAeeWarning aee_kernel_warning
#define kalSendAeeReminding aee_kernel_reminding
#else
#define kalSendAeeException(_module, _desc, ...)
#define kalSendAeeWarning(_module, _desc, ...)
#define kalSendAeeReminding(_module, _desc, ...)
#endif
#define PRINTF_ARG(...) __VA_ARGS__
#define SPRINTF(buf, arg) {buf += sprintf((char *)(buf), PRINTF_ARG arg); }
#define USEC_TO_SYSTIME(_usec) ((_usec) / USEC_PER_MSEC)
#define MSEC_TO_SYSTIME(_msec) (_msec)
#define MSEC_TO_JIFFIES(_msec) msecs_to_jiffies(_msec)
#define KAL_TIME_INTERVAL_DECLARATION() struct timeval __rTs, __rTe
#define KAL_REC_TIME_START() do_gettimeofday(&__rTs)
#define KAL_REC_TIME_END() do_gettimeofday(&__rTe)
#define KAL_GET_TIME_INTERVAL() \
((SEC_TO_USEC(__rTe.tv_sec) + __rTe.tv_usec) - (SEC_TO_USEC(__rTs.tv_sec) + __rTs.tv_usec))
#define KAL_ADD_TIME_INTERVAL(_Interval) \
{ \
(_Interval) += KAL_GET_TIME_INTERVAL(); \
}
#define KAL_GET_HOST_CLOCK() local_clock()
/*******************************************************************************
* F U N C T I O N D E C L A R A T I O N S
********************************************************************************
*/
/*----------------------------------------------------------------------------*/
/* Routines in gl_kal.c */
/*----------------------------------------------------------------------------*/
VOID kalAcquireSpinLock(IN P_GLUE_INFO_T prGlueInfo, IN ENUM_SPIN_LOCK_CATEGORY_E rLockCategory, OUT PULONG plFlags);
VOID kalReleaseSpinLock(IN P_GLUE_INFO_T prGlueInfo, IN ENUM_SPIN_LOCK_CATEGORY_E rLockCategory, IN ULONG ulFlags);
VOID kalUpdateMACAddress(IN P_GLUE_INFO_T prGlueInfo, IN PUINT_8 pucMacAddr);
VOID kalAcquireMutex(IN P_GLUE_INFO_T prGlueInfo, IN ENUM_MUTEX_CATEGORY_E rMutexCategory);
VOID kalReleaseMutex(IN P_GLUE_INFO_T prGlueInfo, IN ENUM_MUTEX_CATEGORY_E rMutexCategory);
VOID kalPacketFree(IN P_GLUE_INFO_T prGlueInfo, IN PVOID pvPacket);
PVOID kalPacketAlloc(IN P_GLUE_INFO_T prGlueInfo, IN UINT_32 u4Size, OUT PUINT_8 *ppucData);
VOID kalOsTimerInitialize(IN P_GLUE_INFO_T prGlueInfo, IN PVOID prTimerHandler);
BOOL kalSetTimer(IN P_GLUE_INFO_T prGlueInfo, IN OS_SYSTIME rInterval);
WLAN_STATUS
kalProcessRxPacket(IN P_GLUE_INFO_T prGlueInfo, IN PVOID pvPacket, IN PUINT_8 pucPacketStart, IN UINT_32 u4PacketLen,
/* IN PBOOLEAN pfgIsRetain, */
IN BOOLEAN fgIsRetain, IN ENUM_CSUM_RESULT_T aeCSUM[]);
WLAN_STATUS kalRxIndicatePkts(IN P_GLUE_INFO_T prGlueInfo, IN PVOID apvPkts[], IN UINT_8 ucPktNum);
WLAN_STATUS kalRxIndicateOnePkt(IN P_GLUE_INFO_T prGlueInfo, IN PVOID pvPkt);
VOID
kalIndicateStatusAndComplete(IN P_GLUE_INFO_T prGlueInfo, IN WLAN_STATUS eStatus, IN PVOID pvBuf, IN UINT_32 u4BufLen);
VOID
kalUpdateReAssocReqInfo(IN P_GLUE_INFO_T prGlueInfo,
IN PUINT_8 pucFrameBody, IN UINT_32 u4FrameBodyLen, IN BOOLEAN fgReassocRequest);
VOID kalUpdateReAssocRspInfo(IN P_GLUE_INFO_T prGlueInfo, IN PUINT_8 pucFrameBody, IN UINT_32 u4FrameBodyLen);
#if CFG_TX_FRAGMENT
BOOLEAN
kalQueryTxPacketHeader(IN P_GLUE_INFO_T prGlueInfo,
IN PVOID pvPacket, OUT PUINT_16 pu2EtherTypeLen, OUT PUINT_8 pucEthDestAddr);
#endif /* CFG_TX_FRAGMENT */
VOID kalSendCompleteAndAwakeQueue(IN P_GLUE_INFO_T prGlueInfo, IN PVOID pvPacket);
#if CFG_TCP_IP_CHKSUM_OFFLOAD
VOID kalQueryTxChksumOffloadParam(IN PVOID pvPacket, OUT PUINT_8 pucFlag);
VOID kalUpdateRxCSUMOffloadParam(IN PVOID pvPacket, IN ENUM_CSUM_RESULT_T eCSUM[]);
#endif /* CFG_TCP_IP_CHKSUM_OFFLOAD */
BOOLEAN kalRetrieveNetworkAddress(IN P_GLUE_INFO_T prGlueInfo, IN OUT PARAM_MAC_ADDRESS *prMacAddr);
VOID
kalReadyOnChannel(IN P_GLUE_INFO_T prGlueInfo,
IN UINT_64 u8Cookie,
IN ENUM_BAND_T eBand, IN ENUM_CHNL_EXT_T eSco, IN UINT_8 ucChannelNum, IN UINT_32 u4DurationMs);
VOID
kalRemainOnChannelExpired(IN P_GLUE_INFO_T prGlueInfo,
IN UINT_64 u8Cookie, IN ENUM_BAND_T eBand, IN ENUM_CHNL_EXT_T eSco, IN UINT_8 ucChannelNum);
VOID
kalIndicateMgmtTxStatus(IN P_GLUE_INFO_T prGlueInfo,
IN UINT_64 u8Cookie, IN BOOLEAN fgIsAck, IN PUINT_8 pucFrameBuf, IN UINT_32 u4FrameLen);
VOID kalIndicateRxMgmtFrame(IN P_GLUE_INFO_T prGlueInfo, IN P_SW_RFB_T prSwRfb);
/*----------------------------------------------------------------------------*/
/* Routines in interface - ehpi/sdio.c */
/*----------------------------------------------------------------------------*/
BOOL kalDevRegRead(IN P_GLUE_INFO_T prGlueInfo, IN UINT_32 u4Register, OUT PUINT_32 pu4Value);
BOOL kalDevRegRead_mac(IN P_GLUE_INFO_T prGlueInfo, IN UINT_32 u4Register, OUT PUINT_32 pu4Value);
BOOL kalDevRegWrite(P_GLUE_INFO_T prGlueInfo, IN UINT_32 u4Register, IN UINT_32 u4Value);
BOOL kalDevRegWrite_mac(P_GLUE_INFO_T prGlueInfo, IN UINT_32 u4Register, IN UINT_32 u4Value);
BOOL
kalDevPortRead(IN P_GLUE_INFO_T prGlueInfo,
IN UINT_16 u2Port, IN UINT_32 u2Len, OUT PUINT_8 pucBuf, IN UINT_32 u2ValidOutBufSize);
BOOL
kalDevPortWrite(P_GLUE_INFO_T prGlueInfo,
IN UINT_16 u2Port, IN UINT_32 u2Len, IN PUINT_8 pucBuf, IN UINT_32 u2ValidInBufSize);
BOOL kalDevWriteData(IN P_GLUE_INFO_T prGlueInfo, IN P_MSDU_INFO_T prMsduInfo);
BOOL kalDevWriteCmd(IN P_GLUE_INFO_T prGlueInfo, IN P_CMD_INFO_T prCmdInfo, IN UINT_8 ucTC);
BOOL kalDevKickData(IN P_GLUE_INFO_T prGlueInfo);
VOID kalDevReadIntStatus(IN P_ADAPTER_T prAdapter, OUT PUINT_32 pu4IntStatus);
BOOL kalDevWriteWithSdioCmd52(IN P_GLUE_INFO_T prGlueInfo, IN UINT_32 u4Addr, IN UINT_8 ucData);
#if CFG_SUPPORT_EXT_CONFIG
UINT_32 kalReadExtCfg(IN P_GLUE_INFO_T prGlueInfo);
#endif
BOOLEAN
kalQoSFrameClassifierAndPacketInfo(IN P_GLUE_INFO_T prGlueInfo,
IN P_NATIVE_PACKET prPacket, OUT P_TX_PACKET_INFO prTxPktInfo);
BOOLEAN kalGetEthDestAddr(IN P_GLUE_INFO_T prGlueInfo, IN P_NATIVE_PACKET prPacket, OUT PUINT_8 pucEthDestAddr);
VOID
kalOidComplete(IN P_GLUE_INFO_T prGlueInfo,
IN BOOLEAN fgSetQuery, IN UINT_32 u4SetQueryInfoLen, IN WLAN_STATUS rOidStatus);
WLAN_STATUS
kalIoctl(IN P_GLUE_INFO_T prGlueInfo,
IN PFN_OID_HANDLER_FUNC pfnOidHandler,
IN PVOID pvInfoBuf,
IN UINT_32 u4InfoBufLen, IN BOOL fgRead, IN BOOL fgWaitResp, IN BOOL fgCmd, OUT PUINT_32 pu4QryInfoLen);
WLAN_STATUS
kalIoctlTimeout(IN P_GLUE_INFO_T prGlueInfo,
IN PFN_OID_HANDLER_FUNC pfnOidHandler,
IN PVOID pvInfoBuf,
IN UINT_32 u4InfoBufLen, IN BOOL fgRead, IN BOOL fgWaitResp, IN BOOL fgCmd, IN INT_32 i4OidTimeout,
OUT PUINT_32 pu4QryInfoLen);
VOID kalHandleAssocInfo(IN P_GLUE_INFO_T prGlueInfo, IN P_EVENT_ASSOC_INFO prAssocInfo);
#if CFG_ENABLE_FW_DOWNLOAD
WLAN_STATUS kalFirmwareOpen(IN P_GLUE_INFO_T prGlueInfo, IN PPUINT_8 apucNameTable);
WLAN_STATUS kalFirmwareClose(IN P_GLUE_INFO_T prGlueInfo);
WLAN_STATUS kalFirmwareLoad(IN P_GLUE_INFO_T prGlueInfo, OUT PVOID prBuf, IN UINT_32 u4Offset, OUT PUINT_32 pu4Size);
WLAN_STATUS kalFirmwareSize(IN P_GLUE_INFO_T prGlueInfo, OUT PUINT_32 pu4Size);
VOID kalConstructDefaultFirmwarePrio(P_GLUE_INFO_T prGlueInfo, PPUINT_8 apucNameTable,
PPUINT_8 apucName, PUINT_8 pucNameIdx, UINT_8 ucMaxNameIdx);
PVOID kalFirmwareImageMapping(IN P_GLUE_INFO_T prGlueInfo,
OUT PPVOID ppvMapFileBuf, OUT PUINT_32 pu4FileLength, IN ENUM_IMG_DL_IDX_T eDlIdx);
VOID kalFirmwareImageUnmapping(IN P_GLUE_INFO_T prGlueInfo, IN PVOID prFwHandle, IN PVOID pvMapFileBuf);
#endif
/*----------------------------------------------------------------------------*/
/* Card Removal Check */
/*----------------------------------------------------------------------------*/
BOOLEAN kalIsCardRemoved(IN P_GLUE_INFO_T prGlueInfo);
/*----------------------------------------------------------------------------*/
/* TX */
/*----------------------------------------------------------------------------*/
VOID kalFlushPendingTxPackets(IN P_GLUE_INFO_T prGlueInfo);
/*----------------------------------------------------------------------------*/
/* Media State Indication */
/*----------------------------------------------------------------------------*/
ENUM_PARAM_MEDIA_STATE_T kalGetMediaStateIndicated(IN P_GLUE_INFO_T prGlueInfo);
VOID kalSetMediaStateIndicated(IN P_GLUE_INFO_T prGlueInfo, IN ENUM_PARAM_MEDIA_STATE_T eParamMediaStateIndicate);
/*----------------------------------------------------------------------------*/
/* OID handling */
/*----------------------------------------------------------------------------*/
VOID kalOidCmdClearance(IN P_GLUE_INFO_T prGlueInfo);
VOID kalOidClearance(IN P_GLUE_INFO_T prGlueInfo);
VOID kalEnqueueCommand(IN P_GLUE_INFO_T prGlueInfo, IN P_QUE_ENTRY_T prQueueEntry);
#if CFG_ENABLE_BT_OVER_WIFI
/*----------------------------------------------------------------------------*/
/* Bluetooth over Wi-Fi handling */
/*----------------------------------------------------------------------------*/
VOID kalIndicateBOWEvent(IN P_GLUE_INFO_T prGlueInfo, IN P_AMPC_EVENT prEvent);
ENUM_BOW_DEVICE_STATE kalGetBowState(IN P_GLUE_INFO_T prGlueInfo, IN PARAM_MAC_ADDRESS rPeerAddr);
BOOLEAN kalSetBowState(IN P_GLUE_INFO_T prGlueInfo, IN ENUM_BOW_DEVICE_STATE eBowState, PARAM_MAC_ADDRESS rPeerAddr);
ENUM_BOW_DEVICE_STATE kalGetBowGlobalState(IN P_GLUE_INFO_T prGlueInfo);
UINT_32 kalGetBowFreqInKHz(IN P_GLUE_INFO_T prGlueInfo);
UINT_8 kalGetBowRole(IN P_GLUE_INFO_T prGlueInfo, IN PARAM_MAC_ADDRESS rPeerAddr);
VOID kalSetBowRole(IN P_GLUE_INFO_T prGlueInfo, IN UINT_8 ucRole, IN PARAM_MAC_ADDRESS rPeerAddr);
UINT_8 kalGetBowAvailablePhysicalLinkCount(IN P_GLUE_INFO_T prGlueInfo);
#if CFG_BOW_SEPARATE_DATA_PATH
/*----------------------------------------------------------------------------*/
/* Bluetooth over Wi-Fi Net Device Init/Uninit */
/*----------------------------------------------------------------------------*/
BOOLEAN kalInitBowDevice(IN P_GLUE_INFO_T prGlueInfo, IN const char *prDevName);
BOOLEAN kalUninitBowDevice(IN P_GLUE_INFO_T prGlueInfo);
#endif /* CFG_BOW_SEPARATE_DATA_PATH */
#endif /* CFG_ENABLE_BT_OVER_WIFI */
/*----------------------------------------------------------------------------*/
/* Security Frame Clearance */
/*----------------------------------------------------------------------------*/
VOID kalClearSecurityFrames(IN P_GLUE_INFO_T prGlueInfo);
VOID kalClearSecurityFramesByBssIdx(IN P_GLUE_INFO_T prGlueInfo, IN UINT_8 ucBssIndex);
VOID kalSecurityFrameSendComplete(IN P_GLUE_INFO_T prGlueInfo, IN PVOID pvPacket, IN WLAN_STATUS rStatus);
/*----------------------------------------------------------------------------*/
/* Management Frame Clearance */
/*----------------------------------------------------------------------------*/
VOID kalClearMgmtFrames(IN P_GLUE_INFO_T prGlueInfo);
VOID kalClearMgmtFramesByBssIdx(IN P_GLUE_INFO_T prGlueInfo, IN UINT_8 ucBssIndex);
UINT_32 kalGetTxPendingFrameCount(IN P_GLUE_INFO_T prGlueInfo);
UINT_32 kalGetTxPendingCmdCount(IN P_GLUE_INFO_T prGlueInfo);
VOID kalClearCommandQueue(IN P_GLUE_INFO_T prGlueInfo);
BOOLEAN kalSetTimer(IN P_GLUE_INFO_T prGlueInfo, IN UINT_32 u4Interval);
BOOLEAN kalCancelTimer(IN P_GLUE_INFO_T prGlueInfo);
VOID kalScanDone(IN P_GLUE_INFO_T prGlueInfo, IN ENUM_KAL_NETWORK_TYPE_INDEX_T eNetTypeIdx, IN WLAN_STATUS status);
UINT_32 kalRandomNumber(VOID);
VOID kalTimeoutHandler(unsigned long arg);
VOID kalSetEvent(P_GLUE_INFO_T pr);
VOID kalSetIntEvent(P_GLUE_INFO_T pr);
#if CFG_SUPPORT_MULTITHREAD
VOID kalSetTxEvent2Hif(P_GLUE_INFO_T pr);
VOID kalSetTxEvent2Rx(P_GLUE_INFO_T pr);
VOID kalSetTxCmdEvent2Hif(P_GLUE_INFO_T pr);
#endif
/*----------------------------------------------------------------------------*/
/* NVRAM/Registry Service */
/*----------------------------------------------------------------------------*/
BOOLEAN kalIsConfigurationExist(IN P_GLUE_INFO_T prGlueInfo);
P_REG_INFO_T kalGetConfiguration(IN P_GLUE_INFO_T prGlueInfo);
VOID
kalGetConfigurationVersion(IN P_GLUE_INFO_T prGlueInfo,
OUT PUINT_16 pu2Part1CfgOwnVersion,
OUT PUINT_16 pu2Part1CfgPeerVersion,
OUT PUINT_16 pu2Part2CfgOwnVersion, OUT PUINT_16 pu2Part2CfgPeerVersion);
BOOLEAN kalCfgDataRead16(IN P_GLUE_INFO_T prGlueInfo, IN UINT_32 u4Offset, OUT PUINT_16 pu2Data);
BOOLEAN kalCfgDataWrite16(IN P_GLUE_INFO_T prGlueInfo, IN UINT_32 u4Offset, IN UINT_16 u2Data);
/*----------------------------------------------------------------------------*/
/* WSC Connection */
/*----------------------------------------------------------------------------*/
BOOLEAN kalWSCGetActiveState(IN P_GLUE_INFO_T prGlueInfo);
/*----------------------------------------------------------------------------*/
/* RSSI Updating */
/*----------------------------------------------------------------------------*/
VOID
kalUpdateRSSI(IN P_GLUE_INFO_T prGlueInfo,
IN ENUM_KAL_NETWORK_TYPE_INDEX_T eNetTypeIdx, IN INT_8 cRssi, IN INT_8 cLinkQuality);
/*----------------------------------------------------------------------------*/
/* I/O Buffer Pre-allocation */
/*----------------------------------------------------------------------------*/
BOOLEAN kalInitIOBuffer(BOOLEAN is_pre_alloc);
VOID kalUninitIOBuffer(VOID);
PVOID kalAllocateIOBuffer(IN UINT_32 u4AllocSize);
VOID kalReleaseIOBuffer(IN PVOID pvAddr, IN UINT_32 u4Size);
VOID
kalGetChannelList(IN P_GLUE_INFO_T prGlueInfo,
IN ENUM_BAND_T eSpecificBand,
IN UINT_8 ucMaxChannelNum, IN PUINT_8 pucNumOfChannel, IN P_RF_CHANNEL_INFO_T paucChannelList);
BOOL kalIsAPmode(IN P_GLUE_INFO_T prGlueInfo);
#if CFG_SUPPORT_802_11W
/*----------------------------------------------------------------------------*/
/* 802.11W */
/*----------------------------------------------------------------------------*/
UINT_32 kalGetMfpSetting(IN P_GLUE_INFO_T prGlueInfo);
UINT_8 kalGetRsnIeMfpCap(IN P_GLUE_INFO_T prGlueInfo);
#endif
/*----------------------------------------------------------------------------*/
/* file opetation */
/*----------------------------------------------------------------------------*/
UINT_32 kalWriteToFile(const PUINT_8 pucPath, BOOLEAN fgDoAppend, PUINT_8 pucData, UINT_32 u4Size);
UINT_32 kalCheckPath(const PUINT_8 pucPath);
UINT_32 kalTrunkPath(const PUINT_8 pucPath);
INT_32 kalReadToFile(const PUINT_8 pucPath, PUINT_8 pucData, UINT_32 u4Size, PUINT_32 pu4ReadSize);
INT_32 kalRequestFirmware(const PUINT_8 pucPath, PUINT_8 pucData, UINT_32 u4Size,
PUINT_32 pu4ReadSize, struct device *dev);
/*----------------------------------------------------------------------------*/
/* NL80211 */
/*----------------------------------------------------------------------------*/
VOID
kalIndicateBssInfo(IN P_GLUE_INFO_T prGlueInfo,
IN PUINT_8 pucFrameBuf, IN UINT_32 u4BufLen, IN UINT_8 ucChannelNum, IN INT_32 i4SignalStrength);
/*----------------------------------------------------------------------------*/
/* Net device */
/*----------------------------------------------------------------------------*/
WLAN_STATUS
kalHardStartXmit(struct sk_buff *prSkb, IN struct net_device *prDev, P_GLUE_INFO_T prGlueInfo, UINT_8 ucBssIndex);
BOOLEAN
kalIsPairwiseEapolPacket(IN P_NATIVE_PACKET prPacket);
BOOLEAN
kalGetIPv4Address(IN struct net_device *prDev,
IN UINT_32 u4MaxNumOfAddr, OUT PUINT_8 pucIpv4Addrs, OUT PUINT_32 pu4NumOfIpv4Addr);
#if IS_ENABLED(CONFIG_IPV6)
BOOLEAN
kalGetIPv6Address(IN struct net_device *prDev,
IN UINT_32 u4MaxNumOfAddr, OUT PUINT_8 pucIpv6Addrs, OUT PUINT_32 pu4NumOfIpv6Addr);
#else
static inline BOOLEAN
kalGetIPv6Address(IN struct net_device *prDev,
IN UINT_32 u4MaxNumOfAddr, OUT PUINT_8 pucIpv6Addrs, OUT PUINT_32 pu4NumOfIpv6Addr) {
/* Not support IPv6 */
*pu4NumOfIpv6Addr = 0;
return FALSE;
}
#endif /* IS_ENABLED(CONFIG_IPV6) */
VOID kalSetNetAddressFromInterface(IN P_GLUE_INFO_T prGlueInfo, IN struct net_device *prDev, IN BOOLEAN fgSet);
WLAN_STATUS kalResetStats(IN struct net_device *prDev);
PVOID kalGetStats(IN struct net_device *prDev);
VOID kalResetPacket(IN P_GLUE_INFO_T prGlueInfo, IN P_NATIVE_PACKET prPacket);
#if CFG_SUPPORT_QA_TOOL
struct file *kalFileOpen(const char *path, int flags, int rights);
VOID kalFileClose(struct file *file);
UINT_32 kalFileRead(struct file *file, unsigned long long offset, unsigned char *data, unsigned int size);
#endif
#if CFG_SUPPORT_SDIO_READ_WRITE_PATTERN
/*----------------------------------------------------------------------------*/
/* SDIO Read/Write Pattern Support */
/*----------------------------------------------------------------------------*/
BOOLEAN kalSetSdioTestPattern(IN P_GLUE_INFO_T prGlueInfo, IN BOOLEAN fgEn, IN BOOLEAN fgRead);
#endif
/*----------------------------------------------------------------------------*/
/* PNO Support */
/*----------------------------------------------------------------------------*/
VOID kalSchedScanResults(IN P_GLUE_INFO_T prGlueInfo);
VOID kalSchedScanStopped(IN P_GLUE_INFO_T prGlueInfo);
#if CFG_MULTI_ECOVER_SUPPORT
#if 0
typedef enum _ENUM_WMTHWVER_TYPE_T {
WMTHWVER_E1 = 0x0,
WMTHWVER_E2 = 0x1,
WMTHWVER_E3 = 0x2,
WMTHWVER_E4 = 0x3,
WMTHWVER_E5 = 0x4,
WMTHWVER_E6 = 0x5,
WMTHWVER_MAX,
WMTHWVER_INVALID = 0xff
} ENUM_WMTHWVER_TYPE_T, *P_ENUM_WMTHWVER_TYPE_T;
extern ENUM_WMTHWVER_TYPE_T mtk_wcn_wmt_hwver_get(VOID);
#else
typedef enum _ENUM_WMTCHIN_TYPE_T {
WMTCHIN_CHIPID = 0x0,
WMTCHIN_HWVER = WMTCHIN_CHIPID + 1,
WMTCHIN_MAPPINGHWVER = WMTCHIN_HWVER + 1,
WMTCHIN_FWVER = WMTCHIN_MAPPINGHWVER + 1,
WMTCHIN_MAX
} ENUM_WMT_CHIPINFO_TYPE_T, *P_ENUM_WMT_CHIPINFO_TYPE_T;
UINT_32 mtk_wcn_wmt_ic_info_get(ENUM_WMT_CHIPINFO_TYPE_T type);
#endif
#endif
VOID kalSetFwOwnEvent2Hif(P_GLUE_INFO_T pr);
#if CFG_ASSERT_DUMP
/* Core Dump out put file */
WLAN_STATUS kalOpenCorDumpFile(BOOLEAN fgIsN9);
WLAN_STATUS kalWriteCorDumpFile(PUINT_8 pucBuffer, UINT_16 u2Size, BOOLEAN fgIsN9);
WLAN_STATUS kalCloseCorDumpFile(BOOLEAN fgIsN9);
#endif
/*******************************************************************************
* F U N C T I O N S
********************************************************************************
*/
#if CFG_WOW_SUPPORT
VOID kalWowInit(IN P_GLUE_INFO_T prGlueInfo);
VOID kalWowProcess(IN P_GLUE_INFO_T prGlueInfo, UINT_8 enable);
VOID kalWowUninit(IN P_GLUE_INFO_T prGlueInfo);
#endif
int main_thread(void *data);
#if CFG_SUPPORT_MULTITHREAD
int hif_thread(void *data);
int rx_thread(void *data);
#endif
UINT_64 kalGetBootTime(VOID);
int kalMetInitProcfs(IN P_GLUE_INFO_T prGlueInfo);
int kalMetRemoveProcfs(void);
VOID kalFreeTxMsduWorker(struct work_struct *work);
VOID kalFreeTxMsdu(P_ADAPTER_T prAdapter, P_MSDU_INFO_T prMsduInfo);
#if KERNEL_VERSION(3, 0, 0) <= LINUX_VERSION_CODE
/* since: 0b5c9db1b11d3175bb42b80663a9f072f801edf5 */
static inline void kal_skb_reset_mac_len(struct sk_buff *skb)
{
skb_reset_mac_len(skb);
}
#else
static inline void kal_skb_reset_mac_len(struct sk_buff *skb)
{
skb->mac_len = skb->network_header - skb->mac_header;
}
#endif
static inline UINT_64 kalDivU64(UINT_64 dividend, UINT_32 divisor)
{
return div_u64(dividend, divisor);
}
VOID kalInitDevWakeup(P_ADAPTER_T prAdapter, struct device *prDev);
#endif /* _GL_KAL_H */