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