自学教程：C++ strtoi函数代码示例

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_tpidfile_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 intgetsecs(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. */intrpc_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;}