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#include "ioctl.h"
34#include "iocmd.h"
35#include "mac.h"
36#include "card.h"
37#include "hostap.h"
38#include "wpactl.h"
39#include "rf.h"
40
41
42
43
44
45
46
47static int msglevel =MSG_LEVEL_INFO;
48
49#ifdef WPA_SM_Transtatus
50 SWPAResult wpa_Result;
51#endif
52
53
54
55
56
57int private_ioctl(PSDevice pDevice, struct ifreq *rq) {
58
59 PSCmdRequest pReq = (PSCmdRequest)rq;
60 PSMgmtObject pMgmt = pDevice->pMgmt;
61 int result = 0;
62 PWLAN_IE_SSID pItemSSID;
63 SCmdBSSJoin sJoinCmd;
64 SCmdZoneTypeSet sZoneTypeCmd;
65 SCmdScan sScanCmd;
66 SCmdStartAP sStartAPCmd;
67 SCmdSetWEP sWEPCmd;
68 SCmdValue sValue;
69 SBSSIDList sList;
70 SNodeList sNodeList;
71 PSBSSIDList pList;
72 PSNodeList pNodeList;
73 UINT cbListCount;
74 PKnownBSS pBSS;
75 PKnownNodeDB pNode;
76 UINT ii, jj;
77 SCmdLinkStatus sLinkStatus;
78 BYTE abySuppRates[] = {WLAN_EID_SUPP_RATES, 4, 0x02, 0x04, 0x0B, 0x16};
79 BYTE abyNullAddr[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
80 DWORD dwKeyIndex= 0;
81 BYTE abyScanSSID[WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1];
82 LONG ldBm;
83
84 pReq->wResult = 0;
85
86 switch(pReq->wCmdCode) {
87
88 case WLAN_CMD_BSS_SCAN:
89
90 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_BSS_SCAN..begin \n");
91 if (copy_from_user(&sScanCmd, pReq->data, sizeof(SCmdScan))) {
92 result = -EFAULT;
93 break;
94 };
95
96 pItemSSID = (PWLAN_IE_SSID)sScanCmd.ssid;
97 if (pItemSSID->len != 0) {
98 memset(abyScanSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
99 memcpy(abyScanSSID, pItemSSID, pItemSSID->len + WLAN_IEHDR_LEN);
100 }
101
102 if (pDevice->bMACSuspend == TRUE) {
103 if (pDevice->bRadioOff == TRUE)
104 CARDbRadioPowerOn(pDevice);
105 vMgrTimerInit(pDevice);
106 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
107 add_timer(&pMgmt->sTimerSecondCallback);
108 pDevice->bMACSuspend = FALSE;
109 }
110 spin_lock_irq(&pDevice->lock);
111 if (memcmp(pMgmt->abyCurrBSSID, &abyNullAddr[0], 6) == 0)
112 BSSvClearBSSList((HANDLE)pDevice, FALSE);
113 else
114 BSSvClearBSSList((HANDLE)pDevice, pDevice->bLinkPass);
115
116 if (pItemSSID->len != 0)
117 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, abyScanSSID);
118 else
119 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
120 spin_unlock_irq(&pDevice->lock);
121 break;
122
123 case WLAN_CMD_ZONETYPE_SET:
124
125 result=-EOPNOTSUPP;
126 break;
127
128 if (copy_from_user(&sZoneTypeCmd, pReq->data, sizeof(SCmdZoneTypeSet))) {
129 result = -EFAULT;
130 break;
131 };
132
133 if(sZoneTypeCmd.bWrite==TRUE) {
134
135 if(sZoneTypeCmd.ZoneType == ZoneType_USA) {
136
137 printk("set_ZoneType:USA\n");
138 }
139 else if(sZoneTypeCmd.ZoneType == ZoneType_Japan) {
140
141 printk("set_ZoneType:Japan\n");
142 }
143 else if(sZoneTypeCmd.ZoneType == ZoneType_Europe) {
144
145 printk("set_ZoneType:Europe\n");
146 }
147 }
148 else {
149
150 BYTE zonetype=0;
151
152
153 if(zonetype == 0x00) {
154 sZoneTypeCmd.ZoneType = ZoneType_USA;
155 }
156 else if(zonetype == 0x01) {
157 sZoneTypeCmd.ZoneType = ZoneType_Japan;
158 }
159 else if(zonetype == 0x02) {
160 sZoneTypeCmd.ZoneType = ZoneType_Europe;
161 }
162 else {
163 printk("Error:ZoneType[%x] Unknown ???\n",zonetype);
164 result = -EFAULT;
165 break;
166 }
167 if (copy_to_user(pReq->data, &sZoneTypeCmd, sizeof(SCmdZoneTypeSet))) {
168 result = -EFAULT;
169 break;
170 };
171 }
172
173 break;
174
175 case WLAN_CMD_BSS_JOIN:
176
177 if (pDevice->bMACSuspend == TRUE) {
178 if (pDevice->bRadioOff == TRUE)
179 CARDbRadioPowerOn(pDevice);
180 vMgrTimerInit(pDevice);
181 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
182 add_timer(&pMgmt->sTimerSecondCallback);
183 pDevice->bMACSuspend = FALSE;
184 }
185
186 if (copy_from_user(&sJoinCmd, pReq->data, sizeof(SCmdBSSJoin))) {
187 result = -EFAULT;
188 break;
189 };
190
191 pItemSSID = (PWLAN_IE_SSID)sJoinCmd.ssid;
192 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
193 memcpy(pMgmt->abyDesireSSID, pItemSSID, pItemSSID->len + WLAN_IEHDR_LEN);
194 if (sJoinCmd.wBSSType == ADHOC) {
195 pMgmt->eConfigMode = WMAC_CONFIG_IBSS_STA;
196 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "ioct set to adhoc mode\n");
197 }
198 else {
199 pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;
200 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "ioct set to STA mode\n");
201 }
202 if (sJoinCmd.bPSEnable == TRUE) {
203 pDevice->ePSMode = WMAC_POWER_FAST;
204
205 pMgmt->wListenInterval = 2;
206 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Power Saving On\n");
207 }
208 else {
209 pDevice->ePSMode = WMAC_POWER_CAM;
210 pMgmt->wListenInterval = 1;
211 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Power Saving Off \n");
212 }
213
214 if (sJoinCmd.bShareKeyAuth == TRUE){
215 pMgmt->bShareKeyAlgorithm = TRUE;
216 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Share Key \n");
217 }
218 else {
219 pMgmt->bShareKeyAlgorithm = FALSE;
220 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Open System \n");
221 }
222 pDevice->uChannel = sJoinCmd.uChannel;
223 netif_stop_queue(pDevice->dev);
224 spin_lock_irq(&pDevice->lock);
225 pMgmt->eCurrState = WMAC_STATE_IDLE;
226 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID);
227 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_SSID, NULL);
228 spin_unlock_irq(&pDevice->lock);
229 break;
230
231 case WLAN_CMD_SET_WEP:
232 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_SET_WEP Key. \n");
233 memset(&sWEPCmd, 0 ,sizeof(SCmdSetWEP));
234 if (copy_from_user(&sWEPCmd, pReq->data, sizeof(SCmdSetWEP))) {
235 result = -EFAULT;
236 break;
237 };
238 if (sWEPCmd.bEnableWep != TRUE) {
239 pDevice->bEncryptionEnable = FALSE;
240 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
241 MACvDisableDefaultKey(pDevice->PortOffset);
242 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WEP function disable. \n");
243 break;
244 }
245
246 for (ii = 0; ii < WLAN_WEP_NKEYS; ii ++) {
247 if (sWEPCmd.bWepKeyAvailable[ii]) {
248 if (ii == sWEPCmd.byKeyIndex)
249
250
251
252 dwKeyIndex =ii|(1 << 31);
253 else
254 dwKeyIndex = ii;
255
256 KeybSetDefaultKey(&(pDevice->sKey),
257 dwKeyIndex,
258 sWEPCmd.auWepKeyLength[ii],
259 NULL,
260 (PBYTE)&sWEPCmd.abyWepKey[ii][0],
261 KEY_CTL_WEP,
262 pDevice->PortOffset,
263 pDevice->byLocalID);
264 }
265 }
266 pDevice->byKeyIndex = sWEPCmd.byKeyIndex;
267 pDevice->bTransmitKey = TRUE;
268 pDevice->bEncryptionEnable = TRUE;
269 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
270
271 break;
272
273 case WLAN_CMD_GET_LINK:
274 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_GET_LINK status. \n");
275
276 memset(sLinkStatus.abySSID, 0 , WLAN_SSID_MAXLEN + 1);
277
278 if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA)
279 sLinkStatus.wBSSType = ADHOC;
280 else
281 sLinkStatus.wBSSType = INFRA;
282
283 if (pMgmt->eCurrState == WMAC_STATE_JOINTED)
284 sLinkStatus.byState = ADHOC_JOINTED;
285 else
286 sLinkStatus.byState = ADHOC_STARTED;
287
288 sLinkStatus.uChannel = pMgmt->uCurrChannel;
289 if (pDevice->bLinkPass == TRUE) {
290 sLinkStatus.bLink = TRUE;
291 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyCurrSSID;
292 memcpy(sLinkStatus.abySSID, pItemSSID->abySSID, pItemSSID->len);
293 memcpy(sLinkStatus.abyBSSID, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
294 sLinkStatus.uLinkRate = pMgmt->sNodeDBTable[0].wTxDataRate;
295 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Link Success ! \n");
296 }
297 else {
298 sLinkStatus.bLink = FALSE;
299 }
300 if (copy_to_user(pReq->data, &sLinkStatus, sizeof(SCmdLinkStatus))) {
301 result = -EFAULT;
302 break;
303 };
304
305 break;
306
307 case WLAN_CMD_GET_LISTLEN:
308 cbListCount = 0;
309 pBSS = &(pMgmt->sBSSList[0]);
310 for (ii = 0; ii < MAX_BSS_NUM; ii++) {
311 pBSS = &(pMgmt->sBSSList[ii]);
312 if (!pBSS->bActive)
313 continue;
314 cbListCount++;
315 };
316 sList.uItem = cbListCount;
317 if (copy_to_user(pReq->data, &sList, sizeof(SBSSIDList))) {
318 result = -EFAULT;
319 break;
320 };
321 pReq->wResult = 0;
322 break;
323
324 case WLAN_CMD_GET_LIST:
325 if (copy_from_user(&sList, pReq->data, sizeof(SBSSIDList))) {
326 result = -EFAULT;
327 break;
328 };
329 pList = (PSBSSIDList)kmalloc(sizeof(SBSSIDList) + (sList.uItem * sizeof(SBSSIDItem)), (int)GFP_ATOMIC);
330 if (pList == NULL) {
331 result = -ENOMEM;
332 break;
333 }
334 pList->uItem = sList.uItem;
335 pBSS = &(pMgmt->sBSSList[0]);
336 for (ii = 0, jj = 0; jj < MAX_BSS_NUM ; jj++) {
337 pBSS = &(pMgmt->sBSSList[jj]);
338 if (pBSS->bActive) {
339 pList->sBSSIDList[ii].uChannel = pBSS->uChannel;
340 pList->sBSSIDList[ii].wBeaconInterval = pBSS->wBeaconInterval;
341 pList->sBSSIDList[ii].wCapInfo = pBSS->wCapInfo;
342
343 RFvRSSITodBm(pDevice, (BYTE)(pBSS->uRSSI), &ldBm);
344 pList->sBSSIDList[ii].uRSSI = (UINT)ldBm;
345 memcpy(pList->sBSSIDList[ii].abyBSSID, pBSS->abyBSSID, WLAN_BSSID_LEN);
346 pItemSSID = (PWLAN_IE_SSID)pBSS->abySSID;
347 memset(pList->sBSSIDList[ii].abySSID, 0, WLAN_SSID_MAXLEN + 1);
348 memcpy(pList->sBSSIDList[ii].abySSID, pItemSSID->abySSID, pItemSSID->len);
349 if (WLAN_GET_CAP_INFO_ESS(pBSS->wCapInfo)) {
350 pList->sBSSIDList[ii].byNetType = INFRA;
351 }
352 else {
353 pList->sBSSIDList[ii].byNetType = ADHOC;
354 }
355 if (WLAN_GET_CAP_INFO_PRIVACY(pBSS->wCapInfo)) {
356 pList->sBSSIDList[ii].bWEPOn = TRUE;
357 }
358 else {
359 pList->sBSSIDList[ii].bWEPOn = FALSE;
360 }
361 ii ++;
362 if (ii >= pList->uItem)
363 break;
364 }
365 }
366
367 if (copy_to_user(pReq->data, pList, sizeof(SBSSIDList) + (sList.uItem * sizeof(SBSSIDItem)))) {
368 result = -EFAULT;
369 break;
370 };
371 kfree(pList);
372 pReq->wResult = 0;
373 break;
374
375 case WLAN_CMD_GET_MIB:
376 if (copy_to_user(pReq->data, &(pDevice->s802_11Counter), sizeof(SDot11MIBCount))) {
377 result = -EFAULT;
378 break;
379 };
380 break;
381
382 case WLAN_CMD_GET_STAT:
383 if (copy_to_user(pReq->data, &(pDevice->scStatistic), sizeof(SStatCounter))) {
384 result = -EFAULT;
385 break;
386 };
387 break;
388 case WLAN_CMD_STOP_MAC:
389
390 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_STOP_MAC\n");
391 netif_stop_queue(pDevice->dev);
392
393 spin_lock_irq(&pDevice->lock);
394 if (pDevice->bRadioOff == FALSE) {
395 CARDbRadioPowerOff(pDevice);
396 }
397 pDevice->bLinkPass = FALSE;
398 memset(pMgmt->abyCurrBSSID, 0, 6);
399 pMgmt->eCurrState = WMAC_STATE_IDLE;
400 del_timer(&pDevice->sTimerCommand);
401 del_timer(&pMgmt->sTimerSecondCallback);
402 pDevice->bCmdRunning = FALSE;
403 pDevice->bMACSuspend = TRUE;
404 MACvIntDisable(pDevice->PortOffset);
405 spin_unlock_irq(&pDevice->lock);
406
407 break;
408
409 case WLAN_CMD_START_MAC:
410
411 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_START_MAC\n");
412
413 if (pDevice->bMACSuspend == TRUE) {
414 if (pDevice->bRadioOff == TRUE)
415 CARDbRadioPowerOn(pDevice);
416 vMgrTimerInit(pDevice);
417 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
418 add_timer(&pMgmt->sTimerSecondCallback);
419 pDevice->bMACSuspend = FALSE;
420 }
421 break;
422
423 case WLAN_CMD_SET_HOSTAPD:
424
425 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_SET_HOSTAPD\n");
426
427 if (copy_from_user(&sValue, pReq->data, sizeof(SCmdValue))) {
428 result = -EFAULT;
429 break;
430 };
431 if (sValue.dwValue == 1) {
432 if (hostap_set_hostapd(pDevice, 1, 1) == 0){
433 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Enable HOSTAP\n");
434 }
435 else {
436 result = -EFAULT;
437 break;
438 }
439 }
440 else {
441 hostap_set_hostapd(pDevice, 0, 1);
442 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Disable HOSTAP\n");
443 }
444
445 break;
446
447 case WLAN_CMD_SET_HOSTAPD_STA:
448
449 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_SET_HOSTAPD_STA\n");
450
451 break;
452 case WLAN_CMD_SET_802_1X:
453
454 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_SET_802_1X\n");
455 if (copy_from_user(&sValue, pReq->data, sizeof(SCmdValue))) {
456 result = -EFAULT;
457 break;
458 };
459
460 if (sValue.dwValue == 1) {
461 pDevice->bEnable8021x = TRUE;
462 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Enable 802.1x\n");
463 }
464 else {
465 pDevice->bEnable8021x = FALSE;
466 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Disable 802.1x\n");
467 }
468
469 break;
470
471
472 case WLAN_CMD_SET_HOST_WEP:
473
474 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_SET_HOST_WEP\n");
475 if (copy_from_user(&sValue, pReq->data, sizeof(SCmdValue))) {
476 result = -EFAULT;
477 break;
478 };
479
480 if (sValue.dwValue == 1) {
481 pDevice->bEnableHostWEP = TRUE;
482 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Enable HostWEP\n");
483 }
484 else {
485 pDevice->bEnableHostWEP = FALSE;
486 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Disable HostWEP\n");
487 }
488
489 break;
490
491 case WLAN_CMD_SET_WPA:
492 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_SET_WPA\n");
493
494 if (copy_from_user(&sValue, pReq->data, sizeof(SCmdValue))) {
495 result = -EFAULT;
496 break;
497 };
498 if (sValue.dwValue == 1) {
499 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "up wpadev\n");
500 memcpy(pDevice->wpadev->dev_addr, pDevice->dev->dev_addr, U_ETHER_ADDR_LEN);
501 pDevice->bWPADEVUp = TRUE;
502 }
503 else {
504 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "close wpadev\n");
505 pDevice->bWPADEVUp = FALSE;
506 }
507
508 break;
509
510 case WLAN_CMD_AP_START:
511
512 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WLAN_CMD_AP_START\n");
513 if (pDevice->bRadioOff == TRUE) {
514 CARDbRadioPowerOn(pDevice);
515 vMgrTimerInit(pDevice);
516 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
517 add_timer(&pMgmt->sTimerSecondCallback);
518 }
519 if (copy_from_user(&sStartAPCmd, pReq->data, sizeof(SCmdStartAP))) {
520 result = -EFAULT;
521 break;
522 };
523
524 if (sStartAPCmd.wBSSType == AP) {
525 pMgmt->eConfigMode = WMAC_CONFIG_AP;
526 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "ioct set to AP mode\n");
527 }
528 else {
529 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "ioct BSS type not set to AP mode\n");
530 result = -EFAULT;
531 break;
532 }
533
534
535 if (sStartAPCmd.wBBPType == PHY80211g) {
536 pMgmt->byAPBBType = PHY_TYPE_11G;
537 }
538 else if (sStartAPCmd.wBBPType == PHY80211a) {
539 pMgmt->byAPBBType = PHY_TYPE_11A;
540 }
541 else {
542 pMgmt->byAPBBType = PHY_TYPE_11B;
543 }
544
545 pItemSSID = (PWLAN_IE_SSID)sStartAPCmd.ssid;
546 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
547 memcpy(pMgmt->abyDesireSSID, pItemSSID, pItemSSID->len + WLAN_IEHDR_LEN);
548
549 if ((sStartAPCmd.uChannel > 0)&&(sStartAPCmd.uChannel <= 14))
550 pDevice->uChannel = sStartAPCmd.uChannel;
551
552 if ((sStartAPCmd.uBeaconInt >= 20) && (sStartAPCmd.uBeaconInt <= 1000))
553 pMgmt->wIBSSBeaconPeriod = sStartAPCmd.uBeaconInt;
554 else
555 pMgmt->wIBSSBeaconPeriod = 100;
556
557 if (sStartAPCmd.bShareKeyAuth == TRUE){
558 pMgmt->bShareKeyAlgorithm = TRUE;
559 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Share Key \n");
560 }
561 else {
562 pMgmt->bShareKeyAlgorithm = FALSE;
563 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Open System \n");
564 }
565 memcpy(pMgmt->abyIBSSSuppRates, abySuppRates, 6);
566
567 if (sStartAPCmd.byBasicRate & BIT3) {
568 pMgmt->abyIBSSSuppRates[2] |= BIT7;
569 pMgmt->abyIBSSSuppRates[3] |= BIT7;
570 pMgmt->abyIBSSSuppRates[4] |= BIT7;
571 pMgmt->abyIBSSSuppRates[5] |= BIT7;
572 }else if (sStartAPCmd.byBasicRate & BIT2) {
573 pMgmt->abyIBSSSuppRates[2] |= BIT7;
574 pMgmt->abyIBSSSuppRates[3] |= BIT7;
575 pMgmt->abyIBSSSuppRates[4] |= BIT7;
576 }else if (sStartAPCmd.byBasicRate & BIT1) {
577 pMgmt->abyIBSSSuppRates[2] |= BIT7;
578 pMgmt->abyIBSSSuppRates[3] |= BIT7;
579 }else if (sStartAPCmd.byBasicRate & BIT1) {
580 pMgmt->abyIBSSSuppRates[2] |= BIT7;
581 }else {
582
583 pMgmt->abyIBSSSuppRates[2] |= BIT7;
584 pMgmt->abyIBSSSuppRates[3] |= BIT7;
585 }
586
587 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Support Rate= %x %x %x %x\n",
588 pMgmt->abyIBSSSuppRates[2],
589 pMgmt->abyIBSSSuppRates[3],
590 pMgmt->abyIBSSSuppRates[4],
591 pMgmt->abyIBSSSuppRates[5]
592 );
593
594 netif_stop_queue(pDevice->dev);
595 spin_lock_irq(&pDevice->lock);
596 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL);
597 spin_unlock_irq(&pDevice->lock);
598 break;
599
600 case WLAN_CMD_GET_NODE_CNT:
601
602 cbListCount = 0;
603 pNode = &(pMgmt->sNodeDBTable[0]);
604 for (ii = 0; ii < (MAX_NODE_NUM + 1); ii++) {
605 pNode = &(pMgmt->sNodeDBTable[ii]);
606 if (!pNode->bActive)
607 continue;
608 cbListCount++;
609 };
610
611 sNodeList.uItem = cbListCount;
612 if (copy_to_user(pReq->data, &sNodeList, sizeof(SNodeList))) {
613 result = -EFAULT;
614 break;
615 };
616 pReq->wResult = 0;
617 break;
618
619 case WLAN_CMD_GET_NODE_LIST:
620
621 if (copy_from_user(&sNodeList, pReq->data, sizeof(SNodeList))) {
622 result = -EFAULT;
623 break;
624 };
625 pNodeList = (PSNodeList)kmalloc(sizeof(SNodeList) + (sNodeList.uItem * sizeof(SNodeItem)), (int)GFP_ATOMIC);
626 if (pNodeList == NULL) {
627 result = -ENOMEM;
628 break;
629 }
630 pNodeList->uItem = sNodeList.uItem;
631 pNode = &(pMgmt->sNodeDBTable[0]);
632 for (ii = 0, jj = 0; ii < (MAX_NODE_NUM + 1); ii++) {
633 pNode = &(pMgmt->sNodeDBTable[ii]);
634 if (pNode->bActive) {
635 pNodeList->sNodeList[jj].wAID = pNode->wAID;
636 memcpy(pNodeList->sNodeList[jj].abyMACAddr, pNode->abyMACAddr, WLAN_ADDR_LEN);
637 pNodeList->sNodeList[jj].wTxDataRate = pNode->wTxDataRate;
638 pNodeList->sNodeList[jj].wInActiveCount = (WORD)pNode->uInActiveCount;
639 pNodeList->sNodeList[jj].wEnQueueCnt = (WORD)pNode->wEnQueueCnt;
640 pNodeList->sNodeList[jj].wFlags = (WORD)pNode->dwFlags;
641 pNodeList->sNodeList[jj].bPWBitOn = pNode->bPSEnable;
642 pNodeList->sNodeList[jj].byKeyIndex = pNode->byKeyIndex;
643 pNodeList->sNodeList[jj].wWepKeyLength = pNode->uWepKeyLength;
644 memcpy(&(pNodeList->sNodeList[jj].abyWepKey[0]), &(pNode->abyWepKey[0]), WEP_KEYMAXLEN);
645 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "key= %2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
646 pNodeList->sNodeList[jj].abyWepKey[0],
647 pNodeList->sNodeList[jj].abyWepKey[1],
648 pNodeList->sNodeList[jj].abyWepKey[2],
649 pNodeList->sNodeList[jj].abyWepKey[3],
650 pNodeList->sNodeList[jj].abyWepKey[4]
651 );
652 pNodeList->sNodeList[jj].bIsInFallback = pNode->bIsInFallback;
653 pNodeList->sNodeList[jj].uTxFailures = pNode->uTxFailures;
654 pNodeList->sNodeList[jj].uTxAttempts = pNode->uTxAttempts;
655 pNodeList->sNodeList[jj].wFailureRatio = (WORD)pNode->uFailureRatio;
656 jj ++;
657 if (jj >= pNodeList->uItem)
658 break;
659 }
660 };
661 if (copy_to_user(pReq->data, pNodeList, sizeof(SNodeList) + (sNodeList.uItem * sizeof(SNodeItem)))) {
662 result = -EFAULT;
663 break;
664 };
665 kfree(pNodeList);
666 pReq->wResult = 0;
667 break;
668
669#ifdef WPA_SM_Transtatus
670 case 0xFF:
671 memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
672 wpa_Result.proto = 0;
673 wpa_Result.key_mgmt = 0;
674 wpa_Result.eap_type = 0;
675 wpa_Result.authenticated = FALSE;
676 pDevice->fWPA_Authened = FALSE;
677 if (copy_from_user(&wpa_Result, pReq->data, sizeof(wpa_Result))) {
678 result = -EFAULT;
679 break;
680 }
681
682if(wpa_Result.authenticated==TRUE) {
683 #ifdef SndEvt_ToAPI
684 {
685 union iwreq_data wrqu;
686
687 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyCurrSSID;
688
689 memset(&wrqu, 0, sizeof(wrqu));
690 wrqu.data.flags = RT_WPACONNECTED_EVENT_FLAG;
691 wrqu.data.length =pItemSSID->len;
692 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, pItemSSID->abySSID);
693 }
694 #endif
695 pDevice->fWPA_Authened = TRUE;
696}
697
698
699
700
701
702
703
704
705 pReq->wResult = 0;
706 break;
707#endif
708
709 default:
710 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Private command not support..\n");
711 }
712
713 return result;
714}
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753