777 lines
17 KiB
C
777 lines
17 KiB
C
/****************************************************************************
|
|
* apps/system/cfgdata/cfgdata_main.c
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership. The
|
|
* ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance with the
|
|
* License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Included Files
|
|
****************************************************************************/
|
|
|
|
#include <nuttx/config.h>
|
|
#include <nuttx/mtd/mtd.h>
|
|
#include <nuttx/mtd/configdata.h>
|
|
#include <sys/ioctl.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <ctype.h>
|
|
#include <inttypes.h>
|
|
|
|
/****************************************************************************
|
|
* Private data
|
|
****************************************************************************/
|
|
|
|
static const char *g_config_dev = "/dev/config";
|
|
|
|
/****************************************************************************
|
|
* Private Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Print usage information
|
|
****************************************************************************/
|
|
|
|
static void cfgdatacmd_help(void)
|
|
{
|
|
printf("\nUsage: cfgdata <cmd> [arguments]\n");
|
|
printf("Where <cmd> is one of:\n\n");
|
|
printf(" all: show all config entries\n");
|
|
printf(" print: display a specific config entry\n");
|
|
printf(" set: set or change a config entry\n");
|
|
printf(" unset: delete a config entry\n");
|
|
printf(" format: delete all config entries\n\n");
|
|
|
|
printf("Syntax for 'set' cmd:\n");
|
|
#ifdef CONFIG_MTD_CONFIG_NAMED
|
|
printf(" set name [hex_byte,hex_byte,etc.]\n");
|
|
printf(" set name \"string\"\n\n");
|
|
#else
|
|
printf(" set id,instance [bytes]\n");
|
|
printf(" set id,instance \"string\"\n\n");
|
|
#endif
|
|
|
|
printf("Syntax for 'print' cmd:\n");
|
|
#ifdef CONFIG_MTD_CONFIG_NAMED
|
|
printf(" print name\n");
|
|
#else
|
|
printf(" print id,instance\n");
|
|
#endif
|
|
|
|
printf("Syntax for 'unset' cmd:\n");
|
|
#ifdef CONFIG_MTD_CONFIG_NAMED
|
|
printf(" unset name\n");
|
|
#else
|
|
printf(" unset id,instance\n");
|
|
#endif
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Parse out the id,inst,name tokens
|
|
****************************************************************************/
|
|
|
|
#ifndef CONFIG_MTD_CONFIG_NAMED
|
|
static int cfgdatacmd_idtok(int startpos, char *token)
|
|
{
|
|
while (token[startpos] != ',' && token[startpos] != '\0')
|
|
{
|
|
startpos++;
|
|
}
|
|
|
|
if (token[startpos] != ',')
|
|
{
|
|
/* Error in format */
|
|
|
|
printf("Expected config identifier in 'id,instance' format\n");
|
|
return 0;
|
|
}
|
|
|
|
/* return, skipping the ',' */
|
|
|
|
return startpos + 1;
|
|
}
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Set a config item value
|
|
*
|
|
* config set 1,0,wr_width_cs0 [0x3]
|
|
* config set 1,1,wr_width_cs1 [0x2]
|
|
*
|
|
****************************************************************************/
|
|
|
|
static void cfgdatacmd_parse_byte_array(struct config_data_s *cfg,
|
|
int argc, char *argv[])
|
|
{
|
|
int x;
|
|
int c;
|
|
int count;
|
|
int val;
|
|
|
|
/* Start with arg3 */
|
|
|
|
x = 3;
|
|
c = 1;
|
|
count = 0;
|
|
|
|
/* Loop for all remaining arguments until ']' found */
|
|
|
|
while (x < argc && argv[x][c] != ']' && argv[x][c] != '\0')
|
|
{
|
|
/* Count this item */
|
|
|
|
count++;
|
|
|
|
/* Skip to next item */
|
|
|
|
while (argv[x][c] != ',' && argv[x][c] != ']' && argv[x][c] != 0)
|
|
{
|
|
c++;
|
|
}
|
|
|
|
/* Test for comma separator */
|
|
|
|
if (argv[x][c] == ',')
|
|
{
|
|
c++;
|
|
}
|
|
|
|
/* Test for space separated items */
|
|
|
|
if (argv[x][c] == 0)
|
|
{
|
|
x++;
|
|
c = 0;
|
|
}
|
|
}
|
|
|
|
/* Test if static stack space allocation is big enough for data */
|
|
|
|
if (count > cfg->len)
|
|
{
|
|
/* Perform dynamic memory allocation */
|
|
|
|
cfg->configdata = (FAR uint8_t *)malloc(count);
|
|
cfg->len = count;
|
|
}
|
|
|
|
/* Count determined. Start with arg3 again and parse the bytes */
|
|
|
|
x = 3;
|
|
c = 1;
|
|
count = 0;
|
|
|
|
/* Loop for all remaining arguments until ']' found */
|
|
|
|
while (x < argc && argv[x][c] != ']' && argv[x][c] != '\0')
|
|
{
|
|
/* Parse this item */
|
|
|
|
if (strncmp(&argv[x][c], "0x", 2) == 0)
|
|
{
|
|
/* Hex byte */
|
|
|
|
sscanf(&argv[x][c + 2], "%x", &val);
|
|
cfg->configdata[count] = (uint8_t)val;
|
|
}
|
|
else
|
|
{
|
|
/* Decimal value */
|
|
|
|
cfg->configdata[count] = (uint8_t)atoi(&argv[x][c]);
|
|
}
|
|
|
|
/* Increment the count */
|
|
|
|
count++;
|
|
|
|
/* Skip to next item */
|
|
|
|
while (argv[x][c] != ',' && argv[x][c] != ']' && argv[x][c] != 0)
|
|
{
|
|
c++;
|
|
}
|
|
|
|
/* Test for comma separator */
|
|
|
|
if (argv[x][c] == ',')
|
|
{
|
|
c++;
|
|
}
|
|
|
|
/* Test for space separated items */
|
|
|
|
if (argv[x][c] == 0)
|
|
{
|
|
x++;
|
|
c = 0;
|
|
}
|
|
}
|
|
|
|
cfg->len = count;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Set a config item value
|
|
*
|
|
* config set 1,0,wr_width_cs0 [0x3]
|
|
* config set 1,1,wr_width_cs1 [0x2]
|
|
*
|
|
****************************************************************************/
|
|
|
|
static void cfgdatacmd_set(int argc, char *argv[])
|
|
{
|
|
int ret;
|
|
int fd;
|
|
int x;
|
|
struct config_data_s cfg;
|
|
uint8_t data[32];
|
|
|
|
#ifdef CONFIG_MTD_CONFIG_NAMED
|
|
|
|
/* Copy the name to the cfg struct */
|
|
|
|
strlcpy(cfg.name, argv[2], CONFIG_MTD_CONFIG_NAME_LEN);
|
|
|
|
#else
|
|
|
|
/* Parse the id and instance */
|
|
|
|
cfg.id = atoi(argv[2]);
|
|
|
|
/* Advance past ',' to instance number */
|
|
|
|
x = cfgdatacmd_idtok(0, argv[2]);
|
|
if (x == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/* Convert instance to integer */
|
|
|
|
cfg.instance = atoi(&argv[2][x]);
|
|
#endif
|
|
|
|
/* Test if data is an array of bytes or simple string */
|
|
|
|
if (argv[3][0] == '[')
|
|
{
|
|
/* It is an array of bytes. Count the number of bytes */
|
|
|
|
cfg.configdata = data;
|
|
cfg.len = sizeof(data);
|
|
cfgdatacmd_parse_byte_array(&cfg, argc, argv);
|
|
}
|
|
else
|
|
{
|
|
bool isnumber = true;
|
|
|
|
/* It is a simple string. Test if it looks like a number */
|
|
|
|
cfg.configdata = data;
|
|
if (strncmp(argv[3], "0x", 2) == 0)
|
|
{
|
|
/* Test for all hex digit values */
|
|
|
|
for (x = 2; x < strlen(argv[3]); x++)
|
|
{
|
|
if (!isxdigit(argv[3][x]))
|
|
{
|
|
isnumber = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (isnumber)
|
|
{
|
|
sscanf(&argv[3][2], "%" SCNx32, (int32_t *)&cfg.configdata);
|
|
cfg.len = 4;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Test for all hex digit values */
|
|
|
|
for (x = 0; x < strlen(argv[3]); x++)
|
|
{
|
|
if (!isdigit(argv[3][x]))
|
|
{
|
|
isnumber = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (isnumber)
|
|
{
|
|
int32_t temp = atoi(argv[3]);
|
|
*((int32_t *)cfg.configdata) = temp;
|
|
cfg.len = 4;
|
|
}
|
|
}
|
|
|
|
if (!isnumber)
|
|
{
|
|
/* Point to the string and calculate the length */
|
|
|
|
cfg.configdata = (FAR uint8_t *)argv[3];
|
|
cfg.len = strlen(argv[3]) + 1;
|
|
}
|
|
}
|
|
|
|
/* Now open the /dev/config file and set the config item */
|
|
|
|
if ((fd = open(g_config_dev, 0)) < 2)
|
|
{
|
|
/* Display error */
|
|
|
|
printf("error: unable to open %s\n", g_config_dev);
|
|
return;
|
|
}
|
|
|
|
ret = ioctl(fd, CFGDIOC_SETCONFIG, (unsigned long)(uintptr_t)&cfg);
|
|
|
|
/* Close the file and report error if any */
|
|
|
|
close(fd);
|
|
if (ret != OK)
|
|
{
|
|
printf("Error %d setting config entry\n", errno);
|
|
}
|
|
|
|
/* Free the cfg.configdata if needed */
|
|
|
|
if (cfg.configdata != (FAR uint8_t *)argv[3] &&
|
|
cfg.configdata != data)
|
|
{
|
|
free(cfg.configdata);
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Unset a config item value
|
|
****************************************************************************/
|
|
|
|
static void cfgdatacmd_unset(int argc, char *argv[])
|
|
{
|
|
int ret;
|
|
int fd;
|
|
struct config_data_s cfg;
|
|
|
|
#ifdef CONFIG_MTD_CONFIG_NAMED
|
|
/* Copy the name to the cfg struct */
|
|
|
|
strlcpy(cfg.name, argv[2], CONFIG_MTD_CONFIG_NAME_LEN);
|
|
|
|
#else
|
|
int x;
|
|
|
|
/* Parse the id and instance */
|
|
|
|
cfg.id = atoi(argv[2]);
|
|
|
|
/* Advance past ',' to instance number */
|
|
|
|
x = cfgdatacmd_idtok(0, argv[2]);
|
|
if (x == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/* Convert instance to integer */
|
|
|
|
cfg.instance = atoi(&argv[2][x]);
|
|
#endif
|
|
|
|
cfg.configdata = NULL;
|
|
cfg.len = 0;
|
|
|
|
/* Try to open the /dev/config file */
|
|
|
|
if ((fd = open(g_config_dev, 0)) < 2)
|
|
{
|
|
/* Display error */
|
|
|
|
printf("error: unable to open %s\n", g_config_dev);
|
|
return;
|
|
}
|
|
|
|
/* Delete the config item */
|
|
|
|
ret = ioctl(fd, CFGDIOC_DELCONFIG, (unsigned long)(uintptr_t)&cfg);
|
|
close(fd);
|
|
|
|
if (ret != OK)
|
|
{
|
|
printf("Error deletign config entry '%s'\n", argv[2]);
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Print a config item value
|
|
*
|
|
* config print 1,1
|
|
* config print wr_width_cs0
|
|
*
|
|
****************************************************************************/
|
|
|
|
static void cfgdatacmd_print(int argc, char *argv[])
|
|
{
|
|
int ret;
|
|
int fd;
|
|
int x;
|
|
struct config_data_s cfg;
|
|
bool isstring;
|
|
|
|
#ifdef CONFIG_MTD_CONFIG_NAMED
|
|
|
|
/* Copy the name to the cfg struct */
|
|
|
|
strlcpy(cfg.name, argv[2], CONFIG_MTD_CONFIG_NAME_LEN);
|
|
|
|
#else
|
|
|
|
/* Parse the id and instance */
|
|
|
|
cfg.id = atoi(argv[2]);
|
|
|
|
/* Advance past ',' to instance number */
|
|
|
|
x = cfgdatacmd_idtok(0, argv[2]);
|
|
if (x == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/* Convert instance to integer */
|
|
|
|
cfg.instance = atoi(&argv[2][x]);
|
|
#endif
|
|
|
|
/* Try to open the /dev/config file */
|
|
|
|
if ((fd = open(g_config_dev, O_RDONLY)) < 2)
|
|
{
|
|
/* Display error */
|
|
|
|
printf("error: unable to open %s\n", g_config_dev);
|
|
return;
|
|
}
|
|
|
|
cfg.configdata = (FAR uint8_t *)malloc(256);
|
|
cfg.len = 256;
|
|
if (cfg.configdata == NULL)
|
|
{
|
|
printf("Error allocating buffer\n");
|
|
return;
|
|
}
|
|
|
|
/* Get the config item */
|
|
|
|
ret = ioctl(fd, CFGDIOC_GETCONFIG, (unsigned long)(uintptr_t)&cfg);
|
|
close(fd);
|
|
|
|
if (ret != OK)
|
|
{
|
|
printf("Error reading config entry '%s'\n", argv[2]);
|
|
free(cfg.configdata);
|
|
return;
|
|
}
|
|
|
|
/* Display the data */
|
|
|
|
isstring = cfg.configdata[cfg.len - 1] == 0;
|
|
for (x = 0; x < cfg.len - 1; x++)
|
|
{
|
|
/* Test for all ascii characters */
|
|
|
|
if (cfg.configdata[x] < ' ' || cfg.configdata[x] > '~')
|
|
{
|
|
isstring = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Display the data */
|
|
|
|
if (isstring)
|
|
{
|
|
printf("%s\n", cfg.configdata);
|
|
}
|
|
else
|
|
{
|
|
/* Loop though all bytes and display them */
|
|
|
|
for (x = 0; x < cfg.len; x++)
|
|
{
|
|
/* Print the next byte */
|
|
|
|
printf("0x%02X ", cfg.configdata[x]);
|
|
|
|
if (((x + 1) & 7) == 0 && x + 1 != cfg.len)
|
|
{
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
free(cfg.configdata);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Enumerate and display all config items
|
|
****************************************************************************/
|
|
|
|
static void cfgdatacmd_show_all_config_items(void)
|
|
{
|
|
int ret;
|
|
int fd;
|
|
int x;
|
|
struct config_data_s cfg;
|
|
char fmtstr[24];
|
|
bool isstring;
|
|
|
|
/* Try to open the /dev/config file */
|
|
|
|
if ((fd = open(g_config_dev, 0)) < 2)
|
|
{
|
|
/* Display error */
|
|
|
|
printf("error: unable to open %s\n", g_config_dev);
|
|
return;
|
|
}
|
|
|
|
/* Print header */
|
|
|
|
#ifdef CONFIG_MTD_CONFIG_NAMED
|
|
snprintf(fmtstr, sizeof(fmtstr),
|
|
"%%-%ds%%-6sData\n", CONFIG_MTD_CONFIG_NAME_LEN);
|
|
printf(fmtstr, "Name", "Len");
|
|
snprintf(fmtstr, sizeof(fmtstr),
|
|
"%%-%ds%%-6d", CONFIG_MTD_CONFIG_NAME_LEN);
|
|
#else
|
|
strlcpy(fmtstr, "%-6s%-6s%-6sData\n", sizeof(fmtstr));
|
|
printf(fmtstr, "ID", "Inst", "Len");
|
|
strlcpy(fmtstr, "%-6d%-6d%-6d", sizeof(fmtstr));
|
|
#endif
|
|
|
|
/* Get the first config item */
|
|
|
|
cfg.configdata = (FAR uint8_t *)malloc(256);
|
|
cfg.len = 256;
|
|
if (cfg.configdata == NULL)
|
|
{
|
|
printf("Error allocating buffer\n");
|
|
return;
|
|
}
|
|
|
|
ret = ioctl(fd, CFGDIOC_FIRSTCONFIG, (unsigned long)(uintptr_t)&cfg);
|
|
|
|
while (ret != -1)
|
|
{
|
|
/* Print this entry */
|
|
|
|
#ifdef CONFIG_MTD_CONFIG_NAMED
|
|
printf(fmtstr, cfg.name, cfg.len);
|
|
#else
|
|
printf(fmtstr, cfg.id, cfg.instance, cfg.len);
|
|
#endif
|
|
|
|
/* Test if data is a string */
|
|
|
|
isstring = cfg.configdata[cfg.len - 1] == 0;
|
|
for (x = 0; x < cfg.len - 1; x++)
|
|
{
|
|
/* Test for all ascii characters */
|
|
|
|
if (cfg.configdata[x] < ' ' || cfg.configdata[x] > '~')
|
|
{
|
|
isstring = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Display the data */
|
|
|
|
if (isstring)
|
|
{
|
|
printf("%s\n", cfg.configdata);
|
|
}
|
|
else
|
|
{
|
|
char fmtstr2[10];
|
|
|
|
#ifdef CONFIG_MTD_CONFIG_NAMED
|
|
snprintf(fmtstr2, sizeof(fmtstr2),
|
|
"\n%ds", CONFIG_MTD_CONFIG_NAME_LEN + 6);
|
|
#else
|
|
strlcpy(fmtstr2, "\n%18s", sizeof(fmtstr2));
|
|
#endif
|
|
/* Loop though all bytes and display them */
|
|
|
|
for (x = 0; x < cfg.len; x++)
|
|
{
|
|
/* Print the next byte */
|
|
|
|
printf("0x%02X ", cfg.configdata[x]);
|
|
|
|
if (((x + 1) & 7) == 0 && x + 1 != cfg.len)
|
|
{
|
|
printf(fmtstr2, " ");
|
|
}
|
|
}
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
/* Get the next config item */
|
|
|
|
cfg.len = 256;
|
|
ret = ioctl(fd, CFGDIOC_NEXTCONFIG, (unsigned long)(uintptr_t)&cfg);
|
|
}
|
|
|
|
close(fd);
|
|
free(cfg.configdata);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Erase all config items
|
|
****************************************************************************/
|
|
|
|
static void cfgdatacmd_format(void)
|
|
{
|
|
int fd;
|
|
int ret;
|
|
|
|
/* Try to open the /dev/config file */
|
|
|
|
if ((fd = open(g_config_dev, 0)) < 2)
|
|
{
|
|
/* Display error */
|
|
|
|
printf("error: unable to open %s\n", g_config_dev);
|
|
return;
|
|
}
|
|
|
|
ret = ioctl(fd, MTDIOC_BULKERASE, 0);
|
|
close(fd);
|
|
|
|
if (ret != OK)
|
|
{
|
|
printf("Error %d config format\n", errno);
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
int main(int argc, FAR char *argv[])
|
|
{
|
|
/* Argument given? */
|
|
|
|
if (argc == 1)
|
|
{
|
|
/* Show usage info and exit */
|
|
|
|
cfgdatacmd_help();
|
|
return 0;
|
|
}
|
|
|
|
/* Test for "all" cmd */
|
|
|
|
if (strcmp(argv[1], "all") == 0)
|
|
{
|
|
/* Print the existing config items */
|
|
|
|
cfgdatacmd_show_all_config_items();
|
|
return 0;
|
|
}
|
|
|
|
/* Test for "set" cmd */
|
|
|
|
if (strcmp(argv[1], "set") == 0)
|
|
{
|
|
if (argc < 4)
|
|
{
|
|
printf("At least 2 arguments needed for 'set' command\n");
|
|
return 0;
|
|
}
|
|
|
|
/* Call the routine to set a config item */
|
|
|
|
cfgdatacmd_set(argc, argv);
|
|
return 0;
|
|
}
|
|
|
|
/* Test for "print" cmd */
|
|
|
|
if (strcmp(argv[1], "print") == 0)
|
|
{
|
|
/* Test for print all */
|
|
|
|
if (strcmp(argv[2], "all") == 0)
|
|
{
|
|
cfgdatacmd_show_all_config_items();
|
|
}
|
|
else
|
|
{
|
|
/* Call the routine to print a config item */
|
|
|
|
cfgdatacmd_print(argc, argv);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Test for "unset" cmd */
|
|
|
|
if (strcmp(argv[1], "unset") == 0)
|
|
{
|
|
if (argc < 3)
|
|
{
|
|
printf("Need 1 argument for 'unset' command\n");
|
|
return 0;
|
|
}
|
|
|
|
/* Call the routine to set a config item */
|
|
|
|
cfgdatacmd_unset(argc, argv);
|
|
return 0;
|
|
}
|
|
|
|
/* Test for "format" cmd */
|
|
|
|
if (strcmp(argv[1], "format") == 0)
|
|
{
|
|
/* Call the routine to erase all config items */
|
|
|
|
cfgdatacmd_format();
|
|
return 0;
|
|
}
|
|
|
|
/* Unknown cmd */
|
|
|
|
printf("Unknown config command: %s\n", argv[1]);
|
|
|
|
return 0;
|
|
}
|