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