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