?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
3w-xxxx: scsi_dma_unmap fix
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / staging / wlan-ng / p80211wext.c
blob0d570f1f378cd2274df70c0a43c596e5de686e27
1 /* src/p80211/p80211wext.c
2 *
3 * Glue code to make linux-wlan-ng a happy wireless extension camper.
4 *
5 * original author: Reyk Floeter <reyk@synack.de>
6 * Completely re-written by Solomon Peachy <solomon@linux-wlan.com>
7 *
8 * Copyright (C) 2002 AbsoluteValue Systems, Inc. All Rights Reserved.
9 * --------------------------------------------------------------------
10 *
11 * linux-wlan
12 *
13 * The contents of this file are subject to the Mozilla Public
14 * License Version 1.1 (the "License"); you may not use this file
15 * except in compliance with the License. You may obtain a copy of
16 * the License at http://www.mozilla.org/MPL/
17 *
18 * Software distributed under the License is distributed on an "AS
19 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
20 * implied. See the License for the specific language governing
21 * rights and limitations under the License.
22 *
23 * Alternatively, the contents of this file may be used under the
24 * terms of the GNU Public License version 2 (the "GPL"), in which
25 * case the provisions of the GPL are applicable instead of the
26 * above. If you wish to allow the use of your version of this file
27 * only under the terms of the GPL and not to allow others to use
28 * your version of this file under the MPL, indicate your decision
29 * by deleting the provisions above and replace them with the notice
30 * and other provisions required by the GPL. If you do not delete
31 * the provisions above, a recipient may use your version of this
32 * file under either the MPL or the GPL.
33 *
34 * --------------------------------------------------------------------
35 */
36
37 /*================================================================*/
38 /* System Includes */
39
40
41
42 #include <linux/kernel.h>
43 #include <linux/sched.h>
44 #include <linux/types.h>
45 #include <linux/slab.h>
46 #include <linux/netdevice.h>
47 #include <linux/etherdevice.h>
48 #include <linux/wireless.h>
49 #include <net/iw_handler.h>
50 #include <linux/if_arp.h>
51 #include <asm/bitops.h>
52 #include <asm/uaccess.h>
53 #include <asm/byteorder.h>
54
55 /*================================================================*/
56 /* Project Includes */
57
58 #include "wlan_compat.h"
59
60 #include "p80211types.h"
61 #include "p80211hdr.h"
62 #include "p80211conv.h"
63 #include "p80211mgmt.h"
64 #include "p80211msg.h"
65 #include "p80211metastruct.h"
66 #include "p80211metadef.h"
67 #include "p80211netdev.h"
68 #include "p80211ioctl.h"
69 #include "p80211req.h"
70
71 static int p80211wext_giwrate(netdevice_t *dev,
72 struct iw_request_info *info,
73 struct iw_param *rrq, char *extra);
74 static int p80211wext_giwessid(netdevice_t *dev,
75 struct iw_request_info *info,
76 struct iw_point *data, char *essid);
77
78 static u8 p80211_mhz_to_channel(u16 mhz)
79 {
80 if (mhz >= 5000) {
81 return ((mhz - 5000) / 5);
82 }
83
84 if (mhz == 2482)
85 return 14;
86
87 if (mhz >= 2407) {
88 return ((mhz - 2407) / 5);
89 }
90
91 return 0;
92 }
93
94 static u16 p80211_channel_to_mhz(u8 ch, int dot11a)
95 {
96
97 if (ch == 0)
98 return 0;
99 if (ch > 200)
100 return 0;
101
102 /* 5G */
103
104 if (dot11a) {
105 return (5000 + (5 * ch));
106 }
107
108 /* 2.4G */
109
110 if (ch == 14)
111 return 2484;
112
113 if ((ch < 14) && (ch > 0)) {
114 return (2407 + (5 * ch));
115 }
116
117 return 0;
118 }
119
120 /* taken from orinoco.c ;-) */
121 static const long p80211wext_channel_freq[] = {
122 2412, 2417, 2422, 2427, 2432, 2437, 2442,
123 2447, 2452, 2457, 2462, 2467, 2472, 2484
124 };
125 #define NUM_CHANNELS ARRAY_SIZE(p80211wext_channel_freq)
126
127 /* steal a spare bit to store the shared/opensystems state. should default to open if not set */
128 #define HOSTWEP_SHAREDKEY BIT3
129
130
131 /** function declarations =============== */
132
133 static int qual_as_percent(int snr ) {
134 if ( snr <= 0 )
135 return 0;
136 if ( snr <= 40 )
137 return snr*5/2;
138 return 100;
139 }
140
141
142
143
144 static int p80211wext_dorequest(wlandevice_t *wlandev, u32 did, u32 data)
145 {
146 p80211msg_dot11req_mibset_t msg;
147 p80211item_uint32_t mibitem;
148 int result;
149
150 DBFENTER;
151
152 msg.msgcode = DIDmsg_dot11req_mibset;
153 mibitem.did = did;
154 mibitem.data = data;
155 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
156 result = p80211req_dorequest(wlandev, (u8*)&msg);
157
158 DBFEXIT;
159 return result;
160 }
161
162 static int p80211wext_autojoin(wlandevice_t *wlandev)
163 {
164 p80211msg_lnxreq_autojoin_t msg;
165 struct iw_point data;
166 char ssid[IW_ESSID_MAX_SIZE];
167
168 int result;
169 int err = 0;
170
171 DBFENTER;
172
173 /* Get ESSID */
174 result = p80211wext_giwessid(wlandev->netdev, NULL, &data, ssid);
175
176 if (result) {
177 err = -EFAULT;
178 goto exit;
179 }
180
181 if ( wlandev->hostwep & HOSTWEP_SHAREDKEY )
182 msg.authtype.data = P80211ENUM_authalg_sharedkey;
183 else
184 msg.authtype.data = P80211ENUM_authalg_opensystem;
185
186 msg.msgcode = DIDmsg_lnxreq_autojoin;
187
188 /* Trim the last '\0' to fit the SSID format */
189
190 if (data.length && ssid[data.length-1] == '\0') {
191 data.length = data.length - 1;
192 }
193
194 memcpy(msg.ssid.data.data, ssid, data.length);
195 msg.ssid.data.len = data.length;
196
197 result = p80211req_dorequest(wlandev, (u8*)&msg);
198
199 if (result) {
200 err = -EFAULT;
201 goto exit;
202 }
203
204 exit:
205
206 DBFEXIT;
207 return err;
208
209 }
210
211 /* called by /proc/net/wireless */
212 struct iw_statistics* p80211wext_get_wireless_stats (netdevice_t *dev)
213 {
214 p80211msg_lnxreq_commsquality_t quality;
215 wlandevice_t *wlandev = dev->ml_priv;
216 struct iw_statistics* wstats = &wlandev->wstats;
217 int retval;
218
219 DBFENTER;
220 /* Check */
221 if ( (wlandev == NULL) || (wlandev->msdstate != WLAN_MSD_RUNNING) )
222 return NULL;
223
224 /* XXX Only valid in station mode */
225 wstats->status = 0;
226
227 /* build request message */
228 quality.msgcode = DIDmsg_lnxreq_commsquality;
229 quality.dbm.data = P80211ENUM_truth_true;
230 quality.dbm.status = P80211ENUM_msgitem_status_data_ok;
231
232 /* send message to nsd */
233 if ( wlandev->mlmerequest == NULL )
234 return NULL;
235
236 retval = wlandev->mlmerequest(wlandev, (p80211msg_t*) &quality);
237
238 wstats->qual.qual = qual_as_percent(quality.link.data); /* overall link quality */
239 wstats->qual.level = quality.level.data; /* instant signal level */
240 wstats->qual.noise = quality.noise.data; /* instant noise level */
241
242 wstats->qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
243 wstats->discard.code = wlandev->rx.decrypt_err;
244 wstats->discard.nwid = 0;
245 wstats->discard.misc = 0;
246
247 wstats->discard.fragment = 0; // incomplete fragments
248 wstats->discard.retries = 0; // tx retries.
249 wstats->miss.beacon = 0;
250
251 DBFEXIT;
252
253 return wstats;
254 }
255
256 static int p80211wext_giwname(netdevice_t *dev,
257 struct iw_request_info *info,
258 char *name, char *extra)
259 {
260 struct iw_param rate;
261 int result;
262 int err = 0;
263
264 DBFENTER;
265
266 result = p80211wext_giwrate(dev, NULL, &rate, NULL);
267
268 if (result) {
269 err = -EFAULT;
270 goto exit;
271 }
272
273 switch (rate.value) {
274 case 1000000:
275 case 2000000:
276 strcpy(name, "IEEE 802.11-DS");
277 break;
278 case 5500000:
279 case 11000000:
280 strcpy(name, "IEEE 802.11-b");
281 break;
282 }
283 exit:
284 DBFEXIT;
285 return err;
286 }
287
288 static int p80211wext_giwfreq(netdevice_t *dev,
289 struct iw_request_info *info,
290 struct iw_freq *freq, char *extra)
291 {
292 wlandevice_t *wlandev = dev->ml_priv;
293 p80211item_uint32_t mibitem;
294 p80211msg_dot11req_mibset_t msg;
295 int result;
296 int err = 0;
297
298 DBFENTER;
299
300 msg.msgcode = DIDmsg_dot11req_mibget;
301 mibitem.did = DIDmib_dot11phy_dot11PhyDSSSTable_dot11CurrentChannel;
302 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
303 result = p80211req_dorequest(wlandev, (u8*)&msg);
304
305 if (result) {
306 err = -EFAULT;
307 goto exit;
308 }
309
310 memcpy(&mibitem, &msg.mibattribute.data, sizeof(mibitem));
311
312 if (mibitem.data > NUM_CHANNELS) {
313 err = -EFAULT;
314 goto exit;
315 }
316
317 /* convert into frequency instead of a channel */
318 freq->e = 1;
319 freq->m = p80211_channel_to_mhz(mibitem.data, 0) * 100000;
320
321 exit:
322 DBFEXIT;
323 return err;
324 }
325
326 static int p80211wext_siwfreq(netdevice_t *dev,
327 struct iw_request_info *info,
328 struct iw_freq *freq, char *extra)
329 {
330 wlandevice_t *wlandev = dev->ml_priv;
331 p80211item_uint32_t mibitem;
332 p80211msg_dot11req_mibset_t msg;
333 int result;
334 int err = 0;
335
336 DBFENTER;
337
338 if (!wlan_wext_write) {
339 err = (-EOPNOTSUPP);
340 goto exit;
341 }
342
343 msg.msgcode = DIDmsg_dot11req_mibset;
344 mibitem.did = DIDmib_dot11phy_dot11PhyDSSSTable_dot11CurrentChannel;
345 mibitem.status = P80211ENUM_msgitem_status_data_ok;
346
347 if ( (freq->e == 0) && (freq->m <= 1000) )
348 mibitem.data = freq->m;
349 else
350 mibitem.data = p80211_mhz_to_channel(freq->m);
351
352 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
353 result = p80211req_dorequest(wlandev, (u8*)&msg);
354
355 if (result) {
356 err = -EFAULT;
357 goto exit;
358 }
359
360 exit:
361 DBFEXIT;
362 return err;
363 }
364
365 static int p80211wext_giwmode(netdevice_t *dev,
366 struct iw_request_info *info,
367 __u32 *mode, char *extra)
368 {
369 wlandevice_t *wlandev = dev->ml_priv;
370
371 DBFENTER;
372
373 switch (wlandev->macmode) {
374 case WLAN_MACMODE_IBSS_STA:
375 *mode = IW_MODE_ADHOC;
376 break;
377 case WLAN_MACMODE_ESS_STA:
378 *mode = IW_MODE_INFRA;
379 break;
380 case WLAN_MACMODE_ESS_AP:
381 *mode = IW_MODE_MASTER;
382 break;
383 default:
384 /* Not set yet. */
385 *mode = IW_MODE_AUTO;
386 }
387
388 DBFEXIT;
389 return 0;
390 }
391
392 static int p80211wext_siwmode(netdevice_t *dev,
393 struct iw_request_info *info,
394 __u32 *mode, char *extra)
395 {
396 wlandevice_t *wlandev = dev->ml_priv;
397 p80211item_uint32_t mibitem;
398 p80211msg_dot11req_mibset_t msg;
399 int result;
400 int err = 0;
401
402 DBFENTER;
403
404 if (!wlan_wext_write) {
405 err = (-EOPNOTSUPP);
406 goto exit;
407 }
408
409 if (*mode != IW_MODE_ADHOC && *mode != IW_MODE_INFRA &&
410 *mode != IW_MODE_MASTER) {
411 err = (-EOPNOTSUPP);
412 goto exit;
413 }
414
415 /* Operation mode is the same with current mode */
416 if (*mode == wlandev->macmode)
417 goto exit;
418
419 switch (*mode) {
420 case IW_MODE_ADHOC:
421 wlandev->macmode = WLAN_MACMODE_IBSS_STA;
422 break;
423 case IW_MODE_INFRA:
424 wlandev->macmode = WLAN_MACMODE_ESS_STA;
425 break;
426 case IW_MODE_MASTER:
427 wlandev->macmode = WLAN_MACMODE_ESS_AP;
428 break;
429 default:
430 /* Not set yet. */
431 WLAN_LOG_INFO("Operation mode: %d not support\n", *mode);
432 return -EOPNOTSUPP;
433 }
434
435 /* Set Operation mode to the PORT TYPE RID */
436 msg.msgcode = DIDmsg_dot11req_mibset;
437 mibitem.did = DIDmib_p2_p2Static_p2CnfPortType;
438 mibitem.data = (*mode == IW_MODE_ADHOC) ? 0 : 1;
439 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
440 result = p80211req_dorequest(wlandev, (u8*)&msg);
441
442 if (result)
443 err = -EFAULT;
444
445 exit:
446 DBFEXIT;
447
448 return err;
449 }
450
451
452 static int p80211wext_giwrange(netdevice_t *dev,
453 struct iw_request_info *info,
454 struct iw_point *data, char *extra)
455 {
456 struct iw_range *range = (struct iw_range *) extra;
457 int i, val;
458
459 DBFENTER;
460
461 // for backward compatability set size & zero everything we don't understand
462 data->length = sizeof(*range);
463 memset(range,0,sizeof(*range));
464
465 range->txpower_capa = IW_TXPOW_DBM;
466 // XXX what about min/max_pmp, min/max_pmt, etc.
467
468 range->we_version_compiled = WIRELESS_EXT;
469 range->we_version_source = 13;
470
471 range->retry_capa = IW_RETRY_LIMIT;
472 range->retry_flags = IW_RETRY_LIMIT;
473 range->min_retry = 0;
474 range->max_retry = 255;
475
476 range->event_capa[0] = (IW_EVENT_CAPA_K_0 | //mode/freq/ssid
477 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
478 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
479 range->event_capa[1] = IW_EVENT_CAPA_K_1; //encode
480 range->event_capa[4] = (IW_EVENT_CAPA_MASK(IWEVQUAL) |
481 IW_EVENT_CAPA_MASK(IWEVCUSTOM) );
482
483 range->num_channels = NUM_CHANNELS;
484
485 /* XXX need to filter against the regulatory domain &| active set */
486 val = 0;
487 for (i = 0; i < NUM_CHANNELS ; i++) {
488 range->freq[val].i = i + 1;
489 range->freq[val].m = p80211wext_channel_freq[i] * 100000;
490 range->freq[val].e = 1;
491 val++;
492 }
493
494 range->num_frequency = val;
495
496 /* Max of /proc/net/wireless */
497 range->max_qual.qual = 100;
498 range->max_qual.level = 0;
499 range->max_qual.noise = 0;
500 range->sensitivity = 3;
501 // XXX these need to be nsd-specific!
502
503 range->min_rts = 0;
504 range->max_rts = 2347;
505 range->min_frag = 256;
506 range->max_frag = 2346;
507
508 range->max_encoding_tokens = NUM_WEPKEYS;
509 range->num_encoding_sizes = 2;
510 range->encoding_size[0] = 5;
511 range->encoding_size[1] = 13;
512
513 // XXX what about num_bitrates/throughput?
514 range->num_bitrates = 0;
515
516 /* estimated max throughput */
517 // XXX need to cap it if we're running at ~2Mbps..
518 range->throughput = 5500000;
519
520 DBFEXIT;
521 return 0;
522 }
523
524 static int p80211wext_giwap(netdevice_t *dev,
525 struct iw_request_info *info,
526 struct sockaddr *ap_addr, char *extra)
527 {
528
529 wlandevice_t *wlandev = dev->ml_priv;
530
531 DBFENTER;
532
533 memcpy(ap_addr->sa_data, wlandev->bssid, WLAN_BSSID_LEN);
534 ap_addr->sa_family = ARPHRD_ETHER;
535
536 DBFEXIT;
537 return 0;
538 }
539
540 static int p80211wext_giwencode(netdevice_t *dev,
541 struct iw_request_info *info,
542 struct iw_point *erq, char *key)
543 {
544 wlandevice_t *wlandev = dev->ml_priv;
545 int err = 0;
546 int i;
547
548 DBFENTER;
549
550 i = (erq->flags & IW_ENCODE_INDEX) - 1;
551 erq->flags = 0;
552
553 if (wlandev->hostwep & HOSTWEP_PRIVACYINVOKED)
554 erq->flags |= IW_ENCODE_ENABLED;
555 else
556 erq->flags |= IW_ENCODE_DISABLED;
557
558 if (wlandev->hostwep & HOSTWEP_EXCLUDEUNENCRYPTED)
559 erq->flags |= IW_ENCODE_RESTRICTED;
560 else
561 erq->flags |= IW_ENCODE_OPEN;
562
563 i = (erq->flags & IW_ENCODE_INDEX) - 1;
564
565 if (i == -1)
566 i = wlandev->hostwep & HOSTWEP_DEFAULTKEY_MASK;
567
568 if ((i < 0) || (i >= NUM_WEPKEYS)) {
569 err = -EINVAL;
570 goto exit;
571 }
572
573 erq->flags |= i + 1;
574
575 /* copy the key from the driver cache as the keys are read-only MIBs */
576 erq->length = wlandev->wep_keylens[i];
577 memcpy(key, wlandev->wep_keys[i], erq->length);
578
579 exit:
580 DBFEXIT;
581 return err;
582 }
583
584 static int p80211wext_siwencode(netdevice_t *dev,
585 struct iw_request_info *info,
586 struct iw_point *erq, char *key)
587 {
588 wlandevice_t *wlandev = dev->ml_priv;
589 p80211msg_dot11req_mibset_t msg;
590 p80211item_pstr32_t pstr;
591
592 int err = 0;
593 int result = 0;
594 int i;
595
596 DBFENTER;
597 if (!wlan_wext_write) {
598 err = (-EOPNOTSUPP);
599 goto exit;
600 }
601
602 /* Check the Key index first. */
603 if((i = (erq->flags & IW_ENCODE_INDEX))) {
604
605 if ((i < 1) || (i > NUM_WEPKEYS)) {
606 err = -EINVAL;
607 goto exit;
608 }
609 else
610 i--;
611
612 /* Set current key number only if no keys are given */
613 if (erq->flags & IW_ENCODE_NOKEY) {
614 result = p80211wext_dorequest(wlandev, DIDmib_dot11smt_dot11PrivacyTable_dot11WEPDefaultKeyID, i);
615
616 if (result) {
617 err = -EFAULT;
618 goto exit;
619 }
620 }
621
622 } else {
623 // Use defaultkey if no Key Index
624 i = wlandev->hostwep & HOSTWEP_DEFAULTKEY_MASK;
625 }
626
627 /* Check if there is no key information in the iwconfig request */
628 if((erq->flags & IW_ENCODE_NOKEY) == 0 ) {
629
630 /*------------------------------------------------------------
631 * If there is WEP Key for setting, check the Key Information
632 * and then set it to the firmware.
633 -------------------------------------------------------------*/
634
635 if (erq->length > 0) {
636
637 /* copy the key from the driver cache as the keys are read-only MIBs */
638 wlandev->wep_keylens[i] = erq->length;
639 memcpy(wlandev->wep_keys[i], key, erq->length);
640
641 /* Prepare data struture for p80211req_dorequest. */
642 memcpy(pstr.data.data, key, erq->length);
643 pstr.data.len = erq->length;
644
645 switch(i)
646 {
647 case 0:
648 pstr.did = DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey0;
649 break;
650
651 case 1:
652 pstr.did = DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey1;
653 break;
654
655 case 2:
656 pstr.did = DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey2;
657 break;
658
659 case 3:
660 pstr.did = DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey3;
661 break;
662
663 default:
664 err = -EINVAL;
665 goto exit;
666 }
667
668 msg.msgcode = DIDmsg_dot11req_mibset;
669 memcpy(&msg.mibattribute.data, &pstr, sizeof(pstr));
670 result = p80211req_dorequest(wlandev, (u8*)&msg);
671
672 if (result) {
673 err = -EFAULT;
674 goto exit;
675 }
676 }
677
678 }
679
680 /* Check the PrivacyInvoked flag */
681 if (erq->flags & IW_ENCODE_DISABLED) {
682 result = p80211wext_dorequest(wlandev, DIDmib_dot11smt_dot11PrivacyTable_dot11PrivacyInvoked, P80211ENUM_truth_false);
683 } else {
684 result = p80211wext_dorequest(wlandev, DIDmib_dot11smt_dot11PrivacyTable_dot11PrivacyInvoked, P80211ENUM_truth_true);
685 }
686
687 if (result) {
688 err = -EFAULT;
689 goto exit;
690 }
691
692 /* The security mode may be open or restricted, and its meaning
693 depends on the card used. With most cards, in open mode no
694 authentication is used and the card may also accept non-
695 encrypted sessions, whereas in restricted mode only encrypted
696 sessions are accepted and the card will use authentication if
697 available.
698 */
699 if (erq->flags & IW_ENCODE_RESTRICTED) {
700 result = p80211wext_dorequest(wlandev, DIDmib_dot11smt_dot11PrivacyTable_dot11ExcludeUnencrypted, P80211ENUM_truth_true);
701 }
702 else if (erq->flags & IW_ENCODE_OPEN) {
703 result = p80211wext_dorequest(wlandev, DIDmib_dot11smt_dot11PrivacyTable_dot11ExcludeUnencrypted, P80211ENUM_truth_false);
704 }
705
706 if (result) {
707 err = -EFAULT;
708 goto exit;
709 }
710
711 exit:
712
713 DBFEXIT;
714 return err;
715 }
716
717 static int p80211wext_giwessid(netdevice_t *dev,
718 struct iw_request_info *info,
719 struct iw_point *data, char *essid)
720 {
721 wlandevice_t *wlandev = dev->ml_priv;
722
723 DBFENTER;
724
725 if (wlandev->ssid.len) {
726 data->length = wlandev->ssid.len;
727 data->flags = 1;
728 memcpy(essid, wlandev->ssid.data, data->length);
729 essid[data->length] = 0;
730 #if (WIRELESS_EXT < 21)
731 data->length++;
732 #endif
733 } else {
734 memset(essid, 0, sizeof(wlandev->ssid.data));
735 data->length = 0;
736 data->flags = 0;
737 }
738
739 DBFEXIT;
740 return 0;
741 }
742
743 static int p80211wext_siwessid(netdevice_t *dev,
744 struct iw_request_info *info,
745 struct iw_point *data, char *essid)
746 {
747 wlandevice_t *wlandev = dev->ml_priv;
748 p80211msg_lnxreq_autojoin_t msg;
749
750 int result;
751 int err = 0;
752 int length = data->length;
753
754 DBFENTER;
755
756 if (!wlan_wext_write) {
757 err = (-EOPNOTSUPP);
758 goto exit;
759 }
760
761
762 if ( wlandev->hostwep & HOSTWEP_SHAREDKEY )
763 msg.authtype.data = P80211ENUM_authalg_sharedkey;
764 else
765 msg.authtype.data = P80211ENUM_authalg_opensystem;
766
767 msg.msgcode = DIDmsg_lnxreq_autojoin;
768
769 #if (WIRELESS_EXT < 21)
770 if (length) length--;
771 #endif
772
773 /* Trim the last '\0' to fit the SSID format */
774
775 if (length && essid[length-1] == '\0') {
776 length--;
777 }
778
779 memcpy(msg.ssid.data.data, essid, length);
780 msg.ssid.data.len = length;
781
782 WLAN_LOG_DEBUG(1,"autojoin_ssid for %s \n",essid);
783 result = p80211req_dorequest(wlandev, (u8*)&msg);
784 WLAN_LOG_DEBUG(1,"autojoin_ssid %d\n",result);
785
786 if (result) {
787 err = -EFAULT;
788 goto exit;
789 }
790
791 exit:
792 DBFEXIT;
793 return err;
794 }
795
796
797 static int p80211wext_siwcommit(netdevice_t *dev,
798 struct iw_request_info *info,
799 struct iw_point *data, char *essid)
800 {
801 wlandevice_t *wlandev = dev->ml_priv;
802 int err = 0;
803
804 DBFENTER;
805
806 if (!wlan_wext_write) {
807 err = (-EOPNOTSUPP);
808 goto exit;
809 }
810
811 /* Auto Join */
812 err = p80211wext_autojoin(wlandev);
813
814 exit:
815 DBFEXIT;
816 return err;
817 }
818
819
820 static int p80211wext_giwrate(netdevice_t *dev,
821 struct iw_request_info *info,
822 struct iw_param *rrq, char *extra)
823 {
824 wlandevice_t *wlandev = dev->ml_priv;
825 p80211item_uint32_t mibitem;
826 p80211msg_dot11req_mibset_t msg;
827 int result;
828 int err = 0;
829
830 DBFENTER;
831
832 msg.msgcode = DIDmsg_dot11req_mibget;
833 mibitem.did = DIDmib_p2_p2MAC_p2CurrentTxRate;
834 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
835 result = p80211req_dorequest(wlandev, (u8*)&msg);
836
837 if (result) {
838 err = -EFAULT;
839 goto exit;
840 }
841
842 memcpy(&mibitem, &msg.mibattribute.data, sizeof(mibitem));
843
844 rrq->fixed = 0; /* can it change? */
845 rrq->disabled = 0;
846 rrq->value = 0;
847
848 #define HFA384x_RATEBIT_1 ((u16)1)
849 #define HFA384x_RATEBIT_2 ((u16)2)
850 #define HFA384x_RATEBIT_5dot5 ((u16)4)
851 #define HFA384x_RATEBIT_11 ((u16)8)
852
853 switch (mibitem.data) {
854 case HFA384x_RATEBIT_1:
855 rrq->value = 1000000;
856 break;
857 case HFA384x_RATEBIT_2:
858 rrq->value = 2000000;
859 break;
860 case HFA384x_RATEBIT_5dot5:
861 rrq->value = 5500000;
862 break;
863 case HFA384x_RATEBIT_11:
864 rrq->value = 11000000;
865 break;
866 default:
867 err = -EINVAL;
868 }
869 exit:
870 DBFEXIT;
871 return err;
872 }
873
874 static int p80211wext_giwrts(netdevice_t *dev,
875 struct iw_request_info *info,
876 struct iw_param *rts, char *extra)
877 {
878 wlandevice_t *wlandev = dev->ml_priv;
879 p80211item_uint32_t mibitem;
880 p80211msg_dot11req_mibset_t msg;
881 int result;
882 int err = 0;
883
884 DBFENTER;
885
886 msg.msgcode = DIDmsg_dot11req_mibget;
887 mibitem.did = DIDmib_dot11mac_dot11OperationTable_dot11RTSThreshold;
888 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
889 result = p80211req_dorequest(wlandev, (u8*)&msg);
890
891 if (result) {
892 err = -EFAULT;
893 goto exit;
894 }
895
896 memcpy(&mibitem, &msg.mibattribute.data, sizeof(mibitem));
897
898 rts->value = mibitem.data;
899 rts->disabled = (rts->value == 2347);
900 rts->fixed = 1;
901
902 exit:
903 DBFEXIT;
904 return err;
905 }
906
907
908 static int p80211wext_siwrts(netdevice_t *dev,
909 struct iw_request_info *info,
910 struct iw_param *rts, char *extra)
911 {
912 wlandevice_t *wlandev = dev->ml_priv;
913 p80211item_uint32_t mibitem;
914 p80211msg_dot11req_mibset_t msg;
915 int result;
916 int err = 0;
917
918 DBFENTER;
919
920 if (!wlan_wext_write) {
921 err = (-EOPNOTSUPP);
922 goto exit;
923 }
924
925 msg.msgcode = DIDmsg_dot11req_mibget;
926 mibitem.did = DIDmib_dot11mac_dot11OperationTable_dot11RTSThreshold;
927 if (rts->disabled)
928 mibitem.data = 2347;
929 else
930 mibitem.data = rts->value;
931
932 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
933 result = p80211req_dorequest(wlandev, (u8*)&msg);
934
935 if (result) {
936 err = -EFAULT;
937 goto exit;
938 }
939
940 exit:
941 DBFEXIT;
942 return err;
943 }
944
945 static int p80211wext_giwfrag(netdevice_t *dev,
946 struct iw_request_info *info,
947 struct iw_param *frag, char *extra)
948 {
949 wlandevice_t *wlandev = dev->ml_priv;
950 p80211item_uint32_t mibitem;
951 p80211msg_dot11req_mibset_t msg;
952 int result;
953 int err = 0;
954
955 DBFENTER;
956
957 msg.msgcode = DIDmsg_dot11req_mibget;
958 mibitem.did = DIDmib_dot11mac_dot11OperationTable_dot11FragmentationThreshold;
959 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
960 result = p80211req_dorequest(wlandev, (u8*)&msg);
961
962 if (result) {
963 err = -EFAULT;
964 goto exit;
965 }
966
967 memcpy(&mibitem, &msg.mibattribute.data, sizeof(mibitem));
968
969 frag->value = mibitem.data;
970 frag->disabled = (frag->value == 2346);
971 frag->fixed = 1;
972
973 exit:
974 DBFEXIT;
975 return err;
976 }
977
978 static int p80211wext_siwfrag(netdevice_t *dev,
979 struct iw_request_info *info,
980 struct iw_param *frag, char *extra)
981 {
982 wlandevice_t *wlandev = dev->ml_priv;
983 p80211item_uint32_t mibitem;
984 p80211msg_dot11req_mibset_t msg;
985 int result;
986 int err = 0;
987
988 DBFENTER;
989
990 if (!wlan_wext_write) {
991 err = (-EOPNOTSUPP);
992 goto exit;
993 }
994
995 msg.msgcode = DIDmsg_dot11req_mibset;
996 mibitem.did = DIDmib_dot11mac_dot11OperationTable_dot11FragmentationThreshold;
997
998 if (frag->disabled)
999 mibitem.data = 2346;
1000 else
1001 mibitem.data = frag->value;
1002
1003 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
1004 result = p80211req_dorequest(wlandev, (u8*)&msg);
1005
1006 if (result) {
1007 err = -EFAULT;
1008 goto exit;
1009 }
1010
1011 exit:
1012 DBFEXIT;
1013 return err;
1014 }
1015
1016 #ifndef IW_RETRY_LONG
1017 #define IW_RETRY_LONG IW_RETRY_MAX
1018 #endif
1019
1020 #ifndef IW_RETRY_SHORT
1021 #define IW_RETRY_SHORT IW_RETRY_MIN
1022 #endif
1023
1024 static int p80211wext_giwretry(netdevice_t *dev,
1025 struct iw_request_info *info,
1026 struct iw_param *rrq, char *extra)
1027 {
1028 wlandevice_t *wlandev = dev->ml_priv;
1029 p80211item_uint32_t mibitem;
1030 p80211msg_dot11req_mibset_t msg;
1031 int result;
1032 int err = 0;
1033 u16 shortretry, longretry, lifetime;
1034
1035 DBFENTER;
1036
1037 msg.msgcode = DIDmsg_dot11req_mibget;
1038 mibitem.did = DIDmib_dot11mac_dot11OperationTable_dot11ShortRetryLimit;
1039
1040 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
1041 result = p80211req_dorequest(wlandev, (u8*)&msg);
1042
1043 if (result) {
1044 err = -EFAULT;
1045 goto exit;
1046 }
1047
1048 memcpy(&mibitem, &msg.mibattribute.data, sizeof(mibitem));
1049
1050 shortretry = mibitem.data;
1051
1052 mibitem.did = DIDmib_dot11mac_dot11OperationTable_dot11LongRetryLimit;
1053
1054 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
1055 result = p80211req_dorequest(wlandev, (u8*)&msg);
1056
1057 if (result) {
1058 err = -EFAULT;
1059 goto exit;
1060 }
1061
1062 memcpy(&mibitem, &msg.mibattribute.data, sizeof(mibitem));
1063
1064 longretry = mibitem.data;
1065
1066 mibitem.did = DIDmib_dot11mac_dot11OperationTable_dot11MaxTransmitMSDULifetime;
1067
1068 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
1069 result = p80211req_dorequest(wlandev, (u8*)&msg);
1070
1071 if (result) {
1072 err = -EFAULT;
1073 goto exit;
1074 }
1075
1076 memcpy(&mibitem, &msg.mibattribute.data, sizeof(mibitem));
1077
1078 lifetime = mibitem.data;
1079
1080 rrq->disabled = 0;
1081
1082 if ((rrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
1083 rrq->flags = IW_RETRY_LIFETIME;
1084 rrq->value = lifetime * 1024;
1085 } else {
1086 if (rrq->flags & IW_RETRY_LONG) {
1087 rrq->flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
1088 rrq->value = longretry;
1089 } else {
1090 rrq->flags = IW_RETRY_LIMIT;
1091 rrq->value = shortretry;
1092 if (shortretry != longretry)
1093 rrq->flags |= IW_RETRY_SHORT;
1094 }
1095 }
1096
1097 exit:
1098 DBFEXIT;
1099 return err;
1100
1101 }
1102
1103 static int p80211wext_siwretry(netdevice_t *dev,
1104 struct iw_request_info *info,
1105 struct iw_param *rrq, char *extra)
1106 {
1107 wlandevice_t *wlandev = dev->ml_priv;
1108 p80211item_uint32_t mibitem;
1109 p80211msg_dot11req_mibset_t msg;
1110 int result;
1111 int err = 0;
1112
1113 DBFENTER;
1114
1115 if (!wlan_wext_write) {
1116 err = (-EOPNOTSUPP);
1117 goto exit;
1118 }
1119
1120 if (rrq->disabled) {
1121 err = -EINVAL;
1122 goto exit;
1123 }
1124
1125 msg.msgcode = DIDmsg_dot11req_mibset;
1126
1127 if ((rrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
1128 mibitem.did = DIDmib_dot11mac_dot11OperationTable_dot11MaxTransmitMSDULifetime;
1129 mibitem.data = rrq->value /= 1024;
1130
1131 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
1132 result = p80211req_dorequest(wlandev, (u8*)&msg);
1133
1134 if (result) {
1135 err = -EFAULT;
1136 goto exit;
1137 }
1138 } else {
1139 if (rrq->flags & IW_RETRY_LONG) {
1140 mibitem.did = DIDmib_dot11mac_dot11OperationTable_dot11LongRetryLimit;
1141 mibitem.data = rrq->value;
1142
1143 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
1144 result = p80211req_dorequest(wlandev, (u8*)&msg);
1145
1146 if (result) {
1147 err = -EFAULT;
1148 goto exit;
1149 }
1150 }
1151
1152 if (rrq->flags & IW_RETRY_SHORT) {
1153 mibitem.did = DIDmib_dot11mac_dot11OperationTable_dot11ShortRetryLimit;
1154 mibitem.data = rrq->value;
1155
1156 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
1157 result = p80211req_dorequest(wlandev, (u8*)&msg);
1158
1159 if (result) {
1160 err = -EFAULT;
1161 goto exit;
1162 }
1163 }
1164 }
1165
1166 exit:
1167 DBFEXIT;
1168 return err;
1169
1170 }
1171
1172 static int p80211wext_siwtxpow(netdevice_t *dev,
1173 struct iw_request_info *info,
1174 struct iw_param *rrq, char *extra)
1175 {
1176 wlandevice_t *wlandev = dev->ml_priv;
1177 p80211item_uint32_t mibitem;
1178 p80211msg_dot11req_mibset_t msg;
1179 int result;
1180 int err = 0;
1181
1182 DBFENTER;
1183
1184 if (!wlan_wext_write) {
1185 err = (-EOPNOTSUPP);
1186 goto exit;
1187 }
1188
1189 msg.msgcode = DIDmsg_dot11req_mibset;
1190 mibitem.did = DIDmib_dot11phy_dot11PhyTxPowerTable_dot11CurrentTxPowerLevel;
1191 if (rrq->fixed == 0)
1192 mibitem.data = 30;
1193 else
1194 mibitem.data = rrq->value;
1195 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
1196 result = p80211req_dorequest(wlandev, (u8*)&msg);
1197
1198 if (result) {
1199 err = -EFAULT;
1200 goto exit;
1201 }
1202
1203 exit:
1204 DBFEXIT;
1205 return err;
1206 }
1207
1208 static int p80211wext_giwtxpow(netdevice_t *dev,
1209 struct iw_request_info *info,
1210 struct iw_param *rrq, char *extra)
1211 {
1212 wlandevice_t *wlandev = dev->ml_priv;
1213 p80211item_uint32_t mibitem;
1214 p80211msg_dot11req_mibset_t msg;
1215 int result;
1216 int err = 0;
1217
1218 DBFENTER;
1219
1220 msg.msgcode = DIDmsg_dot11req_mibget;
1221 mibitem.did = DIDmib_dot11phy_dot11PhyTxPowerTable_dot11CurrentTxPowerLevel;
1222
1223 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
1224 result = p80211req_dorequest(wlandev, (u8*)&msg);
1225
1226 if (result) {
1227 err = -EFAULT;
1228 goto exit;
1229 }
1230
1231 memcpy(&mibitem, &msg.mibattribute.data, sizeof(mibitem));
1232
1233 // XXX handle OFF by setting disabled = 1;
1234
1235 rrq->flags = 0; // IW_TXPOW_DBM;
1236 rrq->disabled = 0;
1237 rrq->fixed = 0;
1238 rrq->value = mibitem.data;
1239
1240 exit:
1241 DBFEXIT;
1242 return err;
1243 }
1244
1245 static int p80211wext_siwspy(netdevice_t *dev,
1246 struct iw_request_info *info,
1247 struct iw_point *srq, char *extra)
1248 {
1249 wlandevice_t *wlandev = dev->ml_priv;
1250 struct sockaddr address[IW_MAX_SPY];
1251 int number = srq->length;
1252 int i;
1253
1254 DBFENTER;
1255
1256 /* Copy the data from the input buffer */
1257 memcpy(address, extra, sizeof(struct sockaddr)*number);
1258
1259 wlandev->spy_number = 0;
1260
1261 if (number > 0) {
1262
1263 /* extract the addresses */
1264 for (i = 0; i < number; i++) {
1265
1266 memcpy(wlandev->spy_address[i], address[i].sa_data, ETH_ALEN);
1267 }
1268
1269 /* reset stats */
1270 memset(wlandev->spy_stat, 0, sizeof(struct iw_quality) * IW_MAX_SPY);
1271
1272 /* set number of addresses */
1273 wlandev->spy_number = number;
1274 }
1275
1276 DBFEXIT;
1277 return 0;
1278 }
1279
1280 /* jkriegl: from orinoco, modified */
1281 static int p80211wext_giwspy(netdevice_t *dev,
1282 struct iw_request_info *info,
1283 struct iw_point *srq, char *extra)
1284 {
1285 wlandevice_t *wlandev = dev->ml_priv;
1286
1287 struct sockaddr address[IW_MAX_SPY];
1288 struct iw_quality spy_stat[IW_MAX_SPY];
1289 int number;
1290 int i;
1291
1292 DBFENTER;
1293
1294 number = wlandev->spy_number;
1295
1296 if (number > 0) {
1297
1298 /* populate address and spy struct's */
1299 for (i = 0; i < number; i++) {
1300 memcpy(address[i].sa_data, wlandev->spy_address[i], ETH_ALEN);
1301 address[i].sa_family = AF_UNIX;
1302 memcpy(&spy_stat[i], &wlandev->spy_stat[i], sizeof(struct iw_quality));
1303 }
1304
1305 /* reset update flag */
1306 for (i=0; i < number; i++)
1307 wlandev->spy_stat[i].updated = 0;
1308 }
1309
1310 /* push stuff to user space */
1311 srq->length = number;
1312 memcpy(extra, address, sizeof(struct sockaddr)*number);
1313 memcpy(extra+sizeof(struct sockaddr)*number, spy_stat, sizeof(struct iw_quality)*number);
1314
1315 DBFEXIT;
1316 return 0;
1317 }
1318
1319 static int prism2_result2err (int prism2_result)
1320 {
1321 int err = 0;
1322
1323 switch (prism2_result) {
1324 case P80211ENUM_resultcode_invalid_parameters:
1325 err = -EINVAL;
1326 break;
1327 case P80211ENUM_resultcode_implementation_failure:
1328 err = -EIO;
1329 break;
1330 case P80211ENUM_resultcode_not_supported:
1331 err = -EOPNOTSUPP;
1332 break;
1333 default:
1334 err = 0;
1335 break;
1336 }
1337
1338 return err;
1339 }
1340
1341 static int p80211wext_siwscan(netdevice_t *dev,
1342 struct iw_request_info *info,
1343 struct iw_point *srq, char *extra)
1344 {
1345 wlandevice_t *wlandev = dev->ml_priv;
1346 p80211msg_dot11req_scan_t msg;
1347 int result;
1348 int err = 0;
1349 int i = 0;
1350
1351 DBFENTER;
1352
1353 if (wlandev->macmode == WLAN_MACMODE_ESS_AP) {
1354 WLAN_LOG_ERROR("Can't scan in AP mode\n");
1355 err = (-EOPNOTSUPP);
1356 goto exit;
1357 }
1358
1359 memset(&msg, 0x00, sizeof(p80211msg_dot11req_scan_t));
1360 msg.msgcode = DIDmsg_dot11req_scan;
1361 msg.bsstype.data = P80211ENUM_bsstype_any;
1362
1363 memset(&(msg.bssid.data), 0xFF, sizeof (p80211item_pstr6_t));
1364 msg.bssid.data.len = 6;
1365
1366 msg.scantype.data = P80211ENUM_scantype_active;
1367 msg.probedelay.data = 0;
1368
1369 for (i = 1; i <= 14; i++)
1370 msg.channellist.data.data[i-1] = i;
1371 msg.channellist.data.len = 14;
1372
1373 msg.maxchanneltime.data = 250;
1374 msg.minchanneltime.data = 200;
1375
1376 result = p80211req_dorequest(wlandev, (u8*)&msg);
1377 if (result)
1378 err = prism2_result2err (msg.resultcode.data);
1379
1380 exit:
1381 DBFEXIT;
1382 return err;
1383 }
1384
1385
1386 /* Helper to translate scan into Wireless Extensions scan results.
1387 * Inspired by the prism54 code, which was in turn inspired by the
1388 * airo driver code.
1389 */
1390 static char *
1391 wext_translate_bss(struct iw_request_info *info, char *current_ev,
1392 char *end_buf, p80211msg_dot11req_scan_results_t *bss)
1393 {
1394 struct iw_event iwe; /* Temporary buffer */
1395
1396 /* The first entry must be the MAC address */
1397 memcpy(iwe.u.ap_addr.sa_data, bss->bssid.data.data, WLAN_BSSID_LEN);
1398 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1399 iwe.cmd = SIOCGIWAP;
1400 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe, IW_EV_ADDR_LEN);
1401
1402 /* The following entries will be displayed in the same order we give them */
1403
1404 /* The ESSID. */
1405 if (bss->ssid.data.len > 0) {
1406 char essid[IW_ESSID_MAX_SIZE + 1];
1407 int size;
1408
1409 size = wlan_min(IW_ESSID_MAX_SIZE, bss->ssid.data.len);
1410 memset(&essid, 0, sizeof (essid));
1411 memcpy(&essid, bss->ssid.data.data, size);
1412 WLAN_LOG_DEBUG(1, " essid size = %d\n", size);
1413 iwe.u.data.length = size;
1414 iwe.u.data.flags = 1;
1415 iwe.cmd = SIOCGIWESSID;
1416 current_ev = iwe_stream_add_point(info, current_ev, end_buf, &iwe, &essid[0]);
1417 WLAN_LOG_DEBUG(1, " essid size OK.\n");
1418 }
1419
1420 switch (bss->bsstype.data) {
1421 case P80211ENUM_bsstype_infrastructure:
1422 iwe.u.mode = IW_MODE_MASTER;
1423 break;
1424
1425 case P80211ENUM_bsstype_independent:
1426 iwe.u.mode = IW_MODE_ADHOC;
1427 break;
1428
1429 default:
1430 iwe.u.mode = 0;
1431 break;
1432 }
1433 iwe.cmd = SIOCGIWMODE;
1434 if (iwe.u.mode)
1435 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe, IW_EV_UINT_LEN);
1436
1437 /* Encryption capability */
1438 if (bss->privacy.data == P80211ENUM_truth_true)
1439 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
1440 else
1441 iwe.u.data.flags = IW_ENCODE_DISABLED;
1442 iwe.u.data.length = 0;
1443 iwe.cmd = SIOCGIWENCODE;
1444 current_ev = iwe_stream_add_point(info, current_ev, end_buf, &iwe, NULL);
1445
1446 /* Add frequency. (short) bss->channel is the frequency in MHz */
1447 iwe.u.freq.m = bss->dschannel.data;
1448 iwe.u.freq.e = 0;
1449 iwe.cmd = SIOCGIWFREQ;
1450 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe, IW_EV_FREQ_LEN);
1451
1452 /* Add quality statistics */
1453 iwe.u.qual.level = bss->signal.data;
1454 iwe.u.qual.noise = bss->noise.data;
1455 /* do a simple SNR for quality */
1456 iwe.u.qual.qual = qual_as_percent(bss->signal.data - bss->noise.data);
1457 iwe.cmd = IWEVQUAL;
1458 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);
1459
1460 return current_ev;
1461 }
1462
1463
1464 static int p80211wext_giwscan(netdevice_t *dev,
1465 struct iw_request_info *info,
1466 struct iw_point *srq, char *extra)
1467 {
1468 wlandevice_t *wlandev = dev->ml_priv;
1469 p80211msg_dot11req_scan_results_t msg;
1470 int result = 0;
1471 int err = 0;
1472 int i = 0;
1473 int scan_good = 0;
1474 char *current_ev = extra;
1475
1476 DBFENTER;
1477
1478 /* Since wireless tools doesn't really have a way of passing how
1479 * many scan results results there were back here, keep grabbing them
1480 * until we fail.
1481 */
1482 do {
1483 memset(&msg, 0, sizeof(msg));
1484 msg.msgcode = DIDmsg_dot11req_scan_results;
1485 msg.bssindex.data = i;
1486
1487 result = p80211req_dorequest(wlandev, (u8*)&msg);
1488 if ((result != 0) ||
1489 (msg.resultcode.data != P80211ENUM_resultcode_success)) {
1490 break;
1491 }
1492
1493 current_ev = wext_translate_bss(info, current_ev, extra + IW_SCAN_MAX_DATA, &msg);
1494 scan_good = 1;
1495 i++;
1496 } while (i < IW_MAX_AP);
1497
1498 srq->length = (current_ev - extra);
1499 srq->flags = 0; /* todo */
1500
1501 if (result && !scan_good)
1502 err = prism2_result2err (msg.resultcode.data);
1503
1504 DBFEXIT;
1505 return err;
1506 }
1507
1508 /*****************************************************/
1509 //extra wireless extensions stuff to support NetworkManager (I hope)
1510
1511 /* SIOCSIWENCODEEXT */
1512 static int p80211wext_set_encodeext(struct net_device *dev,
1513 struct iw_request_info *info,
1514 union iwreq_data *wrqu, char *extra)
1515 {
1516 wlandevice_t *wlandev = dev->ml_priv;
1517 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
1518 p80211msg_dot11req_mibset_t msg;
1519 p80211item_pstr32_t *pstr;
1520
1521 int result = 0;
1522 struct iw_point *encoding = &wrqu->encoding;
1523 int idx = encoding->flags & IW_ENCODE_INDEX;
1524
1525 WLAN_LOG_DEBUG(1,"set_encode_ext flags[%d] alg[%d] keylen[%d]\n",ext->ext_flags,(int)ext->alg,(int)ext->key_len);
1526
1527
1528 if ( ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY ) {
1529 // set default key ? I'm not sure if this the the correct thing to do here
1530
1531 if ( idx ) {
1532 if (idx < 1 || idx > NUM_WEPKEYS) {
1533 return -EINVAL;
1534 } else
1535 idx--;
1536 }
1537 WLAN_LOG_DEBUG(1,"setting default key (%d)\n",idx);
1538 result = p80211wext_dorequest(wlandev, DIDmib_dot11smt_dot11PrivacyTable_dot11WEPDefaultKeyID, idx);
1539 if ( result )
1540 return -EFAULT;
1541 }
1542
1543
1544 if ( ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY ) {
1545 if (!(ext->alg & IW_ENCODE_ALG_WEP)) {
1546 WLAN_LOG_DEBUG(1,"asked to set a non wep key :(");
1547 return -EINVAL;
1548 }
1549 if (idx) {
1550 if (idx <1 || idx > NUM_WEPKEYS)
1551 return -EINVAL;
1552 else
1553 idx--;
1554 }
1555 WLAN_LOG_DEBUG(1,"Set WEP key (%d)\n",idx);
1556 wlandev->wep_keylens[idx] = ext->key_len;
1557 memcpy(wlandev->wep_keys[idx], ext->key, ext->key_len);
1558
1559 memset( &msg,0,sizeof(msg));
1560 pstr = (p80211item_pstr32_t*)&msg.mibattribute.data;
1561 memcpy(pstr->data.data, ext->key,ext->key_len);
1562 pstr->data.len = ext->key_len;
1563 switch (idx) {
1564 case 0:
1565 pstr->did = DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey0;
1566 break;
1567 case 1:
1568 pstr->did = DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey1;
1569 break;
1570 case 2:
1571 pstr->did = DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey2;
1572 break;
1573 case 3:
1574 pstr->did = DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey3;
1575 break;
1576 default:
1577 break;
1578 }
1579 msg.msgcode = DIDmsg_dot11req_mibset;
1580 result = p80211req_dorequest(wlandev,(u8*)&msg);
1581 WLAN_LOG_DEBUG(1,"result (%d)\n",result);
1582 }
1583 return result;
1584 }
1585
1586 /* SIOCGIWENCODEEXT */
1587 static int p80211wext_get_encodeext(struct net_device *dev,
1588 struct iw_request_info *info,
1589 union iwreq_data *wrqu, char *extra)
1590
1591 {
1592 wlandevice_t *wlandev = dev->ml_priv;
1593 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
1594
1595 struct iw_point *encoding = &wrqu->encoding;
1596 int result = 0;
1597 int max_len;
1598 int idx;
1599
1600 DBFENTER;
1601
1602 WLAN_LOG_DEBUG(1,"get_encode_ext flags[%d] alg[%d] keylen[%d]\n",ext->ext_flags,(int)ext->alg,(int)ext->key_len);
1603
1604
1605 max_len = encoding->length - sizeof(*ext);
1606 if ( max_len <= 0) {
1607 WLAN_LOG_DEBUG(1,"get_encodeext max_len [%d] invalid\n",max_len);
1608 result = -EINVAL;
1609 goto exit;
1610 }
1611 idx = encoding->flags & IW_ENCODE_INDEX;
1612
1613 WLAN_LOG_DEBUG(1,"get_encode_ext index [%d]\n",idx);
1614
1615 if (idx) {
1616 if (idx < 1 || idx > NUM_WEPKEYS ) {
1617 WLAN_LOG_DEBUG(1,"get_encode_ext invalid key index [%d]\n",idx);
1618 result = -EINVAL;
1619 goto exit;
1620 }
1621 idx--;
1622 } else {
1623 /* default key ? not sure what to do */
1624 /* will just use key[0] for now ! FIX ME */
1625 }
1626
1627 encoding->flags = idx + 1;
1628 memset(ext,0,sizeof(*ext));
1629
1630 ext->alg = IW_ENCODE_ALG_WEP;
1631 ext->key_len = wlandev->wep_keylens[idx];
1632 memcpy( ext->key, wlandev->wep_keys[idx] , ext->key_len );
1633
1634 encoding->flags |= IW_ENCODE_ENABLED;
1635 exit:
1636 DBFEXIT;
1637
1638 return result;
1639 }
1640
1641
1642 /* SIOCSIWAUTH */
1643 static int p80211_wext_set_iwauth (struct net_device *dev,
1644 struct iw_request_info *info,
1645 union iwreq_data *wrqu, char *extra)
1646 {
1647 wlandevice_t *wlandev = dev->ml_priv;
1648 struct iw_param *param = &wrqu->param;
1649 int result =0;
1650
1651 WLAN_LOG_DEBUG(1,"set_iwauth flags[%d]\n",(int)param->flags & IW_AUTH_INDEX );
1652
1653 switch (param->flags & IW_AUTH_INDEX) {
1654 case IW_AUTH_DROP_UNENCRYPTED:
1655 WLAN_LOG_DEBUG(1,"drop_unencrypted %d\n",param->value);
1656 if (param->value)
1657 result = p80211wext_dorequest(wlandev, DIDmib_dot11smt_dot11PrivacyTable_dot11ExcludeUnencrypted, P80211ENUM_truth_true);
1658 else
1659 result = p80211wext_dorequest(wlandev, DIDmib_dot11smt_dot11PrivacyTable_dot11ExcludeUnencrypted, P80211ENUM_truth_false);
1660 break;
1661
1662 case IW_AUTH_PRIVACY_INVOKED:
1663 WLAN_LOG_DEBUG(1,"privacy invoked %d\n",param->value);
1664 if ( param->value)
1665 result = p80211wext_dorequest(wlandev, DIDmib_dot11smt_dot11PrivacyTable_dot11PrivacyInvoked, P80211ENUM_truth_true);
1666 else
1667 result = p80211wext_dorequest(wlandev, DIDmib_dot11smt_dot11PrivacyTable_dot11PrivacyInvoked, P80211ENUM_truth_false);
1668
1669 break;
1670
1671 case IW_AUTH_80211_AUTH_ALG:
1672 if ( param->value & IW_AUTH_ALG_OPEN_SYSTEM ) {
1673 WLAN_LOG_DEBUG(1,"set open_system\n");
1674 wlandev->hostwep &= ~HOSTWEP_SHAREDKEY;
1675 } else if ( param->value & IW_AUTH_ALG_SHARED_KEY) {
1676 WLAN_LOG_DEBUG(1,"set shared key\n");
1677 wlandev->hostwep |= HOSTWEP_SHAREDKEY;
1678 } else {
1679 /* don't know what to do know :( */
1680 WLAN_LOG_DEBUG(1,"unknown AUTH_ALG (%d)\n",param->value);
1681 result = -EINVAL;
1682 }
1683 break;
1684
1685 default:
1686 break;
1687 }
1688
1689
1690
1691 return result;
1692 }
1693
1694 /* SIOCSIWAUTH */
1695 static int p80211_wext_get_iwauth (struct net_device *dev,
1696 struct iw_request_info *info,
1697 union iwreq_data *wrqu, char *extra)
1698 {
1699 wlandevice_t *wlandev = dev->ml_priv;
1700 struct iw_param *param = &wrqu->param;
1701 int result =0;
1702
1703 WLAN_LOG_DEBUG(1,"get_iwauth flags[%d]\n",(int)param->flags & IW_AUTH_INDEX );
1704
1705 switch (param->flags & IW_AUTH_INDEX) {
1706 case IW_AUTH_DROP_UNENCRYPTED:
1707 param->value = wlandev->hostwep & HOSTWEP_EXCLUDEUNENCRYPTED?1:0;
1708 break;
1709
1710 case IW_AUTH_PRIVACY_INVOKED:
1711 param->value = wlandev->hostwep & HOSTWEP_PRIVACYINVOKED?1:0;
1712 break;
1713
1714 case IW_AUTH_80211_AUTH_ALG:
1715 param->value = wlandev->hostwep & HOSTWEP_SHAREDKEY?IW_AUTH_ALG_SHARED_KEY:IW_AUTH_ALG_OPEN_SYSTEM;
1716 break;
1717
1718
1719 default:
1720 break;
1721 }
1722
1723
1724
1725 return result;
1726 }
1727
1728 static iw_handler p80211wext_handlers[] = {
1729 (iw_handler) p80211wext_siwcommit, /* SIOCSIWCOMMIT */
1730 (iw_handler) p80211wext_giwname, /* SIOCGIWNAME */
1731 (iw_handler) NULL, /* SIOCSIWNWID */
1732 (iw_handler) NULL, /* SIOCGIWNWID */
1733 (iw_handler) p80211wext_siwfreq, /* SIOCSIWFREQ */
1734 (iw_handler) p80211wext_giwfreq, /* SIOCGIWFREQ */
1735 (iw_handler) p80211wext_siwmode, /* SIOCSIWMODE */
1736 (iw_handler) p80211wext_giwmode, /* SIOCGIWMODE */
1737 (iw_handler) NULL, /* SIOCSIWSENS */
1738 (iw_handler) NULL, /* SIOCGIWSENS */
1739 (iw_handler) NULL, /* not used */ /* SIOCSIWRANGE */
1740 (iw_handler) p80211wext_giwrange, /* SIOCGIWRANGE */
1741 (iw_handler) NULL, /* not used */ /* SIOCSIWPRIV */
1742 (iw_handler) NULL, /* kernel code */ /* SIOCGIWPRIV */
1743 (iw_handler) NULL, /* not used */ /* SIOCSIWSTATS */
1744 (iw_handler) NULL, /* kernel code */ /* SIOCGIWSTATS */
1745 (iw_handler) p80211wext_siwspy, /* SIOCSIWSPY */
1746 (iw_handler) p80211wext_giwspy, /* SIOCGIWSPY */
1747 (iw_handler) NULL, /* -- hole -- */
1748 (iw_handler) NULL, /* -- hole -- */
1749 (iw_handler) NULL, /* SIOCSIWAP */
1750 (iw_handler) p80211wext_giwap, /* SIOCGIWAP */
1751 (iw_handler) NULL, /* -- hole -- */
1752 (iw_handler) NULL, /* SIOCGIWAPLIST */
1753 (iw_handler) p80211wext_siwscan, /* SIOCSIWSCAN */
1754 (iw_handler) p80211wext_giwscan, /* SIOCGIWSCAN */
1755 (iw_handler) p80211wext_siwessid, /* SIOCSIWESSID */
1756 (iw_handler) p80211wext_giwessid, /* SIOCGIWESSID */
1757 (iw_handler) NULL, /* SIOCSIWNICKN */
1758 (iw_handler) p80211wext_giwessid, /* SIOCGIWNICKN */
1759 (iw_handler) NULL, /* -- hole -- */
1760 (iw_handler) NULL, /* -- hole -- */
1761 (iw_handler) NULL, /* SIOCSIWRATE */
1762 (iw_handler) p80211wext_giwrate, /* SIOCGIWRATE */
1763 (iw_handler) p80211wext_siwrts, /* SIOCSIWRTS */
1764 (iw_handler) p80211wext_giwrts, /* SIOCGIWRTS */
1765 (iw_handler) p80211wext_siwfrag, /* SIOCSIWFRAG */
1766 (iw_handler) p80211wext_giwfrag, /* SIOCGIWFRAG */
1767 (iw_handler) p80211wext_siwtxpow, /* SIOCSIWTXPOW */
1768 (iw_handler) p80211wext_giwtxpow, /* SIOCGIWTXPOW */
1769 (iw_handler) p80211wext_siwretry, /* SIOCSIWRETRY */
1770 (iw_handler) p80211wext_giwretry, /* SIOCGIWRETRY */
1771 (iw_handler) p80211wext_siwencode, /* SIOCSIWENCODE */
1772 (iw_handler) p80211wext_giwencode, /* SIOCGIWENCODE */
1773 (iw_handler) NULL, /* SIOCSIWPOWER */
1774 (iw_handler) NULL, /* SIOCGIWPOWER */
1775 /* WPA operations */
1776 (iw_handler) NULL, /* -- hole -- */
1777 (iw_handler) NULL, /* -- hole -- */
1778 (iw_handler) NULL, /* SIOCSIWGENIE set generic IE */
1779 (iw_handler) NULL, /* SIOCGIWGENIE get generic IE */
1780 (iw_handler) p80211_wext_set_iwauth, /* SIOCSIWAUTH set authentication mode params */
1781 (iw_handler) p80211_wext_get_iwauth, /* SIOCGIWAUTH get authentication mode params */
1782
1783 (iw_handler) p80211wext_set_encodeext, /* SIOCSIWENCODEEXT set encoding token & mode */
1784 (iw_handler) p80211wext_get_encodeext, /* SIOCGIWENCODEEXT get encoding token & mode */
1785 (iw_handler) NULL, /* SIOCSIWPMKSA PMKSA cache operation */
1786 };
1787
1788 struct iw_handler_def p80211wext_handler_def = {
1789 .num_standard = ARRAY_SIZE(p80211wext_handlers),
1790 .num_private = 0,
1791 .num_private_args = 0,
1792 .standard = p80211wext_handlers,
1793 .private = NULL,
1794 .private_args = NULL,
1795 .get_wireless_stats = p80211wext_get_wireless_stats
1796 };
1797
1798
1799 int p80211wext_event_associated(wlandevice_t *wlandev, int assoc)
1800 {
1801 union iwreq_data data;
1802
1803 DBFENTER;
1804
1805 /* Send the association state first */
1806 data.ap_addr.sa_family = ARPHRD_ETHER;
1807 if (assoc) {
1808 memcpy(data.ap_addr.sa_data, wlandev->bssid, WLAN_ADDR_LEN);
1809 } else {
1810 memset(data.ap_addr.sa_data, 0, WLAN_ADDR_LEN);
1811 }
1812
1813 if (wlan_wext_write)
1814 wireless_send_event(wlandev->netdev, SIOCGIWAP, &data, NULL);
1815
1816 if (!assoc) goto done;
1817
1818 // XXX send association data, like IEs, etc etc.
1819
1820 done:
1821 DBFEXIT;
1822 return 0;
1823 }
1824
1825
1826
1827
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree