982 lines
39 KiB
C
982 lines
39 KiB
C
/*
|
|
* Copyright (c) 2015-2016, The Linux Foundation. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided
|
|
* with the distribution.
|
|
* * Neither the name of The Linux Foundation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
|
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
|
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/*
|
|
* This file was originally distributed by Qualcomm Atheros, Inc.
|
|
* under proprietary terms before Copyright ownership was assigned
|
|
* to the Linux Foundation.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "dsrc_dcc.h"
|
|
|
|
#define DCC_NDL_ACTIVE_STATE_SIZE 4
|
|
|
|
dcc_ndl_chan g_chan[2];
|
|
dcc_ndl_active_state_config g_state_cfg[8];
|
|
|
|
int str_to_ac(char *token)
|
|
{
|
|
if (!strcasecmp(token, "AC_BK")) {
|
|
return DCC_AC_BK;
|
|
} else if (!strcasecmp(token, "AC_BE")) {
|
|
return DCC_AC_BE;
|
|
} else if (!strcasecmp(token, "AC_VI")) {
|
|
return DCC_AC_VI;
|
|
} else if (!strcasecmp(token, "AC_VO")) {
|
|
return DCC_AC_VO;
|
|
}
|
|
|
|
return DCC_AC_BK;
|
|
}
|
|
|
|
int str_to_mcs(char *token)
|
|
{
|
|
if (!strcasecmp(token, "MCS0")) {
|
|
return 0;
|
|
} else if (!strcasecmp(token, "MCS1")) {
|
|
return 1;
|
|
} else if (!strcasecmp(token, "MCS2")) {
|
|
return 2;
|
|
} else if (!strcasecmp(token, "MCS3")) {
|
|
return 3;
|
|
} else if (!strcasecmp(token, "MCS4")) {
|
|
return 4;
|
|
} else if (!strcasecmp(token, "MCS5")) {
|
|
return 5;
|
|
} else if (!strcasecmp(token, "MCS6")) {
|
|
return 6;
|
|
} else if (!strcasecmp(token, "MCS7")) {
|
|
return 7;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int str_to_state_id(char *token)
|
|
{
|
|
if (!strcasecmp(token, "ActiveState_1")) {
|
|
return 1;
|
|
}
|
|
if (!strcasecmp(token, "ActiveState_2")) {
|
|
return 2;
|
|
}
|
|
if (!strcasecmp(token, "ActiveState_3")) {
|
|
return 3;
|
|
}
|
|
if (!strcasecmp(token, "ActiveState_4")) {
|
|
return 4;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int tokenize_string(char *line, char **tokens)
|
|
{
|
|
char *token;
|
|
int i = 0;
|
|
char *saveptr;
|
|
|
|
token = strtok_r(line, "=,- \n", &saveptr);
|
|
while (token) {
|
|
if (token[0] == '#') {
|
|
return 0;
|
|
}
|
|
tokens[i++] = token;
|
|
DCC_DEBUG_PRINT("%d: %lu, %s\n", i, (unsigned long) strlen(token), token);
|
|
token = strtok_r(NULL, "=,- \n", &saveptr);
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
unsigned char g_num_channels = 0;
|
|
|
|
void update_dcc_config(int num_tokens, char **tokens,
|
|
dcc_ndl_chan *chan,
|
|
dcc_ndl_active_state_config *state_cfg)
|
|
{
|
|
int i = 0, num_chan = 0, state_id;
|
|
|
|
if (!strcasecmp(tokens[0], "DCC_Channels")) {
|
|
g_num_channels = num_tokens - 1;
|
|
|
|
if (g_num_channels > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < g_num_channels; i++) {
|
|
DCC_CHAN_FREQ_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "DCC_ControlLoopEnable")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_DCC_ENABLE_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "DCC_StatsEnable")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_DCC_STATS_ENABLE_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "DCC_MinDccSampling")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_MIN_DCC_SAMPLING_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "DCC_MeasurementInterval")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_MEASURE_INTERVAL_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "DCC_StatsInterval")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_DCC_STATS_INTERVAL_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_minTxPower")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_MIN_TX_POWER_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_MaxTxPower")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_MAX_TX_POWER_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_defTxPower")) {
|
|
num_chan = num_tokens - 2;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_DEF_TX_POWER_SET(&chan[i], str_to_ac(tokens[1]), atoi(tokens[i+2]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_maxPacketDuration")) {
|
|
num_chan = num_tokens - 2;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_MAX_PACKET_DURATION_SET(&chan[i], str_to_ac(tokens[1]), atoi(tokens[i+2]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_minPacketInterval")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_MIN_PACKET_INTERVAL_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_maxPacketInterval")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_MAX_PACKET_INTERVAL_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_defPacketInterval")) {
|
|
num_chan = num_tokens - 2;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_DEF_PACKET_INTERVAL_SET(&chan[i], str_to_ac(tokens[1]), atoi(tokens[i+2]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_minDatarate")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_MIN_DATARATE_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_maxDatarate")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_MAX_DATARATE_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_defDatarate")) {
|
|
num_chan = num_tokens - 2;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_DEF_DATARATE_SET(&chan[i], str_to_ac(tokens[1]), atoi(tokens[i+2]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_minCarrierSense")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_MIN_CARRIER_SENSE_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_maxCarrierSense")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_MAX_CARRIER_SENSE_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_defCarrierSense")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_DEF_CARRIER_SENSE_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_defDccSensitivity")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_DEF_DCC_SENSITIVITY_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_maxCsRange")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_MAX_CS_RANGE_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_refPathloss")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_REF_PATH_LOSS_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_minSNR")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_MIN_SNR_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_snrBackoff")) {
|
|
num_chan = num_tokens - 2;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_SNR_BACKOFF_SET(&chan[i], str_to_mcs(tokens[1]), atoi(tokens[i+2]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_tmPacketArrivalRate")) {
|
|
num_chan = num_tokens - 2;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_TM_PACKET_ARRIVAL_RATE_SET(&chan[i], str_to_ac(tokens[1]), atoi(tokens[i+2]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_tmPacketAvgDuration")) {
|
|
num_chan = num_tokens - 2;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_TM_PACKET_AVG_DURATION_SET(&chan[i], str_to_ac(tokens[1]), atoi(tokens[i+2]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_tmSignalAvgPower")) {
|
|
num_chan = num_tokens - 2;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_TM_SIGNAL_AVG_POWER_SET(&chan[i], str_to_ac(tokens[1]), atoi(tokens[i+2]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_maxChannelUse")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_TM_MAX_CHANNEL_USE_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_tmChannelUse")) {
|
|
num_chan = num_tokens - 2;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_TM_CHANNEL_USE_SET(&chan[i], str_to_ac(tokens[1]), atoi(tokens[i+2]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_minChannelLoad")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_MIN_CHANNEL_LOAD_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_maxChannelLoad")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_MAX_CHANNEL_LOAD_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_numQueue")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_NUM_QUEUE_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_refQueueStatus")) {
|
|
num_chan = num_tokens - 2;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_REF_QUEUE_STATUS_SET(&chan[i], str_to_ac(tokens[1]), atoi(tokens[i+2]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_queueLen")) {
|
|
num_chan = num_tokens - 2;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_REF_QUEUE_LEN_SET(&chan[i], str_to_ac(tokens[1]), atoi(tokens[i+2]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_timeUp")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_TIME_UP_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_timeDown")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_TIME_DOWN_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_NumActiveStates")) {
|
|
num_chan = num_tokens - 1;
|
|
|
|
if (num_chan > (sizeof(g_chan) / sizeof(dcc_ndl_chan))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
for (state_id = 1; state_id < 5; state_id++) {
|
|
DCC_NDL_AS_STATE_ID_SET(&state_cfg[i*4+state_id-1], state_id);
|
|
}
|
|
DCC_NDL_NUM_ACTIVE_STATE_SET(&chan[i], atoi(tokens[i+1]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_asChanLoad")) {
|
|
num_chan = num_tokens - 2;
|
|
|
|
if (num_tokens < 3) {
|
|
return;
|
|
}
|
|
|
|
if (num_chan >
|
|
(sizeof(g_state_cfg) / (sizeof(dcc_ndl_active_state_config) * 4))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
state_id = str_to_state_id(tokens[1]);
|
|
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_AS_CHAN_LOAD_SET(&state_cfg[i*4+state_id-1], atoi(tokens[i+2]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_asDcc")) {
|
|
num_chan = num_tokens - 3;
|
|
|
|
if (num_tokens < 4) {
|
|
return;
|
|
}
|
|
|
|
if (num_chan >
|
|
(sizeof(g_state_cfg) / (sizeof(dcc_ndl_active_state_config) * 4))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
state_id = str_to_state_id(tokens[2]);
|
|
|
|
for (i = 0; i < num_chan; i++) {
|
|
DCC_NDL_AS_DCC_SET(&state_cfg[i*4+state_id-1], str_to_ac(tokens[1]), atoi(tokens[i+3]));
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_asTxPower")) {
|
|
num_chan = num_tokens - 3;
|
|
|
|
if (num_tokens < 4) {
|
|
return;
|
|
}
|
|
|
|
if (num_chan >
|
|
(sizeof(g_state_cfg) / (sizeof(dcc_ndl_active_state_config) * 4))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
state_id = str_to_state_id(tokens[2]);
|
|
|
|
for (i = 0; i < num_chan; i++) {
|
|
if (!strcasecmp(tokens[i+3],"ref")) {
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+state_id-1], str_to_ac(tokens[1]), INVALID_TXPOWER);
|
|
} else {
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+state_id-1], str_to_ac(tokens[1]), atoi(tokens[i+3]));
|
|
}
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_asPacketInterval")) {
|
|
num_chan = num_tokens - 3;
|
|
|
|
if (num_tokens < 4) {
|
|
return;
|
|
}
|
|
|
|
if (num_chan >
|
|
(sizeof(g_state_cfg) / (sizeof(dcc_ndl_active_state_config) * 4))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
state_id = str_to_state_id(tokens[2]);
|
|
|
|
for (i = 0; i < num_chan; i++) {
|
|
if (!strcasecmp(tokens[i+3],"ref")) {
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+state_id-1], str_to_ac(tokens[1]), INVALID_PACKETINTERVAL);
|
|
} else {
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+state_id-1], str_to_ac(tokens[1]), atoi(tokens[i+3]));
|
|
}
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_asDatarate")) {
|
|
num_chan = num_tokens - 3;
|
|
|
|
if (num_tokens < 4) {
|
|
return;
|
|
}
|
|
|
|
if (num_chan >
|
|
(sizeof(g_state_cfg) / (sizeof(dcc_ndl_active_state_config) * 4))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
state_id = str_to_state_id(tokens[2]);
|
|
|
|
for (i = 0; i < num_chan; i++) {
|
|
if (!strcasecmp(tokens[i+3],"ref")) {
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+state_id-1], str_to_ac(tokens[1]), INVALID_DATARATE);
|
|
} else {
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+state_id-1], str_to_ac(tokens[1]), atoi(tokens[i+3]));
|
|
}
|
|
}
|
|
} else if (!strcasecmp(tokens[0], "NDL_asCarrierSense")) {
|
|
num_chan = num_tokens - 3;
|
|
|
|
if (num_tokens < 4) {
|
|
return;
|
|
}
|
|
|
|
if (num_chan >
|
|
(sizeof(g_state_cfg) / (sizeof(dcc_ndl_active_state_config) * 4))) {
|
|
DCC_PRINT("Invalid value for %s", tokens[0]);
|
|
return;
|
|
}
|
|
state_id = str_to_state_id(tokens[2]);
|
|
|
|
for (i = 0; i < num_chan; i++) {
|
|
if (!strcasecmp(tokens[i+3],"ref")) {
|
|
DCC_NDL_AS_CARRIER_SENSE_SET(&state_cfg[i*4+state_id-1], str_to_ac(tokens[1]), INVALID_RXPOWER);
|
|
} else {
|
|
DCC_NDL_AS_CARRIER_SENSE_SET(&state_cfg[i*4+state_id-1], str_to_ac(tokens[1]), atoi(tokens[i+3]));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
void initialize_dcc_config(dcc_ndl_chan *chan,
|
|
dcc_ndl_active_state_config *state_cfg)
|
|
{
|
|
unsigned long i = 0, ac, num_chan = 2, state_id;
|
|
unsigned long chan_freq[2] = {5860, 5870};
|
|
unsigned long max_pkt_dur[2]= {125,125};
|
|
unsigned long min_pkt_intr[2] = {4,4};
|
|
unsigned long max_pkt_intr[2] = {200,200};
|
|
unsigned long def_pkt_intr[2] = {50,50};
|
|
unsigned long min_dr[2] = {2,2};
|
|
unsigned long max_dr[2] = {5,5};
|
|
unsigned long def_dr[2] = {2,2};
|
|
unsigned long min_cs[2] = {110,110};
|
|
unsigned long max_cs[2] = {50,50};
|
|
unsigned long def_cs[2] = {90,90};
|
|
unsigned long def_dcc_sens[2] = {90,90};
|
|
unsigned long max_cs_r[2] = {1000,1000};
|
|
unsigned long ref_pathl[2] = {10,10};
|
|
unsigned long min_snr[2] = {40,40};
|
|
unsigned long bo_mcs0[2] = {20,20};
|
|
unsigned long bo_mcs1[2] = {22,22};
|
|
unsigned long bo_mcs2[2] = {26,26};
|
|
unsigned long bo_mcs3[2] = {30,30};
|
|
unsigned long bo_mcs4[2] = {36,36};
|
|
unsigned long bo_mcs5[2] = {44,44};
|
|
unsigned long bo_mcs6[2] = {52,52};
|
|
unsigned long bo_mcs7[2] = {54,54};
|
|
unsigned long pkt_arr_r[2] = {0, 0};
|
|
unsigned long pkt_avg_dur[2] = {0,0};
|
|
unsigned long signal_avg_pwr[2] = {0,0};
|
|
unsigned long max_chan_use[2] = {0,0};
|
|
unsigned long chan_use[2] = {0,0};
|
|
unsigned long min_channelld[2] = {150,200};
|
|
unsigned long max_channelld[2] = {400,500};
|
|
unsigned long num_q[2] = {4,4};
|
|
unsigned long ref_q_status[2] = {1,1};
|
|
unsigned long ref_q_len[2] = {2,8};
|
|
unsigned long time_up[2] = {100,100};
|
|
unsigned long time_dn[2] = {500,500};
|
|
unsigned long num_a_states[2] = {4,4};
|
|
|
|
unsigned long as1_chanload[2] = {250,250};
|
|
unsigned long as1_dcc_BK[2] = {1,1};
|
|
unsigned long as1_dcc_BE[2] = {1,1};
|
|
unsigned long as1_dcc_VI[2] = {0,0};
|
|
unsigned long as1_dcc_VO[2] = {0,0};
|
|
unsigned long as1_txpwr_BK[2] = {80,80};
|
|
unsigned long as1_txpwr_BE[2] = {90,90};
|
|
unsigned long as1_txpwr_VI[2] = {INVALID_TXPOWER,INVALID_TXPOWER};
|
|
unsigned long as1_txpwr_VO[2] = {INVALID_TXPOWER,INVALID_TXPOWER};
|
|
unsigned long as1_pkt_intr[2] = {INVALID_PACKETINTERVAL,INVALID_PACKETINTERVAL};
|
|
unsigned long as1_dr[2] = {INVALID_DATARATE,INVALID_DATARATE};
|
|
unsigned long as_cs[2] = {INVALID_RXPOWER,INVALID_RXPOWER};
|
|
|
|
unsigned long as2_chanload[2] = {300,300};
|
|
unsigned long as2_dcc_BK[2] = {3,3};
|
|
unsigned long as2_dcc_BE[2] = {1,1};
|
|
unsigned long as2_dcc_VI[2] = {1,1};
|
|
unsigned long as2_dcc_VO[2] = {1,1};
|
|
unsigned long as2_txpwr_BK[2] = {60,60};
|
|
unsigned long as2_txpwr_BE[2] = {80,80};
|
|
unsigned long as2_txpwr_VI[2] = {90,90};
|
|
unsigned long as2_txpwr_VO[2] = {90,90};
|
|
unsigned long as2_pkt_intr_BK[2] = {100,100};
|
|
unsigned long as2_pkt_intr_BE[2] = {INVALID_PACKETINTERVAL,INVALID_PACKETINTERVAL};
|
|
unsigned long as2_pkt_intr_VI[2] = {INVALID_PACKETINTERVAL,INVALID_PACKETINTERVAL};
|
|
unsigned long as2_pkt_intr_VO[2] = {INVALID_PACKETINTERVAL,INVALID_PACKETINTERVAL};
|
|
unsigned long as2_dr[2] = {INVALID_DATARATE,INVALID_DATARATE};
|
|
|
|
unsigned long as3_chanload[2] = {350,350};
|
|
unsigned long as3_dcc_BK[2] = {7,7};
|
|
unsigned long as3_dcc_BE[2] = {7,7};
|
|
unsigned long as3_dcc_VI[2] = {1,1};
|
|
unsigned long as3_dcc_VO[2] = {1,1};
|
|
unsigned long as3_txpwr_BK[2] = {50,50};
|
|
unsigned long as3_txpwr_BE[2] = {60,60};
|
|
unsigned long as3_txpwr_VI[2] = {70,70};
|
|
unsigned long as3_txpwr_VO[2] = {70,70};
|
|
unsigned long as3_pkt_intr_BK[2] = {150,150};
|
|
unsigned long as3_pkt_intr_BE[2] = {100,100};
|
|
unsigned long as3_pkt_intr_VI[2] = {INVALID_PACKETINTERVAL,INVALID_PACKETINTERVAL};
|
|
unsigned long as3_pkt_intr_VO[2] = {INVALID_PACKETINTERVAL,INVALID_PACKETINTERVAL};
|
|
unsigned long as3_dr_BK[2] = {3,3};
|
|
unsigned long as3_dr_BE[2] = {3,3};
|
|
unsigned long as3_dr_VI[2] = {INVALID_DATARATE,INVALID_DATARATE};
|
|
unsigned long as3_dr_VO[2] = {INVALID_DATARATE,INVALID_DATARATE};
|
|
|
|
unsigned long as4_chanload[2] = {400,400};
|
|
unsigned long as4_dcc_BK[2] = {7,7};
|
|
unsigned long as4_dcc_BE[2] = {7,7};
|
|
unsigned long as4_dcc_VI[2] = {7,7};
|
|
unsigned long as4_dcc_VO[2] = {5,5};
|
|
unsigned long as4_txpwr_BK[2] = {20,20};
|
|
unsigned long as4_txpwr_BE[2] = {30,30};
|
|
unsigned long as4_txpwr_VI[2] = {40,40};
|
|
unsigned long as4_txpwr_VO[2] = {10,10};
|
|
unsigned long as4_pkt_intr_BK[2] = {200,200};
|
|
unsigned long as4_pkt_intr_BE[2] = {150,150};
|
|
unsigned long as4_pkt_intr_VI[2] = {100,100};
|
|
unsigned long as4_pkt_intr_VO[2] = {INVALID_PACKETINTERVAL,INVALID_PACKETINTERVAL};
|
|
unsigned long as4_dr_BK[2] = {5,5};
|
|
unsigned long as4_dr_BE[2] = {5,5};
|
|
unsigned long as4_dr_VI[2] = {4,4};
|
|
unsigned long as4_dr_VO[2] = {4,4};
|
|
|
|
for (i = 0; i < num_chan; i++) {
|
|
|
|
DCC_CHAN_FREQ_SET(&chan[i], chan_freq[i]);
|
|
DCC_NDL_NUM_ACTIVE_STATE_SET(&chan[i], 0);
|
|
DCC_NDL_DCC_ENABLE_SET(&chan[i], 0);
|
|
DCC_NDL_DCC_STATS_ENABLE_SET(&chan[i], 0);
|
|
DCC_NDL_MIN_DCC_SAMPLING_SET(&chan[i], 1);
|
|
DCC_NDL_MEASURE_INTERVAL_SET(&chan[i], 500);
|
|
DCC_NDL_DCC_STATS_INTERVAL_SET(&chan[i], 500);
|
|
DCC_NDL_MIN_TX_POWER_SET(&chan[i], 20);
|
|
DCC_NDL_MAX_TX_POWER_SET(&chan[i], 106);
|
|
|
|
for (ac = DCC_AC_VO; ac < DCC_AC_MAX; ac++) {
|
|
DCC_NDL_DEF_TX_POWER_SET(&chan[i], ac, 86);
|
|
DCC_NDL_MAX_PACKET_DURATION_SET(&chan[i], ac, max_pkt_dur[i]);
|
|
DCC_NDL_DEF_PACKET_INTERVAL_SET(&chan[i], ac, def_pkt_intr[i]);
|
|
DCC_NDL_DEF_DATARATE_SET(&chan[i], ac, def_dr[i]);
|
|
DCC_NDL_TM_PACKET_ARRIVAL_RATE_SET(&chan[i], ac, pkt_arr_r[i]);
|
|
DCC_NDL_TM_PACKET_AVG_DURATION_SET(&chan[i], ac, pkt_avg_dur[i]);
|
|
DCC_NDL_TM_SIGNAL_AVG_POWER_SET(&chan[i], ac, signal_avg_pwr[i]);
|
|
DCC_NDL_TM_CHANNEL_USE_SET(&chan[i], ac, chan_use[i]);
|
|
DCC_NDL_REF_QUEUE_STATUS_SET(&chan[i], ac, ref_q_status[i]);
|
|
DCC_NDL_REF_QUEUE_LEN_SET(&chan[i], ac, ref_q_len[i]);
|
|
}
|
|
|
|
DCC_NDL_MIN_PACKET_INTERVAL_SET(&chan[i], min_pkt_intr[i]);
|
|
DCC_NDL_MAX_PACKET_INTERVAL_SET(&chan[i], max_pkt_intr[i]);
|
|
DCC_NDL_MIN_DATARATE_SET(&chan[i], min_dr[i]);
|
|
DCC_NDL_MAX_DATARATE_SET(&chan[i], max_dr[i]);
|
|
DCC_NDL_MIN_CARRIER_SENSE_SET(&chan[i], min_cs[i]);
|
|
DCC_NDL_MAX_CARRIER_SENSE_SET(&chan[i], max_cs[i]);
|
|
DCC_NDL_DEF_CARRIER_SENSE_SET(&chan[i], def_cs[i]);
|
|
DCC_NDL_DEF_DCC_SENSITIVITY_SET(&chan[i], def_dcc_sens[i]);
|
|
DCC_NDL_MAX_CS_RANGE_SET(&chan[i], max_cs_r[i]);
|
|
DCC_NDL_REF_PATH_LOSS_SET(&chan[i], ref_pathl[i]);
|
|
DCC_NDL_MIN_SNR_SET(&chan[i], min_snr[i]);
|
|
|
|
DCC_NDL_SNR_BACKOFF_SET(&chan[i], 0, bo_mcs0[i]);
|
|
DCC_NDL_SNR_BACKOFF_SET(&chan[i], 1, bo_mcs1[i]);
|
|
DCC_NDL_SNR_BACKOFF_SET(&chan[i], 2, bo_mcs2[i]);
|
|
DCC_NDL_SNR_BACKOFF_SET(&chan[i], 3, bo_mcs3[i]);
|
|
DCC_NDL_SNR_BACKOFF_SET(&chan[i], 4, bo_mcs4[i]);
|
|
DCC_NDL_SNR_BACKOFF_SET(&chan[i], 5, bo_mcs5[i]);
|
|
DCC_NDL_SNR_BACKOFF_SET(&chan[i], 6, bo_mcs6[i]);
|
|
DCC_NDL_SNR_BACKOFF_SET(&chan[i], 7, bo_mcs7[i]);
|
|
|
|
DCC_NDL_TM_MAX_CHANNEL_USE_SET(&chan[i], max_chan_use[i]);
|
|
DCC_NDL_MIN_CHANNEL_LOAD_SET(&chan[i], min_channelld[i]);
|
|
DCC_NDL_MAX_CHANNEL_LOAD_SET(&chan[i], max_channelld[i]);
|
|
DCC_NDL_NUM_QUEUE_SET(&chan[i], num_q[i]);
|
|
DCC_NDL_TIME_UP_SET(&chan[i], time_up[i]);
|
|
DCC_NDL_TIME_DOWN_SET(&chan[i], time_dn[i]);
|
|
|
|
DCC_NDL_AS_STATE_ID_SET(&state_cfg[i*4+0], 1);
|
|
DCC_NDL_AS_STATE_ID_SET(&state_cfg[i*4+1], 2);
|
|
DCC_NDL_AS_STATE_ID_SET(&state_cfg[i*4+2], 3);
|
|
DCC_NDL_AS_STATE_ID_SET(&state_cfg[i*4+3], 4);
|
|
|
|
DCC_NDL_NUM_ACTIVE_STATE_SET(&chan[i], num_a_states[i]);
|
|
|
|
DCC_NDL_AS_CHAN_LOAD_SET(&state_cfg[i*4+0], as1_chanload[i]);
|
|
DCC_NDL_AS_CHAN_LOAD_SET(&state_cfg[i*4+1], as2_chanload[i]);
|
|
DCC_NDL_AS_CHAN_LOAD_SET(&state_cfg[i*4+2], as3_chanload[i]);
|
|
DCC_NDL_AS_CHAN_LOAD_SET(&state_cfg[i*4+3], as4_chanload[i]);
|
|
|
|
DCC_NDL_AS_DCC_SET(&state_cfg[i*4+0], DCC_AC_BK, as1_dcc_BK[i]);
|
|
DCC_NDL_AS_DCC_SET(&state_cfg[i*4+0], DCC_AC_BE, as1_dcc_BE[i]);
|
|
DCC_NDL_AS_DCC_SET(&state_cfg[i*4+0], DCC_AC_VI, as1_dcc_VI[i]);
|
|
DCC_NDL_AS_DCC_SET(&state_cfg[i*4+0], DCC_AC_VO, as1_dcc_VO[i]);
|
|
|
|
DCC_NDL_AS_DCC_SET(&state_cfg[i*4+1], DCC_AC_BK, as2_dcc_BK[i]);
|
|
DCC_NDL_AS_DCC_SET(&state_cfg[i*4+1], DCC_AC_BE, as2_dcc_BE[i]);
|
|
DCC_NDL_AS_DCC_SET(&state_cfg[i*4+1], DCC_AC_VI, as2_dcc_VI[i]);
|
|
DCC_NDL_AS_DCC_SET(&state_cfg[i*4+1], DCC_AC_VO, as2_dcc_VO[i]);
|
|
|
|
DCC_NDL_AS_DCC_SET(&state_cfg[i*4+2], DCC_AC_BK, as3_dcc_BK[i]);
|
|
DCC_NDL_AS_DCC_SET(&state_cfg[i*4+2], DCC_AC_BE, as3_dcc_BE[i]);
|
|
DCC_NDL_AS_DCC_SET(&state_cfg[i*4+2], DCC_AC_VI, as3_dcc_VI[i]);
|
|
DCC_NDL_AS_DCC_SET(&state_cfg[i*4+2], DCC_AC_VO, as3_dcc_VO[i]);
|
|
|
|
DCC_NDL_AS_DCC_SET(&state_cfg[i*4+3], DCC_AC_BK, as4_dcc_BK[i]);
|
|
DCC_NDL_AS_DCC_SET(&state_cfg[i*4+3], DCC_AC_BE, as4_dcc_BE[i]);
|
|
DCC_NDL_AS_DCC_SET(&state_cfg[i*4+3], DCC_AC_VI, as4_dcc_VI[i]);
|
|
DCC_NDL_AS_DCC_SET(&state_cfg[i*4+3], DCC_AC_VO, as4_dcc_VO[i]);
|
|
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+0], DCC_AC_BK, as1_txpwr_BK[i]);
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+0], DCC_AC_BE, as1_txpwr_BE[i]);
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+0], DCC_AC_VI, as1_txpwr_VI[i]);
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+0], DCC_AC_VO, as1_txpwr_VO[i]);
|
|
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+1], DCC_AC_BK, as2_txpwr_BK[i]);
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+1], DCC_AC_BE, as2_txpwr_BE[i]);
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+1], DCC_AC_VI, as2_txpwr_VI[i]);
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+1], DCC_AC_VO, as2_txpwr_VO[i]);
|
|
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+2], DCC_AC_BK, as3_txpwr_BK[i]);
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+2], DCC_AC_BE, as3_txpwr_BE[i]);
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+2], DCC_AC_VI, as3_txpwr_VI[i]);
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+2], DCC_AC_VO, as3_txpwr_VO[i]);
|
|
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+3], DCC_AC_BK, as4_txpwr_BK[i]);
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+3], DCC_AC_BE, as4_txpwr_BE[i]);
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+3], DCC_AC_VI, as4_txpwr_VI[i]);
|
|
DCC_NDL_AS_TX_POWER_SET(&state_cfg[i*4+3], DCC_AC_VO, as4_txpwr_VO[i]);
|
|
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+0], DCC_AC_BK, as1_pkt_intr[i]);
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+0], DCC_AC_BE, as1_pkt_intr[i]);
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+0], DCC_AC_VI, as1_pkt_intr[i]);
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+0], DCC_AC_VO, as1_pkt_intr[i]);
|
|
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+1], DCC_AC_BK, as2_pkt_intr_BK[i]);
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+1], DCC_AC_BE, as2_pkt_intr_BE[i]);
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+1], DCC_AC_VI, as2_pkt_intr_VI[i]);
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+1], DCC_AC_VO, as2_pkt_intr_VO[i]);
|
|
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+2], DCC_AC_BK, as3_pkt_intr_BK[i]);
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+2], DCC_AC_BE, as3_pkt_intr_BE[i]);
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+2], DCC_AC_VI, as3_pkt_intr_VI[i]);
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+2], DCC_AC_VO, as3_pkt_intr_VO[i]);
|
|
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+3], DCC_AC_BK, as4_pkt_intr_BK[i]);
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+3], DCC_AC_BE, as4_pkt_intr_BE[i]);
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+3], DCC_AC_VI, as4_pkt_intr_VI[i]);
|
|
DCC_NDL_AS_PACKET_INTERVAL_SET(&state_cfg[i*4+3], DCC_AC_VO, as4_pkt_intr_VO[i]);
|
|
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+0], DCC_AC_BK, as1_dr[i]);
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+0], DCC_AC_BE, as1_dr[i]);
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+0], DCC_AC_VI, as1_dr[i]);
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+0], DCC_AC_VO, as1_dr[i]);
|
|
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+1], DCC_AC_BK, as2_dr[i]);
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+1], DCC_AC_BE, as2_dr[i]);
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+1], DCC_AC_VI, as2_dr[i]);
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+1], DCC_AC_VO, as2_dr[i]);
|
|
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+2], DCC_AC_BK, as3_dr_BK[i]);
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+2], DCC_AC_BE, as3_dr_BE[i]);
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+2], DCC_AC_VI, as3_dr_VI[i]);
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+2], DCC_AC_VO, as3_dr_VO[i]);
|
|
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+3], DCC_AC_BK, as4_dr_BK[i]);
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+3], DCC_AC_BE, as4_dr_BE[i]);
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+3], DCC_AC_VI, as4_dr_VI[i]);
|
|
DCC_NDL_AS_DATARATE_SET(&state_cfg[i*4+3], DCC_AC_VO, as4_dr_VO[i]);
|
|
|
|
for (state_id = 1; state_id < 5; state_id++) {
|
|
for (ac = DCC_AC_VI; ac < DCC_AC_MAX; ac++) {
|
|
DCC_NDL_AS_CARRIER_SENSE_SET(&state_cfg[i*4+state_id-1], ac, as_cs[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void dcc_get_config(unsigned char *num_channels, dcc_ndl_chan **chan,
|
|
unsigned char *num_active_states, dcc_ndl_active_state_config **state_cfg)
|
|
{
|
|
FILE *fp = NULL;
|
|
char *line = NULL;
|
|
unsigned int linecount = 0, num_tokens;
|
|
size_t len;
|
|
char *tokens[128];
|
|
unsigned int i;
|
|
|
|
fp = fopen(DCC_CFG_FILE, "r");
|
|
if (!fp) {
|
|
DCC_PRINT("Failed to open file %s\n", DCC_CFG_FILE);
|
|
return;
|
|
}
|
|
|
|
*chan = &g_chan[0];
|
|
*state_cfg = &g_state_cfg[0];
|
|
|
|
initialize_dcc_config(*chan, *state_cfg);
|
|
|
|
while(0 < getline(&line, &len, fp)) {
|
|
linecount++;
|
|
DCC_DEBUG_PRINT("linecount %d\n", linecount);
|
|
DCC_DEBUG_PRINT("%u : %s\n", linecount, line);
|
|
num_tokens = tokenize_string(line, &tokens[0]);
|
|
|
|
for (i = 0; i < num_tokens; i++) {
|
|
DCC_DEBUG_PRINT("%d: %s\n", i, tokens[i]);
|
|
}
|
|
|
|
if (num_tokens > 0) {
|
|
DCC_DEBUG_PRINT("Step %d\n", 5);
|
|
update_dcc_config(num_tokens, &tokens[0],
|
|
*chan,
|
|
*state_cfg);
|
|
}
|
|
}
|
|
|
|
if (num_active_states == NULL) {
|
|
fclose(fp);
|
|
return;
|
|
}
|
|
|
|
*num_active_states = 0;
|
|
for (i = 0; i < g_num_channels; i++) {
|
|
*num_active_states += DCC_NDL_NUM_ACTIVE_STATE_GET(&g_chan[i]);
|
|
DCC_DEBUG_PRINT("DCC num_active_states for chan idx %u: %lu\n",
|
|
i, DCC_NDL_NUM_ACTIVE_STATE_GET(&g_chan[i]));
|
|
}
|
|
|
|
/* Copy over state configurations for channel 2 to right after that of channel 1 to make it contiguous */
|
|
if (g_num_channels > 1) {
|
|
memcpy(&g_state_cfg[DCC_NDL_NUM_ACTIVE_STATE_GET(&g_chan[0])],
|
|
&g_state_cfg[DCC_NDL_ACTIVE_STATE_SIZE],
|
|
sizeof(dcc_ndl_active_state_config) * DCC_NDL_NUM_ACTIVE_STATE_GET(&g_chan[1]));
|
|
}
|
|
|
|
*num_channels = g_num_channels;
|
|
|
|
fclose(fp);
|
|
}
|
|
|
|
void dcc_print_stats(unsigned char num_channels, dcc_ndl_stats_per_channel *stats)
|
|
{
|
|
unsigned long i, ac, mcs;
|
|
|
|
DCC_PRINT("DCC stats num_channels = %d\n", num_channels);
|
|
|
|
for (i = 0; i < num_channels; i++) {
|
|
|
|
DCC_PRINT("DCC NDL chan freq = %lu\n", DCC_NDL_STATS_CHAN_FREQ_GET(&stats[i]));
|
|
DCC_PRINT("DCC NDL stats bitmap = %lu\n", DCC_NDL_STATS_DCC_STATS_BITMAP_GET(&stats[i]));
|
|
|
|
for (mcs = 0; mcs < 8; mcs++) {
|
|
DCC_PRINT("DCC NDL snr backoff (mcs=%lu) = %lu\n", mcs, DCC_NDL_STATS_SNR_BACKOFF_GET(&stats[i], mcs));
|
|
}
|
|
|
|
DCC_PRINT("DCC NDL tx power = %lu\n", DCC_TX_POWER_GET(&stats[i]));
|
|
DCC_PRINT("DCC NDL datarate = %lu\n", DCC_TX_DATARATE_GET(&stats[i]));
|
|
DCC_PRINT("DCC NDL carrier sense range = %lu\n", DCC_NDL_CARRIER_SENSE_RANGE_GET(&stats[i]));
|
|
DCC_PRINT("DCC NDL communication range = %lu\n", DCC_NDL_EST_COMM_RANGE_GET(&stats[i]));
|
|
DCC_PRINT("DCC NDL sensitivity = %lu\n", DCC_DCC_SENSITIVITY_GET(&stats[i]));
|
|
DCC_PRINT("DCC NDL carrier sense = %lu\n", DCC_CARRIER_SENSE_GET(&stats[i]));
|
|
DCC_PRINT("DCC NDL channel load = %lu\n", DCC_NDL_CHANNEL_LOAD_GET(&stats[i]));
|
|
DCC_PRINT("DCC NDL arrival rate = %lu\n", DCC_NDL_PACKET_ARRIVAL_RATE_GET(&stats[i]));
|
|
DCC_PRINT("DCC NDL avg duration = %lu\n", DCC_NDL_PACKET_AVG_DURATION_GET(&stats[i]));
|
|
DCC_PRINT("DCC NDL channel busy time = %lu\n", DCC_NDL_CHANNEL_BUSY_TIME_GET(&stats[i]));
|
|
|
|
for (ac = DCC_AC_VO; ac < DCC_AC_MAX; ac++) {
|
|
DCC_PRINT("DCC NDL tx packet arrival rate (ac=%lu) = %lu\n", ac, DCC_NDL_TX_PACKET_ARRIVAL_RATE_GET(&stats[i], ac));
|
|
DCC_PRINT("DCC NDL tx packet avg duration (ac=%lu) = %lu\n", ac, DCC_NDL_TX_PACKET_AVG_DURATION_GET(&stats[i], ac));
|
|
DCC_PRINT("DCC NDL tx channel use (ac=%lu) = %lu\n", ac, DCC_NDL_TX_CHANNEL_USE_GET(&stats[i], ac));
|
|
DCC_PRINT("DCC NDL tx signal avg power (ac=%lu) = %lu\n", ac, DCC_NDL_TX_SIGNAL_AVG_POWER_GET(&stats[i], ac));
|
|
}
|
|
}
|
|
}
|