diff options
Diffstat (limited to 'drivers/staging/rtl8192e/rtl819x_HTProc.c')
-rw-r--r-- | drivers/staging/rtl8192e/rtl819x_HTProc.c | 1531 |
1 files changed, 1531 insertions, 0 deletions
diff --git a/drivers/staging/rtl8192e/rtl819x_HTProc.c b/drivers/staging/rtl8192e/rtl819x_HTProc.c new file mode 100644 index 00000000000..eaf73676f95 --- /dev/null +++ b/drivers/staging/rtl8192e/rtl819x_HTProc.c | |||
@@ -0,0 +1,1531 @@ | |||
1 | /****************************************************************************** | ||
2 | * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved. | ||
3 | * | ||
4 | * This program is distributed in the hope that it will be useful, but WITHOUT | ||
5 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
6 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
7 | * more details. | ||
8 | * | ||
9 | * You should have received a copy of the GNU General Public License along with | ||
10 | * this program; if not, write to the Free Software Foundation, Inc., | ||
11 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA | ||
12 | * | ||
13 | * The full GNU General Public License is included in this distribution in the | ||
14 | * file called LICENSE. | ||
15 | * | ||
16 | * Contact Information: | ||
17 | * wlanfae <wlanfae@realtek.com> | ||
18 | ******************************************************************************/ | ||
19 | #include "rtllib.h" | ||
20 | #include "rtl819x_HT.h" | ||
21 | u8 MCS_FILTER_ALL[16] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; | ||
22 | |||
23 | u8 MCS_FILTER_1SS[16] = {0xff, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; | ||
24 | |||
25 | u16 MCS_DATA_RATE[2][2][77] = | ||
26 | { { {13, 26, 39, 52, 78, 104, 117, 130, 26, 52, 78 ,104, 156, 208, 234, 260, | ||
27 | 39, 78, 117, 234, 312, 351, 390, 52, 104, 156, 208, 312, 416, 468, 520, | ||
28 | 0, 78, 104, 130, 117, 156, 195, 104, 130, 130, 156, 182, 182, 208, 156, 195, | ||
29 | 195, 234, 273, 273, 312, 130, 156, 181, 156, 181, 208, 234, 208, 234, 260, 260, | ||
30 | 286, 195, 234, 273, 234, 273, 312, 351, 312, 351, 390, 390, 429}, | ||
31 | {14, 29, 43, 58, 87, 116, 130, 144, 29, 58, 87, 116, 173, 231, 260, 289, | ||
32 | 43, 87, 130, 173, 260, 347, 390, 433, 58, 116, 173, 231, 347, 462, 520, 578, | ||
33 | 0, 87, 116, 144, 130, 173, 217, 116, 144, 144, 173, 202, 202, 231, 173, 217, | ||
34 | 217, 260, 303, 303, 347, 144, 173, 202, 173, 202, 231, 260, 231, 260, 289, 289, | ||
35 | 318, 217, 260, 303, 260, 303, 347, 390, 347, 390, 433, 433, 477} }, | ||
36 | { {27, 54, 81, 108, 162, 216, 243, 270, 54, 108, 162, 216, 324, 432, 486, 540, | ||
37 | 81, 162, 243, 324, 486, 648, 729, 810, 108, 216, 324, 432, 648, 864, 972, 1080, | ||
38 | 12, 162, 216, 270, 243, 324, 405, 216, 270, 270, 324, 378, 378, 432, 324, 405, | ||
39 | 405, 486, 567, 567, 648, 270, 324, 378, 324, 378, 432, 486, 432, 486, 540, 540, | ||
40 | 594, 405, 486, 567, 486, 567, 648, 729, 648, 729, 810, 810, 891}, | ||
41 | {30, 60, 90, 120, 180, 240, 270, 300, 60, 120, 180, 240, 360, 480, 540, 600, | ||
42 | 90, 180, 270, 360, 540, 720, 810, 900, 120, 240, 360, 480, 720, 960, 1080, 1200, | ||
43 | 13, 180, 240, 300, 270, 360, 450, 240, 300, 300, 360, 420, 420, 480, 360, 450, | ||
44 | 450, 540, 630, 630, 720, 300, 360, 420, 360, 420, 480, 540, 480, 540, 600, 600, | ||
45 | 660, 450, 540, 630, 540, 630, 720, 810, 720, 810, 900, 900, 990} } | ||
46 | }; | ||
47 | |||
48 | static u8 UNKNOWN_BORADCOM[3] = {0x00, 0x14, 0xbf}; | ||
49 | static u8 LINKSYSWRT330_LINKSYSWRT300_BROADCOM[3] = {0x00, 0x1a, 0x70}; | ||
50 | static u8 LINKSYSWRT350_LINKSYSWRT150_BROADCOM[3] = {0x00, 0x1d, 0x7e}; | ||
51 | static u8 BELKINF5D8233V1_RALINK[3] = {0x00, 0x17, 0x3f}; | ||
52 | static u8 BELKINF5D82334V3_RALINK[3] = {0x00, 0x1c, 0xdf}; | ||
53 | static u8 PCI_RALINK[3] = {0x00, 0x90, 0xcc}; | ||
54 | static u8 EDIMAX_RALINK[3] = {0x00, 0x0e, 0x2e}; | ||
55 | static u8 AIRLINK_RALINK[3] = {0x00, 0x18, 0x02}; | ||
56 | static u8 DLINK_ATHEROS_1[3] = {0x00, 0x1c, 0xf0}; | ||
57 | static u8 DLINK_ATHEROS_2[3] = {0x00, 0x21, 0x91}; | ||
58 | static u8 CISCO_BROADCOM[3] = {0x00, 0x17, 0x94}; | ||
59 | #if defined(RTL8192SU) | ||
60 | static u8 NETGEAR_BROADCOM[3] = {0x00, 0x1f, 0x33}; | ||
61 | #endif | ||
62 | static u8 LINKSYS_MARVELL_4400N[3] = {0x00, 0x14, 0xa4}; | ||
63 | void HTUpdateDefaultSetting(struct rtllib_device* ieee) | ||
64 | { | ||
65 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
66 | |||
67 | #ifdef RTL8192CE | ||
68 | pHTInfo->bRDGEnable = 0; | ||
69 | #endif | ||
70 | |||
71 | pHTInfo->bAcceptAddbaReq = 1; | ||
72 | |||
73 | pHTInfo->bRegShortGI20MHz= 1; | ||
74 | pHTInfo->bRegShortGI40MHz= 1; | ||
75 | |||
76 | pHTInfo->bRegBW40MHz = 1; | ||
77 | |||
78 | if (pHTInfo->bRegBW40MHz) | ||
79 | pHTInfo->bRegSuppCCK = 1; | ||
80 | else | ||
81 | pHTInfo->bRegSuppCCK = true; | ||
82 | |||
83 | pHTInfo->nAMSDU_MaxSize = 7935UL; | ||
84 | pHTInfo->bAMSDU_Support = 0; | ||
85 | |||
86 | pHTInfo->bAMPDUEnable = 1; | ||
87 | pHTInfo->AMPDU_Factor = 2; | ||
88 | pHTInfo->MPDU_Density = 0; | ||
89 | |||
90 | pHTInfo->SelfMimoPs = 3; | ||
91 | if (pHTInfo->SelfMimoPs == 2) | ||
92 | pHTInfo->SelfMimoPs = 3; | ||
93 | ieee->bTxDisableRateFallBack = 0; | ||
94 | ieee->bTxUseDriverAssingedRate = 0; | ||
95 | |||
96 | ieee->bTxEnableFwCalcDur = 1; | ||
97 | |||
98 | pHTInfo->bRegRT2RTAggregation = 1; | ||
99 | |||
100 | pHTInfo->bRegRxReorderEnable = 1; | ||
101 | pHTInfo->RxReorderWinSize = 64; | ||
102 | pHTInfo->RxReorderPendingTime = 30; | ||
103 | |||
104 | #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE | ||
105 | pHTInfo->UsbTxAggrNum = 4; | ||
106 | #endif | ||
107 | #ifdef USB_RX_AGGREGATION_SUPPORT | ||
108 | #ifdef RTL8192SU | ||
109 | pHTInfo->UsbRxFwAggrEn = 1; | ||
110 | pHTInfo->UsbRxFwAggrPageNum = 48; | ||
111 | pHTInfo->UsbRxFwAggrPacketNum = 8; | ||
112 | pHTInfo->UsbRxFwAggrTimeout = 4; | ||
113 | pHTInfo->UsbRxPageSize= 128; | ||
114 | #else | ||
115 | pHTInfo->UsbRxFwAggrEn = 1; | ||
116 | pHTInfo->UsbRxFwAggrPageNum = 24; | ||
117 | pHTInfo->UsbRxFwAggrPacketNum = 8; | ||
118 | pHTInfo->UsbRxFwAggrTimeout = 8; | ||
119 | #endif | ||
120 | #endif | ||
121 | |||
122 | |||
123 | } | ||
124 | void HTDebugHTCapability(u8* CapIE, u8* TitleString ) | ||
125 | { | ||
126 | |||
127 | static u8 EWC11NHTCap[] = {0x00, 0x90, 0x4c, 0x33}; | ||
128 | PHT_CAPABILITY_ELE pCapELE; | ||
129 | |||
130 | if (!memcmp(CapIE, EWC11NHTCap, sizeof(EWC11NHTCap))) | ||
131 | { | ||
132 | RTLLIB_DEBUG(RTLLIB_DL_HT, "EWC IE in %s()\n", __func__); | ||
133 | pCapELE = (PHT_CAPABILITY_ELE)(&CapIE[4]); | ||
134 | }else | ||
135 | pCapELE = (PHT_CAPABILITY_ELE)(&CapIE[0]); | ||
136 | |||
137 | RTLLIB_DEBUG(RTLLIB_DL_HT, "<Log HT Capability>. Called by %s\n", TitleString ); | ||
138 | |||
139 | RTLLIB_DEBUG(RTLLIB_DL_HT, "\tSupported Channel Width = %s\n", (pCapELE->ChlWidth)?"20MHz": "20/40MHz"); | ||
140 | RTLLIB_DEBUG(RTLLIB_DL_HT, "\tSupport Short GI for 20M = %s\n", (pCapELE->ShortGI20Mhz)?"YES": "NO"); | ||
141 | RTLLIB_DEBUG(RTLLIB_DL_HT, "\tSupport Short GI for 40M = %s\n", (pCapELE->ShortGI40Mhz)?"YES": "NO"); | ||
142 | RTLLIB_DEBUG(RTLLIB_DL_HT, "\tSupport TX STBC = %s\n", (pCapELE->TxSTBC)?"YES": "NO"); | ||
143 | RTLLIB_DEBUG(RTLLIB_DL_HT, "\tMax AMSDU Size = %s\n", (pCapELE->MaxAMSDUSize)?"3839": "7935"); | ||
144 | RTLLIB_DEBUG(RTLLIB_DL_HT, "\tSupport CCK in 20/40 mode = %s\n", (pCapELE->DssCCk)?"YES": "NO"); | ||
145 | RTLLIB_DEBUG(RTLLIB_DL_HT, "\tMax AMPDU Factor = %d\n", pCapELE->MaxRxAMPDUFactor); | ||
146 | RTLLIB_DEBUG(RTLLIB_DL_HT, "\tMPDU Density = %d\n", pCapELE->MPDUDensity); | ||
147 | RTLLIB_DEBUG(RTLLIB_DL_HT, "\tMCS Rate Set = [%x][%x][%x][%x][%x]\n", pCapELE->MCS[0],\ | ||
148 | pCapELE->MCS[1], pCapELE->MCS[2], pCapELE->MCS[3], pCapELE->MCS[4]); | ||
149 | return; | ||
150 | |||
151 | } | ||
152 | void HTDebugHTInfo(u8* InfoIE, u8* TitleString) | ||
153 | { | ||
154 | |||
155 | static u8 EWC11NHTInfo[] = {0x00, 0x90, 0x4c, 0x34}; | ||
156 | PHT_INFORMATION_ELE pHTInfoEle; | ||
157 | |||
158 | if (!memcmp(InfoIE, EWC11NHTInfo, sizeof(EWC11NHTInfo))) | ||
159 | { | ||
160 | RTLLIB_DEBUG(RTLLIB_DL_HT, "EWC IE in %s()\n", __func__); | ||
161 | pHTInfoEle = (PHT_INFORMATION_ELE)(&InfoIE[4]); | ||
162 | }else | ||
163 | pHTInfoEle = (PHT_INFORMATION_ELE)(&InfoIE[0]); | ||
164 | |||
165 | |||
166 | RTLLIB_DEBUG(RTLLIB_DL_HT, "<Log HT Information Element>. Called by %s\n", TitleString); | ||
167 | |||
168 | RTLLIB_DEBUG(RTLLIB_DL_HT, "\tPrimary channel = %d\n", pHTInfoEle->ControlChl); | ||
169 | RTLLIB_DEBUG(RTLLIB_DL_HT, "\tSenondary channel ="); | ||
170 | switch (pHTInfoEle->ExtChlOffset) | ||
171 | { | ||
172 | case 0: | ||
173 | RTLLIB_DEBUG(RTLLIB_DL_HT, "Not Present\n"); | ||
174 | break; | ||
175 | case 1: | ||
176 | RTLLIB_DEBUG(RTLLIB_DL_HT, "Upper channel\n"); | ||
177 | break; | ||
178 | case 2: | ||
179 | RTLLIB_DEBUG(RTLLIB_DL_HT, "Reserved. Eooro!!!\n"); | ||
180 | break; | ||
181 | case 3: | ||
182 | RTLLIB_DEBUG(RTLLIB_DL_HT, "Lower Channel\n"); | ||
183 | break; | ||
184 | } | ||
185 | RTLLIB_DEBUG(RTLLIB_DL_HT, "\tRecommended channel width = %s\n", (pHTInfoEle->RecommemdedTxWidth)?"20Mhz": "40Mhz"); | ||
186 | |||
187 | RTLLIB_DEBUG(RTLLIB_DL_HT, "\tOperation mode for protection = "); | ||
188 | switch (pHTInfoEle->OptMode) | ||
189 | { | ||
190 | case 0: | ||
191 | RTLLIB_DEBUG(RTLLIB_DL_HT, "No Protection\n"); | ||
192 | break; | ||
193 | case 1: | ||
194 | RTLLIB_DEBUG(RTLLIB_DL_HT, "HT non-member protection mode\n"); | ||
195 | break; | ||
196 | case 2: | ||
197 | RTLLIB_DEBUG(RTLLIB_DL_HT, "Suggest to open protection\n"); | ||
198 | break; | ||
199 | case 3: | ||
200 | RTLLIB_DEBUG(RTLLIB_DL_HT, "HT mixed mode\n"); | ||
201 | break; | ||
202 | } | ||
203 | |||
204 | RTLLIB_DEBUG(RTLLIB_DL_HT, "\tBasic MCS Rate Set = [%x][%x][%x][%x][%x]\n", pHTInfoEle->BasicMSC[0],\ | ||
205 | pHTInfoEle->BasicMSC[1], pHTInfoEle->BasicMSC[2], pHTInfoEle->BasicMSC[3], pHTInfoEle->BasicMSC[4]); | ||
206 | return; | ||
207 | } | ||
208 | |||
209 | bool IsHTHalfNmode40Bandwidth(struct rtllib_device* ieee) | ||
210 | { | ||
211 | bool retValue = false; | ||
212 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
213 | |||
214 | if (pHTInfo->bCurrentHTSupport == false ) | ||
215 | retValue = false; | ||
216 | else if (pHTInfo->bRegBW40MHz == false) | ||
217 | retValue = false; | ||
218 | else if (!ieee->GetHalfNmodeSupportByAPsHandler(ieee->dev)) | ||
219 | retValue = false; | ||
220 | else if (((PHT_CAPABILITY_ELE)(pHTInfo->PeerHTCapBuf))->ChlWidth) | ||
221 | retValue = true; | ||
222 | else | ||
223 | retValue = false; | ||
224 | |||
225 | return retValue; | ||
226 | } | ||
227 | |||
228 | bool IsHTHalfNmodeSGI(struct rtllib_device* ieee, bool is40MHz) | ||
229 | { | ||
230 | bool retValue = false; | ||
231 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
232 | |||
233 | if (pHTInfo->bCurrentHTSupport == false ) | ||
234 | retValue = false; | ||
235 | else if (!ieee->GetHalfNmodeSupportByAPsHandler(ieee->dev)) | ||
236 | retValue = false; | ||
237 | else if (is40MHz) | ||
238 | { | ||
239 | if (((PHT_CAPABILITY_ELE)(pHTInfo->PeerHTCapBuf))->ShortGI40Mhz) | ||
240 | retValue = true; | ||
241 | else | ||
242 | retValue = false; | ||
243 | } | ||
244 | else | ||
245 | { | ||
246 | if (((PHT_CAPABILITY_ELE)(pHTInfo->PeerHTCapBuf))->ShortGI20Mhz) | ||
247 | retValue = true; | ||
248 | else | ||
249 | retValue = false; | ||
250 | } | ||
251 | |||
252 | return retValue; | ||
253 | } | ||
254 | |||
255 | u16 HTHalfMcsToDataRate(struct rtllib_device* ieee, u8 nMcsRate) | ||
256 | { | ||
257 | |||
258 | u8 is40MHz; | ||
259 | u8 isShortGI; | ||
260 | |||
261 | is40MHz = (IsHTHalfNmode40Bandwidth(ieee))?1:0; | ||
262 | isShortGI = (IsHTHalfNmodeSGI(ieee, is40MHz))? 1:0; | ||
263 | |||
264 | return MCS_DATA_RATE[is40MHz][isShortGI][(nMcsRate&0x7f)]; | ||
265 | } | ||
266 | |||
267 | |||
268 | u16 HTMcsToDataRate( struct rtllib_device* ieee, u8 nMcsRate) | ||
269 | { | ||
270 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
271 | |||
272 | u8 is40MHz = (pHTInfo->bCurBW40MHz)?1:0; | ||
273 | u8 isShortGI = (pHTInfo->bCurBW40MHz)? | ||
274 | ((pHTInfo->bCurShortGI40MHz)?1:0): | ||
275 | ((pHTInfo->bCurShortGI20MHz)?1:0); | ||
276 | return MCS_DATA_RATE[is40MHz][isShortGI][(nMcsRate&0x7f)]; | ||
277 | } | ||
278 | |||
279 | u16 TxCountToDataRate( struct rtllib_device* ieee, u8 nDataRate) | ||
280 | { | ||
281 | u16 CCKOFDMRate[12] = {0x02 , 0x04 , 0x0b , 0x16 , 0x0c , 0x12 , 0x18 , 0x24 , 0x30 , 0x48 , 0x60 , 0x6c}; | ||
282 | u8 is40MHz = 0; | ||
283 | u8 isShortGI = 0; | ||
284 | |||
285 | if (nDataRate < 12) | ||
286 | { | ||
287 | return CCKOFDMRate[nDataRate]; | ||
288 | } | ||
289 | else | ||
290 | { | ||
291 | if (nDataRate >= 0x10 && nDataRate <= 0x1f) | ||
292 | { | ||
293 | is40MHz = 0; | ||
294 | isShortGI = 0; | ||
295 | |||
296 | } | ||
297 | else if (nDataRate >=0x20 && nDataRate <= 0x2f ) | ||
298 | { | ||
299 | is40MHz = 1; | ||
300 | isShortGI = 0; | ||
301 | |||
302 | } | ||
303 | else if (nDataRate >= 0x30 && nDataRate <= 0x3f ) | ||
304 | { | ||
305 | is40MHz = 0; | ||
306 | isShortGI = 1; | ||
307 | |||
308 | } | ||
309 | else if (nDataRate >= 0x40 && nDataRate <= 0x4f ) | ||
310 | { | ||
311 | is40MHz = 1; | ||
312 | isShortGI = 1; | ||
313 | |||
314 | } | ||
315 | return MCS_DATA_RATE[is40MHz][isShortGI][nDataRate&0xf]; | ||
316 | } | ||
317 | } | ||
318 | |||
319 | |||
320 | |||
321 | bool IsHTHalfNmodeAPs(struct rtllib_device* ieee) | ||
322 | { | ||
323 | bool retValue = false; | ||
324 | struct rtllib_network* net = &ieee->current_network; | ||
325 | |||
326 | if ((memcmp(net->bssid, BELKINF5D8233V1_RALINK, 3)==0) || | ||
327 | (memcmp(net->bssid, BELKINF5D82334V3_RALINK, 3)==0) || | ||
328 | (memcmp(net->bssid, PCI_RALINK, 3)==0) || | ||
329 | (memcmp(net->bssid, EDIMAX_RALINK, 3)==0) || | ||
330 | (memcmp(net->bssid, AIRLINK_RALINK, 3)==0) || | ||
331 | (net->ralink_cap_exist)) | ||
332 | retValue = true; | ||
333 | else if ((memcmp(net->bssid, UNKNOWN_BORADCOM, 3)==0) || | ||
334 | (memcmp(net->bssid, LINKSYSWRT330_LINKSYSWRT300_BROADCOM, 3)==0)|| | ||
335 | (memcmp(net->bssid, LINKSYSWRT350_LINKSYSWRT150_BROADCOM, 3)==0)|| | ||
336 | (net->broadcom_cap_exist)) | ||
337 | retValue = true; | ||
338 | else if (net->bssht.bdRT2RTAggregation) | ||
339 | retValue = true; | ||
340 | else | ||
341 | retValue = false; | ||
342 | |||
343 | return retValue; | ||
344 | } | ||
345 | |||
346 | void HTIOTPeerDetermine(struct rtllib_device* ieee) | ||
347 | { | ||
348 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
349 | struct rtllib_network* net = &ieee->current_network; | ||
350 | if (net->bssht.bdRT2RTAggregation){ | ||
351 | pHTInfo->IOTPeer = HT_IOT_PEER_REALTEK; | ||
352 | if (net->bssht.RT2RT_HT_Mode & RT_HT_CAP_USE_92SE){ | ||
353 | pHTInfo->IOTPeer = HT_IOT_PEER_REALTEK_92SE; | ||
354 | } | ||
355 | if (net->bssht.RT2RT_HT_Mode & RT_HT_CAP_USE_SOFTAP){ | ||
356 | pHTInfo->IOTPeer = HT_IOT_PEER_92U_SOFTAP; | ||
357 | } | ||
358 | } | ||
359 | else if (net->broadcom_cap_exist) | ||
360 | pHTInfo->IOTPeer = HT_IOT_PEER_BROADCOM; | ||
361 | else if ((memcmp(net->bssid, UNKNOWN_BORADCOM, 3)==0) || | ||
362 | (memcmp(net->bssid, LINKSYSWRT330_LINKSYSWRT300_BROADCOM, 3)==0)|| | ||
363 | (memcmp(net->bssid, LINKSYSWRT350_LINKSYSWRT150_BROADCOM, 3)==0)/*|| | ||
364 | (memcmp(net->bssid, NETGEAR834Bv2_BROADCOM, 3)==0) */) | ||
365 | pHTInfo->IOTPeer = HT_IOT_PEER_BROADCOM; | ||
366 | else if ((memcmp(net->bssid, BELKINF5D8233V1_RALINK, 3)==0) || | ||
367 | (memcmp(net->bssid, BELKINF5D82334V3_RALINK, 3)==0) || | ||
368 | (memcmp(net->bssid, PCI_RALINK, 3)==0) || | ||
369 | (memcmp(net->bssid, EDIMAX_RALINK, 3)==0) || | ||
370 | (memcmp(net->bssid, AIRLINK_RALINK, 3)==0) || | ||
371 | net->ralink_cap_exist) | ||
372 | pHTInfo->IOTPeer = HT_IOT_PEER_RALINK; | ||
373 | else if ((net->atheros_cap_exist )|| | ||
374 | (memcmp(net->bssid, DLINK_ATHEROS_1, 3) == 0)|| | ||
375 | (memcmp(net->bssid, DLINK_ATHEROS_2, 3) == 0)) | ||
376 | pHTInfo->IOTPeer = HT_IOT_PEER_ATHEROS; | ||
377 | else if ((memcmp(net->bssid, CISCO_BROADCOM, 3)==0)||net->cisco_cap_exist) | ||
378 | pHTInfo->IOTPeer = HT_IOT_PEER_CISCO; | ||
379 | else if ((memcmp(net->bssid, LINKSYS_MARVELL_4400N, 3) == 0) || | ||
380 | net->marvell_cap_exist) | ||
381 | pHTInfo->IOTPeer = HT_IOT_PEER_MARVELL; | ||
382 | else if (net->airgo_cap_exist) | ||
383 | pHTInfo->IOTPeer = HT_IOT_PEER_AIRGO; | ||
384 | else | ||
385 | pHTInfo->IOTPeer = HT_IOT_PEER_UNKNOWN; | ||
386 | |||
387 | RTLLIB_DEBUG(RTLLIB_DL_IOT, "Joseph debug!! IOTPEER: %x\n", pHTInfo->IOTPeer); | ||
388 | } | ||
389 | |||
390 | u8 HTIOTActIsDisableMCS14(struct rtllib_device* ieee, u8* PeerMacAddr) | ||
391 | { | ||
392 | return 0; | ||
393 | } | ||
394 | |||
395 | |||
396 | bool HTIOTActIsDisableMCS15(struct rtllib_device* ieee) | ||
397 | { | ||
398 | bool retValue = false; | ||
399 | |||
400 | #if defined(RTL8192U) | ||
401 | if (ieee->current_network.bssht.bdBandWidth == HT_CHANNEL_WIDTH_20_40) | ||
402 | retValue = true; | ||
403 | else | ||
404 | retValue = false; | ||
405 | #endif | ||
406 | |||
407 | |||
408 | return retValue; | ||
409 | } | ||
410 | |||
411 | bool HTIOTActIsDisableMCSTwoSpatialStream(struct rtllib_device* ieee) | ||
412 | { | ||
413 | bool retValue = false; | ||
414 | #ifdef RTL8192U | ||
415 | struct rtllib_network* net = &ieee->current_network; | ||
416 | |||
417 | if ((ieee->pHTInfo->bCurrentHTSupport == true) && (ieee->pairwise_key_type == KEY_TYPE_CCMP)) | ||
418 | { | ||
419 | if ((memcmp(net->bssid, BELKINF5D8233V1_RALINK, 3)==0) || | ||
420 | (memcmp(net->bssid, PCI_RALINK, 3)==0) || | ||
421 | (memcmp(net->bssid, EDIMAX_RALINK, 3)==0)) | ||
422 | { | ||
423 | retValue = false; | ||
424 | } | ||
425 | } | ||
426 | #endif | ||
427 | #if defined(RTL8192SU) || defined RTL8192CE | ||
428 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
429 | if (ieee->rtllib_ap_sec_type && | ||
430 | (ieee->rtllib_ap_sec_type(ieee)&(SEC_ALG_WEP|SEC_ALG_TKIP))) | ||
431 | { | ||
432 | if ( (pHTInfo->IOTPeer != HT_IOT_PEER_ATHEROS) && | ||
433 | (pHTInfo->IOTPeer != HT_IOT_PEER_UNKNOWN) && | ||
434 | (pHTInfo->IOTPeer != HT_IOT_PEER_MARVELL) && | ||
435 | (pHTInfo->IOTPeer != HT_IOT_PEER_REALTEK_92SE) && | ||
436 | (pHTInfo->IOTPeer != HT_IOT_PEER_RALINK) ) | ||
437 | retValue = true; | ||
438 | } | ||
439 | #elif defined(RTL8192SE) | ||
440 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
441 | if (ieee->rtllib_ap_sec_type && | ||
442 | (ieee->rtllib_ap_sec_type(ieee)&SEC_ALG_TKIP)) { | ||
443 | if (pHTInfo->IOTPeer == HT_IOT_PEER_RALINK){ | ||
444 | retValue = true; | ||
445 | } | ||
446 | } | ||
447 | #endif | ||
448 | return retValue; | ||
449 | } | ||
450 | |||
451 | u8 HTIOTActIsDisableEDCATurbo(struct rtllib_device* ieee, u8* PeerMacAddr) | ||
452 | { | ||
453 | return false; | ||
454 | } | ||
455 | |||
456 | |||
457 | bool HTIOTActIsEnableBETxOPLimit(struct rtllib_device* ieee) | ||
458 | { | ||
459 | bool retValue = false; | ||
460 | |||
461 | #if defined RTL8192SU | ||
462 | if (ieee->mode == IEEE_G) | ||
463 | retValue = true; | ||
464 | #elif defined RTL8192CE | ||
465 | if (ieee->mode == IEEE_G || | ||
466 | (ieee->rtllib_ap_sec_type(ieee)&(SEC_ALG_WEP|SEC_ALG_TKIP))) | ||
467 | retValue = true; | ||
468 | #endif | ||
469 | |||
470 | return retValue; | ||
471 | } | ||
472 | |||
473 | |||
474 | u8 HTIOTActIsMgntUseCCK6M(struct rtllib_device* ieee,struct rtllib_network *network) | ||
475 | { | ||
476 | u8 retValue = 0; | ||
477 | |||
478 | |||
479 | #if (defined RTL8192U || defined RTL8192E || defined RTL8190P) | ||
480 | { | ||
481 | if (ieee->pHTInfo->IOTPeer == HT_IOT_PEER_BROADCOM) | ||
482 | { | ||
483 | retValue = 1; | ||
484 | } | ||
485 | } | ||
486 | #endif | ||
487 | |||
488 | return retValue; | ||
489 | } | ||
490 | |||
491 | u8 | ||
492 | HTIOTActWAIOTBroadcom(struct rtllib_device* ieee) | ||
493 | { | ||
494 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
495 | u8 retValue = false; | ||
496 | u8 boundary=59; | ||
497 | |||
498 | pHTInfo->bWAIotBroadcom = false; | ||
499 | if (ieee->pHTInfo->IOTPeer == HT_IOT_PEER_BROADCOM) | ||
500 | { | ||
501 | if (ieee->current_network.bssht.bdBandWidth == HT_CHANNEL_WIDTH_20_40) | ||
502 | { | ||
503 | if (!(pHTInfo->bRegBW40MHz)) | ||
504 | { | ||
505 | if (ieee->current_network.mode != WIRELESS_MODE_B) | ||
506 | { | ||
507 | pHTInfo->bWAIotBroadcom = true; | ||
508 | |||
509 | if (ieee->b_customer_lenovo_id == true) | ||
510 | boundary = 30; | ||
511 | |||
512 | if ( ieee->current_network.RSSI >= boundary) | ||
513 | retValue = true; | ||
514 | } | ||
515 | }else{ | ||
516 | ; | ||
517 | } | ||
518 | } | ||
519 | } | ||
520 | return retValue; | ||
521 | } | ||
522 | |||
523 | u8 HTIOTActIsForcedCTS2Self(struct rtllib_device *ieee, struct rtllib_network *network) | ||
524 | { | ||
525 | u8 retValue = 0; | ||
526 | #if (defined RTL8192SE || defined RTL8192SU || defined RTL8192CE) | ||
527 | if ((ieee->pHTInfo->IOTPeer == HT_IOT_PEER_MARVELL) ||(ieee->pHTInfo->IOTPeer == HT_IOT_PEER_ATHEROS) ) | ||
528 | #else | ||
529 | if (ieee->pHTInfo->IOTPeer == HT_IOT_PEER_MARVELL) | ||
530 | #endif | ||
531 | { | ||
532 | retValue = 1; | ||
533 | } | ||
534 | |||
535 | return retValue; | ||
536 | } | ||
537 | |||
538 | u8 HTIOTActIsForcedRTSCTS(struct rtllib_device *ieee, struct rtllib_network *network) | ||
539 | { | ||
540 | u8 retValue = 0; | ||
541 | #if defined(RTL8192SE) || defined(RTL8192SU) | ||
542 | if (ieee->pHTInfo->bCurrentHTSupport) | ||
543 | { | ||
544 | if ((ieee->pHTInfo->IOTPeer != HT_IOT_PEER_REALTEK)&& | ||
545 | (ieee->pHTInfo->IOTPeer != HT_IOT_PEER_REALTEK_92SE)) | ||
546 | { | ||
547 | if ((ieee->pHTInfo->IOTAction & HT_IOT_ACT_TX_NO_AGGREGATION) == 0) | ||
548 | retValue = 1; | ||
549 | } | ||
550 | } | ||
551 | #endif | ||
552 | return retValue; | ||
553 | } | ||
554 | |||
555 | u8 | ||
556 | HTIOTActIsForcedAMSDU8K(struct rtllib_device *ieee, struct rtllib_network *network) | ||
557 | { | ||
558 | u8 retValue = 0; | ||
559 | |||
560 | return retValue; | ||
561 | } | ||
562 | |||
563 | u8 HTIOTActIsCCDFsync(struct rtllib_device *ieee) | ||
564 | { | ||
565 | u8 retValue = 0; | ||
566 | #if (defined RTL8190P || defined RTL8192U || defined RTL8192SU) | ||
567 | if (ieee->pHTInfo->IOTPeer == HT_IOT_PEER_BROADCOM) | ||
568 | { | ||
569 | retValue = 1; | ||
570 | } | ||
571 | #endif | ||
572 | return retValue; | ||
573 | } | ||
574 | |||
575 | u8 | ||
576 | HTIOCActRejcectADDBARequest(struct rtllib_network *network) | ||
577 | { | ||
578 | u8 retValue = 0; | ||
579 | #if (defined RTL8192SE || defined RTL8192SU || defined RTL8192CE) | ||
580 | { | ||
581 | |||
582 | |||
583 | } | ||
584 | #endif | ||
585 | |||
586 | return retValue; | ||
587 | |||
588 | } | ||
589 | |||
590 | u8 | ||
591 | HTIOTActIsEDCABiasRx(struct rtllib_device* ieee,struct rtllib_network *network) | ||
592 | { | ||
593 | u8 retValue = 0; | ||
594 | #ifdef RTL8192SU | ||
595 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
596 | { | ||
597 | if (pHTInfo->IOTPeer==HT_IOT_PEER_ATHEROS || | ||
598 | pHTInfo->IOTPeer==HT_IOT_PEER_BROADCOM || | ||
599 | pHTInfo->IOTPeer==HT_IOT_PEER_RALINK) | ||
600 | return 1; | ||
601 | |||
602 | } | ||
603 | #elif defined RTL8192CE | ||
604 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
605 | { | ||
606 | if (pHTInfo->IOTPeer==HT_IOT_PEER_ATHEROS || | ||
607 | pHTInfo->IOTPeer==HT_IOT_PEER_RALINK) | ||
608 | return 1; | ||
609 | |||
610 | } | ||
611 | #elif defined RTL8192SE | ||
612 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
613 | { | ||
614 | if (ieee->rtllib_ap_sec_type != NULL) | ||
615 | if (ieee->rtllib_ap_sec_type(ieee) == SEC_ALG_CCMP) | ||
616 | if (pHTInfo->IOTPeer==HT_IOT_PEER_RALINK){ | ||
617 | return 1; | ||
618 | } | ||
619 | |||
620 | } | ||
621 | #endif | ||
622 | return retValue; | ||
623 | } | ||
624 | |||
625 | u8 | ||
626 | HTIOTActDisableShortGI(struct rtllib_device* ieee,struct rtllib_network *network) | ||
627 | { | ||
628 | u8 retValue = 0; | ||
629 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
630 | |||
631 | if (pHTInfo->IOTPeer==HT_IOT_PEER_RALINK) | ||
632 | { | ||
633 | retValue = 1; | ||
634 | } | ||
635 | |||
636 | return retValue; | ||
637 | } | ||
638 | |||
639 | u8 | ||
640 | HTIOTActDisableHighPower(struct rtllib_device* ieee,struct rtllib_network *network) | ||
641 | { | ||
642 | u8 retValue = 0; | ||
643 | #if (defined RTL8192SE || defined RTL8192SU || defined RTL8192CE) | ||
644 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
645 | #endif | ||
646 | |||
647 | #ifdef RTL8192SU | ||
648 | if (pHTInfo->IOTPeer==HT_IOT_PEER_RALINK || | ||
649 | pHTInfo->IOTPeer==HT_IOT_PEER_REALTEK || | ||
650 | pHTInfo->IOTPeer==HT_IOT_PEER_REALTEK_92SE) | ||
651 | { | ||
652 | retValue = 1; | ||
653 | } | ||
654 | #elif defined RTL8192SE || defined RTL8192CE | ||
655 | if (pHTInfo->IOTPeer==HT_IOT_PEER_RALINK || | ||
656 | pHTInfo->IOTPeer==HT_IOT_PEER_REALTEK ) | ||
657 | { | ||
658 | retValue = 1; | ||
659 | } | ||
660 | #endif | ||
661 | return retValue; | ||
662 | } | ||
663 | |||
664 | void | ||
665 | HTIOTActDetermineRaFunc(struct rtllib_device* ieee, bool bPeerRx2ss) | ||
666 | { | ||
667 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
668 | pHTInfo->IOTRaFunc &= HT_IOT_RAFUNC_DISABLE_ALL; | ||
669 | |||
670 | if (pHTInfo->IOTPeer == HT_IOT_PEER_RALINK && !bPeerRx2ss) | ||
671 | pHTInfo->IOTRaFunc |= HT_IOT_RAFUNC_PEER_1R; | ||
672 | |||
673 | if (pHTInfo->IOTAction & HT_IOT_ACT_AMSDU_ENABLE) | ||
674 | pHTInfo->IOTRaFunc |= HT_IOT_RAFUNC_TX_AMSDU; | ||
675 | |||
676 | } | ||
677 | |||
678 | |||
679 | u8 | ||
680 | HTIOTActIsDisableTx40MHz(struct rtllib_device* ieee,struct rtllib_network *network) | ||
681 | { | ||
682 | u8 retValue = 0; | ||
683 | |||
684 | #if (defined RTL8192SU || defined RTL8192SE || defined RTL8192CE) | ||
685 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
686 | if ( (KEY_TYPE_WEP104 == ieee->pairwise_key_type) || | ||
687 | (KEY_TYPE_WEP40 == ieee->pairwise_key_type) || | ||
688 | (KEY_TYPE_WEP104 == ieee->group_key_type) || | ||
689 | (KEY_TYPE_WEP40 == ieee->group_key_type) || | ||
690 | (KEY_TYPE_TKIP == ieee->pairwise_key_type) ) | ||
691 | { | ||
692 | if ((pHTInfo->IOTPeer==HT_IOT_PEER_REALTEK) && (network->bssht.bdSupportHT)) | ||
693 | retValue = 1; | ||
694 | } | ||
695 | #endif | ||
696 | |||
697 | return retValue; | ||
698 | } | ||
699 | |||
700 | u8 | ||
701 | HTIOTActIsTxNoAggregation(struct rtllib_device* ieee,struct rtllib_network *network) | ||
702 | { | ||
703 | u8 retValue = 0; | ||
704 | |||
705 | #if (defined RTL8192SU || defined RTL8192SE || defined RTL8192CE) | ||
706 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
707 | if ( (KEY_TYPE_WEP104 == ieee->pairwise_key_type) || | ||
708 | (KEY_TYPE_WEP40 == ieee->pairwise_key_type) || | ||
709 | (KEY_TYPE_WEP104 == ieee->group_key_type) || | ||
710 | (KEY_TYPE_WEP40 == ieee->group_key_type) || | ||
711 | (KEY_TYPE_TKIP == ieee->pairwise_key_type) ) | ||
712 | { | ||
713 | if (pHTInfo->IOTPeer==HT_IOT_PEER_REALTEK) | ||
714 | retValue = 1; | ||
715 | } | ||
716 | #endif | ||
717 | |||
718 | return retValue; | ||
719 | } | ||
720 | |||
721 | |||
722 | u8 | ||
723 | HTIOTActIsDisableTx2SS(struct rtllib_device* ieee,struct rtllib_network *network) | ||
724 | { | ||
725 | u8 retValue = 0; | ||
726 | |||
727 | #if (defined RTL8192SU || defined RTL8192SE || defined RTL8192CE) | ||
728 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
729 | if ( (KEY_TYPE_WEP104 == ieee->pairwise_key_type) || | ||
730 | (KEY_TYPE_WEP40 == ieee->pairwise_key_type) || | ||
731 | (KEY_TYPE_WEP104 == ieee->group_key_type) || | ||
732 | (KEY_TYPE_WEP40 == ieee->group_key_type) || | ||
733 | (KEY_TYPE_TKIP == ieee->pairwise_key_type) ) | ||
734 | { | ||
735 | if ((pHTInfo->IOTPeer==HT_IOT_PEER_REALTEK) && (network->bssht.bdSupportHT)) | ||
736 | retValue = 1; | ||
737 | } | ||
738 | #endif | ||
739 | |||
740 | return retValue; | ||
741 | } | ||
742 | |||
743 | |||
744 | bool HTIOCActIsDisableCckRate(struct rtllib_device* ieee,struct rtllib_network *network) | ||
745 | { | ||
746 | bool retValue = false; | ||
747 | #if defined(RTL8192SU) | ||
748 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
749 | if (pHTInfo->IOTPeer == HT_IOT_PEER_BROADCOM) | ||
750 | { | ||
751 | if ((memcmp(network->bssid, NETGEAR_BROADCOM, 3)==0) | ||
752 | && (network->bssht.bdBandWidth == HT_CHANNEL_WIDTH_20_40)) | ||
753 | return true; | ||
754 | } | ||
755 | #endif | ||
756 | return retValue; | ||
757 | } | ||
758 | |||
759 | bool HTIOCActAllowPeerAggOnePacket(struct rtllib_device* ieee,struct rtllib_network *network) | ||
760 | { | ||
761 | bool retValue = false; | ||
762 | #if defined(RTL8192SE) || defined(RTL8192SU) | ||
763 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
764 | { | ||
765 | if (ieee->VersionID<2) | ||
766 | if (pHTInfo->IOTPeer == HT_IOT_PEER_MARVELL) | ||
767 | return true; | ||
768 | |||
769 | } | ||
770 | #endif | ||
771 | return retValue; | ||
772 | } | ||
773 | |||
774 | bool | ||
775 | HTIOTActIsNullDataPowerSaving(struct rtllib_device* ieee,struct rtllib_network *network) | ||
776 | { | ||
777 | bool retValue = false; | ||
778 | #if defined(RTL8192SE) || defined(RTL8192SU) | ||
779 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
780 | { | ||
781 | if (pHTInfo->IOTPeer == HT_IOT_PEER_BROADCOM) | ||
782 | return true; | ||
783 | |||
784 | } | ||
785 | #endif | ||
786 | return retValue; | ||
787 | } | ||
788 | |||
789 | void HTResetIOTSetting( | ||
790 | PRT_HIGH_THROUGHPUT pHTInfo | ||
791 | ) | ||
792 | { | ||
793 | pHTInfo->IOTAction = 0; | ||
794 | pHTInfo->IOTPeer = HT_IOT_PEER_UNKNOWN; | ||
795 | pHTInfo->IOTRaFunc = 0; | ||
796 | } | ||
797 | |||
798 | |||
799 | void HTConstructCapabilityElement(struct rtllib_device* ieee, u8* posHTCap, u8* len, u8 IsEncrypt, bool bAssoc) | ||
800 | { | ||
801 | PRT_HIGH_THROUGHPUT pHT = ieee->pHTInfo; | ||
802 | PHT_CAPABILITY_ELE pCapELE = NULL; | ||
803 | |||
804 | if ((posHTCap == NULL) || (pHT == NULL)) | ||
805 | { | ||
806 | RTLLIB_DEBUG(RTLLIB_DL_ERR, "posHTCap or pHTInfo can't be null in HTConstructCapabilityElement()\n"); | ||
807 | return; | ||
808 | } | ||
809 | memset(posHTCap, 0, *len); | ||
810 | |||
811 | if ((bAssoc) && (pHT->ePeerHTSpecVer == HT_SPEC_VER_EWC)) | ||
812 | { | ||
813 | u8 EWC11NHTCap[] = {0x00, 0x90, 0x4c, 0x33}; | ||
814 | memcpy(posHTCap, EWC11NHTCap, sizeof(EWC11NHTCap)); | ||
815 | pCapELE = (PHT_CAPABILITY_ELE)&(posHTCap[4]); | ||
816 | *len = 30 + 2; | ||
817 | }else | ||
818 | { | ||
819 | pCapELE = (PHT_CAPABILITY_ELE)posHTCap; | ||
820 | *len = 26 + 2; | ||
821 | } | ||
822 | |||
823 | pCapELE->AdvCoding = 0; | ||
824 | if (ieee->GetHalfNmodeSupportByAPsHandler(ieee->dev)) | ||
825 | pCapELE->ChlWidth = 0; | ||
826 | else | ||
827 | pCapELE->ChlWidth = (pHT->bRegBW40MHz?1:0); | ||
828 | |||
829 | pCapELE->MimoPwrSave = pHT->SelfMimoPs; | ||
830 | pCapELE->GreenField = 0; | ||
831 | pCapELE->ShortGI20Mhz = 1; | ||
832 | pCapELE->ShortGI40Mhz = 1; | ||
833 | |||
834 | pCapELE->TxSTBC = 1; | ||
835 | #if defined RTL8192SE || defined RTL8192CE | ||
836 | pCapELE->TxSTBC = 0; | ||
837 | #endif | ||
838 | pCapELE->RxSTBC = 0; | ||
839 | pCapELE->DelayBA = 0; | ||
840 | pCapELE->MaxAMSDUSize = (MAX_RECEIVE_BUFFER_SIZE>=7935)?1:0; | ||
841 | pCapELE->DssCCk = ((pHT->bRegBW40MHz)?(pHT->bRegSuppCCK?1:0):0); | ||
842 | pCapELE->PSMP = 0; | ||
843 | pCapELE->LSigTxopProtect = 0; | ||
844 | |||
845 | |||
846 | RTLLIB_DEBUG(RTLLIB_DL_HT, "TX HT cap/info ele BW=%d MaxAMSDUSize:%d DssCCk:%d\n", pCapELE->ChlWidth, pCapELE->MaxAMSDUSize, pCapELE->DssCCk); | ||
847 | |||
848 | if ( IsEncrypt) | ||
849 | { | ||
850 | pCapELE->MPDUDensity = 7; | ||
851 | pCapELE->MaxRxAMPDUFactor = 2; | ||
852 | } | ||
853 | else | ||
854 | { | ||
855 | pCapELE->MaxRxAMPDUFactor = 3; | ||
856 | pCapELE->MPDUDensity = 0; | ||
857 | } | ||
858 | |||
859 | memcpy(pCapELE->MCS, ieee->Regdot11HTOperationalRateSet, 16); | ||
860 | memset(&pCapELE->ExtHTCapInfo, 0, 2); | ||
861 | memset(pCapELE->TxBFCap, 0, 4); | ||
862 | |||
863 | pCapELE->ASCap = 0; | ||
864 | |||
865 | if (bAssoc) { | ||
866 | if (pHT->IOTAction & HT_IOT_ACT_DISABLE_MCS15) | ||
867 | pCapELE->MCS[1] &= 0x7f; | ||
868 | |||
869 | if (pHT->IOTAction & HT_IOT_ACT_DISABLE_MCS14) | ||
870 | pCapELE->MCS[1] &= 0xbf; | ||
871 | |||
872 | if (pHT->IOTAction & HT_IOT_ACT_DISABLE_ALL_2SS) | ||
873 | pCapELE->MCS[1] &= 0x00; | ||
874 | |||
875 | if (pHT->IOTAction & HT_IOT_ACT_DISABLE_RX_40MHZ_SHORT_GI) | ||
876 | pCapELE->ShortGI40Mhz = 0; | ||
877 | |||
878 | if (ieee->GetHalfNmodeSupportByAPsHandler(ieee->dev)) | ||
879 | { | ||
880 | pCapELE->ChlWidth = 0; | ||
881 | |||
882 | pCapELE->MCS[1] = 0; | ||
883 | } | ||
884 | } | ||
885 | |||
886 | |||
887 | |||
888 | |||
889 | |||
890 | return; | ||
891 | |||
892 | } | ||
893 | void HTConstructInfoElement(struct rtllib_device* ieee, u8* posHTInfo, u8* len, u8 IsEncrypt) | ||
894 | { | ||
895 | PRT_HIGH_THROUGHPUT pHT = ieee->pHTInfo; | ||
896 | PHT_INFORMATION_ELE pHTInfoEle = (PHT_INFORMATION_ELE)posHTInfo; | ||
897 | if ((posHTInfo == NULL) || (pHTInfoEle == NULL)) | ||
898 | { | ||
899 | RTLLIB_DEBUG(RTLLIB_DL_ERR, "posHTInfo or pHTInfoEle can't be null in HTConstructInfoElement()\n"); | ||
900 | return; | ||
901 | } | ||
902 | |||
903 | memset(posHTInfo, 0, *len); | ||
904 | if ( (ieee->iw_mode == IW_MODE_ADHOC) || (ieee->iw_mode == IW_MODE_MASTER)) | ||
905 | { | ||
906 | pHTInfoEle->ControlChl = ieee->current_network.channel; | ||
907 | pHTInfoEle->ExtChlOffset = ((pHT->bRegBW40MHz == false)?HT_EXTCHNL_OFFSET_NO_EXT: | ||
908 | (ieee->current_network.channel<=6)? | ||
909 | HT_EXTCHNL_OFFSET_UPPER:HT_EXTCHNL_OFFSET_LOWER); | ||
910 | pHTInfoEle->RecommemdedTxWidth = pHT->bRegBW40MHz; | ||
911 | pHTInfoEle->RIFS = 0; | ||
912 | pHTInfoEle->PSMPAccessOnly = 0; | ||
913 | pHTInfoEle->SrvIntGranularity = 0; | ||
914 | pHTInfoEle->OptMode = pHT->CurrentOpMode; | ||
915 | pHTInfoEle->NonGFDevPresent = 0; | ||
916 | pHTInfoEle->DualBeacon = 0; | ||
917 | pHTInfoEle->SecondaryBeacon = 0; | ||
918 | pHTInfoEle->LSigTxopProtectFull = 0; | ||
919 | pHTInfoEle->PcoActive = 0; | ||
920 | pHTInfoEle->PcoPhase = 0; | ||
921 | |||
922 | memset(pHTInfoEle->BasicMSC, 0, 16); | ||
923 | |||
924 | |||
925 | *len = 22 + 2; | ||
926 | |||
927 | } | ||
928 | else | ||
929 | { | ||
930 | *len = 0; | ||
931 | } | ||
932 | return; | ||
933 | } | ||
934 | |||
935 | void HTConstructRT2RTAggElement(struct rtllib_device* ieee, u8* posRT2RTAgg, u8* len) | ||
936 | { | ||
937 | if (posRT2RTAgg == NULL) { | ||
938 | RTLLIB_DEBUG(RTLLIB_DL_ERR, "posRT2RTAgg can't be null in HTConstructRT2RTAggElement()\n"); | ||
939 | return; | ||
940 | } | ||
941 | memset(posRT2RTAgg, 0, *len); | ||
942 | *posRT2RTAgg++ = 0x00; | ||
943 | *posRT2RTAgg++ = 0xe0; | ||
944 | *posRT2RTAgg++ = 0x4c; | ||
945 | *posRT2RTAgg++ = 0x02; | ||
946 | *posRT2RTAgg++ = 0x01; | ||
947 | |||
948 | #ifdef RTL8192CE | ||
949 | *posRT2RTAgg = 0x70; | ||
950 | #else | ||
951 | *posRT2RTAgg = 0x30; | ||
952 | #endif | ||
953 | |||
954 | if (ieee->bSupportRemoteWakeUp) { | ||
955 | *posRT2RTAgg |= RT_HT_CAP_USE_WOW; | ||
956 | } | ||
957 | |||
958 | *len = 6 + 2; | ||
959 | |||
960 | return; | ||
961 | |||
962 | #ifdef TODO | ||
963 | posRT2RTAgg->Length = 6; | ||
964 | #endif | ||
965 | |||
966 | |||
967 | |||
968 | |||
969 | } | ||
970 | |||
971 | u8 HT_PickMCSRate(struct rtllib_device* ieee, u8* pOperateMCS) | ||
972 | { | ||
973 | u8 i; | ||
974 | if (pOperateMCS == NULL) | ||
975 | { | ||
976 | RTLLIB_DEBUG(RTLLIB_DL_ERR, "pOperateMCS can't be null in HT_PickMCSRate()\n"); | ||
977 | return false; | ||
978 | } | ||
979 | |||
980 | switch (ieee->mode) { | ||
981 | case IEEE_A: | ||
982 | case IEEE_B: | ||
983 | case IEEE_G: | ||
984 | for (i=0;i<=15;i++) | ||
985 | pOperateMCS[i] = 0; | ||
986 | break; | ||
987 | case IEEE_N_24G: | ||
988 | case IEEE_N_5G: | ||
989 | pOperateMCS[0] &=RATE_ADPT_1SS_MASK; | ||
990 | pOperateMCS[1] &=RATE_ADPT_2SS_MASK; | ||
991 | pOperateMCS[3] &=RATE_ADPT_MCS32_MASK; | ||
992 | break; | ||
993 | default: | ||
994 | break; | ||
995 | |||
996 | } | ||
997 | |||
998 | return true; | ||
999 | } | ||
1000 | |||
1001 | u8 HTGetHighestMCSRate(struct rtllib_device* ieee, u8* pMCSRateSet, u8* pMCSFilter) | ||
1002 | { | ||
1003 | u8 i, j; | ||
1004 | u8 bitMap; | ||
1005 | u8 mcsRate = 0; | ||
1006 | u8 availableMcsRate[16]; | ||
1007 | if (pMCSRateSet == NULL || pMCSFilter == NULL) | ||
1008 | { | ||
1009 | RTLLIB_DEBUG(RTLLIB_DL_ERR, "pMCSRateSet or pMCSFilter can't be null in HTGetHighestMCSRate()\n"); | ||
1010 | return false; | ||
1011 | } | ||
1012 | for (i=0; i<16; i++) | ||
1013 | availableMcsRate[i] = pMCSRateSet[i] & pMCSFilter[i]; | ||
1014 | |||
1015 | for (i = 0; i < 16; i++) | ||
1016 | { | ||
1017 | if (availableMcsRate[i] != 0) | ||
1018 | break; | ||
1019 | } | ||
1020 | if (i == 16) | ||
1021 | return false; | ||
1022 | |||
1023 | for (i = 0; i < 16; i++) | ||
1024 | { | ||
1025 | if (availableMcsRate[i] != 0) | ||
1026 | { | ||
1027 | bitMap = availableMcsRate[i]; | ||
1028 | for (j = 0; j < 8; j++) | ||
1029 | { | ||
1030 | if ((bitMap%2) != 0) | ||
1031 | { | ||
1032 | if (HTMcsToDataRate(ieee, (8*i+j)) > HTMcsToDataRate(ieee, mcsRate)) | ||
1033 | mcsRate = (8*i+j); | ||
1034 | } | ||
1035 | bitMap = bitMap>>1; | ||
1036 | } | ||
1037 | } | ||
1038 | } | ||
1039 | return (mcsRate|0x80); | ||
1040 | } | ||
1041 | |||
1042 | u8 HTFilterMCSRate( struct rtllib_device* ieee, u8* pSupportMCS, u8* pOperateMCS) | ||
1043 | { | ||
1044 | |||
1045 | u8 i=0; | ||
1046 | |||
1047 | for (i=0;i<=15;i++){ | ||
1048 | pOperateMCS[i] = ieee->Regdot11TxHTOperationalRateSet[i]&pSupportMCS[i]; | ||
1049 | } | ||
1050 | |||
1051 | |||
1052 | |||
1053 | HT_PickMCSRate(ieee, pOperateMCS); | ||
1054 | |||
1055 | if (ieee->GetHalfNmodeSupportByAPsHandler(ieee->dev)) | ||
1056 | pOperateMCS[1] = 0; | ||
1057 | |||
1058 | for (i=2; i<=15; i++) | ||
1059 | pOperateMCS[i] = 0; | ||
1060 | |||
1061 | return true; | ||
1062 | } | ||
1063 | void HTSetConnectBwMode(struct rtllib_device* ieee, HT_CHANNEL_WIDTH Bandwidth, HT_EXTCHNL_OFFSET Offset); | ||
1064 | void HTOnAssocRsp(struct rtllib_device *ieee) | ||
1065 | { | ||
1066 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
1067 | PHT_CAPABILITY_ELE pPeerHTCap = NULL; | ||
1068 | PHT_INFORMATION_ELE pPeerHTInfo = NULL; | ||
1069 | u16 nMaxAMSDUSize = 0; | ||
1070 | u8* pMcsFilter = NULL; | ||
1071 | |||
1072 | static u8 EWC11NHTCap[] = {0x00, 0x90, 0x4c, 0x33}; | ||
1073 | static u8 EWC11NHTInfo[] = {0x00, 0x90, 0x4c, 0x34}; | ||
1074 | |||
1075 | if ( pHTInfo->bCurrentHTSupport == false ) | ||
1076 | { | ||
1077 | RTLLIB_DEBUG(RTLLIB_DL_ERR, "<=== HTOnAssocRsp(): HT_DISABLE\n"); | ||
1078 | return; | ||
1079 | } | ||
1080 | RTLLIB_DEBUG(RTLLIB_DL_HT, "===> HTOnAssocRsp_wq(): HT_ENABLE\n"); | ||
1081 | |||
1082 | if (!memcmp(pHTInfo->PeerHTCapBuf,EWC11NHTCap, sizeof(EWC11NHTCap))) | ||
1083 | pPeerHTCap = (PHT_CAPABILITY_ELE)(&pHTInfo->PeerHTCapBuf[4]); | ||
1084 | else | ||
1085 | pPeerHTCap = (PHT_CAPABILITY_ELE)(pHTInfo->PeerHTCapBuf); | ||
1086 | |||
1087 | if (!memcmp(pHTInfo->PeerHTInfoBuf, EWC11NHTInfo, sizeof(EWC11NHTInfo))) | ||
1088 | pPeerHTInfo = (PHT_INFORMATION_ELE)(&pHTInfo->PeerHTInfoBuf[4]); | ||
1089 | else | ||
1090 | pPeerHTInfo = (PHT_INFORMATION_ELE)(pHTInfo->PeerHTInfoBuf); | ||
1091 | |||
1092 | RTLLIB_DEBUG_DATA(RTLLIB_DL_DATA|RTLLIB_DL_HT, pPeerHTCap, sizeof(HT_CAPABILITY_ELE)); | ||
1093 | HTSetConnectBwMode(ieee, (HT_CHANNEL_WIDTH)(pPeerHTCap->ChlWidth), (HT_EXTCHNL_OFFSET)(pPeerHTInfo->ExtChlOffset)); | ||
1094 | pHTInfo->bCurTxBW40MHz = ((pPeerHTInfo->RecommemdedTxWidth == 1)?true:false); | ||
1095 | |||
1096 | pHTInfo->bCurShortGI20MHz= | ||
1097 | ((pHTInfo->bRegShortGI20MHz)?((pPeerHTCap->ShortGI20Mhz==1)?true:false):false); | ||
1098 | pHTInfo->bCurShortGI40MHz= | ||
1099 | ((pHTInfo->bRegShortGI40MHz)?((pPeerHTCap->ShortGI40Mhz==1)?true:false):false); | ||
1100 | |||
1101 | pHTInfo->bCurSuppCCK = | ||
1102 | ((pHTInfo->bRegSuppCCK)?((pPeerHTCap->DssCCk==1)?true:false):false); | ||
1103 | |||
1104 | |||
1105 | pHTInfo->bCurrent_AMSDU_Support = pHTInfo->bAMSDU_Support; | ||
1106 | |||
1107 | nMaxAMSDUSize = (pPeerHTCap->MaxAMSDUSize==0)?3839:7935; | ||
1108 | |||
1109 | if (pHTInfo->nAMSDU_MaxSize > nMaxAMSDUSize ) | ||
1110 | pHTInfo->nCurrent_AMSDU_MaxSize = nMaxAMSDUSize; | ||
1111 | else | ||
1112 | pHTInfo->nCurrent_AMSDU_MaxSize = pHTInfo->nAMSDU_MaxSize; | ||
1113 | |||
1114 | pHTInfo->bCurrentAMPDUEnable = pHTInfo->bAMPDUEnable; | ||
1115 | if (ieee->rtllib_ap_sec_type && | ||
1116 | (ieee->rtllib_ap_sec_type(ieee)&(SEC_ALG_WEP|SEC_ALG_TKIP))){ | ||
1117 | if ( (pHTInfo->IOTPeer== HT_IOT_PEER_ATHEROS) || | ||
1118 | (pHTInfo->IOTPeer == HT_IOT_PEER_UNKNOWN) ) | ||
1119 | pHTInfo->bCurrentAMPDUEnable = false; | ||
1120 | } | ||
1121 | |||
1122 | if (!pHTInfo->bRegRT2RTAggregation) | ||
1123 | { | ||
1124 | if (pHTInfo->AMPDU_Factor > pPeerHTCap->MaxRxAMPDUFactor) | ||
1125 | pHTInfo->CurrentAMPDUFactor = pPeerHTCap->MaxRxAMPDUFactor; | ||
1126 | else | ||
1127 | pHTInfo->CurrentAMPDUFactor = pHTInfo->AMPDU_Factor; | ||
1128 | |||
1129 | } else { | ||
1130 | if (ieee->current_network.bssht.bdRT2RTAggregation) | ||
1131 | { | ||
1132 | if ( ieee->pairwise_key_type != KEY_TYPE_NA) | ||
1133 | pHTInfo->CurrentAMPDUFactor = pPeerHTCap->MaxRxAMPDUFactor; | ||
1134 | else | ||
1135 | pHTInfo->CurrentAMPDUFactor = HT_AGG_SIZE_64K; | ||
1136 | }else | ||
1137 | { | ||
1138 | if (pPeerHTCap->MaxRxAMPDUFactor < HT_AGG_SIZE_32K) | ||
1139 | pHTInfo->CurrentAMPDUFactor = pPeerHTCap->MaxRxAMPDUFactor; | ||
1140 | else | ||
1141 | pHTInfo->CurrentAMPDUFactor = HT_AGG_SIZE_32K; | ||
1142 | } | ||
1143 | } | ||
1144 | if (pHTInfo->MPDU_Density > pPeerHTCap->MPDUDensity) | ||
1145 | pHTInfo->CurrentMPDUDensity = pHTInfo->MPDU_Density; | ||
1146 | else | ||
1147 | pHTInfo->CurrentMPDUDensity = pPeerHTCap->MPDUDensity; | ||
1148 | #if (defined RTL8192SE || defined RTL8192SU || defined RTL8192CE) | ||
1149 | if (ieee->SetHwRegHandler != NULL) { | ||
1150 | ieee->SetHwRegHandler( ieee->dev, HW_VAR_SHORTGI_DENSITY, (u8*)(&ieee->MaxMssDensity)); | ||
1151 | ieee->SetHwRegHandler(ieee->dev, HW_VAR_AMPDU_FACTOR, &pHTInfo->CurrentAMPDUFactor); | ||
1152 | ieee->SetHwRegHandler(ieee->dev, HW_VAR_AMPDU_MIN_SPACE, &pHTInfo->CurrentMPDUDensity); | ||
1153 | } | ||
1154 | #elif defined RTL8192CE | ||
1155 | if (ieee->SetHwRegHandler != NULL) { | ||
1156 | ieee->SetHwRegHandler(ieee->dev, HW_VAR_AMPDU_FACTOR, &pHTInfo->CurrentAMPDUFactor); | ||
1157 | ieee->SetHwRegHandler(ieee->dev, HW_VAR_AMPDU_MIN_SPACE, &pHTInfo->CurrentMPDUDensity); | ||
1158 | } | ||
1159 | #endif | ||
1160 | #ifndef RTL8190P | ||
1161 | if (pHTInfo->IOTAction & HT_IOT_ACT_TX_USE_AMSDU_8K) | ||
1162 | #else | ||
1163 | if ( 0 ) | ||
1164 | #endif | ||
1165 | { | ||
1166 | pHTInfo->bCurrentAMPDUEnable = false; | ||
1167 | pHTInfo->ForcedAMSDUMode = HT_AGG_FORCE_ENABLE; | ||
1168 | pHTInfo->ForcedAMSDUMaxSize = 7935; | ||
1169 | } | ||
1170 | pHTInfo->bCurRxReorderEnable = pHTInfo->bRegRxReorderEnable; | ||
1171 | |||
1172 | if (pPeerHTCap->MCS[0] == 0) | ||
1173 | pPeerHTCap->MCS[0] = 0xff; | ||
1174 | |||
1175 | HTIOTActDetermineRaFunc(ieee, ((pPeerHTCap->MCS[1])!=0)); | ||
1176 | |||
1177 | HTFilterMCSRate(ieee, pPeerHTCap->MCS, ieee->dot11HTOperationalRateSet); | ||
1178 | |||
1179 | pHTInfo->PeerMimoPs = pPeerHTCap->MimoPwrSave; | ||
1180 | if (pHTInfo->PeerMimoPs == MIMO_PS_STATIC) | ||
1181 | pMcsFilter = MCS_FILTER_1SS; | ||
1182 | else | ||
1183 | pMcsFilter = MCS_FILTER_ALL; | ||
1184 | ieee->HTHighestOperaRate = HTGetHighestMCSRate(ieee, ieee->dot11HTOperationalRateSet, pMcsFilter); | ||
1185 | ieee->HTCurrentOperaRate = ieee->HTHighestOperaRate; | ||
1186 | |||
1187 | pHTInfo->CurrentOpMode = pPeerHTInfo->OptMode; | ||
1188 | |||
1189 | } | ||
1190 | |||
1191 | void HTSetConnectBwModeCallback(struct rtllib_device* ieee); | ||
1192 | void HTInitializeHTInfo(struct rtllib_device* ieee) | ||
1193 | { | ||
1194 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
1195 | |||
1196 | RTLLIB_DEBUG(RTLLIB_DL_HT, "===========>%s()\n", __func__); | ||
1197 | pHTInfo->bCurrentHTSupport = false; | ||
1198 | |||
1199 | pHTInfo->bCurBW40MHz = false; | ||
1200 | pHTInfo->bCurTxBW40MHz = false; | ||
1201 | |||
1202 | pHTInfo->bCurShortGI20MHz = false; | ||
1203 | pHTInfo->bCurShortGI40MHz = false; | ||
1204 | pHTInfo->bForcedShortGI = false; | ||
1205 | |||
1206 | pHTInfo->bCurSuppCCK = true; | ||
1207 | |||
1208 | pHTInfo->bCurrent_AMSDU_Support = false; | ||
1209 | pHTInfo->nCurrent_AMSDU_MaxSize = pHTInfo->nAMSDU_MaxSize; | ||
1210 | pHTInfo->CurrentMPDUDensity = pHTInfo->MPDU_Density; | ||
1211 | pHTInfo->CurrentAMPDUFactor = pHTInfo->AMPDU_Factor; | ||
1212 | |||
1213 | memset((void*)(&(pHTInfo->SelfHTCap)), 0, sizeof(pHTInfo->SelfHTCap)); | ||
1214 | memset((void*)(&(pHTInfo->SelfHTInfo)), 0, sizeof(pHTInfo->SelfHTInfo)); | ||
1215 | memset((void*)(&(pHTInfo->PeerHTCapBuf)), 0, sizeof(pHTInfo->PeerHTCapBuf)); | ||
1216 | memset((void*)(&(pHTInfo->PeerHTInfoBuf)), 0, sizeof(pHTInfo->PeerHTInfoBuf)); | ||
1217 | |||
1218 | pHTInfo->bSwBwInProgress = false; | ||
1219 | pHTInfo->ChnlOp = CHNLOP_NONE; | ||
1220 | |||
1221 | pHTInfo->ePeerHTSpecVer = HT_SPEC_VER_IEEE; | ||
1222 | |||
1223 | pHTInfo->bCurrentRT2RTAggregation = false; | ||
1224 | pHTInfo->bCurrentRT2RTLongSlotTime = false; | ||
1225 | pHTInfo->RT2RT_HT_Mode = (RT_HT_CAPBILITY)0; | ||
1226 | |||
1227 | pHTInfo->IOTPeer = 0; | ||
1228 | pHTInfo->IOTAction = 0; | ||
1229 | pHTInfo->IOTRaFunc = 0; | ||
1230 | |||
1231 | { | ||
1232 | u8* RegHTSuppRateSets = &(ieee->RegHTSuppRateSet[0]); | ||
1233 | RegHTSuppRateSets[0] = 0xFF; | ||
1234 | RegHTSuppRateSets[1] = 0xFF; | ||
1235 | RegHTSuppRateSets[4] = 0x01; | ||
1236 | } | ||
1237 | } | ||
1238 | void HTInitializeBssDesc(PBSS_HT pBssHT) | ||
1239 | { | ||
1240 | |||
1241 | pBssHT->bdSupportHT = false; | ||
1242 | memset(pBssHT->bdHTCapBuf, 0, sizeof(pBssHT->bdHTCapBuf)); | ||
1243 | pBssHT->bdHTCapLen = 0; | ||
1244 | memset(pBssHT->bdHTInfoBuf, 0, sizeof(pBssHT->bdHTInfoBuf)); | ||
1245 | pBssHT->bdHTInfoLen = 0; | ||
1246 | |||
1247 | pBssHT->bdHTSpecVer= HT_SPEC_VER_IEEE; | ||
1248 | |||
1249 | pBssHT->bdRT2RTAggregation = false; | ||
1250 | pBssHT->bdRT2RTLongSlotTime = false; | ||
1251 | pBssHT->RT2RT_HT_Mode = (RT_HT_CAPBILITY)0; | ||
1252 | } | ||
1253 | |||
1254 | void HTResetSelfAndSavePeerSetting(struct rtllib_device* ieee, struct rtllib_network * pNetwork) | ||
1255 | { | ||
1256 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
1257 | u8 bIOTAction = 0; | ||
1258 | |||
1259 | RTLLIB_DEBUG(RTLLIB_DL_HT, "==============>%s()\n", __func__); | ||
1260 | /*unmark bEnableHT flag here is the same reason why unmarked in function rtllib_softmac_new_net. WB 2008.09.10*/ | ||
1261 | if (pNetwork->bssht.bdSupportHT) | ||
1262 | { | ||
1263 | pHTInfo->bCurrentHTSupport = true; | ||
1264 | pHTInfo->ePeerHTSpecVer = pNetwork->bssht.bdHTSpecVer; | ||
1265 | |||
1266 | if (pNetwork->bssht.bdHTCapLen > 0 && pNetwork->bssht.bdHTCapLen <= sizeof(pHTInfo->PeerHTCapBuf)) | ||
1267 | memcpy(pHTInfo->PeerHTCapBuf, pNetwork->bssht.bdHTCapBuf, pNetwork->bssht.bdHTCapLen); | ||
1268 | |||
1269 | if (pNetwork->bssht.bdHTInfoLen > 0 && pNetwork->bssht.bdHTInfoLen <= sizeof(pHTInfo->PeerHTInfoBuf)) | ||
1270 | memcpy(pHTInfo->PeerHTInfoBuf, pNetwork->bssht.bdHTInfoBuf, pNetwork->bssht.bdHTInfoLen); | ||
1271 | |||
1272 | if (pHTInfo->bRegRT2RTAggregation) | ||
1273 | { | ||
1274 | pHTInfo->bCurrentRT2RTAggregation = pNetwork->bssht.bdRT2RTAggregation; | ||
1275 | pHTInfo->bCurrentRT2RTLongSlotTime = pNetwork->bssht.bdRT2RTLongSlotTime; | ||
1276 | pHTInfo->RT2RT_HT_Mode = pNetwork->bssht.RT2RT_HT_Mode; | ||
1277 | } | ||
1278 | else | ||
1279 | { | ||
1280 | pHTInfo->bCurrentRT2RTAggregation = false; | ||
1281 | pHTInfo->bCurrentRT2RTLongSlotTime = false; | ||
1282 | pHTInfo->RT2RT_HT_Mode = (RT_HT_CAPBILITY)0; | ||
1283 | } | ||
1284 | |||
1285 | HTIOTPeerDetermine(ieee); | ||
1286 | |||
1287 | pHTInfo->IOTAction = 0; | ||
1288 | bIOTAction = HTIOTActIsDisableMCS14(ieee, pNetwork->bssid); | ||
1289 | if (bIOTAction) | ||
1290 | pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_MCS14; | ||
1291 | |||
1292 | bIOTAction = HTIOTActIsDisableMCS15(ieee); | ||
1293 | if (bIOTAction) | ||
1294 | pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_MCS15; | ||
1295 | |||
1296 | bIOTAction = HTIOTActIsDisableMCSTwoSpatialStream(ieee); | ||
1297 | if (bIOTAction) | ||
1298 | pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_ALL_2SS; | ||
1299 | |||
1300 | |||
1301 | bIOTAction = HTIOTActIsDisableEDCATurbo(ieee, pNetwork->bssid); | ||
1302 | if (bIOTAction) | ||
1303 | pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_EDCA_TURBO; | ||
1304 | |||
1305 | #if defined(RTL8190P) || defined(RTL8192E) || defined(RTL8192U) | ||
1306 | bIOTAction = HTIOTActIsMgntUseCCK6M(ieee,pNetwork); | ||
1307 | if (bIOTAction) | ||
1308 | pHTInfo->IOTAction |= HT_IOT_ACT_MGNT_USE_CCK_6M; | ||
1309 | #elif defined(RTL8192SE) || defined(RTL8192SU) || defined RTL8192CE | ||
1310 | bIOTAction = HTIOTActWAIOTBroadcom(ieee); | ||
1311 | if (bIOTAction) | ||
1312 | { | ||
1313 | pHTInfo->IOTAction |= HT_IOT_ACT_WA_IOT_Broadcom; | ||
1314 | } | ||
1315 | #endif | ||
1316 | bIOTAction = HTIOTActIsCCDFsync(ieee); | ||
1317 | if (bIOTAction) | ||
1318 | pHTInfo->IOTAction |= HT_IOT_ACT_CDD_FSYNC; | ||
1319 | #if defined(RTL8192SU) || defined(RTL8192SE) || defined RTL8192CE | ||
1320 | bIOTAction = HTIOTActIsForcedCTS2Self(ieee,pNetwork); | ||
1321 | if (bIOTAction) | ||
1322 | pHTInfo->IOTAction |= HT_IOT_ACT_FORCED_CTS2SELF; | ||
1323 | |||
1324 | |||
1325 | bIOTAction = HTIOTActIsEnableBETxOPLimit(ieee); | ||
1326 | if (bIOTAction) | ||
1327 | pHTInfo->IOTAction |= HT_IOT_ACT_FORCED_ENABLE_BE_TXOP; | ||
1328 | |||
1329 | #if defined(RTL8192SU) | ||
1330 | bIOTAction = HTIOCActRejcectADDBARequest(pNetwork); | ||
1331 | if (bIOTAction) | ||
1332 | pHTInfo->IOTAction |= HT_IOT_ACT_REJECT_ADDBA_REQ; | ||
1333 | #endif | ||
1334 | |||
1335 | bIOTAction = HTIOCActAllowPeerAggOnePacket(ieee, pNetwork); | ||
1336 | if (bIOTAction) | ||
1337 | pHTInfo->IOTAction |= HT_IOT_ACT_ALLOW_PEER_AGG_ONE_PKT; | ||
1338 | |||
1339 | bIOTAction = HTIOTActIsEDCABiasRx(ieee, pNetwork); | ||
1340 | if (bIOTAction) | ||
1341 | pHTInfo->IOTAction |= HT_IOT_ACT_EDCA_BIAS_ON_RX; | ||
1342 | |||
1343 | #if defined(RTL8192SU) | ||
1344 | bIOTAction = HTIOCActIsDisableCckRate(ieee, pNetwork); | ||
1345 | if (bIOTAction) | ||
1346 | pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_CCK_RATE; | ||
1347 | #endif | ||
1348 | bIOTAction = HTIOTActDisableShortGI(ieee, pNetwork); | ||
1349 | if (bIOTAction) | ||
1350 | pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_SHORT_GI; | ||
1351 | |||
1352 | bIOTAction = HTIOTActDisableHighPower(ieee, pNetwork); | ||
1353 | if (bIOTAction) | ||
1354 | pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_HIGH_POWER; | ||
1355 | |||
1356 | |||
1357 | bIOTAction = HTIOTActIsForcedAMSDU8K(ieee, pNetwork); | ||
1358 | if (bIOTAction) | ||
1359 | pHTInfo->IOTAction |= HT_IOT_ACT_TX_USE_AMSDU_8K; | ||
1360 | |||
1361 | #if defined(RTL8192SU) | ||
1362 | bIOTAction = HTIOTActIsTxNoAggregation(ieee, pNetwork); | ||
1363 | if (bIOTAction) | ||
1364 | pHTInfo->IOTAction |= HT_IOT_ACT_TX_NO_AGGREGATION; | ||
1365 | |||
1366 | bIOTAction = HTIOTActIsDisableTx40MHz(ieee, pNetwork); | ||
1367 | if (bIOTAction) | ||
1368 | pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_TX_40_MHZ; | ||
1369 | |||
1370 | bIOTAction = HTIOTActIsDisableTx2SS(ieee, pNetwork); | ||
1371 | if (bIOTAction) | ||
1372 | pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_TX_2SS; | ||
1373 | #endif | ||
1374 | |||
1375 | bIOTAction = HTIOTActIsForcedRTSCTS(ieee, pNetwork); | ||
1376 | if (bIOTAction) | ||
1377 | pHTInfo->IOTAction |= HT_IOT_ACT_FORCED_RTS; | ||
1378 | |||
1379 | bIOTAction = HTIOTActIsNullDataPowerSaving(ieee, pNetwork); | ||
1380 | if (bIOTAction) | ||
1381 | pHTInfo->IOTAction |= HT_IOT_ACT_NULL_DATA_POWER_SAVING; | ||
1382 | #endif | ||
1383 | |||
1384 | } else { | ||
1385 | pHTInfo->bCurrentHTSupport = false; | ||
1386 | pHTInfo->bCurrentRT2RTAggregation = false; | ||
1387 | pHTInfo->bCurrentRT2RTLongSlotTime = false; | ||
1388 | pHTInfo->RT2RT_HT_Mode = (RT_HT_CAPBILITY)0; | ||
1389 | |||
1390 | pHTInfo->IOTAction = 0; | ||
1391 | pHTInfo->IOTRaFunc = 0; | ||
1392 | } | ||
1393 | |||
1394 | } | ||
1395 | |||
1396 | void HTUpdateSelfAndPeerSetting(struct rtllib_device* ieee, struct rtllib_network * pNetwork) | ||
1397 | { | ||
1398 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
1399 | PHT_INFORMATION_ELE pPeerHTInfo = (PHT_INFORMATION_ELE)pNetwork->bssht.bdHTInfoBuf; | ||
1400 | |||
1401 | if (pHTInfo->bCurrentHTSupport) | ||
1402 | { | ||
1403 | if (pNetwork->bssht.bdHTInfoLen != 0) | ||
1404 | pHTInfo->CurrentOpMode = pPeerHTInfo->OptMode; | ||
1405 | |||
1406 | } | ||
1407 | } | ||
1408 | |||
1409 | void HTUseDefaultSetting(struct rtllib_device* ieee) | ||
1410 | { | ||
1411 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
1412 | |||
1413 | if (pHTInfo->bEnableHT) | ||
1414 | { | ||
1415 | pHTInfo->bCurrentHTSupport = true; | ||
1416 | pHTInfo->bCurSuppCCK = pHTInfo->bRegSuppCCK; | ||
1417 | |||
1418 | pHTInfo->bCurBW40MHz = pHTInfo->bRegBW40MHz; | ||
1419 | pHTInfo->bCurShortGI20MHz= pHTInfo->bRegShortGI20MHz; | ||
1420 | |||
1421 | pHTInfo->bCurShortGI40MHz= pHTInfo->bRegShortGI40MHz; | ||
1422 | |||
1423 | if (ieee->iw_mode == IW_MODE_ADHOC) | ||
1424 | { | ||
1425 | ieee->current_network.qos_data.active = ieee->current_network.qos_data.supported; | ||
1426 | } | ||
1427 | pHTInfo->bCurrent_AMSDU_Support = pHTInfo->bAMSDU_Support; | ||
1428 | pHTInfo->nCurrent_AMSDU_MaxSize = pHTInfo->nAMSDU_MaxSize; | ||
1429 | |||
1430 | pHTInfo->bCurrentAMPDUEnable = pHTInfo->bAMPDUEnable; | ||
1431 | pHTInfo->CurrentAMPDUFactor = pHTInfo->AMPDU_Factor; | ||
1432 | |||
1433 | pHTInfo->CurrentMPDUDensity = pHTInfo->CurrentMPDUDensity; | ||
1434 | |||
1435 | |||
1436 | HTFilterMCSRate(ieee, ieee->Regdot11TxHTOperationalRateSet, ieee->dot11HTOperationalRateSet); | ||
1437 | #ifdef TODO | ||
1438 | Adapter->HalFunc.InitHalRATRTableHandler( Adapter, &pMgntInfo->dot11OperationalRateSet, pMgntInfo->dot11HTOperationalRateSet); | ||
1439 | #endif | ||
1440 | ieee->HTHighestOperaRate = HTGetHighestMCSRate(ieee, ieee->dot11HTOperationalRateSet, MCS_FILTER_ALL); | ||
1441 | ieee->HTCurrentOperaRate = ieee->HTHighestOperaRate; | ||
1442 | |||
1443 | #if (defined RTL8192SE || defined RTL8192SU || defined RTL8192CE) | ||
1444 | if (ieee->SetHwRegHandler != NULL) { | ||
1445 | ieee->SetHwRegHandler( ieee->dev, HW_VAR_SHORTGI_DENSITY, (u8*)(&ieee->MaxMssDensity)); | ||
1446 | ieee->SetHwRegHandler(ieee->dev, HW_VAR_AMPDU_FACTOR, &pHTInfo->CurrentAMPDUFactor); | ||
1447 | ieee->SetHwRegHandler(ieee->dev, HW_VAR_AMPDU_MIN_SPACE, &pHTInfo->CurrentMPDUDensity); | ||
1448 | } | ||
1449 | #endif | ||
1450 | |||
1451 | } | ||
1452 | else | ||
1453 | { | ||
1454 | pHTInfo->bCurrentHTSupport = false; | ||
1455 | } | ||
1456 | return; | ||
1457 | } | ||
1458 | u8 HTCCheck(struct rtllib_device* ieee, u8* pFrame) | ||
1459 | { | ||
1460 | if (ieee->pHTInfo->bCurrentHTSupport) | ||
1461 | { | ||
1462 | if ( (IsQoSDataFrame(pFrame) && Frame_Order(pFrame)) == 1) | ||
1463 | { | ||
1464 | RTLLIB_DEBUG(RTLLIB_DL_HT, "HT CONTROL FILED EXIST!!\n"); | ||
1465 | return true; | ||
1466 | } | ||
1467 | } | ||
1468 | return false; | ||
1469 | } | ||
1470 | |||
1471 | void HTSetConnectBwMode(struct rtllib_device* ieee, HT_CHANNEL_WIDTH Bandwidth, HT_EXTCHNL_OFFSET Offset) | ||
1472 | { | ||
1473 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
1474 | |||
1475 | if (pHTInfo->bRegBW40MHz == false) | ||
1476 | return; | ||
1477 | |||
1478 | if (ieee->GetHalfNmodeSupportByAPsHandler(ieee->dev)) | ||
1479 | Bandwidth=HT_CHANNEL_WIDTH_20; | ||
1480 | |||
1481 | |||
1482 | if (pHTInfo->bSwBwInProgress) { | ||
1483 | printk("%s: bSwBwInProgress!!\n", __func__); | ||
1484 | return; | ||
1485 | } | ||
1486 | if (Bandwidth==HT_CHANNEL_WIDTH_20_40) | ||
1487 | { | ||
1488 | if (ieee->current_network.channel<2 && Offset==HT_EXTCHNL_OFFSET_LOWER) | ||
1489 | Offset = HT_EXTCHNL_OFFSET_NO_EXT; | ||
1490 | if (Offset==HT_EXTCHNL_OFFSET_UPPER || Offset==HT_EXTCHNL_OFFSET_LOWER) { | ||
1491 | pHTInfo->bCurBW40MHz = true; | ||
1492 | pHTInfo->CurSTAExtChnlOffset = Offset; | ||
1493 | } else { | ||
1494 | pHTInfo->bCurBW40MHz = false; | ||
1495 | pHTInfo->CurSTAExtChnlOffset = HT_EXTCHNL_OFFSET_NO_EXT; | ||
1496 | } | ||
1497 | } else { | ||
1498 | pHTInfo->bCurBW40MHz = false; | ||
1499 | pHTInfo->CurSTAExtChnlOffset = HT_EXTCHNL_OFFSET_NO_EXT; | ||
1500 | } | ||
1501 | |||
1502 | printk("%s():pHTInfo->bCurBW40MHz:%x\n", __func__, pHTInfo->bCurBW40MHz); | ||
1503 | |||
1504 | pHTInfo->bSwBwInProgress = true; | ||
1505 | |||
1506 | HTSetConnectBwModeCallback(ieee); | ||
1507 | |||
1508 | } | ||
1509 | |||
1510 | void HTSetConnectBwModeCallback(struct rtllib_device* ieee) | ||
1511 | { | ||
1512 | PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo; | ||
1513 | |||
1514 | RTLLIB_DEBUG(RTLLIB_DL_HT, "======>%s()\n", __func__); | ||
1515 | if (pHTInfo->bCurBW40MHz) | ||
1516 | { | ||
1517 | if (pHTInfo->CurSTAExtChnlOffset==HT_EXTCHNL_OFFSET_UPPER) | ||
1518 | ieee->set_chan(ieee->dev, ieee->current_network.channel+2); | ||
1519 | else if (pHTInfo->CurSTAExtChnlOffset==HT_EXTCHNL_OFFSET_LOWER) | ||
1520 | ieee->set_chan(ieee->dev, ieee->current_network.channel-2); | ||
1521 | else | ||
1522 | ieee->set_chan(ieee->dev, ieee->current_network.channel); | ||
1523 | |||
1524 | ieee->SetBWModeHandler(ieee->dev, HT_CHANNEL_WIDTH_20_40, pHTInfo->CurSTAExtChnlOffset); | ||
1525 | } else { | ||
1526 | ieee->set_chan(ieee->dev, ieee->current_network.channel); | ||
1527 | ieee->SetBWModeHandler(ieee->dev, HT_CHANNEL_WIDTH_20, HT_EXTCHNL_OFFSET_NO_EXT); | ||
1528 | } | ||
1529 | |||
1530 | pHTInfo->bSwBwInProgress = false; | ||
1531 | } | ||