projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix common misspellings
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / wlags49_h2 / wl_wext.c
1 /*******************************************************************************
2 * Agere Systems Inc.
3 * Wireless device driver for Linux (wlags49).
4 *
5 * Copyright (c) 1998-2003 Agere Systems Inc.
6 * All rights reserved.
7 * http://www.agere.com
8 *
9 * Initially developed by TriplePoint, Inc.
10 * http://www.triplepoint.com
11 *
12 *------------------------------------------------------------------------------
13 *
14 * SOFTWARE LICENSE
15 *
16 * This software is provided subject to the following terms and conditions,
17 * which you should read carefully before using the software. Using this
18 * software indicates your acceptance of these terms and conditions. If you do
19 * not agree with these terms and conditions, do not use the software.
20 *
21 * Copyright © 2003 Agere Systems Inc.
22 * All rights reserved.
23 *
24 * Redistribution and use in source or binary forms, with or without
25 * modifications, are permitted provided that the following conditions are met:
26 *
27 * . Redistributions of source code must retain the above copyright notice, this
28 * list of conditions and the following Disclaimer as comments in the code as
29 * well as in the documentation and/or other materials provided with the
30 * distribution.
31 *
32 * . Redistributions in binary form must reproduce the above copyright notice,
33 * this list of conditions and the following Disclaimer in the documentation
34 * and/or other materials provided with the distribution.
35 *
36 * . Neither the name of Agere Systems Inc. nor the names of the contributors
37 * may be used to endorse or promote products derived from this software
38 * without specific prior written permission.
39 *
40 * Disclaimer
41 *
42 * THIS SOFTWARE IS PROVIDED \93AS IS\94 AND ANY EXPRESS OR IMPLIED WARRANTIES,
43 * INCLUDING, BUT NOT LIMITED TO, INFRINGEMENT AND THE IMPLIED WARRANTIES OF
44 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ANY
45 * USE, MODIFICATION OR DISTRIBUTION OF THIS SOFTWARE IS SOLELY AT THE USERS OWN
46 * RISK. IN NO EVENT SHALL AGERE SYSTEMS INC. OR CONTRIBUTORS BE LIABLE FOR ANY
47 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
48 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
49 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
50 * ON ANY THEORY OF LIABILITY, INCLUDING, BUT NOT LIMITED TO, CONTRACT, STRICT
51 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
52 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
53 * DAMAGE.
54 *
55 ******************************************************************************/
56
57 /*******************************************************************************
58 * include files
59 ******************************************************************************/
60 #include <wl_version.h>
61
62 #include <linux/if_arp.h>
63 #include <linux/ioport.h>
64 #include <linux/delay.h>
65 #include <asm/uaccess.h>
66
67 #include <debug.h>
68 #include <hcf.h>
69 #include <hcfdef.h>
70
71 #include <wl_if.h>
72 #include <wl_internal.h>
73 #include <wl_util.h>
74 #include <wl_main.h>
75 #include <wl_wext.h>
76 #include <wl_priv.h>
77
78
79
80 /* If WIRELESS_EXT is not defined (as a result of HAS_WIRELESS_EXTENSIONS
81 #including linux/wireless.h), then these functions do not need to be included
82 in the build. */
83 #ifdef WIRELESS_EXT
84
85 #define IWE_STREAM_ADD_EVENT(info, buf, end, iwe, len) \
86 iwe_stream_add_event(info, buf, end, iwe, len)
87 #define IWE_STREAM_ADD_POINT(info, buf, end, iwe, msg) \
88 iwe_stream_add_point(info, buf, end, iwe, msg)
89
90
91
92 /*******************************************************************************
93 * global definitions
94 ******************************************************************************/
95 #if DBG
96 extern dbg_info_t *DbgInfo;
97 #endif // DBG
98
99
100
101
102 /*******************************************************************************
103 * wireless_commit()
104 *******************************************************************************
105 *
106 * DESCRIPTION:
107 *
108 * Commit
109 * protocol used.
110 *
111 * PARAMETERS:
112 *
113 * wrq - the wireless request buffer
114 *
115 * RETURNS:
116 *
117 * N/A
118 *
119 ******************************************************************************/
120 static int wireless_commit(struct net_device *dev,
121 struct iw_request_info *info,
122 union iwreq_data *rqu, char *extra)
123 {
124 struct wl_private *lp = wl_priv(dev);
125 unsigned long flags;
126 int ret = 0;
127 /*------------------------------------------------------------------------*/
128
129 DBG_FUNC( "wireless_commit" );
130 DBG_ENTER(DbgInfo);
131
132 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
133 ret = -EBUSY;
134 goto out;
135 }
136
137 wl_lock( lp, &flags );
138
139 wl_act_int_off( lp );
140
141 wl_apply(lp);
142
143 wl_act_int_on( lp );
144
145 wl_unlock(lp, &flags);
146
147 out:
148 DBG_LEAVE( DbgInfo );
149 return ret;
150 } // wireless_commit
151 /*============================================================================*/
152
153
154
155
156 /*******************************************************************************
157 * wireless_get_protocol()
158 *******************************************************************************
159 *
160 * DESCRIPTION:
161 *
162 * Returns a vendor-defined string that should identify the wireless
163 * protocol used.
164 *
165 * PARAMETERS:
166 *
167 * wrq - the wireless request buffer
168 *
169 * RETURNS:
170 *
171 * N/A
172 *
173 ******************************************************************************/
174 static int wireless_get_protocol(struct net_device *dev, struct iw_request_info *info, char *name, char *extra)
175 {
176 DBG_FUNC( "wireless_get_protocol" );
177 DBG_ENTER( DbgInfo );
178
179 /* Originally, the driver was placing the string "Wireless" here. However,
180 the wireless extensions (/linux/wireless.h) indicate this string should
181 describe the wireless protocol. */
182
183 strcpy(name, "IEEE 802.11b");
184
185 DBG_LEAVE(DbgInfo);
186 return 0;
187 } // wireless_get_protocol
188 /*============================================================================*/
189
190
191
192
193 /*******************************************************************************
194 * wireless_set_frequency()
195 *******************************************************************************
196 *
197 * DESCRIPTION:
198 *
199 * Sets the frequency (channel) on which the card should Tx/Rx.
200 *
201 * PARAMETERS:
202 *
203 * wrq - the wireless request buffer
204 * lp - the device's private adapter structure
205 *
206 * RETURNS:
207 *
208 * 0 on success
209 * errno value otherwise
210 *
211 ******************************************************************************/
212 static int wireless_set_frequency(struct net_device *dev, struct iw_request_info *info, struct iw_freq *freq, char *extra)
213 {
214 struct wl_private *lp = wl_priv(dev);
215 unsigned long flags;
216 int channel = 0;
217 int ret = 0;
218 /*------------------------------------------------------------------------*/
219
220
221 DBG_FUNC( "wireless_set_frequency" );
222 DBG_ENTER( DbgInfo );
223
224 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
225 ret = -EBUSY;
226 goto out;
227 }
228
229 if( !capable( CAP_NET_ADMIN )) {
230 ret = -EPERM;
231 DBG_LEAVE( DbgInfo );
232 return ret;
233 }
234
235
236 /* If frequency specified, look up channel */
237 if( freq->e == 1 ) {
238 int f = freq->m / 100000;
239 channel = wl_get_chan_from_freq( f );
240 }
241
242
243 /* Channel specified */
244 if( freq->e == 0 ) {
245 channel = freq->m;
246 }
247
248
249 /* If the channel is an 802.11a channel, set Bit 8 */
250 if( channel > 14 ) {
251 channel = channel | 0x100;
252 }
253
254
255 wl_lock( lp, &flags );
256
257 wl_act_int_off( lp );
258
259 lp->Channel = channel;
260
261
262 /* Commit the adapter parameters */
263 wl_apply( lp );
264
265 /* Send an event that channel/freq has been set */
266 wl_wext_event_freq( lp->dev );
267
268 wl_act_int_on( lp );
269
270 wl_unlock(lp, &flags);
271
272 out:
273 DBG_LEAVE( DbgInfo );
274 return ret;
275 } // wireless_set_frequency
276 /*============================================================================*/
277
278
279
280
281 /*******************************************************************************
282 * wireless_get_frequency()
283 *******************************************************************************
284 *
285 * DESCRIPTION:
286 *
287 * Gets the frequency (channel) on which the card is Tx/Rx.
288 *
289 * PARAMETERS:
290 *
291 * wrq - the wireless request buffer
292 * lp - the device's private adapter structure
293 *
294 * RETURNS:
295 *
296 * N/A
297 *
298 ******************************************************************************/
299 static int wireless_get_frequency(struct net_device *dev, struct iw_request_info *info, struct iw_freq *freq, char *extra)
300
301 {
302 struct wl_private *lp = wl_priv(dev);
303 unsigned long flags;
304 int ret = -1;
305 /*------------------------------------------------------------------------*/
306
307
308 DBG_FUNC( "wireless_get_frequency" );
309 DBG_ENTER( DbgInfo );
310
311 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
312 ret = -EBUSY;
313 goto out;
314 }
315
316 wl_lock( lp, &flags );
317
318 wl_act_int_off( lp );
319
320 lp->ltvRecord.len = 2;
321 lp->ltvRecord.typ = CFG_CUR_CHANNEL;
322
323 ret = hcf_get_info( &(lp->hcfCtx), (LTVP)&( lp->ltvRecord ));
324 if( ret == HCF_SUCCESS ) {
325 hcf_16 channel = CNV_LITTLE_TO_INT( lp->ltvRecord.u.u16[0] );
326
327 #ifdef USE_FREQUENCY
328
329 freq->m = wl_get_freq_from_chan( channel ) * 100000;
330 freq->e = 1;
331 #else
332
333 freq->m = channel;
334 freq->e = 0;
335
336 #endif /* USE_FREQUENCY */
337 }
338
339 wl_act_int_on( lp );
340
341 wl_unlock(lp, &flags);
342
343 ret = (ret == HCF_SUCCESS ? 0 : -EFAULT);
344
345 out:
346 DBG_LEAVE( DbgInfo );
347 return ret;
348 } // wireless_get_frequency
349 /*============================================================================*/
350
351
352
353
354 /*******************************************************************************
355 * wireless_get_range()
356 *******************************************************************************
357 *
358 * DESCRIPTION:
359 *
360 * This function is used to provide misc info and statistics about the
361 * wireless device.
362 *
363 * PARAMETERS:
364 *
365 * wrq - the wireless request buffer
366 * lp - the device's private adapter structure
367 *
368 * RETURNS:
369 *
370 * 0 on success
371 * errno value otherwise
372 *
373 ******************************************************************************/
374 static int wireless_get_range(struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *extra)
375 {
376 struct wl_private *lp = wl_priv(dev);
377 unsigned long flags;
378 struct iw_range *range = (struct iw_range *) extra;
379 int ret = 0;
380 int status = -1;
381 int count;
382 __u16 *pTxRate;
383 int retries = 0;
384 /*------------------------------------------------------------------------*/
385
386
387 DBG_FUNC( "wireless_get_range" );
388 DBG_ENTER( DbgInfo );
389
390 /* Set range information */
391 data->length = sizeof(struct iw_range);
392 memset(range, 0, sizeof(struct iw_range));
393
394 wl_lock( lp, &flags );
395
396 wl_act_int_off( lp );
397
398 /* Set range information */
399 memset( range, 0, sizeof( struct iw_range ));
400
401 retry:
402 /* Get the current transmit rate from the adapter */
403 lp->ltvRecord.len = 1 + (sizeof(*pTxRate) / sizeof(hcf_16));
404 lp->ltvRecord.typ = CFG_CUR_TX_RATE;
405
406 status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
407 if( status != HCF_SUCCESS ) {
408 /* Recovery action: reset and retry up to 10 times */
409 DBG_TRACE( DbgInfo, "Get CFG_CUR_TX_RATE failed: 0x%x\n", status );
410
411 if (retries < 10) {
412 retries++;
413
414 /* Holding the lock too long, make a gap to allow other processes */
415 wl_unlock(lp, &flags);
416 wl_lock( lp, &flags );
417
418 status = wl_reset( dev );
419 if ( status != HCF_SUCCESS ) {
420 DBG_TRACE( DbgInfo, "reset failed: 0x%x\n", status );
421
422 ret = -EFAULT;
423 goto out_unlock;
424 }
425
426 /* Holding the lock too long, make a gap to allow other processes */
427 wl_unlock(lp, &flags);
428 wl_lock( lp, &flags );
429
430 goto retry;
431
432 } else {
433 DBG_TRACE( DbgInfo, "Get CFG_CUR_TX_RATE failed: %d retries\n", retries );
434 ret = -EFAULT;
435 goto out_unlock;
436 }
437 }
438
439 /* Holding the lock too long, make a gap to allow other processes */
440 wl_unlock(lp, &flags);
441 wl_lock( lp, &flags );
442
443 pTxRate = (__u16 *)&( lp->ltvRecord.u.u32 );
444
445 range->throughput = CNV_LITTLE_TO_INT( *pTxRate ) * MEGABIT;
446
447 if (retries > 0) {
448 DBG_TRACE( DbgInfo, "Get CFG_CUR_TX_RATE succes: %d retries\n", retries );
449 }
450
451 // NWID - NOT SUPPORTED
452
453
454 /* Channel/Frequency Info */
455 range->num_channels = RADIO_CHANNELS;
456
457
458 /* Signal Level Thresholds */
459 range->sensitivity = RADIO_SENSITIVITY_LEVELS;
460
461
462 /* Link quality */
463 #ifdef USE_DBM
464
465 range->max_qual.qual = (u_char)HCF_MAX_COMM_QUALITY;
466
467 /* If the value returned in /proc/net/wireless is greater than the maximum range,
468 iwconfig assumes that the value is in dBm. Because an unsigned char is used,
469 it requires a bit of contorsion... */
470
471 range->max_qual.level = (u_char)( dbm( HCF_MIN_SIGNAL_LEVEL ) - 1 );
472 range->max_qual.noise = (u_char)( dbm( HCF_MIN_NOISE_LEVEL ) - 1 );
473 #else
474
475 range->max_qual.qual = 100;
476 range->max_qual.level = 100;
477 range->max_qual.noise = 100;
478
479 #endif /* USE_DBM */
480
481
482 /* Set available rates */
483 range->num_bitrates = 0;
484
485 lp->ltvRecord.len = 6;
486 lp->ltvRecord.typ = CFG_SUPPORTED_DATA_RATES;
487
488 status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
489 if( status == HCF_SUCCESS ) {
490 for( count = 0; count < MAX_RATES; count++ )
491 if( lp->ltvRecord.u.u8[count+2] != 0 ) {
492 range->bitrate[count] = lp->ltvRecord.u.u8[count+2] * MEGABIT / 2;
493 range->num_bitrates++;
494 }
495 } else {
496 DBG_TRACE( DbgInfo, "CFG_SUPPORTED_DATA_RATES: 0x%x\n", status );
497 ret = -EFAULT;
498 goto out_unlock;
499 }
500
501 /* RTS Threshold info */
502 range->min_rts = MIN_RTS_BYTES;
503 range->max_rts = MAX_RTS_BYTES;
504
505 // Frag Threshold info - NOT SUPPORTED
506
507 // Power Management info - NOT SUPPORTED
508
509 /* Encryption */
510
511 #if WIRELESS_EXT > 8
512
513 /* Holding the lock too long, make a gap to allow other processes */
514 wl_unlock(lp, &flags);
515 wl_lock( lp, &flags );
516
517 /* Is WEP supported? */
518
519 if( wl_has_wep( &( lp->hcfCtx ))) {
520 /* WEP: RC4 40 bits */
521 range->encoding_size[0] = MIN_KEY_SIZE;
522
523 /* RC4 ~128 bits */
524 range->encoding_size[1] = MAX_KEY_SIZE;
525 range->num_encoding_sizes = 2;
526 range->max_encoding_tokens = MAX_KEYS;
527 }
528
529 #endif /* WIRELESS_EXT > 8 */
530
531 /* Tx Power Info */
532 range->txpower_capa = IW_TXPOW_MWATT;
533 range->num_txpower = 1;
534 range->txpower[0] = RADIO_TX_POWER_MWATT;
535
536 #if WIRELESS_EXT > 10
537
538 /* Wireless Extension Info */
539 range->we_version_compiled = WIRELESS_EXT;
540 range->we_version_source = WIRELESS_SUPPORT;
541
542 // Retry Limits and Lifetime - NOT SUPPORTED
543
544 #endif
545
546
547 #if WIRELESS_EXT > 11
548
549 /* Holding the lock too long, make a gap to allow other processes */
550 wl_unlock(lp, &flags);
551 wl_lock( lp, &flags );
552
553 DBG_TRACE( DbgInfo, "calling wl_wireless_stats\n" );
554 wl_wireless_stats( lp->dev );
555 range->avg_qual = lp->wstats.qual;
556 DBG_TRACE( DbgInfo, "wl_wireless_stats done\n" );
557
558 #endif
559
560 /* Event capability (kernel + driver) */
561 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
562 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
563 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
564 range->event_capa[1] = IW_EVENT_CAPA_K_1;
565 range->event_capa[4] = (IW_EVENT_CAPA_MASK(IWEVREGISTERED) |
566 IW_EVENT_CAPA_MASK(IWEVCUSTOM) |
567 IW_EVENT_CAPA_MASK(IWEVEXPIRED));
568
569 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_CIPHER_TKIP;
570
571 out_unlock:
572 wl_act_int_on( lp );
573
574 wl_unlock(lp, &flags);
575
576 DBG_LEAVE(DbgInfo);
577 return ret;
578 } // wireless_get_range
579 /*============================================================================*/
580
581
582 /*******************************************************************************
583 * wireless_get_bssid()
584 *******************************************************************************
585 *
586 * DESCRIPTION:
587 *
588 * Gets the BSSID the wireless device is currently associated with.
589 *
590 * PARAMETERS:
591 *
592 * wrq - the wireless request buffer
593 * lp - the device's private adapter structure
594 *
595 * RETURNS:
596 *
597 * 0 on success
598 * errno value otherwise
599 *
600 ******************************************************************************/
601 static int wireless_get_bssid(struct net_device *dev, struct iw_request_info *info, struct sockaddr *ap_addr, char *extra)
602 {
603 struct wl_private *lp = wl_priv(dev);
604 unsigned long flags;
605 int ret = 0;
606 #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
607 int status = -1;
608 #endif /* (HCF_TYPE) & HCF_TYPE_STA */
609 /*------------------------------------------------------------------------*/
610
611
612 DBG_FUNC( "wireless_get_bssid" );
613 DBG_ENTER( DbgInfo );
614
615 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
616 ret = -EBUSY;
617 goto out;
618 }
619
620 wl_lock( lp, &flags );
621
622 wl_act_int_off( lp );
623
624 memset( &ap_addr->sa_data, 0, ETH_ALEN );
625
626 ap_addr->sa_family = ARPHRD_ETHER;
627
628 /* Assume AP mode here, which means the BSSID is our own MAC address. In
629 STA mode, this address will be overwritten with the actual BSSID using
630 the code below. */
631 memcpy(&ap_addr->sa_data, lp->dev->dev_addr, ETH_ALEN);
632
633
634 #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
635 //;?should we return an error status in AP mode
636
637 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_STA ) {
638 /* Get Current BSSID */
639 lp->ltvRecord.typ = CFG_CUR_BSSID;
640 lp->ltvRecord.len = 4;
641 status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
642
643 if( status == HCF_SUCCESS ) {
644 /* Copy info into sockaddr struct */
645 memcpy(&ap_addr->sa_data, lp->ltvRecord.u.u8, ETH_ALEN);
646 } else {
647 ret = -EFAULT;
648 }
649 }
650
651 #endif // (HCF_TYPE) & HCF_TYPE_STA
652
653 wl_act_int_on( lp );
654
655 wl_unlock(lp, &flags);
656
657 out:
658 DBG_LEAVE(DbgInfo);
659 return ret;
660 } // wireless_get_bssid
661 /*============================================================================*/
662
663
664
665
666 /*******************************************************************************
667 * wireless_get_ap_list()
668 *******************************************************************************
669 *
670 * DESCRIPTION:
671 *
672 * Gets the results of a network scan.
673 *
674 * PARAMETERS:
675 *
676 * wrq - the wireless request buffer
677 * lp - the device's private adapter structure
678 *
679 * RETURNS:
680 *
681 * 0 on success
682 * errno value otherwise
683 *
684 * NOTE: SIOCGIWAPLIST has been deprecated by SIOCSIWSCAN. This function
685 * implements SIOCGIWAPLIST only to provide backwards compatibility. For
686 * all systems using WIRELESS_EXT v14 and higher, use SIOCSIWSCAN!
687 *
688 ******************************************************************************/
689 static int wireless_get_ap_list (struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *extra)
690 {
691 struct wl_private *lp = wl_priv(dev);
692 unsigned long flags;
693 int ret;
694 int num_aps = -1;
695 int sec_count = 0;
696 hcf_32 count;
697 struct sockaddr *hwa = NULL;
698 struct iw_quality *qual = NULL;
699 #ifdef WARP
700 ScanResult *p = &lp->scan_results;
701 #else
702 ProbeResult *p = &lp->probe_results;
703 #endif // WARP
704 /*------------------------------------------------------------------------*/
705
706 DBG_FUNC( "wireless_get_ap_list" );
707 DBG_ENTER( DbgInfo );
708
709 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
710 ret = -EBUSY;
711 goto out;
712 }
713
714 wl_lock( lp, &flags );
715
716 wl_act_int_off( lp );
717
718 /* Set the completion state to FALSE */
719 lp->scan_results.scan_complete = FALSE;
720 lp->probe_results.scan_complete = FALSE;
721 /* Channels to scan */
722 lp->ltvRecord.len = 2;
723 lp->ltvRecord.typ = CFG_SCAN_CHANNELS_2GHZ;
724 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( 0x7FFF );
725 ret = hcf_put_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
726 DBG_TRACE( DbgInfo, "CFG_SCAN_CHANNELS_2GHZ result: 0x%x\n", ret );
727
728 /* Set the SCAN_SSID to "ANY". Using this RID for scan prevents the need to
729 disassociate from the network we are currently on */
730 lp->ltvRecord.len = 2;
731 lp->ltvRecord.typ = CFG_SCAN_SSID;
732 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( 0 );
733 ret = hcf_put_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
734 DBG_TRACE( DbgInfo, "CFG_SCAN_SSID to 'any' ret: 0x%x\n", ret );
735
736 /* Initiate the scan */
737 #ifdef WARP
738 ret = hcf_action( &( lp->hcfCtx ), MDD_ACT_SCAN );
739 #else
740 ret = hcf_action( &( lp->hcfCtx ), HCF_ACT_ACS_SCAN );
741 #endif // WARP
742
743 wl_act_int_on( lp );
744
745 //;? unlock? what about the access to lp below? is it broken?
746 wl_unlock(lp, &flags);
747
748 if( ret == HCF_SUCCESS ) {
749 DBG_TRACE( DbgInfo, "SUCCESSFULLY INITIATED SCAN...\n" );
750 while( (*p).scan_complete == FALSE && ret == HCF_SUCCESS ) {
751 DBG_TRACE( DbgInfo, "Waiting for scan results...\n" );
752 /* Abort the scan if we've waited for more than MAX_SCAN_TIME_SEC */
753 if( sec_count++ > MAX_SCAN_TIME_SEC ) {
754 ret = -EIO;
755 } else {
756 /* Wait for 1 sec in 10ms intervals, scheduling the kernel to do
757 other things in the meantime, This prevents system lockups by
758 giving some time back to the kernel */
759 for( count = 0; count < 100; count ++ ) {
760 mdelay( 10 );
761 schedule( );
762 }
763 }
764 }
765
766 rmb();
767
768 if ( ret != HCF_SUCCESS ) {
769 DBG_ERROR( DbgInfo, "timeout waiting for scan results\n" );
770 } else {
771 num_aps = (*p)/*lp->probe_results*/.num_aps;
772 if (num_aps > IW_MAX_AP) {
773 num_aps = IW_MAX_AP;
774 }
775 data->length = num_aps;
776 hwa = (struct sockaddr *)extra;
777 qual = (struct iw_quality *) extra +
778 ( sizeof( struct sockaddr ) * num_aps );
779
780 /* This flag is used to tell the user if we provide quality
781 information. Since we provide signal/noise levels but no
782 quality info on a scan, this is set to 0. Setting to 1 and
783 providing a quality of 0 produces weird results. If we ever
784 provide quality (or can calculate it), this can be changed */
785 data->flags = 0;
786
787 for( count = 0; count < num_aps; count++ ) {
788 #ifdef WARP
789 memcpy( hwa[count].sa_data,
790 (*p)/*lp->scan_results*/.APTable[count].bssid, ETH_ALEN );
791 #else //;?why use BSSID and bssid as names in seemingly very comparable situations
792 DBG_PRINT("BSSID: %pM\n",
793 (*p).ProbeTable[count].BSSID);
794 memcpy( hwa[count].sa_data,
795 (*p)/*lp->probe_results*/.ProbeTable[count].BSSID, ETH_ALEN );
796 #endif // WARP
797 }
798 /* Once the data is copied to the wireless struct, invalidate the
799 scan result to initiate a rescan on the next request */
800 (*p)/*lp->probe_results*/.scan_complete = FALSE;
801 /* Send the wireless event that the scan has completed, just in case
802 it's needed */
803 wl_wext_event_scan_complete( lp->dev );
804 }
805 }
806 out:
807 DBG_LEAVE( DbgInfo );
808 return ret;
809 } // wireless_get_ap_list
810 /*============================================================================*/
811
812
813
814
815 /*******************************************************************************
816 * wireless_set_sensitivity()
817 *******************************************************************************
818 *
819 * DESCRIPTION:
820 *
821 * Sets the sensitivity (distance between APs) of the wireless card.
822 *
823 * PARAMETERS:
824 *
825 * wrq - the wireless request buffer
826 * lp - the device's private adapter structure
827 *
828 * RETURNS:
829 *
830 * 0 on success
831 * errno value otherwise
832 *
833 ******************************************************************************/
834 static int wireless_set_sensitivity(struct net_device *dev, struct iw_request_info *info, struct iw_param *sens, char *extra)
835 {
836 struct wl_private *lp = wl_priv(dev);
837 unsigned long flags;
838 int ret = 0;
839 int dens = sens->value;
840 /*------------------------------------------------------------------------*/
841
842
843 DBG_FUNC( "wireless_set_sensitivity" );
844 DBG_ENTER( DbgInfo );
845
846 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
847 ret = -EBUSY;
848 goto out;
849 }
850
851 if(( dens < 1 ) || ( dens > 3 )) {
852 ret = -EINVAL;
853 goto out;
854 }
855
856 wl_lock( lp, &flags );
857
858 wl_act_int_off( lp );
859
860 lp->DistanceBetweenAPs = dens;
861 wl_apply( lp );
862
863 wl_act_int_on( lp );
864
865 wl_unlock(lp, &flags);
866
867 out:
868 DBG_LEAVE( DbgInfo );
869 return ret;
870 } // wireless_set_sensitivity
871 /*============================================================================*/
872
873
874
875
876 /*******************************************************************************
877 * wireless_get_sensitivity()
878 *******************************************************************************
879 *
880 * DESCRIPTION:
881 *
882 * Gets the sensitivity (distance between APs) of the wireless card.
883 *
884 * PARAMETERS:
885 *
886 * wrq - the wireless request buffer
887 * lp - the device's private adapter structure
888 *
889 * RETURNS:
890 *
891 * 0 on success
892 * errno value otherwise
893 *
894 ******************************************************************************/
895 static int wireless_get_sensitivity(struct net_device *dev, struct iw_request_info *info, struct iw_param *sens, char *extra)
896 {
897 struct wl_private *lp = wl_priv(dev);
898 int ret = 0;
899 /*------------------------------------------------------------------------*/
900 /*------------------------------------------------------------------------*/
901
902
903 DBG_FUNC( "wireless_get_sensitivity" );
904 DBG_ENTER( DbgInfo );
905
906 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
907 ret = -EBUSY;
908 goto out;
909 }
910
911 /* not worth locking ... */
912 sens->value = lp->DistanceBetweenAPs;
913 sens->fixed = 0; /* auto */
914 out:
915 DBG_LEAVE( DbgInfo );
916 return ret;
917 } // wireless_get_sensitivity
918 /*============================================================================*/
919
920
921
922
923 /*******************************************************************************
924 * wireless_set_essid()
925 *******************************************************************************
926 *
927 * DESCRIPTION:
928 *
929 * Sets the ESSID (network name) that the wireless device should associate
930 * with.
931 *
932 * PARAMETERS:
933 *
934 * wrq - the wireless request buffer
935 * lp - the device's private adapter structure
936 *
937 * RETURNS:
938 *
939 * 0 on success
940 * errno value otherwise
941 *
942 ******************************************************************************/
943 static int wireless_set_essid(struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *ssid)
944 {
945 struct wl_private *lp = wl_priv(dev);
946 unsigned long flags;
947 int ret = 0;
948
949 DBG_FUNC( "wireless_set_essid" );
950 DBG_ENTER( DbgInfo );
951
952 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
953 ret = -EBUSY;
954 goto out;
955 }
956
957 if (data->flags != 0 && data->length > HCF_MAX_NAME_LEN + 1) {
958 ret = -EINVAL;
959 goto out;
960 }
961
962 wl_lock( lp, &flags );
963
964 wl_act_int_off( lp );
965
966 memset( lp->NetworkName, 0, sizeof( lp->NetworkName ));
967
968 /* data->flags is zero to ask for "any" */
969 if( data->flags == 0 ) {
970 /* Need this because in STAP build PARM_DEFAULT_SSID is "LinuxAP"
971 * ;?but there ain't no STAP anymore*/
972 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_STA ) {
973 strcpy( lp->NetworkName, "ANY" );
974 } else {
975 //strcpy( lp->NetworkName, "ANY" );
976 strcpy( lp->NetworkName, PARM_DEFAULT_SSID );
977 }
978 } else {
979 memcpy( lp->NetworkName, ssid, data->length );
980 }
981
982 DBG_NOTICE( DbgInfo, "set NetworkName: %s\n", ssid );
983
984 /* Commit the adapter parameters */
985 wl_apply( lp );
986
987 /* Send an event that ESSID has been set */
988 wl_wext_event_essid( lp->dev );
989
990 wl_act_int_on( lp );
991
992 wl_unlock(lp, &flags);
993
994 out:
995 DBG_LEAVE( DbgInfo );
996 return ret;
997 } // wireless_set_essid
998 /*============================================================================*/
999
1000
1001
1002
1003 /*******************************************************************************
1004 * wireless_get_essid()
1005 *******************************************************************************
1006 *
1007 * DESCRIPTION:
1008 *
1009 * Gets the ESSID (network name) that the wireless device is associated
1010 * with.
1011 *
1012 * PARAMETERS:
1013 *
1014 * wrq - the wireless request buffer
1015 * lp - the device's private adapter structure
1016 *
1017 * RETURNS:
1018 *
1019 * 0 on success
1020 * errno value otherwise
1021 *
1022 ******************************************************************************/
1023 static int wireless_get_essid(struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *essid)
1024
1025 {
1026 struct wl_private *lp = wl_priv(dev);
1027 unsigned long flags;
1028 int ret = 0;
1029 int status = -1;
1030 wvName_t *pName;
1031 /*------------------------------------------------------------------------*/
1032
1033
1034 DBG_FUNC( "wireless_get_essid" );
1035 DBG_ENTER( DbgInfo );
1036
1037 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1038 ret = -EBUSY;
1039 goto out;
1040 }
1041
1042 wl_lock( lp, &flags );
1043
1044 wl_act_int_off( lp );
1045
1046 /* Get the desired network name */
1047 lp->ltvRecord.len = 1 + ( sizeof( *pName ) / sizeof( hcf_16 ));
1048
1049
1050 #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
1051 //;?should we return an error status in AP mode
1052
1053 lp->ltvRecord.typ = CFG_DESIRED_SSID;
1054
1055 #endif
1056
1057
1058 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
1059 //;?should we restore this to allow smaller memory footprint
1060
1061 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ) {
1062 lp->ltvRecord.typ = CFG_CNF_OWN_SSID;
1063 }
1064
1065 #endif // HCF_AP
1066
1067
1068 status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1069 if( status == HCF_SUCCESS ) {
1070 pName = (wvName_t *)&( lp->ltvRecord.u.u32 );
1071
1072 /* Endian translate the string length */
1073 pName->length = CNV_LITTLE_TO_INT( pName->length );
1074
1075 /* Copy the information into the user buffer */
1076 data->length = pName->length;
1077
1078 /* NOTE: Null terminating is necessary for proper display of the SSID in
1079 the wireless tools */
1080 data->length = pName->length + 1;
1081 if( pName->length < HCF_MAX_NAME_LEN ) {
1082 pName->name[pName->length] = '\0';
1083 }
1084
1085 data->flags = 1;
1086
1087
1088 #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
1089 //;?should we return an error status in AP mode
1090 #ifdef RETURN_CURRENT_NETWORKNAME
1091
1092 /* if desired is null ("any"), return current or "any" */
1093 if( pName->name[0] == '\0' ) {
1094 /* Get the current network name */
1095 lp->ltvRecord.len = 1 + ( sizeof(*pName ) / sizeof( hcf_16 ));
1096 lp->ltvRecord.typ = CFG_CUR_SSID;
1097
1098 status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1099
1100 if( status == HCF_SUCCESS ) {
1101 pName = (wvName_t *)&( lp->ltvRecord.u.u32 );
1102
1103 /* Endian translate the string length */
1104 pName->length = CNV_LITTLE_TO_INT( pName->length );
1105
1106 /* Copy the information into the user buffer */
1107 data->length = pName->length + 1;
1108 if( pName->length < HCF_MAX_NAME_LEN ) {
1109 pName->name[pName->length] = '\0';
1110 }
1111
1112 data->flags = 1;
1113 } else {
1114 ret = -EFAULT;
1115 goto out_unlock;
1116 }
1117 }
1118
1119 #endif // RETURN_CURRENT_NETWORKNAME
1120 #endif // HCF_STA
1121
1122 data->length--;
1123
1124 if (pName->length > IW_ESSID_MAX_SIZE) {
1125 ret = -EFAULT;
1126 goto out_unlock;
1127 }
1128
1129 memcpy(essid, pName->name, pName->length);
1130 } else {
1131 ret = -EFAULT;
1132 goto out_unlock;
1133 }
1134
1135 out_unlock:
1136 wl_act_int_on( lp );
1137
1138 wl_unlock(lp, &flags);
1139
1140 out:
1141 DBG_LEAVE( DbgInfo );
1142 return ret;
1143 } // wireless_get_essid
1144 /*============================================================================*/
1145
1146
1147
1148
1149 /*******************************************************************************
1150 * wireless_set_encode()
1151 *******************************************************************************
1152 *
1153 * DESCRIPTION:
1154 *
1155 * Sets the encryption keys and status (enable or disable).
1156 *
1157 * PARAMETERS:
1158 *
1159 * wrq - the wireless request buffer
1160 * lp - the device's private adapter structure
1161 *
1162 * RETURNS:
1163 *
1164 * 0 on success
1165 * errno value otherwise
1166 *
1167 ******************************************************************************/
1168 static int wireless_set_encode(struct net_device *dev, struct iw_request_info *info, struct iw_point *erq, char *keybuf)
1169 {
1170 struct wl_private *lp = wl_priv(dev);
1171 unsigned long flags;
1172 int ret = 0;
1173
1174 #if 1 //;? #if WIRELESS_EXT > 8 - used unconditionally in the rest of the code...
1175 hcf_8 encryption_state;
1176 #endif // WIRELESS_EXT > 8
1177 /*------------------------------------------------------------------------*/
1178
1179
1180 DBG_FUNC( "wireless_set_encode" );
1181 DBG_ENTER( DbgInfo );
1182
1183 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1184 ret = -EBUSY;
1185 goto out;
1186 }
1187
1188 wl_lock( lp, &flags );
1189
1190 wl_act_int_off( lp );
1191
1192 /* Is encryption supported? */
1193 if( !wl_has_wep( &( lp->hcfCtx ))) {
1194 DBG_WARNING( DbgInfo, "WEP not supported on this device\n" );
1195 ret = -EOPNOTSUPP;
1196 goto out_unlock;
1197 }
1198
1199 DBG_NOTICE( DbgInfo, "pointer: %p, length: %d, flags: %#x\n",
1200 keybuf, erq->length,
1201 erq->flags);
1202
1203 /* Save state of Encryption switch */
1204 encryption_state = lp->EnableEncryption;
1205
1206 /* Basic checking: do we have a key to set? */
1207 if((erq->length) != 0) {
1208 int index = ( erq->flags & IW_ENCODE_INDEX ) - 1;
1209 int tk = lp->TransmitKeyID - 1; // current key
1210
1211
1212 /* Check the size of the key */
1213 switch(erq->length) {
1214 case 0:
1215 break;
1216
1217 case MIN_KEY_SIZE:
1218 case MAX_KEY_SIZE:
1219
1220 /* Check the index */
1221 if(( index < 0 ) || ( index >= MAX_KEYS )) {
1222 index = tk;
1223 }
1224
1225 /* Cleanup */
1226 memset( lp->DefaultKeys.key[index].key, 0, MAX_KEY_SIZE );
1227
1228 /* Copy the key in the driver */
1229 memcpy( lp->DefaultKeys.key[index].key, keybuf, erq->length);
1230
1231 /* Set the length */
1232 lp->DefaultKeys.key[index].len = erq->length;
1233
1234 DBG_NOTICE( DbgInfo, "encoding.length: %d\n", erq->length );
1235 DBG_NOTICE( DbgInfo, "set key: %s(%d) [%d]\n", lp->DefaultKeys.key[index].key,
1236 lp->DefaultKeys.key[index].len, index );
1237
1238 /* Enable WEP (if possible) */
1239 if(( index == tk ) && ( lp->DefaultKeys.key[tk].len > 0 )) {
1240 lp->EnableEncryption = 1;
1241 }
1242
1243 break;
1244
1245 default:
1246 DBG_WARNING( DbgInfo, "Invalid Key length\n" );
1247 ret = -EINVAL;
1248 goto out_unlock;
1249 }
1250 } else {
1251 int index = ( erq->flags & IW_ENCODE_INDEX ) - 1;
1252
1253
1254 /* Do we want to just set the current transmit key? */
1255 if(( index >= 0 ) && ( index < MAX_KEYS )) {
1256 DBG_NOTICE( DbgInfo, "index: %d; len: %d\n", index,
1257 lp->DefaultKeys.key[index].len );
1258
1259 if( lp->DefaultKeys.key[index].len > 0 ) {
1260 lp->TransmitKeyID = index + 1;
1261 lp->EnableEncryption = 1;
1262 } else {
1263 DBG_WARNING( DbgInfo, "Problem setting the current TxKey\n" );
1264 DBG_LEAVE( DbgInfo );
1265 ret = -EINVAL;
1266 }
1267 }
1268 }
1269
1270 /* Read the flags */
1271 if( erq->flags & IW_ENCODE_DISABLED ) {
1272 lp->EnableEncryption = 0; // disable encryption
1273 } else {
1274 lp->EnableEncryption = 1;
1275 }
1276
1277 if( erq->flags & IW_ENCODE_RESTRICTED ) {
1278 DBG_WARNING( DbgInfo, "IW_ENCODE_RESTRICTED invalid\n" );
1279 ret = -EINVAL; // Invalid
1280 }
1281
1282 DBG_TRACE( DbgInfo, "encryption_state : %d\n", encryption_state );
1283 DBG_TRACE( DbgInfo, "lp->EnableEncryption : %d\n", lp->EnableEncryption );
1284 DBG_TRACE( DbgInfo, "erq->length : %d\n",
1285 erq->length);
1286 DBG_TRACE( DbgInfo, "erq->flags : 0x%x\n",
1287 erq->flags);
1288
1289 /* Write the changes to the card */
1290 if( ret == 0 ) {
1291 DBG_NOTICE( DbgInfo, "encrypt: %d, ID: %d\n", lp->EnableEncryption,
1292 lp->TransmitKeyID );
1293
1294 if( lp->EnableEncryption == encryption_state ) {
1295 if( erq->length != 0 ) {
1296 /* Dynamic WEP key update */
1297 wl_set_wep_keys( lp );
1298 }
1299 } else {
1300 /* To switch encryption on/off, soft reset is required */
1301 wl_apply( lp );
1302 }
1303 }
1304
1305 /* Send an event that Encryption has been set */
1306 wl_wext_event_encode( dev );
1307
1308 out_unlock:
1309
1310 wl_act_int_on( lp );
1311
1312 wl_unlock(lp, &flags);
1313
1314 out:
1315 DBG_LEAVE( DbgInfo );
1316 return ret;
1317 } // wireless_set_encode
1318 /*============================================================================*/
1319
1320
1321
1322
1323 /*******************************************************************************
1324 * wireless_get_encode()
1325 *******************************************************************************
1326 *
1327 * DESCRIPTION:
1328 *
1329 * Gets the encryption keys and status.
1330 *
1331 * PARAMETERS:
1332 *
1333 * wrq - the wireless request buffer
1334 * lp - the device's private adapter structure
1335 *
1336 * RETURNS:
1337 *
1338 * 0 on success
1339 * errno value otherwise
1340 *
1341 ******************************************************************************/
1342 static int wireless_get_encode(struct net_device *dev, struct iw_request_info *info, struct iw_point *erq, char *key)
1343
1344 {
1345 struct wl_private *lp = wl_priv(dev);
1346 unsigned long flags;
1347 int ret = 0;
1348 int index;
1349 /*------------------------------------------------------------------------*/
1350
1351
1352 DBG_FUNC( "wireless_get_encode" );
1353 DBG_ENTER( DbgInfo );
1354 DBG_NOTICE(DbgInfo, "GIWENCODE: encrypt: %d, ID: %d\n", lp->EnableEncryption, lp->TransmitKeyID);
1355
1356 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1357 ret = -EBUSY;
1358 goto out;
1359 }
1360
1361 /* Only super-user can see WEP key */
1362 if( !capable( CAP_NET_ADMIN )) {
1363 ret = -EPERM;
1364 DBG_LEAVE( DbgInfo );
1365 return ret;
1366 }
1367
1368 wl_lock( lp, &flags );
1369
1370 wl_act_int_off( lp );
1371
1372 /* Is it supported? */
1373 if( !wl_has_wep( &( lp->hcfCtx ))) {
1374 ret = -EOPNOTSUPP;
1375 goto out_unlock;
1376 }
1377
1378 /* Basic checking */
1379 index = (erq->flags & IW_ENCODE_INDEX ) - 1;
1380
1381
1382 /* Set the flags */
1383 erq->flags = 0;
1384
1385 if( lp->EnableEncryption == 0 ) {
1386 erq->flags |= IW_ENCODE_DISABLED;
1387 }
1388
1389 /* Which key do we want */
1390 if(( index < 0 ) || ( index >= MAX_KEYS )) {
1391 index = lp->TransmitKeyID - 1;
1392 }
1393
1394 erq->flags |= index + 1;
1395
1396 /* Copy the key to the user buffer */
1397 erq->length = lp->DefaultKeys.key[index].len;
1398
1399 memcpy(key, lp->DefaultKeys.key[index].key, erq->length);
1400
1401 out_unlock:
1402
1403 wl_act_int_on( lp );
1404
1405 wl_unlock(lp, &flags);
1406
1407 out:
1408 DBG_LEAVE( DbgInfo );
1409 return ret;
1410 } // wireless_get_encode
1411 /*============================================================================*/
1412
1413
1414
1415
1416 /*******************************************************************************
1417 * wireless_set_nickname()
1418 *******************************************************************************
1419 *
1420 * DESCRIPTION:
1421 *
1422 * Sets the nickname, or station name, of the wireless device.
1423 *
1424 * PARAMETERS:
1425 *
1426 * wrq - the wireless request buffer
1427 * lp - the device's private adapter structure
1428 *
1429 * RETURNS:
1430 *
1431 * 0 on success
1432 * errno value otherwise
1433 *
1434 ******************************************************************************/
1435 static int wireless_set_nickname(struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *nickname)
1436 {
1437 struct wl_private *lp = wl_priv(dev);
1438 unsigned long flags;
1439 int ret = 0;
1440 /*------------------------------------------------------------------------*/
1441
1442
1443 DBG_FUNC( "wireless_set_nickname" );
1444 DBG_ENTER( DbgInfo );
1445
1446 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1447 ret = -EBUSY;
1448 goto out;
1449 }
1450
1451 #if 0 //;? Needed, was present in original code but not in 7.18 Linux 2.6 kernel version
1452 if( !capable(CAP_NET_ADMIN )) {
1453 ret = -EPERM;
1454 DBG_LEAVE( DbgInfo );
1455 return ret;
1456 }
1457 #endif
1458
1459 /* Validate the new value */
1460 if(data->length > HCF_MAX_NAME_LEN) {
1461 ret = -EINVAL;
1462 goto out;
1463 }
1464
1465 wl_lock( lp, &flags );
1466
1467 wl_act_int_off( lp );
1468
1469 memset( lp->StationName, 0, sizeof( lp->StationName ));
1470
1471 memcpy( lp->StationName, nickname, data->length );
1472
1473 /* Commit the adapter parameters */
1474 wl_apply( lp );
1475
1476 wl_act_int_on( lp );
1477
1478 wl_unlock(lp, &flags);
1479
1480 out:
1481 DBG_LEAVE( DbgInfo );
1482 return ret;
1483 } // wireless_set_nickname
1484 /*============================================================================*/
1485
1486
1487
1488
1489 /*******************************************************************************
1490 * wireless_get_nickname()
1491 *******************************************************************************
1492 *
1493 * DESCRIPTION:
1494 *
1495 * Gets the nickname, or station name, of the wireless device.
1496 *
1497 * PARAMETERS:
1498 *
1499 * wrq - the wireless request buffer
1500 * lp - the device's private adapter structure
1501 *
1502 * RETURNS:
1503 *
1504 * 0 on success
1505 * errno value otherwise
1506 *
1507 ******************************************************************************/
1508 static int wireless_get_nickname(struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *nickname)
1509 {
1510 struct wl_private *lp = wl_priv(dev);
1511 unsigned long flags;
1512 int ret = 0;
1513 int status = -1;
1514 wvName_t *pName;
1515 /*------------------------------------------------------------------------*/
1516
1517
1518 DBG_FUNC( "wireless_get_nickname" );
1519 DBG_ENTER( DbgInfo );
1520
1521 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1522 ret = -EBUSY;
1523 goto out;
1524 }
1525
1526 wl_lock( lp, &flags );
1527
1528 wl_act_int_off( lp );
1529
1530 /* Get the current station name */
1531 lp->ltvRecord.len = 1 + ( sizeof( *pName ) / sizeof( hcf_16 ));
1532 lp->ltvRecord.typ = CFG_CNF_OWN_NAME;
1533
1534 status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1535
1536 if( status == HCF_SUCCESS ) {
1537 pName = (wvName_t *)&( lp->ltvRecord.u.u32 );
1538
1539 /* Endian translate the length */
1540 pName->length = CNV_LITTLE_TO_INT( pName->length );
1541
1542 if ( pName->length > IW_ESSID_MAX_SIZE ) {
1543 ret = -EFAULT;
1544 } else {
1545 /* Copy the information into the user buffer */
1546 data->length = pName->length;
1547 memcpy(nickname, pName->name, pName->length);
1548 }
1549 } else {
1550 ret = -EFAULT;
1551 }
1552
1553 wl_act_int_on( lp );
1554
1555 wl_unlock(lp, &flags);
1556
1557 out:
1558 DBG_LEAVE(DbgInfo);
1559 return ret;
1560 } // wireless_get_nickname
1561 /*============================================================================*/
1562
1563
1564
1565
1566 /*******************************************************************************
1567 * wireless_set_porttype()
1568 *******************************************************************************
1569 *
1570 * DESCRIPTION:
1571 *
1572 * Sets the port type of the wireless device.
1573 *
1574 * PARAMETERS:
1575 *
1576 * wrq - the wireless request buffer
1577 * lp - the device's private adapter structure
1578 *
1579 * RETURNS:
1580 *
1581 * 0 on success
1582 * errno value otherwise
1583 *
1584 ******************************************************************************/
1585 static int wireless_set_porttype(struct net_device *dev, struct iw_request_info *info, __u32 *mode, char *extra)
1586 {
1587 struct wl_private *lp = wl_priv(dev);
1588 unsigned long flags;
1589 int ret = 0;
1590 hcf_16 portType;
1591 hcf_16 createIBSS;
1592 /*------------------------------------------------------------------------*/
1593
1594 DBG_FUNC( "wireless_set_porttype" );
1595 DBG_ENTER( DbgInfo );
1596
1597 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1598 ret = -EBUSY;
1599 goto out;
1600 }
1601
1602 wl_lock( lp, &flags );
1603
1604 wl_act_int_off( lp );
1605
1606 /* Validate the new value */
1607 switch( *mode ) {
1608 case IW_MODE_ADHOC:
1609
1610 /* When user requests ad-hoc, set IBSS mode! */
1611 portType = 1;
1612 createIBSS = 1;
1613
1614 lp->DownloadFirmware = WVLAN_DRV_MODE_STA; //1;
1615
1616 break;
1617
1618
1619 case IW_MODE_AUTO:
1620 case IW_MODE_INFRA:
1621
1622 /* Both automatic and infrastructure set port to BSS/STA mode */
1623 portType = 1;
1624 createIBSS = 0;
1625
1626 lp->DownloadFirmware = WVLAN_DRV_MODE_STA; //1;
1627
1628 break;
1629
1630
1631 #if 0 //;? (HCF_TYPE) & HCF_TYPE_AP
1632
1633 case IW_MODE_MASTER:
1634
1635 /* Set BSS/AP mode */
1636 portType = 1;
1637
1638 lp->CreateIBSS = 0;
1639 lp->DownloadFirmware = WVLAN_DRV_MODE_AP; //2;
1640
1641 break;
1642
1643 #endif /* (HCF_TYPE) & HCF_TYPE_AP */
1644
1645
1646 default:
1647
1648 portType = 0;
1649 createIBSS = 0;
1650 ret = -EINVAL;
1651 }
1652
1653 if( portType != 0 ) {
1654 /* Only do something if there is a mode change */
1655 if( ( lp->PortType != portType ) || (lp->CreateIBSS != createIBSS)) {
1656 lp->PortType = portType;
1657 lp->CreateIBSS = createIBSS;
1658
1659 /* Commit the adapter parameters */
1660 wl_go( lp );
1661
1662 /* Send an event that mode has been set */
1663 wl_wext_event_mode( lp->dev );
1664 }
1665 }
1666
1667 wl_act_int_on( lp );
1668
1669 wl_unlock(lp, &flags);
1670
1671 out:
1672 DBG_LEAVE( DbgInfo );
1673 return ret;
1674 } // wireless_set_porttype
1675 /*============================================================================*/
1676
1677
1678
1679
1680 /*******************************************************************************
1681 * wireless_get_porttype()
1682 *******************************************************************************
1683 *
1684 * DESCRIPTION:
1685 *
1686 * Gets the port type of the wireless device.
1687 *
1688 * PARAMETERS:
1689 *
1690 * wrq - the wireless request buffer
1691 * lp - the device's private adapter structure
1692 *
1693 * RETURNS:
1694 *
1695 * 0 on success
1696 * errno value otherwise
1697 *
1698 ******************************************************************************/
1699 static int wireless_get_porttype(struct net_device *dev, struct iw_request_info *info, __u32 *mode, char *extra)
1700
1701 {
1702 struct wl_private *lp = wl_priv(dev);
1703 unsigned long flags;
1704 int ret = 0;
1705 int status = -1;
1706 hcf_16 *pPortType;
1707 /*------------------------------------------------------------------------*/
1708
1709
1710 DBG_FUNC( "wireless_get_porttype" );
1711 DBG_ENTER( DbgInfo );
1712
1713 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1714 ret = -EBUSY;
1715 goto out;
1716 }
1717
1718 wl_lock( lp, &flags );
1719
1720 wl_act_int_off( lp );
1721
1722 /* Get the current port type */
1723 lp->ltvRecord.len = 1 + ( sizeof( *pPortType ) / sizeof( hcf_16 ));
1724 lp->ltvRecord.typ = CFG_CNF_PORT_TYPE;
1725
1726 status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1727
1728 if( status == HCF_SUCCESS ) {
1729 pPortType = (hcf_16 *)&( lp->ltvRecord.u.u32 );
1730
1731 *pPortType = CNV_LITTLE_TO_INT( *pPortType );
1732
1733 switch( *pPortType ) {
1734 case 1:
1735
1736 #if 0
1737 #if (HCF_TYPE) & HCF_TYPE_AP
1738
1739 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ) {
1740 *mode = IW_MODE_MASTER;
1741 } else {
1742 *mode = IW_MODE_INFRA;
1743 }
1744
1745 #else
1746
1747 *mode = IW_MODE_INFRA;
1748
1749 #endif /* (HCF_TYPE) & HCF_TYPE_AP */
1750 #endif
1751
1752 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ) {
1753 *mode = IW_MODE_MASTER;
1754 } else {
1755 if( lp->CreateIBSS ) {
1756 *mode = IW_MODE_ADHOC;
1757 } else {
1758 *mode = IW_MODE_INFRA;
1759 }
1760 }
1761
1762 break;
1763
1764
1765 case 3:
1766 *mode = IW_MODE_ADHOC;
1767 break;
1768
1769 default:
1770 ret = -EFAULT;
1771 break;
1772 }
1773 } else {
1774 ret = -EFAULT;
1775 }
1776
1777 wl_act_int_on( lp );
1778
1779 wl_unlock(lp, &flags);
1780
1781 out:
1782 DBG_LEAVE( DbgInfo );
1783 return ret;
1784 } // wireless_get_porttype
1785 /*============================================================================*/
1786
1787
1788
1789
1790 /*******************************************************************************
1791 * wireless_set_power()
1792 *******************************************************************************
1793 *
1794 * DESCRIPTION:
1795 *
1796 * Sets the power management settings of the wireless device.
1797 *
1798 * PARAMETERS:
1799 *
1800 * wrq - the wireless request buffer
1801 * lp - the device's private adapter structure
1802 *
1803 * RETURNS:
1804 *
1805 * 0 on success
1806 * errno value otherwise
1807 *
1808 ******************************************************************************/
1809 static int wireless_set_power(struct net_device *dev, struct iw_request_info *info, struct iw_param *wrq, char *extra)
1810 {
1811 struct wl_private *lp = wl_priv(dev);
1812 unsigned long flags;
1813 int ret = 0;
1814 /*------------------------------------------------------------------------*/
1815
1816
1817 DBG_FUNC( "wireless_set_power" );
1818 DBG_ENTER( DbgInfo );
1819
1820 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1821 ret = -EBUSY;
1822 goto out;
1823 }
1824
1825 DBG_PRINT( "THIS CORRUPTS PMEnabled ;?!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n" );
1826
1827 #if 0 //;? Needed, was present in original code but not in 7.18 Linux 2.6 kernel version
1828 if( !capable( CAP_NET_ADMIN )) {
1829 ret = -EPERM;
1830
1831 DBG_LEAVE( DbgInfo );
1832 return ret;
1833 }
1834 #endif
1835
1836 wl_lock( lp, &flags );
1837
1838 wl_act_int_off( lp );
1839
1840 /* Set the power management state based on the 'disabled' value */
1841 if( wrq->disabled ) {
1842 lp->PMEnabled = 0;
1843 } else {
1844 lp->PMEnabled = 1;
1845 }
1846
1847 /* Commit the adapter parameters */
1848 wl_apply( lp );
1849
1850 wl_act_int_on( lp );
1851
1852 wl_unlock(lp, &flags);
1853
1854 out:
1855 DBG_LEAVE( DbgInfo );
1856 return ret;
1857 } // wireless_set_power
1858 /*============================================================================*/
1859
1860
1861
1862
1863 /*******************************************************************************
1864 * wireless_get_power()
1865 *******************************************************************************
1866 *
1867 * DESCRIPTION:
1868 *
1869 * Gets the power management settings of the wireless device.
1870 *
1871 * PARAMETERS:
1872 *
1873 * wrq - the wireless request buffer
1874 * lp - the device's private adapter structure
1875 *
1876 * RETURNS:
1877 *
1878 * 0 on success
1879 * errno value otherwise
1880 *
1881 ******************************************************************************/
1882 static int wireless_get_power(struct net_device *dev, struct iw_request_info *info, struct iw_param *rrq, char *extra)
1883
1884 {
1885 struct wl_private *lp = wl_priv(dev);
1886 unsigned long flags;
1887 int ret = 0;
1888 /*------------------------------------------------------------------------*/
1889 DBG_FUNC( "wireless_get_power" );
1890 DBG_ENTER( DbgInfo );
1891
1892 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1893 ret = -EBUSY;
1894 goto out;
1895 }
1896
1897 DBG_PRINT( "THIS IS PROBABLY AN OVER-SIMPLIFICATION ;?!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n" );
1898
1899 wl_lock( lp, &flags );
1900
1901 wl_act_int_off( lp );
1902
1903 rrq->flags = 0;
1904 rrq->value = 0;
1905
1906 if( lp->PMEnabled ) {
1907 rrq->disabled = 0;
1908 } else {
1909 rrq->disabled = 1;
1910 }
1911
1912 wl_act_int_on( lp );
1913
1914 wl_unlock(lp, &flags);
1915
1916 out:
1917 DBG_LEAVE( DbgInfo );
1918 return ret;
1919 } // wireless_get_power
1920 /*============================================================================*/
1921
1922
1923
1924
1925 /*******************************************************************************
1926 * wireless_get_tx_power()
1927 *******************************************************************************
1928 *
1929 * DESCRIPTION:
1930 *
1931 * Gets the transmit power of the wireless device's radio.
1932 *
1933 * PARAMETERS:
1934 *
1935 * wrq - the wireless request buffer
1936 * lp - the device's private adapter structure
1937 *
1938 * RETURNS:
1939 *
1940 * 0 on success
1941 * errno value otherwise
1942 *
1943 ******************************************************************************/
1944 static int wireless_get_tx_power(struct net_device *dev, struct iw_request_info *info, struct iw_param *rrq, char *extra)
1945 {
1946 struct wl_private *lp = wl_priv(dev);
1947 unsigned long flags;
1948 int ret = 0;
1949 /*------------------------------------------------------------------------*/
1950 DBG_FUNC( "wireless_get_tx_power" );
1951 DBG_ENTER( DbgInfo );
1952
1953 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1954 ret = -EBUSY;
1955 goto out;
1956 }
1957
1958 wl_lock( lp, &flags );
1959
1960 wl_act_int_off( lp );
1961
1962 #ifdef USE_POWER_DBM
1963 rrq->value = RADIO_TX_POWER_DBM;
1964 rrq->flags = IW_TXPOW_DBM;
1965 #else
1966 rrq->value = RADIO_TX_POWER_MWATT;
1967 rrq->flags = IW_TXPOW_MWATT;
1968 #endif
1969 rrq->fixed = 1;
1970 rrq->disabled = 0;
1971
1972 wl_act_int_on( lp );
1973
1974 wl_unlock(lp, &flags);
1975
1976 out:
1977 DBG_LEAVE( DbgInfo );
1978 return ret;
1979 } // wireless_get_tx_power
1980 /*============================================================================*/
1981
1982
1983
1984
1985 /*******************************************************************************
1986 * wireless_set_rts_threshold()
1987 *******************************************************************************
1988 *
1989 * DESCRIPTION:
1990 *
1991 * Sets the RTS threshold for the wireless card.
1992 *
1993 * PARAMETERS:
1994 *
1995 * wrq - the wireless request buffer
1996 * lp - the device's private adapter structure
1997 *
1998 * RETURNS:
1999 *
2000 * 0 on success
2001 * errno value otherwise
2002 *
2003 ******************************************************************************/
2004 static int wireless_set_rts_threshold (struct net_device *dev, struct iw_request_info *info, struct iw_param *rts, char *extra)
2005 {
2006 int ret = 0;
2007 struct wl_private *lp = wl_priv(dev);
2008 unsigned long flags;
2009 int rthr = rts->value;
2010 /*------------------------------------------------------------------------*/
2011
2012
2013 DBG_FUNC( "wireless_set_rts_threshold" );
2014 DBG_ENTER( DbgInfo );
2015
2016 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
2017 ret = -EBUSY;
2018 goto out;
2019 }
2020
2021 if(rts->fixed == 0) {
2022 ret = -EINVAL;
2023 goto out;
2024 }
2025
2026 #if WIRELESS_EXT > 8
2027 if( rts->disabled ) {
2028 rthr = 2347;
2029 }
2030 #endif /* WIRELESS_EXT > 8 */
2031
2032 if(( rthr < 256 ) || ( rthr > 2347 )) {
2033 ret = -EINVAL;
2034 goto out;
2035 }
2036
2037 wl_lock( lp, &flags );
2038
2039 wl_act_int_off( lp );
2040
2041 lp->RTSThreshold = rthr;
2042
2043 wl_apply( lp );
2044
2045 wl_act_int_on( lp );
2046
2047 wl_unlock(lp, &flags);
2048
2049 out:
2050 DBG_LEAVE( DbgInfo );
2051 return ret;
2052 } // wireless_set_rts_threshold
2053 /*============================================================================*/
2054
2055
2056
2057
2058 /*******************************************************************************
2059 * wireless_get_rts_threshold()
2060 *******************************************************************************
2061 *
2062 * DESCRIPTION:
2063 *
2064 * Gets the RTS threshold for the wireless card.
2065 *
2066 * PARAMETERS:
2067 *
2068 * wrq - the wireless request buffer
2069 * lp - the device's private adapter structure
2070 *
2071 * RETURNS:
2072 *
2073 * 0 on success
2074 * errno value otherwise
2075 *
2076 ******************************************************************************/
2077 static int wireless_get_rts_threshold (struct net_device *dev, struct iw_request_info *info, struct iw_param *rts, char *extra)
2078 {
2079 int ret = 0;
2080 struct wl_private *lp = wl_priv(dev);
2081 unsigned long flags;
2082 /*------------------------------------------------------------------------*/
2083
2084 DBG_FUNC( "wireless_get_rts_threshold" );
2085 DBG_ENTER( DbgInfo );
2086
2087 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
2088 ret = -EBUSY;
2089 goto out;
2090 }
2091
2092 wl_lock( lp, &flags );
2093
2094 wl_act_int_off( lp );
2095
2096 rts->value = lp->RTSThreshold;
2097
2098 #if WIRELESS_EXT > 8
2099
2100 rts->disabled = ( rts->value == 2347 );
2101
2102 #endif /* WIRELESS_EXT > 8 */
2103
2104 rts->fixed = 1;
2105
2106 wl_act_int_on( lp );
2107
2108 wl_unlock(lp, &flags);
2109
2110 out:
2111 DBG_LEAVE( DbgInfo );
2112 return ret;
2113 } // wireless_get_rts_threshold
2114 /*============================================================================*/
2115
2116
2117
2118
2119
2120 /*******************************************************************************
2121 * wireless_set_rate()
2122 *******************************************************************************
2123 *
2124 * DESCRIPTION:
2125 *
2126 * Set the default data rate setting used by the wireless device.
2127 *
2128 * PARAMETERS:
2129 *
2130 * wrq - the wireless request buffer
2131 * lp - the device's private adapter structure
2132 *
2133 * RETURNS:
2134 *
2135 * 0 on success
2136 * errno value otherwise
2137 *
2138 ******************************************************************************/
2139 static int wireless_set_rate(struct net_device *dev, struct iw_request_info *info, struct iw_param *rrq, char *extra)
2140 {
2141 struct wl_private *lp = wl_priv(dev);
2142 unsigned long flags;
2143 int ret = 0;
2144 #ifdef WARP
2145 int status = -1;
2146 int index = 0;
2147 #endif // WARP
2148 /*------------------------------------------------------------------------*/
2149
2150
2151 DBG_FUNC( "wireless_set_rate" );
2152 DBG_ENTER( DbgInfo );
2153
2154 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
2155 ret = -EBUSY;
2156 goto out;
2157 }
2158
2159 wl_lock( lp, &flags );
2160
2161 wl_act_int_off( lp );
2162
2163 #ifdef WARP
2164
2165 /* Determine if the card is operating in the 2.4 or 5.0 GHz band; check
2166 if Bit 9 is set in the current channel RID */
2167 lp->ltvRecord.len = 2;
2168 lp->ltvRecord.typ = CFG_CUR_CHANNEL;
2169
2170 status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
2171
2172 if( status == HCF_SUCCESS ) {
2173 index = ( CNV_LITTLE_TO_INT( lp->ltvRecord.u.u16[0] ) & 0x100 ) ? 1 : 0;
2174
2175 DBG_PRINT( "Index: %d\n", index );
2176 } else {
2177 DBG_ERROR( DbgInfo, "Could not determine radio frequency\n" );
2178 DBG_LEAVE( DbgInfo );
2179 ret = -EINVAL;
2180 goto out_unlock;
2181 }
2182
2183 if( rrq->value > 0 &&
2184 rrq->value <= 1 * MEGABIT ) {
2185 lp->TxRateControl[index] = 0x0001;
2186 }
2187 else if( rrq->value > 1 * MEGABIT &&
2188 rrq->value <= 2 * MEGABIT ) {
2189 if( rrq->fixed == 1 ) {
2190 lp->TxRateControl[index] = 0x0002;
2191 } else {
2192 lp->TxRateControl[index] = 0x0003;
2193 }
2194 }
2195 else if( rrq->value > 2 * MEGABIT &&
2196 rrq->value <= 5 * MEGABIT ) {
2197 if( rrq->fixed == 1 ) {
2198 lp->TxRateControl[index] = 0x0004;
2199 } else {
2200 lp->TxRateControl[index] = 0x0007;
2201 }
2202 }
2203 else if( rrq->value > 5 * MEGABIT &&
2204 rrq->value <= 6 * MEGABIT ) {
2205 if( rrq->fixed == 1 ) {
2206 lp->TxRateControl[index] = 0x0010;
2207 } else {
2208 lp->TxRateControl[index] = 0x0017;
2209 }
2210 }
2211 else if( rrq->value > 6 * MEGABIT &&
2212 rrq->value <= 9 * MEGABIT ) {
2213 if( rrq->fixed == 1 ) {
2214 lp->TxRateControl[index] = 0x0020;
2215 } else {
2216 lp->TxRateControl[index] = 0x0037;
2217 }
2218 }
2219 else if( rrq->value > 9 * MEGABIT &&
2220 rrq->value <= 11 * MEGABIT ) {
2221 if( rrq->fixed == 1 ) {
2222 lp->TxRateControl[index] = 0x0008;
2223 } else {
2224 lp->TxRateControl[index] = 0x003F;
2225 }
2226 }
2227 else if( rrq->value > 11 * MEGABIT &&
2228 rrq->value <= 12 * MEGABIT ) {
2229 if( rrq->fixed == 1 ) {
2230 lp->TxRateControl[index] = 0x0040;
2231 } else {
2232 lp->TxRateControl[index] = 0x007F;
2233 }
2234 }
2235 else if( rrq->value > 12 * MEGABIT &&
2236 rrq->value <= 18 * MEGABIT ) {
2237 if( rrq->fixed == 1 ) {
2238 lp->TxRateControl[index] = 0x0080;
2239 } else {
2240 lp->TxRateControl[index] = 0x00FF;
2241 }
2242 }
2243 else if( rrq->value > 18 * MEGABIT &&
2244 rrq->value <= 24 * MEGABIT ) {
2245 if( rrq->fixed == 1 ) {
2246 lp->TxRateControl[index] = 0x0100;
2247 } else {
2248 lp->TxRateControl[index] = 0x01FF;
2249 }
2250 }
2251 else if( rrq->value > 24 * MEGABIT &&
2252 rrq->value <= 36 * MEGABIT ) {
2253 if( rrq->fixed == 1 ) {
2254 lp->TxRateControl[index] = 0x0200;
2255 } else {
2256 lp->TxRateControl[index] = 0x03FF;
2257 }
2258 }
2259 else if( rrq->value > 36 * MEGABIT &&
2260 rrq->value <= 48 * MEGABIT ) {
2261 if( rrq->fixed == 1 ) {
2262 lp->TxRateControl[index] = 0x0400;
2263 } else {
2264 lp->TxRateControl[index] = 0x07FF;
2265 }
2266 }
2267 else if( rrq->value > 48 * MEGABIT &&
2268 rrq->value <= 54 * MEGABIT ) {
2269 if( rrq->fixed == 1 ) {
2270 lp->TxRateControl[index] = 0x0800;
2271 } else {
2272 lp->TxRateControl[index] = 0x0FFF;
2273 }
2274 }
2275 else if( rrq->fixed == 0 ) {
2276 /* In this case, the user has not specified a bitrate, only the "auto"
2277 moniker. So, set to all supported rates */
2278 lp->TxRateControl[index] = PARM_MAX_TX_RATE;
2279 } else {
2280 rrq->value = 0;
2281 ret = -EINVAL;
2282 goto out_unlock;
2283 }
2284
2285
2286 #else
2287
2288 if( rrq->value > 0 &&
2289 rrq->value <= 1 * MEGABIT ) {
2290 lp->TxRateControl[0] = 1;
2291 }
2292 else if( rrq->value > 1 * MEGABIT &&
2293 rrq->value <= 2 * MEGABIT ) {
2294 if( rrq->fixed ) {
2295 lp->TxRateControl[0] = 2;
2296 } else {
2297 lp->TxRateControl[0] = 6;
2298 }
2299 }
2300 else if( rrq->value > 2 * MEGABIT &&
2301 rrq->value <= 5 * MEGABIT ) {
2302 if( rrq->fixed ) {
2303 lp->TxRateControl[0] = 4;
2304 } else {
2305 lp->TxRateControl[0] = 7;
2306 }
2307 }
2308 else if( rrq->value > 5 * MEGABIT &&
2309 rrq->value <= 11 * MEGABIT ) {
2310 if( rrq->fixed) {
2311 lp->TxRateControl[0] = 5;
2312 } else {
2313 lp->TxRateControl[0] = 3;
2314 }
2315 }
2316 else if( rrq->fixed == 0 ) {
2317 /* In this case, the user has not specified a bitrate, only the "auto"
2318 moniker. So, set the rate to 11Mb auto */
2319 lp->TxRateControl[0] = 3;
2320 } else {
2321 rrq->value = 0;
2322 ret = -EINVAL;
2323 goto out_unlock;
2324 }
2325
2326 #endif // WARP
2327
2328
2329 /* Commit the adapter parameters */
2330 wl_apply( lp );
2331
2332 out_unlock:
2333
2334 wl_act_int_on( lp );
2335
2336 wl_unlock(lp, &flags);
2337
2338 out:
2339 DBG_LEAVE( DbgInfo );
2340 return ret;
2341 } // wireless_set_rate
2342 /*============================================================================*/
2343
2344
2345
2346
2347 /*******************************************************************************
2348 * wireless_get_rate()
2349 *******************************************************************************
2350 *
2351 * DESCRIPTION:
2352 *
2353 * Get the default data rate setting used by the wireless device.
2354 *
2355 * PARAMETERS:
2356 *
2357 * wrq - the wireless request buffer
2358 * lp - the device's private adapter structure
2359 *
2360 * RETURNS:
2361 *
2362 * 0 on success
2363 * errno value otherwise
2364 *
2365 ******************************************************************************/
2366 static int wireless_get_rate(struct net_device *dev, struct iw_request_info *info, struct iw_param *rrq, char *extra)
2367
2368 {
2369 struct wl_private *lp = wl_priv(dev);
2370 unsigned long flags;
2371 int ret = 0;
2372 int status = -1;
2373 hcf_16 txRate;
2374 /*------------------------------------------------------------------------*/
2375
2376
2377 DBG_FUNC( "wireless_get_rate" );
2378 DBG_ENTER( DbgInfo );
2379
2380 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
2381 ret = -EBUSY;
2382 goto out;
2383 }
2384
2385 wl_lock( lp, &flags );
2386
2387 wl_act_int_off( lp );
2388
2389 /* Get the current transmit rate from the adapter */
2390 lp->ltvRecord.len = 1 + ( sizeof(txRate)/sizeof(hcf_16));
2391 lp->ltvRecord.typ = CFG_CUR_TX_RATE;
2392
2393 status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
2394
2395 if( status == HCF_SUCCESS ) {
2396 #ifdef WARP
2397
2398 txRate = CNV_LITTLE_TO_INT( lp->ltvRecord.u.u16[0] );
2399
2400 if( txRate & 0x0001 ) {
2401 txRate = 1;
2402 }
2403 else if( txRate & 0x0002 ) {
2404 txRate = 2;
2405 }
2406 else if( txRate & 0x0004 ) {
2407 txRate = 5;
2408 }
2409 else if( txRate & 0x0008 ) {
2410 txRate = 11;
2411 }
2412 else if( txRate & 0x00010 ) {
2413 txRate = 6;
2414 }
2415 else if( txRate & 0x00020 ) {
2416 txRate = 9;
2417 }
2418 else if( txRate & 0x00040 ) {
2419 txRate = 12;
2420 }
2421 else if( txRate & 0x00080 ) {
2422 txRate = 18;
2423 }
2424 else if( txRate & 0x00100 ) {
2425 txRate = 24;
2426 }
2427 else if( txRate & 0x00200 ) {
2428 txRate = 36;
2429 }
2430 else if( txRate & 0x00400 ) {
2431 txRate = 48;
2432 }
2433 else if( txRate & 0x00800 ) {
2434 txRate = 54;
2435 }
2436
2437 #else
2438
2439 txRate = (hcf_16)CNV_LITTLE_TO_LONG( lp->ltvRecord.u.u32[0] );
2440
2441 #endif // WARP
2442
2443 rrq->value = txRate * MEGABIT;
2444 } else {
2445 rrq->value = 0;
2446 ret = -EFAULT;
2447 }
2448
2449 wl_act_int_on( lp );
2450
2451 wl_unlock(lp, &flags);
2452
2453 out:
2454 DBG_LEAVE( DbgInfo );
2455 return ret;
2456 } // wireless_get_rate
2457 /*============================================================================*/
2458
2459
2460
2461
2462 #if 0 //;? Not used anymore
2463 /*******************************************************************************
2464 * wireless_get_private_interface()
2465 *******************************************************************************
2466 *
2467 * DESCRIPTION:
2468 *
2469 * Returns the Linux Wireless Extensions' compatible private interface of
2470 * the driver.
2471 *
2472 * PARAMETERS:
2473 *
2474 * wrq - the wireless request buffer
2475 * lp - the device's private adapter structure
2476 *
2477 * RETURNS:
2478 *
2479 * 0 on success
2480 * errno value otherwise
2481 *
2482 ******************************************************************************/
2483 int wireless_get_private_interface( struct iwreq *wrq, struct wl_private *lp )
2484 {
2485 int ret = 0;
2486 /*------------------------------------------------------------------------*/
2487
2488
2489 DBG_FUNC( "wireless_get_private_interface" );
2490 DBG_ENTER( DbgInfo );
2491
2492 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
2493 ret = -EBUSY;
2494 goto out;
2495 }
2496
2497 if( wrq->u.data.pointer != NULL ) {
2498 struct iw_priv_args priv[] =
2499 {
2500 { SIOCSIWNETNAME, IW_PRIV_TYPE_CHAR | HCF_MAX_NAME_LEN, 0, "snetwork_name" },
2501 { SIOCGIWNETNAME, 0, IW_PRIV_TYPE_CHAR | HCF_MAX_NAME_LEN, "gnetwork_name" },
2502 { SIOCSIWSTANAME, IW_PRIV_TYPE_CHAR | HCF_MAX_NAME_LEN, 0, "sstation_name" },
2503 { SIOCGIWSTANAME, 0, IW_PRIV_TYPE_CHAR | HCF_MAX_NAME_LEN, "gstation_name" },
2504 { SIOCSIWPORTTYPE, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, 0, "sport_type" },
2505 { SIOCGIWPORTTYPE, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "gport_type" },
2506 };
2507
2508 /* Verify the user buffer */
2509 ret = verify_area( VERIFY_WRITE, wrq->u.data.pointer, sizeof( priv ));
2510
2511 if( ret != 0 ) {
2512 DBG_LEAVE( DbgInfo );
2513 return ret;
2514 }
2515
2516 /* Copy the data into the user's buffer */
2517 wrq->u.data.length = NELEM( priv );
2518 copy_to_user( wrq->u.data.pointer, &priv, sizeof( priv ));
2519 }
2520
2521 out:
2522 DBG_LEAVE( DbgInfo );
2523 return ret;
2524 } // wireless_get_private_interface
2525 /*============================================================================*/
2526 #endif
2527
2528
2529
2530 #if WIRELESS_EXT > 13
2531
2532 /*******************************************************************************
2533 * wireless_set_scan()
2534 *******************************************************************************
2535 *
2536 * DESCRIPTION:
2537 *
2538 * Instructs the driver to initiate a network scan.
2539 *
2540 * PARAMETERS:
2541 *
2542 * wrq - the wireless request buffer
2543 * lp - the device's private adapter structure
2544 *
2545 * RETURNS:
2546 *
2547 * 0 on success
2548 * errno value otherwise
2549 *
2550 ******************************************************************************/
2551 static int wireless_set_scan(struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *extra)
2552 {
2553 struct wl_private *lp = wl_priv(dev);
2554 unsigned long flags;
2555 int ret = 0;
2556 int status = -1;
2557 int retries = 0;
2558 /*------------------------------------------------------------------------*/
2559
2560 //;? Note: shows results as trace, retruns always 0 unless BUSY
2561
2562 DBG_FUNC( "wireless_set_scan" );
2563 DBG_ENTER( DbgInfo );
2564
2565 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
2566 ret = -EBUSY;
2567 goto out;
2568 }
2569
2570 wl_lock( lp, &flags );
2571
2572 wl_act_int_off( lp );
2573
2574 /*
2575 * This looks like a nice place to test if the HCF is still
2576 * communicating with the card. It seems that sometimes BAP_1
2577 * gets corrupted. By looking at the comments in HCF the
2578 * cause is still a mystery. Okay, the communication to the
2579 * card is dead, reset the card to revive.
2580 */
2581 if((lp->hcfCtx.IFB_CardStat & CARD_STAT_DEFUNCT) != 0)
2582 {
2583 DBG_TRACE( DbgInfo, "CARD is in DEFUNCT mode, reset it to bring it back to life\n" );
2584 wl_reset( dev );
2585 }
2586
2587 retry:
2588 /* Set the completion state to FALSE */
2589 lp->probe_results.scan_complete = FALSE;
2590
2591
2592 /* Channels to scan */
2593 #ifdef WARP
2594 lp->ltvRecord.len = 5;
2595 lp->ltvRecord.typ = CFG_SCAN_CHANNEL;
2596 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( 0x3FFF ); // 2.4 GHz Band
2597 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( 0xFFFF ); // 5.0 GHz Band
2598 lp->ltvRecord.u.u16[2] = CNV_INT_TO_LITTLE( 0xFFFF ); // ..
2599 lp->ltvRecord.u.u16[3] = CNV_INT_TO_LITTLE( 0x0007 ); // ..
2600 #else
2601 lp->ltvRecord.len = 2;
2602 lp->ltvRecord.typ = CFG_SCAN_CHANNEL;
2603 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( 0x7FFF );
2604 #endif // WARP
2605
2606 status = hcf_put_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
2607
2608 DBG_TRACE( DbgInfo, "CFG_SCAN_CHANNEL result : 0x%x\n", status );
2609
2610 // Holding the lock too long, make a gap to allow other processes
2611 wl_unlock(lp, &flags);
2612 wl_lock( lp, &flags );
2613
2614 if( status != HCF_SUCCESS ) {
2615 //Recovery
2616 retries++;
2617 if(retries <= 10) {
2618 DBG_TRACE( DbgInfo, "Reset card to recover, attempt: %d\n", retries );
2619 wl_reset( dev );
2620
2621 // Holding the lock too long, make a gap to allow other processes
2622 wl_unlock(lp, &flags);
2623 wl_lock( lp, &flags );
2624
2625 goto retry;
2626 }
2627 }
2628
2629 /* Set the SCAN_SSID to "ANY". Using this RID for scan prevents the need to
2630 disassociate from the network we are currently on */
2631 lp->ltvRecord.len = 18;
2632 lp->ltvRecord.typ = CFG_SCAN_SSID;
2633 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( 0 );
2634 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( 0 );
2635
2636 status = hcf_put_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
2637
2638 // Holding the lock too long, make a gap to allow other processes
2639 wl_unlock(lp, &flags);
2640 wl_lock( lp, &flags );
2641
2642 DBG_TRACE( DbgInfo, "CFG_SCAN_SSID to 'any' status: 0x%x\n", status );
2643
2644 /* Initiate the scan */
2645 /* NOTE: Using HCF_ACT_SCAN has been removed, as using HCF_ACT_ACS_SCAN to
2646 retrieve probe responses must always be used to support WPA */
2647 status = hcf_action( &( lp->hcfCtx ), HCF_ACT_ACS_SCAN );
2648
2649 if( status == HCF_SUCCESS ) {
2650 DBG_TRACE( DbgInfo, "SUCCESSFULLY INITIATED SCAN...\n" );
2651 } else {
2652 DBG_TRACE( DbgInfo, "INITIATE SCAN FAILED...\n" );
2653 }
2654
2655 wl_act_int_on( lp );
2656
2657 wl_unlock(lp, &flags);
2658
2659 out:
2660 DBG_LEAVE(DbgInfo);
2661 return ret;
2662 } // wireless_set_scan
2663 /*============================================================================*/
2664
2665
2666
2667
2668 /*******************************************************************************
2669 * wireless_get_scan()
2670 *******************************************************************************
2671 *
2672 * DESCRIPTION:
2673 *
2674 * Instructs the driver to gather and return the results of a network scan.
2675 *
2676 * PARAMETERS:
2677 *
2678 * wrq - the wireless request buffer
2679 * lp - the device's private adapter structure
2680 *
2681 * RETURNS:
2682 *
2683 * 0 on success
2684 * errno value otherwise
2685 *
2686 ******************************************************************************/
2687 static int wireless_get_scan(struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *extra)
2688 {
2689 struct wl_private *lp = wl_priv(dev);
2690 unsigned long flags;
2691 int ret = 0;
2692 int count;
2693 char *buf;
2694 char *buf_end;
2695 struct iw_event iwe;
2696 PROBE_RESP *probe_resp;
2697 hcf_8 msg[512];
2698 hcf_8 *wpa_ie;
2699 hcf_16 wpa_ie_len;
2700 /*------------------------------------------------------------------------*/
2701
2702
2703 DBG_FUNC( "wireless_get_scan" );
2704 DBG_ENTER( DbgInfo );
2705
2706 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
2707 ret = -EBUSY;
2708 goto out;
2709 }
2710
2711 wl_lock( lp, &flags );
2712
2713 wl_act_int_off( lp );
2714
2715 /* If the scan is not done, tell the calling process to try again later */
2716 if( !lp->probe_results.scan_complete ) {
2717 ret = -EAGAIN;
2718 goto out_unlock;
2719 }
2720
2721 DBG_TRACE( DbgInfo, "SCAN COMPLETE, Num of APs: %d\n",
2722 lp->probe_results.num_aps );
2723
2724 buf = extra;
2725 buf_end = extra + IW_SCAN_MAX_DATA;
2726
2727 for( count = 0; count < lp->probe_results.num_aps; count++ ) {
2728 /* Reference the probe response from the table */
2729 probe_resp = (PROBE_RESP *)&lp->probe_results.ProbeTable[count];
2730
2731
2732 /* First entry MUST be the MAC address */
2733 memset( &iwe, 0, sizeof( iwe ));
2734
2735 iwe.cmd = SIOCGIWAP;
2736 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
2737 memcpy( iwe.u.ap_addr.sa_data, probe_resp->BSSID, ETH_ALEN);
2738 iwe.len = IW_EV_ADDR_LEN;
2739
2740 buf = IWE_STREAM_ADD_EVENT(info, buf, buf_end, &iwe, IW_EV_ADDR_LEN);
2741
2742
2743 /* Use the mode to indicate if it's a station or AP */
2744 /* Won't always be an AP if in IBSS mode */
2745 memset( &iwe, 0, sizeof( iwe ));
2746
2747 iwe.cmd = SIOCGIWMODE;
2748
2749 if( probe_resp->capability & CAPABILITY_IBSS ) {
2750 iwe.u.mode = IW_MODE_INFRA;
2751 } else {
2752 iwe.u.mode = IW_MODE_MASTER;
2753 }
2754
2755 iwe.len = IW_EV_UINT_LEN;
2756
2757 buf = IWE_STREAM_ADD_EVENT(info, buf, buf_end, &iwe, IW_EV_UINT_LEN);
2758
2759
2760 /* Any quality information */
2761 memset(&iwe, 0, sizeof(iwe));
2762
2763 iwe.cmd = IWEVQUAL;
2764 iwe.u.qual.level = dbm(probe_resp->signal);
2765 iwe.u.qual.noise = dbm(probe_resp->silence);
2766 iwe.u.qual.qual = iwe.u.qual.level - iwe.u.qual.noise;
2767 iwe.u.qual.updated = lp->probe_results.scan_complete | IW_QUAL_DBM;
2768 iwe.len = IW_EV_QUAL_LEN;
2769
2770 buf = IWE_STREAM_ADD_EVENT(info, buf, buf_end, &iwe, IW_EV_QUAL_LEN);
2771
2772
2773 /* ESSID information */
2774 if( probe_resp->rawData[1] > 0 ) {
2775 memset( &iwe, 0, sizeof( iwe ));
2776
2777 iwe.cmd = SIOCGIWESSID;
2778 iwe.u.data.length = probe_resp->rawData[1];
2779 iwe.u.data.flags = 1;
2780
2781 buf = IWE_STREAM_ADD_POINT(info, buf, buf_end, &iwe, &probe_resp->rawData[2]);
2782 }
2783
2784
2785 /* Encryption Information */
2786 memset( &iwe, 0, sizeof( iwe ));
2787
2788 iwe.cmd = SIOCGIWENCODE;
2789 iwe.u.data.length = 0;
2790
2791 /* Check the capabilities field of the Probe Response to see if
2792 'privacy' is supported on the AP in question */
2793 if( probe_resp->capability & CAPABILITY_PRIVACY ) {
2794 iwe.u.data.flags |= IW_ENCODE_ENABLED;
2795 } else {
2796 iwe.u.data.flags |= IW_ENCODE_DISABLED;
2797 }
2798
2799 buf = IWE_STREAM_ADD_POINT(info, buf, buf_end, &iwe, NULL);
2800
2801
2802 /* Frequency Info */
2803 memset( &iwe, 0, sizeof( iwe ));
2804
2805 iwe.cmd = SIOCGIWFREQ;
2806 iwe.len = IW_EV_FREQ_LEN;
2807 iwe.u.freq.m = wl_parse_ds_ie( probe_resp );
2808 iwe.u.freq.e = 0;
2809
2810 buf = IWE_STREAM_ADD_EVENT(info, buf, buf_end, &iwe, IW_EV_FREQ_LEN);
2811
2812
2813 #if WIRELESS_EXT > 14
2814 /* Custom info (Beacon Interval) */
2815 memset( &iwe, 0, sizeof( iwe ));
2816 memset( msg, 0, sizeof( msg ));
2817
2818 iwe.cmd = IWEVCUSTOM;
2819 sprintf( msg, "beacon_interval=%d", probe_resp->beaconInterval );
2820 iwe.u.data.length = strlen( msg );
2821
2822 buf = IWE_STREAM_ADD_POINT(info, buf, buf_end, &iwe, msg);
2823
2824
2825 /* Custom info (WPA-IE) */
2826 wpa_ie = NULL;
2827 wpa_ie_len = 0;
2828
2829 wpa_ie = wl_parse_wpa_ie( probe_resp, &wpa_ie_len );
2830 if( wpa_ie != NULL ) {
2831 memset( &iwe, 0, sizeof( iwe ));
2832 memset( msg, 0, sizeof( msg ));
2833
2834 iwe.cmd = IWEVCUSTOM;
2835 sprintf( msg, "wpa_ie=%s", wl_print_wpa_ie( wpa_ie, wpa_ie_len ));
2836 iwe.u.data.length = strlen( msg );
2837
2838 buf = IWE_STREAM_ADD_POINT(info, buf, buf_end, &iwe, msg);
2839 }
2840
2841 /* Add other custom info in formatted string format as needed... */
2842 #endif
2843 }
2844
2845 data->length = buf - extra;
2846
2847 out_unlock:
2848
2849 wl_act_int_on( lp );
2850
2851 wl_unlock(lp, &flags);
2852
2853 out:
2854 DBG_LEAVE( DbgInfo );
2855 return ret;
2856 } // wireless_get_scan
2857 /*============================================================================*/
2858
2859 #endif // WIRELESS_EXT > 13
2860
2861
2862 #if WIRELESS_EXT > 17
2863
2864 static int wireless_set_auth(struct net_device *dev,
2865 struct iw_request_info *info,
2866 struct iw_param *data, char *extra)
2867 {
2868 struct wl_private *lp = wl_priv(dev);
2869 unsigned long flags;
2870 int ret;
2871 int iwa_idx = data->flags & IW_AUTH_INDEX;
2872 int iwa_val = data->value;
2873
2874 DBG_FUNC( "wireless_set_auth" );
2875 DBG_ENTER( DbgInfo );
2876
2877 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
2878 ret = -EBUSY;
2879 goto out;
2880 }
2881
2882 wl_lock( lp, &flags );
2883
2884 wl_act_int_off( lp );
2885
2886 switch (iwa_idx) {
2887 case IW_AUTH_WPA_VERSION:
2888 DBG_TRACE( DbgInfo, "IW_AUTH_WPA_VERSION\n");
2889 /* We do support WPA only; how should DISABLED be treated? */
2890 if (iwa_val == IW_AUTH_WPA_VERSION_WPA)
2891 ret = 0;
2892 else
2893 ret = -EINVAL;
2894 break;
2895
2896 case IW_AUTH_WPA_ENABLED:
2897 DBG_TRACE( DbgInfo, "IW_AUTH_WPA_ENABLED: val = %d\n", iwa_val);
2898 if (iwa_val)
2899 lp->EnableEncryption = 2;
2900 else
2901 lp->EnableEncryption = 0;
2902 ret = 0;
2903 break;
2904
2905 case IW_AUTH_TKIP_COUNTERMEASURES:
2906 DBG_TRACE( DbgInfo, "IW_AUTH_TKIP_COUNTERMEASURES\n");
2907 lp->driverEnable = !iwa_val;
2908 if(lp->driverEnable)
2909 hcf_cntl(&(lp->hcfCtx), HCF_CNTL_ENABLE | HCF_PORT_0);
2910 else
2911 hcf_cntl(&(lp->hcfCtx), HCF_CNTL_DISABLE | HCF_PORT_0);
2912 ret = 0;
2913 break;
2914
2915 case IW_AUTH_DROP_UNENCRYPTED:
2916 DBG_TRACE( DbgInfo, "IW_AUTH_DROP_UNENCRYPTED\n");
2917 /* We do not actually do anything here, just to silence
2918 * wpa_supplicant */
2919 ret = 0;
2920 break;
2921
2922 case IW_AUTH_CIPHER_PAIRWISE:
2923 DBG_TRACE( DbgInfo, "IW_AUTH_CIPHER_PAIRWISE\n");
2924 /* not implemented, return an error */
2925 ret = -EINVAL;
2926 break;
2927
2928 case IW_AUTH_CIPHER_GROUP:
2929 DBG_TRACE( DbgInfo, "IW_AUTH_CIPHER_GROUP\n");
2930 /* not implemented, return an error */
2931 ret = -EINVAL;
2932 break;
2933
2934 case IW_AUTH_KEY_MGMT:
2935 DBG_TRACE( DbgInfo, "IW_AUTH_KEY_MGMT\n");
2936 /* not implemented, return an error */
2937 ret = -EINVAL;
2938 break;
2939
2940 case IW_AUTH_80211_AUTH_ALG:
2941 DBG_TRACE( DbgInfo, "IW_AUTH_80211_AUTH_ALG\n");
2942 /* not implemented, return an error */
2943 ret = -EINVAL;
2944 break;
2945
2946 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
2947 DBG_TRACE( DbgInfo, "IW_AUTH_RX_UNENCRYPTED_EAPOL\n");
2948 /* not implemented, return an error */
2949 ret = -EINVAL;
2950 break;
2951
2952 case IW_AUTH_ROAMING_CONTROL:
2953 DBG_TRACE( DbgInfo, "IW_AUTH_ROAMING_CONTROL\n");
2954 /* not implemented, return an error */
2955 ret = -EINVAL;
2956 break;
2957
2958 case IW_AUTH_PRIVACY_INVOKED:
2959 DBG_TRACE( DbgInfo, "IW_AUTH_PRIVACY_INVOKED\n");
2960 /* not implemented, return an error */
2961 ret = -EINVAL;
2962 break;
2963
2964 default:
2965 DBG_TRACE( DbgInfo, "IW_AUTH_?? (%d) unknown\n", iwa_idx);
2966 /* return an error */
2967 ret = -EINVAL;
2968 break;
2969 }
2970
2971 wl_act_int_on( lp );
2972
2973 wl_unlock(lp, &flags);
2974
2975 out:
2976 DBG_LEAVE( DbgInfo );
2977 return ret;
2978 } // wireless_set_auth
2979 /*============================================================================*/
2980
2981
2982
2983 static int hermes_set_key(ltv_t *ltv, int alg, int key_idx, u8 *addr,
2984 int set_tx, u8 *seq, u8 *key, size_t key_len)
2985 {
2986 int ret = -EINVAL;
2987 // int count = 0;
2988 int buf_idx = 0;
2989 hcf_8 tsc[IW_ENCODE_SEQ_MAX_SIZE] =
2990 { 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00 };
2991
2992 DBG_FUNC( "hermes_set_key" );
2993 DBG_ENTER( DbgInfo );
2994
2995 /*
2996 * Check the key index here; if 0, load as Pairwise Key, otherwise,
2997 * load as a group key. Note that for the Hermes, the RIDs for
2998 * group/pariwise keys are different from each other and different
2999 * than the default WEP keys as well.
3000 */
3001 switch (alg)
3002 {
3003 case IW_ENCODE_ALG_TKIP:
3004 DBG_TRACE( DbgInfo, "IW_ENCODE_ALG_TKIP: key(%d)\n", key_idx);
3005 #if 0
3006 /*
3007 * Make sure that there is no data queued up in the firmware
3008 * before setting the TKIP keys. If this check is not
3009 * performed, some data may be sent out with incorrect MIC
3010 * and cause synchronizarion errors with the AP
3011 */
3012 /* Check every 1ms for 100ms */
3013 for( count = 0; count < 100; count++ )
3014 {
3015 usleep( 1000 );
3016
3017 ltv.len = 2;
3018 ltv.typ = 0xFD91; // This RID not defined in HCF yet!!!
3019 ltv.u.u16[0] = 0;
3020
3021 wl_get_info( sock, &ltv, ifname );
3022
3023 if( ltv.u.u16[0] == 0 )
3024 {
3025 break;
3026 }
3027 }
3028
3029 if( count == 100 )
3030 {
3031 wpa_printf( MSG_DEBUG, "Timed out waiting for TxQ!" );
3032 }
3033 #endif
3034
3035 switch (key_idx) {
3036 case 0:
3037 ltv->len = 28;
3038 ltv->typ = CFG_ADD_TKIP_MAPPED_KEY;
3039
3040 /* Load the BSSID */
3041 memcpy(&ltv->u.u8[buf_idx], addr, ETH_ALEN);
3042 buf_idx += ETH_ALEN;
3043
3044 /* Load the TKIP key */
3045 memcpy(&ltv->u.u8[buf_idx], &key[0], 16);
3046 buf_idx += 16;
3047
3048 /* Load the TSC */
3049 memcpy(&ltv->u.u8[buf_idx], tsc, IW_ENCODE_SEQ_MAX_SIZE);
3050 buf_idx += IW_ENCODE_SEQ_MAX_SIZE;
3051
3052 /* Load the RSC */
3053 memcpy(&ltv->u.u8[buf_idx], seq, IW_ENCODE_SEQ_MAX_SIZE);
3054 buf_idx += IW_ENCODE_SEQ_MAX_SIZE;
3055
3056 /* Load the TxMIC key */
3057 memcpy(&ltv->u.u8[buf_idx], &key[16], 8);
3058 buf_idx += 8;
3059
3060 /* Load the RxMIC key */
3061 memcpy(&ltv->u.u8[buf_idx], &key[24], 8);
3062
3063 ret = 0;
3064 break;
3065 case 1:
3066 case 2:
3067 case 3:
3068 ltv->len = 26;
3069 ltv->typ = CFG_ADD_TKIP_DEFAULT_KEY;
3070
3071 /* Load the key Index */
3072 ltv->u.u16[buf_idx] = key_idx;
3073 /* If this is a Tx Key, set bit 8000 */
3074 if(set_tx)
3075 ltv->u.u16[buf_idx] |= 0x8000;
3076 buf_idx += 2;
3077
3078 /* Load the RSC */
3079 memcpy(&ltv->u.u8[buf_idx], seq, IW_ENCODE_SEQ_MAX_SIZE);
3080 buf_idx += IW_ENCODE_SEQ_MAX_SIZE;
3081
3082 /* Load the TKIP, TxMIC, and RxMIC keys in one shot, because in
3083 CFG_ADD_TKIP_DEFAULT_KEY they are back-to-back */
3084 memcpy(&ltv->u.u8[buf_idx], key, key_len);
3085 buf_idx += key_len;
3086
3087 /* Load the TSC */
3088 memcpy(&ltv->u.u8[buf_idx], tsc, IW_ENCODE_SEQ_MAX_SIZE);
3089
3090 ltv->u.u16[0] = CNV_INT_TO_LITTLE(ltv->u.u16[0]);
3091
3092 ret = 0;
3093 break;
3094 default:
3095 break;
3096 }
3097
3098 break;
3099
3100 case IW_ENCODE_ALG_WEP:
3101 DBG_TRACE( DbgInfo, "IW_ENCODE_ALG_WEP: key(%d)\n", key_idx);
3102 break;
3103
3104 case IW_ENCODE_ALG_CCMP:
3105 DBG_TRACE( DbgInfo, "IW_ENCODE_ALG_CCMP: key(%d)\n", key_idx);
3106 break;
3107
3108 case IW_ENCODE_ALG_NONE:
3109 DBG_TRACE( DbgInfo, "IW_ENCODE_ALG_NONE: key(%d)\n", key_idx);
3110 switch (key_idx) {
3111 case 0:
3112 if (memcmp(addr, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) != 0) {
3113 //if (addr != NULL) {
3114 ltv->len = 7;
3115 ltv->typ = CFG_REMOVE_TKIP_MAPPED_KEY;
3116 memcpy(&ltv->u.u8[0], addr, ETH_ALEN);
3117 ret = 0;
3118 }
3119 break;
3120 case 1:
3121 case 2:
3122 case 3:
3123 /* Clear the Group TKIP keys by index */
3124 ltv->len = 2;
3125 ltv->typ = CFG_REMOVE_TKIP_DEFAULT_KEY;
3126 ltv->u.u16[0] = key_idx;
3127
3128 ret = 0;
3129 break;
3130 default:
3131 break;
3132 }
3133 break;
3134 default:
3135 DBG_TRACE( DbgInfo, "IW_ENCODE_??: key(%d)\n", key_idx);
3136 break;
3137 }
3138
3139 DBG_LEAVE( DbgInfo );
3140 return ret;
3141 } // hermes_set_key
3142 /*============================================================================*/
3143
3144
3145
3146 static int wireless_set_encodeext (struct net_device *dev,
3147 struct iw_request_info *info,
3148 struct iw_point *erq, char *keybuf)
3149 {
3150 struct wl_private *lp = wl_priv(dev);
3151 unsigned long flags;
3152 int ret;
3153 int key_idx = (erq->flags&IW_ENCODE_INDEX) - 1;
3154 ltv_t ltv;
3155 struct iw_encode_ext *ext = (struct iw_encode_ext *)keybuf;
3156
3157 DBG_FUNC( "wireless_set_encodeext" );
3158 DBG_ENTER( DbgInfo );
3159
3160 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
3161 ret = -EBUSY;
3162 goto out;
3163 }
3164
3165 if (sizeof(ext->rx_seq) != 8) {
3166 DBG_TRACE(DbgInfo, "rz_seq size mismatch\n");
3167 DBG_LEAVE(DbgInfo);
3168 return -EINVAL;
3169 }
3170
3171 /* Handle WEP keys via the old set encode procedure */
3172 if(ext->alg == IW_ENCODE_ALG_WEP) {
3173 struct iw_point wep_erq;
3174 char *wep_keybuf;
3175
3176 /* Build request structure */
3177 wep_erq.flags = erq->flags; // take over flags with key index
3178 wep_erq.length = ext->key_len; // take length from extended key info
3179 wep_keybuf = ext->key; // pointer to the key text
3180
3181 /* Call wireless_set_encode tot handle the WEP key */
3182 ret = wireless_set_encode(dev, info, &wep_erq, wep_keybuf);
3183 goto out;
3184 }
3185
3186 /* Proceed for extended encode functions for WAP and NONE */
3187 wl_lock( lp, &flags );
3188
3189 wl_act_int_off( lp );
3190
3191 memset(&ltv, 0, sizeof(ltv));
3192 ret = hermes_set_key(&ltv, ext->alg, key_idx, ext->addr.sa_data,
3193 ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY,
3194 ext->rx_seq, ext->key, ext->key_len);
3195
3196 if (ret != 0) {
3197 DBG_TRACE( DbgInfo, "hermes_set_key returned != 0, key not set\n");
3198 goto out_unlock;
3199 }
3200
3201 /* Put the key in HCF */
3202 ret = hcf_put_info(&(lp->hcfCtx), (LTVP)&ltv);
3203
3204 out_unlock:
3205 if(ret == HCF_SUCCESS) {
3206 DBG_TRACE( DbgInfo, "Put key info succes\n");
3207 } else {
3208 DBG_TRACE( DbgInfo, "Put key info failed, key not set\n");
3209 }
3210
3211 wl_act_int_on( lp );
3212
3213 wl_unlock(lp, &flags);
3214
3215 out:
3216 DBG_LEAVE( DbgInfo );
3217 return ret;
3218 } // wireless_set_encodeext
3219 /*============================================================================*/
3220
3221
3222
3223 static int wireless_get_genie(struct net_device *dev,
3224 struct iw_request_info *info,
3225 struct iw_point *data, char *extra)
3226
3227 {
3228 struct wl_private *lp = wl_priv(dev);
3229 unsigned long flags;
3230 int ret = 0;
3231 ltv_t ltv;
3232
3233 DBG_FUNC( "wireless_get_genie" );
3234 DBG_ENTER( DbgInfo );
3235
3236 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
3237 ret = -EBUSY;
3238 goto out;
3239 }
3240
3241 wl_lock( lp, &flags );
3242
3243 wl_act_int_off( lp );
3244
3245 memset(&ltv, 0, sizeof(ltv));
3246 ltv.len = 2;
3247 ltv.typ = CFG_SET_WPA_AUTH_KEY_MGMT_SUITE;
3248 lp->AuthKeyMgmtSuite = ltv.u.u16[0] = 4;
3249 ltv.u.u16[0] = CNV_INT_TO_LITTLE(ltv.u.u16[0]);
3250
3251 ret = hcf_put_info(&(lp->hcfCtx), (LTVP)&ltv);
3252
3253 wl_act_int_on( lp );
3254
3255 wl_unlock(lp, &flags);
3256
3257 out:
3258 DBG_LEAVE( DbgInfo );
3259 return ret;
3260 }
3261 /*============================================================================*/
3262
3263
3264 #endif // WIRELESS_EXT > 17
3265
3266 /*******************************************************************************
3267 * wl_wireless_stats()
3268 *******************************************************************************
3269 *
3270 * DESCRIPTION:
3271 *
3272 * Return the current device wireless statistics.
3273 *
3274 * PARAMETERS:
3275 *
3276 * wrq - the wireless request buffer
3277 * lp - the device's private adapter structure
3278 *
3279 * RETURNS:
3280 *
3281 * 0 on success
3282 * errno value otherwise
3283 *
3284 ******************************************************************************/
3285 struct iw_statistics * wl_wireless_stats( struct net_device *dev )
3286 {
3287 struct iw_statistics *pStats;
3288 struct wl_private *lp = wl_priv(dev);
3289 /*------------------------------------------------------------------------*/
3290
3291
3292 DBG_FUNC( "wl_wireless_stats" );
3293 DBG_ENTER(DbgInfo);
3294 DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev);
3295
3296 pStats = NULL;
3297
3298 /* Initialize the statistics */
3299 pStats = &( lp->wstats );
3300 pStats->qual.updated = 0x00;
3301
3302 if( !( lp->flags & WVLAN2_UIL_BUSY ))
3303 {
3304 CFG_COMMS_QUALITY_STRCT *pQual;
3305 CFG_HERMES_TALLIES_STRCT tallies;
3306 int status;
3307
3308 /* Update driver status */
3309 pStats->status = 0;
3310
3311 /* Get the current link quality information */
3312 lp->ltvRecord.len = 1 + ( sizeof( *pQual ) / sizeof( hcf_16 ));
3313 lp->ltvRecord.typ = CFG_COMMS_QUALITY;
3314 status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
3315
3316 if( status == HCF_SUCCESS ) {
3317 pQual = (CFG_COMMS_QUALITY_STRCT *)&( lp->ltvRecord );
3318
3319 #ifdef USE_DBM
3320 pStats->qual.qual = (u_char) CNV_LITTLE_TO_INT( pQual->coms_qual );
3321 pStats->qual.level = (u_char) dbm( CNV_LITTLE_TO_INT( pQual->signal_lvl ));
3322 pStats->qual.noise = (u_char) dbm( CNV_LITTLE_TO_INT( pQual->noise_lvl ));
3323
3324 pStats->qual.updated |= (IW_QUAL_QUAL_UPDATED |
3325 IW_QUAL_LEVEL_UPDATED |
3326 IW_QUAL_NOISE_UPDATED |
3327 IW_QUAL_DBM);
3328 #else
3329 pStats->qual.qual = percent( CNV_LITTLE_TO_INT( pQual->coms_qual ),
3330 HCF_MIN_COMM_QUALITY,
3331 HCF_MAX_COMM_QUALITY );
3332
3333 pStats->qual.level = percent( CNV_LITTLE_TO_INT( pQual->signal_lvl ),
3334 HCF_MIN_SIGNAL_LEVEL,
3335 HCF_MAX_SIGNAL_LEVEL );
3336
3337 pStats->qual.noise = percent( CNV_LITTLE_TO_INT( pQual->noise_lvl ),
3338 HCF_MIN_NOISE_LEVEL,
3339 HCF_MAX_NOISE_LEVEL );
3340
3341 pStats->qual.updated |= (IW_QUAL_QUAL_UPDATED |
3342 IW_QUAL_LEVEL_UPDATED |
3343 IW_QUAL_NOISE_UPDATED);
3344 #endif /* USE_DBM */
3345 } else {
3346 memset( &( pStats->qual ), 0, sizeof( pStats->qual ));
3347 }
3348
3349 /* Get the current tallies from the adapter */
3350 /* Only possible when the device is open */
3351 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
3352 if( wl_get_tallies( lp, &tallies ) == 0 ) {
3353 /* No endian translation is needed here, as CFG_TALLIES is an
3354 MSF RID; all processing is done on the host, not the card! */
3355 pStats->discard.nwid = 0L;
3356 pStats->discard.code = tallies.RxWEPUndecryptable;
3357 pStats->discard.misc = tallies.TxDiscards +
3358 tallies.RxFCSErrors +
3359 //tallies.RxDiscardsNoBuffer +
3360 tallies.TxDiscardsWrongSA;
3361 //;? Extra taken over from Linux driver based on 7.18 version
3362 pStats->discard.retries = tallies.TxRetryLimitExceeded;
3363 pStats->discard.fragment = tallies.RxMsgInBadMsgFragments;
3364 } else {
3365 memset( &( pStats->discard ), 0, sizeof( pStats->discard ));
3366 }
3367 } else {
3368 memset( &( pStats->discard ), 0, sizeof( pStats->discard ));
3369 }
3370 }
3371
3372 DBG_LEAVE( DbgInfo );
3373 return pStats;
3374 } // wl_wireless_stats
3375 /*============================================================================*/
3376
3377
3378
3379
3380 /*******************************************************************************
3381 * wl_get_wireless_stats()
3382 *******************************************************************************
3383 *
3384 * DESCRIPTION:
3385 *
3386 * Return the current device wireless statistics. This function calls
3387 * wl_wireless_stats, but acquires spinlocks first as it can be called
3388 * directly by the network layer.
3389 *
3390 * PARAMETERS:
3391 *
3392 * wrq - the wireless request buffer
3393 * lp - the device's private adapter structure
3394 *
3395 * RETURNS:
3396 *
3397 * 0 on success
3398 * errno value otherwise
3399 *
3400 ******************************************************************************/
3401 struct iw_statistics * wl_get_wireless_stats( struct net_device *dev )
3402 {
3403 unsigned long flags;
3404 struct wl_private *lp = wl_priv(dev);
3405 struct iw_statistics *pStats = NULL;
3406 /*------------------------------------------------------------------------*/
3407
3408 DBG_FUNC( "wl_get_wireless_stats" );
3409 DBG_ENTER(DbgInfo);
3410
3411 wl_lock( lp, &flags );
3412
3413 wl_act_int_off( lp );
3414
3415 #ifdef USE_RTS
3416 if( lp->useRTS == 1 ) {
3417 DBG_TRACE( DbgInfo, "Skipping wireless stats, in RTS mode\n" );
3418 } else
3419 #endif
3420 {
3421 pStats = wl_wireless_stats( dev );
3422 }
3423 wl_act_int_on( lp );
3424
3425 wl_unlock(lp, &flags);
3426
3427 DBG_LEAVE( DbgInfo );
3428 return pStats;
3429 } // wl_get_wireless_stats
3430
3431
3432 /*******************************************************************************
3433 * wl_spy_gather()
3434 *******************************************************************************
3435 *
3436 * DESCRIPTION:
3437 *
3438 * Gather wireless spy statistics.
3439 *
3440 * PARAMETERS:
3441 *
3442 * wrq - the wireless request buffer
3443 * lp - the device's private adapter structure
3444 *
3445 * RETURNS:
3446 *
3447 * 0 on success
3448 * errno value otherwise
3449 *
3450 ******************************************************************************/
3451 inline void wl_spy_gather( struct net_device *dev, u_char *mac )
3452 {
3453 struct iw_quality wstats;
3454 int status;
3455 u_char stats[2];
3456 DESC_STRCT desc[1];
3457 struct wl_private *lp = wl_priv(dev);
3458 /*------------------------------------------------------------------------*/
3459
3460 /* shortcut */
3461 if (!lp->spy_data.spy_number) {
3462 return;
3463 }
3464
3465 /* Gather wireless spy statistics: for each packet, compare the source
3466 address with out list, and if match, get the stats. */
3467 memset( stats, 0, sizeof(stats));
3468 memset( desc, 0, sizeof(DESC_STRCT));
3469
3470 desc[0].buf_addr = stats;
3471 desc[0].BUF_SIZE = sizeof(stats);
3472 desc[0].next_desc_addr = 0; // terminate list
3473
3474 status = hcf_rcv_msg( &( lp->hcfCtx ), &desc[0], 0 );
3475
3476 if( status == HCF_SUCCESS ) {
3477 wstats.level = (u_char) dbm(stats[1]);
3478 wstats.noise = (u_char) dbm(stats[0]);
3479 wstats.qual = wstats.level > wstats.noise ? wstats.level - wstats.noise : 0;
3480
3481 wstats.updated = (IW_QUAL_QUAL_UPDATED |
3482 IW_QUAL_LEVEL_UPDATED |
3483 IW_QUAL_NOISE_UPDATED |
3484 IW_QUAL_DBM);
3485
3486 wireless_spy_update( dev, mac, &wstats );
3487 }
3488 } // wl_spy_gather
3489 /*============================================================================*/
3490
3491
3492
3493
3494 /*******************************************************************************
3495 * wl_wext_event_freq()
3496 *******************************************************************************
3497 *
3498 * DESCRIPTION:
3499 *
3500 * This function is used to send an event that the channel/freq
3501 * configuration for a specific device has changed.
3502 *
3503 *
3504 * PARAMETERS:
3505 *
3506 * dev - the network device for which this event is to be issued
3507 *
3508 * RETURNS:
3509 *
3510 * N/A
3511 *
3512 ******************************************************************************/
3513 void wl_wext_event_freq( struct net_device *dev )
3514 {
3515 #if WIRELESS_EXT > 13
3516 union iwreq_data wrqu;
3517 struct wl_private *lp = wl_priv(dev);
3518 /*------------------------------------------------------------------------*/
3519
3520
3521 memset( &wrqu, 0, sizeof( wrqu ));
3522
3523 wrqu.freq.m = lp->Channel;
3524 wrqu.freq.e = 0;
3525
3526 wireless_send_event( dev, SIOCSIWFREQ, &wrqu, NULL );
3527 #endif /* WIRELESS_EXT > 13 */
3528
3529 return;
3530 } // wl_wext_event_freq
3531 /*============================================================================*/
3532
3533
3534
3535
3536 /*******************************************************************************
3537 * wl_wext_event_mode()
3538 *******************************************************************************
3539 *
3540 * DESCRIPTION:
3541 *
3542 * This function is used to send an event that the mode of operation
3543 * for a specific device has changed.
3544 *
3545 *
3546 * PARAMETERS:
3547 *
3548 * dev - the network device for which this event is to be issued
3549 *
3550 * RETURNS:
3551 *
3552 * N/A
3553 *
3554 ******************************************************************************/
3555 void wl_wext_event_mode( struct net_device *dev )
3556 {
3557 #if WIRELESS_EXT > 13
3558 union iwreq_data wrqu;
3559 struct wl_private *lp = wl_priv(dev);
3560 /*------------------------------------------------------------------------*/
3561
3562
3563 memset( &wrqu, 0, sizeof( wrqu ));
3564
3565 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_STA ) {
3566 wrqu.mode = IW_MODE_INFRA;
3567 } else {
3568 wrqu.mode = IW_MODE_MASTER;
3569 }
3570
3571 wireless_send_event( dev, SIOCSIWMODE, &wrqu, NULL );
3572 #endif /* WIRELESS_EXT > 13 */
3573
3574 return;
3575 } // wl_wext_event_mode
3576 /*============================================================================*/
3577
3578
3579
3580
3581 /*******************************************************************************
3582 * wl_wext_event_essid()
3583 *******************************************************************************
3584 *
3585 * DESCRIPTION:
3586 *
3587 * This function is used to send an event that the ESSID configuration for
3588 * a specific device has changed.
3589 *
3590 *
3591 * PARAMETERS:
3592 *
3593 * dev - the network device for which this event is to be issued
3594 *
3595 * RETURNS:
3596 *
3597 * N/A
3598 *
3599 ******************************************************************************/
3600 void wl_wext_event_essid( struct net_device *dev )
3601 {
3602 #if WIRELESS_EXT > 13
3603 union iwreq_data wrqu;
3604 struct wl_private *lp = wl_priv(dev);
3605 /*------------------------------------------------------------------------*/
3606
3607
3608 memset( &wrqu, 0, sizeof( wrqu ));
3609
3610 /* Fill out the buffer. Note that the buffer doesn't actually contain the
3611 ESSID, but a pointer to the contents. In addition, the 'extra' field of
3612 the call to wireless_send_event() must also point to where the ESSID
3613 lives */
3614 wrqu.essid.length = strlen( lp->NetworkName );
3615 wrqu.essid.pointer = (caddr_t)lp->NetworkName;
3616 wrqu.essid.flags = 1;
3617
3618 wireless_send_event( dev, SIOCSIWESSID, &wrqu, lp->NetworkName );
3619 #endif /* WIRELESS_EXT > 13 */
3620
3621 return;
3622 } // wl_wext_event_essid
3623 /*============================================================================*/
3624
3625
3626
3627
3628 /*******************************************************************************
3629 * wl_wext_event_encode()
3630 *******************************************************************************
3631 *
3632 * DESCRIPTION:
3633 *
3634 * This function is used to send an event that the encryption configuration
3635 * for a specific device has changed.
3636 *
3637 *
3638 * PARAMETERS:
3639 *
3640 * dev - the network device for which this event is to be issued
3641 *
3642 * RETURNS:
3643 *
3644 * N/A
3645 *
3646 ******************************************************************************/
3647 void wl_wext_event_encode( struct net_device *dev )
3648 {
3649 #if WIRELESS_EXT > 13
3650 union iwreq_data wrqu;
3651 struct wl_private *lp = wl_priv(dev);
3652 int index = 0;
3653 /*------------------------------------------------------------------------*/
3654
3655
3656 memset( &wrqu, 0, sizeof( wrqu ));
3657
3658 if( lp->EnableEncryption == 0 ) {
3659 wrqu.encoding.flags = IW_ENCODE_DISABLED;
3660 } else {
3661 wrqu.encoding.flags |= lp->TransmitKeyID;
3662
3663 index = lp->TransmitKeyID - 1;
3664
3665 /* Only set IW_ENCODE_RESTRICTED/OPEN flag using lp->ExcludeUnencrypted
3666 if we're in AP mode */
3667 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
3668 //;?should we restore this to allow smaller memory footprint
3669
3670 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ) {
3671 if( lp->ExcludeUnencrypted ) {
3672 wrqu.encoding.flags |= IW_ENCODE_RESTRICTED;
3673 } else {
3674 wrqu.encoding.flags |= IW_ENCODE_OPEN;
3675 }
3676 }
3677
3678 #endif // HCF_TYPE_AP
3679
3680 /* Only provide the key if permissions allow */
3681 if( capable( CAP_NET_ADMIN )) {
3682 wrqu.encoding.pointer = (caddr_t)lp->DefaultKeys.key[index].key;
3683 wrqu.encoding.length = lp->DefaultKeys.key[index].len;
3684 } else {
3685 wrqu.encoding.flags |= IW_ENCODE_NOKEY;
3686 }
3687 }
3688
3689 wireless_send_event( dev, SIOCSIWENCODE, &wrqu,
3690 lp->DefaultKeys.key[index].key );
3691 #endif /* WIRELESS_EXT > 13 */
3692
3693 return;
3694 } // wl_wext_event_encode
3695 /*============================================================================*/
3696
3697
3698
3699
3700 /*******************************************************************************
3701 * wl_wext_event_ap()
3702 *******************************************************************************
3703 *
3704 * DESCRIPTION:
3705 *
3706 * This function is used to send an event that the device has been
3707 * associated to a new AP.
3708 *
3709 *
3710 * PARAMETERS:
3711 *
3712 * dev - the network device for which this event is to be issued
3713 *
3714 * RETURNS:
3715 *
3716 * N/A
3717 *
3718 ******************************************************************************/
3719 void wl_wext_event_ap( struct net_device *dev )
3720 {
3721 #if WIRELESS_EXT > 13
3722 union iwreq_data wrqu;
3723 struct wl_private *lp = wl_priv(dev);
3724 int status;
3725 /*------------------------------------------------------------------------*/
3726
3727
3728 /* Retrieve the WPA-IEs used by the firmware and send an event. We must send
3729 this event BEFORE sending the association event, as there are timing
3730 issues with the hostap supplicant. The supplicant will attempt to process
3731 an EAPOL-Key frame from an AP before receiving this information, which
3732 is required properly process the said frame. */
3733 wl_wext_event_assoc_ie( dev );
3734
3735 /* Get the BSSID */
3736 lp->ltvRecord.typ = CFG_CUR_BSSID;
3737 lp->ltvRecord.len = 4;
3738
3739 status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
3740 if( status == HCF_SUCCESS ) {
3741 memset( &wrqu, 0, sizeof( wrqu ));
3742
3743 memcpy( wrqu.addr.sa_data, lp->ltvRecord.u.u8, ETH_ALEN );
3744
3745 wrqu.addr.sa_family = ARPHRD_ETHER;
3746
3747 wireless_send_event( dev, SIOCGIWAP, &wrqu, NULL );
3748 }
3749
3750 #endif /* WIRELESS_EXT > 13 */
3751
3752 return;
3753 } // wl_wext_event_ap
3754 /*============================================================================*/
3755
3756
3757
3758 /*******************************************************************************
3759 * wl_wext_event_scan_complete()
3760 *******************************************************************************
3761 *
3762 * DESCRIPTION:
3763 *
3764 * This function is used to send an event that a request for a network scan
3765 * has completed.
3766 *
3767 *
3768 * PARAMETERS:
3769 *
3770 * dev - the network device for which this event is to be issued
3771 *
3772 * RETURNS:
3773 *
3774 * N/A
3775 *
3776 ******************************************************************************/
3777 void wl_wext_event_scan_complete( struct net_device *dev )
3778 {
3779 #if WIRELESS_EXT > 13
3780 union iwreq_data wrqu;
3781 /*------------------------------------------------------------------------*/
3782
3783
3784 memset( &wrqu, 0, sizeof( wrqu ));
3785
3786 wrqu.addr.sa_family = ARPHRD_ETHER;
3787 wireless_send_event( dev, SIOCGIWSCAN, &wrqu, NULL );
3788 #endif /* WIRELESS_EXT > 13 */
3789
3790 return;
3791 } // wl_wext_event_scan_complete
3792 /*============================================================================*/
3793
3794
3795
3796
3797 /*******************************************************************************
3798 * wl_wext_event_new_sta()
3799 *******************************************************************************
3800 *
3801 * DESCRIPTION:
3802 *
3803 * This function is used to send an event that an AP has registered a new
3804 * station.
3805 *
3806 *
3807 * PARAMETERS:
3808 *
3809 * dev - the network device for which this event is to be issued
3810 *
3811 * RETURNS:
3812 *
3813 * N/A
3814 *
3815 ******************************************************************************/
3816 void wl_wext_event_new_sta( struct net_device *dev )
3817 {
3818 #if WIRELESS_EXT > 14
3819 union iwreq_data wrqu;
3820 /*------------------------------------------------------------------------*/
3821
3822
3823 memset( &wrqu, 0, sizeof( wrqu ));
3824
3825 /* Send the station's mac address here */
3826 memcpy( wrqu.addr.sa_data, dev->dev_addr, ETH_ALEN );
3827 wrqu.addr.sa_family = ARPHRD_ETHER;
3828 wireless_send_event( dev, IWEVREGISTERED, &wrqu, NULL );
3829 #endif /* WIRELESS_EXT > 14 */
3830
3831 return;
3832 } // wl_wext_event_new_sta
3833 /*============================================================================*/
3834
3835
3836
3837
3838 /*******************************************************************************
3839 * wl_wext_event_expired_sta()
3840 *******************************************************************************
3841 *
3842 * DESCRIPTION:
3843 *
3844 * This function is used to send an event that an AP has deregistered a
3845 * station.
3846 *
3847 *
3848 * PARAMETERS:
3849 *
3850 * dev - the network device for which this event is to be issued
3851 *
3852 * RETURNS:
3853 *
3854 * N/A
3855 *
3856 ******************************************************************************/
3857 void wl_wext_event_expired_sta( struct net_device *dev )
3858 {
3859 #if WIRELESS_EXT > 14
3860 union iwreq_data wrqu;
3861 /*------------------------------------------------------------------------*/
3862
3863
3864 memset( &wrqu, 0, sizeof( wrqu ));
3865
3866 memcpy( wrqu.addr.sa_data, dev->dev_addr, ETH_ALEN );
3867 wrqu.addr.sa_family = ARPHRD_ETHER;
3868 wireless_send_event( dev, IWEVEXPIRED, &wrqu, NULL );
3869 #endif /* WIRELESS_EXT > 14 */
3870
3871 return;
3872 } // wl_wext_event_expired_sta
3873 /*============================================================================*/
3874
3875
3876
3877
3878 /*******************************************************************************
3879 * wl_wext_event_mic_failed()
3880 *******************************************************************************
3881 *
3882 * DESCRIPTION:
3883 *
3884 * This function is used to send an event that MIC calculations failed.
3885 *
3886 *
3887 * PARAMETERS:
3888 *
3889 * dev - the network device for which this event is to be issued
3890 *
3891 * RETURNS:
3892 *
3893 * N/A
3894 *
3895 ******************************************************************************/
3896 void wl_wext_event_mic_failed( struct net_device *dev )
3897 {
3898 #if WIRELESS_EXT > 14
3899 char msg[512];
3900 union iwreq_data wrqu;
3901 struct wl_private *lp = wl_priv(dev);
3902 int key_idx;
3903 char *addr1;
3904 char *addr2;
3905 WVLAN_RX_WMP_HDR *hdr;
3906 /*------------------------------------------------------------------------*/
3907
3908
3909 key_idx = lp->lookAheadBuf[HFS_STAT+1] >> 3;
3910 key_idx &= 0x03;
3911
3912 /* Cast the lookahead buffer into a RFS format */
3913 hdr = (WVLAN_RX_WMP_HDR *)&lp->lookAheadBuf[HFS_STAT];
3914
3915 /* Cast the addresses to byte buffers, as in the above RFS they are word
3916 length */
3917 addr1 = (char *)hdr->address1;
3918 addr2 = (char *)hdr->address2;
3919
3920 DBG_PRINT( "MIC FAIL - KEY USED : %d, STATUS : 0x%04x\n", key_idx,
3921 hdr->status );
3922
3923 memset( &wrqu, 0, sizeof( wrqu ));
3924 memset( msg, 0, sizeof( msg ));
3925
3926
3927 /* Because MIC failures are not part of the Wireless Extensions yet, they
3928 must be passed as a string using an IWEVCUSTOM event. In order for the
3929 event to be effective, the string format must be known by both the
3930 driver and the supplicant. The following is the string format used by the
3931 hostap project's WPA supplicant, and will be used here until the Wireless
3932 Extensions interface adds this support:
3933
3934 MLME-MICHAELMICFAILURE.indication(keyid=# broadcast/unicast addr=addr2)
3935 */
3936
3937 /* NOTE: Format of MAC address (using colons to separate bytes) may cause
3938 a problem in future versions of the supplicant, if they ever
3939 actually parse these parameters */
3940 #if DBG
3941 sprintf(msg, "MLME-MICHAELMICFAILURE.indication(keyid=%d %scast "
3942 "addr=%pM)", key_idx, addr1[0] & 0x01 ? "broad" : "uni",
3943 addr2);
3944 #endif
3945 wrqu.data.length = strlen( msg );
3946 wireless_send_event( dev, IWEVCUSTOM, &wrqu, msg );
3947 #endif /* WIRELESS_EXT > 14 */
3948
3949 return;
3950 } // wl_wext_event_mic_failed
3951 /*============================================================================*/
3952
3953
3954
3955
3956 /*******************************************************************************
3957 * wl_wext_event_assoc_ie()
3958 *******************************************************************************
3959 *
3960 * DESCRIPTION:
3961 *
3962 * This function is used to send an event containing the WPA-IE generated
3963 * by the firmware in an association request.
3964 *
3965 *
3966 * PARAMETERS:
3967 *
3968 * dev - the network device for which this event is to be issued
3969 *
3970 * RETURNS:
3971 *
3972 * N/A
3973 *
3974 ******************************************************************************/
3975 void wl_wext_event_assoc_ie( struct net_device *dev )
3976 {
3977 #if WIRELESS_EXT > 14
3978 char msg[512];
3979 union iwreq_data wrqu;
3980 struct wl_private *lp = wl_priv(dev);
3981 int status;
3982 PROBE_RESP data;
3983 hcf_16 length;
3984 hcf_8 *wpa_ie;
3985 /*------------------------------------------------------------------------*/
3986
3987
3988 memset( &wrqu, 0, sizeof( wrqu ));
3989 memset( msg, 0, sizeof( msg ));
3990
3991 /* Retrieve the Association Request IE */
3992 lp->ltvRecord.len = 45;
3993 lp->ltvRecord.typ = CFG_CUR_ASSOC_REQ_INFO;
3994
3995 status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
3996 if( status == HCF_SUCCESS )
3997 {
3998 length = 0;
3999 memcpy( &data.rawData, &( lp->ltvRecord.u.u8[1] ), 88 );
4000 wpa_ie = wl_parse_wpa_ie( &data, &length );
4001
4002 /* Because this event (Association WPA-IE) is not part of the Wireless
4003 Extensions yet, it must be passed as a string using an IWEVCUSTOM event.
4004 In order for the event to be effective, the string format must be known
4005 by both the driver and the supplicant. The following is the string format
4006 used by the hostap project's WPA supplicant, and will be used here until
4007 the Wireless Extensions interface adds this support:
4008
4009 ASSOCINFO(ReqIEs=WPA-IE RespIEs=WPA-IE)
4010 */
4011
4012 if( length != 0 )
4013 {
4014 sprintf( msg, "ASSOCINFO(ReqIEs=%s)", wl_print_wpa_ie( wpa_ie, length ));
4015 wrqu.data.length = strlen( msg );
4016 wireless_send_event( dev, IWEVCUSTOM, &wrqu, msg );
4017 }
4018 }
4019 #endif /* WIRELESS_EXT > 14 */
4020
4021 return;
4022 } // wl_wext_event_assoc_ie
4023 /*============================================================================*/
4024 /* Structures to export the Wireless Handlers */
4025
4026 static const iw_handler wl_handler[] =
4027 {
4028 (iw_handler) wireless_commit, /* SIOCSIWCOMMIT */
4029 (iw_handler) wireless_get_protocol, /* SIOCGIWNAME */
4030 (iw_handler) NULL, /* SIOCSIWNWID */
4031 (iw_handler) NULL, /* SIOCGIWNWID */
4032 (iw_handler) wireless_set_frequency, /* SIOCSIWFREQ */
4033 (iw_handler) wireless_get_frequency, /* SIOCGIWFREQ */
4034 (iw_handler) wireless_set_porttype, /* SIOCSIWMODE */
4035 (iw_handler) wireless_get_porttype, /* SIOCGIWMODE */
4036 (iw_handler) wireless_set_sensitivity, /* SIOCSIWSENS */
4037 (iw_handler) wireless_get_sensitivity, /* SIOCGIWSENS */
4038 (iw_handler) NULL , /* SIOCSIWRANGE */
4039 (iw_handler) wireless_get_range, /* SIOCGIWRANGE */
4040 (iw_handler) NULL , /* SIOCSIWPRIV */
4041 (iw_handler) NULL /* kernel code */, /* SIOCGIWPRIV */
4042 (iw_handler) NULL , /* SIOCSIWSTATS */
4043 (iw_handler) NULL /* kernel code */, /* SIOCGIWSTATS */
4044 iw_handler_set_spy, /* SIOCSIWSPY */
4045 iw_handler_get_spy, /* SIOCGIWSPY */
4046 NULL, /* SIOCSIWTHRSPY */
4047 NULL, /* SIOCGIWTHRSPY */
4048 (iw_handler) NULL, /* SIOCSIWAP */
4049 #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
4050 (iw_handler) wireless_get_bssid, /* SIOCGIWAP */
4051 #else
4052 (iw_handler) NULL, /* SIOCGIWAP */
4053 #endif
4054 (iw_handler) NULL, /* SIOCSIWMLME */
4055 (iw_handler) wireless_get_ap_list, /* SIOCGIWAPLIST */
4056 (iw_handler) wireless_set_scan, /* SIOCSIWSCAN */
4057 (iw_handler) wireless_get_scan, /* SIOCGIWSCAN */
4058 (iw_handler) wireless_set_essid, /* SIOCSIWESSID */
4059 (iw_handler) wireless_get_essid, /* SIOCGIWESSID */
4060 (iw_handler) wireless_set_nickname, /* SIOCSIWNICKN */
4061 (iw_handler) wireless_get_nickname, /* SIOCGIWNICKN */
4062 (iw_handler) NULL, /* -- hole -- */
4063 (iw_handler) NULL, /* -- hole -- */
4064 (iw_handler) wireless_set_rate, /* SIOCSIWRATE */
4065 (iw_handler) wireless_get_rate, /* SIOCGIWRATE */
4066 (iw_handler) wireless_set_rts_threshold,/* SIOCSIWRTS */
4067 (iw_handler) wireless_get_rts_threshold,/* SIOCGIWRTS */
4068 (iw_handler) NULL, /* SIOCSIWFRAG */
4069 (iw_handler) NULL, /* SIOCGIWFRAG */
4070 (iw_handler) NULL, /* SIOCSIWTXPOW */
4071 (iw_handler) wireless_get_tx_power, /* SIOCGIWTXPOW */
4072 (iw_handler) NULL, /* SIOCSIWRETRY */
4073 (iw_handler) NULL, /* SIOCGIWRETRY */
4074 (iw_handler) wireless_set_encode, /* SIOCSIWENCODE */
4075 (iw_handler) wireless_get_encode, /* SIOCGIWENCODE */
4076 (iw_handler) wireless_set_power, /* SIOCSIWPOWER */
4077 (iw_handler) wireless_get_power, /* SIOCGIWPOWER */
4078 (iw_handler) NULL, /* -- hole -- */
4079 (iw_handler) NULL, /* -- hole -- */
4080 (iw_handler) wireless_get_genie, /* SIOCSIWGENIE */
4081 (iw_handler) NULL, /* SIOCGIWGENIE */
4082 (iw_handler) wireless_set_auth, /* SIOCSIWAUTH */
4083 (iw_handler) NULL, /* SIOCGIWAUTH */
4084 (iw_handler) wireless_set_encodeext, /* SIOCSIWENCODEEXT */
4085 (iw_handler) NULL, /* SIOCGIWENCODEEXT */
4086 (iw_handler) NULL, /* SIOCSIWPMKSA */
4087 (iw_handler) NULL, /* -- hole -- */
4088 };
4089
4090 static const iw_handler wl_private_handler[] =
4091 { /* SIOCIWFIRSTPRIV + */
4092 wvlan_set_netname, /* 0: SIOCSIWNETNAME */
4093 wvlan_get_netname, /* 1: SIOCGIWNETNAME */
4094 wvlan_set_station_nickname, /* 2: SIOCSIWSTANAME */
4095 wvlan_get_station_nickname, /* 3: SIOCGIWSTANAME */
4096 #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
4097 wvlan_set_porttype, /* 4: SIOCSIWPORTTYPE */
4098 wvlan_get_porttype, /* 5: SIOCGIWPORTTYPE */
4099 #endif
4100 };
4101
4102 struct iw_priv_args wl_priv_args[] = {
4103 {SIOCSIWNETNAME, IW_PRIV_TYPE_CHAR | HCF_MAX_NAME_LEN, 0, "snetwork_name" },
4104 {SIOCGIWNETNAME, 0, IW_PRIV_TYPE_CHAR | HCF_MAX_NAME_LEN, "gnetwork_name" },
4105 {SIOCSIWSTANAME, IW_PRIV_TYPE_CHAR | HCF_MAX_NAME_LEN, 0, "sstation_name" },
4106 {SIOCGIWSTANAME, 0, IW_PRIV_TYPE_CHAR | HCF_MAX_NAME_LEN, "gstation_name" },
4107 #if 1 //;? #if (HCF_TYPE) & HCF_TYPE_STA
4108 {SIOCSIWPORTTYPE, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "sport_type" },
4109 {SIOCGIWPORTTYPE, 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gport_type" },
4110 #endif
4111 };
4112
4113 const struct iw_handler_def wl_iw_handler_def =
4114 {
4115 .num_private = sizeof(wl_private_handler) / sizeof(iw_handler),
4116 .private = (iw_handler *) wl_private_handler,
4117 .private_args = (struct iw_priv_args *) wl_priv_args,
4118 .num_private_args = sizeof(wl_priv_args) / sizeof(struct iw_priv_args),
4119 .num_standard = sizeof(wl_handler) / sizeof(iw_handler),
4120 .standard = (iw_handler *) wl_handler,
4121 .get_wireless_stats = wl_get_wireless_stats,
4122 };
4123
4124 #endif // WIRELESS_EXT
kernel source for telekom puls (alcatel/mediatek)