VOID wlanDebugUninit(VOID)
{
/* debug for command/tc4 resource begin */
kalMemFree(gprTcReleaseTraceBuffer, PHY_MEM_TYPE,
TC_RELEASE_TRACE_BUF_MAX_NUM * sizeof(TC_RES_RELEASE_ENTRY));
kalMemFree(gprCmdTraceEntry, PHY_MEM_TYPE, TXED_CMD_TRACE_BUF_MAX_NUM * sizeof(CMD_TRACE_ENTRY));
/* debug for command/tc4 resource end */
}
/*----------------------------------------------------------------------------*/
int
mtk_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *ndev, struct cfg80211_pmksa *pmksa)
{
P_GLUE_INFO_T prGlueInfo = NULL;
WLAN_STATUS rStatus;
UINT_32 u4BufLen;
P_PARAM_PMKID_T prPmkid;
prGlueInfo = (P_GLUE_INFO_T) wiphy_priv(wiphy);
ASSERT(prGlueInfo);
prPmkid = (P_PARAM_PMKID_T) kalMemAlloc(8 + sizeof(PARAM_BSSID_INFO_T), VIR_MEM_TYPE);
if (!prPmkid) {
DBGLOG(INIT, INFO, ("Can not alloc memory for IW_PMKSA_ADD\n"));
return -ENOMEM;
}
prPmkid->u4Length = 8 + sizeof(PARAM_BSSID_INFO_T);
prPmkid->u4BSSIDInfoCount = 1;
kalMemCopy(prPmkid->arBSSIDInfo->arBSSID, pmksa->bssid, 6);
kalMemCopy(prPmkid->arBSSIDInfo->arPMKID, pmksa->pmkid, IW_PMKID_LEN);
rStatus = kalIoctl(prGlueInfo,
wlanoidSetPmkid,
prPmkid, sizeof(PARAM_PMKID_T), FALSE, FALSE, FALSE, FALSE, &u4BufLen);
if (rStatus != WLAN_STATUS_SUCCESS) {
DBGLOG(INIT, INFO, ("add pmkid error:%lx\n", rStatus));
}
kalMemFree(prPmkid, VIR_MEM_TYPE, 8 + sizeof(PARAM_BSSID_INFO_T));
return 0;
}
/*----------------------------------------------------------------------------*/
int mtk_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *ndev)
{
P_GLUE_INFO_T prGlueInfo = NULL;
WLAN_STATUS rStatus;
UINT_32 u4BufLen;
P_PARAM_PMKID_T prPmkid;
prGlueInfo = (P_GLUE_INFO_T) wiphy_priv(wiphy);
ASSERT(prGlueInfo);
prPmkid = (P_PARAM_PMKID_T) kalMemAlloc(8, VIR_MEM_TYPE);
if (!prPmkid) {
DBGLOG(INIT, INFO, ("Can not alloc memory for IW_PMKSA_FLUSH\n"));
return -ENOMEM;
}
prPmkid->u4Length = 8;
prPmkid->u4BSSIDInfoCount = 0;
rStatus = kalIoctl(prGlueInfo,
wlanoidSetPmkid,
prPmkid, sizeof(PARAM_PMKID_T), FALSE, FALSE, FALSE, FALSE, &u4BufLen);
if (rStatus != WLAN_STATUS_SUCCESS) {
DBGLOG(INIT, INFO, ("flush pmkid error:%lx\n", rStatus));
}
kalMemFree(prPmkid, VIR_MEM_TYPE, 8);
return 0;
}
/*----------------------------------------------------------------------------*/
NDIS_STATUS dbgLogWr2(IN PINT_8 debugStr, IN ...
)
{
#define TMP_BUF_LEN 256
#define TMP_WBUF_LEN (TMP_BUF_LEN * 2)
va_list paramList;
PINT_16 wbuf_p;
PINT_8 buf_p;
INT_32 strLen;
/* Create log message buffer */
buf_p = (PINT_8) kalMemAlloc(TMP_BUF_LEN, VIR_MEM_TYPE);
if (buf_p == NULL) {
return NDIS_STATUS_FAILURE;
}
wbuf_p = (PINT_16) kalMemAlloc(TMP_WBUF_LEN, VIR_MEM_TYPE);
if (wbuf_p == NULL) {
kalMemFree(buf_p, VIR_MEM_TYPE, TMP_BUF_LEN);
return NDIS_STATUS_FAILURE;
}
/* Format message */
kalMemZero(buf_p, TMP_BUF_LEN);
kalMemZero(wbuf_p, TMP_WBUF_LEN);
va_start(paramList, debugStr);
_vsnprintf(buf_p, TMP_BUF_LEN - 1, debugStr, paramList);
va_end(paramList);
strLen = strlen(buf_p);
/* Converts a sequence of multibyte characters to a corresponding sequence
of wide characters. */
mbstowcs(wbuf_p, buf_p, strLen);
/* Print unicode message */
NKDbgPrintfW(TEXT("%s"), wbuf_p);
/* Free message buffer */
kalMemFree(buf_p, VIR_MEM_TYPE, TMP_BUF_LEN);
kalMemFree(wbuf_p, VIR_MEM_TYPE, TMP_WBUF_LEN);
return NDIS_STATUS_SUCCESS;
} /* dbgLogWr2 */
int mtk_cfg80211_vendor_llstats_get_info(struct wiphy *wiphy, struct wireless_dev *wdev, const void *data, int data_len)
{
INT_32 i4Status = -EINVAL;
WIFI_RADIO_STAT *pRadioStat;
struct sk_buff *skb;
UINT_32 u4BufLen;
ASSERT(wiphy);
ASSERT(wdev);
u4BufLen = sizeof(WIFI_RADIO_STAT) + sizeof(WIFI_IFACE_STAT);
pRadioStat = kalMemAlloc(u4BufLen, VIR_MEM_TYPE);
if (!pRadioStat) {
DBGLOG(REQ, ERROR, "%s kalMemAlloc pRadioStat failed\n", __func__);
return -ENOMEM;
}
kalMemZero(pRadioStat, u4BufLen);
skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, u4BufLen);
if (!skb) {
DBGLOG(REQ, TRACE, "%s allocate skb failed:%x\n", __func__, i4Status);
return -ENOMEM;
}
/*rStatus = kalIoctl(prGlueInfo,
wlanoidQueryStatistics,
&rRadioStat,
sizeof(rRadioStat),
TRUE,
TRUE,
TRUE,
FALSE,
&u4BufLen); */
/* only for test */
pRadioStat->radio = 10;
pRadioStat->on_time = 11;
pRadioStat->tx_time = 12;
pRadioStat->num_channels = 4;
/*NLA_PUT(skb, NL80211_ATTR_VENDOR_LLSTAT, u4BufLen, pRadioStat);*/
if (unlikely(nla_put(skb, NL80211_ATTR_VENDOR_LLSTAT,
u4BufLen, pRadioStat) < 0))
goto nla_put_failure;
i4Status = cfg80211_vendor_cmd_reply(skb);
kalMemFree(pRadioStat, VIR_MEM_TYPE, u4BufLen);
return -1; /* not support LLS now*/
/* return i4Status; */
nla_put_failure:
kfree_skb(skb);
return i4Status;
}
/*----------------------------------------------------------------------------*/
NDIS_STATUS dbgLogWr(IN PINT_8 debugStr, IN ...
)
{
#define TMP_BUF_LEN 256
int strLen;
DWORD BytesWritten;
PINT_8 buf_p = NULL;
HANDLE FileHandle = NULL;
va_list paramList;
UINT_32 systemUpTime;
/* Open the log file */
FileHandle = CreateFile(TEXT(DEBUG_FILE_NAME), GENERIC_WRITE, 0, /* No sharing */
NULL, /* Handle cannot be inherited */
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (FileHandle == INVALID_HANDLE_VALUE) {
return NDIS_STATUS_FAILURE;
}
/* Create log message buffer */
buf_p = (PUINT_8) kalMemAlloc(TMP_BUF_LEN, VIR_MEM_TYPE);
if (buf_p == NULL) {
CloseHandle(FileHandle);
return NDIS_STATUS_FAILURE;
}
/* Get system time */
NdisGetSystemUpTime(&systemUpTime);
/* Format log message: systemTime + message */
kalMemZero(buf_p, TMP_BUF_LEN);
va_start(paramList, debugStr);
sprintf(buf_p, "%10d ", systemUpTime);
/* 11: 10-digit time and 1 space */
_vsnprintf(buf_p + 11, TMP_BUF_LEN - 12, debugStr, paramList);
strLen = strlen(buf_p);
/* Write message log to log file */
SetFilePointer(FileHandle, 0, 0, FILE_END);
WriteFile(FileHandle, buf_p, strLen, &BytesWritten, NULL);
CloseHandle(FileHandle);
kalMemFree(buf_p, VIR_MEM_TYPE, TMP_BUF_LEN);
return NDIS_STATUS_SUCCESS;
} /* dbgLogWr */
/*----------------------------------------------------------------------------*/
WLAN_STATUS
wlanoidSetP2pSetNetworkAddress(IN P_ADAPTER_T prAdapter,
IN PVOID pvSetBuffer,
IN UINT_32 u4SetBufferLen, OUT PUINT_32 pu4SetInfoLen)
{
WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
UINT_32 i, j;
P_CMD_SET_NETWORK_ADDRESS_LIST prCmdNetworkAddressList;
P_PARAM_NETWORK_ADDRESS_LIST prNetworkAddressList =
(P_PARAM_NETWORK_ADDRESS_LIST) pvSetBuffer;
P_PARAM_NETWORK_ADDRESS prNetworkAddress;
P_PARAM_NETWORK_ADDRESS_IP prNetAddrIp;
UINT_32 u4IpAddressCount, u4CmdSize;
PUINT_8 pucBuf = (PUINT_8) pvSetBuffer;
DEBUGFUNC("wlanoidSetP2pSetNetworkAddress");
DBGLOG(INIT, TRACE, ("\n"));
printk("wlanoidSetP2pSetNetworkAddress (%d)\n", (INT_16) u4SetBufferLen);
ASSERT(prAdapter);
ASSERT(pu4SetInfoLen);
*pu4SetInfoLen = 4;
if (u4SetBufferLen < sizeof(PARAM_NETWORK_ADDRESS_LIST)) {
return WLAN_STATUS_INVALID_DATA;
}
*pu4SetInfoLen = 0;
u4IpAddressCount = 0;
prNetworkAddress = prNetworkAddressList->arAddress;
for (i = 0; i < prNetworkAddressList->u4AddressCount; i++) {
if (prNetworkAddress->u2AddressType == PARAM_PROTOCOL_ID_TCP_IP &&
prNetworkAddress->u2AddressLength == sizeof(PARAM_NETWORK_ADDRESS_IP)) {
u4IpAddressCount++;
}
prNetworkAddress = (P_PARAM_NETWORK_ADDRESS) ((UINT_32) prNetworkAddress +
(UINT_32) (prNetworkAddress->
u2AddressLength +
OFFSET_OF
(PARAM_NETWORK_ADDRESS,
aucAddress)));
}
/* construct payload of command packet */
u4CmdSize = OFFSET_OF(CMD_SET_NETWORK_ADDRESS_LIST, arNetAddress) +
sizeof(IPV4_NETWORK_ADDRESS) * u4IpAddressCount;
if (u4IpAddressCount == 0) {
u4CmdSize = sizeof(CMD_SET_NETWORK_ADDRESS_LIST);
}
prCmdNetworkAddressList =
(P_CMD_SET_NETWORK_ADDRESS_LIST) kalMemAlloc(u4CmdSize, VIR_MEM_TYPE);
if (prCmdNetworkAddressList == NULL)
return WLAN_STATUS_FAILURE;
/* fill P_CMD_SET_NETWORK_ADDRESS_LIST */
prCmdNetworkAddressList->ucNetTypeIndex = NETWORK_TYPE_P2P_INDEX;
/* only to set IP address to FW once ARP filter is enabled */
if (prAdapter->fgEnArpFilter) {
prCmdNetworkAddressList->ucAddressCount = (UINT_8) u4IpAddressCount;
prNetworkAddress = prNetworkAddressList->arAddress;
printk("u4IpAddressCount (%ld)\n", (INT_32) u4IpAddressCount);
for (i = 0, j = 0; i < prNetworkAddressList->u4AddressCount; i++) {
if (prNetworkAddress->u2AddressType == PARAM_PROTOCOL_ID_TCP_IP &&
prNetworkAddress->u2AddressLength == sizeof(PARAM_NETWORK_ADDRESS_IP)) {
prNetAddrIp =
(P_PARAM_NETWORK_ADDRESS_IP) prNetworkAddress->aucAddress;
kalMemCopy(prCmdNetworkAddressList->arNetAddress[j].aucIpAddr,
&(prNetAddrIp->in_addr), sizeof(UINT_32));
j++;
pucBuf = (PUINT_8) &prNetAddrIp->in_addr;
printk("prNetAddrIp->in_addr:%d:%d:%d:%d\n", (UINT_8) pucBuf[0],
(UINT_8) pucBuf[1], (UINT_8) pucBuf[2], (UINT_8) pucBuf[3]);
}
prNetworkAddress = (P_PARAM_NETWORK_ADDRESS) ((UINT_32) prNetworkAddress +
(UINT_32) (prNetworkAddress->
u2AddressLength +
OFFSET_OF
(PARAM_NETWORK_ADDRESS,
aucAddress)));
}
} else {
prCmdNetworkAddressList->ucAddressCount = 0;
}
rStatus = wlanSendSetQueryCmd(prAdapter,
CMD_ID_SET_IP_ADDRESS,
TRUE,
FALSE,
TRUE,
nicCmdEventSetIpAddress,
nicOidCmdTimeoutCommon,
u4CmdSize,
(PUINT_8) prCmdNetworkAddressList,
pvSetBuffer, u4SetBufferLen);
kalMemFree(prCmdNetworkAddressList, VIR_MEM_TYPE, u4CmdSize);
return rStatus;
} /* end of wlanoidSetP2pSetNetworkAddress() */
int mtk_cfg80211_vendor_set_hotlist(struct wiphy *wiphy, struct wireless_dev *wdev, const void *data, int data_len)
{
/*WLAN_STATUS rStatus;*/
P_GLUE_INFO_T prGlueInfo = NULL;
CMD_SET_PSCAN_ADD_HOTLIST_BSSID rCmdPscnAddHotlist;
INT_32 i4Status = -EINVAL;
P_PARAM_WIFI_BSSID_HOTLIST prWifiHotlistCmd = NULL;
UINT_8 flush = 0;
/* struct nlattr *attr[GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_FLUSH + 1]; */
struct nlattr **attr = NULL;
struct nlattr *paplist;
int i, k;
UINT_32 len_basic, len_aplist;
ASSERT(wiphy);
ASSERT(wdev);
if ((data == NULL) || !data_len)
goto nla_put_failure;
DBGLOG(REQ, INFO, "%s for vendor command: data_len=%d \r\n", __func__, data_len);
for (i = 0; i < 5; i++)
DBGLOG(REQ, LOUD, "0x%x 0x%x 0x%x 0x%x \r\n",
*((UINT_32 *) data + i * 4), *((UINT_32 *) data + i * 4 + 1),
*((UINT_32 *) data + i * 4 + 2), *((UINT_32 *) data + i * 4 + 3));
prWifiHotlistCmd = kalMemAlloc(sizeof(PARAM_WIFI_BSSID_HOTLIST), VIR_MEM_TYPE);
if (prWifiHotlistCmd == NULL)
goto nla_put_failure;
kalMemZero(prWifiHotlistCmd, sizeof(PARAM_WIFI_BSSID_HOTLIST));
attr = kalMemAlloc(sizeof(struct nlattr *) * (GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_FLUSH + 1), VIR_MEM_TYPE);
if (attr == NULL)
goto nla_put_failure;
kalMemZero(attr, sizeof(struct nlattr *) * (GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_FLUSH + 1));
if (nla_parse_nested(attr, GSCAN_ATTRIBUTE_NUM_AP, (struct nlattr *)(data - NLA_HDRLEN), nla_parse_policy) < 0)
goto nla_put_failure;
len_basic = 0;
for (k = GSCAN_ATTRIBUTE_HOTLIST_FLUSH; k <= GSCAN_ATTRIBUTE_NUM_AP; k++) {
if (attr[k]) {
switch (k) {
case GSCAN_ATTRIBUTE_LOST_AP_SAMPLE_SIZE:
prWifiHotlistCmd->lost_ap_sample_size = nla_get_u32(attr[k]);
len_basic += NLA_ALIGN(attr[k]->nla_len);
break;
case GSCAN_ATTRIBUTE_NUM_AP:
prWifiHotlistCmd->num_ap = nla_get_u16(attr[k]);
len_basic += NLA_ALIGN(attr[k]->nla_len);
DBGLOG(REQ, TRACE, "attr=0x%x, num_ap=%d nla_len=%d, \r\n",
*(UINT_32 *) attr[k], prWifiHotlistCmd->num_ap, attr[k]->nla_len);
break;
case GSCAN_ATTRIBUTE_HOTLIST_FLUSH:
flush = nla_get_u8(attr[k]);
len_basic += NLA_ALIGN(attr[k]->nla_len);
break;
}
}
}
paplist = (struct nlattr *)((UINT_8 *) data + len_basic);
DBGLOG(REQ, TRACE, "+++basic attribute size=%d flush=%d\r\n", len_basic, flush);
if (paplist->nla_type == GSCAN_ATTRIBUTE_HOTLIST_BSSIDS)
paplist = (struct nlattr *)((UINT_8 *) paplist + NLA_HDRLEN);
for (i = 0; i < prWifiHotlistCmd->num_ap; i++) {
if (nla_parse_nested(attr, GSCAN_ATTRIBUTE_RSSI_HIGH, (struct nlattr *)paplist, nla_parse_policy) < 0)
goto nla_put_failure;
paplist = (struct nlattr *)((UINT_8 *) paplist + NLA_HDRLEN);
/* request.attr_start(i) as nested attribute */
len_aplist = 0;
for (k = GSCAN_ATTRIBUTE_BSSID; k <= GSCAN_ATTRIBUTE_RSSI_HIGH; k++) {
if (attr[k]) {
switch (k) {
case GSCAN_ATTRIBUTE_BSSID:
kalMemCopy(prWifiHotlistCmd->ap[i].bssid, nla_data(attr[k]), sizeof(mac_addr));
len_aplist += NLA_ALIGN(attr[k]->nla_len);
break;
case GSCAN_ATTRIBUTE_RSSI_LOW:
prWifiHotlistCmd->ap[i].low = nla_get_u32(attr[k]);
len_aplist += NLA_ALIGN(attr[k]->nla_len);
break;
case GSCAN_ATTRIBUTE_RSSI_HIGH:
prWifiHotlistCmd->ap[i].high = nla_get_u32(attr[k]);
len_aplist += NLA_ALIGN(attr[k]->nla_len);
break;
}
}
}
if (((i + 1) % 4 == 0) || (i == prWifiHotlistCmd->num_ap - 1))
DBGLOG(REQ, TRACE, "ap[%d], len_aplist=%d\n", i, len_aplist);
else
DBGLOG(REQ, TRACE, "ap[%d], len_aplist=%d \t", i, len_aplist);
paplist = (struct nlattr *)((UINT_8 *) paplist + len_aplist);
}
DBGLOG(REQ, TRACE,
"flush=%d, lost_ap_sample_size=%d, Hotlist:ap[0].channel=%d low=%d high=%d, ap[1].channel=%d low=%d high=%d",
flush, prWifiHotlistCmd->lost_ap_sample_size,
prWifiHotlistCmd->ap[0].channel, prWifiHotlistCmd->ap[0].low, prWifiHotlistCmd->ap[0].high,
prWifiHotlistCmd->ap[1].channel, prWifiHotlistCmd->ap[1].low, prWifiHotlistCmd->ap[1].high);
memcpy(&(rCmdPscnAddHotlist.aucMacAddr), &(prWifiHotlistCmd->ap[0].bssid), 6 * sizeof(UINT_8));
rCmdPscnAddHotlist.ucFlags = (UINT_8) TRUE;
prGlueInfo = (P_GLUE_INFO_T) wiphy_priv(wiphy);
ASSERT(prGlueInfo);
kalMemFree(prWifiHotlistCmd, VIR_MEM_TYPE, sizeof(PARAM_WIFI_BSSID_HOTLIST));
kalMemFree(attr, VIR_MEM_TYPE, sizeof(struct nlattr *) * (GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_FLUSH + 1));
return 0;
nla_put_failure:
if (prWifiHotlistCmd)
kalMemFree(prWifiHotlistCmd, VIR_MEM_TYPE, sizeof(PARAM_WIFI_BSSID_HOTLIST));
if (attr)
kalMemFree(attr, VIR_MEM_TYPE,
sizeof(struct nlattr *) * (GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_FLUSH + 1));
return i4Status;
}
int mtk_cfg80211_vendor_set_significant_change(struct wiphy *wiphy, struct wireless_dev *wdev,
const void *data, int data_len)
{
INT_32 i4Status = -EINVAL;
P_PARAM_WIFI_SIGNIFICANT_CHANGE prWifiChangeCmd = NULL;
UINT_8 flush = 0;
/* struct nlattr *attr[GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_FLUSH + 1]; */
struct nlattr **attr = NULL;
struct nlattr *paplist;
int i, k;
UINT_32 len_basic, len_aplist;
ASSERT(wiphy);
ASSERT(wdev);
if ((data == NULL) || !data_len)
goto nla_put_failure;
DBGLOG(REQ, INFO, "%s for vendor command: data_len=%d \r\n", __func__, data_len);
for (i = 0; i < 6; i++)
DBGLOG(REQ, LOUD, "0x%x 0x%x 0x%x 0x%x \r\n",
*((UINT_32 *) data + i * 4), *((UINT_32 *) data + i * 4 + 1),
*((UINT_32 *) data + i * 4 + 2), *((UINT_32 *) data + i * 4 + 3));
prWifiChangeCmd = kalMemAlloc(sizeof(PARAM_WIFI_SIGNIFICANT_CHANGE), VIR_MEM_TYPE);
if (prWifiChangeCmd == NULL)
goto nla_put_failure;
kalMemZero(prWifiChangeCmd, sizeof(PARAM_WIFI_SIGNIFICANT_CHANGE));
attr = kalMemAlloc(sizeof(struct nlattr *) * (GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_FLUSH + 1), VIR_MEM_TYPE);
if (attr == NULL)
goto nla_put_failure;
kalMemZero(attr, sizeof(struct nlattr *) * (GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_FLUSH + 1));
if (nla_parse_nested(attr, GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_FLUSH,
(struct nlattr *)(data - NLA_HDRLEN), nla_parse_policy) < 0)
goto nla_put_failure;
len_basic = 0;
for (k = GSCAN_ATTRIBUTE_RSSI_SAMPLE_SIZE; k <= GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_FLUSH; k++) {
if (attr[k]) {
switch (k) {
case GSCAN_ATTRIBUTE_RSSI_SAMPLE_SIZE:
prWifiChangeCmd->rssi_sample_size = nla_get_u16(attr[k]);
len_basic += NLA_ALIGN(attr[k]->nla_len);
break;
case GSCAN_ATTRIBUTE_LOST_AP_SAMPLE_SIZE:
prWifiChangeCmd->lost_ap_sample_size = nla_get_u16(attr[k]);
len_basic += NLA_ALIGN(attr[k]->nla_len);
break;
case GSCAN_ATTRIBUTE_MIN_BREACHING:
prWifiChangeCmd->min_breaching = nla_get_u16(attr[k]);
len_basic += NLA_ALIGN(attr[k]->nla_len);
break;
case GSCAN_ATTRIBUTE_NUM_AP:
prWifiChangeCmd->num_ap = nla_get_u16(attr[k]);
len_basic += NLA_ALIGN(attr[k]->nla_len);
DBGLOG(REQ, TRACE, "attr=0x%x, num_ap=%d nla_len=%d, \r\n",
*(UINT_32 *) attr[k], prWifiChangeCmd->num_ap, attr[k]->nla_len);
break;
case GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_FLUSH:
flush = nla_get_u8(attr[k]);
len_basic += NLA_ALIGN(attr[k]->nla_len);
break;
}
}
}
paplist = (struct nlattr *)((UINT_8 *) data + len_basic);
DBGLOG(REQ, TRACE, "+++basic attribute size=%d flush=%d\r\n", len_basic, flush);
if (paplist->nla_type == GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_BSSIDS)
paplist = (struct nlattr *)((UINT_8 *) paplist + NLA_HDRLEN);
for (i = 0; i < prWifiChangeCmd->num_ap; i++) {
if (nla_parse_nested(attr, GSCAN_ATTRIBUTE_RSSI_HIGH, (struct nlattr *)paplist, nla_parse_policy) < 0)
goto nla_put_failure;
paplist = (struct nlattr *)((UINT_8 *) paplist + NLA_HDRLEN);
/* request.attr_start(i) as nested attribute */
len_aplist = 0;
for (k = GSCAN_ATTRIBUTE_BSSID; k <= GSCAN_ATTRIBUTE_RSSI_HIGH; k++) {
if (attr[k]) {
switch (k) {
case GSCAN_ATTRIBUTE_BSSID:
kalMemCopy(prWifiChangeCmd->ap[i].bssid, nla_data(attr[k]), sizeof(mac_addr));
len_aplist += NLA_ALIGN(attr[k]->nla_len);
break;
case GSCAN_ATTRIBUTE_RSSI_LOW:
prWifiChangeCmd->ap[i].low = nla_get_u32(attr[k]);
len_aplist += NLA_ALIGN(attr[k]->nla_len);
break;
case GSCAN_ATTRIBUTE_RSSI_HIGH:
prWifiChangeCmd->ap[i].high = nla_get_u32(attr[k]);
len_aplist += NLA_ALIGN(attr[k]->nla_len);
break;
}
}
}
if (((i + 1) % 4 == 0) || (i == prWifiChangeCmd->num_ap - 1))
DBGLOG(REQ, TRACE, "ap[%d], len_aplist=%d\n", i, len_aplist);
else
DBGLOG(REQ, TRACE, "ap[%d], len_aplist=%d \t", i, len_aplist);
paplist = (struct nlattr *)((UINT_8 *) paplist + len_aplist);
}
DBGLOG(REQ, TRACE,
"flush=%d, rssi_sample_size=%d lost_ap_sample_size=%d min_breaching=%d",
flush, prWifiChangeCmd->rssi_sample_size, prWifiChangeCmd->lost_ap_sample_size,
prWifiChangeCmd->min_breaching);
DBGLOG(REQ, TRACE,
"ap[0].channel=%d low=%d high=%d, ap[1].channel=%d low=%d high=%d",
prWifiChangeCmd->ap[0].channel, prWifiChangeCmd->ap[0].low, prWifiChangeCmd->ap[0].high,
prWifiChangeCmd->ap[1].channel, prWifiChangeCmd->ap[1].low, prWifiChangeCmd->ap[1].high);
kalMemFree(prWifiChangeCmd, VIR_MEM_TYPE, sizeof(PARAM_WIFI_SIGNIFICANT_CHANGE));
kalMemFree(attr, VIR_MEM_TYPE, sizeof(struct nlattr *) * (GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_FLUSH + 1));
return 0;
nla_put_failure:
if (prWifiChangeCmd)
kalMemFree(prWifiChangeCmd, VIR_MEM_TYPE, sizeof(PARAM_WIFI_SIGNIFICANT_CHANGE));
if (attr)
kalMemFree(attr, VIR_MEM_TYPE,
sizeof(struct nlattr *) * (GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_FLUSH + 1));
return i4Status;
}
int mtk_cfg80211_vendor_set_scan_config(struct wiphy *wiphy, struct wireless_dev *wdev, const void *data, int data_len)
{
WLAN_STATUS rStatus;
UINT_32 u4BufLen;
P_GLUE_INFO_T prGlueInfo = NULL;
INT_32 i4Status = -EINVAL;
/*PARAM_WIFI_GSCAN_CMD_PARAMS rWifiScanCmd;*/
P_PARAM_WIFI_GSCAN_CMD_PARAMS prWifiScanCmd;
struct nlattr *attr[GSCAN_ATTRIBUTE_NUM_SCANS_TO_CACHE + 1];
/* UINT_32 num_scans = 0; */ /* another attribute */
int k;
ASSERT(wiphy);
ASSERT(wdev);
if ((data == NULL) || !data_len)
goto nla_put_failure;
DBGLOG(REQ, INFO, "%s for vendor command: data_len=%d \r\n", __func__, data_len);
/*kalMemZero(&rWifiScanCmd, sizeof(rWifiScanCmd));*/
prWifiScanCmd = kalMemAlloc(sizeof(PARAM_WIFI_GSCAN_CMD_PARAMS), VIR_MEM_TYPE);
if (prWifiScanCmd == NULL)
goto nla_put_failure;
kalMemZero(prWifiScanCmd, sizeof(PARAM_WIFI_GSCAN_CMD_PARAMS));
kalMemZero(attr, sizeof(struct nlattr *) * (GSCAN_ATTRIBUTE_NUM_SCANS_TO_CACHE + 1));
if (nla_parse_nested(attr, GSCAN_ATTRIBUTE_NUM_SCANS_TO_CACHE,
(struct nlattr *)(data - NLA_HDRLEN), nla_parse_policy) < 0)
goto nla_put_failure;
for (k = GSCAN_ATTRIBUTE_NUM_AP_PER_SCAN; k <= GSCAN_ATTRIBUTE_NUM_SCANS_TO_CACHE; k++) {
if (attr[k]) {
switch (k) {
case GSCAN_ATTRIBUTE_NUM_AP_PER_SCAN:
prWifiScanCmd->max_ap_per_scan = nla_get_u32(attr[k]);
break;
case GSCAN_ATTRIBUTE_REPORT_THRESHOLD:
prWifiScanCmd->report_threshold = nla_get_u32(attr[k]);
break;
case GSCAN_ATTRIBUTE_NUM_SCANS_TO_CACHE:
prWifiScanCmd->num_scans = nla_get_u32(attr[k]);
break;
}
}
}
DBGLOG(REQ, TRACE, "attr=0x%x, attr2=0x%x ", *(UINT_32 *) attr[GSCAN_ATTRIBUTE_NUM_AP_PER_SCAN],
*(UINT_32 *) attr[GSCAN_ATTRIBUTE_REPORT_THRESHOLD]);
DBGLOG(REQ, TRACE, "max_ap_per_scan=%d, report_threshold=%d num_scans=%d \r\n",
prWifiScanCmd->max_ap_per_scan, prWifiScanCmd->report_threshold, prWifiScanCmd->num_scans);
prGlueInfo = (P_GLUE_INFO_T) wiphy_priv(wiphy);
ASSERT(prGlueInfo);
rStatus = kalIoctl(prGlueInfo,
wlanoidSetGSCNAConfig,
prWifiScanCmd, sizeof(PARAM_WIFI_GSCAN_CMD_PARAMS), FALSE, FALSE, TRUE, FALSE, &u4BufLen);
kalMemFree(prWifiScanCmd, VIR_MEM_TYPE, sizeof(PARAM_WIFI_GSCAN_CMD_PARAMS));
return 0;
nla_put_failure:
return i4Status;
}
