projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Staging: wlags49_h2: add Agere driver for HERMES II and HERMES II.5 chipsets
[deliverable/linux.git] / drivers / staging / wlags49_h2 / wl_priv.c
1 /*******************************************************************************
2 * Agere Systems Inc.
3 * Wireless device driver for Linux (wlags49).
4 *
5 * Copyright (c) 1998-2003 Agere Systems Inc.
6 * All rights reserved.
7 * http://www.agere.com
8 *
9 * Initially developed by TriplePoint, Inc.
10 * http://www.triplepoint.com
11 *
12 *------------------------------------------------------------------------------
13 *
14 * This file defines handling routines for the private IOCTLs
15 *
16 *------------------------------------------------------------------------------
17 *
18 * SOFTWARE LICENSE
19 *
20 * This software is provided subject to the following terms and conditions,
21 * which you should read carefully before using the software. Using this
22 * software indicates your acceptance of these terms and conditions. If you do
23 * not agree with these terms and conditions, do not use the software.
24 *
25 * Copyright © 2003 Agere Systems Inc.
26 * All rights reserved.
27 *
28 * Redistribution and use in source or binary forms, with or without
29 * modifications, are permitted provided that the following conditions are met:
30 *
31 * . Redistributions of source code must retain the above copyright notice, this
32 * list of conditions and the following Disclaimer as comments in the code as
33 * well as in the documentation and/or other materials provided with the
34 * distribution.
35 *
36 * . Redistributions in binary form must reproduce the above copyright notice,
37 * this list of conditions and the following Disclaimer in the documentation
38 * and/or other materials provided with the distribution.
39 *
40 * . Neither the name of Agere Systems Inc. nor the names of the contributors
41 * may be used to endorse or promote products derived from this software
42 * without specific prior written permission.
43 *
44 * Disclaimer
45 *
46 * THIS SOFTWARE IS PROVIDED \93AS IS\94 AND ANY EXPRESS OR IMPLIED WARRANTIES,
47 * INCLUDING, BUT NOT LIMITED TO, INFRINGEMENT AND THE IMPLIED WARRANTIES OF
48 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ANY
49 * USE, MODIFICATION OR DISTRIBUTION OF THIS SOFTWARE IS SOLELY AT THE USERS OWN
50 * RISK. IN NO EVENT SHALL AGERE SYSTEMS INC. OR CONTRIBUTORS BE LIABLE FOR ANY
51 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
52 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
53 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
54 * ON ANY THEORY OF LIABILITY, INCLUDING, BUT NOT LIMITED TO, CONTRACT, STRICT
55 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
56 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
57 * DAMAGE.
58 *
59 ******************************************************************************/
60
61
62
63
64 /*******************************************************************************
65 * VERSION CONTROL INFORMATION
66 *******************************************************************************
67 *
68 * $Author: nico $
69 * $Date: 2004/08/03 11:39:39 $
70 * $Revision: 1.5 $
71 * $Source: /usr/local/cvs/wl_lkm/wireless/wl_priv.c,v $
72 *
73 ******************************************************************************/
74
75
76
77
78 /*******************************************************************************
79 * include files
80 ******************************************************************************/
81 #include <wl_version.h>
82
83 #include <linux/if_arp.h>
84 #include <linux/ioport.h>
85 #include <linux/delay.h>
86 #include <asm/uaccess.h>
87
88 #include <debug.h>
89 #include <hcf.h>
90 #include <hcfdef.h>
91
92 #include <wl_if.h>
93 #include <wl_internal.h>
94 #include <wl_enc.h>
95 #include <wl_main.h>
96 #include <wl_priv.h>
97 #include <wl_util.h>
98 #include <wl_netdev.h>
99
100 int wvlan_uil_connect( struct uilreq *urq, struct wl_private *lp );
101 int wvlan_uil_disconnect( struct uilreq *urq, struct wl_private *lp );
102 int wvlan_uil_action( struct uilreq *urq, struct wl_private *lp );
103 int wvlan_uil_block( struct uilreq *urq, struct wl_private *lp );
104 int wvlan_uil_unblock( struct uilreq *urq, struct wl_private *lp );
105 int wvlan_uil_send_diag_msg( struct uilreq *urq, struct wl_private *lp );
106 int wvlan_uil_put_info( struct uilreq *urq, struct wl_private *lp );
107 int wvlan_uil_get_info( struct uilreq *urq, struct wl_private *lp );
108
109 int cfg_driver_info( struct uilreq *urq, struct wl_private *lp );
110 int cfg_driver_identity( struct uilreq *urq, struct wl_private *lp );
111
112
113 /*******************************************************************************
114 * global variables
115 ******************************************************************************/
116 #if DBG
117 extern dbg_info_t *DbgInfo;
118 #endif // DBG
119
120
121
122
123 /* If USE_UIL is not defined, then none of the UIL Interface code below will
124 be included in the build */
125 #ifdef USE_UIL
126
127 /*******************************************************************************
128 * wvlan_uil()
129 *******************************************************************************
130 *
131 * DESCRIPTION:
132 *
133 * The handler function for the UIL interface.
134 *
135 * PARAMETERS:
136 *
137 * urq - a pointer to the UIL request buffer
138 * lp - a pointer to the device's private adapter structure
139 *
140 * RETURNS:
141 *
142 * 0 on success
143 * errno value otherwise
144 *
145 ******************************************************************************/
146 int wvlan_uil( struct uilreq *urq, struct wl_private *lp )
147 {
148 int ioctl_ret = 0;
149 /*------------------------------------------------------------------------*/
150
151 DBG_FUNC( "wvlan_uil" );
152 DBG_ENTER( DbgInfo );
153
154 switch( urq->command ) {
155 case UIL_FUN_CONNECT:
156 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_UIL -- WVLAN2_UIL_CONNECT\n");
157 ioctl_ret = wvlan_uil_connect( urq, lp );
158 break;
159 case UIL_FUN_DISCONNECT:
160 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_UIL -- WVLAN2_UIL_DISCONNECT\n");
161 ioctl_ret = wvlan_uil_disconnect( urq, lp );
162 break;
163 case UIL_FUN_ACTION:
164 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_UIL -- WVLAN2_UIL_ACTION\n" );
165 ioctl_ret = wvlan_uil_action( urq, lp );
166 break;
167 case UIL_FUN_SEND_DIAG_MSG:
168 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_UIL -- WVLAN2_UIL_SEND_DIAG_MSG\n");
169 ioctl_ret = wvlan_uil_send_diag_msg( urq, lp );
170 break;
171 case UIL_FUN_GET_INFO:
172 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_UIL -- WVLAN2_UIL_GET_INFO\n");
173 ioctl_ret = wvlan_uil_get_info( urq, lp );
174 break;
175 case UIL_FUN_PUT_INFO:
176 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_UIL -- WVLAN2_UIL_PUT_INFO\n");
177 ioctl_ret = wvlan_uil_put_info( urq, lp );
178 break;
179 default:
180 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_UIL -- UNSUPPORTED UIL CODE: 0x%X", urq->command );
181 ioctl_ret = -EOPNOTSUPP;
182 break;
183 }
184 DBG_LEAVE( DbgInfo );
185 return ioctl_ret;
186 } // wvlan_uil
187 /*============================================================================*/
188
189
190
191
192 /*******************************************************************************
193 * wvlan_uil_connect()
194 *******************************************************************************
195 *
196 * DESCRIPTION:
197 *
198 * Connect to the UIL in order to make a request.
199 *
200 * PARAMETERS:
201 *
202 * urq - a pointer to the UIL request buffer
203 * lp - a pointer to the device's private adapter structure
204 *
205 * RETURNS:
206 *
207 * UIL_SUCCESS
208 * UIL_ERR_xxx value otherwise
209 *
210 ******************************************************************************/
211 int wvlan_uil_connect( struct uilreq *urq, struct wl_private *lp )
212 {
213 int result = 0;
214 /*------------------------------------------------------------------------*/
215
216
217 DBG_FUNC( "wvlan_uil_connect" );
218 DBG_ENTER( DbgInfo );
219
220
221 if( !( lp->flags & WVLAN2_UIL_CONNECTED )) {
222 lp->flags |= WVLAN2_UIL_CONNECTED;
223 urq->hcfCtx = &( lp->hcfCtx );
224 urq->result = UIL_SUCCESS;
225 } else {
226 DBG_WARNING( DbgInfo, "UIL_ERR_IN_USE\n" );
227 urq->result = UIL_ERR_IN_USE;
228 }
229
230 DBG_LEAVE( DbgInfo );
231 return result;
232 } // wvlan_uil_connect
233 /*============================================================================*/
234
235
236
237
238 /*******************************************************************************
239 * wvlan_uil_disconnect()
240 *******************************************************************************
241 *
242 * DESCRIPTION:
243 *
244 * Disonnect from the UIL after a request has been completed.
245 *
246 * PARAMETERS:
247 *
248 * urq - a pointer to the UIL request buffer
249 * lp - a pointer to the device's private adapter structure
250 *
251 * RETURNS:
252 *
253 * UIL_SUCCESS
254 * UIL_ERR_xxx value otherwise
255 *
256 ******************************************************************************/
257 int wvlan_uil_disconnect( struct uilreq *urq, struct wl_private *lp )
258 {
259 int result = 0;
260 /*------------------------------------------------------------------------*/
261
262
263 DBG_FUNC( "wvlan_uil_disconnect" );
264 DBG_ENTER( DbgInfo );
265
266
267 if( urq->hcfCtx == &( lp->hcfCtx )) {
268 if (lp->flags & WVLAN2_UIL_CONNECTED) {
269 lp->flags &= ~WVLAN2_UIL_CONNECTED;
270 /*
271 if (lp->flags & WVLAN2_UIL_BUSY) {
272 lp->flags &= ~WVLAN2_UIL_BUSY;
273 netif_start_queue(lp->dev);
274 }
275 */
276 }
277
278 urq->hcfCtx = NULL;
279 urq->result = UIL_SUCCESS;
280 } else {
281 DBG_ERROR( DbgInfo, "UIL_ERR_WRONG_IFB\n" );
282 urq->result = UIL_ERR_WRONG_IFB;
283 }
284
285 DBG_LEAVE( DbgInfo );
286 return result;
287 } // wvlan_uil_disconnect
288 /*============================================================================*/
289
290
291
292
293 /*******************************************************************************
294 * wvlan_uil_action()
295 *******************************************************************************
296 *
297 * DESCRIPTION:
298 *
299 * Handler for the UIL_ACT_xxx subcodes associated with UIL_FUN_ACTION
300 *
301 * PARAMETERS:
302 *
303 * urq - a pointer to the UIL request buffer
304 * lp - a pointer to the device's private adapter structure
305 *
306 * RETURNS:
307 *
308 * UIL_SUCCESS
309 * UIL_ERR_xxx value otherwise
310 *
311 ******************************************************************************/
312 int wvlan_uil_action( struct uilreq *urq, struct wl_private *lp )
313 {
314 int result = 0;
315 ltv_t *ltv;
316 /*------------------------------------------------------------------------*/
317
318
319 DBG_FUNC( "wvlan_uil_action" );
320 DBG_ENTER( DbgInfo );
321
322
323 if( urq->hcfCtx == &( lp->hcfCtx )) {
324 /* Make sure there's an LTV in the request buffer */
325 ltv = (ltv_t *)urq->data;
326 if( ltv != NULL ) {
327 /* Switch on the Type field of the LTV contained in the request
328 buffer */
329 switch( ltv->typ ) {
330 case UIL_ACT_BLOCK:
331 DBG_TRACE( DbgInfo, "UIL_ACT_BLOCK\n" );
332 result = wvlan_uil_block( urq, lp );
333 break;
334 case UIL_ACT_UNBLOCK:
335 DBG_TRACE( DbgInfo, "UIL_ACT_UNBLOCK\n" );
336 result = wvlan_uil_unblock( urq, lp );
337 break;
338 case UIL_ACT_SCAN:
339 DBG_TRACE( DbgInfo, "UIL_ACT_SCAN\n" );
340 urq->result = hcf_action( &( lp->hcfCtx ), MDD_ACT_SCAN );
341 break;
342 case UIL_ACT_APPLY:
343 DBG_TRACE( DbgInfo, "UIL_ACT_APPLY\n" );
344 urq->result = wl_apply( lp );
345 break;
346 case UIL_ACT_RESET:
347 DBG_TRACE( DbgInfo, "UIL_ACT_RESET\n" );
348 urq->result = wl_go( lp );
349 break;
350 default:
351 DBG_WARNING( DbgInfo, "Unknown action code: 0x%x\n", ltv->typ );
352 break;
353 }
354 } else {
355 DBG_ERROR( DbgInfo, "Bad LTV for this action\n" );
356 urq->result = UIL_ERR_LEN;
357 }
358 } else {
359 DBG_ERROR( DbgInfo, "UIL_ERR_WRONG_IFB\n" );
360 urq->result = UIL_ERR_WRONG_IFB;
361 }
362
363 DBG_LEAVE( DbgInfo );
364 return result;
365 } // wvlan_uil_action
366 /*============================================================================*/
367
368
369
370
371 /*******************************************************************************
372 * wvlan_uil_block()
373 *******************************************************************************
374 *
375 * DESCRIPTION:
376 *
377 * Sets a block in the driver to prevent access to the card by other
378 * processes.
379 *
380 * PARAMETERS:
381 *
382 * urq - a pointer to the UIL request buffer
383 * lp - a pointer to the device's private adapter structure
384 *
385 * RETURNS:
386 *
387 * UIL_SUCCESS
388 * UIL_ERR_xxx value otherwise
389 *
390 ******************************************************************************/
391
392 int wvlan_uil_block( struct uilreq *urq, struct wl_private *lp )
393 {
394 int result = 0;
395 /*------------------------------------------------------------------------*/
396
397
398 DBG_FUNC( "wvlan_uil_block" );
399 DBG_ENTER( DbgInfo );
400
401 if( urq->hcfCtx == &( lp->hcfCtx )) {
402 if( capable( CAP_NET_ADMIN )) {
403 lp->flags |= WVLAN2_UIL_BUSY;
404 netif_stop_queue(lp->dev);
405 WL_WDS_NETIF_STOP_QUEUE( lp );
406 urq->result = UIL_SUCCESS;
407 } else {
408 DBG_ERROR( DbgInfo, "EPERM\n" );
409 urq->result = UIL_FAILURE;
410 result = -EPERM;
411 }
412 } else {
413 DBG_ERROR( DbgInfo, "UIL_ERR_WRONG_IFB\n" );
414 urq->result = UIL_ERR_WRONG_IFB;
415 }
416
417 DBG_LEAVE( DbgInfo );
418 return result;
419 } // wvlan_uil_block
420 /*============================================================================*/
421
422
423
424
425 /*******************************************************************************
426 * wvlan_uil_unblock()
427 *******************************************************************************
428 *
429 * DESCRIPTION:
430 *
431 * Unblocks the driver to restore access to the card by other processes.
432 *
433 * PARAMETERS:
434 *
435 * urq - a pointer to the UIL request buffer
436 * lp - a pointer to the device's private adapter structure
437 *
438 * RETURNS:
439 *
440 * UIL_SUCCESS
441 * UIL_ERR_xxx value otherwise
442 *
443 ******************************************************************************/
444 int wvlan_uil_unblock( struct uilreq *urq, struct wl_private *lp )
445 {
446 int result = 0;
447 /*------------------------------------------------------------------------*/
448
449
450 DBG_FUNC( "wvlan_uil_unblock" );
451 DBG_ENTER( DbgInfo );
452
453 if( urq->hcfCtx == &( lp->hcfCtx )) {
454 if( capable( CAP_NET_ADMIN )) {
455 if (lp->flags & WVLAN2_UIL_BUSY) {
456 lp->flags &= ~WVLAN2_UIL_BUSY;
457 netif_wake_queue(lp->dev);
458 WL_WDS_NETIF_WAKE_QUEUE( lp );
459 }
460 } else {
461 DBG_ERROR( DbgInfo, "EPERM\n" );
462 urq->result = UIL_FAILURE;
463 result = -EPERM;
464 }
465 } else {
466 DBG_ERROR( DbgInfo, "UIL_ERR_WRONG_IFB\n" );
467 urq->result = UIL_ERR_WRONG_IFB;
468 }
469
470 DBG_LEAVE( DbgInfo );
471 return result;
472 } // wvlan_uil_unblock
473 /*============================================================================*/
474
475
476
477
478 /*******************************************************************************
479 * wvlan_uil_send_diag_msg()
480 *******************************************************************************
481 *
482 * DESCRIPTION:
483 *
484 * Sends a diagnostic message to the card.
485 *
486 * PARAMETERS:
487 *
488 * urq - a pointer to the UIL request buffer
489 * lp - a pointer to the device's private adapter structure
490 *
491 * RETURNS:
492 *
493 * UIL_SUCCESS
494 * UIL_ERR_xxx value otherwise
495 *
496 ******************************************************************************/
497 int wvlan_uil_send_diag_msg( struct uilreq *urq, struct wl_private *lp )
498 {
499 int result = 0;
500 DESC_STRCT Descp[1];
501 /*------------------------------------------------------------------------*/
502
503
504 DBG_FUNC( "wvlan_uil_send_diag_msg" );
505 DBG_ENTER( DbgInfo );
506
507 if( urq->hcfCtx == &( lp->hcfCtx )) {
508 if( capable( CAP_NET_ADMIN )) {
509 if ((urq->data != NULL) && (urq->len != 0)) {
510 if (lp->hcfCtx.IFB_RscInd != 0) {
511 u_char *data;
512
513 // Verify the user buffer
514 result = verify_area(VERIFY_READ, urq->data, urq->len);
515 if (result != 0) {
516 DBG_ERROR( DbgInfo, "verify_area failed, result: %d\n", result );
517 urq->result = UIL_FAILURE;
518 DBG_LEAVE( DbgInfo );
519 return result;
520 }
521
522 if ((data = kmalloc(urq->len, GFP_KERNEL)) != NULL) {
523 memset( Descp, 0, sizeof( DESC_STRCT ));
524 memcpy( data, urq->data, urq->len );
525
526 Descp[0].buf_addr = (wci_bufp)data;
527 Descp[0].BUF_CNT = urq->len;
528 Descp[0].next_desc_addr = 0; // terminate list
529
530 hcf_send_msg( &(lp->hcfCtx), &Descp[0], HCF_PORT_0 );
531 kfree( data );
532 } else {
533 DBG_ERROR( DbgInfo, "ENOMEM\n" );
534 urq->result = UIL_FAILURE;
535 result = -ENOMEM;
536 DBG_LEAVE( DbgInfo );
537 return result;
538 }
539
540 } else {
541 urq->result = UIL_ERR_BUSY;
542 }
543
544 } else {
545 urq->result = UIL_FAILURE;
546 }
547 } else {
548 DBG_ERROR( DbgInfo, "EPERM\n" );
549 urq->result = UIL_FAILURE;
550 result = -EPERM;
551 }
552 } else {
553 DBG_ERROR( DbgInfo, "UIL_ERR_WRONG_IFB\n" );
554 urq->result = UIL_ERR_WRONG_IFB;
555 }
556
557 DBG_LEAVE( DbgInfo );
558 return result;
559 } // wvlan_uil_send_diag_msg
560 /*============================================================================*/
561
562
563 /*******************************************************************************
564 * wvlan_uil_put_info()
565 *******************************************************************************
566 *
567 * DESCRIPTION:
568 *
569 * Sends a specific RID directly to the driver to set configuration info.
570 *
571 * PARAMETERS:
572 *
573 * urq - a pointer to the UIL request buffer
574 * lp - a pointer to the device's private adapter structure
575 *
576 * RETURNS:
577 *
578 * UIL_SUCCESS
579 * UIL_ERR_xxx value otherwise
580 *
581 ******************************************************************************/
582 int wvlan_uil_put_info( struct uilreq *urq, struct wl_private *lp )
583 {
584 int result = 0;
585 ltv_t *pLtv;
586 bool_t ltvAllocated = FALSE;
587 ENCSTRCT sEncryption;
588
589 #ifdef USE_WDS
590 hcf_16 hcfPort = HCF_PORT_0;
591 #endif /* USE_WDS */
592 /*------------------------------------------------------------------------*/
593 DBG_FUNC( "wvlan_uil_put_info" );
594 DBG_ENTER( DbgInfo );
595
596
597 if( urq->hcfCtx == &( lp->hcfCtx )) {
598 if( capable( CAP_NET_ADMIN )) {
599 if(( urq->data != NULL ) && ( urq->len != 0 )) {
600 /* Make sure that we have at least a command and length to send. */
601 if( urq->len < ( sizeof( hcf_16 ) * 2 )) {
602 urq->len = sizeof( lp->ltvRecord );
603 urq->result = UIL_ERR_LEN;
604 DBG_ERROR( DbgInfo, "No Length/Type in LTV!!!\n" );
605 DBG_ERROR( DbgInfo, "UIL_ERR_LEN\n" );
606 DBG_LEAVE( DbgInfo );
607 return result;
608 }
609
610 /* Verify the user buffer */
611 result = verify_area( VERIFY_READ, urq->data, urq->len );
612 if( result != 0 ) {
613 urq->result = UIL_FAILURE;
614 DBG_ERROR( DbgInfo, "verify_area(), VERIFY_READ FAILED\n" );
615 DBG_LEAVE( DbgInfo );
616 return result;
617 }
618
619 /* Get only the command and length information. */
620 copy_from_user( &( lp->ltvRecord ), urq->data, sizeof( hcf_16 ) * 2 );
621
622 /* Make sure the incoming LTV record length is within the bounds of the
623 IOCTL length */
624 if((( lp->ltvRecord.len + 1 ) * sizeof( hcf_16 )) > urq->len ) {
625 urq->len = sizeof( lp->ltvRecord );
626 urq->result = UIL_ERR_LEN;
627 DBG_ERROR( DbgInfo, "UIL_ERR_LEN\n" );
628 DBG_LEAVE( DbgInfo );
629 return result;
630 }
631
632 /* If the requested length is greater than the size of our local
633 LTV record, try to allocate it from the kernel stack.
634 Otherwise, we just use our local LTV record. */
635 if( urq->len > sizeof( lp->ltvRecord )) {
636 if(( pLtv = (ltv_t *)kmalloc( urq->len, GFP_KERNEL )) != NULL ) {
637 ltvAllocated = TRUE;
638 } else {
639 DBG_ERROR( DbgInfo, "Alloc FAILED\n" );
640 urq->len = sizeof( lp->ltvRecord );
641 urq->result = UIL_ERR_LEN;
642 result = -ENOMEM;
643 DBG_LEAVE( DbgInfo );
644 return result;
645 }
646 } else {
647 pLtv = &( lp->ltvRecord );
648 }
649
650 /* Copy the data from the user's buffer into the local LTV
651 record data area. */
652 copy_from_user( pLtv, urq->data, urq->len );
653
654
655 /* We need to snoop the commands to see if there is anything we
656 need to store for the purposes of a reset or start/stop
657 sequence. Perform endian translation as needed */
658 switch( pLtv->typ ) {
659 case CFG_CNF_PORT_TYPE:
660 lp->PortType = pLtv->u.u16[0];
661 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
662 break;
663 case CFG_CNF_OWN_MAC_ADDR:
664 /* TODO: determine if we are going to store anything based on this */
665 break;
666 case CFG_CNF_OWN_CHANNEL:
667 lp->Channel = pLtv->u.u16[0];
668 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
669 break;
670 /* CFG_CNF_OWN_SSID currently same as CNF_DESIRED_SSID. Do we
671 need seperate storage for this? */
672 //case CFG_CNF_OWN_SSID:
673 case CFG_CNF_OWN_ATIM_WINDOW:
674 lp->atimWindow = pLtv->u.u16[0];
675 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
676 break;
677 case CFG_CNF_SYSTEM_SCALE:
678 lp->DistanceBetweenAPs = pLtv->u.u16[0];
679 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
680
681 case CFG_CNF_MAX_DATA_LEN:
682 /* TODO: determine if we are going to store anything based
683 on this */
684 break;
685 case CFG_CNF_PM_ENABLED:
686 lp->PMEnabled = pLtv->u.u16[0];
687 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
688 break;
689 case CFG_CNF_MCAST_RX:
690 lp->MulticastReceive = pLtv->u.u16[0];
691 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
692 break;
693 case CFG_CNF_MAX_SLEEP_DURATION:
694 lp->MaxSleepDuration = pLtv->u.u16[0];
695 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
696 break;
697 case CFG_CNF_HOLDOVER_DURATION:
698 lp->holdoverDuration = pLtv->u.u16[0];
699 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
700 break;
701 case CFG_CNF_OWN_NAME:
702 memset( lp->StationName, 0, sizeof( lp->StationName ));
703 memcpy( (void *)lp->StationName, (void *)&pLtv->u.u8[2], (size_t)pLtv->u.u16[0]);
704 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
705 break;
706 case CFG_CNF_LOAD_BALANCING:
707 lp->loadBalancing = pLtv->u.u16[0];
708 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
709 break;
710 case CFG_CNF_MEDIUM_DISTRIBUTION:
711 lp->mediumDistribution = pLtv->u.u16[0];
712 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
713 break;
714 #ifdef WARP
715 case CFG_CNF_TX_POW_LVL:
716 lp->txPowLevel = pLtv->u.u16[0];
717 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
718 break;
719 //case CFG_CNF_SHORT_RETRY_LIMIT: // Short Retry Limit
720 //case 0xFC33: // Long Retry Limit
721 case CFG_SUPPORTED_RATE_SET_CNTL: // Supported Rate Set Control
722 lp->srsc[0] = pLtv->u.u16[0];
723 lp->srsc[1] = pLtv->u.u16[1];
724 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
725 pLtv->u.u16[1] = CNV_INT_TO_LITTLE( pLtv->u.u16[1] );
726 break;
727 case CFG_BASIC_RATE_SET_CNTL: // Basic Rate Set Control
728 lp->brsc[0] = pLtv->u.u16[0];
729 lp->brsc[1] = pLtv->u.u16[1];
730 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
731 pLtv->u.u16[1] = CNV_INT_TO_LITTLE( pLtv->u.u16[1] );
732 break;
733 case CFG_CNF_CONNECTION_CNTL:
734 lp->connectionControl = pLtv->u.u16[0];
735 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
736 break;
737 //case CFG_PROBE_DATA_RATE:
738 #endif // HERMES25
739
740 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
741 //;?should we restore this to allow smaller memory footprint
742
743 case CFG_CNF_OWN_DTIM_PERIOD:
744 lp->DTIMPeriod = pLtv->u.u16[0];
745 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
746 break;
747 #ifdef WARP
748 case CFG_CNF_OWN_BEACON_INTERVAL: // Own Beacon Interval
749 lp->ownBeaconInterval = pLtv->u.u16[0];
750 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
751 break;
752 #endif // WARP
753 case CFG_COEXISTENSE_BEHAVIOUR: // Coexistence behavior
754 lp->coexistence = pLtv->u.u16[0];
755 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
756 break;
757 #ifdef USE_WDS
758 case CFG_CNF_WDS_ADDR1:
759 memcpy( &lp->wds_port[0].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
760 hcfPort = HCF_PORT_1;
761 break;
762 case CFG_CNF_WDS_ADDR2:
763 memcpy( &lp->wds_port[1].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
764 hcfPort = HCF_PORT_2;
765 break;
766 case CFG_CNF_WDS_ADDR3:
767 memcpy( &lp->wds_port[2].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
768 hcfPort = HCF_PORT_3;
769 break;
770 case CFG_CNF_WDS_ADDR4:
771 memcpy( &lp->wds_port[3].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
772 hcfPort = HCF_PORT_4;
773 break;
774 case CFG_CNF_WDS_ADDR5:
775 memcpy( &lp->wds_port[4].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
776 hcfPort = HCF_PORT_5;
777 break;
778 case CFG_CNF_WDS_ADDR6:
779 memcpy( &lp->wds_port[5].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
780 hcfPort = HCF_PORT_6;
781 break;
782 #endif /* USE_WDS */
783
784 case CFG_CNF_MCAST_PM_BUF:
785 lp->multicastPMBuffering = pLtv->u.u16[0];
786 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
787 break;
788 case CFG_CNF_REJECT_ANY:
789 lp->RejectAny = pLtv->u.u16[0];
790 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
791 break;
792 #endif
793
794 case CFG_CNF_ENCRYPTION:
795 lp->EnableEncryption = pLtv->u.u16[0];
796 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
797 break;
798 case CFG_CNF_AUTHENTICATION:
799 lp->authentication = pLtv->u.u16[0];
800 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
801 break;
802 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
803 //;?should we restore this to allow smaller memory footprint
804
805 //case CFG_CNF_EXCL_UNENCRYPTED:
806 //lp->ExcludeUnencrypted = pLtv->u.u16[0];
807 //pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
808 //break;
809 case CFG_CNF_MCAST_RATE:
810 /* TODO: determine if we are going to store anything based on this */
811 break;
812 case CFG_CNF_INTRA_BSS_RELAY:
813 lp->intraBSSRelay = pLtv->u.u16[0];
814 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
815 break;
816 #endif
817
818 case CFG_CNF_MICRO_WAVE:
819 /* TODO: determine if we are going to store anything based on this */
820 break;
821 //case CFG_CNF_LOAD_BALANCING:
822 /* TODO: determine if we are going to store anything based on this */
823 //break;
824 //case CFG_CNF_MEDIUM_DISTRIBUTION:
825 /* TODO: determine if we are going to store anything based on this */
826 //break;
827 //case CFG_CNF_RX_ALL_GROUP_ADDRESS:
828 // TODO: determine if we are going to store anything based on this
829 //break;
830 //case CFG_CNF_COUNTRY_INFO:
831 /* TODO: determine if we are going to store anything based on this */
832 //break;
833 case CFG_CNF_OWN_SSID:
834 //case CNF_DESIRED_SSID:
835 case CFG_DESIRED_SSID:
836 memset( lp->NetworkName, 0, sizeof( lp->NetworkName ));
837 memcpy( (void *)lp->NetworkName, (void *)&pLtv->u.u8[2], (size_t)pLtv->u.u16[0] );
838 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
839
840 /* take care of the special network name "ANY" case */
841 if(( strlen( &pLtv->u.u8[2] ) == 0 ) ||
842 ( strcmp( &pLtv->u.u8[2], "ANY" ) == 0 ) ||
843 ( strcmp( &pLtv->u.u8[2], "any" ) == 0 )) {
844 /* set the SSID_STRCT llen field (u16[0]) to zero, and the
845 effectually null the string u8[2] */
846 pLtv->u.u16[0] = 0;
847 pLtv->u.u8[2] = 0;
848 }
849 break;
850 case CFG_GROUP_ADDR:
851 /* TODO: determine if we are going to store anything based on this */
852 break;
853 case CFG_CREATE_IBSS:
854 lp->CreateIBSS = pLtv->u.u16[0];
855 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
856 break;
857 case CFG_RTS_THRH:
858 lp->RTSThreshold = pLtv->u.u16[0];
859 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
860 break;
861 case CFG_TX_RATE_CNTL:
862 lp->TxRateControl[0] = pLtv->u.u16[0];
863 lp->TxRateControl[1] = pLtv->u.u16[1];
864 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
865 pLtv->u.u16[1] = CNV_INT_TO_LITTLE( pLtv->u.u16[1] );
866 break;
867 case CFG_PROMISCUOUS_MODE:
868 /* TODO: determine if we are going to store anything based on this */
869 break;
870 //case CFG_WAKE_ON_LAN:
871 /* TODO: determine if we are going to store anything based on this */
872 //break;
873 #if 1 //;? #if (HCF_TYPE) & HCF_TYPE_AP
874 //;?should we restore this to allow smaller memory footprint
875 case CFG_RTS_THRH0:
876 lp->RTSThreshold = pLtv->u.u16[0];
877 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
878 break;
879 case CFG_TX_RATE_CNTL0:
880 //;?no idea what this should be, get going so comment it out lp->TxRateControl = pLtv->u.u16[0];
881 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
882 break;
883 #ifdef USE_WDS
884 case CFG_RTS_THRH1:
885 lp->wds_port[0].rtsThreshold = pLtv->u.u16[0];
886 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
887 hcfPort = HCF_PORT_1;
888 break;
889 case CFG_RTS_THRH2:
890 lp->wds_port[1].rtsThreshold = pLtv->u.u16[0];
891 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
892 hcfPort = HCF_PORT_2;
893 break;
894 case CFG_RTS_THRH3:
895 lp->wds_port[2].rtsThreshold = pLtv->u.u16[0];
896 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
897 hcfPort = HCF_PORT_3;
898 break;
899 case CFG_RTS_THRH4:
900 lp->wds_port[3].rtsThreshold = pLtv->u.u16[0];
901 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
902 hcfPort = HCF_PORT_4;
903 break;
904 case CFG_RTS_THRH5:
905 lp->wds_port[4].rtsThreshold = pLtv->u.u16[0];
906 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
907 hcfPort = HCF_PORT_5;
908 break;
909 case CFG_RTS_THRH6:
910 lp->wds_port[5].rtsThreshold = pLtv->u.u16[0];
911 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
912 hcfPort = HCF_PORT_6;
913 break;
914 case CFG_TX_RATE_CNTL1:
915 lp->wds_port[0].txRateCntl = pLtv->u.u16[0];
916 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
917 hcfPort = HCF_PORT_1;
918 break;
919 case CFG_TX_RATE_CNTL2:
920 lp->wds_port[1].txRateCntl = pLtv->u.u16[0];
921 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
922 hcfPort = HCF_PORT_2;
923 break;
924 case CFG_TX_RATE_CNTL3:
925 lp->wds_port[2].txRateCntl = pLtv->u.u16[0];
926 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
927 hcfPort = HCF_PORT_3;
928 break;
929 case CFG_TX_RATE_CNTL4:
930 lp->wds_port[3].txRateCntl = pLtv->u.u16[0];
931 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
932 hcfPort = HCF_PORT_4;
933 break;
934 case CFG_TX_RATE_CNTL5:
935 lp->wds_port[4].txRateCntl = pLtv->u.u16[0];
936 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
937 hcfPort = HCF_PORT_5;
938 break;
939 case CFG_TX_RATE_CNTL6:
940 lp->wds_port[5].txRateCntl = pLtv->u.u16[0];
941 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
942 hcfPort = HCF_PORT_6;
943 break;
944 #endif /* USE_WDS */
945 #endif /* (HCF_TYPE) & HCF_TYPE_AP */
946
947 case CFG_DEFAULT_KEYS:
948 {
949 CFG_DEFAULT_KEYS_STRCT *pKeys = (CFG_DEFAULT_KEYS_STRCT *)pLtv;
950
951 pKeys->key[0].len = CNV_INT_TO_LITTLE( pKeys->key[0].len );
952 pKeys->key[1].len = CNV_INT_TO_LITTLE( pKeys->key[1].len );
953 pKeys->key[2].len = CNV_INT_TO_LITTLE( pKeys->key[2].len );
954 pKeys->key[3].len = CNV_INT_TO_LITTLE( pKeys->key[3].len );
955
956 memcpy( (void *)&(lp->DefaultKeys), (void *)pKeys,
957 sizeof( CFG_DEFAULT_KEYS_STRCT ));
958 }
959 break;
960 case CFG_TX_KEY_ID:
961 lp->TransmitKeyID = pLtv->u.u16[0];
962 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
963 break;
964 case CFG_SCAN_SSID:
965 /* TODO: determine if we are going to store anything based on this */
966 break;
967 case CFG_TICK_TIME:
968 /* TODO: determine if we are going to store anything based on this */
969 break;
970 /* these RIDS are Info RIDs, and should they be allowed for puts??? */
971 case CFG_MAX_LOAD_TIME:
972 case CFG_DL_BUF:
973 //case CFG_HSI_SUP_RANGE:
974 case CFG_NIC_SERIAL_NUMBER:
975 case CFG_NIC_IDENTITY:
976 case CFG_NIC_MFI_SUP_RANGE:
977 case CFG_NIC_CFI_SUP_RANGE:
978 case CFG_NIC_TEMP_TYPE:
979 case CFG_NIC_PROFILE:
980 case CFG_FW_IDENTITY:
981 case CFG_FW_SUP_RANGE:
982 case CFG_MFI_ACT_RANGES_STA:
983 case CFG_CFI_ACT_RANGES_STA:
984 case CFG_PORT_STAT:
985 case CFG_CUR_SSID:
986 case CFG_CUR_BSSID:
987 case CFG_COMMS_QUALITY:
988 case CFG_CUR_TX_RATE:
989 case CFG_CUR_BEACON_INTERVAL:
990 case CFG_CUR_SCALE_THRH:
991 case CFG_PROTOCOL_RSP_TIME:
992 case CFG_CUR_SHORT_RETRY_LIMIT:
993 case CFG_CUR_LONG_RETRY_LIMIT:
994 case CFG_MAX_TX_LIFETIME:
995 case CFG_MAX_RX_LIFETIME:
996 case CFG_CF_POLLABLE:
997 case CFG_AUTHENTICATION_ALGORITHMS:
998 case CFG_PRIVACY_OPT_IMPLEMENTED:
999 //case CFG_CURRENT_REMOTE_RATES:
1000 //case CFG_CURRENT_USED_RATES:
1001 //case CFG_CURRENT_SYSTEM_SCALE:
1002 //case CFG_CURRENT_TX_RATE1:
1003 //case CFG_CURRENT_TX_RATE2:
1004 //case CFG_CURRENT_TX_RATE3:
1005 //case CFG_CURRENT_TX_RATE4:
1006 //case CFG_CURRENT_TX_RATE5:
1007 //case CFG_CURRENT_TX_RATE6:
1008 case CFG_NIC_MAC_ADDR:
1009 case CFG_PCF_INFO:
1010 //case CFG_CURRENT_COUNTRY_INFO:
1011 case CFG_PHY_TYPE:
1012 case CFG_CUR_CHANNEL:
1013 //case CFG_CURRENT_POWER_STATE:
1014 //case CFG_CCAMODE:
1015 case CFG_SUPPORTED_DATA_RATES:
1016 break;
1017 case CFG_AP_MODE:
1018 //;? lp->DownloadFirmware = ( pLtv->u.u16[0] ) + 1;
1019 DBG_ERROR( DbgInfo, "set CFG_AP_MODE no longer supported\n" );
1020 break;
1021 case CFG_ENCRYPT_STRING:
1022 /* TODO: ENDIAN TRANSLATION HERE??? */
1023 memset( lp->szEncryption, 0, sizeof( lp->szEncryption ));
1024 memcpy( (void *)lp->szEncryption, (void *)&pLtv->u.u8[0],
1025 ( pLtv->len * sizeof( hcf_16 )) );
1026 wl_wep_decode( CRYPT_CODE, &sEncryption,
1027 lp->szEncryption );
1028
1029 /* the Linux driver likes to use 1-4 for the key IDs, and then
1030 convert to 0-3 when sending to the card. The Windows code
1031 base used 0-3 in the API DLL, which was ported to Linux. For
1032 the sake of the user experience, we decided to keep 0-3 as the
1033 numbers used in the DLL; and will perform the +1 conversion here.
1034 We could have converted the entire Linux driver, but this is
1035 less obtrusive. This may be a "todo" to convert the whole driver */
1036 lp->TransmitKeyID = sEncryption.wTxKeyID + 1;
1037 lp->EnableEncryption = sEncryption.wEnabled;
1038
1039 memcpy( &lp->DefaultKeys, &sEncryption.EncStr,
1040 sizeof( CFG_DEFAULT_KEYS_STRCT ));
1041 break;
1042 /*case CFG_COUNTRY_STRING:
1043 memset( lp->countryString, 0, sizeof( lp->countryString ));
1044 memcpy( (void *)lp->countryString, (void *)&pLtv->u.u8[2], (size_t)pLtv->u.u16[0]);
1045 break;
1046 */
1047
1048 case CFG_DRIVER_ENABLE:
1049 lp->driverEnable = pLtv->u.u16[0];
1050 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
1051 break;
1052 case CFG_WOLAS_ENABLE:
1053 lp->wolasEnable = pLtv->u.u16[0];
1054 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
1055 break;
1056 case CFG_SET_WPA_AUTH_KEY_MGMT_SUITE:
1057 lp->AuthKeyMgmtSuite = pLtv->u.u16[0];
1058 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
1059 break;
1060 case CFG_DISASSOCIATE_ADDR:
1061 pLtv->u.u16[ETH_ALEN / 2] = CNV_INT_TO_LITTLE( pLtv->u.u16[ETH_ALEN / 2] );
1062 break;
1063 case CFG_ADD_TKIP_DEFAULT_KEY:
1064 case CFG_REMOVE_TKIP_DEFAULT_KEY:
1065 /* Endian convert the Tx Key Information */
1066 pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
1067 break;
1068 case CFG_ADD_TKIP_MAPPED_KEY:
1069 break;
1070 case CFG_REMOVE_TKIP_MAPPED_KEY:
1071 break;
1072 /* some RIDs just can't be put */
1073 case CFG_MB_INFO:
1074 case CFG_IFB:
1075 default:
1076 break;
1077 }
1078
1079 /* This code will prevent Static Configuration Entities from
1080 being sent to the card, as they require a call to
1081 UIL_ACT_APPLY to take effect. Dynamic Entities will be sent
1082 immediately */
1083 switch( pLtv->typ ) {
1084 case CFG_CNF_PORT_TYPE:
1085 case CFG_CNF_OWN_MAC_ADDR:
1086 case CFG_CNF_OWN_CHANNEL:
1087 case CFG_CNF_OWN_SSID:
1088 case CFG_CNF_OWN_ATIM_WINDOW:
1089 case CFG_CNF_SYSTEM_SCALE:
1090 case CFG_CNF_MAX_DATA_LEN:
1091 case CFG_CNF_PM_ENABLED:
1092 case CFG_CNF_MCAST_RX:
1093 case CFG_CNF_MAX_SLEEP_DURATION:
1094 case CFG_CNF_HOLDOVER_DURATION:
1095 case CFG_CNF_OWN_NAME:
1096 case CFG_CNF_LOAD_BALANCING:
1097 case CFG_CNF_MEDIUM_DISTRIBUTION:
1098 #ifdef WARP
1099 case CFG_CNF_TX_POW_LVL:
1100 case CFG_CNF_CONNECTION_CNTL:
1101 //case CFG_PROBE_DATA_RATE:
1102 #endif // HERMES25
1103 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
1104 //;?should we restore this to allow smaller memory footprint
1105 case CFG_CNF_OWN_DTIM_PERIOD:
1106 #ifdef WARP
1107 case CFG_CNF_OWN_BEACON_INTERVAL: // Own Beacon Interval
1108 #endif // WARP
1109 #ifdef USE_WDS
1110 case CFG_CNF_WDS_ADDR1:
1111 case CFG_CNF_WDS_ADDR2:
1112 case CFG_CNF_WDS_ADDR3:
1113 case CFG_CNF_WDS_ADDR4:
1114 case CFG_CNF_WDS_ADDR5:
1115 case CFG_CNF_WDS_ADDR6:
1116 #endif
1117 case CFG_CNF_MCAST_PM_BUF:
1118 case CFG_CNF_REJECT_ANY:
1119 #endif
1120
1121 case CFG_CNF_ENCRYPTION:
1122 case CFG_CNF_AUTHENTICATION:
1123 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
1124 //;?should we restore this to allow smaller memory footprint
1125
1126 case CFG_CNF_EXCL_UNENCRYPTED:
1127 case CFG_CNF_MCAST_RATE:
1128 case CFG_CNF_INTRA_BSS_RELAY:
1129 #endif
1130
1131 case CFG_CNF_MICRO_WAVE:
1132 //case CFG_CNF_LOAD_BALANCING:
1133 //case CFG_CNF_MEDIUM_DISTRIBUTION:
1134 //case CFG_CNF_RX_ALL_GROUP_ADDRESS:
1135 //case CFG_CNF_COUNTRY_INFO:
1136 //case CFG_COUNTRY_STRING:
1137 case CFG_AP_MODE:
1138 case CFG_ENCRYPT_STRING:
1139 //case CFG_DRIVER_ENABLE:
1140 case CFG_WOLAS_ENABLE:
1141 case CFG_MB_INFO:
1142 case CFG_IFB:
1143 break;
1144 /* Deal with this dynamic MSF RID, as it's required for WPA */
1145 case CFG_DRIVER_ENABLE:
1146 if( lp->driverEnable ) {
1147 //hcf_cntl_port( &( lp->hcfCtx ),
1148 // HCF_PORT_ENABLE | HCF_PORT_0 );
1149 // //hcf_cntl( &( lp->hcfCtx ),
1150 // // HCF_PORT_ENABLE | HCF_PORT_0 );
1151 //hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_ENABLE );
1152 // //hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_CONNECT );
1153
1154 hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_ENABLE | HCF_PORT_0 );
1155 hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_CONNECT );
1156 } else {
1157 //hcf_cntl_port( &( lp->hcfCtx ),
1158 // HCF_PORT_DISABLE | HCF_PORT_0 );
1159 // //hcf_cntl( &( lp->hcfCtx ),
1160 // // HCF_PORT_DISABLE | HCF_PORT_0 );
1161 //hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_DISABLE );
1162 // //hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_DISCONNECT );
1163
1164 hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_DISABLE | HCF_PORT_0 );
1165 hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_DISCONNECT );
1166 }
1167 break;
1168 default:
1169 wl_act_int_off( lp );
1170 urq->result = hcf_put_info(&(lp->hcfCtx), (LTVP) pLtv);
1171 wl_act_int_on( lp );
1172 break;
1173 }
1174
1175 if( ltvAllocated ) {
1176 kfree( pLtv );
1177 }
1178 } else {
1179 urq->result = UIL_FAILURE;
1180 }
1181 } else {
1182 DBG_ERROR( DbgInfo, "EPERM\n" );
1183 urq->result = UIL_FAILURE;
1184 result = -EPERM;
1185 }
1186 } else {
1187 DBG_ERROR( DbgInfo, "UIL_ERR_WRONG_IFB\n" );
1188 urq->result = UIL_ERR_WRONG_IFB;
1189 }
1190
1191 DBG_LEAVE( DbgInfo );
1192 return result;
1193 } // wvlan_uil_put_info
1194 /*============================================================================*/
1195
1196 /*******************************************************************************
1197 * wvlan_uil_get_info()
1198 *******************************************************************************
1199 *
1200 * DESCRIPTION:
1201 *
1202 * Sends a specific RID directly to the driver to retrieve configuration
1203 * info.
1204 *
1205 * PARAMETERS:
1206 *
1207 * urq - a pointer to the UIL request buffer
1208 * lp - a pointer to the device's private adapter structure
1209 *
1210 * RETURNS:
1211 *
1212 * UIL_SUCCESS
1213 * UIL_ERR_xxx value otherwise
1214 *
1215 ******************************************************************************/
1216 int wvlan_uil_get_info( struct uilreq *urq, struct wl_private *lp )
1217 {
1218 int result = 0;
1219 int i;
1220 /*------------------------------------------------------------------------*/
1221
1222 DBG_FUNC( "wvlan_uil_get_info" );
1223 DBG_ENTER( DbgInfo );
1224
1225 if( urq->hcfCtx == &( lp->hcfCtx )) {
1226 if(( urq->data != NULL ) && ( urq->len != 0 )) {
1227 ltv_t *pLtv;
1228 bool_t ltvAllocated = FALSE;
1229
1230 /* Make sure that we have at least a command and length */
1231 if( urq->len < ( sizeof( hcf_16 ) * 2 )) {
1232 urq->len = sizeof( lp->ltvRecord );
1233 DBG_ERROR( DbgInfo, "No Length/Type in LTV!!!\n" );
1234 DBG_ERROR( DbgInfo, "UIL_ERR_LEN\n" );
1235 urq->result = UIL_ERR_LEN;
1236 DBG_LEAVE( DbgInfo );
1237 return result;
1238 }
1239
1240 /* Verify the user's LTV record header. */
1241 result = verify_area( VERIFY_READ, urq->data, sizeof( hcf_16 ) * 2 );
1242 if( result != 0 ) {
1243 DBG_ERROR( DbgInfo, "verify_area(), VERIFY_READ FAILED\n" );
1244 urq->result = UIL_FAILURE;
1245 DBG_LEAVE( DbgInfo );
1246 return result;
1247 }
1248
1249 /* Get only the command and length information. */
1250 result = copy_from_user( &( lp->ltvRecord ), urq->data, sizeof( hcf_16 ) * 2 );
1251
1252 /* Make sure the incoming LTV record length is within the bounds of
1253 the IOCTL length. */
1254 if((( lp->ltvRecord.len + 1 ) * sizeof( hcf_16 )) > urq->len ) {
1255 DBG_ERROR( DbgInfo, "Incoming LTV too big\n" );
1256 urq->len = sizeof( lp->ltvRecord );
1257 urq->result = UIL_ERR_LEN;
1258 DBG_LEAVE( DbgInfo );
1259 return result;
1260 }
1261
1262 /* Determine if hcf_get_info() is needed or not */
1263 switch ( lp->ltvRecord.typ ) {
1264 case CFG_NIC_IDENTITY:
1265 memcpy( &lp->ltvRecord.u.u8[0], &lp->NICIdentity, sizeof( lp->NICIdentity ));
1266 break;
1267 case CFG_PRI_IDENTITY:
1268 memcpy( &lp->ltvRecord.u.u8[0], &lp->PrimaryIdentity, sizeof( lp->PrimaryIdentity ));
1269 break;
1270 case CFG_AP_MODE:
1271 DBG_ERROR( DbgInfo, "set CFG_AP_MODE no longer supported, so is get useful ????\n" );
1272 lp->ltvRecord.u.u16[0] =
1273 CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP;
1274 break;
1275 //case CFG_DRV_INFO:
1276 case CFG_ENCRYPT_STRING:
1277 case CFG_COUNTRY_STRING:
1278 case CFG_DRIVER_ENABLE:
1279 case CFG_WOLAS_ENABLE:
1280 // TODO: determine if we're going to support these
1281 urq->result = UIL_FAILURE;
1282 break;
1283 case CFG_DRV_INFO:
1284 DBG_TRACE( DbgInfo, "Intercept CFG_DRV_INFO\n" );
1285 result = cfg_driver_info( urq, lp );
1286 break;
1287 case CFG_DRV_IDENTITY:
1288 DBG_TRACE( DbgInfo, "Intercept CFG_DRV_IDENTITY\n" );
1289 result = cfg_driver_identity( urq, lp );
1290 break;
1291 case CFG_IFB:
1292 /* IFB can be a security hole */
1293 if( !capable( CAP_NET_ADMIN )) {
1294 result = -EPERM;
1295 break;
1296 }
1297
1298 /* Else fall through to the default */
1299
1300 case CFG_FW_IDENTITY: // For Hermes-1, this is cached
1301 default:
1302
1303 /* Verify the user buffer */
1304 result = verify_area( VERIFY_WRITE, urq->data, urq->len );
1305 if( result != 0 ) {
1306 DBG_ERROR( DbgInfo, "verify_area(), VERIFY_WRITE FAILED\n" );
1307 urq->result = UIL_FAILURE;
1308 break;
1309 }
1310
1311 /* If the requested length is greater than the size of our local
1312 LTV record, try to allocate it from the kernel stack.
1313 Otherwise, we just use our local LTV record. */
1314 if( urq->len > sizeof( lp->ltvRecord )) {
1315 if(( pLtv = (ltv_t *)kmalloc( urq->len, GFP_KERNEL )) != NULL ) {
1316 ltvAllocated = TRUE;
1317
1318 /* Copy the command/length information into the new buffer. */
1319 memcpy( pLtv, &( lp->ltvRecord ), sizeof( hcf_16 ) * 2 );
1320 } else {
1321 urq->len = sizeof( lp->ltvRecord );
1322 urq->result = UIL_ERR_LEN;
1323 DBG_ERROR( DbgInfo, "kmalloc FAILED\n" );
1324 DBG_ERROR( DbgInfo, "UIL_ERR_LEN\n" );
1325 result = -ENOMEM;
1326 break;
1327 }
1328 } else {
1329 pLtv = &( lp->ltvRecord );
1330 }
1331
1332 wl_act_int_off( lp );
1333 urq->result = hcf_get_info( &( lp->hcfCtx ), (LTVP) pLtv );
1334 wl_act_int_on( lp );
1335
1336 // Copy the LTV into the user's buffer.
1337 //copy_to_user( urq->data, pLtv, urq->len );
1338
1339 //if( ltvAllocated )
1340 //{
1341 // kfree( pLtv );
1342 //}
1343
1344 //urq->result = UIL_SUCCESS;
1345 break;
1346 }
1347
1348 /* Handle endian conversion of special fields */
1349 switch( lp->ltvRecord.typ ) {
1350 /* simple int gets just need the first hcf_16 byte flipped */
1351 case CFG_CNF_PORT_TYPE:
1352 case CFG_CNF_OWN_CHANNEL:
1353 case CFG_CNF_OWN_ATIM_WINDOW:
1354 case CFG_CNF_SYSTEM_SCALE:
1355 case CFG_CNF_MAX_DATA_LEN:
1356 case CFG_CNF_PM_ENABLED:
1357 case CFG_CNF_MCAST_RX:
1358 case CFG_CNF_MAX_SLEEP_DURATION:
1359 case CFG_CNF_HOLDOVER_DURATION:
1360 case CFG_CNF_OWN_DTIM_PERIOD:
1361 case CFG_CNF_MCAST_PM_BUF:
1362 case CFG_CNF_REJECT_ANY:
1363 case CFG_CNF_ENCRYPTION:
1364 case CFG_CNF_AUTHENTICATION:
1365 case CFG_CNF_EXCL_UNENCRYPTED:
1366 case CFG_CNF_INTRA_BSS_RELAY:
1367 case CFG_CNF_MICRO_WAVE:
1368 case CFG_CNF_LOAD_BALANCING:
1369 case CFG_CNF_MEDIUM_DISTRIBUTION:
1370 #ifdef WARP
1371 case CFG_CNF_TX_POW_LVL:
1372 case CFG_CNF_CONNECTION_CNTL:
1373 case CFG_CNF_OWN_BEACON_INTERVAL: // Own Beacon Interval
1374 case CFG_COEXISTENSE_BEHAVIOUR: // Coexistence Behavior
1375 //case CFG_CNF_RX_ALL_GROUP_ADDRESS:
1376 #endif // HERMES25
1377 case CFG_CREATE_IBSS:
1378 case CFG_RTS_THRH:
1379 case CFG_PROMISCUOUS_MODE:
1380 //case CFG_WAKE_ON_LAN:
1381 case CFG_RTS_THRH0:
1382 case CFG_RTS_THRH1:
1383 case CFG_RTS_THRH2:
1384 case CFG_RTS_THRH3:
1385 case CFG_RTS_THRH4:
1386 case CFG_RTS_THRH5:
1387 case CFG_RTS_THRH6:
1388 case CFG_TX_RATE_CNTL0:
1389 case CFG_TX_RATE_CNTL1:
1390 case CFG_TX_RATE_CNTL2:
1391 case CFG_TX_RATE_CNTL3:
1392 case CFG_TX_RATE_CNTL4:
1393 case CFG_TX_RATE_CNTL5:
1394 case CFG_TX_RATE_CNTL6:
1395 case CFG_TX_KEY_ID:
1396 case CFG_TICK_TIME:
1397 case CFG_MAX_LOAD_TIME:
1398 case CFG_NIC_TEMP_TYPE:
1399 case CFG_PORT_STAT:
1400 case CFG_CUR_TX_RATE:
1401 case CFG_CUR_BEACON_INTERVAL:
1402 case CFG_PROTOCOL_RSP_TIME:
1403 case CFG_CUR_SHORT_RETRY_LIMIT:
1404 case CFG_CUR_LONG_RETRY_LIMIT:
1405 case CFG_MAX_TX_LIFETIME:
1406 case CFG_MAX_RX_LIFETIME:
1407 case CFG_CF_POLLABLE:
1408 case CFG_PRIVACY_OPT_IMPLEMENTED:
1409 //case CFG_CURRENT_REMOTE_RATES:
1410 //case CFG_CURRENT_USED_RATES:
1411 //case CFG_CURRENT_SYSTEM_SCALE:
1412 //case CFG_CURRENT_TX_RATE1:
1413 //case CFG_CURRENT_TX_RATE2:
1414 //case CFG_CURRENT_TX_RATE3:
1415 //case CFG_CURRENT_TX_RATE4:
1416 //case CFG_CURRENT_TX_RATE5:
1417 //case CFG_CURRENT_TX_RATE6:
1418 case CFG_PHY_TYPE:
1419 case CFG_CUR_CHANNEL:
1420 //case CFG_CURRENT_POWER_STATE:
1421 //case CFG_CCAMODE:
1422 // lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1423 // break;
1424 /* name string gets just need the first hcf_16 byte flipped (length of string) */
1425 case CFG_CNF_OWN_SSID:
1426 case CFG_CNF_OWN_NAME:
1427 //case CNF_DESIRED_SSID:
1428 case CFG_DESIRED_SSID:
1429 case CFG_SCAN_SSID:
1430 case CFG_CUR_SSID:
1431 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1432 break;
1433 /* non-length counted strings need no byte flipping */
1434 case CFG_CNF_OWN_MAC_ADDR:
1435 /* this case is no longer valid: CFG_CNF_WDS_ADDR */
1436 case CFG_CNF_WDS_ADDR1:
1437 case CFG_CNF_WDS_ADDR2:
1438 case CFG_CNF_WDS_ADDR3:
1439 case CFG_CNF_WDS_ADDR4:
1440 case CFG_CNF_WDS_ADDR5:
1441 case CFG_CNF_WDS_ADDR6:
1442 case CFG_GROUP_ADDR:
1443 case CFG_NIC_SERIAL_NUMBER:
1444 case CFG_CUR_BSSID:
1445 case CFG_NIC_MAC_ADDR:
1446 case CFG_SUPPORTED_DATA_RATES: /* need to ensure we can treat this as a string */
1447 break;
1448 //case CFG_CNF_COUNTRY_INFO: /* special case, see page 75 of 022486, Rev C. */
1449 //case CFG_CURRENT_COUNTRY_INFO: /* special case, see page 101 of 022486, Rev C. */
1450 /*
1451 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1452 lp->ltvRecord.u.u16[3] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[3] );
1453
1454 for( i = 4; i < lp->ltvRecord.len; i++ ) {
1455 lp->ltvRecord.u.u16[i] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[i] );
1456 }
1457 break;
1458 */
1459
1460 case CFG_DEFAULT_KEYS:
1461 {
1462 CFG_DEFAULT_KEYS_STRCT *pKeys = (CFG_DEFAULT_KEYS_STRCT *)&lp->ltvRecord.u.u8[0];
1463
1464 pKeys[0].len = CNV_INT_TO_LITTLE( pKeys[0].len );
1465 pKeys[1].len = CNV_INT_TO_LITTLE( pKeys[1].len );
1466 pKeys[2].len = CNV_INT_TO_LITTLE( pKeys[2].len );
1467 pKeys[3].len = CNV_INT_TO_LITTLE( pKeys[3].len );
1468 }
1469 break;
1470 case CFG_CNF_MCAST_RATE:
1471 case CFG_TX_RATE_CNTL:
1472 case CFG_SUPPORTED_RATE_SET_CNTL: // Supported Rate Set Control
1473 case CFG_BASIC_RATE_SET_CNTL: // Basic Rate Set Control
1474 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1475 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[1] );
1476 break;
1477 case CFG_DL_BUF:
1478 case CFG_NIC_IDENTITY:
1479 case CFG_COMMS_QUALITY:
1480 case CFG_PCF_INFO:
1481 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1482 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[1] );
1483 lp->ltvRecord.u.u16[2] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[2] );
1484 break;
1485 case CFG_FW_IDENTITY:
1486 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1487 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[1] );
1488 lp->ltvRecord.u.u16[2] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[2] );
1489 lp->ltvRecord.u.u16[3] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[3] );
1490 break;
1491 //case CFG_HSI_SUP_RANGE:
1492 case CFG_NIC_MFI_SUP_RANGE:
1493 case CFG_NIC_CFI_SUP_RANGE:
1494 case CFG_NIC_PROFILE:
1495 case CFG_FW_SUP_RANGE:
1496 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1497 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[1] );
1498 lp->ltvRecord.u.u16[2] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[2] );
1499 lp->ltvRecord.u.u16[3] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[3] );
1500 lp->ltvRecord.u.u16[4] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[4] );
1501 break;
1502 case CFG_MFI_ACT_RANGES_STA:
1503 case CFG_CFI_ACT_RANGES_STA:
1504 case CFG_CUR_SCALE_THRH:
1505 case CFG_AUTHENTICATION_ALGORITHMS:
1506 for( i = 0; i < ( lp->ltvRecord.len - 1 ); i++ ) {
1507 lp->ltvRecord.u.u16[i] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[i] );
1508 }
1509 break;
1510 /* done at init time, and endian handled then */
1511 case CFG_PRI_IDENTITY:
1512 break;
1513 case CFG_MB_INFO:
1514 //wvlanEndianTranslateMailbox( pLtv );
1515 break;
1516 /* MSF and HCF RIDS */
1517 case CFG_IFB:
1518 case CFG_DRV_INFO:
1519 case CFG_AP_MODE:
1520 case CFG_ENCRYPT_STRING:
1521 case CFG_COUNTRY_STRING:
1522 case CFG_DRIVER_ENABLE:
1523 case CFG_WOLAS_ENABLE:
1524 default:
1525 break;
1526 }
1527
1528 // Copy the LTV into the user's buffer.
1529 copy_to_user( urq->data, &( lp->ltvRecord ), urq->len );
1530
1531 if( ltvAllocated ) {
1532 kfree( &( lp->ltvRecord ));
1533 }
1534
1535 urq->result = UIL_SUCCESS;
1536 } else {
1537 urq->result = UIL_FAILURE;
1538 }
1539 } else {
1540 DBG_ERROR( DbgInfo, "UIL_ERR_WRONG_IFB\n" );
1541 urq->result = UIL_ERR_WRONG_IFB;
1542 }
1543
1544 DBG_LEAVE( DbgInfo );
1545 return result;
1546 } // wvlan_uil_get_info
1547 /*============================================================================*/
1548
1549
1550
1551
1552
1553 /*******************************************************************************
1554 * cfg_driver_info()
1555 *******************************************************************************
1556 *
1557 * DESCRIPTION:
1558 *
1559 * Retrieves driver information.
1560 *
1561 * PARAMETERS:
1562 *
1563 * urq - a pointer to the UIL request buffer
1564 * lp - a pointer to the device's private adapter structure
1565 *
1566 * RETURNS:
1567 *
1568 * UIL_SUCCESS
1569 * UIL_ERR_xxx value otherwise
1570 *
1571 ******************************************************************************/
1572 int cfg_driver_info( struct uilreq *urq, struct wl_private *lp )
1573 {
1574 int result = 0;
1575 /*------------------------------------------------------------------------*/
1576
1577
1578 DBG_FUNC( "cfg_driver_info" );
1579 DBG_ENTER( DbgInfo );
1580
1581
1582 /* Make sure that user buffer can handle the driver information buffer */
1583 if( urq->len < sizeof( lp->driverInfo )) {
1584 urq->len = sizeof( lp->driverInfo );
1585 urq->result = UIL_ERR_LEN;
1586 DBG_LEAVE( DbgInfo );
1587 return result;
1588 }
1589
1590 /* Verify the user buffer. */
1591 result = verify_area( VERIFY_WRITE, urq->data, sizeof( lp->driverInfo ));
1592 if( result != 0 ) {
1593 urq->result = UIL_FAILURE;
1594 DBG_LEAVE( DbgInfo );
1595 return result;
1596 }
1597
1598 lp->driverInfo.card_stat = lp->hcfCtx.IFB_CardStat;
1599
1600 // Copy the driver information into the user's buffer.
1601 urq->result = UIL_SUCCESS;
1602 copy_to_user( urq->data, &( lp->driverInfo ), sizeof( lp->driverInfo ));
1603
1604 DBG_LEAVE( DbgInfo );
1605 return result;
1606 } // cfg_driver_info
1607 /*============================================================================*/
1608
1609
1610
1611
1612 /*******************************************************************************
1613 * cfg_driver_identity()
1614 *******************************************************************************
1615 *
1616 * DESCRIPTION:
1617 *
1618 * Retrieves ID information from the card.
1619 *
1620 * PARAMETERS:
1621 *
1622 * urq - a pointer to the UIL request buffer
1623 * lp - a pointer to the device's private adapter structure
1624 *
1625 * RETURNS:
1626 *
1627 * UIL_SUCCESS
1628 * UIL_ERR_xxx value otherwise
1629 *
1630 ******************************************************************************/
1631 int cfg_driver_identity( struct uilreq *urq, struct wl_private *lp )
1632 {
1633 int result = 0;
1634 /*------------------------------------------------------------------------*/
1635
1636
1637 DBG_FUNC( "wvlan_driver_identity" );
1638 DBG_ENTER( DbgInfo );
1639
1640
1641 /* Make sure that user buffer can handle the driver identity structure. */
1642 if( urq->len < sizeof( lp->driverIdentity )) {
1643 urq->len = sizeof( lp->driverIdentity );
1644 urq->result = UIL_ERR_LEN;
1645 DBG_LEAVE( DbgInfo );
1646 return result;
1647 }
1648
1649 /* Verify the user buffer. */
1650 result = verify_area( VERIFY_WRITE, urq->data, sizeof( lp->driverIdentity ));
1651 if( result != 0 ) {
1652 urq->result = UIL_FAILURE;
1653 DBG_LEAVE( DbgInfo );
1654 return result;
1655 }
1656
1657 /* Copy the driver identity into the user's buffer. */
1658 urq->result = UIL_SUCCESS;
1659 copy_to_user( urq->data, &( lp->driverIdentity ), sizeof( lp->driverIdentity ));
1660
1661 DBG_LEAVE( DbgInfo );
1662 return result;
1663 } // cfg_driver_identity
1664 /*============================================================================*/
1665
1666
1667 #endif /* USE_UIL */
1668
1669
1670 /* If WIRELESS_EXT is not defined, then the functions that follow will not be
1671 included in the build. */
1672 /* NOTE: Are these still even needed? */
1673 #ifdef WIRELESS_EXT
1674
1675
1676 /*******************************************************************************
1677 * wvlan_set_netname()
1678 *******************************************************************************
1679 *
1680 * DESCRIPTION:
1681 *
1682 * Set the ESSID of the card.
1683 *
1684 * PARAMETERS:
1685 *
1686 * wrq - a pointer to the wireless request buffer
1687 * lp - a pointer to the device's private adapter structure
1688 *
1689 * RETURNS:
1690 *
1691 * 0 on success
1692 * errno value otherwise
1693 *
1694 ******************************************************************************/
1695 int wvlan_set_netname(struct net_device *dev,
1696 struct iw_request_info *info,
1697 union iwreq_data *wrqu,
1698 char *extra)
1699 {
1700 struct wl_private *lp = wl_priv(dev);
1701 unsigned long flags;
1702 int ret = 0;
1703 /*------------------------------------------------------------------------*/
1704
1705
1706 DBG_FUNC( "wvlan_set_netname" );
1707 DBG_ENTER( DbgInfo );
1708
1709 wl_lock(lp, &flags);
1710
1711 memset( lp->NetworkName, 0, sizeof( lp->NetworkName ));
1712 memcpy( lp->NetworkName, extra, wrqu->data.length);
1713
1714 /* Commit the adapter parameters */
1715 wl_apply(lp);
1716 wl_unlock(lp, &flags);
1717
1718 DBG_LEAVE( DbgInfo );
1719 return ret;
1720 } // wvlan_set_netname
1721 /*============================================================================*/
1722
1723
1724
1725
1726 /*******************************************************************************
1727 * wvlan_get_netname()
1728 *******************************************************************************
1729 *
1730 * DESCRIPTION:
1731 *
1732 * Get the ESSID of the card.
1733 *
1734 * PARAMETERS:
1735 *
1736 * wrq - a pointer to the wireless request buffer
1737 * lp - a pointer to the device's private adapter structure
1738 *
1739 * RETURNS:
1740 *
1741 * 0 on success
1742 * errno value otherwise
1743 *
1744 ******************************************************************************/
1745 int wvlan_get_netname(struct net_device *dev,
1746 struct iw_request_info *info,
1747 union iwreq_data *wrqu,
1748 char *extra)
1749 {
1750 struct wl_private *lp = wl_priv(dev);
1751 unsigned long flags;
1752 int ret = 0;
1753 int status = -1;
1754 wvName_t *pName;
1755 /*------------------------------------------------------------------------*/
1756
1757
1758 DBG_FUNC( "wvlan_get_netname" );
1759 DBG_ENTER( DbgInfo );
1760
1761 wl_lock(lp, &flags);
1762
1763 /* Get the current network name */
1764 lp->ltvRecord.len = 1 + ( sizeof( *pName ) / sizeof( hcf_16 ));
1765 lp->ltvRecord.typ = CFG_CUR_SSID;
1766
1767 status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1768
1769 if( status == HCF_SUCCESS ) {
1770 pName = (wvName_t *)&( lp->ltvRecord.u.u32 );
1771
1772 memset(extra, '\0', HCF_MAX_NAME_LEN);
1773 wrqu->data.length = pName->length;
1774
1775 memcpy(extra, pName->name, pName->length);
1776 } else {
1777 ret = -EFAULT;
1778 }
1779
1780 wl_unlock(lp, &flags);
1781
1782 DBG_LEAVE( DbgInfo );
1783 return ret;
1784 } // wvlan_get_netname
1785 /*============================================================================*/
1786
1787
1788
1789
1790 /*******************************************************************************
1791 * wvlan_set_station_nickname()
1792 *******************************************************************************
1793 *
1794 * DESCRIPTION:
1795 *
1796 * Set the card's station nickname.
1797 *
1798 * PARAMETERS:
1799 *
1800 * wrq - a pointer to the wireless request buffer
1801 * lp - a pointer to the device's private adapter structure
1802 *
1803 * RETURNS:
1804 *
1805 * 0 on success
1806 * errno value otherwise
1807 *
1808 ******************************************************************************/
1809 int wvlan_set_station_nickname(struct net_device *dev,
1810 struct iw_request_info *info,
1811 union iwreq_data *wrqu,
1812 char *extra)
1813 {
1814 struct wl_private *lp = wl_priv(dev);
1815 unsigned long flags;
1816 int ret = 0;
1817 /*------------------------------------------------------------------------*/
1818
1819
1820 DBG_FUNC( "wvlan_set_station_nickname" );
1821 DBG_ENTER( DbgInfo );
1822
1823 wl_lock(lp, &flags);
1824
1825 memset( lp->StationName, 0, sizeof( lp->StationName ));
1826
1827 memcpy( lp->StationName, extra, wrqu->data.length);
1828
1829 /* Commit the adapter parameters */
1830 wl_apply( lp );
1831 wl_unlock(lp, &flags);
1832
1833 DBG_LEAVE( DbgInfo );
1834 return ret;
1835 } // wvlan_set_station_nickname
1836 /*============================================================================*/
1837
1838
1839
1840
1841 /*******************************************************************************
1842 * wvlan_get_station_nickname()
1843 *******************************************************************************
1844 *
1845 * DESCRIPTION:
1846 *
1847 * Get the card's station nickname.
1848 *
1849 * PARAMETERS:
1850 *
1851 * wrq - a pointer to the wireless request buffer
1852 * lp - a pointer to the device's private adapter structure
1853 *
1854 * RETURNS:
1855 *
1856 * 0 on success
1857 * errno value otherwise
1858 *
1859 ******************************************************************************/
1860 int wvlan_get_station_nickname(struct net_device *dev,
1861 struct iw_request_info *info,
1862 union iwreq_data *wrqu,
1863 char *extra)
1864 {
1865 struct wl_private *lp = wl_priv(dev);
1866 unsigned long flags;
1867 int ret = 0;
1868 int status = -1;
1869 wvName_t *pName;
1870 /*------------------------------------------------------------------------*/
1871
1872
1873 DBG_FUNC( "wvlan_get_station_nickname" );
1874 DBG_ENTER( DbgInfo );
1875
1876 wl_lock( lp, &flags );
1877
1878 /* Get the current station name */
1879 lp->ltvRecord.len = 1 + ( sizeof( *pName ) / sizeof( hcf_16 ));
1880 lp->ltvRecord.typ = CFG_CNF_OWN_NAME;
1881
1882 status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1883
1884 if( status == HCF_SUCCESS ) {
1885 pName = (wvName_t *)&( lp->ltvRecord.u.u32 );
1886
1887 memset(extra, '\0', HCF_MAX_NAME_LEN);
1888 wrqu->data.length = pName->length;
1889 memcpy(extra, pName->name, pName->length);
1890 } else {
1891 ret = -EFAULT;
1892 }
1893
1894 wl_unlock(lp, &flags);
1895
1896 //out:
1897 DBG_LEAVE( DbgInfo );
1898 return ret;
1899 } // wvlan_get_station_nickname
1900 /*============================================================================*/
1901
1902
1903
1904
1905 /*******************************************************************************
1906 * wvlan_set_porttype()
1907 *******************************************************************************
1908 *
1909 * DESCRIPTION:
1910 *
1911 * Set the card's porttype
1912 *
1913 * PARAMETERS:
1914 *
1915 * wrq - a pointer to the wireless request buffer
1916 * lp - a pointer to the device's private adapter structure
1917 *
1918 * RETURNS:
1919 *
1920 * 0 on success
1921 * errno value otherwise
1922 *
1923 ******************************************************************************/
1924 int wvlan_set_porttype(struct net_device *dev,
1925 struct iw_request_info *info,
1926 union iwreq_data *wrqu,
1927 char *extra)
1928 {
1929 struct wl_private *lp = wl_priv(dev);
1930 unsigned long flags;
1931 int ret = 0;
1932 hcf_16 portType;
1933 /*------------------------------------------------------------------------*/
1934
1935
1936 DBG_FUNC( "wvlan_set_porttype" );
1937 DBG_ENTER( DbgInfo );
1938
1939 wl_lock(lp, &flags);
1940
1941 /* Validate the new value */
1942 portType = *((__u32 *)extra);
1943
1944 if( !(( portType == 1 ) || ( portType == 3 ))) {
1945 ret = -EINVAL;
1946 goto out_unlock;
1947 }
1948
1949 lp->PortType = portType;
1950
1951 /* Commit the adapter parameters */
1952 wl_apply( lp );
1953
1954 out_unlock:
1955 wl_unlock(lp, &flags);
1956
1957 //out:
1958 DBG_LEAVE( DbgInfo );
1959 return ret;
1960 }
1961
1962 /*============================================================================*/
1963
1964
1965 /*******************************************************************************
1966 * wvlan_get_porttype()
1967 *******************************************************************************
1968 *
1969 * DESCRIPTION:
1970 *
1971 * Get the card's porttype
1972 *
1973 * PARAMETERS:
1974 *
1975 * wrq - a pointer to the wireless request buffer
1976 * lp - a pointer to the device's private adapter structure
1977 *
1978 * RETURNS:
1979 *
1980 * 0 on success
1981 * errno value otherwise
1982 *
1983 ******************************************************************************/
1984 int wvlan_get_porttype(struct net_device *dev,
1985 struct iw_request_info *info,
1986 union iwreq_data *wrqu,
1987 char *extra)
1988 {
1989 struct wl_private *lp = wl_priv(dev);
1990 unsigned long flags;
1991 int ret = 0;
1992 int status = -1;
1993 hcf_16 *pPortType;
1994 __u32 *pData = (__u32 *)extra;
1995 /*------------------------------------------------------------------------*/
1996
1997
1998 DBG_FUNC( "wvlan_get_porttype" );
1999 DBG_ENTER( DbgInfo );
2000
2001 wl_lock( lp, &flags );
2002
2003 /* Get the current port type */
2004 lp->ltvRecord.len = 1 + ( sizeof( *pPortType ) / sizeof( hcf_16 ));
2005 lp->ltvRecord.typ = CFG_CNF_PORT_TYPE;
2006
2007 status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
2008
2009 if( status == HCF_SUCCESS ) {
2010 pPortType = (hcf_16 *)&( lp->ltvRecord.u.u32 );
2011
2012 *pData = CNV_LITTLE_TO_INT( *pPortType );
2013 } else {
2014 ret = -EFAULT;
2015 }
2016
2017 wl_unlock(lp, &flags);
2018
2019 //out:
2020 DBG_LEAVE( DbgInfo );
2021 return ret;
2022 } // wvlan_get_porttype
2023 /*============================================================================*/
2024
2025 #endif // WIRELESS_EXT
2026
2027
2028
2029
2030 #ifdef USE_RTS
2031 /*******************************************************************************
2032 * wvlan_rts()
2033 *******************************************************************************
2034 *
2035 * DESCRIPTION:
2036 *
2037 * IOCTL handler for RTS commands
2038 *
2039 * PARAMETERS:
2040 *
2041 * rrq - a pointer to the rts request buffer
2042 * lp - a pointer to the device's private adapter structure
2043 *
2044 * RETURNS:
2045 *
2046 * 0 on success
2047 * errno value otherwise
2048 *
2049 ******************************************************************************/
2050 int wvlan_rts( struct rtsreq *rrq, __u32 io_base )
2051 {
2052 int ioctl_ret = 0;
2053 /*------------------------------------------------------------------------*/
2054
2055
2056 DBG_FUNC( "wvlan_rts" );
2057 DBG_ENTER( DbgInfo );
2058
2059
2060 DBG_PRINT( "io_base: 0x%08x\n", io_base );
2061
2062 switch( rrq->typ ) {
2063 case WL_IOCTL_RTS_READ:
2064 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- WL_IOCTL_RTS_READ\n");
2065 rrq->data[0] = IN_PORT_WORD( io_base + rrq->reg );
2066 DBG_TRACE( DbgInfo, " reg 0x%04x ==> 0x%04x\n", rrq->reg, CNV_LITTLE_TO_SHORT( rrq->data[0] ) );
2067 break;
2068 case WL_IOCTL_RTS_WRITE:
2069 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- WL_IOCTL_RTS_WRITE\n");
2070 OUT_PORT_WORD( io_base + rrq->reg, rrq->data[0] );
2071 DBG_TRACE( DbgInfo, " reg 0x%04x <== 0x%04x\n", rrq->reg, CNV_LITTLE_TO_SHORT( rrq->data[0] ) );
2072 break;
2073 case WL_IOCTL_RTS_BATCH_READ:
2074 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- WL_IOCTL_RTS_BATCH_READ\n");
2075 IN_PORT_STRING_16( io_base + rrq->reg, rrq->data, rrq->len );
2076 DBG_TRACE( DbgInfo, " reg 0x%04x ==> %d bytes\n", rrq->reg, rrq->len * sizeof (__u16 ) );
2077 break;
2078 case WL_IOCTL_RTS_BATCH_WRITE:
2079 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- WL_IOCTL_RTS_BATCH_WRITE\n");
2080 OUT_PORT_STRING_16( io_base + rrq->reg, rrq->data, rrq->len );
2081 DBG_TRACE( DbgInfo, " reg 0x%04x <== %d bytes\n", rrq->reg, rrq->len * sizeof (__u16) );
2082 break;
2083 default:
2084
2085 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- UNSUPPORTED RTS CODE: 0x%X", rrq->typ );
2086 ioctl_ret = -EOPNOTSUPP;
2087 break;
2088 }
2089
2090 DBG_LEAVE( DbgInfo );
2091 return ioctl_ret;
2092 } // wvlan_rts
2093 /*============================================================================*/
2094
2095 #endif /* USE_RTS */
Linux kernel - Deliverables
This page took 0.125089 seconds and 5 git commands to generate.