[PATCH] Marvell Libertas 8388 802.11b/g USB driver
[linux-2.6.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 "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          WLANSET8021XAUTHALG,
1092          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1093          IW_PRIV_TYPE_NONE,
1094          "8021xauthalgs",
1095          },
1096         {
1097          WLANSETENCRYPTIONMODE,
1098          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1099          IW_PRIV_TYPE_NONE,
1100          "encryptionmode",
1101          },
1102         {
1103          WLANSETREGION,
1104          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1105          IW_PRIV_TYPE_NONE,
1106          "setregioncode"},
1107         {
1108          WLAN_SET_LISTEN_INTERVAL,
1109          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1110          IW_PRIV_TYPE_NONE,
1111          "setlisteninter"},
1112         {
1113          WLAN_SET_MULTIPLE_DTIM,
1114          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1115          IW_PRIV_TYPE_NONE,
1116          "setmultipledtim"},
1117         {
1118          WLAN_SET_ATIM_WINDOW,
1119          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1120          IW_PRIV_TYPE_NONE,
1121          "atimwindow"},
1122         {
1123          WLANSETBCNAVG,
1124          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1125          IW_PRIV_TYPE_NONE,
1126          "setbcnavg"},
1127         {
1128          WLANSETDATAAVG,
1129          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1130          IW_PRIV_TYPE_NONE,
1131          "setdataavg"},
1132         {
1133          WLAN_SET_LINKMODE,
1134          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1135          IW_PRIV_TYPE_NONE,
1136          "linkmode"},
1137         {
1138          WLAN_SET_RADIOMODE,
1139          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1140          IW_PRIV_TYPE_NONE,
1141          "radiomode"},
1142         {
1143          WLAN_SET_DEBUGMODE,
1144          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1145          IW_PRIV_TYPE_NONE,
1146          "debugmode"},
1147         {
1148          WLAN_SUBCMD_MESH_SET_TTL,
1149          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1150          IW_PRIV_TYPE_NONE,
1151          "mesh_set_ttl"},
1152         {
1153          WLAN_SETNONE_GETONEINT,
1154          IW_PRIV_TYPE_NONE,
1155          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1156          ""},
1157         {
1158          WLANGETREGION,
1159          IW_PRIV_TYPE_NONE,
1160          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1161          "getregioncode"},
1162         {
1163          WLAN_GET_LISTEN_INTERVAL,
1164          IW_PRIV_TYPE_NONE,
1165          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1166          "getlisteninter"},
1167         {
1168          WLAN_GET_MULTIPLE_DTIM,
1169          IW_PRIV_TYPE_NONE,
1170          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1171          "getmultipledtim"},
1172         {
1173          WLAN_GET_TX_RATE,
1174          IW_PRIV_TYPE_NONE,
1175          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1176          "gettxrate"},
1177         {
1178          WLANGETBCNAVG,
1179          IW_PRIV_TYPE_NONE,
1180          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1181          "getbcnavg"},
1182         {
1183          WLAN_GET_LINKMODE,
1184          IW_PRIV_TYPE_NONE,
1185          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1186          "get_linkmode"},
1187         {
1188          WLAN_GET_RADIOMODE,
1189          IW_PRIV_TYPE_NONE,
1190          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1191          "get_radiomode"},
1192         {
1193          WLAN_GET_DEBUGMODE,
1194          IW_PRIV_TYPE_NONE,
1195          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1196          "get_debugmode"},
1197         {
1198          WLAN_SUBCMD_FWT_CLEANUP,
1199          IW_PRIV_TYPE_NONE,
1200          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1201          "fwt_cleanup"},
1202         {
1203          WLAN_SUBCMD_FWT_TIME,
1204          IW_PRIV_TYPE_NONE,
1205          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1206          "fwt_time"},
1207         {
1208          WLAN_SUBCMD_MESH_GET_TTL,
1209          IW_PRIV_TYPE_NONE,
1210          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1211          "mesh_get_ttl"},
1212         {
1213          WLAN_SETNONE_GETTWELVE_CHAR,
1214          IW_PRIV_TYPE_NONE,
1215          IW_PRIV_TYPE_CHAR | 12,
1216          ""},
1217         {
1218          WLAN_SUBCMD_GETRXANTENNA,
1219          IW_PRIV_TYPE_NONE,
1220          IW_PRIV_TYPE_CHAR | 12,
1221          "getrxant"},
1222         {
1223          WLAN_SUBCMD_GETTXANTENNA,
1224          IW_PRIV_TYPE_NONE,
1225          IW_PRIV_TYPE_CHAR | 12,
1226          "gettxant"},
1227         {
1228          WLAN_GET_TSF,
1229          IW_PRIV_TYPE_NONE,
1230          IW_PRIV_TYPE_CHAR | 12,
1231          "gettsf"},
1232         {
1233          WLAN_SETNONE_GETNONE,
1234          IW_PRIV_TYPE_NONE,
1235          IW_PRIV_TYPE_NONE,
1236          ""},
1237         {
1238          WLANDEAUTH,
1239          IW_PRIV_TYPE_NONE,
1240          IW_PRIV_TYPE_NONE,
1241          "deauth"},
1242         {
1243          WLANADHOCSTOP,
1244          IW_PRIV_TYPE_NONE,
1245          IW_PRIV_TYPE_NONE,
1246          "adhocstop"},
1247         {
1248          WLANRADIOON,
1249          IW_PRIV_TYPE_NONE,
1250          IW_PRIV_TYPE_NONE,
1251          "radioon"},
1252         {
1253          WLANRADIOOFF,
1254          IW_PRIV_TYPE_NONE,
1255          IW_PRIV_TYPE_NONE,
1256          "radiooff"},
1257         {
1258          WLANWLANIDLEON,
1259          IW_PRIV_TYPE_NONE,
1260          IW_PRIV_TYPE_NONE,
1261          "wlanidle-on"},
1262         {
1263          WLANWLANIDLEOFF,
1264          IW_PRIV_TYPE_NONE,
1265          IW_PRIV_TYPE_NONE,
1266          "wlanidle-off"},
1267         {
1268          WLAN_SUBCMD_FWT_RESET,
1269          IW_PRIV_TYPE_NONE,
1270          IW_PRIV_TYPE_NONE,
1271          "fwt_reset"},
1272         {
1273          WLAN_SUBCMD_BT_RESET,
1274          IW_PRIV_TYPE_NONE,
1275          IW_PRIV_TYPE_NONE,
1276          "bt_reset"},
1277         {
1278          WLAN_SET128CHAR_GET128CHAR,
1279          IW_PRIV_TYPE_CHAR | 128,
1280          IW_PRIV_TYPE_CHAR | 128,
1281          ""},
1282         /* BT Management */
1283         {
1284          WLAN_SUBCMD_BT_ADD,
1285          IW_PRIV_TYPE_CHAR | 128,
1286          IW_PRIV_TYPE_CHAR | 128,
1287          "bt_add"},
1288         {
1289          WLAN_SUBCMD_BT_DEL,
1290          IW_PRIV_TYPE_CHAR | 128,
1291          IW_PRIV_TYPE_CHAR | 128,
1292          "bt_del"},
1293         {
1294          WLAN_SUBCMD_BT_LIST,
1295          IW_PRIV_TYPE_CHAR | 128,
1296          IW_PRIV_TYPE_CHAR | 128,
1297          "bt_list"},
1298         /* FWT Management */
1299         {
1300          WLAN_SUBCMD_FWT_ADD,
1301          IW_PRIV_TYPE_CHAR | 128,
1302          IW_PRIV_TYPE_CHAR | 128,
1303          "fwt_add"},
1304         {
1305          WLAN_SUBCMD_FWT_DEL,
1306          IW_PRIV_TYPE_CHAR | 128,
1307          IW_PRIV_TYPE_CHAR | 128,
1308          "fwt_del"},
1309         {
1310          WLAN_SUBCMD_FWT_LOOKUP,
1311          IW_PRIV_TYPE_CHAR | 128,
1312          IW_PRIV_TYPE_CHAR | 128,
1313          "fwt_lookup"},
1314         {
1315          WLAN_SUBCMD_FWT_LIST_NEIGHBOR,
1316          IW_PRIV_TYPE_CHAR | 128,
1317          IW_PRIV_TYPE_CHAR | 128,
1318          "fwt_list_neigh"},
1319         {
1320          WLAN_SUBCMD_FWT_LIST,
1321          IW_PRIV_TYPE_CHAR | 128,
1322          IW_PRIV_TYPE_CHAR | 128,
1323          "fwt_list"},
1324         {
1325          WLAN_SUBCMD_FWT_LIST_ROUTE,
1326          IW_PRIV_TYPE_CHAR | 128,
1327          IW_PRIV_TYPE_CHAR | 128,
1328          "fwt_list_route"},
1329         {
1330          WLANSCAN_MODE,
1331          IW_PRIV_TYPE_CHAR | 128,
1332          IW_PRIV_TYPE_CHAR | 128,
1333          "scanmode"},
1334         {
1335          WLAN_GET_ADHOC_STATUS,
1336          IW_PRIV_TYPE_CHAR | 128,
1337          IW_PRIV_TYPE_CHAR | 128,
1338          "getadhocstatus"},
1339         {
1340          WLAN_SETNONE_GETWORDCHAR,
1341          IW_PRIV_TYPE_NONE,
1342          IW_PRIV_TYPE_CHAR | 128,
1343          ""},
1344         {
1345          WLANSETWPAIE,
1346          IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | 24,
1347          IW_PRIV_TYPE_NONE,
1348          "setwpaie"},
1349         {
1350          WLANGETLOG,
1351          IW_PRIV_TYPE_NONE,
1352          IW_PRIV_TYPE_CHAR | GETLOG_BUFSIZE,
1353          "getlog"},
1354         {
1355          WLAN_SET_GET_SIXTEEN_INT,
1356          IW_PRIV_TYPE_INT | 16,
1357          IW_PRIV_TYPE_INT | 16,
1358          ""},
1359         {
1360          WLAN_TPCCFG,
1361          IW_PRIV_TYPE_INT | 16,
1362          IW_PRIV_TYPE_INT | 16,
1363          "tpccfg"},
1364         {
1365          WLAN_POWERCFG,
1366          IW_PRIV_TYPE_INT | 16,
1367          IW_PRIV_TYPE_INT | 16,
1368          "powercfg"},
1369         {
1370          WLAN_AUTO_FREQ_SET,
1371          IW_PRIV_TYPE_INT | 16,
1372          IW_PRIV_TYPE_INT | 16,
1373          "setafc"},
1374         {
1375          WLAN_AUTO_FREQ_GET,
1376          IW_PRIV_TYPE_INT | 16,
1377          IW_PRIV_TYPE_INT | 16,
1378          "getafc"},
1379         {
1380          WLAN_SCANPROBES,
1381          IW_PRIV_TYPE_INT | 16,
1382          IW_PRIV_TYPE_INT | 16,
1383          "scanprobes"},
1384         {
1385          WLAN_LED_GPIO_CTRL,
1386          IW_PRIV_TYPE_INT | 16,
1387          IW_PRIV_TYPE_INT | 16,
1388          "ledgpio"},
1389         {
1390          WLAN_ADAPT_RATESET,
1391          IW_PRIV_TYPE_INT | 16,
1392          IW_PRIV_TYPE_INT | 16,
1393          "rateadapt"},
1394         {
1395          WLAN_INACTIVITY_TIMEOUT,
1396          IW_PRIV_TYPE_INT | 16,
1397          IW_PRIV_TYPE_INT | 16,
1398          "inactivityto"},
1399         {
1400          WLANSNR,
1401          IW_PRIV_TYPE_INT | 16,
1402          IW_PRIV_TYPE_INT | 16,
1403          "getSNR"},
1404         {
1405          WLAN_GET_RATE,
1406          IW_PRIV_TYPE_INT | 16,
1407          IW_PRIV_TYPE_INT | 16,
1408          "getrate"},
1409         {
1410          WLAN_GET_RXINFO,
1411          IW_PRIV_TYPE_INT | 16,
1412          IW_PRIV_TYPE_INT | 16,
1413          "getrxinfo"},
1414 };
1415
1416 static struct iw_statistics *wlan_get_wireless_stats(struct net_device *dev)
1417 {
1418         enum {
1419                 POOR = 30,
1420                 FAIR = 60,
1421                 GOOD = 80,
1422                 VERY_GOOD = 90,
1423                 EXCELLENT = 95,
1424                 PERFECT = 100
1425         };
1426         wlan_private *priv = dev->priv;
1427         wlan_adapter *adapter = priv->adapter;
1428         u32 rssi_qual;
1429         u32 tx_qual;
1430         u32 quality = 0;
1431         int stats_valid = 0;
1432         u8 rssi;
1433         u32 tx_retries;
1434
1435         ENTER();
1436
1437         priv->wstats.status = adapter->inframode;
1438
1439         /* If we're not associated, all quality values are meaningless */
1440         if (adapter->connect_status != libertas_connected)
1441                 goto out;
1442
1443         /* Quality by RSSI */
1444         priv->wstats.qual.level =
1445             CAL_RSSI(adapter->SNR[TYPE_BEACON][TYPE_NOAVG],
1446              adapter->NF[TYPE_BEACON][TYPE_NOAVG]);
1447
1448         if (adapter->NF[TYPE_BEACON][TYPE_NOAVG] == 0) {
1449                 priv->wstats.qual.noise = MRVDRV_NF_DEFAULT_SCAN_VALUE;
1450         } else {
1451                 priv->wstats.qual.noise =
1452                     CAL_NF(adapter->NF[TYPE_BEACON][TYPE_NOAVG]);
1453         }
1454
1455         lbs_pr_debug(1, "Signal Level = %#x\n", priv->wstats.qual.level);
1456         lbs_pr_debug(1, "Noise = %#x\n", priv->wstats.qual.noise);
1457
1458         rssi = priv->wstats.qual.level - priv->wstats.qual.noise;
1459         if (rssi < 15)
1460                 rssi_qual = rssi * POOR / 10;
1461         else if (rssi < 20)
1462                 rssi_qual = (rssi - 15) * (FAIR - POOR) / 5 + POOR;
1463         else if (rssi < 30)
1464                 rssi_qual = (rssi - 20) * (GOOD - FAIR) / 5 + FAIR;
1465         else if (rssi < 40)
1466                 rssi_qual = (rssi - 30) * (VERY_GOOD - GOOD) /
1467                     10 + GOOD;
1468         else
1469                 rssi_qual = (rssi - 40) * (PERFECT - VERY_GOOD) /
1470                     10 + VERY_GOOD;
1471         quality = rssi_qual;
1472
1473         /* Quality by TX errors */
1474         priv->wstats.discard.retries = priv->stats.tx_errors;
1475
1476         tx_retries = adapter->logmsg.retry;
1477
1478         if (tx_retries > 75)
1479                 tx_qual = (90 - tx_retries) * POOR / 15;
1480         else if (tx_retries > 70)
1481                 tx_qual = (75 - tx_retries) * (FAIR - POOR) / 5 + POOR;
1482         else if (tx_retries > 65)
1483                 tx_qual = (70 - tx_retries) * (GOOD - FAIR) / 5 + FAIR;
1484         else if (tx_retries > 50)
1485                 tx_qual = (65 - tx_retries) * (VERY_GOOD - GOOD) /
1486                     15 + GOOD;
1487         else
1488                 tx_qual = (50 - tx_retries) *
1489                     (PERFECT - VERY_GOOD) / 50 + VERY_GOOD;
1490         quality = min(quality, tx_qual);
1491
1492         priv->wstats.discard.code = adapter->logmsg.wepundecryptable;
1493         priv->wstats.discard.fragment = adapter->logmsg.fcserror;
1494         priv->wstats.discard.retries = tx_retries;
1495         priv->wstats.discard.misc = adapter->logmsg.ackfailure;
1496
1497         /* Calculate quality */
1498         priv->wstats.qual.qual = max(quality, (u32)100);
1499         priv->wstats.qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
1500         stats_valid = 1;
1501
1502         /* update stats asynchronously for future calls */
1503         libertas_prepare_and_send_command(priv, cmd_802_11_rssi, 0,
1504                                         0, 0, NULL);
1505         libertas_prepare_and_send_command(priv, cmd_802_11_get_log, 0,
1506                                         0, 0, NULL);
1507 out:
1508         if (!stats_valid) {
1509                 priv->wstats.miss.beacon = 0;
1510                 priv->wstats.discard.retries = 0;
1511                 priv->wstats.qual.qual = 0;
1512                 priv->wstats.qual.level = 0;
1513                 priv->wstats.qual.noise = 0;
1514                 priv->wstats.qual.updated = IW_QUAL_ALL_UPDATED;
1515                 priv->wstats.qual.updated |= IW_QUAL_NOISE_INVALID |
1516                     IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
1517         }
1518
1519         LEAVE ();
1520         return &priv->wstats;
1521
1522
1523 }
1524
1525 static int wlan_set_freq(struct net_device *dev, struct iw_request_info *info,
1526                   struct iw_freq *fwrq, char *extra)
1527 {
1528         int ret = 0;
1529         wlan_private *priv = dev->priv;
1530         wlan_adapter *adapter = priv->adapter;
1531         int rc = -EINPROGRESS;  /* Call commit handler */
1532         struct chan_freq_power *cfp;
1533
1534         ENTER();
1535
1536         /*
1537          * If setting by frequency, convert to a channel
1538          */
1539         if (fwrq->e == 1) {
1540
1541                 long f = fwrq->m / 100000;
1542                 int c = 0;
1543
1544                 cfp = find_cfp_by_band_and_freq(adapter, 0, f);
1545                 if (!cfp) {
1546                         lbs_pr_debug(1, "Invalid freq=%ld\n", f);
1547                         return -EINVAL;
1548                 }
1549
1550                 c = (int)cfp->channel;
1551
1552                 if (c < 0)
1553                         return -EINVAL;
1554
1555                 fwrq->e = 0;
1556                 fwrq->m = c;
1557         }
1558
1559         /*
1560          * Setting by channel number
1561          */
1562         if (fwrq->m > 1000 || fwrq->e > 0) {
1563                 rc = -EOPNOTSUPP;
1564         } else {
1565                 int channel = fwrq->m;
1566
1567                 cfp = libertas_find_cfp_by_band_and_channel(adapter, 0, channel);
1568                 if (!cfp) {
1569                         rc = -EINVAL;
1570                 } else {
1571                         if (adapter->inframode == wlan802_11ibss) {
1572                                 rc = changeadhocchannel(priv, channel);
1573                                 /*  If station is WEP enabled, send the
1574                                  *  command to set WEP in firmware
1575                                  */
1576                                 if (adapter->secinfo.WEPstatus ==
1577                                     wlan802_11WEPenabled) {
1578                                         lbs_pr_debug(1, "set_freq: WEP enabled\n");
1579                                         ret = libertas_prepare_and_send_command(priv,
1580                                                                     cmd_802_11_set_wep,
1581                                                                     cmd_act_add,
1582                                                                     cmd_option_waitforrsp,
1583                                                                     0,
1584                                                                     NULL);
1585
1586                                         if (ret) {
1587                                                 LEAVE();
1588                                                 return ret;
1589                                         }
1590
1591                                         adapter->currentpacketfilter |=
1592                                             cmd_act_mac_wep_enable;
1593
1594                                         libertas_set_mac_packet_filter(priv);
1595                                 }
1596                         } else {
1597                                 rc = -EOPNOTSUPP;
1598                         }
1599                 }
1600         }
1601
1602         LEAVE();
1603         return rc;
1604 }
1605
1606 /**
1607  *  @brief use index to get the data rate
1608  *
1609  *  @param index                The index of data rate
1610  *  @return                     data rate or 0
1611  */
1612 u32 libertas_index_to_data_rate(u8 index)
1613 {
1614         if (index >= sizeof(libertas_wlan_data_rates))
1615                 index = 0;
1616
1617         return libertas_wlan_data_rates[index];
1618 }
1619
1620 /**
1621  *  @brief use rate to get the index
1622  *
1623  *  @param rate                 data rate
1624  *  @return                     index or 0
1625  */
1626 u8 libertas_data_rate_to_index(u32 rate)
1627 {
1628         u8 *ptr;
1629
1630         if (rate)
1631                 if ((ptr = memchr(libertas_wlan_data_rates, (u8) rate,
1632                                   sizeof(libertas_wlan_data_rates))))
1633                         return (ptr - libertas_wlan_data_rates);
1634
1635         return 0;
1636 }
1637
1638 static int wlan_set_rate(struct net_device *dev, struct iw_request_info *info,
1639                   struct iw_param *vwrq, char *extra)
1640 {
1641         wlan_private *priv = dev->priv;
1642         wlan_adapter *adapter = priv->adapter;
1643         u32 data_rate;
1644         u16 action;
1645         int ret = 0;
1646         u8 rates[WLAN_SUPPORTED_RATES];
1647         u8 *rate;
1648
1649         ENTER();
1650
1651         lbs_pr_debug(1, "Vwrq->value = %d\n", vwrq->value);
1652
1653         if (vwrq->value == -1) {
1654                 action = cmd_act_set_tx_auto;   // Auto
1655                 adapter->is_datarate_auto = 1;
1656                 adapter->datarate = 0;
1657         } else {
1658                 if (vwrq->value % 100000) {
1659                         return -EINVAL;
1660                 }
1661
1662                 data_rate = vwrq->value / 500000;
1663
1664                 memset(rates, 0, sizeof(rates));
1665                 get_active_data_rates(adapter, rates);
1666                 rate = rates;
1667                 while (*rate) {
1668                         lbs_pr_debug(1, "Rate=0x%X  Wanted=0x%X\n", *rate,
1669                                data_rate);
1670                         if ((*rate & 0x7f) == (data_rate & 0x7f))
1671                                 break;
1672                         rate++;
1673                 }
1674                 if (!*rate) {
1675                         lbs_pr_alert( "The fixed data rate 0x%X is out "
1676                                "of range.\n", data_rate);
1677                         return -EINVAL;
1678                 }
1679
1680                 adapter->datarate = data_rate;
1681                 action = cmd_act_set_tx_fix_rate;
1682                 adapter->is_datarate_auto = 0;
1683         }
1684
1685         ret = libertas_prepare_and_send_command(priv, cmd_802_11_data_rate,
1686                                     action, cmd_option_waitforrsp, 0, NULL);
1687
1688         LEAVE();
1689         return ret;
1690 }
1691
1692 static int wlan_get_rate(struct net_device *dev, struct iw_request_info *info,
1693                   struct iw_param *vwrq, char *extra)
1694 {
1695         wlan_private *priv = dev->priv;
1696         wlan_adapter *adapter = priv->adapter;
1697
1698         ENTER();
1699
1700         if (adapter->is_datarate_auto) {
1701                 vwrq->fixed = 0;
1702         } else {
1703                 vwrq->fixed = 1;
1704         }
1705
1706         vwrq->value = adapter->datarate * 500000;
1707
1708         LEAVE();
1709         return 0;
1710 }
1711
1712 static int wlan_set_mode(struct net_device *dev,
1713                   struct iw_request_info *info, u32 * uwrq, char *extra)
1714 {
1715         int ret = 0;
1716         wlan_private *priv = dev->priv;
1717         wlan_adapter *adapter = priv->adapter;
1718         struct assoc_request * assoc_req;
1719         enum WLAN_802_11_NETWORK_INFRASTRUCTURE new_mode;
1720
1721         ENTER();
1722
1723         switch (*uwrq) {
1724         case IW_MODE_ADHOC:
1725                 lbs_pr_debug(1, "Wanted mode is ad-hoc: current datarate=%#x\n",
1726                        adapter->datarate);
1727                 new_mode = wlan802_11ibss;
1728                 adapter->adhocchannel = DEFAULT_AD_HOC_CHANNEL;
1729                 break;
1730
1731         case IW_MODE_INFRA:
1732                 lbs_pr_debug(1, "Wanted mode is Infrastructure\n");
1733                 new_mode = wlan802_11infrastructure;
1734                 break;
1735
1736         case IW_MODE_AUTO:
1737                 lbs_pr_debug(1, "Wanted mode is Auto\n");
1738                 new_mode = wlan802_11autounknown;
1739                 break;
1740
1741         default:
1742                 lbs_pr_debug(1, "Wanted mode is Unknown: 0x%x\n", *uwrq);
1743                 return -EINVAL;
1744         }
1745
1746         mutex_lock(&adapter->lock);
1747         assoc_req = wlan_get_association_request(adapter);
1748         if (!assoc_req) {
1749                 ret = -ENOMEM;
1750         } else {
1751                 assoc_req->mode = new_mode;
1752         }
1753
1754         if (ret == 0) {
1755                 set_bit(ASSOC_FLAG_MODE, &assoc_req->flags);
1756                 wlan_postpone_association_work(priv);
1757         } else {
1758                 wlan_cancel_association_work(priv);
1759         }
1760         mutex_unlock(&adapter->lock);
1761
1762         LEAVE();
1763         return ret;
1764 }
1765
1766
1767 /**
1768  *  @brief Get Encryption key
1769  *
1770  *  @param dev                  A pointer to net_device structure
1771  *  @param info                 A pointer to iw_request_info structure
1772  *  @param vwrq                 A pointer to iw_param structure
1773  *  @param extra                A pointer to extra data buf
1774  *  @return                     0 --success, otherwise fail
1775  */
1776 static int wlan_get_encode(struct net_device *dev,
1777                            struct iw_request_info *info,
1778                            struct iw_point *dwrq, u8 * extra)
1779 {
1780         wlan_private *priv = dev->priv;
1781         wlan_adapter *adapter = priv->adapter;
1782         int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1783
1784         ENTER();
1785
1786         lbs_pr_debug(1, "flags=0x%x index=%d length=%d wep_tx_keyidx=%d\n",
1787                dwrq->flags, index, dwrq->length, adapter->wep_tx_keyidx);
1788
1789         dwrq->flags = 0;
1790
1791         /* Authentication method */
1792         switch (adapter->secinfo.authmode) {
1793         case wlan802_11authmodeopen:
1794                 dwrq->flags = IW_ENCODE_OPEN;
1795                 break;
1796
1797         case wlan802_11authmodeshared:
1798         case wlan802_11authmodenetworkEAP:
1799                 dwrq->flags = IW_ENCODE_RESTRICTED;
1800                 break;
1801         default:
1802                 dwrq->flags = IW_ENCODE_DISABLED | IW_ENCODE_OPEN;
1803                 break;
1804         }
1805
1806         if ((adapter->secinfo.WEPstatus == wlan802_11WEPenabled)
1807             || adapter->secinfo.WPAenabled || adapter->secinfo.WPA2enabled) {
1808                 dwrq->flags &= ~IW_ENCODE_DISABLED;
1809         } else {
1810                 dwrq->flags |= IW_ENCODE_DISABLED;
1811         }
1812
1813         memset(extra, 0, 16);
1814
1815         mutex_lock(&adapter->lock);
1816
1817         /* Default to returning current transmit key */
1818         if (index < 0)
1819                 index = adapter->wep_tx_keyidx;
1820
1821         if ((adapter->wep_keys[index].len) &&
1822             (adapter->secinfo.WEPstatus == wlan802_11WEPenabled)) {
1823                 memcpy(extra, adapter->wep_keys[index].key,
1824                        adapter->wep_keys[index].len);
1825                 dwrq->length = adapter->wep_keys[index].len;
1826
1827                 dwrq->flags |= (index + 1);
1828                 /* Return WEP enabled */
1829                 dwrq->flags &= ~IW_ENCODE_DISABLED;
1830         } else if ((adapter->secinfo.WPAenabled)
1831                    || (adapter->secinfo.WPA2enabled)) {
1832                 /* return WPA enabled */
1833                 dwrq->flags &= ~IW_ENCODE_DISABLED;
1834         } else {
1835                 dwrq->flags |= IW_ENCODE_DISABLED;
1836         }
1837
1838         mutex_unlock(&adapter->lock);
1839
1840         dwrq->flags |= IW_ENCODE_NOKEY;
1841
1842         lbs_pr_debug(1, "key:%02x:%02x:%02x:%02x:%02x:%02x keylen=%d\n",
1843                extra[0], extra[1], extra[2],
1844                extra[3], extra[4], extra[5], dwrq->length);
1845
1846         lbs_pr_debug(1, "Return flags=0x%x\n", dwrq->flags);
1847
1848         LEAVE();
1849         return 0;
1850 }
1851
1852 /**
1853  *  @brief Set Encryption key (internal)
1854  *
1855  *  @param priv                 A pointer to private card structure
1856  *  @param key_material         A pointer to key material
1857  *  @param key_length           length of key material
1858  *  @param index                key index to set
1859  *  @param set_tx_key           Force set TX key (1 = yes, 0 = no)
1860  *  @return                     0 --success, otherwise fail
1861  */
1862 static int wlan_set_wep_key(struct assoc_request *assoc_req,
1863                             const char *key_material,
1864                             u16 key_length,
1865                             u16 index,
1866                             int set_tx_key)
1867 {
1868         struct WLAN_802_11_KEY *pkey;
1869
1870         ENTER();
1871
1872         /* Paranoid validation of key index */
1873         if (index > 3) {
1874                 LEAVE();
1875                 return -EINVAL;
1876         }
1877
1878         /* validate max key length */
1879         if (key_length > KEY_LEN_WEP_104) {
1880                 LEAVE();
1881                 return -EINVAL;
1882         }
1883
1884         pkey = &assoc_req->wep_keys[index];
1885
1886         if (key_length > 0) {
1887                 memset(pkey, 0, sizeof(struct WLAN_802_11_KEY));
1888                 pkey->type = KEY_TYPE_ID_WEP;
1889
1890                 /* Standardize the key length */
1891                 pkey->len = (key_length > KEY_LEN_WEP_40) ?
1892                                 KEY_LEN_WEP_104 : KEY_LEN_WEP_40;
1893                 memcpy(pkey->key, key_material, key_length);
1894         }
1895
1896         if (set_tx_key) {
1897                 /* Ensure the chosen key is valid */
1898                 if (!pkey->len) {
1899                         lbs_pr_debug(1, "key not set, so cannot enable it\n");
1900                         LEAVE();
1901                         return -EINVAL;
1902                 }
1903                 assoc_req->wep_tx_keyidx = index;
1904         }
1905
1906         assoc_req->secinfo.WEPstatus = wlan802_11WEPenabled;
1907
1908         LEAVE();
1909         return 0;
1910 }
1911
1912 static int validate_key_index(u16 def_index, u16 raw_index,
1913                               u16 *out_index, u16 *is_default)
1914 {
1915         if (!out_index || !is_default)
1916                 return -EINVAL;
1917
1918         /* Verify index if present, otherwise use default TX key index */
1919         if (raw_index > 0) {
1920                 if (raw_index > 4)
1921                         return -EINVAL;
1922                 *out_index = raw_index - 1;
1923         } else {
1924                 *out_index = def_index;
1925                 *is_default = 1;
1926         }
1927         return 0;
1928 }
1929
1930 static void disable_wep(struct assoc_request *assoc_req)
1931 {
1932         int i;
1933
1934         /* Set Open System auth mode */
1935         assoc_req->secinfo.authmode = wlan802_11authmodeopen;
1936
1937         /* Clear WEP keys and mark WEP as disabled */
1938         assoc_req->secinfo.WEPstatus = wlan802_11WEPdisabled;
1939         for (i = 0; i < 4; i++)
1940                 assoc_req->wep_keys[i].len = 0;
1941
1942         set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
1943         set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
1944 }
1945
1946 /**
1947  *  @brief Set Encryption key
1948  *
1949  *  @param dev                  A pointer to net_device structure
1950  *  @param info                 A pointer to iw_request_info structure
1951  *  @param vwrq                 A pointer to iw_param structure
1952  *  @param extra                A pointer to extra data buf
1953  *  @return                     0 --success, otherwise fail
1954  */
1955 static int wlan_set_encode(struct net_device *dev,
1956                     struct iw_request_info *info,
1957                     struct iw_point *dwrq, char *extra)
1958 {
1959         int ret = 0;
1960         wlan_private *priv = dev->priv;
1961         wlan_adapter *adapter = priv->adapter;
1962         struct assoc_request * assoc_req;
1963         u16 is_default = 0, index = 0, set_tx_key = 0;
1964
1965         ENTER();
1966
1967         mutex_lock(&adapter->lock);
1968         assoc_req = wlan_get_association_request(adapter);
1969         if (!assoc_req) {
1970                 ret = -ENOMEM;
1971                 goto out;
1972         }
1973
1974         if (dwrq->flags & IW_ENCODE_DISABLED) {
1975                 disable_wep (assoc_req);
1976                 goto out;
1977         }
1978
1979         ret = validate_key_index(assoc_req->wep_tx_keyidx,
1980                                  (dwrq->flags & IW_ENCODE_INDEX),
1981                                  &index, &is_default);
1982         if (ret) {
1983                 ret = -EINVAL;
1984                 goto out;
1985         }
1986
1987         /* If WEP isn't enabled, or if there is no key data but a valid
1988          * index, set the TX key.
1989          */
1990         if ((assoc_req->secinfo.WEPstatus != wlan802_11WEPenabled)
1991             || (dwrq->length == 0 && !is_default))
1992                 set_tx_key = 1;
1993
1994         ret = wlan_set_wep_key(assoc_req, extra, dwrq->length, index, set_tx_key);
1995         if (ret)
1996                 goto out;
1997
1998         if (dwrq->length)
1999                 set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
2000         if (set_tx_key)
2001                 set_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags);
2002
2003         if (dwrq->flags & IW_ENCODE_RESTRICTED) {
2004                 assoc_req->secinfo.authmode = wlan802_11authmodeshared;
2005         } else if (dwrq->flags & IW_ENCODE_OPEN) {
2006                 assoc_req->secinfo.authmode = wlan802_11authmodeopen;
2007         }
2008
2009 out:
2010         if (ret == 0) {
2011                 set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
2012                 wlan_postpone_association_work(priv);
2013         } else {
2014                 wlan_cancel_association_work(priv);
2015         }
2016         mutex_unlock(&adapter->lock);
2017
2018         LEAVE();
2019         return ret;
2020 }
2021
2022 /**
2023  *  @brief Get Extended Encryption key (WPA/802.1x and WEP)
2024  *
2025  *  @param dev                  A pointer to net_device structure
2026  *  @param info                 A pointer to iw_request_info structure
2027  *  @param vwrq                 A pointer to iw_param structure
2028  *  @param extra                A pointer to extra data buf
2029  *  @return                     0 on success, otherwise failure
2030  */
2031 static int wlan_get_encodeext(struct net_device *dev,
2032                               struct iw_request_info *info,
2033                               struct iw_point *dwrq,
2034                               char *extra)
2035 {
2036         int ret = -EINVAL;
2037         wlan_private *priv = dev->priv;
2038         wlan_adapter *adapter = priv->adapter;
2039         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
2040         int index, max_key_len;
2041
2042         ENTER();
2043
2044         max_key_len = dwrq->length - sizeof(*ext);
2045         if (max_key_len < 0)
2046                 goto out;
2047
2048         index = dwrq->flags & IW_ENCODE_INDEX;
2049         if (index) {
2050                 if (index < 1 || index > 4)
2051                         goto out;
2052                 index--;
2053         } else {
2054                 index = adapter->wep_tx_keyidx;
2055         }
2056
2057         if (!ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY &&
2058             ext->alg != IW_ENCODE_ALG_WEP) {
2059                 if (index != 0 || adapter->inframode != wlan802_11infrastructure)
2060                         goto out;
2061         }
2062
2063         dwrq->flags = index + 1;
2064         memset(ext, 0, sizeof(*ext));
2065
2066         if ((adapter->secinfo.WEPstatus == wlan802_11WEPdisabled)
2067             && !adapter->secinfo.WPAenabled && !adapter->secinfo.WPA2enabled) {
2068                 ext->alg = IW_ENCODE_ALG_NONE;
2069                 ext->key_len = 0;
2070                 dwrq->flags |= IW_ENCODE_DISABLED;
2071         } else {
2072                 u8 *key = NULL;
2073
2074                 if ((adapter->secinfo.WEPstatus == wlan802_11WEPenabled)
2075                     && !adapter->secinfo.WPAenabled
2076                     && !adapter->secinfo.WPA2enabled) {
2077                         ext->alg = IW_ENCODE_ALG_WEP;
2078                         ext->key_len = adapter->wep_keys[index].len;
2079                         key = &adapter->wep_keys[index].key[0];
2080                 } else if ((adapter->secinfo.WEPstatus == wlan802_11WEPdisabled) &&
2081                            (adapter->secinfo.WPAenabled ||
2082                             adapter->secinfo.WPA2enabled)) {
2083                         /* WPA */
2084                         ext->alg = IW_ENCODE_ALG_TKIP;
2085                         ext->key_len = 0;
2086                 } else {
2087                         goto out;
2088                 }
2089
2090                 if (ext->key_len > max_key_len) {
2091                         ret = -E2BIG;
2092                         goto out;
2093                 }
2094
2095                 if (ext->key_len)
2096                         memcpy(ext->key, key, ext->key_len);
2097                 else
2098                         dwrq->flags |= IW_ENCODE_NOKEY;
2099                 dwrq->flags |= IW_ENCODE_ENABLED;
2100         }
2101         ret = 0;
2102
2103 out:
2104         LEAVE();
2105         return ret;
2106 }
2107
2108 /**
2109  *  @brief Set Encryption key Extended (WPA/802.1x and WEP)
2110  *
2111  *  @param dev                  A pointer to net_device structure
2112  *  @param info                 A pointer to iw_request_info structure
2113  *  @param vwrq                 A pointer to iw_param structure
2114  *  @param extra                A pointer to extra data buf
2115  *  @return                     0 --success, otherwise fail
2116  */
2117 static int wlan_set_encodeext(struct net_device *dev,
2118                               struct iw_request_info *info,
2119                               struct iw_point *dwrq,
2120                               char *extra)
2121 {
2122         int ret = 0;
2123         wlan_private *priv = dev->priv;
2124         wlan_adapter *adapter = priv->adapter;
2125         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
2126         int alg = ext->alg;
2127         struct assoc_request * assoc_req;
2128
2129         ENTER();
2130
2131         mutex_lock(&adapter->lock);
2132         assoc_req = wlan_get_association_request(adapter);
2133         if (!assoc_req) {
2134                 ret = -ENOMEM;
2135                 goto out;
2136         }
2137
2138         if ((alg == IW_ENCODE_ALG_NONE) || (dwrq->flags & IW_ENCODE_DISABLED)) {
2139                 disable_wep (assoc_req);
2140         } else if (alg == IW_ENCODE_ALG_WEP) {
2141                 u16 is_default = 0, index, set_tx_key = 0;
2142
2143                 ret = validate_key_index(assoc_req->wep_tx_keyidx,
2144                                          (dwrq->flags & IW_ENCODE_INDEX),
2145                                          &index, &is_default);
2146                 if (ret)
2147                         goto out;
2148
2149                 /* If WEP isn't enabled, or if there is no key data but a valid
2150                  * index, or if the set-TX-key flag was passed, set the TX key.
2151                  */
2152                 if ((assoc_req->secinfo.WEPstatus != wlan802_11WEPenabled)
2153                     || (dwrq->length == 0 && !is_default)
2154                     || (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY))
2155                         set_tx_key = 1;
2156
2157                 /* Copy key to driver */
2158                 ret = wlan_set_wep_key (assoc_req, ext->key, ext->key_len, index,
2159                                         set_tx_key);
2160                 if (ret)
2161                         goto out;
2162
2163                 if (dwrq->flags & IW_ENCODE_RESTRICTED) {
2164                         assoc_req->secinfo.authmode =
2165                             wlan802_11authmodeshared;
2166                 } else if (dwrq->flags & IW_ENCODE_OPEN) {
2167                         assoc_req->secinfo.authmode =
2168                             wlan802_11authmodeopen;
2169                 }
2170
2171                 /* Mark the various WEP bits as modified */
2172                 set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
2173                 if (dwrq->length)
2174                         set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
2175                 if (set_tx_key)
2176                         set_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags);
2177
2178         } else if ((alg == IW_ENCODE_ALG_TKIP) || (alg == IW_ENCODE_ALG_CCMP)) {
2179                 struct WLAN_802_11_KEY * pkey;
2180
2181                 /* validate key length */
2182                 if (((alg == IW_ENCODE_ALG_TKIP)
2183                         && (ext->key_len != KEY_LEN_WPA_TKIP))
2184                     || ((alg == IW_ENCODE_ALG_CCMP)
2185                         && (ext->key_len != KEY_LEN_WPA_AES))) {
2186                                 lbs_pr_debug(1, "Invalid size %d for key of alg"
2187                                        "type %d.\n",
2188                                        ext->key_len,
2189                                        alg);
2190                                 ret = -EINVAL;
2191                                 goto out;
2192                 }
2193
2194                 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
2195                         pkey = &assoc_req->wpa_mcast_key;
2196                 else
2197                         pkey = &assoc_req->wpa_unicast_key;
2198
2199                 memset(pkey, 0, sizeof (struct WLAN_802_11_KEY));
2200                 memcpy(pkey->key, ext->key, ext->key_len);
2201                 pkey->len = ext->key_len;
2202                 pkey->flags = KEY_INFO_WPA_ENABLED;
2203
2204                 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
2205                         pkey->flags |= KEY_INFO_WPA_MCAST;
2206                         set_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags);
2207                 } else {
2208                         pkey->flags |= KEY_INFO_WPA_UNICAST;
2209                         set_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags);
2210                 }
2211
2212                 if (alg == IW_ENCODE_ALG_TKIP)
2213                         pkey->type = KEY_TYPE_ID_TKIP;
2214                 else if (alg == IW_ENCODE_ALG_CCMP)
2215                         pkey->type = KEY_TYPE_ID_AES;
2216
2217                 /* If WPA isn't enabled yet, do that now */
2218                 if (   assoc_req->secinfo.WPAenabled == 0
2219                     && assoc_req->secinfo.WPA2enabled == 0) {
2220                         assoc_req->secinfo.WPAenabled = 1;
2221                         assoc_req->secinfo.WPA2enabled = 1;
2222                         set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
2223                 }
2224
2225                 disable_wep (assoc_req);
2226         }
2227
2228 out:
2229         if (ret == 0) {
2230                 wlan_postpone_association_work(priv);
2231         } else {
2232                 wlan_cancel_association_work(priv);
2233         }
2234         mutex_unlock(&adapter->lock);
2235
2236         LEAVE();
2237         return ret;
2238 }
2239
2240
2241 static int wlan_set_genie(struct net_device *dev,
2242                           struct iw_request_info *info,
2243                           struct iw_point *dwrq,
2244                           char *extra)
2245 {
2246         wlan_private *priv = dev->priv;
2247         wlan_adapter *adapter = priv->adapter;
2248         int ret = 0;
2249         struct assoc_request * assoc_req;
2250
2251         ENTER();
2252
2253         mutex_lock(&adapter->lock);
2254         assoc_req = wlan_get_association_request(adapter);
2255         if (!assoc_req) {
2256                 ret = -ENOMEM;
2257                 goto out;
2258         }
2259
2260         if (dwrq->length > MAX_WPA_IE_LEN ||
2261             (dwrq->length && extra == NULL)) {
2262                 ret = -EINVAL;
2263                 goto out;
2264         }
2265
2266         if (dwrq->length) {
2267                 memcpy(&assoc_req->wpa_ie[0], extra, dwrq->length);
2268                 assoc_req->wpa_ie_len = dwrq->length;
2269         } else {
2270                 memset(&assoc_req->wpa_ie[0], 0, sizeof(adapter->wpa_ie));
2271                 assoc_req->wpa_ie_len = 0;
2272         }
2273
2274 out:
2275         if (ret == 0) {
2276                 set_bit(ASSOC_FLAG_WPA_IE, &assoc_req->flags);
2277                 wlan_postpone_association_work(priv);
2278         } else {
2279                 wlan_cancel_association_work(priv);
2280         }
2281         mutex_unlock(&adapter->lock);
2282
2283         LEAVE();
2284         return ret;
2285 }
2286
2287 static int wlan_get_genie(struct net_device *dev,
2288                           struct iw_request_info *info,
2289                           struct iw_point *dwrq,
2290                           char *extra)
2291 {
2292         wlan_private *priv = dev->priv;
2293         wlan_adapter *adapter = priv->adapter;
2294
2295         ENTER();
2296
2297         if (adapter->wpa_ie_len == 0) {
2298                 dwrq->length = 0;
2299                 LEAVE();
2300                 return 0;
2301         }
2302
2303         if (dwrq->length < adapter->wpa_ie_len) {
2304                 LEAVE();
2305                 return -E2BIG;
2306         }
2307
2308         dwrq->length = adapter->wpa_ie_len;
2309         memcpy(extra, &adapter->wpa_ie[0], adapter->wpa_ie_len);
2310
2311         LEAVE();
2312         return 0;
2313 }
2314
2315
2316 static int wlan_set_auth(struct net_device *dev,
2317                          struct iw_request_info *info,
2318                          struct iw_param *dwrq,
2319                          char *extra)
2320 {
2321         wlan_private *priv = dev->priv;
2322         wlan_adapter *adapter = priv->adapter;
2323         struct assoc_request * assoc_req;
2324         int ret = 0;
2325         int updated = 0;
2326
2327         ENTER();
2328
2329         mutex_lock(&adapter->lock);
2330         assoc_req = wlan_get_association_request(adapter);
2331         if (!assoc_req) {
2332                 ret = -ENOMEM;
2333                 goto out;
2334         }
2335
2336         switch (dwrq->flags & IW_AUTH_INDEX) {
2337         case IW_AUTH_TKIP_COUNTERMEASURES:
2338         case IW_AUTH_CIPHER_PAIRWISE:
2339         case IW_AUTH_CIPHER_GROUP:
2340         case IW_AUTH_KEY_MGMT:
2341                 /*
2342                  * libertas does not use these parameters
2343                  */
2344                 break;
2345
2346         case IW_AUTH_WPA_VERSION:
2347                 if (dwrq->value & IW_AUTH_WPA_VERSION_DISABLED) {
2348                         assoc_req->secinfo.WPAenabled = 0;
2349                         assoc_req->secinfo.WPA2enabled = 0;
2350                 }
2351                 if (dwrq->value & IW_AUTH_WPA_VERSION_WPA) {
2352                         assoc_req->secinfo.WPAenabled = 1;
2353                         assoc_req->secinfo.WEPstatus = wlan802_11WEPdisabled;
2354                         assoc_req->secinfo.authmode =
2355                             wlan802_11authmodeopen;
2356                 }
2357                 if (dwrq->value & IW_AUTH_WPA_VERSION_WPA2) {
2358                         assoc_req->secinfo.WPA2enabled = 1;
2359                         assoc_req->secinfo.WEPstatus = wlan802_11WEPdisabled;
2360                         assoc_req->secinfo.authmode =
2361                             wlan802_11authmodeopen;
2362                 }
2363                 updated = 1;
2364                 break;
2365
2366         case IW_AUTH_DROP_UNENCRYPTED:
2367                 if (dwrq->value) {
2368                         adapter->currentpacketfilter |=
2369                             cmd_act_mac_strict_protection_enable;
2370                 } else {
2371                         adapter->currentpacketfilter &=
2372                             ~cmd_act_mac_strict_protection_enable;
2373                 }
2374                 updated = 1;
2375                 break;
2376
2377         case IW_AUTH_80211_AUTH_ALG:
2378                 if (dwrq->value & IW_AUTH_ALG_SHARED_KEY) {
2379                         assoc_req->secinfo.authmode =
2380                             wlan802_11authmodeshared;
2381                 } else if (dwrq->value & IW_AUTH_ALG_OPEN_SYSTEM) {
2382                         assoc_req->secinfo.authmode =
2383                             wlan802_11authmodeopen;
2384                 } else if (dwrq->value & IW_AUTH_ALG_LEAP) {
2385                         assoc_req->secinfo.authmode =
2386                             wlan802_11authmodenetworkEAP;
2387                 } else {
2388                         ret = -EINVAL;
2389                 }
2390                 updated = 1;
2391                 break;
2392
2393         case IW_AUTH_WPA_ENABLED:
2394                 if (dwrq->value) {
2395                         if (!assoc_req->secinfo.WPAenabled &&
2396                             !assoc_req->secinfo.WPA2enabled) {
2397                                 assoc_req->secinfo.WPAenabled = 1;
2398                                 assoc_req->secinfo.WPA2enabled = 1;
2399                                 assoc_req->secinfo.WEPstatus = wlan802_11WEPdisabled;
2400                                 assoc_req->secinfo.authmode =
2401                                     wlan802_11authmodeopen;
2402                         }
2403                 } else {
2404                         assoc_req->secinfo.WPAenabled = 0;
2405                         assoc_req->secinfo.WPA2enabled = 0;
2406                 }
2407                 updated = 1;
2408                 break;
2409
2410         default:
2411                 ret = -EOPNOTSUPP;
2412                 break;
2413         }
2414
2415 out:
2416         if (ret == 0) {
2417                 if (updated)
2418                         set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
2419                 wlan_postpone_association_work(priv);
2420         } else if (ret != -EOPNOTSUPP) {
2421                 wlan_cancel_association_work(priv);
2422         }
2423         mutex_unlock(&adapter->lock);
2424
2425         LEAVE();
2426         return ret;
2427 }
2428
2429 static int wlan_get_auth(struct net_device *dev,
2430                          struct iw_request_info *info,
2431                          struct iw_param *dwrq,
2432                          char *extra)
2433 {
2434         wlan_private *priv = dev->priv;
2435         wlan_adapter *adapter = priv->adapter;
2436
2437         ENTER();
2438
2439         switch (dwrq->flags & IW_AUTH_INDEX) {
2440         case IW_AUTH_WPA_VERSION:
2441                 dwrq->value = 0;
2442                 if (adapter->secinfo.WPAenabled)
2443                         dwrq->value |= IW_AUTH_WPA_VERSION_WPA;
2444                 if (adapter->secinfo.WPA2enabled)
2445                         dwrq->value |= IW_AUTH_WPA_VERSION_WPA2;
2446                 if (!dwrq->value)
2447                         dwrq->value |= IW_AUTH_WPA_VERSION_DISABLED;
2448                 break;
2449
2450         case IW_AUTH_DROP_UNENCRYPTED:
2451                 dwrq->value = 0;
2452                 if (adapter->currentpacketfilter &
2453                     cmd_act_mac_strict_protection_enable)
2454                         dwrq->value = 1;
2455                 break;
2456
2457         case IW_AUTH_80211_AUTH_ALG:
2458                 switch (adapter->secinfo.authmode) {
2459                 case wlan802_11authmodeshared:
2460                         dwrq->value = IW_AUTH_ALG_SHARED_KEY;
2461                         break;
2462                 case wlan802_11authmodeopen:
2463                         dwrq->value = IW_AUTH_ALG_OPEN_SYSTEM;
2464                         break;
2465                 case wlan802_11authmodenetworkEAP:
2466                         dwrq->value = IW_AUTH_ALG_LEAP;
2467                         break;
2468                 default:
2469                         break;
2470                 }
2471                 break;
2472
2473         case IW_AUTH_WPA_ENABLED:
2474                 if (adapter->secinfo.WPAenabled && adapter->secinfo.WPA2enabled)
2475                         dwrq->value = 1;
2476                 break;
2477
2478         default:
2479                 LEAVE();
2480                 return -EOPNOTSUPP;
2481         }
2482
2483         LEAVE();
2484         return 0;
2485 }
2486
2487
2488 static int wlan_set_txpow(struct net_device *dev, struct iw_request_info *info,
2489                    struct iw_param *vwrq, char *extra)
2490 {
2491         int ret = 0;
2492         wlan_private *priv = dev->priv;
2493         wlan_adapter *adapter = priv->adapter;
2494
2495         u16 dbm;
2496
2497         ENTER();
2498
2499         if (vwrq->disabled) {
2500                 wlan_radio_ioctl(priv, RADIO_OFF);
2501                 return 0;
2502         }
2503
2504         adapter->preamble = cmd_type_auto_preamble;
2505
2506         wlan_radio_ioctl(priv, RADIO_ON);
2507
2508         if ((vwrq->flags & IW_TXPOW_TYPE) == IW_TXPOW_MWATT) {
2509                 dbm = (u16) mw_to_dbm(vwrq->value);
2510         } else
2511                 dbm = (u16) vwrq->value;
2512
2513         /* auto tx power control */
2514
2515         if (vwrq->fixed == 0)
2516                 dbm = 0xffff;
2517
2518         lbs_pr_debug(1, "<1>TXPOWER SET %d dbm.\n", dbm);
2519
2520         ret = libertas_prepare_and_send_command(priv,
2521                                     cmd_802_11_rf_tx_power,
2522                                     cmd_act_tx_power_opt_set_low,
2523                                     cmd_option_waitforrsp, 0, (void *)&dbm);
2524
2525         LEAVE();
2526         return ret;
2527 }
2528
2529 static int wlan_get_essid(struct net_device *dev, struct iw_request_info *info,
2530                    struct iw_point *dwrq, char *extra)
2531 {
2532         wlan_private *priv = dev->priv;
2533         wlan_adapter *adapter = priv->adapter;
2534
2535         ENTER();
2536         /*
2537          * Note : if dwrq->flags != 0, we should get the relevant SSID from
2538          * the SSID list...
2539          */
2540
2541         /*
2542          * Get the current SSID
2543          */
2544         if (adapter->connect_status == libertas_connected) {
2545                 memcpy(extra, adapter->curbssparams.ssid.ssid,
2546                        adapter->curbssparams.ssid.ssidlength);
2547                 extra[adapter->curbssparams.ssid.ssidlength] = '\0';
2548         } else {
2549                 memset(extra, 0, 32);
2550                 extra[adapter->curbssparams.ssid.ssidlength] = '\0';
2551         }
2552         /*
2553          * If none, we may want to get the one that was set
2554          */
2555
2556         /* To make the driver backward compatible with WPA supplicant v0.2.4 */
2557         if (dwrq->length == 32) /* check with WPA supplicant buffer size */
2558                 dwrq->length = min_t(size_t, adapter->curbssparams.ssid.ssidlength,
2559                                    IW_ESSID_MAX_SIZE);
2560         else
2561                 dwrq->length = adapter->curbssparams.ssid.ssidlength + 1;
2562
2563         dwrq->flags = 1;        /* active */
2564
2565         LEAVE();
2566         return 0;
2567 }
2568
2569 static int wlan_set_essid(struct net_device *dev, struct iw_request_info *info,
2570                    struct iw_point *dwrq, char *extra)
2571 {
2572         wlan_private *priv = dev->priv;
2573         wlan_adapter *adapter = priv->adapter;
2574         int ret = 0;
2575         struct WLAN_802_11_SSID ssid;
2576         struct assoc_request * assoc_req;
2577         int ssid_len = dwrq->length;
2578
2579         ENTER();
2580
2581         /*
2582          * WE-20 and earlier NULL pad the end of the SSID and increment
2583          * SSID length so it can be used like a string.  WE-21 and later don't,
2584          * but some userspace tools aren't able to cope with the change.
2585          */
2586         if ((ssid_len > 0) && (extra[ssid_len - 1] == '\0'))
2587                 ssid_len--;
2588
2589         /* Check the size of the string */
2590         if (ssid_len > IW_ESSID_MAX_SIZE) {
2591                 ret = -E2BIG;
2592                 goto out;
2593         }
2594
2595         memset(&ssid, 0, sizeof(struct WLAN_802_11_SSID));
2596
2597         if (!dwrq->flags || !ssid_len) {
2598                 /* "any" SSID requested; leave SSID blank */
2599         } else {
2600                 /* Specific SSID requested */
2601                 memcpy(&ssid.ssid, extra, ssid_len);
2602                 ssid.ssidlength = ssid_len;
2603         }
2604
2605         lbs_pr_debug(1, "Requested new SSID = %s\n",
2606                (ssid.ssidlength > 0) ? (char *)ssid.ssid : "any");
2607
2608 out:
2609         mutex_lock(&adapter->lock);
2610         if (ret == 0) {
2611                 /* Get or create the current association request */
2612                 assoc_req = wlan_get_association_request(adapter);
2613                 if (!assoc_req) {
2614                         ret = -ENOMEM;
2615                 } else {
2616                         /* Copy the SSID to the association request */
2617                         memcpy(&assoc_req->ssid, &ssid, sizeof(struct WLAN_802_11_SSID));
2618                         set_bit(ASSOC_FLAG_SSID, &assoc_req->flags);
2619                         wlan_postpone_association_work(priv);
2620                 }
2621         }
2622
2623         /* Cancel the association request if there was an error */
2624         if (ret != 0) {
2625                 wlan_cancel_association_work(priv);
2626         }
2627
2628         mutex_unlock(&adapter->lock);
2629
2630         LEAVE();
2631         return ret;
2632 }
2633
2634 /**
2635  *  @brief Connect to the AP or Ad-hoc Network with specific bssid
2636  *
2637  *  @param dev          A pointer to net_device structure
2638  *  @param info         A pointer to iw_request_info structure
2639  *  @param awrq         A pointer to iw_param structure
2640  *  @param extra        A pointer to extra data buf
2641  *  @return             0 --success, otherwise fail
2642  */
2643 static int wlan_set_wap(struct net_device *dev, struct iw_request_info *info,
2644                  struct sockaddr *awrq, char *extra)
2645 {
2646         wlan_private *priv = dev->priv;
2647         wlan_adapter *adapter = priv->adapter;
2648         struct assoc_request * assoc_req;
2649         int ret = 0;
2650
2651         ENTER();
2652
2653         if (awrq->sa_family != ARPHRD_ETHER)
2654                 return -EINVAL;
2655
2656         lbs_pr_debug(1, "ASSOC: WAP: sa_data: " MAC_FMT "\n", MAC_ARG(awrq->sa_data));
2657
2658         mutex_lock(&adapter->lock);
2659
2660         /* Get or create the current association request */
2661         assoc_req = wlan_get_association_request(adapter);
2662         if (!assoc_req) {
2663                 wlan_cancel_association_work(priv);
2664                 ret = -ENOMEM;
2665         } else {
2666                 /* Copy the BSSID to the association request */
2667                 memcpy(&assoc_req->bssid, awrq->sa_data, ETH_ALEN);
2668                 set_bit(ASSOC_FLAG_BSSID, &assoc_req->flags);
2669                 wlan_postpone_association_work(priv);
2670         }
2671
2672         mutex_unlock(&adapter->lock);
2673
2674         return ret;
2675 }
2676
2677 void libertas_get_fwversion(wlan_adapter * adapter, char *fwversion, int maxlen)
2678 {
2679         union {
2680                 u32 l;
2681                 u8 c[4];
2682         } ver;
2683         char fwver[32];
2684
2685         mutex_lock(&adapter->lock);
2686         ver.l = adapter->fwreleasenumber;
2687         mutex_unlock(&adapter->lock);
2688
2689         if (ver.c[3] == 0)
2690                 sprintf(fwver, "%u.%u.%u", ver.c[2], ver.c[1], ver.c[0]);
2691         else
2692                 sprintf(fwver, "%u.%u.%u.p%u",
2693                         ver.c[2], ver.c[1], ver.c[0], ver.c[3]);
2694
2695         snprintf(fwversion, maxlen, fwver);
2696 }
2697
2698
2699 /*
2700  * iwconfig settable callbacks
2701  */
2702 static const iw_handler wlan_handler[] = {
2703         (iw_handler) NULL,      /* SIOCSIWCOMMIT */
2704         (iw_handler) wlan_get_name,     /* SIOCGIWNAME */
2705         (iw_handler) NULL,      /* SIOCSIWNWID */
2706         (iw_handler) NULL,      /* SIOCGIWNWID */
2707         (iw_handler) wlan_set_freq,     /* SIOCSIWFREQ */
2708         (iw_handler) wlan_get_freq,     /* SIOCGIWFREQ */
2709         (iw_handler) wlan_set_mode,     /* SIOCSIWMODE */
2710         (iw_handler) wlan_get_mode,     /* SIOCGIWMODE */
2711         (iw_handler) NULL,      /* SIOCSIWSENS */
2712         (iw_handler) NULL,      /* SIOCGIWSENS */
2713         (iw_handler) NULL,      /* SIOCSIWRANGE */
2714         (iw_handler) wlan_get_range,    /* SIOCGIWRANGE */
2715         (iw_handler) NULL,      /* SIOCSIWPRIV */
2716         (iw_handler) NULL,      /* SIOCGIWPRIV */
2717         (iw_handler) NULL,      /* SIOCSIWSTATS */
2718         (iw_handler) NULL,      /* SIOCGIWSTATS */
2719         iw_handler_set_spy,     /* SIOCSIWSPY */
2720         iw_handler_get_spy,     /* SIOCGIWSPY */
2721         iw_handler_set_thrspy,  /* SIOCSIWTHRSPY */
2722         iw_handler_get_thrspy,  /* SIOCGIWTHRSPY */
2723         (iw_handler) wlan_set_wap,      /* SIOCSIWAP */
2724         (iw_handler) wlan_get_wap,      /* SIOCGIWAP */
2725         (iw_handler) NULL,      /* SIOCSIWMLME */
2726         (iw_handler) NULL,      /* SIOCGIWAPLIST - deprecated */
2727         (iw_handler) libertas_set_scan, /* SIOCSIWSCAN */
2728         (iw_handler) libertas_get_scan, /* SIOCGIWSCAN */
2729         (iw_handler) wlan_set_essid,    /* SIOCSIWESSID */
2730         (iw_handler) wlan_get_essid,    /* SIOCGIWESSID */
2731         (iw_handler) wlan_set_nick,     /* SIOCSIWNICKN */
2732         (iw_handler) wlan_get_nick,     /* SIOCGIWNICKN */
2733         (iw_handler) NULL,      /* -- hole -- */
2734         (iw_handler) NULL,      /* -- hole -- */
2735         (iw_handler) wlan_set_rate,     /* SIOCSIWRATE */
2736         (iw_handler) wlan_get_rate,     /* SIOCGIWRATE */
2737         (iw_handler) wlan_set_rts,      /* SIOCSIWRTS */
2738         (iw_handler) wlan_get_rts,      /* SIOCGIWRTS */
2739         (iw_handler) wlan_set_frag,     /* SIOCSIWFRAG */
2740         (iw_handler) wlan_get_frag,     /* SIOCGIWFRAG */
2741         (iw_handler) wlan_set_txpow,    /* SIOCSIWTXPOW */
2742         (iw_handler) wlan_get_txpow,    /* SIOCGIWTXPOW */
2743         (iw_handler) wlan_set_retry,    /* SIOCSIWRETRY */
2744         (iw_handler) wlan_get_retry,    /* SIOCGIWRETRY */
2745         (iw_handler) wlan_set_encode,   /* SIOCSIWENCODE */
2746         (iw_handler) wlan_get_encode,   /* SIOCGIWENCODE */
2747         (iw_handler) wlan_set_power,    /* SIOCSIWPOWER */
2748         (iw_handler) wlan_get_power,    /* SIOCGIWPOWER */
2749         (iw_handler) NULL,      /* -- hole -- */
2750         (iw_handler) NULL,      /* -- hole -- */
2751         (iw_handler) wlan_set_genie,    /* SIOCSIWGENIE */
2752         (iw_handler) wlan_get_genie,    /* SIOCGIWGENIE */
2753         (iw_handler) wlan_set_auth,     /* SIOCSIWAUTH */
2754         (iw_handler) wlan_get_auth,     /* SIOCGIWAUTH */
2755         (iw_handler) wlan_set_encodeext,/* SIOCSIWENCODEEXT */
2756         (iw_handler) wlan_get_encodeext,/* SIOCGIWENCODEEXT */
2757         (iw_handler) NULL,              /* SIOCSIWPMKSA */
2758 };
2759
2760 struct iw_handler_def libertas_handler_def = {
2761         .num_standard   = sizeof(wlan_handler) / sizeof(iw_handler),
2762         .num_private    = sizeof(wlan_private_handler) / sizeof(iw_handler),
2763         .num_private_args = sizeof(wlan_private_args) /
2764                 sizeof(struct iw_priv_args),
2765         .standard       = (iw_handler *) wlan_handler,
2766         .private        = (iw_handler *) wlan_private_handler,
2767         .private_args   = (struct iw_priv_args *)wlan_private_args,
2768         .get_wireless_stats = wlan_get_wireless_stats,
2769 };