rtl8723bu/hal/phydm/phydm_pathdiv.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
  21 //============================================================
  22 // include files
  23 //============================================================
  24 #include "mp_precomp.h"
  25 #include "phydm_precomp.h"
  26
  27 #if(defined(CONFIG_PATH_DIVERSITY))
  28 #if RTL8814A_SUPPORT
  29
  30 VOID
  31 phydm_dtp_fix_tx_path(
  32         IN      PVOID   pDM_VOID,
  33         IN      u1Byte  path
  34         )
  35 {
  36         PDM_ODM_T               pDM_Odm = (PDM_ODM_T)pDM_VOID;
  37         pPATHDIV_T              pDM_PathDiv = &pDM_Odm->DM_PathDiv;
  38         u1Byte                  i,num_enable_path=0;
  39
  40         if(path==pDM_PathDiv->pre_tx_path)
  41         {
  42                 return;
  43         }
  44         else
  45         {
  46                 pDM_PathDiv->pre_tx_path=path;
  47         }
  48
  49         ODM_SetBBReg( pDM_Odm, 0x93c, BIT18|BIT19, 3);
  50
  51         for(i=0; i<4; i++)
  52         {
  53                 if(path&BIT(i))
  54                         num_enable_path++;
  55         }
  56         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" Number of trun-on path : (( %d ))\n", num_enable_path));
  57
  58         if(num_enable_path == 1)
  59         {
  60                 ODM_SetBBReg( pDM_Odm, 0x93c, 0xf00000, path);
  61
  62                 if(path==PHYDM_A)//1-1
  63                 {
  64                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" Trun on path (( A ))\n"));
  65                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT25|BIT24, 0);
  66                 }
  67                 else    if(path==PHYDM_B)//1-2
  68                 {
  69                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" Trun on path (( B ))\n"));
  70                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT27|BIT26, 0);
  71                 }
  72                 else    if(path==PHYDM_C)//1-3
  73                 {
  74                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" Trun on path (( C ))\n"));
  75                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT29|BIT28, 0);
  76
  77                 }
  78                 else    if(path==PHYDM_D)//1-4
  79                 {
  80                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" Trun on path (( D ))\n"));
  81                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT31|BIT30, 0);
  82                 }
  83
  84         }
  85         else    if(num_enable_path == 2)
  86         {
  87                 ODM_SetBBReg( pDM_Odm, 0x93c, 0xf00000, path);
  88                 ODM_SetBBReg( pDM_Odm, 0x940, 0xf0, path);
  89
  90                 if(path==PHYDM_AB)//2-1
  91                 {
  92                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" Trun on path (( A B ))\n"));
  93                         //set for 1ss
  94                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT25|BIT24, 0);
  95                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT27|BIT26, 1);
  96                         //set for 2ss
  97                         ODM_SetBBReg( pDM_Odm, 0x940, BIT9|BIT8, 0);
  98                         ODM_SetBBReg( pDM_Odm, 0x940, BIT11|BIT10, 1);
  99                 }
 100                 else    if(path==PHYDM_AC)//2-2
 101                 {
 102                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" Trun on path (( A C ))\n"));
 103                         //set for 1ss
 104                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT25|BIT24, 0);
 105                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT29|BIT28, 1);
 106                         //set for 2ss
 107                         ODM_SetBBReg( pDM_Odm, 0x940, BIT9|BIT8, 0);
 108                         ODM_SetBBReg( pDM_Odm, 0x940, BIT13|BIT12, 1);
 109                 }
 110                 else    if(path==PHYDM_AD)//2-3
 111                 {
 112                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" Trun on path (( A D ))\n"));
 113                         //set for 1ss
 114                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT25|BIT24, 0);
 115                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT31|BIT30, 1);
 116                         //set for 2ss
 117                         ODM_SetBBReg( pDM_Odm, 0x940, BIT9|BIT8, 0);
 118                         ODM_SetBBReg( pDM_Odm, 0x940, BIT15|BIT14, 1);
 119                 }
 120                 else    if(path==PHYDM_BC)//2-4
 121                 {
 122                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" Trun on path (( B C ))\n"));
 123                         //set for 1ss
 124                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT27|BIT26, 0);
 125                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT29|BIT28, 1);
 126                         //set for 2ss
 127                         ODM_SetBBReg( pDM_Odm, 0x940, BIT11|BIT10, 0);
 128                         ODM_SetBBReg( pDM_Odm, 0x940, BIT13|BIT12, 1);
 129                 }
 130                 else    if(path==PHYDM_BD)//2-5
 131                 {
 132                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" Trun on path (( B D ))\n"));
 133                         //set for 1ss
 134                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT27|BIT26, 0);
 135                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT31|BIT30, 1);
 136                         //set for 2ss
 137                         ODM_SetBBReg( pDM_Odm, 0x940, BIT11|BIT10, 0);
 138                         ODM_SetBBReg( pDM_Odm, 0x940, BIT15|BIT14, 1);
 139                 }
 140                 else    if(path==PHYDM_CD)//2-6
 141                 {
 142                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" Trun on path (( C D ))\n"));
 143                         //set for 1ss
 144                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT29|BIT28, 0);
 145                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT31|BIT30, 1);
 146                         //set for 2ss
 147                         ODM_SetBBReg( pDM_Odm, 0x940, BIT13|BIT12, 0);
 148                         ODM_SetBBReg( pDM_Odm, 0x940, BIT15|BIT14, 1);
 149                 }
 150
 151         }
 152         else    if(num_enable_path == 3)
 153         {
 154                 ODM_SetBBReg( pDM_Odm, 0x93c, 0xf00000, path);
 155                 ODM_SetBBReg( pDM_Odm, 0x940, 0xf0, path);
 156                 ODM_SetBBReg( pDM_Odm, 0x940, 0xf0000, path);
 157
 158                 if(path==PHYDM_ABC)//3-1
 159                 {
 160                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" Trun on path (( A B C))\n"));
 161                         //set for 1ss
 162                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT25|BIT24, 0);
 163                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT27|BIT26, 1);
 164                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT29|BIT28, 2);
 165                         //set for 2ss
 166                         ODM_SetBBReg( pDM_Odm, 0x940, BIT9|BIT8, 0);
 167                         ODM_SetBBReg( pDM_Odm, 0x940, BIT11|BIT10, 1);
 168                         ODM_SetBBReg( pDM_Odm, 0x940, BIT13|BIT12, 2);
 169                         //set for 3ss
 170                         ODM_SetBBReg( pDM_Odm, 0x940, BIT21|BIT20, 0);
 171                         ODM_SetBBReg( pDM_Odm, 0x940, BIT23|BIT22, 1);
 172                         ODM_SetBBReg( pDM_Odm, 0x940, BIT25|BIT24, 2);
 173                 }
 174                 else    if(path==PHYDM_ABD)//3-2
 175                 {
 176                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" Trun on path (( A B D ))\n"));
 177                         //set for 1ss
 178                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT25|BIT24, 0);
 179                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT27|BIT26, 1);
 180                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT31|BIT30, 2);
 181                         //set for 2ss
 182                         ODM_SetBBReg( pDM_Odm, 0x940, BIT9|BIT8, 0);
 183                         ODM_SetBBReg( pDM_Odm, 0x940, BIT11|BIT10, 1);
 184                         ODM_SetBBReg( pDM_Odm, 0x940, BIT15|BIT14, 2);
 185                         //set for 3ss
 186                         ODM_SetBBReg( pDM_Odm, 0x940, BIT21|BIT20, 0);
 187                         ODM_SetBBReg( pDM_Odm, 0x940, BIT23|BIT22, 1);
 188                         ODM_SetBBReg( pDM_Odm, 0x940, BIT27|BIT26, 2);
 189
 190                 }
 191                 else    if(path==PHYDM_ACD)//3-3
 192                 {
 193                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" Trun on path (( A C D ))\n"));
 194                         //set for 1ss
 195                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT25|BIT24, 0);
 196                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT29|BIT28, 1);
 197                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT31|BIT30, 2);
 198                         //set for 2ss
 199                         ODM_SetBBReg( pDM_Odm, 0x940, BIT9|BIT8, 0);
 200                         ODM_SetBBReg( pDM_Odm, 0x940, BIT13|BIT12, 1);
 201                         ODM_SetBBReg( pDM_Odm, 0x940, BIT15|BIT14, 2);
 202                         //set for 3ss
 203                         ODM_SetBBReg( pDM_Odm, 0x940, BIT21|BIT20, 0);
 204                         ODM_SetBBReg( pDM_Odm, 0x940, BIT25|BIT24, 1);
 205                         ODM_SetBBReg( pDM_Odm, 0x940, BIT27|BIT26, 2);
 206                 }
 207                 else    if(path==PHYDM_BCD)//3-4
 208                 {
 209                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" Trun on path (( B C D))\n"));
 210                         //set for 1ss
 211                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT27|BIT26, 0);
 212                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT29|BIT28, 1);
 213                         ODM_SetBBReg( pDM_Odm, 0x93c, BIT31|BIT30, 2);
 214                         //set for 2ss
 215                         ODM_SetBBReg( pDM_Odm, 0x940, BIT11|BIT10, 0);
 216                         ODM_SetBBReg( pDM_Odm, 0x940, BIT13|BIT12, 1);
 217                         ODM_SetBBReg( pDM_Odm, 0x940, BIT15|BIT14, 2);
 218                         //set for 3ss
 219                         ODM_SetBBReg( pDM_Odm, 0x940, BIT23|BIT22, 0);
 220                         ODM_SetBBReg( pDM_Odm, 0x940, BIT25|BIT24, 1);
 221                         ODM_SetBBReg( pDM_Odm, 0x940, BIT27|BIT26, 2);
 222                 }
 223         }
 224         else    if(num_enable_path == 4)
 225         {
 226                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" Trun on path ((A  B C D))\n"));
 227         }
 228
 229 }
 230
 231 VOID
 232 phydm_find_default_path(
 233         IN      PVOID   pDM_VOID
 234         )
 235 {
 236         PDM_ODM_T               pDM_Odm = (PDM_ODM_T)pDM_VOID;
 237         pPATHDIV_T              pDM_PathDiv = &pDM_Odm->DM_PathDiv;
 238         u4Byte  rssi_avg_a=0, rssi_avg_b=0, rssi_avg_c=0, rssi_avg_d=0, rssi_avg_bcd=0;
 239         u4Byte  rssi_total_a=0, rssi_total_b=0, rssi_total_c=0, rssi_total_d=0;
 240
 241         //2 Default Path Selection By RSSI
 242
 243         rssi_avg_a = (pDM_PathDiv->path_a_cnt_all > 0)? (pDM_PathDiv->path_a_sum_all / pDM_PathDiv->path_a_cnt_all) :0 ;
 244         rssi_avg_b = (pDM_PathDiv->path_b_cnt_all > 0)? (pDM_PathDiv->path_b_sum_all / pDM_PathDiv->path_b_cnt_all) :0 ;
 245         rssi_avg_c = (pDM_PathDiv->path_c_cnt_all > 0)? (pDM_PathDiv->path_c_sum_all / pDM_PathDiv->path_c_cnt_all) :0 ;
 246         rssi_avg_d = (pDM_PathDiv->path_d_cnt_all > 0)? (pDM_PathDiv->path_d_sum_all / pDM_PathDiv->path_d_cnt_all) :0 ;
 247
 248
 249         pDM_PathDiv->path_a_sum_all = 0;
 250         pDM_PathDiv->path_a_cnt_all = 0;
 251         pDM_PathDiv->path_b_sum_all = 0;
 252         pDM_PathDiv->path_b_cnt_all = 0;
 253         pDM_PathDiv->path_c_sum_all = 0;
 254         pDM_PathDiv->path_c_cnt_all = 0;
 255         pDM_PathDiv->path_d_sum_all = 0;
 256         pDM_PathDiv->path_d_cnt_all = 0;
 257
 258         if(pDM_PathDiv->use_path_a_as_default_ant == 1)
 259         {
 260                 rssi_avg_bcd=(rssi_avg_b+rssi_avg_c+rssi_avg_d)/3;
 261
 262                 if( (rssi_avg_a + ANT_DECT_RSSI_TH) > rssi_avg_bcd  )
 263                 {
 264                         pDM_PathDiv->is_pathA_exist=TRUE;
 265                         pDM_PathDiv->default_path=PATH_A;
 266                 }
 267                 else
 268                 {
 269                         pDM_PathDiv->is_pathA_exist=FALSE;
 270                 }
 271         }
 272         else
 273         {
 274                 if( (rssi_avg_a >=rssi_avg_b) && (rssi_avg_a >=rssi_avg_c)&&(rssi_avg_a >=rssi_avg_d))
 275                         pDM_PathDiv->default_path=PATH_A;
 276                 else if(  (rssi_avg_b >=rssi_avg_c)&&(rssi_avg_b >=rssi_avg_d))
 277                         pDM_PathDiv->default_path=PATH_B;
 278                 else if(  rssi_avg_c >=rssi_avg_d)
 279                         pDM_PathDiv->default_path=PATH_C;
 280                 else
 281                         pDM_PathDiv->default_path=PATH_D;
 282         }
 283
 284
 285 }
 286
 287
 288 VOID
 289 phydm_candidate_dtp_update(
 290         IN      PVOID   pDM_VOID
 291         )
 292 {
 293         PDM_ODM_T               pDM_Odm = (PDM_ODM_T)pDM_VOID;
 294         pPATHDIV_T              pDM_PathDiv = &pDM_Odm->DM_PathDiv;
 295
 296         pDM_PathDiv->num_candidate=3;
 297
 298         if(pDM_PathDiv->use_path_a_as_default_ant == 1)
 299         {
 300                 if(pDM_PathDiv->num_tx_path==3)
 301                 {
 302                         if(pDM_PathDiv->is_pathA_exist)
 303                         {
 304                                 pDM_PathDiv->ant_candidate_1 =  PHYDM_ABC;
 305                                 pDM_PathDiv->ant_candidate_2 =  PHYDM_ABD;
 306                                 pDM_PathDiv->ant_candidate_3 =  PHYDM_ACD;
 307                         }
 308                         else // use path BCD
 309                         {
 310                                 pDM_PathDiv->num_candidate=1;
 311                                 phydm_dtp_fix_tx_path(pDM_Odm, PHYDM_BCD);
 312                                 return;
 313                         }
 314                 }
 315                 else    if(pDM_PathDiv->num_tx_path==2)
 316                 {
 317                         if(pDM_PathDiv->is_pathA_exist)
 318                         {
 319                                 pDM_PathDiv->ant_candidate_1 =  PHYDM_AB;
 320                                 pDM_PathDiv->ant_candidate_2 =  PHYDM_AC;
 321                                 pDM_PathDiv->ant_candidate_3 =  PHYDM_AD;
 322                         }
 323                         else
 324                         {
 325                                 pDM_PathDiv->ant_candidate_1 =  PHYDM_BC;
 326                                 pDM_PathDiv->ant_candidate_2 =  PHYDM_BD;
 327                                 pDM_PathDiv->ant_candidate_3 =  PHYDM_CD;
 328                         }
 329                 }
 330         }
 331         else
 332         {
 333                 //2 3 TX Mode
 334                 if(pDM_PathDiv->num_tx_path==3)//choose 3 ant form 4
 335                 {
 336                         if(pDM_PathDiv->default_path == PATH_A) //choose 2 ant form 3
 337                         {
 338                                 pDM_PathDiv->ant_candidate_1 =  PHYDM_ABC;
 339                                 pDM_PathDiv->ant_candidate_2 =  PHYDM_ABD;
 340                                 pDM_PathDiv->ant_candidate_3 =  PHYDM_ACD;
 341                         }
 342                         else if(pDM_PathDiv->default_path==PATH_B)
 343                         {
 344                                 pDM_PathDiv->ant_candidate_1 =  PHYDM_ABC;
 345                                 pDM_PathDiv->ant_candidate_2 =  PHYDM_ABD;
 346                                 pDM_PathDiv->ant_candidate_3 =  PHYDM_BCD;
 347                         }
 348                         else if(pDM_PathDiv->default_path == PATH_C)
 349                         {
 350                                 pDM_PathDiv->ant_candidate_1 =  PHYDM_ABC;
 351                                 pDM_PathDiv->ant_candidate_2 =  PHYDM_ACD;
 352                                 pDM_PathDiv->ant_candidate_3 =  PHYDM_BCD;
 353                         }
 354                         else if(pDM_PathDiv->default_path == PATH_D)
 355                         {
 356                                 pDM_PathDiv->ant_candidate_1 =  PHYDM_ABD;
 357                                 pDM_PathDiv->ant_candidate_2 =  PHYDM_ACD;
 358                                 pDM_PathDiv->ant_candidate_3 =  PHYDM_BCD;
 359                         }
 360                 }
 361
 362                 //2 2 TX Mode
 363                 else if(pDM_PathDiv->num_tx_path==2)//choose 2 ant form 4
 364                 {
 365                         if(pDM_PathDiv->default_path == PATH_A) //choose 2 ant form 3
 366                         {
 367                                 pDM_PathDiv->ant_candidate_1 =  PHYDM_AB;
 368                                 pDM_PathDiv->ant_candidate_2 =  PHYDM_AC;
 369                                 pDM_PathDiv->ant_candidate_3 =  PHYDM_AD;
 370                         }
 371                         else if(pDM_PathDiv->default_path==PATH_B)
 372                         {
 373                                 pDM_PathDiv->ant_candidate_1 =  PHYDM_AB;
 374                                 pDM_PathDiv->ant_candidate_2 =  PHYDM_BC;
 375                                 pDM_PathDiv->ant_candidate_3 =  PHYDM_BD;
 376                         }
 377                         else if(pDM_PathDiv->default_path == PATH_C)
 378                         {
 379                                 pDM_PathDiv->ant_candidate_1 =  PHYDM_AC;
 380                                 pDM_PathDiv->ant_candidate_2 =  PHYDM_BC;
 381                                 pDM_PathDiv->ant_candidate_3 =  PHYDM_CD;
 382                         }
 383                         else if(pDM_PathDiv->default_path == PATH_D)
 384                         {
 385                                 pDM_PathDiv->ant_candidate_1=  PHYDM_AD;
 386                                 pDM_PathDiv->ant_candidate_2 =  PHYDM_BD;
 387                                 pDM_PathDiv->ant_candidate_3=  PHYDM_CD;
 388                         }
 389                 }
 390         }
 391 }
 392
 393
 394 VOID
 395 phydm_dynamic_tx_path(
 396         IN      PVOID   pDM_VOID
 397 )
 398 {
 399         PDM_ODM_T               pDM_Odm = (PDM_ODM_T)pDM_VOID;
 400         pPATHDIV_T              pDM_PathDiv = &pDM_Odm->DM_PathDiv;
 401
 402         PSTA_INFO_T     pEntry;
 403         u4Byte  i;
 404         u1Byte  num_client=0;
 405         u1Byte  H2C_Parameter[6] ={0};
 406
 407
 408         if(!pDM_Odm->bLinked) //bLinked==False
 409         {
 410                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("DTP_8814 [No Link!!!]\n"));
 411
 412                 if(pDM_PathDiv->bBecomeLinked == TRUE)
 413                 {
 414                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" [Be disconnected]----->\n"));
 415                         pDM_PathDiv->bBecomeLinked = pDM_Odm->bLinked;
 416                 }
 417                 return;
 418         }
 419         else
 420         {
 421                 if(pDM_PathDiv->bBecomeLinked ==FALSE)
 422                 {
 423                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, (" [Be Linked !!!]----->\n"));
 424                         pDM_PathDiv->bBecomeLinked = pDM_Odm->bLinked;
 425                 }
 426         }
 427
 428         //2 [Period CTRL]
 429         if(pDM_PathDiv->dtp_period >=2)
 430         {
 431                 pDM_PathDiv->dtp_period=0;
 432         }
 433         else
 434         {
 435                 //ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("Phydm_Dynamic_Tx_Path_8814A()  Stay = (( %d ))\n",pDM_PathDiv->dtp_period));
 436                 pDM_PathDiv->dtp_period++;
 437                 return;
 438         }
 439
 440
 441         //2 [Fix Path]
 442         if (pDM_Odm->path_select != PHYDM_AUTO_PATH)
 443         {
 444                 return;
 445         }
 446
 447         //2 [Check Bfer]
 448         #if (DM_ODM_SUPPORT_TYPE == ODM_WIN)
 449         #endif
 450
 451         if(pDM_PathDiv->use_path_a_as_default_ant ==1)
 452         {
 453                 phydm_find_default_path(pDM_Odm);
 454                 phydm_candidate_dtp_update(pDM_Odm);
 455         }
 456         else
 457         {
 458                 if( pDM_PathDiv->dtp_state == PHYDM_DTP_INIT)
 459                 {
 460                         phydm_find_default_path(pDM_Odm);
 461                         phydm_candidate_dtp_update(pDM_Odm);
 462                         pDM_PathDiv->dtp_state = PHYDM_DTP_RUNNING_1;
 463                 }
 464
 465                 else    if( pDM_PathDiv->dtp_state == PHYDM_DTP_RUNNING_1)
 466                 {
 467                         pDM_PathDiv->dtp_check_patha_counter++;
 468
 469                         if(pDM_PathDiv->dtp_check_patha_counter>=NUM_RESET_DTP_PERIOD)
 470                         {
 471                                 pDM_PathDiv->dtp_check_patha_counter=0;
 472                                 pDM_PathDiv->dtp_state = PHYDM_DTP_INIT;
 473                         }
 474                         //2 Search space update
 475                         else
 476                         {
 477                                 // 1.  find the worst candidate
 478
 479
 480                                 // 2. repalce the worst candidate
 481                         }
 482                 }
 483         }
 484
 485         //2 Dynamic Path Selection H2C
 486
 487         if(pDM_PathDiv->num_candidate == 1)
 488         {
 489                 return;
 490         }
 491         else
 492         {
 493                 H2C_Parameter[0] =  pDM_PathDiv->num_candidate;
 494                 H2C_Parameter[1] =  pDM_PathDiv->num_tx_path;
 495                 H2C_Parameter[2] =  pDM_PathDiv->ant_candidate_1;
 496                 H2C_Parameter[3] =  pDM_PathDiv->ant_candidate_2;
 497                 H2C_Parameter[4] =  pDM_PathDiv->ant_candidate_3;
 498
 499                 ODM_FillH2CCmd(pDM_Odm, PHYDM_H2C_DYNAMIC_TX_PATH, 6, H2C_Parameter);
 500         }
 501
 502 }
 503
 504
 505
 506 VOID
 507 phydm_dynamic_tx_path_init(
 508         IN      PVOID   pDM_VOID
 509         )
 510 {
 511         PDM_ODM_T               pDM_Odm = (PDM_ODM_T)pDM_VOID;
 512         pPATHDIV_T              pDM_PathDiv  = &(pDM_Odm->DM_PathDiv);
 513         PADAPTER                pAdapter = pDM_Odm->Adapter;
 514         #if (DM_ODM_SUPPORT_TYPE == ODM_WIN)
 515         USB_MODE_MECH   *pUsbModeMech = &pAdapter->UsbModeMechanism;
 516         #endif
 517         u1Byte                  search_space_2[NUM_CHOOSE2_FROM4]= {PHYDM_AB, PHYDM_AC, PHYDM_AD, PHYDM_BC, PHYDM_BD, PHYDM_CD };
 518         u1Byte                  search_space_3[NUM_CHOOSE3_FROM4]= {PHYDM_BCD, PHYDM_ACD,  PHYDM_ABD, PHYDM_ABC};
 519
 520         #if (DM_ODM_SUPPORT_TYPE == ODM_WIN)
 521                 pDM_PathDiv->is_u3_mode = (pUsbModeMech->CurUsbMode==USB_MODE_U3)? 1 : 0 ;
 522         #else
 523                 pDM_PathDiv->is_u3_mode = 1;
 524         #endif
 525         ODM_RT_TRACE(pDM_Odm, ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("Dynamic TX Path Init 8814\n"));
 526         ODM_RT_TRACE(pDM_Odm, ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("is_u3_mode = (( %d ))\n", pDM_PathDiv->is_u3_mode));
 527
 528         memcpy(&(pDM_PathDiv->search_space_2[0]), &(search_space_2[0]), NUM_CHOOSE2_FROM4);
 529         memcpy(&(pDM_PathDiv->search_space_3[0]), &(search_space_3[0]), NUM_CHOOSE3_FROM4);
 530
 531         pDM_PathDiv->use_path_a_as_default_ant= 1;
 532         pDM_PathDiv->dtp_state = PHYDM_DTP_INIT;
 533         pDM_Odm->path_select = PHYDM_AUTO_PATH;
 534         pDM_PathDiv->path_div_type = PHYDM_4R_PATH_DIV;
 535
 536
 537         if(pDM_PathDiv->is_u3_mode )
 538         {
 539                 pDM_PathDiv->num_tx_path=3;
 540                 phydm_dtp_fix_tx_path(pDM_Odm, PHYDM_BCD);/* 3TX  Set Init TX Path*/
 541
 542         }
 543         else
 544         {
 545                 pDM_PathDiv->num_tx_path=2;
 546                 phydm_dtp_fix_tx_path(pDM_Odm, PHYDM_BC);/* 2TX // Set Init TX Path*/
 547         }
 548
 549 }
 550
 551
 552 VOID
 553 phydm_process_rssi_for_path_div(
 554         IN OUT          PVOID                   pDM_VOID,
 555         IN                      PVOID                   p_phy_info_void,
 556         IN                      PVOID                   p_pkt_info_void
 557         )
 558 {
 559         PDM_ODM_T                       pDM_Odm = (PDM_ODM_T)pDM_VOID;
 560         PODM_PHY_INFO_T                 pPhyInfo=(PODM_PHY_INFO_T)p_phy_info_void;
 561         PODM_PACKET_INFO_T       pPktinfo=(PODM_PACKET_INFO_T)p_pkt_info_void;
 562         pPATHDIV_T                      pDM_PathDiv  = &(pDM_Odm->DM_PathDiv);
 563
 564         if(pPktinfo->bPacketToSelf || pPktinfo->bPacketMatchBSSID)
 565         {
 566                 if(pPktinfo->DataRate > ODM_RATE11M)
 567                 {
 568                         if(pDM_PathDiv->path_div_type == PHYDM_4R_PATH_DIV)
 569                         {
 570                                 #if RTL8814A_SUPPORT
 571                                 if(pDM_Odm->SupportICType & ODM_RTL8814A)
 572                                 {
 573                                         pDM_PathDiv->path_a_sum_all+=pPhyInfo->RxMIMOSignalStrength[0];
 574                                         pDM_PathDiv->path_a_cnt_all++;
 575
 576                                         pDM_PathDiv->path_b_sum_all+=pPhyInfo->RxMIMOSignalStrength[1];
 577                                         pDM_PathDiv->path_b_cnt_all++;
 578
 579                                         pDM_PathDiv->path_c_sum_all+=pPhyInfo->RxMIMOSignalStrength[2];
 580                                         pDM_PathDiv->path_c_cnt_all++;
 581
 582                                         pDM_PathDiv->path_d_sum_all+=pPhyInfo->RxMIMOSignalStrength[3];
 583                                         pDM_PathDiv->path_d_cnt_all++;
 584                                 }
 585                                 #endif
 586                         }
 587                         else
 588                         {
 589                                 pDM_PathDiv->PathA_Sum[pPktinfo->StationID]+=pPhyInfo->RxMIMOSignalStrength[0];
 590                                 pDM_PathDiv->PathA_Cnt[pPktinfo->StationID]++;
 591
 592                                 pDM_PathDiv->PathB_Sum[pPktinfo->StationID]+=pPhyInfo->RxMIMOSignalStrength[1];
 593                                 pDM_PathDiv->PathB_Cnt[pPktinfo->StationID]++;
 594                         }
 595                 }
 596         }
 597
 598
 599 }
 600
 601 #endif //#if RTL8814A_SUPPORT
 602
 603 VOID
 604 odm_pathdiv_debug(
 605         IN              PVOID           pDM_VOID,
 606         IN              u4Byte          *const dm_value,
 607         IN              u4Byte          *_used,
 608         OUT             char                    *output,
 609         IN              u4Byte          *_out_len
 610         )
 611 {
 612         PDM_ODM_T               pDM_Odm = (PDM_ODM_T)pDM_VOID;
 613         pPATHDIV_T                      pDM_PathDiv  = &(pDM_Odm->DM_PathDiv);
 614         u4Byte used = *_used;
 615         u4Byte out_len = *_out_len;
 616
 617         pDM_Odm->path_select = (dm_value[0] & 0xf);
 618         PHYDM_SNPRINTF((output+used, out_len-used,"Path_select = (( 0x%x ))\n",pDM_Odm->path_select ));
 619
 620         //2 [Fix Path]
 621         if (pDM_Odm->path_select != PHYDM_AUTO_PATH)
 622         {
 623                 PHYDM_SNPRINTF((output+used, out_len-used,"Trun on path  [%s%s%s%s]\n",
 624                         ((pDM_Odm->path_select) & 0x1)?"A":"",
 625                         ((pDM_Odm->path_select) & 0x2)?"B":"",
 626                         ((pDM_Odm->path_select) & 0x4)?"C":"",
 627                         ((pDM_Odm->path_select) & 0x8)?"D":"" ));
 628
 629                 phydm_dtp_fix_tx_path( pDM_Odm, pDM_Odm->path_select );
 630         }
 631         else
 632         {
 633                 PHYDM_SNPRINTF((output+used, out_len-used,"%s\n","Auto Path"));
 634         }
 635 }
 636
 637 #endif // #if(defined(CONFIG_PATH_DIVERSITY))
 638
 639 VOID
 640 phydm_c2h_dtp_handler(
 641  IN     PVOID   pDM_VOID,
 642  IN     pu1Byte   CmdBuf,
 643  IN     u1Byte  CmdLen
 644 )
 645 {
 646 #if(defined(CONFIG_PATH_DIVERSITY))
 647         PDM_ODM_T               pDM_Odm = (PDM_ODM_T)pDM_VOID;
 648         pPATHDIV_T              pDM_PathDiv  = &(pDM_Odm->DM_PathDiv);
 649
 650         u1Byte  macid = CmdBuf[0];
 651         u1Byte  target = CmdBuf[1];
 652         u1Byte  nsc_1 = CmdBuf[2];
 653         u1Byte  nsc_2 = CmdBuf[3];
 654         u1Byte  nsc_3 = CmdBuf[4];
 655
 656         ODM_RT_TRACE(pDM_Odm, ODM_COMP_PATH_DIV,ODM_DBG_LOUD,("Target_candidate = (( %d ))\n", target));
 657         /*
 658         if( (nsc_1 >= nsc_2) &&  (nsc_1 >= nsc_3))
 659         {
 660                 phydm_dtp_fix_tx_path(pDM_Odm, pDM_PathDiv->ant_candidate_1);
 661         }
 662         else    if( nsc_2 >= nsc_3)
 663         {
 664                 phydm_dtp_fix_tx_path(pDM_Odm, pDM_PathDiv->ant_candidate_2);
 665         }
 666         else
 667         {
 668                 phydm_dtp_fix_tx_path(pDM_Odm, pDM_PathDiv->ant_candidate_3);
 669         }
 670         */
 671 #endif
 672 }
 673
 674 VOID
 675 odm_PathDiversity(
 676         IN      PVOID   pDM_VOID
 677 )
 678 {
 679 #if(defined(CONFIG_PATH_DIVERSITY))
 680         PDM_ODM_T               pDM_Odm = (PDM_ODM_T)pDM_VOID;
 681         if(!(pDM_Odm->SupportAbility & ODM_BB_PATH_DIV))
 682         {
 683                 ODM_RT_TRACE(pDM_Odm, ODM_COMP_PATH_DIV,ODM_DBG_LOUD,("Return: Not Support PathDiv\n"));
 684                 return;
 685         }
 686
 687         #if RTL8812A_SUPPORT
 688
 689         if(pDM_Odm->SupportICType & ODM_RTL8812)
 690                         ODM_PathDiversity_8812A(pDM_Odm);
 691                 else
 692         #endif
 693
 694         #if RTL8814A_SUPPORT
 695                 if(pDM_Odm->SupportICType & ODM_RTL8814A)
 696                         phydm_dynamic_tx_path(pDM_Odm);
 697                 else
 698         #endif
 699                 {}
 700 #endif
 701 }
 702
 703 VOID
 704 odm_PathDiversityInit(
 705         IN      PVOID   pDM_VOID
 706 )
 707 {
 708 #if(defined(CONFIG_PATH_DIVERSITY))
 709         PDM_ODM_T               pDM_Odm = (PDM_ODM_T)pDM_VOID;
 710
 711         /*pDM_Odm->SupportAbility |= ODM_BB_PATH_DIV;*/
 712
 713         if(pDM_Odm->mp_mode == TRUE)
 714                 return;
 715
 716         if(!(pDM_Odm->SupportAbility & ODM_BB_PATH_DIV))
 717         {
 718                 ODM_RT_TRACE(pDM_Odm, ODM_COMP_PATH_DIV,ODM_DBG_LOUD,("Return: Not Support PathDiv\n"));
 719                 return;
 720         }
 721
 722 #if RTL8812A_SUPPORT
 723                 if(pDM_Odm->SupportICType & ODM_RTL8812)
 724                         ODM_PathDiversityInit_8812A(pDM_Odm);
 725                 else
 726         #endif
 727
 728         #if RTL8814A_SUPPORT
 729                 if(pDM_Odm->SupportICType & ODM_RTL8814A)
 730                         phydm_dynamic_tx_path_init(pDM_Odm);
 731                 else
 732         #endif
 733                 {}
 734 #endif
 735 }
 736
 737
 738
 739 #if (DM_ODM_SUPPORT_TYPE == ODM_WIN)
 740 //
 741 // 2011/12/02 MH Copy from MP oursrc for temporarily test.
 742 //
 743 #if RTL8192C_SUPPORT
 744 BOOLEAN
 745 odm_IsConnected_92C(
 746         IN      PADAPTER        Adapter
 747 )
 748 {
 749         PRT_WLAN_STA    pEntry;
 750         PMGNT_INFO              pMgntInfo = &(Adapter->MgntInfo);
 751         u4Byte          i;
 752         BOOLEAN         bConnected=FALSE;
 753
 754         if(pMgntInfo->mAssoc)
 755         {
 756                 bConnected = TRUE;
 757         }
 758         else
 759         {
 760                 for(i = 0; i < ODM_ASSOCIATE_ENTRY_NUM; i++)
 761                 {
 762                         if(IsAPModeExist(Adapter)  && GetFirstExtAdapter(Adapter) != NULL)
 763                                 pEntry = AsocEntry_EnumStation(GetFirstExtAdapter(Adapter), i);
 764                         else
 765                                 pEntry = AsocEntry_EnumStation(GetDefaultAdapter(Adapter), i);
 766
 767                         if(pEntry!=NULL)
 768                         {
 769                                 if(pEntry->bAssociated)
 770                                 {
 771                                         bConnected = TRUE;
 772                                         break;
 773                                 }
 774                         }
 775                         else
 776                         {
 777                                 break;
 778                         }
 779                 }
 780         }
 781         return  bConnected;
 782 }
 783
 784 BOOLEAN
 785 ODM_PathDiversityBeforeLink92C(
 786         //IN    PADAPTER        Adapter
 787         IN              PDM_ODM_T               pDM_Odm
 788         )
 789 {
 790 #if (RT_MEM_SIZE_LEVEL != RT_MEM_SIZE_MINIMUM)
 791         PADAPTER                Adapter = pDM_Odm->Adapter;
 792         HAL_DATA_TYPE*  pHalData = NULL;
 793         PMGNT_INFO              pMgntInfo = NULL;
 794         //pSWAT_T               pDM_SWAT_Table = &Adapter->DM_SWAT_Table;
 795         pPD_T                   pDM_PDTable = NULL;
 796
 797         s1Byte                  Score = 0;
 798         PRT_WLAN_BSS    pTmpBssDesc;
 799         PRT_WLAN_BSS    pTestBssDesc;
 800
 801         u1Byte                  target_chnl = 0;
 802         u2Byte                  index;
 803
 804         if (pDM_Odm->Adapter == NULL)  //For BSOD when plug/unplug fast.  //By YJ,120413
 805         {       // The ODM structure is not initialized.
 806                 return FALSE;
 807         }
 808         pHalData = GET_HAL_DATA(Adapter);
 809         pMgntInfo = &Adapter->MgntInfo;
 810         pDM_PDTable = &Adapter->DM_PDTable;
 811
 812         // Condition that does not need to use path diversity.
 813         if((!(pHalData->CVID_Version==VERSION_1_BEFORE_8703B && IS_92C_SERIAL(pHalData->VersionID))) || (pHalData->PathDivCfg!=1) || pMgntInfo->AntennaTest )
 814         {
 815                 RT_TRACE(COMP_INIT, DBG_LOUD,
 816                                 ("ODM_PathDiversityBeforeLink92C(): No PathDiv Mechanism before link.\n"));
 817                 return FALSE;
 818         }
 819
 820         // Since driver is going to set BB register, it shall check if there is another thread controlling BB/RF.
 821         PlatformAcquireSpinLock(Adapter, RT_RF_STATE_SPINLOCK);
 822         if(pHalData->eRFPowerState!=eRfOn || pMgntInfo->RFChangeInProgress || pMgntInfo->bMediaConnect)
 823         {
 824                 PlatformReleaseSpinLock(Adapter, RT_RF_STATE_SPINLOCK);
 825
 826                 RT_TRACE(COMP_INIT, DBG_LOUD,
 827                                 ("ODM_PathDiversityBeforeLink92C(): RFChangeInProgress(%x), eRFPowerState(%x)\n",
 828                                 pMgntInfo->RFChangeInProgress,
 829                                 pHalData->eRFPowerState));
 830
 831                 //pDM_SWAT_Table->SWAS_NoLink_State = 0;
 832                 pDM_PDTable->PathDiv_NoLink_State = 0;
 833
 834                 return FALSE;
 835         }
 836         else
 837         {
 838                 PlatformReleaseSpinLock(Adapter, RT_RF_STATE_SPINLOCK);
 839         }
 840
 841         //1 Run AntDiv mechanism "Before Link" part.
 842         //if(pDM_SWAT_Table->SWAS_NoLink_State == 0)
 843         if(pDM_PDTable->PathDiv_NoLink_State == 0)
 844         {
 845                 //1 Prepare to do Scan again to check current antenna state.
 846
 847                 // Set check state to next step.
 848                 //pDM_SWAT_Table->SWAS_NoLink_State = 1;
 849                 pDM_PDTable->PathDiv_NoLink_State = 1;
 850
 851                 // Copy Current Scan list.
 852                 Adapter->MgntInfo.tmpNumBssDesc = pMgntInfo->NumBssDesc;
 853                 PlatformMoveMemory((PVOID)Adapter->MgntInfo.tmpbssDesc, (PVOID)pMgntInfo->bssDesc, sizeof(RT_WLAN_BSS)*MAX_BSS_DESC);
 854
 855                 // Switch Antenna to another one.
 856                 if(pDM_PDTable->DefaultRespPath == 0)
 857                 {
 858                         PHY_SetBBReg(Adapter, rCCK0_AFESetting  , 0x0F000000, 0x05); // TRX path = PathB
 859                         odm_SetRespPath_92C(Adapter, 1);
 860                         pDM_PDTable->OFDMTXPath = 0xFFFFFFFF;
 861                         pDM_PDTable->CCKTXPath = 0xFFFFFFFF;
 862                 }
 863                 else
 864                 {
 865                         PHY_SetBBReg(Adapter, rCCK0_AFESetting  , 0x0F000000, 0x00); // TRX path = PathA
 866                         odm_SetRespPath_92C(Adapter, 0);
 867                         pDM_PDTable->OFDMTXPath = 0x0;
 868                         pDM_PDTable->CCKTXPath = 0x0;
 869                 }
 870 #if 0
 871
 872                 pDM_SWAT_Table->PreAntenna = pDM_SWAT_Table->CurAntenna;
 873                 pDM_SWAT_Table->CurAntenna = (pDM_SWAT_Table->CurAntenna==Antenna_A)?Antenna_B:Antenna_A;
 874
 875                 RT_TRACE(COMP_INIT, DBG_LOUD,
 876                         ("ODM_SwAntDivCheckBeforeLink: Change to Ant(%s) for testing.\n", (pDM_SWAT_Table->CurAntenna==Antenna_A)?"A":"B"));
 877                 //PHY_SetBBReg(Adapter, rFPGA0_XA_RFInterfaceOE, 0x300, DM_SWAT_Table.CurAntenna);
 878                 pDM_SWAT_Table->SWAS_NoLink_BK_Reg860 = ((pDM_SWAT_Table->SWAS_NoLink_BK_Reg860 & 0xfffffcff) | (pDM_SWAT_Table->CurAntenna<<8));
 879                 PHY_SetBBReg(Adapter, rFPGA0_XA_RFInterfaceOE, bMaskDWord, pDM_SWAT_Table->SWAS_NoLink_BK_Reg860);
 880 #endif
 881
 882                 // Go back to scan function again.
 883                 RT_TRACE(COMP_INIT, DBG_LOUD, ("ODM_PathDiversityBeforeLink92C: Scan one more time\n"));
 884                 pMgntInfo->ScanStep=0;
 885                 target_chnl = odm_SwAntDivSelectScanChnl(Adapter);
 886                 odm_SwAntDivConstructScanChnl(Adapter, target_chnl);
 887                 PlatformSetTimer(Adapter, &pMgntInfo->ScanTimer, 5);
 888
 889                 return TRUE;
 890         }
 891         else
 892         {
 893                 //1 ScanComple() is called after antenna swiched.
 894                 //1 Check scan result and determine which antenna is going
 895                 //1 to be used.
 896
 897                 for(index=0; index<Adapter->MgntInfo.tmpNumBssDesc; index++)
 898                 {
 899                         pTmpBssDesc = &(Adapter->MgntInfo.tmpbssDesc[index]);
 900                         pTestBssDesc = &(pMgntInfo->bssDesc[index]);
 901
 902                         if(PlatformCompareMemory(pTestBssDesc->bdBssIdBuf, pTmpBssDesc->bdBssIdBuf, 6)!=0)
 903                         {
 904                                 RT_TRACE(COMP_INIT, DBG_LOUD, ("ODM_PathDiversityBeforeLink92C(): ERROR!! This shall not happen.\n"));
 905                                 continue;
 906                         }
 907
 908                         if(pTmpBssDesc->RecvSignalPower > pTestBssDesc->RecvSignalPower)
 909                         {
 910                                 RT_TRACE(COMP_INIT, DBG_LOUD, ("ODM_PathDiversityBeforeLink92C: Compare scan entry: Score++\n"));
 911                                 RT_PRINT_STR(COMP_INIT, DBG_LOUD, "SSID: ", pTestBssDesc->bdSsIdBuf, pTestBssDesc->bdSsIdLen);
 912                                 RT_TRACE(COMP_INIT, DBG_LOUD, ("Original: %d, Test: %d\n", pTmpBssDesc->RecvSignalPower, pTestBssDesc->RecvSignalPower));
 913
 914                                 Score++;
 915                                 PlatformMoveMemory(pTestBssDesc, pTmpBssDesc, sizeof(RT_WLAN_BSS));
 916                         }
 917                         else if(pTmpBssDesc->RecvSignalPower < pTestBssDesc->RecvSignalPower)
 918                         {
 919                                 RT_TRACE(COMP_INIT, DBG_LOUD, ("ODM_PathDiversityBeforeLink92C: Compare scan entry: Score--\n"));
 920                                 RT_PRINT_STR(COMP_INIT, DBG_LOUD, "SSID: ", pTestBssDesc->bdSsIdBuf, pTestBssDesc->bdSsIdLen);
 921                                 RT_TRACE(COMP_INIT, DBG_LOUD, ("Original: %d, Test: %d\n", pTmpBssDesc->RecvSignalPower, pTestBssDesc->RecvSignalPower));
 922                                 Score--;
 923                         }
 924
 925                 }
 926
 927                 if(pMgntInfo->NumBssDesc!=0 && Score<=0)
 928                 {
 929                         RT_TRACE(COMP_INIT, DBG_LOUD,
 930                                 ("ODM_PathDiversityBeforeLink92C(): DefaultRespPath=%d\n", pDM_PDTable->DefaultRespPath));
 931
 932                         //pDM_SWAT_Table->PreAntenna = pDM_SWAT_Table->CurAntenna;
 933                 }
 934                 else
 935                 {
 936                         RT_TRACE(COMP_INIT, DBG_LOUD,
 937                                 ("ODM_PathDiversityBeforeLink92C(): DefaultRespPath=%d\n", pDM_PDTable->DefaultRespPath));
 938
 939                         if(pDM_PDTable->DefaultRespPath == 0)
 940                         {
 941                                 pDM_PDTable->OFDMTXPath = 0xFFFFFFFF;
 942                                 pDM_PDTable->CCKTXPath = 0xFFFFFFFF;
 943                                 odm_SetRespPath_92C(Adapter, 1);
 944                         }
 945                         else
 946                         {
 947                                 pDM_PDTable->OFDMTXPath = 0x0;
 948                                 pDM_PDTable->CCKTXPath = 0x0;
 949                                 odm_SetRespPath_92C(Adapter, 0);
 950                         }
 951                         PHY_SetBBReg(Adapter, rCCK0_AFESetting  , 0x0F000000, 0x01); // RX path = PathAB
 952
 953                         //pDM_SWAT_Table->CurAntenna = pDM_SWAT_Table->PreAntenna;
 954
 955                         //PHY_SetBBReg(Adapter, rFPGA0_XA_RFInterfaceOE, 0x300, DM_SWAT_Table.CurAntenna);
 956                         //pDM_SWAT_Table->SWAS_NoLink_BK_Reg860 = ((pDM_SWAT_Table->SWAS_NoLink_BK_Reg860 & 0xfffffcff) | (pDM_SWAT_Table->CurAntenna<<8));
 957                         //PHY_SetBBReg(Adapter, rFPGA0_XA_RFInterfaceOE, bMaskDWord, pDM_SWAT_Table->SWAS_NoLink_BK_Reg860);
 958                 }
 959
 960                 // Check state reset to default and wait for next time.
 961                 //pDM_SWAT_Table->SWAS_NoLink_State = 0;
 962                 pDM_PDTable->PathDiv_NoLink_State = 0;
 963
 964                 return FALSE;
 965         }
 966 #else
 967                 return  FALSE;
 968 #endif
 969
 970 }
 971
 972
 973
 974 VOID
 975 odm_PathDiversityAfterLink_92C(
 976         IN      PADAPTER        Adapter
 977 )
 978 {
 979         HAL_DATA_TYPE           *pHalData = GET_HAL_DATA(Adapter);
 980         PDM_ODM_T               pDM_Odm = &pHalData->DM_OutSrc;
 981         pPD_T           pDM_PDTable = &Adapter->DM_PDTable;
 982         u1Byte          DefaultRespPath=0;
 983
 984         if((!(pHalData->CVID_Version==VERSION_1_BEFORE_8703B && IS_92C_SERIAL(pHalData->VersionID))) || (pHalData->PathDivCfg != 1) || (pHalData->eRFPowerState == eRfOff))
 985         {
 986                 if(pHalData->PathDivCfg == 0)
 987                 {
 988                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("No ODM_TXPathDiversity()\n"));
 989                 }
 990                 else
 991                 {
 992                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("2T ODM_TXPathDiversity()\n"));
 993                 }
 994                 return;
 995         }
 996         if(!odm_IsConnected_92C(Adapter))
 997         {
 998                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("ODM_TXPathDiversity(): No Connections\n"));
 999                 return;
