1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
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
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);
92
93int cfg_driver_info(struct uilreq *urq, struct wl_private *lp);
94int cfg_driver_identity(struct uilreq *urq, struct wl_private *lp);
95
96
97
98
99
100#if DBG
101extern dbg_info_t *DbgInfo;
102#endif
103
104
105
106
107
108
109#ifdef USE_UIL
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130int 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}
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195int 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}
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241int 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
256
257
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}
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296int 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
309 ltv = (ltv_t *)urq->data;
310 if (ltv != NULL) {
311
312
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}
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376int 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}
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428int 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}
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481int 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
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;
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}
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567int 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
574#ifdef USE_WDS
575 hcf_16 hcfPort = HCF_PORT_0;
576#endif
577
578 DBG_FUNC("wvlan_uil_put_info");
579 DBG_ENTER(DbgInfo);
580
581
582 if (urq->hcfCtx == &(lp->hcfCtx)) {
583 if (capable(CAP_NET_ADMIN)) {
584 if ((urq->data != NULL) && (urq->len != 0)) {
585
586 if (urq->len < (sizeof(hcf_16) * 2)) {
587 urq->len = sizeof(lp->ltvRecord);
588 urq->result = UIL_ERR_LEN;
589 DBG_ERROR(DbgInfo, "No Length/Type in LTV!!!\n");
590 DBG_ERROR(DbgInfo, "UIL_ERR_LEN\n");
591 DBG_LEAVE(DbgInfo);
592 return result;
593 }
594
595
596 result = verify_area(VERIFY_READ, urq->data, urq->len);
597 if (result != 0) {
598 urq->result = UIL_FAILURE;
599 DBG_ERROR(DbgInfo, "verify_area(), VERIFY_READ FAILED\n");
600 DBG_LEAVE(DbgInfo);
601 return result;
602 }
603
604
605 copy_from_user(&(lp->ltvRecord), urq->data, sizeof(hcf_16) * 2);
606
607
608
609 if (((lp->ltvRecord.len + 1) * sizeof(hcf_16)) > urq->len) {
610 urq->len = sizeof(lp->ltvRecord);
611 urq->result = UIL_ERR_LEN;
612 DBG_ERROR(DbgInfo, "UIL_ERR_LEN\n");
613 DBG_LEAVE(DbgInfo);
614 return result;
615 }
616
617
618
619
620 if (urq->len > sizeof(lp->ltvRecord)) {
621 pLtv = kmalloc(urq->len, GFP_KERNEL);
622 if (pLtv != NULL) {
623 ltvAllocated = TRUE;
624 } else {
625 DBG_ERROR(DbgInfo, "Alloc FAILED\n");
626 urq->len = sizeof(lp->ltvRecord);
627 urq->result = UIL_ERR_LEN;
628 result = -ENOMEM;
629 DBG_LEAVE(DbgInfo);
630 return result;
631 }
632 } else {
633 pLtv = &(lp->ltvRecord);
634 }
635
636
637
638 copy_from_user(pLtv, urq->data, urq->len);
639
640
641
642
643
644 switch (pLtv->typ) {
645 case CFG_CNF_PORT_TYPE:
646 lp->PortType = pLtv->u.u16[0];
647 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
648 break;
649 case CFG_CNF_OWN_MAC_ADDR:
650
651 break;
652 case CFG_CNF_OWN_CHANNEL:
653 lp->Channel = pLtv->u.u16[0];
654 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
655 break;
656
657
658
659 case CFG_CNF_OWN_ATIM_WINDOW:
660 lp->atimWindow = pLtv->u.u16[0];
661 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
662 break;
663 case CFG_CNF_SYSTEM_SCALE:
664 lp->DistanceBetweenAPs = pLtv->u.u16[0];
665 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
666
667 case CFG_CNF_MAX_DATA_LEN:
668
669
670 break;
671 case CFG_CNF_PM_ENABLED:
672 lp->PMEnabled = pLtv->u.u16[0];
673 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
674 break;
675 case CFG_CNF_MCAST_RX:
676 lp->MulticastReceive = pLtv->u.u16[0];
677 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
678 break;
679 case CFG_CNF_MAX_SLEEP_DURATION:
680 lp->MaxSleepDuration = pLtv->u.u16[0];
681 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
682 break;
683 case CFG_CNF_HOLDOVER_DURATION:
684 lp->holdoverDuration = pLtv->u.u16[0];
685 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
686 break;
687 case CFG_CNF_OWN_NAME:
688 memset(lp->StationName, 0, sizeof(lp->StationName));
689 memcpy((void *)lp->StationName, (void *)&pLtv->u.u8[2], (size_t)pLtv->u.u16[0]);
690 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
691 break;
692 case CFG_CNF_LOAD_BALANCING:
693 lp->loadBalancing = pLtv->u.u16[0];
694 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
695 break;
696 case CFG_CNF_MEDIUM_DISTRIBUTION:
697 lp->mediumDistribution = pLtv->u.u16[0];
698 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
699 break;
700#ifdef WARP
701 case CFG_CNF_TX_POW_LVL:
702 lp->txPowLevel = pLtv->u.u16[0];
703 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
704 break;
705
706
707 case CFG_SUPPORTED_RATE_SET_CNTL:
708 lp->srsc[0] = pLtv->u.u16[0];
709 lp->srsc[1] = pLtv->u.u16[1];
710 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
711 pLtv->u.u16[1] = CNV_INT_TO_LITTLE(pLtv->u.u16[1]);
712 break;
713 case CFG_BASIC_RATE_SET_CNTL:
714 lp->brsc[0] = pLtv->u.u16[0];
715 lp->brsc[1] = pLtv->u.u16[1];
716 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
717 pLtv->u.u16[1] = CNV_INT_TO_LITTLE(pLtv->u.u16[1]);
718 break;
719 case CFG_CNF_CONNECTION_CNTL:
720 lp->connectionControl = pLtv->u.u16[0];
721 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
722 break;
723
724#endif
725
726#if 1
727
728
729 case CFG_CNF_OWN_DTIM_PERIOD:
730 lp->DTIMPeriod = pLtv->u.u16[0];
731 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
732 break;
733#ifdef WARP
734 case CFG_CNF_OWN_BEACON_INTERVAL:
735 lp->ownBeaconInterval = pLtv->u.u16[0];
736 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
737 break;
738#endif
739 case CFG_COEXISTENSE_BEHAVIOUR:
740 lp->coexistence = pLtv->u.u16[0];
741 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
742 break;
743#ifdef USE_WDS
744 case CFG_CNF_WDS_ADDR1:
745 memcpy(&lp->wds_port[0].wdsAddress, &pLtv->u.u8[0], ETH_ALEN);
746 hcfPort = HCF_PORT_1;
747 break;
748 case CFG_CNF_WDS_ADDR2:
749 memcpy(&lp->wds_port[1].wdsAddress, &pLtv->u.u8[0], ETH_ALEN);
750 hcfPort = HCF_PORT_2;
751 break;
752 case CFG_CNF_WDS_ADDR3:
753 memcpy(&lp->wds_port[2].wdsAddress, &pLtv->u.u8[0], ETH_ALEN);
754 hcfPort = HCF_PORT_3;
755 break;
756 case CFG_CNF_WDS_ADDR4:
757 memcpy(&lp->wds_port[3].wdsAddress, &pLtv->u.u8[0], ETH_ALEN);
758 hcfPort = HCF_PORT_4;
759 break;
760 case CFG_CNF_WDS_ADDR5:
761 memcpy(&lp->wds_port[4].wdsAddress, &pLtv->u.u8[0], ETH_ALEN);
762 hcfPort = HCF_PORT_5;
763 break;
764 case CFG_CNF_WDS_ADDR6:
765 memcpy(&lp->wds_port[5].wdsAddress, &pLtv->u.u8[0], ETH_ALEN);
766 hcfPort = HCF_PORT_6;
767 break;
768#endif
769
770 case CFG_CNF_MCAST_PM_BUF:
771 lp->multicastPMBuffering = pLtv->u.u16[0];
772 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
773 break;
774 case CFG_CNF_REJECT_ANY:
775 lp->RejectAny = pLtv->u.u16[0];
776 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
777 break;
778#endif
779
780 case CFG_CNF_ENCRYPTION:
781 lp->EnableEncryption = pLtv->u.u16[0];
782 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
783 break;
784 case CFG_CNF_AUTHENTICATION:
785 lp->authentication = pLtv->u.u16[0];
786 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
787 break;
788#if 1
789
790
791
792
793
794
795 case CFG_CNF_MCAST_RATE:
796
797 break;
798 case CFG_CNF_INTRA_BSS_RELAY:
799 lp->intraBSSRelay = pLtv->u.u16[0];
800 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
801 break;
802#endif
803
804 case CFG_CNF_MICRO_WAVE:
805
806 break;
807
808
809
810
811
812
813
814
815
816
817
818
819 case CFG_CNF_OWN_SSID:
820
821 case CFG_DESIRED_SSID:
822 memset(lp->NetworkName, 0, sizeof(lp->NetworkName));
823 memcpy((void *)lp->NetworkName, (void *)&pLtv->u.u8[2], (size_t)pLtv->u.u16[0]);
824 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
825
826
827 if ((strlen(&pLtv->u.u8[2]) == 0) ||
828 (strcmp(&pLtv->u.u8[2], "ANY") == 0) ||
829 (strcmp(&pLtv->u.u8[2], "any") == 0)) {
830
831
832 pLtv->u.u16[0] = 0;
833 pLtv->u.u8[2] = 0;
834 }
835 break;
836 case CFG_GROUP_ADDR:
837
838 break;
839 case CFG_CREATE_IBSS:
840 lp->CreateIBSS = pLtv->u.u16[0];
841 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
842 break;
843 case CFG_RTS_THRH:
844 lp->RTSThreshold = pLtv->u.u16[0];
845 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
846 break;
847 case CFG_TX_RATE_CNTL:
848 lp->TxRateControl[0] = pLtv->u.u16[0];
849 lp->TxRateControl[1] = pLtv->u.u16[1];
850 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
851 pLtv->u.u16[1] = CNV_INT_TO_LITTLE(pLtv->u.u16[1]);
852 break;
853 case CFG_PROMISCUOUS_MODE:
854
855 break;
856
857
858
859#if 1
860
861 case CFG_RTS_THRH0:
862 lp->RTSThreshold = pLtv->u.u16[0];
863 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
864 break;
865 case CFG_TX_RATE_CNTL0:
866
867 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
868 break;
869#ifdef USE_WDS
870 case CFG_RTS_THRH1:
871 lp->wds_port[0].rtsThreshold = pLtv->u.u16[0];
872 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
873 hcfPort = HCF_PORT_1;
874 break;
875 case CFG_RTS_THRH2:
876 lp->wds_port[1].rtsThreshold = pLtv->u.u16[0];
877 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
878 hcfPort = HCF_PORT_2;
879 break;
880 case CFG_RTS_THRH3:
881 lp->wds_port[2].rtsThreshold = pLtv->u.u16[0];
882 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
883 hcfPort = HCF_PORT_3;
884 break;
885 case CFG_RTS_THRH4:
886 lp->wds_port[3].rtsThreshold = pLtv->u.u16[0];
887 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
888 hcfPort = HCF_PORT_4;
889 break;
890 case CFG_RTS_THRH5:
891 lp->wds_port[4].rtsThreshold = pLtv->u.u16[0];
892 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
893 hcfPort = HCF_PORT_5;
894 break;
895 case CFG_RTS_THRH6:
896 lp->wds_port[5].rtsThreshold = pLtv->u.u16[0];
897 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
898 hcfPort = HCF_PORT_6;
899 break;
900 case CFG_TX_RATE_CNTL1:
901 lp->wds_port[0].txRateCntl = pLtv->u.u16[0];
902 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
903 hcfPort = HCF_PORT_1;
904 break;
905 case CFG_TX_RATE_CNTL2:
906 lp->wds_port[1].txRateCntl = pLtv->u.u16[0];
907 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
908 hcfPort = HCF_PORT_2;
909 break;
910 case CFG_TX_RATE_CNTL3:
911 lp->wds_port[2].txRateCntl = pLtv->u.u16[0];
912 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
913 hcfPort = HCF_PORT_3;
914 break;
915 case CFG_TX_RATE_CNTL4:
916 lp->wds_port[3].txRateCntl = pLtv->u.u16[0];
917 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
918 hcfPort = HCF_PORT_4;
919 break;
920 case CFG_TX_RATE_CNTL5:
921 lp->wds_port[4].txRateCntl = pLtv->u.u16[0];
922 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
923 hcfPort = HCF_PORT_5;
924 break;
925 case CFG_TX_RATE_CNTL6:
926 lp->wds_port[5].txRateCntl = pLtv->u.u16[0];
927 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
928 hcfPort = HCF_PORT_6;
929 break;
930#endif
931#endif
932
933 case CFG_DEFAULT_KEYS:
934 {
935 CFG_DEFAULT_KEYS_STRCT *pKeys = (CFG_DEFAULT_KEYS_STRCT *)pLtv;
936
937 pKeys->key[0].len = CNV_INT_TO_LITTLE(pKeys->key[0].len);
938 pKeys->key[1].len = CNV_INT_TO_LITTLE(pKeys->key[1].len);
939 pKeys->key[2].len = CNV_INT_TO_LITTLE(pKeys->key[2].len);
940 pKeys->key[3].len = CNV_INT_TO_LITTLE(pKeys->key[3].len);
941
942 memcpy((void *)&(lp->DefaultKeys), (void *)pKeys,
943 sizeof(CFG_DEFAULT_KEYS_STRCT));
944 }
945 break;
946 case CFG_TX_KEY_ID:
947 lp->TransmitKeyID = pLtv->u.u16[0];
948 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
949 break;
950 case CFG_SCAN_SSID:
951
952 break;
953 case CFG_TICK_TIME:
954
955 break;
956
957 case CFG_MAX_LOAD_TIME:
958 case CFG_DL_BUF:
959
960 case CFG_NIC_SERIAL_NUMBER:
961 case CFG_NIC_IDENTITY:
962 case CFG_NIC_MFI_SUP_RANGE:
963 case CFG_NIC_CFI_SUP_RANGE:
964 case CFG_NIC_TEMP_TYPE:
965 case CFG_NIC_PROFILE:
966 case CFG_FW_IDENTITY:
967 case CFG_FW_SUP_RANGE:
968 case CFG_MFI_ACT_RANGES_STA:
969 case CFG_CFI_ACT_RANGES_STA:
970 case CFG_PORT_STAT:
971 case CFG_CUR_SSID:
972 case CFG_CUR_BSSID:
973 case CFG_COMMS_QUALITY:
974 case CFG_CUR_TX_RATE:
975 case CFG_CUR_BEACON_INTERVAL:
976 case CFG_CUR_SCALE_THRH:
977 case CFG_PROTOCOL_RSP_TIME:
978 case CFG_CUR_SHORT_RETRY_LIMIT:
979 case CFG_CUR_LONG_RETRY_LIMIT:
980 case CFG_MAX_TX_LIFETIME:
981 case CFG_MAX_RX_LIFETIME:
982 case CFG_CF_POLLABLE:
983 case CFG_AUTHENTICATION_ALGORITHMS:
984 case CFG_PRIVACY_OPT_IMPLEMENTED:
985
986
987
988
989
990
991
992
993
994 case CFG_NIC_MAC_ADDR:
995 case CFG_PCF_INFO:
996
997 case CFG_PHY_TYPE:
998 case CFG_CUR_CHANNEL:
999
1000
1001 case CFG_SUPPORTED_DATA_RATES:
1002 break;
1003 case CFG_AP_MODE:
1004
1005 DBG_ERROR(DbgInfo, "set CFG_AP_MODE no longer supported\n");
1006 break;
1007 case CFG_ENCRYPT_STRING:
1008
1009 memset(lp->szEncryption, 0, sizeof(lp->szEncryption));
1010 memcpy((void *)lp->szEncryption, (void *)&pLtv->u.u8[0],
1011 (pLtv->len * sizeof(hcf_16)));
1012 wl_wep_decode(CRYPT_CODE, &sEncryption,
1013 lp->szEncryption);
1014
1015
1016
1017
1018
1019
1020
1021
1022 lp->TransmitKeyID = sEncryption.wTxKeyID + 1;
1023 lp->EnableEncryption = sEncryption.wEnabled;
1024
1025 memcpy(&lp->DefaultKeys, &sEncryption.EncStr,
1026 sizeof(CFG_DEFAULT_KEYS_STRCT));
1027 break;
1028
1029
1030
1031
1032
1033
1034 case CFG_DRIVER_ENABLE:
1035 lp->driverEnable = pLtv->u.u16[0];
1036 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
1037 break;
1038 case CFG_WOLAS_ENABLE:
1039 lp->wolasEnable = pLtv->u.u16[0];
1040 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
1041 break;
1042 case CFG_SET_WPA_AUTH_KEY_MGMT_SUITE:
1043 lp->AuthKeyMgmtSuite = pLtv->u.u16[0];
1044 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
1045 break;
1046 case CFG_DISASSOCIATE_ADDR:
1047 pLtv->u.u16[ETH_ALEN / 2] = CNV_INT_TO_LITTLE(pLtv->u.u16[ETH_ALEN / 2]);
1048 break;
1049 case CFG_ADD_TKIP_DEFAULT_KEY:
1050 case CFG_REMOVE_TKIP_DEFAULT_KEY:
1051
1052 pLtv->u.u16[0] = CNV_INT_TO_LITTLE(pLtv->u.u16[0]);
1053 break;
1054 case CFG_ADD_TKIP_MAPPED_KEY:
1055 break;
1056 case CFG_REMOVE_TKIP_MAPPED_KEY:
1057 break;
1058
1059 case CFG_MB_INFO:
1060 case CFG_IFB:
1061 default:
1062 break;
1063 }
1064
1065
1066
1067
1068
1069 switch (pLtv->typ) {
1070 case CFG_CNF_PORT_TYPE:
1071 case CFG_CNF_OWN_MAC_ADDR:
1072 case CFG_CNF_OWN_CHANNEL:
1073 case CFG_CNF_OWN_SSID:
1074 case CFG_CNF_OWN_ATIM_WINDOW:
1075 case CFG_CNF_SYSTEM_SCALE:
1076 case CFG_CNF_MAX_DATA_LEN:
1077 case CFG_CNF_PM_ENABLED:
1078 case CFG_CNF_MCAST_RX:
1079 case CFG_CNF_MAX_SLEEP_DURATION:
1080 case CFG_CNF_HOLDOVER_DURATION:
1081 case CFG_CNF_OWN_NAME:
1082 case CFG_CNF_LOAD_BALANCING:
1083 case CFG_CNF_MEDIUM_DISTRIBUTION:
1084#ifdef WARP
1085 case CFG_CNF_TX_POW_LVL:
1086 case CFG_CNF_CONNECTION_CNTL:
1087
1088#endif
1089#if 1
1090
1091 case CFG_CNF_OWN_DTIM_PERIOD:
1092#ifdef WARP
1093 case CFG_CNF_OWN_BEACON_INTERVAL:
1094#endif
1095#ifdef USE_WDS
1096 case CFG_CNF_WDS_ADDR1:
1097 case CFG_CNF_WDS_ADDR2:
1098 case CFG_CNF_WDS_ADDR3:
1099 case CFG_CNF_WDS_ADDR4:
1100 case CFG_CNF_WDS_ADDR5:
1101 case CFG_CNF_WDS_ADDR6:
1102#endif
1103 case CFG_CNF_MCAST_PM_BUF:
1104 case CFG_CNF_REJECT_ANY:
1105#endif
1106
1107 case CFG_CNF_ENCRYPTION:
1108 case CFG_CNF_AUTHENTICATION:
1109#if 1
1110
1111
1112 case CFG_CNF_EXCL_UNENCRYPTED:
1113 case CFG_CNF_MCAST_RATE:
1114 case CFG_CNF_INTRA_BSS_RELAY:
1115#endif
1116
1117 case CFG_CNF_MICRO_WAVE:
1118
1119
1120
1121
1122
1123 case CFG_AP_MODE:
1124 case CFG_ENCRYPT_STRING:
1125
1126 case CFG_WOLAS_ENABLE:
1127 case CFG_MB_INFO:
1128 case CFG_IFB:
1129 break;
1130
1131 case CFG_DRIVER_ENABLE:
1132 if (lp->driverEnable) {
1133 hcf_cntl(&(lp->hcfCtx), HCF_CNTL_ENABLE | HCF_PORT_0);
1134 hcf_cntl(&(lp->hcfCtx), HCF_CNTL_CONNECT);
1135 } else {
1136 hcf_cntl(&(lp->hcfCtx), HCF_CNTL_DISABLE | HCF_PORT_0);
1137 hcf_cntl(&(lp->hcfCtx), HCF_CNTL_DISCONNECT);
1138 }
1139 break;
1140 default:
1141 wl_act_int_off(lp);
1142 urq->result = hcf_put_info(&(lp->hcfCtx), (LTVP) pLtv);
1143 wl_act_int_on(lp);
1144 break;
1145 }
1146
1147 if (ltvAllocated)
1148 kfree(pLtv);
1149 } else {
1150 urq->result = UIL_FAILURE;
1151 }
1152 } else {
1153 DBG_ERROR(DbgInfo, "EPERM\n");
1154 urq->result = UIL_FAILURE;
1155 result = -EPERM;
1156 }
1157 } else {
1158 DBG_ERROR(DbgInfo, "UIL_ERR_WRONG_IFB\n");
1159 urq->result = UIL_ERR_WRONG_IFB;
1160 }
1161
1162 DBG_LEAVE(DbgInfo);
1163 return result;
1164}
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188int wvlan_uil_get_info(struct uilreq *urq, struct wl_private *lp)
1189{
1190 int result = 0;
1191 int i;
1192
1193
1194 DBG_FUNC("wvlan_uil_get_info");
1195 DBG_ENTER(DbgInfo);
1196
1197 if (urq->hcfCtx == &(lp->hcfCtx)) {
1198 if ((urq->data != NULL) && (urq->len != 0)) {
1199 ltv_t *pLtv;
1200 bool_t ltvAllocated = FALSE;
1201
1202
1203 if (urq->len < (sizeof(hcf_16) * 2)) {
1204 urq->len = sizeof(lp->ltvRecord);
1205 DBG_ERROR(DbgInfo, "No Length/Type in LTV!!!\n");
1206 DBG_ERROR(DbgInfo, "UIL_ERR_LEN\n");
1207 urq->result = UIL_ERR_LEN;
1208 DBG_LEAVE(DbgInfo);
1209 return result;
1210 }
1211
1212
1213 result = verify_area(VERIFY_READ, urq->data, sizeof(hcf_16) * 2);
1214 if (result != 0) {
1215 DBG_ERROR(DbgInfo, "verify_area(), VERIFY_READ FAILED\n");
1216 urq->result = UIL_FAILURE;
1217 DBG_LEAVE(DbgInfo);
1218 return result;
1219 }
1220
1221
1222 result = copy_from_user(&(lp->ltvRecord), urq->data, sizeof(hcf_16) * 2);
1223
1224
1225
1226 if (((lp->ltvRecord.len + 1) * sizeof(hcf_16)) > urq->len) {
1227 DBG_ERROR(DbgInfo, "Incoming LTV too big\n");
1228 urq->len = sizeof(lp->ltvRecord);
1229 urq->result = UIL_ERR_LEN;
1230 DBG_LEAVE(DbgInfo);
1231 return result;
1232 }
1233
1234
1235 switch (lp->ltvRecord.typ) {
1236 case CFG_NIC_IDENTITY:
1237 memcpy(&lp->ltvRecord.u.u8[0], &lp->NICIdentity, sizeof(lp->NICIdentity));
1238 break;
1239 case CFG_PRI_IDENTITY:
1240 memcpy(&lp->ltvRecord.u.u8[0], &lp->PrimaryIdentity, sizeof(lp->PrimaryIdentity));
1241 break;
1242 case CFG_AP_MODE:
1243 DBG_ERROR(DbgInfo, "set CFG_AP_MODE no longer supported, so is get useful ????\n");
1244 lp->ltvRecord.u.u16[0] =
1245 CNV_INT_TO_LITTLE(lp->hcfCtx.IFB_FWIdentity.comp_id) == COMP_ID_FW_AP;
1246 break;
1247
1248 case CFG_ENCRYPT_STRING:
1249 case CFG_COUNTRY_STRING:
1250 case CFG_DRIVER_ENABLE:
1251 case CFG_WOLAS_ENABLE:
1252
1253 urq->result = UIL_FAILURE;
1254 break;
1255 case CFG_DRV_INFO:
1256 DBG_TRACE(DbgInfo, "Intercept CFG_DRV_INFO\n");
1257 result = cfg_driver_info(urq, lp);
1258 break;
1259 case CFG_DRV_IDENTITY:
1260 DBG_TRACE(DbgInfo, "Intercept CFG_DRV_IDENTITY\n");
1261 result = cfg_driver_identity(urq, lp);
1262 break;
1263 case CFG_IFB:
1264
1265 if (!capable(CAP_NET_ADMIN)) {
1266 result = -EPERM;
1267 break;
1268 }
1269
1270
1271
1272 case CFG_FW_IDENTITY:
1273 default:
1274
1275
1276 result = verify_area(VERIFY_WRITE, urq->data, urq->len);
1277 if (result != 0) {
1278 DBG_ERROR(DbgInfo, "verify_area(), VERIFY_WRITE FAILED\n");
1279 urq->result = UIL_FAILURE;
1280 break;
1281 }
1282
1283
1284
1285
1286 if (urq->len > sizeof(lp->ltvRecord)) {
1287 pLtv = kmalloc(urq->len, GFP_KERNEL);
1288 if (pLtv != NULL) {
1289 ltvAllocated = TRUE;
1290
1291
1292 memcpy(pLtv, &(lp->ltvRecord), sizeof(hcf_16) * 2);
1293 } else {
1294 urq->len = sizeof(lp->ltvRecord);
1295 urq->result = UIL_ERR_LEN;
1296 DBG_ERROR(DbgInfo, "kmalloc FAILED\n");
1297 DBG_ERROR(DbgInfo, "UIL_ERR_LEN\n");
1298 result = -ENOMEM;
1299 break;
1300 }
1301 } else {
1302 pLtv = &(lp->ltvRecord);
1303 }
1304
1305 wl_act_int_off(lp);
1306 urq->result = hcf_get_info(&(lp->hcfCtx), (LTVP) pLtv);
1307 wl_act_int_on(lp);
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318 break;
1319 }
1320
1321
1322 switch (lp->ltvRecord.typ) {
1323
1324 case CFG_CNF_PORT_TYPE:
1325 case CFG_CNF_OWN_CHANNEL:
1326 case CFG_CNF_OWN_ATIM_WINDOW:
1327 case CFG_CNF_SYSTEM_SCALE:
1328 case CFG_CNF_MAX_DATA_LEN:
1329 case CFG_CNF_PM_ENABLED:
1330 case CFG_CNF_MCAST_RX:
1331 case CFG_CNF_MAX_SLEEP_DURATION:
1332 case CFG_CNF_HOLDOVER_DURATION:
1333 case CFG_CNF_OWN_DTIM_PERIOD:
1334 case CFG_CNF_MCAST_PM_BUF:
1335 case CFG_CNF_REJECT_ANY:
1336 case CFG_CNF_ENCRYPTION:
1337 case CFG_CNF_AUTHENTICATION:
1338 case CFG_CNF_EXCL_UNENCRYPTED:
1339 case CFG_CNF_INTRA_BSS_RELAY:
1340 case CFG_CNF_MICRO_WAVE:
1341 case CFG_CNF_LOAD_BALANCING:
1342 case CFG_CNF_MEDIUM_DISTRIBUTION:
1343#ifdef WARP
1344 case CFG_CNF_TX_POW_LVL:
1345 case CFG_CNF_CONNECTION_CNTL:
1346 case CFG_CNF_OWN_BEACON_INTERVAL:
1347 case CFG_COEXISTENSE_BEHAVIOUR:
1348
1349#endif
1350 case CFG_CREATE_IBSS:
1351 case CFG_RTS_THRH:
1352 case CFG_PROMISCUOUS_MODE:
1353
1354 case CFG_RTS_THRH0:
1355 case CFG_RTS_THRH1:
1356 case CFG_RTS_THRH2:
1357 case CFG_RTS_THRH3:
1358 case CFG_RTS_THRH4:
1359 case CFG_RTS_THRH5:
1360 case CFG_RTS_THRH6:
1361 case CFG_TX_RATE_CNTL0:
1362 case CFG_TX_RATE_CNTL1:
1363 case CFG_TX_RATE_CNTL2:
1364 case CFG_TX_RATE_CNTL3:
1365 case CFG_TX_RATE_CNTL4:
1366 case CFG_TX_RATE_CNTL5:
1367 case CFG_TX_RATE_CNTL6:
1368 case CFG_TX_KEY_ID:
1369 case CFG_TICK_TIME:
1370 case CFG_MAX_LOAD_TIME:
1371 case CFG_NIC_TEMP_TYPE:
1372 case CFG_PORT_STAT:
1373 case CFG_CUR_TX_RATE:
1374 case CFG_CUR_BEACON_INTERVAL:
1375 case CFG_PROTOCOL_RSP_TIME:
1376 case CFG_CUR_SHORT_RETRY_LIMIT:
1377 case CFG_CUR_LONG_RETRY_LIMIT:
1378 case CFG_MAX_TX_LIFETIME:
1379 case CFG_MAX_RX_LIFETIME:
1380 case CFG_CF_POLLABLE:
1381 case CFG_PRIVACY_OPT_IMPLEMENTED:
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391 case CFG_PHY_TYPE:
1392 case CFG_CUR_CHANNEL:
1393
1394
1395
1396
1397
1398 case CFG_CNF_OWN_SSID:
1399 case CFG_CNF_OWN_NAME:
1400
1401 case CFG_DESIRED_SSID:
1402 case CFG_SCAN_SSID:
1403 case CFG_CUR_SSID:
1404 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE(lp->ltvRecord.u.u16[0]);
1405 break;
1406
1407 case CFG_CNF_OWN_MAC_ADDR:
1408
1409 case CFG_CNF_WDS_ADDR1:
1410 case CFG_CNF_WDS_ADDR2:
1411 case CFG_CNF_WDS_ADDR3:
1412 case CFG_CNF_WDS_ADDR4:
1413 case CFG_CNF_WDS_ADDR5:
1414 case CFG_CNF_WDS_ADDR6:
1415 case CFG_GROUP_ADDR:
1416 case CFG_NIC_SERIAL_NUMBER:
1417 case CFG_CUR_BSSID:
1418 case CFG_NIC_MAC_ADDR:
1419 case CFG_SUPPORTED_DATA_RATES:
1420 break;
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433 case CFG_DEFAULT_KEYS:
1434 {
1435 CFG_DEFAULT_KEYS_STRCT *pKeys = (CFG_DEFAULT_KEYS_STRCT *)&lp->ltvRecord.u.u8[0];
1436
1437 pKeys[0].len = CNV_INT_TO_LITTLE(pKeys[0].len);
1438 pKeys[1].len = CNV_INT_TO_LITTLE(pKeys[1].len);
1439 pKeys[2].len = CNV_INT_TO_LITTLE(pKeys[2].len);
1440 pKeys[3].len = CNV_INT_TO_LITTLE(pKeys[3].len);
1441 }
1442 break;
1443 case CFG_CNF_MCAST_RATE:
1444 case CFG_TX_RATE_CNTL:
1445 case CFG_SUPPORTED_RATE_SET_CNTL:
1446 case CFG_BASIC_RATE_SET_CNTL:
1447 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE(lp->ltvRecord.u.u16[0]);
1448 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE(lp->ltvRecord.u.u16[1]);
1449 break;
1450 case CFG_DL_BUF:
1451 case CFG_NIC_IDENTITY:
1452 case CFG_COMMS_QUALITY:
1453 case CFG_PCF_INFO:
1454 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE(lp->ltvRecord.u.u16[0]);
1455 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE(lp->ltvRecord.u.u16[1]);
1456 lp->ltvRecord.u.u16[2] = CNV_INT_TO_LITTLE(lp->ltvRecord.u.u16[2]);
1457 break;
1458 case CFG_FW_IDENTITY:
1459 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE(lp->ltvRecord.u.u16[0]);
1460 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE(lp->ltvRecord.u.u16[1]);
1461 lp->ltvRecord.u.u16[2] = CNV_INT_TO_LITTLE(lp->ltvRecord.u.u16[2]);
1462 lp->ltvRecord.u.u16[3] = CNV_INT_TO_LITTLE(lp->ltvRecord.u.u16[3]);
1463 break;
1464
1465 case CFG_NIC_MFI_SUP_RANGE:
1466 case CFG_NIC_CFI_SUP_RANGE:
1467 case CFG_NIC_PROFILE:
1468 case CFG_FW_SUP_RANGE:
1469 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE(lp->ltvRecord.u.u16[0]);
1470 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE(lp->ltvRecord.u.u16[1]);
1471 lp->ltvRecord.u.u16[2] = CNV_INT_TO_LITTLE(lp->ltvRecord.u.u16[2]);
1472 lp->ltvRecord.u.u16[3] = CNV_INT_TO_LITTLE(lp->ltvRecord.u.u16[3]);
1473 lp->ltvRecord.u.u16[4] = CNV_INT_TO_LITTLE(lp->ltvRecord.u.u16[4]);
1474 break;
1475 case CFG_MFI_ACT_RANGES_STA:
1476 case CFG_CFI_ACT_RANGES_STA:
1477 case CFG_CUR_SCALE_THRH:
1478 case CFG_AUTHENTICATION_ALGORITHMS:
1479 for (i = 0; i < (lp->ltvRecord.len - 1); i++)
1480 lp->ltvRecord.u.u16[i] = CNV_INT_TO_LITTLE(lp->ltvRecord.u.u16[i]);
1481 break;
1482
1483 case CFG_PRI_IDENTITY:
1484 break;
1485 case CFG_MB_INFO:
1486
1487 break;
1488
1489 case CFG_IFB:
1490 case CFG_DRV_INFO:
1491 case CFG_AP_MODE:
1492 case CFG_ENCRYPT_STRING:
1493 case CFG_COUNTRY_STRING:
1494 case CFG_DRIVER_ENABLE:
1495 case CFG_WOLAS_ENABLE:
1496 default:
1497 break;
1498 }
1499
1500
1501 copy_to_user(urq->data, &(lp->ltvRecord), urq->len);
1502
1503 if (ltvAllocated)
1504 kfree(&(lp->ltvRecord));
1505 urq->result = UIL_SUCCESS;
1506 } else {
1507 urq->result = UIL_FAILURE;
1508 }
1509 } else {
1510 DBG_ERROR(DbgInfo, "UIL_ERR_WRONG_IFB\n");
1511 urq->result = UIL_ERR_WRONG_IFB;
1512 }
1513
1514 DBG_LEAVE(DbgInfo);
1515 return result;
1516}
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542int cfg_driver_info(struct uilreq *urq, struct wl_private *lp)
1543{
1544 int result = 0;
1545
1546
1547
1548 DBG_FUNC("cfg_driver_info");
1549 DBG_ENTER(DbgInfo);
1550
1551
1552
1553 if (urq->len < sizeof(lp->driverInfo)) {
1554 urq->len = sizeof(lp->driverInfo);
1555 urq->result = UIL_ERR_LEN;
1556 DBG_LEAVE(DbgInfo);
1557 return result;
1558 }
1559
1560
1561 result = verify_area(VERIFY_WRITE, urq->data, sizeof(lp->driverInfo));
1562 if (result != 0) {
1563 urq->result = UIL_FAILURE;
1564 DBG_LEAVE(DbgInfo);
1565 return result;
1566 }
1567
1568 lp->driverInfo.card_stat = lp->hcfCtx.IFB_CardStat;
1569
1570
1571 urq->result = UIL_SUCCESS;
1572 copy_to_user(urq->data, &(lp->driverInfo), sizeof(lp->driverInfo));
1573
1574 DBG_LEAVE(DbgInfo);
1575 return result;
1576}
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601int cfg_driver_identity(struct uilreq *urq, struct wl_private *lp)
1602{
1603 int result = 0;
1604
1605
1606
1607 DBG_FUNC("wvlan_driver_identity");
1608 DBG_ENTER(DbgInfo);
1609
1610
1611
1612 if (urq->len < sizeof(lp->driverIdentity)) {
1613 urq->len = sizeof(lp->driverIdentity);
1614 urq->result = UIL_ERR_LEN;
1615 DBG_LEAVE(DbgInfo);
1616 return result;
1617 }
1618
1619
1620 result = verify_area(VERIFY_WRITE, urq->data, sizeof(lp->driverIdentity));
1621 if (result != 0) {
1622 urq->result = UIL_FAILURE;
1623 DBG_LEAVE(DbgInfo);
1624 return result;
1625 }
1626
1627
1628 urq->result = UIL_SUCCESS;
1629 copy_to_user(urq->data, &(lp->driverIdentity), sizeof(lp->driverIdentity));
1630
1631 DBG_LEAVE(DbgInfo);
1632 return result;
1633}
1634
1635
1636
1637#endif
1638
1639
1640
1641
1642
1643#ifdef WIRELESS_EXT
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665int wvlan_set_netname(struct net_device *dev,
1666 struct iw_request_info *info,
1667 union iwreq_data *wrqu,
1668 char *extra)
1669{
1670 struct wl_private *lp = wl_priv(dev);
1671 unsigned long flags;
1672 int ret = 0;
1673
1674
1675
1676 DBG_FUNC("wvlan_set_netname");
1677 DBG_ENTER(DbgInfo);
1678
1679 wl_lock(lp, &flags);
1680
1681 memset(lp->NetworkName, 0, sizeof(lp->NetworkName));
1682 memcpy(lp->NetworkName, extra, wrqu->data.length);
1683
1684
1685 wl_apply(lp);
1686 wl_unlock(lp, &flags);
1687
1688 DBG_LEAVE(DbgInfo);
1689 return ret;
1690}
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715int wvlan_get_netname(struct net_device *dev,
1716 struct iw_request_info *info,
1717 union iwreq_data *wrqu,
1718 char *extra)
1719{
1720 struct wl_private *lp = wl_priv(dev);
1721 unsigned long flags;
1722 int ret = 0;
1723 int status = -1;
1724 wvName_t *pName;
1725
1726
1727
1728 DBG_FUNC("wvlan_get_netname");
1729 DBG_ENTER(DbgInfo);
1730
1731 wl_lock(lp, &flags);
1732
1733
1734 lp->ltvRecord.len = 1 + (sizeof(*pName) / sizeof(hcf_16));
1735 lp->ltvRecord.typ = CFG_CUR_SSID;
1736
1737 status = hcf_get_info(&(lp->hcfCtx), (LTVP)&(lp->ltvRecord));
1738
1739 if (status == HCF_SUCCESS) {
1740 pName = (wvName_t *)&(lp->ltvRecord.u.u32);
1741
1742 memset(extra, '\0', HCF_MAX_NAME_LEN);
1743 wrqu->data.length = pName->length;
1744
1745 memcpy(extra, pName->name, pName->length);
1746 } else {
1747 ret = -EFAULT;
1748 }
1749
1750 wl_unlock(lp, &flags);
1751
1752 DBG_LEAVE(DbgInfo);
1753 return ret;
1754}
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779int wvlan_set_station_nickname(struct net_device *dev,
1780 struct iw_request_info *info,
1781 union iwreq_data *wrqu,
1782 char *extra)
1783{
1784 struct wl_private *lp = wl_priv(dev);
1785 unsigned long flags;
1786 int ret = 0;
1787
1788
1789
1790 DBG_FUNC("wvlan_set_station_nickname");
1791 DBG_ENTER(DbgInfo);
1792
1793 wl_lock(lp, &flags);
1794
1795 memset(lp->StationName, 0, sizeof(lp->StationName));
1796
1797 memcpy(lp->StationName, extra, wrqu->data.length);
1798
1799
1800 wl_apply(lp);
1801 wl_unlock(lp, &flags);
1802
1803 DBG_LEAVE(DbgInfo);
1804 return ret;
1805}
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830int wvlan_get_station_nickname(struct net_device *dev,
1831 struct iw_request_info *info,
1832 union iwreq_data *wrqu,
1833 char *extra)
1834{
1835 struct wl_private *lp = wl_priv(dev);
1836 unsigned long flags;
1837 int ret = 0;
1838 int status = -1;
1839 wvName_t *pName;
1840
1841
1842
1843 DBG_FUNC("wvlan_get_station_nickname");
1844 DBG_ENTER(DbgInfo);
1845
1846 wl_lock(lp, &flags);
1847
1848
1849 lp->ltvRecord.len = 1 + (sizeof(*pName) / sizeof(hcf_16));
1850 lp->ltvRecord.typ = CFG_CNF_OWN_NAME;
1851
1852 status = hcf_get_info(&(lp->hcfCtx), (LTVP)&(lp->ltvRecord));
1853
1854 if (status == HCF_SUCCESS) {
1855 pName = (wvName_t *)&(lp->ltvRecord.u.u32);
1856
1857 memset(extra, '\0', HCF_MAX_NAME_LEN);
1858 wrqu->data.length = pName->length;
1859 memcpy(extra, pName->name, pName->length);
1860 } else {
1861 ret = -EFAULT;
1862 }
1863
1864 wl_unlock(lp, &flags);
1865
1866
1867 DBG_LEAVE(DbgInfo);
1868 return ret;
1869}
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894int wvlan_set_porttype(struct net_device *dev,
1895 struct iw_request_info *info,
1896 union iwreq_data *wrqu,
1897 char *extra)
1898{
1899 struct wl_private *lp = wl_priv(dev);
1900 unsigned long flags;
1901 int ret = 0;
1902 hcf_16 portType;
1903
1904
1905
1906 DBG_FUNC("wvlan_set_porttype");
1907 DBG_ENTER(DbgInfo);
1908
1909 wl_lock(lp, &flags);
1910
1911
1912 portType = *((__u32 *)extra);
1913
1914 if (!((portType == 1) || (portType == 3))) {
1915 ret = -EINVAL;
1916 goto out_unlock;
1917 }
1918
1919 lp->PortType = portType;
1920
1921
1922 wl_apply(lp);
1923
1924out_unlock:
1925 wl_unlock(lp, &flags);
1926
1927
1928 DBG_LEAVE(DbgInfo);
1929 return ret;
1930}
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954int wvlan_get_porttype(struct net_device *dev,
1955 struct iw_request_info *info,
1956 union iwreq_data *wrqu,
1957 char *extra)
1958{
1959 struct wl_private *lp = wl_priv(dev);
1960 unsigned long flags;
1961 int ret = 0;
1962 int status = -1;
1963 hcf_16 *pPortType;
1964 __u32 *pData = (__u32 *)extra;
1965
1966
1967
1968 DBG_FUNC("wvlan_get_porttype");
1969 DBG_ENTER(DbgInfo);
1970
1971 wl_lock(lp, &flags);
1972
1973
1974 lp->ltvRecord.len = 1 + (sizeof(*pPortType) / sizeof(hcf_16));
1975 lp->ltvRecord.typ = CFG_CNF_PORT_TYPE;
1976
1977 status = hcf_get_info(&(lp->hcfCtx), (LTVP)&(lp->ltvRecord));
1978
1979 if (status == HCF_SUCCESS) {
1980 pPortType = (hcf_16 *)&(lp->ltvRecord.u.u32);
1981
1982 *pData = CNV_LITTLE_TO_INT(*pPortType);
1983 } else {
1984 ret = -EFAULT;
1985 }
1986
1987 wl_unlock(lp, &flags);
1988
1989
1990 DBG_LEAVE(DbgInfo);
1991 return ret;
1992}
1993
1994
1995#endif
1996
1997
1998
1999
2000#ifdef USE_RTS
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020int wvlan_rts(struct rtsreq *rrq, __u32 io_base)
2021{
2022 int ioctl_ret = 0;
2023
2024
2025
2026 DBG_FUNC("wvlan_rts");
2027 DBG_ENTER(DbgInfo);
2028
2029
2030 DBG_PRINT("io_base: 0x%08x\n", io_base);
2031
2032 switch (rrq->typ) {
2033 case WL_IOCTL_RTS_READ:
2034 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- WL_IOCTL_RTS_READ\n");
2035 rrq->data[0] = IN_PORT_WORD(io_base + rrq->reg);
2036 DBG_TRACE(DbgInfo, " reg 0x%04x ==> 0x%04x\n", rrq->reg, CNV_LITTLE_TO_SHORT(rrq->data[0]));
2037 break;
2038 case WL_IOCTL_RTS_WRITE:
2039 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- WL_IOCTL_RTS_WRITE\n");
2040 OUT_PORT_WORD(io_base + rrq->reg, rrq->data[0]);
2041 DBG_TRACE(DbgInfo, " reg 0x%04x <== 0x%04x\n", rrq->reg, CNV_LITTLE_TO_SHORT(rrq->data[0]));
2042 break;
2043 case WL_IOCTL_RTS_BATCH_READ:
2044 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- WL_IOCTL_RTS_BATCH_READ\n");
2045 IN_PORT_STRING_16(io_base + rrq->reg, rrq->data, rrq->len);
2046 DBG_TRACE(DbgInfo, " reg 0x%04x ==> %d bytes\n", rrq->reg, rrq->len * sizeof(__u16));
2047 break;
2048 case WL_IOCTL_RTS_BATCH_WRITE:
2049 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- WL_IOCTL_RTS_BATCH_WRITE\n");
2050 OUT_PORT_STRING_16(io_base + rrq->reg, rrq->data, rrq->len);
2051 DBG_TRACE(DbgInfo, " reg 0x%04x <== %d bytes\n", rrq->reg, rrq->len * sizeof(__u16));
2052 break;
2053 default:
2054
2055 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- UNSUPPORTED RTS CODE: 0x%X", rrq->typ);
2056 ioctl_ret = -EOPNOTSUPP;
2057 break;
2058 }
2059
2060 DBG_LEAVE(DbgInfo);
2061 return ioctl_ret;
2062}
2063
2064
2065#endif
2066
