| /* |
| * Copyright (c) 2011-2012 Qualcomm Atheros Inc. |
| * |
| * Permission to use, copy, modify, and/or distribute this software for any |
| * purpose with or without fee is hereby granted, provided that the above |
| * copyright notice and this permission notice appear in all copies. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
| * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
| * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
| * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| */ |
| |
| #include <sys/types.h> |
| #include <sys/file.h> |
| #include <sys/ioctl.h> |
| #include <sys/socket.h> |
| #include <linux/types.h> |
| #include <net/if.h> |
| |
| #include <errno.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <getopt.h> |
| #include <stdint.h> |
| #include <stdbool.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| #include <unistd.h> |
| #include <assert.h> |
| #include <ctype.h> |
| #include <math.h> |
| #include <time.h> |
| |
| #include "athtestcmd.h" |
| #include "libtcmd.h" |
| #include "testcmd.h" |
| #include "sinit_eep.h" |
| #include "sinit_common.h" |
| |
| const char *progname; |
| const char commands[] = "commands:\n" |
| "--tx <sine/frame/tx99/tx100/off>\n" |
| "--txfreq <Tx channel or freq(default 2412)>\n" |
| "--txrate <rate index>\n" |
| "--txpwr <frame/tx99/tx100: 0-30dBm,0.5dBm resolution; sine: 0-60, PCDAC vaule>\n" |
| "--txantenna <1/2/0 (auto)>\n" |
| "--txpktsz <pkt size, [32-1500](default 1500)>\n" |
| "--txpattern <tx data pattern, 0: all zeros; 1: all ones;" |
| " 2: repeating 10; 3: PN7; 4: PN9; 5: PN15\n" |
| "--ani (Enable ANI. The ANI is disabled if this option is not specified)\n" |
| "--scrambleroff (Disable scrambler. The scrambler is enabled by default)\n" |
| "--aifsn <AIFS slots num,[0-252](Used only under '--tx frame' mode)>\n" |
| "--shortguard (use short guard)\n" |
| "--mode <ht40plus/ht40minus/ht20>\n" |
| "--setlongpreamble <1/0>\n" |
| "--numpackets <number of packets to send 0-65535>\n" |
| "--tx sine --txfreq <Tx channel or freq(default 2412)>\n" |
| "--rx <promis/filter/report>\n" |
| "--rxfreq <Rx channel or freq(default 2412)>\n" |
| "--rxantenna <1/2/0 (auto)>\n" |
| "--mode <ht40plus/ht40minus>\n" |
| "--pm <wakeup/sleep/deepsleep>\n" |
| "--setmac <mac addr like 00:03:7f:be:ef:11>\n" |
| "--getmac\n" |
| "--SetAntSwitchTable <table1 in decimal value>" |
| " <table2 in decimal value> (Set table1=0 and table2=0 will" |
| " restore the default AntSwitchTable)\n" |
| "--efusedump --start <start address> --end <end address>\n" |
| "--efusewrite --start <start address> --data <data> (could be one or multiple data in quotation marks)\n" |
| "--otpwrite --data (could be one or multiple data in quotation marks)\n" |
| "--otpdump\n"; |
| |
| #define A_ERR(ret, args...) printf(args); exit(ret); |
| |
| #define A_FREQ_MIN 4920 |
| #define A_FREQ_MAX 5825 |
| |
| #define A_CHAN0_FREQ 5000 |
| #define A_CHAN_MAX ((A_FREQ_MAX - A_CHAN0_FREQ)/5) |
| |
| #define BG_FREQ_MIN 2412 |
| #define BG_FREQ_MAX 2484 |
| |
| #define BG_CHAN0_FREQ 2407 |
| #define BG_CHAN_MIN ((BG_FREQ_MIN - BG_CHAN0_FREQ)/5) |
| #define BG_CHAN_MAX 14 /* corresponding to 2484 MHz */ |
| |
| #define A_20MHZ_BAND_FREQ_MAX 5000 |
| |
| #define INVALID_FREQ 0 |
| #define A_OK 0 |
| |
| #define ATH6KL_INTERFACE "wlan0" |
| |
| #define A_RATE_NUM 28 |
| #define G_RATE_NUM 28 |
| |
| #define RATE_STR_LEN 20 |
| #define VENUS_OTP_SIZE 512 |
| typedef const char RATE_STR[RATE_STR_LEN]; |
| |
| const RATE_STR bgRateStrTbl[G_RATE_NUM] = { |
| {"1 Mb"}, |
| {"2 Mb"}, |
| {"5.5 Mb"}, |
| {"11 Mb"}, |
| {"6 Mb"}, |
| {"9 Mb"}, |
| {"12 Mb"}, |
| {"18 Mb"}, |
| {"24 Mb"}, |
| {"36 Mb"}, |
| {"48 Mb"}, |
| {"54 Mb"}, |
| {"HT20 MCS0 6.5 Mb"}, |
| {"HT20 MCS1 13 Mb"}, |
| {"HT20 MCS2 19.5 Mb"}, |
| {"HT20 MCS3 26 Mb"}, |
| {"HT20 MCS4 39 Mb"}, |
| {"HT20 MCS5 52 Mb"}, |
| {"HT20 MCS6 58.5 Mb"}, |
| {"HT20 MCS7 65 Mb"}, |
| {"HT40 MCS0 13.5 Mb"}, |
| {"HT40 MCS1 27.0 Mb"}, |
| {"HT40 MCS2 40.5 Mb"}, |
| {"HT40 MCS3 54 Mb"}, |
| {"HT40 MCS4 81 Mb"}, |
| {"HT40 MCS5 108 Mb"}, |
| {"HT40 MCS6 121.5 Mb"}, |
| {"HT40 MCS7 135 Mb"} |
| }; |
| #if !defined(_printf) |
| #define _printf printf |
| #endif |
| |
| #define _NAME_MAX 256 |
| #define _LABEL_MAX 16 |
| |
| typedef struct _calSetup { |
| double attenDUT2PM_5G; |
| double attenDUT2PM_2G; |
| char testflowBinFilename[_NAME_MAX]; |
| char goldenBinFilename[_NAME_MAX]; |
| char outputBinFilename[_NAME_MAX]; |
| char label[_LABEL_MAX]; |
| } _CAL_SETUP; |
| _CAL_SETUP calSetup = { |
| 19.0, |
| 18.0, |
| "calTestFlow.bin", |
| #ifdef ANDROID |
| "/system/etc/firmware/ath6k/AR6003/hw2.1.1/bdata.bin", |
| #else |
| "/lib/firmware/ath6k/AR6003/hw2.1.1/bdata.bin", |
| #endif |
| #ifdef ANDROID |
| "/persist/bdata.bin", |
| #else |
| "new_bdata.bin", |
| #endif |
| "wbgf10_010_d0001", |
| }; |
| |
| uint32_t AR6003_EEPROM_SIZE; |
| uint32_t AR6K_EEPROM_SIZE; |
| static bool bCalResult; |
| #define FIRST_WAIT_INTERVAL 2 |
| #define POLLING_INTERVAL 1 |
| #define MAX_WAIT_CYCLE 20 |
| |
| static time_t startTime, endTime; |
| static void rxReport(void *buf); |
| static void rx_cb(void *buf, int len); |
| static uint32_t freqValid(uint32_t val); |
| static uint16_t wmic_ieee2freq(uint32_t chan); |
| static void prtRateTbl(uint32_t freq); |
| static uint32_t rateValid(uint32_t val, uint32_t freq); |
| static uint32_t antValid(uint32_t val); |
| static bool txPwrValid(TCMD_CONT_TX * txCmd); |
| static int ath_ether_aton(const char *orig, uint8_t * eth); |
| static uint32_t pktSzValid(uint32_t val); |
| static void updateCALData(_CAL_SETUP *pCalSetup, TC_MSG *pTCMsg); |
| static bool dumpPSATCharResult2File(TC_MSG *pTCMsg); |
| |
| static bool isHex(char c) { |
| return (((c >= '0') && (c <= '9')) || |
| ((c >= 'A') && (c <= 'F')) || |
| ((c >= 'a') && (c <= 'f'))); |
| } |
| |
| static int usage(void) |
| { |
| fprintf(stderr, "usage:\n%s [-i device] commands\n", progname); |
| fprintf(stderr, "%s\n", commands); |
| prtRateTbl(INVALID_FREQ); |
| A_ERR(-1, "Incorrect usage"); |
| } |
| |
| unsigned int cmd = 0; |
| unsigned int act = 0; |
| uint16_t data_length = 0; |
| uint16_t efuse_begin = 0, efuse_end = (VENUS_OTP_SIZE - 1); |
| static TC_CMDS sTcCmds; |
| |
| int main(int argc, char **argv) |
| { |
| int c, err,i; |
| char ifname[IFNAMSIZ]; |
| progname = argv[0]; |
| char buf[2048]; |
| bool resp = false; |
| TCMD_CONT_TX *txCmd = (TCMD_CONT_TX *) buf; |
| TCMD_CONT_RX *rxCmd = (TCMD_CONT_RX *) buf; |
| TCMD_PM *pmCmd = (TCMD_PM *) buf; |
| TCMD_SET_REG *setRegCmd = (TCMD_SET_REG *)buf; |
| TC_CMDS *tCmds = (TC_CMDS *)buf; |
| char efuseBuf[VENUS_OTP_SIZE]; |
| char efuseWriteBuf[VENUS_OTP_SIZE]; |
| int bufferLength = sizeof(*txCmd); |
| |
| txCmd->numPackets = 0; |
| txCmd->wlanMode = TCMD_WLAN_MODE_NOHT; |
| txCmd->tpcm = TPC_TX_PWR; |
| rxCmd->u.para.wlanMode = TCMD_WLAN_MODE_NOHT; |
| rxCmd->u.para.freq = 2412; |
| |
| if (argc == 1) { |
| usage(); |
| } |
| |
| /* Log The Start time */ |
| startTime = time(NULL); |
| |
| while (1) { |
| int option_index = 0; |
| |
| static struct option long_options[] = { |
| {"version", 0, NULL, 'v'}, |
| {"interface", 1, NULL, 'i'}, |
| {"tx", 1, NULL, 't'}, |
| {"txfreq", 1, NULL, 'f'}, |
| {"txrate", 1, NULL, 'g'}, |
| {"txpwr", 1, NULL, 'h'}, |
| {"tgtpwr", 0, NULL, 'H'}, |
| {"pcdac", 1, NULL, 'I'}, |
| {"txantenna", 1, NULL, 'j'}, |
| {"txpktsz", 1, NULL, 'z'}, |
| {"txpattern", 1, NULL, 'e'}, |
| {"rx", 1, NULL, 'r'}, |
| {"rxfreq", 1, NULL, 'p'}, |
| {"rxantenna", 1, NULL, 'q'}, |
| {"pm", 1, NULL, 'x'}, |
| {"setmac", 1, NULL, 's'}, |
| {"getmac", 0, NULL, 'C'}, |
| {"ani", 0, NULL, 'a'}, |
| {"scrambleroff", 0, NULL, 'o'}, |
| {"aifsn", 1, NULL, 'u'}, |
| {"SetAntSwitchTable", 1, NULL, 'S'}, |
| {"shortguard", 0, NULL, 'G'}, |
| {"numpackets", 1, NULL, 'n'}, |
| {"mode", 1, NULL, 'M'}, |
| {"setlongpreamble", 1, NULL, 'l'}, |
| {"setreg", 1, NULL, 'R'}, |
| {"regval", 1, NULL, 'V'}, |
| {"flag", 1, NULL, 'F'}, |
| {"writeotp", 0, NULL, 'w'}, |
| {"otpregdmn", 1, NULL, 'E'}, |
| {"efusedump", 0, NULL, 'm'}, |
| {"efusewrite", 0, NULL, 'W'}, |
| {"start", 1, NULL, 'A'}, |
| {"end", 1, NULL, 'L'}, |
| {"data", 1, NULL, 'U'}, |
| {"otpwrite", 0, NULL, 'O'}, |
| {"otpdump", 0, NULL, 'P'}, |
| {"btaddr", 1, NULL, 'B'}, |
| {"therm", 0, NULL, 'c'}, |
| {"selfInit", 0, NULL, TCMD_PSAT_CAL}, |
| {"selfInit_result", 0, NULL, TCMD_PSAT_CAL_RESULT}, |
| {"psat_char", 1, NULL, TCMD_CHAR_PSAT}, |
| {"psat_char_result", 0, NULL, TCMD_CHAR_PSAT_RESULT}, |
| {"sinit", 0, NULL, TCMD_SINIT_WAIT}, |
| {0, 0, 0, 0} |
| }; |
| |
| c = getopt_long(argc, argv, "vi:t:f:g:h:HI:r:p:q:x:u:ao:M:A:L:mU:WOP", |
| long_options, &option_index); |
| |
| if (c == -1) |
| break; |
| |
| switch (c) { |
| case 'i': |
| memset(ifname, '\0', 8); |
| strcpy(ifname, optarg); |
| break; |
| case 't': |
| cmd = TESTMODE_CONT_TX; |
| txCmd->testCmdId = TCMD_CONT_TX_ID; |
| if (!strcmp(optarg, "sine")) { |
| txCmd->mode = TCMD_CONT_TX_SINE; |
| } else if (!strcmp(optarg, "offset")) { |
| txCmd->mode = TCMD_CONT_TX_OFFSETTONE; |
| } else if (!strcmp(optarg, "frame")) { |
| txCmd->mode = TCMD_CONT_TX_FRAME; |
| } else if (!strcmp(optarg, "tx99")) { |
| txCmd->mode = TCMD_CONT_TX_TX99; |
| } else if (!strcmp(optarg, "tx100")) { |
| txCmd->mode = TCMD_CONT_TX_TX100; |
| } else if (!strcmp(optarg, "off")) { |
| txCmd->mode = TCMD_CONT_TX_OFF; |
| }else { |
| cmd = 0; |
| } |
| break; |
| case 'f': |
| if (TESTMODE_CMDS == cmd) { |
| uint32_t freq = freqValid(atoi(optarg)); |
| uint8_t freqBin; |
| // TBD: temporarily borrow the length's high B for freq |
| if (freq < 4900) { |
| freqBin = FREQ2FBIN(atoi(optarg), 1); |
| } |
| else { |
| freqBin = FREQ2FBIN(atoi(optarg), 0); |
| } |
| tCmds->hdr.u.parm.length &= 0x00ff; |
| tCmds->hdr.u.parm.length |= (freqBin << 8) & 0xff00; |
| } |
| else { |
| txCmd->freq = freqValid(atoi(optarg)); |
| } |
| break; |
| case 'G': |
| txCmd->shortGuard = 1; |
| break; |
| case 'M': |
| if(cmd == TESTMODE_CONT_TX) { |
| if (!strcmp(optarg, "ht20")) { |
| txCmd->wlanMode = TCMD_WLAN_MODE_HT20; |
| } else if (!strcmp(optarg, "ht40plus")) { |
| txCmd->wlanMode = TCMD_WLAN_MODE_HT40PLUS; |
| } else if (!strcmp(optarg, "ht40minus")) { |
| txCmd->wlanMode = TCMD_WLAN_MODE_HT40MINUS; |
| } |
| } else if(cmd == TESTMODE_CONT_RX) { |
| if (!strcmp(optarg, "ht20")) { |
| rxCmd->u.para.wlanMode = TCMD_WLAN_MODE_HT20; |
| } else if (!strcmp(optarg, "ht40plus")) { |
| rxCmd->u.para.wlanMode = TCMD_WLAN_MODE_HT40PLUS; |
| } else if (!strcmp(optarg, "ht40minus")) { |
| rxCmd->u.para.wlanMode = TCMD_WLAN_MODE_HT40MINUS; |
| } |
| } |
| break; |
| case 'n': |
| txCmd->numPackets = atoi(optarg); |
| break; |
| case 'g': |
| /* let user input index of rateTable instead of string parse */ |
| txCmd->dataRate = rateValid(atoi(optarg), txCmd->freq); |
| break; |
| case 'h': |
| { |
| int txPowerAsInt; |
| /* Get tx power from user. This is given in the form of a number |
| * that's supposed to be either an integer, or an integer + 0.5 |
| */ |
| double txPowerIndBm = atof(optarg); |
| |
| /* |
| * Check to make sure that the number given is either an integer |
| * or an integer + 0.5 |
| */ |
| txPowerAsInt = (int)txPowerIndBm; |
| if (((txPowerIndBm - (double)txPowerAsInt) == 0) || |
| (((txPowerIndBm - (double)txPowerAsInt)) == 0.5) || |
| (((txPowerIndBm - (double)txPowerAsInt)) == -0.5)) { |
| if ((txCmd->mode != TCMD_CONT_TX_SINE) && (txCmd->mode != TCMD_CONT_TX_OFFSETTONE)) { |
| txCmd->txPwr = txPowerIndBm * 2; |
| } else { |
| txCmd->txPwr = txPowerIndBm; |
| } |
| } else { |
| printf("Bad argument to --txpwr, must be in steps of 0.5 dBm\n"); |
| cmd = 0; |
| } |
| |
| txCmd->tpcm = TPC_TX_PWR; |
| } |
| break; |
| case 'H': |
| txCmd->tpcm = TPC_TGT_PWR; |
| break; |
| case 'I': |
| txCmd->tpcm = TPC_FORCED_GAIN; |
| txCmd->txPwr = atof(optarg); |
| break; |
| case 'j': |
| txCmd->antenna = antValid(atoi(optarg)); |
| break; |
| case 'z': |
| txCmd->pktSz = pktSzValid(atoi(optarg)); |
| break; |
| case 'e': |
| txCmd->txPattern = atoi(optarg); |
| break; |
| case 'r': |
| cmd = TESTMODE_CONT_RX; |
| rxCmd->testCmdId = TCMD_CONT_RX_ID; |
| if (!strcmp(optarg, "promis")) { |
| rxCmd->act = TCMD_CONT_RX_PROMIS; |
| printf(" Its cont Rx promis mode \n"); |
| } else if (!strcmp(optarg, "filter")) { |
| rxCmd->act = TCMD_CONT_RX_FILTER; |
| printf(" Its cont Rx filter mode \n"); |
| } else if (!strcmp(optarg, "report")) { |
| printf(" Its cont Rx report mode \n"); |
| rxCmd->act = TCMD_CONT_RX_REPORT; |
| resp = true; |
| } else { |
| cmd = 0; |
| } |
| break; |
| case 'p': |
| rxCmd->u.para.freq = freqValid(atoi(optarg)); |
| break; |
| case 'q': |
| rxCmd->u.para.antenna = antValid(atoi(optarg)); |
| break; |
| case 'x': |
| cmd = TESTMODE_PM; |
| pmCmd->testCmdId = TCMD_PM_ID; |
| if (!strcmp(optarg, "wakeup")) { |
| pmCmd->mode = TCMD_PM_WAKEUP; |
| } else if (!strcmp(optarg, "sleep")) { |
| pmCmd->mode = TCMD_PM_SLEEP; |
| } else if (!strcmp(optarg, "deepsleep")) { |
| pmCmd->mode = TCMD_PM_DEEPSLEEP; |
| } else { |
| cmd = 0; |
| } |
| break; |
| case 's': |
| { |
| uint8_t mac[ATH_MAC_LEN]; |
| |
| cmd = TESTMODE_CONT_RX; |
| rxCmd->testCmdId = TCMD_CONT_RX_ID; |
| rxCmd->act = TCMD_CONT_RX_SETMAC; |
| if (ath_ether_aton(optarg, mac) != 0) { |
| printf("Invalid mac address format! \n"); |
| } |
| memcpy(rxCmd->u.mac.addr, mac, ATH_MAC_LEN); |
| printf("JLU: tcmd: setmac 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x\n", |
| mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); |
| break; |
| } |
| case 'C': |
| cmd = TESTMODE_CONT_RX; |
| rxCmd->testCmdId = TCMD_CONT_RX_ID; |
| act = rxCmd->act = TCMD_CONT_RX_GETMAC; |
| resp = true; |
| break; |
| case 'u': |
| { |
| txCmd->aifsn = atoi(optarg) & 0xff; |
| printf("AIFS:%d\n", txCmd->aifsn); |
| } |
| break; |
| case 'a': |
| if(cmd == TESTMODE_CONT_TX) { |
| txCmd->enANI = true; |
| } else if(cmd == TESTMODE_CONT_RX) { |
| rxCmd->enANI = true; |
| } |
| break; |
| case 'o': |
| txCmd->scramblerOff = true; |
| break; |
| case 'S': |
| if (argc < 4) |
| usage(); |
| cmd = TESTMODE_CONT_RX; |
| rxCmd->testCmdId = TCMD_CONT_RX_ID; |
| rxCmd->act = TCMD_CONT_RX_SET_ANT_SWITCH_TABLE; |
| rxCmd->u.antswitchtable.antswitch1 = strtoul(argv[2], (char **)NULL,0); |
| rxCmd->u.antswitchtable.antswitch2 = strtoul(argv[3], (char **)NULL,0); |
| break; |
| case 'l': |
| printf("Not supported\n"); |
| return 0; |
| break; |
| case 'R': |
| if (argc < 5) { |
| printf("usage:athtestcmd -i wlan0 --setreg 0x1234 --regval 0x01 --flag 0\n"); |
| } |
| cmd = TESTMODE_SETREG; |
| setRegCmd->testCmdId = TCMD_SET_REG_ID; |
| setRegCmd->regAddr = strtoul(optarg, (char **)NULL, 0);//atoi(optarg); |
| break; |
| case 'V': |
| setRegCmd->val = strtoul(optarg, (char **)NULL, 0); |
| break; |
| case 'F': |
| setRegCmd->flag = atoi(optarg); |
| break; |
| case 'w': |
| rxCmd->u.mac.otpWriteFlag = 1; |
| break; |
| case 'E': |
| rxCmd->u.mac.regDmn[0] = 0xffff&(strtoul(optarg, (char **)NULL, 0)); |
| rxCmd->u.mac.regDmn[1] = 0xffff&(strtoul(optarg, (char **)NULL, 0)>>16); |
| break; |
| case 'B': |
| { |
| uint8_t btaddr[ATH_MAC_LEN]; |
| if (ath_ether_aton(optarg, btaddr) != 0) { |
| printf("Invalid mac address format! \n"); |
| } |
| memcpy(rxCmd->u.mac.btaddr, btaddr, ATH_MAC_LEN); |
| printf("JLU: tcmd: setbtaddr 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x\n", |
| btaddr[0], btaddr[1], btaddr[2], btaddr[3], btaddr[4], btaddr[5]); |
| } |
| break; |
| case 'c': |
| cmd = TESTMODE_CMDS; |
| tCmds->hdr.testCmdId = TC_CMDS_ID; |
| { |
| tCmds->hdr.u.parm.length = 0; |
| tCmds->hdr.u.parm.version = TC_CMDS_VERSION_TS; |
| act = tCmds->hdr.act = TC_CMDS_READTHERMAL;//TC_CMDS_CAL_THERMALVOLT; |
| resp = true; |
| } |
| break; |
| case 'A': |
| efuse_begin = atoi(optarg); |
| break; |
| |
| case 'L': |
| efuse_end = atoi(optarg); |
| break; |
| |
| case 'U': |
| { |
| uint8_t* pucArg = (uint8_t*)optarg; |
| uint8_t c; |
| uint8_t strBuf[256]; |
| uint8_t pos = 0; |
| uint16_t length = 0; |
| uint32_t data; |
| |
| /* Sweep string to end */ |
| while (1) { |
| c = *pucArg++; |
| if (isHex(c)) { |
| strBuf[pos++] = c; |
| } else { |
| strBuf[pos] = '\0'; |
| pos = 0; |
| sscanf(((char *)&strBuf), "%x", &data); |
| efuseWriteBuf[length++] = (data & 0xFF); |
| |
| /* End of arg string */ |
| if (c == '\0') { |
| break; |
| } |
| } |
| } |
| |
| data_length = length; |
| } |
| break; |
| |
| case 'm': |
| cmd = TESTMODE_CMDS; |
| tCmds->hdr.testCmdId = TC_CMDS_ID; |
| act = tCmds->hdr.act = TC_CMDS_EFUSEDUMP; |
| resp = true; |
| break; |
| |
| case 'W': |
| cmd = TESTMODE_CMDS; |
| tCmds->hdr.testCmdId = TC_CMDS_ID; |
| act = tCmds->hdr.act = TC_CMDS_EFUSEWRITE; |
| resp = true; |
| break; |
| |
| case 'O': |
| cmd = TESTMODE_CMDS; |
| tCmds->hdr.testCmdId = TC_CMDS_ID; |
| act = tCmds->hdr.act = TC_CMDS_OTPSTREAMWRITE; |
| resp = true; |
| break; |
| |
| case 'P': |
| cmd = TESTMODE_CMDS; |
| tCmds->hdr.testCmdId = TC_CMDS_ID; |
| act = tCmds->hdr.act = TC_CMDS_OTPDUMP; |
| resp = true; |
| break; |
| |
| case TCMD_PSAT_CAL: |
| cmd = TESTMODE_CMDS; |
| tCmds->hdr.testCmdId = TC_CMDS_ID; |
| tCmds->hdr.u.parm.length = 0; |
| tCmds->hdr.u.parm.version = TC_CMDS_VERSION_TS; |
| tCmds->hdr.act = TC_CMDS_PSAT_CAL; |
| resp = true; |
| break; |
| |
| case TCMD_SINIT_WAIT: |
| cmd = TESTMODE_CMDS; |
| tCmds->hdr.testCmdId = TC_CMDS_ID; |
| tCmds->hdr.u.parm.length = (uint16_t)0; |
| tCmds->hdr.u.parm.version = TC_CMDS_VERSION_TS; |
| tCmds->hdr.act = TC_CMDS_SINIT_WAIT; |
| resp = true; |
| break; |
| |
| case TCMD_PSAT_CAL_RESULT: |
| cmd = TESTMODE_CMDS; |
| tCmds->hdr.testCmdId = TC_CMDS_ID; |
| { |
| tCmds->hdr.u.parm.length = 0; |
| tCmds->hdr.u.parm.version = TC_CMDS_VERSION_TS; |
| tCmds->hdr.act = TC_CMDS_PSAT_CAL_RESULT; |
| } |
| resp = true; |
| bCalResult = false; |
| break; |
| |
| case TCMD_CHAR_PSAT: |
| cmd = TESTMODE_CMDS; |
| tCmds->hdr.testCmdId = TC_CMDS_ID; |
| { |
| tCmds->hdr.u.parm.length = 0; |
| tCmds->hdr.u.parm.version = TC_CMDS_VERSION_TS; |
| tCmds->hdr.act = TC_CMDS_CHAR_PSAT; |
| } |
| // TBD: temporarily borrow the length's lower B for sweep entry |
| tCmds->hdr.u.parm.length &= 0xff00; |
| tCmds->hdr.u.parm.length |= (atoi(optarg)) & 0xff; |
| printf("optarg %s %d\n", optarg, tCmds->hdr.u.parm.length ); |
| |
| break; |
| |
| case TCMD_CHAR_PSAT_RESULT: |
| cmd = TESTMODE_CMDS; |
| tCmds->hdr.testCmdId = TC_CMDS_ID; |
| { |
| tCmds->hdr.u.parm.length = NUM_PSAT_CHAR_PARMS; |
| tCmds->hdr.u.parm.version = TC_CMDS_VERSION_TS; |
| tCmds->hdr.act = TC_CMDS_CHAR_PSAT_RESULT; |
| } |
| resp = true; |
| break; |
| |
| default: |
| usage(); |
| } |
| } |
| |
| if ( cmd == TESTMODE_CMDS ) |
| { |
| if ( tCmds->hdr.act == TC_CMDS_EFUSEWRITE ) |
| { |
| int i; |
| /* Error check */ |
| if (data_length == 0) { |
| printf("No data to write, exit..\n"); |
| return 0; |
| } else if ((efuse_begin + data_length + 4) > TC_CMDS_SIZE_MAX) { |
| printf("Exceed eFuse border: %d, exit..\n", (TC_CMDS_SIZE_MAX - 1)); |
| return 0; |
| } |
| |
| /* PRINT */ |
| printf("eFuse data (%d Bytes): ", data_length); |
| for (i = 0; i < data_length; i++) { |
| printf("%02X ", efuseWriteBuf[i]); |
| } |
| printf("\n"); |
| |
| /* Write address and data length */ |
| tCmds->buf[0] = (efuse_begin & 0xFF); |
| tCmds->buf[1] = (efuse_begin >> 8) & 0xFF; |
| tCmds->buf[2] = (data_length & 0xFF); |
| tCmds->buf[3] = (data_length >> 8) & 0xFF; |
| |
| /* Copy data to tcmd buffer. The first 4 bytes are the ID and length */ |
| memcpy((void*)&(tCmds->buf[4]), (void*)&(efuseWriteBuf[0]), data_length); |
| |
| /* Construct eFuse Write */ |
| tCmds->hdr.u.parm.length = (4 + data_length); |
| tCmds->hdr.u.parm.version = TC_CMDS_VERSION_TS; |
| } |
| else if ( tCmds->hdr.act == TC_CMDS_OTPSTREAMWRITE ) |
| { |
| int i; |
| |
| /* Error check */ |
| if (data_length == 0) { |
| printf("No data to write, exit..\n"); |
| return 0; |
| } else if ((data_length + 4) > TC_CMDS_SIZE_MAX) { |
| printf("Exceed OTP size: %d, exit..\n", data_length); |
| return 0; |
| } |
| |
| /* PRINT */ |
| printf("Write OTP data (%d Bytes): ", data_length); |
| for (i = 0; i < data_length; i++) { |
| printf("%02X ", efuseWriteBuf[i]); |
| } |
| printf("\n"); |
| |
| /* Copy data to tcmd buffer. The first 4 bytes are the ID and length */ |
| memcpy((void*)&(tCmds->buf[0]), (void*)&(efuseWriteBuf[0]), data_length); |
| |
| /* Construct eFuse Write */ |
| tCmds->hdr.u.parm.length = data_length; |
| tCmds->hdr.u.parm.version = TC_CMDS_VERSION_TS; |
| } |
| else if ( tCmds->hdr.act == TC_CMDS_OTPDUMP ) |
| { |
| tCmds->hdr.u.parm.length = 0; |
| tCmds->hdr.u.parm.version = TC_CMDS_VERSION_TS; |
| } |
| else if ( tCmds->hdr.act == TC_CMDS_CHAR_PSAT ) |
| { |
| uint32_t ii = tCmds->hdr.u.parm.length & 0xff; |
| uint8_t freq= (uint8_t)((tCmds->hdr.u.parm.length >> 8) & 0xff); |
| tCmds->hdr.u.parm.length = NUM_PSAT_CHAR_PARMS; |
| tCmds->buf[0] = psatSweepTbl[ii].an_txrf3_rdiv2g; |
| tCmds->buf[1] = psatSweepTbl[ii].an_txrf3_pdpredist2g; |
| tCmds->buf[2] = psatSweepTbl[ii].an_rxtx2_mxrgain; |
| tCmds->buf[3] = psatSweepTbl[ii].an_rxrf_bias1_pwd_ic25mxr2gh; |
| tCmds->buf[4] = psatSweepTbl[ii].an_bias2_pwd_ic25rxrf; |
| tCmds->buf[5] = psatSweepTbl[ii].an_bb1_i2v_curr2x; |
| tCmds->buf[6] = psatSweepTbl[ii].an_txrf3_capdiv2g; |
| tCmds->buf[7] = freq; |
| printf("freq %d %d %d %d %d %d %d %d\n", tCmds->buf[7], tCmds->buf[0], tCmds->buf[1], tCmds->buf[2], tCmds->buf[3],tCmds->buf[4], tCmds->buf[5], tCmds->buf[6]); |
| } |
| } |
| |
| /* default bufferLength = sizeof(*txCmd)*/ |
| if ( cmd == TESTMODE_CONT_TX ) |
| { |
| bufferLength = sizeof(*txCmd); |
| } |
| else if ( cmd == TESTMODE_CONT_RX ) |
| { |
| bufferLength = sizeof(*rxCmd); |
| } |
| else if ( cmd == TESTMODE_PM ) |
| { |
| bufferLength = sizeof(*pmCmd); |
| } |
| else if ( cmd == TESTMODE_SETREG) |
| { |
| bufferLength = sizeof(*setRegCmd); |
| } |
| else if ( cmd == TESTMODE_CMDS ) |
| { |
| bufferLength = sizeof(*tCmds); |
| } |
| |
| printf("Cmd %d length %d respNeeded %d\n",cmd,bufferLength,resp); |
| |
| err = tcmd_tx_init(ATH6KL_INTERFACE, rx_cb); |
| |
| if (err) |
| return err; |
| |
| if ( (cmd == TESTMODE_CMDS) && (tCmds->hdr.act == TC_CMDS_EFUSEDUMP) ) |
| { |
| int i, k; |
| int blkNum; |
| uint16_t efuseEnd = efuse_end; |
| uint16_t efuseBegin = efuse_begin; |
| uint16_t efusePrintAnkor; |
| uint16_t numPlaceHolder; |
| |
| /* Input check */ |
| if (efuseEnd > (VENUS_OTP_SIZE - 1)) { |
| efuseEnd = (VENUS_OTP_SIZE - 1); |
| } |
| |
| if (efuseBegin > efuseEnd) { |
| efuseBegin = efuseEnd; |
| } |
| |
| efusePrintAnkor = efuseBegin; |
| |
| blkNum = ((efuseEnd - efuseBegin) / TC_CMDS_SIZE_MAX) + 1; |
| |
| /* Request data in several trys */ |
| for (i = 0; i < blkNum; i++) { |
| tCmds->hdr.testCmdId = TC_CMDS_ID; |
| tCmds->hdr.act = TC_CMDS_EFUSEDUMP; |
| tCmds->hdr.u.parm.length = 4; |
| tCmds->hdr.u.parm.version = TC_CMDS_VERSION_TS; |
| |
| tCmds->buf[0] = (efuseBegin & 0xFF); |
| tCmds->buf[1] = (efuseBegin >> 8) & 0xFF; |
| tCmds->buf[2] = (efuseEnd & 0xFF); |
| tCmds->buf[3] = (efuseEnd >> 8) & 0xFF; |
| |
| /* This field may get polluted so needs a refresh here */ |
| tCmds->hdr.u.parm.bufLen = 4; |
| |
| if ((err = tcmd_tx(buf, bufferLength /* weak */, resp))) { |
| fprintf(stderr, "tcmd_tx had error: %s!\n", strerror(-err)); |
| return 0; |
| } |
| |
| /* Last block? */ |
| //sTcCmds populated in the callback.. |
| if ((efuseEnd - efuseBegin + 1) < TC_CMDS_SIZE_MAX) { |
| memcpy((void*)(efuseBuf + efuseBegin), (void*)&(sTcCmds.buf[0]), (efuseEnd - efuseBegin + 1)); |
| } else { |
| memcpy((void*)(efuseBuf + efuseBegin), (void*)&(sTcCmds.buf[0]), TC_CMDS_SIZE_MAX); |
| } |
| |
| /* Adjust the efuseBegin but keep efuseEnd unchanged */ |
| efuseBegin += TC_CMDS_SIZE_MAX; |
| } |
| |
| /* Output Dump */ |
| printf("------------------- eFuse Dump ----------------------"); |
| for (i = efusePrintAnkor; i <= efuseEnd; i++) { |
| /* Cosmetics */ |
| if (i == efusePrintAnkor) { |
| numPlaceHolder = (efusePrintAnkor & 0x0F); |
| printf("\n%04X:", (efusePrintAnkor & 0xFFF0)); |
| for (k = 0; k < numPlaceHolder; k++) { |
| printf(" "); |
| } |
| } else if ((i & 0x0F) == 0) { |
| printf("\n%04X:", i); |
| } |
| |
| printf(" %02X", efuseBuf[i]); |
| } |
| printf("\n\n"); |
| } |
| else if ( (cmd == TESTMODE_CMDS) && (tCmds->hdr.act == TC_CMDS_SINIT_WAIT) ) |
| { |
| if ((err = tcmd_tx(buf, bufferLength /* weak */, resp))) { |
| fprintf(stderr, "tcmd_tx had error: %s!\n", strerror(-err)); |
| return 0; |
| } |
| |
| sleep(FIRST_WAIT_INTERVAL); /* Wait 2s first */ |
| |
| /* Request data in several trys */ |
| for (i = 0; i < MAX_WAIT_CYCLE; i++) { |
| tCmds->hdr.testCmdId = TC_CMDS_ID; |
| tCmds->hdr.u.parm.length = (uint16_t)0; |
| tCmds->hdr.u.parm.version = TC_CMDS_VERSION_TS; |
| tCmds->hdr.act = TC_CMDS_PSAT_CAL_RESULT; |
| resp = true; |
| bCalResult = false; |
| |
| if ((err = tcmd_tx(buf, bufferLength /* weak */, resp))) { |
| /*don't let main return bcs the reply may not be ready. Try again.*/ |
| /*fprintf(stderr, "tcmd_tx had error: %s!\n", strerror(-err));*/ |
| /*return 0;*/ |
| } |
| if (!bCalResult) { |
| sleep(POLLING_INTERVAL); |
| printf("."); |
| } else { |
| endTime = time(NULL); |
| printf("Wait time = %ld(s)\n", (endTime - startTime)); |
| break; |
| } |
| } |
| } |
| else |
| { |
| if ((err = tcmd_tx(buf, bufferLength /* weak */, resp))) { |
| fprintf(stderr, "tcmd_tx had error: %s!\n", strerror(-err)); |
| } |
| } |
| |
| return 0; |
| } |
| |
| static void rxReport(void *buf) |
| { |
| struct TCMD_CONT_RX_REPORT *report = &((TCMD_CONT_RX *) buf)->u.report; |
| uint32_t pkt = report->totalPkt; |
| int32_t rssi = report->rssiInDBm; |
| uint32_t crcError = report->crcErrPkt; |
| uint32_t secErr = report->secErrPkt; |
| uint16_t *rateCnt = report->rateCnt; |
| uint16_t *rateCntShortGuard = report->rateCntShortGuard; |
| |
| printf |
| ("total pkt %d ; crcError pkt %d ; secErr pkt %d ; average rssi %d\n", |
| pkt, crcError, secErr, |
| (int32_t) (pkt ? (rssi / (int32_t) pkt) : 0)); |
| |
| printf("1Mbps %d\n", rateCnt[0]); |
| printf("2Mbps %d\n", rateCnt[1]); |
| printf("5.5Mbps %d\n", rateCnt[2]); |
| printf("11Mbps %d\n", rateCnt[3]); |
| printf("6Mbps %d\n", rateCnt[4]); |
| printf("9Mbps %d\n", rateCnt[5]); |
| printf("12Mbps %d\n", rateCnt[6]); |
| printf("18Mbps %d\n", rateCnt[7]); |
| printf("24Mbps %d\n", rateCnt[8]); |
| printf("36Mbps %d\n", rateCnt[9]); |
| printf("48Mbps %d\n", rateCnt[10]); |
| printf("54Mbps %d\n", rateCnt[11]); |
| printf("\n"); |
| printf("HT20 MCS0 6.5Mbps %d (SGI: %d)\n", rateCnt[12], |
| rateCntShortGuard[12]); |
| printf("HT20 MCS1 13Mbps %d (SGI: %d)\n", rateCnt[13], |
| rateCntShortGuard[13]); |
| printf("HT20 MCS2 19.5Mbps %d (SGI: %d)\n", rateCnt[14], |
| rateCntShortGuard[14]); |
| printf("HT20 MCS3 26Mbps %d (SGI: %d)\n", rateCnt[15], |
| rateCntShortGuard[15]); |
| printf("HT20 MCS4 39Mbps %d (SGI: %d)\n", rateCnt[16], |
| rateCntShortGuard[16]); |
| printf("HT20 MCS5 52Mbps %d (SGI: %d)\n", rateCnt[17], |
| rateCntShortGuard[17]); |
| printf("HT20 MCS6 58.5Mbps %d (SGI: %d)\n", rateCnt[18], |
| rateCntShortGuard[18]); |
| printf("HT20 MCS7 65Mbps %d (SGI: %d)\n", rateCnt[19], |
| rateCntShortGuard[19]); |
| printf("\n"); |
| printf("HT40 MCS0 13.5Mbps %d (SGI: %d)\n", rateCnt[20], |
| rateCntShortGuard[20]); |
| printf("HT40 MCS1 27.0Mbps %d (SGI: %d)\n", rateCnt[21], |
| rateCntShortGuard[21]); |
| printf("HT40 MCS2 40.5Mbps %d (SGI: %d)\n", rateCnt[22], |
| rateCntShortGuard[22]); |
| printf("HT40 MCS3 54Mbps %d (SGI: %d)\n", rateCnt[23], |
| rateCntShortGuard[23]); |
| printf("HT40 MCS4 81Mbps %d (SGI: %d)\n", rateCnt[24], |
| rateCntShortGuard[24]); |
| printf("HT40 MCS5 108Mbps %d (SGI: %d)\n", rateCnt[25], |
| rateCntShortGuard[25]); |
| printf("HT40 MCS6 121.5Mbps %d (SGI: %d)\n", rateCnt[26], |
| rateCntShortGuard[26]); |
| printf("HT40 MCS7 135Mbps %d (SGI: %d)\n", rateCnt[27], |
| rateCntShortGuard[27]); |
| |
| } |
| |
| static void readThermal(void *buf,int len) |
| { |
| TC_CMDS *tCmd; |
| |
| tCmd = (TC_CMDS *)buf; |
| |
| printf("Length rx cb rcvd %d\n",len); |
| printf("act %d version %d length %d\n",tCmd->hdr.act,tCmd->hdr.u.parm.version,tCmd->hdr.u.parm.length); |
| printf("chip thermal value:%d\n", tCmd->buf[0]); |
| return; |
| } |
| |
| static void getMac(void *buf,int len) |
| { |
| TC_CMDS *tCmd; |
| |
| tCmd = (TC_CMDS *)buf; |
| |
| printf("Length rx cb rcvd %d\n",len); |
| printf("act %d version %d length %d\n",tCmd->hdr.act,tCmd->hdr.u.parm.version,tCmd->hdr.u.parm.length); |
| printf("MAC address : %02x:%02x:%02x:%02x:%02x:%02x\n", tCmd->buf[0], tCmd->buf[1], tCmd->buf[2], tCmd->buf[3], tCmd->buf[4], tCmd->buf[5]); |
| return; |
| } |
| |
| static void cmdReply(void *buf, int len) |
| { |
| TC_CMDS tCmdReply; |
| TC_MSG *pTCMsg; |
| uint32_t act; |
| uint16_t wBytes; |
| int i=0; |
| |
| printf("Length rx cb rcvd %d\n",len); |
| |
| buf = (void*)((uint8_t*)buf + (2 * sizeof(unsigned int))); |
| |
| uint8_t *reply = (uint8_t*)buf; |
| |
| tCmdReply.hdr.u.parm.length = *(uint16_t *)&(reply[0]); |
| tCmdReply.hdr.u.parm.version = (uint8_t)(reply[2]); |
| act = tCmdReply.hdr.u.parm.version; |
| pTCMsg = (TC_MSG *)&(tCmdReply.buf[0]); |
| |
| /* Error Check */ |
| if (tCmdReply.hdr.u.parm.length > (TC_CMDS_SIZE_MAX + 1)) { |
| printf("Error: Reply lenth=%d, limit=%d\n", tCmdReply.hdr.u.parm.length, TC_CMDS_SIZE_MAX); |
| return; |
| } else { |
| ; |
| } |
| |
| if (tCmdReply.hdr.u.parm.length > 0) { |
| memcpy((void*)&(tCmdReply.buf), (void*)((uint8_t*)buf+4), tCmdReply.hdr.u.parm.length); |
| memcpy((void*)&(sTcCmds.buf[0]), (void*)&(tCmdReply.buf[0]), tCmdReply.hdr.u.parm.length); |
| sTcCmds.hdr.u.parm.length = tCmdReply.hdr.u.parm.length; |
| } |
| |
| switch (act) { |
| case TC_CMDS_EFUSEDUMP: |
| printf("eFuse data:\n"); |
| break; |
| case TC_CMDS_EFUSEWRITE: |
| printf("(write eFuse data)\n"); |
| wBytes = ((sTcCmds.buf[1] << 8) | sTcCmds.buf[0]); |
| printf("%d bytes written to eFuse.\n", wBytes); |
| break; |
| case TC_CMDS_OTPSTREAMWRITE: |
| printf("(OTP stream write)\n"); |
| |
| if (sTcCmds.buf[0] == A_OK) { |
| printf("Write %d bytes to OTP\n", data_length); |
| } else { |
| printf("Failed to write OTP\n"); |
| } |
| break; |
| case TC_CMDS_OTPDUMP: |
| printf("OTP Dump\n"); |
| if (sTcCmds.hdr.u.parm.length) { |
| /* Received bytes are in sTcCmds */ |
| for (i = 0; i < sTcCmds.hdr.u.parm.length; i++) { |
| printf("%02x ", sTcCmds.buf[i]); |
| } |
| printf("\n"); |
| } else { |
| printf("No valid stream found in OTP!\n"); |
| } |
| break; |
| case TC_CMDS_PSAT_CAL: |
| break; |
| case TC_CMDS_SINIT_WAIT: |
| if (TC_MSG_PSAT_CAL_ACK == (TC_MSG_ID)pTCMsg->msgId) { |
| printf("ACK Received.\n"); |
| } |
| break; |
| case TC_CMDS_PSAT_CAL_RESULT: |
| if (TC_MSG_PSAT_CAL_RESULTS == (TC_MSG_ID)pTCMsg->msgId) { |
| // update CAL data, read eeprom bin, re-generate eeprom bin |
| updateCALData(&calSetup, pTCMsg); |
| bCalResult = true; |
| } |
| break; |
| case TC_CMDS_CHAR_PSAT: |
| break; |
| case TC_CMDS_CHAR_PSAT_RESULT: |
| if (TC_MSG_CHAR_PSAT_RESULTS == (TC_MSG_ID)pTCMsg->msgId) { |
| dumpPSATCharResult2File(pTCMsg); |
| } |
| break; |
| default: |
| printf("Invalid action!\n"); |
| break; |
| } |
| } |
| |
| static void rx_cb(void *buf, int len) |
| { |
| TCMD_ID tcmd; |
| |
| if ( cmd == TESTMODE_CMDS ) |
| { |
| if ( act == TC_CMDS_READTHERMAL ) |
| { |
| readThermal(buf,len); |
| } |
| else |
| { |
| cmdReply(buf,len); |
| } |
| |
| return; |
| } |
| |
| if ( cmd == TESTMODE_CONT_RX ) |
| { |
| if ( act == TCMD_CONT_RX_GETMAC ) |
| { |
| getMac(buf, len); |
| } |
| } |
| |
| tcmd = * ((uint32_t *) buf + 1); |
| |
| switch (tcmd) { |
| case TCMD_CONT_RX_REPORT: |
| rxReport(buf); |
| break; |
| default: |
| break; |
| } |
| |
| } |
| |
| static uint32_t freqValid(uint32_t val) |
| { |
| do { |
| if (val <= A_CHAN_MAX) { |
| uint16_t freq; |
| |
| if (val < BG_CHAN_MIN) |
| break; |
| |
| freq = wmic_ieee2freq(val); |
| if (INVALID_FREQ == freq) |
| break; |
| else |
| return freq; |
| } |
| |
| if ((val == BG_FREQ_MAX) || |
| ((val < BG_FREQ_MAX) && (val >= BG_FREQ_MIN) |
| && !((val - BG_FREQ_MIN) % 5))) |
| return val; |
| else if ((val >= A_FREQ_MIN) && (val < A_20MHZ_BAND_FREQ_MAX) |
| && !((val - A_FREQ_MIN) % 20)) |
| return val; |
| else if ((val >= A_20MHZ_BAND_FREQ_MAX) && (val <= A_FREQ_MAX) |
| && !((val - A_20MHZ_BAND_FREQ_MAX) % 5)) |
| return val; |
| } while (false); |
| |
| A_ERR(-1, "Invalid channel or freq #: %d !\n", val); |
| return 0; |
| } |
| |
| static uint32_t rateValid(uint32_t val, uint32_t freq) |
| { |
| if (((freq >= A_FREQ_MIN) && (freq <= A_FREQ_MAX) |
| && (val >= A_RATE_NUM)) || ((freq >= BG_FREQ_MIN) |
| && (freq <= BG_FREQ_MAX) |
| && (val >= G_RATE_NUM))) { |
| printf("Invalid rate value %d for frequency %d! \n", val, freq); |
| prtRateTbl(freq); |
| A_ERR(-1, "Invalid rate value %d for frequency %d! \n", val, |
| freq); |
| } |
| |
| return val; |
| } |
| |
| static void prtRateTbl(uint32_t freq) |
| { |
| int i; |
| |
| for (i = 0; i < G_RATE_NUM; i++) { |
| printf("<rate> %d \t \t %s \n", i, bgRateStrTbl[i]); |
| } |
| printf("\n"); |
| } |
| |
| /* |
| * converts ieee channel number to frequency |
| */ |
| static uint16_t wmic_ieee2freq(uint32_t chan) |
| { |
| if (chan == BG_CHAN_MAX) { |
| return BG_FREQ_MAX; |
| } |
| if (chan < BG_CHAN_MAX) { /* 0-13 */ |
| return (BG_CHAN0_FREQ + (chan * 5)); |
| } |
| if (chan <= A_CHAN_MAX) { |
| return (A_CHAN0_FREQ + (chan * 5)); |
| } else { |
| return INVALID_FREQ; |
| } |
| } |
| |
| static uint32_t antValid(uint32_t val) |
| { |
| if (val > 2) { |
| A_ERR(-1, |
| "Invalid antenna setting! <0: auto; 1/2: ant 1/2>\n"); |
| } |
| |
| return val; |
| } |
| |
| static bool txPwrValid(TCMD_CONT_TX * txCmd) |
| { |
| bool rc = false; |
| if (txCmd->mode == TCMD_CONT_TX_SINE) { |
| if ((txCmd->txPwr >= 0) && (txCmd->txPwr <= 150)) |
| rc = true; |
| } else if (txCmd->mode == TCMD_CONT_TX_OFFSETTONE) { |
| if ((txCmd->txPwr >= 0) && (txCmd->txPwr <= 150)) |
| rc = true; |
| } else if (txCmd->mode != TCMD_CONT_TX_OFF) { |
| if (txCmd->tpcm != TPC_FORCED_GAIN) { |
| if ((txCmd->txPwr >= -30) && (txCmd->txPwr <= 60)) |
| rc = true; |
| } else { |
| if ((txCmd->txPwr >= 0) && (txCmd->txPwr <= 120)) |
| rc = true; |
| } |
| } else if (txCmd->mode == TCMD_CONT_TX_OFF) { |
| rc = true; |
| } |
| |
| if (!rc) |
| A_ERR(1, |
| "Invalid Tx Power value! \nTx data: [-15 - 14]dBm \nTx sine: [ 0 - 150]PCDAC value\n"); |
| return rc; |
| } |
| |
| static uint32_t pktSzValid(uint32_t val) |
| { |
| if ((val < 32) || (val > 1500)) { |
| A_ERR(-1, "Invalid package size! < 32 - 1500 >\n"); |
| } |
| return val; |
| } |
| |
| #ifdef NOTYET |
| |
| // Validate a hex character |
| static bool _is_hex(char c) |
| { |
| return (((c >= '0') && (c <= '9')) || |
| ((c >= 'A') && (c <= 'F')) || ((c >= 'a') && (c <= 'f'))); |
| } |
| |
| // Convert a single hex nibble |
| static int _from_hex(char c) |
| { |
| int ret = 0; |
| |
| if ((c >= '0') && (c <= '9')) { |
| ret = (c - '0'); |
| } else if ((c >= 'a') && (c <= 'f')) { |
| ret = (c - 'a' + 0x0a); |
| } else if ((c >= 'A') && (c <= 'F')) { |
| ret = (c - 'A' + 0x0A); |
| } |
| return ret; |
| } |
| |
| // Convert a character to lower case |
| static char _tolower(char c) |
| { |
| if ((c >= 'A') && (c <= 'Z')) { |
| c = (c - 'A') + 'a'; |
| } |
| return c; |
| } |
| |
| // Validate alpha |
| static bool isalpha(int c) |
| { |
| return (((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'))); |
| } |
| |
| // Validate digit |
| static bool isdigit(int c) |
| { |
| return ((c >= '0') && (c <= '9')); |
| } |
| |
| // Validate alphanum |
| static bool isalnum(int c) |
| { |
| return (isalpha(c) || isdigit(c)); |
| } |
| #endif |
| |
| /*------------------------------------------------------------------*/ |
| /* |
| * Input an Ethernet address and convert to binary. |
| */ |
| static int ath_ether_aton(const char *orig, uint8_t * eth) |
| { |
| int mac[6]; |
| if (sscanf(orig, "%02x:%02x:%02X:%02X:%02X:%02X", |
| &mac[0], &mac[1], &mac[2], &mac[3], &mac[4], &mac[5]) == 6) { |
| int i; |
| #ifdef DEBUG |
| if (*(orig + 12 + 5) != 0) { |
| fprintf(stderr, "%s: trailing junk '%s'!\n", __func__, |
| orig); |
| return -1; |
| } |
| #endif |
| for (i = 0; i < 6; ++i) |
| eth[i] = mac[i] & 0xff; |
| return 0; |
| } |
| return -1; |
| } |
| |
| // Read "golden" eeprom bin |
| // Update it with CAL data |
| |
| bool readCalDataFromFileBin(char *fileName, AR6003_EEPROM *eepromData) |
| { |
| FILE *fp; |
| bool rc=true; |
| uint32_t numBytes; |
| |
| printf("readCalDataFromFile - reading EEPROM file %s\n",fileName); |
| if( (fp = fopen(fileName, "rb")) == NULL) { |
| _printf("Could not open %s to read\n", fileName); |
| return false; |
| } |
| |
| if (AR6K_EEPROM_SIZE_LARGEST == (numBytes = fread((uint8_t *)eepromData, 1, AR6K_EEPROM_SIZE_LARGEST, fp))) { |
| printf("Read %d from %s\n", numBytes, fileName); |
| rc = true; |
| } |
| else { |
| if (feof(fp)) { |
| printf("good Read %d from %s\n", numBytes, fileName); |
| rc = true; |
| } |
| else if (ferror(fp)) { |
| _printf("Error reading %s\n", fileName); |
| rc = false; |
| } |
| else { _printf("Unknown fread rc\n"); rc = false; } |
| } |
| if (fp) fclose(fp); |
| |
| if (rc) { |
| if ((eepromData->baseEepHeader.version & AR6003_EEP_VER_MINOR_MASK) >= AR6003_EEP_MINOR_VER10) { |
| if (AR6K_EEPROM_SIZE_LARGEST != numBytes) { |
| printf("Num of bytes read %d mismatch expected %d\n", numBytes, AR6K_EEPROM_SIZE_LARGEST); |
| rc = false; |
| } |
| else { |
| AR6K_EEPROM_SIZE = AR6003_EEPROM_SIZE = AR6K_EEPROM_SIZE_LARGEST; |
| printf("New TPC scheme selected! %x %d\n", eepromData->baseEepHeader.version, AR6K_EEPROM_SIZE); |
| } |
| } |
| else { |
| _printf("EEPROM file version %d not supported, please re-calibrate it.\n", eepromData->baseEepHeader.version); |
| rc = false; |
| } |
| } |
| return rc; |
| } |
| |
| #define _PSAT_COMMON_4_HOST |
| |
| // if host doesn't support math.h, this section can be skipped, it is purely for data gathering |
| static double cmacPwr(double cmac) |
| { |
| double pwr; |
| double vfull=1.0, cycles = -15.0; |
| |
| pwr = 10*log10(4*((double)cmac)*((double)pow(2.0, cycles))*((double)pow(vfull/512, 2))); |
| return(pwr); |
| } |
| static bool dumpPSATCharResult2File(TC_MSG *pTCMsg) |
| { |
| FILE *dbgFp; |
| int i; |
| uint32_t cmac_i; |
| |
| #ifdef ANDROID |
| if ( (dbgFp = fopen("/persist/psatCharData.csv", "a+")) == NULL) { |
| printf("Error: open _psatCharData.csv\n"); |
| return(false); |
| } |
| #else |
| if ( (dbgFp = fopen("_psatCharData.csv", "a+")) == NULL) { |
| printf("Error: open _psatCharData.csv\n"); |
| return(false); |
| } |
| #endif |
| |
| fprintf(dbgFp, "%d, %d, %d, %d, %d, %d, %d, %d\n", |
| pTCMsg->msg.psatCharResults.freq, |
| pTCMsg->msg.psatCharResults.an_txrf3_rdiv2g, |
| pTCMsg->msg.psatCharResults.an_txrf3_pdpredist2g, |
| pTCMsg->msg.psatCharResults.an_rxtx2_mxrgain, |
| pTCMsg->msg.psatCharResults.an_rxrf_bias1_pwd_ic25mxr2gh, |
| pTCMsg->msg.psatCharResults.an_bias2_pwd_ic25rxrf, |
| pTCMsg->msg.psatCharResults.an_bb1_i2v_curr2x, |
| pTCMsg->msg.psatCharResults.an_txrf3_capdiv2g); |
| for (i=0;i<_MAX_TX_GAIN_ENTRIES;i++) { |
| cmac_i = pTCMsg->msg.psatCharResults.cmac_i[i]; |
| fprintf(dbgFp, "%d, %d, %f, %d\n", pTCMsg->msg.psatCharResults.pcdac[i], cmac_i, cmacPwr(cmac_i), cmac2Pwr_t10(cmac_i)); |
| } |
| |
| if (dbgFp) fclose(dbgFp); |
| return(true); |
| } |
| |
| uint16_t computeChecksumOnly(uint16_t *pHalf, uint16_t length) |
| { |
| uint16_t sum = 0, i; |
| for (i = 0; i < length; i++) { sum ^= *pHalf++; } |
| return(sum); |
| } |
| |
| void computeChecksum(AR6003_EEPROM *pEepStruct) |
| { |
| uint16_t sum, *pHalf; |
| uint8_t eepromVersion; |
| |
| eepromVersion = pEepStruct->baseEepHeader.version & AR6003_EEP_VER_MINOR_MASK; |
| if (eepromVersion >= AR6003_EEP_MINOR_VER5) { |
| // first checksum |
| pEepStruct->baseEepHeader.checksum = 0x0000; |
| pHalf = (uint16_t *)pEepStruct; |
| sum = computeChecksumOnly(pHalf, AR6K_EEPROM_SIZE_PRIOR_VER4/2); |
| pEepStruct->baseEepHeader.checksum = 0xFFFF ^ sum; |
| |
| // second (expanded checksum) |
| pEepStruct->checksumExpanded = 0x0000; |
| pHalf = (uint16_t *)pEepStruct; |
| pHalf += AR6K_EEPROM_SIZE_PRIOR_VER4/2; |
| sum = computeChecksumOnly(pHalf, (AR6003_EEPROM_SIZE - AR6K_EEPROM_SIZE_PRIOR_VER4)/2); |
| pEepStruct->checksumExpanded = 0xFFFF ^ sum; |
| |
| _printf("--computeChecksum old 0x%x expanded 0x%x\n", pEepStruct->baseEepHeader.checksum, pEepStruct->checksumExpanded); |
| } |
| else { |
| pEepStruct->baseEepHeader.checksum = 0x0000; |
| pHalf = (uint16_t *)pEepStruct; |
| sum = computeChecksumOnly(pHalf, AR6K_EEPROM_SIZE_PRIOR_VER4/2); |
| pEepStruct->baseEepHeader.checksum = 0xFFFF ^ sum; |
| _printf("--computeChecksum old 0x%x\n", pEepStruct->baseEepHeader.checksum); |
| } |
| } |
| |
| bool genEepromBinFile(char *fileName, AR6003_EEPROM *pEepStruct) |
| { |
| FILE *fp; |
| |
| // re-computing checksum |
| pEepStruct->baseEepHeader.checksum = 0; |
| computeChecksum(pEepStruct); |
| |
| if ( (fp = fopen(fileName, "wb")) == NULL) { |
| _printf("Error: open to write eeprom bin %s \n", fileName); |
| return false; |
| } |
| if (sizeof(AR6003_EEPROM) != fwrite((uint8_t *)pEepStruct, 1, sizeof(AR6003_EEPROM), fp)) { |
| _printf("Error: writing to %s\n", fileName); |
| } |
| if (fp) fclose(fp); |
| return(true); |
| } |
| |
| static void updateCALData(_CAL_SETUP *pCalSetup, TC_MSG *pTCMsg) |
| { |
| bool rc; |
| AR6003_EEPROM eepromData, *pEeprom=&eepromData; |
| AR6003_BASE_EEP_HEADER *pBase; |
| AR6003_CAL_DATA_PER_FREQ_OLPC_EXPANDED *pRawDataSet2G_ext, *pRawDataSet5G_ext; |
| uint8_t *pCalChans2G, *pCalChans5G; |
| uint32_t numPiers2G, numPiers5G; |
| uint32_t i; |
| |
| // read in golden bin |
| rc = readCalDataFromFileBin(pCalSetup->goldenBinFilename, pEeprom); |
| assert(rc); |
| printf("Read %s\n", pCalSetup->goldenBinFilename); |
| |
| numPiers2G = numPiers5G = 0; |
| pBase = &(pEeprom->baseEepHeader); |
| |
| { |
| if (pBase->opCapFlags & WLAN_11G_CAPABILITY) { |
| pRawDataSet2G_ext = pEeprom->calPierData2GExpanded; |
| pCalChans2G = pEeprom->calFreqPier2GExpanded; |
| for (numPiers2G = 0; numPiers2G < AR6003_NUM_2G_CAL_PIERS_EXPANDED; numPiers2G++) { |
| if (pCalChans2G[numPiers2G] == AR6003_BCHAN_UNUSED) { |
| break; |
| } |
| } |
| } |
| |
| if (pBase->opCapFlags & WLAN_11A_CAPABILITY) { |
| pRawDataSet5G_ext = pEeprom->calPierData5GExpanded; |
| pCalChans5G = pEeprom->calFreqPier5GExpanded; |
| for (numPiers5G = 0; numPiers5G < AR6003_NUM_5G_CAL_PIERS_EXPANDED; numPiers5G++) { |
| if (pCalChans5G[numPiers5G] == AR6003_BCHAN_UNUSED) { |
| break; |
| } |
| } |
| } |
| } |
| |
| PSAT_CAL_RESULTS *pPsatCalResults = &(pTCMsg->msg.psatCalResults); |
| |
| for (i=0;i<numPiers2G;i++) { |
| printf("%d %d %d %d %d %.2f %.2f %d %d 0x%x %d %d 0x%x\n", pPsatCalResults->olpcGainTherm2G[i].olpcGainDelta_diff, pPsatCalResults->olpcGainTherm2G[i].olpcGainDelta_abs, pPsatCalResults->olpcGainTherm2G[i].thermCalVal, |
| pPsatCalResults->olpcGainTherm2G[i].cmac_psat, pPsatCalResults->olpcGainTherm2G[i].cmac_olpc, |
| cmacPwr(pPsatCalResults->olpcGainTherm2G[i].cmac_psat), cmacPwr(pPsatCalResults->olpcGainTherm2G[i].cmac_olpc), |
| pPsatCalResults->olpcGainTherm2G[i].cmac_psat_pcdac, pPsatCalResults->olpcGainTherm2G[i].cmac_olpc_pcdac, |
| pPsatCalResults->olpcGainTherm2G[i].numTryBF, |
| pPsatCalResults->olpcGainTherm2G[i].lineSlope, pPsatCalResults->olpcGainTherm2G[i].lineVariance, |
| pPsatCalResults->olpcGainTherm2G[i].psatParm); |
| //} |
| } |
| for (i=0;i<numPiers5G ;i++) { |
| printf("%d %d %d %d %d %.2f %.2f %d %d 0x%x\n", pPsatCalResults->olpcGainTherm5G[i].olpcGainDelta_diff, pPsatCalResults->olpcGainTherm5G[i].olpcGainDelta_abs, pPsatCalResults->olpcGainTherm5G[i].thermCalVal, |
| pPsatCalResults->olpcGainTherm5G[i].cmac_psat, pPsatCalResults->olpcGainTherm5G[i].cmac_olpc, |
| cmacPwr(pPsatCalResults->olpcGainTherm5G[i].cmac_psat), cmacPwr(pPsatCalResults->olpcGainTherm5G[i].cmac_olpc), |
| pPsatCalResults->olpcGainTherm5G[i].cmac_psat_pcdac, pPsatCalResults->olpcGainTherm5G[i].cmac_olpc_pcdac, |
| pPsatCalResults->olpcGainTherm5G[i].numTryBF); |
| //} |
| } |
| |
| for (i=0;i<numPiers2G;i++) { |
| if (pEeprom->baseEepHeader.boardFlagsExt & AR6003_BOARDFLAGSEXT_PSAT_CAL_ABS) { |
| pRawDataSet2G_ext[i].olpcBasic.olpcGainDelta = (int8_t) (pPsatCalResults->olpcGainTherm2G[i].olpcGainDelta_abs); |
| pRawDataSet2G_ext[i].olpcGainDelta_t10 = (int16_t) (pPsatCalResults->olpcGainTherm2G[i].olpcGainDelta_abs *5); |
| } |
| else { |
| pRawDataSet2G_ext[i].olpcBasic.olpcGainDelta = (int8_t) (pPsatCalResults->olpcGainTherm2G[i].olpcGainDelta_diff); |
| pRawDataSet2G_ext[i].olpcGainDelta_t10 = (int16_t) (pPsatCalResults->olpcGainTherm2G[i].olpcGainDelta_diff *5); |
| } |
| pRawDataSet2G_ext[i].olpcBasic.thermCalVal = (uint8_t) pPsatCalResults->olpcGainTherm2G[i].thermCalVal; |
| } |
| |
| for (i=0;i<numPiers5G;i++) { |
| if (pEeprom->baseEepHeader.boardFlagsExt & AR6003_BOARDFLAGSEXT_PSAT_CAL_ABS) { |
| pRawDataSet5G_ext[i].olpcBasic.olpcGainDelta = (int8_t)pPsatCalResults->olpcGainTherm5G[i].olpcGainDelta_abs; |
| } |
| else { |
| pRawDataSet5G_ext[i].olpcBasic.olpcGainDelta = (int8_t)pPsatCalResults->olpcGainTherm5G[i].olpcGainDelta_diff; |
| } |
| pRawDataSet5G_ext[i].olpcBasic.thermCalVal = (uint8_t)pPsatCalResults->olpcGainTherm5G[i].thermCalVal; |
| pRawDataSet5G_ext[i].olpcGainDelta_t10 = (int16_t)(pPsatCalResults->olpcGainTherm5G[i].olpcGainDelta_diff * 5); |
| } |
| |
| memcpy((void*)&(pEeprom->baseEepHeader.custData[0]), pCalSetup->label, sizeof(pCalSetup->label)); |
| |
| // Generate bin |
| if (pEeprom->baseEepHeader.boardFlagsExt & AR6003_BOARDFLAGSEXT_PSAT_CAL_GEN_EEPROM) { |
| rc = genEepromBinFile(pCalSetup->outputBinFilename, pEeprom); |
| assert(rc); |
| } |
| |
| return; |
| } |
| |