1000         }
1001
1002
1003         if(pDM_PDTable->TrainingState == 0)
1004         {
1005                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("ODM_TXPathDiversity() ==>\n"));
1006                 odm_OFDMTXPathDiversity_92C(Adapter);
1007
1008                 if((pDM_PDTable->CCKPathDivEnable == TRUE) && (pDM_PDTable->OFDM_Pkt_Cnt < 100))
1009                 {
1010                         //RT_TRACE(     COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: TrainingState=0\n"));
1011
1012                         if(pDM_PDTable->CCK_Pkt_Cnt > 300)
1013                                 pDM_PDTable->Timer = 20;
1014                         else if(pDM_PDTable->CCK_Pkt_Cnt > 100)
1015                                 pDM_PDTable->Timer = 60;
1016                         else
1017                                 pDM_PDTable->Timer = 250;
1018                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: timer=%d\n",pDM_PDTable->Timer));
1019
1020                         PHY_SetBBReg(Adapter, rCCK0_AFESetting  , 0x0F000000, 0x00); // RX path = PathA
1021                         pDM_PDTable->TrainingState = 1;
1022                         ODM_SetTimer( pDM_Odm, &pDM_Odm->CCKPathDiversityTimer, pDM_PDTable->Timer); //ms
1023                 }
1024                 else
1025                 {
1026                         pDM_PDTable->CCKTXPath = pDM_PDTable->OFDMTXPath;
1027                         DefaultRespPath = pDM_PDTable->OFDMDefaultRespPath;
1028                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_SetRespPath_92C: Skip odm_CCKTXPathDiversity_92C, DefaultRespPath is OFDM\n"));
1029                         odm_SetRespPath_92C(Adapter, DefaultRespPath);
1030                         odm_ResetPathDiversity_92C(Adapter);
1031                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("ODM_TXPathDiversity() <==\n"));
1032                 }
1033         }
1034         else if(pDM_PDTable->TrainingState == 1)
1035         {
1036                 //RT_TRACE(     COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: TrainingState=1\n"));
1037                 PHY_SetBBReg(Adapter, rCCK0_AFESetting  , 0x0F000000, 0x05); // RX path = PathB
1038                 pDM_PDTable->TrainingState = 2;
1039                 ODM_SetTimer( pDM_Odm, &pDM_Odm->CCKPathDiversityTimer, pDM_PDTable->Timer); //ms
1040         }
1041         else
1042         {
1043                 //RT_TRACE(     COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: TrainingState=2\n"));
1044                 pDM_PDTable->TrainingState = 0;
1045                 odm_CCKTXPathDiversity_92C(Adapter);
1046                 if(pDM_PDTable->OFDM_Pkt_Cnt != 0)
1047                 {
1048                         DefaultRespPath = pDM_PDTable->OFDMDefaultRespPath;
1049                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_SetRespPath_92C: DefaultRespPath is OFDM\n"));
1050                 }
1051                 else
1052                 {
1053                         DefaultRespPath = pDM_PDTable->CCKDefaultRespPath;
1054                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_SetRespPath_92C: DefaultRespPath is CCK\n"));
1055                 }
1056                 odm_SetRespPath_92C(Adapter, DefaultRespPath);
1057                 odm_ResetPathDiversity_92C(Adapter);
1058                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("ODM_TXPathDiversity() <==\n"));
1059         }
1060
1061 }
1062
1063 VOID
1064 odm_SetRespPath_92C(
1065         IN      PADAPTER        Adapter,
1066         IN      u1Byte  DefaultRespPath
1067         )
1068 {
1069         pPD_T   pDM_PDTable = &Adapter->DM_PDTable;
1070
1071         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_SetRespPath_92C: Select Response Path=%d\n",DefaultRespPath));
1072         if(DefaultRespPath != pDM_PDTable->DefaultRespPath)
1073         {
1074                 if(DefaultRespPath == 0)
1075                 {
1076                         PlatformEFIOWrite1Byte(Adapter, 0x6D8, (PlatformEFIORead1Byte(Adapter, 0x6D8)&0xc0)|0x15);
1077                 }
1078                 else
1079                 {
1080                         PlatformEFIOWrite1Byte(Adapter, 0x6D8, (PlatformEFIORead1Byte(Adapter, 0x6D8)&0xc0)|0x2A);
1081                 }
1082         }
1083         pDM_PDTable->DefaultRespPath = DefaultRespPath;
1084 }
1085
1086 VOID
1087 odm_OFDMTXPathDiversity_92C(
1088         IN      PADAPTER        Adapter)
1089 {
1090 //      HAL_DATA_TYPE           *pHalData = GET_HAL_DATA(Adapter);
1091         PMGNT_INFO              pMgntInfo = &(Adapter->MgntInfo);
1092         PRT_WLAN_STA    pEntry;
1093         u1Byte  i, DefaultRespPath = 0;
1094         s4Byte  MinRSSI = 0xFF;
1095         pPD_T   pDM_PDTable = &Adapter->DM_PDTable;
1096         pDM_PDTable->OFDMTXPath = 0;
1097
1098         //1 Default Port
1099         if(pMgntInfo->mAssoc)
1100         {
1101                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: Default port RSSI[0]=%d, RSSI[1]=%d\n",
1102                         Adapter->RxStats.RxRSSIPercentage[0], Adapter->RxStats.RxRSSIPercentage[1]));
1103                 if(Adapter->RxStats.RxRSSIPercentage[0] > Adapter->RxStats.RxRSSIPercentage[1])
1104                 {
1105                         pDM_PDTable->OFDMTXPath = pDM_PDTable->OFDMTXPath & (~BIT0);
1106                         MinRSSI =  Adapter->RxStats.RxRSSIPercentage[1];
1107                         DefaultRespPath = 0;
1108                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: Default port Select Path-0\n"));
1109                 }
1110                 else
1111                 {
1112                         pDM_PDTable->OFDMTXPath =  pDM_PDTable->OFDMTXPath | BIT0;
1113                         MinRSSI =  Adapter->RxStats.RxRSSIPercentage[0];
1114                         DefaultRespPath = 1;
1115                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: Default port Select Path-1\n"));
1116                 }
1117                         //RT_TRACE(     COMP_INIT, DBG_LOUD, ("pDM_PDTable->OFDMTXPath =0x%x\n",pDM_PDTable->OFDMTXPath));
1118         }
1119         //1 Extension Port
1120         for(i = 0; i < ODM_ASSOCIATE_ENTRY_NUM; i++)
1121         {
1122                 if(IsAPModeExist(Adapter)  && GetFirstExtAdapter(Adapter) != NULL)
1123                         pEntry = AsocEntry_EnumStation(GetFirstExtAdapter(Adapter), i);
1124                 else
1125                         pEntry = AsocEntry_EnumStation(GetDefaultAdapter(Adapter), i);
1126
1127                 if(pEntry!=NULL)
1128                 {
1129                         if(pEntry->bAssociated)
1130                         {
1131                                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: MACID=%d, RSSI_0=%d, RSSI_1=%d\n",
1132                                         pEntry->AssociatedMacId, pEntry->rssi_stat.RxRSSIPercentage[0], pEntry->rssi_stat.RxRSSIPercentage[1]));
1133
1134                                 if(pEntry->rssi_stat.RxRSSIPercentage[0] > pEntry->rssi_stat.RxRSSIPercentage[1])
1135                                 {
1136                                         pDM_PDTable->OFDMTXPath = pDM_PDTable->OFDMTXPath & ~(BIT(pEntry->AssociatedMacId));
1137                                         //pHalData->TXPath = pHalData->TXPath & ~(1<<(pEntry->AssociatedMacId));
1138                                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: MACID=%d Select Path-0\n", pEntry->AssociatedMacId));
1139                                         if(pEntry->rssi_stat.RxRSSIPercentage[1] < MinRSSI)
1140                                         {
1141                                                 MinRSSI = pEntry->rssi_stat.RxRSSIPercentage[1];
1142                                                 DefaultRespPath = 0;
1143                                         }
1144                                 }
1145                                 else
1146                                 {
1147                                         pDM_PDTable->OFDMTXPath = pDM_PDTable->OFDMTXPath | BIT(pEntry->AssociatedMacId);
1148                                         //pHalData->TXPath = pHalData->TXPath | (1 << (pEntry->AssociatedMacId));
1149                                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: MACID=%d Select Path-1\n", pEntry->AssociatedMacId));
1150                                         if(pEntry->rssi_stat.RxRSSIPercentage[0] < MinRSSI)
1151                                         {
1152                                                 MinRSSI = pEntry->rssi_stat.RxRSSIPercentage[0];
1153                                                 DefaultRespPath = 1;
1154                                         }
1155                                 }
1156                         }
1157                 }
1158                 else
1159                 {
1160                         break;
1161                 }
1162         }
1163
1164         pDM_PDTable->OFDMDefaultRespPath = DefaultRespPath;
1165 }
1166
1167
1168 VOID
1169 odm_CCKTXPathDiversity_92C(
1170         IN      PADAPTER        Adapter
1171 )
1172 {
1173         HAL_DATA_TYPE           *pHalData = GET_HAL_DATA(Adapter);
1174         PMGNT_INFO              pMgntInfo = &(Adapter->MgntInfo);
1175         PRT_WLAN_STA    pEntry;
1176         s4Byte  MinRSSI = 0xFF;
1177         u1Byte  i, DefaultRespPath = 0;
1178 //      BOOLEAN bBModePathDiv = FALSE;
1179         pPD_T   pDM_PDTable = &Adapter->DM_PDTable;
1180
1181         //1 Default Port
1182         if(pMgntInfo->mAssoc)
1183         {
1184                 if(pHalData->OFDM_Pkt_Cnt == 0)
1185                 {
1186                         for(i=0; i<2; i++)
1187                         {
1188                                 if(pDM_PDTable->RSSI_CCK_Path_cnt[i] > 1) //Because the first packet is discarded
1189                                         pDM_PDTable->RSSI_CCK_Path[i] = pDM_PDTable->RSSI_CCK_Path[i] / (pDM_PDTable->RSSI_CCK_Path_cnt[i]-1);
1190                                 else
1191                                         pDM_PDTable->RSSI_CCK_Path[i] = 0;
1192                         }
1193                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: pDM_PDTable->RSSI_CCK_Path[0]=%d, pDM_PDTable->RSSI_CCK_Path[1]=%d\n",
1194                                 pDM_PDTable->RSSI_CCK_Path[0], pDM_PDTable->RSSI_CCK_Path[1]));
1195                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: pDM_PDTable->RSSI_CCK_Path_cnt[0]=%d, pDM_PDTable->RSSI_CCK_Path_cnt[1]=%d\n",
1196                                 pDM_PDTable->RSSI_CCK_Path_cnt[0], pDM_PDTable->RSSI_CCK_Path_cnt[1]));
1197
1198                         if(pDM_PDTable->RSSI_CCK_Path[0] > pDM_PDTable->RSSI_CCK_Path[1])
1199                         {
1200                                 pDM_PDTable->CCKTXPath = pDM_PDTable->CCKTXPath & (~BIT0);
1201                                 MinRSSI =  pDM_PDTable->RSSI_CCK_Path[1];
1202                                 DefaultRespPath = 0;
1203                                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Default port Select CCK Path-0\n"));
1204                         }
1205                         else if(pDM_PDTable->RSSI_CCK_Path[0] < pDM_PDTable->RSSI_CCK_Path[1])
1206                         {
1207                                 pDM_PDTable->CCKTXPath =  pDM_PDTable->CCKTXPath | BIT0;
1208                                 MinRSSI =  pDM_PDTable->RSSI_CCK_Path[0];
1209                                 DefaultRespPath = 1;
1210                                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Default port Select CCK Path-1\n"));
1211                         }
1212                         else
1213                         {
1214                                 if((pDM_PDTable->RSSI_CCK_Path[0] != 0) && (pDM_PDTable->RSSI_CCK_Path[0] < MinRSSI))
1215                                 {
1216                                         pDM_PDTable->CCKTXPath = pDM_PDTable->CCKTXPath & (~BIT0);
1217                                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Default port Select CCK Path-0\n"));
1218                                         MinRSSI =  pDM_PDTable->RSSI_CCK_Path[1];
1219                                         DefaultRespPath = 0;
1220                                 }
1221                                 else
1222                                 {
1223                                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Default port unchange CCK Path\n"));
1224                                 }
1225                         }
1226                 }
1227                 else //Follow OFDM decision
1228                 {
1229                         pDM_PDTable->CCKTXPath = (pDM_PDTable->CCKTXPath & (~BIT0)) | (pDM_PDTable->OFDMTXPath &BIT0);
1230                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Follow OFDM decision, Default port Select CCK Path-%d\n",
1231                                 pDM_PDTable->CCKTXPath &BIT0));
1232                 }
1233         }
1234         //1 Extension Port
1235         for(i = 0; i < ODM_ASSOCIATE_ENTRY_NUM; i++)
1236         {
1237                 if(IsAPModeExist(Adapter)  && GetFirstExtAdapter(Adapter) != NULL)
1238                         pEntry = AsocEntry_EnumStation(GetFirstExtAdapter(Adapter), i);
1239                 else
1240                         pEntry = AsocEntry_EnumStation(GetDefaultAdapter(Adapter), i);
1241
1242                 if(pEntry!=NULL)
1243                 {
1244                         if(pEntry->bAssociated)
1245                         {
1246                                 if(pEntry->rssi_stat.OFDM_Pkt_Cnt == 0)
1247                                 {
1248                                         u1Byte j=0;
1249                                         for(j=0; j<2; j++)
1250                                         {
1251                                                 if(pEntry->rssi_stat.RSSI_CCK_Path_cnt[j] > 1)
1252                                                         pEntry->rssi_stat.RSSI_CCK_Path[j] = pEntry->rssi_stat.RSSI_CCK_Path[j] / (pEntry->rssi_stat.RSSI_CCK_Path_cnt[j]-1);
1253                                                 else
1254                                                         pEntry->rssi_stat.RSSI_CCK_Path[j] = 0;
1255                                         }
1256                                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: MACID=%d, RSSI_CCK0=%d, RSSI_CCK1=%d\n",
1257                                                 pEntry->AssociatedMacId, pEntry->rssi_stat.RSSI_CCK_Path[0], pEntry->rssi_stat.RSSI_CCK_Path[1]));
1258
1259                                         if(pEntry->rssi_stat.RSSI_CCK_Path[0] >pEntry->rssi_stat.RSSI_CCK_Path[1])
1260                                         {
1261                                                 pDM_PDTable->CCKTXPath = pDM_PDTable->CCKTXPath & ~(BIT(pEntry->AssociatedMacId));
1262                                                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: MACID=%d Select CCK Path-0\n", pEntry->AssociatedMacId));
1263                                                 if(pEntry->rssi_stat.RSSI_CCK_Path[1] < MinRSSI)
1264                                                 {
1265                                                         MinRSSI = pEntry->rssi_stat.RSSI_CCK_Path[1];
1266                                                         DefaultRespPath = 0;
1267                                                 }
1268                                         }
1269                                         else if(pEntry->rssi_stat.RSSI_CCK_Path[0] <pEntry->rssi_stat.RSSI_CCK_Path[1])
1270                                         {
1271                                                 pDM_PDTable->CCKTXPath = pDM_PDTable->CCKTXPath | BIT(pEntry->AssociatedMacId);
1272                                                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: MACID=%d Select CCK Path-1\n", pEntry->AssociatedMacId));
1273                                                 if(pEntry->rssi_stat.RSSI_CCK_Path[0] < MinRSSI)
1274                                                 {
1275                                                         MinRSSI = pEntry->rssi_stat.RSSI_CCK_Path[0];
1276                                                         DefaultRespPath = 1;
1277                                                 }
1278                                         }
1279                                         else
1280                                         {
1281                                                 if((pEntry->rssi_stat.RSSI_CCK_Path[0] != 0) && (pEntry->rssi_stat.RSSI_CCK_Path[0] < MinRSSI))
1282                                                 {
1283                                                         pDM_PDTable->CCKTXPath = pDM_PDTable->CCKTXPath & ~(BIT(pEntry->AssociatedMacId));
1284                                                         MinRSSI = pEntry->rssi_stat.RSSI_CCK_Path[1];
1285                                                         DefaultRespPath = 0;
1286                                                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: MACID=%d Select CCK Path-0\n", pEntry->AssociatedMacId));
1287                                                 }
1288                                                 else
1289                                                 {
1290                                                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: MACID=%d unchange CCK Path\n", pEntry->AssociatedMacId));
1291                                                 }
1292                                         }
1293                                 }
1294                                 else //Follow OFDM decision
1295                                 {
1296                                         pDM_PDTable->CCKTXPath = (pDM_PDTable->CCKTXPath & (~(BIT(pEntry->AssociatedMacId)))) | (pDM_PDTable->OFDMTXPath & BIT(pEntry->AssociatedMacId));
1297                                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Follow OFDM decision, MACID=%d Select CCK Path-%d\n",
1298                                                 pEntry->AssociatedMacId, (pDM_PDTable->CCKTXPath & BIT(pEntry->AssociatedMacId))>>(pEntry->AssociatedMacId)));
1299                                 }
1300                         }
1301                 }
1302                 else
1303                 {
1304                         break;
1305                 }
1306         }
1307
1308         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C:MinRSSI=%d\n",MinRSSI));
1309
1310         if(MinRSSI == 0xFF)
1311                 DefaultRespPath = pDM_PDTable->CCKDefaultRespPath;
1312
1313         pDM_PDTable->CCKDefaultRespPath = DefaultRespPath;
1314 }
1315
1316
1317 VOID
1318 odm_ResetPathDiversity_92C(
1319                 IN      PADAPTER        Adapter
1320 )
1321 {
1322         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
1323         pPD_T   pDM_PDTable = &Adapter->DM_PDTable;
1324         PRT_WLAN_STA    pEntry;
1325         u4Byte  i,j;
1326
1327         pDM_PDTable->CCK_Pkt_Cnt = 0;
1328         pDM_PDTable->OFDM_Pkt_Cnt = 0;
1329         pHalData->CCK_Pkt_Cnt =0;
1330         pHalData->OFDM_Pkt_Cnt =0;
1331
1332         if(pDM_PDTable->CCKPathDivEnable == TRUE)
1333                 PHY_SetBBReg(Adapter, rCCK0_AFESetting  , 0x0F000000, 0x01); //RX path = PathAB
1334
1335         for(i=0; i<2; i++)
1336         {
1337                 pDM_PDTable->RSSI_CCK_Path_cnt[i]=0;
1338                 pDM_PDTable->RSSI_CCK_Path[i] = 0;
1339         }
1340         for(i = 0; i < ODM_ASSOCIATE_ENTRY_NUM; i++)
1341         {
1342                 if(IsAPModeExist(Adapter)  && GetFirstExtAdapter(Adapter) != NULL)
1343                         pEntry = AsocEntry_EnumStation(GetFirstExtAdapter(Adapter), i);
1344                 else
1345                         pEntry = AsocEntry_EnumStation(GetDefaultAdapter(Adapter), i);
1346
1347                 if(pEntry!=NULL)
1348                 {
1349                         pEntry->rssi_stat.CCK_Pkt_Cnt = 0;
1350                         pEntry->rssi_stat.OFDM_Pkt_Cnt = 0;
1351                         for(j=0; j<2; j++)
1352                         {
1353                                 pEntry->rssi_stat.RSSI_CCK_Path_cnt[j] = 0;
1354                                 pEntry->rssi_stat.RSSI_CCK_Path[j] = 0;
1355                         }
1356                 }
1357                 else
1358                         break;
1359         }
1360 }
1361
1362
1363
1364
1365
1366 VOID
1367 odm_CCKTXPathDiversityCallback(
1368         PRT_TIMER               pTimer
1369 )
1370 {
1371 #if USE_WORKITEM
1372        PADAPTER Adapter = (PADAPTER)pTimer->Adapter;
1373        HAL_DATA_TYPE    *pHalData = GET_HAL_DATA(Adapter);
1374            PDM_ODM_T            pDM_Odm = &pHalData->DM_OutSrc;
1375 #else
1376         PADAPTER        Adapter = (PADAPTER)pTimer->Adapter;
1377 #endif
1378
1379 #if DEV_BUS_TYPE==RT_PCI_INTERFACE
1380 #if USE_WORKITEM
1381         PlatformScheduleWorkItem(&pDM_Odm->CCKPathDiversityWorkitem);
1382 #else
1383         odm_PathDiversityAfterLink_92C(Adapter);
1384 #endif
1385 #else
1386         PlatformScheduleWorkItem(&pDM_Odm->CCKPathDiversityWorkitem);
1387 #endif
1388
1389 }
1390
1391
1392 VOID
1393 odm_CCKTXPathDiversityWorkItemCallback(
1394     IN PVOID            pContext
1395     )
1396 {
1397         PADAPTER        Adapter = (PADAPTER)pContext;
1398
1399         odm_CCKTXPathDiversity_92C(Adapter);
1400 }
1401
1402 //
1403 // 20100514 Luke/Joseph:
1404 // Callback function for 500ms antenna test trying.
1405 //
1406 VOID
1407 odm_PathDivChkAntSwitchCallback(
1408         PRT_TIMER               pTimer
1409 )
1410 {
1411         PADAPTER                Adapter = (PADAPTER)pTimer->Adapter;
1412         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
1413         PDM_ODM_T               pDM_Odm = &pHalData->DM_OutSrc;
1414
1415 #if DEV_BUS_TYPE==RT_PCI_INTERFACE
1416
1417 #if USE_WORKITEM
1418         PlatformScheduleWorkItem(&pDM_Odm->PathDivSwitchWorkitem);
1419 #else
1420         odm_PathDivChkAntSwitch(pDM_Odm);
1421 #endif
1422 #else
1423         PlatformScheduleWorkItem(&pDM_Odm->PathDivSwitchWorkitem);
1424 #endif
1425
1426 //odm_SwAntDivChkAntSwitch(Adapter, SWAW_STEP_DETERMINE);
1427
1428 }
1429
1430
1431 VOID
1432 odm_PathDivChkAntSwitchWorkitemCallback(
1433     IN PVOID            pContext
1434     )
1435 {
1436         PADAPTER        pAdapter = (PADAPTER)pContext;
1437         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(pAdapter);
1438         PDM_ODM_T               pDM_Odm = &pHalData->DM_OutSrc;
1439
1440         odm_PathDivChkAntSwitch(pDM_Odm);
1441 }
1442
1443
1444  //MAC0_ACCESS_PHY1
1445
1446 // 2011-06-22 Neil Chen & Gary Hsin
1447 // Refer to Jr.Luke's SW ANT DIV
1448 // 92D Path Diversity Main function
1449 // refer to 88C software antenna diversity
1450 //
1451 VOID
1452 odm_PathDivChkAntSwitch(
1453         PDM_ODM_T               pDM_Odm
1454         //PADAPTER              Adapter,
1455         //u1Byte                        Step
1456 )
1457 {
1458         PADAPTER                Adapter = pDM_Odm->Adapter;
1459         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
1460         PMGNT_INFO              pMgntInfo = &Adapter->MgntInfo;
1461
1462
1463         pSWAT_T                 pDM_SWAT_Table = &pDM_Odm->DM_SWAT_Table;
1464         s4Byte                  curRSSI=100, RSSI_A, RSSI_B;
1465         u1Byte                  nextAntenna=AUX_ANT;
1466         static u8Byte           lastTxOkCnt=0, lastRxOkCnt=0;
1467         u8Byte                  curTxOkCnt, curRxOkCnt;
1468         static u8Byte           TXByteCnt_A=0, TXByteCnt_B=0, RXByteCnt_A=0, RXByteCnt_B=0;
1469         u8Byte                  CurByteCnt=0, PreByteCnt=0;
1470         static u1Byte           TrafficLoad = TRAFFIC_LOW;
1471         u1Byte                  Score_A=0, Score_B=0;
1472         u1Byte                  i=0x0;
1473        // Neil Chen
1474        static u1Byte        pathdiv_para=0x0;
1475        static u1Byte        switchfirsttime=0x00;
1476         // u1Byte                 regB33 = (u1Byte) PHY_QueryBBReg(Adapter, 0xB30,BIT27);
1477         u1Byte                  regB33 = (u1Byte)ODM_GetBBReg(pDM_Odm, PATHDIV_REG, BIT27);
1478
1479
1480        //u1Byte                 reg637 =0x0;
1481        static u1Byte        fw_value=0x0;
1482         //u8Byte                        curTxOkCnt_tmp, curRxOkCnt_tmp;
1483        PADAPTER            BuddyAdapter = Adapter->BuddyAdapter;     // another adapter MAC
1484         // Path Diversity   //Neil Chen--2011--06--22
1485
1486         //u1Byte                 PathDiv_Trigger = (u1Byte) PHY_QueryBBReg(Adapter, 0xBA0,BIT31);
1487         u1Byte                 PathDiv_Trigger = (u1Byte) ODM_GetBBReg(pDM_Odm, PATHDIV_TRI,BIT31);
1488         u1Byte                 PathDiv_Enable = pHalData->bPathDiv_Enable;
1489
1490
1491         //DbgPrint("Path Div PG Value:%x \n",PathDiv_Enable);
1492        if((BuddyAdapter==NULL)||(!PathDiv_Enable)||(PathDiv_Trigger)||(pHalData->CurrentBandType == BAND_ON_2_4G))
1493        {
1494            return;
1495        }
1496         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD,("===================>odm_PathDivChkAntSwitch()\n"));
1497
1498        // The first time to switch path excluding 2nd, 3rd, ....etc....
1499         if(switchfirsttime==0)
1500         {
1501             if(regB33==0)
1502             {
1503                pDM_SWAT_Table->CurAntenna = MAIN_ANT;    // Default MAC0_5G-->Path A (current antenna)
1504             }
1505         }
1506
1507         // Condition that does not need to use antenna diversity.
1508         if(pDM_Odm->SupportICType != ODM_RTL8192D)
1509         {
1510                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("odm_PathDiversityMechanims(): No PathDiv Mechanism.\n"));
1511                 return;
1512         }
1513
1514         // Radio off: Status reset to default and return.
1515         if(pHalData->eRFPowerState==eRfOff)
1516         {
1517                 //ODM_SwAntDivRestAfterLink(Adapter);
1518                 return;
1519         }
1520
1521        /*
1522         // Handling step mismatch condition.
1523         // Peak step is not finished at last time. Recover the variable and check again.
1524         if(     Step != pDM_SWAT_Table->try_flag        )
1525         {
1526                 ODM_SwAntDivRestAfterLink(Adapter);
1527         } */
1528
1529         if(pDM_SWAT_Table->try_flag == 0xff)
1530         {
1531                 // Select RSSI checking target
1532                 if(pMgntInfo->mAssoc && !ACTING_AS_AP(Adapter))
1533                 {
1534                         // Target: Infrastructure mode AP.
1535                         pHalData->RSSI_target = NULL;
1536                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("odm_PathDivMechanism(): RSSI_target is DEF AP!\n"));
1537                 }
1538                 else
1539                 {
1540                         u1Byte                  index = 0;
1541                         PRT_WLAN_STA    pEntry = NULL;
1542                         PADAPTER                pTargetAdapter = NULL;
1543
1544                         if(     pMgntInfo->mIbss || ACTING_AS_AP(Adapter) )
1545                         {
1546                                 // Target: AP/IBSS peer.
1547                                 pTargetAdapter = Adapter;
1548                         }
1549                         else if(IsAPModeExist(Adapter)  && GetFirstExtAdapter(Adapter) != NULL)
1550                         {
1551                                 // Target: VWIFI peer.
1552                                 pTargetAdapter = GetFirstExtAdapter(Adapter);
1553                         }
1554
1555                         if(pTargetAdapter != NULL)
1556                         {
1557                                 for(index=0; index<ODM_ASSOCIATE_ENTRY_NUM; index++)
1558                                 {
1559                                         pEntry = AsocEntry_EnumStation(pTargetAdapter, index);
1560                                         if(pEntry != NULL)
1561                                         {
1562                                                 if(pEntry->bAssociated)
1563                                                         break;
1564                                         }
1565                                 }
1566                         }
1567
1568                         if(pEntry == NULL)
1569                         {
1570                                 ODM_PathDivRestAfterLink(pDM_Odm);
1571                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("odm_SwAntDivChkAntSwitch(): No Link.\n"));
1572                                 return;
1573                         }
1574                         else
1575                         {
1576                                 pHalData->RSSI_target = pEntry;
1577                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("odm_SwAntDivChkAntSwitch(): RSSI_target is PEER STA\n"));
1578                         }
1579                 }
1580
1581                 pHalData->RSSI_cnt_A = 0;
1582                 pHalData->RSSI_cnt_B = 0;
1583                 pDM_SWAT_Table->try_flag = 0;
1584                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("odm_SwAntDivChkAntSwitch(): Set try_flag to 0 prepare for peak!\n"));
1585                 return;
1586         }
1587         else
1588         {
1589                // 1st step
1590                 curTxOkCnt = Adapter->TxStats.NumTxBytesUnicast - lastTxOkCnt;
1591                 curRxOkCnt = Adapter->RxStats.NumRxBytesUnicast - lastRxOkCnt;
1592                 lastTxOkCnt = Adapter->TxStats.NumTxBytesUnicast;
1593                 lastRxOkCnt = Adapter->RxStats.NumRxBytesUnicast;
1594
1595                 if(pDM_SWAT_Table->try_flag == 1)   // Training State
1596                 {
1597                         if(pDM_SWAT_Table->CurAntenna == MAIN_ANT)
1598                         {
1599                                 TXByteCnt_A += curTxOkCnt;
1600                                 RXByteCnt_A += curRxOkCnt;
1601                         }
1602                         else
1603                         {
1604                                 TXByteCnt_B += curTxOkCnt;
1605                                 RXByteCnt_B += curRxOkCnt;
1606                         }
1607
1608                         nextAntenna = (pDM_SWAT_Table->CurAntenna == MAIN_ANT)? AUX_ANT : MAIN_ANT;
1609                         pDM_SWAT_Table->RSSI_Trying--;
1610                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH DIV=: RSSI_Trying = %d\n",pDM_SWAT_Table->RSSI_Trying));
1611                         if(pDM_SWAT_Table->RSSI_Trying == 0)
1612                         {
1613                                 CurByteCnt = (pDM_SWAT_Table->CurAntenna == MAIN_ANT)? (TXByteCnt_A+RXByteCnt_A) : (TXByteCnt_B+RXByteCnt_B);
1614                                 PreByteCnt = (pDM_SWAT_Table->CurAntenna == MAIN_ANT)? (TXByteCnt_B+RXByteCnt_B) : (TXByteCnt_A+RXByteCnt_A);
1615
1616                                 if(TrafficLoad == TRAFFIC_HIGH)
1617                                 {
1618                                         //CurByteCnt = PlatformDivision64(CurByteCnt, 9);
1619                                         PreByteCnt =PreByteCnt*9;
1620                                 }
1621                                 else if(TrafficLoad == TRAFFIC_LOW)
1622                                 {
1623                                         //CurByteCnt = PlatformDivision64(CurByteCnt, 2);
1624                                         PreByteCnt =PreByteCnt*2;
1625                                 }
1626                                 if(pHalData->RSSI_cnt_A > 0)
1627                                         RSSI_A = pHalData->RSSI_sum_A/pHalData->RSSI_cnt_A;
1628                                 else
1629                                         RSSI_A = 0;
1630                                 if(pHalData->RSSI_cnt_B > 0)
1631                                         RSSI_B = pHalData->RSSI_sum_B/pHalData->RSSI_cnt_B;
1632                              else
1633                                         RSSI_B = 0;
1634                                 curRSSI = (pDM_SWAT_Table->CurAntenna == MAIN_ANT)? RSSI_A : RSSI_B;
1635                                 pDM_SWAT_Table->PreRSSI =  (pDM_SWAT_Table->CurAntenna == MAIN_ANT)? RSSI_B : RSSI_A;
1636                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH DIV=: PreRSSI = %d, CurRSSI = %d\n",pDM_SWAT_Table->PreRSSI, curRSSI));
1637                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH DIV=: preAntenna= %s, curAntenna= %s \n",
1638                                 (pDM_SWAT_Table->PreAntenna == MAIN_ANT?"MAIN":"AUX"), (pDM_SWAT_Table->CurAntenna == MAIN_ANT?"MAIN":"AUX")));
1639                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH DIV=: RSSI_A= %d, RSSI_cnt_A = %d, RSSI_B= %d, RSSI_cnt_B = %d\n",
1640                                         RSSI_A, pHalData->RSSI_cnt_A, RSSI_B, pHalData->RSSI_cnt_B));
1641                         }
1642
1643                 }
1644                 else   // try_flag=0
1645                 {
1646
1647                         if(pHalData->RSSI_cnt_A > 0)
1648                                 RSSI_A = pHalData->RSSI_sum_A/pHalData->RSSI_cnt_A;
1649                         else
1650                                 RSSI_A = 0;
1651                         if(pHalData->RSSI_cnt_B > 0)
1652                                 RSSI_B = pHalData->RSSI_sum_B/pHalData->RSSI_cnt_B;
1653                         else
1654                                 RSSI_B = 0;
1655                         curRSSI = (pDM_SWAT_Table->CurAntenna == MAIN_ANT)? RSSI_A : RSSI_B;
1656                         pDM_SWAT_Table->PreRSSI =  (pDM_SWAT_Table->PreAntenna == MAIN_ANT)? RSSI_A : RSSI_B;
1657                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH DIV=: PreRSSI = %d, CurRSSI = %d\n", pDM_SWAT_Table->PreRSSI, curRSSI));
1658                        ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH DIV=: preAntenna= %s, curAntenna= %s \n",
1659                         (pDM_SWAT_Table->PreAntenna == MAIN_ANT?"MAIN":"AUX"), (pDM_SWAT_Table->CurAntenna == MAIN_ANT?"MAIN":"AUX")));
1660
1661                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH DIV=: RSSI_A= %d, RSSI_cnt_A = %d, RSSI_B= %d, RSSI_cnt_B = %d\n",
1662                                 RSSI_A, pHalData->RSSI_cnt_A, RSSI_B, pHalData->RSSI_cnt_B));
1663                         //RT_TRACE(COMP_INIT, DBG_LOUD, ("Ekul:curTxOkCnt = %d\n", curTxOkCnt));
1664                         //RT_TRACE(COMP_INIT, DBG_LOUD, ("Ekul:curRxOkCnt = %d\n", curRxOkCnt));
1665                 }
1666
1667                 //1 Trying State
1668                 if((pDM_SWAT_Table->try_flag == 1)&&(pDM_SWAT_Table->RSSI_Trying == 0))
1669                 {
1670
1671                         if(pDM_SWAT_Table->TestMode == TP_MODE)
1672                         {
1673                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: TestMode = TP_MODE"));
1674                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH= TRY:CurByteCnt = %"i64fmt"d,", CurByteCnt));
1675                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH= TRY:PreByteCnt = %"i64fmt"d\n",PreByteCnt));
1676                                 if(CurByteCnt < PreByteCnt)
1677                                 {
1678                                         if(pDM_SWAT_Table->CurAntenna == MAIN_ANT)
1679                                                 pDM_SWAT_Table->SelectAntennaMap=pDM_SWAT_Table->SelectAntennaMap<<1;
1680                                         else
1681                                                 pDM_SWAT_Table->SelectAntennaMap=(pDM_SWAT_Table->SelectAntennaMap<<1)+1;
1682                                 }
1683                                 else
1684                                 {
1685                                         if(pDM_SWAT_Table->CurAntenna == MAIN_ANT)
1686                                                 pDM_SWAT_Table->SelectAntennaMap=(pDM_SWAT_Table->SelectAntennaMap<<1)+1;
1687                                         else
1688                                                 pDM_SWAT_Table->SelectAntennaMap=pDM_SWAT_Table->SelectAntennaMap<<1;
1689                                 }
1690                                 for (i= 0; i<8; i++)
1691                                 {
1692                                         if(((pDM_SWAT_Table->SelectAntennaMap>>i)&BIT0) == 1)
1693                                                 Score_A++;
1694                                         else
1695                                                 Score_B++;
1696                                 }
1697                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("SelectAntennaMap=%x\n ",pDM_SWAT_Table->SelectAntennaMap));
1698                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Score_A=%d, Score_B=%d\n", Score_A, Score_B));
1699
1700                                 if(pDM_SWAT_Table->CurAntenna == MAIN_ANT)
1701                                 {
1702                                         nextAntenna = (Score_A >= Score_B)?MAIN_ANT:AUX_ANT;
1703                                 }
1704                                 else
1705                                 {
1706                                         nextAntenna = (Score_B >= Score_A)?AUX_ANT:MAIN_ANT;
1707                                 }
1708                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: nextAntenna=%s\n",(nextAntenna==MAIN_ANT)?"MAIN":"AUX"));
1709                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: preAntenna= %s, curAntenna= %s \n",
1710                                 (pDM_SWAT_Table->PreAntenna == MAIN_ANT?"MAIN":"AUX"), (pDM_SWAT_Table->CurAntenna == MAIN_ANT?"MAIN":"AUX")));
1711
1712                                 if(nextAntenna != pDM_SWAT_Table->CurAntenna)
1713                                 {
1714                                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Switch back to another antenna"));
1715                                 }
1716                                 else
1717                                 {
1718                                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: current anntena is good\n"));
1719                                 }
1720                         }
1721
1722
1723                         if(pDM_SWAT_Table->TestMode == RSSI_MODE)
1724                         {
1725                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: TestMode = RSSI_MODE"));
1726                                 pDM_SWAT_Table->SelectAntennaMap=0xAA;
1727                                 if(curRSSI < pDM_SWAT_Table->PreRSSI) //Current antenna is worse than previous antenna
1728                                 {
1729                                         //RT_TRACE(COMP_INIT, DBG_LOUD, ("SWAS: Switch back to another antenna"));
1730                                         nextAntenna = (pDM_SWAT_Table->CurAntenna == MAIN_ANT)?AUX_ANT : MAIN_ANT;
1731                                 }
1732                                 else // current anntena is good
1733                                 {
1734                                         nextAntenna =pDM_SWAT_Table->CurAntenna;
1735                                         //RT_TRACE(COMP_INIT, DBG_LOUD, ("SWAS: current anntena is good\n"));
1736                                 }
1737                         }
1738
1739                         pDM_SWAT_Table->try_flag = 0;
1740                         pHalData->RSSI_sum_A = 0;
1741                         pHalData->RSSI_cnt_A = 0;
1742                         pHalData->RSSI_sum_B = 0;
1743                         pHalData->RSSI_cnt_B = 0;
1744                         TXByteCnt_A = 0;
1745                         TXByteCnt_B = 0;
1746                         RXByteCnt_A = 0;
1747                         RXByteCnt_B = 0;
1748
1749                 }
1750
1751                 //1 Normal State
1752                 else if(pDM_SWAT_Table->try_flag == 0)
1753                 {
1754                         if(TrafficLoad == TRAFFIC_HIGH)
1755                         {
1756                                 if ((curTxOkCnt+curRxOkCnt) > 3750000)//if(PlatformDivision64(curTxOkCnt+curRxOkCnt, 2) > 1875000)
1757                                         TrafficLoad = TRAFFIC_HIGH;
1758                                 else
1759                                         TrafficLoad = TRAFFIC_LOW;
1760                         }
1761                         else if(TrafficLoad == TRAFFIC_LOW)
1762                                 {
1763                                 if ((curTxOkCnt+curRxOkCnt) > 3750000)//if(PlatformDivision64(curTxOkCnt+curRxOkCnt, 2) > 1875000)
1764                                         TrafficLoad = TRAFFIC_HIGH;
1765                                 else
1766                                         TrafficLoad = TRAFFIC_LOW;
1767                         }
1768                         if(TrafficLoad == TRAFFIC_HIGH)
1769                                 pDM_SWAT_Table->bTriggerAntennaSwitch = 0;
1770                         //RT_TRACE(COMP_INIT, DBG_LOUD, ("Normal:TrafficLoad = %llu\n", curTxOkCnt+curRxOkCnt));
1771
1772                         //Prepare To Try Antenna
1773                                 nextAntenna = (pDM_SWAT_Table->CurAntenna == MAIN_ANT)? AUX_ANT : MAIN_ANT;
1774                                 pDM_SWAT_Table->try_flag = 1;
1775                         if((curRxOkCnt+curTxOkCnt) > 1000)
1776                         {
1777 #if DEV_BUS_TYPE==RT_PCI_INTERFACE
1778                             pDM_SWAT_Table->RSSI_Trying = 4;
1779 #else
1780                             pDM_SWAT_Table->RSSI_Trying = 2;
1781 #endif
1782                                 pDM_SWAT_Table->TestMode = TP_MODE;
1783                         }
1784                         else
1785                         {
1786                                 pDM_SWAT_Table->RSSI_Trying = 2;
1787                                 pDM_SWAT_Table->TestMode = RSSI_MODE;
1788
1789                         }
1790
1791                         //RT_TRACE(COMP_INIT, DBG_LOUD, ("SWAS: Normal State -> Begin Trying!\n"));
1792                         pHalData->RSSI_sum_A = 0;
1793                         pHalData->RSSI_cnt_A = 0;
1794                         pHalData->RSSI_sum_B = 0;
1795                         pHalData->RSSI_cnt_B = 0;
1796                 } // end of try_flag=0
1797         }
1798
1799         //1 4.Change TRX antenna
1800         if(nextAntenna != pDM_SWAT_Table->CurAntenna)
1801         {
1802
1803                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Change TX Antenna!\n "));
1804                 //PHY_SetBBReg(Adapter, rFPGA0_XA_RFInterfaceOE, 0x300, nextAntenna); for 88C
1805                 if(nextAntenna==MAIN_ANT)
1806                 {
1807                     ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Next Antenna is RF PATH A\n "));
1808                     pathdiv_para = 0x02;   //02 to switchback to RF path A
1809                     fw_value = 0x03;
1810 #if DEV_BUS_TYPE==RT_PCI_INTERFACE
1811                  odm_PathDiversity_8192D(pDM_Odm, pathdiv_para);
1812 #else
1813                  ODM_FillH2CCmd(pDM_Odm, ODM_H2C_PathDiv,1,(pu1Byte)(&fw_value));
1814 #endif
1815                 }
1816                else if(nextAntenna==AUX_ANT)
1817                {
1818                    ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Next Antenna is RF PATH B\n "));
1819                    if(switchfirsttime==0)  // First Time To Enter Path Diversity
1820                    {
1821                        switchfirsttime=0x01;
1822                       pathdiv_para = 0x00;
1823                           fw_value=0x00;    // to backup RF Path A Releated Registers
1824
1825 #if DEV_BUS_TYPE==RT_PCI_INTERFACE
1826                      odm_PathDiversity_8192D(pDM_Odm, pathdiv_para);
1827 #else
1828                      ODM_FillH2CCmd(pDM_Odm, ODM_H2C_PathDiv,1,(pu1Byte)(&fw_value));
1829                      //for(u1Byte n=0; n<80,n++)
1830                      //{
1831                      //delay_us(500);
1832                           ODM_delay_ms(500);
1833                      odm_PathDiversity_8192D(pDM_Odm, pathdiv_para);
1834
1835                          fw_value=0x01;         // to backup RF Path A Releated Registers
1836                      ODM_FillH2CCmd(pDM_Odm, ODM_H2C_PathDiv,1,(pu1Byte)(&fw_value));
1837 #endif
1838                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: FIRST TIME To DO PATH SWITCH!\n "));
1839                    }
1840                     else
1841                     {
1842                         pathdiv_para = 0x01;
1843                          fw_value = 0x02;
1844 #if DEV_BUS_TYPE==RT_PCI_INTERFACE
1845                      odm_PathDiversity_8192D(pDM_Odm, pathdiv_para);
1846 #else
1847                      ODM_FillH2CCmd(pDM_Odm, ODM_H2C_PathDiv,1,(pu1Byte)(&fw_value));
1848 #endif
1849                     }
1850                }
1851            //   odm_PathDiversity_8192D(Adapter, pathdiv_para);
1852         }
1853
1854         //1 5.Reset Statistics
1855         pDM_SWAT_Table->PreAntenna = pDM_SWAT_Table->CurAntenna;
1856         pDM_SWAT_Table->CurAntenna = nextAntenna;
1857         pDM_SWAT_Table->PreRSSI = curRSSI;
1858
1859         //1 6.Set next timer
1860
1861         if(pDM_SWAT_Table->RSSI_Trying == 0)
1862                 return;
1863
1864         if(pDM_SWAT_Table->RSSI_Trying%2 == 0)
1865         {
1866                 if(pDM_SWAT_Table->TestMode == TP_MODE)
1867                 {
1868                         if(TrafficLoad == TRAFFIC_HIGH)
1869                         {
1870 #if DEV_BUS_TYPE==RT_PCI_INTERFACE
1871                                 ODM_SetTimer( pDM_Odm, &pDM_Odm->PathDivSwitchTimer, 10 ); //ms
1872                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Test another antenna for 10 ms\n"));
1873 #else
1874                                 ODM_SetTimer( pDM_Odm, &pDM_Odm->PathDivSwitchTimer, 20 ); //ms
1875                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Test another antenna for 20 ms\n"));
1876 #endif
1877                         }
1878                         else if(TrafficLoad == TRAFFIC_LOW)
1879                         {
1880                                 ODM_SetTimer( pDM_Odm, &pDM_Odm->PathDivSwitchTimer, 50 ); //ms
1881                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Test another antenna for 50 ms\n"));
1882                         }
1883                 }
1884                 else   // TestMode == RSSI_MODE
1885                 {
1886                         ODM_SetTimer( pDM_Odm, &pDM_Odm->PathDivSwitchTimer, 500 ); //ms
1887                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Test another antenna for 500 ms\n"));
1888                 }
1889         }
1890         else
1891         {
1892                 if(pDM_SWAT_Table->TestMode == TP_MODE)
1893                 {
1894                         if(TrafficLoad == TRAFFIC_HIGH)
1895
1896 #if DEV_BUS_TYPE==RT_PCI_INTERFACE
1897                                 ODM_SetTimer( pDM_Odm, &pDM_Odm->PathDivSwitchTimer, 90 ); //ms
1898                                 //ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Test another antenna for 90 ms\n"));
1899 #else
1900                                 ODM_SetTimer( pDM_Odm, &pDM_Odm->PathDivSwitchTimer, 180); //ms
1901 #endif
1902                         else if(TrafficLoad == TRAFFIC_LOW)
1903                                 ODM_SetTimer( pDM_Odm, &pDM_Odm->PathDivSwitchTimer, 100 ); //ms
1904                 }
1905                 else
1906                         ODM_SetTimer( pDM_Odm, &pDM_Odm->PathDivSwitchTimer, 500 ); //ms
1907         }
1908 }
1909
1910
1911
1912 VOID
1913 ODM_CCKPathDiversityChkPerPktRssi(
1914         PADAPTER                Adapter,
1915         BOOLEAN                 bIsDefPort,
1916         BOOLEAN                 bMatchBSSID,
1917         PRT_WLAN_STA    pEntry,
1918         PRT_RFD                 pRfd,
1919         pu1Byte                 pDesc
1920         )
1921 {
1922         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
1923         BOOLEAN                 bCount = FALSE;
1924         pPD_T   pDM_PDTable = &Adapter->DM_PDTable;
1925         //BOOLEAN       isCCKrate = RX_HAL_IS_CCK_RATE_92C(pDesc);
1926 #if DEV_BUS_TYPE != RT_SDIO_INTERFACE
1927         BOOLEAN isCCKrate = RX_HAL_IS_CCK_RATE(Adapter, pDesc);
1928 #else  //below code would be removed if we have verified SDIO
1929         BOOLEAN isCCKrate = IS_HARDWARE_TYPE_8188E(Adapter) ? RX_HAL_IS_CCK_RATE_88E(pDesc) : RX_HAL_IS_CCK_RATE_92C(pDesc);
1930 #endif
1931
1932         if ((pHalData->PathDivCfg != 1))
1933                 return;
1934
1935         if(pHalData->RSSI_target==NULL && bIsDefPort && bMatchBSSID)
1936                 bCount = TRUE;
1937         else if(pHalData->RSSI_target!=NULL && pEntry!=NULL && pHalData->RSSI_target==pEntry)
1938                 bCount = TRUE;
1939
1940         if(bCount && isCCKrate)
1941         {
1942                 if(pDM_PDTable->TrainingState == 1 )
1943                 {
1944                         if(pEntry)
1945                         {
1946                                 if(pEntry->rssi_stat.RSSI_CCK_Path_cnt[0] != 0)
1947                                         pEntry->rssi_stat.RSSI_CCK_Path[0] += pRfd->Status.RxPWDBAll;
1948                                 pEntry->rssi_stat.RSSI_CCK_Path_cnt[0]++;
1949                         }
1950                         else
1951                         {
1952                                 if(pDM_PDTable->RSSI_CCK_Path_cnt[0] != 0)
1953                                         pDM_PDTable->RSSI_CCK_Path[0] += pRfd->Status.RxPWDBAll;
1954                                 pDM_PDTable->RSSI_CCK_Path_cnt[0]++;
1955                         }
1956                 }
1957                 else if(pDM_PDTable->TrainingState == 2 )
1958                 {
1959                         if(pEntry)
1960                         {
1961                                 if(pEntry->rssi_stat.RSSI_CCK_Path_cnt[1] != 0)
1962                                         pEntry->rssi_stat.RSSI_CCK_Path[1] += pRfd->Status.RxPWDBAll;
1963                                 pEntry->rssi_stat.RSSI_CCK_Path_cnt[1]++;
1964                         }
1965                         else
1966                         {
1967                                 if(pDM_PDTable->RSSI_CCK_Path_cnt[1] != 0)
1968                                         pDM_PDTable->RSSI_CCK_Path[1] += pRfd->Status.RxPWDBAll;
1969                                 pDM_PDTable->RSSI_CCK_Path_cnt[1]++;
1970                         }
1971                 }
1972         }
1973 }
1974
1975
1976
1977
1978 //Neil Chen---2011--06--22
1979 //----92D Path Diversity----//
1980 //#ifdef PathDiv92D
1981 //==================================
1982 //3 Path Diversity
1983 //==================================
1984 //
1985 // 20100514 Luke/Joseph:
1986 // Add new function for antenna diversity after link.
1987 // This is the main function of antenna diversity after link.
1988 // This function is called in HalDmWatchDog() and ODM_SwAntDivChkAntSwitchCallback().
1989 // HalDmWatchDog() calls this function with SWAW_STEP_PEAK to initialize the antenna test.
1990 // In SWAW_STEP_PEAK, another antenna and a 500ms timer will be set for testing.
1991 // After 500ms, ODM_SwAntDivChkAntSwitchCallback() calls this function to compare the signal just
1992 // listened on the air with the RSSI of original antenna.
1993 // It chooses the antenna with better RSSI.
1994 // There is also a aged policy for error trying. Each error trying will cost more 5 seconds waiting
1995 // penalty to get next try.
1996 //
1997 //
1998 // 20100503 Joseph:
1999 // Add new function SwAntDivCheck8192C().
2000 // This is the main function of Antenna diversity function before link.
2001 // Mainly, it just retains last scan result and scan again.
2002 // After that, it compares the scan result to see which one gets better RSSI.
2003 // It selects antenna with better receiving power and returns better scan result.
2004 //
2005
2006
2007 //
2008 // 20100514 Luke/Joseph:
2009 // This function is used to gather the RSSI information for antenna testing.
2010 // It selects the RSSI of the peer STA that we want to know.
2011 //
2012 VOID
2013 ODM_PathDivChkPerPktRssi(
2014         PADAPTER                Adapter,
2015         BOOLEAN                 bIsDefPort,
2016         BOOLEAN                 bMatchBSSID,
2017         PRT_WLAN_STA    pEntry,
2018         PRT_RFD                 pRfd
2019         )
2020 {
2021         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
2022         BOOLEAN                 bCount = FALSE;
2023         PDM_ODM_T               pDM_Odm = &pHalData->DM_OutSrc;
2024         pSWAT_T                 pDM_SWAT_Table = &pDM_Odm->DM_SWAT_Table;
2025
2026         if(pHalData->RSSI_target==NULL && bIsDefPort && bMatchBSSID)
2027                 bCount = TRUE;
2028         else if(pHalData->RSSI_target!=NULL && pEntry!=NULL && pHalData->RSSI_target==pEntry)
2029                 bCount = TRUE;
2030
2031         if(bCount)
2032         {
2033                 //1 RSSI for SW Antenna Switch
2034                 if(pDM_SWAT_Table->CurAntenna == MAIN_ANT)
2035                 {
2036                         pHalData->RSSI_sum_A += pRfd->Status.RxPWDBAll;
2037                         pHalData->RSSI_cnt_A++;
2038                 }
2039                 else
2040                 {
2041                         pHalData->RSSI_sum_B += pRfd->Status.RxPWDBAll;
2042                         pHalData->RSSI_cnt_B++;
2043
2044                 }
2045         }
2046 }
2047
2048
2049 //
2050 // 20100514 Luke/Joseph:
2051 // Add new function to reset antenna diversity state after link.
2052 //
2053 VOID
2054 ODM_PathDivRestAfterLink(
2055         IN      PDM_ODM_T               pDM_Odm
2056         )
2057 {
2058         PADAPTER                Adapter=pDM_Odm->Adapter;
2059         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
2060         pSWAT_T                 pDM_SWAT_Table = &pDM_Odm->DM_SWAT_Table;
2061
2062         pHalData->RSSI_cnt_A = 0;
2063         pHalData->RSSI_cnt_B = 0;
2064         pDM_SWAT_Table->try_flag = 0x0;       // NOT 0xff
2065         pDM_SWAT_Table->RSSI_Trying = 0;
2066         pDM_SWAT_Table->SelectAntennaMap=0xAA;
2067         pDM_SWAT_Table->CurAntenna = MAIN_ANT;
2068 }
2069
2070
2071 //==================================================
2072 //3 PathDiv End
2073 //==================================================
2074
2075
2076 VOID
2077 ODM_FillTXPathInTXDESC(
2078                 IN      PADAPTER        Adapter,
2079                 IN      PRT_TCB         pTcb,
2080                 IN      pu1Byte         pDesc
2081 )
2082 {
2083         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
2084         u4Byte  TXPath;
2085         pPD_T   pDM_PDTable = &Adapter->DM_PDTable;
2086
2087         //2011.09.05  Add by Luke Lee for path diversity
2088         if(pHalData->PathDivCfg == 1)
2089         {
2090                 TXPath = (pDM_PDTable->OFDMTXPath >> pTcb->macId) & BIT0;
2091                 //RT_TRACE(     COMP_INIT, DBG_LOUD, ("Fill TXDESC: macID=%d, TXPath=%d\n", pTcb->macId, TXPath));
2092                 //SET_TX_DESC_TX_ANT_CCK(pDesc,TXPath);
2093                 if(TXPath == 0)
2094                 {
2095                         SET_TX_DESC_TX_ANTL_92C(pDesc,1);
2096                         SET_TX_DESC_TX_ANT_HT_92C(pDesc,1);
2097                 }
2098                 else
2099                 {
2100                         SET_TX_DESC_TX_ANTL_92C(pDesc,2);
2101                         SET_TX_DESC_TX_ANT_HT_92C(pDesc,2);
2102                 }
2103                 TXPath = (pDM_PDTable->CCKTXPath >> pTcb->macId) & BIT0;
2104                 if(TXPath == 0)
2105                 {
2106                         SET_TX_DESC_TX_ANT_CCK_92C(pDesc,1);
2107                 }
2108                 else
2109                 {
2110                         SET_TX_DESC_TX_ANT_CCK_92C(pDesc,2);
2111                 }
2112         }
2113 }
2114
2115 //Only for MP //Neil Chen--2012--0502--
2116 VOID
2117 odm_PathDivInit_92D(
2118 IN      PDM_ODM_T       pDM_Odm)
2119 {
2120         pPATHDIV_PARA   pathIQK = &pDM_Odm->pathIQK;
2121
2122         pathIQK->org_2g_RegC14=0x0;
2123         pathIQK->org_2g_RegC4C=0x0;
2124         pathIQK->org_2g_RegC80=0x0;
2125         pathIQK->org_2g_RegC94=0x0;
2126         pathIQK->org_2g_RegCA0=0x0;
2127         pathIQK->org_5g_RegC14=0x0;
2128         pathIQK->org_5g_RegCA0=0x0;
2129         pathIQK->org_5g_RegE30=0x0;
2130         pathIQK->swt_2g_RegC14=0x0;
2131         pathIQK->swt_2g_RegC4C=0x0;
2132         pathIQK->swt_2g_RegC80=0x0;
2133         pathIQK->swt_2g_RegC94=0x0;
2134         pathIQK->swt_2g_RegCA0=0x0;
2135         pathIQK->swt_5g_RegC14=0x0;
2136         pathIQK->swt_5g_RegCA0=0x0;
2137         pathIQK->swt_5g_RegE30=0x0;
2138
2139 }
2140
2141
2142 u1Byte
2143 odm_SwAntDivSelectScanChnl(
2144         IN      PADAPTER        Adapter
2145         )
2146 {
2147 #if (RT_MEM_SIZE_LEVEL != RT_MEM_SIZE_MINIMUM)
2148         PHAL_DATA_TYPE          pHalData = GET_HAL_DATA(Adapter);
2149         PMGNT_INFO                      pMgntInfo = &(Adapter->MgntInfo);
2150         PDM_ODM_T                       pDM_Odm = &pHalData->DM_OutSrc;
2151         u2Byte                          i;
2152         u1Byte                          j, ScanChannel = 0, ChannelNum = 0;
2153         PRT_CHANNEL_LIST        pChannelList = GET_RT_CHANNEL_LIST(pMgntInfo);
2154         u1Byte                          EachChannelSTAs[MAX_SCAN_CHANNEL_NUM] = {0};
2155
2156         if(pMgntInfo->tmpNumBssDesc == 0)
2157                 return 0;
2158
2159         for(i = 0; i < pMgntInfo->tmpNumBssDesc; i++)
2160         {
2161                 ChannelNum = pMgntInfo->tmpbssDesc[i].ChannelNumber;
2162                 for(j = 0; j < pChannelList->ChannelLen; j++)
2163                 {
2164                         if(pChannelList->ChnlListEntry[j].ChannelNum == ChannelNum)
2165                         {
2166                                 EachChannelSTAs[j]++;
2167                                 break;
2168                         }
2169                 }
2170         }
2171
2172         for(i = 0; i < MAX_SCAN_CHANNEL_NUM; i++)
2173                 {
2174                 if(EachChannelSTAs[i] > EachChannelSTAs[ScanChannel])
2175                         ScanChannel = (u1Byte)i;
2176                 }
2177
2178         if(EachChannelSTAs[ScanChannel] == 0)
2179         {
2180                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, DBG_LOUD, ("odm_SwAntDivSelectScanChnl(): Scan List is empty.\n"));
2181                 return 0;
2182         }
2183
2184         ScanChannel = pChannelList->ChnlListEntry[ScanChannel].ChannelNum;
2185
2186
2187
2188         ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, DBG_LOUD,
2189                 ("odm_SwAntDivSelectScanChnl(): Channel (( %d )) is select as scan channel.\n", ScanChannel));
2190
2191         return ScanChannel;
2192 #else
2193         return  0;
2194 #endif
2195 }
2196
2197
2198 VOID
2199 odm_SwAntDivConstructScanChnl(
2200         IN      PADAPTER        Adapter,
2201         IN      u1Byte          ScanChnl
2202         )
2203 {
2204
2205         PMGNT_INFO                      pMgntInfo = &Adapter->MgntInfo;
2206
2207         if(ScanChnl == 0)
2208         {
2209                 u1Byte                          i;
2210                 PRT_CHANNEL_LIST        pChannelList = GET_RT_CHANNEL_LIST(pMgntInfo);
2211
2212                 // 20100519 Joseph: Original antenna scanned nothing.
2213                 // Test antenna shall scan all channel with half period in this condition.
2214
2215                 RT_TRACE_F(COMP_SCAN, DBG_TRACE, (" RT_CHNL_LIST_ACTION_CONSTRUCT chnl %d \n", ScanChnl));
2216
2217                 RtActChannelList(Adapter, RT_CHNL_LIST_ACTION_CONSTRUCT_SCAN_LIST, NULL, NULL);
2218                 for(i = 0; i < pChannelList->ChannelLen; i++)
2219                         pChannelList->ChnlListEntry[i].ScanPeriod /= 2;
2220         }
2221         else
2222         {
2223                 // The using of this CustomizedScanRequest is a trick to rescan the two channels
2224                 //      under the NORMAL scanning process. It will not affect MGNT_INFO.CustomizedScanRequest.
2225                 CUSTOMIZED_SCAN_REQUEST CustomScanReq;
2226
2227                 CustomScanReq.bEnabled = TRUE;
2228                 CustomScanReq.Channels[0] = ScanChnl;
2229                 CustomScanReq.Channels[1] = pMgntInfo->dot11CurrentChannelNumber;
2230                 CustomScanReq.nChannels = 2;
2231                 CustomScanReq.ScanType = SCAN_ACTIVE;
2232                 CustomScanReq.Duration = DEFAULT_PASSIVE_SCAN_PERIOD;
2233
2234                 RT_TRACE_F(COMP_SCAN, DBG_TRACE, (" RT_CHNL_LIST_ACTION_CONSTRUCT chnl %d \n", ScanChnl));
2235
2236                 RtActChannelList(Adapter, RT_CHNL_LIST_ACTION_CONSTRUCT_SCAN_LIST, &CustomScanReq, NULL);
2237         }
2238
2239 }
2240 #else
2241
2242 VOID
2243 odm_PathDivChkAntSwitchCallback(
2244         PRT_TIMER               pTimer
2245 )
2246 {
2247 }
2248
2249 VOID
2250 odm_PathDivChkAntSwitchWorkitemCallback(
2251     IN PVOID            pContext
2252     )
2253 {
2254 }
2255
2256 VOID
2257 odm_CCKTXPathDiversityCallback(
2258         PRT_TIMER               pTimer
2259 )
2260 {
2261 }
2262
2263 VOID
2264 odm_CCKTXPathDiversityWorkItemCallback(
2265     IN PVOID            pContext
2266     )
2267 {
2268 }
2269 u1Byte
2270 odm_SwAntDivSelectScanChnl(
2271         IN      PADAPTER        Adapter
2272         )
2273 {
2274         return  0;
2275 }
2276 VOID
2277 odm_SwAntDivConstructScanChnl(
2278         IN      PADAPTER        Adapter,
2279         IN      u1Byte          ScanChnl
2280         )
2281 {
2282 }
2283
2284
2285 #endif
2286
2287 #endif  // #if (DM_ODM_SUPPORT_TYPE == ODM_WIN)