Pileus Git - ~andy/linux/blob - drivers/staging/rtl8192e/rtl_ps.c

   1 /******************************************************************************
   2  * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
   3  *
   4  * Based on the r8180 driver, which is:
   5  * Copyright 2004-2005 Andrea Merello <andreamrl@tiscali.it>, et al.
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of version 2 of the GNU General Public License as
   8  * published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  18  *
  19  * The full GNU General Public License is included in this distribution in the
  20  * file called LICENSE.
  21  *
  22  * Contact Information:
  23  * wlanfae <wlanfae@realtek.com>
  24  *****************************************************************************/
  25 #include "rtl_ps.h"
  26 #include "rtl_core.h"
  27 #include "r8192E_phy.h"
  28 #include "r8192E_phyreg.h"
  29 #include "r8190P_rtl8256.h" /* RTL8225 Radio frontend */
  30 #include "r8192E_cmdpkt.h"
  31
  32 void rtl8192_hw_sleep_down(struct net_device *dev)
  33 {
  34         struct r8192_priv *priv = rtllib_priv(dev);
  35         unsigned long flags = 0;
  36 #ifdef CONFIG_ASPM_OR_D3
  37         PRT_POWER_SAVE_CONTROL  pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->rtllib->PowerSaveControl));
  38 #endif
  39         spin_lock_irqsave(&priv->rf_ps_lock,flags);
  40         if (priv->RFChangeInProgress) {
  41                 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
  42                 RT_TRACE(COMP_DBG, "rtl8192_hw_sleep_down(): RF Change in progress! \n");
  43                 return;
  44         }
  45         spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
  46         RT_TRACE(COMP_DBG, "%s()============>come to sleep down\n", __func__);
  47
  48 #ifdef CONFIG_RTLWIFI_DEBUGFS
  49         if (priv->debug->hw_holding) {
  50                 return;
  51         }
  52 #endif
  53         MgntActSet_RF_State(dev, eRfSleep, RF_CHANGE_BY_PS,false);
  54 #ifdef CONFIG_ASPM_OR_D3
  55         if (pPSC->RegRfPsLevel & RT_RF_LPS_LEVEL_ASPM)
  56         {
  57                 RT_ENABLE_ASPM(dev);
  58                 RT_SET_PS_LEVEL(pPSC, RT_RF_LPS_LEVEL_ASPM);
  59         }
  60 #endif
  61 }
  62
  63 void rtl8192_hw_sleep_wq(void *data)
  64 {
  65         struct rtllib_device *ieee = container_of_dwork_rsl(data,struct rtllib_device,hw_sleep_wq);
  66         struct net_device *dev = ieee->dev;
  67         rtl8192_hw_sleep_down(dev);
  68 }
  69
  70 void rtl8192_hw_wakeup(struct net_device* dev)
  71 {
  72         struct r8192_priv *priv = rtllib_priv(dev);
  73         unsigned long flags = 0;
  74 #ifdef CONFIG_ASPM_OR_D3
  75         PRT_POWER_SAVE_CONTROL  pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->rtllib->PowerSaveControl));
  76 #endif
  77         spin_lock_irqsave(&priv->rf_ps_lock,flags);
  78         if (priv->RFChangeInProgress) {
  79                 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
  80                 RT_TRACE(COMP_DBG, "rtl8192_hw_wakeup(): RF Change in progress! \n");
  81                 queue_delayed_work_rsl(priv->rtllib->wq,&priv->rtllib->hw_wakeup_wq,MSECS(10));
  82                 return;
  83         }
  84         spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
  85 #ifdef CONFIG_ASPM_OR_D3
  86         if (pPSC->RegRfPsLevel & RT_RF_LPS_LEVEL_ASPM) {
  87                 RT_DISABLE_ASPM(dev);
  88                 RT_CLEAR_PS_LEVEL(pPSC, RT_RF_LPS_LEVEL_ASPM);
  89         }
  90 #endif
  91         RT_TRACE(COMP_PS, "%s()============>come to wake up\n", __func__);
  92         MgntActSet_RF_State(dev, eRfOn, RF_CHANGE_BY_PS,false);
  93 }
  94
  95 void rtl8192_hw_wakeup_wq(void *data)
  96 {
  97         struct rtllib_device *ieee = container_of_dwork_rsl(data,struct rtllib_device,hw_wakeup_wq);
  98         struct net_device *dev = ieee->dev;
  99         rtl8192_hw_wakeup(dev);
 100
 101 }
 102
 103 #define MIN_SLEEP_TIME 50
 104 #define MAX_SLEEP_TIME 10000
 105 void rtl8192_hw_to_sleep(struct net_device *dev, u32 th, u32 tl)
 106 {
 107         struct r8192_priv *priv = rtllib_priv(dev);
 108
 109         u32 rb = jiffies;
 110         unsigned long flags;
 111
 112         spin_lock_irqsave(&priv->ps_lock,flags);
 113
 114         tl -= MSECS(8+16+7);
 115
 116         if (((tl>=rb)&& (tl-rb) <= MSECS(MIN_SLEEP_TIME))
 117                         ||((rb>tl)&& (rb-tl) < MSECS(MIN_SLEEP_TIME))) {
 118                 spin_unlock_irqrestore(&priv->ps_lock,flags);
 119                 printk("too short to sleep::%x, %x, %lx\n",tl, rb,  MSECS(MIN_SLEEP_TIME));
 120                 return;
 121         }
 122
 123         if (((tl > rb) && ((tl-rb) > MSECS(MAX_SLEEP_TIME)))||
 124                         ((tl < rb) && (tl>MSECS(69)) && ((rb-tl) > MSECS(MAX_SLEEP_TIME)))||
 125                         ((tl<rb)&&(tl<MSECS(69))&&((tl+0xffffffff-rb)>MSECS(MAX_SLEEP_TIME)))) {
 126                 printk("========>too long to sleep:%x, %x, %lx\n", tl, rb,  MSECS(MAX_SLEEP_TIME));
 127                 spin_unlock_irqrestore(&priv->ps_lock,flags);
 128                 return;
 129         }
 130         {
 131                 u32 tmp = (tl>rb)?(tl-rb):(rb-tl);
 132                 queue_delayed_work_rsl(priv->rtllib->wq,
 133                                 &priv->rtllib->hw_wakeup_wq,tmp);
 134         }
 135         queue_delayed_work_rsl(priv->rtllib->wq,
 136                         (void *)&priv->rtllib->hw_sleep_wq,0);
 137         spin_unlock_irqrestore(&priv->ps_lock,flags);
 138 }
 139
 140 void InactivePsWorkItemCallback(struct net_device *dev)
 141 {
 142         struct r8192_priv *priv = rtllib_priv(dev);
 143         PRT_POWER_SAVE_CONTROL  pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->rtllib->PowerSaveControl));
 144
 145         RT_TRACE(COMP_PS, "InactivePsWorkItemCallback() ---------> \n");
 146         pPSC->bSwRfProcessing = true;
 147
 148         RT_TRACE(COMP_PS, "InactivePsWorkItemCallback(): Set RF to %s.\n", \
 149                         pPSC->eInactivePowerState == eRfOff?"OFF":"ON");
 150 #ifdef CONFIG_ASPM_OR_D3
 151         if (pPSC->eInactivePowerState == eRfOn)
 152         {
 153
 154                 if ((pPSC->RegRfPsLevel & RT_RF_OFF_LEVL_ASPM) && RT_IN_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_ASPM))
 155                 {
 156                         RT_DISABLE_ASPM(dev);
 157                         RT_CLEAR_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_ASPM);
 158                 }
 159         }
 160 #endif
 161         MgntActSet_RF_State(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS,false);
 162
 163 #ifdef CONFIG_ASPM_OR_D3
 164         if (pPSC->eInactivePowerState == eRfOff)
 165         {
 166                 if (pPSC->RegRfPsLevel & RT_RF_OFF_LEVL_ASPM)
 167                 {
 168                         RT_ENABLE_ASPM(dev);
 169                         RT_SET_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_ASPM);
 170                 }
 171         }
 172 #endif
 173
 174         pPSC->bSwRfProcessing = false;
 175         RT_TRACE(COMP_PS, "InactivePsWorkItemCallback() <--------- \n");
 176 }
 177
 178 void
 179 IPSEnter(struct net_device *dev)
 180 {
 181         struct r8192_priv *priv = rtllib_priv(dev);
 182         PRT_POWER_SAVE_CONTROL          pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->rtllib->PowerSaveControl));
 183         RT_RF_POWER_STATE                       rtState;
 184
 185         if (pPSC->bInactivePs)
 186         {
 187                 rtState = priv->rtllib->eRFPowerState;
 188                 if (rtState == eRfOn && !pPSC->bSwRfProcessing &&\
 189                         (priv->rtllib->state != RTLLIB_LINKED)&&\
 190                         (priv->rtllib->iw_mode != IW_MODE_MASTER))
 191                 {
 192                         RT_TRACE(COMP_PS,"IPSEnter(): Turn off RF.\n");
 193                         pPSC->eInactivePowerState = eRfOff;
 194                         priv->isRFOff = true;
 195                         priv->bInPowerSaveMode = true;
 196                         InactivePsWorkItemCallback(dev);
 197                 }
 198         }
 199 }
 200
 201 void
 202 IPSLeave(struct net_device *dev)
 203 {
 204         struct r8192_priv *priv = rtllib_priv(dev);
 205         PRT_POWER_SAVE_CONTROL  pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->rtllib->PowerSaveControl));
 206         RT_RF_POWER_STATE       rtState;
 207
 208         if (pPSC->bInactivePs)
 209         {
 210                 rtState = priv->rtllib->eRFPowerState;
 211                 if (rtState != eRfOn  && !pPSC->bSwRfProcessing && priv->rtllib->RfOffReason <= RF_CHANGE_BY_IPS)
 212                 {
 213                         RT_TRACE(COMP_PS, "IPSLeave(): Turn on RF.\n");
 214                         pPSC->eInactivePowerState = eRfOn;
 215                         priv->bInPowerSaveMode = false;
 216                         InactivePsWorkItemCallback(dev);
 217                 }
 218         }
 219 }
 220 void IPSLeave_wq(void *data)
 221 {
 222         struct rtllib_device *ieee = container_of_work_rsl(data,struct rtllib_device,ips_leave_wq);
 223         struct net_device *dev = ieee->dev;
 224         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 225         down(&priv->rtllib->ips_sem);
 226         IPSLeave(dev);
 227         up(&priv->rtllib->ips_sem);
 228 }
 229
 230 void rtllib_ips_leave_wq(struct net_device *dev)
 231 {
 232         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 233         RT_RF_POWER_STATE       rtState;
 234         rtState = priv->rtllib->eRFPowerState;
 235
 236         if (priv->rtllib->PowerSaveControl.bInactivePs){
 237                 if (rtState == eRfOff){
 238                         if (priv->rtllib->RfOffReason > RF_CHANGE_BY_IPS)
 239                         {
 240                                 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",__func__);
 241                                 return;
 242                         }
 243                         else{
 244                                 printk("=========>%s(): IPSLeave\n",__func__);
 245                                 queue_work_rsl(priv->rtllib->wq,&priv->rtllib->ips_leave_wq);
 246                         }
 247                 }
 248         }
 249 }
 250 void rtllib_ips_leave(struct net_device *dev)
 251 {
 252         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 253         down(&priv->rtllib->ips_sem);
 254         IPSLeave(dev);
 255         up(&priv->rtllib->ips_sem);
 256 }
 257
 258 bool MgntActSet_802_11_PowerSaveMode(struct net_device *dev,    u8 rtPsMode)
 259 {
 260         struct r8192_priv *priv = rtllib_priv(dev);
 261
 262         if (priv->rtllib->iw_mode == IW_MODE_ADHOC)
 263                 return false;
 264
 265         RT_TRACE(COMP_LPS,"%s(): set ieee->ps = %x\n",__func__,rtPsMode);
 266         if (!priv->ps_force) {
 267                 priv->rtllib->ps = rtPsMode;
 268         }
 269         if (priv->rtllib->sta_sleep != LPS_IS_WAKE && rtPsMode == RTLLIB_PS_DISABLED) {
 270                 unsigned long flags;
 271
 272                 rtl8192_hw_wakeup(dev);
 273                 priv->rtllib->sta_sleep = LPS_IS_WAKE;
 274
 275                 spin_lock_irqsave(&(priv->rtllib->mgmt_tx_lock), flags);
 276                 RT_TRACE(COMP_DBG, "LPS leave: notify AP we are awaked"
 277                          " ++++++++++ SendNullFunctionData\n");
 278                 rtllib_sta_ps_send_null_frame(priv->rtllib, 0);
 279                 spin_unlock_irqrestore(&(priv->rtllib->mgmt_tx_lock), flags);
 280         }
 281
 282         return true;
 283 }
 284
 285
 286 void LeisurePSEnter(struct net_device *dev)
 287 {
 288         struct r8192_priv *priv = rtllib_priv(dev);
 289         PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->rtllib->PowerSaveControl));
 290
 291         RT_TRACE(COMP_PS, "LeisurePSEnter()...\n");
 292         RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d,pPSC->LpsIdleCount is %d,RT_CHECK_FOR_HANG_PERIOD is %d\n",
 293                 pPSC->bLeisurePs, priv->rtllib->ps,pPSC->LpsIdleCount,RT_CHECK_FOR_HANG_PERIOD);
 294
 295         if (!((priv->rtllib->iw_mode == IW_MODE_INFRA) && (priv->rtllib->state == RTLLIB_LINKED))
 296             || (priv->rtllib->iw_mode == IW_MODE_ADHOC) || (priv->rtllib->iw_mode == IW_MODE_MASTER))
 297                 return;
 298
 299         if (pPSC->bLeisurePs) {
 300                 if (pPSC->LpsIdleCount >= RT_CHECK_FOR_HANG_PERIOD) {
 301
 302                         if (priv->rtllib->ps == RTLLIB_PS_DISABLED) {
 303
 304                                 RT_TRACE(COMP_LPS, "LeisurePSEnter(): Enter 802.11 power save mode...\n");
 305
 306                                 if (!pPSC->bFwCtrlLPS) {
 307                                         if (priv->rtllib->SetFwCmdHandler)
 308                                                 priv->rtllib->SetFwCmdHandler(dev, FW_CMD_LPS_ENTER);
 309                                 }
 310                                 MgntActSet_802_11_PowerSaveMode(dev, RTLLIB_PS_MBCAST|RTLLIB_PS_UNICAST);
 311                         }
 312                 } else
 313                         pPSC->LpsIdleCount++;
 314         }
 315 }
 316
 317
 318 void LeisurePSLeave(struct net_device *dev)
 319 {
 320         struct r8192_priv *priv = rtllib_priv(dev);
 321         PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->rtllib->PowerSaveControl));
 322
 323
 324         RT_TRACE(COMP_PS, "LeisurePSLeave()...\n");
 325         RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d\n",
 326                 pPSC->bLeisurePs, priv->rtllib->ps);
 327
 328         if (pPSC->bLeisurePs)
 329         {
 330                 if (priv->rtllib->ps != RTLLIB_PS_DISABLED)
 331                 {
 332 #ifdef CONFIG_ASPM_OR_D3
 333                         if (pPSC->RegRfPsLevel & RT_RF_LPS_LEVEL_ASPM && RT_IN_PS_LEVEL(pPSC, RT_RF_LPS_LEVEL_ASPM))
 334                         {
 335                                 RT_DISABLE_ASPM(dev);
 336                                 RT_CLEAR_PS_LEVEL(pPSC, RT_RF_LPS_LEVEL_ASPM);
 337                         }
 338 #endif
 339                         RT_TRACE(COMP_LPS, "LeisurePSLeave(): Busy Traffic , Leave 802.11 power save..\n");
 340                         MgntActSet_802_11_PowerSaveMode(dev, RTLLIB_PS_DISABLED);
 341
 342                         if (!pPSC->bFwCtrlLPS)
 343                         {
 344                                 if (priv->rtllib->SetFwCmdHandler)
 345                                 {
 346                                         priv->rtllib->SetFwCmdHandler(dev, FW_CMD_LPS_LEAVE);
 347                                 }
 348                     }
 349                 }
 350         }
 351 }
 352
 353 #ifdef CONFIG_ASPM_OR_D3
 354
 355 void
 356 PlatformDisableHostL0s(struct net_device *dev)
 357 {
 358         struct r8192_priv       *priv = (struct r8192_priv *)rtllib_priv(dev);
 359         u32                             PciCfgAddrPort=0;
 360         u8                              Num4Bytes;
 361         u8                              uPciBridgeASPMSetting = 0;
 362
 363
 364         if ( (priv->NdisAdapter.BusNumber == 0xff && priv->NdisAdapter.DevNumber == 0xff && priv->NdisAdapter.FuncNumber == 0xff) ||
 365                 (priv->NdisAdapter.PciBridgeBusNum == 0xff && priv->NdisAdapter.PciBridgeDevNum == 0xff && priv->NdisAdapter.PciBridgeFuncNum == 0xff) )
 366         {
 367                 printk("PlatformDisableHostL0s(): Fail to enable ASPM. Cannot find the Bus of PCI(Bridge).\n");
 368                 return;
 369         }
 370
 371         PciCfgAddrPort= (priv->NdisAdapter.PciBridgeBusNum << 16)|(priv->NdisAdapter.PciBridgeDevNum<< 11)|(priv->NdisAdapter.PciBridgeFuncNum <<  8)|(1 << 31);
 372         Num4Bytes = (priv->NdisAdapter.PciBridgePCIeHdrOffset+0x10)/4;
 373
 374
 375         NdisRawWritePortUlong(PCI_CONF_ADDRESS , PciCfgAddrPort+(Num4Bytes << 2));
 376
 377         NdisRawReadPortUchar(PCI_CONF_DATA, &uPciBridgeASPMSetting);
 378
 379         if (uPciBridgeASPMSetting & BIT0)
 380                 uPciBridgeASPMSetting &=  ~(BIT0);
 381
 382         NdisRawWritePortUlong(PCI_CONF_ADDRESS , PciCfgAddrPort+(Num4Bytes << 2));
 383         NdisRawWritePortUchar(PCI_CONF_DATA, uPciBridgeASPMSetting);
 384
 385         udelay(50);
 386
 387         printk("PlatformDisableHostL0s():PciBridge BusNumber[%x], DevNumbe[%x], FuncNumber[%x], Write reg[%x] = %x\n",
 388                 priv->NdisAdapter.PciBridgeBusNum, priv->NdisAdapter.PciBridgeDevNum, priv->NdisAdapter.PciBridgeFuncNum,
 389                 (priv->NdisAdapter.PciBridgePCIeHdrOffset+0x10), (priv->NdisAdapter.PciBridgeLinkCtrlReg | (priv->RegDevicePciASPMSetting&~BIT0)));
 390 }
 391
 392 bool
 393 PlatformEnable92CEBackDoor(struct net_device *dev)
 394 {
 395         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 396         bool                    bResult = true;
 397         u8                      value;
 398
 399         if ( (priv->NdisAdapter.BusNumber == 0xff && priv->NdisAdapter.DevNumber == 0xff && priv->NdisAdapter.FuncNumber == 0xff) ||
 400                 (priv->NdisAdapter.PciBridgeBusNum == 0xff && priv->NdisAdapter.PciBridgeDevNum == 0xff && priv->NdisAdapter.PciBridgeFuncNum == 0xff) )
 401         {
 402                 RT_TRACE(COMP_INIT, "PlatformEnableASPM(): Fail to enable ASPM. Cannot find the Bus of PCI(Bridge).\n");
 403                 return false;
 404         }
 405
 406         pci_read_config_byte(priv->pdev, 0x70f, &value);
 407
 408         if (priv->NdisAdapter.PciBridgeVendor == PCI_BRIDGE_VENDOR_INTEL)
 409         {
 410         value |= BIT7;
 411         }
 412         else
 413         {
 414                 value = 0x23;
 415         }
 416
 417         pci_write_config_byte(priv->pdev, 0x70f, value);
 418
 419
 420         pci_read_config_byte(priv->pdev, 0x719, &value);
 421         value |= (BIT3|BIT4);
 422         pci_write_config_byte(priv->pdev, 0x719, value);
 423
 424
 425         return bResult;
 426 }
 427
 428 bool PlatformSwitchDevicePciASPM(struct net_device *dev, u8 value)
 429 {
 430         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 431         bool bResult = false;
 432
 433         pci_write_config_byte(priv->pdev, 0x80, value);
 434
 435         return bResult;
 436 }
 437
 438 bool PlatformSwitchClkReq(struct net_device *dev, u8 value)
 439 {
 440         bool bResult = false;
 441         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 442         u8      Buffer;
 443
 444         Buffer= value;
 445
 446         pci_write_config_byte(priv->pdev,0x81,value);
 447         bResult = true;
 448
 449         return bResult;
 450 }
 451
 452 void
 453 PlatformDisableASPM(struct net_device *dev)
 454 {
 455         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 456         PRT_POWER_SAVE_CONTROL  pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->rtllib->PowerSaveControl));
 457         u32     PciCfgAddrPort=0;
 458         u8      Num4Bytes;
 459         u8      LinkCtrlReg;
 460         u16     PciBridgeLinkCtrlReg, ASPMLevel=0;
 461
 462         if (priv->NdisAdapter.PciBridgeVendor == PCI_BRIDGE_VENDOR_UNKNOWN)
 463         {
 464                 RT_TRACE(COMP_POWER,  "%s(): Disable ASPM. Recognize the Bus of PCI(Bridge) as UNKNOWN.\n",__func__);
 465         }
 466
 467
 468         LinkCtrlReg = priv->NdisAdapter.LinkCtrlReg;
 469         PciBridgeLinkCtrlReg = priv->NdisAdapter.PciBridgeLinkCtrlReg;
 470
 471         ASPMLevel |= BIT0|BIT1;
 472         LinkCtrlReg &=~ASPMLevel;
 473         PciBridgeLinkCtrlReg &=~(BIT0|BIT1);
 474
 475         if ( (priv->NdisAdapter.BusNumber == 0xff && priv->NdisAdapter.DevNumber == 0xff && priv->NdisAdapter.FuncNumber == 0xff) ||
 476                 (priv->NdisAdapter.PciBridgeBusNum == 0xff && priv->NdisAdapter.PciBridgeDevNum == 0xff && priv->NdisAdapter.PciBridgeFuncNum == 0xff) )
 477         {
 478         } else  {
 479                 PciCfgAddrPort= (priv->NdisAdapter.PciBridgeBusNum << 16)|(priv->NdisAdapter.PciBridgeDevNum<< 11)|(priv->NdisAdapter.PciBridgeFuncNum <<  8)|(1 << 31);
 480                 Num4Bytes = (priv->NdisAdapter.PciBridgePCIeHdrOffset+0x10)/4;
 481
 482                 NdisRawWritePortUlong(PCI_CONF_ADDRESS , PciCfgAddrPort+(Num4Bytes << 2));
 483
 484                 NdisRawWritePortUchar(PCI_CONF_DATA, PciBridgeLinkCtrlReg);
 485                 RT_TRACE(COMP_POWER, "PlatformDisableASPM():PciBridge BusNumber[%x], DevNumbe[%x], FuncNumber[%x], Write reg[%x] = %x\n",
 486                         priv->NdisAdapter.PciBridgeBusNum, priv->NdisAdapter.PciBridgeDevNum, priv->NdisAdapter.PciBridgeFuncNum,
 487                         (priv->NdisAdapter.PciBridgePCIeHdrOffset+0x10), PciBridgeLinkCtrlReg);
 488
 489                 udelay(50);
 490         }
 491 }
 492
 493 void PlatformEnableASPM(struct net_device *dev)
 494 {
 495         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 496         PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->rtllib->PowerSaveControl));
 497         u16     ASPMLevel = 0;
 498         u32     PciCfgAddrPort=0;
 499         u8      Num4Bytes;
 500         u8      uPciBridgeASPMSetting = 0;
 501         u8      uDeviceASPMSetting = 0;
 502
 503
 504         if ( (priv->NdisAdapter.BusNumber == 0xff && priv->NdisAdapter.DevNumber == 0xff && priv->NdisAdapter.FuncNumber == 0xff) ||
 505                 (priv->NdisAdapter.PciBridgeBusNum == 0xff && priv->NdisAdapter.PciBridgeDevNum == 0xff && priv->NdisAdapter.PciBridgeFuncNum == 0xff) )
 506         {
 507                 RT_TRACE(COMP_INIT, "PlatformEnableASPM(): Fail to enable ASPM. Cannot find the Bus of PCI(Bridge).\n");
 508                 return;
 509         }
 510
 511         ASPMLevel |= priv->RegDevicePciASPMSetting;
 512         uDeviceASPMSetting = priv->NdisAdapter.LinkCtrlReg;
 513
 514         uDeviceASPMSetting |= ASPMLevel;
 515
 516         PlatformSwitchDevicePciASPM(dev, uDeviceASPMSetting);
 517
 518         if (pPSC->RegRfPsLevel & RT_RF_OFF_LEVL_CLK_REQ) {
 519                 PlatformSwitchClkReq(dev,(pPSC->RegRfPsLevel & RT_RF_OFF_LEVL_CLK_REQ) ? 1 : 0);
 520                 RT_SET_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_CLK_REQ);
 521         }
 522         udelay(100);
 523
 524         udelay(100);
 525 }
 526
 527 u32 PlatformResetPciSpace(struct net_device *dev,u8 Value)
 528 {
 529         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 530
 531         pci_write_config_byte(priv->pdev,0x04,Value);
 532
 533         return 1;
 534
 535 }
 536 bool PlatformSetPMCSR(struct net_device *dev,u8 value,bool bTempSetting)
 537 {
 538         bool bResult = false;
 539         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 540         u8  Buffer;
 541         bool bActuallySet=false, bSetFunc=false;
 542         unsigned long flag;
 543
 544         Buffer= value;
 545         spin_lock_irqsave(&priv->D3_lock,flag);
 546         if (bActuallySet) {
 547                 if (Buffer) {
 548                         PlatformSwitchClkReq(dev, 0x01);
 549                 } else {
 550                         PlatformSwitchClkReq(dev, 0x00);
 551                 }
 552
 553                 pci_write_config_byte(priv->pdev,0x44,Buffer);
 554                 RT_TRACE(COMP_POWER, "PlatformSetPMCSR(): D3(value: %d)\n", Buffer);
 555
 556                 bResult = true;
 557                 if (!Buffer) {
 558                         PlatformResetPciSpace(dev, 0x06);
 559                         PlatformResetPciSpace(dev, 0x07);
 560                 }
 561
 562                 if (bSetFunc) {
 563                         if (Buffer) {
 564 #ifdef TO_DO_LIST
 565                                 RT_DISABLE_FUNC(Adapter, DF_IO_D3_BIT);
 566 #endif
 567                         } else {
 568 #ifdef TO_DO_LIST
 569                                 RT_ENABLE_FUNC(Adapter, DF_IO_D3_BIT);
 570 #endif
 571                         }
 572                 }
 573
 574         }
 575         spin_unlock_irqrestore(&priv->D3_lock,flag);
 576         return bResult;
 577 }
 578 #endif