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