1 #include <wireless.h>
2 #include <wlan_intf.h>
3 #include <platform/platform_stdlib.h>
4 #include <wifi/wifi_conf.h>
5 #include <wifi/wifi_ind.h>
6 #include <osdep_service.h>
7
iw_ioctl(const char * ifname,unsigned long request,struct iwreq * pwrq)8 int iw_ioctl(const char * ifname, unsigned long request, struct iwreq * pwrq)
9 {
10 memcpy(pwrq->ifr_name, ifname, 5);
11 return rltk_wlan_control(request, (void *) pwrq);
12 }
13
wext_get_ssid(const char * ifname,__u8 * ssid)14 int wext_get_ssid(const char *ifname, __u8 *ssid)
15 {
16 struct iwreq iwr;
17 int ret = 0;
18
19 memset(&iwr, 0, sizeof(iwr));
20 iwr.u.essid.pointer = ssid;
21 iwr.u.essid.length = 32;
22
23 if (iw_ioctl(ifname, SIOCGIWESSID, &iwr) < 0) {
24 #if defined(CONFIG_EXAMPLE_BT_CONFIG) && (CONFIG_EXAMPLE_BT_CONFIG!=1)
25 RTW_API_INFO("\n\rioctl[SIOCGIWESSID] ssid = NULL, not connected"); //do not use perror
26 #endif
27 ret = -1;
28 } else {
29 ret = iwr.u.essid.length;
30 if (ret > 32)
31 ret = 32;
32 /* Some drivers include nul termination in the SSID, so let's
33 * remove it here before further processing. WE-21 changes this
34 * to explicitly require the length _not_ to include nul
35 * termination. */
36 if (ret > 0 && ssid[ret - 1] == '\0')
37 ret--;
38 ssid[ret] = '\0';
39 }
40
41 return ret;
42 }
43
wext_set_ssid(const char * ifname,const __u8 * ssid,__u16 ssid_len)44 int wext_set_ssid(const char *ifname, const __u8 *ssid, __u16 ssid_len)
45 {
46 struct iwreq iwr;
47 int ret = 0;
48
49 memset(&iwr, 0, sizeof(iwr));
50 iwr.u.essid.pointer = (void *) ssid;
51 iwr.u.essid.length = ssid_len;
52 iwr.u.essid.flags = (ssid_len != 0);
53
54 if (iw_ioctl(ifname, SIOCSIWESSID, &iwr) < 0) {
55 RTW_API_INFO("\n\rioctl[SIOCSIWESSID] error");
56 ret = -1;
57 }
58
59 return ret;
60 }
61
wext_set_bssid(const char * ifname,const __u8 * bssid)62 int wext_set_bssid(const char *ifname, const __u8 *bssid)
63 {
64 struct iwreq iwr;
65 int ret = 0;
66
67 memset(&iwr, 0, sizeof(iwr));
68 iwr.u.ap_addr.sa_family = ARPHRD_ETHER;
69 memcpy(iwr.u.ap_addr.sa_data, bssid, ETH_ALEN);
70
71 if(bssid[ETH_ALEN]=='#' && bssid[ETH_ALEN + 1]=='@'){
72 memcpy(iwr.u.ap_addr.sa_data + ETH_ALEN, bssid + ETH_ALEN, 6);
73 }
74
75 if (iw_ioctl(ifname, SIOCSIWAP, &iwr) < 0) {
76 RTW_API_INFO("\n\rioctl[SIOCSIWAP] error");
77 ret = -1;
78 }
79
80 return ret;
81 }
82
wext_get_bssid(const char * ifname,__u8 * bssid)83 int wext_get_bssid(const char*ifname, __u8 *bssid)
84 {
85 struct iwreq iwr;
86 int ret = 0;
87
88 memset(&iwr, 0, sizeof(iwr));
89
90 if (iw_ioctl(ifname, SIOCGIWAP, &iwr) < 0) {
91 RTW_API_INFO("\n\rioctl[SIOCSIWAP] error");
92 ret = -1;
93 } else {
94 memcpy(bssid, iwr.u.ap_addr.sa_data, ETH_ALEN);
95 }
96
97 return ret;
98 }
99
is_broadcast_ether_addr(const unsigned char * addr)100 int is_broadcast_ether_addr(const unsigned char *addr)
101 {
102 return (addr[0] & addr[1] & addr[2] & addr[3] & addr[4] & addr[5]) == 0xff;
103 }
104
wext_set_auth_param(const char * ifname,__u16 idx,__u32 value)105 int wext_set_auth_param(const char *ifname, __u16 idx, __u32 value)
106 {
107 struct iwreq iwr;
108 int ret = 0;
109
110 memset(&iwr, 0, sizeof(iwr));
111 iwr.u.param.flags = idx & IW_AUTH_INDEX;
112 iwr.u.param.value = value;
113
114 if (iw_ioctl(ifname, SIOCSIWAUTH, &iwr) < 0) {
115 RTW_API_INFO("\n\rWEXT: SIOCSIWAUTH(param %d value 0x%x) failed)", idx, value);
116 }
117
118 return ret;
119 }
120
wext_set_mfp_support(const char * ifname,__u8 value)121 int wext_set_mfp_support(const char *ifname, __u8 value)
122 {
123 int ret = 0;
124 struct iwreq iwr;
125
126 memset(&iwr, 0, sizeof(iwr));
127 iwr.u.param.value = value;
128
129 if (iw_ioctl(ifname, SIOCSIWMFP, &iwr) < 0) {
130 RTW_API_INFO("\n\rWEXT: SIOCSIWMFP(value 0x%x) failed)", value);
131 }
132
133 return ret;
134 }
135
136 #ifdef CONFIG_SAE_SUPPORT
wext_set_group_id(const char * ifname,__u8 value)137 int wext_set_group_id(const char *ifname, __u8 value)
138 {
139 int ret = 0;
140 struct iwreq iwr;
141
142 memset(&iwr, 0, sizeof(iwr));
143 iwr.u.param.value = value;
144
145 if (iw_ioctl(ifname, SIOCSIWGRPID, &iwr) < 0) {
146 RTW_API_INFO("\n\rWEXT: SIOCSIWGRPID(value 0x%x) failed)", value);
147 }
148
149 return ret;
150 }
151
wext_set_support_wpa3(__u8 enable)152 int wext_set_support_wpa3(__u8 enable)
153 {
154 extern u8 rtw_cmd_tsk_spt_wap3;
155 rtw_cmd_tsk_spt_wap3 = enable;
156 return 0;
157 }
158
wext_get_support_wpa3(void)159 unsigned char wext_get_support_wpa3(void)
160 {
161 extern u8 rtw_cmd_tsk_spt_wap3;
162 return rtw_cmd_tsk_spt_wap3;
163 }
164
165 #endif
166
167 #ifdef CONFIG_PMKSA_CACHING
wext_set_pmk_cache_enable(const char * ifname,__u8 value)168 int wext_set_pmk_cache_enable(const char *ifname, __u8 value)
169 {
170 int ret = 0;
171 struct iwreq iwr;
172
173 memset(&iwr, 0, sizeof(iwr));
174 iwr.u.param.value = value;
175
176 if (iw_ioctl(ifname, SIOCSIWPMKSA, &iwr) < 0) {
177 RTW_API_INFO("\n\rWEXT: SIOCSIWPMKSA(value 0x%x) failed)", value);
178 }
179
180 return ret;
181 }
182 #endif
183
wext_set_key_ext(const char * ifname,__u16 alg,const __u8 * addr,int key_idx,int set_tx,const __u8 * seq,__u16 seq_len,__u8 * key,__u16 key_len)184 int wext_set_key_ext(const char *ifname, __u16 alg, const __u8 *addr, int key_idx, int set_tx, const __u8 *seq, __u16 seq_len, __u8 *key, __u16 key_len)
185 {
186 struct iwreq iwr;
187 int ret = 0;
188 struct iw_encode_ext *ext;
189
190 ext = (struct iw_encode_ext *) malloc(sizeof(struct iw_encode_ext) + key_len);
191 if (ext == NULL)
192 return -1;
193 else
194 memset(ext, 0, sizeof(struct iw_encode_ext) + key_len);
195
196 memset(&iwr, 0, sizeof(iwr));
197 iwr.u.encoding.flags = key_idx + 1;
198 iwr.u.encoding.flags |= IW_ENCODE_TEMP;
199 iwr.u.encoding.pointer = ext;
200 iwr.u.encoding.length = sizeof(struct iw_encode_ext) + key_len;
201
202 if (alg == IW_ENCODE_DISABLED)
203 iwr.u.encoding.flags |= IW_ENCODE_DISABLED;
204
205 if (addr == NULL || is_broadcast_ether_addr(addr))
206 ext->ext_flags |= IW_ENCODE_EXT_GROUP_KEY;
207
208 if (set_tx)
209 ext->ext_flags |= IW_ENCODE_EXT_SET_TX_KEY;
210
211 ext->addr.sa_family = ARPHRD_ETHER;
212
213 if (addr)
214 memcpy(ext->addr.sa_data, addr, ETH_ALEN);
215 else
216 memset(ext->addr.sa_data, 0xff, ETH_ALEN);
217
218 if (key && key_len) {
219 memcpy(ext->key, key, key_len);
220 ext->key_len = key_len;
221 }
222
223 ext->alg = alg;
224
225 if (seq && seq_len) {
226 ext->ext_flags |= IW_ENCODE_EXT_RX_SEQ_VALID;
227 memcpy(ext->rx_seq, seq, seq_len);
228 }
229
230 if (iw_ioctl(ifname, SIOCSIWENCODEEXT, &iwr) < 0) {
231 ret = -2;
232 RTW_API_INFO("\n\rioctl[SIOCSIWENCODEEXT] set key fail");
233 }
234
235 free(ext);
236
237 return ret;
238 }
239
wext_get_enc_ext(const char * ifname,__u16 * alg,__u8 * key_idx,__u8 * passphrase)240 int wext_get_enc_ext(const char *ifname, __u16 *alg, __u8 *key_idx, __u8 *passphrase)
241 {
242 struct iwreq iwr;
243 int ret = 0;
244 struct iw_encode_ext *ext;
245
246 ext = (struct iw_encode_ext *) malloc(sizeof(struct iw_encode_ext) + 16);
247 if (ext == NULL)
248 return -1;
249 else
250 memset(ext, 0, sizeof(struct iw_encode_ext) + 16);
251
252 iwr.u.encoding.pointer = ext;
253
254 if (iw_ioctl(ifname, SIOCGIWENCODEEXT, &iwr) < 0) {
255 RTW_API_INFO("\n\rioctl[SIOCGIWENCODEEXT] error");
256 ret = -1;
257 }
258 else
259 {
260 *alg = ext->alg;
261 if(key_idx)
262 *key_idx = (__u8)iwr.u.encoding.flags;
263 if(passphrase)
264 memcpy(passphrase, ext->key, ext->key_len);
265 }
266
267 if(ext != NULL)
268 free(ext);
269
270 return ret;
271 }
272
wext_set_passphrase(const char * ifname,const __u8 * passphrase,__u16 passphrase_len)273 int wext_set_passphrase(const char *ifname, const __u8 *passphrase, __u16 passphrase_len)
274 {
275 struct iwreq iwr;
276 int ret = 0;
277
278 memset(&iwr, 0, sizeof(iwr));
279 iwr.u.passphrase.pointer = (void *) passphrase;
280 iwr.u.passphrase.length = passphrase_len;
281 iwr.u.passphrase.flags = (passphrase_len != 0);
282
283 if (iw_ioctl(ifname, SIOCSIWPRIVPASSPHRASE, &iwr) < 0) {
284 RTW_API_INFO("\n\rioctl[SIOCSIWESSID+0x1f] error");
285 ret = -1;
286 }
287
288 return ret;
289 }
290
wext_get_passphrase(const char * ifname,__u8 * passphrase)291 int wext_get_passphrase(const char *ifname, __u8 *passphrase)
292 {
293 struct iwreq iwr;
294 int ret = 0;
295
296 memset(&iwr, 0, sizeof(iwr));
297 iwr.u.passphrase.pointer = (void *) passphrase;
298
299 if (iw_ioctl(ifname, SIOCGIWPRIVPASSPHRASE, &iwr) < 0) {
300 RTW_API_INFO("\n\rioctl[SIOCGIWPRIVPASSPHRASE] error");
301 ret = -1;
302 }
303 else {
304 ret = iwr.u.passphrase.length;
305 passphrase[ret] = '\0';
306 }
307
308 return ret;
309 }
310
311 #if 0
312 int wext_set_mac_address(const char *ifname, char * mac)
313 {
314 char buf[13+17+1];
315 rtw_memset(buf, 0, sizeof(buf));
316 snprintf(buf, 13+17, "write_mac %s", mac);
317 return wext_private_command(ifname, buf, 0);
318 }
319
320 int wext_get_mac_address(const char *ifname, char * mac)
321 {
322 int ret = 0;
323 char buf[32];
324
325 rtw_memset(buf, 0, sizeof(buf));
326 rtw_memcpy(buf, "read_mac", 8);
327 ret = wext_private_command_with_retval(ifname, buf, buf, 32);
328 strcpy(mac, buf);
329 return ret;
330 }
331 #endif
332
wext_enable_powersave(const char * ifname,__u8 ips_mode,__u8 lps_mode)333 int wext_enable_powersave(const char *ifname, __u8 ips_mode, __u8 lps_mode)
334 {
335 struct iwreq iwr;
336 int ret = 0;
337 __u16 pindex = 0;
338 __u8 *para = NULL;
339 int cmd_len = 0;
340
341 memset(&iwr, 0, sizeof(iwr));
342 cmd_len = sizeof("pm_set");
343
344 // Encode parameters as TLV (type, length, value) format
345 para = rtw_malloc( 7 + (1+1+1) + (1+1+1) );
346 if(para == NULL) return -1;
347
348 snprintf((char*)para, cmd_len, "pm_set");
349 pindex = 7;
350
351 para[pindex++] = 0; // type 0 for ips
352 para[pindex++] = 1;
353 para[pindex++] = ips_mode;
354
355 para[pindex++] = 1; // type 1 for lps
356 para[pindex++] = 1;
357 para[pindex++] = lps_mode;
358
359 iwr.u.data.pointer = para;
360 iwr.u.data.length = pindex;
361
362 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
363 RTW_API_INFO("\n\rioctl[SIOCSIWPRIVPMSET] error");
364 ret = -1;
365 }
366
367 rtw_free(para);
368 return ret;
369 }
370
wext_resume_powersave(const char * ifname)371 int wext_resume_powersave(const char *ifname)
372 {
373 struct iwreq iwr;
374 int ret = 0;
375 __u16 pindex = 0;
376 __u8 *para = NULL;
377 int cmd_len = 0;
378
379 memset(&iwr, 0, sizeof(iwr));
380 cmd_len = sizeof("pm_set");
381
382 // Encode parameters as TLV (type, length, value) format
383 para = rtw_malloc( 7 + (1+1+1) + (1+1+1) );
384 if(para == NULL) return -1;
385
386 snprintf((char*)para, cmd_len, "pm_set");
387 pindex = 7;
388
389 para[pindex++] = 8; // type 8 for power save resume
390 para[pindex++] = 0;
391
392 iwr.u.data.pointer = para;
393 iwr.u.data.length = pindex;
394
395 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
396 RTW_API_INFO("\n\rioctl[SIOCSIWPRIVPMSET] error");
397 ret = -1;
398 }
399
400 rtw_free(para);
401 return ret;
402 }
403
wext_disable_powersave(const char * ifname)404 int wext_disable_powersave(const char *ifname)
405 {
406 struct iwreq iwr;
407 int ret = 0;
408 __u16 pindex = 0;
409 __u8 *para = NULL;
410 int cmd_len = 0;
411
412 memset(&iwr, 0, sizeof(iwr));
413 cmd_len = sizeof("pm_set");
414
415 // Encode parameters as TLV (type, length, value) format
416 para = rtw_malloc( 7 + (1+1+1) + (1+1+1) );
417 if(para == NULL) return -1;
418
419 snprintf((char*)para, cmd_len, "pm_set");
420 pindex = 7;
421
422 para[pindex++] = 0; // type 0 for ips
423 para[pindex++] = 1;
424 para[pindex++] = 0; // ips = 0
425
426 para[pindex++] = 1; // type 1 for lps
427 para[pindex++] = 1;
428 para[pindex++] = 0; // lps = 0
429
430 iwr.u.data.pointer = para;
431 iwr.u.data.length = pindex;
432
433 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
434 RTW_API_INFO("\n\rioctl[SIOCSIWPRIVPMSET] error");
435 ret = -1;
436 }
437
438 rtw_free(para);
439 return ret;
440
441 }
442
wext_set_tdma_param(const char * ifname,__u8 slot_period,__u8 rfon_period_len_1,__u8 rfon_period_len_2,__u8 rfon_period_len_3)443 int wext_set_tdma_param(const char *ifname, __u8 slot_period, __u8 rfon_period_len_1, __u8 rfon_period_len_2, __u8 rfon_period_len_3)
444 {
445 struct iwreq iwr;
446 int ret = 0;
447 __u16 pindex = 0;
448 __u8 *para = NULL;
449 int cmd_len = 0;
450
451 memset(&iwr, 0, sizeof(iwr));
452 cmd_len = sizeof("pm_set");
453
454 // Encode parameters as TLV (type, length, value) format
455 para = rtw_malloc( 7 + (1+1+4) );
456
457 snprintf((char*)para, cmd_len, "pm_set");
458 pindex = 7;
459
460 para[pindex++] = 2; // type 2 tdma param
461 para[pindex++] = 4;
462 para[pindex++] = slot_period;
463 para[pindex++] = rfon_period_len_1;
464 para[pindex++] = rfon_period_len_2;
465 para[pindex++] = rfon_period_len_3;
466
467 iwr.u.data.pointer = para;
468 iwr.u.data.length = pindex;
469
470 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
471 RTW_API_INFO("\n\rioctl[SIOCSIWPRIVPMSET] error");
472 ret = -1;
473 }
474
475 rtw_free(para);
476 return ret;
477 }
478
wext_set_lps_dtim(const char * ifname,__u8 lps_dtim)479 int wext_set_lps_dtim(const char *ifname, __u8 lps_dtim)
480 {
481 struct iwreq iwr;
482 int ret = 0;
483 __u16 pindex = 0;
484 __u8 *para = NULL;
485 int cmd_len = 0;
486
487 memset(&iwr, 0, sizeof(iwr));
488 cmd_len = sizeof("pm_set");
489
490 // Encode parameters as TLV (type, length, value) format
491 para = rtw_malloc( 7 + (1+1+1) );
492
493 snprintf((char*)para, cmd_len, "pm_set");
494 pindex = 7;
495
496 para[pindex++] = 3; // type 3 lps dtim
497 para[pindex++] = 1;
498 para[pindex++] = lps_dtim;
499
500 iwr.u.data.pointer = para;
501 iwr.u.data.length = pindex;
502
503 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
504 RTW_API_INFO("\n\rioctl[SIOCSIWPRIVPMSET] error");
505 ret = -1;
506 }
507
508 rtw_free(para);
509 return ret;
510 }
511
wext_get_lps_dtim(const char * ifname,__u8 * lps_dtim)512 int wext_get_lps_dtim(const char *ifname, __u8 *lps_dtim)
513 {
514
515 struct iwreq iwr;
516 int ret = 0;
517 __u16 pindex = 0;
518 __u8 *para = NULL;
519 int cmd_len = 0;
520
521 memset(&iwr, 0, sizeof(iwr));
522 cmd_len = sizeof("pm_get");
523
524 // Encode parameters as TLV (type, length, value) format
525 para = rtw_malloc( 7 + (1+1+1) );
526
527 snprintf((char*)para, cmd_len, "pm_get");
528 pindex = 7;
529
530 para[pindex++] = 3; // type 3 for lps dtim
531 para[pindex++] = 1;
532 para[pindex++] = 0;
533
534 iwr.u.data.pointer = para;
535 iwr.u.data.length = pindex;
536
537 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
538 RTW_API_INFO("\n\rioctl[SIOCSIWPRIVPMGET] error");
539 ret = -1;
540 goto exit;
541 }
542
543 //get result at the beginning of iwr.u.data.pointer
544 if((para[0]==3)&&(para[1]==1))
545 *lps_dtim = para[2];
546 else
547 RTW_API_INFO("\n\r%s error", __func__);
548
549 exit:
550 rtw_free(para);
551
552 return ret;
553 }
554
wext_set_lps_thresh(const char * ifname,u8 low_thresh)555 int wext_set_lps_thresh(const char *ifname, u8 low_thresh) {
556 struct iwreq iwr;
557 int ret = 0;
558 __u16 pindex = 0;
559 __u8 *para = NULL;
560 int cmd_len = 0;
561
562 memset(&iwr, 0, sizeof(iwr));
563 cmd_len = sizeof("pm_set");
564
565 // Encode parameters as TLV (type, length, value) format
566 para = rtw_malloc( 7 + (1+1+1) );
567
568 snprintf((char*)para, cmd_len, "pm_set");
569 pindex = 7;
570
571 para[pindex++] = 6; // type 6 lps threshold
572 para[pindex++] = 1; // len
573 para[pindex++] = low_thresh;
574
575 iwr.u.data.pointer = para;
576 iwr.u.data.length = pindex;
577
578 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
579 RTW_API_INFO("\n\rioctl[SIOCSIWPRIVPMSET] error");
580 ret = -1;
581 }
582
583 rtw_free(para);
584 return ret;
585 }
586
587 #ifdef LONG_PERIOD_TICKLESS
wext_set_lps_smartps(const char * ifname,__u8 smartps)588 int wext_set_lps_smartps(const char *ifname, __u8 smartps) {
589 struct iwreq iwr;
590 int ret = 0;
591 __u16 pindex = 0;
592 __u8 *para = NULL;
593 int cmd_len = 0;
594
595 memset(&iwr, 0, sizeof(iwr));
596 cmd_len = sizeof("pm_set");
597
598 // Encode parameters as TLV (type, length, value) format
599 para = rtw_malloc( 7 + (1+1+1) );
600
601 snprintf((char*)para, cmd_len, "pm_set");
602 pindex = 7;
603
604 para[pindex++] = 9; // type 9 smartps
605 para[pindex++] = 1; // len
606 para[pindex++] = smartps;
607
608 iwr.u.data.pointer = para;
609 iwr.u.data.length = pindex;
610
611 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
612 RTW_API_INFO("\n\rioctl[SIOCSIWPRIVPMSET] error");
613 ret = -1;
614 }
615
616 rtw_free(para);
617 return ret;
618
619 }
620 #endif
wext_set_beacon_mode(const char * ifname,__u8 mode)621 int wext_set_beacon_mode(const char *ifname, __u8 mode) {
622 struct iwreq iwr;
623 int ret = 0;
624 __u16 pindex = 0;
625 __u8 *para = NULL;
626 int cmd_len = 0;
627
628 memset(&iwr, 0, sizeof(iwr));
629 cmd_len = sizeof("pm_set");
630
631 // Encode parameters as TLV (type, length, value) format
632 para = rtw_malloc( 7 + (1+1+1) );
633
634 snprintf((char*)para, cmd_len, "pm_set");
635 pindex = 7;
636
637 para[pindex++] = 4; // type 4 beacon mode
638 para[pindex++] = 1; // len
639 para[pindex++] = mode;
640
641 iwr.u.data.pointer = para;
642 iwr.u.data.length = pindex;
643
644 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
645 RTW_API_INFO("\n\rioctl[SIOCSIWPRIVPMSET] error");
646 ret = -1;
647 }
648
649 rtw_free(para);
650 return ret;
651 }
652
wext_set_lps_level(const char * ifname,__u8 lps_level)653 int wext_set_lps_level(const char *ifname, __u8 lps_level) {
654 struct iwreq iwr;
655 int ret = 0;
656 __u16 pindex = 0;
657 __u8 *para = NULL;
658 int cmd_len = 0;
659
660 memset(&iwr, 0, sizeof(iwr));
661 cmd_len = sizeof("pm_set");
662
663 // Encode parameters as TLV (type, length, value) format
664 para = rtw_malloc( 7 + (1+1+1) );
665
666 snprintf((char*)para, cmd_len, "pm_set");
667 pindex = 7;
668
669 para[pindex++] = 5; // type 5 lps_level
670 para[pindex++] = 1; // len
671 para[pindex++] = lps_level;
672
673 iwr.u.data.pointer = para;
674 iwr.u.data.length = pindex;
675
676 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
677 RTW_API_INFO("\n\rioctl[SIOCSIWPRIVPMSET] error");
678 ret = -1;
679 }
680
681 rtw_free(para);
682 return ret;
683 }
684
685
wext_set_tos_value(const char * ifname,__u8 * tos_value)686 int wext_set_tos_value(const char *ifname, __u8 *tos_value)
687 {
688 struct iwreq iwr;
689 int ret = 0;
690 __u8 *para = NULL;
691 int cmd_len = sizeof("set_tos_value");
692
693 memset(&iwr, 0, sizeof(iwr));
694
695 para = rtw_malloc(cmd_len + 4);
696 snprintf((char*)para, cmd_len, "set_tos_value");
697
698 if(*tos_value <=32){
699 *(para + cmd_len) = 0x4f;
700 *(para + cmd_len+1) = 0xa4;
701 *(para + cmd_len+2) = 0;
702 *(para + cmd_len+3) = 0;
703 }
704 else if(*tos_value > 32 && *tos_value <=96){
705 *(para + cmd_len) = 0x2b;
706 *(para + cmd_len+1) = 0xa4;
707 *(para + cmd_len+2) = 0;
708 *(para + cmd_len+3) = 0;
709 }
710 else if(*tos_value > 96 && *tos_value <= 160){
711 *(para + cmd_len) = 0x22;
712 *(para + cmd_len+1) = 0x43;
713 *(para + cmd_len+2) = 0x5e;
714 *(para + cmd_len+3) = 0;
715 }
716 else if(*tos_value > 160){
717 *(para + cmd_len) = 0x22;
718 *(para + cmd_len+1) = 0x32;
719 *(para + cmd_len+2) = 0x2f;
720 *(para + cmd_len+3) = 0;
721 }
722
723 iwr.u.data.pointer = para;
724 iwr.u.data.length = cmd_len + 4;
725
726 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
727 RTW_API_INFO("\n\rwext_set_tos_value():ioctl[SIOCDEVPRIVATE] error");
728 ret = -1;
729 }
730
731 rtw_free(para);
732 return ret;
733 }
734
wext_get_tx_power(const char * ifname,__u8 * poweridx)735 int wext_get_tx_power(const char *ifname, __u8 *poweridx)
736 {
737 struct iwreq iwr;
738 int ret = 0;
739 __u8 *para = NULL;
740 int cmd_len = sizeof("get_tx_power");
741
742 memset(&iwr, 0, sizeof(iwr));
743 //Tx power size : 20 Bytes
744 //CCK 1M,2M,5.5M,11M : 4 Bytes
745 //OFDM 6M, 9M, 12M, 18M, 24M, 36M 48M, 54M : 8 Bytes
746 //MCS 0~7 : 8 Bytes
747 para = rtw_malloc(cmd_len + 20);
748 snprintf((char*)para, cmd_len, "get_tx_power");
749
750 iwr.u.data.pointer = para;
751 iwr.u.data.length = cmd_len + 20;
752 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
753 RTW_API_INFO("\n\rwext_get_tx_power():ioctl[SIOCDEVPRIVATE] error");
754 ret = -1;
755 }
756
757 memcpy(poweridx,(__u8 *)(iwr.u.data.pointer),20);
758 rtw_free(para);
759 return ret;
760 }
761
762 #if 0
763 int wext_set_txpower(const char *ifname, int poweridx)
764 {
765 int ret = 0;
766 char buf[24];
767
768 rtw_memset(buf, 0, sizeof(buf));
769 snprintf(buf, 24, "txpower patha=%d", poweridx);
770 ret = wext_private_command(ifname, buf, 0);
771
772 return ret;
773 }
774
775 int wext_get_associated_client_list(const char *ifname, void * client_list_buffer, uint16_t buffer_length)
776 {
777 int ret = 0;
778 char buf[25];
779
780 rtw_memset(buf, 0, sizeof(buf));
781 snprintf(buf, 25, "get_client_list %x", client_list_buffer);
782 ret = wext_private_command(ifname, buf, 0);
783
784 return ret;
785 }
786
787 int wext_get_ap_info(const char *ifname, rtw_bss_info_t * ap_info, rtw_security_t* security)
788 {
789 int ret = 0;
790 char buf[24];
791
792 rtw_memset(buf, 0, sizeof(buf));
793 snprintf(buf, 24, "get_ap_info %x", ap_info);
794 ret = wext_private_command(ifname, buf, 0);
795
796 snprintf(buf, 24, "get_security");
797 ret = wext_private_command_with_retval(ifname, buf, buf, 24);
798 sscanf(buf, "%d", security);
799
800 return ret;
801 }
802 #endif
803
wext_set_mode(const char * ifname,int mode)804 int wext_set_mode(const char *ifname, int mode)
805 {
806 struct iwreq iwr;
807 int ret = 0;
808
809 memset(&iwr, 0, sizeof(iwr));
810 iwr.u.mode = mode;
811 if (iw_ioctl(ifname, SIOCSIWMODE, &iwr) < 0) {
812 RTW_API_INFO("\n\rioctl[SIOCSIWMODE] error");
813 ret = -1;
814 }
815
816 return ret;
817 }
818
wext_get_mode(const char * ifname,int * mode)819 int wext_get_mode(const char *ifname, int *mode)
820 {
821 struct iwreq iwr;
822 int ret = 0;
823
824 memset(&iwr, 0, sizeof(iwr));
825
826 if (iw_ioctl(ifname, SIOCGIWMODE, &iwr) < 0) {
827 RTW_API_INFO("\n\rioctl[SIOCGIWMODE] error");
828 ret = -1;
829 }
830 else
831 *mode = iwr.u.mode;
832
833 return ret;
834 }
835
wext_set_ap_ssid(const char * ifname,const __u8 * ssid,__u16 ssid_len)836 int wext_set_ap_ssid(const char *ifname, const __u8 *ssid, __u16 ssid_len)
837 {
838 struct iwreq iwr;
839 int ret = 0;
840
841 if(ssid_len > 32){
842 printf("Error: SSID should be 0-32 characters\r\n");
843 return -1;
844 }
845
846 memset(&iwr, 0, sizeof(iwr));
847 iwr.u.essid.pointer = (void *) ssid;
848 iwr.u.essid.length = ssid_len;
849 iwr.u.essid.flags = (ssid_len != 0);
850
851 if (iw_ioctl(ifname, SIOCSIWPRIVAPESSID, &iwr) < 0) {
852 RTW_API_INFO("\n\rioctl[SIOCSIWPRIVAPESSID] error");
853 ret = -1;
854 }
855
856 return ret;
857 }
858
wext_set_country(const char * ifname,rtw_country_code_t country_code)859 int wext_set_country(const char *ifname, rtw_country_code_t country_code)
860 {
861 struct iwreq iwr;
862 int ret = 0;
863
864 memset(&iwr, 0, sizeof(iwr));
865
866 iwr.u.param.value = country_code;
867
868 if (iw_ioctl(ifname, SIOCSIWPRIVCOUNTRY, &iwr) < 0) {
869 RTW_API_INFO("\n\rioctl[SIOCSIWPRIVCOUNTRY] error");
870 ret = -1;
871 }
872 return ret;
873 }
874
wext_get_rssi(const char * ifname,int * rssi)875 int wext_get_rssi(const char *ifname, int *rssi)
876 {
877 struct iwreq iwr;
878 int ret = 0;
879
880 memset(&iwr, 0, sizeof(iwr));
881
882 if (iw_ioctl(ifname, SIOCGIWSENS, &iwr) < 0) {
883 RTW_API_INFO("\n\rioctl[SIOCGIWSENS] error");
884 ret = -1;
885 } else {
886 *rssi = 0 - iwr.u.sens.value;
887 }
888 return ret;
889 }
890
wext_get_bcn_rssi(const char * ifname,int * rssi)891 int wext_get_bcn_rssi(const char *ifname, int *rssi)
892 {
893 struct iwreq iwr;
894 int ret = 0;
895
896 memset(&iwr, 0, sizeof(iwr));
897
898 if (iw_ioctl(ifname, SIOCGIWBCNSENS, &iwr) < 0) {
899 printf("\n\rioctl[SIOCGIWBCNSENS] error");
900 ret = -1;
901 } else {
902 *rssi = 0 - iwr.u.bcnsens.value;
903 }
904 return ret;
905 }
906
wext_set_pscan_channel(const char * ifname,__u8 * ch,__u8 * pscan_config,__u8 length)907 int wext_set_pscan_channel(const char *ifname, __u8 *ch, __u8 *pscan_config, __u8 length)
908 {
909 struct iwreq iwr;
910 int ret = 0;
911 __u8 *para = NULL;
912 int i =0;
913
914 memset(&iwr, 0, sizeof(iwr));
915 //Format of para:function_name num_channel chan1... pscan_config1 ...
916 para = rtw_malloc((length + length + 1) + 12);//size:num_chan + num_time + length + function_name
917 if(para == NULL) return -1;
918
919 //Cmd
920 snprintf((char*)para, 12, "PartialScan");
921 //length
922 *(para+12) = length;
923 for(i = 0; i < length; i++){
924 *(para + 13 + i)= *(ch + i);
925 *(para + 13 + length + i)= *(pscan_config + i);
926 }
927
928 iwr.u.data.pointer = para;
929 iwr.u.data.length = (length + length + 1) + 12;
930 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
931 RTW_API_INFO("\n\rwext_set_pscan_channel():ioctl[SIOCDEVPRIVATE] error");
932 ret = -1;
933 }
934 rtw_free(para);
935 return ret;
936 }
wext_set_channel(const char * ifname,__u8 ch)937 int wext_set_channel(const char *ifname, __u8 ch)
938 {
939 struct iwreq iwr;
940 int ret = 0;
941
942 memset(&iwr, 0, sizeof(iwr));
943 iwr.u.freq.m = 0;
944 iwr.u.freq.e = 0;
945 iwr.u.freq.i = ch;
946
947 if (iw_ioctl(ifname, SIOCSIWFREQ, &iwr) < 0) {
948 RTW_API_INFO("\n\rioctl[SIOCSIWFREQ] error");
949 ret = -1;
950 }
951
952 return ret;
953 }
954
wext_get_channel(const char * ifname,__u8 * ch)955 int wext_get_channel(const char *ifname, __u8 *ch)
956 {
957 struct iwreq iwr;
958 int ret = 0;
959
960 memset(&iwr, 0, sizeof(iwr));
961
962 if (iw_ioctl(ifname, SIOCGIWFREQ, &iwr) < 0) {
963 RTW_API_INFO("\n\rioctl[SIOCGIWFREQ] error");
964 ret = -1;
965 }
966 else
967 *ch = iwr.u.freq.i;
968
969 return ret;
970 }
971
wext_register_multicast_address(const char * ifname,rtw_mac_t * mac)972 int wext_register_multicast_address(const char *ifname, rtw_mac_t *mac)
973 {
974 int ret = 0;
975 char buf[32];
976
977 rtw_memset(buf, 0, sizeof(buf));
978 snprintf(buf, 32, "reg_multicast "MAC_FMT, MAC_ARG(mac->octet));
979 ret = wext_private_command(ifname, buf, 0);
980
981 return ret;
982 }
983
wext_unregister_multicast_address(const char * ifname,rtw_mac_t * mac)984 int wext_unregister_multicast_address(const char *ifname, rtw_mac_t *mac)
985 {
986 int ret = 0;
987 char buf[35];
988
989 rtw_memset(buf, 0, sizeof(buf));
990 snprintf(buf, 35, "reg_multicast -d "MAC_FMT, MAC_ARG(mac->octet));
991 ret = wext_private_command(ifname, buf, 0);
992
993 return ret;
994 }
995
wext_set_scan(const char * ifname,char * buf,__u16 buf_len,__u16 flags)996 int wext_set_scan(const char *ifname, char *buf, __u16 buf_len, __u16 flags)
997 {
998 struct iwreq iwr;
999 int ret = 0;
1000
1001 memset(&iwr, 0, sizeof(iwr));
1002 #if 0 //for scan_with_ssid
1003 if(buf)
1004 memset(buf, 0, buf_len);
1005 #endif
1006 iwr.u.data.pointer = buf;
1007 iwr.u.data.flags = flags;
1008 iwr.u.data.length = buf_len;
1009 if (iw_ioctl(ifname, SIOCSIWSCAN, &iwr) < 0) {
1010 RTW_API_INFO("\n\rioctl[SIOCSIWSCAN] error");
1011 ret = -1;
1012 }
1013 return ret;
1014 }
1015
wext_get_scan(const char * ifname,char * buf,__u16 buf_len)1016 int wext_get_scan(const char *ifname, char *buf, __u16 buf_len)
1017 {
1018 struct iwreq iwr;
1019 int ret = 0;
1020
1021 iwr.u.data.pointer = buf;
1022 iwr.u.data.length = buf_len;
1023 if (iw_ioctl(ifname, SIOCGIWSCAN, &iwr) < 0) {
1024 RTW_API_INFO("\n\rioctl[SIOCGIWSCAN] error");
1025 ret = -1;
1026 }else
1027 ret = iwr.u.data.flags;
1028 return ret;
1029 }
1030
wext_private_command_with_retval(const char * ifname,char * cmd,char * ret_buf,int ret_len)1031 int wext_private_command_with_retval(const char *ifname, char *cmd, char *ret_buf, int ret_len)
1032 {
1033 struct iwreq iwr;
1034 int ret = 0;
1035 unsigned int buf_size;
1036 char *buf;
1037
1038 buf_size = 128;
1039 if(strlen(cmd) >= buf_size)
1040 buf_size = strlen(cmd) + 1; // 1 : '\0'
1041 buf = (char*)rtw_malloc(buf_size);
1042 if(!buf){
1043 RTW_API_INFO("\n\rWEXT: Can't malloc memory");
1044 return -1;
1045 }
1046 memset(buf, 0, buf_size);
1047 strncpy(buf, cmd, buf_size);
1048 memset(&iwr, 0, sizeof(iwr));
1049 iwr.u.data.pointer = buf;
1050 iwr.u.data.length = buf_size;
1051 iwr.u.data.flags = 0;
1052
1053 if ((ret = iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr)) < 0) {
1054 RTW_API_INFO("\n\rioctl[SIOCDEVPRIVATE] error. ret=%d\n", ret);
1055 }
1056 if(ret_buf){
1057 if(ret_len > iwr.u.data.length)
1058 ret_len = iwr.u.data.length;
1059 rtw_memcpy(ret_buf, (char *) iwr.u.data.pointer, ret_len);
1060 }
1061 rtw_free(buf);
1062 return ret;
1063 }
1064
wext_private_command(const char * ifname,char * cmd,int show_msg)1065 int wext_private_command(const char *ifname, char *cmd, int show_msg)
1066 {
1067 struct iwreq iwr;
1068 int ret = 0;
1069 unsigned int buf_size;
1070 char *buf;
1071
1072 u8 cmdname[17] = {0}; // IFNAMSIZ+1
1073
1074 sscanf(cmd, "%16s", cmdname);
1075 if((strcmp((const char *)cmdname, "config_get") == 0)
1076 || (strcmp((const char *)cmdname, "config_set") == 0)
1077 || (strcmp((const char *)cmdname, "efuse_get") == 0)
1078 || (strcmp((const char *)cmdname, "efuse_set") == 0)
1079 || (strcmp((const char *)cmdname, "mp_psd") == 0))
1080 buf_size = 2600;//2600 for config_get rmap,0,512 (or realmap)
1081 else
1082 buf_size = 512;
1083
1084 if(strlen(cmd) >= buf_size)
1085 buf_size = strlen(cmd) + 1; // 1 : '\0'
1086 buf = (char*)rtw_malloc(buf_size);
1087 if(!buf){
1088 RTW_API_INFO("\n\rWEXT: Can't malloc memory");
1089 return -1;
1090 }
1091 memset(buf, 0, buf_size);
1092 strncpy(buf, cmd, buf_size);
1093 memset(&iwr, 0, sizeof(iwr));
1094 iwr.u.data.pointer = buf;
1095 iwr.u.data.length = buf_size;
1096 iwr.u.data.flags = 0;
1097
1098 if ((ret = iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr)) < 0) {
1099 RTW_API_INFO("\n\rioctl[SIOCDEVPRIVATE] error. ret=%d\n", ret);
1100 }
1101 if (show_msg && iwr.u.data.length) {
1102 if(iwr.u.data.length > buf_size)
1103 RTW_API_INFO("\n\rWEXT: Malloc memory is not enough");
1104 RTW_API_INFO("\n\rPrivate Message: %s", (char *) iwr.u.data.pointer);
1105 }
1106 rtw_free(buf);
1107 return ret;
1108 }
1109
wext_wlan_indicate(unsigned int cmd,union iwreq_data * wrqu,char * extra)1110 void wext_wlan_indicate(unsigned int cmd, union iwreq_data *wrqu, char *extra)
1111 {
1112 unsigned char null_mac[6] = {0};
1113
1114 switch(cmd)
1115 {
1116 case SIOCGIWAP:
1117 if(wrqu->ap_addr.sa_family == ARPHRD_ETHER)
1118 {
1119 if(!memcmp(wrqu->ap_addr.sa_data, null_mac, sizeof(null_mac)))
1120 wifi_indication(WIFI_EVENT_DISCONNECT, wrqu->ap_addr.sa_data, sizeof(null_mac)+ 2, 0);
1121 else
1122 wifi_indication(WIFI_EVENT_CONNECT, wrqu->ap_addr.sa_data, sizeof(null_mac), 0);
1123 }
1124 break;
1125
1126 case IWEVCUSTOM:
1127 if(extra)
1128 {
1129 if(!memcmp(IW_EXT_STR_FOURWAY_DONE, extra, strlen(IW_EXT_STR_FOURWAY_DONE)))
1130 wifi_indication(WIFI_EVENT_FOURWAY_HANDSHAKE_DONE, extra, strlen(IW_EXT_STR_FOURWAY_DONE), 0);
1131 else if(!memcmp(IW_EXT_STR_RECONNECTION_FAIL, extra, strlen(IW_EXT_STR_RECONNECTION_FAIL)))
1132 wifi_indication(WIFI_EVENT_RECONNECTION_FAIL, extra, strlen(IW_EXT_STR_RECONNECTION_FAIL), 0);
1133 else if(!memcmp(IW_EVT_STR_NO_NETWORK, extra, strlen(IW_EVT_STR_NO_NETWORK)))
1134 wifi_indication(WIFI_EVENT_NO_NETWORK, extra, strlen(IW_EVT_STR_NO_NETWORK), 0);
1135 else if(!memcmp(IW_EVT_STR_ICV_ERROR, extra, strlen(IW_EVT_STR_ICV_ERROR)))
1136 wifi_indication(WIFI_EVENT_ICV_ERROR, extra, strlen(IW_EVT_STR_ICV_ERROR), 0);
1137 else if(!memcmp(IW_EVT_STR_CHALLENGE_FAIL, extra, strlen(IW_EVT_STR_CHALLENGE_FAIL)))
1138 wifi_indication(WIFI_EVENT_CHALLENGE_FAIL, extra, strlen(IW_EVT_STR_CHALLENGE_FAIL), 0);
1139 #if CONFIG_ENABLE_P2P || defined(CONFIG_AP_MODE)
1140 else if(!memcmp(IW_EVT_STR_STA_ASSOC, extra, strlen(IW_EVT_STR_STA_ASSOC)))
1141 wifi_indication(WIFI_EVENT_STA_ASSOC, wrqu->data.pointer, wrqu->data.length, 0);
1142 else if(!memcmp(IW_EVT_STR_STA_DISASSOC, extra, strlen(IW_EVT_STR_STA_DISASSOC)))
1143 wifi_indication(WIFI_EVENT_STA_DISASSOC, wrqu->addr.sa_data, sizeof(null_mac), 0);
1144 else if(!memcmp(IW_EVT_STR_SEND_ACTION_DONE, extra, strlen(IW_EVT_STR_SEND_ACTION_DONE)))
1145 wifi_indication(WIFI_EVENT_SEND_ACTION_DONE, NULL, 0, wrqu->data.flags);
1146 else if(!memcmp(IW_EVT_STR_SOFTAP_START, extra, strlen(IW_EVT_STR_SOFTAP_START)))
1147 wifi_indication(WIFI_EVENT_SOFTAP_START, extra, strlen(IW_EVT_STR_SOFTAP_START), 0);
1148 else if(!memcmp(IW_EVT_STR_SOFTAP_STOP, extra, strlen(IW_EVT_STR_SOFTAP_STOP)))
1149 wifi_indication(WIFI_EVENT_SOFTAP_STOP, extra, strlen(IW_EVT_STR_SOFTAP_STOP), 0);
1150 #endif
1151 }
1152 break;
1153 case SIOCGIWSCAN:
1154 if(wrqu->data.pointer == NULL)
1155 wifi_indication(WIFI_EVENT_SCAN_DONE, NULL, 0, 0);
1156 else
1157 wifi_indication(WIFI_EVENT_SCAN_RESULT_REPORT, wrqu->data.pointer, wrqu->data.length, 0);
1158 break;
1159 case IWEVMGNTRECV:
1160 wifi_indication(WIFI_EVENT_RX_MGNT, wrqu->data.pointer, wrqu->data.length, wrqu->data.flags);
1161 break;
1162 #ifdef REPORT_STA_EVENT
1163 case IWEVREGISTERED:
1164 if(wrqu->addr.sa_family == ARPHRD_ETHER)
1165 wifi_indication(WIFI_EVENT_STA_ASSOC, wrqu->addr.sa_data, sizeof(null_mac), 0);
1166 break;
1167 case IWEVEXPIRED:
1168 if(wrqu->addr.sa_family == ARPHRD_ETHER)
1169 wifi_indication(WIFI_EVENT_STA_DISASSOC, wrqu->addr.sa_data, sizeof(null_mac), 0);
1170 break;
1171 #endif
1172 default:
1173 break;
1174
1175 }
1176
1177 }
1178
1179
wext_send_eapol(const char * ifname,char * buf,__u16 buf_len,__u16 flags)1180 int wext_send_eapol(const char *ifname, char *buf, __u16 buf_len, __u16 flags)
1181 {
1182 struct iwreq iwr;
1183 int ret = 0;
1184
1185 memset(&iwr, 0, sizeof(iwr));
1186 iwr.u.data.pointer = buf;
1187 iwr.u.data.length = buf_len;
1188 iwr.u.data.flags = flags;
1189 if (iw_ioctl(ifname, SIOCSIWEAPOLSEND, &iwr) < 0) {
1190 RTW_API_INFO("\n\rioctl[SIOCSIWEAPOLSEND] error");
1191 ret = -1;
1192 }
1193 return ret;
1194 }
1195
wext_send_mgnt(const char * ifname,char * buf,__u16 buf_len,__u16 flags)1196 int wext_send_mgnt(const char *ifname, char *buf, __u16 buf_len, __u16 flags)
1197 {
1198 struct iwreq iwr;
1199 int ret = 0;
1200
1201 memset(&iwr, 0, sizeof(iwr));
1202 iwr.u.data.pointer = buf;
1203 iwr.u.data.length = buf_len;
1204 iwr.u.data.flags = flags;
1205 if (iw_ioctl(ifname, SIOCSIWMGNTSEND, &iwr) < 0) {
1206 RTW_API_INFO("\n\rioctl[SIOCSIWMGNTSEND] error");
1207 ret = -1;
1208 }
1209 return ret;
1210 }
1211
wext_set_gen_ie(const char * ifname,char * buf,__u16 buf_len,__u16 flags)1212 int wext_set_gen_ie(const char *ifname, char *buf, __u16 buf_len, __u16 flags)
1213 {
1214 struct iwreq iwr;
1215 int ret = 0;
1216
1217 memset(&iwr, 0, sizeof(iwr));
1218 iwr.u.data.pointer = buf;
1219 iwr.u.data.length = buf_len;
1220 iwr.u.data.flags = flags;
1221 if (iw_ioctl(ifname, SIOCSIWGENIE, &iwr) < 0) {
1222 RTW_API_INFO("\n\rioctl[SIOCSIWGENIE] error");
1223 ret = -1;
1224 }
1225 return ret;
1226 }
1227
wext_set_autoreconnect(const char * ifname,__u8 mode,__u8 retry_times,__u16 timeout)1228 int wext_set_autoreconnect(const char *ifname, __u8 mode, __u8 retry_times, __u16 timeout)
1229 {
1230 struct iwreq iwr;
1231 int ret = 0;
1232 __u8 *para = NULL;
1233 int cmd_len = 0;
1234
1235 memset(&iwr, 0, sizeof(iwr));
1236 cmd_len = sizeof("SetAutoRecnt");
1237 para = rtw_malloc((4) + cmd_len);//size:para_len+cmd_len
1238 if(para == NULL) return -1;
1239
1240 //Cmd
1241 snprintf((char*)para, cmd_len, "SetAutoRecnt");
1242 //length
1243 *(para+cmd_len) = mode; //para1
1244 *(para+cmd_len+1) = retry_times; //para2
1245 *(para+cmd_len+2) = timeout; //para3
1246
1247 iwr.u.data.pointer = para;
1248 iwr.u.data.length = (4) + cmd_len;
1249 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
1250 RTW_API_INFO("\n\rwext_set_autoreconnect():ioctl[SIOCDEVPRIVATE] error");
1251 ret = -1;
1252 }
1253 rtw_free(para);
1254 return ret;
1255 }
1256
wext_get_autoreconnect(const char * ifname,__u8 * mode)1257 int wext_get_autoreconnect(const char *ifname, __u8 *mode)
1258 {
1259 struct iwreq iwr;
1260 int ret = 0;
1261 __u8 *para = NULL;
1262 int cmd_len = 0;
1263
1264 memset(&iwr, 0, sizeof(iwr));
1265 cmd_len = sizeof("GetAutoRecnt");
1266 para = rtw_malloc(cmd_len);//size:para_len+cmd_len
1267 //Cmd
1268 snprintf((char*)para, cmd_len, "GetAutoRecnt");
1269 //length
1270
1271 iwr.u.data.pointer = para;
1272 iwr.u.data.length = cmd_len;
1273 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
1274 RTW_API_INFO("\n\rwext_get_autoreconnect():ioctl[SIOCDEVPRIVATE] error");
1275 ret = -1;
1276 }
1277 *mode = *(__u8 *)(iwr.u.data.pointer);
1278 rtw_free(para);
1279 return ret;
1280 }
1281
wext_get_drv_ability(const char * ifname,__u32 * ability)1282 int wext_get_drv_ability(const char *ifname, __u32 *ability)
1283 {
1284 int ret = 0;
1285 char * buf = (char *)rtw_zmalloc(33);
1286 if(buf == NULL) return -1;
1287
1288 snprintf(buf, 33, "get_drv_ability %x", (unsigned int)ability);
1289 ret = wext_private_command(ifname, buf, 0);
1290
1291 rtw_free(buf);
1292 return ret;
1293 }
1294
1295 #ifdef CONFIG_CUSTOM_IE
wext_add_custom_ie(const char * ifname,void * cus_ie,int ie_num)1296 int wext_add_custom_ie(const char *ifname, void *cus_ie, int ie_num)
1297 {
1298 struct iwreq iwr;
1299 int ret = 0;
1300 __u8 *para = NULL;
1301 int cmd_len = 0;
1302 if(ie_num <= 0 || !cus_ie){
1303 RTW_API_INFO("\n\rwext_add_custom_ie():wrong parameter");
1304 ret = -1;
1305 return ret;
1306 }
1307 memset(&iwr, 0, sizeof(iwr));
1308 cmd_len = sizeof("SetCusIE");
1309 para = rtw_malloc((4)* 2 + cmd_len);//size:addr len+cmd_len
1310 if(para == NULL) return -1;
1311
1312 //Cmd
1313 snprintf((char*)para, cmd_len, "SetCusIE");
1314 //addr length
1315 *(__u32 *)(para + cmd_len) = (__u32)cus_ie; //ie addr
1316 //ie_num
1317 *(__u32 *)(para + cmd_len + 4) = ie_num; //num of ie
1318
1319 iwr.u.data.pointer = para;
1320 iwr.u.data.length = (4)* 2 + cmd_len;// 2 input
1321 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
1322 RTW_API_INFO("\n\rwext_add_custom_ie():ioctl[SIOCDEVPRIVATE] error");
1323 ret = -1;
1324 }
1325 rtw_free(para);
1326
1327 return ret;
1328 }
1329
wext_update_custom_ie(const char * ifname,void * cus_ie,int ie_index)1330 int wext_update_custom_ie(const char *ifname, void * cus_ie, int ie_index)
1331 {
1332 struct iwreq iwr;
1333 int ret = 0;
1334 __u8 *para = NULL;
1335 int cmd_len = 0;
1336 if(ie_index <= 0 || !cus_ie){
1337 RTW_API_INFO("\n\rwext_update_custom_ie():wrong parameter");
1338 ret = -1;
1339 return ret;
1340 }
1341 memset(&iwr, 0, sizeof(iwr));
1342 cmd_len = sizeof("UpdateIE");
1343 para = rtw_malloc((4)* 2 + cmd_len);//size:addr len+cmd_len
1344 if(para == NULL) return -1;
1345
1346 //Cmd
1347 snprintf((char*)para, cmd_len, "UpdateIE");
1348 //addr length
1349 *(__u32 *)(para + cmd_len) = (__u32)cus_ie; //ie addr
1350 //ie_index
1351 *(__u32 *)(para + cmd_len + 4) = ie_index; //num of ie
1352
1353 iwr.u.data.pointer = para;
1354 iwr.u.data.length = (4)* 2 + cmd_len;// 2 input
1355 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
1356 RTW_API_INFO("\n\rwext_update_custom_ie():ioctl[SIOCDEVPRIVATE] error");
1357 ret = -1;
1358 }
1359 rtw_free(para);
1360
1361 return ret;
1362
1363 }
1364
wext_del_custom_ie(const char * ifname)1365 int wext_del_custom_ie(const char *ifname)
1366 {
1367 struct iwreq iwr;
1368 int ret = 0;
1369 __u8 *para = NULL;
1370 int cmd_len = 0;
1371
1372 memset(&iwr, 0, sizeof(iwr));
1373 cmd_len = sizeof("DelIE");
1374 para = rtw_malloc(cmd_len);//size:addr len+cmd_len
1375 //Cmd
1376 snprintf((char*)para, cmd_len, "DelIE");
1377
1378 iwr.u.data.pointer = para;
1379 iwr.u.data.length = cmd_len;
1380 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
1381 RTW_API_INFO("\n\rwext_del_custom_ie():ioctl[SIOCDEVPRIVATE] error");
1382 ret = -1;
1383 }
1384 rtw_free(para);
1385
1386 return ret;
1387
1388
1389 }
1390
1391 #endif
1392
1393 #ifdef CONFIG_AP_MODE
wext_enable_forwarding(const char * ifname)1394 int wext_enable_forwarding(const char *ifname)
1395 {
1396 struct iwreq iwr;
1397 int ret = 0;
1398 __u8 *para = NULL;
1399 int cmd_len = 0;
1400
1401 memset(&iwr, 0, sizeof(iwr));
1402 cmd_len = sizeof("forwarding_set");
1403 para = rtw_malloc(cmd_len + 1);
1404 if(para == NULL) return -1;
1405
1406 // forwarding_set 1
1407 snprintf((char *) para, cmd_len, "forwarding_set");
1408 *(para + cmd_len) = '1';
1409
1410 iwr.u.essid.pointer = para;
1411 iwr.u.essid.length = cmd_len + 1;
1412
1413 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
1414 RTW_API_INFO("\n\rwext_enable_forwarding(): ioctl[SIOCDEVPRIVATE] error");
1415 ret = -1;
1416 }
1417
1418 rtw_free(para);
1419 return ret;
1420 }
1421
wext_disable_forwarding(const char * ifname)1422 int wext_disable_forwarding(const char *ifname)
1423 {
1424 struct iwreq iwr;
1425 int ret = 0;
1426 __u8 *para = NULL;
1427 int cmd_len = 0;
1428
1429 memset(&iwr, 0, sizeof(iwr));
1430 cmd_len = sizeof("forwarding_set");
1431 para = rtw_malloc(cmd_len + 1);
1432 if(para == NULL) return -1;
1433
1434 // forwarding_set 0
1435 snprintf((char *) para, cmd_len, "forwarding_set");
1436 *(para + cmd_len) = '0';
1437
1438 iwr.u.essid.pointer = para;
1439 iwr.u.essid.length = cmd_len + 1;
1440
1441 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
1442 RTW_API_INFO("\n\rwext_disable_forwarding(): ioctl[SIOCDEVPRIVATE] error");
1443 ret = -1;
1444 }
1445
1446 rtw_free(para);
1447 return ret;
1448
1449 }
1450 #endif
1451
1452 #ifdef CONFIG_CONCURRENT_MODE
wext_set_ch_deauth(const char * ifname,__u8 enable)1453 int wext_set_ch_deauth(const char *ifname, __u8 enable)
1454 {
1455 int ret = 0;
1456 char * buf = (char *)rtw_zmalloc(16);
1457 if(buf == NULL) return -1;
1458
1459 snprintf(buf, 16, "SetChDeauth %d", enable);
1460 ret = wext_private_command(ifname, buf, 0);
1461
1462 rtw_free(buf);
1463 return ret;
1464 }
1465 #endif
1466
wext_set_adaptivity(rtw_adaptivity_mode_t adaptivity_mode)1467 int wext_set_adaptivity(rtw_adaptivity_mode_t adaptivity_mode)
1468 {
1469 extern u8 rtw_adaptivity_en;
1470 extern u8 rtw_adaptivity_mode;
1471
1472 switch(adaptivity_mode){
1473 case RTW_ADAPTIVITY_NORMAL:
1474 rtw_adaptivity_en = 1; // enable adaptivity
1475 rtw_adaptivity_mode = RTW_ADAPTIVITY_MODE_NORMAL;
1476 break;
1477 case RTW_ADAPTIVITY_CARRIER_SENSE:
1478 rtw_adaptivity_en = 1; // enable adaptivity
1479 rtw_adaptivity_mode = RTW_ADAPTIVITY_MODE_CARRIER_SENSE;
1480 break;
1481 case RTW_ADAPTIVITY_DISABLE:
1482 default:
1483 rtw_adaptivity_en = 0; //disable adaptivity
1484 break;
1485 }
1486 return 0;
1487 }
1488
wext_set_trp_tis(__u8 enable)1489 int wext_set_trp_tis(__u8 enable)
1490 {
1491 extern u8 rtw_tx_pwr_lmt_enable;
1492 extern u8 rtw_tx_pwr_by_rate;
1493 extern u8 rtw_trp_tis_cert_en;
1494 #ifdef CONFIG_POWER_SAVING
1495 extern u8 rtw_powersave_en;
1496 #endif
1497
1498 if(enable != RTW_TRP_TIS_DISABLE){
1499 //close the tx power limit and pwr by rate incase the efficiency of Antenna is not good enough.
1500 rtw_tx_pwr_lmt_enable = 2;//set 0 to disable, set 2 to use efuse value
1501 rtw_tx_pwr_by_rate = 2;//set 0 to disable, set 2 to use efuse value
1502 //disable power save.
1503 #ifdef CONFIG_POWER_SAVING
1504 rtw_powersave_en = 0;
1505 #endif
1506 if(enable == RTW_TRP_TIS_NORMAL){
1507 //disable some dynamic mechanism
1508 rtw_trp_tis_cert_en = BIT0;
1509 }else if(enable == RTW_TRP_TIS_DYNAMIC){
1510 rtw_trp_tis_cert_en = BIT1 | BIT0;
1511 }else if(enable == RTW_TRP_TIS_FIX_ACK_RATE){
1512 rtw_trp_tis_cert_en = BIT2 | BIT0;
1513 }
1514 //you can change autoreconnct mode to RTW_AUTORECONNECT_INFINITE in init_thread function
1515 }
1516 return 0;
1517 }
1518
wext_set_anti_interference(__u8 enable)1519 int wext_set_anti_interference(__u8 enable)
1520 {
1521 extern u8 rtw_anti_interference_en;
1522
1523 if(enable == ENABLE){
1524 rtw_anti_interference_en = 1;
1525 }else{
1526 rtw_anti_interference_en = 0;
1527 }
1528
1529 return 0;
1530 }
1531
wext_set_ant_div_gpio(__u8 type)1532 int wext_set_ant_div_gpio(__u8 type)
1533 {
1534 extern u8 rtw_ant_div_gpio_ext;
1535
1536 rtw_ant_div_gpio_ext = type;
1537
1538 return 0;
1539 }
1540
1541
wext_set_adaptivity_th_l2h_ini(__u8 l2h_threshold)1542 int wext_set_adaptivity_th_l2h_ini(__u8 l2h_threshold)
1543 {
1544 extern s8 rtw_adaptivity_th_l2h_ini;
1545 rtw_adaptivity_th_l2h_ini = (__s8)l2h_threshold;
1546 return 0;
1547 }
1548
wext_set_bw40_enable(__u8 enable)1549 int wext_set_bw40_enable(__u8 enable)
1550 {
1551 extern u8 rtw_cbw40_enable;
1552 /* 0: 20 MHz, 1: 40 MHz, 2: 80 MHz, 3: 160MHz, 4: 80+80MHz
1553 * 2.4G use bit 0 ~ 3, 5G use bit 4 ~ 7
1554 * 0x21 means enable 2.4G 40MHz & 5G 80MHz */
1555 extern u8 rtw_bw_mode;
1556 if(enable == ENABLE){
1557 rtw_cbw40_enable = 1;
1558 rtw_bw_mode = 0x11;
1559 }else{
1560 rtw_cbw40_enable = 0;
1561 rtw_bw_mode = 0;
1562 }
1563
1564 return 0;
1565 }
1566
1567 extern int rltk_get_auto_chl(const char *ifname, unsigned char *channel_set, unsigned char channel_num);
wext_get_auto_chl(const char * ifname,unsigned char * channel_set,unsigned char channel_num)1568 int wext_get_auto_chl(const char *ifname, unsigned char *channel_set, unsigned char channel_num)
1569 {
1570 int ret = -1;
1571 int channel = 0;
1572 wext_disable_powersave(ifname);
1573 if((channel = rltk_get_auto_chl(ifname,channel_set,channel_num)) != 0 )
1574 ret = channel ;
1575 wext_enable_powersave(ifname, 1, 1);
1576 return ret;
1577 }
1578
1579 extern int rltk_set_sta_num(unsigned char ap_sta_num);
wext_set_sta_num(unsigned char ap_sta_num)1580 int wext_set_sta_num(unsigned char ap_sta_num)
1581 {
1582 return rltk_set_sta_num(ap_sta_num);
1583 }
1584
1585 extern int rltk_del_station(const char *ifname, unsigned char* hwaddr);
wext_del_station(const char * ifname,unsigned char * hwaddr)1586 int wext_del_station(const char *ifname, unsigned char* hwaddr)
1587 {
1588 return rltk_del_station(ifname, hwaddr);
1589 }
1590
1591 extern struct list_head *mf_list_head;
wext_init_mac_filter(void)1592 int wext_init_mac_filter(void)
1593 {
1594 if(mf_list_head != NULL){
1595 return -1;
1596 }
1597
1598 mf_list_head = (struct list_head *)malloc(sizeof(struct list_head));
1599 if(mf_list_head == NULL){
1600 RTW_API_INFO("\n\r[ERROR] %s : can't allocate mf_list_head",__func__);
1601 return -1;
1602 }
1603
1604 INIT_LIST_HEAD(mf_list_head);
1605
1606 return 0;
1607 }
1608
wext_deinit_mac_filter(void)1609 int wext_deinit_mac_filter(void)
1610 {
1611 if(mf_list_head == NULL){
1612 return -1;
1613 }
1614 struct list_head *iterator;
1615 rtw_mac_filter_list_t *item;
1616 list_for_each(iterator, mf_list_head) {
1617 item = list_entry(iterator, rtw_mac_filter_list_t, node);
1618 list_del(iterator);
1619 free(item);
1620 item = NULL;
1621 iterator = mf_list_head;
1622 }
1623
1624 free(mf_list_head);
1625 mf_list_head = NULL;
1626 return 0;
1627 }
1628
wext_add_mac_filter(unsigned char * hwaddr)1629 int wext_add_mac_filter(unsigned char* hwaddr)
1630 {
1631 if(mf_list_head == NULL){
1632 return -1;
1633 }
1634
1635 rtw_mac_filter_list_t *mf_list_new;
1636 mf_list_new =(rtw_mac_filter_list_t *) malloc(sizeof(rtw_mac_filter_list_t));
1637 if(mf_list_new == NULL){
1638 RTW_API_INFO("\n\r[ERROR] %s : can't allocate mf_list_new",__func__);
1639 return -1;
1640 }
1641 memcpy(mf_list_new->mac_addr,hwaddr,6);
1642 list_add(&(mf_list_new->node), mf_list_head);
1643
1644 return 0;
1645 }
1646
wext_del_mac_filter(unsigned char * hwaddr)1647 int wext_del_mac_filter(unsigned char* hwaddr)
1648 {
1649 if(mf_list_head == NULL){
1650 return -1;
1651 }
1652
1653 struct list_head *iterator;
1654 rtw_mac_filter_list_t *item;
1655 list_for_each(iterator, mf_list_head) {
1656 item = list_entry(iterator, rtw_mac_filter_list_t, node);
1657 if(memcmp(item->mac_addr,hwaddr,6) == 0){
1658 list_del(iterator);
1659 free(item);
1660 item = NULL;
1661 return 0;
1662 }
1663 }
1664 return -1;
1665 }
1666
1667 extern void rtw_set_indicate_mgnt(int enable);
wext_set_indicate_mgnt(int enable)1668 void wext_set_indicate_mgnt(int enable)
1669 {
1670 rtw_set_indicate_mgnt(enable);
1671 return;
1672 }
1673
1674 #ifdef CONFIG_AP_MODE
1675 extern void rltk_suspend_softap(const char *ifname);
1676 extern void rltk_suspend_softap_beacon(const char *ifname);
1677 extern int rtw_ap_switch_chl_and_inform(unsigned char new_channel);
wext_suspend_softap(const char * ifname)1678 void wext_suspend_softap(const char *ifname)
1679 {
1680 rltk_suspend_softap(ifname);
1681 }
1682
wext_suspend_softap_beacon(const char * ifname)1683 void wext_suspend_softap_beacon(const char *ifname)
1684 {
1685 rltk_suspend_softap_beacon(ifname);
1686 }
wext_ap_switch_chl_and_inform(unsigned char new_channel)1687 int wext_ap_switch_chl_and_inform(unsigned char new_channel)
1688 {
1689 if(rtw_ap_switch_chl_and_inform(new_channel))
1690 return RTW_SUCCESS;
1691 else
1692 return RTW_ERROR;
1693 }
1694 #endif
1695
1696 #ifdef CONFIG_SW_MAILBOX_EN
wext_mailbox_to_wifi(const char * ifname,char * buf,__u16 buf_len)1697 int wext_mailbox_to_wifi(const char *ifname, char *buf, __u16 buf_len)
1698 {
1699 struct iwreq iwr;
1700 int ret = 0;
1701
1702 memset(&iwr, 0, sizeof(iwr));
1703
1704 iwr.u.data.pointer = buf;
1705 iwr.u.data.length = buf_len;
1706 if (iw_ioctl(ifname, SIOCSIMAILBOX, &iwr) < 0) {
1707 RTW_API_INFO("\n\rioctl[SIOCSIMAILBOX] error");
1708 ret = -1;
1709 }
1710 return ret;
1711 }
1712 #endif
1713
1714 #ifdef CONFIG_WOWLAN
wext_wowlan_ctrl(const char * ifname,int enable)1715 int wext_wowlan_ctrl(const char *ifname, int enable){
1716 struct iwreq iwr;
1717 int ret = 0;
1718 __u16 pindex = 0;
1719 __u8 *para = NULL;
1720 int cmd_len = 0;
1721
1722 printf("wext_wowlan_ctrl: enable=%d\n\r", enable);
1723 memset(&iwr, 0, sizeof(iwr));
1724 cmd_len = sizeof("wowlan_ctrl");
1725
1726 // Encode parameters as TLV (type, length, value) format
1727 para = rtw_malloc( cmd_len + (1+1+1) );
1728
1729 snprintf((char*)para, cmd_len, "wowlan_ctrl");
1730 pindex = cmd_len;
1731
1732 para[pindex++] = 0; // type 0 wowlan enable disable
1733 para[pindex++] = 1;
1734 para[pindex++] = enable;
1735
1736 iwr.u.data.pointer = para;
1737 iwr.u.data.length = pindex;
1738
1739 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
1740 RTW_API_INFO("\n\rioctl[SIOCSIWPRIVWWCTL] error");
1741 ret = -1;
1742 }
1743
1744 rtw_free(para);
1745
1746 return ret;
1747 }
1748
wext_wowlan_set_pattern(const char * ifname,wowlan_pattern_t pattern)1749 int wext_wowlan_set_pattern(const char *ifname, wowlan_pattern_t pattern)
1750 {
1751 struct iwreq iwr;
1752 int ret = 0;
1753 __u16 pindex = 0;
1754 __u8 *para = NULL;
1755 int cmd_len = 0;
1756
1757 memset(&iwr, 0, sizeof(iwr));
1758 cmd_len = sizeof("wowlan_ctrl");
1759
1760 para = rtw_malloc( cmd_len + (1+1+1) + sizeof(pattern));
1761 snprintf((char*)para, cmd_len, "wowlan_ctrl");
1762 pindex = cmd_len;
1763
1764 para[pindex++] = 1; // type 1 wowlan set pattern
1765 para[pindex++] = 2;
1766 para[pindex++] = sizeof(pattern);
1767 memcpy(&(para[pindex]), &pattern, sizeof(pattern));
1768
1769 iwr.u.data.pointer = para;
1770 iwr.u.data.length = pindex;
1771
1772 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
1773 RTW_API_INFO("\n\rioctl[SIOCDEVPRIVWWPTN] error");
1774 ret = -1;
1775 }
1776
1777 rtw_free(para);
1778
1779 return ret;
1780 }
1781
wext_wlan_redl_fw(const char * ifname)1782 int wext_wlan_redl_fw(const char *ifname){
1783 struct iwreq iwr;
1784 int ret = 0;
1785 __u16 pindex = 0;
1786 __u8 *para = NULL;
1787 int cmd_len = 0;
1788
1789 printf("+ wext_wlan_redl_fw\n\r");
1790 memset(&iwr, 0, sizeof(iwr));
1791 cmd_len = sizeof("wowlan_ctrl");
1792
1793 // Encode parameters as TLV (type, length, value) format
1794 para = rtw_malloc( cmd_len + (1+1) );
1795
1796 snprintf((char*)para, cmd_len, "wowlan_ctrl");
1797 pindex = cmd_len;
1798
1799 para[pindex++] = 2; // type 2 redownload fw
1800 para[pindex++] = 0;
1801
1802 iwr.u.data.pointer = para;
1803 iwr.u.data.length = pindex;
1804
1805 if (iw_ioctl(ifname, SIOCDEVPRIVATE, &iwr) < 0) {
1806 RTW_API_INFO("\n\rioctl[SIOCSIWPRIVREDLFW] error");
1807 ret = -1;
1808 }
1809
1810 rtw_free(para);
1811
1812 return ret;
1813 }
1814 #endif
1815
1816 #ifdef CONFIG_POWER_SAVING
1817 extern u8 rtw_power_mgnt;
wext_set_powersave_mode(__u8 ps_mode)1818 void wext_set_powersave_mode(__u8 ps_mode){
1819
1820 if((ps_mode!=1)&&(ps_mode!=2)){
1821 printf("\n\rSet powersave mode fail! Wrong powersave mode value, input value can only be 1(min mode) or 2(max mode)");
1822 return;
1823 }
1824 rtw_power_mgnt = ps_mode;
1825 return;
1826 }
1827
wext_get_powersave_mode(__u8 * ps_mode)1828 void wext_get_powersave_mode(__u8 *ps_mode){
1829
1830 *ps_mode = rtw_power_mgnt;
1831 return;
1832 }
1833 #endif
1834
1835