?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / net / wireless / hostap / hostap_ioctl.c
blob8fe195e6a0adc3819bb0d95f291a09679d90089f
1 /* ioctl() (mostly Linux Wireless Extensions) routines for Host AP driver */
2
3 #include <linux/slab.h>
4 #include <linux/types.h>
5 #include <linux/sched.h>
6 #include <linux/ethtool.h>
7 #include <linux/if_arp.h>
8 #include <net/lib80211.h>
9
10 #include "hostap_wlan.h"
11 #include "hostap.h"
12 #include "hostap_ap.h"
13
14 static struct iw_statistics *hostap_get_wireless_stats(struct net_device *dev)
15 {
16 struct hostap_interface *iface;
17 local_info_t *local;
18 struct iw_statistics *wstats;
19
20 iface = netdev_priv(dev);
21 local = iface->local;
22
23 /* Why are we doing that ? Jean II */
24 if (iface->type != HOSTAP_INTERFACE_MAIN)
25 return NULL;
26
27 wstats = &local->wstats;
28
29 wstats->status = 0;
30 wstats->discard.code =
31 local->comm_tallies.rx_discards_wep_undecryptable;
32 wstats->discard.misc =
33 local->comm_tallies.rx_fcs_errors +
34 local->comm_tallies.rx_discards_no_buffer +
35 local->comm_tallies.tx_discards_wrong_sa;
36
37 wstats->discard.retries =
38 local->comm_tallies.tx_retry_limit_exceeded;
39 wstats->discard.fragment =
40 local->comm_tallies.rx_message_in_bad_msg_fragments;
41
42 if (local->iw_mode != IW_MODE_MASTER &&
43 local->iw_mode != IW_MODE_REPEAT) {
44 int update = 1;
45 #ifdef in_atomic
46 /* RID reading might sleep and it must not be called in
47 * interrupt context or while atomic. However, this
48 * function seems to be called while atomic (at least in Linux
49 * 2.5.59). Update signal quality values only if in suitable
50 * context. Otherwise, previous values read from tick timer
51 * will be used. */
52 if (in_atomic())
53 update = 0;
54 #endif /* in_atomic */
55
56 if (update && prism2_update_comms_qual(dev) == 0)
57 wstats->qual.updated = IW_QUAL_ALL_UPDATED |
58 IW_QUAL_DBM;
59
60 wstats->qual.qual = local->comms_qual;
61 wstats->qual.level = local->avg_signal;
62 wstats->qual.noise = local->avg_noise;
63 } else {
64 wstats->qual.qual = 0;
65 wstats->qual.level = 0;
66 wstats->qual.noise = 0;
67 wstats->qual.updated = IW_QUAL_ALL_INVALID;
68 }
69
70 return wstats;
71 }
72
73
74 static int prism2_get_datarates(struct net_device *dev, u8 *rates)
75 {
76 struct hostap_interface *iface;
77 local_info_t *local;
78 u8 buf[12];
79 int len;
80 u16 val;
81
82 iface = netdev_priv(dev);
83 local = iface->local;
84
85 len = local->func->get_rid(dev, HFA384X_RID_SUPPORTEDDATARATES, buf,
86 sizeof(buf), 0);
87 if (len < 2)
88 return 0;
89
90 val = le16_to_cpu(*(__le16 *) buf); /* string length */
91
92 if (len - 2 < val || val > 10)
93 return 0;
94
95 memcpy(rates, buf + 2, val);
96 return val;
97 }
98
99
100 static int prism2_get_name(struct net_device *dev,
101 struct iw_request_info *info,
102 char *name, char *extra)
103 {
104 u8 rates[10];
105 int len, i, over2 = 0;
106
107 len = prism2_get_datarates(dev, rates);
108
109 for (i = 0; i < len; i++) {
110 if (rates[i] == 0x0b || rates[i] == 0x16) {
111 over2 = 1;
112 break;
113 }
114 }
115
116 strcpy(name, over2 ? "IEEE 802.11b" : "IEEE 802.11-DS");
117
118 return 0;
119 }
120
121
122 static int prism2_ioctl_siwencode(struct net_device *dev,
123 struct iw_request_info *info,
124 struct iw_point *erq, char *keybuf)
125 {
126 struct hostap_interface *iface;
127 local_info_t *local;
128 int i;
129 struct lib80211_crypt_data **crypt;
130
131 iface = netdev_priv(dev);
132 local = iface->local;
133
134 i = erq->flags & IW_ENCODE_INDEX;
135 if (i < 1 || i > 4)
136 i = local->crypt_info.tx_keyidx;
137 else
138 i--;
139 if (i < 0 || i >= WEP_KEYS)
140 return -EINVAL;
141
142 crypt = &local->crypt_info.crypt[i];
143
144 if (erq->flags & IW_ENCODE_DISABLED) {
145 if (*crypt)
146 lib80211_crypt_delayed_deinit(&local->crypt_info, crypt);
147 goto done;
148 }
149
150 if (*crypt != NULL && (*crypt)->ops != NULL &&
151 strcmp((*crypt)->ops->name, "WEP") != 0) {
152 /* changing to use WEP; deinit previously used algorithm */
153 lib80211_crypt_delayed_deinit(&local->crypt_info, crypt);
154 }
155
156 if (*crypt == NULL) {
157 struct lib80211_crypt_data *new_crypt;
158
159 /* take WEP into use */
160 new_crypt = kzalloc(sizeof(struct lib80211_crypt_data),
161 GFP_KERNEL);
162 if (new_crypt == NULL)
163 return -ENOMEM;
164 new_crypt->ops = lib80211_get_crypto_ops("WEP");
165 if (!new_crypt->ops) {
166 request_module("lib80211_crypt_wep");
167 new_crypt->ops = lib80211_get_crypto_ops("WEP");
168 }
169 if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
170 new_crypt->priv = new_crypt->ops->init(i);
171 if (!new_crypt->ops || !new_crypt->priv) {
172 kfree(new_crypt);
173 new_crypt = NULL;
174
175 printk(KERN_WARNING "%s: could not initialize WEP: "
176 "load module hostap_crypt_wep.o\n",
177 dev->name);
178 return -EOPNOTSUPP;
179 }
180 *crypt = new_crypt;
181 }
182
183 if (erq->length > 0) {
184 int len = erq->length <= 5 ? 5 : 13;
185 int first = 1, j;
186 if (len > erq->length)
187 memset(keybuf + erq->length, 0, len - erq->length);
188 (*crypt)->ops->set_key(keybuf, len, NULL, (*crypt)->priv);
189 for (j = 0; j < WEP_KEYS; j++) {
190 if (j != i && local->crypt_info.crypt[j]) {
191 first = 0;
192 break;
193 }
194 }
195 if (first)
196 local->crypt_info.tx_keyidx = i;
197 } else {
198 /* No key data - just set the default TX key index */
199 local->crypt_info.tx_keyidx = i;
200 }
201
202 done:
203 local->open_wep = erq->flags & IW_ENCODE_OPEN;
204
205 if (hostap_set_encryption(local)) {
206 printk(KERN_DEBUG "%s: set_encryption failed\n", dev->name);
207 return -EINVAL;
208 }
209
210 /* Do not reset port0 if card is in Managed mode since resetting will
211 * generate new IEEE 802.11 authentication which may end up in looping
212 * with IEEE 802.1X. Prism2 documentation seem to require port reset
213 * after WEP configuration. However, keys are apparently changed at
214 * least in Managed mode. */
215 if (local->iw_mode != IW_MODE_INFRA && local->func->reset_port(dev)) {
216 printk(KERN_DEBUG "%s: reset_port failed\n", dev->name);
217 return -EINVAL;
218 }
219
220 return 0;
221 }
222
223
224 static int prism2_ioctl_giwencode(struct net_device *dev,
225 struct iw_request_info *info,
226 struct iw_point *erq, char *key)
227 {
228 struct hostap_interface *iface;
229 local_info_t *local;
230 int i, len;
231 u16 val;
232 struct lib80211_crypt_data *crypt;
233
234 iface = netdev_priv(dev);
235 local = iface->local;
236
237 i = erq->flags & IW_ENCODE_INDEX;
238 if (i < 1 || i > 4)
239 i = local->crypt_info.tx_keyidx;
240 else
241 i--;
242 if (i < 0 || i >= WEP_KEYS)
243 return -EINVAL;
244
245 crypt = local->crypt_info.crypt[i];
246 erq->flags = i + 1;
247
248 if (crypt == NULL || crypt->ops == NULL) {
249 erq->length = 0;
250 erq->flags |= IW_ENCODE_DISABLED;
251 return 0;
252 }
253
254 if (strcmp(crypt->ops->name, "WEP") != 0) {
255 /* only WEP is supported with wireless extensions, so just
256 * report that encryption is used */
257 erq->length = 0;
258 erq->flags |= IW_ENCODE_ENABLED;
259 return 0;
260 }
261
262 /* Reads from HFA384X_RID_CNFDEFAULTKEY* return bogus values, so show
263 * the keys from driver buffer */
264 len = crypt->ops->get_key(key, WEP_KEY_LEN, NULL, crypt->priv);
265 erq->length = (len >= 0 ? len : 0);
266
267 if (local->func->get_rid(dev, HFA384X_RID_CNFWEPFLAGS, &val, 2, 1) < 0)
268 {
269 printk("CNFWEPFLAGS reading failed\n");
270 return -EOPNOTSUPP;
271 }
272 le16_to_cpus(&val);
273 if (val & HFA384X_WEPFLAGS_PRIVACYINVOKED)
274 erq->flags |= IW_ENCODE_ENABLED;
275 else
276 erq->flags |= IW_ENCODE_DISABLED;
277 if (val & HFA384X_WEPFLAGS_EXCLUDEUNENCRYPTED)
278 erq->flags |= IW_ENCODE_RESTRICTED;
279 else
280 erq->flags |= IW_ENCODE_OPEN;
281
282 return 0;
283 }
284
285
286 static int hostap_set_rate(struct net_device *dev)
287 {
288 struct hostap_interface *iface;
289 local_info_t *local;
290 int ret, basic_rates;
291
292 iface = netdev_priv(dev);
293 local = iface->local;
294
295 basic_rates = local->basic_rates & local->tx_rate_control;
296 if (!basic_rates || basic_rates != local->basic_rates) {
297 printk(KERN_INFO "%s: updating basic rate set automatically "
298 "to match with the new supported rate set\n",
299 dev->name);
300 if (!basic_rates)
301 basic_rates = local->tx_rate_control;
302
303 local->basic_rates = basic_rates;
304 if (hostap_set_word(dev, HFA384X_RID_CNFBASICRATES,
305 basic_rates))
306 printk(KERN_WARNING "%s: failed to set "
307 "cnfBasicRates\n", dev->name);
308 }
309
310 ret = (hostap_set_word(dev, HFA384X_RID_TXRATECONTROL,
311 local->tx_rate_control) ||
312 hostap_set_word(dev, HFA384X_RID_CNFSUPPORTEDRATES,
313 local->tx_rate_control) ||
314 local->func->reset_port(dev));
315
316 if (ret) {
317 printk(KERN_WARNING "%s: TXRateControl/cnfSupportedRates "
318 "setting to 0x%x failed\n",
319 dev->name, local->tx_rate_control);
320 }
321
322 /* Update TX rate configuration for all STAs based on new operational
323 * rate set. */
324 hostap_update_rates(local);
325
326 return ret;
327 }
328
329
330 static int prism2_ioctl_siwrate(struct net_device *dev,
331 struct iw_request_info *info,
332 struct iw_param *rrq, char *extra)
333 {
334 struct hostap_interface *iface;
335 local_info_t *local;
336
337 iface = netdev_priv(dev);
338 local = iface->local;
339
340 if (rrq->fixed) {
341 switch (rrq->value) {
342 case 11000000:
343 local->tx_rate_control = HFA384X_RATES_11MBPS;
344 break;
345 case 5500000:
346 local->tx_rate_control = HFA384X_RATES_5MBPS;
347 break;
348 case 2000000:
349 local->tx_rate_control = HFA384X_RATES_2MBPS;
350 break;
351 case 1000000:
352 local->tx_rate_control = HFA384X_RATES_1MBPS;
353 break;
354 default:
355 local->tx_rate_control = HFA384X_RATES_1MBPS |
356 HFA384X_RATES_2MBPS | HFA384X_RATES_5MBPS |
357 HFA384X_RATES_11MBPS;
358 break;
359 }
360 } else {
361 switch (rrq->value) {
362 case 11000000:
363 local->tx_rate_control = HFA384X_RATES_1MBPS |
364 HFA384X_RATES_2MBPS | HFA384X_RATES_5MBPS |
365 HFA384X_RATES_11MBPS;
366 break;
367 case 5500000:
368 local->tx_rate_control = HFA384X_RATES_1MBPS |
369 HFA384X_RATES_2MBPS | HFA384X_RATES_5MBPS;
370 break;
371 case 2000000:
372 local->tx_rate_control = HFA384X_RATES_1MBPS |
373 HFA384X_RATES_2MBPS;
374 break;
375 case 1000000:
376 local->tx_rate_control = HFA384X_RATES_1MBPS;
377 break;
378 default:
379 local->tx_rate_control = HFA384X_RATES_1MBPS |
380 HFA384X_RATES_2MBPS | HFA384X_RATES_5MBPS |
381 HFA384X_RATES_11MBPS;
382 break;
383 }
384 }
385
386 return hostap_set_rate(dev);
387 }
388
389
390 static int prism2_ioctl_giwrate(struct net_device *dev,
391 struct iw_request_info *info,
392 struct iw_param *rrq, char *extra)
393 {
394 u16 val;
395 struct hostap_interface *iface;
396 local_info_t *local;
397 int ret = 0;
398
399 iface = netdev_priv(dev);
400 local = iface->local;
401
402 if (local->func->get_rid(dev, HFA384X_RID_TXRATECONTROL, &val, 2, 1) <
403 0)
404 return -EINVAL;
405
406 if ((val & 0x1) && (val > 1))
407 rrq->fixed = 0;
408 else
409 rrq->fixed = 1;
410
411 if (local->iw_mode == IW_MODE_MASTER && local->ap != NULL &&
412 !local->fw_tx_rate_control) {
413 /* HFA384X_RID_CURRENTTXRATE seems to always be 2 Mbps in
414 * Host AP mode, so use the recorded TX rate of the last sent
415 * frame */
416 rrq->value = local->ap->last_tx_rate > 0 ?
417 local->ap->last_tx_rate * 100000 : 11000000;
418 return 0;
419 }
420
421 if (local->func->get_rid(dev, HFA384X_RID_CURRENTTXRATE, &val, 2, 1) <
422 0)
423 return -EINVAL;
424
425 switch (val) {
426 case HFA384X_RATES_1MBPS:
427 rrq->value = 1000000;
428 break;
429 case HFA384X_RATES_2MBPS:
430 rrq->value = 2000000;
431 break;
432 case HFA384X_RATES_5MBPS:
433 rrq->value = 5500000;
434 break;
435 case HFA384X_RATES_11MBPS:
436 rrq->value = 11000000;
437 break;
438 default:
439 /* should not happen */
440 rrq->value = 11000000;
441 ret = -EINVAL;
442 break;
443 }
444
445 return ret;
446 }
447
448
449 static int prism2_ioctl_siwsens(struct net_device *dev,
450 struct iw_request_info *info,
451 struct iw_param *sens, char *extra)
452 {
453 struct hostap_interface *iface;
454 local_info_t *local;
455
456 iface = netdev_priv(dev);
457 local = iface->local;
458
459 /* Set the desired AP density */
460 if (sens->value < 1 || sens->value > 3)
461 return -EINVAL;
462
463 if (hostap_set_word(dev, HFA384X_RID_CNFSYSTEMSCALE, sens->value) ||
464 local->func->reset_port(dev))
465 return -EINVAL;
466
467 return 0;
468 }
469
470 static int prism2_ioctl_giwsens(struct net_device *dev,
471 struct iw_request_info *info,
472 struct iw_param *sens, char *extra)
473 {
474 struct hostap_interface *iface;
475 local_info_t *local;
476 __le16 val;
477
478 iface = netdev_priv(dev);
479 local = iface->local;
480
481 /* Get the current AP density */
482 if (local->func->get_rid(dev, HFA384X_RID_CNFSYSTEMSCALE, &val, 2, 1) <
483 0)
484 return -EINVAL;
485
486 sens->value = le16_to_cpu(val);
487 sens->fixed = 1;
488
489 return 0;
490 }
491
492
493 /* Deprecated in new wireless extension API */
494 static int prism2_ioctl_giwaplist(struct net_device *dev,
495 struct iw_request_info *info,
496 struct iw_point *data, char *extra)
497 {
498 struct hostap_interface *iface;
499 local_info_t *local;
500 struct sockaddr *addr;
501 struct iw_quality *qual;
502
503 iface = netdev_priv(dev);
504 local = iface->local;
505
506 if (local->iw_mode != IW_MODE_MASTER) {
507 printk(KERN_DEBUG "SIOCGIWAPLIST is currently only supported "
508 "in Host AP mode\n");
509 data->length = 0;
510 return -EOPNOTSUPP;
511 }
512
513 addr = kmalloc(sizeof(struct sockaddr) * IW_MAX_AP, GFP_KERNEL);
514 qual = kmalloc(sizeof(struct iw_quality) * IW_MAX_AP, GFP_KERNEL);
515 if (addr == NULL || qual == NULL) {
516 kfree(addr);
517 kfree(qual);
518 data->length = 0;
519 return -ENOMEM;
520 }
521
522 data->length = prism2_ap_get_sta_qual(local, addr, qual, IW_MAX_AP, 1);
523
524 memcpy(extra, &addr, sizeof(struct sockaddr) * data->length);
525 data->flags = 1; /* has quality information */
526 memcpy(extra + sizeof(struct sockaddr) * data->length, &qual,
527 sizeof(struct iw_quality) * data->length);
528
529 kfree(addr);
530 kfree(qual);
531 return 0;
532 }
533
534
535 static int prism2_ioctl_siwrts(struct net_device *dev,
536 struct iw_request_info *info,
537 struct iw_param *rts, char *extra)
538 {
539 struct hostap_interface *iface;
540 local_info_t *local;
541 __le16 val;
542
543 iface = netdev_priv(dev);
544 local = iface->local;
545
546 if (rts->disabled)
547 val = cpu_to_le16(2347);
548 else if (rts->value < 0 || rts->value > 2347)
549 return -EINVAL;
550 else
551 val = cpu_to_le16(rts->value);
552
553 if (local->func->set_rid(dev, HFA384X_RID_RTSTHRESHOLD, &val, 2) ||
554 local->func->reset_port(dev))
555 return -EINVAL;
556
557 local->rts_threshold = rts->value;
558
559 return 0;
560 }
561
562 static int prism2_ioctl_giwrts(struct net_device *dev,
563 struct iw_request_info *info,
564 struct iw_param *rts, char *extra)
565 {
566 struct hostap_interface *iface;
567 local_info_t *local;
568 __le16 val;
569
570 iface = netdev_priv(dev);
571 local = iface->local;
572
573 if (local->func->get_rid(dev, HFA384X_RID_RTSTHRESHOLD, &val, 2, 1) <
574 0)
575 return -EINVAL;
576
577 rts->value = le16_to_cpu(val);
578 rts->disabled = (rts->value == 2347);
579 rts->fixed = 1;
580
581 return 0;
582 }
583
584
585 static int prism2_ioctl_siwfrag(struct net_device *dev,
586 struct iw_request_info *info,
587 struct iw_param *rts, char *extra)
588 {
589 struct hostap_interface *iface;
590 local_info_t *local;
591 __le16 val;
592
593 iface = netdev_priv(dev);
594 local = iface->local;
595
596 if (rts->disabled)
597 val = cpu_to_le16(2346);
598 else if (rts->value < 256 || rts->value > 2346)
599 return -EINVAL;
600 else
601 val = cpu_to_le16(rts->value & ~0x1); /* even numbers only */
602
603 local->fragm_threshold = rts->value & ~0x1;
604 if (local->func->set_rid(dev, HFA384X_RID_FRAGMENTATIONTHRESHOLD, &val,
605 2)
606 || local->func->reset_port(dev))
607 return -EINVAL;
608
609 return 0;
610 }
611
612 static int prism2_ioctl_giwfrag(struct net_device *dev,
613 struct iw_request_info *info,
614 struct iw_param *rts, char *extra)
615 {
616 struct hostap_interface *iface;
617 local_info_t *local;
618 __le16 val;
619
620 iface = netdev_priv(dev);
621 local = iface->local;
622
623 if (local->func->get_rid(dev, HFA384X_RID_FRAGMENTATIONTHRESHOLD,
624 &val, 2, 1) < 0)
625 return -EINVAL;
626
627 rts->value = le16_to_cpu(val);
628 rts->disabled = (rts->value == 2346);
629 rts->fixed = 1;
630
631 return 0;
632 }
633
634
635 #ifndef PRISM2_NO_STATION_MODES
636 static int hostap_join_ap(struct net_device *dev)
637 {
638 struct hostap_interface *iface;
639 local_info_t *local;
640 struct hfa384x_join_request req;
641 unsigned long flags;
642 int i;
643 struct hfa384x_hostscan_result *entry;
644
645 iface = netdev_priv(dev);
646 local = iface->local;
647
648 memcpy(req.bssid, local->preferred_ap, ETH_ALEN);
649 req.channel = 0;
650
651 spin_lock_irqsave(&local->lock, flags);
652 for (i = 0; i < local->last_scan_results_count; i++) {
653 if (!local->last_scan_results)
654 break;
655 entry = &local->last_scan_results[i];
656 if (memcmp(local->preferred_ap, entry->bssid, ETH_ALEN) == 0) {
657 req.channel = entry->chid;
658 break;
659 }
660 }
661 spin_unlock_irqrestore(&local->lock, flags);
662
663 if (local->func->set_rid(dev, HFA384X_RID_JOINREQUEST, &req,
664 sizeof(req))) {
665 printk(KERN_DEBUG "%s: JoinRequest %pM failed\n",
666 dev->name, local->preferred_ap);
667 return -1;
668 }
669
670 printk(KERN_DEBUG "%s: Trying to join BSSID %pM\n",
671 dev->name, local->preferred_ap);
672
673 return 0;
674 }
675 #endif /* PRISM2_NO_STATION_MODES */
676
677
678 static int prism2_ioctl_siwap(struct net_device *dev,
679 struct iw_request_info *info,
680 struct sockaddr *ap_addr, char *extra)
681 {
682 #ifdef PRISM2_NO_STATION_MODES
683 return -EOPNOTSUPP;
684 #else /* PRISM2_NO_STATION_MODES */
685 struct hostap_interface *iface;
686 local_info_t *local;
687
688 iface = netdev_priv(dev);
689 local = iface->local;
690
691 memcpy(local->preferred_ap, &ap_addr->sa_data, ETH_ALEN);
692
693 if (local->host_roaming == 1 && local->iw_mode == IW_MODE_INFRA) {
694 struct hfa384x_scan_request scan_req;
695 memset(&scan_req, 0, sizeof(scan_req));
696 scan_req.channel_list = cpu_to_le16(0x3fff);
697 scan_req.txrate = cpu_to_le16(HFA384X_RATES_1MBPS);
698 if (local->func->set_rid(dev, HFA384X_RID_SCANREQUEST,
699 &scan_req, sizeof(scan_req))) {
700 printk(KERN_DEBUG "%s: ScanResults request failed - "
701 "preferred AP delayed to next unsolicited "
702 "scan\n", dev->name);
703 }
704 } else if (local->host_roaming == 2 &&
705 local->iw_mode == IW_MODE_INFRA) {
706 if (hostap_join_ap(dev))
707 return -EINVAL;
708 } else {
709 printk(KERN_DEBUG "%s: Preferred AP (SIOCSIWAP) is used only "
710 "in Managed mode when host_roaming is enabled\n",
711 dev->name);
712 }
713
714 return 0;
715 #endif /* PRISM2_NO_STATION_MODES */
716 }
717
718 static int prism2_ioctl_giwap(struct net_device *dev,
719 struct iw_request_info *info,
720 struct sockaddr *ap_addr, char *extra)
721 {
722 struct hostap_interface *iface;
723 local_info_t *local;
724
725 iface = netdev_priv(dev);
726 local = iface->local;
727
728 ap_addr->sa_family = ARPHRD_ETHER;
729 switch (iface->type) {
730 case HOSTAP_INTERFACE_AP:
731 memcpy(&ap_addr->sa_data, dev->dev_addr, ETH_ALEN);
732 break;
733 case HOSTAP_INTERFACE_STA:
734 memcpy(&ap_addr->sa_data, local->assoc_ap_addr, ETH_ALEN);
735 break;
736 case HOSTAP_INTERFACE_WDS:
737 memcpy(&ap_addr->sa_data, iface->u.wds.remote_addr, ETH_ALEN);
738 break;
739 default:
740 if (local->func->get_rid(dev, HFA384X_RID_CURRENTBSSID,
741 &ap_addr->sa_data, ETH_ALEN, 1) < 0)
742 return -EOPNOTSUPP;
743
744 /* local->bssid is also updated in LinkStatus handler when in
745 * station mode */
746 memcpy(local->bssid, &ap_addr->sa_data, ETH_ALEN);
747 break;
748 }
749
750 return 0;
751 }
752
753
754 static int prism2_ioctl_siwnickn(struct net_device *dev,
755 struct iw_request_info *info,
756 struct iw_point *data, char *nickname)
757 {
758 struct hostap_interface *iface;
759 local_info_t *local;
760
761 iface = netdev_priv(dev);
762 local = iface->local;
763
764 memset(local->name, 0, sizeof(local->name));
765 memcpy(local->name, nickname, data->length);
766 local->name_set = 1;
767
768 if (hostap_set_string(dev, HFA384X_RID_CNFOWNNAME, local->name) ||
769 local->func->reset_port(dev))
770 return -EINVAL;
771
772 return 0;
773 }
774
775 static int prism2_ioctl_giwnickn(struct net_device *dev,
776 struct iw_request_info *info,
777 struct iw_point *data, char *nickname)
778 {
779 struct hostap_interface *iface;
780 local_info_t *local;
781 int len;
782 char name[MAX_NAME_LEN + 3];
783 u16 val;
784
785 iface = netdev_priv(dev);
786 local = iface->local;
787
788 len = local->func->get_rid(dev, HFA384X_RID_CNFOWNNAME,
789 &name, MAX_NAME_LEN + 2, 0);
790 val = le16_to_cpu(*(__le16 *) name);
791 if (len > MAX_NAME_LEN + 2 || len < 0 || val > MAX_NAME_LEN)
792 return -EOPNOTSUPP;
793
794 name[val + 2] = '\0';
795 data->length = val + 1;
796 memcpy(nickname, name + 2, val + 1);
797
798 return 0;
799 }
800
801
802 static int prism2_ioctl_siwfreq(struct net_device *dev,
803 struct iw_request_info *info,
804 struct iw_freq *freq, char *extra)
805 {
806 struct hostap_interface *iface;
807 local_info_t *local;
808
809 iface = netdev_priv(dev);
810 local = iface->local;
811
812 /* freq => chan. */
813 if (freq->e == 1 &&
814 freq->m / 100000 >= freq_list[0] &&
815 freq->m / 100000 <= freq_list[FREQ_COUNT - 1]) {
816 int ch;
817 int fr = freq->m / 100000;
818 for (ch = 0; ch < FREQ_COUNT; ch++) {
819 if (fr == freq_list[ch]) {
820 freq->e = 0;
821 freq->m = ch + 1;
822 break;
823 }
824 }
825 }
826
827 if (freq->e != 0 || freq->m < 1 || freq->m > FREQ_COUNT ||
828 !(local->channel_mask & (1 << (freq->m - 1))))
829 return -EINVAL;
830
831 local->channel = freq->m; /* channel is used in prism2_setup_rids() */
832 if (hostap_set_word(dev, HFA384X_RID_CNFOWNCHANNEL, local->channel) ||
833 local->func->reset_port(dev))
834 return -EINVAL;
835
836 return 0;
837 }
838
839 static int prism2_ioctl_giwfreq(struct net_device *dev,
840 struct iw_request_info *info,
841 struct iw_freq *freq, char *extra)
842 {
843 struct hostap_interface *iface;
844 local_info_t *local;
845 u16 val;
846
847 iface = netdev_priv(dev);
848 local = iface->local;
849
850 if (local->func->get_rid(dev, HFA384X_RID_CURRENTCHANNEL, &val, 2, 1) <
851 0)
852 return -EINVAL;
853
854 le16_to_cpus(&val);
855 if (val < 1 || val > FREQ_COUNT)
856 return -EINVAL;
857
858 freq->m = freq_list[val - 1] * 100000;
859 freq->e = 1;
860
861 return 0;
862 }
863
864
865 static void hostap_monitor_set_type(local_info_t *local)
866 {
867 struct net_device *dev = local->ddev;
868
869 if (dev == NULL)
870 return;
871
872 if (local->monitor_type == PRISM2_MONITOR_PRISM ||
873 local->monitor_type == PRISM2_MONITOR_CAPHDR) {
874 dev->type = ARPHRD_IEEE80211_PRISM;
875 } else if (local->monitor_type == PRISM2_MONITOR_RADIOTAP) {
876 dev->type = ARPHRD_IEEE80211_RADIOTAP;
877 } else {
878 dev->type = ARPHRD_IEEE80211;
879 }
880 }
881
882
883 static int prism2_ioctl_siwessid(struct net_device *dev,
884 struct iw_request_info *info,
885 struct iw_point *data, char *ssid)
886 {
887 struct hostap_interface *iface;
888 local_info_t *local;
889
890 iface = netdev_priv(dev);
891 local = iface->local;
892
893 if (iface->type == HOSTAP_INTERFACE_WDS)
894 return -EOPNOTSUPP;
895
896 if (data->flags == 0)
897 ssid[0] = '\0'; /* ANY */
898
899 if (local->iw_mode == IW_MODE_MASTER && ssid[0] == '\0') {
900 /* Setting SSID to empty string seems to kill the card in
901 * Host AP mode */
902 printk(KERN_DEBUG "%s: Host AP mode does not support "
903 "'Any' essid\n", dev->name);
904 return -EINVAL;
905 }
906
907 memcpy(local->essid, ssid, data->length);
908 local->essid[data->length] = '\0';
909
910 if ((!local->fw_ap &&
911 hostap_set_string(dev, HFA384X_RID_CNFDESIREDSSID, local->essid))
912 || hostap_set_string(dev, HFA384X_RID_CNFOWNSSID, local->essid) ||
913 local->func->reset_port(dev))
914 return -EINVAL;
915
916 return 0;
917 }
918
919 static int prism2_ioctl_giwessid(struct net_device *dev,
920 struct iw_request_info *info,
921 struct iw_point *data, char *essid)
922 {
923 struct hostap_interface *iface;
924 local_info_t *local;
925 u16 val;
926
927 iface = netdev_priv(dev);
928 local = iface->local;
929
930 if (iface->type == HOSTAP_INTERFACE_WDS)
931 return -EOPNOTSUPP;
932
933 data->flags = 1; /* active */
934 if (local->iw_mode == IW_MODE_MASTER) {
935 data->length = strlen(local->essid);
936 memcpy(essid, local->essid, IW_ESSID_MAX_SIZE);
937 } else {
938 int len;
939 char ssid[MAX_SSID_LEN + 2];
940 memset(ssid, 0, sizeof(ssid));
941 len = local->func->get_rid(dev, HFA384X_RID_CURRENTSSID,
942 &ssid, MAX_SSID_LEN + 2, 0);
943 val = le16_to_cpu(*(__le16 *) ssid);
944 if (len > MAX_SSID_LEN + 2 || len < 0 || val > MAX_SSID_LEN) {
945 return -EOPNOTSUPP;
946 }
947 data->length = val;
948 memcpy(essid, ssid + 2, IW_ESSID_MAX_SIZE);
949 }
950
951 return 0;
952 }
953
954
955 static int prism2_ioctl_giwrange(struct net_device *dev,
956 struct iw_request_info *info,
957 struct iw_point *data, char *extra)
958 {
959 struct hostap_interface *iface;
960 local_info_t *local;
961 struct iw_range *range = (struct iw_range *) extra;
962 u8 rates[10];
963 u16 val;
964 int i, len, over2;
965
966 iface = netdev_priv(dev);
967 local = iface->local;
968
969 data->length = sizeof(struct iw_range);
970 memset(range, 0, sizeof(struct iw_range));
971
972 /* TODO: could fill num_txpower and txpower array with
973 * something; however, there are 128 different values.. */
974
975 range->txpower_capa = IW_TXPOW_DBM;
976
977 if (local->iw_mode == IW_MODE_INFRA || local->iw_mode == IW_MODE_ADHOC)
978 {
979 range->min_pmp = 1 * 1024;
980 range->max_pmp = 65535 * 1024;
981 range->min_pmt = 1 * 1024;
982 range->max_pmt = 1000 * 1024;
983 range->pmp_flags = IW_POWER_PERIOD;
984 range->pmt_flags = IW_POWER_TIMEOUT;
985 range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT |
986 IW_POWER_UNICAST_R | IW_POWER_ALL_R;
987 }
988
989 range->we_version_compiled = WIRELESS_EXT;
990 range->we_version_source = 18;
991
992 range->retry_capa = IW_RETRY_LIMIT;
993 range->retry_flags = IW_RETRY_LIMIT;
994 range->min_retry = 0;
995 range->max_retry = 255;
996
997 range->num_channels = FREQ_COUNT;
998
999 val = 0;
1000 for (i = 0; i < FREQ_COUNT; i++) {
1001 if (local->channel_mask & (1 << i)) {
1002 range->freq[val].i = i + 1;
1003 range->freq[val].m = freq_list[i] * 100000;
1004 range->freq[val].e = 1;
1005 val++;
1006 }
1007 if (val == IW_MAX_FREQUENCIES)
1008 break;
1009 }
1010 range->num_frequency = val;
1011
1012 if (local->sta_fw_ver >= PRISM2_FW_VER(1,3,1)) {
1013 range->max_qual.qual = 70; /* what is correct max? This was not
1014 * documented exactly. At least
1015 * 69 has been observed. */
1016 range->max_qual.level = 0; /* dB */
1017 range->max_qual.noise = 0; /* dB */
1018
1019 /* What would be suitable values for "average/typical" qual? */
1020 range->avg_qual.qual = 20;
1021 range->avg_qual.level = -60;
1022 range->avg_qual.noise = -95;
1023 } else {
1024 range->max_qual.qual = 92; /* 0 .. 92 */
1025 range->max_qual.level = 154; /* 27 .. 154 */
1026 range->max_qual.noise = 154; /* 27 .. 154 */
1027 }
1028 range->sensitivity = 3;
1029
1030 range->max_encoding_tokens = WEP_KEYS;
1031 range->num_encoding_sizes = 2;
1032 range->encoding_size[0] = 5;
1033 range->encoding_size[1] = 13;
1034
1035 over2 = 0;
1036 len = prism2_get_datarates(dev, rates);
1037 range->num_bitrates = 0;
1038 for (i = 0; i < len; i++) {
1039 if (range->num_bitrates < IW_MAX_BITRATES) {
1040 range->bitrate[range->num_bitrates] =
1041 rates[i] * 500000;
1042 range->num_bitrates++;
1043 }
1044 if (rates[i] == 0x0b || rates[i] == 0x16)
1045 over2 = 1;
1046 }
1047 /* estimated maximum TCP throughput values (bps) */
1048 range->throughput = over2 ? 5500000 : 1500000;
1049
1050 range->min_rts = 0;
1051 range->max_rts = 2347;
1052 range->min_frag = 256;
1053 range->max_frag = 2346;
1054
1055 /* Event capability (kernel + driver) */
1056 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
1057 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
1058 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
1059 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
1060 range->event_capa[1] = IW_EVENT_CAPA_K_1;
1061 range->event_capa[4] = (IW_EVENT_CAPA_MASK(IWEVTXDROP) |
1062 IW_EVENT_CAPA_MASK(IWEVCUSTOM) |
1063 IW_EVENT_CAPA_MASK(IWEVREGISTERED) |
1064 IW_EVENT_CAPA_MASK(IWEVEXPIRED));
1065
1066 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
1067 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
1068
1069 if (local->sta_fw_ver >= PRISM2_FW_VER(1,3,1))
1070 range->scan_capa = IW_SCAN_CAPA_ESSID;
1071
1072 return 0;
1073 }
1074
1075
1076 static int hostap_monitor_mode_enable(local_info_t *local)
1077 {
1078 struct net_device *dev = local->dev;
1079
1080 printk(KERN_DEBUG "Enabling monitor mode\n");
1081 hostap_monitor_set_type(local);
1082
1083 if (hostap_set_word(dev, HFA384X_RID_CNFPORTTYPE,
1084 HFA384X_PORTTYPE_PSEUDO_IBSS)) {
1085 printk(KERN_DEBUG "Port type setting for monitor mode "
1086 "failed\n");
1087 return -EOPNOTSUPP;
1088 }
1089
1090 /* Host decrypt is needed to get the IV and ICV fields;
1091 * however, monitor mode seems to remove WEP flag from frame
1092 * control field */
1093 if (hostap_set_word(dev, HFA384X_RID_CNFWEPFLAGS,
1094 HFA384X_WEPFLAGS_HOSTENCRYPT |
1095 HFA384X_WEPFLAGS_HOSTDECRYPT)) {
1096 printk(KERN_DEBUG "WEP flags setting failed\n");
1097 return -EOPNOTSUPP;
1098 }
1099
1100 if (local->func->reset_port(dev) ||
1101 local->func->cmd(dev, HFA384X_CMDCODE_TEST |
1102 (HFA384X_TEST_MONITOR << 8),
1103 0, NULL, NULL)) {
1104 printk(KERN_DEBUG "Setting monitor mode failed\n");
1105 return -EOPNOTSUPP;
1106 }
1107
1108 return 0;
1109 }
1110
1111
1112 static int hostap_monitor_mode_disable(local_info_t *local)
1113 {
1114 struct net_device *dev = local->ddev;
1115
1116 if (dev == NULL)
1117 return -1;
1118
1119 printk(KERN_DEBUG "%s: Disabling monitor mode\n", dev->name);
1120 dev->type = ARPHRD_ETHER;
1121
1122 if (local->func->cmd(dev, HFA384X_CMDCODE_TEST |
1123 (HFA384X_TEST_STOP << 8),
1124 0, NULL, NULL))
1125 return -1;
1126 return hostap_set_encryption(local);
1127 }
1128
1129
1130 static int prism2_ioctl_siwmode(struct net_device *dev,
1131 struct iw_request_info *info,
1132 __u32 *mode, char *extra)
1133 {
1134 struct hostap_interface *iface;
1135 local_info_t *local;
1136 int double_reset = 0;
1137
1138 iface = netdev_priv(dev);
1139 local = iface->local;
1140
1141 if (*mode != IW_MODE_ADHOC && *mode != IW_MODE_INFRA &&
1142 *mode != IW_MODE_MASTER && *mode != IW_MODE_REPEAT &&
1143 *mode != IW_MODE_MONITOR)
1144 return -EOPNOTSUPP;
1145
1146 #ifdef PRISM2_NO_STATION_MODES
1147 if (*mode == IW_MODE_ADHOC || *mode == IW_MODE_INFRA)
1148 return -EOPNOTSUPP;
1149 #endif /* PRISM2_NO_STATION_MODES */
1150
1151 if (*mode == local->iw_mode)
1152 return 0;
1153
1154 if (*mode == IW_MODE_MASTER && local->essid[0] == '\0') {
1155 printk(KERN_WARNING "%s: empty SSID not allowed in Master "
1156 "mode\n", dev->name);
1157 return -EINVAL;
1158 }
1159
1160 if (local->iw_mode == IW_MODE_MONITOR)
1161 hostap_monitor_mode_disable(local);
1162
1163 if ((local->iw_mode == IW_MODE_ADHOC ||
1164 local->iw_mode == IW_MODE_MONITOR) && *mode == IW_MODE_MASTER) {
1165 double_reset = 1;
1166 }
1167
1168 printk(KERN_DEBUG "prism2: %s: operating mode changed "
1169 "%d -> %d\n", dev->name, local->iw_mode, *mode);
1170 local->iw_mode = *mode;
1171
1172 if (local->iw_mode == IW_MODE_MONITOR)
1173 hostap_monitor_mode_enable(local);
1174 else if (local->iw_mode == IW_MODE_MASTER && !local->host_encrypt &&
1175 !local->fw_encrypt_ok) {
1176 printk(KERN_DEBUG "%s: defaulting to host-based encryption as "
1177 "a workaround for firmware bug in Host AP mode WEP\n",
1178 dev->name);
1179 local->host_encrypt = 1;
1180 }
1181
1182 if (hostap_set_word(dev, HFA384X_RID_CNFPORTTYPE,
1183 hostap_get_porttype(local)))
1184 return -EOPNOTSUPP;
1185
1186 if (local->func->reset_port(dev))
1187 return -EINVAL;
1188 if (double_reset && local->func->reset_port(dev))
1189 return -EINVAL;
1190
1191 if (local->iw_mode != IW_MODE_INFRA && local->iw_mode != IW_MODE_ADHOC)
1192 {
1193 /* netif_carrier is used only in client modes for now, so make
1194 * sure carrier is on when moving to non-client modes. */
1195 netif_carrier_on(local->dev);
1196 netif_carrier_on(local->ddev);
1197 }
1198 return 0;
1199 }
1200
1201
1202 static int prism2_ioctl_giwmode(struct net_device *dev,
1203 struct iw_request_info *info,
1204 __u32 *mode, char *extra)
1205 {
1206 struct hostap_interface *iface;
1207 local_info_t *local;
1208
1209 iface = netdev_priv(dev);
1210 local = iface->local;
1211
1212 switch (iface->type) {
1213 case HOSTAP_INTERFACE_STA:
1214 *mode = IW_MODE_INFRA;
1215 break;
1216 case HOSTAP_INTERFACE_WDS:
1217 *mode = IW_MODE_REPEAT;
1218 break;
1219 default:
1220 *mode = local->iw_mode;
1221 break;
1222 }
1223 return 0;
1224 }
1225
1226
1227 static int prism2_ioctl_siwpower(struct net_device *dev,
1228 struct iw_request_info *info,
1229 struct iw_param *wrq, char *extra)
1230 {
1231 #ifdef PRISM2_NO_STATION_MODES
1232 return -EOPNOTSUPP;
1233 #else /* PRISM2_NO_STATION_MODES */
1234 int ret = 0;
1235
1236 if (wrq->disabled)
1237 return hostap_set_word(dev, HFA384X_RID_CNFPMENABLED, 0);
1238
1239 switch (wrq->flags & IW_POWER_MODE) {
1240 case IW_POWER_UNICAST_R:
1241 ret = hostap_set_word(dev, HFA384X_RID_CNFMULTICASTRECEIVE, 0);
1242 if (ret)
1243 return ret;
1244 ret = hostap_set_word(dev, HFA384X_RID_CNFPMENABLED, 1);
1245 if (ret)
1246 return ret;
1247 break;
1248 case IW_POWER_ALL_R:
1249 ret = hostap_set_word(dev, HFA384X_RID_CNFMULTICASTRECEIVE, 1);
1250 if (ret)
1251 return ret;
1252 ret = hostap_set_word(dev, HFA384X_RID_CNFPMENABLED, 1);
1253 if (ret)
1254 return ret;
1255 break;
1256 case IW_POWER_ON:
1257 break;
1258 default:
1259 return -EINVAL;
1260 }
1261
1262 if (wrq->flags & IW_POWER_TIMEOUT) {
1263 ret = hostap_set_word(dev, HFA384X_RID_CNFPMENABLED, 1);
1264 if (ret)
1265 return ret;
1266 ret = hostap_set_word(dev, HFA384X_RID_CNFPMHOLDOVERDURATION,
1267 wrq->value / 1024);
1268 if (ret)
1269 return ret;
1270 }
1271 if (wrq->flags & IW_POWER_PERIOD) {
1272 ret = hostap_set_word(dev, HFA384X_RID_CNFPMENABLED, 1);
1273 if (ret)
1274 return ret;
1275 ret = hostap_set_word(dev, HFA384X_RID_CNFMAXSLEEPDURATION,
1276 wrq->value / 1024);
1277 if (ret)
1278 return ret;
1279 }
1280
1281 return ret;
1282 #endif /* PRISM2_NO_STATION_MODES */
1283 }
1284
1285
1286 static int prism2_ioctl_giwpower(struct net_device *dev,
1287 struct iw_request_info *info,
1288 struct iw_param *rrq, char *extra)
1289 {
1290 #ifdef PRISM2_NO_STATION_MODES
1291 return -EOPNOTSUPP;
1292 #else /* PRISM2_NO_STATION_MODES */
1293 struct hostap_interface *iface;
1294 local_info_t *local;
1295 __le16 enable, mcast;
1296
1297 iface = netdev_priv(dev);
1298 local = iface->local;
1299
1300 if (local->func->get_rid(dev, HFA384X_RID_CNFPMENABLED, &enable, 2, 1)
1301 < 0)
1302 return -EINVAL;
1303
1304 if (!le16_to_cpu(enable)) {
1305 rrq->disabled = 1;
1306 return 0;
1307 }
1308
1309 rrq->disabled = 0;
1310
1311 if ((rrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
1312 __le16 timeout;
1313 if (local->func->get_rid(dev,
1314 HFA384X_RID_CNFPMHOLDOVERDURATION,
1315 &timeout, 2, 1) < 0)
1316 return -EINVAL;
1317
1318 rrq->flags = IW_POWER_TIMEOUT;
1319 rrq->value = le16_to_cpu(timeout) * 1024;
1320 } else {
1321 __le16 period;
1322 if (local->func->get_rid(dev, HFA384X_RID_CNFMAXSLEEPDURATION,
1323 &period, 2, 1) < 0)
1324 return -EINVAL;
1325
1326 rrq->flags = IW_POWER_PERIOD;
1327 rrq->value = le16_to_cpu(period) * 1024;
1328 }
1329
1330 if (local->func->get_rid(dev, HFA384X_RID_CNFMULTICASTRECEIVE, &mcast,
1331 2, 1) < 0)
1332 return -EINVAL;
1333
1334 if (le16_to_cpu(mcast))
1335 rrq->flags |= IW_POWER_ALL_R;
1336 else
1337 rrq->flags |= IW_POWER_UNICAST_R;
1338
1339 return 0;
1340 #endif /* PRISM2_NO_STATION_MODES */
1341 }
1342
1343
1344 static int prism2_ioctl_siwretry(struct net_device *dev,
1345 struct iw_request_info *info,
1346 struct iw_param *rrq, char *extra)
1347 {
1348 struct hostap_interface *iface;
1349 local_info_t *local;
1350
1351 iface = netdev_priv(dev);
1352 local = iface->local;
1353
1354 if (rrq->disabled)
1355 return -EINVAL;
1356
1357 /* setting retry limits is not supported with the current station
1358 * firmware code; simulate this with alternative retry count for now */
1359 if (rrq->flags == IW_RETRY_LIMIT) {
1360 if (rrq->value < 0) {
1361 /* disable manual retry count setting and use firmware
1362 * defaults */
1363 local->manual_retry_count = -1;
1364 local->tx_control &= ~HFA384X_TX_CTRL_ALT_RTRY;
1365 } else {
1366 if (hostap_set_word(dev, HFA384X_RID_CNFALTRETRYCOUNT,
1367 rrq->value)) {
1368 printk(KERN_DEBUG "%s: Alternate retry count "
1369 "setting to %d failed\n",
1370 dev->name, rrq->value);
1371 return -EOPNOTSUPP;
1372 }
1373
1374 local->manual_retry_count = rrq->value;
1375 local->tx_control |= HFA384X_TX_CTRL_ALT_RTRY;
1376 }
1377 return 0;
1378 }
1379
1380 return -EOPNOTSUPP;
1381
1382 }
1383
1384 static int prism2_ioctl_giwretry(struct net_device *dev,
1385 struct iw_request_info *info,
1386 struct iw_param *rrq, char *extra)
1387 {
1388 struct hostap_interface *iface;
1389 local_info_t *local;
1390 __le16 shortretry, longretry, lifetime, altretry;
1391
1392 iface = netdev_priv(dev);
1393 local = iface->local;
1394
1395 if (local->func->get_rid(dev, HFA384X_RID_SHORTRETRYLIMIT, &shortretry,
1396 2, 1) < 0 ||
1397 local->func->get_rid(dev, HFA384X_RID_LONGRETRYLIMIT, &longretry,
1398 2, 1) < 0 ||
1399 local->func->get_rid(dev, HFA384X_RID_MAXTRANSMITLIFETIME,
1400 &lifetime, 2, 1) < 0)
1401 return -EINVAL;
1402
1403 rrq->disabled = 0;
1404
1405 if ((rrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
1406 rrq->flags = IW_RETRY_LIFETIME;
1407 rrq->value = le16_to_cpu(lifetime) * 1024;
1408 } else {
1409 if (local->manual_retry_count >= 0) {
1410 rrq->flags = IW_RETRY_LIMIT;
1411 if (local->func->get_rid(dev,
1412 HFA384X_RID_CNFALTRETRYCOUNT,
1413 &altretry, 2, 1) >= 0)
1414 rrq->value = le16_to_cpu(altretry);
1415 else
1416 rrq->value = local->manual_retry_count;
1417 } else if ((rrq->flags & IW_RETRY_LONG)) {
1418 rrq->flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
1419 rrq->value = le16_to_cpu(longretry);
1420 } else {
1421 rrq->flags = IW_RETRY_LIMIT;
1422 rrq->value = le16_to_cpu(shortretry);
1423 if (shortretry != longretry)
1424 rrq->flags |= IW_RETRY_SHORT;
1425 }
1426 }
1427 return 0;
1428 }
1429
1430
1431 /* Note! This TX power controlling is experimental and should not be used in
1432 * production use. It just sets raw power register and does not use any kind of
1433 * feedback information from the measured TX power (CR58). This is now
1434 * commented out to make sure that it is not used by accident. TX power
1435 * configuration will be enabled again after proper algorithm using feedback
1436 * has been implemented. */
1437
1438 #ifdef RAW_TXPOWER_SETTING
1439 /* Map HFA386x's CR31 to and from dBm with some sort of ad hoc mapping..
1440 * This version assumes following mapping:
1441 * CR31 is 7-bit value with -64 to +63 range.
1442 * -64 is mapped into +20dBm and +63 into -43dBm.
1443 * This is certainly not an exact mapping for every card, but at least
1444 * increasing dBm value should correspond to increasing TX power.
1445 */
1446
1447 static int prism2_txpower_hfa386x_to_dBm(u16 val)
1448 {
1449 signed char tmp;
1450
1451 if (val > 255)
1452 val = 255;
1453
1454 tmp = val;
1455 tmp >>= 2;
1456
1457 return -12 - tmp;
1458 }
1459
1460 static u16 prism2_txpower_dBm_to_hfa386x(int val)
1461 {
1462 signed char tmp;
1463
1464 if (val > 20)
1465 return 128;
1466 else if (val < -43)
1467 return 127;
1468
1469 tmp = val;
1470 tmp = -12 - tmp;
1471 tmp <<= 2;
1472
1473 return (unsigned char) tmp;
1474 }
1475 #endif /* RAW_TXPOWER_SETTING */
1476
1477
1478 static int prism2_ioctl_siwtxpow(struct net_device *dev,
1479 struct iw_request_info *info,
1480 struct iw_param *rrq, char *extra)
1481 {
1482 struct hostap_interface *iface;
1483 local_info_t *local;
1484 #ifdef RAW_TXPOWER_SETTING
1485 char *tmp;
1486 #endif
1487 u16 val;
1488 int ret = 0;
1489
1490 iface = netdev_priv(dev);
1491 local = iface->local;
1492
1493 if (rrq->disabled) {
1494 if (local->txpower_type != PRISM2_TXPOWER_OFF) {
1495 val = 0xff; /* use all standby and sleep modes */
1496 ret = local->func->cmd(dev, HFA384X_CMDCODE_WRITEMIF,
1497 HFA386X_CR_A_D_TEST_MODES2,
1498 &val, NULL);
1499 printk(KERN_DEBUG "%s: Turning radio off: %s\n",
1500 dev->name, ret ? "failed" : "OK");
1501 local->txpower_type = PRISM2_TXPOWER_OFF;
1502 }
1503 return (ret ? -EOPNOTSUPP : 0);
1504 }
1505
1506 if (local->txpower_type == PRISM2_TXPOWER_OFF) {
1507 val = 0; /* disable all standby and sleep modes */
1508 ret = local->func->cmd(dev, HFA384X_CMDCODE_WRITEMIF,
1509 HFA386X_CR_A_D_TEST_MODES2, &val, NULL);
1510 printk(KERN_DEBUG "%s: Turning radio on: %s\n",
1511 dev->name, ret ? "failed" : "OK");
1512 local->txpower_type = PRISM2_TXPOWER_UNKNOWN;
1513 }
1514
1515 #ifdef RAW_TXPOWER_SETTING
1516 if (!rrq->fixed && local->txpower_type != PRISM2_TXPOWER_AUTO) {
1517 printk(KERN_DEBUG "Setting ALC on\n");
1518 val = HFA384X_TEST_CFG_BIT_ALC;
1519 local->func->cmd(dev, HFA384X_CMDCODE_TEST |
1520 (HFA384X_TEST_CFG_BITS << 8), 1, &val, NULL);
1521 local->txpower_type = PRISM2_TXPOWER_AUTO;
1522 return 0;
1523 }
1524
1525 if (local->txpower_type != PRISM2_TXPOWER_FIXED) {
1526 printk(KERN_DEBUG "Setting ALC off\n");
1527 val = HFA384X_TEST_CFG_BIT_ALC;
1528 local->func->cmd(dev, HFA384X_CMDCODE_TEST |
1529 (HFA384X_TEST_CFG_BITS << 8), 0, &val, NULL);
1530 local->txpower_type = PRISM2_TXPOWER_FIXED;
1531 }
1532
1533 if (rrq->flags == IW_TXPOW_DBM)
1534 tmp = "dBm";
1535 else if (rrq->flags == IW_TXPOW_MWATT)
1536 tmp = "mW";
1537 else
1538 tmp = "UNKNOWN";
1539 printk(KERN_DEBUG "Setting TX power to %d %s\n", rrq->value, tmp);
1540
1541 if (rrq->flags != IW_TXPOW_DBM) {
1542 printk("SIOCSIWTXPOW with mW is not supported; use dBm\n");
1543 return -EOPNOTSUPP;
1544 }
1545
1546 local->txpower = rrq->value;
1547 val = prism2_txpower_dBm_to_hfa386x(local->txpower);
1548 if (local->func->cmd(dev, HFA384X_CMDCODE_WRITEMIF,
1549 HFA386X_CR_MANUAL_TX_POWER, &val, NULL))
1550 ret = -EOPNOTSUPP;
1551 #else /* RAW_TXPOWER_SETTING */
1552 if (rrq->fixed)
1553 ret = -EOPNOTSUPP;
1554 #endif /* RAW_TXPOWER_SETTING */
1555
1556 return ret;
1557 }
1558
1559 static int prism2_ioctl_giwtxpow(struct net_device *dev,
1560 struct iw_request_info *info,
1561 struct iw_param *rrq, char *extra)
1562 {
1563 #ifdef RAW_TXPOWER_SETTING
1564 struct hostap_interface *iface;
1565 local_info_t *local;
1566 u16 resp0;
1567
1568 iface = netdev_priv(dev);
1569 local = iface->local;
1570
1571 rrq->flags = IW_TXPOW_DBM;
1572 rrq->disabled = 0;
1573 rrq->fixed = 0;
1574
1575 if (local->txpower_type == PRISM2_TXPOWER_AUTO) {
1576 if (local->func->cmd(dev, HFA384X_CMDCODE_READMIF,
1577 HFA386X_CR_MANUAL_TX_POWER,
1578 NULL, &resp0) == 0) {
1579 rrq->value = prism2_txpower_hfa386x_to_dBm(resp0);
1580 } else {
1581 /* Could not get real txpower; guess 15 dBm */
1582 rrq->value = 15;
1583 }
1584 } else if (local->txpower_type == PRISM2_TXPOWER_OFF) {
1585 rrq->value = 0;
1586 rrq->disabled = 1;
1587 } else if (local->txpower_type == PRISM2_TXPOWER_FIXED) {
1588 rrq->value = local->txpower;
1589 rrq->fixed = 1;
1590 } else {
1591 printk("SIOCGIWTXPOW - unknown txpower_type=%d\n",
1592 local->txpower_type);
1593 }
1594 return 0;
1595 #else /* RAW_TXPOWER_SETTING */
1596 return -EOPNOTSUPP;
1597 #endif /* RAW_TXPOWER_SETTING */
1598 }
1599
1600
1601 #ifndef PRISM2_NO_STATION_MODES
1602
1603 /* HostScan request works with and without host_roaming mode. In addition, it
1604 * does not break current association. However, it requires newer station
1605 * firmware version (>= 1.3.1) than scan request. */
1606 static int prism2_request_hostscan(struct net_device *dev,
1607 u8 *ssid, u8 ssid_len)
1608 {
1609 struct hostap_interface *iface;
1610 local_info_t *local;
1611 struct hfa384x_hostscan_request scan_req;
1612
1613 iface = netdev_priv(dev);
1614 local = iface->local;
1615
1616 memset(&scan_req, 0, sizeof(scan_req));
1617 scan_req.channel_list = cpu_to_le16(local->channel_mask &
1618 local->scan_channel_mask);
1619 scan_req.txrate = cpu_to_le16(HFA384X_RATES_1MBPS);
1620 if (ssid) {
1621 if (ssid_len > 32)
1622 return -EINVAL;
1623 scan_req.target_ssid_len = cpu_to_le16(ssid_len);
1624 memcpy(scan_req.target_ssid, ssid, ssid_len);
1625 }
1626
1627 if (local->func->set_rid(dev, HFA384X_RID_HOSTSCAN, &scan_req,
1628 sizeof(scan_req))) {
1629 printk(KERN_DEBUG "%s: HOSTSCAN failed\n", dev->name);
1630 return -EINVAL;
1631 }
1632 return 0;
1633 }
1634
1635
1636 static int prism2_request_scan(struct net_device *dev)
1637 {
1638 struct hostap_interface *iface;
1639 local_info_t *local;
1640 struct hfa384x_scan_request scan_req;
1641 int ret = 0;
1642
1643 iface = netdev_priv(dev);
1644 local = iface->local;
1645
1646 memset(&scan_req, 0, sizeof(scan_req));
1647 scan_req.channel_list = cpu_to_le16(local->channel_mask &
1648 local->scan_channel_mask);
1649 scan_req.txrate = cpu_to_le16(HFA384X_RATES_1MBPS);
1650
1651 /* FIX:
1652 * It seems to be enough to set roaming mode for a short moment to
1653 * host-based and then setup scanrequest data and return the mode to
1654 * firmware-based.
1655 *
1656 * Master mode would need to drop to Managed mode for a short while
1657 * to make scanning work.. Or sweep through the different channels and
1658 * use passive scan based on beacons. */
1659
1660 if (!local->host_roaming)
1661 hostap_set_word(dev, HFA384X_RID_CNFROAMINGMODE,
1662 HFA384X_ROAMING_HOST);
1663
1664 if (local->func->set_rid(dev, HFA384X_RID_SCANREQUEST, &scan_req,
1665 sizeof(scan_req))) {
1666 printk(KERN_DEBUG "SCANREQUEST failed\n");
1667 ret = -EINVAL;
1668 }
1669
1670 if (!local->host_roaming)
1671 hostap_set_word(dev, HFA384X_RID_CNFROAMINGMODE,
1672 HFA384X_ROAMING_FIRMWARE);
1673
1674 return 0;
1675 }
1676
1677 #else /* !PRISM2_NO_STATION_MODES */
1678
1679 static inline int prism2_request_hostscan(struct net_device *dev,
1680 u8 *ssid, u8 ssid_len)
1681 {
1682 return -EOPNOTSUPP;
1683 }
1684
1685
1686 static inline int prism2_request_scan(struct net_device *dev)
1687 {
1688 return -EOPNOTSUPP;
1689 }
1690
1691 #endif /* !PRISM2_NO_STATION_MODES */
1692
1693
1694 static int prism2_ioctl_siwscan(struct net_device *dev,
1695 struct iw_request_info *info,
1696 struct iw_point *data, char *extra)
1697 {
1698 struct hostap_interface *iface;
1699 local_info_t *local;
1700 int ret;
1701 u8 *ssid = NULL, ssid_len = 0;
1702 struct iw_scan_req *req = (struct iw_scan_req *) extra;
1703
1704 iface = netdev_priv(dev);
1705 local = iface->local;
1706
1707 if (data->length < sizeof(struct iw_scan_req))
1708 req = NULL;
1709
1710 if (local->iw_mode == IW_MODE_MASTER) {
1711 /* In master mode, we just return the results of our local
1712 * tables, so we don't need to start anything...
1713 * Jean II */
1714 data->length = 0;
1715 return 0;
1716 }
1717
1718 if (!local->dev_enabled)
1719 return -ENETDOWN;
1720
1721 if (req && data->flags & IW_SCAN_THIS_ESSID) {
1722 ssid = req->essid;
1723 ssid_len = req->essid_len;
1724
1725 if (ssid_len &&
1726 ((local->iw_mode != IW_MODE_INFRA &&
1727 local->iw_mode != IW_MODE_ADHOC) ||
1728 (local->sta_fw_ver < PRISM2_FW_VER(1,3,1))))
1729 return -EOPNOTSUPP;
1730 }
1731
1732 if (local->sta_fw_ver >= PRISM2_FW_VER(1,3,1))
1733 ret = prism2_request_hostscan(dev, ssid, ssid_len);
1734 else
1735 ret = prism2_request_scan(dev);
1736
1737 if (ret == 0)
1738 local->scan_timestamp = jiffies;
1739
1740 /* Could inquire F101, F103 or wait for SIOCGIWSCAN and read RID */
1741
1742 return ret;
1743 }
1744
1745
1746 #ifndef PRISM2_NO_STATION_MODES
1747 static char * __prism2_translate_scan(local_info_t *local,
1748 struct iw_request_info *info,
1749 struct hfa384x_hostscan_result *scan,
1750 struct hostap_bss_info *bss,
1751 char *current_ev, char *end_buf)
1752 {
1753 int i, chan;
1754 struct iw_event iwe;
1755 char *current_val;
1756 u16 capabilities;
1757 u8 *pos;
1758 u8 *ssid, *bssid;
1759 size_t ssid_len;
1760 char *buf;
1761
1762 if (bss) {
1763 ssid = bss->ssid;
1764 ssid_len = bss->ssid_len;
1765 bssid = bss->bssid;
1766 } else {
1767 ssid = scan->ssid;
1768 ssid_len = le16_to_cpu(scan->ssid_len);
1769 bssid = scan->bssid;
1770 }
1771 if (ssid_len > 32)
1772 ssid_len = 32;
1773
1774 /* First entry *MUST* be the AP MAC address */
1775 memset(&iwe, 0, sizeof(iwe));
1776 iwe.cmd = SIOCGIWAP;
1777 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1778 memcpy(iwe.u.ap_addr.sa_data, bssid, ETH_ALEN);
1779 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe,
1780 IW_EV_ADDR_LEN);
1781
1782 /* Other entries will be displayed in the order we give them */
1783
1784 memset(&iwe, 0, sizeof(iwe));
1785 iwe.cmd = SIOCGIWESSID;
1786 iwe.u.data.length = ssid_len;
1787 iwe.u.data.flags = 1;
1788 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
1789 &iwe, ssid);
1790
1791 memset(&iwe, 0, sizeof(iwe));
1792 iwe.cmd = SIOCGIWMODE;
1793 if (bss) {
1794 capabilities = bss->capab_info;
1795 } else {
1796 capabilities = le16_to_cpu(scan->capability);
1797 }
1798 if (capabilities & (WLAN_CAPABILITY_ESS |
1799 WLAN_CAPABILITY_IBSS)) {
1800 if (capabilities & WLAN_CAPABILITY_ESS)
1801 iwe.u.mode = IW_MODE_MASTER;
1802 else
1803 iwe.u.mode = IW_MODE_ADHOC;
1804 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
1805 &iwe, IW_EV_UINT_LEN);
1806 }
1807
1808 memset(&iwe, 0, sizeof(iwe));
1809 iwe.cmd = SIOCGIWFREQ;
1810 if (scan) {
1811 chan = le16_to_cpu(scan->chid);
1812 } else if (bss) {
1813 chan = bss->chan;
1814 } else {
1815 chan = 0;
1816 }
1817
1818 if (chan > 0) {
1819 iwe.u.freq.m = freq_list[chan - 1] * 100000;
1820 iwe.u.freq.e = 1;
1821 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
1822 &iwe, IW_EV_FREQ_LEN);
1823 }
1824
1825 if (scan) {
1826 memset(&iwe, 0, sizeof(iwe));
1827 iwe.cmd = IWEVQUAL;
1828 if (local->last_scan_type == PRISM2_HOSTSCAN) {
1829 iwe.u.qual.level = le16_to_cpu(scan->sl);
1830 iwe.u.qual.noise = le16_to_cpu(scan->anl);
1831 } else {
1832 iwe.u.qual.level =
1833 HFA384X_LEVEL_TO_dBm(le16_to_cpu(scan->sl));
1834 iwe.u.qual.noise =
1835 HFA384X_LEVEL_TO_dBm(le16_to_cpu(scan->anl));
1836 }
1837 iwe.u.qual.updated = IW_QUAL_LEVEL_UPDATED
1838 | IW_QUAL_NOISE_UPDATED
1839 | IW_QUAL_QUAL_INVALID
1840 | IW_QUAL_DBM;
1841 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
1842 &iwe, IW_EV_QUAL_LEN);
1843 }
1844
1845 memset(&iwe, 0, sizeof(iwe));
1846 iwe.cmd = SIOCGIWENCODE;
1847 if (capabilities & WLAN_CAPABILITY_PRIVACY)
1848 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
1849 else
1850 iwe.u.data.flags = IW_ENCODE_DISABLED;
1851 iwe.u.data.length = 0;
1852 current_ev = iwe_stream_add_point(info, current_ev, end_buf, &iwe, "");
1853
1854 /* TODO: add SuppRates into BSS table */
1855 if (scan) {
1856 memset(&iwe, 0, sizeof(iwe));
1857 iwe.cmd = SIOCGIWRATE;
1858 current_val = current_ev + iwe_stream_lcp_len(info);
1859 pos = scan->sup_rates;
1860 for (i = 0; i < sizeof(scan->sup_rates); i++) {
1861 if (pos[i] == 0)
1862 break;
1863 /* Bit rate given in 500 kb/s units (+ 0x80) */
1864 iwe.u.bitrate.value = ((pos[i] & 0x7f) * 500000);
1865 current_val = iwe_stream_add_value(
1866 info, current_ev, current_val, end_buf, &iwe,
1867 IW_EV_PARAM_LEN);
1868 }
1869 /* Check if we added any event */
1870 if ((current_val - current_ev) > iwe_stream_lcp_len(info))
1871 current_ev = current_val;
1872 }
1873
1874 /* TODO: add BeaconInt,resp_rate,atim into BSS table */
1875 buf = kmalloc(MAX_WPA_IE_LEN * 2 + 30, GFP_ATOMIC);
1876 if (buf && scan) {
1877 memset(&iwe, 0, sizeof(iwe));
1878 iwe.cmd = IWEVCUSTOM;
1879 sprintf(buf, "bcn_int=%d", le16_to_cpu(scan->beacon_interval));
1880 iwe.u.data.length = strlen(buf);
1881 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
1882 &iwe, buf);
1883
1884 memset(&iwe, 0, sizeof(iwe));
1885 iwe.cmd = IWEVCUSTOM;
1886 sprintf(buf, "resp_rate=%d", le16_to_cpu(scan->rate));
1887 iwe.u.data.length = strlen(buf);
1888 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
1889 &iwe, buf);
1890
1891 if (local->last_scan_type == PRISM2_HOSTSCAN &&
1892 (capabilities & WLAN_CAPABILITY_IBSS)) {
1893 memset(&iwe, 0, sizeof(iwe));
1894 iwe.cmd = IWEVCUSTOM;
1895 sprintf(buf, "atim=%d", le16_to_cpu(scan->atim));
1896 iwe.u.data.length = strlen(buf);
1897 current_ev = iwe_stream_add_point(info, current_ev,
1898 end_buf, &iwe, buf);
1899 }
1900 }
1901 kfree(buf);
1902
1903 if (bss && bss->wpa_ie_len > 0 && bss->wpa_ie_len <= MAX_WPA_IE_LEN) {
1904 memset(&iwe, 0, sizeof(iwe));
1905 iwe.cmd = IWEVGENIE;
1906 iwe.u.data.length = bss->wpa_ie_len;
1907 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
1908 &iwe, bss->wpa_ie);
1909 }
1910
1911 if (bss && bss->rsn_ie_len > 0 && bss->rsn_ie_len <= MAX_WPA_IE_LEN) {
1912 memset(&iwe, 0, sizeof(iwe));
1913 iwe.cmd = IWEVGENIE;
1914 iwe.u.data.length = bss->rsn_ie_len;
1915 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
1916 &iwe, bss->rsn_ie);
1917 }
1918
1919 return current_ev;
1920 }
1921
1922
1923 /* Translate scan data returned from the card to a card independant
1924 * format that the Wireless Tools will understand - Jean II */
1925 static inline int prism2_translate_scan(local_info_t *local,
1926 struct iw_request_info *info,
1927 char *buffer, int buflen)
1928 {
1929 struct hfa384x_hostscan_result *scan;
1930 int entry, hostscan;
1931 char *current_ev = buffer;
1932 char *end_buf = buffer + buflen;
1933 struct list_head *ptr;
1934
1935 spin_lock_bh(&local->lock);
1936
1937 list_for_each(ptr, &local->bss_list) {
1938 struct hostap_bss_info *bss;
1939 bss = list_entry(ptr, struct hostap_bss_info, list);
1940 bss->included = 0;
1941 }
1942
1943 hostscan = local->last_scan_type == PRISM2_HOSTSCAN;
1944 for (entry = 0; entry < local->last_scan_results_count; entry++) {
1945 int found = 0;
1946 scan = &local->last_scan_results[entry];
1947
1948 /* Report every SSID if the AP is using multiple SSIDs. If no
1949 * BSS record is found (e.g., when WPA mode is disabled),
1950 * report the AP once. */
1951 list_for_each(ptr, &local->bss_list) {
1952 struct hostap_bss_info *bss;
1953 bss = list_entry(ptr, struct hostap_bss_info, list);
1954 if (memcmp(bss->bssid, scan->bssid, ETH_ALEN) == 0) {
1955 bss->included = 1;
1956 current_ev = __prism2_translate_scan(
1957 local, info, scan, bss, current_ev,
1958 end_buf);
1959 found++;
1960 }
1961 }
1962 if (!found) {
1963 current_ev = __prism2_translate_scan(
1964 local, info, scan, NULL, current_ev, end_buf);
1965 }
1966 /* Check if there is space for one more entry */
1967 if ((end_buf - current_ev) <= IW_EV_ADDR_LEN) {
1968 /* Ask user space to try again with a bigger buffer */
1969 spin_unlock_bh(&local->lock);
1970 return -E2BIG;
1971 }
1972 }
1973
1974 /* Prism2 firmware has limits (32 at least in some versions) for number
1975 * of BSSes in scan results. Extend this limit by using local BSS list.
1976 */
1977 list_for_each(ptr, &local->bss_list) {
1978 struct hostap_bss_info *bss;
1979 bss = list_entry(ptr, struct hostap_bss_info, list);
1980 if (bss->included)
1981 continue;
1982 current_ev = __prism2_translate_scan(local, info, NULL, bss,
1983 current_ev, end_buf);
1984 /* Check if there is space for one more entry */
1985 if ((end_buf - current_ev) <= IW_EV_ADDR_LEN) {
1986 /* Ask user space to try again with a bigger buffer */
1987 spin_unlock_bh(&local->lock);
1988 return -E2BIG;
1989 }
1990 }
1991
1992 spin_unlock_bh(&local->lock);
1993
1994 return current_ev - buffer;
1995 }
1996 #endif /* PRISM2_NO_STATION_MODES */
1997
1998
1999 static inline int prism2_ioctl_giwscan_sta(struct net_device *dev,
2000 struct iw_request_info *info,
2001 struct iw_point *data, char *extra)
2002 {
2003 #ifdef PRISM2_NO_STATION_MODES
2004 return -EOPNOTSUPP;
2005 #else /* PRISM2_NO_STATION_MODES */
2006 struct hostap_interface *iface;
2007 local_info_t *local;
2008 int res;
2009
2010 iface = netdev_priv(dev);
2011 local = iface->local;
2012
2013 /* Wait until the scan is finished. We can probably do better
2014 * than that - Jean II */
2015 if (local->scan_timestamp &&
2016 time_before(jiffies, local->scan_timestamp + 3 * HZ)) {
2017 /* Important note : we don't want to block the caller
2018 * until results are ready for various reasons.
2019 * First, managing wait queues is complex and racy
2020 * (there may be multiple simultaneous callers).
2021 * Second, we grab some rtnetlink lock before comming
2022 * here (in dev_ioctl()).
2023 * Third, the caller can wait on the Wireless Event
2024 * - Jean II */
2025 return -EAGAIN;
2026 }
2027 local->scan_timestamp = 0;
2028
2029 res = prism2_translate_scan(local, info, extra, data->length);
2030
2031 if (res >= 0) {
2032 data->length = res;
2033 return 0;
2034 } else {
2035 data->length = 0;
2036 return res;
2037 }
2038 #endif /* PRISM2_NO_STATION_MODES */
2039 }
2040
2041
2042 static int prism2_ioctl_giwscan(struct net_device *dev,
2043 struct iw_request_info *info,
2044 struct iw_point *data, char *extra)
2045 {
2046 struct hostap_interface *iface;
2047 local_info_t *local;
2048 int res;
2049
2050 iface = netdev_priv(dev);
2051 local = iface->local;
2052
2053 if (local->iw_mode == IW_MODE_MASTER) {
2054 /* In MASTER mode, it doesn't make sense to go around
2055 * scanning the frequencies and make the stations we serve
2056 * wait when what the user is really interested about is the
2057 * list of stations and access points we are talking to.
2058 * So, just extract results from our cache...
2059 * Jean II */
2060
2061 /* Translate to WE format */
2062 res = prism2_ap_translate_scan(dev, info, extra);
2063 if (res >= 0) {
2064 printk(KERN_DEBUG "Scan result translation succeeded "
2065 "(length=%d)\n", res);
2066 data->length = res;
2067 return 0;
2068 } else {
2069 printk(KERN_DEBUG
2070 "Scan result translation failed (res=%d)\n",
2071 res);
2072 data->length = 0;
2073 return res;
2074 }
2075 } else {
2076 /* Station mode */
2077 return prism2_ioctl_giwscan_sta(dev, info, data, extra);
2078 }
2079 }
2080
2081
2082 static const struct iw_priv_args prism2_priv[] = {
2083 { PRISM2_IOCTL_MONITOR,
2084 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "monitor" },
2085 { PRISM2_IOCTL_READMIF,
2086 IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1,
2087 IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "readmif" },
2088 { PRISM2_IOCTL_WRITEMIF,
2089 IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 2, 0, "writemif" },
2090 { PRISM2_IOCTL_RESET,
2091 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "reset" },
2092 { PRISM2_IOCTL_INQUIRE,
2093 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "inquire" },
2094 { PRISM2_IOCTL_SET_RID_WORD,
2095 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "set_rid_word" },
2096 { PRISM2_IOCTL_MACCMD,
2097 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "maccmd" },
2098 { PRISM2_IOCTL_WDS_ADD,
2099 IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "wds_add" },
2100 { PRISM2_IOCTL_WDS_DEL,
2101 IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "wds_del" },
2102 { PRISM2_IOCTL_ADDMAC,
2103 IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "addmac" },
2104 { PRISM2_IOCTL_DELMAC,
2105 IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "delmac" },
2106 { PRISM2_IOCTL_KICKMAC,
2107 IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "kickmac" },
2108 /* --- raw access to sub-ioctls --- */
2109 { PRISM2_IOCTL_PRISM2_PARAM,
2110 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "prism2_param" },
2111 { PRISM2_IOCTL_GET_PRISM2_PARAM,
2112 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
2113 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getprism2_param" },
2114 /* --- sub-ioctls handlers --- */
2115 { PRISM2_IOCTL_PRISM2_PARAM,
2116 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "" },
2117 { PRISM2_IOCTL_GET_PRISM2_PARAM,
2118 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "" },
2119 /* --- sub-ioctls definitions --- */
2120 { PRISM2_PARAM_TXRATECTRL,
2121 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "txratectrl" },
2122 { PRISM2_PARAM_TXRATECTRL,
2123 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gettxratectrl" },
2124 { PRISM2_PARAM_BEACON_INT,
2125 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "beacon_int" },
2126 { PRISM2_PARAM_BEACON_INT,
2127 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbeacon_int" },
2128 #ifndef PRISM2_NO_STATION_MODES
2129 { PRISM2_PARAM_PSEUDO_IBSS,
2130 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "pseudo_ibss" },
2131 { PRISM2_PARAM_PSEUDO_IBSS,
2132 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getpseudo_ibss" },
2133 #endif /* PRISM2_NO_STATION_MODES */
2134 { PRISM2_PARAM_ALC,
2135 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "alc" },
2136 { PRISM2_PARAM_ALC,
2137 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getalc" },
2138 { PRISM2_PARAM_DUMP,
2139 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "dump" },
2140 { PRISM2_PARAM_DUMP,
2141 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getdump" },
2142 { PRISM2_PARAM_OTHER_AP_POLICY,
2143 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "other_ap_policy" },
2144 { PRISM2_PARAM_OTHER_AP_POLICY,
2145 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getother_ap_pol" },
2146 { PRISM2_PARAM_AP_MAX_INACTIVITY,
2147 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "max_inactivity" },
2148 { PRISM2_PARAM_AP_MAX_INACTIVITY,
2149 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getmax_inactivi" },
2150 { PRISM2_PARAM_AP_BRIDGE_PACKETS,
2151 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "bridge_packets" },
2152 { PRISM2_PARAM_AP_BRIDGE_PACKETS,
2153 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbridge_packe" },
2154 { PRISM2_PARAM_DTIM_PERIOD,
2155 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "dtim_period" },
2156 { PRISM2_PARAM_DTIM_PERIOD,
2157 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getdtim_period" },
2158 { PRISM2_PARAM_AP_NULLFUNC_ACK,
2159 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "nullfunc_ack" },
2160 { PRISM2_PARAM_AP_NULLFUNC_ACK,
2161 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getnullfunc_ack" },
2162 { PRISM2_PARAM_MAX_WDS,
2163 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "max_wds" },
2164 { PRISM2_PARAM_MAX_WDS,
2165 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getmax_wds" },
2166 { PRISM2_PARAM_AP_AUTOM_AP_WDS,
2167 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "autom_ap_wds" },
2168 { PRISM2_PARAM_AP_AUTOM_AP_WDS,
2169 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getautom_ap_wds" },
2170 { PRISM2_PARAM_AP_AUTH_ALGS,
2171 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "ap_auth_algs" },
2172 { PRISM2_PARAM_AP_AUTH_ALGS,
2173 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getap_auth_algs" },
2174 { PRISM2_PARAM_MONITOR_ALLOW_FCSERR,
2175 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "allow_fcserr" },
2176 { PRISM2_PARAM_MONITOR_ALLOW_FCSERR,
2177 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getallow_fcserr" },
2178 { PRISM2_PARAM_HOST_ENCRYPT,
2179 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "host_encrypt" },
2180 { PRISM2_PARAM_HOST_ENCRYPT,
2181 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethost_encrypt" },
2182 { PRISM2_PARAM_HOST_DECRYPT,
2183 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "host_decrypt" },
2184 { PRISM2_PARAM_HOST_DECRYPT,
2185 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethost_decrypt" },
2186 #ifndef PRISM2_NO_STATION_MODES
2187 { PRISM2_PARAM_HOST_ROAMING,
2188 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "host_roaming" },
2189 { PRISM2_PARAM_HOST_ROAMING,
2190 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethost_roaming" },
2191 #endif /* PRISM2_NO_STATION_MODES */
2192 { PRISM2_PARAM_BCRX_STA_KEY,
2193 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "bcrx_sta_key" },
2194 { PRISM2_PARAM_BCRX_STA_KEY,
2195 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbcrx_sta_key" },
2196 { PRISM2_PARAM_IEEE_802_1X,
2197 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "ieee_802_1x" },
2198 { PRISM2_PARAM_IEEE_802_1X,
2199 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getieee_802_1x" },
2200 { PRISM2_PARAM_ANTSEL_TX,
2201 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "antsel_tx" },
2202 { PRISM2_PARAM_ANTSEL_TX,
2203 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getantsel_tx" },
2204 { PRISM2_PARAM_ANTSEL_RX,
2205 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "antsel_rx" },
2206 { PRISM2_PARAM_ANTSEL_RX,
2207 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getantsel_rx" },
2208 { PRISM2_PARAM_MONITOR_TYPE,
2209 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "monitor_type" },
2210 { PRISM2_PARAM_MONITOR_TYPE,
2211 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getmonitor_type" },
2212 { PRISM2_PARAM_WDS_TYPE,
2213 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wds_type" },
2214 { PRISM2_PARAM_WDS_TYPE,
2215 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getwds_type" },
2216 { PRISM2_PARAM_HOSTSCAN,
2217 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "hostscan" },
2218 { PRISM2_PARAM_HOSTSCAN,
2219 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethostscan" },
2220 { PRISM2_PARAM_AP_SCAN,
2221 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "ap_scan" },
2222 { PRISM2_PARAM_AP_SCAN,
2223 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getap_scan" },
2224 { PRISM2_PARAM_ENH_SEC,
2225 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "enh_sec" },
2226 { PRISM2_PARAM_ENH_SEC,
2227 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getenh_sec" },
2228 #ifdef PRISM2_IO_DEBUG
2229 { PRISM2_PARAM_IO_DEBUG,
2230 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "io_debug" },
2231 { PRISM2_PARAM_IO_DEBUG,
2232 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getio_debug" },
2233 #endif /* PRISM2_IO_DEBUG */
2234 { PRISM2_PARAM_BASIC_RATES,
2235 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "basic_rates" },
2236 { PRISM2_PARAM_BASIC_RATES,
2237 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbasic_rates" },
2238 { PRISM2_PARAM_OPER_RATES,
2239 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "oper_rates" },
2240 { PRISM2_PARAM_OPER_RATES,
2241 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getoper_rates" },
2242 { PRISM2_PARAM_HOSTAPD,
2243 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "hostapd" },
2244 { PRISM2_PARAM_HOSTAPD,
2245 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethostapd" },
2246 { PRISM2_PARAM_HOSTAPD_STA,
2247 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "hostapd_sta" },
2248 { PRISM2_PARAM_HOSTAPD_STA,
2249 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethostapd_sta" },
2250 { PRISM2_PARAM_WPA,
2251 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wpa" },
2252 { PRISM2_PARAM_WPA,
2253 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getwpa" },
2254 { PRISM2_PARAM_PRIVACY_INVOKED,
2255 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "privacy_invoked" },
2256 { PRISM2_PARAM_PRIVACY_INVOKED,
2257 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getprivacy_invo" },
2258 { PRISM2_PARAM_TKIP_COUNTERMEASURES,
2259 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "tkip_countermea" },
2260 { PRISM2_PARAM_TKIP_COUNTERMEASURES,
2261 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gettkip_counter" },
2262 { PRISM2_PARAM_DROP_UNENCRYPTED,
2263 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "drop_unencrypte" },
2264 { PRISM2_PARAM_DROP_UNENCRYPTED,
2265 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getdrop_unencry" },
2266 { PRISM2_PARAM_SCAN_CHANNEL_MASK,
2267 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "scan_channels" },
2268 { PRISM2_PARAM_SCAN_CHANNEL_MASK,
2269 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getscan_channel" },
2270 };
2271
2272
2273 static int prism2_ioctl_priv_inquire(struct net_device *dev, int *i)
2274 {
2275 struct hostap_interface *iface;
2276 local_info_t *local;
2277
2278 iface = netdev_priv(dev);
2279 local = iface->local;
2280
2281 if (local->func->cmd(dev, HFA384X_CMDCODE_INQUIRE, *i, NULL, NULL))
2282 return -EOPNOTSUPP;
2283
2284 return 0;
2285 }
2286
2287
2288 static int prism2_ioctl_priv_prism2_param(struct net_device *dev,
2289 struct iw_request_info *info,
2290 void *wrqu, char *extra)
2291 {
2292 struct hostap_interface *iface;
2293 local_info_t *local;
2294 int *i = (int *) extra;
2295 int param = *i;
2296 int value = *(i + 1);
2297 int ret = 0;
2298 u16 val;
2299
2300 iface = netdev_priv(dev);
2301 local = iface->local;
2302
2303 switch (param) {
2304 case PRISM2_PARAM_TXRATECTRL:
2305 local->fw_tx_rate_control = value;
2306 break;
2307
2308 case PRISM2_PARAM_BEACON_INT:
2309 if (hostap_set_word(dev, HFA384X_RID_CNFBEACONINT, value) ||
2310 local->func->reset_port(dev))
2311 ret = -EINVAL;
2312 else
2313 local->beacon_int = value;
2314 break;
2315
2316 #ifndef PRISM2_NO_STATION_MODES
2317 case PRISM2_PARAM_PSEUDO_IBSS:
2318 if (value == local->pseudo_adhoc)
2319 break;
2320
2321 if (value != 0 && value != 1) {
2322 ret = -EINVAL;
2323 break;
2324 }
2325
2326 printk(KERN_DEBUG "prism2: %s: pseudo IBSS change %d -> %d\n",
2327 dev->name, local->pseudo_adhoc, value);
2328 local->pseudo_adhoc = value;
2329 if (local->iw_mode != IW_MODE_ADHOC)
2330 break;
2331
2332 if (hostap_set_word(dev, HFA384X_RID_CNFPORTTYPE,
2333 hostap_get_porttype(local))) {
2334 ret = -EOPNOTSUPP;
2335 break;
2336 }
2337
2338 if (local->func->reset_port(dev))
2339 ret = -EINVAL;
2340 break;
2341 #endif /* PRISM2_NO_STATION_MODES */
2342
2343 case PRISM2_PARAM_ALC:
2344 printk(KERN_DEBUG "%s: %s ALC\n", dev->name,
2345 value == 0 ? "Disabling" : "Enabling");
2346 val = HFA384X_TEST_CFG_BIT_ALC;
2347 local->func->cmd(dev, HFA384X_CMDCODE_TEST |
2348 (HFA384X_TEST_CFG_BITS << 8),
2349 value == 0 ? 0 : 1, &val, NULL);
2350 break;
2351
2352 case PRISM2_PARAM_DUMP:
2353 local->frame_dump = value;
2354 break;
2355
2356 case PRISM2_PARAM_OTHER_AP_POLICY:
2357 if (value < 0 || value > 3) {
2358 ret = -EINVAL;
2359 break;
2360 }
2361 if (local->ap != NULL)
2362 local->ap->ap_policy = value;
2363 break;
2364
2365 case PRISM2_PARAM_AP_MAX_INACTIVITY:
2366 if (value < 0 || value > 7 * 24 * 60 * 60) {
2367 ret = -EINVAL;
2368 break;
2369 }
2370 if (local->ap != NULL)
2371 local->ap->max_inactivity = value * HZ;
2372 break;
2373
2374 case PRISM2_PARAM_AP_BRIDGE_PACKETS:
2375 if (local->ap != NULL)
2376 local->ap->bridge_packets = value;
2377 break;
2378
2379 case PRISM2_PARAM_DTIM_PERIOD:
2380 if (value < 0 || value > 65535) {
2381 ret = -EINVAL;
2382 break;
2383 }
2384 if (hostap_set_word(dev, HFA384X_RID_CNFOWNDTIMPERIOD, value)
2385 || local->func->reset_port(dev))
2386 ret = -EINVAL;
2387 else
2388 local->dtim_period = value;
2389 break;
2390
2391 case PRISM2_PARAM_AP_NULLFUNC_ACK:
2392 if (local->ap != NULL)
2393 local->ap->nullfunc_ack = value;
2394 break;
2395
2396 case PRISM2_PARAM_MAX_WDS:
2397 local->wds_max_connections = value;
2398 break;
2399
2400 case PRISM2_PARAM_AP_AUTOM_AP_WDS:
2401 if (local->ap != NULL) {
2402 if (!local->ap->autom_ap_wds && value) {
2403 /* add WDS link to all APs in STA table */
2404 hostap_add_wds_links(local);
2405 }
2406 local->ap->autom_ap_wds = value;
2407 }
2408 break;
2409
2410 case PRISM2_PARAM_AP_AUTH_ALGS:
2411 local->auth_algs = value;
2412 if (hostap_set_auth_algs(local))
2413 ret = -EINVAL;
2414 break;
2415
2416 case PRISM2_PARAM_MONITOR_ALLOW_FCSERR:
2417 local->monitor_allow_fcserr = value;
2418 break;
2419
2420 case PRISM2_PARAM_HOST_ENCRYPT:
2421 local->host_encrypt = value;
2422 if (hostap_set_encryption(local) ||
2423 local->func->reset_port(dev))
2424 ret = -EINVAL;
2425 break;
2426
2427 case PRISM2_PARAM_HOST_DECRYPT:
2428 local->host_decrypt = value;
2429 if (hostap_set_encryption(local) ||
2430 local->func->reset_port(dev))
2431 ret = -EINVAL;
2432 break;
2433
2434 #ifndef PRISM2_NO_STATION_MODES
2435 case PRISM2_PARAM_HOST_ROAMING:
2436 if (value < 0 || value > 2) {
2437 ret = -EINVAL;
2438 break;
2439 }
2440 local->host_roaming = value;
2441 if (hostap_set_roaming(local) || local->func->reset_port(dev))
2442 ret = -EINVAL;
2443 break;
2444 #endif /* PRISM2_NO_STATION_MODES */
2445
2446 case PRISM2_PARAM_BCRX_STA_KEY:
2447 local->bcrx_sta_key = value;
2448 break;
2449
2450 case PRISM2_PARAM_IEEE_802_1X:
2451 local->ieee_802_1x = value;
2452 break;
2453
2454 case PRISM2_PARAM_ANTSEL_TX:
2455 if (value < 0 || value > HOSTAP_ANTSEL_HIGH) {
2456 ret = -EINVAL;
2457 break;
2458 }
2459 local->antsel_tx = value;
2460 hostap_set_antsel(local);
2461 break;
2462
2463 case PRISM2_PARAM_ANTSEL_RX:
2464 if (value < 0 || value > HOSTAP_ANTSEL_HIGH) {
2465 ret = -EINVAL;
2466 break;
2467 }
2468 local->antsel_rx = value;
2469 hostap_set_antsel(local);
2470 break;
2471
2472 case PRISM2_PARAM_MONITOR_TYPE:
2473 if (value != PRISM2_MONITOR_80211 &&
2474 value != PRISM2_MONITOR_CAPHDR &&
2475 value != PRISM2_MONITOR_PRISM &&
2476 value != PRISM2_MONITOR_RADIOTAP) {
2477 ret = -EINVAL;
2478 break;
2479 }
2480 local->monitor_type = value;
2481 if (local->iw_mode == IW_MODE_MONITOR)
2482 hostap_monitor_set_type(local);
2483 break;
2484
2485 case PRISM2_PARAM_WDS_TYPE:
2486 local->wds_type = value;
2487 break;
2488
2489 case PRISM2_PARAM_HOSTSCAN:
2490 {
2491 struct hfa384x_hostscan_request scan_req;
2492 u16 rate;
2493
2494 memset(&scan_req, 0, sizeof(scan_req));
2495 scan_req.channel_list = cpu_to_le16(0x3fff);
2496 switch (value) {
2497 case 1: rate = HFA384X_RATES_1MBPS; break;
2498 case 2: rate = HFA384X_RATES_2MBPS; break;
2499 case 3: rate = HFA384X_RATES_5MBPS; break;
2500 case 4: rate = HFA384X_RATES_11MBPS; break;
2501 default: rate = HFA384X_RATES_1MBPS; break;
2502 }
2503 scan_req.txrate = cpu_to_le16(rate);
2504 /* leave SSID empty to accept all SSIDs */
2505
2506 if (local->iw_mode == IW_MODE_MASTER) {
2507 if (hostap_set_word(dev, HFA384X_RID_CNFPORTTYPE,
2508 HFA384X_PORTTYPE_BSS) ||
2509 local->func->reset_port(dev))
2510 printk(KERN_DEBUG "Leaving Host AP mode "
2511 "for HostScan failed\n");
2512 }
2513
2514 if (local->func->set_rid(dev, HFA384X_RID_HOSTSCAN, &scan_req,
2515 sizeof(scan_req))) {
2516 printk(KERN_DEBUG "HOSTSCAN failed\n");
2517 ret = -EINVAL;
2518 }
2519 if (local->iw_mode == IW_MODE_MASTER) {
2520 wait_queue_t __wait;
2521 init_waitqueue_entry(&__wait, current);
2522 add_wait_queue(&local->hostscan_wq, &__wait);
2523 set_current_state(TASK_INTERRUPTIBLE);
2524 schedule_timeout(HZ);
2525 if (signal_pending(current))
2526 ret = -EINTR;
2527 set_current_state(TASK_RUNNING);
2528 remove_wait_queue(&local->hostscan_wq, &__wait);
2529
2530 if (hostap_set_word(dev, HFA384X_RID_CNFPORTTYPE,
2531 HFA384X_PORTTYPE_HOSTAP) ||
2532 local->func->reset_port(dev))
2533 printk(KERN_DEBUG "Returning to Host AP mode "
2534 "after HostScan failed\n");
2535 }
2536 break;
2537 }
2538
2539 case PRISM2_PARAM_AP_SCAN:
2540 local->passive_scan_interval = value;
2541 if (timer_pending(&local->passive_scan_timer))
2542 del_timer(&local->passive_scan_timer);
2543 if (value > 0) {
2544 local->passive_scan_timer.expires = jiffies +
2545 local->passive_scan_interval * HZ;
2546 add_timer(&local->passive_scan_timer);
2547 }
2548 break;
2549
2550 case PRISM2_PARAM_ENH_SEC:
2551 if (value < 0 || value > 3) {
2552 ret = -EINVAL;
2553 break;
2554 }
2555 local->enh_sec = value;
2556 if (hostap_set_word(dev, HFA384X_RID_CNFENHSECURITY,
2557 local->enh_sec) ||
2558 local->func->reset_port(dev)) {
2559 printk(KERN_INFO "%s: cnfEnhSecurity requires STA f/w "
2560 "1.6.3 or newer\n", dev->name);
2561 ret = -EOPNOTSUPP;
2562 }
2563 break;
2564
2565 #ifdef PRISM2_IO_DEBUG
2566 case PRISM2_PARAM_IO_DEBUG:
2567 local->io_debug_enabled = value;
2568 break;
2569 #endif /* PRISM2_IO_DEBUG */
2570
2571 case PRISM2_PARAM_BASIC_RATES:
2572 if ((value & local->tx_rate_control) != value || value == 0) {
2573 printk(KERN_INFO "%s: invalid basic rate set - basic "
2574 "rates must be in supported rate set\n",
2575 dev->name);
2576 ret = -EINVAL;
2577 break;
2578 }
2579 local->basic_rates = value;
2580 if (hostap_set_word(dev, HFA384X_RID_CNFBASICRATES,
2581 local->basic_rates) ||
2582 local->func->reset_port(dev))
2583 ret = -EINVAL;
2584 break;
2585
2586 case PRISM2_PARAM_OPER_RATES:
2587 local->tx_rate_control = value;
2588 if (hostap_set_rate(dev))
2589 ret = -EINVAL;
2590 break;
2591
2592 case PRISM2_PARAM_HOSTAPD:
2593 ret = hostap_set_hostapd(local, value, 1);
2594 break;
2595
2596 case PRISM2_PARAM_HOSTAPD_STA:
2597 ret = hostap_set_hostapd_sta(local, value, 1);
2598 break;
2599
2600 case PRISM2_PARAM_WPA:
2601 local->wpa = value;
2602 if (local->sta_fw_ver < PRISM2_FW_VER(1,7,0))
2603 ret = -EOPNOTSUPP;
2604 else if (hostap_set_word(dev, HFA384X_RID_SSNHANDLINGMODE,
2605 value ? 1 : 0))
2606 ret = -EINVAL;
2607 break;
2608
2609 case PRISM2_PARAM_PRIVACY_INVOKED:
2610 local->privacy_invoked = value;
2611 if (hostap_set_encryption(local) ||
2612 local->func->reset_port(dev))
2613 ret = -EINVAL;
2614 break;
2615
2616 case PRISM2_PARAM_TKIP_COUNTERMEASURES:
2617 local->tkip_countermeasures = value;
2618 break;
2619
2620 case PRISM2_PARAM_DROP_UNENCRYPTED:
2621 local->drop_unencrypted = value;
2622 break;
2623
2624 case PRISM2_PARAM_SCAN_CHANNEL_MASK:
2625 local->scan_channel_mask = value;
2626 break;
2627
2628 default:
2629 printk(KERN_DEBUG "%s: prism2_param: unknown param %d\n",
2630 dev->name, param);
2631 ret = -EOPNOTSUPP;
2632 break;
2633 }
2634
2635 return ret;
2636 }
2637
2638
2639 static int prism2_ioctl_priv_get_prism2_param(struct net_device *dev,
2640 struct iw_request_info *info,
2641 void *wrqu, char *extra)
2642 {
2643 struct hostap_interface *iface;
2644 local_info_t *local;
2645 int *param = (int *) extra;
2646 int ret = 0;
2647
2648 iface = netdev_priv(dev);
2649 local = iface->local;
2650
2651 switch (*param) {
2652 case PRISM2_PARAM_TXRATECTRL:
2653 *param = local->fw_tx_rate_control;
2654 break;
2655
2656 case PRISM2_PARAM_BEACON_INT:
2657 *param = local->beacon_int;
2658 break;
2659
2660 case PRISM2_PARAM_PSEUDO_IBSS:
2661 *param = local->pseudo_adhoc;
2662 break;
2663
2664 case PRISM2_PARAM_ALC:
2665 ret = -EOPNOTSUPP; /* FIX */
2666 break;
2667
2668 case PRISM2_PARAM_DUMP:
2669 *param = local->frame_dump;
2670 break;
2671
2672 case PRISM2_PARAM_OTHER_AP_POLICY:
2673 if (local->ap != NULL)
2674 *param = local->ap->ap_policy;
2675 else
2676 ret = -EOPNOTSUPP;
2677 break;
2678
2679 case PRISM2_PARAM_AP_MAX_INACTIVITY:
2680 if (local->ap != NULL)
2681 *param = local->ap->max_inactivity / HZ;
2682 else
2683 ret = -EOPNOTSUPP;
2684 break;
2685
2686 case PRISM2_PARAM_AP_BRIDGE_PACKETS:
2687 if (local->ap != NULL)
2688 *param = local->ap->bridge_packets;
2689 else
2690 ret = -EOPNOTSUPP;
2691 break;
2692
2693 case PRISM2_PARAM_DTIM_PERIOD:
2694 *param = local->dtim_period;
2695 break;
2696
2697 case PRISM2_PARAM_AP_NULLFUNC_ACK:
2698 if (local->ap != NULL)
2699 *param = local->ap->nullfunc_ack;
2700 else
2701 ret = -EOPNOTSUPP;
2702 break;
2703
2704 case PRISM2_PARAM_MAX_WDS:
2705 *param = local->wds_max_connections;
2706 break;
2707
2708 case PRISM2_PARAM_AP_AUTOM_AP_WDS:
2709 if (local->ap != NULL)
2710 *param = local->ap->autom_ap_wds;
2711 else
2712 ret = -EOPNOTSUPP;
2713 break;
2714
2715 case PRISM2_PARAM_AP_AUTH_ALGS:
2716 *param = local->auth_algs;
2717 break;
2718
2719 case PRISM2_PARAM_MONITOR_ALLOW_FCSERR:
2720 *param = local->monitor_allow_fcserr;
2721 break;
2722
2723 case PRISM2_PARAM_HOST_ENCRYPT:
2724 *param = local->host_encrypt;
2725 break;
2726
2727 case PRISM2_PARAM_HOST_DECRYPT:
2728 *param = local->host_decrypt;
2729 break;
2730
2731 case PRISM2_PARAM_HOST_ROAMING:
2732 *param = local->host_roaming;
2733 break;
2734
2735 case PRISM2_PARAM_BCRX_STA_KEY:
2736 *param = local->bcrx_sta_key;
2737 break;
2738
2739 case PRISM2_PARAM_IEEE_802_1X:
2740 *param = local->ieee_802_1x;
2741 break;
2742
2743 case PRISM2_PARAM_ANTSEL_TX:
2744 *param = local->antsel_tx;
2745 break;
2746
2747 case PRISM2_PARAM_ANTSEL_RX:
2748 *param = local->antsel_rx;
2749 break;
2750
2751 case PRISM2_PARAM_MONITOR_TYPE:
2752 *param = local->monitor_type;
2753 break;
2754
2755 case PRISM2_PARAM_WDS_TYPE:
2756 *param = local->wds_type;
2757 break;
2758
2759 case PRISM2_PARAM_HOSTSCAN:
2760 ret = -EOPNOTSUPP;
2761 break;
2762
2763 case PRISM2_PARAM_AP_SCAN:
2764 *param = local->passive_scan_interval;
2765 break;
2766
2767 case PRISM2_PARAM_ENH_SEC:
2768 *param = local->enh_sec;
2769 break;
2770
2771 #ifdef PRISM2_IO_DEBUG
2772 case PRISM2_PARAM_IO_DEBUG:
2773 *param = local->io_debug_enabled;
2774 break;
2775 #endif /* PRISM2_IO_DEBUG */
2776
2777 case PRISM2_PARAM_BASIC_RATES:
2778 *param = local->basic_rates;
2779 break;
2780
2781 case PRISM2_PARAM_OPER_RATES:
2782 *param = local->tx_rate_control;
2783 break;
2784
2785 case PRISM2_PARAM_HOSTAPD:
2786 *param = local->hostapd;
2787 break;
2788
2789 case PRISM2_PARAM_HOSTAPD_STA:
2790 *param = local->hostapd_sta;
2791 break;
2792
2793 case PRISM2_PARAM_WPA:
2794 if (local->sta_fw_ver < PRISM2_FW_VER(1,7,0))
2795 ret = -EOPNOTSUPP;
2796 *param = local->wpa;
2797 break;
2798
2799 case PRISM2_PARAM_PRIVACY_INVOKED:
2800 *param = local->privacy_invoked;
2801 break;
2802
2803 case PRISM2_PARAM_TKIP_COUNTERMEASURES:
2804 *param = local->tkip_countermeasures;
2805 break;
2806
2807 case PRISM2_PARAM_DROP_UNENCRYPTED:
2808 *param = local->drop_unencrypted;
2809 break;
2810
2811 case PRISM2_PARAM_SCAN_CHANNEL_MASK:
2812 *param = local->scan_channel_mask;
2813 break;
2814
2815 default:
2816 printk(KERN_DEBUG "%s: get_prism2_param: unknown param %d\n",
2817 dev->name, *param);
2818 ret = -EOPNOTSUPP;
2819 break;
2820 }
2821
2822 return ret;
2823 }
2824
2825
2826 static int prism2_ioctl_priv_readmif(struct net_device *dev,
2827 struct iw_request_info *info,
2828 void *wrqu, char *extra)
2829 {
2830 struct hostap_interface *iface;
2831 local_info_t *local;
2832 u16 resp0;
2833
2834 iface = netdev_priv(dev);
2835 local = iface->local;
2836
2837 if (local->func->cmd(dev, HFA384X_CMDCODE_READMIF, *extra, NULL,
2838 &resp0))
2839 return -EOPNOTSUPP;
2840 else
2841 *extra = resp0;
2842
2843 return 0;
2844 }
2845
2846
2847 static int prism2_ioctl_priv_writemif(struct net_device *dev,
2848 struct iw_request_info *info,
2849 void *wrqu, char *extra)
2850 {
2851 struct hostap_interface *iface;
2852 local_info_t *local;
2853 u16 cr, val;
2854
2855 iface = netdev_priv(dev);
2856 local = iface->local;
2857
2858 cr = *extra;
2859 val = *(extra + 1);
2860 if (local->func->cmd(dev, HFA384X_CMDCODE_WRITEMIF, cr, &val, NULL))
2861 return -EOPNOTSUPP;
2862
2863 return 0;
2864 }
2865
2866
2867 static int prism2_ioctl_priv_monitor(struct net_device *dev, int *i)
2868 {
2869 struct hostap_interface *iface;
2870 local_info_t *local;
2871 int ret = 0;
2872 u32 mode;
2873
2874 iface = netdev_priv(dev);
2875 local = iface->local;
2876
2877 printk(KERN_DEBUG "%s: process %d (%s) used deprecated iwpriv monitor "
2878 "- update software to use iwconfig mode monitor\n",
2879 dev->name, task_pid_nr(current), current->comm);
2880
2881 /* Backward compatibility code - this can be removed at some point */
2882
2883 if (*i == 0) {
2884 /* Disable monitor mode - old mode was not saved, so go to
2885 * Master mode */
2886 mode = IW_MODE_MASTER;
2887 ret = prism2_ioctl_siwmode(dev, NULL, &mode, NULL);
2888 } else if (*i == 1) {
2889 /* netlink socket mode is not supported anymore since it did
2890 * not separate different devices from each other and was not
2891 * best method for delivering large amount of packets to
2892 * user space */
2893 ret = -EOPNOTSUPP;
2894 } else if (*i == 2 || *i == 3) {
2895 switch (*i) {
2896 case 2:
2897 local->monitor_type = PRISM2_MONITOR_80211;
2898 break;
2899 case 3:
2900 local->monitor_type = PRISM2_MONITOR_PRISM;
2901 break;
2902 }
2903 mode = IW_MODE_MONITOR;
2904 ret = prism2_ioctl_siwmode(dev, NULL, &mode, NULL);
2905 hostap_monitor_mode_enable(local);
2906 } else
2907 ret = -EINVAL;
2908
2909 return ret;
2910 }
2911
2912
2913 static int prism2_ioctl_priv_reset(struct net_device *dev, int *i)
2914 {
2915 struct hostap_interface *iface;
2916 local_info_t *local;
2917
2918 iface = netdev_priv(dev);
2919 local = iface->local;
2920
2921 printk(KERN_DEBUG "%s: manual reset request(%d)\n", dev->name, *i);
2922 switch (*i) {
2923 case 0:
2924 /* Disable and enable card */
2925 local->func->hw_shutdown(dev, 1);
2926 local->func->hw_config(dev, 0);
2927 break;
2928
2929 case 1:
2930 /* COR sreset */
2931 local->func->hw_reset(dev);
2932 break;
2933
2934 case 2:
2935 /* Disable and enable port 0 */
2936 local->func->reset_port(dev);
2937 break;
2938
2939 case 3:
2940 prism2_sta_deauth(local, WLAN_REASON_DEAUTH_LEAVING);
2941 if (local->func->cmd(dev, HFA384X_CMDCODE_DISABLE, 0, NULL,
2942 NULL))
2943 return -EINVAL;
2944 break;
2945
2946 case 4:
2947 if (local->func->cmd(dev, HFA384X_CMDCODE_ENABLE, 0, NULL,
2948 NULL))
2949 return -EINVAL;
2950 break;
2951
2952 default:
2953 printk(KERN_DEBUG "Unknown reset request %d\n", *i);
2954 return -EOPNOTSUPP;
2955 }
2956
2957 return 0;
2958 }
2959
2960
2961 static int prism2_ioctl_priv_set_rid_word(struct net_device *dev, int *i)
2962 {
2963 int rid = *i;
2964 int value = *(i + 1);
2965
2966 printk(KERN_DEBUG "%s: Set RID[0x%X] = %d\n", dev->name, rid, value);
2967
2968 if (hostap_set_word(dev, rid, value))
2969 return -EINVAL;
2970
2971 return 0;
2972 }
2973
2974
2975 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
2976 static int ap_mac_cmd_ioctl(local_info_t *local, int *cmd)
2977 {
2978 int ret = 0;
2979
2980 switch (*cmd) {
2981 case AP_MAC_CMD_POLICY_OPEN:
2982 local->ap->mac_restrictions.policy = MAC_POLICY_OPEN;
2983 break;
2984 case AP_MAC_CMD_POLICY_ALLOW:
2985 local->ap->mac_restrictions.policy = MAC_POLICY_ALLOW;
2986 break;
2987 case AP_MAC_CMD_POLICY_DENY:
2988 local->ap->mac_restrictions.policy = MAC_POLICY_DENY;
2989 break;
2990 case AP_MAC_CMD_FLUSH:
2991 ap_control_flush_macs(&local->ap->mac_restrictions);
2992 break;
2993 case AP_MAC_CMD_KICKALL:
2994 ap_control_kickall(local->ap);
2995 hostap_deauth_all_stas(local->dev, local->ap, 0);
2996 break;
2997 default:
2998 ret = -EOPNOTSUPP;
2999 break;
3000 }
3001
3002 return ret;
3003 }
3004 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
3005
3006
3007 #ifdef PRISM2_DOWNLOAD_SUPPORT
3008 static int prism2_ioctl_priv_download(local_info_t *local, struct iw_point *p)
3009 {
3010 struct prism2_download_param *param;
3011 int ret = 0;
3012
3013 if (p->length < sizeof(struct prism2_download_param) ||
3014 p->length > 1024 || !p->pointer)
3015 return -EINVAL;
3016
3017 param = kmalloc(p->length, GFP_KERNEL);
3018 if (param == NULL)
3019 return -ENOMEM;
3020
3021 if (copy_from_user(param, p->pointer, p->length)) {
3022 ret = -EFAULT;
3023 goto out;
3024 }
3025
3026 if (p->length < sizeof(struct prism2_download_param) +
3027 param->num_areas * sizeof(struct prism2_download_area)) {
3028 ret = -EINVAL;
3029 goto out;
3030 }
3031
3032 ret = local->func->download(local, param);
3033
3034 out:
3035 kfree(param);
3036 return ret;
3037 }
3038 #endif /* PRISM2_DOWNLOAD_SUPPORT */
3039
3040
3041 static int prism2_set_genericelement(struct net_device *dev, u8 *elem,
3042 size_t len)
3043 {
3044 struct hostap_interface *iface = netdev_priv(dev);
3045 local_info_t *local = iface->local;
3046 u8 *buf;
3047
3048 /*
3049 * Add 16-bit length in the beginning of the buffer because Prism2 RID
3050 * includes it.
3051 */
3052 buf = kmalloc(len + 2, GFP_KERNEL);
3053 if (buf == NULL)
3054 return -ENOMEM;
3055
3056 *((__le16 *) buf) = cpu_to_le16(len);
3057 memcpy(buf + 2, elem, len);
3058
3059 kfree(local->generic_elem);
3060 local->generic_elem = buf;
3061 local->generic_elem_len = len + 2;
3062
3063 return local->func->set_rid(local->dev, HFA384X_RID_GENERICELEMENT,
3064 buf, len + 2);
3065 }
3066
3067
3068 static int prism2_ioctl_siwauth(struct net_device *dev,
3069 struct iw_request_info *info,
3070 struct iw_param *data, char *extra)
3071 {
3072 struct hostap_interface *iface = netdev_priv(dev);
3073 local_info_t *local = iface->local;
3074
3075 switch (data->flags & IW_AUTH_INDEX) {
3076 case IW_AUTH_WPA_VERSION:
3077 case IW_AUTH_CIPHER_PAIRWISE:
3078 case IW_AUTH_CIPHER_GROUP:
3079 case IW_AUTH_KEY_MGMT:
3080 /*
3081 * Host AP driver does not use these parameters and allows
3082 * wpa_supplicant to control them internally.
3083 */
3084 break;
3085 case IW_AUTH_TKIP_COUNTERMEASURES:
3086 local->tkip_countermeasures = data->value;
3087 break;
3088 case IW_AUTH_DROP_UNENCRYPTED:
3089 local->drop_unencrypted = data->value;
3090 break;
3091 case IW_AUTH_80211_AUTH_ALG:
3092 local->auth_algs = data->value;
3093 break;
3094 case IW_AUTH_WPA_ENABLED:
3095 if (data->value == 0) {
3096 local->wpa = 0;
3097 if (local->sta_fw_ver < PRISM2_FW_VER(1,7,0))
3098 break;
3099 prism2_set_genericelement(dev, "", 0);
3100 local->host_roaming = 0;
3101 local->privacy_invoked = 0;
3102 if (hostap_set_word(dev, HFA384X_RID_SSNHANDLINGMODE,
3103 0) ||
3104 hostap_set_roaming(local) ||
3105 hostap_set_encryption(local) ||
3106 local->func->reset_port(dev))
3107 return -EINVAL;
3108 break;
3109 }
3110 if (local->sta_fw_ver < PRISM2_FW_VER(1,7,0))
3111 return -EOPNOTSUPP;
3112 local->host_roaming = 2;
3113 local->privacy_invoked = 1;
3114 local->wpa = 1;
3115 if (hostap_set_word(dev, HFA384X_RID_SSNHANDLINGMODE, 1) ||
3116 hostap_set_roaming(local) ||
3117 hostap_set_encryption(local) ||
3118 local->func->reset_port(dev))
3119 return -EINVAL;
3120 break;
3121 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
3122 local->ieee_802_1x = data->value;
3123 break;
3124 case IW_AUTH_PRIVACY_INVOKED:
3125 local->privacy_invoked = data->value;
3126 break;
3127 default:
3128 return -EOPNOTSUPP;
3129 }
3130 return 0;
3131 }
3132
3133
3134 static int prism2_ioctl_giwauth(struct net_device *dev,
3135 struct iw_request_info *info,
3136 struct iw_param *data, char *extra)
3137 {
3138 struct hostap_interface *iface = netdev_priv(dev);
3139 local_info_t *local = iface->local;
3140
3141 switch (data->flags & IW_AUTH_INDEX) {
3142 case IW_AUTH_WPA_VERSION:
3143 case IW_AUTH_CIPHER_PAIRWISE:
3144 case IW_AUTH_CIPHER_GROUP:
3145 case IW_AUTH_KEY_MGMT:
3146 /*
3147 * Host AP driver does not use these parameters and allows
3148 * wpa_supplicant to control them internally.
3149 */
3150 return -EOPNOTSUPP;
3151 case IW_AUTH_TKIP_COUNTERMEASURES:
3152 data->value = local->tkip_countermeasures;
3153 break;
3154 case IW_AUTH_DROP_UNENCRYPTED:
3155 data->value = local->drop_unencrypted;
3156 break;
3157 case IW_AUTH_80211_AUTH_ALG:
3158 data->value = local->auth_algs;
3159 break;
3160 case IW_AUTH_WPA_ENABLED:
3161 data->value = local->wpa;
3162 break;
3163 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
3164 data->value = local->ieee_802_1x;
3165 break;
3166 default:
3167 return -EOPNOTSUPP;
3168 }
3169 return 0;
3170 }
3171
3172
3173 static int prism2_ioctl_siwencodeext(struct net_device *dev,
3174 struct iw_request_info *info,
3175 struct iw_point *erq, char *extra)
3176 {
3177 struct hostap_interface *iface = netdev_priv(dev);
3178 local_info_t *local = iface->local;
3179 struct iw_encode_ext *ext = (struct iw_encode_ext *) extra;
3180 int i, ret = 0;
3181 struct lib80211_crypto_ops *ops;
3182 struct lib80211_crypt_data **crypt;
3183 void *sta_ptr;
3184 u8 *addr;
3185 const char *alg, *module;
3186
3187 i = erq->flags & IW_ENCODE_INDEX;
3188 if (i > WEP_KEYS)
3189 return -EINVAL;
3190 if (i < 1 || i > WEP_KEYS)
3191 i = local->crypt_info.tx_keyidx;
3192 else
3193 i--;
3194 if (i < 0 || i >= WEP_KEYS)
3195 return -EINVAL;
3196
3197 addr = ext->addr.sa_data;
3198 if (addr[0] == 0xff && addr[1] == 0xff && addr[2] == 0xff &&
3199 addr[3] == 0xff && addr[4] == 0xff && addr[5] == 0xff) {
3200 sta_ptr = NULL;
3201 crypt = &local->crypt_info.crypt[i];
3202 } else {
3203 if (i != 0)
3204 return -EINVAL;
3205 sta_ptr = ap_crypt_get_ptrs(local->ap, addr, 0, &crypt);
3206 if (sta_ptr == NULL) {
3207 if (local->iw_mode == IW_MODE_INFRA) {
3208 /*
3209 * TODO: add STA entry for the current AP so
3210 * that unicast key can be used. For now, this
3211 * is emulated by using default key idx 0.
3212 */
3213 i = 0;
3214 crypt = &local->crypt_info.crypt[i];
3215 } else
3216 return -EINVAL;
3217 }
3218 }
3219
3220 if ((erq->flags & IW_ENCODE_DISABLED) ||
3221 ext->alg == IW_ENCODE_ALG_NONE) {
3222 if (*crypt)
3223 lib80211_crypt_delayed_deinit(&local->crypt_info, crypt);
3224 goto done;
3225 }
3226
3227 switch (ext->alg) {
3228 case IW_ENCODE_ALG_WEP:
3229 alg = "WEP";
3230 module = "lib80211_crypt_wep";
3231 break;
3232 case IW_ENCODE_ALG_TKIP:
3233 alg = "TKIP";
3234 module = "lib80211_crypt_tkip";
3235 break;
3236 case IW_ENCODE_ALG_CCMP:
3237 alg = "CCMP";
3238 module = "lib80211_crypt_ccmp";
3239 break;
3240 default:
3241 printk(KERN_DEBUG "%s: unsupported algorithm %d\n",
3242 local->dev->name, ext->alg);
3243 ret = -EOPNOTSUPP;
3244 goto done;
3245 }
3246
3247 ops = lib80211_get_crypto_ops(alg);
3248 if (ops == NULL) {
3249 request_module(module);
3250 ops = lib80211_get_crypto_ops(alg);
3251 }
3252 if (ops == NULL) {
3253 printk(KERN_DEBUG "%s: unknown crypto alg '%s'\n",
3254 local->dev->name, alg);
3255 ret = -EOPNOTSUPP;
3256 goto done;
3257 }
3258
3259 if (sta_ptr || ext->alg != IW_ENCODE_ALG_WEP) {
3260 /*
3261 * Per station encryption and other than WEP algorithms
3262 * require host-based encryption, so force them on
3263 * automatically.
3264 */
3265 local->host_decrypt = local->host_encrypt = 1;
3266 }
3267
3268 if (*crypt == NULL || (*crypt)->ops != ops) {
3269 struct lib80211_crypt_data *new_crypt;
3270
3271 lib80211_crypt_delayed_deinit(&local->crypt_info, crypt);
3272
3273 new_crypt = kzalloc(sizeof(struct lib80211_crypt_data),
3274 GFP_KERNEL);
3275 if (new_crypt == NULL) {
3276 ret = -ENOMEM;
3277 goto done;
3278 }
3279 new_crypt->ops = ops;
3280 if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
3281 new_crypt->priv = new_crypt->ops->init(i);
3282 if (new_crypt->priv == NULL) {
3283 kfree(new_crypt);
3284 ret = -EINVAL;
3285 goto done;
3286 }
3287
3288 *crypt = new_crypt;
3289 }
3290
3291 /*
3292 * TODO: if ext_flags does not have IW_ENCODE_EXT_RX_SEQ_VALID, the
3293 * existing seq# should not be changed.
3294 * TODO: if ext_flags has IW_ENCODE_EXT_TX_SEQ_VALID, next TX seq#
3295 * should be changed to something else than zero.
3296 */
3297 if ((!(ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) || ext->key_len > 0)
3298 && (*crypt)->ops->set_key &&
3299 (*crypt)->ops->set_key(ext->key, ext->key_len, ext->rx_seq,
3300 (*crypt)->priv) < 0) {
3301 printk(KERN_DEBUG "%s: key setting failed\n",
3302 local->dev->name);
3303 ret = -EINVAL;
3304 goto done;
3305 }
3306
3307 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
3308 if (!sta_ptr)
3309 local->crypt_info.tx_keyidx = i;
3310 }
3311
3312
3313 if (sta_ptr == NULL && ext->key_len > 0) {
3314 int first = 1, j;
3315 for (j = 0; j < WEP_KEYS; j++) {
3316 if (j != i && local->crypt_info.crypt[j]) {
3317 first = 0;
3318 break;
3319 }
3320 }
3321 if (first)
3322 local->crypt_info.tx_keyidx = i;
3323 }
3324
3325 done:
3326 if (sta_ptr)
3327 hostap_handle_sta_release(sta_ptr);
3328
3329 local->open_wep = erq->flags & IW_ENCODE_OPEN;
3330
3331 /*
3332 * Do not reset port0 if card is in Managed mode since resetting will
3333 * generate new IEEE 802.11 authentication which may end up in looping
3334 * with IEEE 802.1X. Prism2 documentation seem to require port reset
3335 * after WEP configuration. However, keys are apparently changed at
3336 * least in Managed mode.
3337 */
3338 if (ret == 0 &&
3339 (hostap_set_encryption(local) ||
3340 (local->iw_mode != IW_MODE_INFRA &&
3341 local->func->reset_port(local->dev))))
3342 ret = -EINVAL;
3343
3344 return ret;
3345 }
3346
3347
3348 static int prism2_ioctl_giwencodeext(struct net_device *dev,
3349 struct iw_request_info *info,
3350 struct iw_point *erq, char *extra)
3351 {
3352 struct hostap_interface *iface = netdev_priv(dev);
3353 local_info_t *local = iface->local;
3354 struct lib80211_crypt_data **crypt;
3355 void *sta_ptr;
3356 int max_key_len, i;
3357 struct iw_encode_ext *ext = (struct iw_encode_ext *) extra;
3358 u8 *addr;
3359
3360 max_key_len = erq->length - sizeof(*ext);
3361 if (max_key_len < 0)
3362 return -EINVAL;
3363
3364 i = erq->flags & IW_ENCODE_INDEX;
3365 if (i < 1 || i > WEP_KEYS)
3366 i = local->crypt_info.tx_keyidx;
3367 else
3368 i--;
3369
3370 addr = ext->addr.sa_data;
3371 if (addr[0] == 0xff && addr[1] == 0xff && addr[2] == 0xff &&
3372 addr[3] == 0xff && addr[4] == 0xff && addr[5] == 0xff) {
3373 sta_ptr = NULL;
3374 crypt = &local->crypt_info.crypt[i];
3375 } else {
3376 i = 0;
3377 sta_ptr = ap_crypt_get_ptrs(local->ap, addr, 0, &crypt);
3378 if (sta_ptr == NULL)
3379 return -EINVAL;
3380 }
3381 erq->flags = i + 1;
3382 memset(ext, 0, sizeof(*ext));
3383
3384 if (*crypt == NULL || (*crypt)->ops == NULL) {
3385 ext->alg = IW_ENCODE_ALG_NONE;
3386 ext->key_len = 0;
3387 erq->flags |= IW_ENCODE_DISABLED;
3388 } else {
3389 if (strcmp((*crypt)->ops->name, "WEP") == 0)
3390 ext->alg = IW_ENCODE_ALG_WEP;
3391 else if (strcmp((*crypt)->ops->name, "TKIP") == 0)
3392 ext->alg = IW_ENCODE_ALG_TKIP;
3393 else if (strcmp((*crypt)->ops->name, "CCMP") == 0)
3394 ext->alg = IW_ENCODE_ALG_CCMP;
3395 else
3396 return -EINVAL;
3397
3398 if ((*crypt)->ops->get_key) {
3399 ext->key_len =
3400 (*crypt)->ops->get_key(ext->key,
3401 max_key_len,
3402 ext->tx_seq,
3403 (*crypt)->priv);
3404 if (ext->key_len &&
3405 (ext->alg == IW_ENCODE_ALG_TKIP ||
3406 ext->alg == IW_ENCODE_ALG_CCMP))
3407 ext->ext_flags |= IW_ENCODE_EXT_TX_SEQ_VALID;
3408 }
3409 }
3410
3411 if (sta_ptr)
3412 hostap_handle_sta_release(sta_ptr);
3413
3414 return 0;
3415 }
3416
3417
3418 static int prism2_ioctl_set_encryption(local_info_t *local,
3419 struct prism2_hostapd_param *param,
3420 int param_len)
3421 {
3422 int ret = 0;
3423 struct lib80211_crypto_ops *ops;
3424 struct lib80211_crypt_data **crypt;
3425 void *sta_ptr;
3426
3427 param->u.crypt.err = 0;
3428 param->u.crypt.alg[HOSTAP_CRYPT_ALG_NAME_LEN - 1] = '\0';
3429
3430 if (param_len !=
3431 (int) ((char *) param->u.crypt.key - (char *) param) +
3432 param->u.crypt.key_len)
3433 return -EINVAL;
3434
3435 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
3436 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
3437 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
3438 if (param->u.crypt.idx >= WEP_KEYS)
3439 return -EINVAL;
3440 sta_ptr = NULL;
3441 crypt = &local->crypt_info.crypt[param->u.crypt.idx];
3442 } else {
3443 if (param->u.crypt.idx)
3444 return -EINVAL;
3445 sta_ptr = ap_crypt_get_ptrs(
3446 local->ap, param->sta_addr,
3447 (param->u.crypt.flags & HOSTAP_CRYPT_FLAG_PERMANENT),
3448 &crypt);
3449
3450 if (sta_ptr == NULL) {
3451 param->u.crypt.err = HOSTAP_CRYPT_ERR_UNKNOWN_ADDR;
3452 return -EINVAL;
3453 }
3454 }
3455
3456 if (strcmp(param->u.crypt.alg, "none") == 0) {
3457 if (crypt)
3458 lib80211_crypt_delayed_deinit(&local->crypt_info, crypt);
3459 goto done;
3460 }
3461
3462 ops = lib80211_get_crypto_ops(param->u.crypt.alg);
3463 if (ops == NULL && strcmp(param->u.crypt.alg, "WEP") == 0) {
3464 request_module("lib80211_crypt_wep");
3465 ops = lib80211_get_crypto_ops(param->u.crypt.alg);
3466 } else if (ops == NULL && strcmp(param->u.crypt.alg, "TKIP") == 0) {
3467 request_module("lib80211_crypt_tkip");
3468 ops = lib80211_get_crypto_ops(param->u.crypt.alg);
3469 } else if (ops == NULL && strcmp(param->u.crypt.alg, "CCMP") == 0) {
3470 request_module("lib80211_crypt_ccmp");
3471 ops = lib80211_get_crypto_ops(param->u.crypt.alg);
3472 }
3473 if (ops == NULL) {
3474 printk(KERN_DEBUG "%s: unknown crypto alg '%s'\n",
3475 local->dev->name, param->u.crypt.alg);
3476 param->u.crypt.err = HOSTAP_CRYPT_ERR_UNKNOWN_ALG;
3477 ret = -EINVAL;
3478 goto done;
3479 }
3480
3481 /* station based encryption and other than WEP algorithms require
3482 * host-based encryption, so force them on automatically */
3483 local->host_decrypt = local->host_encrypt = 1;
3484
3485 if (*crypt == NULL || (*crypt)->ops != ops) {
3486 struct lib80211_crypt_data *new_crypt;
3487
3488 lib80211_crypt_delayed_deinit(&local->crypt_info, crypt);
3489
3490 new_crypt = kzalloc(sizeof(struct lib80211_crypt_data),
3491 GFP_KERNEL);
3492 if (new_crypt == NULL) {
3493 ret = -ENOMEM;
3494 goto done;
3495 }
3496 new_crypt->ops = ops;
3497 new_crypt->priv = new_crypt->ops->init(param->u.crypt.idx);
3498 if (new_crypt->priv == NULL) {
3499 kfree(new_crypt);
3500 param->u.crypt.err =
3501 HOSTAP_CRYPT_ERR_CRYPT_INIT_FAILED;
3502 ret = -EINVAL;
3503 goto done;
3504 }
3505
3506 *crypt = new_crypt;
3507 }
3508
3509 if ((!(param->u.crypt.flags & HOSTAP_CRYPT_FLAG_SET_TX_KEY) ||
3510 param->u.crypt.key_len > 0) && (*crypt)->ops->set_key &&
3511 (*crypt)->ops->set_key(param->u.crypt.key,
3512 param->u.crypt.key_len, param->u.crypt.seq,
3513 (*crypt)->priv) < 0) {
3514 printk(KERN_DEBUG "%s: key setting failed\n",
3515 local->dev->name);
3516 param->u.crypt.err = HOSTAP_CRYPT_ERR_KEY_SET_FAILED;
3517 ret = -EINVAL;
3518 goto done;
3519 }
3520
3521 if (param->u.crypt.flags & HOSTAP_CRYPT_FLAG_SET_TX_KEY) {
3522 if (!sta_ptr)
3523 local->crypt_info.tx_keyidx = param->u.crypt.idx;
3524 else if (param->u.crypt.idx) {
3525 printk(KERN_DEBUG "%s: TX key idx setting failed\n",
3526 local->dev->name);
3527 param->u.crypt.err =
3528 HOSTAP_CRYPT_ERR_TX_KEY_SET_FAILED;
3529 ret = -EINVAL;
3530 goto done;
3531 }
3532 }
3533
3534 done:
3535 if (sta_ptr)
3536 hostap_handle_sta_release(sta_ptr);
3537
3538 /* Do not reset port0 if card is in Managed mode since resetting will
3539 * generate new IEEE 802.11 authentication which may end up in looping
3540 * with IEEE 802.1X. Prism2 documentation seem to require port reset
3541 * after WEP configuration. However, keys are apparently changed at
3542 * least in Managed mode. */
3543 if (ret == 0 &&
3544 (hostap_set_encryption(local) ||
3545 (local->iw_mode != IW_MODE_INFRA &&
3546 local->func->reset_port(local->dev)))) {
3547 param->u.crypt.err = HOSTAP_CRYPT_ERR_CARD_CONF_FAILED;
3548 return -EINVAL;
3549 }
3550
3551 return ret;
3552 }
3553
3554
3555 static int prism2_ioctl_get_encryption(local_info_t *local,
3556 struct prism2_hostapd_param *param,
3557 int param_len)
3558 {
3559 struct lib80211_crypt_data **crypt;
3560 void *sta_ptr;
3561 int max_key_len;
3562
3563 param->u.crypt.err = 0;
3564
3565 max_key_len = param_len -
3566 (int) ((char *) param->u.crypt.key - (char *) param);
3567 if (max_key_len < 0)
3568 return -EINVAL;
3569
3570 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
3571 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
3572 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
3573 sta_ptr = NULL;
3574 if (param->u.crypt.idx >= WEP_KEYS)
3575 param->u.crypt.idx = local->crypt_info.tx_keyidx;
3576 crypt = &local->crypt_info.crypt[param->u.crypt.idx];
3577 } else {
3578 param->u.crypt.idx = 0;
3579 sta_ptr = ap_crypt_get_ptrs(local->ap, param->sta_addr, 0,
3580 &crypt);
3581
3582 if (sta_ptr == NULL) {
3583 param->u.crypt.err = HOSTAP_CRYPT_ERR_UNKNOWN_ADDR;
3584 return -EINVAL;
3585 }
3586 }
3587
3588 if (*crypt == NULL || (*crypt)->ops == NULL) {
3589 memcpy(param->u.crypt.alg, "none", 5);
3590 param->u.crypt.key_len = 0;
3591 param->u.crypt.idx = 0xff;
3592 } else {
3593 strncpy(param->u.crypt.alg, (*crypt)->ops->name,
3594 HOSTAP_CRYPT_ALG_NAME_LEN);
3595 param->u.crypt.key_len = 0;
3596
3597 memset(param->u.crypt.seq, 0, 8);
3598 if ((*crypt)->ops->get_key) {
3599 param->u.crypt.key_len =
3600 (*crypt)->ops->get_key(param->u.crypt.key,
3601 max_key_len,
3602 param->u.crypt.seq,
3603 (*crypt)->priv);
3604 }
3605 }
3606
3607 if (sta_ptr)
3608 hostap_handle_sta_release(sta_ptr);
3609
3610 return 0;
3611 }
3612
3613
3614 static int prism2_ioctl_get_rid(local_info_t *local,
3615 struct prism2_hostapd_param *param,
3616 int param_len)
3617 {
3618 int max_len, res;
3619
3620 max_len = param_len - PRISM2_HOSTAPD_RID_HDR_LEN;
3621 if (max_len < 0)
3622 return -EINVAL;
3623
3624 res = local->func->get_rid(local->dev, param->u.rid.rid,
3625 param->u.rid.data, param->u.rid.len, 0);
3626 if (res >= 0) {
3627 param->u.rid.len = res;
3628 return 0;
3629 }
3630
3631 return res;
3632 }
3633
3634
3635 static int prism2_ioctl_set_rid(local_info_t *local,
3636 struct prism2_hostapd_param *param,
3637 int param_len)
3638 {
3639 int max_len;
3640
3641 max_len = param_len - PRISM2_HOSTAPD_RID_HDR_LEN;
3642 if (max_len < 0 || max_len < param->u.rid.len)
3643 return -EINVAL;
3644
3645 return local->func->set_rid(local->dev, param->u.rid.rid,
3646 param->u.rid.data, param->u.rid.len);
3647 }
3648
3649
3650 static int prism2_ioctl_set_assoc_ap_addr(local_info_t *local,
3651 struct prism2_hostapd_param *param,
3652 int param_len)
3653 {
3654 printk(KERN_DEBUG "%ssta: associated as client with AP %pM\n",
3655 local->dev->name, param->sta_addr);
3656 memcpy(local->assoc_ap_addr, param->sta_addr, ETH_ALEN);
3657 return 0;
3658 }
3659
3660
3661 static int prism2_ioctl_siwgenie(struct net_device *dev,
3662 struct iw_request_info *info,
3663 struct iw_point *data, char *extra)
3664 {
3665 return prism2_set_genericelement(dev, extra, data->length);
3666 }
3667
3668
3669 static int prism2_ioctl_giwgenie(struct net_device *dev,
3670 struct iw_request_info *info,
3671 struct iw_point *data, char *extra)
3672 {
3673 struct hostap_interface *iface = netdev_priv(dev);
3674 local_info_t *local = iface->local;
3675 int len = local->generic_elem_len - 2;
3676
3677 if (len <= 0 || local->generic_elem == NULL) {
3678 data->length = 0;
3679 return 0;
3680 }
3681
3682 if (data->length < len)
3683 return -E2BIG;
3684
3685 data->length = len;
3686 memcpy(extra, local->generic_elem + 2, len);
3687
3688 return 0;
3689 }
3690
3691
3692 static int prism2_ioctl_set_generic_element(local_info_t *local,
3693 struct prism2_hostapd_param *param,
3694 int param_len)
3695 {
3696 int max_len, len;
3697
3698 len = param->u.generic_elem.len;
3699 max_len = param_len - PRISM2_HOSTAPD_GENERIC_ELEMENT_HDR_LEN;
3700 if (max_len < 0 || max_len < len)
3701 return -EINVAL;
3702
3703 return prism2_set_genericelement(local->dev,
3704 param->u.generic_elem.data, len);
3705 }
3706
3707
3708 static int prism2_ioctl_siwmlme(struct net_device *dev,
3709 struct iw_request_info *info,
3710 struct iw_point *data, char *extra)
3711 {
3712 struct hostap_interface *iface = netdev_priv(dev);
3713 local_info_t *local = iface->local;
3714 struct iw_mlme *mlme = (struct iw_mlme *) extra;
3715 __le16 reason;
3716
3717 reason = cpu_to_le16(mlme->reason_code);
3718
3719 switch (mlme->cmd) {
3720 case IW_MLME_DEAUTH:
3721 return prism2_sta_send_mgmt(local, mlme->addr.sa_data,
3722 IEEE80211_STYPE_DEAUTH,
3723 (u8 *) &reason, 2);
3724 case IW_MLME_DISASSOC:
3725 return prism2_sta_send_mgmt(local, mlme->addr.sa_data,
3726 IEEE80211_STYPE_DISASSOC,
3727 (u8 *) &reason, 2);
3728 default:
3729 return -EOPNOTSUPP;
3730 }
3731 }
3732
3733
3734 static int prism2_ioctl_mlme(local_info_t *local,
3735 struct prism2_hostapd_param *param)
3736 {
3737 __le16 reason;
3738
3739 reason = cpu_to_le16(param->u.mlme.reason_code);
3740 switch (param->u.mlme.cmd) {
3741 case MLME_STA_DEAUTH:
3742 return prism2_sta_send_mgmt(local, param->sta_addr,
3743 IEEE80211_STYPE_DEAUTH,
3744 (u8 *) &reason, 2);
3745 case MLME_STA_DISASSOC:
3746 return prism2_sta_send_mgmt(local, param->sta_addr,
3747 IEEE80211_STYPE_DISASSOC,
3748 (u8 *) &reason, 2);
3749 default:
3750 return -EOPNOTSUPP;
3751 }
3752 }
3753
3754
3755 static int prism2_ioctl_scan_req(local_info_t *local,
3756 struct prism2_hostapd_param *param)
3757 {
3758 #ifndef PRISM2_NO_STATION_MODES
3759 if ((local->iw_mode != IW_MODE_INFRA &&
3760 local->iw_mode != IW_MODE_ADHOC) ||
3761 (local->sta_fw_ver < PRISM2_FW_VER(1,3,1)))
3762 return -EOPNOTSUPP;
3763
3764 if (!local->dev_enabled)
3765 return -ENETDOWN;
3766
3767 return prism2_request_hostscan(local->dev, param->u.scan_req.ssid,
3768 param->u.scan_req.ssid_len);
3769 #else /* PRISM2_NO_STATION_MODES */
3770 return -EOPNOTSUPP;
3771 #endif /* PRISM2_NO_STATION_MODES */
3772 }
3773
3774
3775 static int prism2_ioctl_priv_hostapd(local_info_t *local, struct iw_point *p)
3776 {
3777 struct prism2_hostapd_param *param;
3778 int ret = 0;
3779 int ap_ioctl = 0;
3780
3781 if (p->length < sizeof(struct prism2_hostapd_param) ||
3782 p->length > PRISM2_HOSTAPD_MAX_BUF_SIZE || !p->pointer)
3783 return -EINVAL;
3784
3785 param = kmalloc(p->length, GFP_KERNEL);
3786 if (param == NULL)
3787 return -ENOMEM;
3788
3789 if (copy_from_user(param, p->pointer, p->length)) {
3790 ret = -EFAULT;
3791 goto out;
3792 }
3793
3794 switch (param->cmd) {
3795 case PRISM2_SET_ENCRYPTION:
3796 ret = prism2_ioctl_set_encryption(local, param, p->length);
3797 break;
3798 case PRISM2_GET_ENCRYPTION:
3799 ret = prism2_ioctl_get_encryption(local, param, p->length);
3800 break;
3801 case PRISM2_HOSTAPD_GET_RID:
3802 ret = prism2_ioctl_get_rid(local, param, p->length);
3803 break;
3804 case PRISM2_HOSTAPD_SET_RID:
3805 ret = prism2_ioctl_set_rid(local, param, p->length);
3806 break;
3807 case PRISM2_HOSTAPD_SET_ASSOC_AP_ADDR:
3808 ret = prism2_ioctl_set_assoc_ap_addr(local, param, p->length);
3809 break;
3810 case PRISM2_HOSTAPD_SET_GENERIC_ELEMENT:
3811 ret = prism2_ioctl_set_generic_element(local, param,
3812 p->length);
3813 break;
3814 case PRISM2_HOSTAPD_MLME:
3815 ret = prism2_ioctl_mlme(local, param);
3816 break;
3817 case PRISM2_HOSTAPD_SCAN_REQ:
3818 ret = prism2_ioctl_scan_req(local, param);
3819 break;
3820 default:
3821 ret = prism2_hostapd(local->ap, param);
3822 ap_ioctl = 1;
3823 break;
3824 }
3825
3826 if (ret == 1 || !ap_ioctl) {
3827 if (copy_to_user(p->pointer, param, p->length)) {
3828 ret = -EFAULT;
3829 goto out;
3830 } else if (ap_ioctl)
3831 ret = 0;
3832 }
3833
3834 out:
3835 kfree(param);
3836 return ret;
3837 }
3838
3839
3840 static void prism2_get_drvinfo(struct net_device *dev,
3841 struct ethtool_drvinfo *info)
3842 {
3843 struct hostap_interface *iface;
3844 local_info_t *local;
3845
3846 iface = netdev_priv(dev);
3847 local = iface->local;
3848
3849 strncpy(info->driver, "hostap", sizeof(info->driver) - 1);
3850 snprintf(info->fw_version, sizeof(info->fw_version) - 1,
3851 "%d.%d.%d", (local->sta_fw_ver >> 16) & 0xff,
3852 (local->sta_fw_ver >> 8) & 0xff,
3853 local->sta_fw_ver & 0xff);
3854 }
3855
3856 const struct ethtool_ops prism2_ethtool_ops = {
3857 .get_drvinfo = prism2_get_drvinfo
3858 };
3859
3860
3861 /* Structures to export the Wireless Handlers */
3862
3863 static const iw_handler prism2_handler[] =
3864 {
3865 (iw_handler) NULL, /* SIOCSIWCOMMIT */
3866 (iw_handler) prism2_get_name, /* SIOCGIWNAME */
3867 (iw_handler) NULL, /* SIOCSIWNWID */
3868 (iw_handler) NULL, /* SIOCGIWNWID */
3869 (iw_handler) prism2_ioctl_siwfreq, /* SIOCSIWFREQ */
3870 (iw_handler) prism2_ioctl_giwfreq, /* SIOCGIWFREQ */
3871 (iw_handler) prism2_ioctl_siwmode, /* SIOCSIWMODE */
3872 (iw_handler) prism2_ioctl_giwmode, /* SIOCGIWMODE */
3873 (iw_handler) prism2_ioctl_siwsens, /* SIOCSIWSENS */
3874 (iw_handler) prism2_ioctl_giwsens, /* SIOCGIWSENS */
3875 (iw_handler) NULL /* not used */, /* SIOCSIWRANGE */
3876 (iw_handler) prism2_ioctl_giwrange, /* SIOCGIWRANGE */
3877 (iw_handler) NULL /* not used */, /* SIOCSIWPRIV */
3878 (iw_handler) NULL /* kernel code */, /* SIOCGIWPRIV */
3879 (iw_handler) NULL /* not used */, /* SIOCSIWSTATS */
3880 (iw_handler) NULL /* kernel code */, /* SIOCGIWSTATS */
3881 iw_handler_set_spy, /* SIOCSIWSPY */
3882 iw_handler_get_spy, /* SIOCGIWSPY */
3883 iw_handler_set_thrspy, /* SIOCSIWTHRSPY */
3884 iw_handler_get_thrspy, /* SIOCGIWTHRSPY */
3885 (iw_handler) prism2_ioctl_siwap, /* SIOCSIWAP */
3886 (iw_handler) prism2_ioctl_giwap, /* SIOCGIWAP */
3887 (iw_handler) prism2_ioctl_siwmlme, /* SIOCSIWMLME */
3888 (iw_handler) prism2_ioctl_giwaplist, /* SIOCGIWAPLIST */
3889 (iw_handler) prism2_ioctl_siwscan, /* SIOCSIWSCAN */
3890 (iw_handler) prism2_ioctl_giwscan, /* SIOCGIWSCAN */
3891 (iw_handler) prism2_ioctl_siwessid, /* SIOCSIWESSID */
3892 (iw_handler) prism2_ioctl_giwessid, /* SIOCGIWESSID */
3893 (iw_handler) prism2_ioctl_siwnickn, /* SIOCSIWNICKN */
3894 (iw_handler) prism2_ioctl_giwnickn, /* SIOCGIWNICKN */
3895 (iw_handler) NULL, /* -- hole -- */
3896 (iw_handler) NULL, /* -- hole -- */
3897 (iw_handler) prism2_ioctl_siwrate, /* SIOCSIWRATE */
3898 (iw_handler) prism2_ioctl_giwrate, /* SIOCGIWRATE */
3899 (iw_handler) prism2_ioctl_siwrts, /* SIOCSIWRTS */
3900 (iw_handler) prism2_ioctl_giwrts, /* SIOCGIWRTS */
3901 (iw_handler) prism2_ioctl_siwfrag, /* SIOCSIWFRAG */
3902 (iw_handler) prism2_ioctl_giwfrag, /* SIOCGIWFRAG */
3903 (iw_handler) prism2_ioctl_siwtxpow, /* SIOCSIWTXPOW */
3904 (iw_handler) prism2_ioctl_giwtxpow, /* SIOCGIWTXPOW */
3905 (iw_handler) prism2_ioctl_siwretry, /* SIOCSIWRETRY */
3906 (iw_handler) prism2_ioctl_giwretry, /* SIOCGIWRETRY */
3907 (iw_handler) prism2_ioctl_siwencode, /* SIOCSIWENCODE */
3908 (iw_handler) prism2_ioctl_giwencode, /* SIOCGIWENCODE */
3909 (iw_handler) prism2_ioctl_siwpower, /* SIOCSIWPOWER */
3910 (iw_handler) prism2_ioctl_giwpower, /* SIOCGIWPOWER */
3911 (iw_handler) NULL, /* -- hole -- */
3912 (iw_handler) NULL, /* -- hole -- */
3913 (iw_handler) prism2_ioctl_siwgenie, /* SIOCSIWGENIE */
3914 (iw_handler) prism2_ioctl_giwgenie, /* SIOCGIWGENIE */
3915 (iw_handler) prism2_ioctl_siwauth, /* SIOCSIWAUTH */
3916 (iw_handler) prism2_ioctl_giwauth, /* SIOCGIWAUTH */
3917 (iw_handler) prism2_ioctl_siwencodeext, /* SIOCSIWENCODEEXT */
3918 (iw_handler) prism2_ioctl_giwencodeext, /* SIOCGIWENCODEEXT */
3919 (iw_handler) NULL, /* SIOCSIWPMKSA */
3920 (iw_handler) NULL, /* -- hole -- */
3921 };
3922
3923 static const iw_handler prism2_private_handler[] =
3924 { /* SIOCIWFIRSTPRIV + */
3925 (iw_handler) prism2_ioctl_priv_prism2_param, /* 0 */
3926 (iw_handler) prism2_ioctl_priv_get_prism2_param, /* 1 */
3927 (iw_handler) prism2_ioctl_priv_writemif, /* 2 */
3928 (iw_handler) prism2_ioctl_priv_readmif, /* 3 */
3929 };
3930
3931 const struct iw_handler_def hostap_iw_handler_def =
3932 {
3933 .num_standard = ARRAY_SIZE(prism2_handler),
3934 .num_private = ARRAY_SIZE(prism2_private_handler),
3935 .num_private_args = ARRAY_SIZE(prism2_priv),
3936 .standard = (iw_handler *) prism2_handler,
3937 .private = (iw_handler *) prism2_private_handler,
3938 .private_args = (struct iw_priv_args *) prism2_priv,
3939 .get_wireless_stats = hostap_get_wireless_stats,
3940 };
3941
3942
3943 int hostap_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
3944 {
3945 struct iwreq *wrq = (struct iwreq *) ifr;
3946 struct hostap_interface *iface;
3947 local_info_t *local;
3948 int ret = 0;
3949
3950 iface = netdev_priv(dev);
3951 local = iface->local;
3952
3953 switch (cmd) {
3954 /* Private ioctls (iwpriv) that have not yet been converted
3955 * into new wireless extensions API */
3956
3957 case PRISM2_IOCTL_INQUIRE:
3958 if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
3959 else ret = prism2_ioctl_priv_inquire(dev, (int *) wrq->u.name);
3960 break;
3961
3962 case PRISM2_IOCTL_MONITOR:
3963 if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
3964 else ret = prism2_ioctl_priv_monitor(dev, (int *) wrq->u.name);
3965 break;
3966
3967 case PRISM2_IOCTL_RESET:
3968 if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
3969 else ret = prism2_ioctl_priv_reset(dev, (int *) wrq->u.name);
3970 break;
3971
3972 case PRISM2_IOCTL_WDS_ADD:
3973 if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
3974 else ret = prism2_wds_add(local, wrq->u.ap_addr.sa_data, 1);
3975 break;
3976
3977 case PRISM2_IOCTL_WDS_DEL:
3978 if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
3979 else ret = prism2_wds_del(local, wrq->u.ap_addr.sa_data, 1, 0);
3980 break;
3981
3982 case PRISM2_IOCTL_SET_RID_WORD:
3983 if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
3984 else ret = prism2_ioctl_priv_set_rid_word(dev,
3985 (int *) wrq->u.name);
3986 break;
3987
3988 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
3989 case PRISM2_IOCTL_MACCMD:
3990 if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
3991 else ret = ap_mac_cmd_ioctl(local, (int *) wrq->u.name);
3992 break;
3993
3994 case PRISM2_IOCTL_ADDMAC:
3995 if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
3996 else ret = ap_control_add_mac(&local->ap->mac_restrictions,
3997 wrq->u.ap_addr.sa_data);
3998 break;
3999 case PRISM2_IOCTL_DELMAC:
4000 if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
4001 else ret = ap_control_del_mac(&local->ap->mac_restrictions,
4002 wrq->u.ap_addr.sa_data);
4003 break;
4004 case PRISM2_IOCTL_KICKMAC:
4005 if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
4006 else ret = ap_control_kick_mac(local->ap, local->dev,
4007 wrq->u.ap_addr.sa_data);
4008 break;
4009 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
4010
4011
4012 /* Private ioctls that are not used with iwpriv;
4013 * in SIOCDEVPRIVATE range */
4014
4015 #ifdef PRISM2_DOWNLOAD_SUPPORT
4016 case PRISM2_IOCTL_DOWNLOAD:
4017 if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
4018 else ret = prism2_ioctl_priv_download(local, &wrq->u.data);
4019 break;
4020 #endif /* PRISM2_DOWNLOAD_SUPPORT */
4021
4022 case PRISM2_IOCTL_HOSTAPD:
4023 if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
4024 else ret = prism2_ioctl_priv_hostapd(local, &wrq->u.data);
4025 break;
4026
4027 default:
4028 ret = -EOPNOTSUPP;
4029 break;
4030 }
4031
4032 return ret;
4033 }
Tomato firmware and modifications.