1 /*
2 * Linux cfg80211 Vendor Extension Code
3 *
4 * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
5 *
6 * Copyright (C) 1999-2017, Broadcom Corporation
7 *
8 * Unless you and Broadcom execute a separate written software license
9 * agreement governing use of this software, this software is licensed to you
10 * under the terms of the GNU General Public License version 2 (the "GPL"),
11 * available at http://www.broadcom.com/licenses/GPLv2.php, with the
12 * following added to such license:
13 *
14 * As a special exception, the copyright holders of this software give you
15 * permission to link this software with independent modules, and to copy and
16 * distribute the resulting executable under terms of your choice, provided that
17 * you also meet, for each linked independent module, the terms and conditions of
18 * the license of that module. An independent module is a module which is not
19 * derived from this software. The special exception does not apply to any
20 * modifications of the software.
21 *
22 * Notwithstanding the above, under no circumstances may you combine this
23 * software in any way with any other Broadcom software provided under a license
24 * other than the GPL, without Broadcom's express prior written consent.
25 *
26 *
27 * <<Broadcom-WL-IPTag/Open:>>
28 *
29 * $Id: wl_cfgvendor.c 815871 2019-04-22 06:21:38Z $
30 */
31
32 /*
33 * New vendor interface additon to nl80211/cfg80211 to allow vendors
34 * to implement proprietary features over the cfg80211 stack.
35 */
36
37 #include <typedefs.h>
38 #include <linuxver.h>
39 #include <osl.h>
40 #include <linux/kernel.h>
41 #include <linux/vmalloc.h>
42
43 #include <bcmutils.h>
44 #include <bcmwifi_channels.h>
45 #include <bcmendian.h>
46 #include <ethernet.h>
47 #include <802.11.h>
48 #include <linux/if_arp.h>
49 #include <asm/uaccess.h>
50
51 #include <dngl_stats.h>
52 #include <dhd.h>
53 #include <dhd_debug.h>
54 #include <dhdioctl.h>
55 #include <wlioctl.h>
56 #include <wlioctl_utils.h>
57 #include <dhd_cfg80211.h>
58 #ifdef DHD_PKT_LOGGING
59 #include <dhd_pktlog.h>
60 #endif /* DHD_PKT_LOGGING */
61 #ifdef PNO_SUPPORT
62 #include <dhd_pno.h>
63 #endif /* PNO_SUPPORT */
64 #ifdef RTT_SUPPORT
65 #include <dhd_rtt.h>
66 #endif /* RTT_SUPPORT */
67
68 #include <ethernet.h>
69 #include <linux/kernel.h>
70 #include <linux/kthread.h>
71 #include <linux/netdevice.h>
72 #include <linux/sched.h>
73 #include <linux/etherdevice.h>
74 #include <linux/wireless.h>
75 #include <linux/ieee80211.h>
76 #include <linux/wait.h>
77 #include <net/cfg80211.h>
78 #include <net/rtnetlink.h>
79
80 #include <wlioctl.h>
81 #include <wldev_common.h>
82 #include <wl_cfg80211.h>
83 #include <wl_cfgp2p.h>
84 #ifdef WL_NAN
85 #include <wl_cfgnan.h>
86 #endif /* WL_NAN */
87 #ifdef OEM_ANDROID
88 #include <wl_android.h>
89 #endif /* OEM_ANDROID */
90 #include <wl_cfgvendor.h>
91 #ifdef PROP_TXSTATUS
92 #include <dhd_wlfc.h>
93 #endif // endif
94 #include <brcm_nl80211.h>
95
96 char*
wl_get_kernel_timestamp(void)97 wl_get_kernel_timestamp(void)
98 {
99 static char buf[32];
100 u64 ts_nsec;
101 unsigned long rem_nsec;
102
103 ts_nsec = local_clock();
104 rem_nsec = DIV_AND_MOD_U64_BY_U32(ts_nsec, NSEC_PER_SEC);
105 snprintf(buf, sizeof(buf), "%5lu.%06lu",
106 (unsigned long)ts_nsec, rem_nsec / NSEC_PER_USEC);
107
108 return buf;
109 }
110
111 #if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 13, 0)) || defined(WL_VENDOR_EXT_SUPPORT)
112 #if defined(WL_SUPP_EVENT)
113 int
wl_cfgvendor_send_supp_eventstring(const char * func_name,const char * fmt,...)114 wl_cfgvendor_send_supp_eventstring(const char *func_name, const char *fmt, ...)
115 {
116 char buf[SUPP_LOG_LEN] = {0};
117 struct bcm_cfg80211 *cfg;
118 struct wiphy *wiphy;
119 va_list args;
120 int len;
121 int prefix_len;
122 int rem_len;
123
124 cfg = wl_cfg80211_get_bcmcfg();
125 if (!cfg || !cfg->wdev) {
126 WL_DBG(("supp evt invalid arg\n"));
127 return BCME_OK;
128 }
129
130 wiphy = cfg->wdev->wiphy;
131 prefix_len = snprintf(buf, SUPP_LOG_LEN, "[DHD]<%s> %s: ",
132 wl_get_kernel_timestamp(), __func__);
133 /* Remaining buffer len */
134 rem_len = SUPP_LOG_LEN - (prefix_len + 1);
135 /* Print the arg list on to the remaining part of the buffer */
136 va_start(args, fmt);
137 len = vsnprintf((buf + prefix_len), rem_len, fmt, args);
138 va_end(args);
139 if (len < 0) {
140 return -EINVAL;
141 }
142
143 if (len > rem_len) {
144 /* If return length is greater than buffer len,
145 * then its truncated buffer case.
146 */
147 len = rem_len;
148 }
149
150 /* Ensure the buffer is null terminated */
151 len += prefix_len;
152 buf[len] = '\0';
153 len++;
154
155 return wl_cfgvendor_send_async_event(wiphy,
156 bcmcfg_to_prmry_ndev(cfg), BRCM_VENDOR_EVENT_PRIV_STR, buf, len);
157 }
158
159 int
wl_cfgvendor_notify_supp_event_str(const char * evt_name,const char * fmt,...)160 wl_cfgvendor_notify_supp_event_str(const char *evt_name, const char *fmt, ...)
161 {
162 char buf[SUPP_LOG_LEN] = {0};
163 struct bcm_cfg80211 *cfg;
164 struct wiphy *wiphy;
165 va_list args;
166 int len;
167 int prefix_len;
168 int rem_len;
169
170 cfg = wl_cfg80211_get_bcmcfg();
171 if (!cfg || !cfg->wdev) {
172 WL_DBG(("supp evt invalid arg\n"));
173 return BCME_OK;
174 }
175 wiphy = cfg->wdev->wiphy;
176 prefix_len = snprintf(buf, SUPP_LOG_LEN, "%s ", evt_name);
177 /* Remaining buffer len */
178 rem_len = SUPP_LOG_LEN - (prefix_len + 1);
179 /* Print the arg list on to the remaining part of the buffer */
180 va_start(args, fmt);
181 len = vsnprintf((buf + prefix_len), rem_len, fmt, args);
182 va_end(args);
183 if (len < 0) {
184 return -EINVAL;
185 }
186
187 if (len > rem_len) {
188 /* If return length is greater than buffer len,
189 * then its truncated buffer case.
190 */
191 len = rem_len;
192 }
193
194 /* Ensure the buffer is null terminated */
195 len += prefix_len;
196 buf[len] = '\0';
197 len++;
198
199 return wl_cfgvendor_send_async_event(wiphy,
200 bcmcfg_to_prmry_ndev(cfg), BRCM_VENDOR_EVENT_PRIV_STR, buf, len);
201 }
202 #endif /* WL_SUPP_EVENT */
203
204 /*
205 * This API is to be used for asynchronous vendor events. This
206 * shouldn't be used in response to a vendor command from its
207 * do_it handler context (instead wl_cfgvendor_send_cmd_reply should
208 * be used).
209 */
wl_cfgvendor_send_async_event(struct wiphy * wiphy,struct net_device * dev,int event_id,const void * data,int len)210 int wl_cfgvendor_send_async_event(struct wiphy *wiphy,
211 struct net_device *dev, int event_id, const void *data, int len)
212 {
213 gfp_t kflags;
214 struct sk_buff *skb;
215
216 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
217
218 /* Alloc the SKB for vendor_event */
219 #if (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || \
220 LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0)
221 skb = cfg80211_vendor_event_alloc(wiphy, ndev_to_wdev(dev), len, event_id, kflags);
222 #else
223 skb = cfg80211_vendor_event_alloc(wiphy, len, event_id, kflags);
224 #endif /* (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || */
225 /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0) */
226 if (!skb) {
227 WL_ERR(("skb alloc failed"));
228 return -ENOMEM;
229 }
230
231 /* Push the data to the skb */
232 nla_put_nohdr(skb, len, data);
233
234 cfg80211_vendor_event(skb, kflags);
235
236 return 0;
237 }
238
239 static int
wl_cfgvendor_send_cmd_reply(struct wiphy * wiphy,const void * data,int len)240 wl_cfgvendor_send_cmd_reply(struct wiphy *wiphy,
241 const void *data, int len)
242 {
243 struct sk_buff *skb;
244 int err;
245
246 /* Alloc the SKB for vendor_event */
247 skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, len);
248 if (unlikely(!skb)) {
249 WL_ERR(("skb alloc failed"));
250 err = -ENOMEM;
251 goto exit;
252 }
253
254 /* Push the data to the skb */
255 nla_put_nohdr(skb, len, data);
256 err = cfg80211_vendor_cmd_reply(skb);
257 exit:
258 WL_DBG(("wl_cfgvendor_send_cmd_reply status %d", err));
259 return err;
260 }
261
262 static int
wl_cfgvendor_get_feature_set(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)263 wl_cfgvendor_get_feature_set(struct wiphy *wiphy,
264 struct wireless_dev *wdev, const void *data, int len)
265 {
266 int err = 0;
267 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
268 int reply;
269
270 reply = dhd_dev_get_feature_set(bcmcfg_to_prmry_ndev(cfg));
271
272 err = wl_cfgvendor_send_cmd_reply(wiphy, &reply, sizeof(int));
273 if (unlikely(err))
274 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
275
276 return err;
277 }
278
279 static int
wl_cfgvendor_get_feature_set_matrix(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)280 wl_cfgvendor_get_feature_set_matrix(struct wiphy *wiphy,
281 struct wireless_dev *wdev, const void *data, int len)
282 {
283 int err = 0;
284 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
285 struct sk_buff *skb;
286 int reply;
287 int mem_needed, i;
288
289 mem_needed = VENDOR_REPLY_OVERHEAD +
290 (ATTRIBUTE_U32_LEN * MAX_FEATURE_SET_CONCURRRENT_GROUPS) + ATTRIBUTE_U32_LEN;
291
292 /* Alloc the SKB for vendor_event */
293 skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, mem_needed);
294 if (unlikely(!skb)) {
295 WL_ERR(("skb alloc failed"));
296 err = -ENOMEM;
297 goto exit;
298 }
299
300 err = nla_put_u32(skb, ANDR_WIFI_ATTRIBUTE_NUM_FEATURE_SET,
301 MAX_FEATURE_SET_CONCURRRENT_GROUPS);
302 if (unlikely(err)) {
303 kfree_skb(skb);
304 goto exit;
305 }
306 for (i = 0; i < MAX_FEATURE_SET_CONCURRRENT_GROUPS; i++) {
307 reply = dhd_dev_get_feature_set_matrix(bcmcfg_to_prmry_ndev(cfg), i);
308 if (reply != WIFI_FEATURE_INVALID) {
309 err = nla_put_u32(skb, ANDR_WIFI_ATTRIBUTE_FEATURE_SET,
310 reply);
311 if (unlikely(err)) {
312 kfree_skb(skb);
313 goto exit;
314 }
315 }
316 }
317
318 err = cfg80211_vendor_cmd_reply(skb);
319
320 if (unlikely(err)) {
321 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
322 }
323 exit:
324 return err;
325 }
326
327 static int
wl_cfgvendor_set_pno_rand_mac_oui(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)328 wl_cfgvendor_set_pno_rand_mac_oui(struct wiphy *wiphy,
329 struct wireless_dev *wdev, const void *data, int len)
330 {
331 int err = -EINVAL;
332 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
333 int type;
334
335 if (!data) {
336 WL_ERR(("data is not available\n"));
337 goto exit;
338 }
339
340 if (len <= 0) {
341 WL_ERR(("invalid len %d\n", len));
342 goto exit;
343 }
344
345 type = nla_type(data);
346
347 if (type == ANDR_WIFI_ATTRIBUTE_PNO_RANDOM_MAC_OUI) {
348 if (nla_len(data) != DOT11_OUI_LEN) {
349 WL_ERR(("nla_len not matched.\n"));
350 goto exit;
351 }
352 err = dhd_dev_cfg_rand_mac_oui(bcmcfg_to_prmry_ndev(cfg), nla_data(data));
353
354 if (unlikely(err))
355 WL_ERR(("Bad OUI, could not set:%d \n", err));
356 }
357 exit:
358 return err;
359 }
360 #ifdef CUSTOM_FORCE_NODFS_FLAG
361 static int
wl_cfgvendor_set_nodfs_flag(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)362 wl_cfgvendor_set_nodfs_flag(struct wiphy *wiphy,
363 struct wireless_dev *wdev, const void *data, int len)
364 {
365 int err = -EINVAL;
366 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
367 int type;
368 u32 nodfs;
369
370 if (!data) {
371 WL_ERR(("data is not available\n"));
372 return -EINVAL;
373 }
374
375 if (len <= 0) {
376 WL_ERR(("invalid len %d\n", len));
377 return -EINVAL;
378 }
379
380 type = nla_type(data);
381 if (type == ANDR_WIFI_ATTRIBUTE_NODFS_SET) {
382 nodfs = nla_get_u32(data);
383 err = dhd_dev_set_nodfs(bcmcfg_to_prmry_ndev(cfg), nodfs);
384 }
385
386 return err;
387 }
388 #endif /* CUSTOM_FORCE_NODFS_FLAG */
389
390 static int
wl_cfgvendor_set_country(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)391 wl_cfgvendor_set_country(struct wiphy *wiphy,
392 struct wireless_dev *wdev, const void *data, int len)
393 {
394 int err = BCME_ERROR, rem, type;
395 char country_code[WLC_CNTRY_BUF_SZ] = {0};
396 const struct nlattr *iter;
397 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
398 struct net_device *primary_ndev = bcmcfg_to_prmry_ndev(cfg);
399
400 nla_for_each_attr(iter, data, len, rem) {
401 type = nla_type(iter);
402 switch (type) {
403 case ANDR_WIFI_ATTRIBUTE_COUNTRY:
404 err = memcpy_s(country_code, WLC_CNTRY_BUF_SZ,
405 nla_data(iter), nla_len(iter));
406 if (err) {
407 WL_ERR(("Failed to copy country code: %d\n", err));
408 return err;
409 }
410 break;
411 default:
412 WL_ERR(("Unknown type: %d\n", type));
413 return err;
414 }
415 }
416 /* country code is unique for dongle..hence using primary interface. */
417 err = wl_cfg80211_set_country_code(primary_ndev, country_code, true, true, -1);
418 if (err < 0) {
419 WL_ERR(("Set country failed ret:%d\n", err));
420 }
421
422 return err;
423 }
424
425 #ifdef GSCAN_SUPPORT
426 int
wl_cfgvendor_send_hotlist_event(struct wiphy * wiphy,struct net_device * dev,void * data,int len,wl_vendor_event_t event)427 wl_cfgvendor_send_hotlist_event(struct wiphy *wiphy,
428 struct net_device *dev, void *data, int len, wl_vendor_event_t event)
429 {
430 gfp_t kflags;
431 const void *ptr;
432 struct sk_buff *skb;
433 int malloc_len, total, iter_cnt_to_send, cnt;
434 gscan_results_cache_t *cache = (gscan_results_cache_t *)data;
435
436 total = len/sizeof(wifi_gscan_result_t);
437 while (total > 0) {
438 malloc_len = (total * sizeof(wifi_gscan_result_t)) + VENDOR_DATA_OVERHEAD;
439 if (malloc_len > NLMSG_DEFAULT_SIZE) {
440 malloc_len = NLMSG_DEFAULT_SIZE;
441 }
442 iter_cnt_to_send =
443 (malloc_len - VENDOR_DATA_OVERHEAD)/sizeof(wifi_gscan_result_t);
444 total = total - iter_cnt_to_send;
445
446 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
447
448 /* Alloc the SKB for vendor_event */
449 #if (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || \
450 LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0)
451 skb = cfg80211_vendor_event_alloc(wiphy, ndev_to_wdev(dev),
452 malloc_len, event, kflags);
453 #else
454 skb = cfg80211_vendor_event_alloc(wiphy, malloc_len, event, kflags);
455 #endif /* (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || */
456 /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0) */
457 if (!skb) {
458 WL_ERR(("skb alloc failed"));
459 return -ENOMEM;
460 }
461
462 while (cache && iter_cnt_to_send) {
463 ptr = (const void *) &cache->results[cache->tot_consumed];
464
465 if (iter_cnt_to_send < (cache->tot_count - cache->tot_consumed)) {
466 cnt = iter_cnt_to_send;
467 } else {
468 cnt = (cache->tot_count - cache->tot_consumed);
469 }
470
471 iter_cnt_to_send -= cnt;
472 cache->tot_consumed += cnt;
473 /* Push the data to the skb */
474 nla_append(skb, cnt * sizeof(wifi_gscan_result_t), ptr);
475 if (cache->tot_consumed == cache->tot_count) {
476 cache = cache->next;
477 }
478
479 }
480
481 cfg80211_vendor_event(skb, kflags);
482 }
483
484 return 0;
485 }
486
487 static int
wl_cfgvendor_gscan_get_capabilities(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)488 wl_cfgvendor_gscan_get_capabilities(struct wiphy *wiphy,
489 struct wireless_dev *wdev, const void *data, int len)
490 {
491 int err = 0;
492 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
493 dhd_pno_gscan_capabilities_t *reply = NULL;
494 uint32 reply_len = 0;
495
496 reply = dhd_dev_pno_get_gscan(bcmcfg_to_prmry_ndev(cfg),
497 DHD_PNO_GET_CAPABILITIES, NULL, &reply_len);
498 if (!reply) {
499 WL_ERR(("Could not get capabilities\n"));
500 err = -EINVAL;
501 return err;
502 }
503
504 err = wl_cfgvendor_send_cmd_reply(wiphy, reply, reply_len);
505 if (unlikely(err)) {
506 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
507 }
508
509 MFREE(cfg->osh, reply, reply_len);
510 return err;
511 }
512
513 static int
wl_cfgvendor_gscan_get_batch_results(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)514 wl_cfgvendor_gscan_get_batch_results(struct wiphy *wiphy,
515 struct wireless_dev *wdev, const void *data, int len)
516 {
517 int err = 0;
518 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
519 gscan_results_cache_t *results, *iter;
520 uint32 reply_len, is_done = 1;
521 int32 mem_needed, num_results_iter;
522 wifi_gscan_result_t *ptr;
523 uint16 num_scan_ids, num_results;
524 struct sk_buff *skb;
525 struct nlattr *scan_hdr, *complete_flag;
526
527 err = dhd_dev_wait_batch_results_complete(bcmcfg_to_prmry_ndev(cfg));
528 if (err != BCME_OK)
529 return -EBUSY;
530
531 err = dhd_dev_pno_lock_access_batch_results(bcmcfg_to_prmry_ndev(cfg));
532 if (err != BCME_OK) {
533 WL_ERR(("Can't obtain lock to access batch results %d\n", err));
534 return -EBUSY;
535 }
536 results = dhd_dev_pno_get_gscan(bcmcfg_to_prmry_ndev(cfg),
537 DHD_PNO_GET_BATCH_RESULTS, NULL, &reply_len);
538
539 if (!results) {
540 WL_ERR(("No results to send %d\n", err));
541 err = wl_cfgvendor_send_cmd_reply(wiphy, results, 0);
542
543 if (unlikely(err))
544 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
545 dhd_dev_pno_unlock_access_batch_results(bcmcfg_to_prmry_ndev(cfg));
546 return err;
547 }
548 num_scan_ids = reply_len & 0xFFFF;
549 num_results = (reply_len & 0xFFFF0000) >> 16;
550 mem_needed = (num_results * sizeof(wifi_gscan_result_t)) +
551 (num_scan_ids * GSCAN_BATCH_RESULT_HDR_LEN) +
552 VENDOR_REPLY_OVERHEAD + SCAN_RESULTS_COMPLETE_FLAG_LEN;
553
554 if (mem_needed > (int32)NLMSG_DEFAULT_SIZE) {
555 mem_needed = (int32)NLMSG_DEFAULT_SIZE;
556 }
557
558 WL_TRACE(("is_done %d mem_needed %d max_mem %d\n", is_done, mem_needed,
559 (int)NLMSG_DEFAULT_SIZE));
560 /* Alloc the SKB for vendor_event */
561 skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, mem_needed);
562 if (unlikely(!skb)) {
563 WL_ERR(("skb alloc failed"));
564 dhd_dev_pno_unlock_access_batch_results(bcmcfg_to_prmry_ndev(cfg));
565 return -ENOMEM;
566 }
567 iter = results;
568 complete_flag = nla_reserve(skb, GSCAN_ATTRIBUTE_SCAN_RESULTS_COMPLETE,
569 sizeof(is_done));
570
571 if (unlikely(!complete_flag)) {
572 WL_ERR(("complete_flag could not be reserved"));
573 kfree_skb(skb);
574 dhd_dev_pno_unlock_access_batch_results(bcmcfg_to_prmry_ndev(cfg));
575 return -ENOMEM;
576 }
577 mem_needed = mem_needed - (SCAN_RESULTS_COMPLETE_FLAG_LEN + VENDOR_REPLY_OVERHEAD);
578
579 while (iter) {
580 num_results_iter = (mem_needed - (int32)GSCAN_BATCH_RESULT_HDR_LEN);
581 num_results_iter /= (int32)sizeof(wifi_gscan_result_t);
582 if (num_results_iter <= 0 ||
583 ((iter->tot_count - iter->tot_consumed) > num_results_iter)) {
584 break;
585 }
586 scan_hdr = nla_nest_start(skb, GSCAN_ATTRIBUTE_SCAN_RESULTS);
587 /* no more room? we are done then (for now) */
588 if (scan_hdr == NULL) {
589 is_done = 0;
590 break;
591 }
592 err = nla_put_u32(skb, GSCAN_ATTRIBUTE_SCAN_ID, iter->scan_id);
593 if (unlikely(err)) {
594 goto fail;
595 }
596 err = nla_put_u8(skb, GSCAN_ATTRIBUTE_SCAN_FLAGS, iter->flag);
597 if (unlikely(err)) {
598 goto fail;
599 }
600 err = nla_put_u32(skb, GSCAN_ATTRIBUTE_CH_BUCKET_BITMASK, iter->scan_ch_bucket);
601 if (unlikely(err)) {
602 goto fail;
603 }
604 num_results_iter = iter->tot_count - iter->tot_consumed;
605
606 err = nla_put_u32(skb, GSCAN_ATTRIBUTE_NUM_OF_RESULTS, num_results_iter);
607 if (unlikely(err)) {
608 goto fail;
609 }
610 if (num_results_iter) {
611 ptr = &iter->results[iter->tot_consumed];
612 err = nla_put(skb, GSCAN_ATTRIBUTE_SCAN_RESULTS,
613 num_results_iter * sizeof(wifi_gscan_result_t), ptr);
614 if (unlikely(err)) {
615 goto fail;
616 }
617 iter->tot_consumed += num_results_iter;
618 }
619 nla_nest_end(skb, scan_hdr);
620 mem_needed -= GSCAN_BATCH_RESULT_HDR_LEN +
621 (num_results_iter * sizeof(wifi_gscan_result_t));
622 iter = iter->next;
623 }
624 /* Cleans up consumed results and returns TRUE if all results are consumed */
625 is_done = dhd_dev_gscan_batch_cache_cleanup(bcmcfg_to_prmry_ndev(cfg));
626 memcpy(nla_data(complete_flag), &is_done, sizeof(is_done));
627 dhd_dev_pno_unlock_access_batch_results(bcmcfg_to_prmry_ndev(cfg));
628 return cfg80211_vendor_cmd_reply(skb);
629 fail:
630 /* Free up consumed results which will now not be sent */
631 (void)dhd_dev_gscan_batch_cache_cleanup(bcmcfg_to_prmry_ndev(cfg));
632 kfree_skb(skb);
633 dhd_dev_pno_unlock_access_batch_results(bcmcfg_to_prmry_ndev(cfg));
634 return err;
635 }
636
637 static int
wl_cfgvendor_initiate_gscan(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)638 wl_cfgvendor_initiate_gscan(struct wiphy *wiphy,
639 struct wireless_dev *wdev, const void *data, int len)
640 {
641 int err = 0;
642 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
643 int type, tmp = len;
644 int run = 0xFF;
645 int flush = 0;
646 const struct nlattr *iter;
647
648 nla_for_each_attr(iter, data, len, tmp) {
649 type = nla_type(iter);
650 if (type == GSCAN_ATTRIBUTE_ENABLE_FEATURE)
651 run = nla_get_u32(iter);
652 else if (type == GSCAN_ATTRIBUTE_FLUSH_FEATURE)
653 flush = nla_get_u32(iter);
654 }
655
656 if (run != 0xFF) {
657 err = dhd_dev_pno_run_gscan(bcmcfg_to_prmry_ndev(cfg), run, flush);
658
659 if (unlikely(err)) {
660 WL_ERR(("Could not run gscan:%d \n", err));
661 }
662 return err;
663 } else {
664 return -EINVAL;
665 }
666
667 }
668
669 static int
wl_cfgvendor_enable_full_scan_result(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)670 wl_cfgvendor_enable_full_scan_result(struct wiphy *wiphy,
671 struct wireless_dev *wdev, const void *data, int len)
672 {
673 int err = 0;
674 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
675 int type;
676 bool real_time = FALSE;
677
678 if (!data) {
679 WL_ERR(("data is not available\n"));
680 return -EINVAL;
681 }
682
683 if (len <= 0) {
684 WL_ERR(("invalid len %d\n", len));
685 return -EINVAL;
686 }
687
688 type = nla_type(data);
689
690 if (type == GSCAN_ATTRIBUTE_ENABLE_FULL_SCAN_RESULTS) {
691 real_time = nla_get_u32(data);
692
693 err = dhd_dev_pno_enable_full_scan_result(bcmcfg_to_prmry_ndev(cfg), real_time);
694
695 if (unlikely(err)) {
696 WL_ERR(("Could not run gscan:%d \n", err));
697 }
698
699 } else {
700 err = -EINVAL;
701 }
702
703 return err;
704 }
705
706 static int
wl_cfgvendor_set_scan_cfg_bucket(const struct nlattr * prev,gscan_scan_params_t * scan_param,int num)707 wl_cfgvendor_set_scan_cfg_bucket(const struct nlattr *prev,
708 gscan_scan_params_t *scan_param, int num)
709 {
710 struct dhd_pno_gscan_channel_bucket *ch_bucket;
711 int k = 0;
712 int type, err = 0, rem;
713 const struct nlattr *cur, *next;
714
715 nla_for_each_nested(cur, prev, rem) {
716 type = nla_type(cur);
717 ch_bucket = scan_param->channel_bucket;
718 switch (type) {
719 case GSCAN_ATTRIBUTE_BUCKET_ID:
720 break;
721 case GSCAN_ATTRIBUTE_BUCKET_PERIOD:
722 if (nla_len(cur) != sizeof(uint32)) {
723 err = -EINVAL;
724 goto exit;
725 }
726
727 ch_bucket[num].bucket_freq_multiple =
728 nla_get_u32(cur) / MSEC_PER_SEC;
729 break;
730 case GSCAN_ATTRIBUTE_BUCKET_NUM_CHANNELS:
731 if (nla_len(cur) != sizeof(uint32)) {
732 err = -EINVAL;
733 goto exit;
734 }
735 ch_bucket[num].num_channels = nla_get_u32(cur);
736 if (ch_bucket[num].num_channels >
737 GSCAN_MAX_CHANNELS_IN_BUCKET) {
738 WL_ERR(("channel range:%d,bucket:%d\n",
739 ch_bucket[num].num_channels,
740 num));
741 err = -EINVAL;
742 goto exit;
743 }
744 break;
745 case GSCAN_ATTRIBUTE_BUCKET_CHANNELS:
746 nla_for_each_nested(next, cur, rem) {
747 if (k >= GSCAN_MAX_CHANNELS_IN_BUCKET)
748 break;
749 if (nla_len(next) != sizeof(uint32)) {
750 err = -EINVAL;
751 goto exit;
752 }
753 ch_bucket[num].chan_list[k] = nla_get_u32(next);
754 k++;
755 }
756 break;
757 case GSCAN_ATTRIBUTE_BUCKETS_BAND:
758 if (nla_len(cur) != sizeof(uint32)) {
759 err = -EINVAL;
760 goto exit;
761 }
762 ch_bucket[num].band = (uint16)nla_get_u32(cur);
763 break;
764 case GSCAN_ATTRIBUTE_REPORT_EVENTS:
765 if (nla_len(cur) != sizeof(uint32)) {
766 err = -EINVAL;
767 goto exit;
768 }
769 ch_bucket[num].report_flag = (uint8)nla_get_u32(cur);
770 break;
771 case GSCAN_ATTRIBUTE_BUCKET_STEP_COUNT:
772 if (nla_len(cur) != sizeof(uint32)) {
773 err = -EINVAL;
774 goto exit;
775 }
776 ch_bucket[num].repeat = (uint16)nla_get_u32(cur);
777 break;
778 case GSCAN_ATTRIBUTE_BUCKET_MAX_PERIOD:
779 if (nla_len(cur) != sizeof(uint32)) {
780 err = -EINVAL;
781 goto exit;
782 }
783 ch_bucket[num].bucket_max_multiple =
784 nla_get_u32(cur) / MSEC_PER_SEC;
785 break;
786 default:
787 WL_ERR(("unknown attr type:%d\n", type));
788 err = -EINVAL;
789 goto exit;
790 }
791 }
792
793 exit:
794 return err;
795 }
796
797 static int
wl_cfgvendor_set_scan_cfg(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)798 wl_cfgvendor_set_scan_cfg(struct wiphy *wiphy, struct wireless_dev *wdev,
799 const void *data, int len)
800 {
801 int err = 0;
802 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
803 gscan_scan_params_t *scan_param;
804 int j = 0;
805 int type, tmp;
806 const struct nlattr *iter;
807
808 scan_param = (gscan_scan_params_t *)MALLOCZ(cfg->osh,
809 sizeof(gscan_scan_params_t));
810 if (!scan_param) {
811 WL_ERR(("Could not set GSCAN scan cfg, mem alloc failure\n"));
812 err = -EINVAL;
813 return err;
814
815 }
816
817 scan_param->scan_fr = PNO_SCAN_MIN_FW_SEC;
818 nla_for_each_attr(iter, data, len, tmp) {
819 type = nla_type(iter);
820
821 if (j >= GSCAN_MAX_CH_BUCKETS) {
822 break;
823 }
824
825 switch (type) {
826 case GSCAN_ATTRIBUTE_BASE_PERIOD:
827 if (nla_len(iter) != sizeof(uint32)) {
828 err = -EINVAL;
829 goto exit;
830 }
831 scan_param->scan_fr = nla_get_u32(iter) / MSEC_PER_SEC;
832 break;
833 case GSCAN_ATTRIBUTE_NUM_BUCKETS:
834 if (nla_len(iter) != sizeof(uint32)) {
835 err = -EINVAL;
836 goto exit;
837 }
838 scan_param->nchannel_buckets = nla_get_u32(iter);
839 if (scan_param->nchannel_buckets >=
840 GSCAN_MAX_CH_BUCKETS) {
841 WL_ERR(("ncha_buck out of range %d\n",
842 scan_param->nchannel_buckets));
843 err = -EINVAL;
844 goto exit;
845 }
846 break;
847 case GSCAN_ATTRIBUTE_CH_BUCKET_1:
848 case GSCAN_ATTRIBUTE_CH_BUCKET_2:
849 case GSCAN_ATTRIBUTE_CH_BUCKET_3:
850 case GSCAN_ATTRIBUTE_CH_BUCKET_4:
851 case GSCAN_ATTRIBUTE_CH_BUCKET_5:
852 case GSCAN_ATTRIBUTE_CH_BUCKET_6:
853 case GSCAN_ATTRIBUTE_CH_BUCKET_7:
854 err = wl_cfgvendor_set_scan_cfg_bucket(iter, scan_param, j);
855 if (err < 0) {
856 WL_ERR(("set_scan_cfg_buck error:%d\n", err));
857 goto exit;
858 }
859 j++;
860 break;
861 default:
862 WL_ERR(("Unknown type %d\n", type));
863 err = -EINVAL;
864 goto exit;
865 }
866 }
867
868 err = dhd_dev_pno_set_cfg_gscan(bcmcfg_to_prmry_ndev(cfg),
869 DHD_PNO_SCAN_CFG_ID, scan_param, FALSE);
870
871 if (err < 0) {
872 WL_ERR(("Could not set GSCAN scan cfg\n"));
873 err = -EINVAL;
874 }
875
876 exit:
877 MFREE(cfg->osh, scan_param, sizeof(gscan_scan_params_t));
878 return err;
879
880 }
881
882 static int
wl_cfgvendor_hotlist_cfg(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)883 wl_cfgvendor_hotlist_cfg(struct wiphy *wiphy,
884 struct wireless_dev *wdev, const void *data, int len)
885 {
886 int err = 0;
887 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
888 gscan_hotlist_scan_params_t *hotlist_params;
889 int tmp, tmp1, tmp2, type, j = 0, dummy;
890 const struct nlattr *outer, *inner = NULL, *iter;
891 bool flush = FALSE;
892 struct bssid_t *pbssid;
893
894 BCM_REFERENCE(dummy);
895
896 if (len < sizeof(*hotlist_params) || len >= WLC_IOCTL_MAXLEN) {
897 WL_ERR(("buffer length :%d wrong - bail out.\n", len));
898 return -EINVAL;
899 }
900
901 hotlist_params = (gscan_hotlist_scan_params_t *)MALLOCZ(cfg->osh,
902 sizeof(*hotlist_params)
903 + (sizeof(struct bssid_t) * (PFN_SWC_MAX_NUM_APS - 1)));
904
905 if (!hotlist_params) {
906 WL_ERR(("Cannot Malloc memory.\n"));
907 return -ENOMEM;
908 }
909
910 hotlist_params->lost_ap_window = GSCAN_LOST_AP_WINDOW_DEFAULT;
911
912 nla_for_each_attr(iter, data, len, tmp2) {
913 type = nla_type(iter);
914 switch (type) {
915 case GSCAN_ATTRIBUTE_HOTLIST_BSSID_COUNT:
916 if (nla_len(iter) != sizeof(uint32)) {
917 WL_DBG(("type:%d length:%d not matching.\n",
918 type, nla_len(iter)));
919 err = -EINVAL;
920 goto exit;
921 }
922 hotlist_params->nbssid = (uint16)nla_get_u32(iter);
923 if ((hotlist_params->nbssid == 0) ||
924 (hotlist_params->nbssid > PFN_SWC_MAX_NUM_APS)) {
925 WL_ERR(("nbssid:%d exceed limit.\n",
926 hotlist_params->nbssid));
927 err = -EINVAL;
928 goto exit;
929 }
930 break;
931 case GSCAN_ATTRIBUTE_HOTLIST_BSSIDS:
932 if (hotlist_params->nbssid == 0) {
933 WL_ERR(("nbssid not retrieved.\n"));
934 err = -EINVAL;
935 goto exit;
936 }
937 pbssid = hotlist_params->bssid;
938 nla_for_each_nested(outer, iter, tmp) {
939 if (j >= hotlist_params->nbssid)
940 break;
941 nla_for_each_nested(inner, outer, tmp1) {
942 type = nla_type(inner);
943
944 switch (type) {
945 case GSCAN_ATTRIBUTE_BSSID:
946 if (nla_len(inner) != sizeof(pbssid[j].macaddr)) {
947 WL_ERR(("type:%d length:%d not matching.\n",
948 type, nla_len(inner)));
949 err = -EINVAL;
950 goto exit;
951 }
952 memcpy(
953 &(pbssid[j].macaddr),
954 nla_data(inner),
955 sizeof(pbssid[j].macaddr));
956 break;
957 case GSCAN_ATTRIBUTE_RSSI_LOW:
958 if (nla_len(inner) != sizeof(uint8)) {
959 WL_ERR(("type:%d length:%d not matching.\n",
960 type, nla_len(inner)));
961 err = -EINVAL;
962 goto exit;
963 }
964 pbssid[j].rssi_reporting_threshold =
965 (int8)nla_get_u8(inner);
966 break;
967 case GSCAN_ATTRIBUTE_RSSI_HIGH:
968 if (nla_len(inner) != sizeof(uint8)) {
969 WL_ERR(("type:%d length:%d not matching.\n",
970 type, nla_len(inner)));
971 err = -EINVAL;
972 goto exit;
973 }
974 dummy = (int8)nla_get_u8(inner);
975 WL_DBG(("dummy %d\n", dummy));
976 break;
977 default:
978 WL_ERR(("ATTR unknown %d\n", type));
979 err = -EINVAL;
980 goto exit;
981 }
982 }
983 j++;
984 }
985 if (j != hotlist_params->nbssid) {
986 WL_ERR(("bssid_cnt:%d != nbssid:%d.\n", j,
987 hotlist_params->nbssid));
988 err = -EINVAL;
989 goto exit;
990 }
991 break;
992 case GSCAN_ATTRIBUTE_HOTLIST_FLUSH:
993 if (nla_len(iter) != sizeof(uint8)) {
994 WL_ERR(("type:%d length:%d not matching.\n",
995 type, nla_len(iter)));
996 err = -EINVAL;
997 goto exit;
998 }
999 flush = nla_get_u8(iter);
1000 break;
1001 case GSCAN_ATTRIBUTE_LOST_AP_SAMPLE_SIZE:
1002 if (nla_len(iter) != sizeof(uint32)) {
1003 WL_ERR(("type:%d length:%d not matching.\n",
1004 type, nla_len(iter)));
1005 err = -EINVAL;
1006 goto exit;
1007 }
1008 hotlist_params->lost_ap_window = (uint16)nla_get_u32(iter);
1009 break;
1010 default:
1011 WL_ERR(("Unknown type %d\n", type));
1012 err = -EINVAL;
1013 goto exit;
1014 }
1015
1016 }
1017
1018 if (dhd_dev_pno_set_cfg_gscan(bcmcfg_to_prmry_ndev(cfg),
1019 DHD_PNO_GEOFENCE_SCAN_CFG_ID, hotlist_params, flush) < 0) {
1020 WL_ERR(("Could not set GSCAN HOTLIST cfg error: %d\n", err));
1021 err = -EINVAL;
1022 goto exit;
1023 }
1024 exit:
1025 MFREE(cfg->osh, hotlist_params, sizeof(*hotlist_params)
1026 + (sizeof(struct bssid_t) * (PFN_SWC_MAX_NUM_APS - 1)));
1027 return err;
1028 }
1029
wl_cfgvendor_epno_cfg(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)1030 static int wl_cfgvendor_epno_cfg(struct wiphy *wiphy,
1031 struct wireless_dev *wdev, const void *data, int len)
1032 {
1033 int err = 0;
1034 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
1035 dhd_pno_ssid_t *ssid_elem = NULL;
1036 int tmp, tmp1, tmp2, type = 0, num = 0;
1037 const struct nlattr *outer, *inner, *iter;
1038 uint8 flush = FALSE, i = 0;
1039 wl_ssid_ext_params_t params;
1040
1041 nla_for_each_attr(iter, data, len, tmp2) {
1042 type = nla_type(iter);
1043 switch (type) {
1044 case GSCAN_ATTRIBUTE_EPNO_SSID_LIST:
1045 nla_for_each_nested(outer, iter, tmp) {
1046 ssid_elem = (dhd_pno_ssid_t *)
1047 dhd_dev_pno_get_gscan(bcmcfg_to_prmry_ndev(cfg),
1048 DHD_PNO_GET_NEW_EPNO_SSID_ELEM,
1049 NULL, &num);
1050 if (!ssid_elem) {
1051 WL_ERR(("Failed to get SSID LIST buffer\n"));
1052 err = -ENOMEM;
1053 goto exit;
1054 }
1055 i++;
1056 nla_for_each_nested(inner, outer, tmp1) {
1057 type = nla_type(inner);
1058
1059 switch (type) {
1060 case GSCAN_ATTRIBUTE_EPNO_SSID:
1061 memcpy(ssid_elem->SSID,
1062 nla_data(inner),
1063 DOT11_MAX_SSID_LEN);
1064 break;
1065 case GSCAN_ATTRIBUTE_EPNO_SSID_LEN:
1066 ssid_elem->SSID_len =
1067 nla_get_u32(inner);
1068 if (ssid_elem->SSID_len >
1069 DOT11_MAX_SSID_LEN) {
1070 WL_ERR(("SSID too"
1071 "long %d\n",
1072 ssid_elem->SSID_len));
1073 err = -EINVAL;
1074 MFREE(cfg->osh, ssid_elem,
1075 num);
1076 goto exit;
1077 }
1078 break;
1079 case GSCAN_ATTRIBUTE_EPNO_FLAGS:
1080 ssid_elem->flags =
1081 nla_get_u32(inner);
1082 ssid_elem->hidden =
1083 ((ssid_elem->flags &
1084 DHD_EPNO_HIDDEN_SSID) != 0);
1085 break;
1086 case GSCAN_ATTRIBUTE_EPNO_AUTH:
1087 ssid_elem->wpa_auth =
1088 nla_get_u32(inner);
1089 break;
1090 }
1091 }
1092 if (!ssid_elem->SSID_len) {
1093 WL_ERR(("Broadcast SSID is illegal for ePNO\n"));
1094 err = -EINVAL;
1095 MFREE(cfg->osh, ssid_elem, num);
1096 goto exit;
1097 }
1098 dhd_pno_translate_epno_fw_flags(&ssid_elem->flags);
1099 dhd_pno_set_epno_auth_flag(&ssid_elem->wpa_auth);
1100 MFREE(cfg->osh, ssid_elem, num);
1101 }
1102 break;
1103 case GSCAN_ATTRIBUTE_EPNO_SSID_NUM:
1104 num = nla_get_u8(iter);
1105 break;
1106 case GSCAN_ATTRIBUTE_EPNO_FLUSH:
1107 flush = (bool)nla_get_u32(iter);
1108 /* Flush attribute is expected before any ssid attribute */
1109 if (i && flush) {
1110 WL_ERR(("Bad attributes\n"));
1111 err = -EINVAL;
1112 goto exit;
1113 }
1114 /* Need to flush driver and FW cfg */
1115 dhd_dev_pno_set_cfg_gscan(bcmcfg_to_prmry_ndev(cfg),
1116 DHD_PNO_EPNO_CFG_ID, NULL, flush);
1117 dhd_dev_flush_fw_epno(bcmcfg_to_prmry_ndev(cfg));
1118 break;
1119 case GSCAN_ATTRIBUTE_EPNO_5G_RSSI_THR:
1120 params.min5G_rssi = nla_get_s8(iter);
1121 break;
1122 case GSCAN_ATTRIBUTE_EPNO_2G_RSSI_THR:
1123 params.min2G_rssi = nla_get_s8(iter);
1124 break;
1125 case GSCAN_ATTRIBUTE_EPNO_INIT_SCORE_MAX:
1126 params.init_score_max = nla_get_s16(iter);
1127 break;
1128 case GSCAN_ATTRIBUTE_EPNO_CUR_CONN_BONUS:
1129 params.cur_bssid_bonus = nla_get_s16(iter);
1130 break;
1131 case GSCAN_ATTRIBUTE_EPNO_SAME_NETWORK_BONUS:
1132 params.same_ssid_bonus = nla_get_s16(iter);
1133 break;
1134 case GSCAN_ATTRIBUTE_EPNO_SECURE_BONUS:
1135 params.secure_bonus = nla_get_s16(iter);
1136 break;
1137 case GSCAN_ATTRIBUTE_EPNO_5G_BONUS:
1138 params.band_5g_bonus = nla_get_s16(iter);
1139 break;
1140 default:
1141 WL_ERR(("%s: No such attribute %d\n", __FUNCTION__, type));
1142 err = -EINVAL;
1143 goto exit;
1144 }
1145 }
1146 if (i != num) {
1147 WL_ERR(("%s: num_ssid %d does not match ssids sent %d\n", __FUNCTION__,
1148 num, i));
1149 err = -EINVAL;
1150 }
1151 exit:
1152 /* Flush all configs if error condition */
1153 if (err < 0) {
1154 dhd_dev_pno_set_cfg_gscan(bcmcfg_to_prmry_ndev(cfg),
1155 DHD_PNO_EPNO_CFG_ID, NULL, TRUE);
1156 dhd_dev_flush_fw_epno(bcmcfg_to_prmry_ndev(cfg));
1157 } else if (type != GSCAN_ATTRIBUTE_EPNO_FLUSH) {
1158 /* If the last attribute was FLUSH, nothing else to do */
1159 dhd_dev_pno_set_cfg_gscan(bcmcfg_to_prmry_ndev(cfg),
1160 DHD_PNO_EPNO_PARAMS_ID, ¶ms, FALSE);
1161 err = dhd_dev_set_epno(bcmcfg_to_prmry_ndev(cfg));
1162 }
1163 return err;
1164 }
1165
1166 static int
wl_cfgvendor_set_batch_scan_cfg(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)1167 wl_cfgvendor_set_batch_scan_cfg(struct wiphy *wiphy,
1168 struct wireless_dev *wdev, const void *data, int len)
1169 {
1170 int err = 0, tmp, type;
1171 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
1172 gscan_batch_params_t batch_param;
1173 const struct nlattr *iter;
1174
1175 batch_param.mscan = batch_param.bestn = 0;
1176 batch_param.buffer_threshold = GSCAN_BATCH_NO_THR_SET;
1177
1178 nla_for_each_attr(iter, data, len, tmp) {
1179 type = nla_type(iter);
1180
1181 switch (type) {
1182 case GSCAN_ATTRIBUTE_NUM_AP_PER_SCAN:
1183 batch_param.bestn = nla_get_u32(iter);
1184 break;
1185 case GSCAN_ATTRIBUTE_NUM_SCANS_TO_CACHE:
1186 batch_param.mscan = nla_get_u32(iter);
1187 break;
1188 case GSCAN_ATTRIBUTE_REPORT_THRESHOLD:
1189 batch_param.buffer_threshold = nla_get_u32(iter);
1190 break;
1191 default:
1192 WL_ERR(("Unknown type %d\n", type));
1193 break;
1194 }
1195 }
1196
1197 if (dhd_dev_pno_set_cfg_gscan(bcmcfg_to_prmry_ndev(cfg),
1198 DHD_PNO_BATCH_SCAN_CFG_ID, &batch_param, FALSE) < 0) {
1199 WL_ERR(("Could not set batch cfg\n"));
1200 err = -EINVAL;
1201 return err;
1202 }
1203
1204 return err;
1205 }
1206
1207 #endif /* GSCAN_SUPPORT */
1208 #if defined(GSCAN_SUPPORT) || defined(DHD_GET_VALID_CHANNELS)
1209 static int
wl_cfgvendor_gscan_get_channel_list(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)1210 wl_cfgvendor_gscan_get_channel_list(struct wiphy *wiphy,
1211 struct wireless_dev *wdev, const void *data, int len)
1212 {
1213 int err = 0, type, band;
1214 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
1215 uint16 *reply = NULL;
1216 uint32 reply_len = 0, num_channels, mem_needed;
1217 struct sk_buff *skb;
1218 dhd_pub_t *dhdp;
1219 struct net_device *ndev = wdev->netdev;
1220
1221 if (!ndev) {
1222 WL_ERR(("ndev null\n"));
1223 return -EINVAL;
1224 }
1225
1226 dhdp = wl_cfg80211_get_dhdp(ndev);
1227 if (!dhdp) {
1228 WL_ERR(("dhdp null\n"));
1229 return -EINVAL;
1230 }
1231
1232 if (!data) {
1233 WL_ERR(("data is not available\n"));
1234 return -EINVAL;
1235 }
1236
1237 if (len <= 0) {
1238 WL_ERR(("invalid len %d\n", len));
1239 return -EINVAL;
1240 }
1241
1242 type = nla_type(data);
1243 if (type == GSCAN_ATTRIBUTE_BAND) {
1244 band = nla_get_u32(data);
1245 } else {
1246 return -EINVAL;
1247 }
1248
1249 reply = dhd_pno_get_gscan(dhdp,
1250 DHD_PNO_GET_CHANNEL_LIST, &band, &reply_len);
1251 if (!reply) {
1252 WL_ERR(("Could not get channel list\n"));
1253 err = -EINVAL;
1254 return err;
1255 }
1256 num_channels = reply_len/ sizeof(uint32);
1257 mem_needed = reply_len + VENDOR_REPLY_OVERHEAD + (ATTRIBUTE_U32_LEN * 2);
1258
1259 /* Alloc the SKB for vendor_event */
1260 skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, mem_needed);
1261 if (unlikely(!skb)) {
1262 WL_ERR(("skb alloc failed"));
1263 err = -ENOMEM;
1264 goto exit;
1265 }
1266
1267 nla_put_u32(skb, GSCAN_ATTRIBUTE_NUM_CHANNELS, num_channels);
1268 nla_put(skb, GSCAN_ATTRIBUTE_CHANNEL_LIST, reply_len, reply);
1269
1270 err = cfg80211_vendor_cmd_reply(skb);
1271
1272 if (unlikely(err)) {
1273 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
1274 }
1275 exit:
1276 MFREE(cfg->osh, reply, reply_len);
1277 return err;
1278 }
1279 #endif /* GSCAN_SUPPORT || DHD_GET_VALID_CHANNELS */
1280
1281 #ifdef RSSI_MONITOR_SUPPORT
wl_cfgvendor_set_rssi_monitor(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)1282 static int wl_cfgvendor_set_rssi_monitor(struct wiphy *wiphy,
1283 struct wireless_dev *wdev, const void *data, int len)
1284 {
1285 int err = 0, tmp, type, start = 0;
1286 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
1287 int8 max_rssi = 0, min_rssi = 0;
1288 const struct nlattr *iter;
1289
1290 nla_for_each_attr(iter, data, len, tmp) {
1291 type = nla_type(iter);
1292 switch (type) {
1293 case RSSI_MONITOR_ATTRIBUTE_MAX_RSSI:
1294 max_rssi = (int8) nla_get_u32(iter);
1295 break;
1296 case RSSI_MONITOR_ATTRIBUTE_MIN_RSSI:
1297 min_rssi = (int8) nla_get_u32(iter);
1298 break;
1299 case RSSI_MONITOR_ATTRIBUTE_START:
1300 start = nla_get_u32(iter);
1301 }
1302 }
1303
1304 if (dhd_dev_set_rssi_monitor_cfg(bcmcfg_to_prmry_ndev(cfg),
1305 start, max_rssi, min_rssi) < 0) {
1306 WL_ERR(("Could not set rssi monitor cfg\n"));
1307 err = -EINVAL;
1308 }
1309 return err;
1310 }
1311 #endif /* RSSI_MONITOR_SUPPORT */
1312
1313 #ifdef DHD_WAKE_STATUS
1314 static int
wl_cfgvendor_get_wake_reason_stats(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)1315 wl_cfgvendor_get_wake_reason_stats(struct wiphy *wiphy,
1316 struct wireless_dev *wdev, const void *data, int len)
1317 {
1318 struct net_device *ndev = wdev_to_ndev(wdev);
1319 wake_counts_t *pwake_count_info;
1320 int ret, mem_needed;
1321 #if defined(DHD_DEBUG) && defined(DHD_WAKE_EVENT_STATUS)
1322 int flowid;
1323 #endif /* DHD_DEBUG && DHD_WAKE_EVENT_STATUS */
1324 struct sk_buff *skb = NULL;
1325 dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(ndev);
1326
1327 WL_DBG(("Recv get wake status info cmd.\n"));
1328
1329 pwake_count_info = dhd_get_wakecount(dhdp);
1330 mem_needed = VENDOR_REPLY_OVERHEAD + (ATTRIBUTE_U32_LEN * 20) +
1331 (WLC_E_LAST * sizeof(uint));
1332
1333 skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, mem_needed);
1334 if (unlikely(!skb)) {
1335 WL_ERR(("%s: can't allocate %d bytes\n", __FUNCTION__, mem_needed));
1336 ret = -ENOMEM;
1337 goto exit;
1338 }
1339 #ifdef DHD_WAKE_EVENT_STATUS
1340 WL_ERR(("pwake_count_info->rcwake %d\n", pwake_count_info->rcwake));
1341 ret = nla_put_u32(skb, WAKE_STAT_ATTRIBUTE_TOTAL_CMD_EVENT, pwake_count_info->rcwake);
1342 if (unlikely(ret)) {
1343 WL_ERR(("Failed to put Total count of CMD event, ret=%d\n", ret));
1344 goto exit;
1345 }
1346 ret = nla_put_u32(skb, WAKE_STAT_ATTRIBUTE_CMD_EVENT_COUNT_USED, WLC_E_LAST);
1347 if (unlikely(ret)) {
1348 WL_ERR(("Failed to put Max count of event used, ret=%d\n", ret));
1349 goto exit;
1350 }
1351 ret = nla_put(skb, WAKE_STAT_ATTRIBUTE_CMD_EVENT_WAKE, (WLC_E_LAST * sizeof(uint)),
1352 pwake_count_info->rc_event);
1353 if (unlikely(ret)) {
1354 WL_ERR(("Failed to put Event wake data, ret=%d\n", ret));
1355 goto exit;
1356 }
1357 #ifdef DHD_DEBUG
1358 for (flowid = 0; flowid < WLC_E_LAST; flowid++) {
1359 if (pwake_count_info->rc_event[flowid] != 0) {
1360 WL_ERR((" %s = %u\n", bcmevent_get_name(flowid),
1361 pwake_count_info->rc_event[flowid]));
1362 }
1363 }
1364 #endif /* DHD_DEBUG */
1365 #endif /* DHD_WAKE_EVENT_STATUS */
1366 #ifdef DHD_WAKE_RX_STATUS
1367 WL_ERR(("pwake_count_info->rxwake %d\n", pwake_count_info->rxwake));
1368 ret = nla_put_u32(skb, WAKE_STAT_ATTRIBUTE_TOTAL_RX_DATA_WAKE, pwake_count_info->rxwake);
1369 if (unlikely(ret)) {
1370 WL_ERR(("Failed to put Total Wake due RX data, ret=%d\n", ret));
1371 goto exit;
1372 }
1373 ret = nla_put_u32(skb, WAKE_STAT_ATTRIBUTE_RX_UNICAST_COUNT, pwake_count_info->rx_ucast);
1374 if (unlikely(ret)) {
1375 WL_ERR(("Failed to put Total wake due to RX unicast, ret=%d\n", ret));
1376 goto exit;
1377 }
1378 ret = nla_put_u32(skb, WAKE_STAT_ATTRIBUTE_RX_MULTICAST_COUNT, pwake_count_info->rx_mcast);
1379 if (unlikely(ret)) {
1380 WL_ERR(("Failed to put Total wake due RX multicast, ret=%d\n", ret));
1381 goto exit;
1382 }
1383 ret = nla_put_u32(skb, WAKE_STAT_ATTRIBUTE_RX_BROADCAST_COUNT, pwake_count_info->rx_bcast);
1384 if (unlikely(ret)) {
1385 WL_ERR(("Failed to put Total wake due to RX broadcast, ret=%d\n", ret));
1386 goto exit;
1387 }
1388 ret = nla_put_u32(skb, WAKE_STAT_ATTRIBUTE_RX_ICMP_PKT, pwake_count_info->rx_arp);
1389 if (unlikely(ret)) {
1390 WL_ERR(("Failed to put Total wake due to ICMP pkt, ret=%d\n", ret));
1391 goto exit;
1392 }
1393 ret = nla_put_u32(skb, WAKE_STAT_ATTRIBUTE_RX_ICMP6_PKT, pwake_count_info->rx_icmpv6);
1394 if (unlikely(ret)) {
1395 WL_ERR(("Failed to put Total wake due ICMPV6 pkt, ret=%d\n", ret));
1396 goto exit;
1397 }
1398 ret = nla_put_u32(skb, WAKE_STAT_ATTRIBUTE_RX_ICMP6_RA, pwake_count_info->rx_icmpv6_ra);
1399 if (unlikely(ret)) {
1400 WL_ERR(("Failed to put Total wake due to ICMPV6_RA, ret=%d\n", ret));
1401 goto exit;
1402 }
1403 ret = nla_put_u32(skb, WAKE_STAT_ATTRIBUTE_RX_ICMP6_NA, pwake_count_info->rx_icmpv6_na);
1404 if (unlikely(ret)) {
1405 WL_ERR(("Failed to put Total wake due to ICMPV6_NA, ret=%d\n", ret));
1406 goto exit;
1407 }
1408 ret = nla_put_u32(skb, WAKE_STAT_ATTRIBUTE_RX_ICMP6_NS, pwake_count_info->rx_icmpv6_ns);
1409 if (unlikely(ret)) {
1410 WL_ERR(("Failed to put Total wake due to ICMPV6_NS, ret=%d\n", ret));
1411 goto exit;
1412 }
1413 ret = nla_put_u32(skb, WAKE_STAT_ATTRIBUTE_IPV4_RX_MULTICAST_ADD_CNT,
1414 pwake_count_info->rx_multi_ipv4);
1415 if (unlikely(ret)) {
1416 WL_ERR(("Failed to put Total wake due to RX IPV4 MULTICAST, ret=%d\n", ret));
1417 goto exit;
1418 }
1419 ret = nla_put_u32(skb, WAKE_STAT_ATTRIBUTE_IPV6_RX_MULTICAST_ADD_CNT,
1420 pwake_count_info->rx_multi_ipv6);
1421 if (unlikely(ret)) {
1422 WL_ERR(("Failed to put Total wake due to RX IPV6 MULTICAST, ret=%d\n", ret));
1423 goto exit;
1424 }
1425 ret = nla_put_u32(skb, WAKE_STAT_ATTRIBUTE_OTHER_RX_MULTICAST_ADD_CNT,
1426 pwake_count_info->rx_multi_other);
1427 if (unlikely(ret)) {
1428 WL_ERR(("Failed to put Total wake due to Other RX Multicast, ret=%d\n", ret));
1429 goto exit;
1430 }
1431 #endif /* #ifdef DHD_WAKE_RX_STATUS */
1432 ret = cfg80211_vendor_cmd_reply(skb);
1433 if (unlikely(ret)) {
1434 WL_ERR(("Vendor cmd reply for -get wake status failed:%d \n", ret));
1435 }
1436 /* On cfg80211_vendor_cmd_reply() skb is consumed and freed in case of success or failure */
1437 return ret;
1438
1439 exit:
1440 /* Free skb memory */
1441 if (skb) {
1442 kfree_skb(skb);
1443 }
1444 return ret;
1445 }
1446 #endif /* DHD_WAKE_STATUS */
1447
1448 #ifdef DHDTCPACK_SUPPRESS
1449 static int
wl_cfgvendor_set_tcpack_sup_mode(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)1450 wl_cfgvendor_set_tcpack_sup_mode(struct wiphy *wiphy,
1451 struct wireless_dev *wdev, const void *data, int len)
1452 {
1453 int err = BCME_OK, type;
1454 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
1455 struct net_device *ndev = wdev_to_wlc_ndev(wdev, cfg);
1456 uint8 enable = 0;
1457
1458 if (!data) {
1459 WL_ERR(("data is not available\n"));
1460 err = BCME_BADARG;
1461 goto exit;
1462 }
1463
1464 if (len <= 0) {
1465 WL_ERR(("Length of the nlattr is not valid len : %d\n", len));
1466 err = BCME_BADARG;
1467 goto exit;
1468 }
1469
1470 type = nla_type(data);
1471 if (type == ANDR_WIFI_ATTRIBUTE_TCPACK_SUP_VALUE) {
1472 enable = (uint8) nla_get_u32(data);
1473 err = dhd_dev_set_tcpack_sup_mode_cfg(ndev, enable);
1474 if (unlikely(err)) {
1475 WL_ERR(("Could not set TCP Ack Suppress mode cfg: %d\n", err));
1476 }
1477 } else {
1478 err = BCME_BADARG;
1479 }
1480
1481 exit:
1482 return err;
1483 }
1484 #endif /* DHDTCPACK_SUPPRESS */
1485
1486 static int
wl_cfgvendor_set_latency_mode(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)1487 wl_cfgvendor_set_latency_mode(struct wiphy *wiphy,
1488 struct wireless_dev *wdev, const void *data, int len)
1489 {
1490 int err = BCME_OK;
1491 int type;
1492 bool lmode;
1493
1494 struct net_device *ndev = wdev_to_ndev(wdev);
1495 WL_DBG(("wl_cfgvendor_set_latency_mode Enter \n"));
1496 if (!data) {
1497 WL_ERR(("data is not available\n"));
1498 return -EINVAL;
1499 }
1500
1501 if (len <= 0) {
1502 WL_ERR(("invalid len %d\n", len));
1503 return -EINVAL;
1504 }
1505
1506 type = nla_type(data);
1507 if (type == ANDR_WIFI_ATTRIBUTE_LATENCY_MODE) {
1508 lmode = (bool)nla_get_u32(data);
1509 err = wl_cfg80211_set_power_mgmt(wiphy, ndev, !lmode, 0);
1510 }
1511 return err;
1512 }
1513
1514 #if (0)//ndef CONFIG_SOC_S5E5515
1515 static int
wl_cfgvendor_set_random_mac(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)1516 wl_cfgvendor_set_random_mac(struct wiphy *wiphy,
1517 struct wireless_dev *wdev, const void *data, int len)
1518 {
1519 int err = BCME_OK;
1520
1521 WL_ERR(("ANDR_WIFI_ATTRIBUTE_RANDOM_MAC is not available\n"));
1522 err = BCME_UNSUPPORTED;
1523
1524 return err;
1525 }
1526 #endif /* CONFIG_SOC_S5E5515 */
1527
1528 static int
wl_cfgvendor_set_tx_power_scenario(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)1529 wl_cfgvendor_set_tx_power_scenario(struct wiphy *wiphy,
1530 struct wireless_dev *wdev, const void *data, int len)
1531 {
1532 int err = BCME_OK;
1533 int type;
1534 if (!data) {
1535 WL_ERR(("data is not available\n"));
1536 return -EINVAL;
1537 }
1538 if (len <= 0) {
1539 WL_ERR(("invalid len %d\n", len));
1540 return -EINVAL;
1541 }
1542 type = nla_type(data);
1543 if (type == ANDR_WIFI_ATTRIBUTE_TX_POWER_SCENARIO) {
1544 //Handling to be implemented
1545 //err = wl_cfg80211_set_tx_power(wiphy,wdev,type,0);
1546 err = BCME_OK;
1547 }
1548 return err;
1549 }
1550
1551 #if defined(WL_CFG80211) && defined(DHD_FILE_DUMP_EVENT)
1552 static int
wl_cfgvendor_notify_dump_completion(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)1553 wl_cfgvendor_notify_dump_completion(struct wiphy *wiphy,
1554 struct wireless_dev *wdev, const void *data, int len)
1555 {
1556 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
1557 dhd_pub_t *dhd_pub = cfg->pub;
1558 unsigned long flags = 0;
1559
1560 WL_INFORM(("%s, [DUMP] received file dump notification from HAL\n", __FUNCTION__));
1561
1562 DHD_GENERAL_LOCK(dhd_pub, flags);
1563 /* call wmb() to synchronize with the previous memory operations */
1564 OSL_SMP_WMB();
1565 DHD_BUS_BUSY_CLEAR_IN_HALDUMP(dhd_pub);
1566 /* Call another wmb() to make sure wait_for_dump_completion value
1567 * gets updated before waking up waiting context.
1568 */
1569 OSL_SMP_WMB();
1570 dhd_os_busbusy_wake(dhd_pub);
1571 DHD_GENERAL_UNLOCK(dhd_pub, flags);
1572
1573 return BCME_OK;
1574 }
1575 #endif /* WL_CFG80211 && DHD_FILE_DUMP_EVENT */
1576
1577 #if defined(WL_CFG80211)
1578 static int
wl_cfgvendor_set_hal_started(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)1579 wl_cfgvendor_set_hal_started(struct wiphy *wiphy,
1580 struct wireless_dev *wdev, const void *data, int len)
1581 {
1582 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
1583 WL_INFORM(("%s,[DUMP] HAL STARTED\n", __FUNCTION__));
1584
1585 cfg->hal_started = true;
1586 return BCME_OK;
1587 }
1588
1589 static int
wl_cfgvendor_stop_hal(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)1590 wl_cfgvendor_stop_hal(struct wiphy *wiphy,
1591 struct wireless_dev *wdev, const void *data, int len)
1592 {
1593 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
1594 WL_INFORM(("%s,[DUMP] HAL STOPPED\n", __FUNCTION__));
1595
1596 cfg->hal_started = false;
1597 return BCME_OK;
1598 }
1599 #endif /* WL_CFG80211 */
1600
1601 #ifdef RTT_SUPPORT
1602 void
wl_cfgvendor_rtt_evt(void * ctx,void * rtt_data)1603 wl_cfgvendor_rtt_evt(void *ctx, void *rtt_data)
1604 {
1605 struct wireless_dev *wdev = (struct wireless_dev *)ctx;
1606 struct wiphy *wiphy;
1607 struct sk_buff *skb = NULL;
1608 uint32 evt_complete = 0;
1609 gfp_t kflags;
1610 rtt_result_t *rtt_result;
1611 rtt_results_header_t *rtt_header;
1612 struct list_head *rtt_cache_list;
1613 struct nlattr *rtt_nl_hdr;
1614 int ret = BCME_OK;
1615 wiphy = wdev->wiphy;
1616
1617 WL_DBG(("In\n"));
1618 /* Push the data to the skb */
1619 if (!rtt_data) {
1620 WL_ERR(("rtt_data is NULL\n"));
1621 return;
1622 }
1623 rtt_cache_list = (struct list_head *)rtt_data;
1624 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
1625 if (list_empty(rtt_cache_list)) {
1626 #if (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || \
1627 LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0)
1628 skb = cfg80211_vendor_event_alloc(wiphy, NULL, 100,
1629 GOOGLE_RTT_COMPLETE_EVENT, kflags);
1630 #else
1631 skb = cfg80211_vendor_event_alloc(wiphy, 100, GOOGLE_RTT_COMPLETE_EVENT, kflags);
1632 #endif /* (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || */
1633 /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0) */
1634 if (!skb) {
1635 WL_ERR(("skb alloc failed"));
1636 return;
1637 }
1638 evt_complete = 1;
1639 ret = nla_put_u32(skb, RTT_ATTRIBUTE_RESULTS_COMPLETE, evt_complete);
1640 if (ret < 0) {
1641 WL_ERR(("Failed to put RTT_ATTRIBUTE_RESULTS_COMPLETE\n"));
1642 goto free_mem;
1643 }
1644 cfg80211_vendor_event(skb, kflags);
1645 return;
1646 }
1647 GCC_DIAGNOSTIC_PUSH_SUPPRESS_CAST();
1648 list_for_each_entry(rtt_header, rtt_cache_list, list) {
1649 /* Alloc the SKB for vendor_event */
1650 #if (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || \
1651 LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0)
1652 skb = cfg80211_vendor_event_alloc(wiphy, NULL, rtt_header->result_tot_len + 100,
1653 GOOGLE_RTT_COMPLETE_EVENT, kflags);
1654 #else
1655 skb = cfg80211_vendor_event_alloc(wiphy, rtt_header->result_tot_len + 100,
1656 GOOGLE_RTT_COMPLETE_EVENT, kflags);
1657 #endif /* (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || */
1658 /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0) */
1659 if (!skb) {
1660 WL_ERR(("skb alloc failed"));
1661 return;
1662 }
1663 if (list_is_last(&rtt_header->list, rtt_cache_list)) {
1664 evt_complete = 1;
1665 }
1666 ret = nla_put_u32(skb, RTT_ATTRIBUTE_RESULTS_COMPLETE, evt_complete);
1667 if (ret < 0) {
1668 WL_ERR(("Failed to put RTT_ATTRIBUTE_RESULTS_COMPLETE\n"));
1669 goto free_mem;
1670 }
1671 rtt_nl_hdr = nla_nest_start(skb, RTT_ATTRIBUTE_RESULTS_PER_TARGET);
1672 if (!rtt_nl_hdr) {
1673 WL_ERR(("rtt_nl_hdr is NULL\n"));
1674 dev_kfree_skb_any(skb);
1675 break;
1676 }
1677 ret = nla_put(skb, RTT_ATTRIBUTE_TARGET_MAC, ETHER_ADDR_LEN,
1678 &rtt_header->peer_mac);
1679 if (ret < 0) {
1680 WL_ERR(("Failed to put RTT_ATTRIBUTE_TARGET_MAC, ret:%d\n", ret));
1681 goto free_mem;
1682 }
1683 ret = nla_put_u32(skb, RTT_ATTRIBUTE_RESULT_CNT, rtt_header->result_cnt);
1684 if (ret < 0) {
1685 WL_ERR(("Failed to put RTT_ATTRIBUTE_RESULT_CNT, ret:%d\n", ret));
1686 goto free_mem;
1687 }
1688 list_for_each_entry(rtt_result, &rtt_header->result_list, list) {
1689 ret = nla_put(skb, RTT_ATTRIBUTE_RESULT,
1690 rtt_result->report_len, &rtt_result->report);
1691 if (ret < 0) {
1692 WL_ERR(("Failed to put RTT_ATTRIBUTE_RESULT, ret:%d\n", ret));
1693 goto free_mem;
1694 }
1695 ret = nla_put(skb, RTT_ATTRIBUTE_RESULT_DETAIL,
1696 rtt_result->detail_len, &rtt_result->rtt_detail);
1697 if (ret < 0) {
1698 WL_ERR(("Failed to put RTT_ATTRIBUTE_RESULT_DETAIL, ret:%d\n",
1699 ret));
1700 goto free_mem;
1701 }
1702 }
1703 nla_nest_end(skb, rtt_nl_hdr);
1704 cfg80211_vendor_event(skb, kflags);
1705 }
1706 GCC_DIAGNOSTIC_POP();
1707
1708 return;
1709
1710 free_mem:
1711 /* Free skb memory */
1712 if (skb) {
1713 kfree_skb(skb);
1714 }
1715 }
1716
1717 static int
wl_cfgvendor_rtt_set_config(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)1718 wl_cfgvendor_rtt_set_config(struct wiphy *wiphy, struct wireless_dev *wdev,
1719 const void *data, int len) {
1720 int err = 0, rem, rem1, rem2, type;
1721 int target_cnt = 0;
1722 rtt_config_params_t rtt_param;
1723 rtt_target_info_t* rtt_target = NULL;
1724 const struct nlattr *iter, *iter1, *iter2;
1725 int8 eabuf[ETHER_ADDR_STR_LEN];
1726 int8 chanbuf[CHANSPEC_STR_LEN];
1727 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
1728 rtt_capabilities_t capability;
1729
1730 bzero(&rtt_param, sizeof(rtt_param));
1731
1732 WL_DBG(("In\n"));
1733 err = dhd_dev_rtt_register_noti_callback(wdev->netdev, wdev, wl_cfgvendor_rtt_evt);
1734 if (err < 0) {
1735 WL_ERR(("failed to register rtt_noti_callback\n"));
1736 goto exit;
1737 }
1738 err = dhd_dev_rtt_capability(bcmcfg_to_prmry_ndev(cfg), &capability);
1739 if (err < 0) {
1740 WL_ERR(("failed to get the capability\n"));
1741 goto exit;
1742 }
1743
1744 if (len <= 0) {
1745 WL_ERR(("Length of the nlattr is not valid len : %d\n", len));
1746 err = BCME_ERROR;
1747 goto exit;
1748 }
1749 nla_for_each_attr(iter, data, len, rem) {
1750 type = nla_type(iter);
1751 switch (type) {
1752 case RTT_ATTRIBUTE_TARGET_CNT:
1753 if (target_cnt != 0) {
1754 WL_ERR(("attempt to overwrite target_cnt"));
1755 err = -EINVAL;
1756 goto exit;
1757 }
1758 target_cnt = nla_get_u8(iter);
1759 if ((target_cnt <= 0) || (target_cnt > RTT_MAX_TARGET_CNT)) {
1760 WL_ERR(("target_cnt is not valid : %d\n",
1761 target_cnt));
1762 err = BCME_RANGE;
1763 goto exit;
1764 }
1765 rtt_param.rtt_target_cnt = target_cnt;
1766
1767 rtt_param.target_info = (rtt_target_info_t *)MALLOCZ(cfg->osh,
1768 TARGET_INFO_SIZE(target_cnt));
1769 if (rtt_param.target_info == NULL) {
1770 WL_ERR(("failed to allocate target info for (%d)\n", target_cnt));
1771 err = BCME_NOMEM;
1772 goto exit;
1773 }
1774 break;
1775 case RTT_ATTRIBUTE_TARGET_INFO:
1776 /* Added this variable for safe check to avoid crash
1777 * incase the caller did not respect the order
1778 */
1779 if (rtt_param.target_info == NULL) {
1780 WL_ERR(("rtt_target_info is NULL\n"));
1781 err = BCME_NOMEM;
1782 goto exit;
1783 }
1784 rtt_target = rtt_param.target_info;
1785 nla_for_each_nested(iter1, iter, rem1) {
1786 if ((uint8 *)rtt_target >= ((uint8 *)rtt_param.target_info +
1787 TARGET_INFO_SIZE(target_cnt))) {
1788 WL_ERR(("rtt_target increased over its max size"));
1789 err = -EINVAL;
1790 goto exit;
1791 }
1792 nla_for_each_nested(iter2, iter1, rem2) {
1793 type = nla_type(iter2);
1794 switch (type) {
1795 case RTT_ATTRIBUTE_TARGET_MAC:
1796 if (nla_len(iter2) != ETHER_ADDR_LEN) {
1797 WL_ERR(("mac_addr length not match\n"));
1798 err = -EINVAL;
1799 goto exit;
1800 }
1801 memcpy(&rtt_target->addr, nla_data(iter2),
1802 ETHER_ADDR_LEN);
1803 break;
1804 case RTT_ATTRIBUTE_TARGET_TYPE:
1805 rtt_target->type = nla_get_u8(iter2);
1806 if (rtt_target->type == RTT_INVALID ||
1807 (rtt_target->type == RTT_ONE_WAY &&
1808 !capability.rtt_one_sided_supported)) {
1809 WL_ERR(("doesn't support RTT type"
1810 " : %d\n",
1811 rtt_target->type));
1812 err = -EINVAL;
1813 goto exit;
1814 }
1815 break;
1816 case RTT_ATTRIBUTE_TARGET_PEER:
1817 rtt_target->peer = nla_get_u8(iter2);
1818 break;
1819 case RTT_ATTRIBUTE_TARGET_CHAN:
1820 memcpy(&rtt_target->channel, nla_data(iter2),
1821 sizeof(rtt_target->channel));
1822 break;
1823 case RTT_ATTRIBUTE_TARGET_PERIOD:
1824 rtt_target->burst_period = nla_get_u32(iter2);
1825 if (rtt_target->burst_period < 32) {
1826 /* 100ms unit */
1827 rtt_target->burst_period *= 100;
1828 } else {
1829 WL_ERR(("%d value must in (0-31)\n",
1830 rtt_target->burst_period));
1831 err = EINVAL;
1832 goto exit;
1833 }
1834 break;
1835 case RTT_ATTRIBUTE_TARGET_NUM_BURST:
1836 rtt_target->num_burst = nla_get_u32(iter2);
1837 if (rtt_target->num_burst > 16) {
1838 WL_ERR(("%d value must in (0-15)\n",
1839 rtt_target->num_burst));
1840 err = -EINVAL;
1841 goto exit;
1842 }
1843 rtt_target->num_burst = BIT(rtt_target->num_burst);
1844 break;
1845 case RTT_ATTRIBUTE_TARGET_NUM_FTM_BURST:
1846 rtt_target->num_frames_per_burst =
1847 nla_get_u32(iter2);
1848 break;
1849 case RTT_ATTRIBUTE_TARGET_NUM_RETRY_FTM:
1850 rtt_target->num_retries_per_ftm =
1851 nla_get_u32(iter2);
1852 break;
1853 case RTT_ATTRIBUTE_TARGET_NUM_RETRY_FTMR:
1854 rtt_target->num_retries_per_ftmr =
1855 nla_get_u32(iter2);
1856 if (rtt_target->num_retries_per_ftmr > 3) {
1857 WL_ERR(("%d value must in (0-3)\n",
1858 rtt_target->num_retries_per_ftmr));
1859 err = -EINVAL;
1860 goto exit;
1861 }
1862 break;
1863 case RTT_ATTRIBUTE_TARGET_LCI:
1864 rtt_target->LCI_request = nla_get_u8(iter2);
1865 break;
1866 case RTT_ATTRIBUTE_TARGET_LCR:
1867 rtt_target->LCI_request = nla_get_u8(iter2);
1868 break;
1869 case RTT_ATTRIBUTE_TARGET_BURST_DURATION:
1870 if ((nla_get_u32(iter2) > 1 &&
1871 nla_get_u32(iter2) < 12)) {
1872 rtt_target->burst_duration =
1873 dhd_rtt_idx_to_burst_duration(
1874 nla_get_u32(iter2));
1875 } else if (nla_get_u32(iter2) == 15) {
1876 /* use default value */
1877 rtt_target->burst_duration = 0;
1878 } else {
1879 WL_ERR(("%d value must in (2-11) or 15\n",
1880 nla_get_u32(iter2)));
1881 err = -EINVAL;
1882 goto exit;
1883 }
1884 break;
1885 case RTT_ATTRIBUTE_TARGET_BW:
1886 rtt_target->bw = nla_get_u8(iter2);
1887 break;
1888 case RTT_ATTRIBUTE_TARGET_PREAMBLE:
1889 rtt_target->preamble = nla_get_u8(iter2);
1890 break;
1891 }
1892 }
1893 /* convert to chanspec value */
1894 rtt_target->chanspec =
1895 dhd_rtt_convert_to_chspec(rtt_target->channel);
1896 if (rtt_target->chanspec == 0) {
1897 WL_ERR(("Channel is not valid \n"));
1898 err = -EINVAL;
1899 goto exit;
1900 }
1901 WL_INFORM_MEM(("Target addr %s, Channel : %s for RTT \n",
1902 bcm_ether_ntoa((const struct ether_addr *)&rtt_target->addr,
1903 eabuf),
1904 wf_chspec_ntoa(rtt_target->chanspec, chanbuf)));
1905 rtt_target++;
1906 }
1907 break;
1908 }
1909 }
1910 WL_DBG(("leave :target_cnt : %d\n", rtt_param.rtt_target_cnt));
1911 if (dhd_dev_rtt_set_cfg(bcmcfg_to_prmry_ndev(cfg), &rtt_param) < 0) {
1912 WL_ERR(("Could not set RTT configuration\n"));
1913 err = -EINVAL;
1914 }
1915 exit:
1916 /* free the target info list */
1917 if (rtt_param.target_info) {
1918 MFREE(cfg->osh, rtt_param.target_info,
1919 TARGET_INFO_SIZE(target_cnt));
1920 }
1921 return err;
1922 }
1923
1924 static int
wl_cfgvendor_rtt_cancel_config(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)1925 wl_cfgvendor_rtt_cancel_config(struct wiphy *wiphy, struct wireless_dev *wdev,
1926 const void *data, int len)
1927 {
1928 int err = 0, rem, type, target_cnt = 0;
1929 int target_idx = 0;
1930 const struct nlattr *iter;
1931 struct ether_addr *mac_list = NULL;
1932 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
1933
1934 if (len <= 0) {
1935 WL_ERR(("Length of nlattr is not valid len : %d\n", len));
1936 err = -EINVAL;
1937 goto exit;
1938 }
1939 nla_for_each_attr(iter, data, len, rem) {
1940 type = nla_type(iter);
1941 switch (type) {
1942 case RTT_ATTRIBUTE_TARGET_CNT:
1943 if (mac_list != NULL) {
1944 WL_ERR(("mac_list is not NULL\n"));
1945 err = -EINVAL;
1946 goto exit;
1947 }
1948 target_cnt = nla_get_u8(iter);
1949 if ((target_cnt > 0) && (target_cnt < RTT_MAX_TARGET_CNT)) {
1950 mac_list = (struct ether_addr *)MALLOCZ(cfg->osh,
1951 target_cnt * ETHER_ADDR_LEN);
1952 if (mac_list == NULL) {
1953 WL_ERR(("failed to allocate mem for mac list\n"));
1954 err = -EINVAL;
1955 goto exit;
1956 }
1957 } else {
1958 /* cancel the current whole RTT process */
1959 goto cancel;
1960 }
1961 break;
1962 case RTT_ATTRIBUTE_TARGET_MAC:
1963 if (mac_list == NULL) {
1964 WL_ERR(("ATTRIBUTE_TARGET_CNT not found before "
1965 " ATTRIBUTE_TARGET_MAC\n"));
1966 err = -EINVAL;
1967 goto exit;
1968 }
1969
1970 if (target_idx >= target_cnt) {
1971 WL_ERR(("More TARGET_MAC entries found, "
1972 "expected TARGET_CNT:%d\n", target_cnt));
1973 err = -EINVAL;
1974 goto exit;
1975 }
1976
1977 if (nla_len(iter) != ETHER_ADDR_LEN) {
1978 WL_ERR(("Invalid TARGET_MAC ATTR len :%d\n", nla_len(iter)));
1979 err = -EINVAL;
1980 goto exit;
1981 }
1982
1983 memcpy(&mac_list[target_idx], nla_data(iter), ETHER_ADDR_LEN);
1984 target_idx++;
1985
1986 break;
1987 default:
1988 WL_ERR(("Uknown type : %d\n", type));
1989 err = -EINVAL;
1990 goto exit;
1991 }
1992 }
1993 cancel:
1994 if (mac_list && dhd_dev_rtt_cancel_cfg(
1995 bcmcfg_to_prmry_ndev(cfg), mac_list, target_cnt) < 0) {
1996 WL_ERR(("Could not cancel RTT configuration\n"));
1997 err = -EINVAL;
1998 }
1999
2000 exit:
2001 if (mac_list) {
2002 MFREE(cfg->osh, mac_list, target_cnt * ETHER_ADDR_LEN);
2003 }
2004 return err;
2005 }
2006
2007 static int
wl_cfgvendor_rtt_get_capability(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)2008 wl_cfgvendor_rtt_get_capability(struct wiphy *wiphy, struct wireless_dev *wdev,
2009 const void *data, int len)
2010 {
2011 int err = 0;
2012 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
2013 rtt_capabilities_t capability;
2014
2015 err = dhd_dev_rtt_capability(bcmcfg_to_prmry_ndev(cfg), &capability);
2016 if (unlikely(err)) {
2017 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
2018 goto exit;
2019 }
2020 err = wl_cfgvendor_send_cmd_reply(wiphy, &capability, sizeof(capability));
2021
2022 if (unlikely(err)) {
2023 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
2024 }
2025 exit:
2026 return err;
2027 }
2028 static int
get_responder_info(struct bcm_cfg80211 * cfg,struct wifi_rtt_responder * responder_info)2029 get_responder_info(struct bcm_cfg80211 *cfg,
2030 struct wifi_rtt_responder *responder_info)
2031 {
2032 int err = 0;
2033 rtt_capabilities_t capability;
2034 err = dhd_dev_rtt_capability(bcmcfg_to_prmry_ndev(cfg), &capability);
2035 if (unlikely(err)) {
2036 WL_ERR(("Could not get responder capability:%d \n", err));
2037 return err;
2038 }
2039 if (capability.preamble_support & RTT_PREAMBLE_VHT) {
2040 responder_info->preamble |= RTT_PREAMBLE_VHT;
2041 }
2042 if (capability.preamble_support & RTT_PREAMBLE_HT) {
2043 responder_info->preamble |= RTT_PREAMBLE_HT;
2044 }
2045 err = dhd_dev_rtt_avail_channel(bcmcfg_to_prmry_ndev(cfg), &(responder_info->channel));
2046 if (unlikely(err)) {
2047 WL_ERR(("Could not get available channel:%d \n", err));
2048 return err;
2049 }
2050 return err;
2051 }
2052 static int
wl_cfgvendor_rtt_get_responder_info(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)2053 wl_cfgvendor_rtt_get_responder_info(struct wiphy *wiphy, struct wireless_dev *wdev,
2054 const void *data, int len)
2055 {
2056 int err = 0;
2057 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
2058 wifi_rtt_responder_t responder_info;
2059
2060 WL_DBG(("Recv -get_avail_ch command \n"));
2061
2062 bzero(&responder_info, sizeof(responder_info));
2063 err = get_responder_info(cfg, &responder_info);
2064 if (unlikely(err)) {
2065 WL_ERR(("Failed to get responder info:%d \n", err));
2066 return err;
2067 }
2068 err = wl_cfgvendor_send_cmd_reply(wiphy, &responder_info, sizeof(responder_info));
2069 if (unlikely(err)) {
2070 WL_ERR(("Vendor cmd reply for -get_avail_ch failed ret:%d \n", err));
2071 }
2072 return err;
2073 }
2074
2075 static int
wl_cfgvendor_rtt_set_responder(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)2076 wl_cfgvendor_rtt_set_responder(struct wiphy *wiphy, struct wireless_dev *wdev,
2077 const void *data, int len)
2078 {
2079 int err = 0;
2080 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
2081 struct net_device *ndev = wdev_to_wlc_ndev(wdev, cfg);
2082 wifi_rtt_responder_t responder_info;
2083
2084 WL_DBG(("Recv rtt -enable_resp cmd.\n"));
2085
2086 bzero(&responder_info, sizeof(responder_info));
2087
2088 /*
2089 *Passing channel as NULL until implementation
2090 *to get chan info from upper layers is donex
2091 */
2092 err = dhd_dev_rtt_enable_responder(ndev, NULL);
2093 if (unlikely(err)) {
2094 WL_ERR(("Could not enable responder ret:%d \n", err));
2095 goto done;
2096 }
2097 err = get_responder_info(cfg, &responder_info);
2098 if (unlikely(err)) {
2099 WL_ERR(("Failed to get responder info:%d \n", err));
2100 dhd_dev_rtt_cancel_responder(ndev);
2101 goto done;
2102 }
2103 done:
2104 err = wl_cfgvendor_send_cmd_reply(wiphy, &responder_info, sizeof(responder_info));
2105 if (unlikely(err)) {
2106 WL_ERR(("Vendor cmd reply for -enable_resp failed ret:%d \n", err));
2107 }
2108 return err;
2109 }
2110
2111 static int
wl_cfgvendor_rtt_cancel_responder(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)2112 wl_cfgvendor_rtt_cancel_responder(struct wiphy *wiphy, struct wireless_dev *wdev,
2113 const void *data, int len)
2114 {
2115 int err = 0;
2116 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
2117
2118 WL_DBG(("Recv rtt -cancel_resp cmd \n"));
2119
2120 err = dhd_dev_rtt_cancel_responder(bcmcfg_to_prmry_ndev(cfg));
2121 if (unlikely(err)) {
2122 WL_ERR(("Vendor cmd -cancel_resp failed ret:%d \n", err));
2123 }
2124 return err;
2125 }
2126 #endif /* RTT_SUPPORT */
2127
2128 #ifdef GSCAN_SUPPORT
wl_cfgvendor_enable_lazy_roam(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)2129 static int wl_cfgvendor_enable_lazy_roam(struct wiphy *wiphy,
2130 struct wireless_dev *wdev, const void *data, int len)
2131 {
2132 int err = -EINVAL;
2133 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
2134 int type;
2135 uint32 lazy_roam_enable_flag;
2136
2137 if (!data) {
2138 WL_ERR(("data is not available\n"));
2139 return -EINVAL;
2140 }
2141
2142 if (len <= 0) {
2143 WL_ERR(("invaild len %d\n", len));
2144 return -EINVAL;
2145 }
2146
2147 type = nla_type(data);
2148
2149 if (type == GSCAN_ATTRIBUTE_LAZY_ROAM_ENABLE) {
2150 lazy_roam_enable_flag = nla_get_u32(data);
2151
2152 err = dhd_dev_lazy_roam_enable(bcmcfg_to_prmry_ndev(cfg),
2153 lazy_roam_enable_flag);
2154 if (unlikely(err))
2155 WL_ERR(("Could not enable lazy roam:%d \n", err));
2156 }
2157
2158 return err;
2159 }
2160
wl_cfgvendor_set_lazy_roam_cfg(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)2161 static int wl_cfgvendor_set_lazy_roam_cfg(struct wiphy *wiphy,
2162 struct wireless_dev *wdev, const void *data, int len)
2163 {
2164 int err = 0, tmp, type;
2165 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
2166 wlc_roam_exp_params_t roam_param;
2167 const struct nlattr *iter;
2168
2169 bzero(&roam_param, sizeof(roam_param));
2170
2171 nla_for_each_attr(iter, data, len, tmp) {
2172 type = nla_type(iter);
2173 switch (type) {
2174 case GSCAN_ATTRIBUTE_A_BAND_BOOST_THRESHOLD:
2175 roam_param.a_band_boost_threshold = nla_get_u32(iter);
2176 break;
2177 case GSCAN_ATTRIBUTE_A_BAND_PENALTY_THRESHOLD:
2178 roam_param.a_band_penalty_threshold = nla_get_u32(iter);
2179 break;
2180 case GSCAN_ATTRIBUTE_A_BAND_BOOST_FACTOR:
2181 roam_param.a_band_boost_factor = nla_get_u32(iter);
2182 break;
2183 case GSCAN_ATTRIBUTE_A_BAND_PENALTY_FACTOR:
2184 roam_param.a_band_penalty_factor = nla_get_u32(iter);
2185 break;
2186 case GSCAN_ATTRIBUTE_A_BAND_MAX_BOOST:
2187 roam_param.a_band_max_boost = nla_get_u32(iter);
2188 break;
2189 case GSCAN_ATTRIBUTE_LAZY_ROAM_HYSTERESIS:
2190 roam_param.cur_bssid_boost = nla_get_u32(iter);
2191 break;
2192 case GSCAN_ATTRIBUTE_ALERT_ROAM_RSSI_TRIGGER:
2193 roam_param.alert_roam_trigger_threshold = nla_get_u32(iter);
2194 break;
2195 }
2196 }
2197
2198 if (dhd_dev_set_lazy_roam_cfg(bcmcfg_to_prmry_ndev(cfg), &roam_param) < 0) {
2199 WL_ERR(("Could not set batch cfg\n"));
2200 err = -EINVAL;
2201 }
2202 return err;
2203 }
2204
2205 /* small helper function */
2206 static wl_bssid_pref_cfg_t *
create_bssid_pref_cfg(struct bcm_cfg80211 * cfg,uint32 num,uint32 * buf_len)2207 create_bssid_pref_cfg(struct bcm_cfg80211 *cfg, uint32 num, uint32 *buf_len)
2208 {
2209 wl_bssid_pref_cfg_t *bssid_pref;
2210
2211 *buf_len = sizeof(wl_bssid_pref_cfg_t);
2212 if (num) {
2213 *buf_len += (num - 1) * sizeof(wl_bssid_pref_list_t);
2214 }
2215 bssid_pref = (wl_bssid_pref_cfg_t *)MALLOC(cfg->osh, *buf_len);
2216
2217 return bssid_pref;
2218 }
2219
2220 static int
wl_cfgvendor_set_bssid_pref(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)2221 wl_cfgvendor_set_bssid_pref(struct wiphy *wiphy,
2222 struct wireless_dev *wdev, const void *data, int len)
2223 {
2224 int err = 0;
2225 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
2226 wl_bssid_pref_cfg_t *bssid_pref = NULL;
2227 wl_bssid_pref_list_t *bssids;
2228 int tmp, tmp1, tmp2, type;
2229 const struct nlattr *outer, *inner, *iter;
2230 uint32 flush = 0, num = 0, buf_len = 0;
2231 uint8 bssid_found = 0, rssi_found = 0;
2232
2233 /* Assumption: NUM attribute must come first */
2234 nla_for_each_attr(iter, data, len, tmp2) {
2235 type = nla_type(iter);
2236 switch (type) {
2237 case GSCAN_ATTRIBUTE_NUM_BSSID:
2238 if (num) {
2239 WL_ERR(("attempt overide bssid num.\n"));
2240 err = -EINVAL;
2241 goto exit;
2242 }
2243 if (nla_len(iter) != sizeof(uint32)) {
2244 WL_ERR(("nla_len not match\n"));
2245 err = -EINVAL;
2246 goto exit;
2247 }
2248 num = nla_get_u32(iter);
2249 if (num == 0 || num > MAX_BSSID_PREF_LIST_NUM) {
2250 WL_ERR(("wrong BSSID num:%d\n", num));
2251 err = -EINVAL;
2252 goto exit;
2253 }
2254 if ((bssid_pref = create_bssid_pref_cfg(cfg, num, &buf_len))
2255 == NULL) {
2256 WL_ERR(("Can't malloc memory\n"));
2257 err = -ENOMEM;
2258 goto exit;
2259 }
2260 break;
2261 case GSCAN_ATTRIBUTE_BSSID_PREF_FLUSH:
2262 if (nla_len(iter) != sizeof(uint32)) {
2263 WL_ERR(("nla_len not match\n"));
2264 err = -EINVAL;
2265 goto exit;
2266 }
2267 flush = nla_get_u32(iter);
2268 if (flush != 1) {
2269 WL_ERR(("wrong flush value\n"));
2270 err = -EINVAL;
2271 goto exit;
2272 }
2273 break;
2274 case GSCAN_ATTRIBUTE_BSSID_PREF_LIST:
2275 if (!num || !bssid_pref) {
2276 WL_ERR(("bssid list count not set\n"));
2277 err = -EINVAL;
2278 goto exit;
2279 }
2280 bssid_pref->count = 0;
2281 bssids = bssid_pref->bssids;
2282 nla_for_each_nested(outer, iter, tmp) {
2283 if (bssid_pref->count >= num) {
2284 WL_ERR(("too many bssid list\n"));
2285 err = -EINVAL;
2286 goto exit;
2287 }
2288 bssid_found = 0;
2289 rssi_found = 0;
2290 nla_for_each_nested(inner, outer, tmp1) {
2291 type = nla_type(inner);
2292 switch (type) {
2293 case GSCAN_ATTRIBUTE_BSSID_PREF:
2294 if (nla_len(inner) != ETHER_ADDR_LEN) {
2295 WL_ERR(("nla_len not match.\n"));
2296 err = -EINVAL;
2297 goto exit;
2298 }
2299 memcpy(&(bssids[bssid_pref->count].bssid),
2300 nla_data(inner), ETHER_ADDR_LEN);
2301 /* not used for now */
2302 bssids[bssid_pref->count].flags = 0;
2303 bssid_found = 1;
2304 break;
2305 case GSCAN_ATTRIBUTE_RSSI_MODIFIER:
2306 if (nla_len(inner) != sizeof(uint32)) {
2307 WL_ERR(("nla_len not match.\n"));
2308 err = -EINVAL;
2309 goto exit;
2310 }
2311 bssids[bssid_pref->count].rssi_factor =
2312 (int8) nla_get_u32(inner);
2313 rssi_found = 1;
2314 break;
2315 default:
2316 WL_ERR(("wrong type:%d\n", type));
2317 err = -EINVAL;
2318 goto exit;
2319 }
2320 if (bssid_found && rssi_found) {
2321 break;
2322 }
2323 }
2324 bssid_pref->count++;
2325 }
2326 break;
2327 default:
2328 WL_ERR(("%s: No such attribute %d\n", __FUNCTION__, type));
2329 break;
2330 }
2331 }
2332
2333 if (!bssid_pref) {
2334 /* What if only flush is desired? */
2335 if (flush) {
2336 if ((bssid_pref = create_bssid_pref_cfg(cfg, 0, &buf_len)) == NULL) {
2337 WL_ERR(("%s: Can't malloc memory\n", __FUNCTION__));
2338 err = -ENOMEM;
2339 goto exit;
2340 }
2341 bssid_pref->count = 0;
2342 } else {
2343 err = -EINVAL;
2344 goto exit;
2345 }
2346 }
2347 err = dhd_dev_set_lazy_roam_bssid_pref(bcmcfg_to_prmry_ndev(cfg),
2348 bssid_pref, flush);
2349 exit:
2350 if (bssid_pref) {
2351 MFREE(cfg->osh, bssid_pref, buf_len);
2352 }
2353 return err;
2354 }
2355 #endif /* GSCAN_SUPPORT */
2356 #if defined(GSCAN_SUPPORT) || defined(ROAMEXP_SUPPORT)
2357 static int
wl_cfgvendor_set_bssid_blacklist(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)2358 wl_cfgvendor_set_bssid_blacklist(struct wiphy *wiphy,
2359 struct wireless_dev *wdev, const void *data, int len)
2360 {
2361 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
2362 maclist_t *blacklist = NULL;
2363 int err = 0;
2364 int type, tmp;
2365 const struct nlattr *iter;
2366 uint32 mem_needed = 0, flush = 0, num = 0;
2367
2368 /* Assumption: NUM attribute must come first */
2369 nla_for_each_attr(iter, data, len, tmp) {
2370 type = nla_type(iter);
2371 switch (type) {
2372 case GSCAN_ATTRIBUTE_NUM_BSSID:
2373 if (num != 0) {
2374 WL_ERR(("attempt to change BSSID num\n"));
2375 err = -EINVAL;
2376 goto exit;
2377 }
2378 if (nla_len(iter) != sizeof(uint32)) {
2379 WL_ERR(("not matching nla_len.\n"));
2380 err = -EINVAL;
2381 goto exit;
2382 }
2383 num = nla_get_u32(iter);
2384 if (num == 0 || num > MAX_BSSID_BLACKLIST_NUM) {
2385 WL_ERR(("wrong BSSID count:%d\n", num));
2386 err = -EINVAL;
2387 goto exit;
2388 }
2389 if (!blacklist) {
2390 mem_needed = OFFSETOF(maclist_t, ea) +
2391 sizeof(struct ether_addr) * (num);
2392 blacklist = (maclist_t *)
2393 MALLOCZ(cfg->osh, mem_needed);
2394 if (!blacklist) {
2395 WL_ERR(("MALLOCZ failed.\n"));
2396 err = -ENOMEM;
2397 goto exit;
2398 }
2399 }
2400 break;
2401 case GSCAN_ATTRIBUTE_BSSID_BLACKLIST_FLUSH:
2402 if (nla_len(iter) != sizeof(uint32)) {
2403 WL_ERR(("not matching nla_len.\n"));
2404 err = -EINVAL;
2405 goto exit;
2406 }
2407 flush = nla_get_u32(iter);
2408 if (flush != 1) {
2409 WL_ERR(("flush arg is worng:%d\n", flush));
2410 err = -EINVAL;
2411 goto exit;
2412 }
2413 break;
2414 case GSCAN_ATTRIBUTE_BLACKLIST_BSSID:
2415 if (num == 0 || !blacklist) {
2416 WL_ERR(("number of BSSIDs not received.\n"));
2417 err = -EINVAL;
2418 goto exit;
2419 }
2420 if (nla_len(iter) != ETHER_ADDR_LEN) {
2421 WL_ERR(("not matching nla_len.\n"));
2422 err = -EINVAL;
2423 goto exit;
2424 }
2425 if (blacklist->count >= num) {
2426 WL_ERR(("too many BSSIDs than expected:%d\n",
2427 blacklist->count));
2428 err = -EINVAL;
2429 goto exit;
2430 }
2431 memcpy(&(blacklist->ea[blacklist->count]), nla_data(iter),
2432 ETHER_ADDR_LEN);
2433 blacklist->count++;
2434 break;
2435 default:
2436 WL_ERR(("No such attribute:%d\n", type));
2437 break;
2438 }
2439 }
2440
2441 if (blacklist && (blacklist->count != num)) {
2442 WL_ERR(("not matching bssid count:%d to expected:%d\n",
2443 blacklist->count, num));
2444 err = -EINVAL;
2445 goto exit;
2446 }
2447
2448 err = dhd_dev_set_blacklist_bssid(bcmcfg_to_prmry_ndev(cfg),
2449 blacklist, mem_needed, flush);
2450 exit:
2451 MFREE(cfg->osh, blacklist, mem_needed);
2452 return err;
2453 }
2454
2455 static int
wl_cfgvendor_set_ssid_whitelist(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)2456 wl_cfgvendor_set_ssid_whitelist(struct wiphy *wiphy,
2457 struct wireless_dev *wdev, const void *data, int len)
2458 {
2459 int err = 0;
2460 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
2461 wl_ssid_whitelist_t *ssid_whitelist = NULL;
2462 wlc_ssid_t *ssid_elem;
2463 int tmp, tmp1, mem_needed = 0, type;
2464 const struct nlattr *iter, *iter1;
2465 uint32 flush = 0, num = 0;
2466 int ssid_found = 0;
2467
2468 /* Assumption: NUM attribute must come first */
2469 nla_for_each_attr(iter, data, len, tmp) {
2470 type = nla_type(iter);
2471 switch (type) {
2472 case GSCAN_ATTRIBUTE_NUM_WL_SSID:
2473 if (num != 0) {
2474 WL_ERR(("try to change SSID num\n"));
2475 err = -EINVAL;
2476 goto exit;
2477 }
2478 if (nla_len(iter) != sizeof(uint32)) {
2479 WL_ERR(("not matching nla_len.\n"));
2480 err = -EINVAL;
2481 goto exit;
2482 }
2483 num = nla_get_u32(iter);
2484 if (num == 0 || num > MAX_SSID_WHITELIST_NUM) {
2485 WL_ERR(("wrong SSID count:%d\n", num));
2486 err = -EINVAL;
2487 goto exit;
2488 }
2489 mem_needed = sizeof(wl_ssid_whitelist_t) +
2490 sizeof(wlc_ssid_t) * num;
2491 ssid_whitelist = (wl_ssid_whitelist_t *)
2492 MALLOCZ(cfg->osh, mem_needed);
2493 if (ssid_whitelist == NULL) {
2494 WL_ERR(("failed to alloc mem\n"));
2495 err = -ENOMEM;
2496 goto exit;
2497 }
2498 break;
2499 case GSCAN_ATTRIBUTE_WL_SSID_FLUSH:
2500 if (nla_len(iter) != sizeof(uint32)) {
2501 WL_ERR(("not matching nla_len.\n"));
2502 err = -EINVAL;
2503 goto exit;
2504 }
2505 flush = nla_get_u32(iter);
2506 if (flush != 1) {
2507 WL_ERR(("flush arg worng:%d\n", flush));
2508 err = -EINVAL;
2509 goto exit;
2510 }
2511 break;
2512 case GSCAN_ATTRIBUTE_WHITELIST_SSID_ELEM:
2513 if (!num || !ssid_whitelist) {
2514 WL_ERR(("num ssid is not set!\n"));
2515 err = -EINVAL;
2516 goto exit;
2517 }
2518 if (ssid_whitelist->ssid_count >= num) {
2519 WL_ERR(("too many SSIDs:%d\n",
2520 ssid_whitelist->ssid_count));
2521 err = -EINVAL;
2522 goto exit;
2523 }
2524
2525 ssid_elem = &ssid_whitelist->ssids[
2526 ssid_whitelist->ssid_count];
2527 ssid_found = 0;
2528 nla_for_each_nested(iter1, iter, tmp1) {
2529 type = nla_type(iter1);
2530 switch (type) {
2531 case GSCAN_ATTRIBUTE_WL_SSID_LEN:
2532 if (nla_len(iter1) != sizeof(uint32)) {
2533 WL_ERR(("not match nla_len\n"));
2534 err = -EINVAL;
2535 goto exit;
2536 }
2537 ssid_elem->SSID_len = nla_get_u32(iter1);
2538 if (ssid_elem->SSID_len >
2539 DOT11_MAX_SSID_LEN) {
2540 WL_ERR(("wrong SSID len:%d\n",
2541 ssid_elem->SSID_len));
2542 err = -EINVAL;
2543 goto exit;
2544 }
2545 break;
2546 case GSCAN_ATTRIBUTE_WHITELIST_SSID:
2547 if (ssid_elem->SSID_len == 0) {
2548 WL_ERR(("SSID_len not received\n"));
2549 err = -EINVAL;
2550 goto exit;
2551 }
2552 if (nla_len(iter1) != ssid_elem->SSID_len) {
2553 WL_ERR(("not match nla_len\n"));
2554 err = -EINVAL;
2555 goto exit;
2556 }
2557 memcpy(ssid_elem->SSID, nla_data(iter1),
2558 ssid_elem->SSID_len);
2559 ssid_found = 1;
2560 break;
2561 }
2562 if (ssid_found) {
2563 ssid_whitelist->ssid_count++;
2564 break;
2565 }
2566 }
2567 break;
2568 default:
2569 WL_ERR(("No such attribute: %d\n", type));
2570 break;
2571 }
2572 }
2573
2574 if (ssid_whitelist && (ssid_whitelist->ssid_count != num)) {
2575 WL_ERR(("not matching ssid count:%d to expected:%d\n",
2576 ssid_whitelist->ssid_count, num));
2577 err = -EINVAL;
2578 goto exit;
2579 }
2580 err = dhd_dev_set_whitelist_ssid(bcmcfg_to_prmry_ndev(cfg),
2581 ssid_whitelist, mem_needed, flush);
2582 exit:
2583 MFREE(cfg->osh, ssid_whitelist, mem_needed);
2584 return err;
2585 }
2586 #endif /* GSCAN_SUPPORT || ROAMEXP_SUPPORT */
2587
2588 #ifdef ROAMEXP_SUPPORT
2589 typedef enum {
2590 FW_ROAMING_ENABLE = 1,
2591 FW_ROAMING_DISABLE,
2592 FW_ROAMING_PAUSE,
2593 FW_ROAMING_RESUME
2594 } fw_roaming_state_t;
2595
2596 static int
wl_cfgvendor_set_fw_roaming_state(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)2597 wl_cfgvendor_set_fw_roaming_state(struct wiphy *wiphy,
2598 struct wireless_dev *wdev, const void *data, int len)
2599 {
2600 fw_roaming_state_t requested_roaming_state;
2601 int type;
2602 int err = 0;
2603
2604 if (!data) {
2605 WL_ERR(("data is not available\n"));
2606 return -EINVAL;
2607 }
2608
2609 if (len <= 0) {
2610 WL_ERR(("invalid len %d\n", len));
2611 return -EINVAL;
2612 }
2613
2614 /* Get the requested fw roaming state */
2615 type = nla_type(data);
2616 if (type != GSCAN_ATTRIBUTE_ROAM_STATE_SET) {
2617 WL_ERR(("%s: Invalid attribute %d\n", __FUNCTION__, type));
2618 return -EINVAL;
2619 }
2620
2621 requested_roaming_state = nla_get_u32(data);
2622 WL_INFORM(("setting FW roaming state to %d\n", requested_roaming_state));
2623
2624 if ((requested_roaming_state == FW_ROAMING_ENABLE) ||
2625 (requested_roaming_state == FW_ROAMING_RESUME)) {
2626 err = wldev_iovar_setint(wdev_to_ndev(wdev), "roam_off", FALSE);
2627 } else if ((requested_roaming_state == FW_ROAMING_DISABLE) ||
2628 (requested_roaming_state == FW_ROAMING_PAUSE)) {
2629 err = wldev_iovar_setint(wdev_to_ndev(wdev), "roam_off", TRUE);
2630 } else {
2631 err = -EINVAL;
2632 }
2633
2634 return err;
2635 }
2636
2637 static int
wl_cfgvendor_fw_roam_get_capability(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)2638 wl_cfgvendor_fw_roam_get_capability(struct wiphy *wiphy,
2639 struct wireless_dev *wdev, const void *data, int len)
2640 {
2641 int err = 0;
2642 wifi_roaming_capabilities_t roaming_capability;
2643
2644 /* Update max number of blacklist bssids supported */
2645 roaming_capability.max_blacklist_size = MAX_BSSID_BLACKLIST_NUM;
2646 roaming_capability.max_whitelist_size = MAX_SSID_WHITELIST_NUM;
2647 err = wl_cfgvendor_send_cmd_reply(wiphy, &roaming_capability,
2648 sizeof(roaming_capability));
2649 if (unlikely(err)) {
2650 WL_ERR(("Vendor cmd reply for fw roam capability failed ret:%d \n", err));
2651 }
2652
2653 return err;
2654 }
2655 #endif /* ROAMEXP_SUPPORT */
2656
2657 static int
wl_cfgvendor_priv_string_handler(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)2658 wl_cfgvendor_priv_string_handler(struct wiphy *wiphy,
2659 struct wireless_dev *wdev, const void *data, int len)
2660 {
2661 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
2662 int ret = 0;
2663 int ret_len = 0, payload = 0, msglen;
2664 const struct bcm_nlmsg_hdr *nlioc = data;
2665 void *buf = NULL, *cur;
2666 int maxmsglen = PAGE_SIZE - 0x100;
2667 struct sk_buff *reply;
2668 #if defined(OEM_ANDROID)
2669 dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(wdev->netdev);
2670
2671 /* send to dongle only if we are not waiting for reload already */
2672 if (dhdp && dhdp->hang_was_sent) {
2673 WL_INFORM(("Bus down. HANG was sent up earlier\n"));
2674 DHD_OS_WAKE_LOCK_CTRL_TIMEOUT_ENABLE(dhdp, DHD_EVENT_TIMEOUT_MS);
2675 DHD_OS_WAKE_UNLOCK(dhdp);
2676 return OSL_ERROR(BCME_DONGLE_DOWN);
2677 }
2678 #endif /* (OEM_ANDROID) */
2679
2680 if (!data) {
2681 WL_ERR(("data is not available\n"));
2682 return BCME_BADARG;
2683 }
2684
2685 if (len <= 0) {
2686 WL_ERR(("invalid len %d\n", len));
2687 return BCME_BADARG;
2688 }
2689
2690 WL_DBG(("entry: cmd = %d\n", nlioc->cmd));
2691
2692 if (nlioc->offset != sizeof(struct bcm_nlmsg_hdr) ||
2693 len <= sizeof(struct bcm_nlmsg_hdr)) {
2694 WL_ERR(("invalid offset %d\n", nlioc->offset));
2695 return BCME_BADARG;
2696 }
2697 len -= sizeof(struct bcm_nlmsg_hdr);
2698 ret_len = nlioc->len;
2699 if (ret_len > 0 || len > 0) {
2700 if (len >= DHD_IOCTL_MAXLEN) {
2701 WL_ERR(("oversize input buffer %d\n", len));
2702 len = DHD_IOCTL_MAXLEN - 1;
2703 }
2704 if (ret_len >= DHD_IOCTL_MAXLEN) {
2705 WL_ERR(("oversize return buffer %d\n", ret_len));
2706 ret_len = DHD_IOCTL_MAXLEN - 1;
2707 }
2708
2709 payload = max(ret_len, len) + 1;
2710 buf = vzalloc(payload);
2711 if (!buf) {
2712 return -ENOMEM;
2713 }
2714 GCC_DIAGNOSTIC_PUSH_SUPPRESS_CAST();
2715 memcpy(buf, (void *)((char *)nlioc + nlioc->offset), len);
2716 GCC_DIAGNOSTIC_POP();
2717 *((char *)buf + len) = '\0';
2718 }
2719
2720 ret = dhd_cfgvendor_priv_string_handler(cfg, wdev, nlioc, buf);
2721 if (ret) {
2722 WL_ERR(("dhd_cfgvendor returned error %d", ret));
2723 vfree(buf);
2724 return ret;
2725 }
2726 cur = buf;
2727 while (ret_len > 0) {
2728 msglen = ret_len > maxmsglen ? maxmsglen : ret_len;
2729 ret_len -= msglen;
2730 payload = msglen + sizeof(msglen);
2731 reply = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, payload);
2732 if (!reply) {
2733 WL_ERR(("Failed to allocate reply msg\n"));
2734 ret = -ENOMEM;
2735 break;
2736 }
2737
2738 if (nla_put(reply, BCM_NLATTR_DATA, msglen, cur) ||
2739 nla_put_u16(reply, BCM_NLATTR_LEN, msglen)) {
2740 kfree_skb(reply);
2741 ret = -ENOBUFS;
2742 break;
2743 }
2744
2745 ret = cfg80211_vendor_cmd_reply(reply);
2746 if (ret) {
2747 WL_ERR(("testmode reply failed:%d\n", ret));
2748 break;
2749 }
2750 cur = (void *)((char *)cur + msglen);
2751 }
2752
2753 return ret;
2754 }
2755
2756 struct net_device *
wl_cfgvendor_get_ndev(struct bcm_cfg80211 * cfg,struct wireless_dev * wdev,const char * data,unsigned long int * out_addr)2757 wl_cfgvendor_get_ndev(struct bcm_cfg80211 *cfg, struct wireless_dev *wdev,
2758 const char *data, unsigned long int *out_addr)
2759 {
2760 char *pos, *pos1;
2761 char ifname[IFNAMSIZ + 1] = {0};
2762 struct net_info *iter, *next;
2763 struct net_device *ndev = NULL;
2764 ulong ifname_len;
2765 *out_addr = (unsigned long int) data; /* point to command str by default */
2766
2767 /* check whether ifname=<ifname> is provided in the command */
2768 pos = strstr(data, "ifname=");
2769 if (pos) {
2770 pos += strlen("ifname=");
2771 pos1 = strstr(pos, " ");
2772 if (!pos1) {
2773 WL_ERR(("command format error \n"));
2774 return NULL;
2775 }
2776
2777 ifname_len = pos1 - pos;
2778 if (memcpy_s(ifname, (sizeof(ifname) - 1), pos, ifname_len) != BCME_OK) {
2779 WL_ERR(("Failed to copy data. len: %ld\n", ifname_len));
2780 return NULL;
2781 }
2782 GCC_DIAGNOSTIC_PUSH_SUPPRESS_CAST();
2783 for_each_ndev(cfg, iter, next) {
2784 if (iter->ndev) {
2785 if (strncmp(iter->ndev->name, ifname,
2786 strlen(iter->ndev->name)) == 0) {
2787 /* matching ifname found */
2788 WL_DBG(("matching interface (%s) found ndev:%p \n",
2789 iter->ndev->name, iter->ndev));
2790 *out_addr = (unsigned long int)(pos1 + 1);
2791 /* Returns the command portion after ifname=<name> */
2792 return iter->ndev;
2793 }
2794 }
2795 }
2796 GCC_DIAGNOSTIC_POP();
2797 WL_ERR(("Couldn't find ifname:%s in the netinfo list \n",
2798 ifname));
2799 return NULL;
2800 }
2801
2802 /* If ifname=<name> arg is not provided, use default ndev */
2803 ndev = wdev->netdev ? wdev->netdev : bcmcfg_to_prmry_ndev(cfg);
2804 WL_DBG(("Using default ndev (%s) \n", ndev->name));
2805 return ndev;
2806 }
2807
2808 #ifdef WL_SAE
2809 static int
wl_cfgvendor_set_sae_password(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)2810 wl_cfgvendor_set_sae_password(struct wiphy *wiphy,
2811 struct wireless_dev *wdev, const void *data, int len)
2812 {
2813 int err = BCME_OK;
2814 struct net_device *net = wdev->netdev;
2815 struct bcm_cfg80211 *cfg = wl_get_cfg(net);
2816 wsec_pmk_t pmk;
2817 s32 bssidx;
2818
2819 if ((bssidx = wl_get_bssidx_by_wdev(cfg, net->ieee80211_ptr)) < 0) {
2820 WL_ERR(("Find p2p index from wdev(%p) failed\n", net->ieee80211_ptr));
2821 return BCME_ERROR;
2822 }
2823
2824 if (len < WSEC_MIN_PSK_LEN || len >= WSEC_MAX_PSK_LEN) {
2825 WL_ERR(("Invalid passphrase length %d..should be >=8 and <=63\n",
2826 len));
2827 err = BCME_BADLEN;
2828 goto done;
2829 }
2830 /* Set AUTH to SAE */
2831 err = wldev_iovar_setint_bsscfg(net, "wpa_auth", WPA3_AUTH_SAE_PSK, bssidx);
2832 if (unlikely(err)) {
2833 WL_ERR(("could not set wpa_auth (0x%x)\n", err));
2834 goto done;
2835 }
2836 pmk.key_len = htod16(len);
2837 bcopy((const u8*)data, pmk.key, len);
2838 pmk.flags = htod16(WSEC_PASSPHRASE);
2839
2840 err = wldev_ioctl_set(net, WLC_SET_WSEC_PMK, &pmk, sizeof(pmk));
2841 if (err) {
2842 WL_ERR(("\n failed to set pmk %d\n", err));
2843 goto done;
2844 } else {
2845 WL_MEM(("sae passphrase set successfully\n"));
2846 }
2847 done:
2848 return err;
2849 }
2850 #endif /* WL_SAE */
2851
2852 #ifdef BCM_PRIV_CMD_SUPPORT
2853 /* strlen("ifname=") + IFNAMESIZE + strlen(" ") + '\0' */
2854 #define ANDROID_PRIV_CMD_IF_PREFIX_LEN (7 + IFNAMSIZ + 2)
2855 /* Max length for the reply buffer. For BRCM_ATTR_DRIVER_CMD, the reply
2856 * would be a formatted string and reply buf would be the size of the
2857 * string.
2858 */
2859 #define WL_DRIVER_PRIV_CMD_LEN 512
2860 static int
wl_cfgvendor_priv_bcm_handler(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)2861 wl_cfgvendor_priv_bcm_handler(struct wiphy *wiphy,
2862 struct wireless_dev *wdev, const void *data, int len)
2863 {
2864 const struct nlattr *iter;
2865 int err = 0;
2866 int data_len = 0, cmd_len = 0, tmp = 0, type = 0;
2867 struct net_device *ndev = wdev->netdev;
2868 char *cmd = NULL;
2869 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
2870 int bytes_written;
2871 struct net_device *net = NULL;
2872 unsigned long int cmd_out = 0;
2873 #if defined(WL_ANDROID_PRIV_CMD_OVER_NL80211) && defined(OEM_ANDROID)
2874 u32 cmd_buf_len = WL_DRIVER_PRIV_CMD_LEN;
2875 char cmd_prefix[ANDROID_PRIV_CMD_IF_PREFIX_LEN + 1] = {0};
2876 char *cmd_buf = NULL;
2877 char *current_pos;
2878 u32 cmd_offset;
2879 #endif /* WL_ANDROID_PRIV_CMD_OVER_NL80211 && OEM_ANDROID */
2880
2881 WL_DBG(("%s: Enter \n", __func__));
2882
2883 /* hold wake lock */
2884 net_os_wake_lock(ndev);
2885
2886 nla_for_each_attr(iter, data, len, tmp) {
2887 type = nla_type(iter);
2888 cmd = nla_data(iter);
2889 cmd_len = nla_len(iter);
2890
2891 WL_DBG(("%s: type: %d cmd_len:%d cmd_ptr:%p \n", __func__, type, cmd_len, cmd));
2892 if (!cmd || !cmd_len) {
2893 WL_ERR(("Invalid cmd data \n"));
2894 err = -EINVAL;
2895 goto exit;
2896 }
2897
2898 #if defined(WL_ANDROID_PRIV_CMD_OVER_NL80211) && defined(OEM_ANDROID)
2899 if (type == BRCM_ATTR_DRIVER_CMD) {
2900 if ((cmd_len >= WL_DRIVER_PRIV_CMD_LEN) ||
2901 (cmd_len < ANDROID_PRIV_CMD_IF_PREFIX_LEN)) {
2902 WL_ERR(("Unexpected command length (%u)."
2903 "Ignore the command\n", cmd_len));
2904 err = -EINVAL;
2905 goto exit;
2906 }
2907
2908 /* check whether there is any ifname prefix provided */
2909 if (memcpy_s(cmd_prefix, (sizeof(cmd_prefix) - 1),
2910 cmd, ANDROID_PRIV_CMD_IF_PREFIX_LEN) != BCME_OK) {
2911 WL_ERR(("memcpy failed for cmd buffer. len:%d\n", cmd_len));
2912 err = -ENOMEM;
2913 goto exit;
2914 }
2915
2916 net = wl_cfgvendor_get_ndev(cfg, wdev, cmd_prefix, &cmd_out);
2917 if (!cmd_out || !net) {
2918 WL_ERR(("ndev not found\n"));
2919 err = -ENODEV;
2920 goto exit;
2921 }
2922
2923 /* find offset of the command */
2924 current_pos = (char *)cmd_out;
2925 cmd_offset = current_pos - cmd_prefix;
2926
2927 if (!current_pos || (cmd_offset) > ANDROID_PRIV_CMD_IF_PREFIX_LEN) {
2928 WL_ERR(("Invalid len cmd_offset: %u \n", cmd_offset));
2929 err = -EINVAL;
2930 goto exit;
2931 }
2932
2933 /* Private command data in expected to be in str format. To ensure that
2934 * the data is null terminated, copy to a local buffer before use
2935 */
2936 cmd_buf = (char *)MALLOCZ(cfg->osh, cmd_buf_len);
2937 if (!cmd_buf) {
2938 WL_ERR(("memory alloc failed for %u \n", cmd_buf_len));
2939 err = -ENOMEM;
2940 goto exit;
2941 }
2942
2943 /* Point to the start of command */
2944 if (memcpy_s(cmd_buf, (WL_DRIVER_PRIV_CMD_LEN - 1),
2945 (const void *)(cmd + cmd_offset),
2946 (cmd_len - cmd_offset - 1)) != BCME_OK) {
2947 WL_ERR(("memcpy failed for cmd buffer. len:%d\n", cmd_len));
2948 err = -ENOMEM;
2949 goto exit;
2950 }
2951 cmd_buf[WL_DRIVER_PRIV_CMD_LEN - 1] = '\0';
2952
2953 WL_DBG(("vendor_command: %s len: %u \n", cmd_buf, cmd_buf_len));
2954 bytes_written = wl_handle_private_cmd(net, cmd_buf, cmd_buf_len);
2955 WL_DBG(("bytes_written: %d \n", bytes_written));
2956 if (bytes_written == 0) {
2957 snprintf(cmd_buf, cmd_buf_len, "%s", "OK");
2958 data_len = sizeof("OK");
2959 } else if (bytes_written > 0) {
2960 if (bytes_written >= (cmd_buf_len - 1)) {
2961 /* Not expected */
2962 ASSERT(0);
2963 err = -EINVAL;
2964 goto exit;
2965 }
2966 data_len = bytes_written;
2967 } else {
2968 /* -ve return value. Propagate the error back */
2969 err = bytes_written;
2970 goto exit;
2971 }
2972 if ((data_len > 0) && (data_len < (cmd_buf_len - 1)) && cmd_buf) {
2973 err = wl_cfgvendor_send_cmd_reply(wiphy, cmd_buf, data_len);
2974 if (unlikely(err)) {
2975 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
2976 } else {
2977 WL_DBG(("Vendor Command reply sent successfully!\n"));
2978 }
2979 } else {
2980 /* No data to be sent back as reply */
2981 WL_ERR(("Vendor_cmd: No reply expected. data_len:%u cmd_buf %p \n",
2982 data_len, cmd_buf));
2983 }
2984 break;
2985 }
2986 #endif /* WL_ANDROID_PRIV_CMD_OVER_NL80211 && OEM_ANDROID */
2987 }
2988
2989 exit:
2990 #if defined(WL_ANDROID_PRIV_CMD_OVER_NL80211) && defined(OEM_ANDROID)
2991 if (cmd_buf) {
2992 MFREE(cfg->osh, cmd_buf, cmd_buf_len);
2993 }
2994 #endif /* WL_ANDROID_PRIV_CMD_OVER_NL80211 && OEM_ANDROID */
2995 net_os_wake_unlock(ndev);
2996 return err;
2997 }
2998 #endif /* BCM_PRIV_CMD_SUPPORT */
2999
3000 #ifdef WL_NAN
nan_attr_to_str(u16 cmd)3001 static const char *nan_attr_to_str(u16 cmd)
3002 {
3003 switch (cmd) {
3004 C2S(NAN_ATTRIBUTE_HEADER)
3005 C2S(NAN_ATTRIBUTE_HANDLE)
3006 C2S(NAN_ATTRIBUTE_TRANSAC_ID)
3007 C2S(NAN_ATTRIBUTE_2G_SUPPORT)
3008 C2S(NAN_ATTRIBUTE_SDF_2G_SUPPORT)
3009 C2S(NAN_ATTRIBUTE_SDF_5G_SUPPORT)
3010 C2S(NAN_ATTRIBUTE_5G_SUPPORT)
3011 C2S(NAN_ATTRIBUTE_SYNC_DISC_2G_BEACON)
3012 C2S(NAN_ATTRIBUTE_SYNC_DISC_5G_BEACON)
3013 C2S(NAN_ATTRIBUTE_CLUSTER_LOW)
3014 C2S(NAN_ATTRIBUTE_CLUSTER_HIGH)
3015 C2S(NAN_ATTRIBUTE_SID_BEACON)
3016 C2S(NAN_ATTRIBUTE_RSSI_CLOSE)
3017 C2S(NAN_ATTRIBUTE_RSSI_MIDDLE)
3018 C2S(NAN_ATTRIBUTE_RSSI_PROXIMITY)
3019 C2S(NAN_ATTRIBUTE_RSSI_CLOSE_5G)
3020 C2S(NAN_ATTRIBUTE_RSSI_MIDDLE_5G)
3021 C2S(NAN_ATTRIBUTE_RSSI_PROXIMITY_5G)
3022 C2S(NAN_ATTRIBUTE_HOP_COUNT_LIMIT)
3023 C2S(NAN_ATTRIBUTE_RANDOM_TIME)
3024 C2S(NAN_ATTRIBUTE_MASTER_PREF)
3025 C2S(NAN_ATTRIBUTE_PERIODIC_SCAN_INTERVAL)
3026 C2S(NAN_ATTRIBUTE_PUBLISH_ID)
3027 C2S(NAN_ATTRIBUTE_TTL)
3028 C2S(NAN_ATTRIBUTE_PERIOD)
3029 C2S(NAN_ATTRIBUTE_REPLIED_EVENT_FLAG)
3030 C2S(NAN_ATTRIBUTE_PUBLISH_TYPE)
3031 C2S(NAN_ATTRIBUTE_TX_TYPE)
3032 C2S(NAN_ATTRIBUTE_PUBLISH_COUNT)
3033 C2S(NAN_ATTRIBUTE_SERVICE_NAME_LEN)
3034 C2S(NAN_ATTRIBUTE_SERVICE_NAME)
3035 C2S(NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN)
3036 C2S(NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO)
3037 C2S(NAN_ATTRIBUTE_RX_MATCH_FILTER_LEN)
3038 C2S(NAN_ATTRIBUTE_RX_MATCH_FILTER)
3039 C2S(NAN_ATTRIBUTE_TX_MATCH_FILTER_LEN)
3040 C2S(NAN_ATTRIBUTE_TX_MATCH_FILTER)
3041 C2S(NAN_ATTRIBUTE_SUBSCRIBE_ID)
3042 C2S(NAN_ATTRIBUTE_SUBSCRIBE_TYPE)
3043 C2S(NAN_ATTRIBUTE_SERVICERESPONSEFILTER)
3044 C2S(NAN_ATTRIBUTE_SERVICERESPONSEINCLUDE)
3045 C2S(NAN_ATTRIBUTE_USESERVICERESPONSEFILTER)
3046 C2S(NAN_ATTRIBUTE_SSIREQUIREDFORMATCHINDICATION)
3047 C2S(NAN_ATTRIBUTE_SUBSCRIBE_MATCH)
3048 C2S(NAN_ATTRIBUTE_SUBSCRIBE_COUNT)
3049 C2S(NAN_ATTRIBUTE_MAC_ADDR)
3050 C2S(NAN_ATTRIBUTE_MAC_ADDR_LIST)
3051 C2S(NAN_ATTRIBUTE_MAC_ADDR_LIST_NUM_ENTRIES)
3052 C2S(NAN_ATTRIBUTE_PUBLISH_MATCH)
3053 C2S(NAN_ATTRIBUTE_ENABLE_STATUS)
3054 C2S(NAN_ATTRIBUTE_JOIN_STATUS)
3055 C2S(NAN_ATTRIBUTE_ROLE)
3056 C2S(NAN_ATTRIBUTE_MASTER_RANK)
3057 C2S(NAN_ATTRIBUTE_ANCHOR_MASTER_RANK)
3058 C2S(NAN_ATTRIBUTE_CNT_PEND_TXFRM)
3059 C2S(NAN_ATTRIBUTE_CNT_BCN_TX)
3060 C2S(NAN_ATTRIBUTE_CNT_BCN_RX)
3061 C2S(NAN_ATTRIBUTE_CNT_SVC_DISC_TX)
3062 C2S(NAN_ATTRIBUTE_CNT_SVC_DISC_RX)
3063 C2S(NAN_ATTRIBUTE_AMBTT)
3064 C2S(NAN_ATTRIBUTE_CLUSTER_ID)
3065 C2S(NAN_ATTRIBUTE_INST_ID)
3066 C2S(NAN_ATTRIBUTE_OUI)
3067 C2S(NAN_ATTRIBUTE_STATUS)
3068 C2S(NAN_ATTRIBUTE_DE_EVENT_TYPE)
3069 C2S(NAN_ATTRIBUTE_MERGE)
3070 C2S(NAN_ATTRIBUTE_IFACE)
3071 C2S(NAN_ATTRIBUTE_CHANNEL)
3072 C2S(NAN_ATTRIBUTE_24G_CHANNEL)
3073 C2S(NAN_ATTRIBUTE_5G_CHANNEL)
3074 C2S(NAN_ATTRIBUTE_PEER_ID)
3075 C2S(NAN_ATTRIBUTE_NDP_ID)
3076 C2S(NAN_ATTRIBUTE_SECURITY)
3077 C2S(NAN_ATTRIBUTE_QOS)
3078 C2S(NAN_ATTRIBUTE_RSP_CODE)
3079 C2S(NAN_ATTRIBUTE_INST_COUNT)
3080 C2S(NAN_ATTRIBUTE_PEER_DISC_MAC_ADDR)
3081 C2S(NAN_ATTRIBUTE_PEER_NDI_MAC_ADDR)
3082 C2S(NAN_ATTRIBUTE_IF_ADDR)
3083 C2S(NAN_ATTRIBUTE_WARMUP_TIME)
3084 C2S(NAN_ATTRIBUTE_RECV_IND_CFG)
3085 C2S(NAN_ATTRIBUTE_CONNMAP)
3086 C2S(NAN_ATTRIBUTE_DWELL_TIME)
3087 C2S(NAN_ATTRIBUTE_SCAN_PERIOD)
3088 C2S(NAN_ATTRIBUTE_RSSI_WINDOW_SIZE)
3089 C2S(NAN_ATTRIBUTE_CONF_CLUSTER_VAL)
3090 C2S(NAN_ATTRIBUTE_CIPHER_SUITE_TYPE)
3091 C2S(NAN_ATTRIBUTE_KEY_TYPE)
3092 C2S(NAN_ATTRIBUTE_KEY_LEN)
3093 C2S(NAN_ATTRIBUTE_SCID)
3094 C2S(NAN_ATTRIBUTE_SCID_LEN)
3095 C2S(NAN_ATTRIBUTE_SDE_CONTROL_CONFIG_DP)
3096 C2S(NAN_ATTRIBUTE_SDE_CONTROL_SECURITY)
3097 C2S(NAN_ATTRIBUTE_SDE_CONTROL_DP_TYPE)
3098 C2S(NAN_ATTRIBUTE_SDE_CONTROL_RANGE_SUPPORT)
3099 C2S(NAN_ATTRIBUTE_NO_CONFIG_AVAIL)
3100 C2S(NAN_ATTRIBUTE_2G_AWAKE_DW)
3101 C2S(NAN_ATTRIBUTE_5G_AWAKE_DW)
3102 C2S(NAN_ATTRIBUTE_RSSI_THRESHOLD_FLAG)
3103 C2S(NAN_ATTRIBUTE_KEY_DATA)
3104 C2S(NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO_LEN)
3105 C2S(NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO)
3106 C2S(NAN_ATTRIBUTE_REASON)
3107 C2S(NAN_ATTRIBUTE_DISC_IND_CFG)
3108 C2S(NAN_ATTRIBUTE_DWELL_TIME_5G)
3109 C2S(NAN_ATTRIBUTE_SCAN_PERIOD_5G)
3110 C2S(NAN_ATTRIBUTE_SUB_SID_BEACON)
3111 default:
3112 return "NAN_ATTRIBUTE_UNKNOWN";
3113 }
3114 }
3115
3116 nan_hal_status_t nan_status_reasonstr_map[] = {
3117 {NAN_STATUS_SUCCESS, "NAN status success"},
3118 {NAN_STATUS_INTERNAL_FAILURE, "NAN Discovery engine failure"},
3119 {NAN_STATUS_PROTOCOL_FAILURE, "protocol failure"},
3120 {NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID, "invalid pub_sub ID"},
3121 {NAN_STATUS_NO_RESOURCE_AVAILABLE, "No space available"},
3122 {NAN_STATUS_INVALID_PARAM, "invalid param"},
3123 {NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID, "invalid req inst id"},
3124 {NAN_STATUS_INVALID_NDP_ID, "invalid ndp id"},
3125 {NAN_STATUS_NAN_NOT_ALLOWED, "Nan not allowed"},
3126 {NAN_STATUS_NO_OTA_ACK, "No OTA ack"},
3127 {NAN_STATUS_ALREADY_ENABLED, "NAN is Already enabled"},
3128 {NAN_STATUS_FOLLOWUP_QUEUE_FULL, "Follow-up queue full"},
3129 {NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED, "unsupported concurrency"},
3130 };
3131
3132 void
wl_cfgvendor_add_nan_reason_str(nan_status_type_t status,nan_hal_resp_t * nan_req_resp)3133 wl_cfgvendor_add_nan_reason_str(nan_status_type_t status, nan_hal_resp_t *nan_req_resp)
3134 {
3135 int i = 0;
3136 int num = (int)(sizeof(nan_status_reasonstr_map)/sizeof(nan_status_reasonstr_map[0]));
3137 for (i = 0; i < num; i++) {
3138 if (nan_status_reasonstr_map[i].status == status) {
3139 strlcpy(nan_req_resp->nan_reason, nan_status_reasonstr_map[i].nan_reason,
3140 sizeof(nan_status_reasonstr_map[i].nan_reason));
3141 break;
3142 }
3143 }
3144 }
3145
3146 nan_status_type_t
wl_cfgvendor_brcm_to_nanhal_status(int32 vendor_status)3147 wl_cfgvendor_brcm_to_nanhal_status(int32 vendor_status)
3148 {
3149 nan_status_type_t hal_status;
3150 switch (vendor_status) {
3151 case BCME_OK:
3152 hal_status = NAN_STATUS_SUCCESS;
3153 break;
3154 case BCME_BUSY:
3155 case BCME_NOTREADY:
3156 hal_status = NAN_STATUS_NAN_NOT_ALLOWED;
3157 break;
3158 case BCME_BADLEN:
3159 case BCME_BADBAND:
3160 case BCME_UNSUPPORTED:
3161 case BCME_USAGE_ERROR:
3162 case BCME_BADARG:
3163 hal_status = NAN_STATUS_INVALID_PARAM;
3164 break;
3165 case BCME_NOMEM:
3166 case BCME_NORESOURCE:
3167 case WL_NAN_E_SVC_SUB_LIST_FULL:
3168 hal_status = NAN_STATUS_NO_RESOURCE_AVAILABLE;
3169 break;
3170 case WL_NAN_E_SD_TX_LIST_FULL:
3171 hal_status = NAN_STATUS_FOLLOWUP_QUEUE_FULL;
3172 break;
3173 case WL_NAN_E_BAD_INSTANCE:
3174 hal_status = NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID;
3175 break;
3176 default:
3177 WL_ERR(("%s Unknown vendor status, status = %d\n",
3178 __func__, vendor_status));
3179 /* Generic error */
3180 hal_status = NAN_STATUS_INTERNAL_FAILURE;
3181 }
3182 return hal_status;
3183 }
3184
3185 static int
wl_cfgvendor_nan_cmd_reply(struct wiphy * wiphy,int nan_cmd,nan_hal_resp_t * nan_req_resp,int ret,int nan_cmd_status)3186 wl_cfgvendor_nan_cmd_reply(struct wiphy *wiphy, int nan_cmd,
3187 nan_hal_resp_t *nan_req_resp, int ret, int nan_cmd_status)
3188 {
3189 int err;
3190 int nan_reply;
3191 nan_req_resp->subcmd = nan_cmd;
3192 if (ret == BCME_OK) {
3193 nan_reply = nan_cmd_status;
3194 } else {
3195 nan_reply = ret;
3196 }
3197 nan_req_resp->status = wl_cfgvendor_brcm_to_nanhal_status(nan_reply);
3198 nan_req_resp->value = ret;
3199 err = wl_cfgvendor_send_cmd_reply(wiphy, nan_req_resp,
3200 sizeof(*nan_req_resp));
3201 /* giving more prio to ret than err */
3202 return (ret == 0) ? err : ret;
3203 }
3204
3205 static void
wl_cfgvendor_free_disc_cmd_data(struct bcm_cfg80211 * cfg,nan_discover_cmd_data_t * cmd_data)3206 wl_cfgvendor_free_disc_cmd_data(struct bcm_cfg80211 *cfg,
3207 nan_discover_cmd_data_t *cmd_data)
3208 {
3209 if (!cmd_data) {
3210 WL_ERR(("Cmd_data is null\n"));
3211 return;
3212 }
3213 if (cmd_data->svc_info.data) {
3214 MFREE(cfg->osh, cmd_data->svc_info.data, cmd_data->svc_info.dlen);
3215 }
3216 if (cmd_data->svc_hash.data) {
3217 MFREE(cfg->osh, cmd_data->svc_hash.data, cmd_data->svc_hash.dlen);
3218 }
3219 if (cmd_data->rx_match.data) {
3220 MFREE(cfg->osh, cmd_data->rx_match.data, cmd_data->rx_match.dlen);
3221 }
3222 if (cmd_data->tx_match.data) {
3223 MFREE(cfg->osh, cmd_data->tx_match.data, cmd_data->tx_match.dlen);
3224 }
3225 if (cmd_data->mac_list.list) {
3226 MFREE(cfg->osh, cmd_data->mac_list.list,
3227 cmd_data->mac_list.num_mac_addr * ETHER_ADDR_LEN);
3228 }
3229 if (cmd_data->key.data) {
3230 MFREE(cfg->osh, cmd_data->key.data, NAN_MAX_PMK_LEN);
3231 }
3232 if (cmd_data->sde_svc_info.data) {
3233 MFREE(cfg->osh, cmd_data->sde_svc_info.data, cmd_data->sde_svc_info.dlen);
3234 }
3235 MFREE(cfg->osh, cmd_data, sizeof(*cmd_data));
3236 }
3237
3238 static void
wl_cfgvendor_free_dp_cmd_data(struct bcm_cfg80211 * cfg,nan_datapath_cmd_data_t * cmd_data)3239 wl_cfgvendor_free_dp_cmd_data(struct bcm_cfg80211 *cfg,
3240 nan_datapath_cmd_data_t *cmd_data)
3241 {
3242 if (!cmd_data) {
3243 WL_ERR(("Cmd_data is null\n"));
3244 return;
3245 }
3246 if (cmd_data->svc_hash.data) {
3247 MFREE(cfg->osh, cmd_data->svc_hash.data, cmd_data->svc_hash.dlen);
3248 }
3249 if (cmd_data->svc_info.data) {
3250 MFREE(cfg->osh, cmd_data->svc_info.data, cmd_data->svc_info.dlen);
3251 }
3252 if (cmd_data->key.data) {
3253 MFREE(cfg->osh, cmd_data->key.data, NAN_MAX_PMK_LEN);
3254 }
3255 MFREE(cfg->osh, cmd_data, sizeof(*cmd_data));
3256 }
3257
3258 #define WL_NAN_EVENT_MAX_BUF 256
3259 #ifdef WL_NAN_DISC_CACHE
3260 static int
wl_cfgvendor_nan_parse_dp_sec_info_args(struct wiphy * wiphy,const void * buf,int len,nan_datapath_sec_info_cmd_data_t * cmd_data)3261 wl_cfgvendor_nan_parse_dp_sec_info_args(struct wiphy *wiphy,
3262 const void *buf, int len, nan_datapath_sec_info_cmd_data_t *cmd_data)
3263 {
3264 int ret = BCME_OK;
3265 int attr_type;
3266 int rem = len;
3267 const struct nlattr *iter;
3268
3269 NAN_DBG_ENTER();
3270
3271 nla_for_each_attr(iter, buf, len, rem) {
3272 attr_type = nla_type(iter);
3273 WL_TRACE(("attr: %s (%u)\n", nan_attr_to_str(attr_type), attr_type));
3274
3275 switch (attr_type) {
3276 case NAN_ATTRIBUTE_MAC_ADDR:
3277 ret = memcpy_s((char*)&cmd_data->mac_addr, ETHER_ADDR_LEN,
3278 (char*)nla_data(iter), nla_len(iter));
3279 if (ret != BCME_OK) {
3280 WL_ERR(("Failed to copy mac addr\n"));
3281 return ret;
3282 }
3283 break;
3284 case NAN_ATTRIBUTE_PUBLISH_ID:
3285 cmd_data->pub_id = nla_get_u16(iter);
3286 break;
3287 case NAN_ATTRIBUTE_NDP_ID:
3288 cmd_data->ndp_instance_id = nla_get_u32(iter);
3289 break;
3290 default:
3291 WL_ERR(("%s: Unknown type, %d\n", __FUNCTION__, attr_type));
3292 ret = BCME_BADARG;
3293 break;
3294 }
3295 }
3296 /* We need to call set_config_handler b/f calling start enable TBD */
3297 NAN_DBG_EXIT();
3298 return ret;
3299 }
3300 #endif /* WL_NAN_DISC_CACHE */
3301
3302 int8 chanbuf[CHANSPEC_STR_LEN];
3303 static int
wl_cfgvendor_nan_parse_datapath_args(struct wiphy * wiphy,const void * buf,int len,nan_datapath_cmd_data_t * cmd_data)3304 wl_cfgvendor_nan_parse_datapath_args(struct wiphy *wiphy,
3305 const void *buf, int len, nan_datapath_cmd_data_t *cmd_data)
3306 {
3307 int ret = BCME_OK;
3308 int attr_type;
3309 int rem = len;
3310 const struct nlattr *iter;
3311 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
3312 int chan;
3313
3314 NAN_DBG_ENTER();
3315
3316 nla_for_each_attr(iter, buf, len, rem) {
3317 attr_type = nla_type(iter);
3318 WL_TRACE(("attr: %s (%u)\n", nan_attr_to_str(attr_type), attr_type));
3319
3320 switch (attr_type) {
3321 case NAN_ATTRIBUTE_NDP_ID:
3322 if (nla_len(iter) != sizeof(uint32)) {
3323 ret = -EINVAL;
3324 goto exit;
3325 }
3326 cmd_data->ndp_instance_id = nla_get_u32(iter);
3327 break;
3328 case NAN_ATTRIBUTE_IFACE:
3329 if (nla_len(iter) >= sizeof(cmd_data->ndp_iface)) {
3330 WL_ERR(("iface_name len wrong:%d\n", nla_len(iter)));
3331 ret = -EINVAL;
3332 goto exit;
3333 }
3334 strlcpy((char *)cmd_data->ndp_iface, (char *)nla_data(iter),
3335 nla_len(iter));
3336 break;
3337 case NAN_ATTRIBUTE_SECURITY:
3338 if (nla_len(iter) != sizeof(uint8)) {
3339 ret = -EINVAL;
3340 goto exit;
3341 }
3342 cmd_data->ndp_cfg.security_cfg = nla_get_u8(iter);
3343 break;
3344 case NAN_ATTRIBUTE_QOS:
3345 if (nla_len(iter) != sizeof(uint8)) {
3346 ret = -EINVAL;
3347 goto exit;
3348 }
3349 cmd_data->ndp_cfg.qos_cfg = nla_get_u8(iter);
3350 break;
3351 case NAN_ATTRIBUTE_RSP_CODE:
3352 if (nla_len(iter) != sizeof(uint8)) {
3353 ret = -EINVAL;
3354 goto exit;
3355 }
3356 cmd_data->rsp_code = nla_get_u8(iter);
3357 break;
3358 case NAN_ATTRIBUTE_INST_COUNT:
3359 if (nla_len(iter) != sizeof(uint8)) {
3360 ret = -EINVAL;
3361 goto exit;
3362 }
3363 cmd_data->num_ndp_instances = nla_get_u8(iter);
3364 break;
3365 case NAN_ATTRIBUTE_PEER_DISC_MAC_ADDR:
3366 if (nla_len(iter) != ETHER_ADDR_LEN) {
3367 ret = -EINVAL;
3368 goto exit;
3369 }
3370 ret = memcpy_s((char*)&cmd_data->peer_disc_mac_addr,
3371 ETHER_ADDR_LEN, (char*)nla_data(iter), nla_len(iter));
3372 if (ret != BCME_OK) {
3373 WL_ERR(("Failed to copy peer_disc_mac_addr\n"));
3374 goto exit;
3375 }
3376 break;
3377 case NAN_ATTRIBUTE_PEER_NDI_MAC_ADDR:
3378 if (nla_len(iter) != ETHER_ADDR_LEN) {
3379 ret = -EINVAL;
3380 goto exit;
3381 }
3382 ret = memcpy_s((char*)&cmd_data->peer_ndi_mac_addr,
3383 ETHER_ADDR_LEN, (char*)nla_data(iter), nla_len(iter));
3384 if (ret != BCME_OK) {
3385 WL_ERR(("Failed to copy peer_ndi_mac_addr\n"));
3386 goto exit;
3387 }
3388 break;
3389 case NAN_ATTRIBUTE_MAC_ADDR:
3390 if (nla_len(iter) != ETHER_ADDR_LEN) {
3391 ret = -EINVAL;
3392 goto exit;
3393 }
3394 ret = memcpy_s((char*)&cmd_data->mac_addr, ETHER_ADDR_LEN,
3395 (char*)nla_data(iter), nla_len(iter));
3396 if (ret != BCME_OK) {
3397 WL_ERR(("Failed to copy mac_addr\n"));
3398 goto exit;
3399 }
3400 break;
3401 case NAN_ATTRIBUTE_IF_ADDR:
3402 if (nla_len(iter) != ETHER_ADDR_LEN) {
3403 ret = -EINVAL;
3404 goto exit;
3405 }
3406 ret = memcpy_s((char*)&cmd_data->if_addr, ETHER_ADDR_LEN,
3407 (char*)nla_data(iter), nla_len(iter));
3408 if (ret != BCME_OK) {
3409 WL_ERR(("Failed to copy if_addr\n"));
3410 goto exit;
3411 }
3412 break;
3413 case NAN_ATTRIBUTE_ENTRY_CONTROL:
3414 if (nla_len(iter) != sizeof(uint8)) {
3415 ret = -EINVAL;
3416 goto exit;
3417 }
3418 cmd_data->avail_params.duration = nla_get_u8(iter);
3419 break;
3420 case NAN_ATTRIBUTE_AVAIL_BIT_MAP:
3421 if (nla_len(iter) != sizeof(uint32)) {
3422 ret = -EINVAL;
3423 goto exit;
3424 }
3425 cmd_data->avail_params.bmap = nla_get_u32(iter);
3426 break;
3427 case NAN_ATTRIBUTE_CHANNEL: {
3428 if (nla_len(iter) != sizeof(uint32)) {
3429 ret = -EINVAL;
3430 goto exit;
3431 }
3432 /* take the default channel start_factor frequency */
3433 chan = wf_mhz2channel((uint)nla_get_u32(iter), 0);
3434 if (chan <= CH_MAX_2G_CHANNEL) {
3435 cmd_data->avail_params.chanspec[0] =
3436 wf_channel2chspec(chan, WL_CHANSPEC_BW_20);
3437 } else {
3438 cmd_data->avail_params.chanspec[0] =
3439 wf_channel2chspec(chan, WL_CHANSPEC_BW_80);
3440 }
3441 if (cmd_data->avail_params.chanspec[0] == 0) {
3442 WL_ERR(("Channel is not valid \n"));
3443 ret = -EINVAL;
3444 goto exit;
3445 }
3446 WL_TRACE(("valid chanspec, chanspec = 0x%04x \n",
3447 cmd_data->avail_params.chanspec[0]));
3448 break;
3449 }
3450 case NAN_ATTRIBUTE_NO_CONFIG_AVAIL:
3451 if (nla_len(iter) != sizeof(uint8)) {
3452 ret = -EINVAL;
3453 goto exit;
3454 }
3455 cmd_data->avail_params.no_config_avail = (bool)nla_get_u8(iter);
3456 break;
3457 case NAN_ATTRIBUTE_SERVICE_NAME_LEN: {
3458 if (nla_len(iter) != sizeof(uint16)) {
3459 ret = -EINVAL;
3460 goto exit;
3461 }
3462 if (cmd_data->svc_hash.dlen) {
3463 WL_ERR(("trying to overwrite:%d\n", attr_type));
3464 ret = -EINVAL;
3465 goto exit;
3466 }
3467 cmd_data->svc_hash.dlen = nla_get_u16(iter);
3468 if (cmd_data->svc_hash.dlen != WL_NAN_SVC_HASH_LEN) {
3469 WL_ERR(("invalid svc_hash length = %u\n", cmd_data->svc_hash.dlen));
3470 ret = -EINVAL;
3471 goto exit;
3472 }
3473 break;
3474 }
3475 case NAN_ATTRIBUTE_SERVICE_NAME:
3476 if ((!cmd_data->svc_hash.dlen) ||
3477 (nla_len(iter) != cmd_data->svc_hash.dlen)) {
3478 WL_ERR(("invalid svc_hash length = %d,%d\n",
3479 cmd_data->svc_hash.dlen, nla_len(iter)));
3480 ret = -EINVAL;
3481 goto exit;
3482 }
3483 if (cmd_data->svc_hash.data) {
3484 WL_ERR(("trying to overwrite:%d\n", attr_type));
3485 ret = -EINVAL;
3486 goto exit;
3487 }
3488 cmd_data->svc_hash.data =
3489 MALLOCZ(cfg->osh, cmd_data->svc_hash.dlen);
3490 if (!cmd_data->svc_hash.data) {
3491 WL_ERR(("failed to allocate svc_hash data, len=%d\n",
3492 cmd_data->svc_hash.dlen));
3493 ret = -ENOMEM;
3494 goto exit;
3495 }
3496 ret = memcpy_s(cmd_data->svc_hash.data, cmd_data->svc_hash.dlen,
3497 nla_data(iter), nla_len(iter));
3498 if (ret != BCME_OK) {
3499 WL_ERR(("Failed to copy svc hash data\n"));
3500 goto exit;
3501 }
3502 break;
3503 case NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN:
3504 if (nla_len(iter) != sizeof(uint16)) {
3505 ret = -EINVAL;
3506 goto exit;
3507 }
3508 if (cmd_data->svc_info.dlen) {
3509 WL_ERR(("trying to overwrite:%d\n", attr_type));
3510 ret = -EINVAL;
3511 goto exit;
3512 }
3513 cmd_data->svc_info.dlen = nla_get_u16(iter);
3514 if (cmd_data->svc_info.dlen > MAX_APP_INFO_LEN) {
3515 WL_ERR_RLMT(("Not allowed beyond :%d\n", MAX_APP_INFO_LEN));
3516 ret = -EINVAL;
3517 goto exit;
3518 }
3519 break;
3520 case NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO:
3521 if ((!cmd_data->svc_info.dlen) ||
3522 (nla_len(iter) != cmd_data->svc_info.dlen)) {
3523 WL_ERR(("failed to allocate svc info by invalid len=%d,%d\n",
3524 cmd_data->svc_info.dlen, nla_len(iter)));
3525 ret = -EINVAL;
3526 goto exit;
3527 }
3528 if (cmd_data->svc_info.data) {
3529 WL_ERR(("trying to overwrite:%d\n", attr_type));
3530 ret = -EINVAL;
3531 goto exit;
3532 }
3533 cmd_data->svc_info.data = MALLOCZ(cfg->osh, cmd_data->svc_info.dlen);
3534 if (cmd_data->svc_info.data == NULL) {
3535 WL_ERR(("failed to allocate svc info data, len=%d\n",
3536 cmd_data->svc_info.dlen));
3537 ret = -ENOMEM;
3538 goto exit;
3539 }
3540 ret = memcpy_s(cmd_data->svc_info.data, cmd_data->svc_info.dlen,
3541 nla_data(iter), nla_len(iter));
3542 if (ret != BCME_OK) {
3543 WL_ERR(("Failed to copy svc info\n"));
3544 goto exit;
3545 }
3546 break;
3547 case NAN_ATTRIBUTE_PUBLISH_ID:
3548 if (nla_len(iter) != sizeof(uint32)) {
3549 ret = -EINVAL;
3550 goto exit;
3551 }
3552 cmd_data->pub_id = nla_get_u32(iter);
3553 break;
3554 case NAN_ATTRIBUTE_CIPHER_SUITE_TYPE:
3555 if (nla_len(iter) != sizeof(uint8)) {
3556 ret = -EINVAL;
3557 goto exit;
3558 }
3559 cmd_data->csid = nla_get_u8(iter);
3560 WL_TRACE(("CSID = %u\n", cmd_data->csid));
3561 break;
3562 case NAN_ATTRIBUTE_KEY_TYPE:
3563 if (nla_len(iter) != sizeof(uint8)) {
3564 ret = -EINVAL;
3565 goto exit;
3566 }
3567 cmd_data->key_type = nla_get_u8(iter);
3568 WL_TRACE(("Key Type = %u\n", cmd_data->key_type));
3569 break;
3570 case NAN_ATTRIBUTE_KEY_LEN:
3571 if (nla_len(iter) != sizeof(uint32)) {
3572 ret = -EINVAL;
3573 goto exit;
3574 }
3575 if (cmd_data->key.dlen) {
3576 WL_ERR(("trying to overwrite:%d\n", attr_type));
3577 ret = -EINVAL;
3578 goto exit;
3579 }
3580 cmd_data->key.dlen = nla_get_u32(iter);
3581 if ((!cmd_data->key.dlen) || (cmd_data->key.dlen > WL_NAN_NCS_SK_PMK_LEN)) {
3582 WL_ERR(("invalid key length = %u\n", cmd_data->key.dlen));
3583 ret = -EINVAL;
3584 goto exit;
3585 }
3586 WL_TRACE(("valid key length = %u\n", cmd_data->key.dlen));
3587 break;
3588 case NAN_ATTRIBUTE_KEY_DATA:
3589 if ((!cmd_data->key.dlen) ||
3590 (nla_len(iter) != cmd_data->key.dlen)) {
3591 WL_ERR(("failed to allocate key data by invalid len=%d,%d\n",
3592 cmd_data->key.dlen, nla_len(iter)));
3593 ret = -EINVAL;
3594 goto exit;
3595 }
3596 if (cmd_data->key.data) {
3597 WL_ERR(("trying to overwrite key data.\n"));
3598 ret = -EINVAL;
3599 goto exit;
3600 }
3601
3602 cmd_data->key.data = MALLOCZ(cfg->osh, NAN_MAX_PMK_LEN);
3603 if (cmd_data->key.data == NULL) {
3604 WL_ERR(("failed to allocate key data, len=%d\n",
3605 cmd_data->key.dlen));
3606 ret = -ENOMEM;
3607 goto exit;
3608 }
3609 ret = memcpy_s(cmd_data->key.data, NAN_MAX_PMK_LEN,
3610 nla_data(iter), nla_len(iter));
3611 if (ret != BCME_OK) {
3612 WL_ERR(("Failed to key data\n"));
3613 goto exit;
3614 }
3615 break;
3616
3617 default:
3618 WL_ERR(("Unknown type, %d\n", attr_type));
3619 ret = -EINVAL;
3620 goto exit;
3621 }
3622 }
3623 exit:
3624 /* We need to call set_config_handler b/f calling start enable TBD */
3625 NAN_DBG_EXIT();
3626 return ret;
3627 }
3628
3629 static int
wl_cfgvendor_nan_parse_discover_args(struct wiphy * wiphy,const void * buf,int len,nan_discover_cmd_data_t * cmd_data)3630 wl_cfgvendor_nan_parse_discover_args(struct wiphy *wiphy,
3631 const void *buf, int len, nan_discover_cmd_data_t *cmd_data)
3632 {
3633 int ret = BCME_OK;
3634 int attr_type;
3635 int rem = len;
3636 const struct nlattr *iter;
3637 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
3638 u8 val_u8;
3639 u32 bit_flag;
3640 u8 flag_match;
3641
3642 NAN_DBG_ENTER();
3643
3644 nla_for_each_attr(iter, buf, len, rem) {
3645 attr_type = nla_type(iter);
3646 WL_TRACE(("attr: %s (%u)\n", nan_attr_to_str(attr_type), attr_type));
3647
3648 switch (attr_type) {
3649 case NAN_ATTRIBUTE_TRANSAC_ID:
3650 if (nla_len(iter) != sizeof(uint16)) {
3651 ret = -EINVAL;
3652 goto exit;
3653 }
3654 cmd_data->token = nla_get_u16(iter);
3655 break;
3656 case NAN_ATTRIBUTE_PERIODIC_SCAN_INTERVAL:
3657 break;
3658
3659 /* Nan Publish/Subscribe request Attributes */
3660 case NAN_ATTRIBUTE_PUBLISH_ID:
3661 if (nla_len(iter) != sizeof(uint16)) {
3662 ret = -EINVAL;
3663 goto exit;
3664 }
3665 cmd_data->pub_id = nla_get_u16(iter);
3666 cmd_data->local_id = cmd_data->pub_id;
3667 break;
3668 case NAN_ATTRIBUTE_MAC_ADDR:
3669 if (nla_len(iter) != ETHER_ADDR_LEN) {
3670 ret = -EINVAL;
3671 goto exit;
3672 }
3673 ret = memcpy_s((char*)&cmd_data->mac_addr, ETHER_ADDR_LEN,
3674 (char*)nla_data(iter), nla_len(iter));
3675 if (ret != BCME_OK) {
3676 WL_ERR(("Failed to copy mac addr\n"));
3677 return ret;
3678 }
3679 break;
3680 case NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN:
3681 if (nla_len(iter) != sizeof(uint16)) {
3682 ret = -EINVAL;
3683 goto exit;
3684 }
3685 if (cmd_data->svc_info.dlen) {
3686 WL_ERR(("trying to overwrite:%d\n", attr_type));
3687 ret = -EINVAL;
3688 goto exit;
3689 }
3690 cmd_data->svc_info.dlen = nla_get_u16(iter);
3691 if (cmd_data->svc_info.dlen > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
3692 WL_ERR_RLMT(("Not allowed beyond :%d\n",
3693 NAN_MAX_SERVICE_SPECIFIC_INFO_LEN));
3694 ret = -EINVAL;
3695 goto exit;
3696 }
3697 break;
3698 case NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO:
3699 if ((!cmd_data->svc_info.dlen) ||
3700 (nla_len(iter) != cmd_data->svc_info.dlen)) {
3701 WL_ERR(("failed to allocate svc info by invalid len=%d,%d\n",
3702 cmd_data->svc_info.dlen, nla_len(iter)));
3703 ret = -EINVAL;
3704 goto exit;
3705 }
3706 if (cmd_data->svc_info.data) {
3707 WL_ERR(("trying to overwrite:%d\n", attr_type));
3708 ret = -EINVAL;
3709 goto exit;
3710 }
3711
3712 cmd_data->svc_info.data = MALLOCZ(cfg->osh, cmd_data->svc_info.dlen);
3713 if (cmd_data->svc_info.data == NULL) {
3714 WL_ERR(("failed to allocate svc info data, len=%d\n",
3715 cmd_data->svc_info.dlen));
3716 ret = -ENOMEM;
3717 goto exit;
3718 }
3719 ret = memcpy_s(cmd_data->svc_info.data, cmd_data->svc_info.dlen,
3720 nla_data(iter), nla_len(iter));
3721 if (ret != BCME_OK) {
3722 WL_ERR(("Failed to copy svc info\n"));
3723 return ret;
3724 }
3725 break;
3726 case NAN_ATTRIBUTE_SUBSCRIBE_ID:
3727 if (nla_len(iter) != sizeof(uint16)) {
3728 ret = -EINVAL;
3729 goto exit;
3730 }
3731 cmd_data->sub_id = nla_get_u16(iter);
3732 cmd_data->local_id = cmd_data->sub_id;
3733 break;
3734 case NAN_ATTRIBUTE_SUBSCRIBE_TYPE:
3735 if (nla_len(iter) != sizeof(uint8)) {
3736 ret = -EINVAL;
3737 goto exit;
3738 }
3739 cmd_data->flags |= nla_get_u8(iter) ? WL_NAN_SUB_ACTIVE : 0;
3740 break;
3741 case NAN_ATTRIBUTE_PUBLISH_COUNT:
3742 if (nla_len(iter) != sizeof(uint8)) {
3743 ret = -EINVAL;
3744 goto exit;
3745 }
3746 cmd_data->life_count = nla_get_u8(iter);
3747 break;
3748 case NAN_ATTRIBUTE_PUBLISH_TYPE: {
3749 if (nla_len(iter) != sizeof(uint8)) {
3750 ret = -EINVAL;
3751 goto exit;
3752 }
3753 val_u8 = nla_get_u8(iter);
3754 if (val_u8 == 0) {
3755 cmd_data->flags |= WL_NAN_PUB_UNSOLICIT;
3756 } else if (val_u8 == 1) {
3757 cmd_data->flags |= WL_NAN_PUB_SOLICIT;
3758 } else {
3759 cmd_data->flags |= WL_NAN_PUB_BOTH;
3760 }
3761 break;
3762 }
3763 case NAN_ATTRIBUTE_PERIOD: {
3764 if (nla_len(iter) != sizeof(uint16)) {
3765 ret = -EINVAL;
3766 goto exit;
3767 }
3768 if (nla_get_u16(iter) > NAN_MAX_AWAKE_DW_INTERVAL) {
3769 WL_ERR(("Invalid/Out of bound value = %u\n", nla_get_u16(iter)));
3770 ret = BCME_BADARG;
3771 break;
3772 }
3773 if (nla_get_u16(iter)) {
3774 cmd_data->period = 1 << (nla_get_u16(iter)-1);
3775 }
3776 break;
3777 }
3778 case NAN_ATTRIBUTE_REPLIED_EVENT_FLAG:
3779 break;
3780 case NAN_ATTRIBUTE_TTL:
3781 if (nla_len(iter) != sizeof(uint16)) {
3782 ret = -EINVAL;
3783 goto exit;
3784 }
3785 cmd_data->ttl = nla_get_u16(iter);
3786 break;
3787 case NAN_ATTRIBUTE_SERVICE_NAME_LEN: {
3788 if (nla_len(iter) != sizeof(uint16)) {
3789 ret = -EINVAL;
3790 goto exit;
3791 }
3792 if (cmd_data->svc_hash.dlen) {
3793 WL_ERR(("trying to overwrite:%d\n", attr_type));
3794 ret = -EINVAL;
3795 goto exit;
3796 }
3797
3798 cmd_data->svc_hash.dlen = nla_get_u16(iter);
3799 if (cmd_data->svc_hash.dlen != WL_NAN_SVC_HASH_LEN) {
3800 WL_ERR(("invalid svc_hash length = %u\n", cmd_data->svc_hash.dlen));
3801 ret = -EINVAL;
3802 goto exit;
3803 }
3804 break;
3805 }
3806 case NAN_ATTRIBUTE_SERVICE_NAME:
3807 if ((!cmd_data->svc_hash.dlen) ||
3808 (nla_len(iter) != cmd_data->svc_hash.dlen)) {
3809 WL_ERR(("invalid svc_hash length = %d,%d\n",
3810 cmd_data->svc_hash.dlen, nla_len(iter)));
3811 ret = -EINVAL;
3812 goto exit;
3813 }
3814 if (cmd_data->svc_hash.data) {
3815 WL_ERR(("trying to overwrite:%d\n", attr_type));
3816 ret = -EINVAL;
3817 goto exit;
3818 }
3819
3820 cmd_data->svc_hash.data =
3821 MALLOCZ(cfg->osh, cmd_data->svc_hash.dlen);
3822 if (!cmd_data->svc_hash.data) {
3823 WL_ERR(("failed to allocate svc_hash data, len=%d\n",
3824 cmd_data->svc_hash.dlen));
3825 ret = -ENOMEM;
3826 goto exit;
3827 }
3828 ret = memcpy_s(cmd_data->svc_hash.data, cmd_data->svc_hash.dlen,
3829 nla_data(iter), nla_len(iter));
3830 if (ret != BCME_OK) {
3831 WL_ERR(("Failed to copy svc hash data\n"));
3832 return ret;
3833 }
3834 break;
3835 case NAN_ATTRIBUTE_PEER_ID:
3836 if (nla_len(iter) != sizeof(uint32)) {
3837 ret = -EINVAL;
3838 goto exit;
3839 }
3840 cmd_data->remote_id = nla_get_u32(iter);
3841 break;
3842 case NAN_ATTRIBUTE_INST_ID:
3843 if (nla_len(iter) != sizeof(uint16)) {
3844 ret = -EINVAL;
3845 goto exit;
3846 }
3847 cmd_data->local_id = nla_get_u16(iter);
3848 break;
3849 case NAN_ATTRIBUTE_SUBSCRIBE_COUNT:
3850 if (nla_len(iter) != sizeof(uint8)) {
3851 ret = -EINVAL;
3852 goto exit;
3853 }
3854 cmd_data->life_count = nla_get_u8(iter);
3855 break;
3856 case NAN_ATTRIBUTE_SSIREQUIREDFORMATCHINDICATION: {
3857 if (nla_len(iter) != sizeof(uint8)) {
3858 ret = -EINVAL;
3859 goto exit;
3860 }
3861 bit_flag = (u32)nla_get_u8(iter);
3862 cmd_data->flags |=
3863 bit_flag ? WL_NAN_SUB_MATCH_IF_SVC_INFO : 0;
3864 break;
3865 }
3866 case NAN_ATTRIBUTE_SUBSCRIBE_MATCH:
3867 case NAN_ATTRIBUTE_PUBLISH_MATCH: {
3868 if (nla_len(iter) != sizeof(uint8)) {
3869 ret = -EINVAL;
3870 goto exit;
3871 }
3872 flag_match = nla_get_u8(iter);
3873
3874 switch (flag_match) {
3875 case NAN_MATCH_ALG_MATCH_CONTINUOUS:
3876 /* Default fw behaviour, no need to set explicitly */
3877 break;
3878 case NAN_MATCH_ALG_MATCH_ONCE:
3879 cmd_data->flags |= WL_NAN_MATCH_ONCE;
3880 break;
3881 case NAN_MATCH_ALG_MATCH_NEVER:
3882 cmd_data->flags |= WL_NAN_MATCH_NEVER;
3883 break;
3884 default:
3885 WL_ERR(("invalid nan match alg = %u\n", flag_match));
3886 ret = -EINVAL;
3887 goto exit;
3888 }
3889 break;
3890 }
3891 case NAN_ATTRIBUTE_SERVICERESPONSEFILTER:
3892 if (nla_len(iter) != sizeof(uint8)) {
3893 ret = -EINVAL;
3894 goto exit;
3895 }
3896 cmd_data->srf_type = nla_get_u8(iter);
3897 break;
3898 case NAN_ATTRIBUTE_SERVICERESPONSEINCLUDE:
3899 if (nla_len(iter) != sizeof(uint8)) {
3900 ret = -EINVAL;
3901 goto exit;
3902 }
3903 cmd_data->srf_include = nla_get_u8(iter);
3904 break;
3905 case NAN_ATTRIBUTE_USESERVICERESPONSEFILTER:
3906 if (nla_len(iter) != sizeof(uint8)) {
3907 ret = -EINVAL;
3908 goto exit;
3909 }
3910 cmd_data->use_srf = nla_get_u8(iter);
3911 break;
3912 case NAN_ATTRIBUTE_RX_MATCH_FILTER_LEN:
3913 if (nla_len(iter) != sizeof(uint16)) {
3914 ret = -EINVAL;
3915 goto exit;
3916 }
3917 if (cmd_data->rx_match.dlen) {
3918 WL_ERR(("trying to overwrite:%d\n", attr_type));
3919 ret = -EINVAL;
3920 goto exit;
3921 }
3922 cmd_data->rx_match.dlen = nla_get_u16(iter);
3923 if (cmd_data->rx_match.dlen > MAX_MATCH_FILTER_LEN) {
3924 ret = -EINVAL;
3925 WL_ERR_RLMT(("Not allowed beyond %d\n", MAX_MATCH_FILTER_LEN));
3926 goto exit;
3927 }
3928 break;
3929 case NAN_ATTRIBUTE_RX_MATCH_FILTER:
3930 if ((!cmd_data->rx_match.dlen) ||
3931 (nla_len(iter) != cmd_data->rx_match.dlen)) {
3932 WL_ERR(("RX match filter len wrong:%d,%d\n",
3933 cmd_data->rx_match.dlen, nla_len(iter)));
3934 ret = -EINVAL;
3935 goto exit;
3936 }
3937 if (cmd_data->rx_match.data) {
3938 WL_ERR(("trying to overwrite:%d\n", attr_type));
3939 ret = -EINVAL;
3940 goto exit;
3941 }
3942 cmd_data->rx_match.data =
3943 MALLOCZ(cfg->osh, cmd_data->rx_match.dlen);
3944 if (cmd_data->rx_match.data == NULL) {
3945 WL_ERR(("failed to allocate LEN=[%u]\n",
3946 cmd_data->rx_match.dlen));
3947 ret = -ENOMEM;
3948 goto exit;
3949 }
3950 ret = memcpy_s(cmd_data->rx_match.data, cmd_data->rx_match.dlen,
3951 nla_data(iter), nla_len(iter));
3952 if (ret != BCME_OK) {
3953 WL_ERR(("Failed to copy rx match data\n"));
3954 return ret;
3955 }
3956 break;
3957 case NAN_ATTRIBUTE_TX_MATCH_FILTER_LEN:
3958 if (nla_len(iter) != sizeof(uint16)) {
3959 ret = -EINVAL;
3960 goto exit;
3961 }
3962 if (cmd_data->tx_match.dlen) {
3963 WL_ERR(("trying to overwrite:%d\n", attr_type));
3964 ret = -EINVAL;
3965 goto exit;
3966 }
3967 cmd_data->tx_match.dlen = nla_get_u16(iter);
3968 if (cmd_data->tx_match.dlen > MAX_MATCH_FILTER_LEN) {
3969 ret = -EINVAL;
3970 WL_ERR_RLMT(("Not allowed beyond %d\n", MAX_MATCH_FILTER_LEN));
3971 goto exit;
3972 }
3973 break;
3974 case NAN_ATTRIBUTE_TX_MATCH_FILTER:
3975 if ((!cmd_data->tx_match.dlen) ||
3976 (nla_len(iter) != cmd_data->tx_match.dlen)) {
3977 WL_ERR(("TX match filter len wrong:%d,%d\n",
3978 cmd_data->tx_match.dlen, nla_len(iter)));
3979 ret = -EINVAL;
3980 goto exit;
3981 }
3982 if (cmd_data->tx_match.data) {
3983 WL_ERR(("trying to overwrite:%d\n", attr_type));
3984 ret = -EINVAL;
3985 goto exit;
3986 }
3987 cmd_data->tx_match.data =
3988 MALLOCZ(cfg->osh, cmd_data->tx_match.dlen);
3989 if (cmd_data->tx_match.data == NULL) {
3990 WL_ERR(("failed to allocate LEN=[%u]\n",
3991 cmd_data->tx_match.dlen));
3992 ret = -EINVAL;
3993 goto exit;
3994 }
3995 ret = memcpy_s(cmd_data->tx_match.data, cmd_data->tx_match.dlen,
3996 nla_data(iter), nla_len(iter));
3997 if (ret != BCME_OK) {
3998 WL_ERR(("Failed to copy tx match data\n"));
3999 return ret;
4000 }
4001 break;
4002 case NAN_ATTRIBUTE_MAC_ADDR_LIST_NUM_ENTRIES:
4003 if (nla_len(iter) != sizeof(uint16)) {
4004 ret = -EINVAL;
4005 goto exit;
4006 }
4007 if (cmd_data->mac_list.num_mac_addr) {
4008 WL_ERR(("trying to overwrite:%d\n", attr_type));
4009 ret = -EINVAL;
4010 goto exit;
4011 }
4012 cmd_data->mac_list.num_mac_addr = nla_get_u16(iter);
4013 break;
4014 case NAN_ATTRIBUTE_MAC_ADDR_LIST:
4015 if ((!cmd_data->mac_list.num_mac_addr) ||
4016 (nla_len(iter) != (cmd_data->mac_list.num_mac_addr * ETHER_ADDR_LEN))) {
4017 WL_ERR(("wrong mac list len:%d,%d\n",
4018 cmd_data->mac_list.num_mac_addr, nla_len(iter)));
4019 ret = -EINVAL;
4020 goto exit;
4021 }
4022 if (cmd_data->mac_list.list) {
4023 WL_ERR(("trying to overwrite:%d\n", attr_type));
4024 ret = -EINVAL;
4025 goto exit;
4026 }
4027 cmd_data->mac_list.list =
4028 MALLOCZ(cfg->osh, (cmd_data->mac_list.num_mac_addr
4029 * ETHER_ADDR_LEN));
4030 if (cmd_data->mac_list.list == NULL) {
4031 WL_ERR(("failed to allocate LEN=[%u]\n",
4032 (cmd_data->mac_list.num_mac_addr * ETHER_ADDR_LEN)));
4033 ret = -ENOMEM;
4034 goto exit;
4035 }
4036 ret = memcpy_s(cmd_data->mac_list.list,
4037 (cmd_data->mac_list.num_mac_addr * ETHER_ADDR_LEN),
4038 nla_data(iter), nla_len(iter));
4039 if (ret != BCME_OK) {
4040 WL_ERR(("Failed to copy list of mac addresses\n"));
4041 return ret;
4042 }
4043 break;
4044 case NAN_ATTRIBUTE_TX_TYPE:
4045 if (nla_len(iter) != sizeof(uint8)) {
4046 ret = -EINVAL;
4047 goto exit;
4048 }
4049 val_u8 = nla_get_u8(iter);
4050 if (val_u8 == 0) {
4051 cmd_data->flags |= WL_NAN_PUB_BCAST;
4052 WL_TRACE(("NAN_ATTRIBUTE_TX_TYPE: flags=NAN_PUB_BCAST\n"));
4053 }
4054 break;
4055 case NAN_ATTRIBUTE_SDE_CONTROL_CONFIG_DP:
4056 if (nla_len(iter) != sizeof(uint8)) {
4057 ret = -EINVAL;
4058 goto exit;
4059 }
4060 if (nla_get_u8(iter) == 1) {
4061 cmd_data->sde_control_flag
4062 |= NAN_SDE_CF_DP_REQUIRED;
4063 break;
4064 }
4065 break;
4066 case NAN_ATTRIBUTE_SDE_CONTROL_RANGE_SUPPORT:
4067 if (nla_len(iter) != sizeof(uint8)) {
4068 ret = -EINVAL;
4069 goto exit;
4070 }
4071 cmd_data->sde_control_config = TRUE;
4072 if (nla_get_u8(iter) == 1) {
4073 cmd_data->sde_control_flag
4074 |= NAN_SDE_CF_RANGING_REQUIRED;
4075 break;
4076 }
4077 break;
4078 case NAN_ATTRIBUTE_SDE_CONTROL_DP_TYPE:
4079 if (nla_len(iter) != sizeof(uint8)) {
4080 ret = -EINVAL;
4081 goto exit;
4082 }
4083 if (nla_get_u8(iter) == 1) {
4084 cmd_data->sde_control_flag
4085 |= NAN_SDE_CF_MULTICAST_TYPE;
4086 break;
4087 }
4088 break;
4089 case NAN_ATTRIBUTE_SDE_CONTROL_SECURITY:
4090 if (nla_len(iter) != sizeof(uint8)) {
4091 ret = -EINVAL;
4092 goto exit;
4093 }
4094 if (nla_get_u8(iter) == 1) {
4095 cmd_data->sde_control_flag
4096 |= NAN_SDE_CF_SECURITY_REQUIRED;
4097 break;
4098 }
4099 break;
4100 case NAN_ATTRIBUTE_RECV_IND_CFG:
4101 if (nla_len(iter) != sizeof(uint8)) {
4102 ret = -EINVAL;
4103 goto exit;
4104 }
4105 cmd_data->recv_ind_flag = nla_get_u8(iter);
4106 break;
4107 case NAN_ATTRIBUTE_CIPHER_SUITE_TYPE:
4108 if (nla_len(iter) != sizeof(uint8)) {
4109 ret = -EINVAL;
4110 goto exit;
4111 }
4112 cmd_data->csid = nla_get_u8(iter);
4113 WL_TRACE(("CSID = %u\n", cmd_data->csid));
4114 break;
4115 case NAN_ATTRIBUTE_KEY_TYPE:
4116 if (nla_len(iter) != sizeof(uint8)) {
4117 ret = -EINVAL;
4118 goto exit;
4119 }
4120 cmd_data->key_type = nla_get_u8(iter);
4121 WL_TRACE(("Key Type = %u\n", cmd_data->key_type));
4122 break;
4123 case NAN_ATTRIBUTE_KEY_LEN:
4124 if (nla_len(iter) != sizeof(uint32)) {
4125 ret = -EINVAL;
4126 goto exit;
4127 }
4128 if (cmd_data->key.dlen) {
4129 WL_ERR(("trying to overwrite:%d\n", attr_type));
4130 ret = -EINVAL;
4131 goto exit;
4132 }
4133 cmd_data->key.dlen = nla_get_u32(iter);
4134 if ((!cmd_data->key.dlen) || (cmd_data->key.dlen > WL_NAN_NCS_SK_PMK_LEN)) {
4135 WL_ERR(("invalid key length = %u\n",
4136 cmd_data->key.dlen));
4137 break;
4138 }
4139 WL_TRACE(("valid key length = %u\n", cmd_data->key.dlen));
4140 break;
4141 case NAN_ATTRIBUTE_KEY_DATA:
4142 if (!cmd_data->key.dlen ||
4143 (nla_len(iter) != cmd_data->key.dlen)) {
4144 WL_ERR(("failed to allocate key data by invalid len=%d,%d\n",
4145 cmd_data->key.dlen, nla_len(iter)));
4146 ret = -EINVAL;
4147 goto exit;
4148 }
4149 if (cmd_data->key.data) {
4150 WL_ERR(("trying to overwrite:%d\n", attr_type));
4151 ret = -EINVAL;
4152 goto exit;
4153 }
4154
4155 cmd_data->key.data = MALLOCZ(cfg->osh, NAN_MAX_PMK_LEN);
4156 if (cmd_data->key.data == NULL) {
4157 WL_ERR(("failed to allocate key data, len=%d\n",
4158 cmd_data->key.dlen));
4159 ret = -ENOMEM;
4160 goto exit;
4161 }
4162 ret = memcpy_s(cmd_data->key.data, NAN_MAX_PMK_LEN,
4163 nla_data(iter), nla_len(iter));
4164 if (ret != BCME_OK) {
4165 WL_ERR(("Failed to key data\n"));
4166 return ret;
4167 }
4168 break;
4169 case NAN_ATTRIBUTE_RSSI_THRESHOLD_FLAG:
4170 if (nla_len(iter) != sizeof(uint8)) {
4171 ret = -EINVAL;
4172 goto exit;
4173 }
4174 if (nla_get_u8(iter) == 1) {
4175 cmd_data->flags |=
4176 WL_NAN_RANGE_LIMITED;
4177 break;
4178 }
4179 break;
4180 case NAN_ATTRIBUTE_DISC_IND_CFG:
4181 if (nla_len(iter) != sizeof(uint8)) {
4182 ret = -EINVAL;
4183 goto exit;
4184 }
4185 cmd_data->disc_ind_cfg = nla_get_u8(iter);
4186 break;
4187 case NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO_LEN:
4188 if (nla_len(iter) != sizeof(uint16)) {
4189 ret = -EINVAL;
4190 goto exit;
4191 }
4192 if (cmd_data->sde_svc_info.dlen) {
4193 WL_ERR(("trying to overwrite:%d\n", attr_type));
4194 ret = -EINVAL;
4195 goto exit;
4196 }
4197 cmd_data->sde_svc_info.dlen = nla_get_u16(iter);
4198 if (cmd_data->sde_svc_info.dlen > MAX_SDEA_SVC_INFO_LEN) {
4199 ret = -EINVAL;
4200 WL_ERR_RLMT(("Not allowed beyond %d\n", MAX_SDEA_SVC_INFO_LEN));
4201 goto exit;
4202 }
4203 break;
4204 case NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO:
4205 if ((!cmd_data->sde_svc_info.dlen) ||
4206 (nla_len(iter) != cmd_data->sde_svc_info.dlen)) {
4207 WL_ERR(("wrong sdea info len:%d,%d\n",
4208 cmd_data->sde_svc_info.dlen, nla_len(iter)));
4209 ret = -EINVAL;
4210 goto exit;
4211 }
4212 if (cmd_data->sde_svc_info.data) {
4213 WL_ERR(("trying to overwrite:%d\n", attr_type));
4214 ret = -EINVAL;
4215 goto exit;
4216 }
4217 cmd_data->sde_svc_info.data = MALLOCZ(cfg->osh,
4218 cmd_data->sde_svc_info.dlen);
4219 if (cmd_data->sde_svc_info.data == NULL) {
4220 WL_ERR(("failed to allocate svc info data, len=%d\n",
4221 cmd_data->sde_svc_info.dlen));
4222 ret = -ENOMEM;
4223 goto exit;
4224 }
4225 ret = memcpy_s(cmd_data->sde_svc_info.data,
4226 cmd_data->sde_svc_info.dlen,
4227 nla_data(iter), nla_len(iter));
4228 if (ret != BCME_OK) {
4229 WL_ERR(("Failed to sdea info data\n"));
4230 return ret;
4231 }
4232 break;
4233 case NAN_ATTRIBUTE_SECURITY:
4234 if (nla_len(iter) != sizeof(uint8)) {
4235 ret = -EINVAL;
4236 goto exit;
4237 }
4238 cmd_data->ndp_cfg.security_cfg = nla_get_u8(iter);
4239 break;
4240 case NAN_ATTRIBUTE_RANGING_INTERVAL:
4241 if (nla_len(iter) != sizeof(uint32)) {
4242 ret = -EINVAL;
4243 goto exit;
4244 }
4245 cmd_data->ranging_intvl_msec = nla_get_u32(iter);
4246 break;
4247 case NAN_ATTRIBUTE_RANGING_INGRESS_LIMIT:
4248 if (nla_len(iter) != sizeof(uint32)) {
4249 ret = -EINVAL;
4250 goto exit;
4251 }
4252 cmd_data->ingress_limit = nla_get_u32(iter);
4253 break;
4254 case NAN_ATTRIBUTE_RANGING_EGRESS_LIMIT:
4255 if (nla_len(iter) != sizeof(uint32)) {
4256 ret = -EINVAL;
4257 goto exit;
4258 }
4259 cmd_data->egress_limit = nla_get_u32(iter);
4260 break;
4261 case NAN_ATTRIBUTE_RANGING_INDICATION:
4262 if (nla_len(iter) != sizeof(uint32)) {
4263 ret = -EINVAL;
4264 goto exit;
4265 }
4266 cmd_data->ranging_indication = nla_get_u32(iter);
4267 break;
4268 /* Nan accept policy: Per service basis policy
4269 * Based on this policy(ALL/NONE), responder side
4270 * will send ACCEPT/REJECT
4271 */
4272 case NAN_ATTRIBUTE_SVC_RESPONDER_POLICY:
4273 if (nla_len(iter) != sizeof(uint8)) {
4274 ret = -EINVAL;
4275 goto exit;
4276 }
4277 cmd_data->service_responder_policy = nla_get_u8(iter);
4278 break;
4279 default:
4280 WL_ERR(("Unknown type, %d\n", attr_type));
4281 ret = -EINVAL;
4282 goto exit;
4283 }
4284 }
4285 exit:
4286 /* We need to call set_config_handler b/f calling start enable TBD */
4287 NAN_DBG_EXIT();
4288 return ret;
4289 }
4290
4291 static int
wl_cfgvendor_nan_parse_args(struct wiphy * wiphy,const void * buf,int len,nan_config_cmd_data_t * cmd_data,uint32 * nan_attr_mask)4292 wl_cfgvendor_nan_parse_args(struct wiphy *wiphy, const void *buf,
4293 int len, nan_config_cmd_data_t *cmd_data, uint32 *nan_attr_mask)
4294 {
4295 int ret = BCME_OK;
4296 int attr_type = 0;
4297 int rem = len;
4298 const struct nlattr *iter;
4299 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
4300 int chan;
4301 u8 sid_beacon = 0, sub_sid_beacon = 0;
4302
4303 NAN_DBG_ENTER();
4304
4305 nla_for_each_attr(iter, buf, len, rem) {
4306 attr_type = nla_type(iter);
4307 WL_TRACE(("attr: %s (%u)\n", nan_attr_to_str(attr_type), attr_type));
4308
4309 switch (attr_type) {
4310 /* NAN Enable request attributes */
4311 case NAN_ATTRIBUTE_2G_SUPPORT:{
4312 if (nla_len(iter) != sizeof(uint8)) {
4313 ret = -EINVAL;
4314 goto exit;
4315 }
4316 cmd_data->support_2g = nla_get_u8(iter);
4317 *nan_attr_mask |= NAN_ATTR_SUPPORT_2G_CONFIG;
4318 break;
4319 }
4320 case NAN_ATTRIBUTE_5G_SUPPORT:{
4321 if (nla_len(iter) != sizeof(uint8)) {
4322 ret = -EINVAL;
4323 goto exit;
4324 }
4325 cmd_data->support_5g = nla_get_u8(iter);
4326 *nan_attr_mask |= NAN_ATTR_SUPPORT_5G_CONFIG;
4327 break;
4328 }
4329 case NAN_ATTRIBUTE_CLUSTER_LOW: {
4330 if (nla_len(iter) != sizeof(uint16)) {
4331 ret = -EINVAL;
4332 goto exit;
4333 }
4334 cmd_data->clus_id.octet[5] = nla_get_u16(iter);
4335 break;
4336 }
4337 case NAN_ATTRIBUTE_CLUSTER_HIGH: {
4338 if (nla_len(iter) != sizeof(uint16)) {
4339 ret = -EINVAL;
4340 goto exit;
4341 }
4342 cmd_data->clus_id.octet[4] = nla_get_u16(iter);
4343 break;
4344 }
4345 case NAN_ATTRIBUTE_SID_BEACON: {
4346 if (nla_len(iter) != sizeof(uint8)) {
4347 ret = -EINVAL;
4348 goto exit;
4349 }
4350 sid_beacon = nla_get_u8(iter);
4351 cmd_data->sid_beacon.sid_enable = (sid_beacon & 0x01);
4352 if (cmd_data->sid_beacon.sid_enable) {
4353 cmd_data->sid_beacon.sid_count = (sid_beacon >> 1);
4354 *nan_attr_mask |= NAN_ATTR_SID_BEACON_CONFIG;
4355 }
4356 break;
4357 }
4358 case NAN_ATTRIBUTE_SUB_SID_BEACON: {
4359 if (nla_len(iter) != sizeof(uint8)) {
4360 ret = -EINVAL;
4361 goto exit;
4362 }
4363 sub_sid_beacon = nla_get_u8(iter);
4364 cmd_data->sid_beacon.sub_sid_enable = (sub_sid_beacon & 0x01);
4365 if (cmd_data->sid_beacon.sub_sid_enable) {
4366 cmd_data->sid_beacon.sub_sid_count = (sub_sid_beacon >> 1);
4367 *nan_attr_mask |= NAN_ATTR_SUB_SID_BEACON_CONFIG;
4368 }
4369 break;
4370 }
4371 case NAN_ATTRIBUTE_SYNC_DISC_2G_BEACON:
4372 if (nla_len(iter) != sizeof(uint8)) {
4373 ret = -EINVAL;
4374 goto exit;
4375 }
4376 cmd_data->beacon_2g_val = nla_get_u8(iter);
4377 *nan_attr_mask |= NAN_ATTR_SYNC_DISC_2G_BEACON_CONFIG;
4378 break;
4379 case NAN_ATTRIBUTE_SYNC_DISC_5G_BEACON:
4380 if (nla_len(iter) != sizeof(uint8)) {
4381 ret = -EINVAL;
4382 goto exit;
4383 }
4384 cmd_data->beacon_5g_val = nla_get_u8(iter);
4385 *nan_attr_mask |= NAN_ATTR_SYNC_DISC_5G_BEACON_CONFIG;
4386 break;
4387 case NAN_ATTRIBUTE_SDF_2G_SUPPORT:
4388 if (nla_len(iter) != sizeof(uint8)) {
4389 ret = -EINVAL;
4390 goto exit;
4391 }
4392 cmd_data->sdf_2g_val = nla_get_u8(iter);
4393 *nan_attr_mask |= NAN_ATTR_SDF_2G_SUPPORT_CONFIG;
4394 break;
4395 case NAN_ATTRIBUTE_SDF_5G_SUPPORT:
4396 if (nla_len(iter) != sizeof(uint8)) {
4397 ret = -EINVAL;
4398 goto exit;
4399 }
4400 cmd_data->sdf_5g_val = nla_get_u8(iter);
4401 *nan_attr_mask |= NAN_ATTR_SDF_5G_SUPPORT_CONFIG;
4402 break;
4403 case NAN_ATTRIBUTE_HOP_COUNT_LIMIT:
4404 if (nla_len(iter) != sizeof(uint8)) {
4405 ret = -EINVAL;
4406 goto exit;
4407 }
4408 cmd_data->hop_count_limit = nla_get_u8(iter);
4409 *nan_attr_mask |= NAN_ATTR_HOP_COUNT_LIMIT_CONFIG;
4410 break;
4411 case NAN_ATTRIBUTE_RANDOM_TIME:
4412 if (nla_len(iter) != sizeof(uint8)) {
4413 ret = -EINVAL;
4414 goto exit;
4415 }
4416 cmd_data->metrics.random_factor = nla_get_u8(iter);
4417 *nan_attr_mask |= NAN_ATTR_RAND_FACTOR_CONFIG;
4418 break;
4419 case NAN_ATTRIBUTE_MASTER_PREF:
4420 if (nla_len(iter) != sizeof(uint8)) {
4421 ret = -EINVAL;
4422 goto exit;
4423 }
4424 cmd_data->metrics.master_pref = nla_get_u8(iter);
4425 break;
4426 case NAN_ATTRIBUTE_OUI:
4427 if (nla_len(iter) != sizeof(uint32)) {
4428 ret = -EINVAL;
4429 goto exit;
4430 }
4431 cmd_data->nan_oui = nla_get_u32(iter);
4432 *nan_attr_mask |= NAN_ATTR_OUI_CONFIG;
4433 WL_TRACE(("nan_oui=%d\n", cmd_data->nan_oui));
4434 break;
4435 case NAN_ATTRIBUTE_WARMUP_TIME:
4436 if (nla_len(iter) != sizeof(uint16)) {
4437 ret = -EINVAL;
4438 goto exit;
4439 }
4440 cmd_data->warmup_time = nla_get_u16(iter);
4441 break;
4442 case NAN_ATTRIBUTE_AMBTT:
4443 case NAN_ATTRIBUTE_MASTER_RANK:
4444 WL_DBG(("Unhandled attribute, %d\n", attr_type));
4445 break;
4446 case NAN_ATTRIBUTE_CHANNEL: {
4447 if (nla_len(iter) != sizeof(uint32)) {
4448 ret = -EINVAL;
4449 goto exit;
4450 }
4451 /* take the default channel start_factor frequency */
4452 chan = wf_mhz2channel((uint)nla_get_u32(iter), 0);
4453 if (chan <= CH_MAX_2G_CHANNEL) {
4454 cmd_data->chanspec[0] = wf_channel2chspec(chan, WL_CHANSPEC_BW_20);
4455 } else {
4456 cmd_data->chanspec[0] = wf_channel2chspec(chan, WL_CHANSPEC_BW_80);
4457 }
4458 if (cmd_data->chanspec[0] == 0) {
4459 WL_ERR(("Channel is not valid \n"));
4460 ret = -EINVAL;
4461 goto exit;
4462 }
4463 WL_TRACE(("valid chanspec, chanspec = 0x%04x \n",
4464 cmd_data->chanspec[0]));
4465 break;
4466 }
4467 case NAN_ATTRIBUTE_24G_CHANNEL: {
4468 if (nla_len(iter) != sizeof(uint32)) {
4469 ret = -EINVAL;
4470 goto exit;
4471 }
4472 /* take the default channel start_factor frequency */
4473 chan = wf_mhz2channel((uint)nla_get_u32(iter), 0);
4474 /* 20MHz as BW */
4475 cmd_data->chanspec[1] = wf_channel2chspec(chan, WL_CHANSPEC_BW_20);
4476 if (cmd_data->chanspec[1] == 0) {
4477 WL_ERR((" 2.4GHz Channel is not valid \n"));
4478 ret = -EINVAL;
4479 break;
4480 }
4481 *nan_attr_mask |= NAN_ATTR_2G_CHAN_CONFIG;
4482 WL_TRACE(("valid 2.4GHz chanspec, chanspec = 0x%04x \n",
4483 cmd_data->chanspec[1]));
4484 break;
4485 }
4486 case NAN_ATTRIBUTE_5G_CHANNEL: {
4487 if (nla_len(iter) != sizeof(uint32)) {
4488 ret = -EINVAL;
4489 goto exit;
4490 }
4491 /* take the default channel start_factor frequency */
4492 chan = wf_mhz2channel((uint)nla_get_u32(iter), 0);
4493 /* 20MHz as BW */
4494 cmd_data->chanspec[2] = wf_channel2chspec(chan, WL_CHANSPEC_BW_20);
4495 if (cmd_data->chanspec[2] == 0) {
4496 WL_ERR((" 5GHz Channel is not valid \n"));
4497 ret = -EINVAL;
4498 break;
4499 }
4500 *nan_attr_mask |= NAN_ATTR_5G_CHAN_CONFIG;
4501 WL_TRACE(("valid 5GHz chanspec, chanspec = 0x%04x \n",
4502 cmd_data->chanspec[2]));
4503 break;
4504 }
4505 case NAN_ATTRIBUTE_CONF_CLUSTER_VAL:
4506 if (nla_len(iter) != sizeof(uint8)) {
4507 ret = -EINVAL;
4508 goto exit;
4509 }
4510 cmd_data->config_cluster_val = nla_get_u8(iter);
4511 *nan_attr_mask |= NAN_ATTR_CLUSTER_VAL_CONFIG;
4512 break;
4513 case NAN_ATTRIBUTE_DWELL_TIME:
4514 if (nla_len(iter) != sizeof(uint8)) {
4515 ret = -EINVAL;
4516 goto exit;
4517 }
4518 cmd_data->dwell_time[0] = nla_get_u8(iter);
4519 *nan_attr_mask |= NAN_ATTR_2G_DWELL_TIME_CONFIG;
4520 break;
4521 case NAN_ATTRIBUTE_SCAN_PERIOD:
4522 if (nla_len(iter) != sizeof(uint16)) {
4523 ret = -EINVAL;
4524 goto exit;
4525 }
4526 cmd_data->scan_period[0] = nla_get_u16(iter);
4527 *nan_attr_mask |= NAN_ATTR_2G_SCAN_PERIOD_CONFIG;
4528 break;
4529 case NAN_ATTRIBUTE_DWELL_TIME_5G:
4530 if (nla_len(iter) != sizeof(uint8)) {
4531 ret = -EINVAL;
4532 goto exit;
4533 }
4534 cmd_data->dwell_time[1] = nla_get_u8(iter);
4535 *nan_attr_mask |= NAN_ATTR_5G_DWELL_TIME_CONFIG;
4536 break;
4537 case NAN_ATTRIBUTE_SCAN_PERIOD_5G:
4538 if (nla_len(iter) != sizeof(uint16)) {
4539 ret = -EINVAL;
4540 goto exit;
4541 }
4542 cmd_data->scan_period[1] = nla_get_u16(iter);
4543 *nan_attr_mask |= NAN_ATTR_5G_SCAN_PERIOD_CONFIG;
4544 break;
4545 case NAN_ATTRIBUTE_AVAIL_BIT_MAP:
4546 if (nla_len(iter) != sizeof(uint32)) {
4547 ret = -EINVAL;
4548 goto exit;
4549 }
4550 cmd_data->bmap = nla_get_u32(iter);
4551 break;
4552 case NAN_ATTRIBUTE_ENTRY_CONTROL:
4553 if (nla_len(iter) != sizeof(uint8)) {
4554 ret = -EINVAL;
4555 goto exit;
4556 }
4557 cmd_data->avail_params.duration = nla_get_u8(iter);
4558 break;
4559 case NAN_ATTRIBUTE_RSSI_CLOSE:
4560 if (nla_len(iter) != sizeof(uint8)) {
4561 ret = -EINVAL;
4562 goto exit;
4563 }
4564 cmd_data->rssi_attr.rssi_close_2dot4g_val = nla_get_s8(iter);
4565 *nan_attr_mask |= NAN_ATTR_RSSI_CLOSE_CONFIG;
4566 break;
4567 case NAN_ATTRIBUTE_RSSI_MIDDLE:
4568 if (nla_len(iter) != sizeof(uint8)) {
4569 ret = -EINVAL;
4570 goto exit;
4571 }
4572 cmd_data->rssi_attr.rssi_middle_2dot4g_val = nla_get_s8(iter);
4573 *nan_attr_mask |= NAN_ATTR_RSSI_MIDDLE_2G_CONFIG;
4574 break;
4575 case NAN_ATTRIBUTE_RSSI_PROXIMITY:
4576 if (nla_len(iter) != sizeof(uint8)) {
4577 ret = -EINVAL;
4578 goto exit;
4579 }
4580 cmd_data->rssi_attr.rssi_proximity_2dot4g_val = nla_get_s8(iter);
4581 *nan_attr_mask |= NAN_ATTR_RSSI_PROXIMITY_2G_CONFIG;
4582 break;
4583 case NAN_ATTRIBUTE_RSSI_CLOSE_5G:
4584 if (nla_len(iter) != sizeof(uint8)) {
4585 ret = -EINVAL;
4586 goto exit;
4587 }
4588 cmd_data->rssi_attr.rssi_close_5g_val = nla_get_s8(iter);
4589 *nan_attr_mask |= NAN_ATTR_RSSI_CLOSE_5G_CONFIG;
4590 break;
4591 case NAN_ATTRIBUTE_RSSI_MIDDLE_5G:
4592 if (nla_len(iter) != sizeof(uint8)) {
4593 ret = -EINVAL;
4594 goto exit;
4595 }
4596 cmd_data->rssi_attr.rssi_middle_5g_val = nla_get_s8(iter);
4597 *nan_attr_mask |= NAN_ATTR_RSSI_MIDDLE_5G_CONFIG;
4598 break;
4599 case NAN_ATTRIBUTE_RSSI_PROXIMITY_5G:
4600 if (nla_len(iter) != sizeof(uint8)) {
4601 ret = -EINVAL;
4602 goto exit;
4603 }
4604 cmd_data->rssi_attr.rssi_proximity_5g_val = nla_get_s8(iter);
4605 *nan_attr_mask |= NAN_ATTR_RSSI_PROXIMITY_5G_CONFIG;
4606 break;
4607 case NAN_ATTRIBUTE_RSSI_WINDOW_SIZE:
4608 if (nla_len(iter) != sizeof(uint8)) {
4609 ret = -EINVAL;
4610 goto exit;
4611 }
4612 cmd_data->rssi_attr.rssi_window_size = nla_get_u8(iter);
4613 *nan_attr_mask |= NAN_ATTR_RSSI_WINDOW_SIZE_CONFIG;
4614 break;
4615 case NAN_ATTRIBUTE_CIPHER_SUITE_TYPE:
4616 if (nla_len(iter) != sizeof(uint8)) {
4617 ret = -EINVAL;
4618 goto exit;
4619 }
4620 cmd_data->csid = nla_get_u8(iter);
4621 WL_TRACE(("CSID = %u\n", cmd_data->csid));
4622 break;
4623 case NAN_ATTRIBUTE_SCID_LEN:
4624 if (nla_len(iter) != sizeof(uint32)) {
4625 ret = -EINVAL;
4626 goto exit;
4627 }
4628 if (cmd_data->scid.dlen) {
4629 WL_ERR(("trying to overwrite:%d\n", attr_type));
4630 ret = -EINVAL;
4631 goto exit;
4632 }
4633 cmd_data->scid.dlen = nla_get_u32(iter);
4634 if (cmd_data->scid.dlen > MAX_SCID_LEN) {
4635 ret = -EINVAL;
4636 WL_ERR_RLMT(("Not allowed beyond %d\n", MAX_SCID_LEN));
4637 goto exit;
4638 }
4639 WL_TRACE(("valid scid length = %u\n", cmd_data->scid.dlen));
4640 break;
4641 case NAN_ATTRIBUTE_SCID:
4642 if (!cmd_data->scid.dlen || (nla_len(iter) != cmd_data->scid.dlen)) {
4643 WL_ERR(("wrong scid len:%d,%d\n", cmd_data->scid.dlen,
4644 nla_len(iter)));
4645 ret = -EINVAL;
4646 goto exit;
4647 }
4648 if (cmd_data->scid.data) {
4649 WL_ERR(("trying to overwrite:%d\n", attr_type));
4650 ret = -EINVAL;
4651 goto exit;
4652 }
4653
4654 cmd_data->scid.data = MALLOCZ(cfg->osh, cmd_data->scid.dlen);
4655 if (cmd_data->scid.data == NULL) {
4656 WL_ERR(("failed to allocate scid, len=%d\n",
4657 cmd_data->scid.dlen));
4658 ret = -ENOMEM;
4659 goto exit;
4660 }
4661 ret = memcpy_s(cmd_data->scid.data, cmd_data->scid.dlen,
4662 nla_data(iter), nla_len(iter));
4663 if (ret != BCME_OK) {
4664 WL_ERR(("Failed to scid data\n"));
4665 return ret;
4666 }
4667 break;
4668 case NAN_ATTRIBUTE_2G_AWAKE_DW:
4669 if (nla_len(iter) != sizeof(uint32)) {
4670 ret = -EINVAL;
4671 goto exit;
4672 }
4673 if (nla_get_u32(iter) > NAN_MAX_AWAKE_DW_INTERVAL) {
4674 WL_ERR(("%s: Invalid/Out of bound value = %u\n",
4675 __FUNCTION__, nla_get_u32(iter)));
4676 ret = -EINVAL;
4677 goto exit;
4678 }
4679 if (nla_get_u32(iter)) {
4680 cmd_data->awake_dws.dw_interval_2g =
4681 1 << (nla_get_u32(iter)-1);
4682 }
4683 *nan_attr_mask |= NAN_ATTR_2G_DW_CONFIG;
4684 break;
4685 case NAN_ATTRIBUTE_5G_AWAKE_DW:
4686 if (nla_len(iter) != sizeof(uint32)) {
4687 ret = -EINVAL;
4688 goto exit;
4689 }
4690 if (nla_get_u32(iter) > NAN_MAX_AWAKE_DW_INTERVAL) {
4691 WL_ERR(("%s: Invalid/Out of bound value = %u\n",
4692 __FUNCTION__, nla_get_u32(iter)));
4693 ret = BCME_BADARG;
4694 break;
4695 }
4696 if (nla_get_u32(iter)) {
4697 cmd_data->awake_dws.dw_interval_5g =
4698 1 << (nla_get_u32(iter)-1);
4699 }
4700 *nan_attr_mask |= NAN_ATTR_5G_DW_CONFIG;
4701 break;
4702 case NAN_ATTRIBUTE_DISC_IND_CFG:
4703 if (nla_len(iter) != sizeof(uint8)) {
4704 ret = -EINVAL;
4705 goto exit;
4706 }
4707 cmd_data->disc_ind_cfg = nla_get_u8(iter);
4708 break;
4709 case NAN_ATTRIBUTE_MAC_ADDR:
4710 if (nla_len(iter) != ETHER_ADDR_LEN) {
4711 ret = -EINVAL;
4712 goto exit;
4713 }
4714 ret = memcpy_s((char*)&cmd_data->mac_addr, ETHER_ADDR_LEN,
4715 (char*)nla_data(iter), nla_len(iter));
4716 if (ret != BCME_OK) {
4717 WL_ERR(("Failed to copy mac addr\n"));
4718 return ret;
4719 }
4720 break;
4721 case NAN_ATTRIBUTE_RANDOMIZATION_INTERVAL:
4722 if (nla_len(iter) != sizeof(uint32)) {
4723 ret = -EINVAL;
4724 goto exit;
4725 }
4726 cmd_data->nmi_rand_intvl = nla_get_u8(iter);
4727 if (cmd_data->nmi_rand_intvl > 0) {
4728 cfg->nancfg.mac_rand = true;
4729 } else {
4730 cfg->nancfg.mac_rand = false;
4731 }
4732 break;
4733 default:
4734 WL_ERR(("%s: Unknown type, %d\n", __FUNCTION__, attr_type));
4735 ret = -EINVAL;
4736 goto exit;
4737 }
4738 }
4739
4740 exit:
4741 /* We need to call set_config_handler b/f calling start enable TBD */
4742 NAN_DBG_EXIT();
4743 if (ret) {
4744 WL_ERR(("%s: Failed to parse attribute %d ret %d",
4745 __FUNCTION__, attr_type, ret));
4746 }
4747 return ret;
4748
4749 }
4750
4751 static int
wl_cfgvendor_nan_dp_estb_event_data_filler(struct sk_buff * msg,nan_event_data_t * event_data)4752 wl_cfgvendor_nan_dp_estb_event_data_filler(struct sk_buff *msg,
4753 nan_event_data_t *event_data) {
4754 int ret = BCME_OK;
4755 ret = nla_put_u32(msg, NAN_ATTRIBUTE_NDP_ID, event_data->ndp_id);
4756 if (unlikely(ret)) {
4757 WL_ERR(("Failed to put NDP ID, ret=%d\n", ret));
4758 goto fail;
4759 }
4760 /*
4761 * NDI mac address of the peer
4762 * (required to derive target ipv6 address)
4763 */
4764 ret = nla_put(msg, NAN_ATTRIBUTE_PEER_NDI_MAC_ADDR, ETH_ALEN,
4765 event_data->responder_ndi.octet);
4766 if (unlikely(ret)) {
4767 WL_ERR(("Failed to put resp ndi, ret=%d\n", ret));
4768 goto fail;
4769 }
4770 ret = nla_put_u8(msg, NAN_ATTRIBUTE_RSP_CODE, event_data->status);
4771 if (unlikely(ret)) {
4772 WL_ERR(("Failed to put response code, ret=%d\n", ret));
4773 goto fail;
4774 }
4775 if (event_data->svc_info.dlen && event_data->svc_info.data) {
4776 ret = nla_put_u16(msg, NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN,
4777 event_data->svc_info.dlen);
4778 if (unlikely(ret)) {
4779 WL_ERR(("Failed to put svc info len, ret=%d\n", ret));
4780 goto fail;
4781 }
4782 ret = nla_put(msg, NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO,
4783 event_data->svc_info.dlen, event_data->svc_info.data);
4784 if (unlikely(ret)) {
4785 WL_ERR(("Failed to put svc info, ret=%d\n", ret));
4786 goto fail;
4787 }
4788 }
4789
4790 fail:
4791 return ret;
4792 }
4793 static int
wl_cfgvendor_nan_dp_ind_event_data_filler(struct sk_buff * msg,nan_event_data_t * event_data)4794 wl_cfgvendor_nan_dp_ind_event_data_filler(struct sk_buff *msg,
4795 nan_event_data_t *event_data) {
4796 int ret = BCME_OK;
4797
4798 ret = nla_put_u16(msg, NAN_ATTRIBUTE_PUBLISH_ID,
4799 event_data->pub_id);
4800 if (unlikely(ret)) {
4801 WL_ERR(("Failed to put pub ID, ret=%d\n", ret));
4802 goto fail;
4803 }
4804 ret = nla_put_u32(msg, NAN_ATTRIBUTE_NDP_ID, event_data->ndp_id);
4805 if (unlikely(ret)) {
4806 WL_ERR(("Failed to put NDP ID, ret=%d\n", ret));
4807 goto fail;
4808 }
4809 /* Discovery MAC addr of the peer/initiator */
4810 ret = nla_put(msg, NAN_ATTRIBUTE_MAC_ADDR, ETH_ALEN,
4811 event_data->remote_nmi.octet);
4812 if (unlikely(ret)) {
4813 WL_ERR(("Failed to put remote NMI, ret=%d\n", ret));
4814 goto fail;
4815 }
4816 ret = nla_put_u8(msg, NAN_ATTRIBUTE_SECURITY, event_data->security);
4817 if (unlikely(ret)) {
4818 WL_ERR(("Failed to put security, ret=%d\n", ret));
4819 goto fail;
4820 }
4821 if (event_data->svc_info.dlen && event_data->svc_info.data) {
4822 ret = nla_put_u16(msg, NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN,
4823 event_data->svc_info.dlen);
4824 if (unlikely(ret)) {
4825 WL_ERR(("Failed to put svc info len, ret=%d\n", ret));
4826 goto fail;
4827 }
4828 ret = nla_put(msg, NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO,
4829 event_data->svc_info.dlen, event_data->svc_info.data);
4830 if (unlikely(ret)) {
4831 WL_ERR(("Failed to put svc info, ret=%d\n", ret));
4832 goto fail;
4833 }
4834 }
4835
4836 fail:
4837 return ret;
4838 }
4839
4840 static int
wl_cfgvendor_nan_tx_followup_ind_event_data_filler(struct sk_buff * msg,nan_event_data_t * event_data)4841 wl_cfgvendor_nan_tx_followup_ind_event_data_filler(struct sk_buff *msg,
4842 nan_event_data_t *event_data) {
4843 int ret = BCME_OK;
4844 ret = nla_put_u16(msg, NAN_ATTRIBUTE_TRANSAC_ID, event_data->token);
4845 if (unlikely(ret)) {
4846 WL_ERR(("Failed to put transaction id, ret=%d\n", ret));
4847 goto fail;
4848 }
4849 ret = nla_put_u8(msg, NAN_ATTRIBUTE_HANDLE, event_data->local_inst_id);
4850 if (unlikely(ret)) {
4851 WL_ERR(("Failed to put handle, ret=%d\n", ret));
4852 goto fail;
4853 }
4854 ret = nla_put_u16(msg, NAN_ATTRIBUTE_STATUS, event_data->status);
4855 if (unlikely(ret)) {
4856 WL_ERR(("Failed to put nan status, ret=%d\n", ret));
4857 goto fail;
4858 }
4859 if (event_data->status == NAN_STATUS_SUCCESS) {
4860 ret = nla_put(msg, NAN_ATTRIBUTE_REASON,
4861 strlen("NAN_STATUS_SUCCESS"), event_data->nan_reason);
4862 if (unlikely(ret)) {
4863 WL_ERR(("Failed to put nan reason, ret=%d\n", ret));
4864 goto fail;
4865 }
4866 } else {
4867 ret = nla_put(msg, NAN_ATTRIBUTE_REASON,
4868 strlen("NAN_STATUS_NO_OTA_ACK"), event_data->nan_reason);
4869 if (unlikely(ret)) {
4870 WL_ERR(("Failed to put nan reason, ret=%d\n", ret));
4871 goto fail;
4872 }
4873 }
4874 fail:
4875 return ret;
4876 }
4877
4878 static int
wl_cfgvendor_nan_svc_terminate_event_filler(struct sk_buff * msg,struct bcm_cfg80211 * cfg,int event_id,nan_event_data_t * event_data)4879 wl_cfgvendor_nan_svc_terminate_event_filler(struct sk_buff *msg,
4880 struct bcm_cfg80211 *cfg, int event_id, nan_event_data_t *event_data) {
4881 int ret = BCME_OK;
4882 ret = nla_put_u8(msg, NAN_ATTRIBUTE_HANDLE, event_data->local_inst_id);
4883 if (unlikely(ret)) {
4884 WL_ERR(("Failed to put handle, ret=%d\n", ret));
4885 goto fail;
4886 }
4887
4888 if (event_id == GOOGLE_NAN_EVENT_SUBSCRIBE_TERMINATED) {
4889 ret = nla_put_u16(msg, NAN_ATTRIBUTE_SUBSCRIBE_ID,
4890 event_data->local_inst_id);
4891 if (unlikely(ret)) {
4892 WL_ERR(("Failed to put local inst id, ret=%d\n", ret));
4893 goto fail;
4894 }
4895 } else {
4896 ret = nla_put_u16(msg, NAN_ATTRIBUTE_PUBLISH_ID,
4897 event_data->local_inst_id);
4898 if (unlikely(ret)) {
4899 WL_ERR(("Failed to put local inst id, ret=%d\n", ret));
4900 goto fail;
4901 }
4902 }
4903 ret = nla_put_u16(msg, NAN_ATTRIBUTE_STATUS, event_data->status);
4904 if (unlikely(ret)) {
4905 WL_ERR(("Failed to put status, ret=%d\n", ret));
4906 goto fail;
4907 }
4908 if (event_data->status == NAN_STATUS_SUCCESS) {
4909 ret = nla_put(msg, NAN_ATTRIBUTE_REASON,
4910 strlen("NAN_STATUS_SUCCESS"), event_data->nan_reason);
4911 if (unlikely(ret)) {
4912 WL_ERR(("Failed to put nan reason, ret=%d\n", ret));
4913 goto fail;
4914 }
4915 } else {
4916 ret = nla_put(msg, NAN_ATTRIBUTE_REASON,
4917 strlen("NAN_STATUS_INTERNAL_FAILURE"), event_data->nan_reason);
4918 if (unlikely(ret)) {
4919 WL_ERR(("Failed to put nan reason, ret=%d\n", ret));
4920 goto fail;
4921 }
4922 }
4923
4924 ret = wl_cfgnan_remove_inst_id(cfg, event_data->local_inst_id);
4925 if (ret) {
4926 WL_ERR(("failed to free svc instance-id[%d], ret=%d, event_id = %d\n",
4927 event_data->local_inst_id, ret, event_id));
4928 goto fail;
4929 }
4930 fail:
4931 return ret;
4932 }
4933
4934 static int
wl_cfgvendor_nan_opt_params_filler(struct sk_buff * msg,nan_event_data_t * event_data)4935 wl_cfgvendor_nan_opt_params_filler(struct sk_buff *msg,
4936 nan_event_data_t *event_data) {
4937 int ret = BCME_OK;
4938 /* service specific info data */
4939 if (event_data->svc_info.dlen && event_data->svc_info.data) {
4940 ret = nla_put_u16(msg, NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN,
4941 event_data->svc_info.dlen);
4942 if (unlikely(ret)) {
4943 WL_ERR(("Failed to put svc info len, ret=%d\n", ret));
4944 goto fail;
4945 }
4946 ret = nla_put(msg, NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO,
4947 event_data->svc_info.dlen, event_data->svc_info.data);
4948 if (unlikely(ret)) {
4949 WL_ERR(("Failed to put svc info, ret=%d\n", ret));
4950 goto fail;
4951 }
4952 WL_TRACE(("svc info len = %d\n", event_data->svc_info.dlen));
4953 }
4954
4955 /* sdea service specific info data */
4956 if (event_data->sde_svc_info.dlen && event_data->sde_svc_info.data) {
4957 ret = nla_put_u16(msg, NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO_LEN,
4958 event_data->sde_svc_info.dlen);
4959 if (unlikely(ret)) {
4960 WL_ERR(("Failed to put sdea svc info len, ret=%d\n", ret));
4961 goto fail;
4962 }
4963 ret = nla_put(msg, NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO,
4964 event_data->sde_svc_info.dlen,
4965 event_data->sde_svc_info.data);
4966 if (unlikely(ret)) {
4967 WL_ERR(("Failed to put sdea svc info, ret=%d\n", ret));
4968 goto fail;
4969 }
4970 WL_TRACE(("sdea svc info len = %d\n", event_data->sde_svc_info.dlen));
4971 }
4972 /* service control discovery range limit */
4973 /* TODO: */
4974
4975 /* service control binding bitmap */
4976 /* TODO: */
4977 fail:
4978 return ret;
4979 }
4980
4981 static int
wl_cfgvendor_nan_tx_followup_event_filler(struct sk_buff * msg,nan_event_data_t * event_data)4982 wl_cfgvendor_nan_tx_followup_event_filler(struct sk_buff *msg,
4983 nan_event_data_t *event_data) {
4984 int ret = BCME_OK;
4985 /* In followup pkt, instance id and requestor instance id are configured
4986 * from the transmitter perspective. As the event is processed with the
4987 * role of receiver, the local handle should use requestor instance
4988 * id (peer_inst_id)
4989 */
4990 WL_TRACE(("handle=%d\n", event_data->requestor_id));
4991 WL_TRACE(("inst id (local id)=%d\n", event_data->local_inst_id));
4992 WL_TRACE(("peer id (remote id)=%d\n", event_data->requestor_id));
4993 WL_TRACE(("peer mac addr=" MACDBG "\n",
4994 MAC2STRDBG(event_data->remote_nmi.octet)));
4995 WL_TRACE(("peer rssi: %d\n", event_data->fup_rssi));
4996 WL_TRACE(("attribute no: %d\n", event_data->attr_num));
4997 WL_TRACE(("attribute len: %d\n", event_data->attr_list_len));
4998
4999 ret = nla_put_u8(msg, NAN_ATTRIBUTE_HANDLE, event_data->requestor_id);
5000 if (unlikely(ret)) {
5001 WL_ERR(("Failed to put handle, ret=%d\n", ret));
5002 goto fail;
5003 }
5004 ret = nla_put_u32(msg, NAN_ATTRIBUTE_INST_ID, event_data->local_inst_id);
5005 if (unlikely(ret)) {
5006 WL_ERR(("Failed to put local inst id, ret=%d\n", ret));
5007 goto fail;
5008 }
5009 ret = nla_put_u16(msg, NAN_ATTRIBUTE_PEER_ID, event_data->requestor_id);
5010 if (unlikely(ret)) {
5011 WL_ERR(("Failed to put requestor inst id, ret=%d\n", ret));
5012 goto fail;
5013 }
5014 ret = nla_put(msg, NAN_ATTRIBUTE_MAC_ADDR, ETHER_ADDR_LEN,
5015 event_data->remote_nmi.octet);
5016 if (unlikely(ret)) {
5017 WL_ERR(("Failed to put remote nmi, ret=%d\n", ret));
5018 goto fail;
5019 }
5020 ret = nla_put_s8(msg, NAN_ATTRIBUTE_RSSI_PROXIMITY,
5021 event_data->fup_rssi);
5022 if (unlikely(ret)) {
5023 WL_ERR(("Failed to put fup rssi, ret=%d\n", ret));
5024 goto fail;
5025 }
5026 fail:
5027 return ret;
5028 }
5029
5030 static int
wl_cfgvendor_nan_sub_match_event_filler(struct sk_buff * msg,nan_event_data_t * event_data)5031 wl_cfgvendor_nan_sub_match_event_filler(struct sk_buff *msg,
5032 nan_event_data_t *event_data) {
5033 int ret = BCME_OK;
5034 WL_TRACE(("handle (sub_id)=%d\n", event_data->sub_id));
5035 WL_TRACE(("pub id=%d\n", event_data->pub_id));
5036 WL_TRACE(("sub id=%d\n", event_data->sub_id));
5037 WL_TRACE(("pub mac addr=" MACDBG "\n",
5038 MAC2STRDBG(event_data->remote_nmi.octet)));
5039 WL_TRACE(("attr no: %d\n", event_data->attr_num));
5040 WL_TRACE(("attr len: %d\n", event_data->attr_list_len));
5041
5042 ret = nla_put_u8(msg, NAN_ATTRIBUTE_HANDLE, event_data->sub_id);
5043 if (unlikely(ret)) {
5044 WL_ERR(("Failed to put handle, ret=%d\n", ret));
5045 goto fail;
5046 }
5047 ret = nla_put_u16(msg, NAN_ATTRIBUTE_PUBLISH_ID, event_data->pub_id);
5048 if (unlikely(ret)) {
5049 WL_ERR(("Failed to put pub id, ret=%d\n", ret));
5050 goto fail;
5051 }
5052 ret = nla_put_u16(msg, NAN_ATTRIBUTE_SUBSCRIBE_ID, event_data->sub_id);
5053 if (unlikely(ret)) {
5054 WL_ERR(("Failed to put Sub Id, ret=%d\n", ret));
5055 goto fail;
5056 }
5057 ret = nla_put(msg, NAN_ATTRIBUTE_MAC_ADDR, ETHER_ADDR_LEN,
5058 event_data->remote_nmi.octet);
5059 if (unlikely(ret)) {
5060 WL_ERR(("Failed to put remote NMI, ret=%d\n", ret));
5061 goto fail;
5062 }
5063 if (event_data->publish_rssi) {
5064 event_data->publish_rssi = -event_data->publish_rssi;
5065 ret = nla_put_u8(msg, NAN_ATTRIBUTE_RSSI_PROXIMITY,
5066 event_data->publish_rssi);
5067 if (unlikely(ret)) {
5068 WL_ERR(("Failed to put publish rssi, ret=%d\n", ret));
5069 goto fail;
5070 }
5071 }
5072 if (event_data->ranging_result_present) {
5073 ret = nla_put_u32(msg, NAN_ATTRIBUTE_RANGING_INDICATION,
5074 event_data->ranging_ind);
5075 if (unlikely(ret)) {
5076 WL_ERR(("Failed to put ranging ind, ret=%d\n", ret));
5077 goto fail;
5078 }
5079 ret = nla_put_u32(msg, NAN_ATTRIBUTE_RANGING_RESULT,
5080 event_data->range_measurement_cm);
5081 if (unlikely(ret)) {
5082 WL_ERR(("Failed to put range measurement cm, ret=%d\n",
5083 ret));
5084 goto fail;
5085 }
5086 }
5087 /*
5088 * handling optional service control, service response filter
5089 */
5090 if (event_data->tx_match_filter.dlen && event_data->tx_match_filter.data) {
5091 ret = nla_put_u16(msg, NAN_ATTRIBUTE_TX_MATCH_FILTER_LEN,
5092 event_data->tx_match_filter.dlen);
5093 if (unlikely(ret)) {
5094 WL_ERR(("Failed to put tx match filter len, ret=%d\n",
5095 ret));
5096 goto fail;
5097 }
5098 ret = nla_put(msg, NAN_ATTRIBUTE_TX_MATCH_FILTER,
5099 event_data->tx_match_filter.dlen,
5100 event_data->tx_match_filter.data);
5101 if (unlikely(ret)) {
5102 WL_ERR(("Failed to put tx match filter data, ret=%d\n",
5103 ret));
5104 goto fail;
5105 }
5106 WL_TRACE(("tx matching filter (%d):\n",
5107 event_data->tx_match_filter.dlen));
5108 }
5109
5110 fail:
5111 return ret;
5112 }
5113
5114 static int
wl_cfgvendor_nan_de_event_filler(struct sk_buff * msg,nan_event_data_t * event_data)5115 wl_cfgvendor_nan_de_event_filler(struct sk_buff *msg, nan_event_data_t *event_data)
5116 {
5117 int ret = BCME_OK;
5118 ret = nla_put_u8(msg, NAN_ATTRIBUTE_ENABLE_STATUS, event_data->enabled);
5119 if (unlikely(ret)) {
5120 WL_ERR(("Failed to put event_data->enabled, ret=%d\n", ret));
5121 goto fail;
5122 }
5123 ret = nla_put_u8(msg, NAN_ATTRIBUTE_DE_EVENT_TYPE,
5124 event_data->nan_de_evt_type);
5125 if (unlikely(ret)) {
5126 WL_ERR(("Failed to put nan_de_evt_type, ret=%d\n", ret));
5127 goto fail;
5128 }
5129 ret = nla_put(msg, NAN_ATTRIBUTE_CLUSTER_ID, ETH_ALEN,
5130 event_data->clus_id.octet);
5131 if (unlikely(ret)) {
5132 WL_ERR(("Failed to put clust id, ret=%d\n", ret));
5133 goto fail;
5134 }
5135 /* OOB tests requires local nmi */
5136 ret = nla_put(msg, NAN_ATTRIBUTE_MAC_ADDR, ETH_ALEN,
5137 event_data->local_nmi.octet);
5138 if (unlikely(ret)) {
5139 WL_ERR(("Failed to put NMI, ret=%d\n", ret));
5140 goto fail;
5141 }
5142 fail:
5143 return ret;
5144 }
5145
5146 #ifdef RTT_SUPPORT
5147 s32
wl_cfgvendor_send_as_rtt_legacy_event(struct wiphy * wiphy,struct net_device * dev,wl_nan_ev_rng_rpt_ind_t * range_res,uint32 status)5148 wl_cfgvendor_send_as_rtt_legacy_event(struct wiphy *wiphy, struct net_device *dev,
5149 wl_nan_ev_rng_rpt_ind_t *range_res, uint32 status)
5150 {
5151 s32 ret = BCME_OK;
5152 gfp_t kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
5153 rtt_report_t *report = NULL;
5154 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
5155 struct sk_buff *msg = NULL;
5156 struct nlattr *rtt_nl_hdr;
5157
5158 NAN_DBG_ENTER();
5159
5160 report = MALLOCZ(cfg->osh, sizeof(*report));
5161 if (!report) {
5162 WL_ERR(("%s: memory allocation failed\n", __func__));
5163 ret = BCME_NOMEM;
5164 goto exit;
5165 }
5166 if (range_res) {
5167 report->distance = range_res->dist_mm/10;
5168 ret = memcpy_s(&report->addr, ETHER_ADDR_LEN,
5169 &range_res->peer_m_addr, ETHER_ADDR_LEN);
5170 if (ret != BCME_OK) {
5171 WL_ERR(("Failed to copy peer_m_addr\n"));
5172 goto exit;
5173 }
5174 }
5175 report->status = (rtt_reason_t)status;
5176 report->type = RTT_TWO_WAY;
5177
5178 #if (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || \
5179 LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0)
5180 msg = cfg80211_vendor_event_alloc(wiphy, NULL, 100,
5181 GOOGLE_RTT_COMPLETE_EVENT, kflags);
5182 #else
5183 msg = cfg80211_vendor_event_alloc(wiphy, 100, GOOGLE_RTT_COMPLETE_EVENT, kflags);
5184 #endif /* (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || */
5185 /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0) */
5186 if (!msg) {
5187 WL_ERR(("%s: fail to allocate skb for vendor event\n", __FUNCTION__));
5188 ret = BCME_NOMEM;
5189 goto exit;
5190 }
5191
5192 ret = nla_put_u32(msg, RTT_ATTRIBUTE_RESULTS_COMPLETE, 1);
5193 if (ret < 0) {
5194 WL_ERR(("Failed to put RTT_ATTRIBUTE_RESULTS_COMPLETE\n"));
5195 goto exit;
5196 }
5197 rtt_nl_hdr = nla_nest_start(msg, RTT_ATTRIBUTE_RESULTS_PER_TARGET);
5198 if (!rtt_nl_hdr) {
5199 WL_ERR(("rtt_nl_hdr is NULL\n"));
5200 ret = BCME_NOMEM;
5201 goto exit;
5202 }
5203 ret = nla_put(msg, RTT_ATTRIBUTE_TARGET_MAC, ETHER_ADDR_LEN, &report->addr);
5204 if (ret < 0) {
5205 WL_ERR(("Failed to put RTT_ATTRIBUTE_TARGET_MAC\n"));
5206 goto exit;
5207 }
5208 ret = nla_put_u32(msg, RTT_ATTRIBUTE_RESULT_CNT, 1);
5209 if (ret < 0) {
5210 WL_ERR(("Failed to put RTT_ATTRIBUTE_RESULT_CNT\n"));
5211 goto exit;
5212 }
5213 ret = nla_put(msg, RTT_ATTRIBUTE_RESULT,
5214 sizeof(*report), report);
5215 if (ret < 0) {
5216 WL_ERR(("Failed to put RTT_ATTRIBUTE_RESULTS\n"));
5217 goto exit;
5218 }
5219 nla_nest_end(msg, rtt_nl_hdr);
5220 cfg80211_vendor_event(msg, kflags);
5221 if (report) {
5222 MFREE(cfg->osh, report, sizeof(*report));
5223 }
5224
5225 return ret;
5226 exit:
5227 if (msg)
5228 dev_kfree_skb_any(msg);
5229 WL_ERR(("Failed to send event GOOGLE_RTT_COMPLETE_EVENT,"
5230 " -- Free skb, ret = %d\n", ret));
5231 if (report)
5232 MFREE(cfg->osh, report, sizeof(*report));
5233 NAN_DBG_EXIT();
5234 return ret;
5235 }
5236 #endif /* RTT_SUPPORT */
5237
5238 int
wl_cfgvendor_send_nan_event(struct wiphy * wiphy,struct net_device * dev,int event_id,nan_event_data_t * event_data)5239 wl_cfgvendor_send_nan_event(struct wiphy *wiphy, struct net_device *dev,
5240 int event_id, nan_event_data_t *event_data)
5241 {
5242 int ret = BCME_OK;
5243 int buf_len = NAN_EVENT_BUFFER_SIZE_LARGE;
5244 gfp_t kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
5245
5246 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
5247 struct sk_buff *msg;
5248
5249 NAN_DBG_ENTER();
5250
5251 /* Allocate the skb for vendor event */
5252 #if (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || \
5253 LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0)
5254 msg = cfg80211_vendor_event_alloc(wiphy, ndev_to_wdev(dev), buf_len, event_id, kflags);
5255 #else
5256 msg = cfg80211_vendor_event_alloc(wiphy, buf_len, event_id, kflags);
5257 #endif /* (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || */
5258 /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0) */
5259
5260 if (!msg) {
5261 WL_ERR(("%s: fail to allocate skb for vendor event\n", __FUNCTION__));
5262 return -ENOMEM;
5263 }
5264
5265 switch (event_id) {
5266 case GOOGLE_NAN_EVENT_DE_EVENT: {
5267 WL_INFORM_MEM(("[NAN] GOOGLE_NAN_DE_EVENT cluster id=" MACDBG "nmi= " MACDBG "\n",
5268 MAC2STRDBG(event_data->clus_id.octet),
5269 MAC2STRDBG(event_data->local_nmi.octet)));
5270 ret = wl_cfgvendor_nan_de_event_filler(msg, event_data);
5271 if (unlikely(ret)) {
5272 WL_ERR(("Failed to fill de event data, ret=%d\n", ret));
5273 goto fail;
5274 }
5275 break;
5276 }
5277 case GOOGLE_NAN_EVENT_SUBSCRIBE_MATCH:
5278 case GOOGLE_NAN_EVENT_FOLLOWUP: {
5279 if (event_id == GOOGLE_NAN_EVENT_SUBSCRIBE_MATCH) {
5280 WL_DBG(("GOOGLE_NAN_EVENT_SUBSCRIBE_MATCH\n"));
5281 ret = wl_cfgvendor_nan_sub_match_event_filler(msg, event_data);
5282 if (unlikely(ret)) {
5283 WL_ERR(("Failed to fill sub match event data, ret=%d\n", ret));
5284 goto fail;
5285 }
5286 } else if (event_id == GOOGLE_NAN_EVENT_FOLLOWUP) {
5287 WL_DBG(("GOOGLE_NAN_EVENT_FOLLOWUP\n"));
5288 ret = wl_cfgvendor_nan_tx_followup_event_filler(msg, event_data);
5289 if (unlikely(ret)) {
5290 WL_ERR(("Failed to fill sub match event data, ret=%d\n", ret));
5291 goto fail;
5292 }
5293 }
5294 ret = wl_cfgvendor_nan_opt_params_filler(msg, event_data);
5295 if (unlikely(ret)) {
5296 WL_ERR(("Failed to fill sub match event data, ret=%d\n", ret));
5297 goto fail;
5298 }
5299 break;
5300 }
5301
5302 case GOOGLE_NAN_EVENT_DISABLED: {
5303 WL_INFORM_MEM(("[NAN] GOOGLE_NAN_EVENT_DISABLED\n"));
5304 ret = nla_put_u8(msg, NAN_ATTRIBUTE_HANDLE, 0);
5305 if (unlikely(ret)) {
5306 WL_ERR(("Failed to put handle, ret=%d\n", ret));
5307 goto fail;
5308 }
5309 ret = nla_put_u16(msg, NAN_ATTRIBUTE_STATUS, event_data->status);
5310 if (unlikely(ret)) {
5311 WL_ERR(("Failed to put status, ret=%d\n", ret));
5312 goto fail;
5313 }
5314 ret = nla_put(msg, NAN_ATTRIBUTE_REASON,
5315 strlen("NAN_STATUS_SUCCESS"), event_data->nan_reason);
5316 if (unlikely(ret)) {
5317 WL_ERR(("Failed to put reason code, ret=%d\n", ret));
5318 goto fail;
5319 }
5320 break;
5321 }
5322
5323 case GOOGLE_NAN_EVENT_SUBSCRIBE_TERMINATED:
5324 case GOOGLE_NAN_EVENT_PUBLISH_TERMINATED: {
5325 WL_DBG(("GOOGLE_NAN_SVC_TERMINATED, %d\n", event_id));
5326 ret = wl_cfgvendor_nan_svc_terminate_event_filler(msg, cfg, event_id, event_data);
5327 if (unlikely(ret)) {
5328 WL_ERR(("Failed to fill svc terminate event data, ret=%d\n", ret));
5329 goto fail;
5330 }
5331 break;
5332 }
5333
5334 case GOOGLE_NAN_EVENT_TRANSMIT_FOLLOWUP_IND: {
5335 WL_DBG(("GOOGLE_NAN_EVENT_TRANSMIT_FOLLOWUP_IND %d\n",
5336 GOOGLE_NAN_EVENT_TRANSMIT_FOLLOWUP_IND));
5337 ret = wl_cfgvendor_nan_tx_followup_ind_event_data_filler(msg, event_data);
5338 if (unlikely(ret)) {
5339 WL_ERR(("Failed to fill tx follow up ind event data, ret=%d\n", ret));
5340 goto fail;
5341 }
5342
5343 break;
5344 }
5345
5346 case GOOGLE_NAN_EVENT_DATA_REQUEST: {
5347 WL_INFORM_MEM(("[NAN] GOOGLE_NAN_EVENT_DATA_REQUEST\n"));
5348 ret = wl_cfgvendor_nan_dp_ind_event_data_filler(msg, event_data);
5349 if (unlikely(ret)) {
5350 WL_ERR(("Failed to fill dp ind event data, ret=%d\n", ret));
5351 goto fail;
5352 }
5353 break;
5354 }
5355
5356 case GOOGLE_NAN_EVENT_DATA_CONFIRMATION: {
5357 WL_INFORM_MEM(("[NAN] GOOGLE_NAN_EVENT_DATA_CONFIRMATION\n"));
5358
5359 ret = wl_cfgvendor_nan_dp_estb_event_data_filler(msg, event_data);
5360 if (unlikely(ret)) {
5361 WL_ERR(("Failed to fill dp estb event data, ret=%d\n", ret));
5362 goto fail;
5363 }
5364 break;
5365 }
5366
5367 case GOOGLE_NAN_EVENT_DATA_END: {
5368 WL_INFORM_MEM(("[NAN] GOOGLE_NAN_EVENT_DATA_END\n"));
5369 ret = nla_put_u8(msg, NAN_ATTRIBUTE_INST_COUNT, 1);
5370 if (unlikely(ret)) {
5371 WL_ERR(("Failed to put inst count, ret=%d\n", ret));
5372 goto fail;
5373 }
5374 ret = nla_put_u32(msg, NAN_ATTRIBUTE_NDP_ID, event_data->ndp_id);
5375 if (unlikely(ret)) {
5376 WL_ERR(("Failed to put ndp id, ret=%d\n", ret));
5377 goto fail;
5378 }
5379 break;
5380 }
5381
5382 default:
5383 goto fail;
5384 }
5385
5386 cfg80211_vendor_event(msg, kflags);
5387 NAN_DBG_EXIT();
5388 return ret;
5389
5390 fail:
5391 dev_kfree_skb_any(msg);
5392 WL_ERR(("Event not implemented or unknown -- Free skb, event_id = %d, ret = %d\n",
5393 event_id, ret));
5394 NAN_DBG_EXIT();
5395 return ret;
5396 }
5397
5398 static int
wl_cfgvendor_nan_req_subscribe(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)5399 wl_cfgvendor_nan_req_subscribe(struct wiphy *wiphy,
5400 struct wireless_dev *wdev, const void * data, int len)
5401 {
5402 int ret = 0;
5403 nan_discover_cmd_data_t *cmd_data = NULL;
5404 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
5405 nan_hal_resp_t nan_req_resp;
5406
5407 NAN_DBG_ENTER();
5408 /* Blocking Subscribe if NAN is not enable */
5409 if (!cfg->nan_enable) {
5410 WL_ERR(("nan is not enabled, subscribe blocked\n"));
5411 ret = BCME_ERROR;
5412 goto exit;
5413 }
5414 cmd_data = (nan_discover_cmd_data_t *)MALLOCZ(cfg->osh, sizeof(*cmd_data));
5415 if (!cmd_data) {
5416 WL_ERR(("%s: memory allocation failed\n", __func__));
5417 ret = BCME_NOMEM;
5418 goto exit;
5419 }
5420
5421 bzero(&nan_req_resp, sizeof(nan_req_resp));
5422 ret = wl_cfgvendor_nan_parse_discover_args(wiphy, data, len, cmd_data);
5423 if (ret) {
5424 WL_ERR(("failed to parse nan disc vendor args, ret = %d\n", ret));
5425 goto exit;
5426 }
5427
5428 if (cmd_data->sub_id == 0) {
5429 ret = wl_cfgnan_generate_inst_id(cfg, &cmd_data->sub_id);
5430 if (ret) {
5431 WL_ERR(("failed to generate instance-id for subscribe\n"));
5432 goto exit;
5433 }
5434 } else {
5435 cmd_data->svc_update = true;
5436 }
5437
5438 ret = wl_cfgnan_subscribe_handler(wdev->netdev, cfg, cmd_data);
5439 if (unlikely(ret) || unlikely(cmd_data->status)) {
5440 WL_ERR(("failed to subscribe error[%d], status = [%d]\n",
5441 ret, cmd_data->status));
5442 wl_cfgnan_remove_inst_id(cfg, cmd_data->sub_id);
5443 goto exit;
5444 }
5445
5446 WL_DBG(("subscriber instance id=%d\n", cmd_data->sub_id));
5447
5448 if (cmd_data->status == WL_NAN_E_OK) {
5449 nan_req_resp.instance_id = cmd_data->sub_id;
5450 } else {
5451 nan_req_resp.instance_id = 0;
5452 }
5453 exit:
5454 ret = wl_cfgvendor_nan_cmd_reply(wiphy, NAN_WIFI_SUBCMD_REQUEST_SUBSCRIBE,
5455 &nan_req_resp, ret, cmd_data ? cmd_data->status : BCME_OK);
5456 wl_cfgvendor_free_disc_cmd_data(cfg, cmd_data);
5457 NAN_DBG_EXIT();
5458 return ret;
5459 }
5460
5461 static int
wl_cfgvendor_nan_req_publish(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)5462 wl_cfgvendor_nan_req_publish(struct wiphy *wiphy,
5463 struct wireless_dev *wdev, const void * data, int len)
5464 {
5465 int ret = 0;
5466 nan_discover_cmd_data_t *cmd_data = NULL;
5467 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
5468 nan_hal_resp_t nan_req_resp;
5469 NAN_DBG_ENTER();
5470
5471 /* Blocking Publish if NAN is not enable */
5472 if (!cfg->nan_enable) {
5473 WL_ERR(("nan is not enabled publish blocked\n"));
5474 ret = BCME_ERROR;
5475 goto exit;
5476 }
5477 cmd_data = (nan_discover_cmd_data_t *)MALLOCZ(cfg->osh, sizeof(*cmd_data));
5478 if (!cmd_data) {
5479 WL_ERR(("%s: memory allocation failed\n", __func__));
5480 ret = BCME_NOMEM;
5481 goto exit;
5482 }
5483
5484 bzero(&nan_req_resp, sizeof(nan_req_resp));
5485 ret = wl_cfgvendor_nan_parse_discover_args(wiphy, data, len, cmd_data);
5486 if (ret) {
5487 WL_ERR(("failed to parse nan disc vendor args, ret = %d\n", ret));
5488 goto exit;
5489 }
5490
5491 if (cmd_data->pub_id == 0) {
5492 ret = wl_cfgnan_generate_inst_id(cfg, &cmd_data->pub_id);
5493 if (ret) {
5494 WL_ERR(("failed to generate instance-id for publisher\n"));
5495 goto exit;
5496 }
5497 } else {
5498 cmd_data->svc_update = true;
5499 }
5500
5501 ret = wl_cfgnan_publish_handler(wdev->netdev, cfg, cmd_data);
5502 if (unlikely(ret) || unlikely(cmd_data->status)) {
5503 WL_ERR(("failed to publish error[%d], status[%d]\n",
5504 ret, cmd_data->status));
5505 wl_cfgnan_remove_inst_id(cfg, cmd_data->pub_id);
5506 goto exit;
5507 }
5508
5509 WL_DBG(("publisher instance id=%d\n", cmd_data->pub_id));
5510
5511 if (cmd_data->status == WL_NAN_E_OK) {
5512 nan_req_resp.instance_id = cmd_data->pub_id;
5513 } else {
5514 nan_req_resp.instance_id = 0;
5515 }
5516 exit:
5517 ret = wl_cfgvendor_nan_cmd_reply(wiphy, NAN_WIFI_SUBCMD_REQUEST_PUBLISH,
5518 &nan_req_resp, ret, cmd_data ? cmd_data->status : BCME_OK);
5519 wl_cfgvendor_free_disc_cmd_data(cfg, cmd_data);
5520 NAN_DBG_EXIT();
5521 return ret;
5522 }
5523
5524 static int
wl_cfgvendor_nan_start_handler(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)5525 wl_cfgvendor_nan_start_handler(struct wiphy *wiphy,
5526 struct wireless_dev *wdev, const void *data, int len)
5527 {
5528 int ret = 0;
5529 nan_config_cmd_data_t *cmd_data;
5530 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
5531 nan_hal_resp_t nan_req_resp;
5532 uint32 nan_attr_mask = 0;
5533
5534 cmd_data = (nan_config_cmd_data_t *)MALLOCZ(cfg->osh, sizeof(*cmd_data));
5535 if (!cmd_data) {
5536 WL_ERR(("%s: memory allocation failed\n", __func__));
5537 ret = BCME_NOMEM;
5538 goto exit;
5539 }
5540 NAN_DBG_ENTER();
5541
5542 if (cfg->nan_enable) {
5543 WL_ERR(("nan is already enabled\n"));
5544 ret = BCME_OK;
5545 goto exit;
5546 }
5547 bzero(&nan_req_resp, sizeof(nan_req_resp));
5548
5549 cmd_data->sid_beacon.sid_enable = NAN_SID_ENABLE_FLAG_INVALID; /* Setting to some default */
5550 cmd_data->sid_beacon.sid_count = NAN_SID_BEACON_COUNT_INVALID; /* Setting to some default */
5551
5552 ret = wl_cfgvendor_nan_parse_args(wiphy, data, len, cmd_data, &nan_attr_mask);
5553 if (ret) {
5554 WL_ERR(("failed to parse nan vendor args, ret %d\n", ret));
5555 goto exit;
5556 }
5557
5558 ret = wl_cfgnan_start_handler(wdev->netdev, cfg, cmd_data, nan_attr_mask);
5559 if (ret) {
5560 WL_ERR(("failed to start nan error[%d]\n", ret));
5561 goto exit;
5562 }
5563 /* Initializing Instance Id List */
5564 bzero(cfg->nan_inst_ctrl, NAN_ID_CTRL_SIZE * sizeof(nan_svc_inst_t));
5565 exit:
5566 ret = wl_cfgvendor_nan_cmd_reply(wiphy, NAN_WIFI_SUBCMD_ENABLE,
5567 &nan_req_resp, ret, cmd_data ? cmd_data->status : BCME_OK);
5568 if (cmd_data) {
5569 if (cmd_data->scid.data) {
5570 MFREE(cfg->osh, cmd_data->scid.data, cmd_data->scid.dlen);
5571 cmd_data->scid.dlen = 0;
5572 }
5573 MFREE(cfg->osh, cmd_data, sizeof(*cmd_data));
5574 }
5575 NAN_DBG_EXIT();
5576 return ret;
5577 }
5578
5579 static int
wl_cfgvendor_nan_stop_handler(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)5580 wl_cfgvendor_nan_stop_handler(struct wiphy *wiphy,
5581 struct wireless_dev *wdev, const void * data, int len)
5582 {
5583 int ret = 0;
5584 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
5585 nan_hal_resp_t nan_req_resp;
5586 NAN_DBG_ENTER();
5587
5588 if (!cfg->nan_init_state) {
5589 WL_ERR(("nan is not initialized/nmi doesnt exists\n"));
5590 ret = BCME_OK;
5591 goto exit;
5592 }
5593
5594 mutex_lock(&cfg->if_sync);
5595 if (cfg->nan_enable) {
5596 ret = wl_cfgnan_disable(cfg, NAN_USER_INITIATED);
5597 if (ret) {
5598 WL_ERR(("failed to disable nan, error[%d]\n", ret));
5599 }
5600 }
5601 mutex_unlock(&cfg->if_sync);
5602 bzero(&nan_req_resp, sizeof(nan_req_resp));
5603 exit:
5604 ret = wl_cfgvendor_nan_cmd_reply(wiphy, NAN_WIFI_SUBCMD_DISABLE,
5605 &nan_req_resp, ret, BCME_OK);
5606 NAN_DBG_EXIT();
5607 return ret;
5608 }
5609
5610 static int
wl_cfgvendor_nan_config_handler(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)5611 wl_cfgvendor_nan_config_handler(struct wiphy *wiphy,
5612 struct wireless_dev *wdev, const void *data, int len)
5613 {
5614 int ret = 0;
5615 nan_config_cmd_data_t *cmd_data;
5616 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
5617 nan_hal_resp_t nan_req_resp;
5618 uint32 nan_attr_mask = 0;
5619
5620 cmd_data = MALLOCZ(cfg->osh, sizeof(*cmd_data));
5621 if (!cmd_data) {
5622 WL_ERR(("%s: memory allocation failed\n", __func__));
5623 ret = BCME_NOMEM;
5624 goto exit;
5625 }
5626 NAN_DBG_ENTER();
5627
5628 bzero(&nan_req_resp, sizeof(nan_req_resp));
5629
5630 cmd_data->avail_params.duration = NAN_BAND_INVALID; /* Setting to some default */
5631 cmd_data->sid_beacon.sid_enable = NAN_SID_ENABLE_FLAG_INVALID; /* Setting to some default */
5632 cmd_data->sid_beacon.sid_count = NAN_SID_BEACON_COUNT_INVALID; /* Setting to some default */
5633
5634 ret = wl_cfgvendor_nan_parse_args(wiphy, data, len, cmd_data, &nan_attr_mask);
5635 if (ret) {
5636 WL_ERR(("failed to parse nan vendor args, ret = %d\n", ret));
5637 goto exit;
5638 }
5639
5640 ret = wl_cfgnan_config_handler(wdev->netdev, cfg, cmd_data, nan_attr_mask);
5641 if (ret) {
5642 WL_ERR(("failed in config request, nan error[%d]\n", ret));
5643 goto exit;
5644 }
5645 exit:
5646 ret = wl_cfgvendor_nan_cmd_reply(wiphy, NAN_WIFI_SUBCMD_CONFIG,
5647 &nan_req_resp, ret, cmd_data ? cmd_data->status : BCME_OK);
5648 if (cmd_data) {
5649 if (cmd_data->scid.data) {
5650 MFREE(cfg->osh, cmd_data->scid.data, cmd_data->scid.dlen);
5651 cmd_data->scid.dlen = 0;
5652 }
5653 MFREE(cfg->osh, cmd_data, sizeof(*cmd_data));
5654 }
5655 NAN_DBG_EXIT();
5656 return ret;
5657 }
5658
5659 static int
wl_cfgvendor_nan_cancel_publish(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)5660 wl_cfgvendor_nan_cancel_publish(struct wiphy *wiphy,
5661 struct wireless_dev *wdev, const void * data, int len)
5662 {
5663 int ret = 0;
5664 nan_discover_cmd_data_t *cmd_data = NULL;
5665 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
5666 nan_hal_resp_t nan_req_resp;
5667
5668 /* Blocking Cancel_Publish if NAN is not enable */
5669 if (!cfg->nan_enable) {
5670 WL_ERR(("nan is not enabled, cancel publish blocked\n"));
5671 ret = BCME_ERROR;
5672 goto exit;
5673 }
5674 cmd_data = (nan_discover_cmd_data_t *)MALLOCZ(cfg->osh, sizeof(*cmd_data));
5675 if (!cmd_data) {
5676 WL_ERR(("%s: memory allocation failed\n", __func__));
5677 ret = BCME_NOMEM;
5678 goto exit;
5679 }
5680 NAN_DBG_ENTER();
5681
5682 bzero(&nan_req_resp, sizeof(nan_req_resp));
5683
5684 ret = wl_cfgvendor_nan_parse_discover_args(wiphy, data, len, cmd_data);
5685 if (ret) {
5686 WL_ERR(("failed to parse nan disc vendor args, ret= %d\n", ret));
5687 goto exit;
5688 }
5689 nan_req_resp.instance_id = cmd_data->pub_id;
5690 WL_INFORM_MEM(("[NAN] cancel publish instance_id=%d\n", cmd_data->pub_id));
5691
5692 ret = wl_cfgnan_cancel_pub_handler(wdev->netdev, cfg, cmd_data);
5693 if (ret) {
5694 WL_ERR(("failed to cancel publish nan instance-id[%d] error[%d]\n",
5695 cmd_data->pub_id, ret));
5696 goto exit;
5697 }
5698 exit:
5699 ret = wl_cfgvendor_nan_cmd_reply(wiphy, NAN_WIFI_SUBCMD_CANCEL_PUBLISH,
5700 &nan_req_resp, ret, cmd_data ? cmd_data->status : BCME_OK);
5701 wl_cfgvendor_free_disc_cmd_data(cfg, cmd_data);
5702 NAN_DBG_EXIT();
5703 return ret;
5704 }
5705
5706 static int
wl_cfgvendor_nan_cancel_subscribe(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)5707 wl_cfgvendor_nan_cancel_subscribe(struct wiphy *wiphy,
5708 struct wireless_dev *wdev, const void * data, int len)
5709 {
5710 int ret = 0;
5711 nan_discover_cmd_data_t *cmd_data = NULL;
5712 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
5713 nan_hal_resp_t nan_req_resp;
5714
5715 /* Blocking Cancel_Subscribe if NAN is not enableb */
5716 if (!cfg->nan_enable) {
5717 WL_ERR(("nan is not enabled, cancel subscribe blocked\n"));
5718 ret = BCME_ERROR;
5719 goto exit;
5720 }
5721 cmd_data = MALLOCZ(cfg->osh, sizeof(*cmd_data));
5722 if (!cmd_data) {
5723 WL_ERR(("%s: memory allocation failed\n", __func__));
5724 ret = BCME_NOMEM;
5725 goto exit;
5726 }
5727 NAN_DBG_ENTER();
5728
5729 bzero(&nan_req_resp, sizeof(nan_req_resp));
5730
5731 ret = wl_cfgvendor_nan_parse_discover_args(wiphy, data, len, cmd_data);
5732 if (ret) {
5733 WL_ERR(("failed to parse nan disc vendor args, ret= %d\n", ret));
5734 goto exit;
5735 }
5736 nan_req_resp.instance_id = cmd_data->sub_id;
5737 WL_INFORM_MEM(("[NAN] cancel subscribe instance_id=%d\n", cmd_data->sub_id));
5738
5739 ret = wl_cfgnan_cancel_sub_handler(wdev->netdev, cfg, cmd_data);
5740 if (ret) {
5741 WL_ERR(("failed to cancel subscribe nan instance-id[%d] error[%d]\n",
5742 cmd_data->sub_id, ret));
5743 goto exit;
5744 }
5745 exit:
5746 ret = wl_cfgvendor_nan_cmd_reply(wiphy, NAN_WIFI_SUBCMD_CANCEL_SUBSCRIBE,
5747 &nan_req_resp, ret, cmd_data ? cmd_data->status : BCME_OK);
5748 wl_cfgvendor_free_disc_cmd_data(cfg, cmd_data);
5749 NAN_DBG_EXIT();
5750 return ret;
5751 }
5752
5753 static int
wl_cfgvendor_nan_transmit(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)5754 wl_cfgvendor_nan_transmit(struct wiphy *wiphy,
5755 struct wireless_dev *wdev, const void * data, int len)
5756 {
5757 int ret = 0;
5758 nan_discover_cmd_data_t *cmd_data = NULL;
5759 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
5760 nan_hal_resp_t nan_req_resp;
5761
5762 /* Blocking Transmit if NAN is not enable */
5763 if (!cfg->nan_enable) {
5764 WL_ERR(("nan is not enabled, transmit blocked\n"));
5765 ret = BCME_ERROR;
5766 goto exit;
5767 }
5768 cmd_data = (nan_discover_cmd_data_t *)MALLOCZ(cfg->osh, sizeof(*cmd_data));
5769 if (!cmd_data) {
5770 WL_ERR(("%s: memory allocation failed\n", __func__));
5771 ret = BCME_NOMEM;
5772 goto exit;
5773 }
5774 NAN_DBG_ENTER();
5775
5776 bzero(&nan_req_resp, sizeof(nan_req_resp));
5777
5778 ret = wl_cfgvendor_nan_parse_discover_args(wiphy, data, len, cmd_data);
5779 if (ret) {
5780 WL_ERR(("failed to parse nan disc vendor args, ret= %d\n", ret));
5781 goto exit;
5782 }
5783 nan_req_resp.instance_id = cmd_data->local_id;
5784 ret = wl_cfgnan_transmit_handler(wdev->netdev, cfg, cmd_data);
5785 if (ret) {
5786 WL_ERR(("failed to transmit-followup nan error[%d]\n", ret));
5787 goto exit;
5788 }
5789 exit:
5790 ret = wl_cfgvendor_nan_cmd_reply(wiphy, NAN_WIFI_SUBCMD_TRANSMIT,
5791 &nan_req_resp, ret, cmd_data ? cmd_data->status : BCME_OK);
5792 wl_cfgvendor_free_disc_cmd_data(cfg, cmd_data);
5793 NAN_DBG_EXIT();
5794 return ret;
5795 }
5796
5797 static int
wl_cfgvendor_nan_get_capablities(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)5798 wl_cfgvendor_nan_get_capablities(struct wiphy *wiphy,
5799 struct wireless_dev *wdev, const void * data, int len)
5800 {
5801 int ret = 0;
5802 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
5803 nan_hal_resp_t nan_req_resp;
5804
5805 NAN_DBG_ENTER();
5806
5807 bzero(&nan_req_resp, sizeof(nan_req_resp));
5808 ret = wl_cfgnan_get_capablities_handler(wdev->netdev, cfg, &nan_req_resp.capabilities);
5809 if (ret) {
5810 WL_ERR(("Could not get capabilities\n"));
5811 ret = -EINVAL;
5812 goto exit;
5813 }
5814 exit:
5815 ret = wl_cfgvendor_nan_cmd_reply(wiphy, NAN_WIFI_SUBCMD_GET_CAPABILITIES,
5816 &nan_req_resp, ret, BCME_OK);
5817 wl_cfgvendor_send_cmd_reply(wiphy, &nan_req_resp, sizeof(nan_req_resp));
5818
5819 NAN_DBG_EXIT();
5820 return ret;
5821 }
5822
5823 static int
wl_cfgvendor_nan_data_path_iface_create(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)5824 wl_cfgvendor_nan_data_path_iface_create(struct wiphy *wiphy,
5825 struct wireless_dev *wdev, const void * data, int len)
5826 {
5827 int ret = 0;
5828 nan_datapath_cmd_data_t *cmd_data = NULL;
5829 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
5830 nan_hal_resp_t nan_req_resp;
5831 dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(wdev->netdev);
5832
5833 if (!cfg->nan_init_state) {
5834 WL_ERR(("%s: NAN is not inited or Device doesn't support NAN \n", __func__));
5835 ret = -ENODEV;
5836 goto exit;
5837 }
5838
5839 cmd_data = (nan_datapath_cmd_data_t *)MALLOCZ(cfg->osh, sizeof(*cmd_data));
5840 if (!cmd_data) {
5841 WL_ERR(("%s: memory allocation failed\n", __func__));
5842 ret = BCME_NOMEM;
5843 goto exit;
5844 }
5845 NAN_DBG_ENTER();
5846
5847 bzero(&nan_req_resp, sizeof(nan_req_resp));
5848
5849 ret = wl_cfgvendor_nan_parse_datapath_args(wiphy, data, len, cmd_data);
5850 if (ret) {
5851 WL_ERR(("failed to parse nan datapath vendor args, ret = %d\n", ret));
5852 goto exit;
5853 }
5854
5855 if (cfg->nan_enable) { /* new framework Impl, iface create called after nan enab */
5856 ret = wl_cfgnan_data_path_iface_create_delete_handler(wdev->netdev,
5857 cfg, cmd_data->ndp_iface,
5858 NAN_WIFI_SUBCMD_DATA_PATH_IFACE_CREATE, dhdp->up);
5859 if (ret != BCME_OK) {
5860 WL_ERR(("failed to create iface, ret = %d\n", ret));
5861 goto exit;
5862 }
5863 }
5864 exit:
5865 ret = wl_cfgvendor_nan_cmd_reply(wiphy, NAN_WIFI_SUBCMD_DATA_PATH_IFACE_CREATE,
5866 &nan_req_resp, ret, cmd_data ? cmd_data->status : BCME_OK);
5867 wl_cfgvendor_free_dp_cmd_data(cfg, cmd_data);
5868 NAN_DBG_EXIT();
5869 return ret;
5870 }
5871
5872 static int
wl_cfgvendor_nan_data_path_iface_delete(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)5873 wl_cfgvendor_nan_data_path_iface_delete(struct wiphy *wiphy,
5874 struct wireless_dev *wdev, const void * data, int len)
5875 {
5876 int ret = 0;
5877 nan_datapath_cmd_data_t *cmd_data = NULL;
5878 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
5879 nan_hal_resp_t nan_req_resp;
5880 dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(wdev->netdev);
5881
5882 if (cfg->nan_init_state == false) {
5883 WL_ERR(("%s: NAN is not inited or Device doesn't support NAN \n", __func__));
5884 /* Deinit has taken care of cleaing the virtual iface */
5885 ret = BCME_OK;
5886 goto exit;
5887 }
5888
5889 NAN_DBG_ENTER();
5890 cmd_data = (nan_datapath_cmd_data_t *)MALLOCZ(cfg->osh, sizeof(*cmd_data));
5891 if (!cmd_data) {
5892 WL_ERR(("%s: memory allocation failed\n", __func__));
5893 ret = BCME_NOMEM;
5894 goto exit;
5895 }
5896 bzero(&nan_req_resp, sizeof(nan_req_resp));
5897 ret = wl_cfgvendor_nan_parse_datapath_args(wiphy, data, len, cmd_data);
5898 if (ret) {
5899 WL_ERR(("failed to parse nan datapath vendor args, ret = %d\n", ret));
5900 goto exit;
5901 }
5902
5903 ret = wl_cfgnan_data_path_iface_create_delete_handler(wdev->netdev, cfg,
5904 (char*)cmd_data->ndp_iface,
5905 NAN_WIFI_SUBCMD_DATA_PATH_IFACE_DELETE, dhdp->up);
5906 if (ret) {
5907 WL_ERR(("failed to delete ndp iface [%d]\n", ret));
5908 goto exit;
5909 }
5910 exit:
5911 ret = wl_cfgvendor_nan_cmd_reply(wiphy, NAN_WIFI_SUBCMD_DATA_PATH_IFACE_DELETE,
5912 &nan_req_resp, ret, cmd_data ? cmd_data->status : BCME_OK);
5913 wl_cfgvendor_free_dp_cmd_data(cfg, cmd_data);
5914 NAN_DBG_EXIT();
5915 return ret;
5916 }
5917
5918 static int
wl_cfgvendor_nan_data_path_request(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)5919 wl_cfgvendor_nan_data_path_request(struct wiphy *wiphy,
5920 struct wireless_dev *wdev, const void * data, int len)
5921 {
5922 int ret = 0;
5923 nan_datapath_cmd_data_t *cmd_data = NULL;
5924 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
5925 nan_hal_resp_t nan_req_resp;
5926 uint8 ndp_instance_id = 0;
5927
5928 if (!cfg->nan_enable) {
5929 WL_ERR(("nan is not enabled, nan data path request blocked\n"));
5930 ret = BCME_ERROR;
5931 goto exit;
5932 }
5933
5934 NAN_DBG_ENTER();
5935 cmd_data = (nan_datapath_cmd_data_t *)MALLOCZ(cfg->osh, sizeof(*cmd_data));
5936 if (!cmd_data) {
5937 WL_ERR(("%s: memory allocation failed\n", __func__));
5938 ret = BCME_NOMEM;
5939 goto exit;
5940 }
5941
5942 bzero(&nan_req_resp, sizeof(nan_req_resp));
5943 ret = wl_cfgvendor_nan_parse_datapath_args(wiphy, data, len, cmd_data);
5944 if (ret) {
5945 WL_ERR(("failed to parse nan datapath vendor args, ret = %d\n", ret));
5946 goto exit;
5947 }
5948
5949 ret = wl_cfgnan_data_path_request_handler(wdev->netdev, cfg,
5950 cmd_data, &ndp_instance_id);
5951 if (ret) {
5952 WL_ERR(("failed to request nan data path [%d]\n", ret));
5953 goto exit;
5954 }
5955
5956 if (cmd_data->status == BCME_OK) {
5957 nan_req_resp.ndp_instance_id = cmd_data->ndp_instance_id;
5958 } else {
5959 nan_req_resp.ndp_instance_id = 0;
5960 }
5961 exit:
5962 ret = wl_cfgvendor_nan_cmd_reply(wiphy, NAN_WIFI_SUBCMD_DATA_PATH_REQUEST,
5963 &nan_req_resp, ret, cmd_data ? cmd_data->status : BCME_OK);
5964 wl_cfgvendor_free_dp_cmd_data(cfg, cmd_data);
5965 NAN_DBG_EXIT();
5966 return ret;
5967 }
5968
5969 static int
wl_cfgvendor_nan_data_path_response(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)5970 wl_cfgvendor_nan_data_path_response(struct wiphy *wiphy,
5971 struct wireless_dev *wdev, const void * data, int len)
5972 {
5973 int ret = 0;
5974 nan_datapath_cmd_data_t *cmd_data = NULL;
5975 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
5976 nan_hal_resp_t nan_req_resp;
5977
5978 if (!cfg->nan_enable) {
5979 WL_ERR(("nan is not enabled, nan data path response blocked\n"));
5980 ret = BCME_ERROR;
5981 goto exit;
5982 }
5983 NAN_DBG_ENTER();
5984 cmd_data = (nan_datapath_cmd_data_t *)MALLOCZ(cfg->osh, sizeof(*cmd_data));
5985 if (!cmd_data) {
5986 WL_ERR(("%s: memory allocation failed\n", __func__));
5987 ret = BCME_NOMEM;
5988 goto exit;
5989 }
5990
5991 bzero(&nan_req_resp, sizeof(nan_req_resp));
5992 ret = wl_cfgvendor_nan_parse_datapath_args(wiphy, data, len, cmd_data);
5993 if (ret) {
5994 WL_ERR(("failed to parse nan datapath vendor args, ret = %d\n", ret));
5995 goto exit;
5996 }
5997 ret = wl_cfgnan_data_path_response_handler(wdev->netdev, cfg, cmd_data);
5998 if (ret) {
5999 WL_ERR(("failed to response nan data path [%d]\n", ret));
6000 goto exit;
6001 }
6002 exit:
6003 ret = wl_cfgvendor_nan_cmd_reply(wiphy, NAN_WIFI_SUBCMD_DATA_PATH_RESPONSE,
6004 &nan_req_resp, ret, cmd_data ? cmd_data->status : BCME_OK);
6005 wl_cfgvendor_free_dp_cmd_data(cfg, cmd_data);
6006 NAN_DBG_EXIT();
6007 return ret;
6008 }
6009
6010 static int
wl_cfgvendor_nan_data_path_end(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6011 wl_cfgvendor_nan_data_path_end(struct wiphy *wiphy,
6012 struct wireless_dev *wdev, const void * data, int len)
6013 {
6014 int ret = 0;
6015 nan_datapath_cmd_data_t *cmd_data = NULL;
6016 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
6017 nan_hal_resp_t nan_req_resp;
6018
6019 NAN_DBG_ENTER();
6020 if (!cfg->nan_enable) {
6021 WL_ERR(("nan is not enabled, nan data path end blocked\n"));
6022 ret = BCME_OK;
6023 goto exit;
6024 }
6025 cmd_data = (nan_datapath_cmd_data_t *)MALLOCZ(cfg->osh, sizeof(*cmd_data));
6026 if (!cmd_data) {
6027 WL_ERR(("%s: memory allocation failed\n", __func__));
6028 ret = BCME_NOMEM;
6029 goto exit;
6030 }
6031
6032 bzero(&nan_req_resp, sizeof(nan_req_resp));
6033 ret = wl_cfgvendor_nan_parse_datapath_args(wiphy, data, len, cmd_data);
6034 if (ret) {
6035 WL_ERR(("failed to parse nan datapath vendor args, ret = %d\n", ret));
6036 goto exit;
6037 }
6038 ret = wl_cfgnan_data_path_end_handler(wdev->netdev, cfg, cmd_data);
6039 if (ret) {
6040 WL_ERR(("failed to end nan data path [%d]\n", ret));
6041 goto exit;
6042 }
6043 exit:
6044 ret = wl_cfgvendor_nan_cmd_reply(wiphy, NAN_WIFI_SUBCMD_DATA_PATH_END,
6045 &nan_req_resp, ret, cmd_data ? cmd_data->status : BCME_OK);
6046 wl_cfgvendor_free_dp_cmd_data(cfg, cmd_data);
6047 NAN_DBG_EXIT();
6048 return ret;
6049 }
6050
6051 #ifdef WL_NAN_DISC_CACHE
6052 static int
wl_cfgvendor_nan_data_path_sec_info(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6053 wl_cfgvendor_nan_data_path_sec_info(struct wiphy *wiphy,
6054 struct wireless_dev *wdev, const void *data, int len)
6055 {
6056 int ret = 0;
6057 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
6058 nan_hal_resp_t nan_req_resp;
6059 nan_datapath_sec_info_cmd_data_t *cmd_data = NULL;
6060 dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(wdev->netdev);
6061
6062 NAN_DBG_ENTER();
6063 if (!cfg->nan_enable) {
6064 WL_ERR(("nan is not enabled\n"));
6065 ret = BCME_UNSUPPORTED;
6066 goto exit;
6067 }
6068 cmd_data = MALLOCZ(dhdp->osh, sizeof(*cmd_data));
6069 if (!cmd_data) {
6070 WL_ERR(("%s: memory allocation failed\n", __func__));
6071 ret = BCME_NOMEM;
6072 goto exit;
6073 }
6074
6075 ret = wl_cfgvendor_nan_parse_dp_sec_info_args(wiphy, data, len, cmd_data);
6076 if (ret) {
6077 WL_ERR(("failed to parse sec info args\n"));
6078 goto exit;
6079 }
6080
6081 bzero(&nan_req_resp, sizeof(nan_req_resp));
6082 ret = wl_cfgnan_sec_info_handler(cfg, cmd_data, &nan_req_resp);
6083 if (ret) {
6084 WL_ERR(("failed to retrieve svc hash/pub nmi error[%d]\n", ret));
6085 goto exit;
6086 }
6087 exit:
6088 ret = wl_cfgvendor_nan_cmd_reply(wiphy, NAN_WIFI_SUBCMD_DATA_PATH_SEC_INFO,
6089 &nan_req_resp, ret, BCME_OK);
6090 if (cmd_data) {
6091 MFREE(dhdp->osh, cmd_data, sizeof(*cmd_data));
6092 }
6093 NAN_DBG_EXIT();
6094 return ret;
6095 }
6096 #endif /* WL_NAN_DISC_CACHE */
6097
6098 static int
wl_cfgvendor_nan_version_info(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6099 wl_cfgvendor_nan_version_info(struct wiphy *wiphy,
6100 struct wireless_dev *wdev, const void *data, int len)
6101 {
6102 int ret = BCME_OK;
6103 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
6104 uint32 version = NAN_HAL_VERSION_1;
6105
6106 BCM_REFERENCE(cfg);
6107 WL_DBG(("Enter %s version %d\n", __FUNCTION__, version));
6108 ret = wl_cfgvendor_send_cmd_reply(wiphy, &version, sizeof(version));
6109 return ret;
6110 }
6111
6112 #endif /* WL_NAN */
6113
6114 #ifdef LINKSTAT_SUPPORT
6115
6116 #define NUM_RATE 32
6117 #define NUM_PEER 1
6118 #define NUM_CHAN 11
6119 #define HEADER_SIZE sizeof(ver_len)
6120
wl_cfgvendor_lstats_get_bcn_mbss(char * buf,uint32 * rxbeaconmbss)6121 static int wl_cfgvendor_lstats_get_bcn_mbss(char *buf, uint32 *rxbeaconmbss)
6122 {
6123 wl_cnt_info_t *cbuf = (wl_cnt_info_t *)buf;
6124 const void *cnt;
6125
6126 if ((cnt = (const void *)bcm_get_data_from_xtlv_buf(cbuf->data, cbuf->datalen,
6127 WL_CNT_XTLV_CNTV_LE10_UCODE, NULL, BCM_XTLV_OPTION_ALIGN32)) != NULL) {
6128 *rxbeaconmbss = ((const wl_cnt_v_le10_mcst_t *)cnt)->rxbeaconmbss;
6129 } else if ((cnt = (const void *)bcm_get_data_from_xtlv_buf(cbuf->data, cbuf->datalen,
6130 WL_CNT_XTLV_LT40_UCODE_V1, NULL, BCM_XTLV_OPTION_ALIGN32)) != NULL) {
6131 *rxbeaconmbss = ((const wl_cnt_lt40mcst_v1_t *)cnt)->rxbeaconmbss;
6132 } else if ((cnt = (const void *)bcm_get_data_from_xtlv_buf(cbuf->data, cbuf->datalen,
6133 WL_CNT_XTLV_GE40_UCODE_V1, NULL, BCM_XTLV_OPTION_ALIGN32)) != NULL) {
6134 *rxbeaconmbss = ((const wl_cnt_ge40mcst_v1_t *)cnt)->rxbeaconmbss;
6135 } else if ((cnt = (const void *)bcm_get_data_from_xtlv_buf(cbuf->data, cbuf->datalen,
6136 WL_CNT_XTLV_GE80_UCODE_V1, NULL, BCM_XTLV_OPTION_ALIGN32)) != NULL) {
6137 *rxbeaconmbss = ((const wl_cnt_ge80mcst_v1_t *)cnt)->rxbeaconmbss;
6138 } else {
6139 *rxbeaconmbss = 0;
6140 return BCME_NOTFOUND;
6141 }
6142
6143 return BCME_OK;
6144 }
6145
wl_cfgvendor_lstats_get_info(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6146 static int wl_cfgvendor_lstats_get_info(struct wiphy *wiphy,
6147 struct wireless_dev *wdev, const void *data, int len)
6148 {
6149 static char iovar_buf[WLC_IOCTL_MAXLEN];
6150 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
6151 int err = 0, i;
6152 wifi_radio_stat *radio;
6153 wifi_radio_stat_h radio_h;
6154 wl_wme_cnt_t *wl_wme_cnt;
6155 const wl_cnt_wlc_t *wlc_cnt;
6156 scb_val_t scbval;
6157 char *output = NULL;
6158 char *outdata = NULL;
6159 wifi_rate_stat_v1 *p_wifi_rate_stat_v1 = NULL;
6160 wifi_rate_stat *p_wifi_rate_stat = NULL;
6161 uint total_len = 0;
6162 uint32 rxbeaconmbss;
6163 wifi_iface_stat iface;
6164 wlc_rev_info_t revinfo;
6165
6166 WL_INFORM_MEM(("%s: Enter \n", __func__));
6167 RETURN_EIO_IF_NOT_UP(cfg);
6168
6169 /* Get the device rev info */
6170 bzero(&revinfo, sizeof(revinfo));
6171 err = wldev_ioctl_get(bcmcfg_to_prmry_ndev(cfg), WLC_GET_REVINFO, &revinfo,
6172 sizeof(revinfo));
6173 if (err != BCME_OK) {
6174 goto exit;
6175 }
6176
6177 outdata = (void *)MALLOCZ(cfg->osh, WLC_IOCTL_MAXLEN);
6178 if (outdata == NULL) {
6179 WL_ERR(("%s: alloc failed\n", __func__));
6180 return -ENOMEM;
6181 }
6182
6183 bzero(&scbval, sizeof(scb_val_t));
6184 bzero(outdata, WLC_IOCTL_MAXLEN);
6185 output = outdata;
6186
6187 err = wldev_iovar_getbuf(bcmcfg_to_prmry_ndev(cfg), "radiostat", NULL, 0,
6188 iovar_buf, WLC_IOCTL_MAXLEN, NULL);
6189 if (err != BCME_OK && err != BCME_UNSUPPORTED) {
6190 WL_ERR(("error (%d) - size = %zu\n", err, sizeof(wifi_radio_stat)));
6191 goto exit;
6192 }
6193 radio = (wifi_radio_stat *)iovar_buf;
6194
6195 bzero(&radio_h, sizeof(wifi_radio_stat_h));
6196 radio_h.on_time = radio->on_time;
6197 radio_h.tx_time = radio->tx_time;
6198 radio_h.rx_time = radio->rx_time;
6199 radio_h.on_time_scan = radio->on_time_scan;
6200 radio_h.on_time_nbd = radio->on_time_nbd;
6201 radio_h.on_time_gscan = radio->on_time_gscan;
6202 radio_h.on_time_roam_scan = radio->on_time_roam_scan;
6203 radio_h.on_time_pno_scan = radio->on_time_pno_scan;
6204 radio_h.on_time_hs20 = radio->on_time_hs20;
6205 radio_h.num_channels = NUM_CHAN;
6206
6207 memcpy(output, &radio_h, sizeof(wifi_radio_stat_h));
6208
6209 output += sizeof(wifi_radio_stat_h);
6210 output += (NUM_CHAN * sizeof(wifi_channel_stat));
6211
6212 err = wldev_iovar_getbuf(bcmcfg_to_prmry_ndev(cfg), "wme_counters", NULL, 0,
6213 iovar_buf, WLC_IOCTL_MAXLEN, NULL);
6214 if (unlikely(err)) {
6215 WL_ERR(("error (%d)\n", err));
6216 goto exit;
6217 }
6218 wl_wme_cnt = (wl_wme_cnt_t *)iovar_buf;
6219
6220 COMPAT_ASSIGN_VALUE(iface, ac[WIFI_AC_VO].ac, WIFI_AC_VO);
6221 COMPAT_ASSIGN_VALUE(iface, ac[WIFI_AC_VO].tx_mpdu, wl_wme_cnt->tx[AC_VO].packets);
6222 COMPAT_ASSIGN_VALUE(iface, ac[WIFI_AC_VO].rx_mpdu, wl_wme_cnt->rx[AC_VO].packets);
6223 COMPAT_ASSIGN_VALUE(iface, ac[WIFI_AC_VO].mpdu_lost,
6224 wl_wme_cnt->tx_failed[WIFI_AC_VO].packets);
6225
6226 COMPAT_ASSIGN_VALUE(iface, ac[WIFI_AC_VI].ac, WIFI_AC_VI);
6227 COMPAT_ASSIGN_VALUE(iface, ac[WIFI_AC_VI].tx_mpdu, wl_wme_cnt->tx[AC_VI].packets);
6228 COMPAT_ASSIGN_VALUE(iface, ac[WIFI_AC_VI].rx_mpdu, wl_wme_cnt->rx[AC_VI].packets);
6229 COMPAT_ASSIGN_VALUE(iface, ac[WIFI_AC_VI].mpdu_lost,
6230 wl_wme_cnt->tx_failed[WIFI_AC_VI].packets);
6231
6232 COMPAT_ASSIGN_VALUE(iface, ac[WIFI_AC_BE].ac, WIFI_AC_BE);
6233 COMPAT_ASSIGN_VALUE(iface, ac[WIFI_AC_BE].tx_mpdu, wl_wme_cnt->tx[AC_BE].packets);
6234 COMPAT_ASSIGN_VALUE(iface, ac[WIFI_AC_BE].rx_mpdu, wl_wme_cnt->rx[AC_BE].packets);
6235 COMPAT_ASSIGN_VALUE(iface, ac[WIFI_AC_BE].mpdu_lost,
6236 wl_wme_cnt->tx_failed[WIFI_AC_BE].packets);
6237
6238 COMPAT_ASSIGN_VALUE(iface, ac[WIFI_AC_BK].ac, WIFI_AC_BK);
6239 COMPAT_ASSIGN_VALUE(iface, ac[WIFI_AC_BK].tx_mpdu, wl_wme_cnt->tx[AC_BK].packets);
6240 COMPAT_ASSIGN_VALUE(iface, ac[WIFI_AC_BK].rx_mpdu, wl_wme_cnt->rx[AC_BK].packets);
6241 COMPAT_ASSIGN_VALUE(iface, ac[WIFI_AC_BK].mpdu_lost,
6242 wl_wme_cnt->tx_failed[WIFI_AC_BK].packets);
6243
6244 err = wldev_iovar_getbuf(bcmcfg_to_prmry_ndev(cfg), "counters", NULL, 0,
6245 iovar_buf, WLC_IOCTL_MAXLEN, NULL);
6246 if (unlikely(err)) {
6247 WL_ERR(("error (%d) - size = %zu\n", err, sizeof(wl_cnt_wlc_t)));
6248 goto exit;
6249 }
6250
6251 CHK_CNTBUF_DATALEN(iovar_buf, WLC_IOCTL_MAXLEN);
6252 /* Translate traditional (ver <= 10) counters struct to new xtlv type struct */
6253 err = wl_cntbuf_to_xtlv_format(NULL, iovar_buf, WLC_IOCTL_MAXLEN, revinfo.corerev);
6254 if (err != BCME_OK) {
6255 WL_ERR(("%s wl_cntbuf_to_xtlv_format ERR %d\n",
6256 __FUNCTION__, err));
6257 goto exit;
6258 }
6259
6260 if (!(wlc_cnt = GET_WLCCNT_FROM_CNTBUF(iovar_buf))) {
6261 WL_ERR(("%s wlc_cnt NULL!\n", __FUNCTION__));
6262 err = BCME_ERROR;
6263 goto exit;
6264 }
6265
6266 COMPAT_ASSIGN_VALUE(iface, ac[WIFI_AC_BE].retries, wlc_cnt->txretry);
6267
6268 err = wl_cfgvendor_lstats_get_bcn_mbss(iovar_buf, &rxbeaconmbss);
6269 if (unlikely(err)) {
6270 WL_ERR(("get_bcn_mbss error (%d)\n", err));
6271 goto exit;
6272 }
6273
6274 err = wldev_get_rssi(bcmcfg_to_prmry_ndev(cfg), &scbval);
6275 if (unlikely(err)) {
6276 WL_ERR(("get_rssi error (%d)\n", err));
6277 goto exit;
6278 }
6279
6280 COMPAT_ASSIGN_VALUE(iface, beacon_rx, rxbeaconmbss);
6281 COMPAT_ASSIGN_VALUE(iface, rssi_mgmt, scbval.val);
6282 COMPAT_ASSIGN_VALUE(iface, num_peers, NUM_PEER);
6283 COMPAT_ASSIGN_VALUE(iface, peer_info->num_rate, NUM_RATE);
6284
6285 {
6286 memcpy(output, &iface, sizeof(iface));
6287 output += (sizeof(iface) - sizeof(wifi_rate_stat));
6288 }
6289
6290 err = wldev_iovar_getbuf(bcmcfg_to_prmry_ndev(cfg), "ratestat", NULL, 0,
6291 iovar_buf, WLC_IOCTL_MAXLEN, NULL);
6292 if (err != BCME_OK && err != BCME_UNSUPPORTED) {
6293 WL_ERR(("error (%d) - size = %zu\n", err, NUM_RATE*sizeof(wifi_rate_stat)));
6294 goto exit;
6295 }
6296 for (i = 0; i < NUM_RATE; i++) {
6297 p_wifi_rate_stat =
6298 (wifi_rate_stat *)(iovar_buf + i*sizeof(wifi_rate_stat));
6299 p_wifi_rate_stat_v1 = (wifi_rate_stat_v1 *)output;
6300 p_wifi_rate_stat_v1->rate.preamble = p_wifi_rate_stat->rate.preamble;
6301 p_wifi_rate_stat_v1->rate.nss = p_wifi_rate_stat->rate.nss;
6302 p_wifi_rate_stat_v1->rate.bw = p_wifi_rate_stat->rate.bw;
6303 p_wifi_rate_stat_v1->rate.rateMcsIdx = p_wifi_rate_stat->rate.rateMcsIdx;
6304 p_wifi_rate_stat_v1->rate.reserved = p_wifi_rate_stat->rate.reserved;
6305 p_wifi_rate_stat_v1->rate.bitrate = p_wifi_rate_stat->rate.bitrate;
6306 p_wifi_rate_stat_v1->tx_mpdu = p_wifi_rate_stat->tx_mpdu;
6307 p_wifi_rate_stat_v1->rx_mpdu = p_wifi_rate_stat->rx_mpdu;
6308 p_wifi_rate_stat_v1->mpdu_lost = p_wifi_rate_stat->mpdu_lost;
6309 p_wifi_rate_stat_v1->retries = p_wifi_rate_stat->retries;
6310 p_wifi_rate_stat_v1->retries_short = p_wifi_rate_stat->retries_short;
6311 p_wifi_rate_stat_v1->retries_long = p_wifi_rate_stat->retries_long;
6312 output = (char *) &(p_wifi_rate_stat_v1->retries_long);
6313 output += sizeof(p_wifi_rate_stat_v1->retries_long);
6314 }
6315
6316 total_len = sizeof(wifi_radio_stat_h) +
6317 NUM_CHAN * sizeof(wifi_channel_stat);
6318
6319 {
6320 total_len += sizeof(wifi_iface_stat);
6321 }
6322
6323 total_len = total_len - sizeof(wifi_peer_info) +
6324 NUM_PEER * (sizeof(wifi_peer_info) - sizeof(wifi_rate_stat_v1) +
6325 NUM_RATE * sizeof(wifi_rate_stat_v1));
6326
6327 if (total_len > WLC_IOCTL_MAXLEN) {
6328 WL_ERR(("Error! total_len:%d is unexpected value\n", total_len));
6329 err = BCME_BADLEN;
6330 goto exit;
6331 }
6332 err = wl_cfgvendor_send_cmd_reply(wiphy, outdata, total_len);
6333
6334 if (unlikely(err))
6335 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
6336
6337 exit:
6338 if (outdata) {
6339 MFREE(cfg->osh, outdata, WLC_IOCTL_MAXLEN);
6340 }
6341 return err;
6342 }
6343 #endif /* LINKSTAT_SUPPORT */
6344
6345 #ifdef DHD_LOG_DUMP
6346 static int
wl_cfgvendor_get_buf_data(const struct nlattr * iter,struct buf_data ** buf)6347 wl_cfgvendor_get_buf_data(const struct nlattr *iter, struct buf_data **buf)
6348 {
6349 int ret = BCME_OK;
6350
6351 if (nla_len(iter) != sizeof(struct buf_data)) {
6352 WL_ERR(("Invalid len : %d\n", nla_len(iter)));
6353 ret = BCME_BADLEN;
6354 }
6355 (*buf) = (struct buf_data *)nla_data(iter);
6356 if (!(*buf) || (((*buf)->len) <= 0) || !((*buf)->data_buf[0])) {
6357 WL_ERR(("Invalid buffer\n"));
6358 ret = BCME_ERROR;
6359 }
6360 return ret;
6361 }
6362
6363 static int
wl_cfgvendor_dbg_file_dump(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6364 wl_cfgvendor_dbg_file_dump(struct wiphy *wiphy,
6365 struct wireless_dev *wdev, const void *data, int len)
6366 {
6367 int ret = BCME_OK, rem, type = 0;
6368 const struct nlattr *iter;
6369 char *mem_buf = NULL;
6370 struct sk_buff *skb = NULL;
6371 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
6372 struct buf_data *buf;
6373 int pos = 0;
6374
6375 /* Alloc the SKB for vendor_event */
6376 skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, CFG80211_VENDOR_CMD_REPLY_SKB_SZ);
6377 if (!skb) {
6378 WL_ERR(("skb allocation is failed\n"));
6379 ret = BCME_NOMEM;
6380 goto exit;
6381 }
6382 WL_ERR(("%s\n", __FUNCTION__));
6383 nla_for_each_attr(iter, data, len, rem) {
6384 type = nla_type(iter);
6385 ret = wl_cfgvendor_get_buf_data(iter, &buf);
6386 if (ret)
6387 goto exit;
6388 switch (type) {
6389 case DUMP_BUF_ATTR_MEMDUMP:
6390 ret = dhd_os_get_socram_dump(bcmcfg_to_prmry_ndev(cfg), &mem_buf,
6391 (uint32 *)(&(buf->len)));
6392 if (ret) {
6393 WL_ERR(("failed to get_socram_dump : %d\n", ret));
6394 goto exit;
6395 }
6396 ret = dhd_export_debug_data(mem_buf, NULL, buf->data_buf[0],
6397 (int)buf->len, &pos);
6398 break;
6399
6400 case DUMP_BUF_ATTR_TIMESTAMP :
6401 ret = dhd_print_time_str(buf->data_buf[0], NULL,
6402 (uint32)buf->len, &pos);
6403 break;
6404 #ifdef EWP_ECNTRS_LOGGING
6405 case DUMP_BUF_ATTR_ECNTRS :
6406 ret = dhd_print_ecntrs_data(bcmcfg_to_prmry_ndev(cfg), NULL,
6407 buf->data_buf[0], NULL, (uint32)buf->len, &pos);
6408 break;
6409 #endif /* EWP_ECNTRS_LOGGING */
6410 #ifdef DHD_STATUS_LOGGING
6411 case DUMP_BUF_ATTR_STATUS_LOG :
6412 ret = dhd_print_status_log_data(bcmcfg_to_prmry_ndev(cfg), NULL,
6413 buf->data_buf[0], NULL, (uint32)buf->len, &pos);
6414 break;
6415 #endif /* DHD_STATUS_LOGGING */
6416 #ifdef EWP_RTT_LOGGING
6417 case DUMP_BUF_ATTR_RTT_LOG :
6418 ret = dhd_print_rtt_data(bcmcfg_to_prmry_ndev(cfg), NULL,
6419 buf->data_buf[0], NULL, (uint32)buf->len, &pos);
6420 break;
6421 #endif /* EWP_RTT_LOGGING */
6422 case DUMP_BUF_ATTR_DHD_DUMP :
6423 ret = dhd_print_dump_data(bcmcfg_to_prmry_ndev(cfg), NULL,
6424 buf->data_buf[0], NULL, (uint32)buf->len, &pos);
6425 break;
6426 #if defined(BCMPCIE)
6427 case DUMP_BUF_ATTR_EXT_TRAP :
6428 ret = dhd_print_ext_trap_data(bcmcfg_to_prmry_ndev(cfg), NULL,
6429 buf->data_buf[0], NULL, (uint32)buf->len, &pos);
6430 break;
6431 #endif /* BCMPCIE */
6432 #if defined(DHD_FW_COREDUMP) && defined(DNGL_EVENT_SUPPORT)
6433 case DUMP_BUF_ATTR_HEALTH_CHK :
6434 ret = dhd_print_health_chk_data(bcmcfg_to_prmry_ndev(cfg), NULL,
6435 buf->data_buf[0], NULL, (uint32)buf->len, &pos);
6436 break;
6437 #endif // endif
6438 case DUMP_BUF_ATTR_COOKIE :
6439 ret = dhd_print_cookie_data(bcmcfg_to_prmry_ndev(cfg), NULL,
6440 buf->data_buf[0], NULL, (uint32)buf->len, &pos);
6441 break;
6442 #ifdef DHD_DUMP_PCIE_RINGS
6443 case DUMP_BUF_ATTR_FLOWRING_DUMP :
6444 ret = dhd_print_flowring_data(bcmcfg_to_prmry_ndev(cfg), NULL,
6445 buf->data_buf[0], NULL, (uint32)buf->len, &pos);
6446 break;
6447 #endif // endif
6448 case DUMP_BUF_ATTR_GENERAL_LOG :
6449 ret = dhd_get_dld_log_dump(bcmcfg_to_prmry_ndev(cfg), NULL,
6450 buf->data_buf[0], NULL, (uint32)buf->len,
6451 DLD_BUF_TYPE_GENERAL, &pos);
6452 break;
6453
6454 case DUMP_BUF_ATTR_PRESERVE_LOG :
6455 ret = dhd_get_dld_log_dump(bcmcfg_to_prmry_ndev(cfg), NULL,
6456 buf->data_buf[0], NULL, (uint32)buf->len,
6457 DLD_BUF_TYPE_PRESERVE, &pos);
6458 break;
6459
6460 case DUMP_BUF_ATTR_SPECIAL_LOG :
6461 ret = dhd_get_dld_log_dump(bcmcfg_to_prmry_ndev(cfg), NULL,
6462 buf->data_buf[0], NULL, (uint32)buf->len,
6463 DLD_BUF_TYPE_SPECIAL, &pos);
6464 break;
6465 #ifdef DHD_SSSR_DUMP
6466 case DUMP_BUF_ATTR_SSSR_C0_D11_BEFORE :
6467 ret = dhd_sssr_dump_d11_buf_before(bcmcfg_to_prmry_ndev(cfg),
6468 buf->data_buf[0], (uint32)buf->len, 0);
6469 break;
6470
6471 case DUMP_BUF_ATTR_SSSR_C0_D11_AFTER :
6472 ret = dhd_sssr_dump_d11_buf_after(bcmcfg_to_prmry_ndev(cfg),
6473 buf->data_buf[0], (uint32)buf->len, 0);
6474 break;
6475
6476 case DUMP_BUF_ATTR_SSSR_C1_D11_BEFORE :
6477 ret = dhd_sssr_dump_d11_buf_before(bcmcfg_to_prmry_ndev(cfg),
6478 buf->data_buf[0], (uint32)buf->len, 1);
6479 break;
6480
6481 case DUMP_BUF_ATTR_SSSR_C1_D11_AFTER :
6482 ret = dhd_sssr_dump_d11_buf_after(bcmcfg_to_prmry_ndev(cfg),
6483 buf->data_buf[0], (uint32)buf->len, 1);
6484 break;
6485
6486 case DUMP_BUF_ATTR_SSSR_DIG_BEFORE :
6487 ret = dhd_sssr_dump_dig_buf_before(bcmcfg_to_prmry_ndev(cfg),
6488 buf->data_buf[0], (uint32)buf->len);
6489 break;
6490
6491 case DUMP_BUF_ATTR_SSSR_DIG_AFTER :
6492 ret = dhd_sssr_dump_dig_buf_after(bcmcfg_to_prmry_ndev(cfg),
6493 buf->data_buf[0], (uint32)buf->len);
6494 break;
6495 #endif /* DHD_SSSR_DUMP */
6496 #ifdef DHD_PKT_LOGGING
6497 case DUMP_BUF_ATTR_PKTLOG:
6498 ret = dhd_os_get_pktlog_dump(bcmcfg_to_prmry_ndev(cfg),
6499 buf->data_buf[0], (uint32)buf->len);
6500 break;
6501 #endif /* DHD_PKT_LOGGING */
6502 #ifdef DNGL_AXI_ERROR_LOGGING
6503 case DUMP_BUF_ATTR_AXI_ERROR:
6504 ret = dhd_os_get_axi_error_dump(bcmcfg_to_prmry_ndev(cfg),
6505 buf->data_buf[0], (uint32)buf->len);
6506 break;
6507 #endif /* DNGL_AXI_ERROR_LOGGING */
6508 default:
6509 WL_ERR(("Unknown type: %d\n", type));
6510 ret = BCME_ERROR;
6511 goto exit;
6512 }
6513 }
6514
6515 if (ret)
6516 goto exit;
6517
6518 ret = nla_put_u32(skb, type, (uint32)(ret));
6519 if (ret < 0) {
6520 WL_ERR(("Failed to put type, ret:%d\n", ret));
6521 goto exit;
6522 }
6523 ret = cfg80211_vendor_cmd_reply(skb);
6524 if (ret) {
6525 WL_ERR(("Vendor Command reply failed ret:%d \n", ret));
6526 }
6527 return ret;
6528 exit:
6529 if (skb) {
6530 /* Free skb memory */
6531 kfree_skb(skb);
6532 }
6533 return ret;
6534 }
6535 #endif /* DHD_LOG_DUMP */
6536
6537 #ifdef DEBUGABILITY
6538 static int
wl_cfgvendor_dbg_trigger_mem_dump(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6539 wl_cfgvendor_dbg_trigger_mem_dump(struct wiphy *wiphy,
6540 struct wireless_dev *wdev, const void *data, int len)
6541 {
6542 int ret = BCME_OK;
6543 uint32 alloc_len;
6544 struct sk_buff *skb = NULL;
6545 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
6546 dhd_pub_t *dhdp = (dhd_pub_t *)(cfg->pub);
6547
6548 WL_ERR(("wl_cfgvendor_dbg_trigger_mem_dump %d\n", __LINE__));
6549
6550 dhdp->memdump_type = DUMP_TYPE_CFG_VENDOR_TRIGGERED;
6551 ret = dhd_os_socram_dump(bcmcfg_to_prmry_ndev(cfg), &alloc_len);
6552 if (ret) {
6553 WL_ERR(("failed to call dhd_os_socram_dump : %d\n", ret));
6554 goto exit;
6555 }
6556 /* Alloc the SKB for vendor_event */
6557 skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, CFG80211_VENDOR_CMD_REPLY_SKB_SZ);
6558 if (!skb) {
6559 WL_ERR(("skb allocation is failed\n"));
6560 ret = BCME_NOMEM;
6561 goto exit;
6562 }
6563 ret = nla_put_u32(skb, DEBUG_ATTRIBUTE_FW_DUMP_LEN, alloc_len);
6564
6565 if (unlikely(ret)) {
6566 WL_ERR(("Failed to put fw dump length, ret=%d\n", ret));
6567 goto exit;
6568 }
6569
6570 ret = cfg80211_vendor_cmd_reply(skb);
6571
6572 if (ret) {
6573 WL_ERR(("Vendor Command reply failed ret:%d \n", ret));
6574 goto exit;
6575 }
6576 return ret;
6577 exit:
6578 /* Free skb memory */
6579 if (skb) {
6580 kfree_skb(skb);
6581 }
6582 return ret;
6583 }
6584
6585 static int
wl_cfgvendor_dbg_get_mem_dump(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6586 wl_cfgvendor_dbg_get_mem_dump(struct wiphy *wiphy,
6587 struct wireless_dev *wdev, const void *data, int len)
6588 {
6589 int ret = BCME_OK, rem, type;
6590 int buf_len = 0;
6591 uintptr_t user_buf = (uintptr_t)NULL;
6592 const struct nlattr *iter;
6593 char *mem_buf = NULL;
6594 struct sk_buff *skb = NULL;
6595 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
6596
6597 nla_for_each_attr(iter, data, len, rem) {
6598 type = nla_type(iter);
6599 switch (type) {
6600 case DEBUG_ATTRIBUTE_FW_DUMP_LEN:
6601 /* Check if the iter is valid and
6602 * buffer length is not already initialized.
6603 */
6604 if ((nla_len(iter) == sizeof(uint32)) &&
6605 !buf_len) {
6606 buf_len = nla_get_u32(iter);
6607 if (buf_len <= 0) {
6608 ret = BCME_ERROR;
6609 goto exit;
6610 }
6611 } else {
6612 ret = BCME_ERROR;
6613 goto exit;
6614 }
6615 break;
6616 case DEBUG_ATTRIBUTE_FW_DUMP_DATA:
6617 if (nla_len(iter) != sizeof(uint64)) {
6618 WL_ERR(("Invalid len\n"));
6619 ret = BCME_ERROR;
6620 goto exit;
6621 }
6622 user_buf = (uintptr_t)nla_get_u64(iter);
6623 if (!user_buf) {
6624 ret = BCME_ERROR;
6625 goto exit;
6626 }
6627 break;
6628 default:
6629 WL_ERR(("Unknown type: %d\n", type));
6630 ret = BCME_ERROR;
6631 goto exit;
6632 }
6633 }
6634 if (buf_len > 0 && user_buf) {
6635 mem_buf = vmalloc(buf_len);
6636 if (!mem_buf) {
6637 WL_ERR(("failed to allocate mem_buf with size : %d\n", buf_len));
6638 ret = BCME_NOMEM;
6639 goto exit;
6640 }
6641 ret = dhd_os_get_socram_dump(bcmcfg_to_prmry_ndev(cfg), &mem_buf, &buf_len);
6642 if (ret) {
6643 WL_ERR(("failed to get_socram_dump : %d\n", ret));
6644 goto free_mem;
6645 }
6646 {
6647 ret = copy_to_user((void*)user_buf, mem_buf, buf_len);
6648 if (ret) {
6649 WL_ERR(("failed to copy memdump into user buffer : %d\n", ret));
6650 goto free_mem;
6651 }
6652 }
6653 /* Alloc the SKB for vendor_event */
6654 skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, CFG80211_VENDOR_CMD_REPLY_SKB_SZ);
6655 if (!skb) {
6656 WL_ERR(("skb allocation is failed\n"));
6657 ret = BCME_NOMEM;
6658 goto free_mem;
6659 }
6660 /* Indicate the memdump is succesfully copied */
6661 ret = nla_put(skb, DEBUG_ATTRIBUTE_FW_DUMP_DATA, sizeof(ret), &ret);
6662 if (ret < 0) {
6663 WL_ERR(("Failed to put DEBUG_ATTRIBUTE_FW_DUMP_DATA, ret:%d\n", ret));
6664 goto free_mem;
6665 }
6666
6667 ret = cfg80211_vendor_cmd_reply(skb);
6668
6669 if (ret) {
6670 WL_ERR(("Vendor Command reply failed ret:%d \n", ret));
6671 }
6672 skb = NULL;
6673 }
6674
6675 free_mem:
6676 vfree(mem_buf);
6677 /* Free skb memory */
6678 if (skb) {
6679 kfree_skb(skb);
6680 }
6681 exit:
6682 return ret;
6683 }
6684
wl_cfgvendor_dbg_start_logging(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6685 static int wl_cfgvendor_dbg_start_logging(struct wiphy *wiphy,
6686 struct wireless_dev *wdev, const void *data, int len)
6687 {
6688 int ret = BCME_OK, rem, type;
6689 char ring_name[DBGRING_NAME_MAX] = {0};
6690 int log_level = 0, flags = 0, time_intval = 0, threshold = 0;
6691 const struct nlattr *iter;
6692 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
6693 dhd_pub_t *dhd_pub = cfg->pub;
6694 nla_for_each_attr(iter, data, len, rem) {
6695 type = nla_type(iter);
6696 switch (type) {
6697 case DEBUG_ATTRIBUTE_RING_NAME:
6698 strncpy(ring_name, nla_data(iter),
6699 MIN(sizeof(ring_name) -1, nla_len(iter)));
6700 break;
6701 case DEBUG_ATTRIBUTE_LOG_LEVEL:
6702 log_level = nla_get_u32(iter);
6703 break;
6704 case DEBUG_ATTRIBUTE_RING_FLAGS:
6705 flags = nla_get_u32(iter);
6706 break;
6707 case DEBUG_ATTRIBUTE_LOG_TIME_INTVAL:
6708 time_intval = nla_get_u32(iter);
6709 break;
6710 case DEBUG_ATTRIBUTE_LOG_MIN_DATA_SIZE:
6711 threshold = nla_get_u32(iter);
6712 break;
6713 default:
6714 WL_ERR(("Unknown type: %d\n", type));
6715 ret = BCME_BADADDR;
6716 goto exit;
6717 }
6718 }
6719
6720 ret = dhd_os_start_logging(dhd_pub, ring_name, log_level, flags, time_intval, threshold);
6721 if (ret < 0) {
6722 WL_ERR(("start_logging is failed ret: %d\n", ret));
6723 }
6724 exit:
6725 return ret;
6726 }
6727
wl_cfgvendor_dbg_reset_logging(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6728 static int wl_cfgvendor_dbg_reset_logging(struct wiphy *wiphy,
6729 struct wireless_dev *wdev, const void *data, int len)
6730 {
6731 int ret = BCME_OK;
6732 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
6733 dhd_pub_t *dhd_pub = cfg->pub;
6734
6735 ret = dhd_os_reset_logging(dhd_pub);
6736 if (ret < 0) {
6737 WL_ERR(("reset logging is failed ret: %d\n", ret));
6738 }
6739
6740 return ret;
6741 }
6742
wl_cfgvendor_dbg_get_ring_status(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6743 static int wl_cfgvendor_dbg_get_ring_status(struct wiphy *wiphy,
6744 struct wireless_dev *wdev, const void *data, int len)
6745 {
6746 int ret = BCME_OK;
6747 int ring_id, i;
6748 int ring_cnt;
6749 struct sk_buff *skb;
6750 dhd_dbg_ring_status_t dbg_ring_status[DEBUG_RING_ID_MAX];
6751 dhd_dbg_ring_status_t ring_status;
6752 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
6753 dhd_pub_t *dhd_pub = cfg->pub;
6754 bzero(dbg_ring_status, DBG_RING_STATUS_SIZE * DEBUG_RING_ID_MAX);
6755 ring_cnt = 0;
6756 for (ring_id = DEBUG_RING_ID_INVALID + 1; ring_id < DEBUG_RING_ID_MAX; ring_id++) {
6757 ret = dhd_os_get_ring_status(dhd_pub, ring_id, &ring_status);
6758 if (ret == BCME_NOTFOUND) {
6759 WL_DBG(("The ring (%d) is not found \n", ring_id));
6760 } else if (ret == BCME_OK) {
6761 dbg_ring_status[ring_cnt++] = ring_status;
6762 }
6763 }
6764 /* Alloc the SKB for vendor_event */
6765 skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy,
6766 nla_total_size(DBG_RING_STATUS_SIZE) * ring_cnt + nla_total_size(sizeof(ring_cnt)));
6767 if (!skb) {
6768 WL_ERR(("skb allocation is failed\n"));
6769 ret = BCME_NOMEM;
6770 goto exit;
6771 }
6772
6773 /* Ignore return of nla_put_u32 and nla_put since the skb allocated
6774 * above has a requested size for all payload
6775 */
6776 (void)nla_put_u32(skb, DEBUG_ATTRIBUTE_RING_NUM, ring_cnt);
6777 for (i = 0; i < ring_cnt; i++) {
6778 (void)nla_put(skb, DEBUG_ATTRIBUTE_RING_STATUS, DBG_RING_STATUS_SIZE,
6779 &dbg_ring_status[i]);
6780 }
6781 ret = cfg80211_vendor_cmd_reply(skb);
6782
6783 if (ret) {
6784 WL_ERR(("Vendor Command reply failed ret:%d \n", ret));
6785 }
6786 exit:
6787 return ret;
6788 }
6789
wl_cfgvendor_dbg_get_ring_data(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6790 static int wl_cfgvendor_dbg_get_ring_data(struct wiphy *wiphy,
6791 struct wireless_dev *wdev, const void *data, int len)
6792 {
6793 int ret = BCME_OK, rem, type;
6794 char ring_name[DBGRING_NAME_MAX] = {0};
6795 const struct nlattr *iter;
6796 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
6797 dhd_pub_t *dhd_pub = cfg->pub;
6798
6799 nla_for_each_attr(iter, data, len, rem) {
6800 type = nla_type(iter);
6801 switch (type) {
6802 case DEBUG_ATTRIBUTE_RING_NAME:
6803 strlcpy(ring_name, nla_data(iter), sizeof(ring_name));
6804 break;
6805 default:
6806 WL_ERR(("Unknown type: %d\n", type));
6807 return ret;
6808 }
6809 }
6810
6811 ret = dhd_os_trigger_get_ring_data(dhd_pub, ring_name);
6812 if (ret < 0) {
6813 WL_ERR(("trigger_get_data failed ret:%d\n", ret));
6814 }
6815
6816 return ret;
6817 }
6818 #else
6819 static int
wl_cfgvendor_dbg_trigger_mem_dump(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6820 wl_cfgvendor_dbg_trigger_mem_dump(struct wiphy *wiphy,
6821 struct wireless_dev *wdev, const void *data, int len)
6822 {
6823 return WIFI_ERROR_NOT_SUPPORTED;
6824 }
6825
6826 static int
wl_cfgvendor_dbg_get_mem_dump(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6827 wl_cfgvendor_dbg_get_mem_dump(struct wiphy *wiphy,
6828 struct wireless_dev *wdev, const void *data, int len)
6829 {
6830 return WIFI_ERROR_NOT_SUPPORTED;
6831 }
6832
wl_cfgvendor_dbg_start_logging(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6833 static int wl_cfgvendor_dbg_start_logging(struct wiphy *wiphy,
6834 struct wireless_dev *wdev, const void *data, int len)
6835 {
6836 return WIFI_ERROR_NOT_SUPPORTED;
6837 }
6838
wl_cfgvendor_dbg_reset_logging(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6839 static int wl_cfgvendor_dbg_reset_logging(struct wiphy *wiphy,
6840 struct wireless_dev *wdev, const void *data, int len)
6841 {
6842 return WIFI_ERROR_NOT_SUPPORTED;
6843 }
6844
wl_cfgvendor_dbg_get_ring_status(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6845 static int wl_cfgvendor_dbg_get_ring_status(struct wiphy *wiphy,
6846 struct wireless_dev *wdev, const void *data, int len)
6847 {
6848 return WIFI_ERROR_NOT_SUPPORTED;
6849 }
6850
wl_cfgvendor_dbg_get_ring_data(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6851 static int wl_cfgvendor_dbg_get_ring_data(struct wiphy *wiphy,
6852 struct wireless_dev *wdev, const void *data, int len)
6853 {
6854 return WIFI_ERROR_NOT_SUPPORTED;
6855 }
6856 #endif /* DEBUGABILITY */
6857
wl_cfgvendor_dbg_get_feature(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)6858 static int wl_cfgvendor_dbg_get_feature(struct wiphy *wiphy,
6859 struct wireless_dev *wdev, const void *data, int len)
6860 {
6861 int ret = BCME_OK;
6862 u32 supported_features = 0;
6863 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
6864 dhd_pub_t *dhd_pub = cfg->pub;
6865
6866 ret = dhd_os_dbg_get_feature(dhd_pub, &supported_features);
6867 if (ret < 0) {
6868 WL_ERR(("dbg_get_feature failed ret:%d\n", ret));
6869 goto exit;
6870 }
6871 ret = wl_cfgvendor_send_cmd_reply(wiphy, &supported_features,
6872 sizeof(supported_features));
6873 exit:
6874 return ret;
6875 }
6876
6877 #ifdef DEBUGABILITY
wl_cfgvendor_dbg_ring_send_evt(void * ctx,const int ring_id,const void * data,const uint32 len,const dhd_dbg_ring_status_t ring_status)6878 static void wl_cfgvendor_dbg_ring_send_evt(void *ctx,
6879 const int ring_id, const void *data, const uint32 len,
6880 const dhd_dbg_ring_status_t ring_status)
6881 {
6882 struct net_device *ndev = ctx;
6883 struct wiphy *wiphy;
6884 gfp_t kflags;
6885 struct sk_buff *skb;
6886 if (!ndev) {
6887 WL_ERR(("ndev is NULL\n"));
6888 return;
6889 }
6890 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
6891 wiphy = ndev->ieee80211_ptr->wiphy;
6892 /* Alloc the SKB for vendor_event */
6893 #if (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || \
6894 LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0)
6895 skb = cfg80211_vendor_event_alloc(wiphy, NULL, len + 100,
6896 GOOGLE_DEBUG_RING_EVENT, kflags);
6897 #else
6898 skb = cfg80211_vendor_event_alloc(wiphy, len + 100,
6899 GOOGLE_DEBUG_RING_EVENT, kflags);
6900 #endif /* (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || */
6901 /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0) */
6902 if (!skb) {
6903 WL_ERR(("skb alloc failed"));
6904 return;
6905 }
6906 nla_put(skb, DEBUG_ATTRIBUTE_RING_STATUS, sizeof(ring_status), &ring_status);
6907 nla_put(skb, DEBUG_ATTRIBUTE_RING_DATA, len, data);
6908 cfg80211_vendor_event(skb, kflags);
6909 }
6910 #endif /* DEBUGABILITY */
6911
6912 #ifdef DHD_LOG_DUMP
wl_cfgvendor_nla_put_sssr_dump_data(struct sk_buff * skb,struct net_device * ndev)6913 static int wl_cfgvendor_nla_put_sssr_dump_data(struct sk_buff *skb,
6914 struct net_device *ndev)
6915 {
6916 int ret = BCME_OK;
6917 #ifdef DHD_SSSR_DUMP
6918 uint32 arr_len[DUMP_SSSR_ATTR_COUNT];
6919 int i = 0, j = 0;
6920 #endif /* DHD_SSSR_DUMP */
6921 char memdump_path[MEMDUMP_PATH_LEN];
6922
6923 dhd_get_memdump_filename(ndev, memdump_path, MEMDUMP_PATH_LEN,
6924 "sssr_dump_core_0_before_SR");
6925 ret = nla_put_string(skb, DUMP_FILENAME_ATTR_SSSR_CORE_0_BEFORE_DUMP, memdump_path);
6926 if (unlikely(ret)) {
6927 WL_ERR(("Failed to nla put sssr core 0 before dump path, ret=%d\n", ret));
6928 goto exit;
6929 }
6930
6931 dhd_get_memdump_filename(ndev, memdump_path, MEMDUMP_PATH_LEN,
6932 "sssr_dump_core_0_after_SR");
6933 ret = nla_put_string(skb, DUMP_FILENAME_ATTR_SSSR_CORE_0_AFTER_DUMP, memdump_path);
6934 if (unlikely(ret)) {
6935 WL_ERR(("Failed to nla put sssr core 1 after dump path, ret=%d\n", ret));
6936 goto exit;
6937 }
6938
6939 dhd_get_memdump_filename(ndev, memdump_path, MEMDUMP_PATH_LEN,
6940 "sssr_dump_core_1_before_SR");
6941 ret = nla_put_string(skb, DUMP_FILENAME_ATTR_SSSR_CORE_1_BEFORE_DUMP, memdump_path);
6942 if (unlikely(ret)) {
6943 WL_ERR(("Failed to nla put sssr core 1 before dump path, ret=%d\n", ret));
6944 goto exit;
6945 }
6946
6947 dhd_get_memdump_filename(ndev, memdump_path, MEMDUMP_PATH_LEN,
6948 "sssr_dump_core_1_after_SR");
6949 ret = nla_put_string(skb, DUMP_FILENAME_ATTR_SSSR_CORE_1_AFTER_DUMP, memdump_path);
6950 if (unlikely(ret)) {
6951 WL_ERR(("Failed to nla put sssr core 1 after dump path, ret=%d\n", ret));
6952 goto exit;
6953 }
6954
6955 dhd_get_memdump_filename(ndev, memdump_path, MEMDUMP_PATH_LEN,
6956 "sssr_dump_dig_before_SR");
6957 ret = nla_put_string(skb, DUMP_FILENAME_ATTR_SSSR_DIG_BEFORE_DUMP, memdump_path);
6958 if (unlikely(ret)) {
6959 WL_ERR(("Failed to nla put sssr dig before dump path, ret=%d\n", ret));
6960 goto exit;
6961 }
6962
6963 dhd_get_memdump_filename(ndev, memdump_path, MEMDUMP_PATH_LEN,
6964 "sssr_dump_dig_after_SR");
6965 ret = nla_put_string(skb, DUMP_FILENAME_ATTR_SSSR_DIG_AFTER_DUMP, memdump_path);
6966 if (unlikely(ret)) {
6967 WL_ERR(("Failed to nla put sssr dig after dump path, ret=%d\n", ret));
6968 goto exit;
6969 }
6970
6971 #ifdef DHD_SSSR_DUMP
6972 memset(arr_len, 0, sizeof(arr_len));
6973 dhd_nla_put_sssr_dump_len(ndev, arr_len);
6974
6975 for (i = 0, j = DUMP_SSSR_ATTR_START; i < DUMP_SSSR_ATTR_COUNT; i++, j++) {
6976 if (arr_len[i]) {
6977 ret = nla_put_u32(skb, j, arr_len[i]);
6978 if (unlikely(ret)) {
6979 WL_ERR(("Failed to nla put sssr dump len, ret=%d\n", ret));
6980 goto exit;
6981 }
6982 }
6983 }
6984 #endif /* DHD_SSSR_DUMP */
6985
6986 exit:
6987 return ret;
6988 }
6989
wl_cfgvendor_nla_put_debug_dump_data(struct sk_buff * skb,struct net_device * ndev)6990 static int wl_cfgvendor_nla_put_debug_dump_data(struct sk_buff *skb,
6991 struct net_device *ndev)
6992 {
6993 int ret = BCME_OK;
6994 uint32 len = 0;
6995 char dump_path[128];
6996
6997 ret = dhd_get_debug_dump_file_name(ndev, NULL, dump_path, sizeof(dump_path));
6998 if (ret < 0) {
6999 WL_ERR(("%s: Failed to get debug dump filename\n", __FUNCTION__));
7000 goto exit;
7001 }
7002 ret = nla_put_string(skb, DUMP_FILENAME_ATTR_DEBUG_DUMP, dump_path);
7003 if (unlikely(ret)) {
7004 WL_ERR(("Failed to nla put debug dump path, ret=%d\n", ret));
7005 goto exit;
7006 }
7007 WL_ERR(("debug_dump path = %s%s\n", dump_path, FILE_NAME_HAL_TAG));
7008 wl_print_verinfo(wl_get_cfg(ndev));
7009
7010 len = dhd_get_time_str_len();
7011 if (len) {
7012 ret = nla_put_u32(skb, DUMP_LEN_ATTR_TIMESTAMP, len);
7013 if (unlikely(ret)) {
7014 WL_ERR(("Failed to nla put time stamp length, ret=%d\n", ret));
7015 goto exit;
7016 }
7017 }
7018
7019 len = dhd_get_dld_len(DLD_BUF_TYPE_GENERAL);
7020 if (len) {
7021 ret = nla_put_u32(skb, DUMP_LEN_ATTR_GENERAL_LOG, len);
7022 if (unlikely(ret)) {
7023 WL_ERR(("Failed to nla put general log length, ret=%d\n", ret));
7024 goto exit;
7025 }
7026 }
7027 #ifdef EWP_ECNTRS_LOGGING
7028 len = dhd_get_ecntrs_len(ndev, NULL);
7029 if (len) {
7030 ret = nla_put_u32(skb, DUMP_LEN_ATTR_ECNTRS, len);
7031 if (unlikely(ret)) {
7032 WL_ERR(("Failed to nla put ecntrs length, ret=%d\n", ret));
7033 goto exit;
7034 }
7035 }
7036 #endif /* EWP_ECNTRS_LOGGING */
7037 len = dhd_get_dld_len(DLD_BUF_TYPE_SPECIAL);
7038 if (len) {
7039 ret = nla_put_u32(skb, DUMP_LEN_ATTR_SPECIAL_LOG, len);
7040 if (unlikely(ret)) {
7041 WL_ERR(("Failed to nla put special log length, ret=%d\n", ret));
7042 goto exit;
7043 }
7044 }
7045 len = dhd_get_dhd_dump_len(ndev, NULL);
7046 if (len) {
7047 ret = nla_put_u32(skb, DUMP_LEN_ATTR_DHD_DUMP, len);
7048 if (unlikely(ret)) {
7049 WL_ERR(("Failed to nla put dhd dump length, ret=%d\n", ret));
7050 goto exit;
7051 }
7052 }
7053
7054 #if defined(BCMPCIE)
7055 len = dhd_get_ext_trap_len(ndev, NULL);
7056 if (len) {
7057 ret = nla_put_u32(skb, DUMP_LEN_ATTR_EXT_TRAP, len);
7058 if (unlikely(ret)) {
7059 WL_ERR(("Failed to nla put ext trap length, ret=%d\n", ret));
7060 goto exit;
7061 }
7062 }
7063 #endif /* BCMPCIE */
7064
7065 #if defined(DHD_FW_COREDUMP) && defined(DNGL_EVENT_SUPPORT)
7066 len = dhd_get_health_chk_len(ndev, NULL);
7067 if (len) {
7068 ret = nla_put_u32(skb, DUMP_LEN_ATTR_HEALTH_CHK, len);
7069 if (unlikely(ret)) {
7070 WL_ERR(("Failed to nla put health check length, ret=%d\n", ret));
7071 goto exit;
7072 }
7073 }
7074 #endif // endif
7075
7076 len = dhd_get_dld_len(DLD_BUF_TYPE_PRESERVE);
7077 if (len) {
7078 ret = nla_put_u32(skb, DUMP_LEN_ATTR_PRESERVE_LOG, len);
7079 if (unlikely(ret)) {
7080 WL_ERR(("Failed to nla put preserve log length, ret=%d\n", ret));
7081 goto exit;
7082 }
7083 }
7084
7085 len = dhd_get_cookie_log_len(ndev, NULL);
7086 if (len) {
7087 ret = nla_put_u32(skb, DUMP_LEN_ATTR_COOKIE, len);
7088 if (unlikely(ret)) {
7089 WL_ERR(("Failed to nla put cookie length, ret=%d\n", ret));
7090 goto exit;
7091 }
7092 }
7093 #ifdef DHD_DUMP_PCIE_RINGS
7094 len = dhd_get_flowring_len(ndev, NULL);
7095 if (len) {
7096 ret = nla_put_u32(skb, DUMP_LEN_ATTR_FLOWRING_DUMP, len);
7097 if (unlikely(ret)) {
7098 WL_ERR(("Failed to nla put flowring dump length, ret=%d\n", ret));
7099 goto exit;
7100 }
7101 }
7102 #endif // endif
7103 #ifdef DHD_STATUS_LOGGING
7104 len = dhd_get_status_log_len(ndev, NULL);
7105 if (len) {
7106 ret = nla_put_u32(skb, DUMP_LEN_ATTR_STATUS_LOG, len);
7107 if (unlikely(ret)) {
7108 WL_ERR(("Failed to nla put status log length, ret=%d\n", ret));
7109 goto exit;
7110 }
7111 }
7112 #endif /* DHD_STATUS_LOGGING */
7113 #ifdef EWP_RTT_LOGGING
7114 len = dhd_get_rtt_len(ndev, NULL);
7115 if (len) {
7116 ret = nla_put_u32(skb, DUMP_LEN_ATTR_RTT_LOG, len);
7117 if (unlikely(ret)) {
7118 WL_ERR(("Failed to nla put rtt log length, ret=%d\n", ret));
7119 goto exit;
7120 }
7121 }
7122 #endif /* EWP_RTT_LOGGING */
7123 exit:
7124 return ret;
7125 }
7126 #ifdef DNGL_AXI_ERROR_LOGGING
wl_cfgvendor_nla_put_axi_error_data(struct sk_buff * skb,struct net_device * ndev)7127 static void wl_cfgvendor_nla_put_axi_error_data(struct sk_buff *skb,
7128 struct net_device *ndev)
7129 {
7130 int ret = 0;
7131 char axierrordump_path[MEMDUMP_PATH_LEN];
7132 int dumpsize = dhd_os_get_axi_error_dump_size(ndev);
7133 if (dumpsize <= 0) {
7134 WL_ERR(("Failed to calcuate axi error dump len\n"));
7135 return;
7136 }
7137 dhd_os_get_axi_error_filename(ndev, axierrordump_path, MEMDUMP_PATH_LEN);
7138 ret = nla_put_string(skb, DUMP_FILENAME_ATTR_AXI_ERROR_DUMP, axierrordump_path);
7139 if (ret) {
7140 WL_ERR(("Failed to put filename\n"));
7141 return;
7142 }
7143 ret = nla_put_u32(skb, DUMP_LEN_ATTR_AXI_ERROR, dumpsize);
7144 if (ret) {
7145 WL_ERR(("Failed to put filesize\n"));
7146 return;
7147 }
7148 }
7149 #endif /* DNGL_AXI_ERROR_LOGGING */
7150 #ifdef DHD_PKT_LOGGING
wl_cfgvendor_nla_put_pktlogdump_data(struct sk_buff * skb,struct net_device * ndev)7151 static void wl_cfgvendor_nla_put_pktlogdump_data(struct sk_buff *skb,
7152 struct net_device *ndev)
7153 {
7154 int ret = 0;
7155 char pktlogdump_path[MEMDUMP_PATH_LEN];
7156 uint32 pktlog_dumpsize = dhd_os_get_pktlog_dump_size(ndev);
7157 if (pktlog_dumpsize == 0) {
7158 WL_ERR(("Failed to calcuate pktlog len\n"));
7159 return;
7160 }
7161 dhd_os_get_pktlogdump_filename(ndev, pktlogdump_path, MEMDUMP_PATH_LEN);
7162 ret = nla_put_string(skb, DUMP_FILENAME_ATTR_PKTLOG_DUMP, pktlogdump_path);
7163 if (ret) {
7164 WL_ERR(("Failed to put filename\n"));
7165 return;
7166 }
7167 ret = nla_put_u32(skb, DUMP_LEN_ATTR_PKTLOG, pktlog_dumpsize);
7168 if (ret) {
7169 WL_ERR(("Failed to put filesize\n"));
7170 return;
7171 }
7172 }
7173 #endif /* DHD_PKT_LOGGING */
7174
wl_cfgvendor_nla_put_memdump_data(struct sk_buff * skb,struct net_device * ndev,const uint32 fw_len)7175 static int wl_cfgvendor_nla_put_memdump_data(struct sk_buff *skb,
7176 struct net_device *ndev, const uint32 fw_len)
7177 {
7178 char memdump_path[MEMDUMP_PATH_LEN];
7179 int ret = BCME_OK;
7180
7181 dhd_get_memdump_filename(ndev, memdump_path, MEMDUMP_PATH_LEN, "mem_dump");
7182 ret = nla_put_string(skb, DUMP_FILENAME_ATTR_MEM_DUMP, memdump_path);
7183 if (unlikely(ret)) {
7184 WL_ERR(("Failed to nla put mem dump path, ret=%d\n", ret));
7185 goto exit;
7186 }
7187 ret = nla_put_u32(skb, DUMP_LEN_ATTR_MEMDUMP, fw_len);
7188 if (unlikely(ret)) {
7189 WL_ERR(("Failed to nla put mem dump length, ret=%d\n", ret));
7190 goto exit;
7191 }
7192
7193 exit:
7194 return ret;
7195 }
7196
wl_cfgvendor_dbg_send_file_dump_evt(void * ctx,const void * data,const uint32 len,const uint32 fw_len)7197 static void wl_cfgvendor_dbg_send_file_dump_evt(void *ctx, const void *data,
7198 const uint32 len, const uint32 fw_len)
7199 {
7200 struct net_device *ndev = ctx;
7201 struct wiphy *wiphy;
7202 gfp_t kflags;
7203 struct sk_buff *skb = NULL;
7204 struct bcm_cfg80211 *cfg;
7205 dhd_pub_t *dhd_pub;
7206 int ret = BCME_OK;
7207
7208 if (!ndev) {
7209 WL_ERR(("ndev is NULL\n"));
7210 return;
7211 }
7212
7213 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
7214 wiphy = ndev->ieee80211_ptr->wiphy;
7215 /* Alloc the SKB for vendor_event */
7216 #if (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || \
7217 LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0)
7218 skb = cfg80211_vendor_event_alloc(wiphy, NULL, len + CFG80211_VENDOR_EVT_SKB_SZ,
7219 GOOGLE_FILE_DUMP_EVENT, kflags);
7220 #else
7221 skb = cfg80211_vendor_event_alloc(wiphy, len + CFG80211_VENDOR_EVT_SKB_SZ,
7222 GOOGLE_FILE_DUMP_EVENT, kflags);
7223 #endif /* (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || */
7224 /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0) */
7225 if (!skb) {
7226 WL_ERR(("skb alloc failed"));
7227 return;
7228 }
7229
7230 cfg = wiphy_priv(wiphy);
7231 dhd_pub = cfg->pub;
7232 #ifdef DNGL_AXI_ERROR_LOGGING
7233 if (dhd_pub->smmu_fault_occurred) {
7234 wl_cfgvendor_nla_put_axi_error_data(skb, ndev);
7235 }
7236 #endif /* DNGL_AXI_ERROR_LOGGING */
7237 if (
7238 #ifdef DHD_FW_COREDUMP
7239 dhd_pub->memdump_enabled ||
7240 #endif /* DHD_FW_COREDUMP */
7241 (dhd_pub->memdump_type == DUMP_TYPE_BY_SYSDUMP)) {
7242 if (((ret = wl_cfgvendor_nla_put_memdump_data(skb, ndev, fw_len)) < 0) ||
7243 ((ret = wl_cfgvendor_nla_put_debug_dump_data(skb, ndev)) < 0) ||
7244 ((ret = wl_cfgvendor_nla_put_sssr_dump_data(skb, ndev)) < 0)) {
7245 WL_ERR(("nla put failed\n"));
7246 goto done;
7247 }
7248 #ifdef DHD_PKT_LOGGING
7249 wl_cfgvendor_nla_put_pktlogdump_data(skb, ndev);
7250 #endif /* DHD_PKT_LOGGING */
7251 }
7252 /* TODO : Similar to above function add for debug_dump, sssr_dump, and pktlog also. */
7253 cfg80211_vendor_event(skb, kflags);
7254 return;
7255 done:
7256 if (skb) {
7257 dev_kfree_skb_any(skb);
7258 }
7259 }
7260 #endif /* DHD_LOG_DUMP */
7261
wl_cfgvendor_priv_frameburst(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)7262 static int wl_cfgvendor_priv_frameburst(struct wiphy *wiphy,
7263 struct wireless_dev *wdev, const void *data, int len)
7264 {
7265 int ret = BCME_OK;
7266 int val = *(int *)data;
7267 int get_frmbrst = 0;
7268 int err = 0;
7269 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
7270
7271 if (val == 0xa) {
7272 ret = wldev_ioctl_get(bcmcfg_to_prmry_ndev(cfg),
7273 WLC_GET_FAKEFRAG, &get_frmbrst, sizeof(int));
7274 if (ret) {
7275 WL_ERR(("Failed : %d\n", ret));
7276 }
7277 WL_DBG(("Get Frameburst : %d\n", get_frmbrst));
7278 err = wl_cfgvendor_send_cmd_reply(wiphy, &get_frmbrst, sizeof(int));
7279 if (unlikely(err))
7280 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
7281 }
7282 else {
7283 WL_DBG(("Set frameburst %d\n", val));
7284 ret = wldev_ioctl_set(bcmcfg_to_prmry_ndev(cfg),
7285 WLC_SET_FAKEFRAG, &val, sizeof(val));
7286 if (ret < 0) {
7287 WL_ERR(("Failed set frameburst, ret=%d\n", ret));
7288 } else {
7289 WL_ERR(("frameburst is %s\n", val ? "enabled" : "disabled"));
7290 }
7291 }
7292 return ret;
7293 }
7294
wl_cfgvendor_priv_mpc(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)7295 static int wl_cfgvendor_priv_mpc(struct wiphy *wiphy,
7296 struct wireless_dev *wdev, const void *data, int len)
7297 {
7298 int ret = BCME_OK;
7299 int val = *(int *)data;
7300 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
7301 int get_mpc = 0;
7302 int err = 0;
7303
7304 if (val == 0xa) {
7305 ret = wldev_iovar_getint(bcmcfg_to_prmry_ndev(cfg), "mpc", &get_mpc);
7306 if (ret) {
7307 WL_ERR(("Failed : %d\n", ret));
7308 }
7309 WL_DBG(("Get MPC : %d\n", get_mpc));
7310 err = wl_cfgvendor_send_cmd_reply(wiphy, &get_mpc, sizeof(int));
7311 if (unlikely(err))
7312 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
7313 }
7314 else {
7315 WL_DBG(("Set mpc val %d\n", val));
7316 ret = wldev_iovar_setint(bcmcfg_to_prmry_ndev(cfg), "mpc", val);
7317 if (ret < 0) {
7318 WL_ERR(("Failed set mpc, ret=%d\n", ret));
7319 } else {
7320 WL_INFORM_MEM(("mpc is %s\n", val ? "enabled" : "disabled"));
7321 }
7322 }
7323 return ret;
7324 }
7325
wl_cfgvendor_priv_band(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)7326 static int wl_cfgvendor_priv_band(struct wiphy *wiphy,
7327 struct wireless_dev *wdev, const void *data, int len)
7328 {
7329 int ret = BCME_OK;
7330 uint val = *(uint *)data;
7331 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
7332 int get_band = 0;
7333 int err = 0;
7334
7335 if (val == 0xa) {
7336 ret = wldev_ioctl_get(bcmcfg_to_prmry_ndev(cfg),
7337 WLC_GET_BAND, &get_band, sizeof(int));
7338 if (ret) {
7339 WL_ERR(("Failed : %d\n", ret));
7340 }
7341 WL_DBG(("Get band : %d\n", get_band));
7342 err = wl_cfgvendor_send_cmd_reply(wiphy, &get_band, sizeof(int));
7343 if (unlikely(err))
7344 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
7345 }
7346 else {
7347 WL_DBG(("Set band val %d\n", val));
7348 if ((val == WLC_BAND_AUTO) || (val == WLC_BAND_5G) || (val == WLC_BAND_2G)) {
7349 ret = wldev_ioctl_set(bcmcfg_to_prmry_ndev(cfg),
7350 WLC_SET_BAND, &val, sizeof(val));
7351 if (!ret)
7352 dhd_bus_band_set(bcmcfg_to_prmry_ndev(cfg), val);
7353 }
7354
7355 }
7356 return ret;
7357 }
7358
wl_cfgvendor_dbg_get_version(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)7359 static int wl_cfgvendor_dbg_get_version(struct wiphy *wiphy,
7360 struct wireless_dev *wdev, const void *data, int len)
7361 {
7362 int ret = BCME_OK, rem, type;
7363 int buf_len = 1024;
7364 bool dhd_ver = FALSE;
7365 char *buf_ptr;
7366 const struct nlattr *iter;
7367 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
7368
7369 buf_ptr = (char *)MALLOCZ(cfg->osh, buf_len);
7370 if (!buf_ptr) {
7371 WL_ERR(("failed to allocate the buffer for version n"));
7372 ret = BCME_NOMEM;
7373 goto exit;
7374 }
7375 nla_for_each_attr(iter, data, len, rem) {
7376 type = nla_type(iter);
7377 switch (type) {
7378 case DEBUG_ATTRIBUTE_GET_DRIVER:
7379 dhd_ver = TRUE;
7380 break;
7381 case DEBUG_ATTRIBUTE_GET_FW:
7382 dhd_ver = FALSE;
7383 break;
7384 default:
7385 WL_ERR(("Unknown type: %d\n", type));
7386 ret = BCME_ERROR;
7387 goto exit;
7388 }
7389 }
7390 ret = dhd_os_get_version(bcmcfg_to_prmry_ndev(cfg), dhd_ver, &buf_ptr, buf_len);
7391 if (ret < 0) {
7392 WL_ERR(("failed to get the version %d\n", ret));
7393 goto exit;
7394 }
7395 ret = wl_cfgvendor_send_cmd_reply(wiphy, buf_ptr, strlen(buf_ptr));
7396 exit:
7397 MFREE(cfg->osh, buf_ptr, buf_len);
7398 return ret;
7399 }
7400
7401 #ifdef DBG_PKT_MON
wl_cfgvendor_dbg_start_pkt_fate_monitoring(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)7402 static int wl_cfgvendor_dbg_start_pkt_fate_monitoring(struct wiphy *wiphy,
7403 struct wireless_dev *wdev, const void *data, int len)
7404 {
7405 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
7406 dhd_pub_t *dhd_pub = cfg->pub;
7407 int ret;
7408
7409 ret = dhd_os_dbg_attach_pkt_monitor(dhd_pub);
7410 if (unlikely(ret)) {
7411 WL_ERR(("failed to start pkt fate monitoring, ret=%d", ret));
7412 }
7413
7414 return ret;
7415 }
7416
7417 typedef int (*dbg_mon_get_pkts_t) (dhd_pub_t *dhdp, void __user *user_buf,
7418 uint16 req_count, uint16 *resp_count);
7419
__wl_cfgvendor_dbg_get_pkt_fates(struct wiphy * wiphy,const void * data,int len,dbg_mon_get_pkts_t dbg_mon_get_pkts)7420 static int __wl_cfgvendor_dbg_get_pkt_fates(struct wiphy *wiphy,
7421 const void *data, int len, dbg_mon_get_pkts_t dbg_mon_get_pkts)
7422 {
7423 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
7424 dhd_pub_t *dhd_pub = cfg->pub;
7425 struct sk_buff *skb = NULL;
7426 const struct nlattr *iter;
7427 void __user *user_buf = NULL;
7428 uint16 req_count = 0, resp_count = 0;
7429 int ret, tmp, type, mem_needed;
7430
7431 nla_for_each_attr(iter, data, len, tmp) {
7432 type = nla_type(iter);
7433 switch (type) {
7434 case DEBUG_ATTRIBUTE_PKT_FATE_NUM:
7435 req_count = nla_get_u32(iter);
7436 break;
7437 case DEBUG_ATTRIBUTE_PKT_FATE_DATA:
7438 user_buf = (void __user *)(unsigned long) nla_get_u64(iter);
7439 break;
7440 default:
7441 WL_ERR(("%s: no such attribute %d\n", __FUNCTION__, type));
7442 ret = -EINVAL;
7443 goto exit;
7444 }
7445 }
7446
7447 if (!req_count || !user_buf) {
7448 WL_ERR(("%s: invalid request, user_buf=%p, req_count=%u\n",
7449 __FUNCTION__, user_buf, req_count));
7450 ret = -EINVAL;
7451 goto exit;
7452 }
7453
7454 ret = dbg_mon_get_pkts(dhd_pub, user_buf, req_count, &resp_count);
7455 if (unlikely(ret)) {
7456 WL_ERR(("failed to get packets, ret:%d \n", ret));
7457 goto exit;
7458 }
7459
7460 mem_needed = VENDOR_REPLY_OVERHEAD + ATTRIBUTE_U32_LEN;
7461 skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, mem_needed);
7462 if (unlikely(!skb)) {
7463 WL_ERR(("skb alloc failed"));
7464 ret = -ENOMEM;
7465 goto exit;
7466 }
7467
7468 ret = nla_put_u32(skb, DEBUG_ATTRIBUTE_PKT_FATE_NUM, resp_count);
7469 if (ret < 0) {
7470 WL_ERR(("Failed to put DEBUG_ATTRIBUTE_PKT_FATE_NUM, ret:%d\n", ret));
7471 goto exit;
7472 }
7473
7474 ret = cfg80211_vendor_cmd_reply(skb);
7475 if (unlikely(ret)) {
7476 WL_ERR(("vendor Command reply failed ret:%d \n", ret));
7477 }
7478 return ret;
7479
7480 exit:
7481 /* Free skb memory */
7482 if (skb) {
7483 kfree_skb(skb);
7484 }
7485 return ret;
7486 }
7487
wl_cfgvendor_dbg_get_tx_pkt_fates(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)7488 static int wl_cfgvendor_dbg_get_tx_pkt_fates(struct wiphy *wiphy,
7489 struct wireless_dev *wdev, const void *data, int len)
7490 {
7491 int ret;
7492
7493 ret = __wl_cfgvendor_dbg_get_pkt_fates(wiphy, data, len,
7494 dhd_os_dbg_monitor_get_tx_pkts);
7495 if (unlikely(ret)) {
7496 WL_ERR(("failed to get tx packets, ret:%d \n", ret));
7497 }
7498
7499 return ret;
7500 }
7501
wl_cfgvendor_dbg_get_rx_pkt_fates(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)7502 static int wl_cfgvendor_dbg_get_rx_pkt_fates(struct wiphy *wiphy,
7503 struct wireless_dev *wdev, const void *data, int len)
7504 {
7505 int ret;
7506
7507 ret = __wl_cfgvendor_dbg_get_pkt_fates(wiphy, data, len,
7508 dhd_os_dbg_monitor_get_rx_pkts);
7509 if (unlikely(ret)) {
7510 WL_ERR(("failed to get rx packets, ret:%d \n", ret));
7511 }
7512
7513 return ret;
7514 }
7515 #endif /* DBG_PKT_MON */
7516
7517 #ifdef KEEP_ALIVE
wl_cfgvendor_start_mkeep_alive(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)7518 static int wl_cfgvendor_start_mkeep_alive(struct wiphy *wiphy, struct wireless_dev *wdev,
7519 const void *data, int len)
7520 {
7521 /* max size of IP packet for keep alive */
7522 const int MKEEP_ALIVE_IP_PKT_MAX = 256;
7523
7524 int ret = BCME_OK, rem, type;
7525 uint8 mkeep_alive_id = 0;
7526 uint8 *ip_pkt = NULL;
7527 uint16 ip_pkt_len = 0;
7528 uint8 src_mac[ETHER_ADDR_LEN];
7529 uint8 dst_mac[ETHER_ADDR_LEN];
7530 uint32 period_msec = 0;
7531 const struct nlattr *iter;
7532 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
7533 dhd_pub_t *dhd_pub = cfg->pub;
7534
7535 nla_for_each_attr(iter, data, len, rem) {
7536 type = nla_type(iter);
7537 switch (type) {
7538 case MKEEP_ALIVE_ATTRIBUTE_ID:
7539 mkeep_alive_id = nla_get_u8(iter);
7540 break;
7541 case MKEEP_ALIVE_ATTRIBUTE_IP_PKT_LEN:
7542 ip_pkt_len = nla_get_u16(iter);
7543 if (ip_pkt_len > MKEEP_ALIVE_IP_PKT_MAX) {
7544 ret = BCME_BADARG;
7545 goto exit;
7546 }
7547 break;
7548 case MKEEP_ALIVE_ATTRIBUTE_IP_PKT:
7549 if (ip_pkt) {
7550 ret = BCME_BADARG;
7551 WL_ERR(("ip_pkt already allocated\n"));
7552 goto exit;
7553 }
7554 if (!ip_pkt_len) {
7555 ret = BCME_BADARG;
7556 WL_ERR(("ip packet length is 0\n"));
7557 goto exit;
7558 }
7559 ip_pkt = (u8 *)MALLOCZ(cfg->osh, ip_pkt_len);
7560 if (ip_pkt == NULL) {
7561 ret = BCME_NOMEM;
7562 WL_ERR(("Failed to allocate mem for ip packet\n"));
7563 goto exit;
7564 }
7565 memcpy(ip_pkt, (u8*)nla_data(iter), ip_pkt_len);
7566 break;
7567 case MKEEP_ALIVE_ATTRIBUTE_SRC_MAC_ADDR:
7568 memcpy(src_mac, nla_data(iter), ETHER_ADDR_LEN);
7569 break;
7570 case MKEEP_ALIVE_ATTRIBUTE_DST_MAC_ADDR:
7571 memcpy(dst_mac, nla_data(iter), ETHER_ADDR_LEN);
7572 break;
7573 case MKEEP_ALIVE_ATTRIBUTE_PERIOD_MSEC:
7574 period_msec = nla_get_u32(iter);
7575 break;
7576 default:
7577 WL_ERR(("Unknown type: %d\n", type));
7578 ret = BCME_BADARG;
7579 goto exit;
7580 }
7581 }
7582
7583 if (ip_pkt == NULL) {
7584 ret = BCME_BADARG;
7585 WL_ERR(("ip packet is NULL\n"));
7586 goto exit;
7587 }
7588
7589 ret = dhd_dev_start_mkeep_alive(dhd_pub, mkeep_alive_id, ip_pkt, ip_pkt_len, src_mac,
7590 dst_mac, period_msec);
7591 if (ret < 0) {
7592 WL_ERR(("start_mkeep_alive is failed ret: %d\n", ret));
7593 }
7594
7595 exit:
7596 if (ip_pkt) {
7597 MFREE(cfg->osh, ip_pkt, ip_pkt_len);
7598 }
7599
7600 return ret;
7601 }
7602
wl_cfgvendor_stop_mkeep_alive(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)7603 static int wl_cfgvendor_stop_mkeep_alive(struct wiphy *wiphy, struct wireless_dev *wdev,
7604 const void *data, int len)
7605 {
7606 int ret = BCME_OK, rem, type;
7607 uint8 mkeep_alive_id = 0;
7608 const struct nlattr *iter;
7609 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
7610 dhd_pub_t *dhd_pub = cfg->pub;
7611
7612 nla_for_each_attr(iter, data, len, rem) {
7613 type = nla_type(iter);
7614 switch (type) {
7615 case MKEEP_ALIVE_ATTRIBUTE_ID:
7616 mkeep_alive_id = nla_get_u8(iter);
7617 break;
7618 default:
7619 WL_ERR(("Unknown type: %d\n", type));
7620 ret = BCME_BADARG;
7621 break;
7622 }
7623 }
7624
7625 ret = dhd_dev_stop_mkeep_alive(dhd_pub, mkeep_alive_id);
7626 if (ret < 0) {
7627 WL_ERR(("stop_mkeep_alive is failed ret: %d\n", ret));
7628 }
7629
7630 return ret;
7631 }
7632 #endif /* KEEP_ALIVE */
7633
7634 #if defined(PKT_FILTER_SUPPORT) && defined(APF)
7635 static int
wl_cfgvendor_apf_get_capabilities(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)7636 wl_cfgvendor_apf_get_capabilities(struct wiphy *wiphy,
7637 struct wireless_dev *wdev, const void *data, int len)
7638 {
7639 struct net_device *ndev = wdev_to_ndev(wdev);
7640 struct sk_buff *skb = NULL;
7641 int ret, ver, max_len, mem_needed;
7642
7643 /* APF version */
7644 ver = 0;
7645 ret = dhd_dev_apf_get_version(ndev, &ver);
7646 if (unlikely(ret)) {
7647 WL_ERR(("APF get version failed, ret=%d\n", ret));
7648 return ret;
7649 }
7650
7651 /* APF memory size limit */
7652 max_len = 0;
7653 ret = dhd_dev_apf_get_max_len(ndev, &max_len);
7654 if (unlikely(ret)) {
7655 WL_ERR(("APF get maximum length failed, ret=%d\n", ret));
7656 return ret;
7657 }
7658
7659 mem_needed = VENDOR_REPLY_OVERHEAD + (ATTRIBUTE_U32_LEN * 2);
7660
7661 skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, mem_needed);
7662 if (unlikely(!skb)) {
7663 WL_ERR(("%s: can't allocate %d bytes\n", __FUNCTION__, mem_needed));
7664 return -ENOMEM;
7665 }
7666
7667 ret = nla_put_u32(skb, APF_ATTRIBUTE_VERSION, ver);
7668 if (ret < 0) {
7669 WL_ERR(("Failed to put APF_ATTRIBUTE_VERSION, ret:%d\n", ret));
7670 goto exit;
7671 }
7672 ret = nla_put_u32(skb, APF_ATTRIBUTE_MAX_LEN, max_len);
7673 if (ret < 0) {
7674 WL_ERR(("Failed to put APF_ATTRIBUTE_MAX_LEN, ret:%d\n", ret));
7675 goto exit;
7676 }
7677
7678 ret = cfg80211_vendor_cmd_reply(skb);
7679 if (unlikely(ret)) {
7680 WL_ERR(("vendor command reply failed, ret=%d\n", ret));
7681 }
7682 return ret;
7683 exit:
7684 /* Free skb memory */
7685 kfree_skb(skb);
7686 return ret;
7687 }
7688
7689 static int
wl_cfgvendor_apf_set_filter(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)7690 wl_cfgvendor_apf_set_filter(struct wiphy *wiphy,
7691 struct wireless_dev *wdev, const void *data, int len)
7692 {
7693 struct net_device *ndev = wdev_to_ndev(wdev);
7694 const struct nlattr *iter;
7695 u8 *program = NULL;
7696 u32 program_len = 0;
7697 int ret, tmp, type;
7698 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
7699
7700 if (len <= 0) {
7701 WL_ERR(("Invalid len: %d\n", len));
7702 ret = -EINVAL;
7703 goto exit;
7704 }
7705 nla_for_each_attr(iter, data, len, tmp) {
7706 type = nla_type(iter);
7707 switch (type) {
7708 case APF_ATTRIBUTE_PROGRAM_LEN:
7709 /* check if the iter value is valid and program_len
7710 * is not already initialized.
7711 */
7712 if (nla_len(iter) == sizeof(uint32) && !program_len) {
7713 program_len = nla_get_u32(iter);
7714 } else {
7715 ret = -EINVAL;
7716 goto exit;
7717 }
7718
7719 if (program_len > WL_APF_PROGRAM_MAX_SIZE) {
7720 WL_ERR(("program len is more than expected len\n"));
7721 ret = -EINVAL;
7722 goto exit;
7723 }
7724
7725 if (unlikely(!program_len)) {
7726 WL_ERR(("zero program length\n"));
7727 ret = -EINVAL;
7728 goto exit;
7729 }
7730 break;
7731 case APF_ATTRIBUTE_PROGRAM:
7732 if (unlikely(program)) {
7733 WL_ERR(("program already allocated\n"));
7734 ret = -EINVAL;
7735 goto exit;
7736 }
7737 if (unlikely(!program_len)) {
7738 WL_ERR(("program len is not set\n"));
7739 ret = -EINVAL;
7740 goto exit;
7741 }
7742 if (nla_len(iter) != program_len) {
7743 WL_ERR(("program_len is not same\n"));
7744 ret = -EINVAL;
7745 goto exit;
7746 }
7747 program = MALLOCZ(cfg->osh, program_len);
7748 if (unlikely(!program)) {
7749 WL_ERR(("%s: can't allocate %d bytes\n",
7750 __FUNCTION__, program_len));
7751 ret = -ENOMEM;
7752 goto exit;
7753 }
7754 memcpy(program, (u8*)nla_data(iter), program_len);
7755 break;
7756 default:
7757 WL_ERR(("%s: no such attribute %d\n", __FUNCTION__, type));
7758 ret = -EINVAL;
7759 goto exit;
7760 }
7761 }
7762
7763 ret = dhd_dev_apf_add_filter(ndev, program, program_len);
7764
7765 exit:
7766 if (program) {
7767 MFREE(cfg->osh, program, program_len);
7768 }
7769 return ret;
7770 }
7771 #endif /* PKT_FILTER_SUPPORT && APF */
7772
7773 #ifdef NDO_CONFIG_SUPPORT
wl_cfgvendor_configure_nd_offload(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)7774 static int wl_cfgvendor_configure_nd_offload(struct wiphy *wiphy,
7775 struct wireless_dev *wdev, const void *data, int len)
7776 {
7777 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
7778 const struct nlattr *iter;
7779 int ret = BCME_OK, rem, type;
7780 u8 enable = 0;
7781
7782 nla_for_each_attr(iter, data, len, rem) {
7783 type = nla_type(iter);
7784 switch (type) {
7785 case ANDR_WIFI_ATTRIBUTE_ND_OFFLOAD_VALUE:
7786 enable = nla_get_u8(iter);
7787 break;
7788 default:
7789 WL_ERR(("Unknown type: %d\n", type));
7790 ret = BCME_BADARG;
7791 goto exit;
7792 }
7793 }
7794
7795 ret = dhd_dev_ndo_cfg(bcmcfg_to_prmry_ndev(cfg), enable);
7796 if (ret < 0) {
7797 WL_ERR(("dhd_dev_ndo_cfg() failed: %d\n", ret));
7798 }
7799
7800 exit:
7801 return ret;
7802 }
7803 #endif /* NDO_CONFIG_SUPPORT */
7804
7805 /* for kernel >= 4.13 NL80211 wl_cfg80211_set_pmk have to be used. */
7806 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 13, 0))
wl_cfgvendor_set_pmk(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)7807 static int wl_cfgvendor_set_pmk(struct wiphy *wiphy,
7808 struct wireless_dev *wdev, const void *data, int len)
7809 {
7810 int ret = 0;
7811 wsec_pmk_t pmk;
7812 const struct nlattr *iter;
7813 int rem, type;
7814 struct net_device *ndev = wdev_to_ndev(wdev);
7815 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
7816 struct wl_security *sec;
7817
7818 nla_for_each_attr(iter, data, len, rem) {
7819 type = nla_type(iter);
7820 switch (type) {
7821 case BRCM_ATTR_DRIVER_KEY_PMK:
7822 if (nla_len(iter) > sizeof(pmk.key)) {
7823 ret = -EINVAL;
7824 goto exit;
7825 }
7826 pmk.flags = 0;
7827 pmk.key_len = htod16(nla_len(iter));
7828 bcopy((uint8 *)nla_data(iter), pmk.key, len);
7829 break;
7830 default:
7831 WL_ERR(("Unknown type: %d\n", type));
7832 ret = BCME_BADARG;
7833 goto exit;
7834 }
7835 }
7836
7837 sec = wl_read_prof(cfg, ndev, WL_PROF_SEC);
7838 if ((sec->wpa_auth == WLAN_AKM_SUITE_8021X) ||
7839 (sec->wpa_auth == WL_AKM_SUITE_SHA256_1X)) {
7840 ret = wldev_iovar_setbuf(ndev, "okc_info_pmk", pmk.key, pmk.key_len, cfg->ioctl_buf,
7841 WLC_IOCTL_SMLEN, &cfg->ioctl_buf_sync);
7842 if (ret) {
7843 /* could fail in case that 'okc' is not supported */
7844 WL_INFORM_MEM(("okc_info_pmk failed, err=%d (ignore)\n", ret));
7845 }
7846 }
7847
7848 ret = wldev_ioctl_set(ndev, WLC_SET_WSEC_PMK, &pmk, sizeof(pmk));
7849 WL_INFORM_MEM(("IOVAR set_pmk ret:%d", ret));
7850 exit:
7851 return ret;
7852 }
7853 #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(4, 13, 0) */
7854
wl_cfgvendor_get_driver_feature(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)7855 static int wl_cfgvendor_get_driver_feature(struct wiphy *wiphy,
7856 struct wireless_dev *wdev, const void *data, int len)
7857 {
7858 int ret = BCME_OK;
7859 u8 supported[(BRCM_WLAN_VENDOR_FEATURES_MAX / 8) + 1] = {0};
7860 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
7861 dhd_pub_t *dhd_pub = cfg->pub;
7862 struct sk_buff *skb;
7863 int32 mem_needed;
7864
7865 mem_needed = VENDOR_REPLY_OVERHEAD + NLA_HDRLEN + sizeof(supported);
7866
7867 BCM_REFERENCE(dhd_pub);
7868
7869 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 13, 0))
7870 if (FW_SUPPORTED(dhd_pub, idsup)) {
7871 ret = wl_features_set(supported, sizeof(supported),
7872 BRCM_WLAN_VENDOR_FEATURE_KEY_MGMT_OFFLOAD);
7873 }
7874 #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(4, 13, 0) */
7875
7876 /* Alloc the SKB for vendor_event */
7877 skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, mem_needed);
7878 if (unlikely(!skb)) {
7879 WL_ERR(("skb alloc failed"));
7880 ret = BCME_NOMEM;
7881 goto exit;
7882 }
7883
7884 ret = nla_put(skb, BRCM_ATTR_DRIVER_FEATURE_FLAGS, sizeof(supported), supported);
7885 if (ret) {
7886 kfree_skb(skb);
7887 goto exit;
7888 }
7889 ret = cfg80211_vendor_cmd_reply(skb);
7890 exit:
7891 return ret;
7892 }
7893
7894 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 3, 0))
7895 #define WL_VENDOR_POLICY_RAW_DATA .policy = VENDOR_CMD_RAW_DATA
7896 #else
7897 #define WL_VENDOR_POLICY_RAW_DATA
7898 #endif /* LINUX_VER >= 5.3 */
7899
7900 static const struct wiphy_vendor_command wl_vendor_cmds [] = {
7901 {
7902 {
7903 .vendor_id = OUI_BRCM,
7904 .subcmd = BRCM_VENDOR_SCMD_FRAMEBURST
7905 },
7906 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
7907 .doit = wl_cfgvendor_priv_frameburst,
7908 WL_VENDOR_POLICY_RAW_DATA
7909 },
7910 {
7911 {
7912 .vendor_id = OUI_BRCM,
7913 .subcmd = BRCM_VENDOR_SCMD_MPC
7914 },
7915 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
7916 .doit = wl_cfgvendor_priv_mpc,
7917 WL_VENDOR_POLICY_RAW_DATA
7918 },
7919 {
7920 {
7921 .vendor_id = OUI_BRCM,
7922 .subcmd = BRCM_VENDOR_SCMD_BAND
7923 },
7924 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
7925 .doit = wl_cfgvendor_priv_band,
7926 WL_VENDOR_POLICY_RAW_DATA
7927 },
7928 {
7929 {
7930 .vendor_id = OUI_BRCM,
7931 .subcmd = BRCM_VENDOR_SCMD_PRIV_STR
7932 },
7933 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
7934 .doit = wl_cfgvendor_priv_string_handler,
7935 WL_VENDOR_POLICY_RAW_DATA
7936 },
7937 #ifdef BCM_PRIV_CMD_SUPPORT
7938 {
7939 {
7940 .vendor_id = OUI_BRCM,
7941 .subcmd = BRCM_VENDOR_SCMD_BCM_STR
7942 },
7943 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
7944 .doit = wl_cfgvendor_priv_bcm_handler,
7945 WL_VENDOR_POLICY_RAW_DATA
7946 },
7947 #endif /* BCM_PRIV_CMD_SUPPORT */
7948 #ifdef WL_SAE
7949 {
7950 {
7951 .vendor_id = OUI_BRCM,
7952 .subcmd = BRCM_VENDOR_SCMD_BCM_PSK
7953 },
7954 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
7955 .doit = wl_cfgvendor_set_sae_password,
7956 WL_VENDOR_POLICY_RAW_DATA
7957 },
7958 #endif /* WL_SAE */
7959 #ifdef GSCAN_SUPPORT
7960 {
7961 {
7962 .vendor_id = OUI_GOOGLE,
7963 .subcmd = GSCAN_SUBCMD_GET_CAPABILITIES
7964 },
7965 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
7966 .doit = wl_cfgvendor_gscan_get_capabilities,
7967 WL_VENDOR_POLICY_RAW_DATA
7968 },
7969 {
7970 {
7971 .vendor_id = OUI_GOOGLE,
7972 .subcmd = GSCAN_SUBCMD_SET_CONFIG
7973 },
7974 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
7975 .doit = wl_cfgvendor_set_scan_cfg,
7976 WL_VENDOR_POLICY_RAW_DATA
7977 },
7978 {
7979 {
7980 .vendor_id = OUI_GOOGLE,
7981 .subcmd = GSCAN_SUBCMD_SET_SCAN_CONFIG
7982 },
7983 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
7984 .doit = wl_cfgvendor_set_batch_scan_cfg,
7985 WL_VENDOR_POLICY_RAW_DATA
7986 },
7987 {
7988 {
7989 .vendor_id = OUI_GOOGLE,
7990 .subcmd = GSCAN_SUBCMD_ENABLE_GSCAN
7991 },
7992 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
7993 .doit = wl_cfgvendor_initiate_gscan,
7994 WL_VENDOR_POLICY_RAW_DATA
7995 },
7996 {
7997 {
7998 .vendor_id = OUI_GOOGLE,
7999 .subcmd = GSCAN_SUBCMD_ENABLE_FULL_SCAN_RESULTS
8000 },
8001 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8002 .doit = wl_cfgvendor_enable_full_scan_result,
8003 WL_VENDOR_POLICY_RAW_DATA
8004 },
8005 {
8006 {
8007 .vendor_id = OUI_GOOGLE,
8008 .subcmd = GSCAN_SUBCMD_SET_HOTLIST
8009 },
8010 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8011 .doit = wl_cfgvendor_hotlist_cfg,
8012 WL_VENDOR_POLICY_RAW_DATA
8013 },
8014 {
8015 {
8016 .vendor_id = OUI_GOOGLE,
8017 .subcmd = GSCAN_SUBCMD_GET_SCAN_RESULTS
8018 },
8019 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8020 .doit = wl_cfgvendor_gscan_get_batch_results,
8021 WL_VENDOR_POLICY_RAW_DATA
8022 },
8023 #endif /* GSCAN_SUPPORT */
8024 #if defined(GSCAN_SUPPORT) || defined(DHD_GET_VALID_CHANNELS)
8025 {
8026 {
8027 .vendor_id = OUI_GOOGLE,
8028 .subcmd = GSCAN_SUBCMD_GET_CHANNEL_LIST
8029 },
8030 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8031 .doit = wl_cfgvendor_gscan_get_channel_list,
8032 WL_VENDOR_POLICY_RAW_DATA
8033 },
8034 #endif /* GSCAN_SUPPORT || DHD_GET_VALID_CHANNELS */
8035 #ifdef RTT_SUPPORT
8036 {
8037 {
8038 .vendor_id = OUI_GOOGLE,
8039 .subcmd = RTT_SUBCMD_SET_CONFIG
8040 },
8041 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8042 .doit = wl_cfgvendor_rtt_set_config,
8043 WL_VENDOR_POLICY_RAW_DATA
8044 },
8045 {
8046 {
8047 .vendor_id = OUI_GOOGLE,
8048 .subcmd = RTT_SUBCMD_CANCEL_CONFIG
8049 },
8050 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8051 .doit = wl_cfgvendor_rtt_cancel_config,
8052 WL_VENDOR_POLICY_RAW_DATA
8053 },
8054 {
8055 {
8056 .vendor_id = OUI_GOOGLE,
8057 .subcmd = RTT_SUBCMD_GETCAPABILITY
8058 },
8059 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8060 .doit = wl_cfgvendor_rtt_get_capability,
8061 WL_VENDOR_POLICY_RAW_DATA
8062 },
8063 {
8064 {
8065 .vendor_id = OUI_GOOGLE,
8066 .subcmd = RTT_SUBCMD_GETAVAILCHANNEL
8067 },
8068 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8069 .doit = wl_cfgvendor_rtt_get_responder_info,
8070 WL_VENDOR_POLICY_RAW_DATA
8071 },
8072 {
8073 {
8074 .vendor_id = OUI_GOOGLE,
8075 .subcmd = RTT_SUBCMD_SET_RESPONDER
8076 },
8077 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8078 .doit = wl_cfgvendor_rtt_set_responder,
8079 WL_VENDOR_POLICY_RAW_DATA
8080 },
8081 {
8082 {
8083 .vendor_id = OUI_GOOGLE,
8084 .subcmd = RTT_SUBCMD_CANCEL_RESPONDER
8085 },
8086 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8087 .doit = wl_cfgvendor_rtt_cancel_responder,
8088 WL_VENDOR_POLICY_RAW_DATA
8089 },
8090 #endif /* RTT_SUPPORT */
8091 {
8092 {
8093 .vendor_id = OUI_GOOGLE,
8094 .subcmd = ANDR_WIFI_SUBCMD_GET_FEATURE_SET
8095 },
8096 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8097 .doit = wl_cfgvendor_get_feature_set,
8098 WL_VENDOR_POLICY_RAW_DATA
8099 },
8100 {
8101 {
8102 .vendor_id = OUI_GOOGLE,
8103 .subcmd = ANDR_WIFI_SUBCMD_GET_FEATURE_SET_MATRIX
8104 },
8105 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8106 .doit = wl_cfgvendor_get_feature_set_matrix,
8107 WL_VENDOR_POLICY_RAW_DATA
8108 },
8109 {
8110 {
8111 .vendor_id = OUI_GOOGLE,
8112 .subcmd = ANDR_WIFI_SUBCMD_SET_PNO_RANDOM_MAC_OUI
8113 },
8114 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8115 .doit = wl_cfgvendor_set_pno_rand_mac_oui,
8116 WL_VENDOR_POLICY_RAW_DATA
8117 },
8118 #ifdef CUSTOM_FORCE_NODFS_FLAG
8119 {
8120 {
8121 .vendor_id = OUI_GOOGLE,
8122 .subcmd = ANDR_WIFI_NODFS_CHANNELS
8123 },
8124 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8125 .doit = wl_cfgvendor_set_nodfs_flag,
8126 WL_VENDOR_POLICY_RAW_DATA
8127 },
8128 #endif /* CUSTOM_FORCE_NODFS_FLAG */
8129 {
8130 {
8131 .vendor_id = OUI_GOOGLE,
8132 .subcmd = ANDR_WIFI_SET_COUNTRY
8133 },
8134 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8135 .doit = wl_cfgvendor_set_country,
8136 WL_VENDOR_POLICY_RAW_DATA
8137 },
8138 #ifdef LINKSTAT_SUPPORT
8139 {
8140 {
8141 .vendor_id = OUI_GOOGLE,
8142 .subcmd = LSTATS_SUBCMD_GET_INFO
8143 },
8144 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8145 .doit = wl_cfgvendor_lstats_get_info,
8146 WL_VENDOR_POLICY_RAW_DATA
8147 },
8148 #endif /* LINKSTAT_SUPPORT */
8149
8150 #ifdef GSCAN_SUPPORT
8151 {
8152 {
8153 .vendor_id = OUI_GOOGLE,
8154 .subcmd = GSCAN_SUBCMD_SET_EPNO_SSID
8155 },
8156 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8157 .doit = wl_cfgvendor_epno_cfg,
8158 WL_VENDOR_POLICY_RAW_DATA
8159 },
8160 {
8161 {
8162 .vendor_id = OUI_GOOGLE,
8163 .subcmd = WIFI_SUBCMD_SET_LAZY_ROAM_PARAMS
8164 },
8165 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8166 .doit = wl_cfgvendor_set_lazy_roam_cfg,
8167 WL_VENDOR_POLICY_RAW_DATA
8168 },
8169 {
8170 {
8171 .vendor_id = OUI_GOOGLE,
8172 .subcmd = WIFI_SUBCMD_ENABLE_LAZY_ROAM
8173 },
8174 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8175 .doit = wl_cfgvendor_enable_lazy_roam,
8176 WL_VENDOR_POLICY_RAW_DATA
8177
8178 },
8179 {
8180 {
8181 .vendor_id = OUI_GOOGLE,
8182 .subcmd = WIFI_SUBCMD_SET_BSSID_PREF
8183 },
8184 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8185 .doit = wl_cfgvendor_set_bssid_pref,
8186 WL_VENDOR_POLICY_RAW_DATA
8187
8188 },
8189 #endif /* GSCAN_SUPPORT */
8190 #if defined(GSCAN_SUPPORT) || defined(ROAMEXP_SUPPORT)
8191 {
8192 {
8193 .vendor_id = OUI_GOOGLE,
8194 .subcmd = WIFI_SUBCMD_SET_SSID_WHITELIST
8195 },
8196 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8197 .doit = wl_cfgvendor_set_ssid_whitelist,
8198 WL_VENDOR_POLICY_RAW_DATA
8199
8200 },
8201 {
8202 {
8203 .vendor_id = OUI_GOOGLE,
8204 .subcmd = WIFI_SUBCMD_SET_BSSID_BLACKLIST
8205 },
8206 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8207 .doit = wl_cfgvendor_set_bssid_blacklist,
8208 WL_VENDOR_POLICY_RAW_DATA
8209 },
8210 #endif /* GSCAN_SUPPORT || ROAMEXP_SUPPORT */
8211 #ifdef ROAMEXP_SUPPORT
8212 {
8213 {
8214 .vendor_id = OUI_GOOGLE,
8215 .subcmd = WIFI_SUBCMD_FW_ROAM_POLICY
8216 },
8217 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8218 .doit = wl_cfgvendor_set_fw_roaming_state,
8219 WL_VENDOR_POLICY_RAW_DATA
8220 },
8221 {
8222 {
8223 .vendor_id = OUI_GOOGLE,
8224 .subcmd = WIFI_SUBCMD_ROAM_CAPABILITY
8225 },
8226 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8227 .doit = wl_cfgvendor_fw_roam_get_capability,
8228 WL_VENDOR_POLICY_RAW_DATA
8229 },
8230 #endif /* ROAMEXP_SUPPORT */
8231 {
8232 {
8233 .vendor_id = OUI_GOOGLE,
8234 .subcmd = DEBUG_GET_VER
8235 },
8236 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8237 .doit = wl_cfgvendor_dbg_get_version,
8238 WL_VENDOR_POLICY_RAW_DATA
8239 },
8240 #ifdef DHD_LOG_DUMP
8241 {
8242 {
8243 .vendor_id = OUI_GOOGLE,
8244 .subcmd = DEBUG_GET_FILE_DUMP_BUF
8245 },
8246 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8247 .doit = wl_cfgvendor_dbg_file_dump,
8248 WL_VENDOR_POLICY_RAW_DATA
8249 },
8250 #endif /* DHD_LOG_DUMP */
8251 {
8252 {
8253 .vendor_id = OUI_GOOGLE,
8254 .subcmd = DEBUG_TRIGGER_MEM_DUMP
8255 },
8256 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8257 .doit = wl_cfgvendor_dbg_trigger_mem_dump,
8258 WL_VENDOR_POLICY_RAW_DATA
8259 },
8260 {
8261 {
8262 .vendor_id = OUI_GOOGLE,
8263 .subcmd = DEBUG_GET_MEM_DUMP
8264 },
8265 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8266 .doit = wl_cfgvendor_dbg_get_mem_dump,
8267 WL_VENDOR_POLICY_RAW_DATA
8268 },
8269 {
8270 {
8271 .vendor_id = OUI_GOOGLE,
8272 .subcmd = DEBUG_START_LOGGING
8273 },
8274 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8275 .doit = wl_cfgvendor_dbg_start_logging,
8276 WL_VENDOR_POLICY_RAW_DATA
8277 },
8278 {
8279 {
8280 .vendor_id = OUI_GOOGLE,
8281 .subcmd = DEBUG_RESET_LOGGING
8282 },
8283 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8284 .doit = wl_cfgvendor_dbg_reset_logging,
8285 WL_VENDOR_POLICY_RAW_DATA
8286 },
8287 {
8288 {
8289 .vendor_id = OUI_GOOGLE,
8290 .subcmd = DEBUG_GET_RING_STATUS
8291 },
8292 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8293 .doit = wl_cfgvendor_dbg_get_ring_status,
8294 WL_VENDOR_POLICY_RAW_DATA
8295 },
8296 {
8297 {
8298 .vendor_id = OUI_GOOGLE,
8299 .subcmd = DEBUG_GET_RING_DATA
8300 },
8301 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8302 .doit = wl_cfgvendor_dbg_get_ring_data,
8303 WL_VENDOR_POLICY_RAW_DATA
8304 },
8305 {
8306 {
8307 .vendor_id = OUI_GOOGLE,
8308 .subcmd = DEBUG_GET_FEATURE
8309 },
8310 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8311 .doit = wl_cfgvendor_dbg_get_feature,
8312 WL_VENDOR_POLICY_RAW_DATA
8313 },
8314 #ifdef DBG_PKT_MON
8315 {
8316 {
8317 .vendor_id = OUI_GOOGLE,
8318 .subcmd = DEBUG_START_PKT_FATE_MONITORING
8319 },
8320 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8321 .doit = wl_cfgvendor_dbg_start_pkt_fate_monitoring,
8322 WL_VENDOR_POLICY_RAW_DATA
8323 },
8324 {
8325 {
8326 .vendor_id = OUI_GOOGLE,
8327 .subcmd = DEBUG_GET_TX_PKT_FATES
8328 },
8329 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8330 .doit = wl_cfgvendor_dbg_get_tx_pkt_fates,
8331 WL_VENDOR_POLICY_RAW_DATA
8332 },
8333 {
8334 {
8335 .vendor_id = OUI_GOOGLE,
8336 .subcmd = DEBUG_GET_RX_PKT_FATES
8337 },
8338 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8339 .doit = wl_cfgvendor_dbg_get_rx_pkt_fates,
8340 WL_VENDOR_POLICY_RAW_DATA
8341 },
8342 #endif /* DBG_PKT_MON */
8343 #ifdef KEEP_ALIVE
8344 {
8345 {
8346 .vendor_id = OUI_GOOGLE,
8347 .subcmd = WIFI_OFFLOAD_SUBCMD_START_MKEEP_ALIVE
8348 },
8349 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8350 .doit = wl_cfgvendor_start_mkeep_alive,
8351 WL_VENDOR_POLICY_RAW_DATA
8352 },
8353 {
8354 {
8355 .vendor_id = OUI_GOOGLE,
8356 .subcmd = WIFI_OFFLOAD_SUBCMD_STOP_MKEEP_ALIVE
8357 },
8358 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8359 .doit = wl_cfgvendor_stop_mkeep_alive,
8360 WL_VENDOR_POLICY_RAW_DATA
8361 },
8362 #endif /* KEEP_ALIVE */
8363 #ifdef WL_NAN
8364 {
8365 {
8366 .vendor_id = OUI_GOOGLE,
8367 .subcmd = NAN_WIFI_SUBCMD_ENABLE
8368 },
8369 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8370 .doit = wl_cfgvendor_nan_start_handler,
8371 WL_VENDOR_POLICY_RAW_DATA
8372 },
8373 {
8374 {
8375 .vendor_id = OUI_GOOGLE,
8376 .subcmd = NAN_WIFI_SUBCMD_DISABLE
8377 },
8378 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8379 .doit = wl_cfgvendor_nan_stop_handler,
8380 WL_VENDOR_POLICY_RAW_DATA
8381 },
8382 {
8383 {
8384 .vendor_id = OUI_GOOGLE,
8385 .subcmd = NAN_WIFI_SUBCMD_CONFIG
8386 },
8387 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8388 .doit = wl_cfgvendor_nan_config_handler,
8389 WL_VENDOR_POLICY_RAW_DATA
8390 },
8391 {
8392 {
8393 .vendor_id = OUI_GOOGLE,
8394 .subcmd = NAN_WIFI_SUBCMD_REQUEST_PUBLISH
8395 },
8396 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8397 .doit = wl_cfgvendor_nan_req_publish,
8398 WL_VENDOR_POLICY_RAW_DATA
8399 },
8400 {
8401 {
8402 .vendor_id = OUI_GOOGLE,
8403 .subcmd = NAN_WIFI_SUBCMD_REQUEST_SUBSCRIBE
8404 },
8405 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8406 .doit = wl_cfgvendor_nan_req_subscribe,
8407 WL_VENDOR_POLICY_RAW_DATA
8408 },
8409 {
8410 {
8411 .vendor_id = OUI_GOOGLE,
8412 .subcmd = NAN_WIFI_SUBCMD_CANCEL_PUBLISH
8413 },
8414 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8415 .doit = wl_cfgvendor_nan_cancel_publish,
8416 WL_VENDOR_POLICY_RAW_DATA
8417 },
8418 {
8419 {
8420 .vendor_id = OUI_GOOGLE,
8421 .subcmd = NAN_WIFI_SUBCMD_CANCEL_SUBSCRIBE
8422 },
8423 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8424 .doit = wl_cfgvendor_nan_cancel_subscribe,
8425 WL_VENDOR_POLICY_RAW_DATA
8426 },
8427 {
8428 {
8429 .vendor_id = OUI_GOOGLE,
8430 .subcmd = NAN_WIFI_SUBCMD_TRANSMIT
8431 },
8432 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8433 .doit = wl_cfgvendor_nan_transmit,
8434 WL_VENDOR_POLICY_RAW_DATA
8435 },
8436 {
8437 {
8438 .vendor_id = OUI_GOOGLE,
8439 .subcmd = NAN_WIFI_SUBCMD_GET_CAPABILITIES
8440 },
8441 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8442 .doit = wl_cfgvendor_nan_get_capablities,
8443 WL_VENDOR_POLICY_RAW_DATA
8444 },
8445
8446 {
8447 {
8448 .vendor_id = OUI_GOOGLE,
8449 .subcmd = NAN_WIFI_SUBCMD_DATA_PATH_IFACE_CREATE
8450 },
8451 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8452 .doit = wl_cfgvendor_nan_data_path_iface_create,
8453 WL_VENDOR_POLICY_RAW_DATA
8454 },
8455 {
8456 {
8457 .vendor_id = OUI_GOOGLE,
8458 .subcmd = NAN_WIFI_SUBCMD_DATA_PATH_IFACE_DELETE
8459 },
8460 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8461 .doit = wl_cfgvendor_nan_data_path_iface_delete,
8462 WL_VENDOR_POLICY_RAW_DATA
8463 },
8464 {
8465 {
8466 .vendor_id = OUI_GOOGLE,
8467 .subcmd = NAN_WIFI_SUBCMD_DATA_PATH_REQUEST
8468 },
8469 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8470 .doit = wl_cfgvendor_nan_data_path_request,
8471 WL_VENDOR_POLICY_RAW_DATA
8472 },
8473 {
8474 {
8475 .vendor_id = OUI_GOOGLE,
8476 .subcmd = NAN_WIFI_SUBCMD_DATA_PATH_RESPONSE
8477 },
8478 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8479 .doit = wl_cfgvendor_nan_data_path_response,
8480 WL_VENDOR_POLICY_RAW_DATA
8481 },
8482 {
8483 {
8484 .vendor_id = OUI_GOOGLE,
8485 .subcmd = NAN_WIFI_SUBCMD_DATA_PATH_END
8486 },
8487 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8488 .doit = wl_cfgvendor_nan_data_path_end,
8489 WL_VENDOR_POLICY_RAW_DATA
8490 },
8491 #ifdef WL_NAN_DISC_CACHE
8492 {
8493 {
8494 .vendor_id = OUI_GOOGLE,
8495 .subcmd = NAN_WIFI_SUBCMD_DATA_PATH_SEC_INFO
8496 },
8497 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8498 .doit = wl_cfgvendor_nan_data_path_sec_info,
8499 WL_VENDOR_POLICY_RAW_DATA
8500 },
8501 #endif /* WL_NAN_DISC_CACHE */
8502 {
8503 {
8504 .vendor_id = OUI_GOOGLE,
8505 .subcmd = NAN_WIFI_SUBCMD_VERSION_INFO
8506 },
8507 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8508 .doit = wl_cfgvendor_nan_version_info,
8509 WL_VENDOR_POLICY_RAW_DATA
8510 },
8511 #endif /* WL_NAN */
8512 #if defined(PKT_FILTER_SUPPORT) && defined(APF)
8513 {
8514 {
8515 .vendor_id = OUI_GOOGLE,
8516 .subcmd = APF_SUBCMD_GET_CAPABILITIES
8517 },
8518 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8519 .doit = wl_cfgvendor_apf_get_capabilities,
8520 WL_VENDOR_POLICY_RAW_DATA
8521 },
8522
8523 {
8524 {
8525 .vendor_id = OUI_GOOGLE,
8526 .subcmd = APF_SUBCMD_SET_FILTER
8527 },
8528 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8529 .doit = wl_cfgvendor_apf_set_filter,
8530 WL_VENDOR_POLICY_RAW_DATA
8531 },
8532 #endif /* PKT_FILTER_SUPPORT && APF */
8533 #ifdef NDO_CONFIG_SUPPORT
8534 {
8535 {
8536 .vendor_id = OUI_GOOGLE,
8537 .subcmd = WIFI_SUBCMD_CONFIG_ND_OFFLOAD
8538 },
8539 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8540 .doit = wl_cfgvendor_configure_nd_offload,
8541 WL_VENDOR_POLICY_RAW_DATA
8542 },
8543 #endif /* NDO_CONFIG_SUPPORT */
8544 #ifdef RSSI_MONITOR_SUPPORT
8545 {
8546 {
8547 .vendor_id = OUI_GOOGLE,
8548 .subcmd = WIFI_SUBCMD_SET_RSSI_MONITOR
8549 },
8550 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8551 .doit = wl_cfgvendor_set_rssi_monitor,
8552 WL_VENDOR_POLICY_RAW_DATA
8553 },
8554 #endif /* RSSI_MONITOR_SUPPORT */
8555 #ifdef DHD_WAKE_STATUS
8556 {
8557 {
8558 .vendor_id = OUI_GOOGLE,
8559 .subcmd = DEBUG_GET_WAKE_REASON_STATS
8560 },
8561 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8562 .doit = wl_cfgvendor_get_wake_reason_stats,
8563 WL_VENDOR_POLICY_RAW_DATA
8564 },
8565 #endif /* DHD_WAKE_STATUS */
8566 #ifdef DHDTCPACK_SUPPRESS
8567 {
8568 {
8569 .vendor_id = OUI_GOOGLE,
8570 .subcmd = WIFI_SUBCMD_CONFIG_TCPACK_SUP
8571 },
8572 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8573 .doit = wl_cfgvendor_set_tcpack_sup_mode,
8574 WL_VENDOR_POLICY_RAW_DATA
8575 },
8576 #endif /* DHDTCPACK_SUPPRESS */
8577 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 13, 0))
8578 {
8579 {
8580 .vendor_id = OUI_BRCM,
8581 .subcmd = BRCM_VENDOR_SCMD_SET_PMK
8582 },
8583 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8584 .doit = wl_cfgvendor_set_pmk,
8585 WL_VENDOR_POLICY_RAW_DATA
8586 },
8587 #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(4, 13, 0) */
8588 {
8589 {
8590 .vendor_id = OUI_BRCM,
8591 .subcmd = BRCM_VENDOR_SCMD_GET_FEATURES
8592 },
8593 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8594 .doit = wl_cfgvendor_get_driver_feature,
8595 WL_VENDOR_POLICY_RAW_DATA
8596 },
8597 #if defined(WL_CFG80211) && defined(DHD_FILE_DUMP_EVENT)
8598 {
8599 {
8600 .vendor_id = OUI_GOOGLE,
8601 .subcmd = DEBUG_FILE_DUMP_DONE_IND
8602 },
8603 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8604 .doit = wl_cfgvendor_notify_dump_completion,
8605 WL_VENDOR_POLICY_RAW_DATA
8606 },
8607 #endif /* WL_CFG80211 && DHD_FILE_DUMP_EVENT */
8608 #if defined(WL_CFG80211)
8609 {
8610 {
8611 .vendor_id = OUI_GOOGLE,
8612 .subcmd = DEBUG_SET_HAL_START
8613 },
8614 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8615 .doit = wl_cfgvendor_set_hal_started,
8616 WL_VENDOR_POLICY_RAW_DATA
8617 },
8618 {
8619 {
8620 .vendor_id = OUI_GOOGLE,
8621 .subcmd = DEBUG_SET_HAL_STOP
8622 },
8623 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8624 .doit = wl_cfgvendor_stop_hal,
8625 WL_VENDOR_POLICY_RAW_DATA
8626 },
8627 #endif /* WL_CFG80211 */
8628 {
8629 {
8630 .vendor_id = OUI_GOOGLE,
8631 .subcmd = WIFI_SUBCMD_SET_LATENCY_MODE
8632 },
8633 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8634 .doit = wl_cfgvendor_set_latency_mode,
8635 WL_VENDOR_POLICY_RAW_DATA
8636 },
8637 {
8638 {
8639 .vendor_id = OUI_GOOGLE,
8640 .subcmd = WIFI_SUBCMD_TX_POWER_SCENARIO
8641 },
8642 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
8643 .doit = wl_cfgvendor_set_tx_power_scenario,
8644 WL_VENDOR_POLICY_RAW_DATA
8645 }
8646
8647 };
8648
8649 static const struct nl80211_vendor_cmd_info wl_vendor_events [] = {
8650 { OUI_BRCM, BRCM_VENDOR_EVENT_UNSPEC },
8651 { OUI_BRCM, BRCM_VENDOR_EVENT_PRIV_STR },
8652 { OUI_GOOGLE, GOOGLE_GSCAN_SIGNIFICANT_EVENT },
8653 { OUI_GOOGLE, GOOGLE_GSCAN_GEOFENCE_FOUND_EVENT },
8654 { OUI_GOOGLE, GOOGLE_GSCAN_BATCH_SCAN_EVENT },
8655 { OUI_GOOGLE, GOOGLE_SCAN_FULL_RESULTS_EVENT },
8656 { OUI_GOOGLE, GOOGLE_RTT_COMPLETE_EVENT },
8657 { OUI_GOOGLE, GOOGLE_SCAN_COMPLETE_EVENT },
8658 { OUI_GOOGLE, GOOGLE_GSCAN_GEOFENCE_LOST_EVENT },
8659 { OUI_GOOGLE, GOOGLE_SCAN_EPNO_EVENT },
8660 { OUI_GOOGLE, GOOGLE_DEBUG_RING_EVENT },
8661 { OUI_GOOGLE, GOOGLE_FW_DUMP_EVENT },
8662 { OUI_GOOGLE, GOOGLE_PNO_HOTSPOT_FOUND_EVENT },
8663 { OUI_GOOGLE, GOOGLE_RSSI_MONITOR_EVENT },
8664 { OUI_GOOGLE, GOOGLE_MKEEP_ALIVE_EVENT },
8665 { OUI_GOOGLE, GOOGLE_NAN_EVENT_ENABLED},
8666 { OUI_GOOGLE, GOOGLE_NAN_EVENT_DISABLED},
8667 { OUI_GOOGLE, GOOGLE_NAN_EVENT_SUBSCRIBE_MATCH},
8668 { OUI_GOOGLE, GOOGLE_NAN_EVENT_REPLIED},
8669 { OUI_GOOGLE, GOOGLE_NAN_EVENT_PUBLISH_TERMINATED},
8670 { OUI_GOOGLE, GOOGLE_NAN_EVENT_SUBSCRIBE_TERMINATED},
8671 { OUI_GOOGLE, GOOGLE_NAN_EVENT_DE_EVENT},
8672 { OUI_GOOGLE, GOOGLE_NAN_EVENT_FOLLOWUP},
8673 { OUI_GOOGLE, GOOGLE_NAN_EVENT_TRANSMIT_FOLLOWUP_IND},
8674 { OUI_GOOGLE, GOOGLE_NAN_EVENT_DATA_REQUEST},
8675 { OUI_GOOGLE, GOOGLE_NAN_EVENT_DATA_CONFIRMATION},
8676 { OUI_GOOGLE, GOOGLE_NAN_EVENT_DATA_END},
8677 { OUI_GOOGLE, GOOGLE_NAN_EVENT_BEACON},
8678 { OUI_GOOGLE, GOOGLE_NAN_EVENT_SDF},
8679 { OUI_GOOGLE, GOOGLE_NAN_EVENT_TCA},
8680 { OUI_GOOGLE, GOOGLE_NAN_EVENT_SUBSCRIBE_UNMATCH},
8681 { OUI_GOOGLE, GOOGLE_NAN_EVENT_UNKNOWN},
8682 { OUI_GOOGLE, GOOGLE_ROAM_EVENT_START},
8683 { OUI_BRCM, BRCM_VENDOR_EVENT_HANGED},
8684 { OUI_BRCM, BRCM_VENDOR_EVENT_SAE_KEY},
8685 { OUI_BRCM, BRCM_VENDOR_EVENT_BEACON_RECV},
8686 { OUI_BRCM, BRCM_VENDOR_EVENT_PORT_AUTHORIZED},
8687 { OUI_GOOGLE, GOOGLE_FILE_DUMP_EVENT },
8688 { OUI_BRCM, BRCM_VENDOR_EVENT_CU},
8689 { OUI_BRCM, BRCM_VENDOR_EVENT_WIPS}
8690 };
8691
wl_cfgvendor_attach(struct wiphy * wiphy,dhd_pub_t * dhd)8692 int wl_cfgvendor_attach(struct wiphy *wiphy, dhd_pub_t *dhd)
8693 {
8694
8695 WL_INFORM_MEM(("Vendor: Register BRCM cfg80211 vendor cmd(0x%x) interface \n",
8696 NL80211_CMD_VENDOR));
8697
8698 wiphy->vendor_commands = wl_vendor_cmds;
8699 wiphy->n_vendor_commands = ARRAY_SIZE(wl_vendor_cmds);
8700 wiphy->vendor_events = wl_vendor_events;
8701 wiphy->n_vendor_events = ARRAY_SIZE(wl_vendor_events);
8702
8703 #ifdef DEBUGABILITY
8704 dhd_os_dbg_register_callback(FW_VERBOSE_RING_ID, wl_cfgvendor_dbg_ring_send_evt);
8705 dhd_os_dbg_register_callback(DHD_EVENT_RING_ID, wl_cfgvendor_dbg_ring_send_evt);
8706 #endif /* DEBUGABILITY */
8707 #ifdef DHD_LOG_DUMP
8708 dhd_os_dbg_register_urgent_notifier(dhd, wl_cfgvendor_dbg_send_file_dump_evt);
8709 #endif /* DHD_LOG_DUMP */
8710
8711 return 0;
8712 }
8713
wl_cfgvendor_detach(struct wiphy * wiphy)8714 int wl_cfgvendor_detach(struct wiphy *wiphy)
8715 {
8716 WL_INFORM_MEM(("Vendor: Unregister BRCM cfg80211 vendor interface \n"));
8717
8718 wiphy->vendor_commands = NULL;
8719 wiphy->vendor_events = NULL;
8720 wiphy->n_vendor_commands = 0;
8721 wiphy->n_vendor_events = 0;
8722
8723 return 0;
8724 }
8725 #endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(3, 13, 0)) || defined(WL_VENDOR_EXT_SUPPORT) */
8726
8727 #ifdef WL_CFGVENDOR_SEND_HANG_EVENT
8728 void
wl_cfgvendor_send_hang_event(struct net_device * dev,u16 reason,char * string,int hang_info_cnt)8729 wl_cfgvendor_send_hang_event(struct net_device *dev, u16 reason, char *string, int hang_info_cnt)
8730 {
8731 struct bcm_cfg80211 *cfg = wl_get_cfg(dev);
8732 struct wiphy *wiphy;
8733 char *hang_info;
8734 int len = 0;
8735 int bytes_written;
8736 uint32 dummy_data = 0;
8737 int reason_hang_info = 0;
8738 int cnt = 0;
8739 dhd_pub_t *dhd;
8740 int hang_reason_mismatch = FALSE;
8741
8742 if (!cfg || !cfg->wdev) {
8743 WL_ERR(("cfg=%p wdev=%p\n", cfg, (cfg ? cfg->wdev : NULL)));
8744 return;
8745 }
8746
8747 wiphy = cfg->wdev->wiphy;
8748
8749 if (!wiphy) {
8750 WL_ERR(("wiphy is NULL\n"));
8751 return;
8752 }
8753
8754 hang_info = MALLOCZ(cfg->osh, VENDOR_SEND_HANG_EXT_INFO_LEN);
8755 if (hang_info == NULL) {
8756 WL_ERR(("alloc hang_info failed\n"));
8757 return;
8758 }
8759
8760 dhd = (dhd_pub_t *)(cfg->pub);
8761
8762 #ifdef WL_BCNRECV
8763 /* check fakeapscan in progress then stop scan */
8764 if (cfg->bcnrecv_info.bcnrecv_state == BEACON_RECV_STARTED) {
8765 wl_android_bcnrecv_stop(dev, WL_BCNRECV_HANG);
8766 }
8767 #endif /* WL_BCNRECV */
8768 sscanf(string, "%d", &reason_hang_info);
8769 bytes_written = 0;
8770 len = VENDOR_SEND_HANG_EXT_INFO_LEN - bytes_written;
8771 if (strlen(string) == 0 || (reason_hang_info != reason)) {
8772 WL_ERR(("hang reason mismatch: string len %d reason_hang_info %d\n",
8773 (int)strlen(string), reason_hang_info));
8774 hang_reason_mismatch = TRUE;
8775 if (dhd) {
8776 get_debug_dump_time(dhd->debug_dump_time_hang_str);
8777 copy_debug_dump_time(dhd->debug_dump_time_str,
8778 dhd->debug_dump_time_hang_str);
8779 }
8780 bytes_written += scnprintf(&hang_info[bytes_written], len,
8781 "%d %d %s %08x %08x %08x %08x %08x %08x %08x",
8782 reason, VENDOR_SEND_HANG_EXT_INFO_VER,
8783 dhd->debug_dump_time_hang_str,
8784 0, 0, 0, 0, 0, 0, 0);
8785 if (dhd) {
8786 clear_debug_dump_time(dhd->debug_dump_time_hang_str);
8787 }
8788 } else {
8789 bytes_written += scnprintf(&hang_info[bytes_written], len, "%s", string);
8790 }
8791
8792 WL_ERR(("hang reason: %d info cnt: %d\n", reason, hang_info_cnt));
8793
8794 if (hang_reason_mismatch == FALSE) {
8795 cnt = hang_info_cnt;
8796 } else {
8797 cnt = HANG_FIELD_MISMATCH_CNT;
8798 }
8799
8800 while (cnt < HANG_FIELD_CNT_MAX) {
8801 len = VENDOR_SEND_HANG_EXT_INFO_LEN - bytes_written;
8802 if (len <= 0) {
8803 break;
8804 }
8805 bytes_written += scnprintf(&hang_info[bytes_written], len,
8806 "%c%08x", HANG_RAW_DEL, dummy_data);
8807 cnt++;
8808 }
8809
8810 WL_ERR(("hang info cnt: %d len: %d\n", cnt, (int)strlen(hang_info)));
8811 WL_ERR(("hang info data: %s\n", hang_info));
8812
8813 wl_cfgvendor_send_async_event(wiphy,
8814 bcmcfg_to_prmry_ndev(cfg), BRCM_VENDOR_EVENT_HANGED,
8815 hang_info, (int)strlen(hang_info));
8816
8817 memset(string, 0, VENDOR_SEND_HANG_EXT_INFO_LEN);
8818
8819 if (hang_info) {
8820 MFREE(cfg->osh, hang_info, VENDOR_SEND_HANG_EXT_INFO_LEN);
8821 }
8822
8823 #ifdef DHD_LOG_DUMP
8824 dhd_logdump_cookie_save(dhd, dhd->debug_dump_time_hang_str, "HANG");
8825 #endif /* DHD_LOG_DUMP */
8826
8827 if (dhd) {
8828 clear_debug_dump_time(dhd->debug_dump_time_str);
8829 }
8830 }
8831
8832 void
wl_copy_hang_info_if_falure(struct net_device * dev,u16 reason,s32 ret)8833 wl_copy_hang_info_if_falure(struct net_device *dev, u16 reason, s32 ret)
8834 {
8835 struct bcm_cfg80211 *cfg = NULL;
8836 dhd_pub_t *dhd;
8837 s32 err = 0;
8838 char ioctl_buf[WLC_IOCTL_SMLEN];
8839 memuse_info_t mu;
8840 int bytes_written = 0;
8841 int remain_len = 0;
8842
8843 if (!dev) {
8844 WL_ERR(("dev is null"));
8845 return;
8846
8847 }
8848
8849 cfg = wl_get_cfg(dev);
8850 if (!cfg) {
8851 WL_ERR(("dev=%p cfg=%p\n", dev, cfg));
8852 return;
8853 }
8854
8855 dhd = (dhd_pub_t *)(cfg->pub);
8856
8857 if (!dhd || !dhd->hang_info) {
8858 WL_ERR(("%s dhd=%p hang_info=%p\n", __FUNCTION__,
8859 dhd, (dhd ? dhd->hang_info : NULL)));
8860 return;
8861 }
8862
8863 err = wldev_iovar_getbuf_bsscfg(dev, "memuse",
8864 NULL, 0, ioctl_buf, WLC_IOCTL_SMLEN, 0, NULL);
8865 if (unlikely(err)) {
8866 WL_ERR(("error (%d)\n", err));
8867 return;
8868 }
8869
8870 memcpy(&mu, ioctl_buf, sizeof(memuse_info_t));
8871
8872 if (mu.len >= sizeof(memuse_info_t)) {
8873 WL_ERR(("Heap Total: %d(%dK)\n", mu.arena_size, KB(mu.arena_size)));
8874 WL_ERR(("Free: %d(%dK), LWM: %d(%dK)\n",
8875 mu.arena_free, KB(mu.arena_free),
8876 mu.free_lwm, KB(mu.free_lwm)));
8877 WL_ERR(("In use: %d(%dK), HWM: %d(%dK)\n",
8878 mu.inuse_size, KB(mu.inuse_size),
8879 mu.inuse_hwm, KB(mu.inuse_hwm)));
8880 WL_ERR(("Malloc failure count: %d\n", mu.mf_count));
8881 }
8882
8883 memset(dhd->hang_info, 0, VENDOR_SEND_HANG_EXT_INFO_LEN);
8884 remain_len = VENDOR_SEND_HANG_EXT_INFO_LEN - bytes_written;
8885
8886 get_debug_dump_time(dhd->debug_dump_time_hang_str);
8887 copy_debug_dump_time(dhd->debug_dump_time_str, dhd->debug_dump_time_hang_str);
8888
8889 bytes_written += scnprintf(&dhd->hang_info[bytes_written], remain_len,
8890 "%d %d %s %d %d %d %d %d %08x %08x",
8891 reason, VENDOR_SEND_HANG_EXT_INFO_VER,
8892 dhd->debug_dump_time_hang_str,
8893 ret, mu.arena_size, mu.arena_free, mu.inuse_size, mu.mf_count, 0, 0);
8894
8895 dhd->hang_info_cnt = HANG_FIELD_IF_FAILURE_CNT;
8896
8897 clear_debug_dump_time(dhd->debug_dump_time_hang_str);
8898
8899 return;
8900 }
8901 #endif /* WL_CFGVENDOR_SEND_HANG_EVENT */
8902