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 * Automatically frees any old key if present.
78 key = ieee80211_key_alloc(sdata, sta, alg, idx, key_len, _key);
85 if (set_tx_key || (!sta && !sdata->default_key && key))
86 ieee80211_set_default_key(sdata, idx);
95 static int ieee80211_ioctl_siwgenie(struct net_device *dev,
96 struct iw_request_info *info,
97 struct iw_point *data, char *extra)
99 struct ieee80211_sub_if_data *sdata;
100 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
102 if (local->user_space_mlme)
105 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
106 if (sdata->type == IEEE80211_IF_TYPE_STA ||
107 sdata->type == IEEE80211_IF_TYPE_IBSS) {
108 int ret = ieee80211_sta_set_extra_ie(dev, extra, data->length);
111 sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL;
112 ieee80211_sta_req_auth(dev, &sdata->u.sta);
116 if (sdata->type == IEEE80211_IF_TYPE_AP) {
117 kfree(sdata->u.ap.generic_elem);
118 sdata->u.ap.generic_elem = kmalloc(data->length, GFP_KERNEL);
119 if (!sdata->u.ap.generic_elem)
121 memcpy(sdata->u.ap.generic_elem, extra, data->length);
122 sdata->u.ap.generic_elem_len = data->length;
123 return ieee80211_if_config(dev);
128 static int ieee80211_ioctl_giwname(struct net_device *dev,
129 struct iw_request_info *info,
130 char *name, char *extra)
132 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
134 switch (local->hw.conf.phymode) {
135 case MODE_IEEE80211A:
136 strcpy(name, "IEEE 802.11a");
138 case MODE_IEEE80211B:
139 strcpy(name, "IEEE 802.11b");
141 case MODE_IEEE80211G:
142 strcpy(name, "IEEE 802.11g");
144 case MODE_ATHEROS_TURBO:
145 strcpy(name, "5GHz Turbo");
148 strcpy(name, "IEEE 802.11");
156 static int ieee80211_ioctl_giwrange(struct net_device *dev,
157 struct iw_request_info *info,
158 struct iw_point *data, char *extra)
160 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
161 struct iw_range *range = (struct iw_range *) extra;
162 struct ieee80211_hw_mode *mode = NULL;
165 data->length = sizeof(struct iw_range);
166 memset(range, 0, sizeof(struct iw_range));
168 range->we_version_compiled = WIRELESS_EXT;
169 range->we_version_source = 21;
170 range->retry_capa = IW_RETRY_LIMIT;
171 range->retry_flags = IW_RETRY_LIMIT;
172 range->min_retry = 0;
173 range->max_retry = 255;
175 range->max_rts = 2347;
176 range->min_frag = 256;
177 range->max_frag = 2346;
179 range->encoding_size[0] = 5;
180 range->encoding_size[1] = 13;
181 range->num_encoding_sizes = 2;
182 range->max_encoding_tokens = NUM_DEFAULT_KEYS;
184 range->max_qual.qual = local->hw.max_signal;
185 range->max_qual.level = local->hw.max_rssi;
186 range->max_qual.noise = local->hw.max_noise;
187 range->max_qual.updated = local->wstats_flags;
189 range->avg_qual.qual = local->hw.max_signal/2;
190 range->avg_qual.level = 0;
191 range->avg_qual.noise = 0;
192 range->avg_qual.updated = local->wstats_flags;
194 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
195 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
197 list_for_each_entry(mode, &local->modes_list, list) {
200 if (!(local->enabled_modes & (1 << mode->mode)) ||
201 (local->hw_modes & local->enabled_modes &
202 (1 << MODE_IEEE80211G) && mode->mode == MODE_IEEE80211B))
205 while (i < mode->num_channels && c < IW_MAX_FREQUENCIES) {
206 struct ieee80211_channel *chan = &mode->channels[i];
208 if (chan->flag & IEEE80211_CHAN_W_SCAN) {
209 range->freq[c].i = chan->chan;
210 range->freq[c].m = chan->freq * 100000;
211 range->freq[c].e = 1;
217 range->num_channels = c;
218 range->num_frequency = c;
220 IW_EVENT_CAPA_SET_KERNEL(range->event_capa);
221 IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWTHRSPY);
222 IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWAP);
223 IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWSCAN);
229 static int ieee80211_ioctl_siwmode(struct net_device *dev,
230 struct iw_request_info *info,
231 __u32 *mode, char *extra)
233 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
236 if (sdata->type == IEEE80211_IF_TYPE_VLAN)
241 type = IEEE80211_IF_TYPE_STA;
244 type = IEEE80211_IF_TYPE_IBSS;
246 case IW_MODE_MONITOR:
247 type = IEEE80211_IF_TYPE_MNTR;
253 if (type == sdata->type)
255 if (netif_running(dev))
258 ieee80211_if_reinit(dev);
259 ieee80211_if_set_type(dev, type);
265 static int ieee80211_ioctl_giwmode(struct net_device *dev,
266 struct iw_request_info *info,
267 __u32 *mode, char *extra)
269 struct ieee80211_sub_if_data *sdata;
271 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
272 switch (sdata->type) {
273 case IEEE80211_IF_TYPE_AP:
274 *mode = IW_MODE_MASTER;
276 case IEEE80211_IF_TYPE_STA:
277 *mode = IW_MODE_INFRA;
279 case IEEE80211_IF_TYPE_IBSS:
280 *mode = IW_MODE_ADHOC;
282 case IEEE80211_IF_TYPE_MNTR:
283 *mode = IW_MODE_MONITOR;
285 case IEEE80211_IF_TYPE_WDS:
286 *mode = IW_MODE_REPEAT;
288 case IEEE80211_IF_TYPE_VLAN:
289 *mode = IW_MODE_SECOND; /* FIXME */
292 *mode = IW_MODE_AUTO;
298 int ieee80211_set_channel(struct ieee80211_local *local, int channel, int freq)
300 struct ieee80211_hw_mode *mode;
304 list_for_each_entry(mode, &local->modes_list, list) {
305 if (!(local->enabled_modes & (1 << mode->mode)))
307 for (c = 0; c < mode->num_channels; c++) {
308 struct ieee80211_channel *chan = &mode->channels[c];
309 if (chan->flag & IEEE80211_CHAN_W_SCAN &&
310 ((chan->chan == channel) || (chan->freq == freq))) {
311 /* Use next_mode as the mode preference to
312 * resolve non-unique channel numbers. */
313 if (set && mode->mode != local->next_mode)
316 local->oper_channel = chan;
317 local->oper_hw_mode = mode;
324 if (local->sta_scanning)
327 ret = ieee80211_hw_config(local);
329 rate_control_clear(local);
335 static int ieee80211_ioctl_siwfreq(struct net_device *dev,
336 struct iw_request_info *info,
337 struct iw_freq *freq, char *extra)
339 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
340 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
342 if (sdata->type == IEEE80211_IF_TYPE_STA)
343 sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_CHANNEL_SEL;
345 /* freq->e == 0: freq->m = channel; otherwise freq = m * 10^e */
348 if (sdata->type == IEEE80211_IF_TYPE_STA)
349 sdata->u.sta.flags |=
350 IEEE80211_STA_AUTO_CHANNEL_SEL;
353 return ieee80211_set_channel(local, freq->m, -1);
355 int i, div = 1000000;
356 for (i = 0; i < freq->e; i++)
359 return ieee80211_set_channel(local, -1, freq->m / div);
366 static int ieee80211_ioctl_giwfreq(struct net_device *dev,
367 struct iw_request_info *info,
368 struct iw_freq *freq, char *extra)
370 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
372 /* TODO: in station mode (Managed/Ad-hoc) might need to poll low-level
373 * driver for the current channel with firmware-based management */
375 freq->m = local->hw.conf.freq;
382 static int ieee80211_ioctl_siwessid(struct net_device *dev,
383 struct iw_request_info *info,
384 struct iw_point *data, char *ssid)
386 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
387 struct ieee80211_sub_if_data *sdata;
388 size_t len = data->length;
390 /* iwconfig uses nul termination in SSID.. */
391 if (len > 0 && ssid[len - 1] == '\0')
394 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
395 if (sdata->type == IEEE80211_IF_TYPE_STA ||
396 sdata->type == IEEE80211_IF_TYPE_IBSS) {
398 if (local->user_space_mlme) {
399 if (len > IEEE80211_MAX_SSID_LEN)
401 memcpy(sdata->u.sta.ssid, ssid, len);
402 sdata->u.sta.ssid_len = len;
406 sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_SSID_SEL;
408 sdata->u.sta.flags |= IEEE80211_STA_AUTO_SSID_SEL;
409 ret = ieee80211_sta_set_ssid(dev, ssid, len);
412 ieee80211_sta_req_auth(dev, &sdata->u.sta);
416 if (sdata->type == IEEE80211_IF_TYPE_AP) {
417 memcpy(sdata->u.ap.ssid, ssid, len);
418 memset(sdata->u.ap.ssid + len, 0,
419 IEEE80211_MAX_SSID_LEN - len);
420 sdata->u.ap.ssid_len = len;
421 return ieee80211_if_config(dev);
427 static int ieee80211_ioctl_giwessid(struct net_device *dev,
428 struct iw_request_info *info,
429 struct iw_point *data, char *ssid)
433 struct ieee80211_sub_if_data *sdata;
434 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
435 if (sdata->type == IEEE80211_IF_TYPE_STA ||
436 sdata->type == IEEE80211_IF_TYPE_IBSS) {
437 int res = ieee80211_sta_get_ssid(dev, ssid, &len);
446 if (sdata->type == IEEE80211_IF_TYPE_AP) {
447 len = sdata->u.ap.ssid_len;
448 if (len > IW_ESSID_MAX_SIZE)
449 len = IW_ESSID_MAX_SIZE;
450 memcpy(ssid, sdata->u.ap.ssid, len);
459 static int ieee80211_ioctl_siwap(struct net_device *dev,
460 struct iw_request_info *info,
461 struct sockaddr *ap_addr, char *extra)
463 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
464 struct ieee80211_sub_if_data *sdata;
466 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
467 if (sdata->type == IEEE80211_IF_TYPE_STA ||
468 sdata->type == IEEE80211_IF_TYPE_IBSS) {
470 if (local->user_space_mlme) {
471 memcpy(sdata->u.sta.bssid, (u8 *) &ap_addr->sa_data,
475 if (is_zero_ether_addr((u8 *) &ap_addr->sa_data))
476 sdata->u.sta.flags |= IEEE80211_STA_AUTO_BSSID_SEL |
477 IEEE80211_STA_AUTO_CHANNEL_SEL;
478 else if (is_broadcast_ether_addr((u8 *) &ap_addr->sa_data))
479 sdata->u.sta.flags |= IEEE80211_STA_AUTO_BSSID_SEL;
481 sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL;
482 ret = ieee80211_sta_set_bssid(dev, (u8 *) &ap_addr->sa_data);
485 ieee80211_sta_req_auth(dev, &sdata->u.sta);
487 } else if (sdata->type == IEEE80211_IF_TYPE_WDS) {
488 if (memcmp(sdata->u.wds.remote_addr, (u8 *) &ap_addr->sa_data,
491 return ieee80211_if_update_wds(dev, (u8 *) &ap_addr->sa_data);
498 static int ieee80211_ioctl_giwap(struct net_device *dev,
499 struct iw_request_info *info,
500 struct sockaddr *ap_addr, char *extra)
502 struct ieee80211_sub_if_data *sdata;
504 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
505 if (sdata->type == IEEE80211_IF_TYPE_STA ||
506 sdata->type == IEEE80211_IF_TYPE_IBSS) {
507 ap_addr->sa_family = ARPHRD_ETHER;
508 memcpy(&ap_addr->sa_data, sdata->u.sta.bssid, ETH_ALEN);
510 } else if (sdata->type == IEEE80211_IF_TYPE_WDS) {
511 ap_addr->sa_family = ARPHRD_ETHER;
512 memcpy(&ap_addr->sa_data, sdata->u.wds.remote_addr, ETH_ALEN);
520 static int ieee80211_ioctl_siwscan(struct net_device *dev,
521 struct iw_request_info *info,
522 struct iw_point *data, char *extra)
524 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
525 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
529 if (!netif_running(dev))
532 switch (sdata->type) {
533 case IEEE80211_IF_TYPE_STA:
534 case IEEE80211_IF_TYPE_IBSS:
535 if (local->scan_flags & IEEE80211_SCAN_MATCH_SSID) {
536 ssid = sdata->u.sta.ssid;
537 ssid_len = sdata->u.sta.ssid_len;
540 case IEEE80211_IF_TYPE_AP:
541 if (local->scan_flags & IEEE80211_SCAN_MATCH_SSID) {
542 ssid = sdata->u.ap.ssid;
543 ssid_len = sdata->u.ap.ssid_len;
550 return ieee80211_sta_req_scan(dev, ssid, ssid_len);
554 static int ieee80211_ioctl_giwscan(struct net_device *dev,
555 struct iw_request_info *info,
556 struct iw_point *data, char *extra)
559 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
560 if (local->sta_scanning)
562 res = ieee80211_sta_scan_results(dev, extra, data->length);
572 static int ieee80211_ioctl_siwrate(struct net_device *dev,
573 struct iw_request_info *info,
574 struct iw_param *rate, char *extra)
576 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
577 struct ieee80211_hw_mode *mode;
579 u32 target_rate = rate->value / 100000;
580 struct ieee80211_sub_if_data *sdata;
582 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
585 mode = local->oper_hw_mode;
586 /* target_rate = -1, rate->fixed = 0 means auto only, so use all rates
587 * target_rate = X, rate->fixed = 1 means only rate X
588 * target_rate = X, rate->fixed = 0 means all rates <= X */
589 sdata->bss->max_ratectrl_rateidx = -1;
590 sdata->bss->force_unicast_rateidx = -1;
593 for (i=0; i< mode->num_rates; i++) {
594 struct ieee80211_rate *rates = &mode->rates[i];
595 int this_rate = rates->rate;
597 if (mode->mode == MODE_ATHEROS_TURBO ||
598 mode->mode == MODE_ATHEROS_TURBOG)
600 if (target_rate == this_rate) {
601 sdata->bss->max_ratectrl_rateidx = i;
603 sdata->bss->force_unicast_rateidx = i;
610 static int ieee80211_ioctl_giwrate(struct net_device *dev,
611 struct iw_request_info *info,
612 struct iw_param *rate, char *extra)
614 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
615 struct sta_info *sta;
616 struct ieee80211_sub_if_data *sdata;
618 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
619 if (sdata->type == IEEE80211_IF_TYPE_STA)
620 sta = sta_info_get(local, sdata->u.sta.bssid);
625 if (sta->txrate < local->oper_hw_mode->num_rates)
626 rate->value = local->oper_hw_mode->rates[sta->txrate].rate * 100000;
633 static int ieee80211_ioctl_giwtxpower(struct net_device *dev,
634 struct iw_request_info *info,
635 union iwreq_data *data, char *extra)
637 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
639 data->txpower.fixed = 1;
640 data->txpower.disabled = !(local->hw.conf.radio_enabled);
641 data->txpower.value = local->hw.conf.power_level;
642 data->txpower.flags = IW_TXPOW_DBM;
647 static int ieee80211_ioctl_siwrts(struct net_device *dev,
648 struct iw_request_info *info,
649 struct iw_param *rts, char *extra)
651 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
654 local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
655 else if (rts->value < 0 || rts->value > IEEE80211_MAX_RTS_THRESHOLD)
658 local->rts_threshold = rts->value;
660 /* If the wlan card performs RTS/CTS in hardware/firmware,
661 * configure it here */
663 if (local->ops->set_rts_threshold)
664 local->ops->set_rts_threshold(local_to_hw(local),
665 local->rts_threshold);
670 static int ieee80211_ioctl_giwrts(struct net_device *dev,
671 struct iw_request_info *info,
672 struct iw_param *rts, char *extra)
674 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
676 rts->value = local->rts_threshold;
677 rts->disabled = (rts->value >= IEEE80211_MAX_RTS_THRESHOLD);
684 static int ieee80211_ioctl_siwfrag(struct net_device *dev,
685 struct iw_request_info *info,
686 struct iw_param *frag, char *extra)
688 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
691 local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
692 else if (frag->value < 256 ||
693 frag->value > IEEE80211_MAX_FRAG_THRESHOLD)
696 /* Fragment length must be even, so strip LSB. */
697 local->fragmentation_threshold = frag->value & ~0x1;
700 /* If the wlan card performs fragmentation in hardware/firmware,
701 * configure it here */
703 if (local->ops->set_frag_threshold)
704 local->ops->set_frag_threshold(
706 local->fragmentation_threshold);
711 static int ieee80211_ioctl_giwfrag(struct net_device *dev,
712 struct iw_request_info *info,
713 struct iw_param *frag, char *extra)
715 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
717 frag->value = local->fragmentation_threshold;
718 frag->disabled = (frag->value >= IEEE80211_MAX_RTS_THRESHOLD);
725 static int ieee80211_ioctl_siwretry(struct net_device *dev,
726 struct iw_request_info *info,
727 struct iw_param *retry, char *extra)
729 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
731 if (retry->disabled ||
732 (retry->flags & IW_RETRY_TYPE) != IW_RETRY_LIMIT)
735 if (retry->flags & IW_RETRY_MAX)
736 local->long_retry_limit = retry->value;
737 else if (retry->flags & IW_RETRY_MIN)
738 local->short_retry_limit = retry->value;
740 local->long_retry_limit = retry->value;
741 local->short_retry_limit = retry->value;
744 if (local->ops->set_retry_limit) {
745 return local->ops->set_retry_limit(
747 local->short_retry_limit,
748 local->long_retry_limit);
755 static int ieee80211_ioctl_giwretry(struct net_device *dev,
756 struct iw_request_info *info,
757 struct iw_param *retry, char *extra)
759 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
762 if (retry->flags == 0 || retry->flags & IW_RETRY_MIN) {
763 /* first return min value, iwconfig will ask max value
765 retry->flags |= IW_RETRY_LIMIT;
766 retry->value = local->short_retry_limit;
767 if (local->long_retry_limit != local->short_retry_limit)
768 retry->flags |= IW_RETRY_MIN;
771 if (retry->flags & IW_RETRY_MAX) {
772 retry->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
773 retry->value = local->long_retry_limit;
779 static int ieee80211_ioctl_prism2_param(struct net_device *dev,
780 struct iw_request_info *info,
781 void *wrqu, char *extra)
783 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
784 struct ieee80211_sub_if_data *sdata;
785 int *i = (int *) extra;
787 int value = *(i + 1);
790 if (!capable(CAP_NET_ADMIN))
793 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
796 case PRISM2_PARAM_IEEE_802_1X:
797 if (local->ops->set_ieee8021x)
798 ret = local->ops->set_ieee8021x(local_to_hw(local),
801 printk(KERN_DEBUG "%s: failed to set IEEE 802.1X (%d) "
802 "for low-level driver\n", dev->name, value);
804 sdata->ieee802_1x = value;
807 case PRISM2_PARAM_CTS_PROTECT_ERP_FRAMES:
808 if (sdata->type == IEEE80211_IF_TYPE_AP) {
810 sdata->flags |= IEEE80211_SDATA_USE_PROTECTION;
812 sdata->flags &= ~IEEE80211_SDATA_USE_PROTECTION;
813 ieee80211_erp_info_change_notify(dev,
814 IEEE80211_ERP_CHANGE_PROTECTION);
820 case PRISM2_PARAM_PREAMBLE:
821 if (sdata->type == IEEE80211_IF_TYPE_AP) {
823 sdata->flags |= IEEE80211_SDATA_SHORT_PREAMBLE;
825 sdata->flags &= ~IEEE80211_SDATA_SHORT_PREAMBLE;
826 ieee80211_erp_info_change_notify(dev,
827 IEEE80211_ERP_CHANGE_PREAMBLE);
833 case PRISM2_PARAM_SHORT_SLOT_TIME:
835 local->hw.conf.flags |= IEEE80211_CONF_SHORT_SLOT_TIME;
837 local->hw.conf.flags &= ~IEEE80211_CONF_SHORT_SLOT_TIME;
838 if (ieee80211_hw_config(local))
842 case PRISM2_PARAM_NEXT_MODE:
843 local->next_mode = value;
846 case PRISM2_PARAM_KEY_TX_RX_THRESHOLD:
847 local->key_tx_rx_threshold = value;
850 case PRISM2_PARAM_WIFI_WME_NOACK_TEST:
851 local->wifi_wme_noack_test = value;
854 case PRISM2_PARAM_SCAN_FLAGS:
855 local->scan_flags = value;
858 case PRISM2_PARAM_MIXED_CELL:
859 if (sdata->type != IEEE80211_IF_TYPE_STA &&
860 sdata->type != IEEE80211_IF_TYPE_IBSS)
864 sdata->u.sta.flags |= IEEE80211_STA_MIXED_CELL;
866 sdata->u.sta.flags &= ~IEEE80211_STA_MIXED_CELL;
870 case PRISM2_PARAM_HW_MODES:
871 local->enabled_modes = value;
874 case PRISM2_PARAM_CREATE_IBSS:
875 if (sdata->type != IEEE80211_IF_TYPE_IBSS)
879 sdata->u.sta.flags |= IEEE80211_STA_CREATE_IBSS;
881 sdata->u.sta.flags &= ~IEEE80211_STA_CREATE_IBSS;
884 case PRISM2_PARAM_WMM_ENABLED:
885 if (sdata->type != IEEE80211_IF_TYPE_STA &&
886 sdata->type != IEEE80211_IF_TYPE_IBSS)
890 sdata->u.sta.flags |= IEEE80211_STA_WMM_ENABLED;
892 sdata->u.sta.flags &= ~IEEE80211_STA_WMM_ENABLED;
904 static int ieee80211_ioctl_get_prism2_param(struct net_device *dev,
905 struct iw_request_info *info,
906 void *wrqu, char *extra)
908 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
909 struct ieee80211_sub_if_data *sdata;
910 int *param = (int *) extra;
913 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
916 case PRISM2_PARAM_IEEE_802_1X:
917 *param = sdata->ieee802_1x;
920 case PRISM2_PARAM_CTS_PROTECT_ERP_FRAMES:
921 *param = !!(sdata->flags & IEEE80211_SDATA_USE_PROTECTION);
924 case PRISM2_PARAM_PREAMBLE:
925 *param = !!(sdata->flags & IEEE80211_SDATA_SHORT_PREAMBLE);
928 case PRISM2_PARAM_SHORT_SLOT_TIME:
929 *param = !!(local->hw.conf.flags & IEEE80211_CONF_SHORT_SLOT_TIME);
932 case PRISM2_PARAM_NEXT_MODE:
933 *param = local->next_mode;
936 case PRISM2_PARAM_KEY_TX_RX_THRESHOLD:
937 *param = local->key_tx_rx_threshold;
940 case PRISM2_PARAM_WIFI_WME_NOACK_TEST:
941 *param = local->wifi_wme_noack_test;
944 case PRISM2_PARAM_SCAN_FLAGS:
945 *param = local->scan_flags;
948 case PRISM2_PARAM_HW_MODES:
949 *param = local->enabled_modes;
952 case PRISM2_PARAM_CREATE_IBSS:
953 if (sdata->type != IEEE80211_IF_TYPE_IBSS)
956 *param = !!(sdata->u.sta.flags &
957 IEEE80211_STA_CREATE_IBSS);
960 case PRISM2_PARAM_MIXED_CELL:
961 if (sdata->type != IEEE80211_IF_TYPE_STA &&
962 sdata->type != IEEE80211_IF_TYPE_IBSS)
965 *param = !!(sdata->u.sta.flags &
966 IEEE80211_STA_MIXED_CELL);
969 case PRISM2_PARAM_WMM_ENABLED:
970 if (sdata->type != IEEE80211_IF_TYPE_STA &&
971 sdata->type != IEEE80211_IF_TYPE_IBSS)
974 *param = !!(sdata->u.sta.flags &
975 IEEE80211_STA_WMM_ENABLED);
985 static int ieee80211_ioctl_siwmlme(struct net_device *dev,
986 struct iw_request_info *info,
987 struct iw_point *data, char *extra)
989 struct ieee80211_sub_if_data *sdata;
990 struct iw_mlme *mlme = (struct iw_mlme *) extra;
992 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
993 if (sdata->type != IEEE80211_IF_TYPE_STA &&
994 sdata->type != IEEE80211_IF_TYPE_IBSS)
999 /* TODO: mlme->addr.sa_data */
1000 return ieee80211_sta_deauthenticate(dev, mlme->reason_code);
1001 case IW_MLME_DISASSOC:
1002 /* TODO: mlme->addr.sa_data */
1003 return ieee80211_sta_disassociate(dev, mlme->reason_code);
1010 static int ieee80211_ioctl_siwencode(struct net_device *dev,
1011 struct iw_request_info *info,
1012 struct iw_point *erq, char *keybuf)
1014 struct ieee80211_sub_if_data *sdata;
1015 int idx, i, alg = ALG_WEP;
1016 u8 bcaddr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1018 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1020 idx = erq->flags & IW_ENCODE_INDEX;
1022 if (sdata->default_key)
1023 for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
1024 if (sdata->default_key == sdata->keys[i]) {
1029 } else if (idx < 1 || idx > 4)
1034 if (erq->flags & IW_ENCODE_DISABLED)
1036 else if (erq->length == 0) {
1037 /* No key data - just set the default TX key index */
1038 ieee80211_set_default_key(sdata, idx);
1042 return ieee80211_set_encryption(
1045 !sdata->default_key,
1046 keybuf, erq->length);
1050 static int ieee80211_ioctl_giwencode(struct net_device *dev,
1051 struct iw_request_info *info,
1052 struct iw_point *erq, char *key)
1054 struct ieee80211_sub_if_data *sdata;
1057 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1059 idx = erq->flags & IW_ENCODE_INDEX;
1060 if (idx < 1 || idx > 4) {
1062 if (!sdata->default_key)
1064 else for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
1065 if (sdata->default_key == sdata->keys[i]) {
1075 erq->flags = idx + 1;
1077 if (!sdata->keys[idx]) {
1079 erq->flags |= IW_ENCODE_DISABLED;
1083 memcpy(key, sdata->keys[idx]->conf.key,
1084 min_t(int, erq->length, sdata->keys[idx]->conf.keylen));
1085 erq->length = sdata->keys[idx]->conf.keylen;
1086 erq->flags |= IW_ENCODE_ENABLED;
1091 static int ieee80211_ioctl_siwauth(struct net_device *dev,
1092 struct iw_request_info *info,
1093 struct iw_param *data, char *extra)
1095 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1096 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1099 switch (data->flags & IW_AUTH_INDEX) {
1100 case IW_AUTH_WPA_VERSION:
1101 case IW_AUTH_CIPHER_PAIRWISE:
1102 case IW_AUTH_CIPHER_GROUP:
1103 case IW_AUTH_WPA_ENABLED:
1104 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
1106 case IW_AUTH_KEY_MGMT:
1107 if (sdata->type != IEEE80211_IF_TYPE_STA)
1111 * Key management was set by wpa_supplicant,
1112 * we only need this to associate to a network
1113 * that has privacy enabled regardless of not
1116 sdata->u.sta.key_management_enabled = !!data->value;
1119 case IW_AUTH_80211_AUTH_ALG:
1120 if (sdata->type == IEEE80211_IF_TYPE_STA ||
1121 sdata->type == IEEE80211_IF_TYPE_IBSS)
1122 sdata->u.sta.auth_algs = data->value;
1126 case IW_AUTH_PRIVACY_INVOKED:
1127 if (local->ops->set_privacy_invoked)
1128 ret = local->ops->set_privacy_invoked(
1129 local_to_hw(local), data->value);
1138 /* Get wireless statistics. Called by /proc/net/wireless and by SIOCGIWSTATS */
1139 static struct iw_statistics *ieee80211_get_wireless_stats(struct net_device *dev)
1141 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1142 struct iw_statistics *wstats = &local->wstats;
1143 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1144 struct sta_info *sta = NULL;
1146 if (sdata->type == IEEE80211_IF_TYPE_STA ||
1147 sdata->type == IEEE80211_IF_TYPE_IBSS)
1148 sta = sta_info_get(local, sdata->u.sta.bssid);
1150 wstats->discard.fragment = 0;
1151 wstats->discard.misc = 0;
1152 wstats->qual.qual = 0;
1153 wstats->qual.level = 0;
1154 wstats->qual.noise = 0;
1155 wstats->qual.updated = IW_QUAL_ALL_INVALID;
1157 wstats->qual.level = sta->last_rssi;
1158 wstats->qual.qual = sta->last_signal;
1159 wstats->qual.noise = sta->last_noise;
1160 wstats->qual.updated = local->wstats_flags;
1166 static int ieee80211_ioctl_giwauth(struct net_device *dev,
1167 struct iw_request_info *info,
1168 struct iw_param *data, char *extra)
1170 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1173 switch (data->flags & IW_AUTH_INDEX) {
1174 case IW_AUTH_80211_AUTH_ALG:
1175 if (sdata->type == IEEE80211_IF_TYPE_STA ||
1176 sdata->type == IEEE80211_IF_TYPE_IBSS)
1177 data->value = sdata->u.sta.auth_algs;
1189 static int ieee80211_ioctl_siwencodeext(struct net_device *dev,
1190 struct iw_request_info *info,
1191 struct iw_point *erq, char *extra)
1193 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1194 struct iw_encode_ext *ext = (struct iw_encode_ext *) extra;
1198 case IW_ENCODE_ALG_NONE:
1201 case IW_ENCODE_ALG_WEP:
1204 case IW_ENCODE_ALG_TKIP:
1207 case IW_ENCODE_ALG_CCMP:
1214 if (erq->flags & IW_ENCODE_DISABLED)
1217 idx = erq->flags & IW_ENCODE_INDEX;
1218 if (idx < 1 || idx > 4) {
1220 if (!sdata->default_key)
1222 else for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
1223 if (sdata->default_key == sdata->keys[i]) {
1233 return ieee80211_set_encryption(dev, ext->addr.sa_data, idx, alg,
1235 IW_ENCODE_EXT_SET_TX_KEY,
1236 ext->key, ext->key_len);
1240 static const struct iw_priv_args ieee80211_ioctl_priv[] = {
1241 { PRISM2_IOCTL_PRISM2_PARAM,
1242 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "param" },
1243 { PRISM2_IOCTL_GET_PRISM2_PARAM,
1244 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1245 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "get_param" },
1248 /* Structures to export the Wireless Handlers */
1250 static const iw_handler ieee80211_handler[] =
1252 (iw_handler) NULL, /* SIOCSIWCOMMIT */
1253 (iw_handler) ieee80211_ioctl_giwname, /* SIOCGIWNAME */
1254 (iw_handler) NULL, /* SIOCSIWNWID */
1255 (iw_handler) NULL, /* SIOCGIWNWID */
1256 (iw_handler) ieee80211_ioctl_siwfreq, /* SIOCSIWFREQ */
1257 (iw_handler) ieee80211_ioctl_giwfreq, /* SIOCGIWFREQ */
1258 (iw_handler) ieee80211_ioctl_siwmode, /* SIOCSIWMODE */
1259 (iw_handler) ieee80211_ioctl_giwmode, /* SIOCGIWMODE */
1260 (iw_handler) NULL, /* SIOCSIWSENS */
1261 (iw_handler) NULL, /* SIOCGIWSENS */
1262 (iw_handler) NULL /* not used */, /* SIOCSIWRANGE */
1263 (iw_handler) ieee80211_ioctl_giwrange, /* SIOCGIWRANGE */
1264 (iw_handler) NULL /* not used */, /* SIOCSIWPRIV */
1265 (iw_handler) NULL /* kernel code */, /* SIOCGIWPRIV */
1266 (iw_handler) NULL /* not used */, /* SIOCSIWSTATS */
1267 (iw_handler) NULL /* kernel code */, /* SIOCGIWSTATS */
1268 (iw_handler) NULL, /* SIOCSIWSPY */
1269 (iw_handler) NULL, /* SIOCGIWSPY */
1270 (iw_handler) NULL, /* SIOCSIWTHRSPY */
1271 (iw_handler) NULL, /* SIOCGIWTHRSPY */
1272 (iw_handler) ieee80211_ioctl_siwap, /* SIOCSIWAP */
1273 (iw_handler) ieee80211_ioctl_giwap, /* SIOCGIWAP */
1274 (iw_handler) ieee80211_ioctl_siwmlme, /* SIOCSIWMLME */
1275 (iw_handler) NULL, /* SIOCGIWAPLIST */
1276 (iw_handler) ieee80211_ioctl_siwscan, /* SIOCSIWSCAN */
1277 (iw_handler) ieee80211_ioctl_giwscan, /* SIOCGIWSCAN */
1278 (iw_handler) ieee80211_ioctl_siwessid, /* SIOCSIWESSID */
1279 (iw_handler) ieee80211_ioctl_giwessid, /* SIOCGIWESSID */
1280 (iw_handler) NULL, /* SIOCSIWNICKN */
1281 (iw_handler) NULL, /* SIOCGIWNICKN */
1282 (iw_handler) NULL, /* -- hole -- */
1283 (iw_handler) NULL, /* -- hole -- */
1284 (iw_handler) ieee80211_ioctl_siwrate, /* SIOCSIWRATE */
1285 (iw_handler) ieee80211_ioctl_giwrate, /* SIOCGIWRATE */
1286 (iw_handler) ieee80211_ioctl_siwrts, /* SIOCSIWRTS */
1287 (iw_handler) ieee80211_ioctl_giwrts, /* SIOCGIWRTS */
1288 (iw_handler) ieee80211_ioctl_siwfrag, /* SIOCSIWFRAG */
1289 (iw_handler) ieee80211_ioctl_giwfrag, /* SIOCGIWFRAG */
1290 (iw_handler) NULL, /* SIOCSIWTXPOW */
1291 (iw_handler) ieee80211_ioctl_giwtxpower, /* SIOCGIWTXPOW */
1292 (iw_handler) ieee80211_ioctl_siwretry, /* SIOCSIWRETRY */
1293 (iw_handler) ieee80211_ioctl_giwretry, /* SIOCGIWRETRY */
1294 (iw_handler) ieee80211_ioctl_siwencode, /* SIOCSIWENCODE */
1295 (iw_handler) ieee80211_ioctl_giwencode, /* SIOCGIWENCODE */
1296 (iw_handler) NULL, /* SIOCSIWPOWER */
1297 (iw_handler) NULL, /* SIOCGIWPOWER */
1298 (iw_handler) NULL, /* -- hole -- */
1299 (iw_handler) NULL, /* -- hole -- */
1300 (iw_handler) ieee80211_ioctl_siwgenie, /* SIOCSIWGENIE */
1301 (iw_handler) NULL, /* SIOCGIWGENIE */
1302 (iw_handler) ieee80211_ioctl_siwauth, /* SIOCSIWAUTH */
1303 (iw_handler) ieee80211_ioctl_giwauth, /* SIOCGIWAUTH */
1304 (iw_handler) ieee80211_ioctl_siwencodeext, /* SIOCSIWENCODEEXT */
1305 (iw_handler) NULL, /* SIOCGIWENCODEEXT */
1306 (iw_handler) NULL, /* SIOCSIWPMKSA */
1307 (iw_handler) NULL, /* -- hole -- */
1310 static const iw_handler ieee80211_private_handler[] =
1311 { /* SIOCIWFIRSTPRIV + */
1312 (iw_handler) ieee80211_ioctl_prism2_param, /* 0 */
1313 (iw_handler) ieee80211_ioctl_get_prism2_param, /* 1 */
1316 const struct iw_handler_def ieee80211_iw_handler_def =
1318 .num_standard = ARRAY_SIZE(ieee80211_handler),
1319 .num_private = ARRAY_SIZE(ieee80211_private_handler),
1320 .num_private_args = ARRAY_SIZE(ieee80211_ioctl_priv),
1321 .standard = (iw_handler *) ieee80211_handler,
1322 .private = (iw_handler *) ieee80211_private_handler,
1323 .private_args = (struct iw_priv_args *) ieee80211_ioctl_priv,
1324 .get_wireless_stats = ieee80211_get_wireless_stats,