aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorMateusz Kulikowski <mateusz.kulikowski@gmail.com>2015-03-31 18:24:26 -0400
committerGreg Kroah-Hartman <gregkh@linuxfoundation.org>2015-04-03 09:29:29 -0400
commit285b7c00e06b4fdd6e9ac63b9b8082508340f1ab (patch)
tree55f437e175ad2677f0553f98be62f4d7d96146c2
parent28eb1f3b640f793371a7cac599f3ac0f89f63b54 (diff)
staging: rtl8192e: Fix UNNECESSARY_ELSE warning
Fix checkpatch warnings 'else is not generally useful after a break or return' Signed-off-by: Mateusz Kulikowski <mateusz.kulikowski@gmail.com> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Diffstat
-rw-r--r--drivers/staging/rtl8192e/rtl8192e/r8192E_dev.c72
-rw-r--r--drivers/staging/rtl8192e/rtl8192e/r8192E_phy.c10
-rw-r--r--drivers/staging/rtl8192e/rtl8192e/rtl_cam.c7
-rw-r--r--drivers/staging/rtl8192e/rtl8192e/rtl_core.c213
-rw-r--r--drivers/staging/rtl8192e/rtl8192e/rtl_dm.c307
-rw-r--r--drivers/staging/rtl8192e/rtl8192e/rtl_ps.c9
-rw-r--r--drivers/staging/rtl8192e/rtl8192e/rtl_wx.c24
-rw-r--r--drivers/staging/rtl8192e/rtl819x_HTProc.c31
-rw-r--r--drivers/staging/rtl8192e/rtl819x_TSProc.c120
-rw-r--r--drivers/staging/rtl8192e/rtllib_rx.c118
-rw-r--r--drivers/staging/rtl8192e/rtllib_softmac.c11
-rw-r--r--drivers/staging/rtl8192e/rtllib_tx.c78
12 files changed, 482 insertions, 518 deletions
diff --git a/drivers/staging/rtl8192e/rtl8192e/r8192E_dev.c b/drivers/staging/rtl8192e/rtl8192e/r8192E_dev.c
index 170ff12c450a..9222e421f123 100644
--- a/drivers/staging/rtl8192e/rtl8192e/r8192E_dev.c
+++ b/drivers/staging/rtl8192e/rtl8192e/r8192E_dev.c
@@ -2025,6 +2025,7 @@ bool rtl8192_rx_query_status_desc(struct net_device *dev,
2025 struct sk_buff *skb) 2025 struct sk_buff *skb)
2026{ 2026{
2027 struct r8192_priv *priv = rtllib_priv(dev); 2027 struct r8192_priv *priv = rtllib_priv(dev);
2028 struct rx_fwinfo *pDrvInfo = NULL;
2028 2029
2029 stats->bICV = pdesc->ICV; 2030 stats->bICV = pdesc->ICV;
2030 stats->bCRC = pdesc->CRC32; 2031 stats->bCRC = pdesc->CRC32;
@@ -2046,51 +2047,49 @@ bool rtl8192_rx_query_status_desc(struct net_device *dev,
2046 priv->stats.rxcrcerrmid++; 2047 priv->stats.rxcrcerrmid++;
2047 } 2048 }
2048 return false; 2049 return false;
2049 } else { 2050 }
2050 struct rx_fwinfo *pDrvInfo = NULL;
2051 2051
2052 stats->RxDrvInfoSize = pdesc->RxDrvInfoSize; 2052 stats->RxDrvInfoSize = pdesc->RxDrvInfoSize;
2053 stats->RxBufShift = ((pdesc->Shift)&0x03); 2053 stats->RxBufShift = ((pdesc->Shift)&0x03);
2054 stats->Decrypted = !pdesc->SWDec; 2054 stats->Decrypted = !pdesc->SWDec;
2055 2055
2056 pDrvInfo = (struct rx_fwinfo *)(skb->data + stats->RxBufShift); 2056 pDrvInfo = (struct rx_fwinfo *)(skb->data + stats->RxBufShift);
2057 2057
2058 stats->rate = HwRateToMRate90((bool)pDrvInfo->RxHT, 2058 stats->rate = HwRateToMRate90((bool)pDrvInfo->RxHT,
2059 (u8)pDrvInfo->RxRate); 2059 (u8)pDrvInfo->RxRate);
2060 stats->bShortPreamble = pDrvInfo->SPLCP; 2060 stats->bShortPreamble = pDrvInfo->SPLCP;
2061 2061
2062 rtl8192_UpdateReceivedRateHistogramStatistics(dev, stats); 2062 rtl8192_UpdateReceivedRateHistogramStatistics(dev, stats);
2063 2063
2064 stats->bIsAMPDU = (pDrvInfo->PartAggr == 1); 2064 stats->bIsAMPDU = (pDrvInfo->PartAggr == 1);
2065 stats->bFirstMPDU = (pDrvInfo->PartAggr == 1) && 2065 stats->bFirstMPDU = (pDrvInfo->PartAggr == 1) &&
2066 (pDrvInfo->FirstAGGR == 1); 2066 (pDrvInfo->FirstAGGR == 1);
2067 2067
2068 stats->TimeStampLow = pDrvInfo->TSFL; 2068 stats->TimeStampLow = pDrvInfo->TSFL;
2069 stats->TimeStampHigh = read_nic_dword(dev, TSFR+4); 2069 stats->TimeStampHigh = read_nic_dword(dev, TSFR+4);
2070 2070
2071 rtl819x_UpdateRxPktTimeStamp(dev, stats); 2071 rtl819x_UpdateRxPktTimeStamp(dev, stats);
2072 2072
2073 if ((stats->RxBufShift + stats->RxDrvInfoSize) > 0) 2073 if ((stats->RxBufShift + stats->RxDrvInfoSize) > 0)
2074 stats->bShift = 1; 2074 stats->bShift = 1;
2075 2075
2076 stats->RxIs40MHzPacket = pDrvInfo->BW; 2076 stats->RxIs40MHzPacket = pDrvInfo->BW;
2077 2077
2078 rtl8192_TranslateRxSignalStuff(dev, skb, stats, pdesc, 2078 rtl8192_TranslateRxSignalStuff(dev, skb, stats, pdesc,
2079 pDrvInfo); 2079 pDrvInfo);
2080 2080
2081 if (pDrvInfo->FirstAGGR == 1 || pDrvInfo->PartAggr == 1) 2081 if (pDrvInfo->FirstAGGR == 1 || pDrvInfo->PartAggr == 1)
2082 RT_TRACE(COMP_RXDESC, 2082 RT_TRACE(COMP_RXDESC,
2083 "pDrvInfo->FirstAGGR = %d, pDrvInfo->PartAggr = %d\n", 2083 "pDrvInfo->FirstAGGR = %d, pDrvInfo->PartAggr = %d\n",
2084 pDrvInfo->FirstAGGR, pDrvInfo->PartAggr); 2084 pDrvInfo->FirstAGGR, pDrvInfo->PartAggr);
2085 skb_trim(skb, skb->len - 4/*sCrcLng*/); 2085 skb_trim(skb, skb->len - 4/*sCrcLng*/);
2086 2086
2087 2087
2088 stats->packetlength = stats->Length-4; 2088 stats->packetlength = stats->Length-4;
2089 stats->fraglength = stats->packetlength; 2089 stats->fraglength = stats->packetlength;
2090 stats->fragoffset = 0; 2090 stats->fragoffset = 0;
2091 stats->ntotalfrag = 1; 2091 stats->ntotalfrag = 1;
2092 return true; 2092 return true;
2093 }
2094} 2093}
2095 2094
2096void rtl8192_halt_adapter(struct net_device *dev, bool reset) 2095void rtl8192_halt_adapter(struct net_device *dev, bool reset)
@@ -2314,8 +2313,7 @@ bool rtl8192_HalRxCheckStuck(struct net_device *dev)
2314 (priv->undecorated_smoothed_pwdb >= RateAdaptiveTH_Low_20M)))) { 2313 (priv->undecorated_smoothed_pwdb >= RateAdaptiveTH_Low_20M)))) {
2315 if (rx_chk_cnt < 2) 2314 if (rx_chk_cnt < 2)
2316 return bStuck; 2315 return bStuck;
2317 else 2316 rx_chk_cnt = 0;
2318 rx_chk_cnt = 0;
2319 } else if ((((priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20) && 2317 } else if ((((priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20) &&
2320 (priv->undecorated_smoothed_pwdb < RateAdaptiveTH_Low_40M)) || 2318 (priv->undecorated_smoothed_pwdb < RateAdaptiveTH_Low_40M)) ||
2321 ((priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20) && 2319 ((priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20) &&
@@ -2323,13 +2321,11 @@ bool rtl8192_HalRxCheckStuck(struct net_device *dev)
2323 priv->undecorated_smoothed_pwdb >= VeryLowRSSI) { 2321 priv->undecorated_smoothed_pwdb >= VeryLowRSSI) {
2324 if (rx_chk_cnt < 4) 2322 if (rx_chk_cnt < 4)
2325 return bStuck; 2323 return bStuck;
2326 else 2324 rx_chk_cnt = 0;
2327 rx_chk_cnt = 0;
2328 } else { 2325 } else {
2329 if (rx_chk_cnt < 8) 2326 if (rx_chk_cnt < 8)
2330 return bStuck; 2327 return bStuck;
2331 else 2328 rx_chk_cnt = 0;
2332 rx_chk_cnt = 0;
2333 } 2329 }
2334 2330
2335 2331
diff --git a/drivers/staging/rtl8192e/rtl8192e/r8192E_phy.c b/drivers/staging/rtl8192e/rtl8192e/r8192E_phy.c
index 1d9b7a17cbde..312979f8fd7e 100644
--- a/drivers/staging/rtl8192e/rtl8192e/r8192E_phy.c
+++ b/drivers/staging/rtl8192e/rtl8192e/r8192E_phy.c
@@ -940,13 +940,11 @@ static u8 rtl8192_phy_SwChnlStepByStep(struct net_device *dev, u8 channel,
940 } 940 }
941 941
942 if (CurrentCmd && CurrentCmd->CmdID == CmdID_End) { 942 if (CurrentCmd && CurrentCmd->CmdID == CmdID_End) {
943 if ((*stage) == 2) { 943 if ((*stage) == 2)
944 return true; 944 return true;
945 } else { 945 (*stage)++;
946 (*stage)++; 946 (*step) = 0;
947 (*step) = 0; 947 continue;
948 continue;
949 }
950 } 948 }
951 949
952 if (!CurrentCmd) 950 if (!CurrentCmd)
diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_cam.c b/drivers/staging/rtl8192e/rtl8192e/rtl_cam.c
index 8b5f6085697e..41b025e250fe 100644
--- a/drivers/staging/rtl8192e/rtl8192e/rtl_cam.c
+++ b/drivers/staging/rtl8192e/rtl8192e/rtl_cam.c
@@ -116,11 +116,10 @@ void setKey(struct net_device *dev, u8 EntryNo, u8 KeyIndex, u16 KeyType,
116 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n", 116 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",
117 __func__); 117 __func__);
118 return; 118 return;
119 } else {
120 down(&priv->rtllib->ips_sem);
121 IPSLeave(dev);
122 up(&priv->rtllib->ips_sem);
123 } 119 }
120 down(&priv->rtllib->ips_sem);
121 IPSLeave(dev);
122 up(&priv->rtllib->ips_sem);
124 } 123 }
125 } 124 }
126 priv->rtllib->is_set_key = true; 125 priv->rtllib->is_set_key = true;
diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_core.c b/drivers/staging/rtl8192e/rtl8192e/rtl_core.c
index bcf7a9d822e2..5f3e28b22d7c 100644
--- a/drivers/staging/rtl8192e/rtl8192e/rtl_core.c
+++ b/drivers/staging/rtl8192e/rtl8192e/rtl_core.c
@@ -204,19 +204,18 @@ u8 read_nic_io_byte(struct net_device *dev, int x)
204 bool bIsLegalPage = false; 204 bool bIsLegalPage = false;
205 u8 Data = 0; 205 u8 Data = 0;
206 206
207 if (u4bPage == 0) { 207 if (u4bPage == 0)
208 return 0xff&inb(dev->base_addr + x); 208 return 0xff&inb(dev->base_addr + x);
209 } else {
210 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage,
211 &u1PageMask);
212 if (bIsLegalPage) {
213 u8 u1bPsr = read_nic_io_byte(dev, PSR);
214 209
215 write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) | 210 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage,
216 (u8)u4bPage)); 211 &u1PageMask);
217 Data = read_nic_io_byte(dev, (x & 0xff)); 212 if (bIsLegalPage) {
218 write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask)); 213 u8 u1bPsr = read_nic_io_byte(dev, PSR);
219 } 214
215 write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) |
216 (u8)u4bPage));
217 Data = read_nic_io_byte(dev, (x & 0xff));
218 write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask));
220 } 219 }
221 220
222 return Data; 221 return Data;
@@ -229,20 +228,17 @@ u16 read_nic_io_word(struct net_device *dev, int x)
229 bool bIsLegalPage = false; 228 bool bIsLegalPage = false;
230 u16 Data = 0; 229 u16 Data = 0;
231 230
232 if (u4bPage == 0) { 231 if (u4bPage == 0)
233 return inw(dev->base_addr + x); 232 return inw(dev->base_addr + x);
234 } else { 233 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage,
235 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage, 234 &u1PageMask);
236 &u1PageMask); 235 if (bIsLegalPage) {
237 if (bIsLegalPage) { 236 u8 u1bPsr = read_nic_io_byte(dev, PSR);
238 u8 u1bPsr = read_nic_io_byte(dev, PSR);
239 237
240 write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) | 238 write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) |
241 (u8)u4bPage)); 239 (u8)u4bPage));
242 Data = read_nic_io_word(dev, (x & 0xff)); 240 Data = read_nic_io_word(dev, (x & 0xff));
243 write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask)); 241 write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask));
244
245 }
246 } 242 }
247 243
248 return Data; 244 return Data;
@@ -255,20 +251,17 @@ u32 read_nic_io_dword(struct net_device *dev, int x)
255 bool bIsLegalPage = false; 251 bool bIsLegalPage = false;
256 u32 Data = 0; 252 u32 Data = 0;
257 253
258 if (u4bPage == 0) { 254 if (u4bPage == 0)
259 return inl(dev->base_addr + x); 255 return inl(dev->base_addr + x);
260 } else { 256 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage,
261 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage, 257 &u1PageMask);
262 &u1PageMask); 258 if (bIsLegalPage) {
263 if (bIsLegalPage) { 259 u8 u1bPsr = read_nic_io_byte(dev, PSR);
264 u8 u1bPsr = read_nic_io_byte(dev, PSR);
265
266 write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) |
267 (u8)u4bPage));
268 Data = read_nic_io_dword(dev, (x & 0xff));
269 write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask));
270 260
271 } 261 write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) |
262 (u8)u4bPage));
263 Data = read_nic_io_dword(dev, (x & 0xff));
264 write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask));
272 } 265 }
273 266
274 return Data; 267 return Data;
@@ -1331,11 +1324,11 @@ static short rtl8192_init(struct net_device *dev)
1331 dev->name, dev)) { 1324 dev->name, dev)) {
1332 netdev_err(dev, "Error allocating IRQ %d", dev->irq); 1325 netdev_err(dev, "Error allocating IRQ %d", dev->irq);
1333 return -1; 1326 return -1;
1334 } else {
1335 priv->irq = dev->irq;
1336 RT_TRACE(COMP_INIT, "IRQ %d\n", dev->irq);
1337 } 1327 }
1338 1328
1329 priv->irq = dev->irq;
1330 RT_TRACE(COMP_INIT, "IRQ %d\n", dev->irq);
1331
1339 if (rtl8192_pci_initdescring(dev) != 0) { 1332 if (rtl8192_pci_initdescring(dev) != 0) {
1340 netdev_err(dev, "Endopoints initialization failed"); 1333 netdev_err(dev, "Endopoints initialization failed");
1341 free_irq(dev->irq, dev); 1334 free_irq(dev->irq, dev);
@@ -1932,17 +1925,16 @@ int rtl8192_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
1932 if (queue_index == TXCMD_QUEUE) { 1925 if (queue_index == TXCMD_QUEUE) {
1933 rtl8192_tx_cmd(dev, skb); 1926 rtl8192_tx_cmd(dev, skb);
1934 return 0; 1927 return 0;
1935 } else {
1936 tcb_desc->RATRIndex = 7;
1937 tcb_desc->bTxDisableRateFallBack = 1;
1938 tcb_desc->bTxUseDriverAssingedRate = 1;
1939 tcb_desc->bTxEnableFwCalcDur = 1;
1940 skb_push(skb, priv->rtllib->tx_headroom);
1941 ret = rtl8192_tx(dev, skb);
1942 if (ret != 0)
1943 kfree_skb(skb);
1944 } 1928 }
1945 1929
1930 tcb_desc->RATRIndex = 7;
1931 tcb_desc->bTxDisableRateFallBack = 1;
1932 tcb_desc->bTxUseDriverAssingedRate = 1;
1933 tcb_desc->bTxEnableFwCalcDur = 1;
1934 skb_push(skb, priv->rtllib->tx_headroom);
1935 ret = rtl8192_tx(dev, skb);
1936 if (ret != 0)
1937 kfree_skb(skb);
1946 return ret; 1938 return ret;
1947} 1939}
1948 1940
@@ -2338,76 +2330,73 @@ static void rtl8192_rx_normal(struct net_device *dev)
2338 [priv->rx_idx[rx_queue_idx]]; 2330 [priv->rx_idx[rx_queue_idx]];
2339 struct sk_buff *skb = priv->rx_buf[rx_queue_idx] 2331 struct sk_buff *skb = priv->rx_buf[rx_queue_idx]
2340 [priv->rx_idx[rx_queue_idx]]; 2332 [priv->rx_idx[rx_queue_idx]];
2333 struct sk_buff *new_skb;
2341 2334
2342 if (pdesc->OWN) { 2335 if (pdesc->OWN)
2343 return; 2336 return;
2344 } else { 2337 if (!priv->ops->rx_query_status_descriptor(dev, &stats,
2345 struct sk_buff *new_skb; 2338 pdesc, skb))
2346 2339 goto done;
2347 if (!priv->ops->rx_query_status_descriptor(dev, &stats, 2340 new_skb = dev_alloc_skb(priv->rxbuffersize);
2348 pdesc, skb)) 2341 /* if allocation of new skb failed - drop current packet
2349 goto done; 2342 * and reuse skb */
2350 new_skb = dev_alloc_skb(priv->rxbuffersize); 2343 if (unlikely(!new_skb))
2351 /* if allocation of new skb failed - drop current packet 2344 goto done;
2352 * and reuse skb */ 2345
2353 if (unlikely(!new_skb)) 2346 pci_unmap_single(priv->pdev,
2354 goto done; 2347 *((dma_addr_t *)skb->cb),
2355 2348 priv->rxbuffersize,
2356 pci_unmap_single(priv->pdev, 2349 PCI_DMA_FROMDEVICE);
2357 *((dma_addr_t *)skb->cb), 2350
2358 priv->rxbuffersize, 2351 skb_put(skb, pdesc->Length);
2359 PCI_DMA_FROMDEVICE); 2352 skb_reserve(skb, stats.RxDrvInfoSize +
2360 2353 stats.RxBufShift);
2361 skb_put(skb, pdesc->Length); 2354 skb_trim(skb, skb->len - 4/*sCrcLng*/);
2362 skb_reserve(skb, stats.RxDrvInfoSize + 2355 rtllib_hdr = (struct rtllib_hdr_1addr *)skb->data;
2363 stats.RxBufShift); 2356 if (!is_multicast_ether_addr(rtllib_hdr->addr1)) {
2364 skb_trim(skb, skb->len - 4/*sCrcLng*/); 2357 /* unicast packet */
2365 rtllib_hdr = (struct rtllib_hdr_1addr *)skb->data; 2358 unicast_packet = true;
2366 if (!is_multicast_ether_addr(rtllib_hdr->addr1)) { 2359 }
2367 /* unicast packet */ 2360 fc = le16_to_cpu(rtllib_hdr->frame_ctl);
2368 unicast_packet = true; 2361 type = WLAN_FC_GET_TYPE(fc);
2369 } 2362 if (type == RTLLIB_FTYPE_MGMT)
2370 fc = le16_to_cpu(rtllib_hdr->frame_ctl); 2363 bLedBlinking = false;
2371 type = WLAN_FC_GET_TYPE(fc); 2364
2372 if (type == RTLLIB_FTYPE_MGMT) 2365 if (bLedBlinking)
2373 bLedBlinking = false; 2366 if (priv->rtllib->LedControlHandler)
2374 2367 priv->rtllib->LedControlHandler(dev,
2375 if (bLedBlinking) 2368 LED_CTL_RX);
2376 if (priv->rtllib->LedControlHandler) 2369
2377 priv->rtllib->LedControlHandler(dev, 2370 if (stats.bCRC) {
2378 LED_CTL_RX); 2371 if (type != RTLLIB_FTYPE_MGMT)
2379 2372 priv->stats.rxdatacrcerr++;
2380 if (stats.bCRC) { 2373 else
2381 if (type != RTLLIB_FTYPE_MGMT) 2374 priv->stats.rxmgmtcrcerr++;
2382 priv->stats.rxdatacrcerr++; 2375 }
2383 else
2384 priv->stats.rxmgmtcrcerr++;
2385 }
2386
2387 skb_len = skb->len;
2388 2376
2389 if (!rtllib_rx(priv->rtllib, skb, &stats)) { 2377 skb_len = skb->len;
2390 dev_kfree_skb_any(skb);
2391 } else {
2392 priv->stats.rxok++;
2393 if (unicast_packet)
2394 priv->stats.rxbytesunicast += skb_len;
2395 }
2396 2378
2397 skb = new_skb; 2379 if (!rtllib_rx(priv->rtllib, skb, &stats)) {
2398 skb->dev = dev; 2380 dev_kfree_skb_any(skb);
2381 } else {
2382 priv->stats.rxok++;
2383 if (unicast_packet)
2384 priv->stats.rxbytesunicast += skb_len;
2385 }
2399 2386
2400 priv->rx_buf[rx_queue_idx][priv->rx_idx[rx_queue_idx]] = 2387 skb = new_skb;
2401 skb; 2388 skb->dev = dev;
2402 *((dma_addr_t *) skb->cb) = pci_map_single(priv->pdev, 2389
2403 skb_tail_pointer_rsl(skb), 2390 priv->rx_buf[rx_queue_idx][priv->rx_idx[rx_queue_idx]] =
2404 priv->rxbuffersize, 2391 skb;
2405 PCI_DMA_FROMDEVICE); 2392 *((dma_addr_t *) skb->cb) = pci_map_single(priv->pdev,
2406 if (pci_dma_mapping_error(priv->pdev, 2393 skb_tail_pointer_rsl(skb),
2407 *((dma_addr_t *)skb->cb))) { 2394 priv->rxbuffersize,
2408 dev_kfree_skb_any(skb); 2395 PCI_DMA_FROMDEVICE);
2409 return; 2396 if (pci_dma_mapping_error(priv->pdev,
2410 } 2397 *((dma_addr_t *)skb->cb))) {
2398 dev_kfree_skb_any(skb);
2399 return;
2411 } 2400 }
2412done: 2401done:
2413 pdesc->BufferAddress = *((dma_addr_t *)skb->cb); 2402 pdesc->BufferAddress = *((dma_addr_t *)skb->cb);
diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_dm.c b/drivers/staging/rtl8192e/rtl8192e/rtl_dm.c
index aa95e88a6931..b26dfcbc3e3b 100644
--- a/drivers/staging/rtl8192e/rtl8192e/rtl_dm.c
+++ b/drivers/staging/rtl8192e/rtl8192e/rtl_dm.c
@@ -378,19 +378,16 @@ static void dm_bandwidth_autoswitch(struct net_device *dev)
378 struct r8192_priv *priv = rtllib_priv(dev); 378 struct r8192_priv *priv = rtllib_priv(dev);
379 379
380 if (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20 || 380 if (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20 ||
381 !priv->rtllib->bandwidth_auto_switch.bautoswitch_enable) { 381 !priv->rtllib->bandwidth_auto_switch.bautoswitch_enable)
382 return; 382 return;
383 if (priv->rtllib->bandwidth_auto_switch.bforced_tx20Mhz == false) {
384 if (priv->undecorated_smoothed_pwdb <=
385 priv->rtllib->bandwidth_auto_switch.threshold_40Mhzto20Mhz)
386 priv->rtllib->bandwidth_auto_switch.bforced_tx20Mhz = true;
383 } else { 387 } else {
384 if (priv->rtllib->bandwidth_auto_switch.bforced_tx20Mhz == false) { 388 if (priv->undecorated_smoothed_pwdb >=
385 if (priv->undecorated_smoothed_pwdb <= 389 priv->rtllib->bandwidth_auto_switch.threshold_20Mhzto40Mhz)
386 priv->rtllib->bandwidth_auto_switch.threshold_40Mhzto20Mhz) 390 priv->rtllib->bandwidth_auto_switch.bforced_tx20Mhz = false;
387 priv->rtllib->bandwidth_auto_switch.bforced_tx20Mhz = true;
388 } else {
389 if (priv->undecorated_smoothed_pwdb >=
390 priv->rtllib->bandwidth_auto_switch.threshold_20Mhzto40Mhz)
391 priv->rtllib->bandwidth_auto_switch.bforced_tx20Mhz = false;
392
393 }
394 } 391 }
395} 392}
396 393
@@ -581,148 +578,148 @@ static void dm_TXPowerTrackingCallback_TSSI(struct net_device *dev)
581 "priv->CCKPresentAttentuation = %d\n", 578 "priv->CCKPresentAttentuation = %d\n",
582 priv->CCKPresentAttentuation); 579 priv->CCKPresentAttentuation);
583 return; 580 return;
584 } else { 581 }
585 if (Avg_TSSI_Meas_from_driver < TSSI_13dBm - E_FOR_TX_POWER_TRACK) { 582 if (Avg_TSSI_Meas_from_driver < TSSI_13dBm - E_FOR_TX_POWER_TRACK) {
586 if (RF_Type == RF_2T4R) { 583 if (RF_Type == RF_2T4R) {
587
588 if ((priv->rfa_txpowertrackingindex > 0) &&
589 (priv->rfc_txpowertrackingindex > 0)) {
590 priv->rfa_txpowertrackingindex--;
591 if (priv->rfa_txpowertrackingindex_real > 4) {
592 priv->rfa_txpowertrackingindex_real--;
593 rtl8192_setBBreg(dev,
594 rOFDM0_XATxIQImbalance,
595 bMaskDWord,
596 priv->txbbgain_table[priv->rfa_txpowertrackingindex_real].txbbgain_value);
597 }
598
599 priv->rfc_txpowertrackingindex--;
600 if (priv->rfc_txpowertrackingindex_real > 4) {
601 priv->rfc_txpowertrackingindex_real--;
602 rtl8192_setBBreg(dev,
603 rOFDM0_XCTxIQImbalance,
604 bMaskDWord,
605 priv->txbbgain_table[priv->rfc_txpowertrackingindex_real].txbbgain_value);
606 }
607 } else {
608 rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance,
609 bMaskDWord,
610 priv->txbbgain_table[4].txbbgain_value);
611 rtl8192_setBBreg(dev,
612 rOFDM0_XCTxIQImbalance,
613 bMaskDWord, priv->txbbgain_table[4].txbbgain_value);
614 }
615 } else {
616 if (priv->rfa_txpowertrackingindex > 0) {
617 priv->rfa_txpowertrackingindex--;
618 if (priv->rfa_txpowertrackingindex_real > 4) {
619 priv->rfa_txpowertrackingindex_real--;
620 rtl8192_setBBreg(dev,
621 rOFDM0_XATxIQImbalance,
622 bMaskDWord,
623 priv->txbbgain_table[priv->rfa_txpowertrackingindex_real].txbbgain_value);
624 }
625 } else
626 rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance,
627 bMaskDWord, priv->txbbgain_table[4].txbbgain_value);
628 584
629 } 585 if ((priv->rfa_txpowertrackingindex > 0) &&
630 } else { 586 (priv->rfc_txpowertrackingindex > 0)) {
631 if (RF_Type == RF_2T4R) { 587 priv->rfa_txpowertrackingindex--;
632 if ((priv->rfa_txpowertrackingindex < 588 if (priv->rfa_txpowertrackingindex_real > 4) {
633 TxBBGainTableLength - 1) && 589 priv->rfa_txpowertrackingindex_real--;
634 (priv->rfc_txpowertrackingindex <
635 TxBBGainTableLength - 1)) {
636 priv->rfa_txpowertrackingindex++;
637 priv->rfa_txpowertrackingindex_real++;
638 rtl8192_setBBreg(dev, 590 rtl8192_setBBreg(dev,
639 rOFDM0_XATxIQImbalance, 591 rOFDM0_XATxIQImbalance,
640 bMaskDWord, 592 bMaskDWord,
641 priv->txbbgain_table 593 priv->txbbgain_table[priv->rfa_txpowertrackingindex_real].txbbgain_value);
642 [priv->rfa_txpowertrackingindex_real].txbbgain_value); 594 }
643 priv->rfc_txpowertrackingindex++; 595
644 priv->rfc_txpowertrackingindex_real++; 596 priv->rfc_txpowertrackingindex--;
597 if (priv->rfc_txpowertrackingindex_real > 4) {
598 priv->rfc_txpowertrackingindex_real--;
645 rtl8192_setBBreg(dev, 599 rtl8192_setBBreg(dev,
646 rOFDM0_XCTxIQImbalance, 600 rOFDM0_XCTxIQImbalance,
647 bMaskDWord, 601 bMaskDWord,
648 priv->txbbgain_table[priv->rfc_txpowertrackingindex_real].txbbgain_value); 602 priv->txbbgain_table[priv->rfc_txpowertrackingindex_real].txbbgain_value);
649 } else {
650 rtl8192_setBBreg(dev,
651 rOFDM0_XATxIQImbalance,
652 bMaskDWord,
653 priv->txbbgain_table[TxBBGainTableLength - 1].txbbgain_value);
654 rtl8192_setBBreg(dev,
655 rOFDM0_XCTxIQImbalance,
656 bMaskDWord, priv->txbbgain_table[TxBBGainTableLength - 1].txbbgain_value);
657 } 603 }
658 } else { 604 } else {
659 if (priv->rfa_txpowertrackingindex < (TxBBGainTableLength - 1)) { 605 rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance,
660 priv->rfa_txpowertrackingindex++; 606 bMaskDWord,
661 priv->rfa_txpowertrackingindex_real++; 607 priv->txbbgain_table[4].txbbgain_value);
662 rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, 608 rtl8192_setBBreg(dev,
609 rOFDM0_XCTxIQImbalance,
610 bMaskDWord, priv->txbbgain_table[4].txbbgain_value);
611 }
612 } else {
613 if (priv->rfa_txpowertrackingindex > 0) {
614 priv->rfa_txpowertrackingindex--;
615 if (priv->rfa_txpowertrackingindex_real > 4) {
616 priv->rfa_txpowertrackingindex_real--;
617 rtl8192_setBBreg(dev,
618 rOFDM0_XATxIQImbalance,
663 bMaskDWord, 619 bMaskDWord,
664 priv->txbbgain_table[priv->rfa_txpowertrackingindex_real].txbbgain_value); 620 priv->txbbgain_table[priv->rfa_txpowertrackingindex_real].txbbgain_value);
665 } else 621 }
666 rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance, 622 } else
667 bMaskDWord, 623 rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance,
668 priv->txbbgain_table[TxBBGainTableLength - 1].txbbgain_value); 624 bMaskDWord, priv->txbbgain_table[4].txbbgain_value);
669 } 625
670 } 626 }
627 } else {
671 if (RF_Type == RF_2T4R) { 628 if (RF_Type == RF_2T4R) {
672 priv->CCKPresentAttentuation_difference 629 if ((priv->rfa_txpowertrackingindex <
673 = priv->rfa_txpowertrackingindex - priv->rfa_txpowertracking_default; 630 TxBBGainTableLength - 1) &&
631 (priv->rfc_txpowertrackingindex <
632 TxBBGainTableLength - 1)) {
633 priv->rfa_txpowertrackingindex++;
634 priv->rfa_txpowertrackingindex_real++;
635 rtl8192_setBBreg(dev,
636 rOFDM0_XATxIQImbalance,
637 bMaskDWord,
638 priv->txbbgain_table
639 [priv->rfa_txpowertrackingindex_real].txbbgain_value);
640 priv->rfc_txpowertrackingindex++;
641 priv->rfc_txpowertrackingindex_real++;
642 rtl8192_setBBreg(dev,
643 rOFDM0_XCTxIQImbalance,
644 bMaskDWord,
645 priv->txbbgain_table[priv->rfc_txpowertrackingindex_real].txbbgain_value);
646 } else {
647 rtl8192_setBBreg(dev,
648 rOFDM0_XATxIQImbalance,
649 bMaskDWord,
650 priv->txbbgain_table[TxBBGainTableLength - 1].txbbgain_value);
651 rtl8192_setBBreg(dev,
652 rOFDM0_XCTxIQImbalance,
653 bMaskDWord, priv->txbbgain_table[TxBBGainTableLength - 1].txbbgain_value);
654 }
674 } else { 655 } else {
675 priv->CCKPresentAttentuation_difference 656 if (priv->rfa_txpowertrackingindex < (TxBBGainTableLength - 1)) {
676 = priv->rfa_txpowertrackingindex_real - priv->rfa_txpowertracking_default; 657 priv->rfa_txpowertrackingindex++;
677 } 658 priv->rfa_txpowertrackingindex_real++;
678 659 rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance,
679 if (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20) 660 bMaskDWord,
680 priv->CCKPresentAttentuation = 661 priv->txbbgain_table[priv->rfa_txpowertrackingindex_real].txbbgain_value);
681 priv->CCKPresentAttentuation_20Mdefault +
682 priv->CCKPresentAttentuation_difference;
683 else
684 priv->CCKPresentAttentuation =
685 priv->CCKPresentAttentuation_40Mdefault +
686 priv->CCKPresentAttentuation_difference;
687
688 if (priv->CCKPresentAttentuation > (CCKTxBBGainTableLength-1))
689 priv->CCKPresentAttentuation = CCKTxBBGainTableLength-1;
690 if (priv->CCKPresentAttentuation < 0)
691 priv->CCKPresentAttentuation = 0;
692
693 if (priv->CCKPresentAttentuation > -1 &&
694 priv->CCKPresentAttentuation < CCKTxBBGainTableLength) {
695 if (priv->rtllib->current_network.channel == 14 &&
696 !priv->bcck_in_ch14) {
697 priv->bcck_in_ch14 = true;
698 dm_cck_txpower_adjust(dev, priv->bcck_in_ch14);
699 } else if (priv->rtllib->current_network.channel != 14 && priv->bcck_in_ch14) {
700 priv->bcck_in_ch14 = false;
701 dm_cck_txpower_adjust(dev, priv->bcck_in_ch14);
702 } else 662 } else
703 dm_cck_txpower_adjust(dev, priv->bcck_in_ch14); 663 rtl8192_setBBreg(dev, rOFDM0_XATxIQImbalance,
664 bMaskDWord,
665 priv->txbbgain_table[TxBBGainTableLength - 1].txbbgain_value);
704 } 666 }
705 RT_TRACE(COMP_POWER_TRACKING, 667 }
706 "priv->rfa_txpowertrackingindex = %d\n", 668 if (RF_Type == RF_2T4R) {
707 priv->rfa_txpowertrackingindex); 669 priv->CCKPresentAttentuation_difference
708 RT_TRACE(COMP_POWER_TRACKING, 670 = priv->rfa_txpowertrackingindex - priv->rfa_txpowertracking_default;
709 "priv->rfa_txpowertrackingindex_real = %d\n", 671 } else {
710 priv->rfa_txpowertrackingindex_real); 672 priv->CCKPresentAttentuation_difference
711 RT_TRACE(COMP_POWER_TRACKING, 673 = priv->rfa_txpowertrackingindex_real - priv->rfa_txpowertracking_default;
712 "priv->CCKPresentAttentuation_difference = %d\n", 674 }
713 priv->CCKPresentAttentuation_difference);
714 RT_TRACE(COMP_POWER_TRACKING,
715 "priv->CCKPresentAttentuation = %d\n",
716 priv->CCKPresentAttentuation);
717 675
718 if (priv->CCKPresentAttentuation_difference <= -12 || priv->CCKPresentAttentuation_difference >= 24) { 676 if (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20)
719 priv->rtllib->bdynamic_txpower_enable = true; 677 priv->CCKPresentAttentuation =
720 write_nic_byte(dev, Pw_Track_Flag, 0); 678 priv->CCKPresentAttentuation_20Mdefault +
721 write_nic_byte(dev, FW_Busy_Flag, 0); 679 priv->CCKPresentAttentuation_difference;
722 RT_TRACE(COMP_POWER_TRACKING, "tx power track--->limited\n"); 680 else
723 return; 681 priv->CCKPresentAttentuation =
724 } 682 priv->CCKPresentAttentuation_40Mdefault +
683 priv->CCKPresentAttentuation_difference;
684
685 if (priv->CCKPresentAttentuation > (CCKTxBBGainTableLength-1))
686 priv->CCKPresentAttentuation = CCKTxBBGainTableLength-1;
687 if (priv->CCKPresentAttentuation < 0)
688 priv->CCKPresentAttentuation = 0;
689
690 if (priv->CCKPresentAttentuation > -1 &&
691 priv->CCKPresentAttentuation < CCKTxBBGainTableLength) {
692 if (priv->rtllib->current_network.channel == 14 &&
693 !priv->bcck_in_ch14) {
694 priv->bcck_in_ch14 = true;
695 dm_cck_txpower_adjust(dev, priv->bcck_in_ch14);
696 } else if (priv->rtllib->current_network.channel != 14 && priv->bcck_in_ch14) {
697 priv->bcck_in_ch14 = false;
698 dm_cck_txpower_adjust(dev, priv->bcck_in_ch14);
699 } else
700 dm_cck_txpower_adjust(dev, priv->bcck_in_ch14);
701 }
702 RT_TRACE(COMP_POWER_TRACKING,
703 "priv->rfa_txpowertrackingindex = %d\n",
704 priv->rfa_txpowertrackingindex);
705 RT_TRACE(COMP_POWER_TRACKING,
706 "priv->rfa_txpowertrackingindex_real = %d\n",
707 priv->rfa_txpowertrackingindex_real);
708 RT_TRACE(COMP_POWER_TRACKING,
709 "priv->CCKPresentAttentuation_difference = %d\n",
710 priv->CCKPresentAttentuation_difference);
711 RT_TRACE(COMP_POWER_TRACKING,
712 "priv->CCKPresentAttentuation = %d\n",
713 priv->CCKPresentAttentuation);
714
715 if (priv->CCKPresentAttentuation_difference <= -12 || priv->CCKPresentAttentuation_difference >= 24) {
716 priv->rtllib->bdynamic_txpower_enable = true;
717 write_nic_byte(dev, Pw_Track_Flag, 0);
718 write_nic_byte(dev, FW_Busy_Flag, 0);
719 RT_TRACE(COMP_POWER_TRACKING, "tx power track--->limited\n");
720 return;
725 } 721 }
722
726 write_nic_byte(dev, Pw_Track_Flag, 0); 723 write_nic_byte(dev, Pw_Track_Flag, 0);
727 Avg_TSSI_Meas_from_driver = 0; 724 Avg_TSSI_Meas_from_driver = 0;
728 for (k = 0; k < 5; k++) 725 for (k = 0; k < 5; k++)
@@ -1401,13 +1398,12 @@ static void dm_CheckTXPowerTracking_ThermalMeter(struct net_device *dev)
1401 TxPowerCheckCnt = 5; 1398 TxPowerCheckCnt = 5;
1402 else 1399 else
1403 TxPowerCheckCnt = 2; 1400 TxPowerCheckCnt = 2;
1404 if (!priv->btxpower_tracking) { 1401 if (!priv->btxpower_tracking)
1402 return;
1403
1404 if (priv->txpower_count <= TxPowerCheckCnt) {
1405 priv->txpower_count++;
1405 return; 1406 return;
1406 } else {
1407 if (priv->txpower_count <= TxPowerCheckCnt) {
1408 priv->txpower_count++;
1409 return;
1410 }
1411 } 1407 }
1412 1408
1413 if (!TM_Trigger) { 1409 if (!TM_Trigger) {
@@ -1419,15 +1415,12 @@ static void dm_CheckTXPowerTracking_ThermalMeter(struct net_device *dev)
1419 } 1415 }
1420 TM_Trigger = 1; 1416 TM_Trigger = 1;
1421 return; 1417 return;
1422 } else {
1423 netdev_info(dev,
1424 "===============>Schedule TxPowerTrackingWorkItem\n");
1425
1426 queue_delayed_work_rsl(priv->priv_wq, &priv->txpower_tracking_wq, 0);
1427 TM_Trigger = 0;
1428 }
1429
1430 } 1418 }
1419 netdev_info(dev, "===============>Schedule TxPowerTrackingWorkItem\n");
1420 queue_delayed_work_rsl(priv->priv_wq, &priv->txpower_tracking_wq, 0);
1421 TM_Trigger = 0;
1422
1423}
1431 1424
1432static void dm_check_txpower_tracking(struct net_device *dev) 1425static void dm_check_txpower_tracking(struct net_device *dev)
1433{ 1426{
@@ -1835,8 +1828,7 @@ static void dm_ctrl_initgain_byrssi_by_fwfalse_alarm(
1835 if (dm_digtable.dig_state == DM_STA_DIG_OFF && 1828 if (dm_digtable.dig_state == DM_STA_DIG_OFF &&
1836 (priv->reset_count == reset_cnt)) 1829 (priv->reset_count == reset_cnt))
1837 return; 1830 return;
1838 else 1831 reset_cnt = priv->reset_count;
1839 reset_cnt = priv->reset_count;
1840 1832
1841 dm_digtable.dig_highpwr_state = DM_STA_DIG_MAX; 1833 dm_digtable.dig_highpwr_state = DM_STA_DIG_MAX;
1842 dm_digtable.dig_state = DM_STA_DIG_OFF; 1834 dm_digtable.dig_state = DM_STA_DIG_OFF;
@@ -1865,12 +1857,11 @@ static void dm_ctrl_initgain_byrssi_by_fwfalse_alarm(
1865 (priv->reset_count == reset_cnt)) { 1857 (priv->reset_count == reset_cnt)) {
1866 dm_ctrl_initgain_byrssi_highpwr(dev); 1858 dm_ctrl_initgain_byrssi_highpwr(dev);
1867 return; 1859 return;
1868 } else {
1869 if (priv->reset_count != reset_cnt)
1870 reset_flag = 1;
1871
1872 reset_cnt = priv->reset_count;
1873 } 1860 }
1861 if (priv->reset_count != reset_cnt)
1862 reset_flag = 1;
1863
1864 reset_cnt = priv->reset_count;
1874 1865
1875 dm_digtable.dig_state = DM_STA_DIG_ON; 1866 dm_digtable.dig_state = DM_STA_DIG_ON;
1876 1867
@@ -1912,8 +1903,7 @@ static void dm_ctrl_initgain_byrssi_highpwr(struct net_device *dev)
1912 if (dm_digtable.dig_highpwr_state == DM_STA_DIG_ON && 1903 if (dm_digtable.dig_highpwr_state == DM_STA_DIG_ON &&
1913 (priv->reset_count == reset_cnt_highpwr)) 1904 (priv->reset_count == reset_cnt_highpwr))
1914 return; 1905 return;
1915 else 1906 dm_digtable.dig_highpwr_state = DM_STA_DIG_ON;
1916 dm_digtable.dig_highpwr_state = DM_STA_DIG_ON;
1917 1907
1918 if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20) 1908 if (priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20)
1919 write_nic_byte(dev, (rOFDM0_XATxAFE+3), 0x10); 1909 write_nic_byte(dev, (rOFDM0_XATxAFE+3), 0x10);
@@ -1923,8 +1913,7 @@ static void dm_ctrl_initgain_byrssi_highpwr(struct net_device *dev)
1923 if (dm_digtable.dig_highpwr_state == DM_STA_DIG_OFF && 1913 if (dm_digtable.dig_highpwr_state == DM_STA_DIG_OFF &&
1924 (priv->reset_count == reset_cnt_highpwr)) 1914 (priv->reset_count == reset_cnt_highpwr))
1925 return; 1915 return;
1926 else 1916 dm_digtable.dig_highpwr_state = DM_STA_DIG_OFF;
1927 dm_digtable.dig_highpwr_state = DM_STA_DIG_OFF;
1928 1917
1929 if (priv->undecorated_smoothed_pwdb < dm_digtable.rssi_high_power_lowthresh && 1918 if (priv->undecorated_smoothed_pwdb < dm_digtable.rssi_high_power_lowthresh &&
1930 priv->undecorated_smoothed_pwdb >= dm_digtable.rssi_high_thresh) { 1919 priv->undecorated_smoothed_pwdb >= dm_digtable.rssi_high_thresh) {
diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_ps.c b/drivers/staging/rtl8192e/rtl8192e/rtl_ps.c
index 40c3be9a5e54..0bbffec0c2ae 100644
--- a/drivers/staging/rtl8192e/rtl8192e/rtl_ps.c
+++ b/drivers/staging/rtl8192e/rtl8192e/rtl_ps.c
@@ -202,12 +202,11 @@ void rtllib_ips_leave_wq(struct net_device *dev)
202 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n", 202 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",
203 __func__); 203 __func__);
204 return; 204 return;
205 } else {
206 netdev_info(dev, "=========>%s(): IPSLeave\n",
207 __func__);
208 queue_work_rsl(priv->rtllib->wq,
209 &priv->rtllib->ips_leave_wq);
210 } 205 }
206 netdev_info(dev, "=========>%s(): IPSLeave\n",
207 __func__);
208 queue_work_rsl(priv->rtllib->wq,
209 &priv->rtllib->ips_leave_wq);
211 } 210 }
212 } 211 }
213} 212}
diff --git a/drivers/staging/rtl8192e/rtl8192e/rtl_wx.c b/drivers/staging/rtl8192e/rtl8192e/rtl_wx.c
index d074f974fe11..04f1f26b83c5 100644
--- a/drivers/staging/rtl8192e/rtl8192e/rtl_wx.c
+++ b/drivers/staging/rtl8192e/rtl8192e/rtl_wx.c
@@ -346,14 +346,12 @@ static int r8192_wx_set_mode(struct net_device *dev, struct iw_request_info *a,
346 __func__); 346 __func__);
347 up(&priv->wx_sem); 347 up(&priv->wx_sem);
348 return -1; 348 return -1;
349 } else {
350 netdev_info(dev,
351 "=========>%s(): IPSLeave\n",
352 __func__);
353 down(&priv->rtllib->ips_sem);
354 IPSLeave(dev);
355 up(&priv->rtllib->ips_sem);
356 } 349 }
350 netdev_info(dev, "=========>%s(): IPSLeave\n",
351 __func__);
352 down(&priv->rtllib->ips_sem);
353 IPSLeave(dev);
354 up(&priv->rtllib->ips_sem);
357 } 355 }
358 } 356 }
359 } 357 }
@@ -509,14 +507,12 @@ static int r8192_wx_set_scan(struct net_device *dev, struct iw_request_info *a,
509 __func__); 507 __func__);
510 up(&priv->wx_sem); 508 up(&priv->wx_sem);
511 return -1; 509 return -1;
512 } else {
513 RT_TRACE(COMP_PS,
514 "=========>%s(): IPSLeave\n",
515 __func__);
516 down(&priv->rtllib->ips_sem);
517 IPSLeave(dev);
518 up(&priv->rtllib->ips_sem);
519 } 510 }
511 RT_TRACE(COMP_PS, "=========>%s(): IPSLeave\n",
512 __func__);
513 down(&priv->rtllib->ips_sem);
514 IPSLeave(dev);
515 up(&priv->rtllib->ips_sem);
520 } 516 }
521 } 517 }
522 rtllib_stop_scan(priv->rtllib); 518 rtllib_stop_scan(priv->rtllib);
diff --git a/drivers/staging/rtl8192e/rtl819x_HTProc.c b/drivers/staging/rtl8192e/rtl819x_HTProc.c
index 9820dd2df5f3..573325cbd2e1 100644
--- a/drivers/staging/rtl8192e/rtl819x_HTProc.c
+++ b/drivers/staging/rtl8192e/rtl819x_HTProc.c
@@ -135,25 +135,22 @@ u16 TxCountToDataRate(struct rtllib_device *ieee, u8 nDataRate)
135 u8 is40MHz = 0; 135 u8 is40MHz = 0;
136 u8 isShortGI = 0; 136 u8 isShortGI = 0;
137 137
138 if (nDataRate < 12) { 138 if (nDataRate < 12)
139 return CCKOFDMRate[nDataRate]; 139 return CCKOFDMRate[nDataRate];
140 } else { 140 if (nDataRate >= 0x10 && nDataRate <= 0x1f) {
141 if (nDataRate >= 0x10 && nDataRate <= 0x1f) { 141 is40MHz = 0;
142 is40MHz = 0; 142 isShortGI = 0;
143 isShortGI = 0; 143 } else if (nDataRate >= 0x20 && nDataRate <= 0x2f) {
144 } else if (nDataRate >= 0x20 && nDataRate <= 0x2f) { 144 is40MHz = 1;
145 is40MHz = 1; 145 isShortGI = 0;
146 isShortGI = 0; 146 } else if (nDataRate >= 0x30 && nDataRate <= 0x3f) {
147 147 is40MHz = 0;
148 } else if (nDataRate >= 0x30 && nDataRate <= 0x3f) { 148 isShortGI = 1;
149 is40MHz = 0; 149 } else if (nDataRate >= 0x40 && nDataRate <= 0x4f) {
150 isShortGI = 1; 150 is40MHz = 1;
151 } else if (nDataRate >= 0x40 && nDataRate <= 0x4f) { 151 isShortGI = 1;
152 is40MHz = 1;
153 isShortGI = 1;
154 }
155 return MCS_DATA_RATE[is40MHz][isShortGI][nDataRate&0xf];
156 } 152 }
153 return MCS_DATA_RATE[is40MHz][isShortGI][nDataRate&0xf];
157} 154}
158 155
159bool IsHTHalfNmodeAPs(struct rtllib_device *ieee) 156bool IsHTHalfNmodeAPs(struct rtllib_device *ieee)
diff --git a/drivers/staging/rtl8192e/rtl819x_TSProc.c b/drivers/staging/rtl8192e/rtl819x_TSProc.c
index 735ae60e5740..7d77d056228d 100644
--- a/drivers/staging/rtl8192e/rtl819x_TSProc.c
+++ b/drivers/staging/rtl8192e/rtl819x_TSProc.c
@@ -311,6 +311,11 @@ bool GetTs(struct rtllib_device *ieee, struct ts_common_info **ppTS,
311 u8 *Addr, u8 TID, enum tr_select TxRxSelect, bool bAddNewTs) 311 u8 *Addr, u8 TID, enum tr_select TxRxSelect, bool bAddNewTs)
312{ 312{
313 u8 UP = 0; 313 u8 UP = 0;
314 union tspec_body TSpec;
315 union qos_tsinfo *pTSInfo = &TSpec.f.TSInfo;
316 struct list_head *pUnusedList;
317 struct list_head *pAddmitList;
318 enum direction_value Dir;
314 319
315 if (is_multicast_ether_addr(Addr)) { 320 if (is_multicast_ether_addr(Addr)) {
316 RTLLIB_DEBUG(RTLLIB_DL_ERR, 321 RTLLIB_DEBUG(RTLLIB_DL_ERR,
@@ -348,75 +353,70 @@ bool GetTs(struct rtllib_device *ieee, struct ts_common_info **ppTS,
348 } 353 }
349 354
350 *ppTS = SearchAdmitTRStream(ieee, Addr, UP, TxRxSelect); 355 *ppTS = SearchAdmitTRStream(ieee, Addr, UP, TxRxSelect);
351 if (*ppTS != NULL) { 356 if (*ppTS != NULL)
352 return true; 357 return true;
353 } else { 358
354 if (!bAddNewTs) { 359 if (!bAddNewTs) {
355 RTLLIB_DEBUG(RTLLIB_DL_TS, 360 RTLLIB_DEBUG(RTLLIB_DL_TS,
356 "add new TS failed(tid:%d)\n", UP); 361 "add new TS failed(tid:%d)\n", UP);
357 return false; 362 return false;
358 } else { 363 }
359 union tspec_body TSpec; 364
360 union qos_tsinfo *pTSInfo = &TSpec.f.TSInfo; 365 pUnusedList = (TxRxSelect == TX_DIR) ?
361 struct list_head *pUnusedList =
362 (TxRxSelect == TX_DIR) ?
363 (&ieee->Tx_TS_Unused_List) : 366 (&ieee->Tx_TS_Unused_List) :
364 (&ieee->Rx_TS_Unused_List); 367 (&ieee->Rx_TS_Unused_List);
365 368
366 struct list_head *pAddmitList = 369 pAddmitList = (TxRxSelect == TX_DIR) ?
367 (TxRxSelect == TX_DIR) ?
368 (&ieee->Tx_TS_Admit_List) : 370 (&ieee->Tx_TS_Admit_List) :
369 (&ieee->Rx_TS_Admit_List); 371 (&ieee->Rx_TS_Admit_List);
370 372
371 enum direction_value Dir = 373 Dir = (ieee->iw_mode == IW_MODE_MASTER) ?
372 (ieee->iw_mode == IW_MODE_MASTER) ? 374 ((TxRxSelect == TX_DIR) ? DIR_DOWN : DIR_UP) :
373 ((TxRxSelect == TX_DIR) ? DIR_DOWN : DIR_UP) : 375 ((TxRxSelect == TX_DIR) ? DIR_UP : DIR_DOWN);
374 ((TxRxSelect == TX_DIR) ? DIR_UP : DIR_DOWN); 376
375 RTLLIB_DEBUG(RTLLIB_DL_TS, "to add Ts\n"); 377 RTLLIB_DEBUG(RTLLIB_DL_TS, "to add Ts\n");
376 if (!list_empty(pUnusedList)) { 378 if (!list_empty(pUnusedList)) {
377 (*ppTS) = list_entry(pUnusedList->next, 379 (*ppTS) = list_entry(pUnusedList->next,
378 struct ts_common_info, List); 380 struct ts_common_info, List);
379 list_del_init(&(*ppTS)->List); 381 list_del_init(&(*ppTS)->List);
380 if (TxRxSelect == TX_DIR) { 382 if (TxRxSelect == TX_DIR) {
381 struct tx_ts_record *tmp = 383 struct tx_ts_record *tmp =
382 container_of(*ppTS, 384 container_of(*ppTS,
383 struct tx_ts_record, 385 struct tx_ts_record,
384 TsCommonInfo); 386 TsCommonInfo);
385 ResetTxTsEntry(tmp); 387 ResetTxTsEntry(tmp);
386 } else { 388 } else {
387 struct rx_ts_record *tmp = 389 struct rx_ts_record *tmp =
388 container_of(*ppTS, 390 container_of(*ppTS,
389 struct rx_ts_record, 391 struct rx_ts_record,
390 TsCommonInfo); 392 TsCommonInfo);
391 ResetRxTsEntry(tmp); 393 ResetRxTsEntry(tmp);
392 }
393
394 RTLLIB_DEBUG(RTLLIB_DL_TS,
395 "to init current TS, UP:%d, Dir:%d, addr: %pM ppTs=%p\n",
396 UP, Dir, Addr, *ppTS);
397 pTSInfo->field.ucTrafficType = 0;
398 pTSInfo->field.ucTSID = UP;
399 pTSInfo->field.ucDirection = Dir;
400 pTSInfo->field.ucAccessPolicy = 1;
401 pTSInfo->field.ucAggregation = 0;
402 pTSInfo->field.ucPSB = 0;
403 pTSInfo->field.ucUP = UP;
404 pTSInfo->field.ucTSInfoAckPolicy = 0;
405 pTSInfo->field.ucSchedule = 0;
406
407 MakeTSEntry(*ppTS, Addr, &TSpec, NULL, 0, 0);
408 AdmitTS(ieee, *ppTS, 0);
409 list_add_tail(&((*ppTS)->List), pAddmitList);
410
411 return true;
412 } else {
413 RTLLIB_DEBUG(RTLLIB_DL_ERR,
414 "ERR!!in function %s() There is not enough dir=%d(0=up down=1) TS record to be used!!",
415 __func__, Dir);
416 return false;
417 }
418 } 394 }
395
396 RTLLIB_DEBUG(RTLLIB_DL_TS,
397 "to init current TS, UP:%d, Dir:%d, addr: %pM ppTs=%p\n",
398 UP, Dir, Addr, *ppTS);
399 pTSInfo->field.ucTrafficType = 0;
400 pTSInfo->field.ucTSID = UP;
401 pTSInfo->field.ucDirection = Dir;
402 pTSInfo->field.ucAccessPolicy = 1;
403 pTSInfo->field.ucAggregation = 0;
404 pTSInfo->field.ucPSB = 0;
405 pTSInfo->field.ucUP = UP;
406 pTSInfo->field.ucTSInfoAckPolicy = 0;
407 pTSInfo->field.ucSchedule = 0;
408
409 MakeTSEntry(*ppTS, Addr, &TSpec, NULL, 0, 0);
410 AdmitTS(ieee, *ppTS, 0);
411 list_add_tail(&((*ppTS)->List), pAddmitList);
412
413 return true;
419 } 414 }
415
416 RTLLIB_DEBUG(RTLLIB_DL_ERR,
417 "ERR!!in function %s() There is not enough dir=%d(0=up down=1) TS record to be used!!",
418 __func__, Dir);
419 return false;
420} 420}
421 421
422static void RemoveTsEntry(struct rtllib_device *ieee, struct ts_common_info *pTs, 422static void RemoveTsEntry(struct rtllib_device *ieee, struct ts_common_info *pTs,
diff --git a/drivers/staging/rtl8192e/rtllib_rx.c b/drivers/staging/rtl8192e/rtllib_rx.c
index 9fc635395ca5..2592bd19054b 100644
--- a/drivers/staging/rtl8192e/rtllib_rx.c
+++ b/drivers/staging/rtl8192e/rtllib_rx.c
@@ -783,74 +783,74 @@ static u8 parse_subframe(struct rtllib_device *ieee, struct sk_buff *skb,
783 memcpy(rxb->dst, dst, ETH_ALEN); 783 memcpy(rxb->dst, dst, ETH_ALEN);
784 rxb->subframes[0]->dev = ieee->dev; 784 rxb->subframes[0]->dev = ieee->dev;
785 return 1; 785 return 1;
786 } else { 786 }
787 rxb->nr_subframes = 0;
788 memcpy(rxb->src, src, ETH_ALEN);
789 memcpy(rxb->dst, dst, ETH_ALEN);
790 while (skb->len > ETHERNET_HEADER_SIZE) {
791 /* Offset 12 denote 2 mac address */
792 nSubframe_Length = *((u16 *)(skb->data + 12));
793 nSubframe_Length = (nSubframe_Length >> 8) +
794 (nSubframe_Length << 8);
795
796 if (skb->len < (ETHERNET_HEADER_SIZE + nSubframe_Length)) {
797 netdev_info(ieee->dev,
798 "%s: A-MSDU parse error!! pRfd->nTotalSubframe : %d\n",
799 __func__, rxb->nr_subframes);
800 netdev_info(ieee->dev,
801 "%s: A-MSDU parse error!! Subframe Length: %d\n",
802 __func__, nSubframe_Length);
803 netdev_info(ieee->dev,
804 "nRemain_Length is %d and nSubframe_Length is : %d\n",
805 skb->len, nSubframe_Length);
806 netdev_info(ieee->dev,
807 "The Packet SeqNum is %d\n",
808 SeqNum);
809 return 0;
810 }
811 787
812 /* move the data point to data content */ 788 rxb->nr_subframes = 0;
813 skb_pull(skb, ETHERNET_HEADER_SIZE); 789 memcpy(rxb->src, src, ETH_ALEN);
790 memcpy(rxb->dst, dst, ETH_ALEN);
791 while (skb->len > ETHERNET_HEADER_SIZE) {
792 /* Offset 12 denote 2 mac address */
793 nSubframe_Length = *((u16 *)(skb->data + 12));
794 nSubframe_Length = (nSubframe_Length >> 8) +
795 (nSubframe_Length << 8);
814 796
815 /* altered by clark 3/30/2010 797 if (skb->len < (ETHERNET_HEADER_SIZE + nSubframe_Length)) {
816 * The struct buffer size of the skb indicated to upper layer 798 netdev_info(ieee->dev,
817 * must be less than 5000, or the defraged IP datagram 799 "%s: A-MSDU parse error!! pRfd->nTotalSubframe : %d\n",
818 * in the IP layer will exceed "ipfrag_high_tresh" and be 800 __func__, rxb->nr_subframes);
819 * discarded. so there must not use the function 801 netdev_info(ieee->dev,
820 * "skb_copy" and "skb_clone" for "skb". 802 "%s: A-MSDU parse error!! Subframe Length: %d\n",
821 */ 803 __func__, nSubframe_Length);
804 netdev_info(ieee->dev,
805 "nRemain_Length is %d and nSubframe_Length is : %d\n",
806 skb->len, nSubframe_Length);
807 netdev_info(ieee->dev,
808 "The Packet SeqNum is %d\n",
809 SeqNum);
810 return 0;
811 }
822 812
823 /* Allocate new skb for releasing to upper layer */ 813 /* move the data point to data content */
824 sub_skb = dev_alloc_skb(nSubframe_Length + 12); 814 skb_pull(skb, ETHERNET_HEADER_SIZE);
825 if (!sub_skb)
826 return 0;
827 skb_reserve(sub_skb, 12);
828 data_ptr = (u8 *)skb_put(sub_skb, nSubframe_Length);
829 memcpy(data_ptr, skb->data, nSubframe_Length);
830
831 sub_skb->dev = ieee->dev;
832 rxb->subframes[rxb->nr_subframes++] = sub_skb;
833 if (rxb->nr_subframes >= MAX_SUBFRAME_COUNT) {
834 RTLLIB_DEBUG_RX("ParseSubframe(): Too many Subframes! Packets dropped!\n");
835 break;
836 }
837 skb_pull(skb, nSubframe_Length);
838 815
839 if (skb->len != 0) { 816 /* altered by clark 3/30/2010
840 nPadding_Length = 4 - ((nSubframe_Length + 817 * The struct buffer size of the skb indicated to upper layer
841 ETHERNET_HEADER_SIZE) % 4); 818 * must be less than 5000, or the defraged IP datagram
842 if (nPadding_Length == 4) 819 * in the IP layer will exceed "ipfrag_high_tresh" and be
843 nPadding_Length = 0; 820 * discarded. so there must not use the function
821 * "skb_copy" and "skb_clone" for "skb".
822 */
844 823
845 if (skb->len < nPadding_Length) 824 /* Allocate new skb for releasing to upper layer */
846 return 0; 825 sub_skb = dev_alloc_skb(nSubframe_Length + 12);
826 if (!sub_skb)
827 return 0;
828 skb_reserve(sub_skb, 12);
829 data_ptr = (u8 *)skb_put(sub_skb, nSubframe_Length);
830 memcpy(data_ptr, skb->data, nSubframe_Length);
847 831
848 skb_pull(skb, nPadding_Length); 832 sub_skb->dev = ieee->dev;
849 } 833 rxb->subframes[rxb->nr_subframes++] = sub_skb;
834 if (rxb->nr_subframes >= MAX_SUBFRAME_COUNT) {
835 RTLLIB_DEBUG_RX("ParseSubframe(): Too many Subframes! Packets dropped!\n");
836 break;
850 } 837 }
838 skb_pull(skb, nSubframe_Length);
839
840 if (skb->len != 0) {
841 nPadding_Length = 4 - ((nSubframe_Length +
842 ETHERNET_HEADER_SIZE) % 4);
843 if (nPadding_Length == 4)
844 nPadding_Length = 0;
851 845
852 return rxb->nr_subframes; 846 if (skb->len < nPadding_Length)
847 return 0;
848
849 skb_pull(skb, nPadding_Length);
850 }
853 } 851 }
852
853 return rxb->nr_subframes;
854} 854}
855 855
856 856
diff --git a/drivers/staging/rtl8192e/rtllib_softmac.c b/drivers/staging/rtl8192e/rtllib_softmac.c
index f1f19fc2305c..70bdf1fe91a4 100644
--- a/drivers/staging/rtl8192e/rtllib_softmac.c
+++ b/drivers/staging/rtl8192e/rtllib_softmac.c
@@ -2540,13 +2540,12 @@ static void rtllib_resume_tx(struct rtllib_device *ieee)
2540 if (ieee->queue_stop) { 2540 if (ieee->queue_stop) {
2541 ieee->tx_pending.frag = i; 2541 ieee->tx_pending.frag = i;
2542 return; 2542 return;
2543 } else {
2544
2545 ieee->softmac_data_hard_start_xmit(
2546 ieee->tx_pending.txb->fragments[i],
2547 ieee->dev, ieee->rate);
2548 ieee->stats.tx_packets++;
2549 } 2543 }
2544
2545 ieee->softmac_data_hard_start_xmit(
2546 ieee->tx_pending.txb->fragments[i],
2547 ieee->dev, ieee->rate);
2548 ieee->stats.tx_packets++;
2550 } 2549 }
2551 2550
2552 rtllib_txb_free(ieee->tx_pending.txb); 2551 rtllib_txb_free(ieee->tx_pending.txb);
diff --git a/drivers/staging/rtl8192e/rtllib_tx.c b/drivers/staging/rtl8192e/rtllib_tx.c
index f6d0257e4c9b..2e1aab1230c5 100644
--- a/drivers/staging/rtl8192e/rtllib_tx.c
+++ b/drivers/staging/rtl8192e/rtllib_tx.c
@@ -413,6 +413,8 @@ static void rtllib_query_protectionmode(struct rtllib_device *ieee,
413 struct cb_desc *tcb_desc, 413 struct cb_desc *tcb_desc,
414 struct sk_buff *skb) 414 struct sk_buff *skb)
415{ 415{
416 struct rt_hi_throughput *pHTInfo;
417
416 tcb_desc->bRTSSTBC = false; 418 tcb_desc->bRTSSTBC = false;
417 tcb_desc->bRTSUseShortGI = false; 419 tcb_desc->bRTSUseShortGI = false;
418 tcb_desc->bCTSEnable = false; 420 tcb_desc->bCTSEnable = false;
@@ -435,50 +437,50 @@ static void rtllib_query_protectionmode(struct rtllib_device *ieee,
435 tcb_desc->rts_rate = MGN_24M; 437 tcb_desc->rts_rate = MGN_24M;
436 } 438 }
437 return; 439 return;
438 } else { 440 }
439 struct rt_hi_throughput *pHTInfo = ieee->pHTInfo;
440 441
441 while (true) { 442 pHTInfo = ieee->pHTInfo;
442 if (pHTInfo->IOTAction & HT_IOT_ACT_FORCED_CTS2SELF) { 443
443 tcb_desc->bCTSEnable = true; 444 while (true) {
444 tcb_desc->rts_rate = MGN_24M; 445 if (pHTInfo->IOTAction & HT_IOT_ACT_FORCED_CTS2SELF) {
445 tcb_desc->bRTSEnable = true; 446 tcb_desc->bCTSEnable = true;
446 break; 447 tcb_desc->rts_rate = MGN_24M;
447 } else if (pHTInfo->IOTAction & (HT_IOT_ACT_FORCED_RTS | 448 tcb_desc->bRTSEnable = true;
448 HT_IOT_ACT_PURE_N_MODE)) { 449 break;
449 tcb_desc->bRTSEnable = true; 450 } else if (pHTInfo->IOTAction & (HT_IOT_ACT_FORCED_RTS |
450 tcb_desc->rts_rate = MGN_24M; 451 HT_IOT_ACT_PURE_N_MODE)) {
451 break; 452 tcb_desc->bRTSEnable = true;
452 } 453 tcb_desc->rts_rate = MGN_24M;
453 if (ieee->current_network.buseprotection) { 454 break;
454 tcb_desc->bRTSEnable = true; 455 }
455 tcb_desc->bCTSEnable = true; 456 if (ieee->current_network.buseprotection) {
456 tcb_desc->rts_rate = MGN_24M; 457 tcb_desc->bRTSEnable = true;
457 break; 458 tcb_desc->bCTSEnable = true;
458 } 459 tcb_desc->rts_rate = MGN_24M;
459 if (pHTInfo->bCurrentHTSupport && pHTInfo->bEnableHT) { 460 break;
460 u8 HTOpMode = pHTInfo->CurrentOpMode; 461 }
461 462 if (pHTInfo->bCurrentHTSupport && pHTInfo->bEnableHT) {
462 if ((pHTInfo->bCurBW40MHz && (HTOpMode == 2 || 463 u8 HTOpMode = pHTInfo->CurrentOpMode;
463 HTOpMode == 3)) || 464
464 (!pHTInfo->bCurBW40MHz && HTOpMode == 3)) { 465 if ((pHTInfo->bCurBW40MHz && (HTOpMode == 2 ||
465 tcb_desc->rts_rate = MGN_24M; 466 HTOpMode == 3)) ||
466 tcb_desc->bRTSEnable = true; 467 (!pHTInfo->bCurBW40MHz && HTOpMode == 3)) {
467 break;
468 }
469 }
470 if (skb->len > ieee->rts) {
471 tcb_desc->rts_rate = MGN_24M; 468 tcb_desc->rts_rate = MGN_24M;
472 tcb_desc->bRTSEnable = true; 469 tcb_desc->bRTSEnable = true;
473 break; 470 break;
474 } 471 }
475 if (tcb_desc->bAMPDUEnable) {
476 tcb_desc->rts_rate = MGN_24M;
477 tcb_desc->bRTSEnable = false;
478 break;
479 }
480 goto NO_PROTECTION;
481 } 472 }
473 if (skb->len > ieee->rts) {
474 tcb_desc->rts_rate = MGN_24M;
475 tcb_desc->bRTSEnable = true;
476 break;
477 }
478 if (tcb_desc->bAMPDUEnable) {
479 tcb_desc->rts_rate = MGN_24M;
480 tcb_desc->bRTSEnable = false;
481 break;
482 }
483 goto NO_PROTECTION;
482 } 484 }
483 if (ieee->current_network.capability & WLAN_CAPABILITY_SHORT_PREAMBLE) 485 if (ieee->current_network.capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
484 tcb_desc->bUseShortPreamble = true; 486 tcb_desc->bUseShortPreamble = true;
generated by cgit v1.2.2 (git 2.25.0) at 2025-12-07 13:52:36 -0500