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