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