1 /******************************************************************************
2 *
3 * Copyright(c) 2012 - 2018 icomm Corporation. All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
17 *
18 *
19 ******************************************************************************/
20
21 #include "dev.h"
22
23 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(CONFIG_SSV_VENDOR_EXT_SUPPORT)
24
25
26 #include <linux/kernel.h>
27 #include <linux/if_arp.h>
28 #include <linux/uaccess.h>
29
30 #include <linux/kernel.h>
31 #include <linux/kthread.h>
32 #include <linux/netdevice.h>
33 #include <linux/sched.h>
34 #include <linux/etherdevice.h>
35 #include <linux/wireless.h>
36 #include <linux/ieee80211.h>
37 #include <linux/wait.h>
38 #include <net/cfg80211.h>
39
40 #include <net/rtnetlink.h>
41 #include "ssv_cfgvendor.h"
42
43 #define DBG_SSV_LEVEL(lev, x, ...) do {printk(x,##__VA_ARGS__);} while(0)
44 #define DBG_SSV(x, ...) do {printk(x,##__VA_ARGS__);} while(0)
45
46 #define wiphy_to_softc(x) (*((struct ssv_softc**)wiphy_priv(x)))
47 #define FUNC_NDEV_FMT "%s"
48 #define FUNC_NDEV_ARG(ndev) __func__
49
50 #define _drv_always_ 1
51 #define _drv_emerg_ 2
52 #define _drv_alert_ 3
53 #define _drv_crit_ 4
54 #define _drv_err_ 5
55 #define _drv_warning_ 6
56 #define _drv_notice_ 7
57 #define _drv_info_ 8
58 #define _drv_dump_ 9
59 #define _drv_debug_ 10
60
61
62 #if 1
ssv_cfg80211_vendor_event_alloc(struct wiphy * wiphy,int len,int event_id,gfp_t gfp)63 struct sk_buff * ssv_cfg80211_vendor_event_alloc(
64 struct wiphy *wiphy, int len, int event_id, gfp_t gfp)
65 {
66 struct sk_buff *skb;
67
68 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 1, 0))
69 skb = cfg80211_vendor_event_alloc(wiphy, len, event_id, gfp);
70 #else
71 skb = cfg80211_vendor_event_alloc(wiphy, NULL, len, event_id, gfp);
72 #endif
73 return skb;
74 }
75
76 #define ssv_cfg80211_vendor_event(skb, gfp) \
77 cfg80211_vendor_event(skb, gfp)
78
79 #define ssv_cfg80211_vendor_cmd_alloc_reply_skb(wiphy, len) \
80 cfg80211_vendor_cmd_alloc_reply_skb(wiphy, len)
81
82 #define ssv_cfg80211_vendor_cmd_reply(skb) \
83 cfg80211_vendor_cmd_reply(skb)
84
85 #endif
86
87 /*
88 * This API is to be used for asynchronous vendor events. This
89 * shouldn't be used in response to a vendor command from its
90 * do_it handler context (instead ssv_cfgvendor_send_cmd_reply should
91 * be used).
92 */
ssv_cfgvendor_send_async_event(struct wiphy * wiphy,struct net_device * dev,int event_id,const void * data,int len)93 int ssv_cfgvendor_send_async_event(struct wiphy *wiphy,
94 struct net_device *dev, int event_id, const void *data, int len)
95 {
96 u16 kflags;
97 struct sk_buff *skb;
98
99 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
100
101 /* Alloc the SKB for vendor_event */
102 skb = ssv_cfg80211_vendor_event_alloc(wiphy, len, event_id, kflags);
103 if (!skb) {
104 DBG_SSV_LEVEL(_drv_err_, FUNC_NDEV_FMT" skb alloc failed", FUNC_NDEV_ARG(dev));
105 return -ENOMEM;
106 }
107
108 /* Push the data to the skb */
109 nla_put_nohdr(skb, len, data);
110
111 ssv_cfg80211_vendor_event(skb, kflags);
112
113 return 0;
114 }
115
ssv_cfgvendor_send_cmd_reply(struct wiphy * wiphy,struct net_device * dev,const void * data,int len)116 static int ssv_cfgvendor_send_cmd_reply(struct wiphy *wiphy,
117 struct net_device *dev, const void *data, int len)
118 {
119 struct sk_buff *skb;
120
121 /* Alloc the SKB for vendor_event */
122 skb = ssv_cfg80211_vendor_cmd_alloc_reply_skb(wiphy, len);
123 if (unlikely(!skb)) {
124 DBG_SSV_LEVEL(_drv_err_, FUNC_NDEV_FMT" skb alloc failed", FUNC_NDEV_ARG(dev));
125 return -ENOMEM;
126 }
127
128 /* Push the data to the skb */
129 nla_put_nohdr(skb, len, data);
130
131 return ssv_cfg80211_vendor_cmd_reply(skb);
132 }
133
134 #define WIFI_FEATURE_INFRA 0x0001 /* Basic infrastructure mode */
135 #define WIFI_FEATURE_INFRA_5G 0x0002 /* Support for 5 GHz Band */
136 #define WIFI_FEATURE_HOTSPOT 0x0004 /* Support for GAS/ANQP */
137 #define WIFI_FEATURE_P2P 0x0008 /* Wifi-Direct */
138 #define WIFI_FEATURE_SOFT_AP 0x0010 /* Soft AP */
139 #define WIFI_FEATURE_GSCAN 0x0020 /* Google-Scan APIs */
140 #define WIFI_FEATURE_NAN 0x0040 /* Neighbor Awareness Networking */
141 #define WIFI_FEATURE_D2D_RTT 0x0080 /* Device-to-device RTT */
142 #define WIFI_FEATURE_D2AP_RTT 0x0100 /* Device-to-AP RTT */
143 #define WIFI_FEATURE_BATCH_SCAN 0x0200 /* Batched Scan (legacy) */
144 #define WIFI_FEATURE_PNO 0x0400 /* Preferred network offload */
145 #define WIFI_FEATURE_ADDITIONAL_STA 0x0800 /* Support for two STAs */
146 #define WIFI_FEATURE_TDLS 0x1000 /* Tunnel directed link setup */
147 #define WIFI_FEATURE_TDLS_OFFCHANNEL 0x2000 /* Support for TDLS off channel */
148 #define WIFI_FEATURE_EPR 0x4000 /* Enhanced power reporting */
149 #define WIFI_FEATURE_AP_STA 0x8000 /* Support for AP STA Concurrency */
150
151 #define MAX_FEATURE_SET_CONCURRRENT_GROUPS 3
152
ssv_dev_get_feature_set(struct net_device * dev)153 int ssv_dev_get_feature_set(struct net_device *dev)
154 {
155 int feature_set = 0;
156
157 feature_set |= WIFI_FEATURE_INFRA;
158
159 feature_set |= WIFI_FEATURE_P2P;
160 feature_set |= WIFI_FEATURE_SOFT_AP;
161
162 #if defined(GSCAN_SUPPORT)
163 feature_set |= WIFI_FEATURE_GSCAN;
164 #endif
165
166 #if defined(RTT_SUPPORT)
167 feature_set |= WIFI_FEATURE_NAN;
168 feature_set |= WIFI_FEATURE_D2D_RTT;
169 feature_set |= WIFI_FEATURE_D2AP_RTT;
170 #endif
171
172 return feature_set;
173 }
174
ssv_dev_get_feature_set_matrix(struct net_device * dev,int * num)175 int *ssv_dev_get_feature_set_matrix(struct net_device *dev, int *num)
176 {
177 int feature_set_full, mem_needed;
178 int *ret;
179
180 *num = 0;
181 mem_needed = sizeof(int) * MAX_FEATURE_SET_CONCURRRENT_GROUPS;
182 ret = (int *)kmalloc(mem_needed,in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
183
184 if (!ret) {
185 DBG_SSV_LEVEL(_drv_err_, FUNC_NDEV_FMT" failed to allocate %d bytes\n"
186 , FUNC_NDEV_ARG(dev), mem_needed);
187 return ret;
188 }
189
190 feature_set_full = ssv_dev_get_feature_set(dev);
191
192 ret[0] = (feature_set_full & WIFI_FEATURE_INFRA) |
193 (feature_set_full & WIFI_FEATURE_INFRA_5G) |
194 (feature_set_full & WIFI_FEATURE_NAN) |
195 (feature_set_full & WIFI_FEATURE_D2D_RTT) |
196 (feature_set_full & WIFI_FEATURE_D2AP_RTT) |
197 (feature_set_full & WIFI_FEATURE_PNO) |
198 (feature_set_full & WIFI_FEATURE_BATCH_SCAN) |
199 (feature_set_full & WIFI_FEATURE_GSCAN) |
200 (feature_set_full & WIFI_FEATURE_HOTSPOT) |
201 (feature_set_full & WIFI_FEATURE_ADDITIONAL_STA) |
202 (feature_set_full & WIFI_FEATURE_EPR);
203
204 ret[1] = (feature_set_full & WIFI_FEATURE_INFRA) |
205 (feature_set_full & WIFI_FEATURE_INFRA_5G) |
206 /* Not yet verified NAN with P2P */
207 /* (feature_set_full & WIFI_FEATURE_NAN) | */
208 (feature_set_full & WIFI_FEATURE_P2P) |
209 (feature_set_full & WIFI_FEATURE_D2AP_RTT) |
210 (feature_set_full & WIFI_FEATURE_D2D_RTT) |
211 (feature_set_full & WIFI_FEATURE_EPR);
212
213 ret[2] = (feature_set_full & WIFI_FEATURE_INFRA) |
214 (feature_set_full & WIFI_FEATURE_INFRA_5G) |
215 (feature_set_full & WIFI_FEATURE_NAN) |
216 (feature_set_full & WIFI_FEATURE_D2D_RTT) |
217 (feature_set_full & WIFI_FEATURE_D2AP_RTT) |
218 (feature_set_full & WIFI_FEATURE_TDLS) |
219 (feature_set_full & WIFI_FEATURE_TDLS_OFFCHANNEL) |
220 (feature_set_full & WIFI_FEATURE_EPR);
221 *num = MAX_FEATURE_SET_CONCURRRENT_GROUPS;
222
223 return ret;
224 }
225
226 #define wdev_to_ndev(wdev) NULL
227
ssv_cfgvendor_get_feature_set(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)228 static int ssv_cfgvendor_get_feature_set(struct wiphy *wiphy,
229 struct wireless_dev *wdev, const void *data, int len)
230 {
231 int err = 0;
232 int reply;
233
234 DBG_SSV("++++++++++++++++in ssv_cfgvendor_get_feature_set\n");
235
236 reply = ssv_dev_get_feature_set(wdev_to_ndev(wdev));
237
238 err = ssv_cfgvendor_send_cmd_reply(wiphy, wdev_to_ndev(wdev), &reply, sizeof(int));
239
240 if (unlikely(err))
241 DBG_SSV_LEVEL(_drv_err_, FUNC_NDEV_FMT" Vendor Command reply failed ret:%d \n"
242 , FUNC_NDEV_ARG(wdev_to_ndev(wdev)), err);
243
244 return err;
245 }
246
ssv_cfgvendor_get_feature_set_matrix(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)247 static int ssv_cfgvendor_get_feature_set_matrix(struct wiphy *wiphy,
248 struct wireless_dev *wdev, const void *data, int len)
249 {
250 int err = 0;
251 struct sk_buff *skb;
252 int *reply;
253 int num, mem_needed, i;
254 DBG_SSV("++++++++++++++++in ssv_cfgvendor_get_feature_set_matrix\n");
255
256 reply = ssv_dev_get_feature_set_matrix(wdev_to_ndev(wdev), &num);
257
258 if (!reply) {
259 DBG_SSV_LEVEL(_drv_err_, FUNC_NDEV_FMT" Could not get feature list matrix\n"
260 , FUNC_NDEV_ARG(wdev_to_ndev(wdev)));
261 err = -EINVAL;
262 return err;
263 }
264
265 mem_needed = VENDOR_REPLY_OVERHEAD + (ATTRIBUTE_U32_LEN * num) +
266 ATTRIBUTE_U32_LEN;
267
268 /* Alloc the SKB for vendor_event */
269 skb = ssv_cfg80211_vendor_cmd_alloc_reply_skb(wiphy, mem_needed);
270 if (unlikely(!skb)) {
271 DBG_SSV_LEVEL(_drv_err_, FUNC_NDEV_FMT" skb alloc failed", FUNC_NDEV_ARG(wdev_to_ndev(wdev)));
272 err = -ENOMEM;
273 goto exit;
274 }
275
276 nla_put_u32(skb, ANDR_WIFI_ATTRIBUTE_NUM_FEATURE_SET, num);
277 for (i = 0; i < num; i++) {
278 nla_put_u32(skb, ANDR_WIFI_ATTRIBUTE_FEATURE_SET, reply[i]);
279 }
280
281 err = ssv_cfg80211_vendor_cmd_reply(skb);
282
283 if (unlikely(err))
284 DBG_SSV_LEVEL(_drv_err_, FUNC_NDEV_FMT" Vendor Command reply failed ret:%d \n"
285 , FUNC_NDEV_ARG(wdev_to_ndev(wdev)), err);
286 exit:
287 kfree((void *)reply);
288 return err;
289 }
290
291 #if defined(GSCAN_SUPPORT) && 0
wl_cfgvendor_send_hotlist_event(struct wiphy * wiphy,struct net_device * dev,void * data,int len,wl_vendor_event_t event)292 int wl_cfgvendor_send_hotlist_event(struct wiphy *wiphy,
293 struct net_device *dev, void *data, int len, wl_vendor_event_t event)
294 {
295 u16 kflags;
296 const void *ptr;
297 struct sk_buff *skb;
298 int malloc_len, total, iter_cnt_to_send, cnt;
299 gscan_results_cache_t *cache = (gscan_results_cache_t *)data;
300
301 total = len/sizeof(wifi_gscan_result_t);
302 while (total > 0) {
303 malloc_len = (total * sizeof(wifi_gscan_result_t)) + VENDOR_DATA_OVERHEAD;
304 if (malloc_len > NLMSG_DEFAULT_SIZE) {
305 malloc_len = NLMSG_DEFAULT_SIZE;
306 }
307 iter_cnt_to_send =
308 (malloc_len - VENDOR_DATA_OVERHEAD)/sizeof(wifi_gscan_result_t);
309 total = total - iter_cnt_to_send;
310
311 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
312
313 /* Alloc the SKB for vendor_event */
314 skb = ssv_cfg80211_vendor_event_alloc(wiphy, malloc_len, event, kflags);
315 if (!skb) {
316 WL_ERR(("skb alloc failed"));
317 return -ENOMEM;
318 }
319
320 while (cache && iter_cnt_to_send) {
321 ptr = (const void *) &cache->results[cache->tot_consumed];
322
323 if (iter_cnt_to_send < (cache->tot_count - cache->tot_consumed))
324 cnt = iter_cnt_to_send;
325 else
326 cnt = (cache->tot_count - cache->tot_consumed);
327
328 iter_cnt_to_send -= cnt;
329 cache->tot_consumed += cnt;
330 /* Push the data to the skb */
331 nla_append(skb, cnt * sizeof(wifi_gscan_result_t), ptr);
332 if (cache->tot_consumed == cache->tot_count)
333 cache = cache->next;
334
335 }
336
337 ssv_cfg80211_vendor_event(skb, kflags);
338 }
339
340 return 0;
341 }
342
343
wl_cfgvendor_gscan_get_capabilities(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)344 static int wl_cfgvendor_gscan_get_capabilities(struct wiphy *wiphy,
345 struct wireless_dev *wdev, const void *data, int len)
346 {
347 int err = 0;
348 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
349 dhd_pno_gscan_capabilities_t *reply = NULL;
350 uint32 reply_len = 0;
351
352
353 reply = dhd_dev_pno_get_gscan(bcmcfg_to_prmry_ndev(cfg),
354 DHD_PNO_GET_CAPABILITIES, NULL, &reply_len);
355 if (!reply) {
356 WL_ERR(("Could not get capabilities\n"));
357 err = -EINVAL;
358 return err;
359 }
360
361 err = ssv_cfgvendor_send_cmd_reply(wiphy, bcmcfg_to_prmry_ndev(cfg),
362 reply, reply_len);
363
364 if (unlikely(err))
365 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
366
367 kfree(reply);
368 return err;
369 }
370
wl_cfgvendor_gscan_get_channel_list(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)371 static int wl_cfgvendor_gscan_get_channel_list(struct wiphy *wiphy,
372 struct wireless_dev *wdev, const void *data, int len)
373 {
374 int err = 0, type, band;
375 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
376 uint16 *reply = NULL;
377 uint32 reply_len = 0, num_channels, mem_needed;
378 struct sk_buff *skb;
379
380 type = nla_type(data);
381
382 if (type == GSCAN_ATTRIBUTE_BAND) {
383 band = nla_get_u32(data);
384 } else {
385 return -1;
386 }
387
388 reply = dhd_dev_pno_get_gscan(bcmcfg_to_prmry_ndev(cfg),
389 DHD_PNO_GET_CHANNEL_LIST, &band, &reply_len);
390
391 if (!reply) {
392 WL_ERR(("Could not get channel list\n"));
393 err = -EINVAL;
394 return err;
395 }
396 num_channels = reply_len/ sizeof(uint32);
397 mem_needed = reply_len + VENDOR_REPLY_OVERHEAD + (ATTRIBUTE_U32_LEN * 2);
398
399 /* Alloc the SKB for vendor_event */
400 skb = ssv_cfg80211_vendor_cmd_alloc_reply_skb(wiphy, mem_needed);
401 if (unlikely(!skb)) {
402 WL_ERR(("skb alloc failed"));
403 err = -ENOMEM;
404 goto exit;
405 }
406
407 nla_put_u32(skb, GSCAN_ATTRIBUTE_NUM_CHANNELS, num_channels);
408 nla_put(skb, GSCAN_ATTRIBUTE_CHANNEL_LIST, reply_len, reply);
409
410 err = ssv_cfg80211_vendor_cmd_reply(skb);
411
412 if (unlikely(err))
413 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
414 exit:
415 kfree(reply);
416 return err;
417 }
418
wl_cfgvendor_gscan_get_batch_results(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)419 static int wl_cfgvendor_gscan_get_batch_results(struct wiphy *wiphy,
420 struct wireless_dev *wdev, const void *data, int len)
421 {
422 int err = 0;
423 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
424 gscan_results_cache_t *results, *iter;
425 uint32 reply_len, complete = 0, num_results_iter;
426 int32 mem_needed;
427 wifi_gscan_result_t *ptr;
428 uint16 num_scan_ids, num_results;
429 struct sk_buff *skb;
430 struct nlattr *scan_hdr;
431
432 dhd_dev_wait_batch_results_complete(bcmcfg_to_prmry_ndev(cfg));
433 dhd_dev_pno_lock_access_batch_results(bcmcfg_to_prmry_ndev(cfg));
434 results = dhd_dev_pno_get_gscan(bcmcfg_to_prmry_ndev(cfg),
435 DHD_PNO_GET_BATCH_RESULTS, NULL, &reply_len);
436
437 if (!results) {
438 WL_ERR(("No results to send %d\n", err));
439 err = ssv_cfgvendor_send_cmd_reply(wiphy, bcmcfg_to_prmry_ndev(cfg),
440 results, 0);
441
442 if (unlikely(err))
443 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
444 dhd_dev_pno_unlock_access_batch_results(bcmcfg_to_prmry_ndev(cfg));
445 return err;
446 }
447 num_scan_ids = reply_len & 0xFFFF;
448 num_results = (reply_len & 0xFFFF0000) >> 16;
449 mem_needed = (num_results * sizeof(wifi_gscan_result_t)) +
450 (num_scan_ids * GSCAN_BATCH_RESULT_HDR_LEN) +
451 VENDOR_REPLY_OVERHEAD + SCAN_RESULTS_COMPLETE_FLAG_LEN;
452
453 if (mem_needed > (int32)NLMSG_DEFAULT_SIZE) {
454 mem_needed = (int32)NLMSG_DEFAULT_SIZE;
455 complete = 0;
456 } else {
457 complete = 1;
458 }
459
460 WL_TRACE(("complete %d mem_needed %d max_mem %d\n", complete, mem_needed,
461 (int)NLMSG_DEFAULT_SIZE));
462 /* Alloc the SKB for vendor_event */
463 skb = ssv_cfg80211_vendor_cmd_alloc_reply_skb(wiphy, mem_needed);
464 if (unlikely(!skb)) {
465 WL_ERR(("skb alloc failed"));
466 dhd_dev_pno_unlock_access_batch_results(bcmcfg_to_prmry_ndev(cfg));
467 return -ENOMEM;
468 }
469 iter = results;
470
471 nla_put_u32(skb, GSCAN_ATTRIBUTE_SCAN_RESULTS_COMPLETE, complete);
472
473 mem_needed = mem_needed - (SCAN_RESULTS_COMPLETE_FLAG_LEN + VENDOR_REPLY_OVERHEAD);
474
475 while (iter && ((mem_needed - GSCAN_BATCH_RESULT_HDR_LEN) > 0)) {
476 scan_hdr = nla_nest_start(skb, GSCAN_ATTRIBUTE_SCAN_RESULTS);
477 nla_put_u32(skb, GSCAN_ATTRIBUTE_SCAN_ID, iter->scan_id);
478 nla_put_u8(skb, GSCAN_ATTRIBUTE_SCAN_FLAGS, iter->flag);
479 num_results_iter =
480 (mem_needed - GSCAN_BATCH_RESULT_HDR_LEN)/sizeof(wifi_gscan_result_t);
481
482 if ((iter->tot_count - iter->tot_consumed) < num_results_iter)
483 num_results_iter = iter->tot_count - iter->tot_consumed;
484
485 nla_put_u32(skb, GSCAN_ATTRIBUTE_NUM_OF_RESULTS, num_results_iter);
486 if (num_results_iter) {
487 ptr = &iter->results[iter->tot_consumed];
488 iter->tot_consumed += num_results_iter;
489 nla_put(skb, GSCAN_ATTRIBUTE_SCAN_RESULTS,
490 num_results_iter * sizeof(wifi_gscan_result_t), ptr);
491 }
492 nla_nest_end(skb, scan_hdr);
493 mem_needed -= GSCAN_BATCH_RESULT_HDR_LEN +
494 (num_results_iter * sizeof(wifi_gscan_result_t));
495 iter = iter->next;
496 }
497
498 dhd_dev_gscan_batch_cache_cleanup(bcmcfg_to_prmry_ndev(cfg));
499 dhd_dev_pno_unlock_access_batch_results(bcmcfg_to_prmry_ndev(cfg));
500
501 return ssv_cfg80211_vendor_cmd_reply(skb);
502 }
503
wl_cfgvendor_initiate_gscan(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)504 static int wl_cfgvendor_initiate_gscan(struct wiphy *wiphy,
505 struct wireless_dev *wdev, const void *data, int len)
506 {
507 int err = 0;
508 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
509 int type, tmp = len;
510 int run = 0xFF;
511 int flush = 0;
512 const struct nlattr *iter;
513
514 nla_for_each_attr(iter, data, len, tmp) {
515 type = nla_type(iter);
516 if (type == GSCAN_ATTRIBUTE_ENABLE_FEATURE)
517 run = nla_get_u32(iter);
518 else if (type == GSCAN_ATTRIBUTE_FLUSH_FEATURE)
519 flush = nla_get_u32(iter);
520 }
521
522 if (run != 0xFF) {
523 err = dhd_dev_pno_run_gscan(bcmcfg_to_prmry_ndev(cfg), run, flush);
524
525 if (unlikely(err))
526 WL_ERR(("Could not run gscan:%d \n", err));
527 return err;
528 } else {
529 return -1;
530 }
531
532
533 }
534
wl_cfgvendor_enable_full_scan_result(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)535 static int wl_cfgvendor_enable_full_scan_result(struct wiphy *wiphy,
536 struct wireless_dev *wdev, const void *data, int len)
537 {
538 int err = 0;
539 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
540 int type;
541 bool real_time = FALSE;
542
543 type = nla_type(data);
544
545 if (type == GSCAN_ATTRIBUTE_ENABLE_FULL_SCAN_RESULTS) {
546 real_time = nla_get_u32(data);
547
548 err = dhd_dev_pno_enable_full_scan_result(bcmcfg_to_prmry_ndev(cfg), real_time);
549
550 if (unlikely(err))
551 WL_ERR(("Could not run gscan:%d \n", err));
552
553 } else {
554 err = -1;
555 }
556
557 return err;
558 }
559
wl_cfgvendor_set_scan_cfg(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)560 static int wl_cfgvendor_set_scan_cfg(struct wiphy *wiphy,
561 struct wireless_dev *wdev, const void *data, int len)
562 {
563 int err = 0;
564 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
565 gscan_scan_params_t *scan_param;
566 int j = 0;
567 int type, tmp, tmp1, tmp2, k = 0;
568 const struct nlattr *iter, *iter1, *iter2;
569 struct dhd_pno_gscan_channel_bucket *ch_bucket;
570
571 scan_param = kzalloc(sizeof(gscan_scan_params_t), GFP_KERNEL);
572 if (!scan_param) {
573 WL_ERR(("Could not set GSCAN scan cfg, mem alloc failure\n"));
574 err = -EINVAL;
575 return err;
576
577 }
578
579 scan_param->scan_fr = PNO_SCAN_MIN_FW_SEC;
580 nla_for_each_attr(iter, data, len, tmp) {
581 type = nla_type(iter);
582
583 if (j >= GSCAN_MAX_CH_BUCKETS)
584 break;
585
586 switch (type) {
587 case GSCAN_ATTRIBUTE_BASE_PERIOD:
588 scan_param->scan_fr = nla_get_u32(iter)/1000;
589 break;
590 case GSCAN_ATTRIBUTE_NUM_BUCKETS:
591 scan_param->nchannel_buckets = nla_get_u32(iter);
592 break;
593 case GSCAN_ATTRIBUTE_CH_BUCKET_1:
594 case GSCAN_ATTRIBUTE_CH_BUCKET_2:
595 case GSCAN_ATTRIBUTE_CH_BUCKET_3:
596 case GSCAN_ATTRIBUTE_CH_BUCKET_4:
597 case GSCAN_ATTRIBUTE_CH_BUCKET_5:
598 case GSCAN_ATTRIBUTE_CH_BUCKET_6:
599 case GSCAN_ATTRIBUTE_CH_BUCKET_7:
600 nla_for_each_nested(iter1, iter, tmp1) {
601 type = nla_type(iter1);
602 ch_bucket =
603 scan_param->channel_bucket;
604
605 switch (type) {
606 case GSCAN_ATTRIBUTE_BUCKET_ID:
607 break;
608 case GSCAN_ATTRIBUTE_BUCKET_PERIOD:
609 ch_bucket[j].bucket_freq_multiple =
610 nla_get_u32(iter1)/1000;
611 break;
612 case GSCAN_ATTRIBUTE_BUCKET_NUM_CHANNELS:
613 ch_bucket[j].num_channels =
614 nla_get_u32(iter1);
615 break;
616 case GSCAN_ATTRIBUTE_BUCKET_CHANNELS:
617 nla_for_each_nested(iter2, iter1, tmp2) {
618 if (k >= PFN_SWC_RSSI_WINDOW_MAX)
619 break;
620 ch_bucket[j].chan_list[k] =
621 nla_get_u32(iter2);
622 k++;
623 }
624 k = 0;
625 break;
626 case GSCAN_ATTRIBUTE_BUCKETS_BAND:
627 ch_bucket[j].band = (uint16)
628 nla_get_u32(iter1);
629 break;
630 case GSCAN_ATTRIBUTE_REPORT_EVENTS:
631 ch_bucket[j].report_flag = (uint8)
632 nla_get_u32(iter1);
633 break;
634 }
635 }
636 j++;
637 break;
638 }
639 }
640
641 if (dhd_dev_pno_set_cfg_gscan(bcmcfg_to_prmry_ndev(cfg),
642 DHD_PNO_SCAN_CFG_ID, scan_param, 0) < 0) {
643 WL_ERR(("Could not set GSCAN scan cfg\n"));
644 err = -EINVAL;
645 }
646
647 kfree(scan_param);
648 return err;
649
650 }
651
wl_cfgvendor_hotlist_cfg(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)652 static int wl_cfgvendor_hotlist_cfg(struct wiphy *wiphy,
653 struct wireless_dev *wdev, const void *data, int len)
654 {
655 int err = 0;
656 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
657 gscan_hotlist_scan_params_t *hotlist_params;
658 int tmp, tmp1, tmp2, type, j = 0, dummy;
659 const struct nlattr *outer, *inner, *iter;
660 uint8 flush = 0;
661 struct bssid_t *pbssid;
662
663 hotlist_params = (gscan_hotlist_scan_params_t *)kzalloc(len, GFP_KERNEL);
664 if (!hotlist_params) {
665 WL_ERR(("Cannot Malloc mem to parse config commands size - %d bytes \n", len));
666 return -1;
667 }
668
669 hotlist_params->lost_ap_window = GSCAN_LOST_AP_WINDOW_DEFAULT;
670
671 nla_for_each_attr(iter, data, len, tmp2) {
672 type = nla_type(iter);
673 switch (type) {
674 case GSCAN_ATTRIBUTE_HOTLIST_BSSIDS:
675 pbssid = hotlist_params->bssid;
676 nla_for_each_nested(outer, iter, tmp) {
677 nla_for_each_nested(inner, outer, tmp1) {
678 type = nla_type(inner);
679
680 switch (type) {
681 case GSCAN_ATTRIBUTE_BSSID:
682 memcpy(&(pbssid[j].macaddr),
683 nla_data(inner), ETHER_ADDR_LEN);
684 break;
685 case GSCAN_ATTRIBUTE_RSSI_LOW:
686 pbssid[j].rssi_reporting_threshold =
687 (int8) nla_get_u8(inner);
688 break;
689 case GSCAN_ATTRIBUTE_RSSI_HIGH:
690 dummy = (int8) nla_get_u8(inner);
691 break;
692 }
693 }
694 j++;
695 }
696 hotlist_params->nbssid = j;
697 break;
698 case GSCAN_ATTRIBUTE_HOTLIST_FLUSH:
699 flush = nla_get_u8(iter);
700 break;
701 case GSCAN_ATTRIBUTE_LOST_AP_SAMPLE_SIZE:
702 hotlist_params->lost_ap_window = nla_get_u32(iter);
703 break;
704 }
705
706 }
707
708 if (dhd_dev_pno_set_cfg_gscan(bcmcfg_to_prmry_ndev(cfg),
709 DHD_PNO_GEOFENCE_SCAN_CFG_ID, hotlist_params, flush) < 0) {
710 WL_ERR(("Could not set GSCAN HOTLIST cfg\n"));
711 err = -EINVAL;
712 goto exit;
713 }
714 exit:
715 kfree(hotlist_params);
716 return err;
717 }
wl_cfgvendor_set_batch_scan_cfg(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)718 static int wl_cfgvendor_set_batch_scan_cfg(struct wiphy *wiphy,
719 struct wireless_dev *wdev, const void *data, int len)
720 {
721 int err = 0, tmp, type;
722 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
723 gscan_batch_params_t batch_param;
724 const struct nlattr *iter;
725
726 batch_param.mscan = batch_param.bestn = 0;
727 batch_param.buffer_threshold = GSCAN_BATCH_NO_THR_SET;
728
729 nla_for_each_attr(iter, data, len, tmp) {
730 type = nla_type(iter);
731
732 switch (type) {
733 case GSCAN_ATTRIBUTE_NUM_AP_PER_SCAN:
734 batch_param.bestn = nla_get_u32(iter);
735 break;
736 case GSCAN_ATTRIBUTE_NUM_SCANS_TO_CACHE:
737 batch_param.mscan = nla_get_u32(iter);
738 break;
739 case GSCAN_ATTRIBUTE_REPORT_THRESHOLD:
740 batch_param.buffer_threshold = nla_get_u32(iter);
741 break;
742 }
743 }
744
745 if (dhd_dev_pno_set_cfg_gscan(bcmcfg_to_prmry_ndev(cfg),
746 DHD_PNO_BATCH_SCAN_CFG_ID, &batch_param, 0) < 0) {
747 WL_ERR(("Could not set batch cfg\n"));
748 err = -EINVAL;
749 return err;
750 }
751
752 return err;
753 }
754
wl_cfgvendor_significant_change_cfg(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)755 static int wl_cfgvendor_significant_change_cfg(struct wiphy *wiphy,
756 struct wireless_dev *wdev, const void *data, int len)
757 {
758 int err = 0;
759 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
760 gscan_swc_params_t *significant_params;
761 int tmp, tmp1, tmp2, type, j = 0;
762 const struct nlattr *outer, *inner, *iter;
763 uint8 flush = 0;
764 wl_pfn_significant_bssid_t *pbssid;
765
766 significant_params = (gscan_swc_params_t *) kzalloc(len, GFP_KERNEL);
767 if (!significant_params) {
768 WL_ERR(("Cannot Malloc mem to parse config commands size - %d bytes \n", len));
769 return -1;
770 }
771
772
773 nla_for_each_attr(iter, data, len, tmp2) {
774 type = nla_type(iter);
775
776 switch (type) {
777 case GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_FLUSH:
778 flush = nla_get_u8(iter);
779 break;
780 case GSCAN_ATTRIBUTE_RSSI_SAMPLE_SIZE:
781 significant_params->rssi_window = nla_get_u16(iter);
782 break;
783 case GSCAN_ATTRIBUTE_LOST_AP_SAMPLE_SIZE:
784 significant_params->lost_ap_window = nla_get_u16(iter);
785 break;
786 case GSCAN_ATTRIBUTE_MIN_BREACHING:
787 significant_params->swc_threshold = nla_get_u16(iter);
788 break;
789 case GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_BSSIDS:
790 pbssid = significant_params->bssid_elem_list;
791 nla_for_each_nested(outer, iter, tmp) {
792 nla_for_each_nested(inner, outer, tmp1) {
793 switch (nla_type(inner)) {
794 case GSCAN_ATTRIBUTE_BSSID:
795 memcpy(&(pbssid[j].macaddr),
796 nla_data(inner),
797 ETHER_ADDR_LEN);
798 break;
799 case GSCAN_ATTRIBUTE_RSSI_HIGH:
800 pbssid[j].rssi_high_threshold =
801 (int8) nla_get_u8(inner);
802 break;
803 case GSCAN_ATTRIBUTE_RSSI_LOW:
804 pbssid[j].rssi_low_threshold =
805 (int8) nla_get_u8(inner);
806 break;
807 }
808 }
809 j++;
810 }
811 break;
812 }
813 }
814 significant_params->nbssid = j;
815
816 if (dhd_dev_pno_set_cfg_gscan(bcmcfg_to_prmry_ndev(cfg),
817 DHD_PNO_SIGNIFICANT_SCAN_CFG_ID, significant_params, flush) < 0) {
818 WL_ERR(("Could not set GSCAN significant cfg\n"));
819 err = -EINVAL;
820 goto exit;
821 }
822 exit:
823 kfree(significant_params);
824 return err;
825 }
826 #endif /* GSCAN_SUPPORT */
827
828 #if defined(RTT_SUPPORT) && 0
wl_cfgvendor_rtt_evt(void * ctx,void * rtt_data)829 void wl_cfgvendor_rtt_evt(void *ctx, void *rtt_data)
830 {
831 struct wireless_dev *wdev = (struct wireless_dev *)ctx;
832 struct wiphy *wiphy;
833 struct sk_buff *skb;
834 uint32 tot_len = NLMSG_DEFAULT_SIZE, entry_len = 0;
835 gfp_t kflags;
836 rtt_report_t *rtt_report = NULL;
837 rtt_result_t *rtt_result = NULL;
838 struct list_head *rtt_list;
839 wiphy = wdev->wiphy;
840
841 WL_DBG(("In\n"));
842 /* Push the data to the skb */
843 if (!rtt_data) {
844 WL_ERR(("rtt_data is NULL\n"));
845 goto exit;
846 }
847 rtt_list = (struct list_head *)rtt_data;
848 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
849 /* Alloc the SKB for vendor_event */
850 skb = ssv_cfg80211_vendor_event_alloc(wiphy, tot_len, GOOGLE_RTT_COMPLETE_EVENT, kflags);
851 if (!skb) {
852 WL_ERR(("skb alloc failed"));
853 goto exit;
854 }
855 /* fill in the rtt results on each entry */
856 list_for_each_entry(rtt_result, rtt_list, list) {
857 entry_len = 0;
858 if (rtt_result->TOF_type == TOF_TYPE_ONE_WAY) {
859 entry_len = sizeof(rtt_report_t);
860 rtt_report = kzalloc(entry_len, kflags);
861 if (!rtt_report) {
862 WL_ERR(("rtt_report alloc failed"));
863 goto exit;
864 }
865 rtt_report->addr = rtt_result->peer_mac;
866 rtt_report->num_measurement = 1; /* ONE SHOT */
867 rtt_report->status = rtt_result->err_code;
868 rtt_report->type = (rtt_result->TOF_type == TOF_TYPE_ONE_WAY) ? RTT_ONE_WAY: RTT_TWO_WAY;
869 rtt_report->peer = rtt_result->target_info->peer;
870 rtt_report->channel = rtt_result->target_info->channel;
871 rtt_report->rssi = rtt_result->avg_rssi;
872 /* tx_rate */
873 rtt_report->tx_rate = rtt_result->tx_rate;
874 /* RTT */
875 rtt_report->rtt = rtt_result->meanrtt;
876 rtt_report->rtt_sd = rtt_result->sdrtt;
877 /* convert to centi meter */
878 if (rtt_result->distance != 0xffffffff)
879 rtt_report->distance = (rtt_result->distance >> 2) * 25;
880 else /* invalid distance */
881 rtt_report->distance = -1;
882
883 rtt_report->ts = rtt_result->ts;
884 nla_append(skb, entry_len, rtt_report);
885 kfree(rtt_report);
886 }
887 }
888 ssv_cfg80211_vendor_event(skb, kflags);
889 exit:
890 return;
891 }
892
wl_cfgvendor_rtt_set_config(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)893 static int wl_cfgvendor_rtt_set_config(struct wiphy *wiphy, struct wireless_dev *wdev,
894 const void *data, int len) {
895 int err = 0, rem, rem1, rem2, type;
896 rtt_config_params_t rtt_param;
897 rtt_target_info_t* rtt_target = NULL;
898 const struct nlattr *iter, *iter1, *iter2;
899 int8 eabuf[ETHER_ADDR_STR_LEN];
900 int8 chanbuf[CHANSPEC_STR_LEN];
901 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
902
903 WL_DBG(("In\n"));
904 err = dhd_dev_rtt_register_noti_callback(wdev->netdev, wdev, wl_cfgvendor_rtt_evt);
905 if (err < 0) {
906 WL_ERR(("failed to register rtt_noti_callback\n"));
907 goto exit;
908 }
909 memset(&rtt_param, 0, sizeof(rtt_param));
910 nla_for_each_attr(iter, data, len, rem) {
911 type = nla_type(iter);
912 switch (type) {
913 case RTT_ATTRIBUTE_TARGET_CNT:
914 rtt_param.rtt_target_cnt = nla_get_u8(iter);
915 if (rtt_param.rtt_target_cnt > RTT_MAX_TARGET_CNT) {
916 WL_ERR(("exceed max target count : %d\n",
917 rtt_param.rtt_target_cnt));
918 err = BCME_RANGE;
919 }
920 break;
921 case RTT_ATTRIBUTE_TARGET_INFO:
922 rtt_target = rtt_param.target_info;
923 nla_for_each_nested(iter1, iter, rem1) {
924 nla_for_each_nested(iter2, iter1, rem2) {
925 type = nla_type(iter2);
926 switch (type) {
927 case RTT_ATTRIBUTE_TARGET_MAC:
928 memcpy(&rtt_target->addr, nla_data(iter2), ETHER_ADDR_LEN);
929 break;
930 case RTT_ATTRIBUTE_TARGET_TYPE:
931 rtt_target->type = nla_get_u8(iter2);
932 break;
933 case RTT_ATTRIBUTE_TARGET_PEER:
934 rtt_target->peer= nla_get_u8(iter2);
935 break;
936 case RTT_ATTRIBUTE_TARGET_CHAN:
937 memcpy(&rtt_target->channel, nla_data(iter2),
938 sizeof(rtt_target->channel));
939 break;
940 case RTT_ATTRIBUTE_TARGET_MODE:
941 rtt_target->continuous = nla_get_u8(iter2);
942 break;
943 case RTT_ATTRIBUTE_TARGET_INTERVAL:
944 rtt_target->interval = nla_get_u32(iter2);
945 break;
946 case RTT_ATTRIBUTE_TARGET_NUM_MEASUREMENT:
947 rtt_target->measure_cnt = nla_get_u32(iter2);
948 break;
949 case RTT_ATTRIBUTE_TARGET_NUM_PKT:
950 rtt_target->ftm_cnt = nla_get_u32(iter2);
951 break;
952 case RTT_ATTRIBUTE_TARGET_NUM_RETRY:
953 rtt_target->retry_cnt = nla_get_u32(iter2);
954 }
955 }
956 /* convert to chanspec value */
957 rtt_target->chanspec = dhd_rtt_convert_to_chspec(rtt_target->channel);
958 if (rtt_target->chanspec == 0) {
959 WL_ERR(("Channel is not valid \n"));
960 goto exit;
961 }
962 WL_INFORM(("Target addr %s, Channel : %s for RTT \n",
963 bcm_ether_ntoa((const struct ether_addr *)&rtt_target->addr, eabuf),
964 wf_chspec_ntoa(rtt_target->chanspec, chanbuf)));
965 rtt_target++;
966 }
967 break;
968 }
969 }
970 WL_DBG(("leave :target_cnt : %d\n", rtt_param.rtt_target_cnt));
971 if (dhd_dev_rtt_set_cfg(bcmcfg_to_prmry_ndev(cfg), &rtt_param) < 0) {
972 WL_ERR(("Could not set RTT configuration\n"));
973 err = -EINVAL;
974 }
975 exit:
976 return err;
977 }
978
wl_cfgvendor_rtt_cancel_config(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)979 static int wl_cfgvendor_rtt_cancel_config(struct wiphy *wiphy, struct wireless_dev *wdev,
980 const void *data, int len)
981 {
982 int err = 0, rem, type, target_cnt = 0;
983 const struct nlattr *iter;
984 struct ether_addr *mac_list = NULL, *mac_addr = NULL;
985 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
986
987 nla_for_each_attr(iter, data, len, rem) {
988 type = nla_type(iter);
989 switch (type) {
990 case RTT_ATTRIBUTE_TARGET_CNT:
991 target_cnt = nla_get_u8(iter);
992 mac_list = (struct ether_addr *)kzalloc(target_cnt * ETHER_ADDR_LEN , GFP_KERNEL);
993 if (mac_list == NULL) {
994 WL_ERR(("failed to allocate mem for mac list\n"));
995 goto exit;
996 }
997 mac_addr = &mac_list[0];
998 break;
999 case RTT_ATTRIBUTE_TARGET_MAC:
1000 if (mac_addr)
1001 memcpy(mac_addr++, nla_data(iter), ETHER_ADDR_LEN);
1002 else {
1003 WL_ERR(("mac_list is NULL\n"));
1004 goto exit;
1005 }
1006 break;
1007 }
1008 if (dhd_dev_rtt_cancel_cfg(bcmcfg_to_prmry_ndev(cfg), mac_list, target_cnt) < 0) {
1009 WL_ERR(("Could not cancel RTT configuration\n"));
1010 err = -EINVAL;
1011 goto exit;
1012 }
1013 }
1014 exit:
1015 if (mac_list)
1016 kfree(mac_list);
1017 return err;
1018 }
wl_cfgvendor_rtt_get_capability(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)1019 static int wl_cfgvendor_rtt_get_capability(struct wiphy *wiphy, struct wireless_dev *wdev,
1020 const void *data, int len)
1021 {
1022 int err = 0;
1023 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
1024 rtt_capabilities_t capability;
1025
1026 err = dhd_dev_rtt_capability(bcmcfg_to_prmry_ndev(cfg), &capability);
1027 if (unlikely(err)) {
1028 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
1029 goto exit;
1030 }
1031 err = ssv_cfgvendor_send_cmd_reply(wiphy, bcmcfg_to_prmry_ndev(cfg),
1032 &capability, sizeof(capability));
1033
1034 if (unlikely(err)) {
1035 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
1036 }
1037 exit:
1038 return err;
1039 }
1040
1041 #endif /* RTT_SUPPORT */
wl_cfgvendor_priv_string_handler(struct wiphy * wiphy,struct wireless_dev * wdev,const void * data,int len)1042 static int wl_cfgvendor_priv_string_handler(struct wiphy *wiphy,
1043 struct wireless_dev *wdev, const void *data, int len)
1044 {
1045 int err = 0;
1046 u8 resp[1] = {'\0'};
1047
1048 DBG_SSV_LEVEL(_drv_always_, FUNC_NDEV_FMT" %s\n", FUNC_NDEV_ARG(wdev_to_ndev(wdev)), (char*)data);
1049 err = ssv_cfgvendor_send_cmd_reply(wiphy, wdev_to_ndev(wdev), resp, 1);
1050 if (unlikely(err))
1051 DBG_SSV_LEVEL(_drv_err_, FUNC_NDEV_FMT"Vendor Command reply failed ret:%d \n"
1052 , FUNC_NDEV_ARG(wdev_to_ndev(wdev)), err);
1053
1054 return err;
1055 #if 0
1056 struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
1057 int err = 0;
1058 int data_len = 0;
1059
1060 bzero(cfg->ioctl_buf, WLC_IOCTL_MAXLEN);
1061
1062 if (strncmp((char *)data, RTK_VENDOR_SCMD_CAPA, strlen(RTK_VENDOR_SCMD_CAPA)) == 0) {
1063 err = wldev_iovar_getbuf(bcmcfg_to_prmry_ndev(cfg), "cap", NULL, 0,
1064 cfg->ioctl_buf, WLC_IOCTL_MAXLEN, &cfg->ioctl_buf_sync);
1065 if (unlikely(err)) {
1066 WL_ERR(("error (%d)\n", err));
1067 return err;
1068 }
1069 data_len = strlen(cfg->ioctl_buf);
1070 cfg->ioctl_buf[data_len] = '\0';
1071 }
1072
1073 err = ssv_cfgvendor_send_cmd_reply(wiphy, bcmcfg_to_prmry_ndev(cfg),
1074 cfg->ioctl_buf, data_len+1);
1075 if (unlikely(err))
1076 WL_ERR(("Vendor Command reply failed ret:%d \n", err));
1077 else
1078 WL_INFORM(("Vendor Command reply sent successfully!\n"));
1079
1080 return err;
1081 #endif
1082 }
1083
1084 static const struct wiphy_vendor_command ssv_vendor_cmds [] = {
1085 {
1086 {
1087 .vendor_id = OUI_SSV,
1088 .subcmd = RTK_VENDOR_SCMD_PRIV_STR
1089 },
1090 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
1091 .doit = wl_cfgvendor_priv_string_handler
1092 },
1093 #if defined(GSCAN_SUPPORT) && 0
1094 {
1095 {
1096 .vendor_id = OUI_GOOGLE,
1097 .subcmd = GSCAN_SUBCMD_GET_CAPABILITIES
1098 },
1099 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
1100 .doit = wl_cfgvendor_gscan_get_capabilities
1101 },
1102 {
1103 {
1104 .vendor_id = OUI_GOOGLE,
1105 .subcmd = GSCAN_SUBCMD_SET_CONFIG
1106 },
1107 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
1108 .doit = wl_cfgvendor_set_scan_cfg
1109 },
1110 {
1111 {
1112 .vendor_id = OUI_GOOGLE,
1113 .subcmd = GSCAN_SUBCMD_SET_SCAN_CONFIG
1114 },
1115 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
1116 .doit = wl_cfgvendor_set_batch_scan_cfg
1117 },
1118 {
1119 {
1120 .vendor_id = OUI_GOOGLE,
1121 .subcmd = GSCAN_SUBCMD_ENABLE_GSCAN
1122 },
1123 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
1124 .doit = wl_cfgvendor_initiate_gscan
1125 },
1126 {
1127 {
1128 .vendor_id = OUI_GOOGLE,
1129 .subcmd = GSCAN_SUBCMD_ENABLE_FULL_SCAN_RESULTS
1130 },
1131 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
1132 .doit = wl_cfgvendor_enable_full_scan_result
1133 },
1134 {
1135 {
1136 .vendor_id = OUI_GOOGLE,
1137 .subcmd = GSCAN_SUBCMD_SET_HOTLIST
1138 },
1139 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
1140 .doit = wl_cfgvendor_hotlist_cfg
1141 },
1142 {
1143 {
1144 .vendor_id = OUI_GOOGLE,
1145 .subcmd = GSCAN_SUBCMD_SET_SIGNIFICANT_CHANGE_CONFIG
1146 },
1147 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
1148 .doit = wl_cfgvendor_significant_change_cfg
1149 },
1150 {
1151 {
1152 .vendor_id = OUI_GOOGLE,
1153 .subcmd = GSCAN_SUBCMD_GET_SCAN_RESULTS
1154 },
1155 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
1156 .doit = wl_cfgvendor_gscan_get_batch_results
1157 },
1158 {
1159 {
1160 .vendor_id = OUI_GOOGLE,
1161 .subcmd = GSCAN_SUBCMD_GET_CHANNEL_LIST
1162 },
1163 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
1164 .doit = wl_cfgvendor_gscan_get_channel_list
1165 },
1166 #endif /* GSCAN_SUPPORT */
1167 #if defined(RTT_SUPPORT) && 0
1168 {
1169 {
1170 .vendor_id = OUI_GOOGLE,
1171 .subcmd = RTT_SUBCMD_SET_CONFIG
1172 },
1173 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
1174 .doit = wl_cfgvendor_rtt_set_config
1175 },
1176 {
1177 {
1178 .vendor_id = OUI_GOOGLE,
1179 .subcmd = RTT_SUBCMD_CANCEL_CONFIG
1180 },
1181 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
1182 .doit = wl_cfgvendor_rtt_cancel_config
1183 },
1184 {
1185 {
1186 .vendor_id = OUI_GOOGLE,
1187 .subcmd = RTT_SUBCMD_GETCAPABILITY
1188 },
1189 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
1190 .doit = wl_cfgvendor_rtt_get_capability
1191 },
1192 #endif /* RTT_SUPPORT */
1193 {
1194 {
1195 .vendor_id = OUI_GOOGLE,
1196 .subcmd = ANDR_WIFI_SUBCMD_GET_FEATURE_SET
1197 },
1198 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
1199 .doit = ssv_cfgvendor_get_feature_set
1200 },
1201 {
1202 {
1203 .vendor_id = OUI_GOOGLE,
1204 .subcmd = ANDR_WIFI_SUBCMD_GET_FEATURE_SET_MATRIX
1205 },
1206 .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV,
1207 .doit = ssv_cfgvendor_get_feature_set_matrix
1208 }
1209 };
1210
1211 static const struct nl80211_vendor_cmd_info ssv_vendor_events [] = {
1212 { OUI_SSV, RTK_VENDOR_EVENT_UNSPEC },
1213 { OUI_SSV, RTK_VENDOR_EVENT_PRIV_STR },
1214 #if defined(GSCAN_SUPPORT) && 0
1215 { OUI_GOOGLE, GOOGLE_GSCAN_SIGNIFICANT_EVENT },
1216 { OUI_GOOGLE, GOOGLE_GSCAN_GEOFENCE_FOUND_EVENT },
1217 { OUI_GOOGLE, GOOGLE_GSCAN_BATCH_SCAN_EVENT },
1218 { OUI_GOOGLE, GOOGLE_SCAN_FULL_RESULTS_EVENT },
1219 #endif /* GSCAN_SUPPORT */
1220 #if defined(RTT_SUPPORT) && 0
1221 { OUI_GOOGLE, GOOGLE_RTT_COMPLETE_EVENT },
1222 #endif /* RTT_SUPPORT */
1223 #if defined(GSCAN_SUPPORT) && 0
1224 { OUI_GOOGLE, GOOGLE_SCAN_COMPLETE_EVENT },
1225 { OUI_GOOGLE, GOOGLE_GSCAN_GEOFENCE_LOST_EVENT }
1226 #endif /* GSCAN_SUPPORT */
1227 };
1228
ssv_cfgvendor_attach(struct wiphy * wiphy)1229 int ssv_cfgvendor_attach(struct wiphy *wiphy)
1230 {
1231
1232 DBG_SSV("Register SSV cfg80211 vendor cmd(0x%x) interface \n", NL80211_CMD_VENDOR);
1233
1234 wiphy->vendor_commands = ssv_vendor_cmds;
1235 wiphy->n_vendor_commands = ARRAY_SIZE(ssv_vendor_cmds);
1236 wiphy->vendor_events = ssv_vendor_events;
1237 wiphy->n_vendor_events = ARRAY_SIZE(ssv_vendor_events);
1238
1239 return 0;
1240 }
1241
ssv_cfgvendor_detach(struct wiphy * wiphy)1242 int ssv_cfgvendor_detach(struct wiphy *wiphy)
1243 {
1244 DBG_SSV("Vendor: Unregister SSV cfg80211 vendor interface \n");
1245
1246 wiphy->vendor_commands = NULL;
1247 wiphy->vendor_events = NULL;
1248 wiphy->n_vendor_commands = 0;
1249 wiphy->n_vendor_events = 0;
1250
1251 return 0;
1252 }
1253 #endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(SSV_VENDOR_EXT_SUPPORT) */
1254
1255