drivers/misc/mediatek/connectivity/combo/common/core/wmt_dbg.c

   1 /*! \file
   2     \brief brief description
   3
   4     Detailed descriptions here.
   5
   6 */
   7
   8
   9
  10 /*******************************************************************************
  11 *                         C O M P I L E R   F L A G S
  12 ********************************************************************************
  13 */
  14
  15 /*******************************************************************************
  16 *                                 M A C R O S
  17 ********************************************************************************
  18 */
  19 #include "osal_typedef.h"
  20 #include "wmt_dbg.h"
  21 #include "wmt_core.h"
  22 #include "wmt_lib.h"
  23 #include "wmt_conf.h"
  24 #include "psm_core.h"
  25 #include "stp_core.h"
  26
  27 #if CFG_WMT_DBG_SUPPORT
  28
  29
  30 #ifdef DFT_TAG
  31 #undef DFT_TAG
  32 #endif
  33 #define DFT_TAG         "[WMT-DEV]"
  34
  35
  36
  37 #define WMT_DBG_PROCNAME "driver/wmt_dbg"
  38
  39 static struct proc_dir_entry *gWmtDbgEntry = NULL;
  40 COEX_BUF gCoexBuf;
  41
  42 #if USE_NEW_PROC_FS_FLAG
  43
  44 ssize_t wmt_dbg_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos);
  45 ssize_t wmt_dbg_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos);
  46
  47 static struct file_operations wmt_dbg_fops = {
  48         .read = wmt_dbg_read,
  49         .write = wmt_dbg_write,
  50 };
  51
  52 #endif
  53
  54 static INT32 wmt_dbg_psm_ctrl(INT32 par1, INT32 par2, INT32 par3);
  55 static INT32 wmt_dbg_dsns_ctrl(INT32 par1, INT32 par2, INT32 par3);
  56 static INT32 wmt_dbg_hwver_get(INT32 par1, INT32 par2, INT32 par3);
  57 static INT32 wmt_dbg_inband_rst(INT32 par1, INT32 par2, INT32 par3);
  58 static INT32 wmt_dbg_chip_rst(INT32 par1, INT32 par2, INT32 par3);
  59 static INT32 wmt_dbg_func_ctrl(INT32 par1, INT32 par2, INT32 par3);
  60 static INT32 wmt_dbg_raed_chipid(INT32 par1, INT32 par2, INT32 par3);
  61 static INT32 wmt_dbg_wmt_dbg_level(INT32 par1, INT32 par2, INT32 par3);
  62 static INT32 wmt_dbg_stp_dbg_level(INT32 par1, INT32 par2, INT32 par3);
  63 static INT32 wmt_dbg_reg_read(INT32 par1, INT32 par2, INT32 par3);
  64 static INT32 wmt_dbg_reg_write(INT32 par1, INT32 par2, INT32 par3);
  65 static INT32 wmt_dbg_coex_test(INT32 par1, INT32 par2, INT32 par3);
  66 static INT32 wmt_dbg_assert_test(INT32 par1, INT32 par2, INT32 par3);
  67 static INT32 wmt_dbg_cmd_test_api(ENUM_WMTDRV_CMD_T cmd);
  68 static INT32 wmt_dbg_rst_ctrl(INT32 par1, INT32 par2, INT32 par3);
  69 static INT32 wmt_dbg_ut_test(INT32 par1, INT32 par2, INT32 par3);
  70 static INT32 wmt_dbg_efuse_read(INT32 par1, INT32 par2, INT32 par3);
  71 static INT32 wmt_dbg_efuse_write(INT32 par1, INT32 par2, INT32 par3);
  72 static INT32 wmt_dbg_sdio_ctrl(INT32 par1, INT32 par2, INT32 par3);
  73 static INT32 wmt_dbg_stp_dbg_ctrl(INT32 par1, INT32 par2, INT32 par3);
  74 static INT32 wmt_dbg_stp_dbg_log_ctrl(INT32 par1, INT32 par2, INT32 par3);
  75 static INT32 wmt_dbg_wmt_assert_ctrl(INT32 par1, INT32 par2, INT32 par3);
  76 static INT32 wmt_dbg_stp_trigger_assert(INT32 par1, INT32 par2, INT32 par3);
  77 static INT32 wmt_dbg_ap_reg_read(INT32 par1, INT32 par2, INT32 par3);
  78 static INT32 wmt_dbg_ap_reg_write(INT32 par1, INT32 par2, INT32 par3);
  79 #if CFG_WMT_LTE_COEX_HANDLING
  80 static INT32 wmt_dbg_lte_coex_test(INT32 par1, INT32 par2, INT32 par3);
  81 #endif
  82
  83
  84 const static WMT_DEV_DBG_FUNC wmt_dev_dbg_func[] = {
  85         [0] = wmt_dbg_psm_ctrl,
  86         [1] = wmt_dbg_psm_ctrl,
  87         [2] = wmt_dbg_dsns_ctrl,
  88         [3] = wmt_dbg_hwver_get,
  89         [4] = wmt_dbg_assert_test,
  90         [5] = wmt_dbg_inband_rst,
  91         [6] = wmt_dbg_chip_rst,
  92         [7] = wmt_dbg_func_ctrl,
  93         [8] = wmt_dbg_raed_chipid,
  94         [9] = wmt_dbg_wmt_dbg_level,
  95         [0xa] = wmt_dbg_stp_dbg_level,
  96         [0xb] = wmt_dbg_reg_read,
  97         [0xc] = wmt_dbg_reg_write,
  98         [0xd] = wmt_dbg_coex_test,
  99         [0xe] = wmt_dbg_rst_ctrl,
 100         [0xf] = wmt_dbg_ut_test,
 101         [0x10] = wmt_dbg_efuse_read,
 102         [0x11] = wmt_dbg_efuse_write,
 103         [0x12] = wmt_dbg_sdio_ctrl,
 104         [0x13] = wmt_dbg_stp_dbg_ctrl,
 105         [0x14] = wmt_dbg_stp_dbg_log_ctrl,
 106         [0x15] = wmt_dbg_wmt_assert_ctrl,
 107         [0x16] = wmt_dbg_stp_trigger_assert,
 108         [0x17] = wmt_dbg_ap_reg_read,
 109         [0x18] = wmt_dbg_ap_reg_write,
 110 #if CFG_WMT_LTE_COEX_HANDLING
 111         [0x20] = wmt_dbg_lte_coex_test,
 112 #endif
 113 };
 114
 115 INT32 wmt_dbg_psm_ctrl(INT32 par1, INT32 par2, INT32 par3)
 116 {
 117 #if CFG_WMT_PS_SUPPORT
 118         if (0 == par2) {
 119                 wmt_lib_ps_ctrl(0);
 120                 WMT_INFO_FUNC("disable PSM\n");
 121         } else {
 122                 par2 = (1 > par2 || 20000 < par2) ? STP_PSM_IDLE_TIME_SLEEP : par2;
 123                 wmt_lib_ps_set_idle_time(par2);
 124                 wmt_lib_ps_ctrl(1);
 125                 WMT_INFO_FUNC("enable PSM, idle to sleep time = %d ms\n", par2);
 126         }
 127 #else
 128         WMT_INFO_FUNC("WMT PS not supported\n");
 129 #endif
 130         return 0;
 131 }
 132
 133 INT32 wmt_dbg_dsns_ctrl(INT32 par1, INT32 par2, INT32 par3)
 134 {
 135         if (WMTDSNS_FM_DISABLE <= par2 && WMTDSNS_MAX > par2) {
 136                 WMT_INFO_FUNC("DSNS type (%d)\n", par2);
 137                 mtk_wcn_wmt_dsns_ctrl(par2);
 138         } else {
 139                 WMT_WARN_FUNC("invalid DSNS type\n");
 140         }
 141         return 0;
 142 }
 143
 144 INT32 wmt_dbg_hwver_get(INT32 par1, INT32 par2, INT32 par3)
 145 {
 146         WMT_INFO_FUNC("query chip version\n");
 147         mtk_wcn_wmt_hwver_get();
 148         return 0;
 149 }
 150
 151 INT32 wmt_dbg_assert_test(INT32 par1, INT32 par2, INT32 par3)
 152 {
 153         if (0 == par3) {
 154                 /* par2 = 0:  send assert command */
 155                 /* par2 != 0: send exception command */
 156                 return wmt_dbg_cmd_test_api(0 == par2 ? 0 : 1);
 157         } else if (1 == par3) {
 158                 /* send noack command */
 159                 return wmt_dbg_cmd_test_api(WMTDRV_CMD_NOACK_TEST);
 160         } else if (2 == par3) {
 161                 /* warn reset test */
 162                 return wmt_dbg_cmd_test_api(WMTDRV_CMD_WARMRST_TEST);
 163         } else if (3 == par3) {
 164                 /* firmware trace test - for soc usage, not used in combo chip */
 165                 return wmt_dbg_cmd_test_api(WMTDRV_CMD_FWTRACE_TEST);
 166         } else {
 167                 INT32 sec = 8;
 168                 INT32 times = 0;
 169                 times = par3;
 170                 do {
 171                         WMT_INFO_FUNC("Send Assert Command per 8 secs!!\n");
 172                         wmt_dbg_cmd_test_api(0);
 173                         osal_sleep_ms(sec * 1000);
 174                 } while (--times);
 175         }
 176         return 0;
 177 }
 178
 179 INT32 wmt_dbg_cmd_test_api(ENUM_WMTDRV_CMD_T cmd)
 180 {
 181
 182         P_OSAL_OP pOp = NULL;
 183         MTK_WCN_BOOL bRet = MTK_WCN_BOOL_FALSE;
 184         P_OSAL_SIGNAL pSignal;
 185
 186         pOp = wmt_lib_get_free_op();
 187         if (!pOp) {
 188                 WMT_WARN_FUNC("get_free_lxop fail\n");
 189                 return MTK_WCN_BOOL_FALSE;
 190         }
 191
 192         pSignal = &pOp->signal;
 193
 194         pOp->op.opId = WMT_OPID_CMD_TEST;
 195
 196         pSignal->timeoutValue = MAX_EACH_WMT_CMD;
 197         /*this test command should be run with usb cable connected, so no host awake is needed */
 198         /* wmt_lib_host_awake_get(); */
 199         wmt_lib_set_host_assert_info(WMTDRV_TYPE_WMT, 0, 1);
 200         switch (cmd) {
 201         case WMTDRV_CMD_ASSERT:
 202                 pOp->op.au4OpData[0] = 0;
 203                 break;
 204         case WMTDRV_CMD_EXCEPTION:
 205                 pOp->op.au4OpData[0] = 1;
 206                 break;
 207         case WMTDRV_CMD_NOACK_TEST:
 208                 pOp->op.au4OpData[0] = 3;
 209                 break;
 210         case WMTDRV_CMD_WARMRST_TEST:
 211                 pOp->op.au4OpData[0] = 4;
 212                 break;
 213         case WMTDRV_CMD_FWTRACE_TEST:
 214                 pOp->op.au4OpData[0] = 5;
 215                 break;
 216         default:
 217                 if (WMTDRV_CMD_COEXDBG_00 <= cmd && WMTDRV_CMD_COEXDBG_15 >= cmd) {
 218                         pOp->op.au4OpData[0] = 2;
 219                         pOp->op.au4OpData[1] = cmd - 2;
 220                 } else {
 221                         pOp->op.au4OpData[0] = 0xff;
 222                         pOp->op.au4OpData[1] = 0xff;
 223                 }
 224                 pOp->op.au4OpData[2] = (size_t) gCoexBuf.buffer;
 225                 pOp->op.au4OpData[3] = osal_sizeof(gCoexBuf.buffer);
 226                 break;
 227         }
 228         WMT_INFO_FUNC("CMD_TEST, opid(%d), par(%d, %d)\n", pOp->op.opId, pOp->op.au4OpData[0],
 229                       pOp->op.au4OpData[1]);
 230         /*wake up chip first */
 231         if (DISABLE_PSM_MONITOR()) {
 232                 WMT_ERR_FUNC("wake up failed\n");
 233                 wmt_lib_put_op_to_free_queue(pOp);
 234                 return -1;
 235         }
 236         bRet = wmt_lib_put_act_op(pOp);
 237         ENABLE_PSM_MONITOR();
 238         if ((cmd != WMTDRV_CMD_ASSERT) &&
 239             (cmd != WMTDRV_CMD_EXCEPTION) &&
 240             (cmd != WMTDRV_CMD_NOACK_TEST) &&
 241             (cmd != WMTDRV_CMD_WARMRST_TEST) && (cmd != WMTDRV_CMD_FWTRACE_TEST)) {
 242                 if (MTK_WCN_BOOL_FALSE == bRet) {
 243                         gCoexBuf.availSize = 0;
 244                 } else {
 245                         gCoexBuf.availSize = pOp->op.au4OpData[3];
 246                         WMT_INFO_FUNC("gCoexBuf.availSize = %d\n", gCoexBuf.availSize);
 247                 }
 248         }
 249         /* wmt_lib_host_awake_put(); */
 250         WMT_INFO_FUNC("CMD_TEST, opid (%d), par(%d, %d), ret(%d), result(%s)\n",
 251                       pOp->op.opId,
 252                       pOp->op.au4OpData[0],
 253                       pOp->op.au4OpData[1],
 254                       bRet, MTK_WCN_BOOL_FALSE == bRet ? "failed" : "succeed");
 255
 256         return 0;
 257 }
 258
 259 INT32 wmt_dbg_inband_rst(INT32 par1, INT32 par2, INT32 par3)
 260 {
 261         if (0 == par2) {
 262                 WMT_INFO_FUNC("inband reset test!!\n");
 263                 mtk_wcn_stp_inband_reset();
 264         } else {
 265                 WMT_INFO_FUNC("STP context reset in host side!!\n");
 266                 mtk_wcn_stp_flush_context();
 267         }
 268
 269         return 0;
 270 }
 271
 272 INT32 wmt_dbg_chip_rst(INT32 par1, INT32 par2, INT32 par3)
 273 {
 274         if (0 == par2) {
 275                 if (mtk_wcn_stp_is_ready()) {
 276                         WMT_INFO_FUNC("whole chip reset test\n");
 277                         wmt_lib_cmb_rst(WMTRSTSRC_RESET_TEST);
 278                 } else {
 279                         WMT_INFO_FUNC("STP not ready , not to launch whole chip reset test\n");
 280                 }
 281         } else if (1 == par2) {
 282                 WMT_INFO_FUNC("chip hardware reset test\n");
 283                 wmt_lib_hw_rst();
 284         } else {
 285                 WMT_INFO_FUNC("chip software reset test\n");
 286                 wmt_lib_sw_rst(1);
 287         }
 288         return 0;
 289 }
 290
 291 INT32 wmt_dbg_func_ctrl(INT32 par1, INT32 par2, INT32 par3)
 292 {
 293         if (WMTDRV_TYPE_WMT > par2 || WMTDRV_TYPE_LPBK == par2) {
 294                 if (0 == par3) {
 295                         WMT_INFO_FUNC("function off test, type(%d)\n", par2);
 296                         mtk_wcn_wmt_func_off(par2);
 297                 } else {
 298                         WMT_INFO_FUNC("function on test, type(%d)\n", par2);
 299                         mtk_wcn_wmt_func_on(par2);
 300                 }
 301         } else {
 302                 WMT_INFO_FUNC("function ctrl test, invalid type(%d)\n", par2);
 303         }
 304         return 0;
 305 }
 306
 307 INT32 wmt_dbg_raed_chipid(INT32 par1, INT32 par2, INT32 par3)
 308 {
 309         WMT_INFO_FUNC("chip version = %d\n", wmt_lib_get_icinfo(WMTCHIN_MAPPINGHWVER));
 310         return 0;
 311 }
 312
 313 INT32 wmt_dbg_wmt_dbg_level(INT32 par1, INT32 par2, INT32 par3)
 314 {
 315         par2 = (WMT_LOG_ERR <= par2 && WMT_LOG_LOUD >= par2) ? par2 : WMT_LOG_INFO;
 316         wmt_lib_dbg_level_set(par2);
 317         WMT_INFO_FUNC("set wmt log level to %d\n", par2);
 318         return 0;
 319 }
 320
 321 INT32 wmt_dbg_stp_dbg_level(INT32 par1, INT32 par2, INT32 par3)
 322 {
 323         par2 = (0 <= par2 && 4 >= par2) ? par2 : 2;
 324         mtk_wcn_stp_dbg_level(par2);
 325         WMT_INFO_FUNC("set stp log level to %d\n", par2);
 326         return 0;
 327
 328 }
 329
 330 INT32 wmt_dbg_reg_read(INT32 par1, INT32 par2, INT32 par3)
 331 {
 332         /* par2-->register address */
 333         /* par3-->register mask */
 334         UINT32 value = 0x0;
 335         UINT32 iRet = -1;
 336 #if 0
 337         DISABLE_PSM_MONITOR();
 338         iRet = wmt_core_reg_rw_raw(0, par2, &value, par3);
 339         ENABLE_PSM_MONITOR();
 340 #endif
 341         iRet = wmt_lib_reg_rw(0, par2, &value, par3);
 342         WMT_INFO_FUNC("read combo chip register (0x%08x) with mask (0x%08x) %s, value = 0x%08x\n",
 343                       par2, par3, iRet != 0 ? "failed" : "succeed", iRet != 0 ? -1 : value);
 344         return 0;
 345 }
 346
 347 INT32 wmt_dbg_reg_write(INT32 par1, INT32 par2, INT32 par3)
 348 {
 349         /* par2-->register address */
 350         /* par3-->value to set */
 351         UINT32 iRet = -1;
 352 #if 0
 353         DISABLE_PSM_MONITOR();
 354         iRet = wmt_core_reg_rw_raw(1, par2, &par3, 0xffffffff);
 355         ENABLE_PSM_MONITOR();
 356 #endif
 357         iRet = wmt_lib_reg_rw(1, par2, &par3, 0xffffffff);
 358         WMT_INFO_FUNC("write combo chip register (0x%08x) with value (0x%08x) %s\n",
 359                       par2, par3, iRet != 0 ? "failed" : "succeed");
 360         return 0;
 361 }
 362
 363 INT32 wmt_dbg_efuse_read(INT32 par1, INT32 par2, INT32 par3)
 364 {
 365         /* par2-->efuse address */
 366         /* par3-->register mask */
 367         UINT32 value = 0x0;
 368         UINT32 iRet = -1;
 369
 370         iRet = wmt_lib_efuse_rw(0, par2, &value, par3);
 371         WMT_INFO_FUNC("read combo chip efuse (0x%08x) with mask (0x%08x) %s, value = 0x%08x\n",
 372                       par2, par3, iRet != 0 ? "failed" : "succeed", iRet != 0 ? -1 : value);
 373         return 0;
 374 }
 375
 376 INT32 wmt_dbg_efuse_write(INT32 par1, INT32 par2, INT32 par3)
 377 {
 378         /* par2-->efuse address */
 379         /* par3-->value to set */
 380         UINT32 iRet = -1;
 381         iRet = wmt_lib_efuse_rw(1, par2, &par3, 0xffffffff);
 382         WMT_INFO_FUNC("write combo chip efuse (0x%08x) with value (0x%08x) %s\n",
 383                       par2, par3, iRet != 0 ? "failed" : "succeed");
 384         return 0;
 385 }
 386
 387
 388 INT32 wmt_dbg_sdio_ctrl(INT32 par1, INT32 par2, INT32 par3)
 389 {
 390         INT32 iRet = -1;
 391         iRet = wmt_lib_sdio_ctrl(0 != par2 ? 1 : 0);
 392         WMT_INFO_FUNC("ctrl SDIO function %s\n", 0 == iRet ? "succeed" : "failed");
 393         return 0;
 394 }
 395
 396
 397 INT32 wmt_dbg_stp_dbg_ctrl(INT32 par1, INT32 par2, INT32 par3)
 398 {
 399         if (1 < par2) {
 400                 mtk_wcn_stp_dbg_dump_package();
 401                 return 0;
 402         }
 403         WMT_INFO_FUNC("%s stp debug function\n", 0 == par2 ? "disable" : "enable");
 404         if (0 == par2) {
 405                 mtk_wcn_stp_dbg_disable();
 406         } else if (1 == par2) {
 407                 mtk_wcn_stp_dbg_enable();
 408         }
 409         return 0;
 410 }
 411
 412 INT32 wmt_dbg_stp_dbg_log_ctrl(INT32 par1, INT32 par2, INT32 par3)
 413 {
 414         mtk_wcn_stp_dbg_log_ctrl(0 != par2 ? 1 : 0);
 415         return 0;
 416 }
 417
 418
 419
 420 INT32 wmt_dbg_wmt_assert_ctrl(INT32 par1, INT32 par2, INT32 par3)
 421 {
 422         mtk_wcn_stp_coredump_flag_ctrl(0 != par2 ? 1 : 0);
 423         return 0;
 424 }
 425
 426 INT32 wmt_dbg_stp_trigger_assert(INT32 par1, INT32 par2, INT32 par3)
 427 {
 428         wmt_lib_btm_cb(BTM_TRIGGER_STP_ASSERT_OP);
 429         return 0;
 430 }
 431
 432 static INT32 wmt_dbg_ap_reg_read(INT32 par1, INT32 par2, INT32 par3)
 433 {
 434         unsigned long value = 0x0;
 435         WMT_INFO_FUNC("AP register read, reg address:0x%x\n", par2);
 436         value = *((volatile unsigned long *)(unsigned long)par2);
 437         WMT_INFO_FUNC("AP register read, reg address:0x%x, value:0x%x\n", par2, value);
 438         return 0;
 439 }
 440
 441
 442 static INT32 wmt_dbg_ap_reg_write(INT32 par1, INT32 par2, INT32 par3)
 443 {
 444         unsigned long value = 0x0;
 445         WMT_INFO_FUNC("AP register write, reg address:0x%x, value:0x%x\n", par2, par3);
 446
 447         *((volatile unsigned long *)(unsigned long)par2) = (UINT32) par3;
 448         mb();
 449         value = *((volatile unsigned long *)(unsigned long)par2);
 450         WMT_INFO_FUNC("AP register write done, value after write:0x%x\n", value);
 451         return 0;
 452 }
 453
 454
 455
 456 INT32 wmt_dbg_coex_test(INT32 par1, INT32 par2, INT32 par3)
 457 {
 458         WMT_INFO_FUNC("coexistance test cmd!!\n");
 459         return wmt_dbg_cmd_test_api(par2 + WMTDRV_CMD_COEXDBG_00);
 460 }
 461
 462 INT32 wmt_dbg_rst_ctrl(INT32 par1, INT32 par2, INT32 par3)
 463 {
 464         WMT_INFO_FUNC("%s audo rst\n", 0 == par2 ? "disable" : "enable");
 465         mtk_wcn_stp_set_auto_rst(0 == par2 ? 0 : 1);
 466         return 0;
 467 }
 468
 469
 470 #if CFG_WMT_LTE_COEX_HANDLING
 471 static INT32 wmt_dbg_lte_to_wmt_test(UINT32 opcode, UINT32 msg_len)
 472 {
 473         ipc_ilm_t ilm;
 474         local_para_struct *p_buf_str;
 475         INT32 i = 0;
 476         INT32 iRet = -1;
 477         WMT_INFO_FUNC("opcode(0x%02x),msg_len(%d)\n", opcode, msg_len);
 478         p_buf_str = osal_malloc(osal_sizeof(local_para_struct) + msg_len);
 479         if (NULL == p_buf_str) {
 480                 WMT_ERR_FUNC("kmalloc for local para ptr structure failed.\n");
 481                 return -1;
 482         }
 483         p_buf_str->msg_len = msg_len;
 484         for (i = 0; i < msg_len; i++)
 485                 p_buf_str->data[i] = i;
 486
 487         ilm.local_para_ptr = p_buf_str;
 488         ilm.msg_id = opcode;
 489
 490         iRet = wmt_lib_handle_idc_msg(&ilm);
 491         osal_free(p_buf_str);
 492         return iRet;
 493
 494 }
 495
 496 static INT32 wmt_dbg_lte_coex_test(INT32 par1, INT32 par2, INT32 par3)
 497 {
 498         UINT8 local_buffer[512] = { 0 };
 499         UINT32 handle_len;
 500         INT32 iRet = -1;
 501
 502         static UINT8 wmt_to_lte_test_evt1[] = { 0x02, 0x16, 0x0d, 0x00,
 503                 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
 504                 0xa, 0xb
 505         };
 506         static UINT8 wmt_to_lte_test_evt2[] = { 0x02, 0x16, 0x09, 0x00,
 507                 0x01, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
 508         };
 509         static UINT8 wmt_to_lte_test_evt3[] = { 0x02, 0x16, 0x02, 0x00,
 510                 0x02, 0xff
 511         };
 512         static UINT8 wmt_to_lte_test_evt4[] = { 0x02, 0x16, 0x0d, 0x00,
 513                 0x03, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
 514                 0xa, 0xb
 515         };
 516
 517         if (par2 == 1) {
 518                 handle_len =
 519                     wmt_idc_msg_to_lte_handing_for_test(&wmt_to_lte_test_evt1[0],
 520                                                         osal_sizeof(wmt_to_lte_test_evt1));
 521                 if (handle_len != osal_sizeof(wmt_to_lte_test_evt1)) {
 522                         WMT_ERR_FUNC
 523                             ("par2=1,wmt send to lte msg fail:handle_len(%d),buff_len(%d)\n",
 524                              handle_len, osal_sizeof(wmt_to_lte_test_evt1));
 525                 } else {
 526                         WMT_INFO_FUNC("par2=1,wmt send to lte msg OK! send_len(%d)\n", handle_len);
 527                 }
 528         }
 529         if (par2 == 2) {
 530                 osal_memcpy(&local_buffer[0], &wmt_to_lte_test_evt1[0],
 531                             osal_sizeof(wmt_to_lte_test_evt1));
 532                 osal_memcpy(&local_buffer[osal_sizeof(wmt_to_lte_test_evt1)],
 533                             &wmt_to_lte_test_evt2[0], osal_sizeof(wmt_to_lte_test_evt2));
 534
 535                 handle_len =
 536                     wmt_idc_msg_to_lte_handing_for_test(&local_buffer[0],
 537                                                         osal_sizeof(wmt_to_lte_test_evt1) +
 538                                                         osal_sizeof(wmt_to_lte_test_evt2));
 539                 if (handle_len !=
 540                     osal_sizeof(wmt_to_lte_test_evt1) + osal_sizeof(wmt_to_lte_test_evt2)) {
 541                         WMT_ERR_FUNC
 542                             ("par2=2,wmt send to lte msg fail:handle_len(%d),buff_len(%d)\n",
 543                              handle_len,
 544                              osal_sizeof(wmt_to_lte_test_evt1) + osal_sizeof(wmt_to_lte_test_evt2));
 545                 } else {
 546                         WMT_INFO_FUNC("par2=1,wmt send to lte msg OK! send_len(%d)\n", handle_len);
 547                 }
 548         }
 549         if (par2 == 3) {
 550                 osal_memcpy(&local_buffer[0], &wmt_to_lte_test_evt1[0],
 551                             osal_sizeof(wmt_to_lte_test_evt1));
 552                 osal_memcpy(&local_buffer[osal_sizeof(wmt_to_lte_test_evt1)],
 553                             &wmt_to_lte_test_evt2[0], osal_sizeof(wmt_to_lte_test_evt2));
 554                 osal_memcpy(&local_buffer
 555                             [osal_sizeof(wmt_to_lte_test_evt1) + osal_sizeof(wmt_to_lte_test_evt2)],
 556                             &wmt_to_lte_test_evt3[0], osal_sizeof(wmt_to_lte_test_evt3));
 557
 558                 handle_len =
 559                     wmt_idc_msg_to_lte_handing_for_test(&local_buffer[0],
 560                                                         osal_sizeof(wmt_to_lte_test_evt1) +
 561                                                         osal_sizeof(wmt_to_lte_test_evt2) +
 562                                                         osal_sizeof(wmt_to_lte_test_evt3));
 563                 if (handle_len !=
 564                     osal_sizeof(wmt_to_lte_test_evt1) + osal_sizeof(wmt_to_lte_test_evt2) +
 565                     osal_sizeof(wmt_to_lte_test_evt3)) {
 566                         WMT_ERR_FUNC
 567                             ("par2=3,wmt send to lte msg fail:handle_len(%d),buff_len(%d)\n",
 568                              handle_len,
 569                              osal_sizeof(wmt_to_lte_test_evt1) + osal_sizeof(wmt_to_lte_test_evt2) +
 570                              osal_sizeof(wmt_to_lte_test_evt3));
 571                 } else {
 572                         WMT_INFO_FUNC("par3=1,wmt send to lte msg OK! send_len(%d)\n", handle_len);
 573                 }
 574         }
 575         if (par2 == 4) {
 576                 handle_len =
 577                     wmt_idc_msg_to_lte_handing_for_test(&wmt_to_lte_test_evt4[0],
 578                                                         osal_sizeof(wmt_to_lte_test_evt4));
 579                 if (handle_len != osal_sizeof(wmt_to_lte_test_evt4)) {
 580                         WMT_ERR_FUNC
 581                             ("par2=1,wmt send to lte msg fail:handle_len(%d),buff_len(%d)\n",
 582                              handle_len, osal_sizeof(wmt_to_lte_test_evt4));
 583                 } else {
 584                         WMT_INFO_FUNC("par2=1,wmt send to lte msg OK! send_len(%d)\n", handle_len);
 585                 }
 586         }
 587         if (par2 == 5) {
 588                 if (par3 >= 1024) {
 589                         par3 = 1024;
 590                 }
 591                 iRet = wmt_dbg_lte_to_wmt_test(IPC_MSG_ID_EL1_LTE_DEFAULT_PARAM_IND, par3);
 592                 WMT_INFO_FUNC("IPC_MSG_ID_EL1_LTE_DEFAULT_PARAM_IND test result(%d)\n", iRet);
 593         }
 594         if (par2 == 6) {
 595                 if (par3 >= 1024) {
 596                         par3 = 1024;
 597                 }
 598                 iRet = wmt_dbg_lte_to_wmt_test(IPC_MSG_ID_EL1_LTE_OPER_FREQ_PARAM_IND, par3);
 599                 WMT_INFO_FUNC("IPC_MSG_ID_EL1_LTE_OPER_FREQ_PARAM_IND test result(%d)\n", iRet);
 600         }
 601         if (par2 == 7) {
 602                 if (par3 >= 1024) {
 603                         par3 = 1024;
 604                 }
 605                 iRet = wmt_dbg_lte_to_wmt_test(IPC_MSG_ID_EL1_WIFI_MAX_PWR_IND, par3);
 606                 WMT_INFO_FUNC("IPC_MSG_ID_EL1_WIFI_MAX_PWR_IND test result(%d)\n", iRet);
 607         }
 608         if (par2 == 8) {
 609                 if (par3 >= 1024) {
 610                         par3 = 1024;
 611                 }
 612                 iRet = wmt_dbg_lte_to_wmt_test(IPC_MSG_ID_EL1_LTE_TX_IND, par3);
 613                 WMT_INFO_FUNC("IPC_MSG_ID_EL1_LTE_TX_IND test result(%d)\n", iRet);
 614         }
 615         if (par2 == 9) {
 616                 if (par3 > 0)
 617                         wmt_core_set_flag_for_test(1);
 618                 else
 619                         wmt_core_set_flag_for_test(0);
 620         }
 621         return 0;
 622 }
 623
 624 #endif
 625
 626 #if USE_NEW_PROC_FS_FLAG
 627 ssize_t wmt_dbg_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
 628 {
 629
 630         INT32 retval = 0;
 631         INT32 i_ret = 0;
 632         PINT8 warn_msg = "no data available, please run echo 15 xx > /proc/driver/wmt_psm first\n";
 633
 634         if (*f_pos > 0) {
 635                 retval = 0;
 636         } else {
 637                 /*len = sprintf(page, "%d\n", g_psm_enable); */
 638                 if (gCoexBuf.availSize <= 0) {
 639                         WMT_INFO_FUNC
 640                             ("no data available, please run echo 15 xx > /proc/driver/wmt_psm first\n");
 641                         retval = osal_strlen(warn_msg) + 1;
 642                         if (count < retval) {
 643                                 retval = count;
 644                         }
 645                         i_ret = copy_to_user(buf, warn_msg, retval);
 646                         if (i_ret) {
 647                                 WMT_ERR_FUNC("copy to buffer failed, ret:%d\n", retval);
 648                                 retval = -EFAULT;
 649                                 goto err_exit;
 650                         }
 651                         *f_pos += retval;
 652                 } else {
 653                         INT32 i = 0;
 654                         INT32 len = 0;
 655                         INT8 msg_info[128];
 656                         INT32 max_num = 0;
 657                         /*we do not check page buffer, because there are only 100 bytes in g_coex_buf, no reason page buffer is not enough, a bomb is placed here on unexpected condition */
 658
 659                         WMT_INFO_FUNC("%d bytes avaliable\n", gCoexBuf.availSize);
 660                         max_num =
 661                             ((osal_sizeof(msg_info) >
 662                               count ? osal_sizeof(msg_info) : count) - 1) / 5;
 663
 664                         if (max_num > gCoexBuf.availSize) {
 665                                 max_num = gCoexBuf.availSize;
 666                         } else {
 667                                 WMT_INFO_FUNC
 668                                     ("round to %d bytes due to local buffer size limitation\n",
 669                                      max_num);
 670                         }
 671
 672
 673                         for (i = 0; i < max_num; i++) {
 674                                 len += osal_sprintf(msg_info + len, "0x%02x ", gCoexBuf.buffer[i]);
 675                         }
 676
 677                         len += osal_sprintf(msg_info + len, "\n");
 678                         retval = len;
 679
 680                         i_ret = copy_to_user(buf, msg_info, retval);
 681                         if (i_ret) {
 682                                 WMT_ERR_FUNC("copy to buffer failed, ret:%d\n", retval);
 683                                 retval = -EFAULT;
 684                                 goto err_exit;
 685                         }
 686                         *f_pos += retval;
 687
 688                 }
 689         }
 690         gCoexBuf.availSize = 0;
 691  err_exit:
 692
 693         return retval;
 694 }
 695
 696
 697 #else
 698
 699 static INT32 wmt_dev_dbg_read(PINT8 page, PPINT8 start, off_t off, INT32 count, INT32 *eof,
 700                               void *data)
 701 {
 702         INT32 len = 0;
 703
 704         if (off > 0) {
 705                 len = 0;
 706         } else {
 707                 /*len = sprintf(page, "%d\n", g_psm_enable); */
 708                 if (gCoexBuf.availSize <= 0) {
 709                         WMT_INFO_FUNC
 710                             ("no data available, please run echo 15 xx > /proc/driver/wmt_psm first\n");
 711                         len =
 712                             osal_sprintf(page,
 713                                          "no data available, please run echo 15 xx > /proc/driver/wmt_psm first\n");
 714                 } else {
 715                         INT32 i = 0;
 716                         /*we do not check page buffer, because there are only 100 bytes in g_coex_buf, no reason page buffer is not enough, a bomb is placed here on unexpected condition */
 717                         for (i = 0; i < gCoexBuf.availSize; i++) {
 718                                 len += osal_sprintf(page + len, "0x%02x ", gCoexBuf.buffer[i]);
 719                         }
 720                         len += osal_sprintf(page + len, "\n");
 721                 }
 722         }
 723         gCoexBuf.availSize = 0;
 724         return len;
 725 }
 726 #endif
 727
 728 INT32 wmt_dbg_ut_test(INT32 par1, INT32 par2, INT32 par3)
 729 {
 730
 731         INT32 i = 0;
 732         INT32 j = 0;
 733         INT32 iRet = 0;
 734
 735         i = 20;
 736         while ((i--) > 0) {
 737                 WMT_INFO_FUNC("#### UT WMT and STP Function On/Off .... %d\n", i);
 738                 j = 10;
 739                 while ((j--) > 0) {
 740                         WMT_INFO_FUNC("#### BT  On .... (%d, %d)\n", i, j);
 741                         iRet = mtk_wcn_wmt_func_on(WMTDRV_TYPE_BT);
 742                         if (iRet == MTK_WCN_BOOL_FALSE) {
 743                                 break;
 744                         }
 745                         WMT_INFO_FUNC("#### GPS On .... (%d, %d)\n", i, j);
 746                         iRet = mtk_wcn_wmt_func_on(WMTDRV_TYPE_GPS);
 747                         if (iRet == MTK_WCN_BOOL_FALSE) {
 748                                 break;
 749                         }
 750                         WMT_INFO_FUNC("#### FM  On .... (%d, %d)\n", i, j);
 751                         iRet = mtk_wcn_wmt_func_on(WMTDRV_TYPE_FM);
 752                         if (iRet == MTK_WCN_BOOL_FALSE) {
 753                                 break;
 754                         }
 755                         WMT_INFO_FUNC("#### WIFI On .... (%d, %d)\n", i, j);
 756                         iRet = mtk_wcn_wmt_func_on(WMTDRV_TYPE_WIFI);
 757                         if (iRet == MTK_WCN_BOOL_FALSE) {
 758                                 break;
 759                         }
 760                         WMT_INFO_FUNC("#### ANT On .... (%d, %d)\n", i, j);
 761                         iRet = mtk_wcn_wmt_func_on(WMTDRV_TYPE_ANT);
 762                         if (iRet == MTK_WCN_BOOL_FALSE) {
 763                                 break;
 764                         }
 765                         WMT_INFO_FUNC("#### BT  Off .... (%d, %d)\n", i, j);
 766                         iRet = mtk_wcn_wmt_func_off(WMTDRV_TYPE_BT);
 767                         if (iRet == MTK_WCN_BOOL_FALSE) {
 768                                 break;
 769                         }
 770                         WMT_INFO_FUNC("#### GPS  Off ....(%d, %d)\n", i, j);
 771                         iRet = mtk_wcn_wmt_func_off(WMTDRV_TYPE_GPS);
 772                         if (iRet == MTK_WCN_BOOL_FALSE) {
 773                                 break;
 774                         }
 775                         WMT_INFO_FUNC("#### FM  Off .... (%d, %d)\n", i, j);
 776                         iRet = mtk_wcn_wmt_func_off(WMTDRV_TYPE_FM);
 777                         if (iRet == MTK_WCN_BOOL_FALSE) {
 778                                 break;
 779                         }
 780                         WMT_INFO_FUNC("#### WIFI  Off ....(%d, %d)\n", i, j);
 781                         iRet = mtk_wcn_wmt_func_off(WMTDRV_TYPE_WIFI);
 782                         if (iRet == MTK_WCN_BOOL_FALSE) {
 783                                 break;
 784                         }
 785                         WMT_INFO_FUNC("#### ANT  Off ....(%d, %d)\n", i, j);
 786                         iRet = mtk_wcn_wmt_func_off(WMTDRV_TYPE_ANT);
 787                         if (iRet == MTK_WCN_BOOL_FALSE) {
 788                                 break;
 789                         }
 790                 }
 791                 if (iRet == MTK_WCN_BOOL_FALSE) {
 792                         break;
 793                 }
 794         }
 795         if (iRet == MTK_WCN_BOOL_FALSE) {
 796                 WMT_INFO_FUNC("#### UT FAIL!!\n");
 797         } else {
 798                 WMT_INFO_FUNC("#### UT PASS!!\n");
 799         }
 800         return iRet;
 801 }
 802
 803 #if USE_NEW_PROC_FS_FLAG
 804 ssize_t wmt_dbg_write(struct file *filp, const char __user *buffer, size_t count, loff_t *f_pos)
 805 {
 806         INT8 buf[256];
 807         PINT8 pBuf;
 808         unsigned long len = count;
 809         INT32 x = 0, y = 0, z = 0;
 810         PINT8 pToken = NULL;
 811         PINT8 pDelimiter = " \t";
 812
 813         WMT_INFO_FUNC("write parameter len = %d\n\r", (INT32) len);
 814         if (len >= osal_sizeof(buf)) {
 815                 WMT_ERR_FUNC("input handling fail!\n");
 816                 len = osal_sizeof(buf) - 1;
 817                 return -1;
 818         }
 819
 820         if (copy_from_user(buf, buffer, len)) {
 821                 return -EFAULT;
 822         }
 823         buf[len] = '\0';
 824         WMT_INFO_FUNC("write parameter data = %s\n\r", buf);
 825
 826         pBuf = buf;
 827         pToken = osal_strsep(&pBuf, pDelimiter);
 828         x = NULL != pToken ? osal_strtol(pToken, NULL, 16) : 0;
 829
 830         pToken = osal_strsep(&pBuf, "\t\n ");
 831         if (pToken != NULL) {
 832                 y = osal_strtol(pToken, NULL, 16);
 833                 WMT_INFO_FUNC("y = 0x%08x\n\r", y);
 834         } else {
 835                 y = 3000;
 836                 /*efuse, register read write default value */
 837                 if (0x11 == x || 0x12 == x || 0x13 == x) {
 838                         y = 0x80000000;
 839                 }
 840         }
 841
 842         pToken = osal_strsep(&pBuf, "\t\n ");
 843         if (pToken != NULL) {
 844                 z = osal_strtol(pToken, NULL, 16);
 845         } else {
 846                 z = 10;
 847                 /*efuse, register read write default value */
 848                 if (0x11 == x || 0x12 == x || 0x13 == x) {
 849                         z = 0xffffffff;
 850                 }
 851         }
 852
 853         WMT_INFO_FUNC("x(0x%08x), y(0x%08x), z(0x%08x)\n\r", x, y, z);
 854
 855         if (osal_array_size(wmt_dev_dbg_func) > x && NULL != wmt_dev_dbg_func[x]) {
 856                 (*wmt_dev_dbg_func[x]) (x, y, z);
 857         } else {
 858                 WMT_WARN_FUNC("no handler defined for command id(0x%08x)\n\r", x);
 859         }
 860         return len;
 861 }
 862
 863 #else
 864
 865 static INT32 wmt_dev_dbg_write(struct file *file, const char *buffer, unsigned long count, void *data)
 866 {
 867
 868         INT8 buf[256];
 869         PINT8 pBuf;
 870         unsigned long len = count;
 871         INT32 x = 0, y = 0, z = 0;
 872         PINT8 pToken = NULL;
 873         PINT8 pDelimiter = " \t";
 874
 875         WMT_INFO_FUNC("write parameter len = %d\n\r", (INT32) len);
 876         if (len >= osal_sizeof(buf)) {
 877                 WMT_ERR_FUNC("input handling fail!\n");
 878                 len = osal_sizeof(buf) - 1;
 879                 return -1;
 880         }
 881
 882         if (copy_from_user(buf, buffer, len)) {
 883                 return -EFAULT;
 884         }
 885         buf[len] = '\0';
 886         WMT_INFO_FUNC("write parameter data = %s\n\r", buf);
 887
 888         pBuf = buf;
 889         pToken = osal_strsep(&pBuf, pDelimiter);
 890         x = NULL != pToken ? osal_strtol(pToken, NULL, 16) : 0;
 891
 892         pToken = osal_strsep(&pBuf, "\t\n ");
 893         if (pToken != NULL) {
 894                 y = osal_strtol(pToken, NULL, 16);
 895                 WMT_INFO_FUNC("y = 0x%08x\n\r", y);
 896         } else {
 897                 y = 3000;
 898                 /*efuse, register read write default value */
 899                 if (0x11 == x || 0x12 == x || 0x13 == x) {
 900                         y = 0x80000000;
 901                 }
 902         }
 903
 904         pToken = osal_strsep(&pBuf, "\t\n ");
 905         if (pToken != NULL) {
 906                 z = osal_strtol(pToken, NULL, 16);
 907         } else {
 908                 z = 10;
 909                 /*efuse, register read write default value */
 910                 if (0x11 == x || 0x12 == x || 0x13 == x) {
 911                         z = 0xffffffff;
 912                 }
 913         }
 914
 915         WMT_INFO_FUNC("x(0x%08x), y(0x%08x), z(0x%08x)\n\r", x, y, z);
 916
 917         if (osal_array_size(wmt_dev_dbg_func) > x && NULL != wmt_dev_dbg_func[x]) {
 918                 (*wmt_dev_dbg_func[x]) (x, y, z);
 919         } else {
 920                 WMT_WARN_FUNC("no handler defined for command id(0x%08x)\n\r", x);
 921         }
 922         return len;
 923 }
 924
 925 #endif
 926 INT32 wmt_dev_dbg_setup(VOID)
 927 {
 928         INT32 i_ret;
 929 #if USE_NEW_PROC_FS_FLAG
 930         gWmtDbgEntry = proc_create(WMT_DBG_PROCNAME, 0664, NULL, &wmt_dbg_fops);
 931         if (gWmtDbgEntry == NULL) {
 932                 WMT_ERR_FUNC("Unable to create / wmt_aee proc entry\n\r");
 933                 i_ret = -1;
 934         }
 935 #else
 936
 937         gWmtDbgEntry = create_proc_entry(WMT_DBG_PROCNAME, 0664, NULL);
 938         if (gWmtDbgEntry == NULL) {
 939                 WMT_ERR_FUNC("Unable to create /proc entry\n\r");
 940                 i_ret = -1;
 941         }
 942         gWmtDbgEntry->read_proc = wmt_dev_dbg_read;
 943         gWmtDbgEntry->write_proc = wmt_dev_dbg_write;
 944 #endif
 945
 946         return i_ret;
 947 }
 948
 949 INT32 wmt_dev_dbg_remove(VOID)
 950 {
 951 #if USE_NEW_PROC_FS_FLAG
 952         if (NULL != gWmtDbgEntry) {
 953                 proc_remove(gWmtDbgEntry);
 954         }
 955 #else
 956
 957         if (NULL != gWmtDbgEntry) {
 958                 remove_proc_entry(WMT_DBG_PROCNAME, NULL);
 959         }
 960 #endif
 961 #if CFG_WMT_PS_SUPPORT
 962         wmt_lib_ps_deinit();
 963 #endif
 964         return 0;
 965 }
 966 #endif