static int wlcore_smart_config_sync_event(struct wl1271 *wl, u8 sync_channel,
u8 sync_band)
{
struct sk_buff *skb;
enum ieee80211_band band;
int freq;
if (sync_band == WLCORE_BAND_5GHZ)
band = IEEE80211_BAND_5GHZ;
else
band = IEEE80211_BAND_2GHZ;
freq = ieee80211_channel_to_frequency(sync_channel, band);
wl1271_debug(DEBUG_EVENT,
"SMART_CONFIG_SYNC_EVENT_ID, freq: %d (chan: %d band %d)",
freq, sync_channel, sync_band);
skb = cfg80211_vendor_event_alloc(wl->hw->wiphy, NULL, 20,
WLCORE_VENDOR_EVENT_SC_SYNC,
GFP_KERNEL);
if (nla_put_u32(skb, WLCORE_VENDOR_ATTR_FREQ, freq)) {
kfree_skb(skb);
return -EMSGSIZE;
}
cfg80211_vendor_event(skb, GFP_KERNEL);
return 0;
}
int mtk_cfg80211_vendor_event_scan_results_available(struct wiphy *wiphy, struct wireless_dev *wdev, UINT_32 num)
{
struct sk_buff *skb;
ASSERT(wiphy);
ASSERT(wdev);
/* UINT_32 scan_result; */
DBGLOG(REQ, INFO, "%s for vendor command %d \r\n", __func__, num);
skb = cfg80211_vendor_event_alloc(wiphy, sizeof(num), GSCAN_EVENT_SCAN_RESULTS_AVAILABLE, GFP_KERNEL);
if (!skb) {
DBGLOG(REQ, ERROR, "%s allocate skb failed\n", __func__);
return -ENOMEM;
}
/* scan_result = 2; */
/*NLA_PUT_U32(skb, GSCAN_EVENT_SCAN_RESULTS_AVAILABLE, num);*/
{
unsigned int __tmp = num;
if (unlikely(nla_put(skb, GSCAN_EVENT_SCAN_RESULTS_AVAILABLE,
sizeof(unsigned int), &__tmp) < 0))
goto nla_put_failure;
}
cfg80211_vendor_event(skb, GFP_KERNEL);
return 0;
nla_put_failure:
kfree_skb(skb);
return -1;
}
int mtk_cfg80211_vendor_event_complete_scan(struct wiphy *wiphy, struct wireless_dev *wdev, WIFI_SCAN_EVENT complete)
{
struct sk_buff *skb;
ASSERT(wiphy);
ASSERT(wdev);
/* WIFI_SCAN_EVENT complete_scan; */
DBGLOG(REQ, INFO, "%s for vendor command \r\n", __func__);
skb = cfg80211_vendor_event_alloc(wiphy, sizeof(complete), GSCAN_EVENT_COMPLETE_SCAN, GFP_KERNEL);
if (!skb) {
DBGLOG(REQ, ERROR, "%s allocate skb failed\n", __func__);
return -ENOMEM;
}
/* complete_scan = WIFI_SCAN_COMPLETE; */
/*NLA_PUT_U32(skb, GSCAN_EVENT_COMPLETE_SCAN, complete);*/
{
unsigned int __tmp = complete;
if (unlikely(nla_put(skb, GSCAN_EVENT_COMPLETE_SCAN,
sizeof(unsigned int), &__tmp) < 0))
goto nla_put_failure;
}
cfg80211_vendor_event(skb, GFP_KERNEL);
return 0;
nla_put_failure:
kfree_skb(skb);
return -1;
}
int mtk_cfg80211_vendor_event_full_scan_results(struct wiphy *wiphy, struct wireless_dev *wdev,
P_PARAM_WIFI_GSCAN_RESULT pdata, UINT_32 data_len)
{
struct sk_buff *skb;
PARAM_WIFI_GSCAN_RESULT result;
ASSERT(wiphy);
ASSERT(wdev);
DBGLOG(REQ, INFO, "%s for vendor command \r\n", __func__);
skb = cfg80211_vendor_event_alloc(wiphy, sizeof(result), GSCAN_EVENT_FULL_SCAN_RESULTS, GFP_KERNEL);
if (!skb) {
DBGLOG(REQ, ERROR, "%s allocate skb failed\n", __func__);
return -ENOMEM;
}
kalMemZero(&result, sizeof(result));
kalMemCopy(result.ssid, "Gscan_full_test", sizeof("Gscan_full_test"));
result.channel = 2437;
/* kalMemCopy(&result, pdata, sizeof(PARAM_WIFI_GSCAN_RESULT); */
/*NLA_PUT(skb, GSCAN_EVENT_FULL_SCAN_RESULTS, sizeof(result), &result);*/
if (unlikely(nla_put(skb, GSCAN_EVENT_FULL_SCAN_RESULTS,
sizeof(result), &result) < 0))
goto nla_put_failure;
cfg80211_vendor_event(skb, GFP_KERNEL);
return 0;
nla_put_failure:
kfree_skb(skb);
return -1;
}
int wl_cfgvendor_send_hotlist_event(struct wiphy *wiphy,
struct net_device *dev, void *data, int len, wl_vendor_event_t event)
{
u16 kflags;
const void *ptr;
struct sk_buff *skb;
int malloc_len, total, iter_cnt_to_send, cnt;
gscan_results_cache_t *cache = (gscan_results_cache_t *)data;
total = len/sizeof(wifi_gscan_result_t);
while (total > 0) {
malloc_len = (total * sizeof(wifi_gscan_result_t)) + VENDOR_DATA_OVERHEAD;
if (malloc_len > NLMSG_DEFAULT_SIZE) {
malloc_len = NLMSG_DEFAULT_SIZE;
}
iter_cnt_to_send =
(malloc_len - VENDOR_DATA_OVERHEAD)/sizeof(wifi_gscan_result_t);
total = total - iter_cnt_to_send;
kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
/* Alloc the SKB for vendor_event */
skb = cfg80211_vendor_event_alloc(wiphy, malloc_len, event, kflags);
if (!skb) {
WL_ERR(("skb alloc failed"));
return -ENOMEM;
}
while (cache && iter_cnt_to_send) {
ptr = (const void *) &cache->results[cache->tot_consumed];
if (iter_cnt_to_send < (cache->tot_count - cache->tot_consumed))
cnt = iter_cnt_to_send;
else
cnt = (cache->tot_count - cache->tot_consumed);
iter_cnt_to_send -= cnt;
cache->tot_consumed += cnt;
/* Push the data to the skb */
nla_append(skb, cnt * sizeof(wifi_gscan_result_t), ptr);
if (cache->tot_consumed == cache->tot_count)
cache = cache->next;
}
cfg80211_vendor_event(skb, kflags);
}
return 0;
}
void dbg_rtw_cfg80211_vendor_event(struct sk_buff *skb, gfp_t gfp
, const enum mstat_f flags, const char *func, const int line)
{
unsigned int truesize = skb->truesize;
if(match_mstat_sniff_rules(flags, truesize))
DBG_871X("DBG_MEM_ALLOC %s:%d %s, truesize=%u\n", func, line, __FUNCTION__, truesize);
cfg80211_vendor_event(skb, gfp);
rtw_mstat_update(
flags
, MSTAT_FREE
, truesize
);
}
/**
* @brief send vendor event to kernel
*
* @param priv A pointer to moal_private
* @param event vendor event
* @param data a pointer to data
* @param len data length
*
* @return 0: success 1: fail
*/
int
woal_cfg80211_vendor_event(IN moal_private *priv,
IN int event, IN t_u8 *data, IN int len)
{
struct wiphy *wiphy = priv->wdev->wiphy;
struct sk_buff *skb = NULL;
int event_id = 0;
t_u8 *pos = NULL;
int ret = 0;
ENTER();
PRINTM(MEVENT, "vendor event :0x%x\n", event);
event_id = woal_get_event_id(event);
if (event_max == event_id) {
PRINTM(MERROR, "Not find this event %d \n", event_id);
ret = 1;
LEAVE();
return ret;
}
/**allocate skb*/
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0)
skb = cfg80211_vendor_event_alloc(wiphy, NULL, len,
#else
skb = cfg80211_vendor_event_alloc(wiphy, len,
#endif
event_id, GFP_ATOMIC);
if (!skb) {
PRINTM(MERROR, "allocate memory fail for vendor event\n");
ret = 1;
LEAVE();
return ret;
}
pos = skb_put(skb, len);
memcpy(pos, data, len);
/**send event*/
cfg80211_vendor_event(skb, GFP_ATOMIC);
LEAVE();
return ret;
}
int mtk_cfg80211_vendor_event_significant_change_results(struct wiphy *wiphy, struct wireless_dev *wdev,
P_PARAM_WIFI_CHANGE_RESULT pdata, UINT_32 data_len)
{
struct sk_buff *skb;
PARAM_WIFI_CHANGE_RESULT result[2], *presult;
ASSERT(wiphy);
ASSERT(wdev);
DBGLOG(REQ, INFO, "%s for vendor command \r\n", __func__);
skb = cfg80211_vendor_event_alloc(wiphy, sizeof(PARAM_WIFI_CHANGE_RESULT),
GSCAN_EVENT_SIGNIFICANT_CHANGE_RESULTS, GFP_KERNEL);
if (!skb) {
DBGLOG(REQ, ERROR, "%s allocate skb failed\n", __func__);
return -ENOMEM;
}
presult = result;
kalMemZero(presult, (sizeof(PARAM_WIFI_CHANGE_RESULT) * 2));
/* only for test */
kalMemCopy(presult->bssid, "213123", sizeof(mac_addr));
presult->channel = 2437;
presult->rssi[0] = -45;
presult->rssi[1] = -46;
presult++;
presult->channel = 2439;
presult->rssi[0] = -47;
presult->rssi[1] = -48;
/*NLA_PUT(skb, GSCAN_EVENT_SIGNIFICANT_CHANGE_RESULTS, (sizeof(PARAM_WIFI_CHANGE_RESULT) * 2), result);*/
if (unlikely(nla_put(skb, GSCAN_EVENT_SIGNIFICANT_CHANGE_RESULTS,
(sizeof(PARAM_WIFI_CHANGE_RESULT) * 2), result) < 0))
goto nla_put_failure;
cfg80211_vendor_event(skb, GFP_KERNEL);
return 0;
nla_put_failure:
kfree_skb(skb);
return -1;
}
static int wlcore_smart_config_decode_event(struct wl1271 *wl,
u8 ssid_len, u8 *ssid,
u8 pwd_len, u8 *pwd)
{
struct sk_buff *skb;
wl1271_debug(DEBUG_EVENT, "SMART_CONFIG_DECODE_EVENT_ID");
wl1271_dump_ascii(DEBUG_EVENT, "SSID:", ssid, ssid_len);
skb = cfg80211_vendor_event_alloc(wl->hw->wiphy, NULL,
ssid_len + pwd_len + 20,
WLCORE_VENDOR_EVENT_SC_DECODE,
GFP_KERNEL);
if (nla_put(skb, WLCORE_VENDOR_ATTR_SSID, ssid_len, ssid) ||
nla_put(skb, WLCORE_VENDOR_ATTR_PSK, pwd_len, pwd)) {
kfree_skb(skb);
return -EMSGSIZE;
}
cfg80211_vendor_event(skb, GFP_KERNEL);
return 0;
}
/*
* This API is to be used for asynchronous vendor events. This
* shouldn't be used in response to a vendor command from its
* do_it handler context (instead wl_cfgvendor_send_cmd_reply should
* be used).
*/
int wl_cfgvendor_send_async_event(struct wiphy *wiphy,
struct net_device *dev, int event_id, const void *data, int len)
{
u16 kflags;
struct sk_buff *skb;
kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
/* Alloc the SKB for vendor_event */
skb = cfg80211_vendor_event_alloc(wiphy, len, event_id, kflags);
if (!skb) {
WL_ERR(("skb alloc failed"));
return -ENOMEM;
}
/* Push the data to the skb */
nla_put_nohdr(skb, len, data);
cfg80211_vendor_event(skb, kflags);
return 0;
}
int mtk_cfg80211_vendor_event_hotlist_ap_found(struct wiphy *wiphy, struct wireless_dev *wdev,
P_PARAM_WIFI_GSCAN_RESULT pdata, UINT_32 data_len)
{
struct sk_buff *skb;
PARAM_WIFI_GSCAN_RESULT result[2], *presult;
ASSERT(wiphy);
ASSERT(wdev);
DBGLOG(REQ, INFO, "%s for vendor command \r\n", __func__);
skb = cfg80211_vendor_event_alloc(wiphy, sizeof(PARAM_WIFI_GSCAN_RESULT),
GSCAN_EVENT_HOTLIST_RESULTS_FOUND, GFP_KERNEL);
if (!skb) {
DBGLOG(REQ, ERROR, "%s allocate skb failed\n", __func__);
return -ENOMEM;
}
presult = result;
kalMemZero(presult, (sizeof(PARAM_WIFI_GSCAN_RESULT) * 2));
/* only for test */
kalMemCopy(presult->bssid, "123123", sizeof(mac_addr));
presult->channel = 2441;
presult->rssi = -45;
presult++;
presult->channel = 2443;
presult->rssi = -47;
/*NLA_PUT(skb, GSCAN_EVENT_HOTLIST_RESULTS_FOUND, (sizeof(PARAM_WIFI_GSCAN_RESULT) * 2), result);*/
if (unlikely(nla_put(skb, GSCAN_EVENT_HOTLIST_RESULTS_FOUND,
(sizeof(PARAM_WIFI_GSCAN_RESULT) * 2), result) < 0))
goto nla_put_failure;
cfg80211_vendor_event(skb, GFP_KERNEL);
return 0;
nla_put_failure:
kfree_skb(skb);
return -1;
}
