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