| /*SH0 |
| ******************************************************************************* |
| ** ** |
| ** Copyright (c) 2009 - 2011 Quantenna Communications Inc ** |
| ** ** |
| ** File : vsp_doc.c ** |
| ** Description : Automatically create VSP QCSAPI documentation ** |
| ** ** |
| ******************************************************************************* |
| ** ** |
| ** Redistribution and use in source and binary forms, with or without ** |
| ** modification, are permitted provided that the following conditions ** |
| ** are met: ** |
| ** 1. Redistributions of source code must retain the above copyright ** |
| ** notice, this list of conditions and the following disclaimer. ** |
| ** 2. 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. ** |
| ** 3. The name of the author may not be used to endorse or promote products ** |
| ** derived from this software without specific prior written permission. ** |
| ** ** |
| ** Alternatively, this software may be distributed under the terms of the ** |
| ** GNU General Public License ("GPL") version 2, or (at your option) any ** |
| ** later version as published by the Free Software Foundation. ** |
| ** ** |
| ** In the case this software is distributed under the GPL license, ** |
| ** you should have received a copy of the GNU General Public License ** |
| ** along with this software; if not, write to the Free Software ** |
| ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ** |
| ** ** |
| ** THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR ** |
| ** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES** |
| ** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ** |
| ** IN NO EVENT SHALL THE AUTHOR 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. ** |
| ** ** |
| ******************************************************************************* |
| EH0*/ |
| |
| #define inline |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <stdint.h> |
| #include <string.h> |
| |
| #include "qcsapi.h" |
| |
| static const struct qvsp_rule_param qvsp_rule_params[] = QVSP_RULE_PARAMS; |
| static const struct qvsp_cfg_param qvsp_cfg_params[] = QVSP_CFG_PARAMS; |
| static const char *qvsp_rule_order_desc[] = QVSP_RULE_ORDER_DESCS; |
| |
| #define E(x) case x: return #x |
| |
| static const char *qvspdoc_enumstr_cfg(enum qvsp_cfg_param_e e) |
| { |
| switch (e) { |
| E(QVSP_CFG_ENABLED); |
| E(QVSP_CFG_ENABLED_ALWAYS); |
| E(QVSP_CFG_FAT_MIN); |
| E(QVSP_CFG_FAT_MIN_SOFT); |
| E(QVSP_CFG_FAT_MIN_SOFT_CONSEC); |
| E(QVSP_CFG_FAT_MIN_SAFE); |
| E(QVSP_CFG_FAT_MIN_CHECK_INTV); |
| E(QVSP_CFG_FAT_MAX_SOFT); |
| E(QVSP_CFG_FAT_MAX_SOFT_CONSEC); |
| E(QVSP_CFG_FAT_MAX_SAFE); |
| E(QVSP_CFG_FAT_MAX_CHECK_INTV); |
| E(QVSP_CFG_NODE_DATA_MIN); |
| E(QVSP_CFG_DISABLE_DEMOTE); |
| E(QVSP_CFG_DISABLE_DEMOTE_FIX_FAT); |
| E(QVSP_CFG_DISABLE_WAIT); |
| E(QVSP_CFG_DISABLE_PER_EVENT_MAX); |
| E(QVSP_CFG_ENABLE_WAIT); |
| E(QVSP_CFG_ENABLE_PER_EVENT_MAX); |
| E(QVSP_CFG_STRM_RMT_DIS_TCP); |
| E(QVSP_CFG_STRM_RMT_DIS_UDP); |
| E(QVSP_CFG_STRM_TPUT_MIN); |
| E(QVSP_CFG_STRM_DISABLED_MAX); |
| E(QVSP_CFG_STRM_ADPT_THROT); |
| E(QVSP_CFG_STRM_ADPT_THROT_STEP); |
| E(QVSP_CFG_STRM_ADPT_THROT_MARGIN); |
| E(QVSP_CFG_STRM_TPUT_SMPL_MIN); |
| E(QVSP_CFG_STRM_COST_RC_ADJUST); |
| E(QVSP_CFG_STRM_MAX); |
| E(QVSP_CFG_STRM_MAX_AC0); |
| E(QVSP_CFG_STRM_MAX_AC1); |
| E(QVSP_CFG_STRM_MAX_AC2); |
| E(QVSP_CFG_STRM_MAX_AC3); |
| E(QVSP_CFG_STRM_MIN); |
| E(QVSP_CFG_STRM_MIN_AC0); |
| E(QVSP_CFG_STRM_MIN_AC1); |
| E(QVSP_CFG_STRM_MIN_AC2); |
| E(QVSP_CFG_STRM_MIN_AC3); |
| E(QVSP_CFG_STRM_TPUT_MAX_TCP); |
| E(QVSP_CFG_STRM_TPUT_MAX_TCP_AC0); |
| E(QVSP_CFG_STRM_TPUT_MAX_TCP_AC1); |
| E(QVSP_CFG_STRM_TPUT_MAX_TCP_AC2); |
| E(QVSP_CFG_STRM_TPUT_MAX_TCP_AC3); |
| E(QVSP_CFG_STRM_TPUT_MAX_UDP); |
| E(QVSP_CFG_STRM_TPUT_MAX_UDP_AC0); |
| E(QVSP_CFG_STRM_TPUT_MAX_UDP_AC1); |
| E(QVSP_CFG_STRM_TPUT_MAX_UDP_AC2); |
| E(QVSP_CFG_STRM_TPUT_MAX_UDP_AC3); |
| E(QVSP_CFG_STRM_ENABLE_WAIT); |
| E(QVSP_CFG_STRM_AGE_MAX); |
| E(QVSP_CFG_AGE_CHK_INTV); |
| E(QVSP_CFG_3RDPT_CTL); |
| E(QVSP_CFG_3RDPT_LOCAL_THROT); |
| E(QVSP_CFG_3RDPT_QTN); |
| E(QVSP_CFG_BA_THROT_INTV); |
| E(QVSP_CFG_BA_THROT_DUR_MIN); |
| E(QVSP_CFG_BA_THROT_DUR_STEP); |
| E(QVSP_CFG_BA_THROT_WINSIZE_MIN); |
| E(QVSP_CFG_BA_THROT_WINSIZE_MAX); |
| E(QVSP_CFG_WME_THROT_AC); |
| E(QVSP_CFG_WME_THROT_AIFSN); |
| E(QVSP_CFG_WME_THROT_ECWMIN); |
| E(QVSP_CFG_WME_THROT_ECWMAX); |
| E(QVSP_CFG_WME_THROT_TXOPLIMIT); |
| E(QVSP_CFG_WME_THROT_THRSH_DISABLED); |
| E(QVSP_CFG_WME_THROT_THRSH_VICTIM); |
| E(QVSP_CFG_EVENT_LOG_LVL); |
| E(QVSP_CFG_DEBUG_LOG_LVL); |
| E(QVSP_CFG_MAX); |
| } |
| return "unknown!"; |
| } |
| |
| static const char *qvspdoc_enumstr_rule_param(enum qvsp_rule_param_e e) |
| { |
| switch (e) { |
| E(QVSP_RULE_PARAM_DIR); |
| E(QVSP_RULE_PARAM_VAPPRI); |
| E(QVSP_RULE_PARAM_AC); |
| E(QVSP_RULE_PARAM_PROTOCOL); |
| E(QVSP_RULE_PARAM_TPUT_MIN); |
| E(QVSP_RULE_PARAM_TPUT_MAX); |
| E(QVSP_RULE_PARAM_COST_MIN); |
| E(QVSP_RULE_PARAM_COST_MAX); |
| E(QVSP_RULE_PARAM_ORDER); |
| E(QVSP_RULE_PARAM_THROT_POLICY); |
| E(QVSP_RULE_PARAM_DEMOTE); |
| E(QVSP_RULE_PARAM_MAX); |
| } |
| return "unknown!"; |
| } |
| |
| static const char *qvspdoc_enumstr_rule_order(enum qvsp_rule_order_e e) |
| { |
| switch (e) { |
| E(QVSP_RULE_ORDER_GREATEST_COST_NODE); |
| E(QVSP_RULE_ORDER_LEAST_COST_NODE); |
| E(QVSP_RULE_ORDER_GREATEST_NODE_INV_PHY_RATE); |
| E(QVSP_RULE_ORDER_LEAST_NODE_INV_PHY_RATE); |
| E(QVSP_RULE_ORDER_GREATEST_COST_STREAM); |
| E(QVSP_RULE_ORDER_LEAST_COST_STREAM); |
| E(QVSP_RULE_ORDER_NEWEST); |
| E(QVSP_RULE_ORDER_OLDEST); |
| E(QVSP_RULE_ORDER_LOWEST_TPUT); |
| E(QVSP_RULE_ORDER_HIGHEST_TPUT); |
| E(QVSP_RULE_ORDER_MAX); |
| } |
| return "unknown!"; |
| } |
| |
| static const char *qvspdoc_enumstr_rule_dir(enum qvsp_rule_dir_e e) |
| { |
| switch (e) { |
| E(QVSP_RULE_DIR_ANY); |
| E(QVSP_RULE_DIR_TX); |
| E(QVSP_RULE_DIR_RX); |
| } |
| return "unknown!"; |
| } |
| |
| static const char *qvsp_rule_dir_descs[] = QVSP_RULE_DIR_DESCS; |
| |
| static void create_cfg_table(void) |
| { |
| int i; |
| const struct qvsp_cfg_param *param; |
| |
| if (0) { |
| printf(" * <TABLE>\n"); |
| printf(" * <TR> <TD> \\b Enum </TD> <TD> \\b Name </TD> <TD> \\b Units </TD> " |
| "<TD> \\b Default </TD> <TD> \\b Min </TD> <TD> \\b Max </TD> <TD> \\b Description </TD> </TR>\n"); |
| |
| for (i = 0; i < QVSP_CFG_MAX; i++) { |
| param = &qvsp_cfg_params[i]; |
| printf(" * <TR><TD>%s (%d)</TD><TD>%s</TD><TD>%s</TD><TD>%u</TD><TD>%u</TD><TD>%u</TD><TD>%s</TD></TR>\n", |
| qvspdoc_enumstr_cfg(i), |
| i, |
| param->name, |
| param->units, |
| param->default_val, |
| param->min_val, |
| param->max_val, |
| param->desc); |
| } |
| |
| printf(" * </TABLE>\n"); |
| } else if(0) { |
| static int colwidths[] = {34, 23, 10, 8, 8, 8, 32}; |
| |
| printf(" * @section vsp_cfg_table VSP Configuration options\n"); |
| printf(" *\n"); |
| printf(" * @code\n"); |
| |
| |
| printf(" * %-*s%-*s%-*s%-*s%-*s%-*s%-*s\n", |
| colwidths[0], "Enum", |
| colwidths[1], "Name", |
| colwidths[2], "Units", |
| colwidths[3], "Default", |
| colwidths[4], "Minimum", |
| colwidths[5], "Maximum", |
| colwidths[6], "Description"); |
| |
| for (i = 0; i < QVSP_CFG_MAX; i++) { |
| param = &qvsp_cfg_params[i]; |
| printf(" * %2d %-*s%-*s%-*s%-*u%-*u%-*u%-*s\n", |
| i, colwidths[0] - 2, qvspdoc_enumstr_cfg(i), |
| colwidths[1], param->name, |
| colwidths[2], param->units, |
| colwidths[3], param->default_val, |
| colwidths[4], param->min_val, |
| colwidths[5], param->max_val, |
| colwidths[6], param->desc); |
| } |
| |
| printf(" * @endcode\n *\n"); |
| } else { |
| printf(" * @section vsp_cfg_table VSP Configuration options\n"); |
| |
| for (i = 0; i < QVSP_CFG_MAX; i++) { |
| param = &qvsp_cfg_params[i]; |
| printf(" * \\li %d: %s - %s<br>Default: %u %s [%u - %u]. %s\n", |
| i, |
| qvspdoc_enumstr_cfg(i), |
| param->name, |
| param->default_val, |
| param->units, |
| param->min_val, |
| param->max_val, |
| param->desc); |
| } |
| } |
| } |
| |
| static void create_rule_table(void) |
| { |
| int i; |
| int j; |
| const struct qvsp_rule_param *rule_param; |
| |
| printf(" * @section vsp_rule_table VSP Rule options\n"); |
| for (i = 0; i < QVSP_RULE_PARAM_MAX; i++) { |
| rule_param = &qvsp_rule_params[i]; |
| printf(" * - %d: %s - %s<br>[%u - %u %s]. %s\n", |
| i, |
| qvspdoc_enumstr_rule_param(i), |
| rule_param->name, |
| rule_param->min_val, |
| rule_param->max_val, |
| rule_param->units, |
| rule_param->desc); |
| switch (i) { |
| case QVSP_RULE_PARAM_DIR: |
| printf(" * <br>Possible values are:\n"); |
| for (j = 0; j < ARRAY_SIZE(qvsp_rule_dir_descs); j++) { |
| printf(" - %s - %s\n", |
| qvspdoc_enumstr_rule_dir(j), |
| qvsp_rule_dir_descs[j]); |
| } |
| break; |
| case QVSP_RULE_PARAM_VAPPRI: |
| printf(" * <br>Possible values are:\n"); |
| printf(" - 0x01 = VAP priority 0\n"); |
| printf(" - 0x02 = VAP priority 1\n"); |
| printf(" - 0x04 = VAP priority 2\n"); |
| printf(" - 0x08 = VAP priority 3\n"); |
| break; |
| case QVSP_RULE_PARAM_AC: |
| printf(" * <br>Possible values are:\n"); |
| printf(" - 0x01 = Best Effort (0)\n"); |
| printf(" - 0x02 = Background (1)\n"); |
| printf(" - 0x04 = Voice (2)\n"); |
| printf(" - 0x08 = Video (3)\n"); |
| break; |
| case QVSP_RULE_PARAM_ORDER: |
| printf(" * <br>Allowed match orderings are (see enum qvsp_rule_order_e):\n"); |
| for (j = 0; j < QVSP_RULE_ORDER_MAX; j++) { |
| printf(" - %d: %s<br>%s\n", |
| j, |
| qvspdoc_enumstr_rule_order(j), |
| qvsp_rule_order_desc[j]); |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| |
| int main(int argc, char **argv) |
| { |
| printf("/** \\addtogroup vsp_group\n\n"); |
| create_cfg_table(); |
| create_rule_table(); |
| printf(" */\n"); |
| return 0; |
| } |