VOID wlanDebugInit(VOID) { /* debug for command/tc4 resource begin */ gprTcReleaseTraceBuffer = kalMemAlloc(TC_RELEASE_TRACE_BUF_MAX_NUM * sizeof(TC_RES_RELEASE_ENTRY), PHY_MEM_TYPE); kalMemZero(gprTcReleaseTraceBuffer, TC_RELEASE_TRACE_BUF_MAX_NUM * sizeof(TC_RES_RELEASE_ENTRY)); gprCmdTraceEntry = kalMemAlloc(TXED_CMD_TRACE_BUF_MAX_NUM * sizeof(CMD_TRACE_ENTRY), PHY_MEM_TYPE); kalMemZero(gprCmdTraceEntry, 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; }
int mtk_cfg80211_vendor_set_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; /* CMD_GSCN_REQ_T rCmdGscnParam; */ /* INT_32 i4Status = -EINVAL; */ P_PARAM_WIFI_GSCAN_CMD_PARAMS prWifiScanCmd; struct nlattr *attr[GSCAN_ATTRIBUTE_REPORT_EVENTS + 1]; struct nlattr *pbucket, *pchannel; UINT_32 len_basic, len_bucket, len_channel; int i, j, k; ASSERT(wiphy); ASSERT(wdev); if ((data == NULL) || !data_len) goto nla_put_failure; prWifiScanCmd = (P_PARAM_WIFI_GSCAN_CMD_PARAMS) kalMemAlloc(sizeof(PARAM_WIFI_GSCAN_CMD_PARAMS), VIR_MEM_TYPE); if (!prWifiScanCmd) { DBGLOG(REQ, ERROR, "Can not alloc memory for PARAM_WIFI_GSCAN_CMD_PARAMS\n"); return -ENOMEM; } DBGLOG(REQ, INFO, "%s for vendor command: data_len=%d \r\n", __func__, data_len); kalMemZero(prWifiScanCmd, sizeof(PARAM_WIFI_GSCAN_CMD_PARAMS)); kalMemZero(attr, sizeof(struct nlattr *) * (GSCAN_ATTRIBUTE_REPORT_EVENTS + 1)); nla_parse_nested(attr, GSCAN_ATTRIBUTE_REPORT_EVENTS, (struct nlattr *)(data - NLA_HDRLEN), nla_parse_policy); len_basic = 0; for (k = GSCAN_ATTRIBUTE_NUM_BUCKETS; k <= GSCAN_ATTRIBUTE_REPORT_EVENTS; k++) { if (attr[k]) { switch (k) { case GSCAN_ATTRIBUTE_BASE_PERIOD: prWifiScanCmd->base_period = nla_get_u32(attr[k]); len_basic += NLA_ALIGN(attr[k]->nla_len); break; case GSCAN_ATTRIBUTE_NUM_BUCKETS: prWifiScanCmd->num_buckets = nla_get_u32(attr[k]); len_basic += NLA_ALIGN(attr[k]->nla_len); DBGLOG(REQ, TRACE, "attr=0x%x, num_buckets=%d nla_len=%d, \r\n", *(UINT_32 *) attr[k], prWifiScanCmd->num_buckets, attr[k]->nla_len); break; } } } pbucket = (struct nlattr *)((UINT_8 *) data + len_basic); DBGLOG(REQ, TRACE, "+++basic attribute size=%d pbucket=%p\r\n", len_basic, pbucket); for (i = 0; i < prWifiScanCmd->num_buckets; i++) { if (nla_parse_nested(attr, GSCAN_ATTRIBUTE_REPORT_EVENTS, (struct nlattr *)pbucket, nla_parse_policy) < 0) goto nla_put_failure; len_bucket = 0; for (k = GSCAN_ATTRIBUTE_NUM_BUCKETS; k <= GSCAN_ATTRIBUTE_REPORT_EVENTS; k++) { if (attr[k]) { switch (k) { case GSCAN_ATTRIBUTE_BUCKETS_BAND: prWifiScanCmd->buckets[i].band = nla_get_u32(attr[k]); len_bucket += NLA_ALIGN(attr[k]->nla_len); break; case GSCAN_ATTRIBUTE_BUCKET_ID: prWifiScanCmd->buckets[i].bucket = nla_get_u32(attr[k]); len_bucket += NLA_ALIGN(attr[k]->nla_len); break; case GSCAN_ATTRIBUTE_BUCKET_PERIOD: prWifiScanCmd->buckets[i].period = nla_get_u32(attr[k]); len_bucket += NLA_ALIGN(attr[k]->nla_len); break; case GSCAN_ATTRIBUTE_REPORT_EVENTS: prWifiScanCmd->buckets[i].report_events = nla_get_u32(attr[k]); len_bucket += NLA_ALIGN(attr[k]->nla_len); break; case GSCAN_ATTRIBUTE_BUCKET_NUM_CHANNELS: prWifiScanCmd->buckets[i].num_channels = nla_get_u32(attr[k]); len_bucket += NLA_ALIGN(attr[k]->nla_len); DBGLOG(REQ, TRACE, "bucket%d: attr=0x%x, num_channels=%d nla_len = %d, \r\n", i, *(UINT_32 *) attr[k], nla_get_u32(attr[k]), attr[k]->nla_len); break; } } } pbucket = (struct nlattr *)((UINT_8 *) pbucket + NLA_HDRLEN); /* request.attr_start(i) as nested attribute */ DBGLOG(REQ, TRACE, "+++pure bucket size=%d pbucket=%p \r\n", len_bucket, pbucket); pbucket = (struct nlattr *)((UINT_8 *) pbucket + len_bucket); /* pure bucket payload, not include channels */ /*don't need to use nla_parse_nested to parse channels */ /* the header of channel in bucket i */ pchannel = (struct nlattr *)((UINT_8 *) pbucket + NLA_HDRLEN); for (j = 0; j < prWifiScanCmd->buckets[i].num_channels; j++) { prWifiScanCmd->buckets[i].channels[j].channel = nla_get_u32(pchannel); len_channel = NLA_ALIGN(pchannel->nla_len); DBGLOG(REQ, TRACE, "attr=0x%x, channel=%d, \r\n", *(UINT_32 *) pchannel, nla_get_u32(pchannel)); pchannel = (struct nlattr *)((UINT_8 *) pchannel + len_channel); } pbucket = pchannel; } DBGLOG(REQ, TRACE, "base_period=%d, num_buckets=%d, bucket0: %d %d %d %d", prWifiScanCmd->base_period, prWifiScanCmd->num_buckets, prWifiScanCmd->buckets[0].bucket, prWifiScanCmd->buckets[0].period, prWifiScanCmd->buckets[0].band, prWifiScanCmd->buckets[0].report_events); DBGLOG(REQ, TRACE, "num_channels=%d, channel0=%d, channel1=%d; num_channels=%d, channel0=%d, channel1=%d", prWifiScanCmd->buckets[0].num_channels, prWifiScanCmd->buckets[0].channels[0].channel, prWifiScanCmd->buckets[0].channels[1].channel, prWifiScanCmd->buckets[1].num_channels, prWifiScanCmd->buckets[1].channels[0].channel, prWifiScanCmd->buckets[1].channels[1].channel); prGlueInfo = (P_GLUE_INFO_T) wiphy_priv(wiphy); ASSERT(prGlueInfo); rStatus = kalIoctl(prGlueInfo, wlanoidSetGSCNAParam, prWifiScanCmd, sizeof(PARAM_WIFI_GSCAN_CMD_PARAMS), FALSE, FALSE, TRUE, FALSE, &u4BufLen); return 0; nla_put_failure: return -1; }