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; }