]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/net/wireless/libertas/wext.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[mirror_ubuntu-bionic-kernel.git] / drivers / net / wireless / libertas / wext.c
1 /**
2 * This file contains ioctl functions
3 */
4 #include <linux/ctype.h>
5 #include <linux/delay.h>
6 #include <linux/if.h>
7 #include <linux/if_arp.h>
8 #include <linux/wireless.h>
9 #include <linux/bitops.h>
10
11 #include <net/ieee80211.h>
12 #include <net/iw_handler.h>
13
14 #include "host.h"
15 #include "radiotap.h"
16 #include "decl.h"
17 #include "defs.h"
18 #include "dev.h"
19 #include "join.h"
20 #include "wext.h"
21 #include "assoc.h"
22
23
24 /**
25 * @brief Convert mw value to dbm value
26 *
27 * @param mw the value of mw
28 * @return the value of dbm
29 */
30 static int mw_to_dbm(int mw)
31 {
32 if (mw < 2)
33 return 0;
34 else if (mw < 3)
35 return 3;
36 else if (mw < 4)
37 return 5;
38 else if (mw < 6)
39 return 7;
40 else if (mw < 7)
41 return 8;
42 else if (mw < 8)
43 return 9;
44 else if (mw < 10)
45 return 10;
46 else if (mw < 13)
47 return 11;
48 else if (mw < 16)
49 return 12;
50 else if (mw < 20)
51 return 13;
52 else if (mw < 25)
53 return 14;
54 else if (mw < 32)
55 return 15;
56 else if (mw < 40)
57 return 16;
58 else if (mw < 50)
59 return 17;
60 else if (mw < 63)
61 return 18;
62 else if (mw < 79)
63 return 19;
64 else if (mw < 100)
65 return 20;
66 else
67 return 21;
68 }
69
70 /**
71 * @brief Find the channel frequency power info with specific channel
72 *
73 * @param adapter A pointer to wlan_adapter structure
74 * @param band it can be BAND_A, BAND_G or BAND_B
75 * @param channel the channel for looking
76 * @return A pointer to struct chan_freq_power structure or NULL if not find.
77 */
78 struct chan_freq_power *libertas_find_cfp_by_band_and_channel(wlan_adapter * adapter,
79 u8 band, u16 channel)
80 {
81 struct chan_freq_power *cfp = NULL;
82 struct region_channel *rc;
83 int count = sizeof(adapter->region_channel) /
84 sizeof(adapter->region_channel[0]);
85 int i, j;
86
87 for (j = 0; !cfp && (j < count); j++) {
88 rc = &adapter->region_channel[j];
89
90 if (adapter->enable11d)
91 rc = &adapter->universal_channel[j];
92 if (!rc->valid || !rc->CFP)
93 continue;
94 if (rc->band != band)
95 continue;
96 for (i = 0; i < rc->nrcfp; i++) {
97 if (rc->CFP[i].channel == channel) {
98 cfp = &rc->CFP[i];
99 break;
100 }
101 }
102 }
103
104 if (!cfp && channel)
105 lbs_pr_debug(1, "libertas_find_cfp_by_band_and_channel(): cannot find "
106 "cfp by band %d & channel %d\n", band, channel);
107
108 return cfp;
109 }
110
111 /**
112 * @brief Find the channel frequency power info with specific frequency
113 *
114 * @param adapter A pointer to wlan_adapter structure
115 * @param band it can be BAND_A, BAND_G or BAND_B
116 * @param freq the frequency for looking
117 * @return A pointer to struct chan_freq_power structure or NULL if not find.
118 */
119 static struct chan_freq_power *find_cfp_by_band_and_freq(wlan_adapter * adapter,
120 u8 band, u32 freq)
121 {
122 struct chan_freq_power *cfp = NULL;
123 struct region_channel *rc;
124 int count = sizeof(adapter->region_channel) /
125 sizeof(adapter->region_channel[0]);
126 int i, j;
127
128 for (j = 0; !cfp && (j < count); j++) {
129 rc = &adapter->region_channel[j];
130
131 if (adapter->enable11d)
132 rc = &adapter->universal_channel[j];
133 if (!rc->valid || !rc->CFP)
134 continue;
135 if (rc->band != band)
136 continue;
137 for (i = 0; i < rc->nrcfp; i++) {
138 if (rc->CFP[i].freq == freq) {
139 cfp = &rc->CFP[i];
140 break;
141 }
142 }
143 }
144
145 if (!cfp && freq)
146 lbs_pr_debug(1, "find_cfp_by_band_and_freql(): cannot find cfp by "
147 "band %d & freq %d\n", band, freq);
148
149 return cfp;
150 }
151
152 static int updatecurrentchannel(wlan_private * priv)
153 {
154 int ret;
155
156 /*
157 ** the channel in f/w could be out of sync, get the current channel
158 */
159 ret = libertas_prepare_and_send_command(priv, cmd_802_11_rf_channel,
160 cmd_opt_802_11_rf_channel_get,
161 cmd_option_waitforrsp, 0, NULL);
162
163 lbs_pr_debug(1, "Current channel = %d\n",
164 priv->adapter->curbssparams.channel);
165
166 return ret;
167 }
168
169 static int setcurrentchannel(wlan_private * priv, int channel)
170 {
171 lbs_pr_debug(1, "Set channel = %d\n", channel);
172
173 /*
174 ** Current channel is not set to adhocchannel requested, set channel
175 */
176 return (libertas_prepare_and_send_command(priv, cmd_802_11_rf_channel,
177 cmd_opt_802_11_rf_channel_set,
178 cmd_option_waitforrsp, 0, &channel));
179 }
180
181 static int changeadhocchannel(wlan_private * priv, int channel)
182 {
183 int ret = 0;
184 wlan_adapter *adapter = priv->adapter;
185
186 adapter->adhocchannel = channel;
187
188 updatecurrentchannel(priv);
189
190 if (adapter->curbssparams.channel == adapter->adhocchannel) {
191 /* adhocchannel is set to the current channel already */
192 LEAVE();
193 return 0;
194 }
195
196 lbs_pr_debug(1, "Updating channel from %d to %d\n",
197 adapter->curbssparams.channel, adapter->adhocchannel);
198
199 setcurrentchannel(priv, adapter->adhocchannel);
200
201 updatecurrentchannel(priv);
202
203 if (adapter->curbssparams.channel != adapter->adhocchannel) {
204 lbs_pr_debug(1, "failed to updated channel to %d, channel = %d\n",
205 adapter->adhocchannel, adapter->curbssparams.channel);
206 LEAVE();
207 return -1;
208 }
209
210 if (adapter->connect_status == libertas_connected) {
211 int i;
212 struct WLAN_802_11_SSID curadhocssid;
213
214 lbs_pr_debug(1, "channel Changed while in an IBSS\n");
215
216 /* Copy the current ssid */
217 memcpy(&curadhocssid, &adapter->curbssparams.ssid,
218 sizeof(struct WLAN_802_11_SSID));
219
220 /* Exit Adhoc mode */
221 lbs_pr_debug(1, "In changeadhocchannel(): Sending Adhoc Stop\n");
222 ret = libertas_stop_adhoc_network(priv);
223
224 if (ret) {
225 LEAVE();
226 return ret;
227 }
228 /* Scan for the network, do not save previous results. Stale
229 * scan data will cause us to join a non-existant adhoc network
230 */
231 libertas_send_specific_SSID_scan(priv, &curadhocssid, 0);
232
233 // find out the BSSID that matches the current SSID
234 i = libertas_find_SSID_in_list(adapter, &curadhocssid, NULL,
235 IW_MODE_ADHOC);
236
237 if (i >= 0) {
238 lbs_pr_debug(1, "SSID found at %d in List,"
239 "so join\n", i);
240 libertas_join_adhoc_network(priv, &adapter->scantable[i]);
241 } else {
242 // else send START command
243 lbs_pr_debug(1, "SSID not found in list, "
244 "so creating adhoc with ssid = %s\n",
245 curadhocssid.ssid);
246 libertas_start_adhoc_network(priv, &curadhocssid);
247 } // end of else (START command)
248 }
249
250 LEAVE();
251 return 0;
252 }
253
254 /**
255 * @brief Set Radio On/OFF
256 *
257 * @param priv A pointer to wlan_private structure
258 * @option Radio Option
259 * @return 0 --success, otherwise fail
260 */
261 int wlan_radio_ioctl(wlan_private * priv, u8 option)
262 {
263 int ret = 0;
264 wlan_adapter *adapter = priv->adapter;
265
266 ENTER();
267
268 if (adapter->radioon != option) {
269 lbs_pr_debug(1, "Switching %s the Radio\n", option ? "On" : "Off");
270 adapter->radioon = option;
271
272 ret = libertas_prepare_and_send_command(priv,
273 cmd_802_11_radio_control,
274 cmd_act_set,
275 cmd_option_waitforrsp, 0, NULL);
276 }
277
278 LEAVE();
279 return ret;
280 }
281
282 /**
283 * @brief Copy rates
284 *
285 * @param dest A pointer to Dest Buf
286 * @param src A pointer to Src Buf
287 * @param len The len of Src Buf
288 * @return Number of rates copyed
289 */
290 static inline int copyrates(u8 * dest, int pos, u8 * src, int len)
291 {
292 int i;
293
294 for (i = 0; i < len && src[i]; i++, pos++) {
295 if (pos >= sizeof(u8) * WLAN_SUPPORTED_RATES)
296 break;
297 dest[pos] = src[i];
298 }
299
300 return pos;
301 }
302
303 /**
304 * @brief Get active data rates
305 *
306 * @param adapter A pointer to wlan_adapter structure
307 * @param rate The buf to return the active rates
308 * @return The number of rates
309 */
310 static int get_active_data_rates(wlan_adapter * adapter,
311 u8* rates)
312 {
313 int k = 0;
314
315 ENTER();
316
317 if (adapter->connect_status != libertas_connected) {
318 if (adapter->mode == IW_MODE_INFRA) {
319 lbs_pr_debug(1, "Infra\n");
320 k = copyrates(rates, k, libertas_supported_rates,
321 sizeof(libertas_supported_rates));
322 } else {
323 lbs_pr_debug(1, "Adhoc G\n");
324 k = copyrates(rates, k, libertas_adhoc_rates_g,
325 sizeof(libertas_adhoc_rates_g));
326 }
327 } else {
328 k = copyrates(rates, 0, adapter->curbssparams.datarates,
329 adapter->curbssparams.numofrates);
330 }
331
332 LEAVE();
333
334 return k;
335 }
336
337 static int wlan_get_name(struct net_device *dev, struct iw_request_info *info,
338 char *cwrq, char *extra)
339 {
340 const char *cp;
341 char comm[6] = { "COMM-" };
342 char mrvl[6] = { "MRVL-" };
343 int cnt;
344
345 ENTER();
346
347 strcpy(cwrq, mrvl);
348
349 cp = strstr(libertas_driver_version, comm);
350 if (cp == libertas_driver_version) //skip leading "COMM-"
351 cp = libertas_driver_version + strlen(comm);
352 else
353 cp = libertas_driver_version;
354
355 cnt = strlen(mrvl);
356 cwrq += cnt;
357 while (cnt < 16 && (*cp != '-')) {
358 *cwrq++ = toupper(*cp++);
359 cnt++;
360 }
361 *cwrq = '\0';
362
363 LEAVE();
364
365 return 0;
366 }
367
368 static int wlan_get_freq(struct net_device *dev, struct iw_request_info *info,
369 struct iw_freq *fwrq, char *extra)
370 {
371 wlan_private *priv = dev->priv;
372 wlan_adapter *adapter = priv->adapter;
373 struct chan_freq_power *cfp;
374
375 ENTER();
376
377 cfp = libertas_find_cfp_by_band_and_channel(adapter, 0,
378 adapter->curbssparams.channel);
379
380 if (!cfp) {
381 if (adapter->curbssparams.channel)
382 lbs_pr_debug(1, "Invalid channel=%d\n",
383 adapter->curbssparams.channel);
384 return -EINVAL;
385 }
386
387 fwrq->m = (long)cfp->freq * 100000;
388 fwrq->e = 1;
389
390 lbs_pr_debug(1, "freq=%u\n", fwrq->m);
391
392 LEAVE();
393 return 0;
394 }
395
396 static int wlan_get_wap(struct net_device *dev, struct iw_request_info *info,
397 struct sockaddr *awrq, char *extra)
398 {
399 wlan_private *priv = dev->priv;
400 wlan_adapter *adapter = priv->adapter;
401
402 ENTER();
403
404 if (adapter->connect_status == libertas_connected) {
405 memcpy(awrq->sa_data, adapter->curbssparams.bssid, ETH_ALEN);
406 } else {
407 memset(awrq->sa_data, 0, ETH_ALEN);
408 }
409 awrq->sa_family = ARPHRD_ETHER;
410
411 LEAVE();
412 return 0;
413 }
414
415 static int wlan_set_nick(struct net_device *dev, struct iw_request_info *info,
416 struct iw_point *dwrq, char *extra)
417 {
418 wlan_private *priv = dev->priv;
419 wlan_adapter *adapter = priv->adapter;
420
421 ENTER();
422
423 /*
424 * Check the size of the string
425 */
426
427 if (dwrq->length > 16) {
428 return -E2BIG;
429 }
430
431 mutex_lock(&adapter->lock);
432 memset(adapter->nodename, 0, sizeof(adapter->nodename));
433 memcpy(adapter->nodename, extra, dwrq->length);
434 mutex_unlock(&adapter->lock);
435
436 LEAVE();
437 return 0;
438 }
439
440 static int wlan_get_nick(struct net_device *dev, struct iw_request_info *info,
441 struct iw_point *dwrq, char *extra)
442 {
443 wlan_private *priv = dev->priv;
444 wlan_adapter *adapter = priv->adapter;
445
446 ENTER();
447
448 /*
449 * Get the Nick Name saved
450 */
451
452 mutex_lock(&adapter->lock);
453 strncpy(extra, adapter->nodename, 16);
454 mutex_unlock(&adapter->lock);
455
456 extra[16] = '\0';
457
458 /*
459 * If none, we may want to get the one that was set
460 */
461
462 /*
463 * Push it out !
464 */
465 dwrq->length = strlen(extra) + 1;
466
467 LEAVE();
468 return 0;
469 }
470
471 static int wlan_set_rts(struct net_device *dev, struct iw_request_info *info,
472 struct iw_param *vwrq, char *extra)
473 {
474 int ret = 0;
475 wlan_private *priv = dev->priv;
476 wlan_adapter *adapter = priv->adapter;
477 int rthr = vwrq->value;
478
479 ENTER();
480
481 if (vwrq->disabled) {
482 adapter->rtsthsd = rthr = MRVDRV_RTS_MAX_VALUE;
483 } else {
484 if (rthr < MRVDRV_RTS_MIN_VALUE || rthr > MRVDRV_RTS_MAX_VALUE)
485 return -EINVAL;
486 adapter->rtsthsd = rthr;
487 }
488
489 ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib,
490 cmd_act_set, cmd_option_waitforrsp,
491 OID_802_11_RTS_THRESHOLD, &rthr);
492
493 LEAVE();
494 return ret;
495 }
496
497 static int wlan_get_rts(struct net_device *dev, struct iw_request_info *info,
498 struct iw_param *vwrq, char *extra)
499 {
500 int ret = 0;
501 wlan_private *priv = dev->priv;
502 wlan_adapter *adapter = priv->adapter;
503
504 ENTER();
505
506 adapter->rtsthsd = 0;
507 ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib,
508 cmd_act_get, cmd_option_waitforrsp,
509 OID_802_11_RTS_THRESHOLD, NULL);
510 if (ret) {
511 LEAVE();
512 return ret;
513 }
514
515 vwrq->value = adapter->rtsthsd;
516 vwrq->disabled = ((vwrq->value < MRVDRV_RTS_MIN_VALUE)
517 || (vwrq->value > MRVDRV_RTS_MAX_VALUE));
518 vwrq->fixed = 1;
519
520 LEAVE();
521 return 0;
522 }
523
524 static int wlan_set_frag(struct net_device *dev, struct iw_request_info *info,
525 struct iw_param *vwrq, char *extra)
526 {
527 int ret = 0;
528 int fthr = vwrq->value;
529 wlan_private *priv = dev->priv;
530 wlan_adapter *adapter = priv->adapter;
531
532 ENTER();
533
534 if (vwrq->disabled) {
535 adapter->fragthsd = fthr = MRVDRV_FRAG_MAX_VALUE;
536 } else {
537 if (fthr < MRVDRV_FRAG_MIN_VALUE
538 || fthr > MRVDRV_FRAG_MAX_VALUE)
539 return -EINVAL;
540 adapter->fragthsd = fthr;
541 }
542
543 ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib,
544 cmd_act_set, cmd_option_waitforrsp,
545 OID_802_11_FRAGMENTATION_THRESHOLD, &fthr);
546 LEAVE();
547 return ret;
548 }
549
550 static int wlan_get_frag(struct net_device *dev, struct iw_request_info *info,
551 struct iw_param *vwrq, char *extra)
552 {
553 int ret = 0;
554 wlan_private *priv = dev->priv;
555 wlan_adapter *adapter = priv->adapter;
556
557 ENTER();
558
559 adapter->fragthsd = 0;
560 ret = libertas_prepare_and_send_command(priv,
561 cmd_802_11_snmp_mib,
562 cmd_act_get, cmd_option_waitforrsp,
563 OID_802_11_FRAGMENTATION_THRESHOLD, NULL);
564 if (ret) {
565 LEAVE();
566 return ret;
567 }
568
569 vwrq->value = adapter->fragthsd;
570 vwrq->disabled = ((vwrq->value < MRVDRV_FRAG_MIN_VALUE)
571 || (vwrq->value > MRVDRV_FRAG_MAX_VALUE));
572 vwrq->fixed = 1;
573
574 LEAVE();
575 return ret;
576 }
577
578 static int wlan_get_mode(struct net_device *dev,
579 struct iw_request_info *info, u32 * uwrq, char *extra)
580 {
581 wlan_private *priv = dev->priv;
582 wlan_adapter *adapter = priv->adapter;
583
584 ENTER();
585
586 *uwrq = adapter->mode;
587
588 LEAVE();
589 return 0;
590 }
591
592 static int wlan_get_txpow(struct net_device *dev,
593 struct iw_request_info *info,
594 struct iw_param *vwrq, char *extra)
595 {
596 int ret = 0;
597 wlan_private *priv = dev->priv;
598 wlan_adapter *adapter = priv->adapter;
599
600 ENTER();
601
602 ret = libertas_prepare_and_send_command(priv,
603 cmd_802_11_rf_tx_power,
604 cmd_act_tx_power_opt_get,
605 cmd_option_waitforrsp, 0, NULL);
606
607 if (ret) {
608 LEAVE();
609 return ret;
610 }
611
612 lbs_pr_debug(1, "TXPOWER GET %d dbm.\n", adapter->txpowerlevel);
613 vwrq->value = adapter->txpowerlevel;
614 vwrq->fixed = 1;
615 if (adapter->radioon) {
616 vwrq->disabled = 0;
617 vwrq->flags = IW_TXPOW_DBM;
618 } else {
619 vwrq->disabled = 1;
620 }
621
622 LEAVE();
623 return 0;
624 }
625
626 static int wlan_set_retry(struct net_device *dev, struct iw_request_info *info,
627 struct iw_param *vwrq, char *extra)
628 {
629 int ret = 0;
630 wlan_private *priv = dev->priv;
631 wlan_adapter *adapter = priv->adapter;
632
633 ENTER();
634
635 if (vwrq->flags == IW_RETRY_LIMIT) {
636 /* The MAC has a 4-bit Total_Tx_Count register
637 Total_Tx_Count = 1 + Tx_Retry_Count */
638 #define TX_RETRY_MIN 0
639 #define TX_RETRY_MAX 14
640 if (vwrq->value < TX_RETRY_MIN || vwrq->value > TX_RETRY_MAX)
641 return -EINVAL;
642
643 /* Adding 1 to convert retry count to try count */
644 adapter->txretrycount = vwrq->value + 1;
645
646 ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib,
647 cmd_act_set,
648 cmd_option_waitforrsp,
649 OID_802_11_TX_RETRYCOUNT, NULL);
650
651 if (ret) {
652 LEAVE();
653 return ret;
654 }
655 } else {
656 return -EOPNOTSUPP;
657 }
658
659 LEAVE();
660 return 0;
661 }
662
663 static int wlan_get_retry(struct net_device *dev, struct iw_request_info *info,
664 struct iw_param *vwrq, char *extra)
665 {
666 wlan_private *priv = dev->priv;
667 wlan_adapter *adapter = priv->adapter;
668 int ret = 0;
669
670 ENTER();
671 adapter->txretrycount = 0;
672 ret = libertas_prepare_and_send_command(priv,
673 cmd_802_11_snmp_mib,
674 cmd_act_get, cmd_option_waitforrsp,
675 OID_802_11_TX_RETRYCOUNT, NULL);
676 if (ret) {
677 LEAVE();
678 return ret;
679 }
680 vwrq->disabled = 0;
681 if (!vwrq->flags) {
682 vwrq->flags = IW_RETRY_LIMIT;
683 /* Subtract 1 to convert try count to retry count */
684 vwrq->value = adapter->txretrycount - 1;
685 }
686
687 LEAVE();
688 return 0;
689 }
690
691 static inline void sort_channels(struct iw_freq *freq, int num)
692 {
693 int i, j;
694 struct iw_freq temp;
695
696 for (i = 0; i < num; i++)
697 for (j = i + 1; j < num; j++)
698 if (freq[i].i > freq[j].i) {
699 temp.i = freq[i].i;
700 temp.m = freq[i].m;
701
702 freq[i].i = freq[j].i;
703 freq[i].m = freq[j].m;
704
705 freq[j].i = temp.i;
706 freq[j].m = temp.m;
707 }
708 }
709
710 /* data rate listing
711 MULTI_BANDS:
712 abg a b b/g
713 Infra G(12) A(8) B(4) G(12)
714 Adhoc A+B(12) A(8) B(4) B(4)
715
716 non-MULTI_BANDS:
717 b b/g
718 Infra B(4) G(12)
719 Adhoc B(4) B(4)
720 */
721 /**
722 * @brief Get Range Info
723 *
724 * @param dev A pointer to net_device structure
725 * @param info A pointer to iw_request_info structure
726 * @param vwrq A pointer to iw_param structure
727 * @param extra A pointer to extra data buf
728 * @return 0 --success, otherwise fail
729 */
730 static int wlan_get_range(struct net_device *dev, struct iw_request_info *info,
731 struct iw_point *dwrq, char *extra)
732 {
733 int i, j;
734 wlan_private *priv = dev->priv;
735 wlan_adapter *adapter = priv->adapter;
736 struct iw_range *range = (struct iw_range *)extra;
737 struct chan_freq_power *cfp;
738 u8 rates[WLAN_SUPPORTED_RATES];
739
740 u8 flag = 0;
741
742 ENTER();
743
744 dwrq->length = sizeof(struct iw_range);
745 memset(range, 0, sizeof(struct iw_range));
746
747 range->min_nwid = 0;
748 range->max_nwid = 0;
749
750 memset(rates, 0, sizeof(rates));
751 range->num_bitrates = get_active_data_rates(adapter, rates);
752
753 for (i = 0; i < min_t(__u8, range->num_bitrates, IW_MAX_BITRATES) && rates[i];
754 i++) {
755 range->bitrate[i] = (rates[i] & 0x7f) * 500000;
756 }
757 range->num_bitrates = i;
758 lbs_pr_debug(1, "IW_MAX_BITRATES=%d num_bitrates=%d\n", IW_MAX_BITRATES,
759 range->num_bitrates);
760
761 range->num_frequency = 0;
762 if (priv->adapter->enable11d &&
763 adapter->connect_status == libertas_connected) {
764 u8 chan_no;
765 u8 band;
766
767 struct parsed_region_chan_11d *parsed_region_chan =
768 &adapter->parsed_region_chan;
769
770 if (parsed_region_chan == NULL) {
771 lbs_pr_debug(1, "11D:parsed_region_chan is NULL\n");
772 LEAVE();
773 return 0;
774 }
775 band = parsed_region_chan->band;
776 lbs_pr_debug(1, "band=%d NoOfChan=%d\n", band,
777 parsed_region_chan->nr_chan);
778
779 for (i = 0; (range->num_frequency < IW_MAX_FREQUENCIES)
780 && (i < parsed_region_chan->nr_chan); i++) {
781 chan_no = parsed_region_chan->chanpwr[i].chan;
782 lbs_pr_debug(1, "chan_no=%d\n", chan_no);
783 range->freq[range->num_frequency].i = (long)chan_no;
784 range->freq[range->num_frequency].m =
785 (long)libertas_chan_2_freq(chan_no, band) * 100000;
786 range->freq[range->num_frequency].e = 1;
787 range->num_frequency++;
788 }
789 flag = 1;
790 }
791 if (!flag) {
792 for (j = 0; (range->num_frequency < IW_MAX_FREQUENCIES)
793 && (j < sizeof(adapter->region_channel)
794 / sizeof(adapter->region_channel[0])); j++) {
795 cfp = adapter->region_channel[j].CFP;
796 for (i = 0; (range->num_frequency < IW_MAX_FREQUENCIES)
797 && adapter->region_channel[j].valid
798 && cfp
799 && (i < adapter->region_channel[j].nrcfp); i++) {
800 range->freq[range->num_frequency].i =
801 (long)cfp->channel;
802 range->freq[range->num_frequency].m =
803 (long)cfp->freq * 100000;
804 range->freq[range->num_frequency].e = 1;
805 cfp++;
806 range->num_frequency++;
807 }
808 }
809 }
810
811 lbs_pr_debug(1, "IW_MAX_FREQUENCIES=%d num_frequency=%d\n",
812 IW_MAX_FREQUENCIES, range->num_frequency);
813
814 range->num_channels = range->num_frequency;
815
816 sort_channels(&range->freq[0], range->num_frequency);
817
818 /*
819 * Set an indication of the max TCP throughput in bit/s that we can
820 * expect using this interface
821 */
822 if (i > 2)
823 range->throughput = 5000 * 1000;
824 else
825 range->throughput = 1500 * 1000;
826
827 range->min_rts = MRVDRV_RTS_MIN_VALUE;
828 range->max_rts = MRVDRV_RTS_MAX_VALUE;
829 range->min_frag = MRVDRV_FRAG_MIN_VALUE;
830 range->max_frag = MRVDRV_FRAG_MAX_VALUE;
831
832 range->encoding_size[0] = 5;
833 range->encoding_size[1] = 13;
834 range->num_encoding_sizes = 2;
835 range->max_encoding_tokens = 4;
836
837 range->min_pmp = 1000000;
838 range->max_pmp = 120000000;
839 range->min_pmt = 1000;
840 range->max_pmt = 1000000;
841 range->pmp_flags = IW_POWER_PERIOD;
842 range->pmt_flags = IW_POWER_TIMEOUT;
843 range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
844
845 /*
846 * Minimum version we recommend
847 */
848 range->we_version_source = 15;
849
850 /*
851 * Version we are compiled with
852 */
853 range->we_version_compiled = WIRELESS_EXT;
854
855 range->retry_capa = IW_RETRY_LIMIT;
856 range->retry_flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
857
858 range->min_retry = TX_RETRY_MIN;
859 range->max_retry = TX_RETRY_MAX;
860
861 /*
862 * Set the qual, level and noise range values
863 */
864 range->max_qual.qual = 100;
865 range->max_qual.level = 0;
866 range->max_qual.noise = 0;
867 range->max_qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
868
869 range->avg_qual.qual = 70;
870 /* TODO: Find real 'good' to 'bad' threshold value for RSSI */
871 range->avg_qual.level = 0;
872 range->avg_qual.noise = 0;
873 range->avg_qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
874
875 range->sensitivity = 0;
876
877 /*
878 * Setup the supported power level ranges
879 */
880 memset(range->txpower, 0, sizeof(range->txpower));
881 range->txpower[0] = 5;
882 range->txpower[1] = 7;
883 range->txpower[2] = 9;
884 range->txpower[3] = 11;
885 range->txpower[4] = 13;
886 range->txpower[5] = 15;
887 range->txpower[6] = 17;
888 range->txpower[7] = 19;
889
890 range->num_txpower = 8;
891 range->txpower_capa = IW_TXPOW_DBM;
892 range->txpower_capa |= IW_TXPOW_RANGE;
893
894 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
895 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
896 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
897 range->event_capa[1] = IW_EVENT_CAPA_K_1;
898
899 if (adapter->fwcapinfo & FW_CAPINFO_WPA) {
900 range->enc_capa = IW_ENC_CAPA_WPA
901 | IW_ENC_CAPA_WPA2
902 | IW_ENC_CAPA_CIPHER_TKIP
903 | IW_ENC_CAPA_CIPHER_CCMP;
904 }
905
906 LEAVE();
907 return 0;
908 }
909
910 static int wlan_set_power(struct net_device *dev, struct iw_request_info *info,
911 struct iw_param *vwrq, char *extra)
912 {
913 wlan_private *priv = dev->priv;
914 wlan_adapter *adapter = priv->adapter;
915
916 ENTER();
917
918 /* PS is currently supported only in Infrastructure mode
919 * Remove this check if it is to be supported in IBSS mode also
920 */
921
922 if (vwrq->disabled) {
923 adapter->psmode = wlan802_11powermodecam;
924 if (adapter->psstate != PS_STATE_FULL_POWER) {
925 libertas_ps_wakeup(priv, cmd_option_waitforrsp);
926 }
927
928 return 0;
929 }
930
931 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
932 lbs_pr_debug(1,
933 "Setting power timeout command is not supported\n");
934 return -EINVAL;
935 } else if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_PERIOD) {
936 lbs_pr_debug(1, "Setting power period command is not supported\n");
937 return -EINVAL;
938 }
939
940 if (adapter->psmode != wlan802_11powermodecam) {
941 return 0;
942 }
943
944 adapter->psmode = wlan802_11powermodemax_psp;
945
946 if (adapter->connect_status == libertas_connected) {
947 libertas_ps_sleep(priv, cmd_option_waitforrsp);
948 }
949
950 LEAVE();
951 return 0;
952 }
953
954 static int wlan_get_power(struct net_device *dev, struct iw_request_info *info,
955 struct iw_param *vwrq, char *extra)
956 {
957 wlan_private *priv = dev->priv;
958 wlan_adapter *adapter = priv->adapter;
959 int mode;
960
961 ENTER();
962
963 mode = adapter->psmode;
964
965 if ((vwrq->disabled = (mode == wlan802_11powermodecam))
966 || adapter->connect_status == libertas_disconnected) {
967 LEAVE();
968 return 0;
969 }
970
971 vwrq->value = 0;
972
973 LEAVE();
974 return 0;
975 }
976
977 /*
978 * iwpriv settable callbacks
979 */
980
981 static const iw_handler wlan_private_handler[] = {
982 NULL, /* SIOCIWFIRSTPRIV */
983 };
984
985 static const struct iw_priv_args wlan_private_args[] = {
986 /*
987 * { cmd, set_args, get_args, name }
988 */
989 /* Using iwpriv sub-command feature */
990 {
991 WLAN_SETONEINT_GETNONE, /* IOCTL: 24 */
992 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
993 IW_PRIV_TYPE_NONE,
994 ""},
995 {
996 WLANSETREGION,
997 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
998 IW_PRIV_TYPE_NONE,
999 "setregioncode"},
1000 {
1001 WLAN_SUBCMD_MESH_SET_TTL,
1002 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1003 IW_PRIV_TYPE_NONE,
1004 "mesh_set_ttl"},
1005 {
1006 WLAN_SETNONE_GETONEINT,
1007 IW_PRIV_TYPE_NONE,
1008 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1009 ""},
1010 {
1011 WLANGETREGION,
1012 IW_PRIV_TYPE_NONE,
1013 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1014 "getregioncode"},
1015 {
1016 WLAN_SUBCMD_FWT_CLEANUP,
1017 IW_PRIV_TYPE_NONE,
1018 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1019 "fwt_cleanup"},
1020 {
1021 WLAN_SUBCMD_FWT_TIME,
1022 IW_PRIV_TYPE_NONE,
1023 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1024 "fwt_time"},
1025 {
1026 WLAN_SUBCMD_MESH_GET_TTL,
1027 IW_PRIV_TYPE_NONE,
1028 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1029 "mesh_get_ttl"},
1030 {
1031 WLAN_SETNONE_GETNONE,
1032 IW_PRIV_TYPE_NONE,
1033 IW_PRIV_TYPE_NONE,
1034 ""},
1035 {
1036 WLAN_SUBCMD_FWT_RESET,
1037 IW_PRIV_TYPE_NONE,
1038 IW_PRIV_TYPE_NONE,
1039 "fwt_reset"},
1040 {
1041 WLAN_SUBCMD_BT_RESET,
1042 IW_PRIV_TYPE_NONE,
1043 IW_PRIV_TYPE_NONE,
1044 "bt_reset"},
1045 {
1046 WLAN_SET128CHAR_GET128CHAR,
1047 IW_PRIV_TYPE_CHAR | 128,
1048 IW_PRIV_TYPE_CHAR | 128,
1049 ""},
1050 /* BT Management */
1051 {
1052 WLAN_SUBCMD_BT_ADD,
1053 IW_PRIV_TYPE_CHAR | 128,
1054 IW_PRIV_TYPE_CHAR | 128,
1055 "bt_add"},
1056 {
1057 WLAN_SUBCMD_BT_DEL,
1058 IW_PRIV_TYPE_CHAR | 128,
1059 IW_PRIV_TYPE_CHAR | 128,
1060 "bt_del"},
1061 {
1062 WLAN_SUBCMD_BT_LIST,
1063 IW_PRIV_TYPE_CHAR | 128,
1064 IW_PRIV_TYPE_CHAR | 128,
1065 "bt_list"},
1066 /* FWT Management */
1067 {
1068 WLAN_SUBCMD_FWT_ADD,
1069 IW_PRIV_TYPE_CHAR | 128,
1070 IW_PRIV_TYPE_CHAR | 128,
1071 "fwt_add"},
1072 {
1073 WLAN_SUBCMD_FWT_DEL,
1074 IW_PRIV_TYPE_CHAR | 128,
1075 IW_PRIV_TYPE_CHAR | 128,
1076 "fwt_del"},
1077 {
1078 WLAN_SUBCMD_FWT_LOOKUP,
1079 IW_PRIV_TYPE_CHAR | 128,
1080 IW_PRIV_TYPE_CHAR | 128,
1081 "fwt_lookup"},
1082 {
1083 WLAN_SUBCMD_FWT_LIST_NEIGHBOR,
1084 IW_PRIV_TYPE_CHAR | 128,
1085 IW_PRIV_TYPE_CHAR | 128,
1086 "fwt_list_neigh"},
1087 {
1088 WLAN_SUBCMD_FWT_LIST,
1089 IW_PRIV_TYPE_CHAR | 128,
1090 IW_PRIV_TYPE_CHAR | 128,
1091 "fwt_list"},
1092 {
1093 WLAN_SUBCMD_FWT_LIST_ROUTE,
1094 IW_PRIV_TYPE_CHAR | 128,
1095 IW_PRIV_TYPE_CHAR | 128,
1096 "fwt_list_route"},
1097 {
1098 WLAN_SET_GET_SIXTEEN_INT,
1099 IW_PRIV_TYPE_INT | 16,
1100 IW_PRIV_TYPE_INT | 16,
1101 ""},
1102 {
1103 WLAN_LED_GPIO_CTRL,
1104 IW_PRIV_TYPE_INT | 16,
1105 IW_PRIV_TYPE_INT | 16,
1106 "ledgpio"},
1107 };
1108
1109 static struct iw_statistics *wlan_get_wireless_stats(struct net_device *dev)
1110 {
1111 enum {
1112 POOR = 30,
1113 FAIR = 60,
1114 GOOD = 80,
1115 VERY_GOOD = 90,
1116 EXCELLENT = 95,
1117 PERFECT = 100
1118 };
1119 wlan_private *priv = dev->priv;
1120 wlan_adapter *adapter = priv->adapter;
1121 u32 rssi_qual;
1122 u32 tx_qual;
1123 u32 quality = 0;
1124 int stats_valid = 0;
1125 u8 rssi;
1126 u32 tx_retries;
1127
1128 ENTER();
1129
1130 priv->wstats.status = adapter->mode;
1131
1132 /* If we're not associated, all quality values are meaningless */
1133 if (adapter->connect_status != libertas_connected)
1134 goto out;
1135
1136 /* Quality by RSSI */
1137 priv->wstats.qual.level =
1138 CAL_RSSI(adapter->SNR[TYPE_BEACON][TYPE_NOAVG],
1139 adapter->NF[TYPE_BEACON][TYPE_NOAVG]);
1140
1141 if (adapter->NF[TYPE_BEACON][TYPE_NOAVG] == 0) {
1142 priv->wstats.qual.noise = MRVDRV_NF_DEFAULT_SCAN_VALUE;
1143 } else {
1144 priv->wstats.qual.noise =
1145 CAL_NF(adapter->NF[TYPE_BEACON][TYPE_NOAVG]);
1146 }
1147
1148 lbs_pr_debug(1, "Signal Level = %#x\n", priv->wstats.qual.level);
1149 lbs_pr_debug(1, "Noise = %#x\n", priv->wstats.qual.noise);
1150
1151 rssi = priv->wstats.qual.level - priv->wstats.qual.noise;
1152 if (rssi < 15)
1153 rssi_qual = rssi * POOR / 10;
1154 else if (rssi < 20)
1155 rssi_qual = (rssi - 15) * (FAIR - POOR) / 5 + POOR;
1156 else if (rssi < 30)
1157 rssi_qual = (rssi - 20) * (GOOD - FAIR) / 5 + FAIR;
1158 else if (rssi < 40)
1159 rssi_qual = (rssi - 30) * (VERY_GOOD - GOOD) /
1160 10 + GOOD;
1161 else
1162 rssi_qual = (rssi - 40) * (PERFECT - VERY_GOOD) /
1163 10 + VERY_GOOD;
1164 quality = rssi_qual;
1165
1166 /* Quality by TX errors */
1167 priv->wstats.discard.retries = priv->stats.tx_errors;
1168
1169 tx_retries = adapter->logmsg.retry;
1170
1171 if (tx_retries > 75)
1172 tx_qual = (90 - tx_retries) * POOR / 15;
1173 else if (tx_retries > 70)
1174 tx_qual = (75 - tx_retries) * (FAIR - POOR) / 5 + POOR;
1175 else if (tx_retries > 65)
1176 tx_qual = (70 - tx_retries) * (GOOD - FAIR) / 5 + FAIR;
1177 else if (tx_retries > 50)
1178 tx_qual = (65 - tx_retries) * (VERY_GOOD - GOOD) /
1179 15 + GOOD;
1180 else
1181 tx_qual = (50 - tx_retries) *
1182 (PERFECT - VERY_GOOD) / 50 + VERY_GOOD;
1183 quality = min(quality, tx_qual);
1184
1185 priv->wstats.discard.code = adapter->logmsg.wepundecryptable;
1186 priv->wstats.discard.fragment = adapter->logmsg.fcserror;
1187 priv->wstats.discard.retries = tx_retries;
1188 priv->wstats.discard.misc = adapter->logmsg.ackfailure;
1189
1190 /* Calculate quality */
1191 priv->wstats.qual.qual = max(quality, (u32)100);
1192 priv->wstats.qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
1193 stats_valid = 1;
1194
1195 /* update stats asynchronously for future calls */
1196 libertas_prepare_and_send_command(priv, cmd_802_11_rssi, 0,
1197 0, 0, NULL);
1198 libertas_prepare_and_send_command(priv, cmd_802_11_get_log, 0,
1199 0, 0, NULL);
1200 out:
1201 if (!stats_valid) {
1202 priv->wstats.miss.beacon = 0;
1203 priv->wstats.discard.retries = 0;
1204 priv->wstats.qual.qual = 0;
1205 priv->wstats.qual.level = 0;
1206 priv->wstats.qual.noise = 0;
1207 priv->wstats.qual.updated = IW_QUAL_ALL_UPDATED;
1208 priv->wstats.qual.updated |= IW_QUAL_NOISE_INVALID |
1209 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
1210 }
1211
1212 LEAVE ();
1213 return &priv->wstats;
1214
1215
1216 }
1217
1218 static int wlan_set_freq(struct net_device *dev, struct iw_request_info *info,
1219 struct iw_freq *fwrq, char *extra)
1220 {
1221 int ret = 0;
1222 wlan_private *priv = dev->priv;
1223 wlan_adapter *adapter = priv->adapter;
1224 int rc = -EINPROGRESS; /* Call commit handler */
1225 struct chan_freq_power *cfp;
1226
1227 ENTER();
1228
1229 /*
1230 * If setting by frequency, convert to a channel
1231 */
1232 if (fwrq->e == 1) {
1233
1234 long f = fwrq->m / 100000;
1235 int c = 0;
1236
1237 cfp = find_cfp_by_band_and_freq(adapter, 0, f);
1238 if (!cfp) {
1239 lbs_pr_debug(1, "Invalid freq=%ld\n", f);
1240 return -EINVAL;
1241 }
1242
1243 c = (int)cfp->channel;
1244
1245 if (c < 0)
1246 return -EINVAL;
1247
1248 fwrq->e = 0;
1249 fwrq->m = c;
1250 }
1251
1252 /*
1253 * Setting by channel number
1254 */
1255 if (fwrq->m > 1000 || fwrq->e > 0) {
1256 rc = -EOPNOTSUPP;
1257 } else {
1258 int channel = fwrq->m;
1259
1260 cfp = libertas_find_cfp_by_band_and_channel(adapter, 0, channel);
1261 if (!cfp) {
1262 rc = -EINVAL;
1263 } else {
1264 if (adapter->mode == IW_MODE_ADHOC) {
1265 rc = changeadhocchannel(priv, channel);
1266 /* If station is WEP enabled, send the
1267 * command to set WEP in firmware
1268 */
1269 if (adapter->secinfo.wep_enabled) {
1270 lbs_pr_debug(1, "set_freq: WEP enabled\n");
1271 ret = libertas_prepare_and_send_command(priv,
1272 cmd_802_11_set_wep,
1273 cmd_act_add,
1274 cmd_option_waitforrsp,
1275 0,
1276 NULL);
1277
1278 if (ret) {
1279 LEAVE();
1280 return ret;
1281 }
1282
1283 adapter->currentpacketfilter |=
1284 cmd_act_mac_wep_enable;
1285
1286 libertas_set_mac_packet_filter(priv);
1287 }
1288 } else {
1289 rc = -EOPNOTSUPP;
1290 }
1291 }
1292 }
1293
1294 LEAVE();
1295 return rc;
1296 }
1297
1298 /**
1299 * @brief use index to get the data rate
1300 *
1301 * @param index The index of data rate
1302 * @return data rate or 0
1303 */
1304 u32 libertas_index_to_data_rate(u8 index)
1305 {
1306 if (index >= sizeof(libertas_wlan_data_rates))
1307 index = 0;
1308
1309 return libertas_wlan_data_rates[index];
1310 }
1311
1312 /**
1313 * @brief use rate to get the index
1314 *
1315 * @param rate data rate
1316 * @return index or 0
1317 */
1318 u8 libertas_data_rate_to_index(u32 rate)
1319 {
1320 u8 *ptr;
1321
1322 if (rate)
1323 if ((ptr = memchr(libertas_wlan_data_rates, (u8) rate,
1324 sizeof(libertas_wlan_data_rates))))
1325 return (ptr - libertas_wlan_data_rates);
1326
1327 return 0;
1328 }
1329
1330 static int wlan_set_rate(struct net_device *dev, struct iw_request_info *info,
1331 struct iw_param *vwrq, char *extra)
1332 {
1333 wlan_private *priv = dev->priv;
1334 wlan_adapter *adapter = priv->adapter;
1335 u32 data_rate;
1336 u16 action;
1337 int ret = 0;
1338 u8 rates[WLAN_SUPPORTED_RATES];
1339 u8 *rate;
1340
1341 ENTER();
1342
1343 lbs_pr_debug(1, "Vwrq->value = %d\n", vwrq->value);
1344
1345 if (vwrq->value == -1) {
1346 action = cmd_act_set_tx_auto; // Auto
1347 adapter->is_datarate_auto = 1;
1348 adapter->datarate = 0;
1349 } else {
1350 if (vwrq->value % 100000) {
1351 return -EINVAL;
1352 }
1353
1354 data_rate = vwrq->value / 500000;
1355
1356 memset(rates, 0, sizeof(rates));
1357 get_active_data_rates(adapter, rates);
1358 rate = rates;
1359 while (*rate) {
1360 lbs_pr_debug(1, "Rate=0x%X Wanted=0x%X\n", *rate,
1361 data_rate);
1362 if ((*rate & 0x7f) == (data_rate & 0x7f))
1363 break;
1364 rate++;
1365 }
1366 if (!*rate) {
1367 lbs_pr_alert( "The fixed data rate 0x%X is out "
1368 "of range.\n", data_rate);
1369 return -EINVAL;
1370 }
1371
1372 adapter->datarate = data_rate;
1373 action = cmd_act_set_tx_fix_rate;
1374 adapter->is_datarate_auto = 0;
1375 }
1376
1377 ret = libertas_prepare_and_send_command(priv, cmd_802_11_data_rate,
1378 action, cmd_option_waitforrsp, 0, NULL);
1379
1380 LEAVE();
1381 return ret;
1382 }
1383
1384 static int wlan_get_rate(struct net_device *dev, struct iw_request_info *info,
1385 struct iw_param *vwrq, char *extra)
1386 {
1387 wlan_private *priv = dev->priv;
1388 wlan_adapter *adapter = priv->adapter;
1389
1390 ENTER();
1391
1392 if (adapter->is_datarate_auto) {
1393 vwrq->fixed = 0;
1394 } else {
1395 vwrq->fixed = 1;
1396 }
1397
1398 vwrq->value = adapter->datarate * 500000;
1399
1400 LEAVE();
1401 return 0;
1402 }
1403
1404 static int wlan_set_mode(struct net_device *dev,
1405 struct iw_request_info *info, u32 * uwrq, char *extra)
1406 {
1407 int ret = 0;
1408 wlan_private *priv = dev->priv;
1409 wlan_adapter *adapter = priv->adapter;
1410 struct assoc_request * assoc_req;
1411
1412 ENTER();
1413
1414 if ( (*uwrq != IW_MODE_ADHOC)
1415 && (*uwrq != IW_MODE_INFRA)
1416 && (*uwrq != IW_MODE_AUTO)) {
1417 lbs_pr_debug(1, "Invalid mode: 0x%x\n", *uwrq);
1418 ret = -EINVAL;
1419 goto out;
1420 }
1421
1422 mutex_lock(&adapter->lock);
1423 assoc_req = wlan_get_association_request(adapter);
1424 if (!assoc_req) {
1425 ret = -ENOMEM;
1426 wlan_cancel_association_work(priv);
1427 } else {
1428 assoc_req->mode = *uwrq;
1429 set_bit(ASSOC_FLAG_MODE, &assoc_req->flags);
1430 wlan_postpone_association_work(priv);
1431 lbs_pr_debug(1, "Switching to mode: 0x%x\n", *uwrq);
1432 }
1433 mutex_unlock(&adapter->lock);
1434
1435 out:
1436 LEAVE();
1437 return ret;
1438 }
1439
1440
1441 /**
1442 * @brief Get Encryption key
1443 *
1444 * @param dev A pointer to net_device structure
1445 * @param info A pointer to iw_request_info structure
1446 * @param vwrq A pointer to iw_param structure
1447 * @param extra A pointer to extra data buf
1448 * @return 0 --success, otherwise fail
1449 */
1450 static int wlan_get_encode(struct net_device *dev,
1451 struct iw_request_info *info,
1452 struct iw_point *dwrq, u8 * extra)
1453 {
1454 wlan_private *priv = dev->priv;
1455 wlan_adapter *adapter = priv->adapter;
1456 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1457
1458 ENTER();
1459
1460 lbs_pr_debug(1, "flags=0x%x index=%d length=%d wep_tx_keyidx=%d\n",
1461 dwrq->flags, index, dwrq->length, adapter->wep_tx_keyidx);
1462
1463 dwrq->flags = 0;
1464
1465 /* Authentication method */
1466 switch (adapter->secinfo.auth_mode) {
1467 case IW_AUTH_ALG_OPEN_SYSTEM:
1468 dwrq->flags = IW_ENCODE_OPEN;
1469 break;
1470
1471 case IW_AUTH_ALG_SHARED_KEY:
1472 case IW_AUTH_ALG_LEAP:
1473 dwrq->flags = IW_ENCODE_RESTRICTED;
1474 break;
1475 default:
1476 dwrq->flags = IW_ENCODE_DISABLED | IW_ENCODE_OPEN;
1477 break;
1478 }
1479
1480 if ( adapter->secinfo.wep_enabled
1481 || adapter->secinfo.WPAenabled
1482 || adapter->secinfo.WPA2enabled) {
1483 dwrq->flags &= ~IW_ENCODE_DISABLED;
1484 } else {
1485 dwrq->flags |= IW_ENCODE_DISABLED;
1486 }
1487
1488 memset(extra, 0, 16);
1489
1490 mutex_lock(&adapter->lock);
1491
1492 /* Default to returning current transmit key */
1493 if (index < 0)
1494 index = adapter->wep_tx_keyidx;
1495
1496 if ((adapter->wep_keys[index].len) && adapter->secinfo.wep_enabled) {
1497 memcpy(extra, adapter->wep_keys[index].key,
1498 adapter->wep_keys[index].len);
1499 dwrq->length = adapter->wep_keys[index].len;
1500
1501 dwrq->flags |= (index + 1);
1502 /* Return WEP enabled */
1503 dwrq->flags &= ~IW_ENCODE_DISABLED;
1504 } else if ((adapter->secinfo.WPAenabled)
1505 || (adapter->secinfo.WPA2enabled)) {
1506 /* return WPA enabled */
1507 dwrq->flags &= ~IW_ENCODE_DISABLED;
1508 } else {
1509 dwrq->flags |= IW_ENCODE_DISABLED;
1510 }
1511
1512 mutex_unlock(&adapter->lock);
1513
1514 dwrq->flags |= IW_ENCODE_NOKEY;
1515
1516 lbs_pr_debug(1, "key:%02x:%02x:%02x:%02x:%02x:%02x keylen=%d\n",
1517 extra[0], extra[1], extra[2],
1518 extra[3], extra[4], extra[5], dwrq->length);
1519
1520 lbs_pr_debug(1, "Return flags=0x%x\n", dwrq->flags);
1521
1522 LEAVE();
1523 return 0;
1524 }
1525
1526 /**
1527 * @brief Set Encryption key (internal)
1528 *
1529 * @param priv A pointer to private card structure
1530 * @param key_material A pointer to key material
1531 * @param key_length length of key material
1532 * @param index key index to set
1533 * @param set_tx_key Force set TX key (1 = yes, 0 = no)
1534 * @return 0 --success, otherwise fail
1535 */
1536 static int wlan_set_wep_key(struct assoc_request *assoc_req,
1537 const char *key_material,
1538 u16 key_length,
1539 u16 index,
1540 int set_tx_key)
1541 {
1542 struct WLAN_802_11_KEY *pkey;
1543
1544 ENTER();
1545
1546 /* Paranoid validation of key index */
1547 if (index > 3) {
1548 LEAVE();
1549 return -EINVAL;
1550 }
1551
1552 /* validate max key length */
1553 if (key_length > KEY_LEN_WEP_104) {
1554 LEAVE();
1555 return -EINVAL;
1556 }
1557
1558 pkey = &assoc_req->wep_keys[index];
1559
1560 if (key_length > 0) {
1561 memset(pkey, 0, sizeof(struct WLAN_802_11_KEY));
1562 pkey->type = KEY_TYPE_ID_WEP;
1563
1564 /* Standardize the key length */
1565 pkey->len = (key_length > KEY_LEN_WEP_40) ?
1566 KEY_LEN_WEP_104 : KEY_LEN_WEP_40;
1567 memcpy(pkey->key, key_material, key_length);
1568 }
1569
1570 if (set_tx_key) {
1571 /* Ensure the chosen key is valid */
1572 if (!pkey->len) {
1573 lbs_pr_debug(1, "key not set, so cannot enable it\n");
1574 LEAVE();
1575 return -EINVAL;
1576 }
1577 assoc_req->wep_tx_keyidx = index;
1578 }
1579
1580 assoc_req->secinfo.wep_enabled = 1;
1581
1582 LEAVE();
1583 return 0;
1584 }
1585
1586 static int validate_key_index(u16 def_index, u16 raw_index,
1587 u16 *out_index, u16 *is_default)
1588 {
1589 if (!out_index || !is_default)
1590 return -EINVAL;
1591
1592 /* Verify index if present, otherwise use default TX key index */
1593 if (raw_index > 0) {
1594 if (raw_index > 4)
1595 return -EINVAL;
1596 *out_index = raw_index - 1;
1597 } else {
1598 *out_index = def_index;
1599 *is_default = 1;
1600 }
1601 return 0;
1602 }
1603
1604 static void disable_wep(struct assoc_request *assoc_req)
1605 {
1606 int i;
1607
1608 /* Set Open System auth mode */
1609 assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
1610
1611 /* Clear WEP keys and mark WEP as disabled */
1612 assoc_req->secinfo.wep_enabled = 0;
1613 for (i = 0; i < 4; i++)
1614 assoc_req->wep_keys[i].len = 0;
1615
1616 set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
1617 set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
1618 }
1619
1620 /**
1621 * @brief Set Encryption key
1622 *
1623 * @param dev A pointer to net_device structure
1624 * @param info A pointer to iw_request_info structure
1625 * @param vwrq A pointer to iw_param structure
1626 * @param extra A pointer to extra data buf
1627 * @return 0 --success, otherwise fail
1628 */
1629 static int wlan_set_encode(struct net_device *dev,
1630 struct iw_request_info *info,
1631 struct iw_point *dwrq, char *extra)
1632 {
1633 int ret = 0;
1634 wlan_private *priv = dev->priv;
1635 wlan_adapter *adapter = priv->adapter;
1636 struct assoc_request * assoc_req;
1637 u16 is_default = 0, index = 0, set_tx_key = 0;
1638
1639 ENTER();
1640
1641 mutex_lock(&adapter->lock);
1642 assoc_req = wlan_get_association_request(adapter);
1643 if (!assoc_req) {
1644 ret = -ENOMEM;
1645 goto out;
1646 }
1647
1648 if (dwrq->flags & IW_ENCODE_DISABLED) {
1649 disable_wep (assoc_req);
1650 goto out;
1651 }
1652
1653 ret = validate_key_index(assoc_req->wep_tx_keyidx,
1654 (dwrq->flags & IW_ENCODE_INDEX),
1655 &index, &is_default);
1656 if (ret) {
1657 ret = -EINVAL;
1658 goto out;
1659 }
1660
1661 /* If WEP isn't enabled, or if there is no key data but a valid
1662 * index, set the TX key.
1663 */
1664 if (!assoc_req->secinfo.wep_enabled || (dwrq->length == 0 && !is_default))
1665 set_tx_key = 1;
1666
1667 ret = wlan_set_wep_key(assoc_req, extra, dwrq->length, index, set_tx_key);
1668 if (ret)
1669 goto out;
1670
1671 if (dwrq->length)
1672 set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
1673 if (set_tx_key)
1674 set_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags);
1675
1676 if (dwrq->flags & IW_ENCODE_RESTRICTED) {
1677 assoc_req->secinfo.auth_mode = IW_AUTH_ALG_SHARED_KEY;
1678 } else if (dwrq->flags & IW_ENCODE_OPEN) {
1679 assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
1680 }
1681
1682 out:
1683 if (ret == 0) {
1684 set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
1685 wlan_postpone_association_work(priv);
1686 } else {
1687 wlan_cancel_association_work(priv);
1688 }
1689 mutex_unlock(&adapter->lock);
1690
1691 LEAVE();
1692 return ret;
1693 }
1694
1695 /**
1696 * @brief Get Extended Encryption key (WPA/802.1x and WEP)
1697 *
1698 * @param dev A pointer to net_device structure
1699 * @param info A pointer to iw_request_info structure
1700 * @param vwrq A pointer to iw_param structure
1701 * @param extra A pointer to extra data buf
1702 * @return 0 on success, otherwise failure
1703 */
1704 static int wlan_get_encodeext(struct net_device *dev,
1705 struct iw_request_info *info,
1706 struct iw_point *dwrq,
1707 char *extra)
1708 {
1709 int ret = -EINVAL;
1710 wlan_private *priv = dev->priv;
1711 wlan_adapter *adapter = priv->adapter;
1712 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
1713 int index, max_key_len;
1714
1715 ENTER();
1716
1717 max_key_len = dwrq->length - sizeof(*ext);
1718 if (max_key_len < 0)
1719 goto out;
1720
1721 index = dwrq->flags & IW_ENCODE_INDEX;
1722 if (index) {
1723 if (index < 1 || index > 4)
1724 goto out;
1725 index--;
1726 } else {
1727 index = adapter->wep_tx_keyidx;
1728 }
1729
1730 if (!ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY &&
1731 ext->alg != IW_ENCODE_ALG_WEP) {
1732 if (index != 0 || adapter->mode != IW_MODE_INFRA)
1733 goto out;
1734 }
1735
1736 dwrq->flags = index + 1;
1737 memset(ext, 0, sizeof(*ext));
1738
1739 if ( !adapter->secinfo.wep_enabled
1740 && !adapter->secinfo.WPAenabled
1741 && !adapter->secinfo.WPA2enabled) {
1742 ext->alg = IW_ENCODE_ALG_NONE;
1743 ext->key_len = 0;
1744 dwrq->flags |= IW_ENCODE_DISABLED;
1745 } else {
1746 u8 *key = NULL;
1747
1748 if ( adapter->secinfo.wep_enabled
1749 && !adapter->secinfo.WPAenabled
1750 && !adapter->secinfo.WPA2enabled) {
1751 ext->alg = IW_ENCODE_ALG_WEP;
1752 ext->key_len = adapter->wep_keys[index].len;
1753 key = &adapter->wep_keys[index].key[0];
1754 } else if ( !adapter->secinfo.wep_enabled
1755 && (adapter->secinfo.WPAenabled ||
1756 adapter->secinfo.WPA2enabled)) {
1757 /* WPA */
1758 ext->alg = IW_ENCODE_ALG_TKIP;
1759 ext->key_len = 0;
1760 } else {
1761 goto out;
1762 }
1763
1764 if (ext->key_len > max_key_len) {
1765 ret = -E2BIG;
1766 goto out;
1767 }
1768
1769 if (ext->key_len)
1770 memcpy(ext->key, key, ext->key_len);
1771 else
1772 dwrq->flags |= IW_ENCODE_NOKEY;
1773 dwrq->flags |= IW_ENCODE_ENABLED;
1774 }
1775 ret = 0;
1776
1777 out:
1778 LEAVE();
1779 return ret;
1780 }
1781
1782 /**
1783 * @brief Set Encryption key Extended (WPA/802.1x and WEP)
1784 *
1785 * @param dev A pointer to net_device structure
1786 * @param info A pointer to iw_request_info structure
1787 * @param vwrq A pointer to iw_param structure
1788 * @param extra A pointer to extra data buf
1789 * @return 0 --success, otherwise fail
1790 */
1791 static int wlan_set_encodeext(struct net_device *dev,
1792 struct iw_request_info *info,
1793 struct iw_point *dwrq,
1794 char *extra)
1795 {
1796 int ret = 0;
1797 wlan_private *priv = dev->priv;
1798 wlan_adapter *adapter = priv->adapter;
1799 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
1800 int alg = ext->alg;
1801 struct assoc_request * assoc_req;
1802
1803 ENTER();
1804
1805 mutex_lock(&adapter->lock);
1806 assoc_req = wlan_get_association_request(adapter);
1807 if (!assoc_req) {
1808 ret = -ENOMEM;
1809 goto out;
1810 }
1811
1812 if ((alg == IW_ENCODE_ALG_NONE) || (dwrq->flags & IW_ENCODE_DISABLED)) {
1813 disable_wep (assoc_req);
1814 } else if (alg == IW_ENCODE_ALG_WEP) {
1815 u16 is_default = 0, index, set_tx_key = 0;
1816
1817 ret = validate_key_index(assoc_req->wep_tx_keyidx,
1818 (dwrq->flags & IW_ENCODE_INDEX),
1819 &index, &is_default);
1820 if (ret)
1821 goto out;
1822
1823 /* If WEP isn't enabled, or if there is no key data but a valid
1824 * index, or if the set-TX-key flag was passed, set the TX key.
1825 */
1826 if ( !assoc_req->secinfo.wep_enabled
1827 || (dwrq->length == 0 && !is_default)
1828 || (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY))
1829 set_tx_key = 1;
1830
1831 /* Copy key to driver */
1832 ret = wlan_set_wep_key (assoc_req, ext->key, ext->key_len, index,
1833 set_tx_key);
1834 if (ret)
1835 goto out;
1836
1837 if (dwrq->flags & IW_ENCODE_RESTRICTED) {
1838 assoc_req->secinfo.auth_mode = IW_AUTH_ALG_SHARED_KEY;
1839 } else if (dwrq->flags & IW_ENCODE_OPEN) {
1840 assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
1841 }
1842
1843 /* Mark the various WEP bits as modified */
1844 set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
1845 if (dwrq->length)
1846 set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
1847 if (set_tx_key)
1848 set_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags);
1849
1850 } else if ((alg == IW_ENCODE_ALG_TKIP) || (alg == IW_ENCODE_ALG_CCMP)) {
1851 struct WLAN_802_11_KEY * pkey;
1852
1853 /* validate key length */
1854 if (((alg == IW_ENCODE_ALG_TKIP)
1855 && (ext->key_len != KEY_LEN_WPA_TKIP))
1856 || ((alg == IW_ENCODE_ALG_CCMP)
1857 && (ext->key_len != KEY_LEN_WPA_AES))) {
1858 lbs_pr_debug(1, "Invalid size %d for key of alg"
1859 "type %d.\n",
1860 ext->key_len,
1861 alg);
1862 ret = -EINVAL;
1863 goto out;
1864 }
1865
1866 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
1867 pkey = &assoc_req->wpa_mcast_key;
1868 else
1869 pkey = &assoc_req->wpa_unicast_key;
1870
1871 memset(pkey, 0, sizeof (struct WLAN_802_11_KEY));
1872 memcpy(pkey->key, ext->key, ext->key_len);
1873 pkey->len = ext->key_len;
1874 pkey->flags = KEY_INFO_WPA_ENABLED;
1875
1876 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
1877 pkey->flags |= KEY_INFO_WPA_MCAST;
1878 set_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags);
1879 } else {
1880 pkey->flags |= KEY_INFO_WPA_UNICAST;
1881 set_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags);
1882 }
1883
1884 if (alg == IW_ENCODE_ALG_TKIP)
1885 pkey->type = KEY_TYPE_ID_TKIP;
1886 else if (alg == IW_ENCODE_ALG_CCMP)
1887 pkey->type = KEY_TYPE_ID_AES;
1888
1889 /* If WPA isn't enabled yet, do that now */
1890 if ( assoc_req->secinfo.WPAenabled == 0
1891 && assoc_req->secinfo.WPA2enabled == 0) {
1892 assoc_req->secinfo.WPAenabled = 1;
1893 assoc_req->secinfo.WPA2enabled = 1;
1894 set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
1895 }
1896
1897 disable_wep (assoc_req);
1898 }
1899
1900 out:
1901 if (ret == 0) {
1902 wlan_postpone_association_work(priv);
1903 } else {
1904 wlan_cancel_association_work(priv);
1905 }
1906 mutex_unlock(&adapter->lock);
1907
1908 LEAVE();
1909 return ret;
1910 }
1911
1912
1913 static int wlan_set_genie(struct net_device *dev,
1914 struct iw_request_info *info,
1915 struct iw_point *dwrq,
1916 char *extra)
1917 {
1918 wlan_private *priv = dev->priv;
1919 wlan_adapter *adapter = priv->adapter;
1920 int ret = 0;
1921 struct assoc_request * assoc_req;
1922
1923 ENTER();
1924
1925 mutex_lock(&adapter->lock);
1926 assoc_req = wlan_get_association_request(adapter);
1927 if (!assoc_req) {
1928 ret = -ENOMEM;
1929 goto out;
1930 }
1931
1932 if (dwrq->length > MAX_WPA_IE_LEN ||
1933 (dwrq->length && extra == NULL)) {
1934 ret = -EINVAL;
1935 goto out;
1936 }
1937
1938 if (dwrq->length) {
1939 memcpy(&assoc_req->wpa_ie[0], extra, dwrq->length);
1940 assoc_req->wpa_ie_len = dwrq->length;
1941 } else {
1942 memset(&assoc_req->wpa_ie[0], 0, sizeof(adapter->wpa_ie));
1943 assoc_req->wpa_ie_len = 0;
1944 }
1945
1946 out:
1947 if (ret == 0) {
1948 set_bit(ASSOC_FLAG_WPA_IE, &assoc_req->flags);
1949 wlan_postpone_association_work(priv);
1950 } else {
1951 wlan_cancel_association_work(priv);
1952 }
1953 mutex_unlock(&adapter->lock);
1954
1955 LEAVE();
1956 return ret;
1957 }
1958
1959 static int wlan_get_genie(struct net_device *dev,
1960 struct iw_request_info *info,
1961 struct iw_point *dwrq,
1962 char *extra)
1963 {
1964 wlan_private *priv = dev->priv;
1965 wlan_adapter *adapter = priv->adapter;
1966
1967 ENTER();
1968
1969 if (adapter->wpa_ie_len == 0) {
1970 dwrq->length = 0;
1971 LEAVE();
1972 return 0;
1973 }
1974
1975 if (dwrq->length < adapter->wpa_ie_len) {
1976 LEAVE();
1977 return -E2BIG;
1978 }
1979
1980 dwrq->length = adapter->wpa_ie_len;
1981 memcpy(extra, &adapter->wpa_ie[0], adapter->wpa_ie_len);
1982
1983 LEAVE();
1984 return 0;
1985 }
1986
1987
1988 static int wlan_set_auth(struct net_device *dev,
1989 struct iw_request_info *info,
1990 struct iw_param *dwrq,
1991 char *extra)
1992 {
1993 wlan_private *priv = dev->priv;
1994 wlan_adapter *adapter = priv->adapter;
1995 struct assoc_request * assoc_req;
1996 int ret = 0;
1997 int updated = 0;
1998
1999 ENTER();
2000
2001 mutex_lock(&adapter->lock);
2002 assoc_req = wlan_get_association_request(adapter);
2003 if (!assoc_req) {
2004 ret = -ENOMEM;
2005 goto out;
2006 }
2007
2008 switch (dwrq->flags & IW_AUTH_INDEX) {
2009 case IW_AUTH_TKIP_COUNTERMEASURES:
2010 case IW_AUTH_CIPHER_PAIRWISE:
2011 case IW_AUTH_CIPHER_GROUP:
2012 case IW_AUTH_KEY_MGMT:
2013 /*
2014 * libertas does not use these parameters
2015 */
2016 break;
2017
2018 case IW_AUTH_WPA_VERSION:
2019 if (dwrq->value & IW_AUTH_WPA_VERSION_DISABLED) {
2020 assoc_req->secinfo.WPAenabled = 0;
2021 assoc_req->secinfo.WPA2enabled = 0;
2022 }
2023 if (dwrq->value & IW_AUTH_WPA_VERSION_WPA) {
2024 assoc_req->secinfo.WPAenabled = 1;
2025 assoc_req->secinfo.wep_enabled = 0;
2026 assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
2027 }
2028 if (dwrq->value & IW_AUTH_WPA_VERSION_WPA2) {
2029 assoc_req->secinfo.WPA2enabled = 1;
2030 assoc_req->secinfo.wep_enabled = 0;
2031 assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
2032 }
2033 updated = 1;
2034 break;
2035
2036 case IW_AUTH_DROP_UNENCRYPTED:
2037 if (dwrq->value) {
2038 adapter->currentpacketfilter |=
2039 cmd_act_mac_strict_protection_enable;
2040 } else {
2041 adapter->currentpacketfilter &=
2042 ~cmd_act_mac_strict_protection_enable;
2043 }
2044 updated = 1;
2045 break;
2046
2047 case IW_AUTH_80211_AUTH_ALG:
2048 if (dwrq->value & IW_AUTH_ALG_SHARED_KEY) {
2049 assoc_req->secinfo.auth_mode = IW_AUTH_ALG_SHARED_KEY;
2050 } else if (dwrq->value & IW_AUTH_ALG_OPEN_SYSTEM) {
2051 assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
2052 } else if (dwrq->value & IW_AUTH_ALG_LEAP) {
2053 assoc_req->secinfo.auth_mode = IW_AUTH_ALG_LEAP;
2054 } else {
2055 ret = -EINVAL;
2056 }
2057 updated = 1;
2058 break;
2059
2060 case IW_AUTH_WPA_ENABLED:
2061 if (dwrq->value) {
2062 if (!assoc_req->secinfo.WPAenabled &&
2063 !assoc_req->secinfo.WPA2enabled) {
2064 assoc_req->secinfo.WPAenabled = 1;
2065 assoc_req->secinfo.WPA2enabled = 1;
2066 assoc_req->secinfo.wep_enabled = 0;
2067 assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
2068 }
2069 } else {
2070 assoc_req->secinfo.WPAenabled = 0;
2071 assoc_req->secinfo.WPA2enabled = 0;
2072 }
2073 updated = 1;
2074 break;
2075
2076 default:
2077 ret = -EOPNOTSUPP;
2078 break;
2079 }
2080
2081 out:
2082 if (ret == 0) {
2083 if (updated)
2084 set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
2085 wlan_postpone_association_work(priv);
2086 } else if (ret != -EOPNOTSUPP) {
2087 wlan_cancel_association_work(priv);
2088 }
2089 mutex_unlock(&adapter->lock);
2090
2091 LEAVE();
2092 return ret;
2093 }
2094
2095 static int wlan_get_auth(struct net_device *dev,
2096 struct iw_request_info *info,
2097 struct iw_param *dwrq,
2098 char *extra)
2099 {
2100 wlan_private *priv = dev->priv;
2101 wlan_adapter *adapter = priv->adapter;
2102
2103 ENTER();
2104
2105 switch (dwrq->flags & IW_AUTH_INDEX) {
2106 case IW_AUTH_WPA_VERSION:
2107 dwrq->value = 0;
2108 if (adapter->secinfo.WPAenabled)
2109 dwrq->value |= IW_AUTH_WPA_VERSION_WPA;
2110 if (adapter->secinfo.WPA2enabled)
2111 dwrq->value |= IW_AUTH_WPA_VERSION_WPA2;
2112 if (!dwrq->value)
2113 dwrq->value |= IW_AUTH_WPA_VERSION_DISABLED;
2114 break;
2115
2116 case IW_AUTH_DROP_UNENCRYPTED:
2117 dwrq->value = 0;
2118 if (adapter->currentpacketfilter &
2119 cmd_act_mac_strict_protection_enable)
2120 dwrq->value = 1;
2121 break;
2122
2123 case IW_AUTH_80211_AUTH_ALG:
2124 dwrq->value = adapter->secinfo.auth_mode;
2125 break;
2126
2127 case IW_AUTH_WPA_ENABLED:
2128 if (adapter->secinfo.WPAenabled && adapter->secinfo.WPA2enabled)
2129 dwrq->value = 1;
2130 break;
2131
2132 default:
2133 LEAVE();
2134 return -EOPNOTSUPP;
2135 }
2136
2137 LEAVE();
2138 return 0;
2139 }
2140
2141
2142 static int wlan_set_txpow(struct net_device *dev, struct iw_request_info *info,
2143 struct iw_param *vwrq, char *extra)
2144 {
2145 int ret = 0;
2146 wlan_private *priv = dev->priv;
2147 wlan_adapter *adapter = priv->adapter;
2148
2149 u16 dbm;
2150
2151 ENTER();
2152
2153 if (vwrq->disabled) {
2154 wlan_radio_ioctl(priv, RADIO_OFF);
2155 return 0;
2156 }
2157
2158 adapter->preamble = cmd_type_auto_preamble;
2159
2160 wlan_radio_ioctl(priv, RADIO_ON);
2161
2162 if ((vwrq->flags & IW_TXPOW_TYPE) == IW_TXPOW_MWATT) {
2163 dbm = (u16) mw_to_dbm(vwrq->value);
2164 } else
2165 dbm = (u16) vwrq->value;
2166
2167 /* auto tx power control */
2168
2169 if (vwrq->fixed == 0)
2170 dbm = 0xffff;
2171
2172 lbs_pr_debug(1, "<1>TXPOWER SET %d dbm.\n", dbm);
2173
2174 ret = libertas_prepare_and_send_command(priv,
2175 cmd_802_11_rf_tx_power,
2176 cmd_act_tx_power_opt_set_low,
2177 cmd_option_waitforrsp, 0, (void *)&dbm);
2178
2179 LEAVE();
2180 return ret;
2181 }
2182
2183 static int wlan_get_essid(struct net_device *dev, struct iw_request_info *info,
2184 struct iw_point *dwrq, char *extra)
2185 {
2186 wlan_private *priv = dev->priv;
2187 wlan_adapter *adapter = priv->adapter;
2188
2189 ENTER();
2190 /*
2191 * Note : if dwrq->flags != 0, we should get the relevant SSID from
2192 * the SSID list...
2193 */
2194
2195 /*
2196 * Get the current SSID
2197 */
2198 if (adapter->connect_status == libertas_connected) {
2199 memcpy(extra, adapter->curbssparams.ssid.ssid,
2200 adapter->curbssparams.ssid.ssidlength);
2201 extra[adapter->curbssparams.ssid.ssidlength] = '\0';
2202 } else {
2203 memset(extra, 0, 32);
2204 extra[adapter->curbssparams.ssid.ssidlength] = '\0';
2205 }
2206 /*
2207 * If none, we may want to get the one that was set
2208 */
2209
2210 /* To make the driver backward compatible with WPA supplicant v0.2.4 */
2211 if (dwrq->length == 32) /* check with WPA supplicant buffer size */
2212 dwrq->length = min_t(size_t, adapter->curbssparams.ssid.ssidlength,
2213 IW_ESSID_MAX_SIZE);
2214 else
2215 dwrq->length = adapter->curbssparams.ssid.ssidlength + 1;
2216
2217 dwrq->flags = 1; /* active */
2218
2219 LEAVE();
2220 return 0;
2221 }
2222
2223 static int wlan_set_essid(struct net_device *dev, struct iw_request_info *info,
2224 struct iw_point *dwrq, char *extra)
2225 {
2226 wlan_private *priv = dev->priv;
2227 wlan_adapter *adapter = priv->adapter;
2228 int ret = 0;
2229 struct WLAN_802_11_SSID ssid;
2230 struct assoc_request * assoc_req;
2231 int ssid_len = dwrq->length;
2232
2233 ENTER();
2234
2235 /*
2236 * WE-20 and earlier NULL pad the end of the SSID and increment
2237 * SSID length so it can be used like a string. WE-21 and later don't,
2238 * but some userspace tools aren't able to cope with the change.
2239 */
2240 if ((ssid_len > 0) && (extra[ssid_len - 1] == '\0'))
2241 ssid_len--;
2242
2243 /* Check the size of the string */
2244 if (ssid_len > IW_ESSID_MAX_SIZE) {
2245 ret = -E2BIG;
2246 goto out;
2247 }
2248
2249 memset(&ssid, 0, sizeof(struct WLAN_802_11_SSID));
2250
2251 if (!dwrq->flags || !ssid_len) {
2252 /* "any" SSID requested; leave SSID blank */
2253 } else {
2254 /* Specific SSID requested */
2255 memcpy(&ssid.ssid, extra, ssid_len);
2256 ssid.ssidlength = ssid_len;
2257 }
2258
2259 lbs_pr_debug(1, "Requested new SSID = %s\n",
2260 (ssid.ssidlength > 0) ? (char *)ssid.ssid : "any");
2261
2262 out:
2263 mutex_lock(&adapter->lock);
2264 if (ret == 0) {
2265 /* Get or create the current association request */
2266 assoc_req = wlan_get_association_request(adapter);
2267 if (!assoc_req) {
2268 ret = -ENOMEM;
2269 } else {
2270 /* Copy the SSID to the association request */
2271 memcpy(&assoc_req->ssid, &ssid, sizeof(struct WLAN_802_11_SSID));
2272 set_bit(ASSOC_FLAG_SSID, &assoc_req->flags);
2273 wlan_postpone_association_work(priv);
2274 }
2275 }
2276
2277 /* Cancel the association request if there was an error */
2278 if (ret != 0) {
2279 wlan_cancel_association_work(priv);
2280 }
2281
2282 mutex_unlock(&adapter->lock);
2283
2284 LEAVE();
2285 return ret;
2286 }
2287
2288 /**
2289 * @brief Connect to the AP or Ad-hoc Network with specific bssid
2290 *
2291 * @param dev A pointer to net_device structure
2292 * @param info A pointer to iw_request_info structure
2293 * @param awrq A pointer to iw_param structure
2294 * @param extra A pointer to extra data buf
2295 * @return 0 --success, otherwise fail
2296 */
2297 static int wlan_set_wap(struct net_device *dev, struct iw_request_info *info,
2298 struct sockaddr *awrq, char *extra)
2299 {
2300 wlan_private *priv = dev->priv;
2301 wlan_adapter *adapter = priv->adapter;
2302 struct assoc_request * assoc_req;
2303 int ret = 0;
2304
2305 ENTER();
2306
2307 if (awrq->sa_family != ARPHRD_ETHER)
2308 return -EINVAL;
2309
2310 lbs_pr_debug(1, "ASSOC: WAP: sa_data: " MAC_FMT "\n", MAC_ARG(awrq->sa_data));
2311
2312 mutex_lock(&adapter->lock);
2313
2314 /* Get or create the current association request */
2315 assoc_req = wlan_get_association_request(adapter);
2316 if (!assoc_req) {
2317 wlan_cancel_association_work(priv);
2318 ret = -ENOMEM;
2319 } else {
2320 /* Copy the BSSID to the association request */
2321 memcpy(&assoc_req->bssid, awrq->sa_data, ETH_ALEN);
2322 set_bit(ASSOC_FLAG_BSSID, &assoc_req->flags);
2323 wlan_postpone_association_work(priv);
2324 }
2325
2326 mutex_unlock(&adapter->lock);
2327
2328 return ret;
2329 }
2330
2331 void libertas_get_fwversion(wlan_adapter * adapter, char *fwversion, int maxlen)
2332 {
2333 union {
2334 u32 l;
2335 u8 c[4];
2336 } ver;
2337 char fwver[32];
2338
2339 mutex_lock(&adapter->lock);
2340 ver.l = adapter->fwreleasenumber;
2341 mutex_unlock(&adapter->lock);
2342
2343 if (ver.c[3] == 0)
2344 sprintf(fwver, "%u.%u.%u", ver.c[2], ver.c[1], ver.c[0]);
2345 else
2346 sprintf(fwver, "%u.%u.%u.p%u",
2347 ver.c[2], ver.c[1], ver.c[0], ver.c[3]);
2348
2349 snprintf(fwversion, maxlen, fwver);
2350 }
2351
2352
2353 /*
2354 * iwconfig settable callbacks
2355 */
2356 static const iw_handler wlan_handler[] = {
2357 (iw_handler) NULL, /* SIOCSIWCOMMIT */
2358 (iw_handler) wlan_get_name, /* SIOCGIWNAME */
2359 (iw_handler) NULL, /* SIOCSIWNWID */
2360 (iw_handler) NULL, /* SIOCGIWNWID */
2361 (iw_handler) wlan_set_freq, /* SIOCSIWFREQ */
2362 (iw_handler) wlan_get_freq, /* SIOCGIWFREQ */
2363 (iw_handler) wlan_set_mode, /* SIOCSIWMODE */
2364 (iw_handler) wlan_get_mode, /* SIOCGIWMODE */
2365 (iw_handler) NULL, /* SIOCSIWSENS */
2366 (iw_handler) NULL, /* SIOCGIWSENS */
2367 (iw_handler) NULL, /* SIOCSIWRANGE */
2368 (iw_handler) wlan_get_range, /* SIOCGIWRANGE */
2369 (iw_handler) NULL, /* SIOCSIWPRIV */
2370 (iw_handler) NULL, /* SIOCGIWPRIV */
2371 (iw_handler) NULL, /* SIOCSIWSTATS */
2372 (iw_handler) NULL, /* SIOCGIWSTATS */
2373 iw_handler_set_spy, /* SIOCSIWSPY */
2374 iw_handler_get_spy, /* SIOCGIWSPY */
2375 iw_handler_set_thrspy, /* SIOCSIWTHRSPY */
2376 iw_handler_get_thrspy, /* SIOCGIWTHRSPY */
2377 (iw_handler) wlan_set_wap, /* SIOCSIWAP */
2378 (iw_handler) wlan_get_wap, /* SIOCGIWAP */
2379 (iw_handler) NULL, /* SIOCSIWMLME */
2380 (iw_handler) NULL, /* SIOCGIWAPLIST - deprecated */
2381 (iw_handler) libertas_set_scan, /* SIOCSIWSCAN */
2382 (iw_handler) libertas_get_scan, /* SIOCGIWSCAN */
2383 (iw_handler) wlan_set_essid, /* SIOCSIWESSID */
2384 (iw_handler) wlan_get_essid, /* SIOCGIWESSID */
2385 (iw_handler) wlan_set_nick, /* SIOCSIWNICKN */
2386 (iw_handler) wlan_get_nick, /* SIOCGIWNICKN */
2387 (iw_handler) NULL, /* -- hole -- */
2388 (iw_handler) NULL, /* -- hole -- */
2389 (iw_handler) wlan_set_rate, /* SIOCSIWRATE */
2390 (iw_handler) wlan_get_rate, /* SIOCGIWRATE */
2391 (iw_handler) wlan_set_rts, /* SIOCSIWRTS */
2392 (iw_handler) wlan_get_rts, /* SIOCGIWRTS */
2393 (iw_handler) wlan_set_frag, /* SIOCSIWFRAG */
2394 (iw_handler) wlan_get_frag, /* SIOCGIWFRAG */
2395 (iw_handler) wlan_set_txpow, /* SIOCSIWTXPOW */
2396 (iw_handler) wlan_get_txpow, /* SIOCGIWTXPOW */
2397 (iw_handler) wlan_set_retry, /* SIOCSIWRETRY */
2398 (iw_handler) wlan_get_retry, /* SIOCGIWRETRY */
2399 (iw_handler) wlan_set_encode, /* SIOCSIWENCODE */
2400 (iw_handler) wlan_get_encode, /* SIOCGIWENCODE */
2401 (iw_handler) wlan_set_power, /* SIOCSIWPOWER */
2402 (iw_handler) wlan_get_power, /* SIOCGIWPOWER */
2403 (iw_handler) NULL, /* -- hole -- */
2404 (iw_handler) NULL, /* -- hole -- */
2405 (iw_handler) wlan_set_genie, /* SIOCSIWGENIE */
2406 (iw_handler) wlan_get_genie, /* SIOCGIWGENIE */
2407 (iw_handler) wlan_set_auth, /* SIOCSIWAUTH */
2408 (iw_handler) wlan_get_auth, /* SIOCGIWAUTH */
2409 (iw_handler) wlan_set_encodeext,/* SIOCSIWENCODEEXT */
2410 (iw_handler) wlan_get_encodeext,/* SIOCGIWENCODEEXT */
2411 (iw_handler) NULL, /* SIOCSIWPMKSA */
2412 };
2413
2414 struct iw_handler_def libertas_handler_def = {
2415 .num_standard = sizeof(wlan_handler) / sizeof(iw_handler),
2416 .num_private = sizeof(wlan_private_handler) / sizeof(iw_handler),
2417 .num_private_args = sizeof(wlan_private_args) /
2418 sizeof(struct iw_priv_args),
2419 .standard = (iw_handler *) wlan_handler,
2420 .private = (iw_handler *) wlan_private_handler,
2421 .private_args = (struct iw_priv_args *)wlan_private_args,
2422 .get_wireless_stats = wlan_get_wireless_stats,
2423 };
ubuntu-bionic-kernel mirror