/**
* Return non-zero if the EC supports the command and version
*
* @param cmd Command to check
* @param ver Version to check
* @return non-zero if command version supported; 0 if not.
*/
int google_chromeec_cmd_version_supported(int cmd, int ver)
{
uint32_t mask = 0;
if (google_chromeec_get_cmd_versions(cmd, &mask))
return 0;
return (mask & EC_VER_MASK(ver)) ? 1 : 0;
}
enum ec_status host_command_process(struct host_cmd_handler_args *args)
{
const struct host_command *cmd = find_host_command(args->command);
enum ec_status rv;
if (hcdebug)
host_command_debug_request(args);
if (!cmd)
rv = EC_RES_INVALID_COMMAND;
else if (!(EC_VER_MASK(args->version) & cmd->version_mask))
rv = EC_RES_INVALID_VERSION;
else
rv = cmd->handler(args);
if (rv != EC_RES_SUCCESS)
CPRINTS("HC err %d", rv);
if (hcdebug >= HCDEBUG_PARAMS && args->response_size)
CPRINTS("HC resp:%.*h", args->response_size,
args->response);
return rv;
}
/*****************************************************************************/
/* Host commands */
int pwm_command_get_keyboard_backlight(struct host_cmd_handler_args *args)
{
struct ec_response_pwm_get_keyboard_backlight *r = args->response;
r->percent = pwm_get_duty(PWM_CH_KBLIGHT);
r->enabled = pwm_get_enabled(PWM_CH_KBLIGHT);
args->response_size = sizeof(*r);
return EC_RES_SUCCESS;
}
DECLARE_HOST_COMMAND(EC_CMD_PWM_GET_KEYBOARD_BACKLIGHT,
pwm_command_get_keyboard_backlight,
EC_VER_MASK(0));
int pwm_command_set_keyboard_backlight(struct host_cmd_handler_args *args)
{
const struct ec_params_pwm_set_keyboard_backlight *p = args->params;
/* Brightness is intentionally zeroed to disable keyboard backlight */
pwm_set_duty(PWM_CH_KBLIGHT, p->percent*0);
return EC_RES_SUCCESS;
}
DECLARE_HOST_COMMAND(EC_CMD_PWM_SET_KEYBOARD_BACKLIGHT,
pwm_command_set_keyboard_backlight,
EC_VER_MASK(0));
/*****************************************************************************/
*/
static int thermal_command_set_threshold(struct host_cmd_handler_args *args)
{
const struct ec_params_thermal_set_threshold_v1 *p = args->params;
if (p->sensor_num >= TEMP_SENSOR_COUNT)
return EC_RES_INVALID_PARAM;
thermal_params[p->sensor_num] = p->cfg;
return EC_RES_SUCCESS;
}
DECLARE_HOST_COMMAND(EC_CMD_THERMAL_SET_THRESHOLD,
thermal_command_set_threshold,
EC_VER_MASK(1));
static int thermal_command_get_threshold(struct host_cmd_handler_args *args)
{
const struct ec_params_thermal_get_threshold_v1 *p = args->params;
struct ec_thermal_config *r = args->response;
if (p->sensor_num >= TEMP_SENSOR_COUNT)
return EC_RES_INVALID_PARAM;
*r = thermal_params[p->sensor_num];
args->response_size = sizeof(*r);
return EC_RES_SUCCESS;
}
DECLARE_HOST_COMMAND(EC_CMD_THERMAL_GET_THRESHOLD,
thermal_command_get_threshold,
if (args->version == 0)
return port80_last_boot(args);
if (p->subcmd == EC_PORT80_GET_INFO) {
rsp->get_info.writes = writes;
rsp->get_info.history_size = ARRAY_SIZE(history);
args->response_size = sizeof(rsp->get_info);
return EC_RES_SUCCESS;
} else if (p->subcmd == EC_PORT80_READ_BUFFER) {
/* do not allow bad offset or size */
if (offset >= ARRAY_SIZE(history) || entries == 0 ||
entries > args->response_max)
return EC_RES_INVALID_PARAM;
for (i = 0; i < entries; i++) {
uint16_t e = history[(i + offset) %
ARRAY_SIZE(history)];
rsp->data.codes[i] = e;
}
args->response_size = entries*sizeof(uint16_t);
return EC_RES_SUCCESS;
}
return EC_RES_INVALID_PARAM;
}
DECLARE_HOST_COMMAND(EC_CMD_PORT80_READ,
port80_command_read,
EC_VER_MASK(0) | EC_VER_MASK(1));
i = p_v1->get_info.index;
len = strlen(gpio_get_name(i));
memcpy(r_v1->get_info.name, gpio_get_name(i), len+1);
r_v1->get_info.val = gpio_get_level(i);
r_v1->get_info.flags = gpio_get_default_flags(i);
args->response_size = sizeof(r_v1->get_info);
break;
default:
return EC_RES_INVALID_PARAM;
}
return EC_RES_SUCCESS;
}
DECLARE_HOST_COMMAND(EC_CMD_GPIO_GET, gpio_command_get,
EC_VER_MASK(0) | EC_VER_MASK(1));
static int gpio_command_set(struct host_cmd_handler_args *args)
{
const struct ec_params_gpio_set *p = args->params;
if (system_is_locked())
return EC_RES_ACCESS_DENIED;
if (set(p->name, p->val) != EC_SUCCESS)
return EC_RES_ERROR;
return EC_RES_SUCCESS;
}
DECLARE_HOST_COMMAND(EC_CMD_GPIO_SET, gpio_command_set, EC_VER_MASK(0));
#endif
default:
/* Call other users of the motion task */
#ifdef CONFIG_LID_ANGLE
if (ret == EC_RES_INVALID_PARAM)
ret = host_cmd_motion_lid(args);
#endif
return ret;
}
return EC_RES_SUCCESS;
}
DECLARE_HOST_COMMAND(EC_CMD_MOTION_SENSE_CMD,
host_cmd_motion_sense,
EC_VER_MASK(1) | EC_VER_MASK(2));
/*****************************************************************************/
/* Console commands */
#ifdef CONFIG_CMD_ACCELS
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);
break;
case SYSTEM_IMAGE_RW:
r->current_image = EC_IMAGE_RW;
break;
default:
r->current_image = EC_IMAGE_UNKNOWN;
break;
}
args->response_size = sizeof(*r);
return EC_RES_SUCCESS;
}
DECLARE_HOST_COMMAND(EC_CMD_GET_VERSION,
host_command_get_version,
EC_VER_MASK(0));
static int host_command_build_info(struct host_cmd_handler_args *args)
{
strzcpy(args->response, system_get_build_info(), args->response_max);
args->response_size = strlen(args->response) + 1;
return EC_RES_SUCCESS;
}
DECLARE_HOST_COMMAND(EC_CMD_GET_BUILD_INFO,
host_command_build_info,
EC_VER_MASK(0));
static int host_command_get_chip_info(struct host_cmd_handler_args *args)
{
struct ec_response_get_chip_info *r = args->response;
sizeof(struct ec_params_flash_write)) &
~(CONFIG_FLASH_WRITE_SIZE - 1);
r->flags = 0;
#if (CONFIG_FLASH_ERASED_VALUE32 == 0)
r->flags |= EC_FLASH_INFO_ERASE_TO_0;
#endif
args->response_size = sizeof(*r);
}
return EC_RES_SUCCESS;
}
DECLARE_HOST_COMMAND(EC_CMD_FLASH_INFO,
flash_command_get_info,
EC_VER_MASK(0) | EC_VER_MASK(1));
static int flash_command_read(struct host_cmd_handler_args *args)
{
const struct ec_params_flash_read *p = args->params;
const char *src;
if (flash_dataptr(p->offset, p->size, 1, &src) < 0)
return EC_RES_ERROR;
if (p->size > args->response_max)
return EC_RES_OVERFLOW;
memcpy(args->response, src, p->size);
args->response_size = p->size;
