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