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