drivers/net/wireless/rockchip_wlan/rtl8189es/core/rtw_bt_mp.c

   1 /******************************************************************************\r
   2  *\r
   3  * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.\r
   4  *                                                                                \r
   5  * This program is free software; you can redistribute it and/or modify it\r
   6  * under the terms of version 2 of the GNU General Public License as\r
   7  * published by the Free Software Foundation.\r
   8  *\r
   9  * This program is distributed in the hope that it will be useful, but WITHOUT\r
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\r
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\r
  12  * more details.\r
  13  *\r
  14  * You should have received a copy of the GNU General Public License along with\r
  15  * this program; if not, write to the Free Software Foundation, Inc.,\r
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA\r
  17  *\r
  18  *\r
  19  ******************************************************************************/\r
  20 \r
  21 \r
  22 #include <drv_types.h>\r
  23 #include <rtw_bt_mp.h>\r
  24 \r
  25 #ifdef CONFIG_RTL8723A\r
  26 #include <rtl8723a_hal.h>\r
  27 #elif defined(CONFIG_RTL8723B)\r
  28 #include <rtl8723b_hal.h>\r
  29 #endif\r
  30 \r
  31 #if defined(CONFIG_RTL8723A) || defined(CONFIG_RTL8723B) || defined(CONFIG_RTL8821A)\r
  32 void MPh2c_timeout_handle(void *FunctionContext)\r
  33 {\r
  34         PADAPTER pAdapter;\r
  35         PMPT_CONTEXT pMptCtx;\r
  36 \r
  37 \r
  38         DBG_8192C("[MPT], MPh2c_timeout_handle \n");\r
  39 \r
  40         pAdapter = (PADAPTER)FunctionContext;\r
  41         pMptCtx = &pAdapter->mppriv.MptCtx;\r
  42 \r
  43         pMptCtx->bMPh2c_timeout = _TRUE;\r
  44 \r
  45         if ((_FALSE == pMptCtx->MptH2cRspEvent)\r
  46                 || ((_TRUE == pMptCtx->MptH2cRspEvent)\r
  47                         && (_FALSE == pMptCtx->MptBtC2hEvent)))\r
  48         {\r
  49                 _rtw_up_sema(&pMptCtx->MPh2c_Sema);\r
  50         }\r
  51 }\r
  52 \r
  53 u32 WaitC2Hevent(PADAPTER pAdapter, u8 *C2H_event, u32 delay_time)\r
  54 {\r
  55         PMPT_CONTEXT            pMptCtx=&(pAdapter->mppriv.MptCtx);\r
  56         pMptCtx->bMPh2c_timeout=_FALSE;\r
  57         \r
  58         if( pAdapter->registrypriv.mp_mode == 0 )\r
  59         {\r
  60                 DBG_8192C("[MPT], Error!! WaitC2Hevent mp_mode == 0!!\n");\r
  61                 return _FALSE;\r
  62         }\r
  63 \r
  64         _set_timer( &pMptCtx->MPh2c_timeout_timer, delay_time );\r
  65         \r
  66         _rtw_down_sema(&pMptCtx->MPh2c_Sema);\r
  67 \r
  68         if (pMptCtx->bMPh2c_timeout == _TRUE)\r
  69         {\r
  70                 *C2H_event = _FALSE;\r
  71                 \r
  72                 return _FALSE;\r
  73         }\r
  74 \r
  75         // for safty, cancel timer here again\r
  76         _cancel_timer_ex(&pMptCtx->MPh2c_timeout_timer);\r
  77         \r
  78         return _TRUE;\r
  79 }\r
  80 \r
  81 BT_CTRL_STATUS\r
  82 mptbt_CheckC2hFrame(\r
  83         PADAPTER                Adapter,\r
  84         PBT_H2C                 pH2c,\r
  85         PBT_EXT_C2H             pExtC2h\r
  86         )\r
  87 {\r
  88         BT_CTRL_STATUS  c2hStatus = BT_STATUS_C2H_SUCCESS;\r
  89                 \r
  90         //DBG_8192C("[MPT], MPT rsp C2H hex: %x %x %x  %x %x %x \n"), pExtC2h , pExtC2h+1 ,pExtC2h+2 ,pExtC2h+3 ,pExtC2h+4 ,pExtC2h+5);\r
  91 \r
  92         DBG_8192C("[MPT], statusCode = 0x%x\n", pExtC2h->statusCode);\r
  93         DBG_8192C("[MPT], retLen = %d\n", pExtC2h->retLen);\r
  94         DBG_8192C("[MPT], opCodeVer : req/rsp=%d/%d\n", pH2c->opCodeVer, pExtC2h->opCodeVer);\r
  95         DBG_8192C("[MPT], reqNum : req/rsp=%d/%d\n", pH2c->reqNum, pExtC2h->reqNum);\r
  96         if(pExtC2h->reqNum != pH2c->reqNum)\r
  97         {\r
  98                 c2hStatus = BT_STATUS_C2H_REQNUM_MISMATCH;\r
  99                 DBG_8192C("[MPT], Error!! C2H reqNum Mismatch!!\n");\r
 100         }\r
 101         else if(pExtC2h->opCodeVer != pH2c->opCodeVer)\r
 102         {\r
 103                 c2hStatus = BT_STATUS_OPCODE_L_VERSION_MISMATCH;\r
 104                 DBG_8192C("[MPT], Error!! OPCode version L mismatch!!\n");\r
 105         }\r
 106 \r
 107         return c2hStatus;\r
 108 }\r
 109 \r
 110 #if defined(CONFIG_RTL8723A)\r
 111 extern s32 FillH2CCmd(PADAPTER padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer);\r
 112 #endif\r
 113 \r
 114 BT_CTRL_STATUS\r
 115 mptbt_SendH2c(\r
 116         PADAPTER        Adapter,\r
 117         PBT_H2C pH2c,\r
 118         u2Byte          h2cCmdLen\r
 119         )\r
 120 {\r
 121         //KIRQL                         OldIrql = KeGetCurrentIrql();\r
 122         BT_CTRL_STATUS  h2cStatus=BT_STATUS_H2C_SUCCESS;\r
 123         PMPT_CONTEXT            pMptCtx=&(Adapter->mppriv.MptCtx);\r
 124         u1Byte                          i;\r
 125 \r
 126         DBG_8192C("[MPT], mptbt_SendH2c()=========>\n");\r
 127 \r
 128         //PlatformResetEvent(&pMptCtx->MptH2cRspEvent);\r
 129         //PlatformResetEvent(&pMptCtx->MptBtC2hEvent);\r
 130         \r
 131 //      if(OldIrql == PASSIVE_LEVEL)\r
 132 //      {\r
 133                 //RTPRINT_DATA(FMPBT, FMPBT_H2C_CONTENT, ("[MPT], MPT H2C hex: \n"), pH2c, h2cCmdLen);\r
 134 \r
 135                 for(i=0; i<BT_H2C_MAX_RETRY; i++)\r
 136                 {\r
 137                         DBG_8192C("[MPT], Send H2C command to wifi!!!\n");\r
 138 \r
 139                         pMptCtx->MptH2cRspEvent = _FALSE;\r
 140                         pMptCtx->MptBtC2hEvent = _FALSE;\r
 141 \r
 142 #if defined(CONFIG_RTL8723A)\r
 143                         FillH2CCmd(Adapter, 70, h2cCmdLen, (pu1Byte)pH2c);\r
 144 #elif defined(CONFIG_RTL8723B)\r
 145                         rtl8723b_set_FwBtMpOper_cmd(Adapter, pH2c->opCode, pH2c->opCodeVer, pH2c->reqNum, pH2c->buf);\r
 146 #endif\r
 147                         pMptCtx->h2cReqNum++;\r
 148                         pMptCtx->h2cReqNum %= 16;\r
 149 \r
 150                         if(WaitC2Hevent(Adapter, &pMptCtx->MptH2cRspEvent, 100))\r
 151                         {\r
 152                                 DBG_8192C("[MPT], Received WiFi MptH2cRspEvent!!!\n");\r
 153                                 if(WaitC2Hevent(Adapter, &pMptCtx->MptBtC2hEvent, 400))\r
 154                                 {\r
 155                                         DBG_8192C("[MPT], Received MptBtC2hEvent!!!\n");\r
 156                                         break;\r
 157                                 }\r
 158                                 else\r
 159                                 {\r
 160                                         DBG_8192C("[MPT], Error!!BT MptBtC2hEvent timeout!!\n");\r
 161                                         h2cStatus = BT_STATUS_H2C_BT_NO_RSP;\r
 162                                 }\r
 163                         }\r
 164                         else\r
 165                         {\r
 166                                 DBG_8192C("[MPT], Error!!WiFi  MptH2cRspEvent timeout!!\n");\r
 167                                 h2cStatus = BT_STATUS_H2C_TIMTOUT;\r
 168                         }\r
 169                 }\r
 170 //      }\r
 171 //      else\r
 172 //      {\r
 173 //              RT_ASSERT(FALSE, ("[MPT],  mptbt_SendH2c() can only run under PASSIVE_LEVEL!!\n"));\r
 174 //              h2cStatus = BT_STATUS_WRONG_LEVEL;\r
 175 //      }\r
 176 \r
 177         DBG_8192C("[MPT], mptbt_SendH2c()<=========\n");\r
 178         return h2cStatus;\r
 179 }\r
 180 \r
 181 \r
 182 \r
 183 BT_CTRL_STATUS\r
 184 mptbt_CheckBtRspStatus(\r
 185         PADAPTER                        Adapter,\r
 186         PBT_EXT_C2H                     pExtC2h\r
 187         )\r
 188 {\r
 189         BT_CTRL_STATUS  retStatus=BT_OP_STATUS_SUCCESS;\r
 190 \r
 191         switch(pExtC2h->statusCode)\r
 192         {\r
 193                 case BT_OP_STATUS_SUCCESS:\r
 194                         retStatus = BT_STATUS_BT_OP_SUCCESS;\r
 195                         DBG_8192C("[MPT], BT status : BT_STATUS_SUCCESS\n");\r
 196                         break;\r
 197                 case BT_OP_STATUS_VERSION_MISMATCH:\r
 198                         retStatus = BT_STATUS_OPCODE_L_VERSION_MISMATCH;\r
 199                         DBG_8192C("[MPT], BT status : BT_STATUS_OPCODE_L_VERSION_MISMATCH\n");\r
 200                         break;\r
 201                 case BT_OP_STATUS_UNKNOWN_OPCODE:\r
 202                         retStatus = BT_STATUS_UNKNOWN_OPCODE_L;\r
 203                         DBG_8192C("[MPT], BT status : BT_STATUS_UNKNOWN_OPCODE_L\n");\r
 204                         break;\r
 205                 case BT_OP_STATUS_ERROR_PARAMETER:\r
 206                         retStatus = BT_STATUS_PARAMETER_FORMAT_ERROR_L;\r
 207                         DBG_8192C("[MPT], BT status : BT_STATUS_PARAMETER_FORMAT_ERROR_L\n");\r
 208                         break;\r
 209                 default:\r
 210                         retStatus = BT_STATUS_UNKNOWN_STATUS_L;\r
 211                         DBG_8192C("[MPT], BT status : BT_STATUS_UNKNOWN_STATUS_L\n");\r
 212                         break;\r
 213         }\r
 214         \r
 215         return retStatus;\r
 216 }       \r
 217 \r
 218 \r
 219 \r
 220 BT_CTRL_STATUS\r
 221 mptbt_BtFwOpCodeProcess(\r
 222         PADAPTER                Adapter,\r
 223         u1Byte                  btFwOpCode,\r
 224         u1Byte                  opCodeVer,\r
 225         pu1Byte                 pH2cPar,\r
 226         u1Byte                  h2cParaLen\r
 227         )\r
 228 {\r
 229         u1Byte                          H2C_Parameter[6] ={0};\r
 230         PBT_H2C                         pH2c=(PBT_H2C)&H2C_Parameter[0];\r
 231         PMPT_CONTEXT            pMptCtx=&(Adapter->mppriv.MptCtx);\r
 232         PBT_EXT_C2H                     pExtC2h=(PBT_EXT_C2H)&pMptCtx->c2hBuf[0];\r
 233         u2Byte                          paraLen=0,i;\r
 234         BT_CTRL_STATUS  h2cStatus=BT_STATUS_H2C_SUCCESS, c2hStatus=BT_STATUS_C2H_SUCCESS;\r
 235         BT_CTRL_STATUS  retStatus=BT_STATUS_H2C_BT_NO_RSP;\r
 236 \r
 237         if( Adapter->registrypriv.mp_mode == 0 )\r
 238         {\r
 239                 DBG_8192C("[MPT], Error!! mptbt_BtFwOpCodeProces mp_mode == 0!!\n");\r
 240                 return _FALSE;\r
 241         }\r
 242 \r
 243         pH2c->opCode = btFwOpCode;\r
 244         pH2c->opCodeVer = opCodeVer;\r
 245         pH2c->reqNum = pMptCtx->h2cReqNum;\r
 246         //PlatformMoveMemory(&pH2c->buf[0], pH2cPar, h2cParaLen);\r
 247         //_rtw_memcpy(&pH2c->buf[0], pH2cPar, h2cParaLen);\r
 248         _rtw_memcpy(pH2c->buf, pH2cPar, h2cParaLen);\r
 249 \r
 250         DBG_8192C("[MPT], pH2c->opCode=%d\n", pH2c->opCode);\r
 251         DBG_8192C("[MPT], pH2c->opCodeVer=%d\n", pH2c->opCodeVer);\r
 252         DBG_8192C("[MPT], pH2c->reqNum=%d\n", pH2c->reqNum);\r
 253         DBG_8192C("[MPT], h2c parameter length=%d\n", h2cParaLen);\r
 254         for (i=0; i<h2cParaLen; i++)\r
 255         {\r
 256                 DBG_8192C("[MPT], parameter[%d]=0x%02x\n", i, pH2c->buf[i]);\r
 257         }\r
 258 \r
 259         h2cStatus = mptbt_SendH2c(Adapter, pH2c, h2cParaLen+2);\r
 260         if(BT_STATUS_H2C_SUCCESS == h2cStatus)\r
 261         {\r
 262                 // if reach here, it means H2C get the correct c2h response, \r
 263                 c2hStatus = mptbt_CheckC2hFrame(Adapter, pH2c, pExtC2h);\r
 264                 if(BT_STATUS_C2H_SUCCESS == c2hStatus)\r
 265                 {\r
 266                         retStatus = mptbt_CheckBtRspStatus(Adapter, pExtC2h);\r
 267                 }\r
 268                 else\r
 269                 {\r
 270                         DBG_8192C("[MPT], Error!! C2H failed for pH2c->opCode=%d\n", pH2c->opCode);\r
 271                         // check c2h status error, return error status code to upper layer.\r
 272                         retStatus = c2hStatus;\r
 273                 }\r
 274         }\r
 275         else\r
 276         {\r
 277                 DBG_8192C("[MPT], Error!! H2C failed for pH2c->opCode=%d\n", pH2c->opCode);\r
 278                 // check h2c status error, return error status code to upper layer.\r
 279                 retStatus = h2cStatus;\r
 280         }\r
 281 \r
 282         return retStatus;\r
 283 }\r
 284 \r
 285 \r
 286 \r
 287 \r
 288 u2Byte\r
 289 mptbt_BtReady(\r
 290         PADAPTER                Adapter,\r
 291         PBT_REQ_CMD     pBtReq,\r
 292         PBT_RSP_CMD     pBtRsp\r
 293         )\r
 294 {\r
 295         u1Byte                          h2cParaBuf[6] ={0};\r
 296         u1Byte                          h2cParaLen=0;\r
 297         u2Byte                          paraLen=0;\r
 298         u1Byte                          retStatus=BT_STATUS_BT_OP_SUCCESS;\r
 299         u1Byte                          btOpcode;\r
 300         u1Byte                          btOpcodeVer=0;\r
 301         PMPT_CONTEXT            pMptCtx=&(Adapter->mppriv.MptCtx);\r
 302         PBT_EXT_C2H                     pExtC2h=(PBT_EXT_C2H)&pMptCtx->c2hBuf[0];\r
 303         u1Byte                          i;\r
 304         u1Byte                          btFwVer=0, bdAddr[6]={0};\r
 305         u2Byte                          btRealFwVer=0;\r
 306         pu2Byte                         pu2Tmp=NULL;\r
 307 \r
 308         //\r
 309         // check upper layer parameters\r
 310         //\r
 311 \r
 312         // 1. check upper layer opcode version\r
 313         if(pBtReq->opCodeVer != 1)\r
 314         {\r
 315                 DBG_8192C("[MPT], Error!! Upper OP code version not match!!!\n");\r
 316                 pBtRsp->status = BT_STATUS_OPCODE_U_VERSION_MISMATCH;\r
 317                 return paraLen;\r
 318         }\r
 319 \r
 320         pBtRsp->pParamStart[0] = MP_BT_NOT_READY;\r
 321         paraLen = 10;\r
 322         //\r
 323         // execute lower layer opcodes\r
 324         //\r
 325 \r
 326         // Get BT FW version\r
 327         // fill h2c parameters\r
 328         btOpcode = BT_LO_OP_GET_BT_VERSION;\r
 329         // execute h2c and check respond c2h from bt fw is correct or not\r
 330         retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
 331         // ckeck bt return status.\r
 332         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
 333         {\r
 334                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
 335                 DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
 336                 return paraLen;\r
 337         }\r
 338         else\r
 339         {\r
 340                 pu2Tmp = (pu2Byte)&pExtC2h->buf[0];\r
 341                 btRealFwVer = *pu2Tmp;\r
 342                 btFwVer = pExtC2h->buf[1];\r
 343                 DBG_8192C("[MPT], btRealFwVer=0x%x, btFwVer=0x%x\n", btRealFwVer, btFwVer);\r
 344         }\r
 345 \r
 346         // Get BD Address\r
 347         // fill h2c parameters\r
 348         btOpcode = BT_LO_OP_GET_BD_ADDR_L;\r
 349         // execute h2c and check respond c2h from bt fw is correct or not\r
 350         retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
 351         // ckeck bt return status.\r
 352         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
 353         {\r
 354                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
 355                 DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
 356                 return paraLen;\r
 357         }\r
 358         else\r
 359         {\r
 360                 bdAddr[5] = pExtC2h->buf[0];\r
 361                 bdAddr[4] = pExtC2h->buf[1];\r
 362                 bdAddr[3] = pExtC2h->buf[2];\r
 363         }\r
 364 \r
 365         // fill h2c parameters\r
 366         btOpcode = BT_LO_OP_GET_BD_ADDR_H;\r
 367         // execute h2c and check respond c2h from bt fw is correct or not\r
 368         retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
 369         // ckeck bt return status.\r
 370         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
 371         {\r
 372                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
 373                 DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
 374                 return paraLen;\r
 375         }\r
 376         else\r
 377         {\r
 378                 bdAddr[2] = pExtC2h->buf[0];\r
 379                 bdAddr[1] = pExtC2h->buf[1];\r
 380                 bdAddr[0] = pExtC2h->buf[2];\r
 381         }\r
 382         DBG_8192C("[MPT], Local BDAddr:");\r
 383         for(i=0; i<6; i++)\r
 384         {\r
 385                 DBG_8192C(" 0x%x ", bdAddr[i]);\r
 386         }\r
 387         pBtRsp->status = BT_STATUS_SUCCESS;\r
 388         pBtRsp->pParamStart[0] = MP_BT_READY;\r
 389         pu2Tmp = (pu2Byte)&pBtRsp->pParamStart[1];\r
 390         *pu2Tmp = btRealFwVer;\r
 391         pBtRsp->pParamStart[3] = btFwVer;\r
 392         for(i=0; i<6; i++)\r
 393         {\r
 394                 pBtRsp->pParamStart[4+i] = bdAddr[5-i];\r
 395         }\r
 396 \r
 397         return paraLen;\r
 398 }\r
 399 \r
 400 void mptbt_close_WiFiRF(PADAPTER Adapter)\r
 401 {\r
 402         PHY_SetBBReg(Adapter, 0x824, 0xF, 0x0);\r
 403         PHY_SetBBReg(Adapter, 0x824, 0x700000, 0x0);\r
 404         PHY_SetRFReg(Adapter, RF90_PATH_A, 0x0, 0xF0000, 0x0);\r
 405 }\r
 406 \r
 407 void mptbt_open_WiFiRF(PADAPTER Adapter)\r
 408 {\r
 409         PHY_SetBBReg(Adapter, 0x824, 0x700000, 0x3);\r
 410         PHY_SetBBReg(Adapter, 0x824, 0xF, 0x2);\r
 411         PHY_SetRFReg(Adapter, RF90_PATH_A, 0x0, 0xF0000, 0x3);\r
 412 }\r
 413 \r
 414 u4Byte mptbt_switch_RF(PADAPTER Adapter, u1Byte Enter)\r
 415 {\r
 416         u2Byte  tmp_2byte = 0;\r
 417 \r
 418         //Enter test mode\r
 419         if (Enter) {\r
 420                 ////1>. close WiFi RF\r
 421                 mptbt_close_WiFiRF(Adapter);\r
 422                 \r
 423                 ////2>. change ant switch to BT\r
 424                 tmp_2byte = rtw_read16(Adapter, 0x860);\r
 425                 tmp_2byte = tmp_2byte | BIT(9);\r
 426                 tmp_2byte = tmp_2byte & (~BIT(8));\r
 427                 rtw_write16(Adapter, 0x860, tmp_2byte);\r
 428                 rtw_write16(Adapter, 0x870, 0x300);\r
 429         } else {\r
 430                 ////1>. Open WiFi RF\r
 431                 mptbt_open_WiFiRF(Adapter);\r
 432                 \r
 433                 ////2>. change ant switch back\r
 434                 tmp_2byte = rtw_read16(Adapter, 0x860);\r
 435                 tmp_2byte = tmp_2byte | BIT(8);\r
 436                 tmp_2byte = tmp_2byte & (~BIT(9));\r
 437                 rtw_write16(Adapter, 0x860, tmp_2byte);\r
 438                 rtw_write16(Adapter, 0x870, 0x300);\r
 439         }\r
 440 \r
 441         return 0;\r
 442 }\r
 443 \r
 444 u2Byte\r
 445 mptbt_BtSetMode(\r
 446         PADAPTER                Adapter,\r
 447         PBT_REQ_CMD     pBtReq,\r
 448         PBT_RSP_CMD     pBtRsp\r
 449         )\r
 450 {\r
 451         u1Byte                          h2cParaBuf[6] ={0};\r
 452         u1Byte                          h2cParaLen=0;\r
 453         u2Byte                          paraLen=0;\r
 454         u1Byte                          retStatus=BT_STATUS_BT_OP_SUCCESS;\r
 455         u1Byte                          btOpcode;\r
 456         u1Byte                          btOpcodeVer=0;\r
 457         u1Byte                          btModeToSet=0;\r
 458 \r
 459         //\r
 460         // check upper layer parameters\r
 461         //\r
 462         // 1. check upper layer opcode version\r
 463         if(pBtReq->opCodeVer != 1)\r
 464         {\r
 465                 DBG_8192C("[MPT], Error!! Upper OP code version not match!!!\n");\r
 466                 pBtRsp->status = BT_STATUS_OPCODE_U_VERSION_MISMATCH;\r
 467                 return paraLen;\r
 468         }\r
 469         // 2. check upper layer parameter length\r
 470         if(1 == pBtReq->paraLength)\r
 471         {\r
 472                 btModeToSet = pBtReq->pParamStart[0];\r
 473                 DBG_8192C("[MPT], BtTestMode=%d \n", btModeToSet);\r
 474         }\r
 475         else\r
 476         {\r
 477                 DBG_8192C("[MPT], Error!! wrong parameter length=%d (should be 1)\n", pBtReq->paraLength);\r
 478                 pBtRsp->status = BT_STATUS_PARAMETER_FORMAT_ERROR_U;\r
 479                 return paraLen;\r
 480         }\r
 481         \r
 482         //\r
 483         // execute lower layer opcodes\r
 484         //\r
 485         \r
 486         // 1. fill h2c parameters       \r
 487         // check bt mode\r
 488         btOpcode = BT_LO_OP_SET_BT_MODE;\r
 489         if(btModeToSet >= MP_BT_MODE_MAX)\r
 490         {\r
 491                 pBtRsp->status = BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
 492                 return paraLen;\r
 493         }\r
 494         else\r
 495         {\r
 496                 mptbt_switch_RF(Adapter, 1);\r
 497 \r
 498                 h2cParaBuf[0] = btModeToSet;\r
 499                 h2cParaLen = 1;\r
 500                 // 2. execute h2c and check respond c2h from bt fw is correct or not\r
 501                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
 502         }\r
 503         \r
 504         // 3. construct respond status code and data.\r
 505         if(BT_STATUS_BT_OP_SUCCESS == retStatus)\r
 506         {\r
 507                 pBtRsp->status = BT_STATUS_SUCCESS;\r
 508         }\r
 509         else\r
 510         {\r
 511                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
 512                 DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
 513         }\r
 514         \r
 515         return paraLen;\r
 516 }\r
 517 \r
 518 \r
 519 VOID\r
 520 MPTBT_FwC2hBtMpCtrl(\r
 521         PADAPTER        Adapter,\r
 522         pu1Byte         tmpBuf,\r
 523         u1Byte          length\r
 524         )\r
 525 {\r
 526         u32 i;\r
 527         PMPT_CONTEXT    pMptCtx=&(Adapter->mppriv.MptCtx);\r
 528         PBT_EXT_C2H pExtC2h=(PBT_EXT_C2H)tmpBuf;\r
 529         \r
 530         if(Adapter->bBTFWReady == _FALSE || Adapter->registrypriv.mp_mode == 0 )\r
 531         {       \r
 532                 DBG_8192C("Ignore C2H BT MP Info since not in MP mode \n");\r
 533                 return;\r
 534         }\r
 535         if( length > 32 || length < 3 )\r
 536         {\r
 537                 DBG_8192C("\n [MPT], pExtC2h->buf hex: length=%d > 32 || < 3\n",length);\r
 538                 return;\r
 539         }\r
 540 \r
 541         //cancel_timeout for h2c handle\r
 542         _cancel_timer_ex(&pMptCtx->MPh2c_timeout_timer);\r
 543 \r
 544         for (i=0; i<length; i++)\r
 545         {\r
 546                 DBG_8192C("[MPT], %s, buf[%d]=0x%02x ", __FUNCTION__, i, tmpBuf[i]);\r
 547         }\r
 548         DBG_8192C("[MPT], pExtC2h->extendId=0x%x\n", pExtC2h->extendId);\r
 549         \r
 550         switch(pExtC2h->extendId)\r
 551         {\r
 552                 case EXT_C2H_WIFI_FW_ACTIVE_RSP:\r
 553                         DBG_8192C("[MPT], EXT_C2H_WIFI_FW_ACTIVE_RSP\n");\r
 554 #if 0\r
 555                         DBG_8192C("[MPT], pExtC2h->buf hex: \n");\r
 556                         for (i=0; i<(length-3); i++)\r
 557                         {\r
 558                                 DBG_8192C(" 0x%x ", pExtC2h->buf[i]);\r
 559                         }\r
 560 #endif\r
 561                         if ((_FALSE == pMptCtx->bMPh2c_timeout)\r
 562                                 && (_FALSE == pMptCtx->MptH2cRspEvent))\r
 563                         {\r
 564                                 pMptCtx->MptH2cRspEvent = _TRUE;\r
 565                                 _rtw_up_sema(&pMptCtx->MPh2c_Sema);\r
 566                         }\r
 567                         break;\r
 568 \r
 569                 case EXT_C2H_TRIG_BY_BT_FW:\r
 570                         DBG_8192C("[MPT], EXT_C2H_TRIG_BY_BT_FW\n");\r
 571                         _rtw_memcpy(&pMptCtx->c2hBuf[0], tmpBuf, length);\r
 572                         DBG_8192C("[MPT], pExtC2h->statusCode=0x%x\n", pExtC2h->statusCode);\r
 573                         DBG_8192C("[MPT], pExtC2h->retLen=0x%x\n", pExtC2h->retLen);\r
 574                         DBG_8192C("[MPT], pExtC2h->opCodeVer=0x%x\n", pExtC2h->opCodeVer);\r
 575                         DBG_8192C("[MPT], pExtC2h->reqNum=0x%x\n", pExtC2h->reqNum);\r
 576                         for (i=0; i<(length-3); i++)\r
 577                         {\r
 578                                 DBG_8192C("[MPT], pExtC2h->buf[%d]=0x%02x\n", i, pExtC2h->buf[i]);\r
 579                         }\r
 580 \r
 581                         if ((_FALSE == pMptCtx->bMPh2c_timeout)\r
 582                                 && (_TRUE == pMptCtx->MptH2cRspEvent)\r
 583                                 && (_FALSE == pMptCtx->MptBtC2hEvent))\r
 584                         {\r
 585                                 pMptCtx->MptBtC2hEvent = _TRUE;\r
 586                                 _rtw_up_sema(&pMptCtx->MPh2c_Sema);\r
 587                         }\r
 588                         break;\r
 589 \r
 590                 default:\r
 591                         DBG_8192C("[MPT], EXT_C2H Target not found,pExtC2h->extendId =%d ,pExtC2h->reqNum=%d\n",pExtC2h->extendId,pExtC2h->reqNum);\r
 592                         break;\r
 593         }\r
 594         \r
 595 \r
 596         \r
 597 }\r
 598 \r
 599 \r
 600 u2Byte\r
 601 mptbt_BtGetGeneral(\r
 602         IN      PADAPTER                Adapter,\r
 603         IN      PBT_REQ_CMD     pBtReq,\r
 604         IN      PBT_RSP_CMD     pBtRsp\r
 605         )\r
 606 {\r
 607         PMPT_CONTEXT            pMptCtx=&(Adapter->mppriv.MptCtx);\r
 608         PBT_EXT_C2H             pExtC2h=(PBT_EXT_C2H)&pMptCtx->c2hBuf[0];\r
 609         u1Byte                          h2cParaBuf[6] ={0};\r
 610         u1Byte                          h2cParaLen=0;\r
 611         u2Byte                          paraLen=0;\r
 612         u1Byte                          retStatus=BT_STATUS_BT_OP_SUCCESS;\r
 613         u1Byte                          btOpcode, bdAddr[6]={0};\r
 614         u1Byte                          btOpcodeVer=0;\r
 615         u1Byte                          getType=0, i;\r
 616         u2Byte                          getParaLen=0, validParaLen=0;\r
 617         u1Byte                          regType=0, reportType=0;\r
 618         u4Byte                          regAddr=0, regValue=0;\r
 619         pu4Byte                         pu4Tmp;\r
 620         pu2Byte                         pu2Tmp;\r
 621         pu1Byte                         pu1Tmp;\r
 622 \r
 623         //\r
 624         // check upper layer parameters\r
 625         //\r
 626         \r
 627         // check upper layer opcode version\r
 628         if(pBtReq->opCodeVer != 1)\r
 629         {\r
 630                 DBG_8192C("[MPT], Error!! Upper OP code version not match!!!\n");\r
 631                 pBtRsp->status = BT_STATUS_OPCODE_U_VERSION_MISMATCH;\r
 632                 return paraLen;\r
 633         }\r
 634         // check upper layer parameter length\r
 635         if(pBtReq->paraLength < 1)\r
 636         {\r
 637                 DBG_8192C("[MPT], Error!! wrong parameter length=%d (should larger than 1)\n", pBtReq->paraLength);\r
 638                 pBtRsp->status = BT_STATUS_PARAMETER_FORMAT_ERROR_U;\r
 639                 return paraLen;\r
 640         }\r
 641         getParaLen = pBtReq->paraLength - 1;\r
 642         getType = pBtReq->pParamStart[0];\r
 643         \r
 644         DBG_8192C("[MPT], getType=%d, getParaLen=%d\n", getType, getParaLen);\r
 645 \r
 646         // check parameter first\r
 647         switch(getType)\r
 648         {\r
 649                 case BT_GGET_REG:\r
 650                         DBG_8192C("[MPT], [BT_GGET_REG]\n");\r
 651                         validParaLen = 5;\r
 652                         if(getParaLen == validParaLen)\r
 653                         {\r
 654                                 btOpcode = BT_LO_OP_READ_REG;\r
 655                                 regType = pBtReq->pParamStart[1];\r
 656                                 pu4Tmp = (pu4Byte)&pBtReq->pParamStart[2];\r
 657                                 regAddr = *pu4Tmp;\r
 658                                 DBG_8192C("[MPT], BT_GGET_REG regType=0x%02x, regAddr=0x%08x!!\n",\r
 659                                         regType, regAddr);\r
 660                                 if(regType >= BT_REG_MAX)\r
 661                                 {\r
 662                                         pBtRsp->status = (btOpcode<<8)| BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
 663                                         return paraLen;\r
 664                                 }\r
 665                                 else\r
 666                                 {\r
 667                                         if( ((BT_REG_RF==regType)&&(regAddr>0x7f)) ||\r
 668                                                 ((BT_REG_MODEM==regType)&&(regAddr>0x1ff)) ||\r
 669                                                 ((BT_REG_BLUEWIZE==regType)&&(regAddr>0xfff)) ||\r
 670                                                 ((BT_REG_VENDOR==regType)&&(regAddr>0xfff)) ||\r
 671                                                 ((BT_REG_LE==regType)&&(regAddr>0xfff)) )\r
 672                                         {                               \r
 673                                                 pBtRsp->status = (btOpcode<<8)| BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
 674                                                 return paraLen;\r
 675                                         }\r
 676                                 }\r
 677                         }\r
 678                         break;\r
 679                 case BT_GGET_STATUS:\r
 680                         DBG_8192C("[MPT], [BT_GGET_STATUS]\n");\r
 681                         validParaLen = 0;\r
 682                         break;\r
 683                 case BT_GGET_REPORT:\r
 684                         DBG_8192C("[MPT], [BT_GGET_REPORT]\n");\r
 685                         validParaLen = 1;\r
 686                         if(getParaLen == validParaLen)\r
 687                         {\r
 688                                 reportType = pBtReq->pParamStart[1];\r
 689                                 DBG_8192C("[MPT], BT_GGET_REPORT reportType=0x%x!!\n", reportType);\r
 690                                 if(reportType >= BT_REPORT_MAX)\r
 691                                 {\r
 692                                         pBtRsp->status = BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
 693                                         return paraLen;\r
 694                                 }\r
 695                         }\r
 696                         break;\r
 697                 default:\r
 698                         {\r
 699                                 DBG_8192C("[MPT], Error!! getType=%d, out of range\n", getType);\r
 700                                 pBtRsp->status = BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
 701                                 return paraLen;\r
 702                         }\r
 703                         break;\r
 704         }\r
 705         if(getParaLen != validParaLen)\r
 706         {\r
 707                 DBG_8192C("[MPT], Error!! wrong parameter length=%d for BT_GET_GEN_CMD cmd id=0x%x, paraLen should=0x%x\n",\r
 708                         getParaLen, getType, validParaLen);\r
 709                 pBtRsp->status = BT_STATUS_PARAMETER_FORMAT_ERROR_U;\r
 710                 return paraLen;\r
 711         }\r
 712         \r
 713         //\r
 714         // execute lower layer opcodes\r
 715         //\r
 716         if(BT_GGET_REG == getType)\r
 717         {\r
 718                 // fill h2c parameters\r
 719                 // here we should write reg value first then write the address, adviced by Austin\r
 720                 btOpcode = BT_LO_OP_READ_REG;\r
 721                 h2cParaBuf[0] = regType;\r
 722                 h2cParaBuf[1] = pBtReq->pParamStart[2];\r
 723                 h2cParaBuf[2] = pBtReq->pParamStart[3];\r
 724                 h2cParaLen = 3;\r
 725                 // execute h2c and check respond c2h from bt fw is correct or not\r
 726                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
 727                 // construct respond status code and data.\r
 728                 if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
 729                 {\r
 730                         pBtRsp->status = ((btOpcode<<8)|retStatus);\r
 731                         DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
 732                         return paraLen;\r
 733                 }\r
 734 \r
 735                 pu2Tmp = (pu2Byte)&pExtC2h->buf[0];\r
 736                 regValue = *pu2Tmp;\r
 737                 DBG_8192C("[MPT], read reg regType=0x%02x, regAddr=0x%08x, regValue=0x%04x\n", \r
 738                         regType, regAddr, regValue);\r
 739                 \r
 740                 pu4Tmp = (pu4Byte)&pBtRsp->pParamStart[0];\r
 741                 *pu4Tmp = regValue;\r
 742                 paraLen = 4;\r
 743         }\r
 744         else if(BT_GGET_STATUS == getType)\r
 745         {\r
 746                 btOpcode = BT_LO_OP_GET_BT_STATUS;\r
 747                 h2cParaLen = 0;\r
 748                 // execute h2c and check respond c2h from bt fw is correct or not\r
 749                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
 750                 // construct respond status code and data.\r
 751                 if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
 752                 {\r
 753                         pBtRsp->status = ((btOpcode<<8)|retStatus);\r
 754                         DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
 755                         return paraLen;\r
 756                 }\r
 757 \r
 758                 pBtRsp->pParamStart[0] = pExtC2h->buf[0];\r
 759                 pBtRsp->pParamStart[1] = pExtC2h->buf[1];\r
 760                 DBG_8192C("[MPT], read bt status, testMode=0x%x, testStatus=0x%x\n", \r
 761                         pBtRsp->pParamStart[0], pBtRsp->pParamStart[1]);                \r
 762                 paraLen = 2;\r
 763         }\r
 764         else if(BT_GGET_REPORT == getType)\r
 765         {\r
 766                 switch(reportType)\r
 767                 {\r
 768                         case BT_REPORT_RX_PACKET_CNT:\r
 769                                 {\r
 770                                         DBG_8192C("[MPT], [Rx Packet Counts]\n");\r
 771                                         btOpcode = BT_LO_OP_GET_RX_PKT_CNT_L;\r
 772                                         h2cParaLen = 0;\r
 773                                         // execute h2c and check respond c2h from bt fw is correct or not\r
 774                                         retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
 775                                         // construct respond status code and data.\r
 776                                         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
 777                                         {\r
 778                                                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
 779                                                 DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
 780                                                 return paraLen;\r
 781                                         }\r
 782                                         pBtRsp->pParamStart[0] = pExtC2h->buf[0];\r
 783                                         pBtRsp->pParamStart[1] = pExtC2h->buf[1];\r
 784 \r
 785                                         btOpcode = BT_LO_OP_GET_RX_PKT_CNT_H;\r
 786                                         h2cParaLen = 0;\r
 787                                         // execute h2c and check respond c2h from bt fw is correct or not\r
 788                                         retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
 789                                         // construct respond status code and data.\r
 790                                         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
 791                                         {\r
 792                                                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
 793                                                 DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
 794                                                 return paraLen;\r
 795                                         }\r
 796                                         pBtRsp->pParamStart[2] = pExtC2h->buf[0];\r
 797                                         pBtRsp->pParamStart[3] = pExtC2h->buf[1];\r
 798                                         paraLen = 4;\r
 799                                 }\r
 800                                 break;\r
 801                         case BT_REPORT_RX_ERROR_BITS:\r
 802                                 {\r
 803                                         DBG_8192C("[MPT], [Rx Error Bits]\n");\r
 804                                         btOpcode = BT_LO_OP_GET_RX_ERROR_BITS_L;\r
 805                                         h2cParaLen = 0;\r
 806                                         // execute h2c and check respond c2h from bt fw is correct or not\r
 807                                         retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
 808                                         // construct respond status code and data.\r
 809                                         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
 810                                         {\r
 811                                                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
 812                                                 DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
 813                                                 return paraLen;\r
 814                                         }\r
 815                                         pBtRsp->pParamStart[0] = pExtC2h->buf[0];\r
 816                                         pBtRsp->pParamStart[1] = pExtC2h->buf[1];\r
 817 \r
 818                                         btOpcode = BT_LO_OP_GET_RX_ERROR_BITS_H;\r
 819                                         h2cParaLen = 0;\r
 820                                         // execute h2c and check respond c2h from bt fw is correct or not\r
 821                                         retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
 822                                         // construct respond status code and data.\r
 823                                         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
 824                                         {\r
 825                                                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
 826                                                 DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
 827                                                 return paraLen;\r
 828                                         }\r
 829                                         pBtRsp->pParamStart[2] = pExtC2h->buf[0];\r
 830                                         pBtRsp->pParamStart[3] = pExtC2h->buf[1];\r
 831                                         paraLen = 4;\r
 832                                 }\r
 833                                 break;\r
 834                         case BT_REPORT_RSSI:\r
 835                                 {\r
 836                                         DBG_8192C("[MPT], [RSSI]\n");\r
 837                                         btOpcode = BT_LO_OP_GET_RSSI;\r
 838                                         h2cParaLen = 0;\r
 839                                         // execute h2c and check respond c2h from bt fw is correct or not\r
 840                                         retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
 841                                         // construct respond status code and data.\r
 842                                         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
 843                                         {\r
 844                                                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
 845                                                 DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
 846                                                 return paraLen;\r
 847                                         }\r
 848                                         pBtRsp->pParamStart[0] = pExtC2h->buf[0];\r
 849                                         pBtRsp->pParamStart[1] = pExtC2h->buf[1];\r
 850                                         paraLen = 2;\r
 851                                 }\r
 852                                 break;\r
 853                         case BT_REPORT_CFO_HDR_QUALITY:\r
 854                                 {\r
 855                                         DBG_8192C("[MPT], [CFO & Header Quality]\n");\r
 856                                         btOpcode = BT_LO_OP_GET_CFO_HDR_QUALITY_L;\r
 857                                         h2cParaLen = 0;\r
 858                                         // execute h2c and check respond c2h from bt fw is correct or not\r
 859                                         retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
 860                                         // construct respond status code and data.\r
 861                                         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
 862                                         {\r
 863                                                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
 864                                                 DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
 865                                                 return paraLen;\r
 866                                         }\r
 867                                         pBtRsp->pParamStart[0] = pExtC2h->buf[0];\r
 868                                         pBtRsp->pParamStart[1] = pExtC2h->buf[1];\r
 869 \r
 870                                         btOpcode = BT_LO_OP_GET_CFO_HDR_QUALITY_H;\r
 871                                         h2cParaLen = 0;\r
 872                                         // execute h2c and check respond c2h from bt fw is correct or not\r
 873                                         retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
 874                                         // construct respond status code and data.\r
 875                                         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
 876                                         {\r
 877                                                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
 878                                                 DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
 879                                                 return paraLen;\r
 880                                         }\r
 881                                         pBtRsp->pParamStart[2] = pExtC2h->buf[0];\r
 882                                         pBtRsp->pParamStart[3] = pExtC2h->buf[1];\r
 883                                         paraLen = 4;\r
 884                                 }\r
 885                                 break;\r
 886                         case BT_REPORT_CONNECT_TARGET_BD_ADDR:\r
 887                                 {\r
 888                                         DBG_8192C("[MPT], [Connected Target BD ADDR]\n");\r
 889                                         btOpcode = BT_LO_OP_GET_TARGET_BD_ADDR_L;\r
 890                                         h2cParaLen = 0;\r
 891                                         // execute h2c and check respond c2h from bt fw is correct or not\r
 892                                         retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
 893                                         // construct respond status code and data.\r
 894                                         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
 895                                         {\r
 896                                                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
 897                                                 DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
 898                                                 return paraLen;\r
 899                                         }\r
 900                                         bdAddr[5] = pExtC2h->buf[0];\r
 901                                         bdAddr[4] = pExtC2h->buf[1];\r
 902                                         bdAddr[3] = pExtC2h->buf[2];\r
 903 \r
 904                                         btOpcode = BT_LO_OP_GET_TARGET_BD_ADDR_H;\r
 905                                         h2cParaLen = 0;\r
 906                                         // execute h2c and check respond c2h from bt fw is correct or not\r
 907                                         retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
 908                                         // construct respond status code and data.\r
 909                                         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
 910                                         {\r
 911                                                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
 912                                                 DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
 913                                                 return paraLen;\r
 914                                         }\r
 915                                         bdAddr[2] = pExtC2h->buf[0];\r
 916                                         bdAddr[1] = pExtC2h->buf[1];\r
 917                                         bdAddr[0] = pExtC2h->buf[2];\r
 918                                                 \r
 919                                         DBG_8192C("[MPT], Connected Target BDAddr:%s", bdAddr);\r
 920                                         for(i=0; i<6; i++)\r
 921                                         {\r
 922                                                 pBtRsp->pParamStart[i] = bdAddr[5-i];\r
 923                                         }\r
 924                                         paraLen = 6;\r
 925                                 }\r
 926                                 break;\r
 927                         default:\r
 928                                 pBtRsp->status = BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
 929                                 return paraLen;\r
 930                                 break;\r
 931                 }\r
 932         }\r
 933 \r
 934         pBtRsp->status = BT_STATUS_SUCCESS;\r
 935         return paraLen;\r
 936 }\r
 937 \r
 938 \r
 939 \r
 940 u2Byte\r
 941 mptbt_BtSetGeneral(\r
 942         IN      PADAPTER                Adapter,\r
 943         IN      PBT_REQ_CMD     pBtReq,\r
 944         IN      PBT_RSP_CMD     pBtRsp\r
 945         )\r
 946 {\r
 947         u1Byte                          h2cParaBuf[6] ={0};\r
 948         u1Byte                          h2cParaLen=0;\r
 949         u2Byte                          paraLen=0;\r
 950         u1Byte                          retStatus=BT_STATUS_BT_OP_SUCCESS;\r
 951         u1Byte                          btOpcode;\r
 952         u1Byte                          btOpcodeVer=0;\r
 953         u1Byte                          setType=0;\r
 954         u2Byte                          setParaLen=0, validParaLen=0;\r
 955         u1Byte                          regType=0, bdAddr[6]={0}, calVal=0;\r
 956         u4Byte                          regAddr=0, regValue=0;\r
 957         pu4Byte                         pu4Tmp;\r
 958         pu2Byte                         pu2Tmp;\r
 959         pu1Byte                         pu1Tmp;\r
 960 \r
 961         //\r
 962         // check upper layer parameters\r
 963         //\r
 964         \r
 965         // check upper layer opcode version\r
 966         if(pBtReq->opCodeVer != 1)\r
 967         {\r
 968                 DBG_8192C("[MPT], Error!! Upper OP code version not match!!!\n");\r
 969                 pBtRsp->status = BT_STATUS_OPCODE_U_VERSION_MISMATCH;\r
 970                 return paraLen;\r
 971         }\r
 972         // check upper layer parameter length\r
 973         if(pBtReq->paraLength < 1)\r
 974         {\r
 975                 DBG_8192C("[MPT], Error!! wrong parameter length=%d (should larger than 1)\n", pBtReq->paraLength);\r
 976                 pBtRsp->status = BT_STATUS_PARAMETER_FORMAT_ERROR_U;\r
 977                 return paraLen;\r
 978         }\r
 979         setParaLen = pBtReq->paraLength - 1;\r
 980         setType = pBtReq->pParamStart[0];\r
 981         \r
 982         DBG_8192C("[MPT], setType=%d, setParaLen=%d\n", setType, setParaLen);\r
 983 \r
 984         // check parameter first\r
 985         switch(setType)\r
 986         {\r
 987                 case BT_GSET_REG:\r
 988                         DBG_8192C ("[MPT], [BT_GSET_REG]\n");\r
 989                         validParaLen = 9;\r
 990                         if(setParaLen == validParaLen)\r
 991                         {\r
 992                                 btOpcode = BT_LO_OP_WRITE_REG_VALUE;\r
 993                                 regType = pBtReq->pParamStart[1];\r
 994                                 pu4Tmp = (pu4Byte)&pBtReq->pParamStart[2];\r
 995                                 regAddr = *pu4Tmp;\r
 996                                 pu4Tmp = (pu4Byte)&pBtReq->pParamStart[6];\r
 997                                 regValue = *pu4Tmp;\r
 998                                 DBG_8192C("[MPT], BT_GSET_REG regType=0x%x, regAddr=0x%x, regValue=0x%x!!\n", \r
 999                                         regType, regAddr, regValue);\r
1000                                 if(regType >= BT_REG_MAX)\r
1001                                 {\r
1002                                         pBtRsp->status = (btOpcode<<8)| BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
1003                                         return paraLen;\r
1004                                 }\r
1005                                 else\r
1006                                 {\r
1007                                         if( ((BT_REG_RF==regType)&&(regAddr>0x7f)) ||\r
1008                                                 ((BT_REG_MODEM==regType)&&(regAddr>0x1ff)) ||\r
1009                                                 ((BT_REG_BLUEWIZE==regType)&&(regAddr>0xfff)) ||\r
1010                                                 ((BT_REG_VENDOR==regType)&&(regAddr>0xfff)) ||\r
1011                                                 ((BT_REG_LE==regType)&&(regAddr>0xfff)) )\r
1012                                         {                               \r
1013                                                 pBtRsp->status = (btOpcode<<8)| BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
1014                                                 return paraLen;\r
1015                                         }\r
1016                                 }\r
1017                         }\r
1018                         break;\r
1019                 case BT_GSET_RESET:\r
1020                         DBG_8192C("[MPT], [BT_GSET_RESET]\n");\r
1021                         validParaLen = 0;\r
1022                         break;\r
1023                 case BT_GSET_TARGET_BD_ADDR:\r
1024                         DBG_8192C("[MPT], [BT_GSET_TARGET_BD_ADDR]\n");\r
1025                         validParaLen = 6;\r
1026                         if(setParaLen == validParaLen)\r
1027                         {\r
1028                                 btOpcode = BT_LO_OP_SET_TARGET_BD_ADDR_H;\r
1029                                 if( (pBtReq->pParamStart[1]==0) &&\r
1030                                         (pBtReq->pParamStart[2]==0) &&\r
1031                                         (pBtReq->pParamStart[3]==0) &&\r
1032                                         (pBtReq->pParamStart[4]==0) &&\r
1033                                         (pBtReq->pParamStart[5]==0) &&\r
1034                                         (pBtReq->pParamStart[6]==0) )\r
1035                                 {\r
1036                                         DBG_8192C("[MPT], Error!! targetBDAddr=all zero\n");\r
1037                                         pBtRsp->status = (btOpcode<<8)|BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
1038                                         return paraLen;\r
1039                                 }\r
1040                                 if( (pBtReq->pParamStart[1]==0xff) &&\r
1041                                         (pBtReq->pParamStart[2]==0xff) &&\r
1042                                         (pBtReq->pParamStart[3]==0xff) &&\r
1043                                         (pBtReq->pParamStart[4]==0xff) &&\r
1044                                         (pBtReq->pParamStart[5]==0xff) &&\r
1045                                         (pBtReq->pParamStart[6]==0xff) )\r
1046                                 {\r
1047                                         DBG_8192C("[MPT], Error!! targetBDAddr=all 0xf\n");\r
1048                                         pBtRsp->status = (btOpcode<<8)|BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
1049                                         return paraLen;\r
1050                                 }\r
1051                                 bdAddr[0] = pBtReq->pParamStart[6];\r
1052                                 bdAddr[1] = pBtReq->pParamStart[5];\r
1053                                 bdAddr[2] = pBtReq->pParamStart[4];\r
1054                                 bdAddr[3] = pBtReq->pParamStart[3];\r
1055                                 bdAddr[4] = pBtReq->pParamStart[2];\r
1056                                 bdAddr[5] = pBtReq->pParamStart[1];\r
1057                                 DBG_8192C ("[MPT], target BDAddr:%x,%x,%x,%x,%x,%x\n", \r
1058                                                         bdAddr[0],bdAddr[1],bdAddr[2],bdAddr[3],bdAddr[4],bdAddr[5]);\r
1059                         }\r
1060                         break;\r
1061                 case BT_GSET_TX_PWR_FINETUNE:\r
1062                         DBG_8192C("[MPT], [BT_GSET_TX_PWR_FINETUNE]\n");\r
1063                         validParaLen = 1;\r
1064                         if(setParaLen == validParaLen)\r
1065                         {\r
1066                                 btOpcode = BT_LO_OP_SET_TX_POWER_CALIBRATION;\r
1067                                 calVal = pBtReq->pParamStart[1];\r
1068                                 if( (calVal<1) || (calVal>9) )\r
1069                                 {\r
1070                                         pBtRsp->status = (btOpcode<<8)|BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
1071                                         return paraLen;\r
1072                                 }\r
1073                                 DBG_8192C ("[MPT], calVal=%d\n", calVal);\r
1074                         }\r
1075                         break;\r
1076                 case BT_SET_TRACKING_INTERVAL:\r
1077                         DBG_871X("[MPT], [BT_SET_TRACKING_INTERVAL] setParaLen =%d \n",setParaLen);\r
1078                         \r
1079                         validParaLen = 1;       \r
1080                         if(setParaLen == validParaLen)  \r
1081                                 calVal = pBtReq->pParamStart[1];\r
1082                         break;\r
1083                 case BT_SET_THERMAL_METER:\r
1084                         DBG_871X("[MPT], [BT_SET_THERMAL_METER] setParaLen =%d \n",setParaLen);\r
1085                         validParaLen = 1;       \r
1086                         if(setParaLen == validParaLen)  \r
1087                                 calVal = pBtReq->pParamStart[1];\r
1088                         break;\r
1089                 case BT_ENABLE_CFO_TRACKING:\r
1090                         DBG_871X("[MPT], [BT_ENABLE_CFO_TRACKING] setParaLen =%d \n",setParaLen);\r
1091                         validParaLen = 1;       \r
1092                         if(setParaLen == validParaLen)  \r
1093                                 calVal = pBtReq->pParamStart[1];\r
1094                         break;\r
1095                 case BT_GSET_UPDATE_BT_PATCH:\r
1096                         if(IS_HARDWARE_TYPE_8723AE(Adapter) && Adapter->bFWReady)\r
1097                         {\r
1098                                 u1Byte i;\r
1099                                 DBG_8192C ("[MPT], write regs for load patch\n");\r
1100                                 //BTFwPatch8723A(Adapter);\r
1101                                 PlatformEFIOWrite1Byte(Adapter, 0xCC, 0x2d);\r
1102                                 rtw_msleep_os(50);\r
1103                                 PlatformEFIOWrite4Byte(Adapter, 0x68, 0xa005000c);\r
1104                                 rtw_msleep_os(50);\r
1105                                 PlatformEFIOWrite4Byte(Adapter, 0x68, 0xb005000c);\r
1106                                 rtw_msleep_os(50);\r
1107                                 PlatformEFIOWrite1Byte(Adapter, 0xCC, 0x29);\r
1108                                 for(i=0; i<12; i++)\r
1109                                 rtw_msleep_os(100);\r
1110 //#if (DEV_BUS_TYPE == RT_PCI_INTERFACE)\r
1111 //                              BTFwPatch8723A(Adapter);\r
1112 //#endif\r
1113                                 DBG_8192C("[MPT], load BT FW Patch finished!!!\n");\r
1114                         }\r
1115                         break;\r
1116                 default:\r
1117                         {\r
1118                                 DBG_8192C ("[MPT], Error!! setType=%d, out of range\n", setType);\r
1119                                 pBtRsp->status = BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
1120                                 return paraLen;\r
1121                         }\r
1122                         break;\r
1123         }\r
1124         if(setParaLen != validParaLen)\r
1125         {\r
1126                 DBG_8192C("[MPT], Error!! wrong parameter length=%d for BT_SET_GEN_CMD cmd id=0x%x, paraLen should=0x%x\n",\r
1127                         setParaLen, setType, validParaLen);\r
1128                 pBtRsp->status = BT_STATUS_PARAMETER_FORMAT_ERROR_U;\r
1129                 return paraLen;\r
1130         }\r
1131         \r
1132         //\r
1133         // execute lower layer opcodes\r
1134         //\r
1135         if(BT_GSET_REG == setType)\r
1136         {\r
1137                 // fill h2c parameters\r
1138                 // here we should write reg value first then write the address, adviced by Austin\r
1139                 btOpcode = BT_LO_OP_WRITE_REG_VALUE;\r
1140                 h2cParaBuf[0] = pBtReq->pParamStart[6];\r
1141                 h2cParaBuf[1] = pBtReq->pParamStart[7];\r
1142                 h2cParaBuf[2] = pBtReq->pParamStart[8];\r
1143                 h2cParaLen = 3;\r
1144                 // execute h2c and check respond c2h from bt fw is correct or not\r
1145                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
1146                 // construct respond status code and data.\r
1147                 if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1148                 {\r
1149                         pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1150                         DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1151                         return paraLen;\r
1152                 }\r
1153                 \r
1154                 // write reg address\r
1155                 btOpcode = BT_LO_OP_WRITE_REG_ADDR;\r
1156                 h2cParaBuf[0] = regType;\r
1157                 h2cParaBuf[1] = pBtReq->pParamStart[2];\r
1158                 h2cParaBuf[2] = pBtReq->pParamStart[3];\r
1159                 h2cParaLen = 3;\r
1160                 // execute h2c and check respond c2h from bt fw is correct or not\r
1161                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
1162                 // construct respond status code and data.\r
1163                 if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1164                 {\r
1165                         pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1166                         DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1167                         return paraLen;\r
1168                 }               \r
1169         }\r
1170         else if(BT_GSET_RESET == setType)\r
1171         {\r
1172                 btOpcode = BT_LO_OP_RESET;\r
1173                 h2cParaLen = 0;\r
1174                 // execute h2c and check respond c2h from bt fw is correct or not\r
1175                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
1176                 // construct respond status code and data.\r
1177                 if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1178                 {\r
1179                         pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1180                         DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1181                         return paraLen;\r
1182                 }\r
1183         }\r
1184         else if(BT_GSET_TARGET_BD_ADDR == setType)\r
1185         {\r
1186                 // fill h2c parameters\r
1187                 btOpcode = BT_LO_OP_SET_TARGET_BD_ADDR_L;\r
1188                 h2cParaBuf[0] = pBtReq->pParamStart[1];\r
1189                 h2cParaBuf[1] = pBtReq->pParamStart[2];\r
1190                 h2cParaBuf[2] = pBtReq->pParamStart[3];\r
1191                 h2cParaLen = 3;\r
1192                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);                \r
1193                 // ckeck bt return status.\r
1194                 if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1195                 {\r
1196                         pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1197                         DBG_8192C ("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1198                         return paraLen;\r
1199                 }\r
1200 \r
1201                 btOpcode = BT_LO_OP_SET_TARGET_BD_ADDR_H;\r
1202                 h2cParaBuf[0] = pBtReq->pParamStart[4];\r
1203                 h2cParaBuf[1] = pBtReq->pParamStart[5];\r
1204                 h2cParaBuf[2] = pBtReq->pParamStart[6];\r
1205                 h2cParaLen = 3;\r
1206                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);                \r
1207                 // ckeck bt return status.\r
1208                 if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1209                 {\r
1210                         pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1211                         DBG_8192C ("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1212                         return paraLen;\r
1213                 }\r
1214         }\r
1215         else if(BT_GSET_TX_PWR_FINETUNE == setType)\r
1216         {\r
1217                 // fill h2c parameters\r
1218                 btOpcode = BT_LO_OP_SET_TX_POWER_CALIBRATION;\r
1219                 h2cParaBuf[0] = calVal;\r
1220                 h2cParaLen = 1;\r
1221                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
1222                 // ckeck bt return status.\r
1223                 if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1224                 {\r
1225                         pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1226                         DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1227                         return paraLen;\r
1228                 }\r
1229         }\r
1230         else if(BT_SET_TRACKING_INTERVAL == setType)\r
1231         {\r
1232                 //      BT_LO_OP_SET_TRACKING_INTERVAL                                                          = 0x22,\r
1233                 //      BT_LO_OP_SET_THERMAL_METER                                                                      = 0x23,\r
1234                 //      BT_LO_OP_ENABLE_CFO_TRACKING                                                                    = 0x24,\r
1235                                 btOpcode = BT_LO_OP_SET_TRACKING_INTERVAL;\r
1236                                 h2cParaBuf[0] = calVal;\r
1237                                 h2cParaLen = 1;\r
1238                                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);                \r
1239                                 // ckeck bt return status.\r
1240                                 if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1241                                 {\r
1242                                         pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1243                                         DBG_8192C ("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1244                                         return paraLen;\r
1245                                 }\r
1246         }\r
1247         else if(BT_SET_THERMAL_METER == setType)\r
1248         {\r
1249                                 btOpcode = BT_LO_OP_SET_THERMAL_METER;\r
1250                                 h2cParaBuf[0] = calVal;\r
1251                                 h2cParaLen = 1;\r
1252                                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);                \r
1253                                 // ckeck bt return status.\r
1254                                 if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1255                                 {\r
1256                                         pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1257                                         DBG_8192C ("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1258                                         return paraLen;\r
1259                                 }\r
1260         }\r
1261         else if(BT_ENABLE_CFO_TRACKING == setType)\r
1262         {\r
1263                                 btOpcode = BT_LO_OP_ENABLE_CFO_TRACKING;\r
1264                                 h2cParaBuf[0] = calVal;\r
1265                                 h2cParaLen = 1;\r
1266                                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);                \r
1267                                 // ckeck bt return status.\r
1268                                 if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1269                                 {\r
1270                                         pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1271                                         DBG_8192C ("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1272                         return paraLen;\r
1273                 }\r
1274         }\r
1275         \r
1276         pBtRsp->status = BT_STATUS_SUCCESS;\r
1277         return paraLen;\r
1278 }\r
1279 \r
1280 \r
1281 \r
1282 u2Byte\r
1283 mptbt_BtSetTxRxPars(\r
1284         IN      PADAPTER                Adapter,\r
1285         IN      PBT_REQ_CMD     pBtReq,\r
1286         IN      PBT_RSP_CMD     pBtRsp\r
1287         )\r
1288 {\r
1289         u1Byte                          h2cParaBuf[6] ={0};\r
1290         u1Byte                          h2cParaLen=0;\r
1291         u2Byte                          paraLen=0;\r
1292         u1Byte                          retStatus=BT_STATUS_BT_OP_SUCCESS;\r
1293         u1Byte                          btOpcode;\r
1294         u1Byte                          btOpcodeVer=0;\r
1295         PBT_TXRX_PARAMETERS pTxRxPars=(PBT_TXRX_PARAMETERS)&pBtReq->pParamStart[0];\r
1296         u2Byte                          lenTxRx=sizeof(BT_TXRX_PARAMETERS);\r
1297         u1Byte                          i;\r
1298         u1Byte                          bdAddr[6]={0};\r
1299 \r
1300         //\r
1301         // check upper layer parameters\r
1302         //\r
1303         \r
1304         // 1. check upper layer opcode version\r
1305         if(pBtReq->opCodeVer != 1)\r
1306         {\r
1307                 DBG_8192C("[MPT], Error!! Upper OP code version not match!!!\n");\r
1308                 pBtRsp->status = BT_STATUS_OPCODE_U_VERSION_MISMATCH;\r
1309                 return paraLen;\r
1310         }\r
1311         // 2. check upper layer parameter length\r
1312         if(pBtReq->paraLength == sizeof(BT_TXRX_PARAMETERS))\r
1313         {       \r
1314                 DBG_8192C ("[MPT], pTxRxPars->txrxChannel=0x%x \n", pTxRxPars->txrxChannel);\r
1315                 DBG_8192C ("[MPT], pTxRxPars->txrxTxPktCnt=0x%8x \n", pTxRxPars->txrxTxPktCnt);\r
1316                 DBG_8192C  ("[MPT], pTxRxPars->txrxTxPktInterval=0x%x \n", pTxRxPars->txrxTxPktInterval);\r
1317                 DBG_8192C  ("[MPT], pTxRxPars->txrxPayloadType=0x%x \n", pTxRxPars->txrxPayloadType);\r
1318                 DBG_8192C  ("[MPT], pTxRxPars->txrxPktType=0x%x \n", pTxRxPars->txrxPktType);\r
1319                 DBG_8192C  ("[MPT], pTxRxPars->txrxPayloadLen=0x%x \n", pTxRxPars->txrxPayloadLen);\r
1320                 DBG_8192C  ("[MPT], pTxRxPars->txrxPktHeader=0x%x \n", pTxRxPars->txrxPktHeader);\r
1321                 DBG_8192C  ("[MPT], pTxRxPars->txrxWhitenCoeff=0x%x \n", pTxRxPars->txrxWhitenCoeff);   \r
1322                 bdAddr[0] = pTxRxPars->txrxBdaddr[5];\r
1323                 bdAddr[1] = pTxRxPars->txrxBdaddr[4];\r
1324                 bdAddr[2] = pTxRxPars->txrxBdaddr[3];\r
1325                 bdAddr[3] = pTxRxPars->txrxBdaddr[2];\r
1326                 bdAddr[4] = pTxRxPars->txrxBdaddr[1];\r
1327                 bdAddr[5] = pTxRxPars->txrxBdaddr[0];\r
1328                 DBG_8192C  ("[MPT], pTxRxPars->txrxBdaddr: %s", &bdAddr[0]);\r
1329                 DBG_8192C ("[MPT], pTxRxPars->txrxTxGainIndex=0x%x \n", pTxRxPars->txrxTxGainIndex);\r
1330         }\r
1331         else\r
1332         {\r
1333                 DBG_8192C  ("[MPT], Error!! pBtReq->paraLength=%d, correct Len=%d\n", pBtReq->paraLength, lenTxRx);\r
1334                 pBtRsp->status = BT_STATUS_PARAMETER_FORMAT_ERROR_U;\r
1335                 return paraLen;\r
1336         }\r
1337 \r
1338         //\r
1339         // execute lower layer opcodes\r
1340         //\r
1341         \r
1342         // fill h2c parameters\r
1343         btOpcode = BT_LO_OP_SET_PKT_HEADER;\r
1344         if(pTxRxPars->txrxPktHeader > 0x3ffff)\r
1345         {\r
1346                 DBG_8192C  ("[MPT], Error!! pTxRxPars->txrxPktHeader=0x%x is out of range, (should be between 0x0~0x3ffff)\n", pTxRxPars->txrxPktHeader);\r
1347                 pBtRsp->status = (btOpcode<<8)|BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
1348                 return paraLen;\r
1349         }\r
1350         else\r
1351         {\r
1352                 h2cParaBuf[0] = (u1Byte)(pTxRxPars->txrxPktHeader&0xff);\r
1353                 h2cParaBuf[1] = (u1Byte)((pTxRxPars->txrxPktHeader&0xff00)>>8);\r
1354                 h2cParaBuf[2] = (u1Byte)((pTxRxPars->txrxPktHeader&0xff0000)>>16);\r
1355                 h2cParaLen = 3;\r
1356                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
1357         }\r
1358         \r
1359         // ckeck bt return status.\r
1360         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1361         {\r
1362                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1363                 DBG_8192C  ("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1364                 return paraLen;\r
1365         }       \r
1366 \r
1367         // fill h2c parameters\r
1368         btOpcode = BT_LO_OP_SET_PKT_TYPE_LEN;\r
1369         {\r
1370                 u2Byte  payloadLenLimit=0;\r
1371                 switch(pTxRxPars->txrxPktType)\r
1372                 {\r
1373                         case MP_BT_PKT_DH1:\r
1374                                 payloadLenLimit = 27*8;\r
1375                                 break;\r
1376                         case MP_BT_PKT_DH3:\r
1377                                 payloadLenLimit = 183*8;\r
1378                                 break;\r
1379                         case MP_BT_PKT_DH5:\r
1380                                 payloadLenLimit = 339*8;\r
1381                                 break;\r
1382                         case MP_BT_PKT_2DH1:\r
1383                                 payloadLenLimit = 54*8;\r
1384                                 break;\r
1385                         case MP_BT_PKT_2DH3:\r
1386                                 payloadLenLimit = 367*8;\r
1387                                 break;\r
1388                         case MP_BT_PKT_2DH5:\r
1389                                 payloadLenLimit = 679*8;\r
1390                                 break;\r
1391                         case MP_BT_PKT_3DH1:\r
1392                                 payloadLenLimit = 83*8;\r
1393                                 break;\r
1394                         case MP_BT_PKT_3DH3:\r
1395                                 payloadLenLimit = 552*8;\r
1396                                 break;\r
1397                         case MP_BT_PKT_3DH5:\r
1398                                 payloadLenLimit = 1021*8;\r
1399                                 break;\r
1400                         case MP_BT_PKT_LE:\r
1401                                 payloadLenLimit = 39*8;\r
1402                                 break;\r
1403                         default:\r
1404                                 {\r
1405                                         DBG_8192C  ("[MPT], Error!! Unknown pTxRxPars->txrxPktType=0x%x\n", pTxRxPars->txrxPktType);\r
1406                                         pBtRsp->status = (btOpcode<<8)|BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
1407                                         return paraLen;\r
1408                                 }\r
1409                                 break;\r
1410                 }\r
1411 \r
1412                 if(pTxRxPars->txrxPayloadLen > payloadLenLimit)\r
1413                 {\r
1414                         DBG_8192C ("[MPT], Error!! pTxRxPars->txrxPayloadLen=0x%x, (should smaller than %d)\n", \r
1415                                 pTxRxPars->txrxPayloadLen, payloadLenLimit);\r
1416                         pBtRsp->status = (btOpcode<<8)|BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
1417                         return paraLen;\r
1418                 }\r
1419 \r
1420                 h2cParaBuf[0] = pTxRxPars->txrxPktType;\r
1421                 h2cParaBuf[1] = (u1Byte)((pTxRxPars->txrxPayloadLen&0xff));\r
1422                 h2cParaBuf[2] = (u1Byte)((pTxRxPars->txrxPayloadLen&0xff00)>>8);\r
1423                 h2cParaLen = 3;\r
1424                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
1425         }\r
1426 \r
1427         // ckeck bt return status.\r
1428         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1429         {\r
1430                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1431                 DBG_8192C ("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1432                 return paraLen;\r
1433         }\r
1434 \r
1435         // fill h2c parameters\r
1436         btOpcode = BT_LO_OP_SET_PKT_CNT_L_PL_TYPE;\r
1437         if(pTxRxPars->txrxPayloadType > MP_BT_PAYLOAD_MAX)\r
1438         {\r
1439                 DBG_8192C  ("[MPT], Error!! pTxRxPars->txrxPayloadType=0x%x, (should be between 0~4)\n", pTxRxPars->txrxPayloadType);\r
1440                 pBtRsp->status = (btOpcode<<8)|BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
1441                 return paraLen;\r
1442         }\r
1443         else\r
1444         {\r
1445                 h2cParaBuf[0] = (u1Byte)((pTxRxPars->txrxTxPktCnt&0xff));\r
1446                 h2cParaBuf[1] = (u1Byte)((pTxRxPars->txrxTxPktCnt&0xff00)>>8);\r
1447                 h2cParaBuf[2] = pTxRxPars->txrxPayloadType;\r
1448                 h2cParaLen = 3;\r
1449                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
1450         }\r
1451         \r
1452         // ckeck bt return status.\r
1453         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1454         {\r
1455                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1456                 DBG_8192C ("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1457                 return paraLen;\r
1458         }       \r
1459 \r
1460         // fill h2c parameters\r
1461         btOpcode = BT_LO_OP_SET_PKT_CNT_H_PKT_INTV;\r
1462         if(pTxRxPars->txrxTxPktInterval > 15)\r
1463         {\r
1464         DBG_8192C  ("[MPT], Error!! pTxRxPars->txrxTxPktInterval=0x%x, (should be between 0~15)\n", pTxRxPars->txrxTxPktInterval);\r
1465         pBtRsp->status = (btOpcode<<8)|BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
1466                 return paraLen;\r
1467         }\r
1468         else\r
1469         {\r
1470                 h2cParaBuf[0] = (u1Byte)((pTxRxPars->txrxTxPktCnt&0xff0000)>>16);\r
1471                 h2cParaBuf[1] = (u1Byte)((pTxRxPars->txrxTxPktCnt&0xff000000)>>24);\r
1472                 h2cParaBuf[2] = pTxRxPars->txrxTxPktInterval;\r
1473                 h2cParaLen = 3;\r
1474                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
1475         }\r
1476         \r
1477         // ckeck bt return status.\r
1478         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1479         {\r
1480                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1481                 DBG_8192C ("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1482                 return paraLen;\r
1483         }       \r
1484 \r
1485         // fill h2c parameters\r
1486         btOpcode = BT_LO_OP_SET_WHITENCOEFF;\r
1487         {\r
1488                 h2cParaBuf[0] = pTxRxPars->txrxWhitenCoeff;\r
1489                 h2cParaLen = 1;\r
1490                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
1491         }\r
1492         \r
1493         // ckeck bt return status.\r
1494         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1495         {\r
1496                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1497                 DBG_8192C  ("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1498                 return paraLen;\r
1499         }\r
1500 \r
1501 \r
1502         // fill h2c parameters\r
1503         btOpcode = BT_LO_OP_SET_CHNL_TX_GAIN;\r
1504         if( (pTxRxPars->txrxChannel > 78) ||\r
1505                 (pTxRxPars->txrxTxGainIndex > 7) )\r
1506         {\r
1507                 DBG_8192C ("[MPT], Error!! pTxRxPars->txrxChannel=0x%x, (should be between 0~78)\n", pTxRxPars->txrxChannel);\r
1508                 DBG_8192C ("[MPT], Error!! pTxRxPars->txrxTxGainIndex=0x%x, (should be between 0~7)\n", pTxRxPars->txrxTxGainIndex);\r
1509                 pBtRsp->status = (btOpcode<<8)|BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
1510                 return paraLen;\r
1511         }\r
1512         else\r
1513         {\r
1514                 h2cParaBuf[0] = pTxRxPars->txrxChannel;\r
1515                 h2cParaBuf[1] = pTxRxPars->txrxTxGainIndex;\r
1516                 h2cParaLen = 2;\r
1517                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
1518         }\r
1519         \r
1520         // ckeck bt return status.\r
1521         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1522         {\r
1523                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1524                 DBG_8192C ("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1525                 return paraLen;\r
1526         }\r
1527 \r
1528         // fill h2c parameters\r
1529         btOpcode = BT_LO_OP_SET_BD_ADDR_L;\r
1530         if( (pTxRxPars->txrxBdaddr[0]==0) &&\r
1531                 (pTxRxPars->txrxBdaddr[1]==0) &&\r
1532                 (pTxRxPars->txrxBdaddr[2]==0) &&\r
1533                 (pTxRxPars->txrxBdaddr[3]==0) &&\r
1534                 (pTxRxPars->txrxBdaddr[4]==0) &&\r
1535                 (pTxRxPars->txrxBdaddr[5]==0) )\r
1536         {\r
1537                 DBG_8192C ("[MPT], Error!! pTxRxPars->txrxBdaddr=all zero\n");\r
1538                 pBtRsp->status = (btOpcode<<8)|BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
1539                 return paraLen;\r
1540         }\r
1541         if( (pTxRxPars->txrxBdaddr[0]==0xff) &&\r
1542                 (pTxRxPars->txrxBdaddr[1]==0xff) &&\r
1543                 (pTxRxPars->txrxBdaddr[2]==0xff) &&\r
1544                 (pTxRxPars->txrxBdaddr[3]==0xff) &&\r
1545                 (pTxRxPars->txrxBdaddr[4]==0xff) &&\r
1546                 (pTxRxPars->txrxBdaddr[5]==0xff) )\r
1547         {\r
1548                 DBG_8192C ("[MPT], Error!! pTxRxPars->txrxBdaddr=all 0xf\n");\r
1549                 pBtRsp->status = (btOpcode<<8)|BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
1550                 return paraLen;\r
1551         }\r
1552         \r
1553         {\r
1554                 h2cParaBuf[0] = pTxRxPars->txrxBdaddr[0];\r
1555                 h2cParaBuf[1] = pTxRxPars->txrxBdaddr[1];\r
1556                 h2cParaBuf[2] = pTxRxPars->txrxBdaddr[2];\r
1557                 h2cParaLen = 3;\r
1558                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
1559         }\r
1560         // ckeck bt return status.\r
1561         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1562         {\r
1563                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1564                 DBG_8192C ("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1565                 return paraLen;\r
1566         }       \r
1567 \r
1568         btOpcode = BT_LO_OP_SET_BD_ADDR_H;\r
1569         {\r
1570                 h2cParaBuf[0] = pTxRxPars->txrxBdaddr[3];\r
1571                 h2cParaBuf[1] = pTxRxPars->txrxBdaddr[4];\r
1572                 h2cParaBuf[2] = pTxRxPars->txrxBdaddr[5];\r
1573                 h2cParaLen = 3;\r
1574                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
1575         }\r
1576         // ckeck bt return status.\r
1577         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1578         {\r
1579                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1580                 DBG_8192C  ("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1581                 return paraLen;\r
1582         }\r
1583 \r
1584         pBtRsp->status = BT_STATUS_SUCCESS;\r
1585         return paraLen;\r
1586 }\r
1587 \r
1588 \r
1589 \r
1590 u2Byte\r
1591 mptbt_BtTestCtrl(\r
1592         IN      PADAPTER                Adapter,\r
1593         IN      PBT_REQ_CMD     pBtReq,\r
1594         IN      PBT_RSP_CMD     pBtRsp\r
1595         )\r
1596 {\r
1597         u1Byte                          h2cParaBuf[6] ={0};\r
1598         u1Byte                          h2cParaLen=0;\r
1599         u2Byte                          paraLen=0;\r
1600         u1Byte                          retStatus=BT_STATUS_BT_OP_SUCCESS;\r
1601         u1Byte                          btOpcode;\r
1602         u1Byte                          btOpcodeVer=0;\r
1603         u1Byte                          testCtrl=0;\r
1604 \r
1605         //\r
1606         // check upper layer parameters\r
1607         //\r
1608         \r
1609         // 1. check upper layer opcode version\r
1610         if(pBtReq->opCodeVer != 1)\r
1611         {\r
1612                 DBG_8192C("[MPT], Error!! Upper OP code version not match!!!\n");\r
1613                 pBtRsp->status = BT_STATUS_OPCODE_U_VERSION_MISMATCH;\r
1614                 return paraLen;\r
1615         }\r
1616         // 2. check upper layer parameter length\r
1617         if(1 == pBtReq->paraLength)\r
1618         {\r
1619                 testCtrl = pBtReq->pParamStart[0];\r
1620                 DBG_8192C("[MPT], testCtrl=%d \n", testCtrl);\r
1621         }\r
1622         else\r
1623         {\r
1624                 DBG_8192C("[MPT], Error!! wrong parameter length=%d (should be 1)\n", pBtReq->paraLength);\r
1625                 pBtRsp->status = BT_STATUS_PARAMETER_FORMAT_ERROR_U;\r
1626                 return paraLen;\r
1627         }\r
1628         \r
1629         //\r
1630         // execute lower layer opcodes\r
1631         //\r
1632         \r
1633         // 1. fill h2c parameters       \r
1634         // check bt mode\r
1635         btOpcode = BT_LO_OP_TEST_CTRL;\r
1636         if(testCtrl >= MP_BT_TEST_MAX)\r
1637         {\r
1638                 DBG_8192C("[MPT], Error!! testCtrl=0x%x, (should be between smaller or equal to 0x%x)\n", \r
1639                         testCtrl, MP_BT_TEST_MAX-1);\r
1640                 pBtRsp->status = BT_STATUS_PARAMETER_OUT_OF_RANGE_U;\r
1641                 return paraLen;\r
1642         }\r
1643         else\r
1644         {\r
1645                 h2cParaBuf[0] = testCtrl;\r
1646                 h2cParaLen = 1;\r
1647                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
1648         }\r
1649         \r
1650         // 3. construct respond status code and data.\r
1651         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1652         {\r
1653                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1654                 DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1655                 return paraLen;\r
1656         }\r
1657 \r
1658         pBtRsp->status = BT_STATUS_SUCCESS;\r
1659         return paraLen;\r
1660 }\r
1661 \r
1662 \r
1663 u2Byte\r
1664 mptbt_TestBT(\r
1665         IN      PADAPTER                Adapter,\r
1666         IN      PBT_REQ_CMD     pBtReq,\r
1667         IN      PBT_RSP_CMD     pBtRsp\r
1668         )\r
1669 {\r
1670 \r
1671         u1Byte                          h2cParaBuf[6] ={0};\r
1672         u1Byte                          h2cParaLen=0;\r
1673         u2Byte                          paraLen=0;\r
1674         u1Byte                          retStatus=BT_STATUS_BT_OP_SUCCESS;\r
1675         u1Byte                          btOpcode;\r
1676         u1Byte                          btOpcodeVer=0;\r
1677         u1Byte                          testCtrl=0;\r
1678 \r
1679         // 1. fill h2c parameters       \r
1680                 btOpcode =  0x11;\r
1681                 h2cParaBuf[0] = 0x11;\r
1682                 h2cParaBuf[1] = 0x0;\r
1683                 h2cParaBuf[2] = 0x0;\r
1684                 h2cParaBuf[3] = 0x0;\r
1685                 h2cParaBuf[4] = 0x0;\r
1686                 h2cParaLen = 1;\r
1687         //      retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);\r
1688                 retStatus = mptbt_BtFwOpCodeProcess(Adapter, btOpcode, btOpcodeVer, h2cParaBuf, h2cParaLen);\r
1689         \r
1690         \r
1691         // 3. construct respond status code and data.\r
1692         if(BT_STATUS_BT_OP_SUCCESS != retStatus)\r
1693         {\r
1694                 pBtRsp->status = ((btOpcode<<8)|retStatus);\r
1695                 DBG_8192C("[MPT], Error!! status code=0x%x \n", pBtRsp->status);\r
1696                 return paraLen;\r
1697         }\r
1698 \r
1699         pBtRsp->status = BT_STATUS_SUCCESS;\r
1700         return paraLen;\r
1701 }\r
1702 \r
1703 VOID\r
1704 mptbt_BtControlProcess(\r
1705         PADAPTER        Adapter,\r
1706         PVOID           pInBuf\r
1707         )\r
1708 {\r
1709         u1Byte                  H2C_Parameter[6] ={0};\r
1710         PBT_H2C                 pH2c=(PBT_H2C)&H2C_Parameter[0];\r
1711         PMPT_CONTEXT    pMptCtx=&(Adapter->mppriv.MptCtx);\r
1712         PBT_REQ_CMD     pBtReq=(PBT_REQ_CMD)pInBuf;\r
1713         PBT_RSP_CMD     pBtRsp;\r
1714         u1Byte                  i;\r
1715 \r
1716 \r
1717         DBG_8192C("[MPT], mptbt_BtControlProcess()=========>\n");\r
1718 \r
1719         DBG_8192C("[MPT], input opCodeVer=%d\n", pBtReq->opCodeVer);\r
1720         DBG_8192C("[MPT], input OpCode=%d\n", pBtReq->OpCode);\r
1721         DBG_8192C("[MPT], paraLength=%d \n", pBtReq->paraLength);\r
1722         if(pBtReq->paraLength)\r
1723         {\r
1724                 //DBG_8192C("[MPT], parameters(hex):0x%x %d \n",&pBtReq->pParamStart[0], pBtReq->paraLength);\r
1725         }\r
1726 \r
1727         _rtw_memset((void*)pMptCtx->mptOutBuf, 0, 100);\r
1728         pMptCtx->mptOutLen = 4; //length of (BT_RSP_CMD.status+BT_RSP_CMD.paraLength)\r
1729 \r
1730         pBtRsp = (PBT_RSP_CMD)pMptCtx->mptOutBuf;\r
1731         pBtRsp->status = BT_STATUS_SUCCESS;\r
1732         pBtRsp->paraLength = 0x0;\r
1733 \r
1734         // The following we should maintain the User OP codes sent by upper layer\r
1735         switch(pBtReq->OpCode)\r
1736         {\r
1737                 case BT_UP_OP_BT_READY:\r
1738                         DBG_8192C("[MPT], OPcode : [BT_READY]\n");\r
1739                         pBtRsp->paraLength = mptbt_BtReady(Adapter, pBtReq, pBtRsp);\r
1740                         break;\r
1741                 case BT_UP_OP_BT_SET_MODE:\r
1742                         DBG_8192C("[MPT], OPcode : [BT_SET_MODE]\n");\r
1743                         pBtRsp->paraLength = mptbt_BtSetMode(Adapter, pBtReq, pBtRsp);\r
1744                         break;\r
1745                 case BT_UP_OP_BT_SET_TX_RX_PARAMETER:\r
1746                         DBG_8192C("[MPT], OPcode : [BT_SET_TXRX_PARAMETER]\n");\r
1747                         pBtRsp->paraLength = mptbt_BtSetTxRxPars(Adapter, pBtReq, pBtRsp);\r
1748                         break;\r
1749                 case BT_UP_OP_BT_SET_GENERAL:\r
1750                         DBG_8192C("[MPT], OPcode : [BT_SET_GENERAL]\n");\r
1751                         pBtRsp->paraLength = mptbt_BtSetGeneral(Adapter, pBtReq, pBtRsp);\r
1752                         break;\r
1753                 case BT_UP_OP_BT_GET_GENERAL:\r
1754                         DBG_8192C("[MPT], OPcode : [BT_GET_GENERAL]\n");\r
1755                         pBtRsp->paraLength = mptbt_BtGetGeneral(Adapter, pBtReq, pBtRsp);\r
1756                         break;\r
1757                 case BT_UP_OP_BT_TEST_CTRL:\r
1758                         DBG_8192C("[MPT], OPcode : [BT_TEST_CTRL]\n");\r
1759                         pBtRsp->paraLength = mptbt_BtTestCtrl(Adapter, pBtReq, pBtRsp);\r
1760                         break;\r
1761                 case BT_UP_OP_TEST_BT:\r
1762                         DBG_8192C("[MPT], OPcode : [TEST_BT]\n");\r
1763                         pBtRsp->paraLength = mptbt_TestBT(Adapter, pBtReq, pBtRsp);\r
1764                         break;\r
1765                 default:\r
1766                         DBG_8192C("[MPT], Error!! OPcode : UNDEFINED!!!!\n");\r
1767                         pBtRsp->status = BT_STATUS_UNKNOWN_OPCODE_U;\r
1768                         pBtRsp->paraLength = 0x0;\r
1769                         break;\r
1770         }\r
1771 \r
1772         pMptCtx->mptOutLen += pBtRsp->paraLength;\r
1773 \r
1774         DBG_8192C("[MPT], pMptCtx->mptOutLen=%d, pBtRsp->paraLength=%d\n", pMptCtx->mptOutLen, pBtRsp->paraLength);\r
1775         DBG_8192C("[MPT], mptbt_BtControlProcess()<=========\n");\r
1776 }\r
1777 \r
1778 #endif\r
1779 \r