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