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