2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005-2006, Devicescape Software, Inc.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/netdevice.h>
13 #include <linux/types.h>
14 #include <linux/slab.h>
15 #include <linux/skbuff.h>
16 #include <linux/etherdevice.h>
17 #include <linux/if_arp.h>
18 #include <linux/wireless.h>
19 #include <net/iw_handler.h>
20 #include <asm/uaccess.h>
22 #include <net/mac80211.h>
23 #include "ieee80211_i.h"
24 #include "hostapd_ioctl.h"
25 #include "ieee80211_rate.h"
29 static int ieee80211_set_encryption(struct net_device *dev, u8 *sta_addr,
30 int idx, int alg, int set_tx_key,
31 const u8 *_key, size_t key_len)
33 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
36 struct ieee80211_key *key;
37 struct ieee80211_sub_if_data *sdata;
39 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
41 if (is_broadcast_ether_addr(sta_addr)) {
43 if (idx >= NUM_DEFAULT_KEYS) {
44 printk(KERN_DEBUG "%s: set_encrypt - invalid idx=%d\n",
48 key = sdata->keys[idx];
52 printk(KERN_DEBUG "%s: set_encrypt - non-zero idx for "
53 "individual key\n", dev->name);
57 sta = sta_info_get(local, sta_addr);
59 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
60 printk(KERN_DEBUG "%s: set_encrypt - unknown addr "
62 dev->name, MAC_ARG(sta_addr));
63 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
71 if (alg == ALG_NONE) {
72 ieee80211_key_free(key);
76 * Need to free it before allocating a new one with
77 * with the same index or the ordering to the driver's
78 * set_key() callback becomes confused.
80 ieee80211_key_free(key);
81 key = ieee80211_key_alloc(sdata, sta, alg, idx, key_len, _key);
88 if (set_tx_key || (!sta && !sdata->default_key && key))
89 ieee80211_set_default_key(sdata, idx);
98 static int ieee80211_ioctl_siwgenie(struct net_device *dev,
99 struct iw_request_info *info,
100 struct iw_point *data, char *extra)
102 struct ieee80211_sub_if_data *sdata;
103 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
105 if (local->user_space_mlme)
108 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
109 if (sdata->type == IEEE80211_IF_TYPE_STA ||
110 sdata->type == IEEE80211_IF_TYPE_IBSS) {
111 int ret = ieee80211_sta_set_extra_ie(dev, extra, data->length);
114 sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL;
115 ieee80211_sta_req_auth(dev, &sdata->u.sta);
119 if (sdata->type == IEEE80211_IF_TYPE_AP) {
120 kfree(sdata->u.ap.generic_elem);
121 sdata->u.ap.generic_elem = kmalloc(data->length, GFP_KERNEL);
122 if (!sdata->u.ap.generic_elem)
124 memcpy(sdata->u.ap.generic_elem, extra, data->length);
125 sdata->u.ap.generic_elem_len = data->length;
126 return ieee80211_if_config(dev);
131 static int ieee80211_ioctl_giwname(struct net_device *dev,
132 struct iw_request_info *info,
133 char *name, char *extra)
135 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
137 switch (local->hw.conf.phymode) {
138 case MODE_IEEE80211A:
139 strcpy(name, "IEEE 802.11a");
141 case MODE_IEEE80211B:
142 strcpy(name, "IEEE 802.11b");
144 case MODE_IEEE80211G:
145 strcpy(name, "IEEE 802.11g");
147 case MODE_ATHEROS_TURBO:
148 strcpy(name, "5GHz Turbo");
151 strcpy(name, "IEEE 802.11");
159 static int ieee80211_ioctl_giwrange(struct net_device *dev,
160 struct iw_request_info *info,
161 struct iw_point *data, char *extra)
163 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
164 struct iw_range *range = (struct iw_range *) extra;
165 struct ieee80211_hw_mode *mode = NULL;
168 data->length = sizeof(struct iw_range);
169 memset(range, 0, sizeof(struct iw_range));
171 range->we_version_compiled = WIRELESS_EXT;
172 range->we_version_source = 21;
173 range->retry_capa = IW_RETRY_LIMIT;
174 range->retry_flags = IW_RETRY_LIMIT;
175 range->min_retry = 0;
176 range->max_retry = 255;
178 range->max_rts = 2347;
179 range->min_frag = 256;
180 range->max_frag = 2346;
182 range->encoding_size[0] = 5;
183 range->encoding_size[1] = 13;
184 range->num_encoding_sizes = 2;
185 range->max_encoding_tokens = NUM_DEFAULT_KEYS;
187 range->max_qual.qual = local->hw.max_signal;
188 range->max_qual.level = local->hw.max_rssi;
189 range->max_qual.noise = local->hw.max_noise;
190 range->max_qual.updated = local->wstats_flags;
192 range->avg_qual.qual = local->hw.max_signal/2;
193 range->avg_qual.level = 0;
194 range->avg_qual.noise = 0;
195 range->avg_qual.updated = local->wstats_flags;
197 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
198 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
200 list_for_each_entry(mode, &local->modes_list, list) {
203 if (!(local->enabled_modes & (1 << mode->mode)) ||
204 (local->hw_modes & local->enabled_modes &
205 (1 << MODE_IEEE80211G) && mode->mode == MODE_IEEE80211B))
208 while (i < mode->num_channels && c < IW_MAX_FREQUENCIES) {
209 struct ieee80211_channel *chan = &mode->channels[i];
211 if (chan->flag & IEEE80211_CHAN_W_SCAN) {
212 range->freq[c].i = chan->chan;
213 range->freq[c].m = chan->freq * 100000;
214 range->freq[c].e = 1;
220 range->num_channels = c;
221 range->num_frequency = c;
223 IW_EVENT_CAPA_SET_KERNEL(range->event_capa);
224 IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWTHRSPY);
225 IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWAP);
226 IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWSCAN);
232 static int ieee80211_ioctl_siwmode(struct net_device *dev,
233 struct iw_request_info *info,
234 __u32 *mode, char *extra)
236 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
239 if (sdata->type == IEEE80211_IF_TYPE_VLAN)
244 type = IEEE80211_IF_TYPE_STA;
247 type = IEEE80211_IF_TYPE_IBSS;
249 case IW_MODE_MONITOR:
250 type = IEEE80211_IF_TYPE_MNTR;
256 if (type == sdata->type)
258 if (netif_running(dev))
261 ieee80211_if_reinit(dev);
262 ieee80211_if_set_type(dev, type);
268 static int ieee80211_ioctl_giwmode(struct net_device *dev,
269 struct iw_request_info *info,
270 __u32 *mode, char *extra)
272 struct ieee80211_sub_if_data *sdata;
274 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
275 switch (sdata->type) {
276 case IEEE80211_IF_TYPE_AP:
277 *mode = IW_MODE_MASTER;
279 case IEEE80211_IF_TYPE_STA:
280 *mode = IW_MODE_INFRA;
282 case IEEE80211_IF_TYPE_IBSS:
283 *mode = IW_MODE_ADHOC;
285 case IEEE80211_IF_TYPE_MNTR:
286 *mode = IW_MODE_MONITOR;
288 case IEEE80211_IF_TYPE_WDS:
289 *mode = IW_MODE_REPEAT;
291 case IEEE80211_IF_TYPE_VLAN:
292 *mode = IW_MODE_SECOND; /* FIXME */
295 *mode = IW_MODE_AUTO;
301 int ieee80211_set_channel(struct ieee80211_local *local, int channel, int freq)
303 struct ieee80211_hw_mode *mode;
307 list_for_each_entry(mode, &local->modes_list, list) {
308 if (!(local->enabled_modes & (1 << mode->mode)))
310 for (c = 0; c < mode->num_channels; c++) {
311 struct ieee80211_channel *chan = &mode->channels[c];
312 if (chan->flag & IEEE80211_CHAN_W_SCAN &&
313 ((chan->chan == channel) || (chan->freq == freq))) {
314 /* Use next_mode as the mode preference to
315 * resolve non-unique channel numbers. */
316 if (set && mode->mode != local->next_mode)
319 local->oper_channel = chan;
320 local->oper_hw_mode = mode;
327 if (local->sta_scanning)
330 ret = ieee80211_hw_config(local);
332 rate_control_clear(local);
338 static int ieee80211_ioctl_siwfreq(struct net_device *dev,
339 struct iw_request_info *info,
340 struct iw_freq *freq, char *extra)
342 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
343 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
345 if (sdata->type == IEEE80211_IF_TYPE_STA)
346 sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_CHANNEL_SEL;
348 /* freq->e == 0: freq->m = channel; otherwise freq = m * 10^e */
351 if (sdata->type == IEEE80211_IF_TYPE_STA)
352 sdata->u.sta.flags |=
353 IEEE80211_STA_AUTO_CHANNEL_SEL;
356 return ieee80211_set_channel(local, freq->m, -1);
358 int i, div = 1000000;
359 for (i = 0; i < freq->e; i++)
362 return ieee80211_set_channel(local, -1, freq->m / div);
369 static int ieee80211_ioctl_giwfreq(struct net_device *dev,
370 struct iw_request_info *info,
371 struct iw_freq *freq, char *extra)
373 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
375 /* TODO: in station mode (Managed/Ad-hoc) might need to poll low-level
376 * driver for the current channel with firmware-based management */
378 freq->m = local->hw.conf.freq;
385 static int ieee80211_ioctl_siwessid(struct net_device *dev,
386 struct iw_request_info *info,
387 struct iw_point *data, char *ssid)
389 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
390 struct ieee80211_sub_if_data *sdata;
391 size_t len = data->length;
393 /* iwconfig uses nul termination in SSID.. */
394 if (len > 0 && ssid[len - 1] == '\0')
397 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
398 if (sdata->type == IEEE80211_IF_TYPE_STA ||
399 sdata->type == IEEE80211_IF_TYPE_IBSS) {
401 if (local->user_space_mlme) {
402 if (len > IEEE80211_MAX_SSID_LEN)
404 memcpy(sdata->u.sta.ssid, ssid, len);
405 sdata->u.sta.ssid_len = len;
409 sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_SSID_SEL;
411 sdata->u.sta.flags |= IEEE80211_STA_AUTO_SSID_SEL;
412 ret = ieee80211_sta_set_ssid(dev, ssid, len);
415 ieee80211_sta_req_auth(dev, &sdata->u.sta);
419 if (sdata->type == IEEE80211_IF_TYPE_AP) {
420 memcpy(sdata->u.ap.ssid, ssid, len);
421 memset(sdata->u.ap.ssid + len, 0,
422 IEEE80211_MAX_SSID_LEN - len);
423 sdata->u.ap.ssid_len = len;
424 return ieee80211_if_config(dev);
430 static int ieee80211_ioctl_giwessid(struct net_device *dev,
431 struct iw_request_info *info,
432 struct iw_point *data, char *ssid)
436 struct ieee80211_sub_if_data *sdata;
437 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
438 if (sdata->type == IEEE80211_IF_TYPE_STA ||
439 sdata->type == IEEE80211_IF_TYPE_IBSS) {
440 int res = ieee80211_sta_get_ssid(dev, ssid, &len);
449 if (sdata->type == IEEE80211_IF_TYPE_AP) {
450 len = sdata->u.ap.ssid_len;
451 if (len > IW_ESSID_MAX_SIZE)
452 len = IW_ESSID_MAX_SIZE;
453 memcpy(ssid, sdata->u.ap.ssid, len);
462 static int ieee80211_ioctl_siwap(struct net_device *dev,
463 struct iw_request_info *info,
464 struct sockaddr *ap_addr, char *extra)
466 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
467 struct ieee80211_sub_if_data *sdata;
469 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
470 if (sdata->type == IEEE80211_IF_TYPE_STA ||
471 sdata->type == IEEE80211_IF_TYPE_IBSS) {
473 if (local->user_space_mlme) {
474 memcpy(sdata->u.sta.bssid, (u8 *) &ap_addr->sa_data,
478 if (is_zero_ether_addr((u8 *) &ap_addr->sa_data))
479 sdata->u.sta.flags |= IEEE80211_STA_AUTO_BSSID_SEL |
480 IEEE80211_STA_AUTO_CHANNEL_SEL;
481 else if (is_broadcast_ether_addr((u8 *) &ap_addr->sa_data))
482 sdata->u.sta.flags |= IEEE80211_STA_AUTO_BSSID_SEL;
484 sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL;
485 ret = ieee80211_sta_set_bssid(dev, (u8 *) &ap_addr->sa_data);
488 ieee80211_sta_req_auth(dev, &sdata->u.sta);
490 } else if (sdata->type == IEEE80211_IF_TYPE_WDS) {
491 if (memcmp(sdata->u.wds.remote_addr, (u8 *) &ap_addr->sa_data,
494 return ieee80211_if_update_wds(dev, (u8 *) &ap_addr->sa_data);
501 static int ieee80211_ioctl_giwap(struct net_device *dev,
502 struct iw_request_info *info,
503 struct sockaddr *ap_addr, char *extra)
505 struct ieee80211_sub_if_data *sdata;
507 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
508 if (sdata->type == IEEE80211_IF_TYPE_STA ||
509 sdata->type == IEEE80211_IF_TYPE_IBSS) {
510 ap_addr->sa_family = ARPHRD_ETHER;
511 memcpy(&ap_addr->sa_data, sdata->u.sta.bssid, ETH_ALEN);
513 } else if (sdata->type == IEEE80211_IF_TYPE_WDS) {
514 ap_addr->sa_family = ARPHRD_ETHER;
515 memcpy(&ap_addr->sa_data, sdata->u.wds.remote_addr, ETH_ALEN);
523 static int ieee80211_ioctl_siwscan(struct net_device *dev,
524 struct iw_request_info *info,
525 struct iw_point *data, char *extra)
527 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
528 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
532 if (!netif_running(dev))
535 switch (sdata->type) {
536 case IEEE80211_IF_TYPE_STA:
537 case IEEE80211_IF_TYPE_IBSS:
538 if (local->scan_flags & IEEE80211_SCAN_MATCH_SSID) {
539 ssid = sdata->u.sta.ssid;
540 ssid_len = sdata->u.sta.ssid_len;
543 case IEEE80211_IF_TYPE_AP:
544 if (local->scan_flags & IEEE80211_SCAN_MATCH_SSID) {
545 ssid = sdata->u.ap.ssid;
546 ssid_len = sdata->u.ap.ssid_len;
553 return ieee80211_sta_req_scan(dev, ssid, ssid_len);
557 static int ieee80211_ioctl_giwscan(struct net_device *dev,
558 struct iw_request_info *info,
559 struct iw_point *data, char *extra)
562 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
563 if (local->sta_scanning)
565 res = ieee80211_sta_scan_results(dev, extra, data->length);
575 static int ieee80211_ioctl_siwrate(struct net_device *dev,
576 struct iw_request_info *info,
577 struct iw_param *rate, char *extra)
579 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
580 struct ieee80211_hw_mode *mode;
582 u32 target_rate = rate->value / 100000;
583 struct ieee80211_sub_if_data *sdata;
585 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
588 mode = local->oper_hw_mode;
589 /* target_rate = -1, rate->fixed = 0 means auto only, so use all rates
590 * target_rate = X, rate->fixed = 1 means only rate X
591 * target_rate = X, rate->fixed = 0 means all rates <= X */
592 sdata->bss->max_ratectrl_rateidx = -1;
593 sdata->bss->force_unicast_rateidx = -1;
596 for (i=0; i< mode->num_rates; i++) {
597 struct ieee80211_rate *rates = &mode->rates[i];
598 int this_rate = rates->rate;
600 if (mode->mode == MODE_ATHEROS_TURBO ||
601 mode->mode == MODE_ATHEROS_TURBOG)
603 if (target_rate == this_rate) {
604 sdata->bss->max_ratectrl_rateidx = i;
606 sdata->bss->force_unicast_rateidx = i;
613 static int ieee80211_ioctl_giwrate(struct net_device *dev,
614 struct iw_request_info *info,
615 struct iw_param *rate, char *extra)
617 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
618 struct sta_info *sta;
619 struct ieee80211_sub_if_data *sdata;
621 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
622 if (sdata->type == IEEE80211_IF_TYPE_STA)
623 sta = sta_info_get(local, sdata->u.sta.bssid);
628 if (sta->txrate < local->oper_hw_mode->num_rates)
629 rate->value = local->oper_hw_mode->rates[sta->txrate].rate * 100000;
636 static int ieee80211_ioctl_giwtxpower(struct net_device *dev,
637 struct iw_request_info *info,
638 union iwreq_data *data, char *extra)
640 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
642 data->txpower.fixed = 1;
643 data->txpower.disabled = !(local->hw.conf.radio_enabled);
644 data->txpower.value = local->hw.conf.power_level;
645 data->txpower.flags = IW_TXPOW_DBM;
650 static int ieee80211_ioctl_siwrts(struct net_device *dev,
651 struct iw_request_info *info,
652 struct iw_param *rts, char *extra)
654 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
657 local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
658 else if (rts->value < 0 || rts->value > IEEE80211_MAX_RTS_THRESHOLD)
661 local->rts_threshold = rts->value;
663 /* If the wlan card performs RTS/CTS in hardware/firmware,
664 * configure it here */
666 if (local->ops->set_rts_threshold)
667 local->ops->set_rts_threshold(local_to_hw(local),
668 local->rts_threshold);
673 static int ieee80211_ioctl_giwrts(struct net_device *dev,
674 struct iw_request_info *info,
675 struct iw_param *rts, char *extra)
677 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
679 rts->value = local->rts_threshold;
680 rts->disabled = (rts->value >= IEEE80211_MAX_RTS_THRESHOLD);
687 static int ieee80211_ioctl_siwfrag(struct net_device *dev,
688 struct iw_request_info *info,
689 struct iw_param *frag, char *extra)
691 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
694 local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
695 else if (frag->value < 256 ||
696 frag->value > IEEE80211_MAX_FRAG_THRESHOLD)
699 /* Fragment length must be even, so strip LSB. */
700 local->fragmentation_threshold = frag->value & ~0x1;
703 /* If the wlan card performs fragmentation in hardware/firmware,
704 * configure it here */
706 if (local->ops->set_frag_threshold)
707 local->ops->set_frag_threshold(
709 local->fragmentation_threshold);
714 static int ieee80211_ioctl_giwfrag(struct net_device *dev,
715 struct iw_request_info *info,
716 struct iw_param *frag, char *extra)
718 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
720 frag->value = local->fragmentation_threshold;
721 frag->disabled = (frag->value >= IEEE80211_MAX_RTS_THRESHOLD);
728 static int ieee80211_ioctl_siwretry(struct net_device *dev,
729 struct iw_request_info *info,
730 struct iw_param *retry, char *extra)
732 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
734 if (retry->disabled ||
735 (retry->flags & IW_RETRY_TYPE) != IW_RETRY_LIMIT)
738 if (retry->flags & IW_RETRY_MAX)
739 local->long_retry_limit = retry->value;
740 else if (retry->flags & IW_RETRY_MIN)
741 local->short_retry_limit = retry->value;
743 local->long_retry_limit = retry->value;
744 local->short_retry_limit = retry->value;
747 if (local->ops->set_retry_limit) {
748 return local->ops->set_retry_limit(
750 local->short_retry_limit,
751 local->long_retry_limit);
758 static int ieee80211_ioctl_giwretry(struct net_device *dev,
759 struct iw_request_info *info,
760 struct iw_param *retry, char *extra)
762 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
765 if (retry->flags == 0 || retry->flags & IW_RETRY_MIN) {
766 /* first return min value, iwconfig will ask max value
768 retry->flags |= IW_RETRY_LIMIT;
769 retry->value = local->short_retry_limit;
770 if (local->long_retry_limit != local->short_retry_limit)
771 retry->flags |= IW_RETRY_MIN;
774 if (retry->flags & IW_RETRY_MAX) {
775 retry->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
776 retry->value = local->long_retry_limit;
782 static int ieee80211_ioctl_prism2_param(struct net_device *dev,
783 struct iw_request_info *info,
784 void *wrqu, char *extra)
786 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
787 struct ieee80211_sub_if_data *sdata;
788 int *i = (int *) extra;
790 int value = *(i + 1);
793 if (!capable(CAP_NET_ADMIN))
796 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
799 case PRISM2_PARAM_IEEE_802_1X:
800 if (local->ops->set_ieee8021x)
801 ret = local->ops->set_ieee8021x(local_to_hw(local),
804 printk(KERN_DEBUG "%s: failed to set IEEE 802.1X (%d) "
805 "for low-level driver\n", dev->name, value);
807 sdata->ieee802_1x = value;
810 case PRISM2_PARAM_CTS_PROTECT_ERP_FRAMES:
811 if (sdata->type == IEEE80211_IF_TYPE_AP) {
813 sdata->flags |= IEEE80211_SDATA_USE_PROTECTION;
815 sdata->flags &= ~IEEE80211_SDATA_USE_PROTECTION;
816 ieee80211_erp_info_change_notify(dev,
817 IEEE80211_ERP_CHANGE_PROTECTION);
823 case PRISM2_PARAM_PREAMBLE:
824 if (sdata->type == IEEE80211_IF_TYPE_AP) {
826 sdata->flags |= IEEE80211_SDATA_SHORT_PREAMBLE;
828 sdata->flags &= ~IEEE80211_SDATA_SHORT_PREAMBLE;
829 ieee80211_erp_info_change_notify(dev,
830 IEEE80211_ERP_CHANGE_PREAMBLE);
836 case PRISM2_PARAM_SHORT_SLOT_TIME:
838 local->hw.conf.flags |= IEEE80211_CONF_SHORT_SLOT_TIME;
840 local->hw.conf.flags &= ~IEEE80211_CONF_SHORT_SLOT_TIME;
841 if (ieee80211_hw_config(local))
845 case PRISM2_PARAM_NEXT_MODE:
846 local->next_mode = value;
849 case PRISM2_PARAM_KEY_TX_RX_THRESHOLD:
850 local->key_tx_rx_threshold = value;
853 case PRISM2_PARAM_WIFI_WME_NOACK_TEST:
854 local->wifi_wme_noack_test = value;
857 case PRISM2_PARAM_SCAN_FLAGS:
858 local->scan_flags = value;
861 case PRISM2_PARAM_MIXED_CELL:
862 if (sdata->type != IEEE80211_IF_TYPE_STA &&
863 sdata->type != IEEE80211_IF_TYPE_IBSS)
867 sdata->u.sta.flags |= IEEE80211_STA_MIXED_CELL;
869 sdata->u.sta.flags &= ~IEEE80211_STA_MIXED_CELL;
873 case PRISM2_PARAM_HW_MODES:
874 local->enabled_modes = value;
877 case PRISM2_PARAM_CREATE_IBSS:
878 if (sdata->type != IEEE80211_IF_TYPE_IBSS)
882 sdata->u.sta.flags |= IEEE80211_STA_CREATE_IBSS;
884 sdata->u.sta.flags &= ~IEEE80211_STA_CREATE_IBSS;
887 case PRISM2_PARAM_WMM_ENABLED:
888 if (sdata->type != IEEE80211_IF_TYPE_STA &&
889 sdata->type != IEEE80211_IF_TYPE_IBSS)
893 sdata->u.sta.flags |= IEEE80211_STA_WMM_ENABLED;
895 sdata->u.sta.flags &= ~IEEE80211_STA_WMM_ENABLED;
907 static int ieee80211_ioctl_get_prism2_param(struct net_device *dev,
908 struct iw_request_info *info,
909 void *wrqu, char *extra)
911 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
912 struct ieee80211_sub_if_data *sdata;
913 int *param = (int *) extra;
916 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
919 case PRISM2_PARAM_IEEE_802_1X:
920 *param = sdata->ieee802_1x;
923 case PRISM2_PARAM_CTS_PROTECT_ERP_FRAMES:
924 *param = !!(sdata->flags & IEEE80211_SDATA_USE_PROTECTION);
927 case PRISM2_PARAM_PREAMBLE:
928 *param = !!(sdata->flags & IEEE80211_SDATA_SHORT_PREAMBLE);
931 case PRISM2_PARAM_SHORT_SLOT_TIME:
932 *param = !!(local->hw.conf.flags & IEEE80211_CONF_SHORT_SLOT_TIME);
935 case PRISM2_PARAM_NEXT_MODE:
936 *param = local->next_mode;
939 case PRISM2_PARAM_KEY_TX_RX_THRESHOLD:
940 *param = local->key_tx_rx_threshold;
943 case PRISM2_PARAM_WIFI_WME_NOACK_TEST:
944 *param = local->wifi_wme_noack_test;
947 case PRISM2_PARAM_SCAN_FLAGS:
948 *param = local->scan_flags;
951 case PRISM2_PARAM_HW_MODES:
952 *param = local->enabled_modes;
955 case PRISM2_PARAM_CREATE_IBSS:
956 if (sdata->type != IEEE80211_IF_TYPE_IBSS)
959 *param = !!(sdata->u.sta.flags &
960 IEEE80211_STA_CREATE_IBSS);
963 case PRISM2_PARAM_MIXED_CELL:
964 if (sdata->type != IEEE80211_IF_TYPE_STA &&
965 sdata->type != IEEE80211_IF_TYPE_IBSS)
968 *param = !!(sdata->u.sta.flags &
969 IEEE80211_STA_MIXED_CELL);
972 case PRISM2_PARAM_WMM_ENABLED:
973 if (sdata->type != IEEE80211_IF_TYPE_STA &&
974 sdata->type != IEEE80211_IF_TYPE_IBSS)
977 *param = !!(sdata->u.sta.flags &
978 IEEE80211_STA_WMM_ENABLED);
988 static int ieee80211_ioctl_siwmlme(struct net_device *dev,
989 struct iw_request_info *info,
990 struct iw_point *data, char *extra)
992 struct ieee80211_sub_if_data *sdata;
993 struct iw_mlme *mlme = (struct iw_mlme *) extra;
995 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
996 if (sdata->type != IEEE80211_IF_TYPE_STA &&
997 sdata->type != IEEE80211_IF_TYPE_IBSS)
1000 switch (mlme->cmd) {
1001 case IW_MLME_DEAUTH:
1002 /* TODO: mlme->addr.sa_data */
1003 return ieee80211_sta_deauthenticate(dev, mlme->reason_code);
1004 case IW_MLME_DISASSOC:
1005 /* TODO: mlme->addr.sa_data */
1006 return ieee80211_sta_disassociate(dev, mlme->reason_code);
1013 static int ieee80211_ioctl_siwencode(struct net_device *dev,
1014 struct iw_request_info *info,
1015 struct iw_point *erq, char *keybuf)
1017 struct ieee80211_sub_if_data *sdata;
1018 int idx, i, alg = ALG_WEP;
1019 u8 bcaddr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1021 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1023 idx = erq->flags & IW_ENCODE_INDEX;
1025 if (sdata->default_key)
1026 for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
1027 if (sdata->default_key == sdata->keys[i]) {
1032 } else if (idx < 1 || idx > 4)
1037 if (erq->flags & IW_ENCODE_DISABLED)
1039 else if (erq->length == 0) {
1040 /* No key data - just set the default TX key index */
1041 ieee80211_set_default_key(sdata, idx);
1045 return ieee80211_set_encryption(
1048 !sdata->default_key,
1049 keybuf, erq->length);
1053 static int ieee80211_ioctl_giwencode(struct net_device *dev,
1054 struct iw_request_info *info,
1055 struct iw_point *erq, char *key)
1057 struct ieee80211_sub_if_data *sdata;
1060 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1062 idx = erq->flags & IW_ENCODE_INDEX;
1063 if (idx < 1 || idx > 4) {
1065 if (!sdata->default_key)
1067 else for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
1068 if (sdata->default_key == sdata->keys[i]) {
1078 erq->flags = idx + 1;
1080 if (!sdata->keys[idx]) {
1082 erq->flags |= IW_ENCODE_DISABLED;
1086 memcpy(key, sdata->keys[idx]->conf.key,
1087 min_t(int, erq->length, sdata->keys[idx]->conf.keylen));
1088 erq->length = sdata->keys[idx]->conf.keylen;
1089 erq->flags |= IW_ENCODE_ENABLED;
1094 static int ieee80211_ioctl_siwauth(struct net_device *dev,
1095 struct iw_request_info *info,
1096 struct iw_param *data, char *extra)
1098 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1099 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1102 switch (data->flags & IW_AUTH_INDEX) {
1103 case IW_AUTH_WPA_VERSION:
1104 case IW_AUTH_CIPHER_PAIRWISE:
1105 case IW_AUTH_CIPHER_GROUP:
1106 case IW_AUTH_WPA_ENABLED:
1107 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
1109 case IW_AUTH_KEY_MGMT:
1110 if (sdata->type != IEEE80211_IF_TYPE_STA)
1114 * Key management was set by wpa_supplicant,
1115 * we only need this to associate to a network
1116 * that has privacy enabled regardless of not
1119 sdata->u.sta.key_management_enabled = !!data->value;
1122 case IW_AUTH_80211_AUTH_ALG:
1123 if (sdata->type == IEEE80211_IF_TYPE_STA ||
1124 sdata->type == IEEE80211_IF_TYPE_IBSS)
1125 sdata->u.sta.auth_algs = data->value;
1129 case IW_AUTH_PRIVACY_INVOKED:
1130 if (local->ops->set_privacy_invoked)
1131 ret = local->ops->set_privacy_invoked(
1132 local_to_hw(local), data->value);
1141 /* Get wireless statistics. Called by /proc/net/wireless and by SIOCGIWSTATS */
1142 static struct iw_statistics *ieee80211_get_wireless_stats(struct net_device *dev)
1144 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1145 struct iw_statistics *wstats = &local->wstats;
1146 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1147 struct sta_info *sta = NULL;
1149 if (sdata->type == IEEE80211_IF_TYPE_STA ||
1150 sdata->type == IEEE80211_IF_TYPE_IBSS)
1151 sta = sta_info_get(local, sdata->u.sta.bssid);
1153 wstats->discard.fragment = 0;
1154 wstats->discard.misc = 0;
1155 wstats->qual.qual = 0;
1156 wstats->qual.level = 0;
1157 wstats->qual.noise = 0;
1158 wstats->qual.updated = IW_QUAL_ALL_INVALID;
1160 wstats->qual.level = sta->last_rssi;
1161 wstats->qual.qual = sta->last_signal;
1162 wstats->qual.noise = sta->last_noise;
1163 wstats->qual.updated = local->wstats_flags;
1169 static int ieee80211_ioctl_giwauth(struct net_device *dev,
1170 struct iw_request_info *info,
1171 struct iw_param *data, char *extra)
1173 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1176 switch (data->flags & IW_AUTH_INDEX) {
1177 case IW_AUTH_80211_AUTH_ALG:
1178 if (sdata->type == IEEE80211_IF_TYPE_STA ||
1179 sdata->type == IEEE80211_IF_TYPE_IBSS)
1180 data->value = sdata->u.sta.auth_algs;
1192 static int ieee80211_ioctl_siwencodeext(struct net_device *dev,
1193 struct iw_request_info *info,
1194 struct iw_point *erq, char *extra)
1196 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1197 struct iw_encode_ext *ext = (struct iw_encode_ext *) extra;
1201 case IW_ENCODE_ALG_NONE:
1204 case IW_ENCODE_ALG_WEP:
1207 case IW_ENCODE_ALG_TKIP:
1210 case IW_ENCODE_ALG_CCMP:
1217 if (erq->flags & IW_ENCODE_DISABLED)
1220 idx = erq->flags & IW_ENCODE_INDEX;
1221 if (idx < 1 || idx > 4) {
1223 if (!sdata->default_key)
1225 else for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
1226 if (sdata->default_key == sdata->keys[i]) {
1236 return ieee80211_set_encryption(dev, ext->addr.sa_data, idx, alg,
1238 IW_ENCODE_EXT_SET_TX_KEY,
1239 ext->key, ext->key_len);
1243 static const struct iw_priv_args ieee80211_ioctl_priv[] = {
1244 { PRISM2_IOCTL_PRISM2_PARAM,
1245 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "param" },
1246 { PRISM2_IOCTL_GET_PRISM2_PARAM,
1247 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1248 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "get_param" },
1251 /* Structures to export the Wireless Handlers */
1253 static const iw_handler ieee80211_handler[] =
1255 (iw_handler) NULL, /* SIOCSIWCOMMIT */
1256 (iw_handler) ieee80211_ioctl_giwname, /* SIOCGIWNAME */
1257 (iw_handler) NULL, /* SIOCSIWNWID */
1258 (iw_handler) NULL, /* SIOCGIWNWID */
1259 (iw_handler) ieee80211_ioctl_siwfreq, /* SIOCSIWFREQ */
1260 (iw_handler) ieee80211_ioctl_giwfreq, /* SIOCGIWFREQ */
1261 (iw_handler) ieee80211_ioctl_siwmode, /* SIOCSIWMODE */
1262 (iw_handler) ieee80211_ioctl_giwmode, /* SIOCGIWMODE */
1263 (iw_handler) NULL, /* SIOCSIWSENS */
1264 (iw_handler) NULL, /* SIOCGIWSENS */
1265 (iw_handler) NULL /* not used */, /* SIOCSIWRANGE */
1266 (iw_handler) ieee80211_ioctl_giwrange, /* SIOCGIWRANGE */
1267 (iw_handler) NULL /* not used */, /* SIOCSIWPRIV */
1268 (iw_handler) NULL /* kernel code */, /* SIOCGIWPRIV */
1269 (iw_handler) NULL /* not used */, /* SIOCSIWSTATS */
1270 (iw_handler) NULL /* kernel code */, /* SIOCGIWSTATS */
1271 (iw_handler) NULL, /* SIOCSIWSPY */
1272 (iw_handler) NULL, /* SIOCGIWSPY */
1273 (iw_handler) NULL, /* SIOCSIWTHRSPY */
1274 (iw_handler) NULL, /* SIOCGIWTHRSPY */
1275 (iw_handler) ieee80211_ioctl_siwap, /* SIOCSIWAP */
1276 (iw_handler) ieee80211_ioctl_giwap, /* SIOCGIWAP */
1277 (iw_handler) ieee80211_ioctl_siwmlme, /* SIOCSIWMLME */
1278 (iw_handler) NULL, /* SIOCGIWAPLIST */
1279 (iw_handler) ieee80211_ioctl_siwscan, /* SIOCSIWSCAN */
1280 (iw_handler) ieee80211_ioctl_giwscan, /* SIOCGIWSCAN */
1281 (iw_handler) ieee80211_ioctl_siwessid, /* SIOCSIWESSID */
1282 (iw_handler) ieee80211_ioctl_giwessid, /* SIOCGIWESSID */
1283 (iw_handler) NULL, /* SIOCSIWNICKN */
1284 (iw_handler) NULL, /* SIOCGIWNICKN */
1285 (iw_handler) NULL, /* -- hole -- */
1286 (iw_handler) NULL, /* -- hole -- */
1287 (iw_handler) ieee80211_ioctl_siwrate, /* SIOCSIWRATE */
1288 (iw_handler) ieee80211_ioctl_giwrate, /* SIOCGIWRATE */
1289 (iw_handler) ieee80211_ioctl_siwrts, /* SIOCSIWRTS */
1290 (iw_handler) ieee80211_ioctl_giwrts, /* SIOCGIWRTS */
1291 (iw_handler) ieee80211_ioctl_siwfrag, /* SIOCSIWFRAG */
1292 (iw_handler) ieee80211_ioctl_giwfrag, /* SIOCGIWFRAG */
1293 (iw_handler) NULL, /* SIOCSIWTXPOW */
1294 (iw_handler) ieee80211_ioctl_giwtxpower, /* SIOCGIWTXPOW */
1295 (iw_handler) ieee80211_ioctl_siwretry, /* SIOCSIWRETRY */
1296 (iw_handler) ieee80211_ioctl_giwretry, /* SIOCGIWRETRY */
1297 (iw_handler) ieee80211_ioctl_siwencode, /* SIOCSIWENCODE */
1298 (iw_handler) ieee80211_ioctl_giwencode, /* SIOCGIWENCODE */
1299 (iw_handler) NULL, /* SIOCSIWPOWER */
1300 (iw_handler) NULL, /* SIOCGIWPOWER */
1301 (iw_handler) NULL, /* -- hole -- */
1302 (iw_handler) NULL, /* -- hole -- */
1303 (iw_handler) ieee80211_ioctl_siwgenie, /* SIOCSIWGENIE */
1304 (iw_handler) NULL, /* SIOCGIWGENIE */
1305 (iw_handler) ieee80211_ioctl_siwauth, /* SIOCSIWAUTH */
1306 (iw_handler) ieee80211_ioctl_giwauth, /* SIOCGIWAUTH */
1307 (iw_handler) ieee80211_ioctl_siwencodeext, /* SIOCSIWENCODEEXT */
1308 (iw_handler) NULL, /* SIOCGIWENCODEEXT */
1309 (iw_handler) NULL, /* SIOCSIWPMKSA */
1310 (iw_handler) NULL, /* -- hole -- */
1313 static const iw_handler ieee80211_private_handler[] =
1314 { /* SIOCIWFIRSTPRIV + */
1315 (iw_handler) ieee80211_ioctl_prism2_param, /* 0 */
1316 (iw_handler) ieee80211_ioctl_get_prism2_param, /* 1 */
1319 const struct iw_handler_def ieee80211_iw_handler_def =
1321 .num_standard = ARRAY_SIZE(ieee80211_handler),
1322 .num_private = ARRAY_SIZE(ieee80211_private_handler),
1323 .num_private_args = ARRAY_SIZE(ieee80211_ioctl_priv),
1324 .standard = (iw_handler *) ieee80211_handler,
1325 .private = (iw_handler *) ieee80211_private_handler,
1326 .private_args = (struct iw_priv_args *) ieee80211_ioctl_priv,
1327 .get_wireless_stats = ieee80211_get_wireless_stats,