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; }