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