drivers/net/wireless/eswin/fullmac/ecrnx_debugfs_func.c

   1 #include "ecrnx_debugfs_func.h"
   2 #include "ecrnx_debugfs_custom.h"
   3
   4 #ifdef CONFIG_ECRNX_DEBUGFS
   5
   6 debugfs_info_t debugfs_info;
   7 debugfs_resp_t debugfs_resp;
   8
   9 u32 reg_buf[512]={0};
  10
  11 REG_MAP_ST mac_reg_table[]={
  12     {"INTC_IRQ_STATUS_ADDR",              0x00510000},
  13     {"INTC_IRQ_UNMASK_SET_ADDR",          0x00510010},
  14     {"INTC_IRQ_INDEX_ADDR",               0x00510040},
  15     {"NXMAC_MAC_ADDR_LOW_ADDR",           0x00610010},
  16     {"NXMAC_MAC_ADDR_HI_ADDR",            0x00610014},
  17     {"NXMAC_STATE_CNTRL_ADDR",            0x00610038},
  18     {"NXMAC_MAC_CNTRL_1_ADDR",            0x0061004c},
  19     {"NXMAC_RX_CNTRL_ADDR",               0x00610060},
  20     {"NXMAC_MAX_POWER_LEVEL_ADDR",        0x006100a0},
  21     {"NXMAC_TIMINGS_1_ADDR",              0x006100e4},
  22     {"NXMAC_RX_CNTRL_2_ADDR",             0x0061010c},
  23     {"NXMAC_MONOTONIC_COUNTER_2_LO_ADDR", 0x00610120},
  24     {"NXMAC_MONOTONIC_COUNTER_2_HI_ADDR", 0x00610124},
  25     {"NXMAC_MAX_RX_LENGTH_ADDR",          0x00610150},
  26     {"NXMAC_GEN_INT_STATUS_ADDR",         0x0061806c},
  27     {"NXMAC_GEN_INT_ENABLE_ADDR",         0x00618074},
  28     {"NXMAC_TX_RX_INT_STATUS_ADDR",       0x00618078},
  29     {"NXMAC_TX_RX_INT_ENABLE_ADDR",       0x00618080},
  30     {"NXMAC_DMA_CNTRL_SET_ADDR",          0x00618180},
  31     {"NXMAC_DMA_STATUS_1_ADDR",           0x00618188},
  32     {"NXMAC_DMA_STATUS_2_ADDR",           0x0061818c},
  33     {"NXMAC_DMA_STATUS_3_ADDR",           0x00618190},
  34     {"NXMAC_DMA_STATUS_4_ADDR",           0x00618194},
  35     {"NXMAC_TX_BCN_HEAD_PTR_ADDR",        0x00618198},
  36     {"NXMAC_TX_AC_0_HEAD_PTR_ADDR",       0x0061819c},
  37     {"NXMAC_TX_AC_1_HEAD_PTR_ADDR",       0x006181a0},
  38     {"NXMAC_TX_AC_2_HEAD_PTR_ADDR",       0x006181a4},
  39     {"NXMAC_TX_AC_3_HEAD_PTR_ADDR",       0x006181a8},
  40     {"NXMAC_RX_BUF_1_START_PTR_ADDR",     0x006181c8},
  41     {"NXMAC_RX_BUF_1_END_PTR_ADDR",       0x006181cc},
  42     {"NXMAC_RX_BUF_1_RD_PTR_ADDR",        0x006181d0},
  43     {"NXMAC_RX_BUF_1_WR_PTR_ADDR",        0x006181d4},
  44     {"NXMAC_RX_BUF_CONFIG_ADDR",          0x006181e8},
  45     {"MDM_HDMCONFIG_ADDR",                0x00700000},
  46 };
  47
  48 REG_MAP_ST rf_reg_table[]={
  49     {"RF_REG_EXAMPLE",                    0x00510000},
  50 };
  51
  52 REG_MAP_ST bb_reg_table[]={
  53     {"BB_REG_EXAMPLE",                    0x00510000},
  54 };
  55
  56 REG_MAP_ST efuse_map_table[]={
  57     {"EFUSE_REG_EXAMPLE",                 0x00510000},
  58 };
  59
  60 int argc;
  61 char *argv[MAX_ARGV];
  62 char slave_cli_cmd[50];
  63 int arg_val[MAX_ARGV];
  64
  65
  66 ECRNX_CLI_TABLE_ST ecrnx_cli_tab[]={
  67     {"macbyp start ", "macbyp_tx_start", 6, {{0,32},{0,32},{0,32},{0,32},{0,32},{0,32}},    cli_macbyp_start},
  68     {"macbyp stop",   "macbyp_tx_stop",  0, {},                                             cli_macbyp_stop},
  69     {"rf txgain ",    "rf_set_txgain",   1, {{0,32}},                                       cli_rf_txgain},
  70     {"rf rxgain ",    "rf_set_rxgain",   4, {{0,32},{0,32},{0,32},{0,32}},                  cli_rf_rxgain},
  71     {"rf chan ",      "rf_set_chan",     2, {{0,32},{0,32}},                                cli_rf_chan},
  72 };
  73
  74
  75 void ecrnx_debugfs_param_send(debugfs_info_t *req)
  76 {
  77     if(debugfs_info.debugfs_type == SLAVE_LOG_LEVEL){
  78         if (req->u.slave_log_level_t.debug_level < DBG_TYPE_D || req->u.slave_log_level_t.debug_level > DBG_TYPE_O) {
  79             ECRNX_ERR("ecrnx debug param error!!!\n");
  80         }
  81     }
  82
  83     ECRNX_DBG("%s: fstype:%d, level:%d, dir:%d \n", __func__, req->debugfs_type, req->u.slave_log_level_t.debug_level, req->u.slave_log_level_t.debug_dir);
  84     //print_hex_dump(KERN_INFO, "ecrnx_debugfs_send ", DUMP_PREFIX_ADDRESS, 32, 1,
  85     //    (u8*)req, sizeof(debugfs_info_t), false);
  86     host_send(req, sizeof(debugfs_info_t), TX_FLAG_MSG_DEBUGFS_IE);
  87 }
  88
  89 int ecrnx_log_level_get(LOG_CTL_ST *log)
  90 {
  91     if (log == NULL)
  92         return -1;
  93
  94     *log = log_ctl;
  95
  96     return 0;
  97 }
  98
  99 int ecrnx_fw_log_level_set(u32 level, u32 dir)
 100 {
 101     log_ctl.level = level;
 102     log_ctl.dir = dir;
 103
 104     debugfs_info.debugfs_type = SLAVE_LOG_LEVEL;
 105     debugfs_info.u.slave_log_level_t.debug_level = level;
 106     debugfs_info.u.slave_log_level_t.debug_dir = dir;
 107
 108     ecrnx_debugfs_param_send(&debugfs_info);
 109
 110     return 0;
 111 }
 112
 113 bool ecrnx_log_host_enable(void)
 114 {
 115     if (log_ctl.dir)
 116         return true;
 117
 118     return false;
 119 }
 120
 121 int ecrnx_host_ver_get(u8 *ver)
 122 {
 123     if (ver == NULL)
 124         return -1;
 125
 126     sprintf(ver, "v%s", HOST_DRIVER_VERSION);
 127
 128     return 0;
 129 }
 130
 131 int ecrnx_fw_ver_get(u8 *ver)
 132 {
 133     if (ver == NULL)
 134         return -1;
 135
 136     debugfs_info.debugfs_type = SLAVE_FW_INFO;
 137     ecrnx_debugfs_param_send(&debugfs_info);
 138
 139     //wait for confirm
 140     debugfs_resp.rxdatas = 0;
 141     wait_event_interruptible_timeout(debugfs_resp.rxdataq, debugfs_resp.rxdatas, 1*HZ);
 142
 143     if (debugfs_resp.rxdatas)
 144         memcpy(ver, debugfs_resp.rxdata, debugfs_resp.rxlen);
 145     else
 146         return -1;
 147
 148     return 0;
 149 }
 150
 151 int ecrnx_build_time_get(u8 *build_time)
 152 {
 153     if (build_time == NULL)
 154         return -1;
 155
 156     sprintf(build_time, "%s %s", __DATE__, __TIME__);
 157
 158     return 0;
 159 }
 160
 161 static int ecrnx_wdevs_get(struct seq_file *seq, struct wireless_dev **wdev)
 162 {
 163     struct ecrnx_hw *ecrnx_hw;
 164     u32 i;
 165
 166     if (seq->private == NULL)
 167         return -1;
 168
 169     ecrnx_hw = seq->private;
 170
 171     for (i=0; i<NX_VIRT_STA_MAX; i++)
 172     {
 173         if (ecrnx_hw->vif_table[i] != NULL)
 174             wdev[i] = &ecrnx_hw->vif_table[i]->wdev;
 175         else
 176             wdev[i] = NULL;
 177     }
 178
 179     return 0;
 180 }
 181
 182 static int ecrnx_wdev_match(struct wireless_dev **wdev, IF_TYPE_EN iftype, u32 *index)
 183 {
 184     struct ecrnx_vif *ecrnx_vif;
 185     u32 i;
 186
 187     for (i=0; i<NX_VIRT_STA_MAX; i++)
 188     {
 189         // 1. valid
 190         if (wdev[i] == NULL)
 191             continue;
 192
 193         // 2. up
 194         ecrnx_vif = netdev_priv(wdev[i]->netdev);
 195         if (ecrnx_vif->up == false)
 196             continue;
 197
 198         // 3. type
 199         switch(wdev[i]->iftype)
 200         {
 201             case NL80211_IFTYPE_STATION:
 202             {
 203                 if (iftype == IF_STA)
 204                 {
 205                     *index = i;
 206                     return 0;
 207                 }
 208                 break;
 209             }
 210
 211             case NL80211_IFTYPE_AP:
 212             case NL80211_IFTYPE_AP_VLAN:
 213             {
 214                 if (iftype == IF_AP)
 215                 {
 216                     *index = i;
 217                     return 0;
 218                 }
 219                 break;
 220             }
 221
 222             case NL80211_IFTYPE_P2P_CLIENT:
 223             case NL80211_IFTYPE_P2P_GO:
 224             case NL80211_IFTYPE_P2P_DEVICE:
 225             {
 226                 if (iftype == IF_P2P)
 227                 {
 228                     *index = i;
 229                     return 0;
 230                 }
 231                 break;
 232             }
 233
 234             default :
 235                 break;
 236         }
 237     }
 238
 239     return -1;
 240 }
 241
 242 int ecrnx_rf_info_get(struct seq_file *seq, IF_TYPE_EN iftype,RF_INFO_ST *cur, RF_INFO_ST *oper)
 243 {
 244     struct wireless_dev *wdev[NX_VIRT_STA_MAX];
 245     struct cfg80211_chan_def chandef;
 246     u32 index;
 247
 248     if (0 != ecrnx_wdevs_get(seq, wdev))
 249         return -1;
 250
 251     if ((cur == NULL) || (oper == NULL))
 252         return -1;
 253
 254     if (0 != ecrnx_wdev_match(wdev, iftype, &index))
 255         return -1;
 256
 257     if (0 != ecrnx_cfg80211_get_channel(wdev[index]->wiphy, wdev[index], &chandef))
 258         return -1;
 259
 260     cur->ch = (chandef.center_freq1 - 2412)/5 + 1;
 261     cur->bw = chandef.width;
 262     cur->ch_offset = 0;
 263
 264     oper->ch = (chandef.center_freq1 - 2412)/5 + 1;
 265     oper->bw = chandef.width;
 266     oper->ch_offset = 0;
 267
 268     return 0;
 269 }
 270
 271 int ecrnx_country_code_get(struct seq_file *seq, char *alpha2)
 272 {
 273     struct ecrnx_hw *ecrnx_hw;
 274
 275     if (seq->private != NULL)
 276         ecrnx_hw = seq->private;
 277     else
 278         return -1;
 279
 280     if (alpha2 == NULL)
 281         return -1;
 282
 283     if (ecrnx_hw->wiphy == NULL)
 284         return -1;
 285
 286     if (ecrnx_hw->wiphy->regd == NULL)
 287         return -1;
 288
 289     memcpy(alpha2, ecrnx_hw->wiphy->regd->alpha2, sizeof(ecrnx_hw->wiphy->regd->alpha2));
 290     alpha2[2] = '\0';
 291
 292     return 0;
 293 }
 294
 295 int ecrnx_mac_addr_get(struct seq_file *seq, IF_TYPE_EN iftype, u8 *mac_addr)
 296 {
 297     struct wireless_dev *wdev[NX_VIRT_STA_MAX];
 298     u32 index;
 299
 300     if (0 != ecrnx_wdevs_get(seq, wdev))
 301         return -1;
 302
 303     if (mac_addr == NULL)
 304         return -1;
 305
 306     if (0 != ecrnx_wdev_match(wdev, iftype, &index))
 307         return -1;
 308
 309     memcpy(mac_addr, wdev[index]->netdev->perm_addr, ETH_ALEN);
 310
 311     return 0;
 312 }
 313
 314 int ecrnx_mac_addr_get_ex(struct seq_file *seq, u8 *mac_addr_info)
 315 {
 316     struct wireless_dev *wdev[NX_VIRT_STA_MAX];
 317     u32 i;
 318
 319     if (0 != ecrnx_wdevs_get(seq, wdev))
 320         return -1;
 321
 322     if (mac_addr_info == NULL)
 323         return -1;
 324
 325     mac_addr_info[0] = '\0';
 326     for (i=0; i<NX_VIRT_STA_MAX; i++)
 327     {
 328         if (wdev[i] != NULL)
 329         {
 330             sprintf(mac_addr_info+strlen(mac_addr_info), "%s hw_port(%d) mac_addr=%02X:%02X:%02X:%02X:%02X:%02X\n", wdev[i]->netdev->name, wdev[i]->netdev->ifindex,
 331                 wdev[i]->netdev->perm_addr[0], wdev[i]->netdev->perm_addr[1], wdev[i]->netdev->perm_addr[2],
 332                 wdev[i]->netdev->perm_addr[3], wdev[i]->netdev->perm_addr[4], wdev[i]->netdev->perm_addr[5]);
 333         }
 334     }
 335
 336     return 0;
 337 }
 338
 339 int ecrnx_channel_get(struct seq_file *seq, IF_TYPE_EN iftype, struct cfg80211_chan_def *chandef)
 340 {
 341     struct wireless_dev *wdev[NX_VIRT_STA_MAX];
 342     u32 index;
 343
 344     if (0 != ecrnx_wdevs_get(seq, wdev))
 345         return -1;
 346
 347     if (chandef == NULL)
 348         return -1;
 349
 350     if (0 != ecrnx_wdev_match(wdev, iftype, &index))
 351         return -1;
 352
 353     return ecrnx_cfg80211_get_channel(wdev[index]->wiphy, wdev[index], chandef);
 354 }
 355
 356 int ecrnx_p2p_role_get(struct seq_file *seq, IF_TYPE_EN iftype)
 357 {
 358     struct wireless_dev *wdev[NX_VIRT_STA_MAX];
 359     u32 index;
 360
 361     if (0 != ecrnx_wdevs_get(seq, wdev))
 362         return -1;
 363
 364     if (0 != ecrnx_wdev_match(wdev, iftype, &index))
 365         return -1;
 366
 367     return wdev[index]->iftype;
 368 }
 369
 370 int ecrnx_bssid_get(struct seq_file *seq, IF_TYPE_EN iftype, u8 *bssid)
 371 {
 372     struct station_info sinfo;
 373     struct wireless_dev *wdev[NX_VIRT_STA_MAX];
 374     u32 index;
 375
 376     if (0 != ecrnx_wdevs_get(seq, wdev))
 377         return -1;
 378
 379     if (bssid == NULL)
 380         return -1;
 381
 382     if (0 != ecrnx_wdev_match(wdev, iftype, &index))
 383         return -1;
 384
 385     return ecrnx_cfg80211_dump_station(wdev[index]->wiphy, wdev[index]->netdev, 0, bssid, &sinfo);
 386 }
 387
 388 int ecrnx_signal_level_get(struct seq_file *seq, IF_TYPE_EN iftype, s8 *noise_dbm)
 389 {
 390     struct wireless_dev *wdev[NX_VIRT_STA_MAX];
 391     struct ecrnx_hw *ecrnx_hw;
 392     u32 index;
 393
 394     if (0 != ecrnx_wdevs_get(seq, wdev))
 395         return -1;
 396
 397     if (noise_dbm == NULL)
 398         return -1;
 399
 400     if (0 != ecrnx_wdev_match(wdev, iftype, &index))
 401         return -1;
 402
 403     ecrnx_hw = wdev_priv(wdev[index]);
 404     *noise_dbm = ecrnx_hw->survey[0].noise_dbm;
 405
 406     return 0;
 407 }
 408
 409 int ecrnx_flags_get(struct seq_file *seq, IF_TYPE_EN iftype, u32 *flags)
 410 {
 411     struct wireless_dev *wdev[NX_VIRT_STA_MAX];
 412     u32 index;
 413
 414     if (0 != ecrnx_wdevs_get(seq, wdev))
 415         return -1;
 416
 417     if (flags == NULL)
 418         return -1;
 419
 420     if (0 != ecrnx_wdev_match(wdev, iftype, &index))
 421         return -1;
 422
 423     *flags = wdev[index]->wiphy->flags;
 424
 425     return 0;
 426 }
 427
 428 int ecrnx_ssid_get(struct seq_file *seq, IF_TYPE_EN iftype, char *ssid)
 429 {
 430     struct wireless_dev *wdev[NX_VIRT_STA_MAX];
 431     u32 index;
 432
 433     if (0 != ecrnx_wdevs_get(seq, wdev))
 434         return -1;
 435
 436     if (ssid == NULL)
 437         return -1;
 438
 439     if (0 != ecrnx_wdev_match(wdev, iftype, &index))
 440         return -1;
 441
 442     memcpy(ssid, wdev[index]->ssid, IEEE80211_MAX_SSID_LEN);
 443
 444     return 0;
 445 }
 446
 447 int ecrnx_sta_mac_get(struct seq_file *seq, IF_TYPE_EN iftype, u8 sta_mac[][ETH_ALEN+1])
 448 {
 449     struct ecrnx_hw *ecrnx_hw;
 450     u32 i;
 451     u8 mac[ETH_ALEN] = {0};
 452
 453     if (seq->private != NULL)
 454         ecrnx_hw = seq->private;
 455     else
 456         return -1;
 457
 458     // station table
 459     for (i=0; i<NX_REMOTE_STA_MAX; i++)
 460     {
 461         if (ecrnx_hw->sta_table[i].valid == true)
 462         {
 463             if (0 == memcmp(mac, ecrnx_hw->sta_table[i].mac_addr, ETH_ALEN))
 464             {
 465                 sta_mac[i][0] = 0xFF;
 466                 continue;
 467             }
 468
 469             sta_mac[i][0] = 0xFF;
 470             memcpy(&sta_mac[i][1], ecrnx_hw->sta_table[i].mac_addr, ETH_ALEN);
 471
 472         }
 473     }
 474
 475     return 0;
 476
 477 }
 478
 479 int ecrnx_mac_reg_dump(struct seq_file *seq)
 480 {
 481     u32 i, data;
 482
 483     seq_printf(seq, "%-34s  %-11s %-10s\n", "name", "addr", "value");
 484
 485     for (i=0; i<(sizeof(mac_reg_table)/sizeof(mac_reg_table[0])); i++)
 486     {
 487         ecrnx_slave_reg_read(mac_reg_table[i].addr, &data, 1);
 488         seq_printf(seq, "%-34s  0x%08X: 0x%08X\n", mac_reg_table[i].name, mac_reg_table[i].addr, data);
 489     }
 490
 491     return 0;
 492 }
 493
 494 int ecrnx_rf_reg_dump(struct seq_file *seq)
 495 {
 496     u32 i, data;
 497
 498     seq_printf(seq, "%-34s  %-11s %-10s\n", "name", "addr", "value");
 499
 500     for (i=0; i<(sizeof(rf_reg_table)/sizeof(rf_reg_table[0])); i++)
 501     {
 502         ecrnx_slave_reg_read(rf_reg_table[i].addr, &data, 1);
 503         seq_printf(seq, "%-34s  0x%08X: 0x%08X\n", rf_reg_table[i].name, rf_reg_table[i].addr, data);
 504     }
 505
 506     return 0;
 507 }
 508
 509 int ecrnx_bb_reg_dump(struct seq_file *seq)
 510 {
 511     u32 i, data;
 512
 513     seq_printf(seq, "%-34s  %-11s %-10s\n", "name", "addr", "value");
 514
 515     for (i=0; i<(sizeof(bb_reg_table)/sizeof(bb_reg_table[0])); i++)
 516     {
 517         ecrnx_slave_reg_read(bb_reg_table[i].addr, &data, 1);
 518         seq_printf(seq, "%-34s  0x%08X: 0x%08X\n", bb_reg_table[i].name, bb_reg_table[i].addr, data);
 519     }
 520
 521     return 0;
 522 }
 523
 524 int ecrnx_efuse_map_dump(struct seq_file *seq)
 525 {
 526     u32 i, data;
 527
 528     seq_printf(seq, "%-34s  %-11s %-10s\n", "name", "addr", "value");
 529
 530     for (i=0; i<(sizeof(efuse_map_table)/sizeof(efuse_map_table[0])); i++)
 531     {
 532         ecrnx_slave_reg_read(efuse_map_table[i].addr, &data, 1);
 533         seq_printf(seq, "%-34s  0x%08X: 0x%08X\n", efuse_map_table[i].name, efuse_map_table[i].addr, data);
 534     }
 535
 536     return 0;
 537 }
 538
 539 int ecrnx_slave_reg_read(u32 addr, u32 *data, u32 len)
 540 {
 541     if (data == NULL)
 542         return -1;
 543
 544     debugfs_info.debugfs_type = SLAVE_READ_REG;
 545     debugfs_info.u.slave_read_reg_t.reg = addr;
 546     debugfs_info.u.slave_read_reg_t.len = len;
 547     ecrnx_debugfs_param_send(&debugfs_info);
 548
 549     //wait for confirm
 550     debugfs_resp.rxdatas = 0;
 551     wait_event_interruptible_timeout(debugfs_resp.rxdataq, debugfs_resp.rxdatas, 1*HZ);
 552
 553     if (debugfs_resp.rxdatas)
 554         memcpy((u8 *)data, (u8 *)debugfs_resp.rxdata, debugfs_resp.rxlen);
 555
 556     return 0;
 557 }
 558
 559 int ecrnx_slave_reg_write(u32 addr, u32 data, u32 len)
 560 {
 561     debugfs_info.debugfs_type = SLAVE_WRITE_REG;
 562     debugfs_info.u.slave_write_reg_t.reg = addr;
 563     debugfs_info.u.slave_write_reg_t.value = data;
 564     ecrnx_debugfs_param_send(&debugfs_info);
 565
 566     //wait for confirm
 567     debugfs_resp.rxdatas = 0;
 568     wait_event_interruptible_timeout(debugfs_resp.rxdataq, debugfs_resp.rxdatas, 1*HZ);
 569
 570     return 0;
 571 }
 572
 573 int ecrnx_slave_cli_send(u8 *cli, u8 *resp)
 574 {
 575     if (cli == NULL)
 576         return -1;
 577
 578     debugfs_info.debugfs_type = SLAVE_FUNC_INFO;
 579     strcpy(debugfs_info.u.slave_cli_func_info_t.func_and_param, cli);
 580     ecrnx_debugfs_param_send(&debugfs_info);
 581
 582     //wait for confirm
 583     debugfs_resp.rxdatas = 0;
 584     wait_event_interruptible_timeout(debugfs_resp.rxdataq, debugfs_resp.rxdatas, 1*HZ);
 585
 586     if ((debugfs_resp.rxdatas) && (debugfs_resp.rxlen))
 587     {
 588         ECRNX_PRINT("%s\n", debugfs_resp.rxdata);
 589     }
 590
 591     return 0;
 592 }
 593
 594 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0))
 595 /**
 596  * ether_addr_copy - Copy an Ethernet address
 597  * @dst: Pointer to a six-byte array Ethernet address destination
 598  * @src: Pointer to a six-byte array Ethernet address source
 599  *
 600  * Please note: dst & src must both be aligned to u16.
 601  */
 602 static inline void ether_addr_copy(u8 *dst, const u8 *src)
 603 {
 604 #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
 605         *(u32 *)dst = *(const u32 *)src;
 606         *(u16 *)(dst + 4) = *(const u16 *)(src + 4);
 607 #else
 608         u16 *a = (u16 *)dst;
 609         const u16 *b = (const u16 *)src;
 610
 611         a[0] = b[0];
 612         a[1] = b[1];
 613         a[2] = b[2];
 614 #endif
 615 }
 616
 617 #endif
 618 void ecrnx_debugfs_survey_info_update(struct ecrnx_hw *ecrnx_hw, struct cfg80211_bss *bss)
 619 {
 620         __le16 ie_cap = 0;
 621         const u8 *ssid_elm;
 622         const u8 *ie_wpa = NULL, *ie_wpa2 = NULL, *ie_wps = NULL;
 623         const u8 *ie_p2p = NULL;
 624
 625         struct ecrnx_debugfs_survey_info_tbl *new_node, *entry, *tmp;
 626         new_node = kzalloc(sizeof(struct ecrnx_debugfs_survey_info_tbl),
 627                    GFP_ATOMIC);
 628
 629         if (bss) {
 630                 const struct cfg80211_bss_ies *ies;
 631
 632                 new_node->ch = ieee80211_frequency_to_channel(bss->channel->center_freq);
 633                 ether_addr_copy(new_node->bssid, bss->bssid);
 634                 new_node->rssi = bss->signal/100;
 635
 636                 rcu_read_lock();
 637
 638                 ie_wpa2 = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
 639
 640                 ies = rcu_dereference(bss->ies);
 641
 642                 ie_wpa = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
 643                                                 WLAN_OUI_TYPE_MICROSOFT_WPA,
 644                                                 ies->data,
 645                                                 ies->len);
 646
 647                 ie_wps = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
 648                                                 WLAN_OUI_TYPE_MICROSOFT_WPS,
 649                                                 ies->data,
 650                                                 ies->len);
 651
 652                 ie_p2p = cfg80211_find_vendor_ie(WLAN_OUI_WFA,
 653                                                 WLAN_OUI_TYPE_WFA_P2P,
 654                                                 ies->data,
 655                                                 ies->len);
 656
 657                 ie_cap = cpu_to_le16(bss->capability);
 658
 659                 ssid_elm = cfg80211_find_ie(WLAN_EID_SSID, ies->data, ies->len);
 660                 if (ssid_elm) {
 661                         if (ssid_elm[1] <= IEEE80211_MAX_SSID_LEN)
 662                                 memcpy(new_node->ssid, ssid_elm + 2, ssid_elm[1]);
 663                 }
 664
 665                 rcu_read_unlock();
 666         }
 667
 668                 sprintf(new_node->flag, "%s%s%s%s%s%s",
 669                         (ie_wpa) ? "[WPA]" : "",
 670                         (ie_wpa2) ? "[WPA2]" : "",
 671                         (!ie_wpa && !ie_wpa && ie_cap & BIT(4)) ? "[WEP]" : "",
 672                         (ie_wps) ? "[WPS]" : "",
 673                         (ie_cap & BIT(0)) ? "[ESS]" : "",
 674                         (ie_p2p) ? "[P2P]" : "");
 675
 676         INIT_LIST_HEAD(&new_node->list);
 677
 678         //if (!list_empty(&ecrnx_hw->debugfs_survey_info_tbl_ptr)) {
 679                 list_for_each_entry_safe(entry, tmp, &ecrnx_hw->debugfs_survey_info_tbl_ptr, list) {
 680                         if(memcmp(entry->bssid, new_node->bssid, ETH_ALEN) == 0) {
 681                                 list_del(&entry->list);
 682                                 kfree(entry);
 683                         }
 684                 }
 685         //}
 686         list_add_tail(&new_node->list, &ecrnx_hw->debugfs_survey_info_tbl_ptr);
 687 }
 688
 689 void ecrnx_debugfs_noise_of_survey_info_update(struct ecrnx_hw *ecrnx_hw, struct ecrnx_survey_info *ecrnx_survey, int chan_no)
 690 {
 691         struct ecrnx_debugfs_survey_info_tbl *entry;
 692
 693         list_for_each_entry(entry, &ecrnx_hw->debugfs_survey_info_tbl_ptr, list) {
 694                 if(entry->ch == chan_no) {
 695                         entry->noise = ecrnx_survey->noise_dbm;
 696                 }
 697         }
 698 }
 699
 700 void ecrnx_debugfs_add_station_in_ap_mode(struct ecrnx_hw *ecrnx_hw,
 701                                             struct ecrnx_sta *sta, struct station_parameters *params)
 702 {
 703     struct ecrnx_debugfs_sta *debugfs_sta;
 704     //char file_name[18];
 705
 706     if(!sta || !params)
 707     {
 708         ECRNX_ERR("%s-%d:sta(%p) or params(%p) is null, return!\n", __func__, __LINE__, sta, params);
 709         return;
 710     }
 711
 712     debugfs_sta = kzalloc(sizeof(struct ecrnx_debugfs_sta), GFP_KERNEL);
 713
 714     if (!debugfs_sta)
 715         ECRNX_ERR("error debugfs_sta kzalloc!\n");
 716
 717
 718     debugfs_sta->sta_idx = sta->sta_idx;
 719     debugfs_sta->aid = sta->aid;
 720     debugfs_sta->ch_idx = sta->ch_idx;
 721     debugfs_sta->ht = sta->ht;
 722     ether_addr_copy(debugfs_sta->mac_addr, sta->mac_addr);
 723     debugfs_sta->qos = sta->qos;
 724     debugfs_sta->vht = sta->vht;
 725     debugfs_sta->width = sta->width;
 726
 727     if(sta->ht)
 728     {
 729         if (params->ht_capa->cap_info & IEEE80211_HT_CAP_TX_STBC)
 730             debugfs_sta->stbc_cap = 1;
 731         if (params->ht_capa->cap_info & IEEE80211_HT_CAP_LDPC_CODING)
 732             debugfs_sta->ldpc_cap = 1;
 733         if (params->ht_capa->cap_info & IEEE80211_HT_CAP_SGI_20)
 734             debugfs_sta->sgi_20m = 1;
 735         if (params->ht_capa->cap_info & IEEE80211_HT_CAP_SGI_40)
 736             debugfs_sta->sgi_40m = 1;
 737     }
 738
 739     ecrnx_debugfs_sta_in_ap_init(debugfs_sta);
 740 }
 741
 742 int cli_parse_args(uint8_t* str, char* argv[])
 743 {
 744     int i = 0;
 745     char* ch = (char *)str;
 746
 747     while(*ch == ' ') ch++;
 748     if (*ch == '\n')
 749         return 0;
 750
 751     while(*ch != '\0')
 752     {
 753         i++;
 754
 755         if (i > MAX_ARGV)
 756             return 0;
 757
 758         argv[i-1] = ch;
 759         while(*ch != '\0')
 760         {
 761             if(*ch == ' ')
 762                 break;
 763             else
 764                 ch++;
 765         }
 766
 767         *ch = '\0';
 768         ch++;
 769         while(*ch == ' ') {
 770             ch++;
 771         }
 772     }
 773
 774     return i;
 775 }
 776
 777 void argv_display(uint32_t argc, char* argv[])
 778 {
 779     uint32_t i;
 780
 781     ECRNX_PRINT("argc is %d\n", argc);
 782     for (i=0; i<argc; i++)
 783     {
 784         ECRNX_PRINT("param %d is %s\n", i, argv[i]);
 785     }
 786 }
 787
 788 int _atoi(char *pstr)
 789 {
 790     int ret_integer = 0;
 791     int integer_sign = 1;
 792
 793     if (pstr == NULL)
 794     {
 795         //printk("Pointer is NULL\n");
 796         return 0;
 797     }
 798
 799     while (*pstr == ' ')
 800     {
 801         pstr++;
 802     }
 803
 804     if (*pstr == '-')
 805     {
 806         integer_sign = -1;
 807     }
 808     if (*pstr == '-' || *pstr == '+')
 809     {
 810         pstr++;
 811     }
 812
 813     while (*pstr >= '0' && *pstr <= '9')
 814     {
 815         ret_integer = ret_integer * 10 + *pstr - '0';
 816         pstr++;
 817     }
 818     ret_integer = integer_sign * ret_integer;
 819
 820     return ret_integer;
 821 }
 822
 823 int cli_check_parm_num(uint32_t index, uint8_t *param)
 824 {
 825     argc = cli_parse_args(param, argv);
 826     //argv_display(argc, argv);
 827
 828     if (argc != ecrnx_cli_tab[index].param_num)
 829         return -1;
 830
 831     return 0;
 832 }
 833
 834 int cli_check_parm_range(uint32_t start_index, uint32_t index, uint32_t argc, char* argv[])
 835 {
 836     uint32_t i;
 837
 838     for (i=start_index; i<argc; i++)
 839     {
 840         arg_val[i] = _atoi(argv[i]);
 841         if ((arg_val[i] < ecrnx_cli_tab[index].param_range[i].range_min)
 842             || (arg_val[i] > ecrnx_cli_tab[index].param_range[i].range_max))
 843         {
 844             ECRNX_PRINT("param %d is out of range! current %d, min %d, max %d\n",
 845                 i, arg_val[i], ecrnx_cli_tab[index].param_range[i].range_min, ecrnx_cli_tab[index].param_range[i].range_max);
 846             return -1;
 847         }
 848     }
 849
 850     return 0;
 851 }
 852
 853 int cli_macbyp_start(uint32_t index, uint8_t *param)
 854 {
 855     uint32_t i;
 856
 857     // parse parameters
 858     if (0 != cli_check_parm_num(index, param))
 859         return -1;
 860
 861     // check range value
 862     if (0 != strcmp(argv[0], "11a")
 863         && 0 != strcmp(argv[0], "11b")
 864         && 0 != strcmp(argv[0], "11g")
 865         && 0 != strcmp(argv[0], "11n")
 866         && 0 != strcmp(argv[0], "11ac")
 867         && 0 != strcmp(argv[0], "11ax"))
 868         return -1;
 869
 870     if (0 != cli_check_parm_range(1, index, argc, argv))
 871         return -1;
 872
 873     // package command
 874     sprintf(slave_cli_cmd, "%s %s", ecrnx_cli_tab[index].map_cmd, argv[0]);
 875     for (i=1; i<argc; i++)
 876         sprintf(slave_cli_cmd+strlen(slave_cli_cmd), " %d", arg_val[i]);
 877
 878     //printk("--->The final command is: %s<-\n", slave_cli_cmd);
 879     ecrnx_slave_cli_send(slave_cli_cmd, NULL);
 880
 881     return 0;
 882 }
 883
 884 int cli_macbyp_stop(uint32_t index, uint8_t *param)
 885 {
 886     // parse parameters
 887     if (0 != cli_check_parm_num(index, param))
 888         return -1;
 889
 890     // package command
 891     sprintf(slave_cli_cmd, "%s", ecrnx_cli_tab[index].map_cmd);
 892
 893     //printk("---> The final command is: %s<-\n", slave_cli_cmd);
 894     ecrnx_slave_cli_send(slave_cli_cmd, NULL);
 895
 896     return 0;
 897 }
 898
 899 int cli_rf_txgain(uint32_t index, uint8_t *param)
 900 {
 901     uint32_t i;
 902
 903     // parse parameters
 904     if (0 != cli_check_parm_num(index, param))
 905         return -1;
 906
 907     // check range value
 908     if (0 != cli_check_parm_range(0, index, argc, argv))
 909         return -1;
 910
 911     // package command
 912     sprintf(slave_cli_cmd, "%s", ecrnx_cli_tab[index].map_cmd);
 913     for (i=0; i<argc; i++)
 914         sprintf(slave_cli_cmd+strlen(slave_cli_cmd), " %d", arg_val[i]);
 915
 916     //printk("---> The final command is: %s<-\n", slave_cli_cmd);
 917     ecrnx_slave_cli_send(slave_cli_cmd, NULL);
 918
 919     return 0;
 920 }
 921
 922 int cli_rf_rxgain(uint32_t index, uint8_t *param)
 923 {
 924     uint32_t i;
 925
 926     // parse parameters
 927     if (0 != cli_check_parm_num(index, param))
 928         return -1;
 929
 930     // check range value
 931     if (0 != cli_check_parm_range(0, index, argc, argv))
 932         return -1;
 933
 934     // package command
 935     sprintf(slave_cli_cmd, "%s", ecrnx_cli_tab[index].map_cmd);
 936     for (i=0; i<argc; i++)
 937         sprintf(slave_cli_cmd+strlen(slave_cli_cmd), " %d", arg_val[i]);
 938
 939     //printk("---> The final command is: %s<-\n", slave_cli_cmd);
 940     ecrnx_slave_cli_send(slave_cli_cmd, NULL);
 941
 942     return 0;
 943 }
 944
 945 int cli_rf_chan(uint32_t index, uint8_t *param)
 946 {
 947     uint32_t i;
 948
 949     // parse parameters
 950     if (0 != cli_check_parm_num(index, param))
 951         return -1;
 952
 953     // check range value
 954     if (0 != cli_check_parm_range(0, index, argc, argv))
 955         return -1;
 956
 957     // package command
 958     sprintf(slave_cli_cmd, "%s", ecrnx_cli_tab[index].map_cmd);
 959     for (i=0; i<argc; i++)
 960         sprintf(slave_cli_cmd+strlen(slave_cli_cmd), " %d", arg_val[i]);
 961
 962     //printk("---> The final command is: %s<-\n", slave_cli_cmd);
 963     ecrnx_slave_cli_send(slave_cli_cmd, NULL);
 964
 965     return 0;
 966 }
 967
 968 int cli_cmd_parse(uint8_t *cmd)
 969 {
 970     uint32_t i;
 971     int ret;
 972
 973     if (cmd == NULL)
 974         return -1;
 975
 976     //printk("cmd is :%s<-\n", cmd);
 977     for (i=0; i<sizeof(ecrnx_cli_tab)/sizeof(ecrnx_cli_tab[0]); i++)
 978     {
 979         if (0 == memcmp(cmd, ecrnx_cli_tab[i].cmd, strlen(ecrnx_cli_tab[i].cmd)))
 980         {
 981             //printk("index %d, cmd %s\n", i, ecrnx_cli_tab[i].cmd);
 982             ret = ecrnx_cli_tab[i].cmd_func(i, cmd + strlen(ecrnx_cli_tab[i].cmd));
 983             goto exit;
 984         }
 985     }
 986
 987     ECRNX_ERR("No matching commands!\n");
 988
 989     return -2;
 990
 991 exit:
 992     return ret;
 993 }
 994 #endif
 995