drivers/net/wireless/rockchip_wlan/rtl8723bs/hal/hal_phy.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17  *
  18  *
  19  ******************************************************************************/
  20 #define _HAL_PHY_C_
  21
  22 #include <drv_types.h>
  23
  24 //================================================================================
  25 //      Constant.
  26 //================================================================================
  27 // 2008/11/20 MH For Debug only, RF
  28 static RF_SHADOW_T RF_Shadow[RF6052_MAX_PATH][RF6052_MAX_REG];
  29
  30 /**
  31 * Function:     PHY_CalculateBitShift
  32 *
  33 * OverView:     Get shifted position of the BitMask
  34 *
  35 * Input:
  36 *                       u4Byte          BitMask,
  37 *
  38 * Output:       none
  39 * Return:               u4Byte          Return the shift bit bit position of the mask
  40 */
  41 u32
  42 PHY_CalculateBitShift(
  43         u32 BitMask
  44         )
  45 {
  46         u32 i;
  47
  48         for(i=0; i<=31; i++)
  49         {
  50                 if ( ((BitMask>>i) &  0x1 ) == 1)
  51                         break;
  52         }
  53
  54         return (i);
  55 }
  56
  57
  58 //
  59 // ==> RF shadow Operation API Code Section!!!
  60 //
  61 /*-----------------------------------------------------------------------------
  62  * Function:    PHY_RFShadowRead
  63  *                              PHY_RFShadowWrite
  64  *                              PHY_RFShadowCompare
  65  *                              PHY_RFShadowRecorver
  66  *                              PHY_RFShadowCompareAll
  67  *                              PHY_RFShadowRecorverAll
  68  *                              PHY_RFShadowCompareFlagSet
  69  *                              PHY_RFShadowRecorverFlagSet
  70  *
  71  * Overview:    When we set RF register, we must write shadow at first.
  72  *                      When we are running, we must compare shadow abd locate error addr.
  73  *                      Decide to recorver or not.
  74  *
  75  * Input:       NONE
  76  *
  77  * Output:      NONE
  78  *
  79  * Return:      NONE
  80  *
  81  * Revised History:
  82  * When                 Who             Remark
  83  * 11/20/2008   MHC             Create Version 0.
  84  *
  85  *---------------------------------------------------------------------------*/
  86 u32
  87 PHY_RFShadowRead(
  88         IN      PADAPTER                Adapter,
  89         IN      u8                              eRFPath,
  90         IN      u32                             Offset)
  91 {
  92         return  RF_Shadow[eRFPath][Offset].Value;
  93
  94 }       /* PHY_RFShadowRead */
  95
  96
  97 VOID
  98 PHY_RFShadowWrite(
  99         IN      PADAPTER                Adapter,
 100         IN      u8                              eRFPath,
 101         IN      u32                             Offset,
 102         IN      u32                             Data)
 103 {
 104         RF_Shadow[eRFPath][Offset].Value = (Data & bRFRegOffsetMask);
 105         RF_Shadow[eRFPath][Offset].Driver_Write = _TRUE;
 106
 107 }       /* PHY_RFShadowWrite */
 108
 109
 110 BOOLEAN
 111 PHY_RFShadowCompare(
 112         IN      PADAPTER                Adapter,
 113         IN      u8                              eRFPath,
 114         IN      u32                             Offset)
 115 {
 116         u32     reg;
 117         // Check if we need to check the register
 118         if (RF_Shadow[eRFPath][Offset].Compare == _TRUE)
 119         {
 120                 reg = rtw_hal_read_rfreg(Adapter, eRFPath, Offset, bRFRegOffsetMask);
 121                 // Compare shadow and real rf register for 20bits!!
 122                 if (RF_Shadow[eRFPath][Offset].Value != reg)
 123                 {
 124                         // Locate error position.
 125                         RF_Shadow[eRFPath][Offset].ErrorOrNot = _TRUE;
 126                         //RT_TRACE(COMP_INIT, DBG_LOUD,
 127                         //("PHY_RFShadowCompare RF-%d Addr%02lx Err = %05lx\n",
 128                         //eRFPath, Offset, reg));
 129                 }
 130                 return RF_Shadow[eRFPath][Offset].ErrorOrNot ;
 131         }
 132         return _FALSE;
 133 }       /* PHY_RFShadowCompare */
 134
 135
 136 VOID
 137 PHY_RFShadowRecorver(
 138         IN      PADAPTER                Adapter,
 139         IN      u8                              eRFPath,
 140         IN      u32                             Offset)
 141 {
 142         // Check if the address is error
 143         if (RF_Shadow[eRFPath][Offset].ErrorOrNot == _TRUE)
 144         {
 145                 // Check if we need to recorver the register.
 146                 if (RF_Shadow[eRFPath][Offset].Recorver == _TRUE)
 147                 {
 148                         rtw_hal_write_rfreg(Adapter, eRFPath, Offset, bRFRegOffsetMask,
 149                                                         RF_Shadow[eRFPath][Offset].Value);
 150                         //RT_TRACE(COMP_INIT, DBG_LOUD,
 151                         //("PHY_RFShadowRecorver RF-%d Addr%02lx=%05lx",
 152                         //eRFPath, Offset, RF_Shadow[eRFPath][Offset].Value));
 153                 }
 154         }
 155
 156 }       /* PHY_RFShadowRecorver */
 157
 158
 159 VOID
 160 PHY_RFShadowCompareAll(
 161         IN      PADAPTER                        Adapter)
 162 {
 163         u8              eRFPath = 0 ;
 164         u32             Offset = 0, maxReg= GET_RF6052_REAL_MAX_REG(Adapter);
 165
 166         for (eRFPath = 0; eRFPath < RF6052_MAX_PATH; eRFPath++)
 167         {
 168                 for (Offset = 0; Offset < maxReg; Offset++)
 169                 {
 170                         PHY_RFShadowCompare(Adapter, eRFPath, Offset);
 171                 }
 172         }
 173
 174 }       /* PHY_RFShadowCompareAll */
 175
 176
 177 VOID
 178 PHY_RFShadowRecorverAll(
 179         IN      PADAPTER                        Adapter)
 180 {
 181         u8              eRFPath =0;
 182         u32             Offset = 0, maxReg= GET_RF6052_REAL_MAX_REG(Adapter);
 183
 184         for (eRFPath = 0; eRFPath < RF6052_MAX_PATH; eRFPath++)
 185         {
 186                 for (Offset = 0; Offset < maxReg; Offset++)
 187                 {
 188                         PHY_RFShadowRecorver(Adapter, eRFPath, Offset);
 189                 }
 190         }
 191
 192 }       /* PHY_RFShadowRecorverAll */
 193
 194
 195 VOID
 196 PHY_RFShadowCompareFlagSet(
 197         IN      PADAPTER                Adapter,
 198         IN      u8                              eRFPath,
 199         IN      u32                             Offset,
 200         IN      u8                              Type)
 201 {
 202         // Set True or False!!!
 203         RF_Shadow[eRFPath][Offset].Compare = Type;
 204
 205 }       /* PHY_RFShadowCompareFlagSet */
 206
 207
 208 VOID
 209 PHY_RFShadowRecorverFlagSet(
 210         IN      PADAPTER                Adapter,
 211         IN      u8                              eRFPath,
 212         IN      u32                             Offset,
 213         IN      u8                              Type)
 214 {
 215         // Set True or False!!!
 216         RF_Shadow[eRFPath][Offset].Recorver= Type;
 217
 218 }       /* PHY_RFShadowRecorverFlagSet */
 219
 220
 221 VOID
 222 PHY_RFShadowCompareFlagSetAll(
 223         IN      PADAPTER                        Adapter)
 224 {
 225         u8              eRFPath = 0;
 226         u32             Offset = 0, maxReg= GET_RF6052_REAL_MAX_REG(Adapter);
 227
 228         for (eRFPath = 0; eRFPath < RF6052_MAX_PATH; eRFPath++)
 229         {
 230                 for (Offset = 0; Offset < maxReg; Offset++)
 231                 {
 232                         // 2008/11/20 MH For S3S4 test, we only check reg 26/27 now!!!!
 233                         if (Offset != 0x26 && Offset != 0x27)
 234                                 PHY_RFShadowCompareFlagSet(Adapter, eRFPath, Offset, _FALSE);
 235                         else
 236                                 PHY_RFShadowCompareFlagSet(Adapter, eRFPath, Offset, _TRUE);
 237                 }
 238         }
 239
 240 }       /* PHY_RFShadowCompareFlagSetAll */
 241
 242
 243 VOID
 244 PHY_RFShadowRecorverFlagSetAll(
 245         IN      PADAPTER                        Adapter)
 246 {
 247         u8              eRFPath = 0;
 248         u32             Offset = 0, maxReg= GET_RF6052_REAL_MAX_REG(Adapter);
 249
 250         for (eRFPath = 0; eRFPath < RF6052_MAX_PATH; eRFPath++)
 251         {
 252                 for (Offset = 0; Offset < maxReg; Offset++)
 253                 {
 254                         // 2008/11/20 MH For S3S4 test, we only check reg 26/27 now!!!!
 255                         if (Offset != 0x26 && Offset != 0x27)
 256                                 PHY_RFShadowRecorverFlagSet(Adapter, eRFPath, Offset, _FALSE);
 257                         else
 258                                 PHY_RFShadowRecorverFlagSet(Adapter, eRFPath, Offset, _TRUE);
 259                 }
 260         }
 261
 262 }       /* PHY_RFShadowCompareFlagSetAll */
 263
 264 VOID
 265 PHY_RFShadowRefresh(
 266         IN      PADAPTER                        Adapter)
 267 {
 268         u8              eRFPath = 0;
 269         u32             Offset = 0, maxReg= GET_RF6052_REAL_MAX_REG(Adapter);
 270
 271         for (eRFPath = 0; eRFPath < RF6052_MAX_PATH; eRFPath++)
 272         {
 273                 for (Offset = 0; Offset < maxReg; Offset++)
 274                 {
 275                         RF_Shadow[eRFPath][Offset].Value = 0;
 276                         RF_Shadow[eRFPath][Offset].Compare = _FALSE;
 277                         RF_Shadow[eRFPath][Offset].Recorver  = _FALSE;
 278                         RF_Shadow[eRFPath][Offset].ErrorOrNot = _FALSE;
 279                         RF_Shadow[eRFPath][Offset].Driver_Write = _FALSE;
 280                 }
 281         }
 282
 283 }       /* PHY_RFShadowRead */
 284
 285