static int command_lp5562(int argc, char **argv)
{
if (argc == 4) {
char *e;
uint8_t red, green, blue;
red = strtoi(argv[1], &e, 0);
if (e && *e)
return EC_ERROR_PARAM1;
green = strtoi(argv[2], &e, 0);
if (e && *e)
return EC_ERROR_PARAM2;
blue = strtoi(argv[3], &e, 0);
if (e && *e)
return EC_ERROR_PARAM3;
return lp5562_set_color((red << 16) | (green << 8) | blue);
} else if (argc == 2) {
int v;
if (!parse_bool(argv[1], &v))
return EC_ERROR_PARAM1;
if (v)
return lp5562_poweron();
else
return lp5562_poweroff();
}
return EC_ERROR_INVAL;
}
static int command_set_mode(int argc, char **argv)
{
int port_id = -1;
int mode = -1;
char *e;
if (argc == 1) {
ccprintf("Port 0: %d\nPort 1: %d\n",
charge_mode[0], charge_mode[1]);
return EC_SUCCESS;
}
if (argc != 3)
return EC_ERROR_PARAM_COUNT;
port_id = strtoi(argv[1], &e, 0);
if (*e || port_id < 0 || port_id >= USB_CHARGE_PORT_COUNT)
return EC_ERROR_PARAM1;
mode = strtoi(argv[2], &e, 0);
if (*e || mode < 0 || mode >= USB_CHARGE_MODE_COUNT)
return EC_ERROR_PARAM2;
return usb_charge_set_mode(port_id, mode);
}
int main(int argc, char* argv[])
{
FILTERKEYS fk = { sizeof(FILTERKEYS) };
if (argc == 3
&& strtoi(argv[1], &fk.iDelayMSec)
&& strtoi(argv[2], &fk.iRepeatMSec))
{
fk.dwFlags = FKF_FILTERKEYSON|FKF_AVAILABLE;
}
else
{
print(STD_OUTPUT_HANDLE,
"Usage: keyrate <delay ms> <repeat ms>\n"
"No parameters given: disabling.");
}
if (!SystemParametersInfo(SPI_SETFILTERKEYS, 0, (LPVOID) &fk, 0))
{
print(STD_ERROR_HANDLE,
"SystemParametersInfo(SPI_SETFILTERKEYS,..) failed.\n"
"Unable to set keyrate.");
}
return 0;
}
static int command_accelerometer_interrupt(int argc, char **argv)
{
char *e;
int id, thresh;
struct motion_sensor_t *sensor;
if (argc != 3)
return EC_ERROR_PARAM_COUNT;
/* First argument is id. */
id = strtoi(argv[1], &e, 0);
if (*e || id < 0 || id >= motion_sensor_count)
return EC_ERROR_PARAM1;
sensor = &motion_sensors[id];
/* Second argument is interrupt threshold. */
thresh = strtoi(argv[2], &e, 0);
if (*e)
return EC_ERROR_PARAM2;
sensor->drv->set_interrupt(sensor, thresh);
return EC_SUCCESS;
}
static int command_mem_dump(int argc, char **argv)
{
volatile uint32_t *address;
uint32_t value, num = 1, i;
char *e;
if (argc < 2)
return EC_ERROR_PARAM_COUNT;
address = (uint32_t *)(uintptr_t)strtoi(argv[1], &e, 0);
if (*e)
return EC_ERROR_PARAM1;
if (argc >= 3)
num = strtoi(argv[2], &e, 0);
for (i = 0; i < num; i++) {
value = address[i];
if (0 == (i%4))
ccprintf("\n%08X: %08x", address+i, value);
else
ccprintf(" %08x", value);
cflush();
/* Lots of output could take a while.
* Let other things happen, too */
if (!(i % 0x100)) {
watchdog_reload();
usleep(10 * MSEC);
}
}
ccprintf("\n");
cflush();
return EC_SUCCESS;
}
static int command_accel_read_xyz(int argc, char **argv)
{
char *e;
int id, n = 1, ret;
struct motion_sensor_t *sensor;
vector_3_t v;
if (argc < 2)
return EC_ERROR_PARAM_COUNT;
/* First argument is sensor id. */
id = strtoi(argv[1], &e, 0);
if (*e || id < 0 || id >= motion_sensor_count)
return EC_ERROR_PARAM1;
if (argc >= 3)
n = strtoi(argv[2], &e, 0);
sensor = &motion_sensors[id];
while ((n == -1) || (n-- > 0)) {
ret = sensor->drv->read(sensor, v);
if (ret == 0)
ccprintf("Current data %d: %-5d %-5d %-5d\n",
id, v[X], v[Y], v[Z]);
else
ccprintf("vector not ready\n");
ccprintf("Last calib. data %d: %-5d %-5d %-5d\n",
id, sensor->xyz[X], sensor->xyz[Y], sensor->xyz[Z]);
task_wait_event(MIN_MOTION_SENSE_WAIT_TIME);
}
return EC_SUCCESS;
}
static int command_hash(int argc, char **argv)
{
uint32_t offset = CONFIG_FW_RW_OFF;
uint32_t size = CONFIG_FW_RW_SIZE;
char *e;
if (argc == 1) {
ccprintf("Offset: 0x%08x\n", data_offset);
ccprintf("Size: 0x%08x (%d)\n", data_size, data_size);
ccprintf("Digest: ");
if (want_abort)
ccprintf("(aborting)\n");
else if (in_progress)
ccprintf("(in progress)\n");
else if (hash)
ccprintf("%.*h\n", SHA256_DIGEST_SIZE, hash);
else
ccprintf("(invalid)\n");
return EC_SUCCESS;
}
if (argc == 2) {
if (!strcasecmp(argv[1], "abort")) {
vboot_hash_abort();
return EC_SUCCESS;
} else if (!strcasecmp(argv[1], "rw")) {
return vboot_hash_start(
CONFIG_FW_RW_OFF,
system_get_image_used(SYSTEM_IMAGE_RW),
NULL, 0);
} else if (!strcasecmp(argv[1], "ro")) {
return vboot_hash_start(
CONFIG_FW_RO_OFF,
system_get_image_used(SYSTEM_IMAGE_RO),
NULL, 0);
}
}
if (argc >= 3) {
offset = strtoi(argv[1], &e, 0);
if (*e)
return EC_ERROR_PARAM1;
size = strtoi(argv[2], &e, 0);
if (*e)
return EC_ERROR_PARAM2;
}
if (argc == 4) {
int nonce = strtoi(argv[3], &e, 0);
if (*e)
return EC_ERROR_PARAM3;
return vboot_hash_start(offset, size,
(const uint8_t *)&nonce,
sizeof(nonce));
} else
return vboot_hash_start(offset, size, NULL, 0);
}
static int command_external_power_limit(int argc, char **argv)
{
int max_current;
int max_voltage;
char *e;
if (argc >= 2) {
max_current = strtoi(argv[1], &e, 10);
if (*e)
return EC_ERROR_PARAM1;
} else
max_current = EC_POWER_LIMIT_NONE;
if (argc >= 3) {
max_voltage = strtoi(argv[2], &e, 10);
if (*e)
return EC_ERROR_PARAM1;
} else
max_voltage = EC_POWER_LIMIT_NONE;
charge_manager_set_external_power_limit(max_current, max_voltage);
ccprintf("max req: %dmA %dmV\n", max_current, max_voltage);
return EC_SUCCESS;
}
static int command_gpio_set(int argc, char **argv)
{
#ifdef CONFIG_CMD_GPIO_EXTENDED
int gpio;
int flags = 0;
int af = -1;
char *e;
if (argc < 3)
return EC_ERROR_PARAM_COUNT;
gpio = find_signal_by_name(argv[1]);
if (gpio == GPIO_COUNT)
return EC_ERROR_PARAM1;
if (strcasecmp(argv[2], "IN") == 0)
flags = GPIO_INPUT;
else if (strcasecmp(argv[2], "1") == 0)
flags = GPIO_OUT_HIGH;
else if (strcasecmp(argv[2], "0") == 0)
flags = GPIO_OUT_LOW;
else if (strcasecmp(argv[2], "A") == 0)
flags = GPIO_ANALOG;
else if (strcasecmp(argv[2], "ALT") == 0) {
if (argc >= 4) {
af = strtoi(argv[3], &e, 0);
if (*e || af < 0 || af > 5)
return EC_ERROR_PARAM2;
}
flags = GPIO_ALTERNATE;
} else
return EC_ERROR_PARAM2;
/* Update alt function if requested. */
if (af >= 0) {
const struct gpio_info *g = gpio_list + gpio;
gpio_set_alternate_function(g->port, g->mask, af);
}
/* Update GPIO flags. */
gpio_set_flags(gpio, flags);
#else
char *e;
int v;
if (argc < 3)
return EC_ERROR_PARAM_COUNT;
v = strtoi(argv[2], &e, 0);
if (*e)
return EC_ERROR_PARAM2;
if (set(argv[1], v) != EC_SUCCESS)
return EC_ERROR_PARAM1;
#endif
return EC_SUCCESS;
}
static int command_spixfer(int argc, char **argv)
{
int dev_id;
uint8_t offset;
int v = 0;
uint8_t data[32];
char *e;
int rv = 0;
if (argc != 5)
return EC_ERROR_PARAM_COUNT;
dev_id = strtoi(argv[2], &e, 0);
if (*e)
return EC_ERROR_PARAM2;
offset = strtoi(argv[3], &e, 0);
if (*e)
return EC_ERROR_PARAM3;
v = strtoi(argv[4], &e, 0);
if (*e)
return EC_ERROR_PARAM4;
if (strcasecmp(argv[1], "rlen") == 0) {
uint8_t cmd = 0x80 | offset;
/* Arbitrary length read; param4 = len */
if (v < 0 || v > sizeof(data))
return EC_ERROR_PARAM4;
rv = spi_transaction(&spi_devices[dev_id], &cmd, 1, data, v);
if (!rv)
ccprintf("Data: %.*h\n", v, data);
} else if (strcasecmp(argv[1], "w") == 0) {
/* 8-bit write */
uint8_t cmd[2] = { offset, v };
rv = spi_transaction(&spi_devices[dev_id], cmd, 2, NULL, 0);
/*
* Some SPI device needs a delay before accepting other
* commands, otherwise the write might be ignored.
*/
msleep(1);
} else {
return EC_ERROR_PARAM1;
}
return rv;
}
static int command_tmp432(int argc, char **argv)
{
char *command;
char *e;
int data;
int offset;
int rv;
if (!has_power()) {
ccprintf("ERROR: Temp sensor not powered.\n");
return EC_ERROR_NOT_POWERED;
}
/* If no args just print status */
if (argc == 1)
return print_status();
if (argc < 3)
return EC_ERROR_PARAM_COUNT;
command = argv[1];
offset = strtoi(argv[2], &e, 0);
if (*e || offset < 0 || offset > 255)
return EC_ERROR_PARAM2;
if (!strcasecmp(command, "getbyte")) {
rv = raw_read8(offset, &data);
if (rv < 0)
return rv;
ccprintf("Byte at offset 0x%02x is %08b\n", offset, data);
return rv;
}
/* Remaining commands are "tmp432 set-command offset data" */
if (argc != 4)
return EC_ERROR_PARAM_COUNT;
data = strtoi(argv[3], &e, 0);
if (*e)
return EC_ERROR_PARAM3;
if (!strcasecmp(command, "settemp")) {
ccprintf("Setting 0x%02x to %dC\n", offset, data);
rv = tmp432_set_temp(offset, data);
} else if (!strcasecmp(command, "setbyte")) {
ccprintf("Setting 0x%02x to 0x%02x\n", offset, data);
rv = raw_write8(offset, data);
} else
return EC_ERROR_PARAM1;
return rv;
}
static int command_accel_data_rate(int argc, char **argv)
{
char *e;
int id, data, round = 1, ret;
struct motion_sensor_t *sensor;
enum sensor_config config_id;
if (argc < 2 || argc > 4)
return EC_ERROR_PARAM_COUNT;
/* First argument is sensor id. */
id = strtoi(argv[1], &e, 0);
if (*e || id < 0 || id >= motion_sensor_count)
return EC_ERROR_PARAM1;
sensor = &motion_sensors[id];
if (argc >= 3) {
/* Second argument is data to write. */
data = strtoi(argv[2], &e, 0);
if (*e)
return EC_ERROR_PARAM2;
if (argc == 4) {
/* Third argument is rounding flag. */
round = strtoi(argv[3], &e, 0);
if (*e)
return EC_ERROR_PARAM3;
}
/*
* Write new data rate, if it returns invalid arg, then
* return a parameter error.
*/
config_id = motion_sense_get_ec_config();
sensor->config[config_id].odr =
data | (round ? ROUND_UP_FLAG : 0);
ret = motion_sense_set_data_rate(sensor);
if (ret)
return EC_ERROR_PARAM2;
/* Sensor might be out of suspend, check the ec_rate */
motion_sense_set_accel_interval();
} else {
ccprintf("Data rate for sensor %d: %d\n", id,
sensor->drv->get_data_rate(sensor));
ccprintf("EC rate for sensor %d: %d\n", id,
motion_sense_ec_rate(sensor));
ccprintf("Current EC rate: %d\n", accel_interval);
}
return EC_SUCCESS;
}
static int command_mem_dump(int argc, char **argv)
{
uint32_t address, i, num = 1;
char *e;
enum format fmt = FMT_WORD;
if (argc > 1) {
if ((argv[1][0] == '.') && (strlen(argv[1]) == 2)) {
switch (argv[1][1]) {
case 'b':
fmt = FMT_BYTE;
break;
case 'h':
fmt = FMT_HALF;
break;
case 's':
fmt = FMT_STRING;
break;
default:
return EC_ERROR_PARAM1;
}
argc--;
argv++;
}
}
if (argc < 2)
return EC_ERROR_PARAM_COUNT;
address = strtoi(argv[1], &e, 0);
if (*e)
return EC_ERROR_PARAM1;
if (argc >= 3)
num = strtoi(argv[2], &e, 0);
for (i = 0; i < num; i++) {
show_val(address, i, fmt);
/* Lots of output could take a while.
* Let other things happen, too */
if (!(i % 0x100)) {
watchdog_reload();
usleep(10 * MSEC);
}
}
ccprintf("\n");
cflush();
return EC_SUCCESS;
}
static int command_set_mode(int argc, char **argv)
{
int port_id = -1;
int mode = -1;
char *e;
switch (argc) {
case 3:
port_id = strtoi(argv[1], &e, 0);
if (*e || port_id < 0 || port_id >= USB_PORT_COUNT)
return EC_ERROR_PARAM1;
if (!parse_bool(argv[2], &mode))
return EC_ERROR_PARAM2;
usb_port_set_enabled(port_id, mode);
/* fallthrough */
case 1:
ccprintf("Port 0: %s\nPort 1: %s\n",
state.en[0] ? "on" : "off",
state.en[1] ? "on" : "off");
return EC_SUCCESS;
}
return EC_ERROR_PARAM_COUNT;
}
static void showSelectedBoatInfo(WM_HWIN thisHandle)
{
WM_HWIN thisListView = thisHandle;
int SelectedRow = -1;
int i = 0;
long SelectedID = 0;
SelectedRow = LISTVIEW_GetSel(thisListView);
if(SelectedRow >= 0)
{
LISTVIEW_GetItemText(thisListView,1,SelectedRow,pStrBuf,10);
SelectedID = strtoi(pStrBuf);
while((boat_list_p[i]->user_id!=SelectedID) && (i<3))
{
i++;
}
/// Find the boat
if(i < 3)
{
index = i;
}
WM_InvalidateRect(subWins[0],&infoRect);
}
}
/**
* Modify and print the sleep mask which controls access to deep sleep
* mode in the idle task.
*/
static int command_sleepmask(int argc, char **argv)
{
int v;
if (argc >= 2) {
if (parse_bool(argv[1], &v)) {
if (v)
disable_sleep(SLEEP_MASK_FORCE_NO_DSLEEP);
else
enable_sleep(SLEEP_MASK_FORCE_NO_DSLEEP);
} else {
char *e;
v = strtoi(argv[1], &e, 10);
if (*e)
return EC_ERROR_PARAM1;
/* Set sleep mask directly. */
sleep_mask = v;
}
}
ccprintf("sleep mask: %08x\n", sleep_mask);
return EC_SUCCESS;
}
/* Upload a mapping to the emulator */
void loadmap(char *map)
{
int i;
int trans[6];
char *nextnum;
procstr(map);
nextnum = map;
for (i=0;i<6;i++) {
if (nextnum) {
trans[i] = strtoi(nextnum, &nextnum, 0);
if ( (!nextnum) ||
( (trans[i] > 127) && (trans[i] < 255) ) ||
(trans[i] > 255) )
printf("Parse error in value %d%s. Command ignored.", i, ofline);
}
if (!nextnum)
trans[i] = 255;
}
/* Load the remap into the emulator, command 4 */
emulcommand(4); /* 4 load remap */
testemul(254, "no load remap ACK");
for (i=0;i<6;i++)
writeemul(trans[i]);
testemul(6, "insufficient data"); /* test receipt of 6 arguments */
}
/* Returns the process ID inside path on success, otherwise -1.
* If no path is given, use the last pidfile path, othewise the default one. */
pid_t
pidfile_read(const char *path)
{
char dpath[PATH_MAX], buf[16], *eptr;
int fd, error;
ssize_t n;
pid_t pid;
if (path == NULL && pidfile_path[0] != '\0')
path = pidfile_path;
if (path == NULL || strchr(path, '/') == NULL) {
if (pidfile_varrun_path(dpath, sizeof(dpath), path) == -1)
return -1;
path = dpath;
}
if ((fd = open(path, O_RDONLY | O_NONBLOCK)) == -1)
return -1;
n = read(fd, buf, sizeof(buf) - 1);
error = errno;
(void) close(fd);
if (n == -1) {
errno = error;
return -1;
}
buf[n] = '\0';
pid = (pid_t)strtoi(buf, &eptr, 10, 1, INT_MAX, &error);
if (error && !(error == ENOTSUP && *eptr == '\n')) {
errno = error;
return -1;
}
return pid;
}
static int command_display_accel_info(int argc, char **argv)
{
char *e;
int val;
if (argc > 3)
return EC_ERROR_PARAM_COUNT;
/* First argument is on/off whether to display accel data. */
if (argc > 1) {
if (!parse_bool(argv[1], &val))
return EC_ERROR_PARAM1;
accel_disp = val;
}
/*
* Second arg changes the accel task time interval. Note accel
* sampling interval will be clobbered when chipset suspends or
* resumes.
*/
if (argc > 2) {
val = strtoi(argv[2], &e, 0);
if (*e)
return EC_ERROR_PARAM2;
accel_interval = val * MSEC;
task_wake(TASK_ID_MOTIONSENSE);
}
return EC_SUCCESS;
}
static int command_powerbtn(int argc, char **argv)
{
int ms = 200; /* Press duration in ms */
char *e;
if (argc > 1) {
ms = strtoi(argv[1], &e, 0);
if (*e)
return EC_ERROR_PARAM1;
}
ccprintf("Simulating %d ms power button press.\n", ms);
simulate_power_pressed = 1;
power_button_is_stable = 0;
hook_call_deferred(power_button_change_deferred, 0);
msleep(ms);
ccprintf("Simulating power button release.\n");
simulate_power_pressed = 0;
power_button_is_stable = 0;
hook_call_deferred(power_button_change_deferred, 0);
return EC_SUCCESS;
}
static int cmd_btn_press(int argc, char **argv)
{
enum gpio_signal gpio;
char *e;
int v;
if (argc < 2)
return EC_ERROR_PARAM_COUNT;
if (!strcasecmp(argv[1], "volup"))
gpio = GPIO_BTN_VOLU_L;
else if (!strcasecmp(argv[1], "voldown"))
gpio = GPIO_BTN_VOLD_L;
else
return EC_ERROR_PARAM1;
if (argc < 3) {
/* Just reading */
ccprintf("Button %s pressed = %d\n", argv[1],
!gpio_get_level(gpio));
return EC_SUCCESS;
}
v = strtoi(argv[2], &e, 0);
if (*e)
return EC_ERROR_PARAM2;
if (v)
gpio_set_flags(gpio, GPIO_OUT_LOW);
else
gpio_set_flags(gpio, GPIO_INPUT | GPIO_PULL_UP);
return EC_SUCCESS;
}
static int command_powerindebug(int argc, char **argv)
{
const struct power_signal_info *s = power_signal_list;
int i;
char *e;
/* If one arg, set the mask */
if (argc == 2) {
int m = strtoi(argv[1], &e, 0);
if (*e)
return EC_ERROR_PARAM1;
in_debug = m;
}
/* Print the mask */
ccprintf("power in: 0x%04x\n", in_signals);
ccprintf("debug mask: 0x%04x\n", in_debug);
/* Print the decode */
ccprintf("bit meanings:\n");
for (i = 0; i < POWER_SIGNAL_COUNT; i++, s++) {
int mask = 1 << i;
ccprintf(" 0x%04x %d %s\n",
mask, in_signals & mask ? 1 : 0, s->name);
}
return EC_SUCCESS;
};
static int
getsecs(const char *f, size_t l, bool local, struct conf *c, const char *p)
{
int e;
char *ep;
intmax_t tot, im;
tot = 0;
if (strcmp(p, "*") == 0) {
c->c_duration = FSTAR;
return 0;
}
if (strcmp(p, "=") == 0) {
if (local)
goto out;
c->c_duration = FEQUAL;
return 0;
}
again:
im = strtoi(p, &ep, 0, 0, INT_MAX, &e);
if (e == ENOTSUP) {
switch (*ep) {
case 'd':
im *= 24;
/*FALLTHROUGH*/
case 'h':
im *= 60;
/*FALLTHROUGH*/
case 'm':
im *= 60;
/*FALLTHROUGH*/
case 's':
e = 0;
tot += im;
if (ep[1] != '\0') {
p = ep + 2;
goto again;
}
break;
}
} else
tot = im;
if (e == 0) {
c->c_duration = (int)tot;
return 0;
}
if (f == NULL)
return -1;
(*lfun)(LOG_ERR, "%s: %s, %zu: Bad number [%s]", __func__, f, l, p);
return -1;
out:
(*lfun)(LOG_ERR, "%s: %s, %zu: `=' duration not allowed in local"
" config", __func__, f, l);
return -1;
}
uint8_t log_level() {
char *log_level_env = getenv("BBTB_LOG_LEVEL");
if (log_level_env == NULL) {
return 0;
}
return strtoi(log_level_env);
}
static int command_accelrange(int argc, char **argv)
{
char *e;
int id, data, round = 1;
struct motion_sensor_t *sensor;
if (argc < 2 || argc > 4)
return EC_ERROR_PARAM_COUNT;
/* First argument is sensor id. */
id = strtoi(argv[1], &e, 0);
if (*e || id < 0 || id >= motion_sensor_count)
return EC_ERROR_PARAM1;
sensor = &motion_sensors[id];
if (argc >= 3) {
/* Second argument is data to write. */
data = strtoi(argv[2], &e, 0);
if (*e)
return EC_ERROR_PARAM2;
if (argc == 4) {
/* Third argument is rounding flag. */
round = strtoi(argv[3], &e, 0);
if (*e)
return EC_ERROR_PARAM3;
}
/*
* Write new range, if it returns invalid arg, then return
* a parameter error.
*/
if (sensor->drv->set_range(sensor,
data,
round) == EC_ERROR_INVAL)
return EC_ERROR_PARAM2;
} else {
ccprintf("Range for sensor %d: %d\n", id,
sensor->drv->get_range(sensor));
}
return EC_SUCCESS;
}
static int command_hibernate(int argc, char **argv)
{
int seconds = 0;
int microseconds = 0;
if (argc >= 2)
seconds = strtoi(argv[1], NULL, 0);
if (argc >= 3)
microseconds = strtoi(argv[2], NULL, 0);
if (seconds || microseconds)
ccprintf("Hibernating for %d.%06d s\n", seconds, microseconds);
else
ccprintf("Hibernating until wake pin asserted.\n");
system_hibernate(seconds, microseconds);
return EC_SUCCESS;
}
/*
* Return a port number from a sockaddr_in expressed in universal address
* format. Note that this routine does not work for address families other
* than INET. Eventually, we should replace this routine with one that
* contacts the rpcbind running locally.
*/
int
rpc_uaddr2port(int af, char *addr)
{
int p1;
int p2;
char *next, *p;
if (af == AF_INET) {
/*
* A struct sockaddr_in expressed in universal address
* format looks like:
*
* "IP.IP.IP.IP.PORT[top byte].PORT[bottom byte]"
*
* Where each component expresses as a character,
* the corresponding part of the IP address
* and port number.
* Thus 127.0.0.1, port 2345 looks like:
*
* 49 50 55 46 48 46 48 46 49 46 57 46 52 49
* 1 2 7 . 0 . 0 . 1 . 9 . 4 1
*
* 2345 = 929base16 = 9.32+9 = 9.41
*/
(void) strtoi(addr, &next);
(void) strtoi(next, &next);
(void) strtoi(next, &next);
(void) strtoi(next, &next);
p1 = strtoi(next, &next);
p2 = strtoi(next, &next);
} else if (af == AF_INET6) {
/*
* An IPv6 address is expressed in following two formats
* fec0:A02::2:202:4FCD or
* ::10.9.2.1
* An universal address will have porthi.portlo appended to
* v6 address. So always look for the last two dots when
* extracting port number.
*/
next = addr;
while (next = strchr(next, '.')) {
p = ++next;
next = strchr(next, '.');
next++;
}
p1 = strtoi(p, &p);
p2 = strtoi(p, &p);
RPCLOG(1, "rpc_uaddr2port: IPv6 port %d\n", ((p1 << 8) + p2));
}
return ((p1 << 8) + p2);
}
static int console_command_bd99955(int argc, char **argv)
{
int rv, reg, data, val;
char rw, *e;
enum bd99955_command cmd;
if (argc < 4)
return EC_ERROR_PARAM_COUNT;
rw = argv[1][0];
if (rw == 'w' && argc < 5)
return EC_ERROR_PARAM_COUNT;
else if (rw != 'w' && rw != 'r')
return EC_ERROR_PARAM1;
reg = strtoi(argv[2], &e, 16);
if (*e || reg < 0)
return EC_ERROR_PARAM2;
cmd = strtoi(argv[3], &e, 0);
if (*e || cmd < 0)
return EC_ERROR_PARAM3;
if (argc == 5) {
val = strtoi(argv[4], &e, 16);
if (*e || val < 0)
return EC_ERROR_PARAM4;
}
if (rw == 'r')
rv = ch_raw_read16(reg, &data, cmd);
else {
rv = ch_raw_write16(reg, val, cmd);
if (rv == EC_SUCCESS)
rv = ch_raw_read16(reg, &data, cmd);
}
CPRINTS("register 0x%x [%d] = 0x%x [%d]", reg, reg, data, data);
return rv;
}
static int command_thermalset(int argc, char **argv)
{
unsigned int n;
int i, val;
char *e;
if (argc < 3 || argc > 7)
return EC_ERROR_PARAM_COUNT;
n = (unsigned int)strtoi(argv[1], &e, 0);
if (*e)
return EC_ERROR_PARAM1;
for (i = 2; i < argc; i++) {
val = strtoi(argv[i], &e, 0);
if (*e)
return EC_ERROR_PARAM1 + i - 1;
if (val < 0)
continue;
switch (i) {
case 2:
thermal_params[n].temp_host[EC_TEMP_THRESH_WARN] = val;
break;
case 3:
thermal_params[n].temp_host[EC_TEMP_THRESH_HIGH] = val;
break;
case 4:
thermal_params[n].temp_host[EC_TEMP_THRESH_HALT] = val;
break;
case 5:
thermal_params[n].temp_fan_off = val;
break;
case 6:
thermal_params[n].temp_fan_max = val;
break;
}
}
command_thermalget(0, 0);
return EC_SUCCESS;
}
static int command_kblight(int argc, char **argv)
{
if (argc >= 2) {
char *e;
int i = strtoi(argv[1], &e, 0);
if (*e)
return EC_ERROR_PARAM1;
pwm_set_duty(PWM_CH_KBLIGHT, i);
}
ccprintf("Keyboard backlight: %d%%\n", pwm_get_duty(PWM_CH_KBLIGHT));
return EC_SUCCESS;
}
