diff options
| -rw-r--r-- | chip/lm4/lpc.c | 10 | ||||
| -rw-r--r-- | chip/lm4/power_button.c | 46 | ||||
| -rw-r--r-- | chip/lm4/pwm.c | 6 | ||||
| -rw-r--r-- | common/charge_state.c | 58 | ||||
| -rw-r--r-- | common/flash_commands.c | 104 | ||||
| -rw-r--r-- | common/host_command.c | 50 | ||||
| -rw-r--r-- | common/host_event_commands.c | 62 | ||||
| -rw-r--r-- | common/keyboard.c | 4 | ||||
| -rw-r--r-- | common/lightbar.c | 18 | ||||
| -rw-r--r-- | common/pstore_commands.c | 44 | ||||
| -rw-r--r-- | common/pwm_commands.c | 36 | ||||
| -rw-r--r-- | common/system_common.c | 62 | ||||
| -rw-r--r-- | common/temp_sensor.c | 7 | ||||
| -rw-r--r-- | common/thermal.c | 6 | ||||
| -rw-r--r-- | common/thermal_commands.c | 32 | ||||
| -rw-r--r-- | common/usb_charge_commands.c | 10 | ||||
| -rw-r--r-- | include/ec_commands.h (renamed from include/lpc_commands.h) | 306 | ||||
| -rw-r--r-- | include/host_command.h | 2 | ||||
| -rw-r--r-- | util/ectool.c | 236 | ||||
| -rw-r--r-- | util/lbplay.c | 64 |
20 files changed, 581 insertions, 582 deletions
diff --git a/chip/lm4/lpc.c b/chip/lm4/lpc.c index 9587c6b8fa..cc32fbcc7f 100644 --- a/chip/lm4/lpc.c +++ b/chip/lm4/lpc.c @@ -12,7 +12,7 @@ #include "host_command.h" #include "i8042.h" #include "lpc.h" -#include "lpc_commands.h" +#include "ec_commands.h" #include "port80.h" #include "registers.h" #include "system.h" @@ -116,13 +116,13 @@ static void lpc_generate_sci(void) uint8_t *host_get_buffer(int slot) { - return (uint8_t *)LPC_POOL_CMD_DATA + EC_LPC_PARAM_SIZE * slot; + return (uint8_t *)LPC_POOL_CMD_DATA + EC_PARAM_SIZE * slot; } uint8_t *lpc_get_memmap_range(void) { - return (uint8_t *)LPC_POOL_CMD_DATA + EC_LPC_PARAM_SIZE * 2; + return (uint8_t *)LPC_POOL_CMD_DATA + EC_PARAM_SIZE * 2; } @@ -158,7 +158,7 @@ void host_send_response(int slot, const uint8_t *data, int size) if (data != out) memcpy(out, data, size); - host_send_result(slot, EC_LPC_RESULT_SUCCESS); + host_send_result(slot, EC_RES_SUCCESS); } /* Return true if the TOH is still set */ @@ -201,7 +201,7 @@ void lpc_comx_put_char(int c) */ static void update_host_event_status(void) { uint32_t *mapped_raw_events = - (uint32_t*)(lpc_get_memmap_range() + EC_LPC_MEMMAP_HOST_EVENTS); + (uint32_t *)(lpc_get_memmap_range() + EC_MEMMAP_HOST_EVENTS); int need_sci = 0; int need_smi = 0; diff --git a/chip/lm4/power_button.c b/chip/lm4/power_button.c index 836a663403..86273c84e5 100644 --- a/chip/lm4/power_button.c +++ b/chip/lm4/power_button.c @@ -13,7 +13,7 @@ #include "keyboard.h" #include "keyboard_scan.h" #include "lpc.h" -#include "lpc_commands.h" +#include "ec_commands.h" #include "power_button.h" #include "pwm.h" #include "system.h" @@ -80,31 +80,31 @@ static int debounced_lid_open; static void update_other_switches(void) { if (gpio_get_level(GPIO_WRITE_PROTECT) == 0) - *memmap_switches |= EC_LPC_SWITCH_WRITE_PROTECT_DISABLED; + *memmap_switches |= EC_SWITCH_WRITE_PROTECT_DISABLED; else - *memmap_switches &= ~EC_LPC_SWITCH_WRITE_PROTECT_DISABLED; + *memmap_switches &= ~EC_SWITCH_WRITE_PROTECT_DISABLED; if (keyboard_scan_recovery_pressed()) - *memmap_switches |= EC_LPC_SWITCH_KEYBOARD_RECOVERY; + *memmap_switches |= EC_SWITCH_KEYBOARD_RECOVERY; else - *memmap_switches &= ~EC_LPC_SWITCH_KEYBOARD_RECOVERY; + *memmap_switches &= ~EC_SWITCH_KEYBOARD_RECOVERY; if (gpio_get_level(GPIO_RECOVERYn) == 0) - *memmap_switches |= EC_LPC_SWITCH_DEDICATED_RECOVERY; + *memmap_switches |= EC_SWITCH_DEDICATED_RECOVERY; else - *memmap_switches &= ~EC_LPC_SWITCH_DEDICATED_RECOVERY; + *memmap_switches &= ~EC_SWITCH_DEDICATED_RECOVERY; /* Was this a reboot requesting recovery? */ /* TODO: should use a different flag, not the dedicated recovery * switch flag! */ if (system_get_recovery_required()) - *memmap_switches |= EC_LPC_SWITCH_DEDICATED_RECOVERY; + *memmap_switches |= EC_SWITCH_DEDICATED_RECOVERY; #ifdef CONFIG_FAKE_DEV_SWITCH if (eoption_get_bool(EOPTION_BOOL_FAKE_DEV)) - *memmap_switches |= EC_LPC_SWITCH_FAKE_DEVELOPER; + *memmap_switches |= EC_SWITCH_FAKE_DEVELOPER; else - *memmap_switches &= ~EC_LPC_SWITCH_FAKE_DEVELOPER; + *memmap_switches &= ~EC_SWITCH_FAKE_DEVELOPER; #endif } @@ -194,7 +194,7 @@ static void state_machine(uint64_t tnow) pwrbtn_state = PWRBTN_STATE_HELD_DOWN; } else { /* Stop stretching the power button press */ - *memmap_switches &= ~EC_LPC_SWITCH_POWER_BUTTON_PRESSED; + *memmap_switches &= ~EC_SWITCH_POWER_BUTTON_PRESSED; keyboard_set_power_button(0); pwrbtn_state = PWRBTN_STATE_STOPPING; } @@ -222,10 +222,10 @@ static void power_button_changed(uint64_t tnow) CPRINTF("[%T PB pressed]\n"); pwrbtn_state = PWRBTN_STATE_START; tnext_state = tnow; - *memmap_switches |= EC_LPC_SWITCH_POWER_BUTTON_PRESSED; + *memmap_switches |= EC_SWITCH_POWER_BUTTON_PRESSED; keyboard_set_power_button(1); lpc_set_host_events( - EC_LPC_HOST_EVENT_MASK(EC_LPC_HOST_EVENT_POWER_BUTTON)); + EC_HOST_EVENT_MASK(EC_HOST_EVENT_POWER_BUTTON)); } else if (pwrbtn_state == PWRBTN_STATE_BOOT_RESET) { /* Ignore the first power button release after a * keyboard-controlled reset, since we already told the PCH the @@ -238,7 +238,7 @@ static void power_button_changed(uint64_t tnow) CPRINTF("[%T PB released]\n"); pwrbtn_state = PWRBTN_STATE_STOPPING; tnext_state = tnow; - *memmap_switches &= ~EC_LPC_SWITCH_POWER_BUTTON_PRESSED; + *memmap_switches &= ~EC_SWITCH_POWER_BUTTON_PRESSED; keyboard_set_power_button(0); } } @@ -250,10 +250,10 @@ static void lid_switch_open(uint64_t tnow) CPRINTF("[%T PB lid open]\n"); debounced_lid_open = 1; - *memmap_switches |= EC_LPC_SWITCH_LID_OPEN; + *memmap_switches |= EC_SWITCH_LID_OPEN; - lpc_set_host_events(EC_LPC_HOST_EVENT_MASK( - EC_LPC_HOST_EVENT_LID_OPEN)); + lpc_set_host_events(EC_HOST_EVENT_MASK( + EC_HOST_EVENT_LID_OPEN)); /* If the chipset is off, send a power button pulse to wake up the * chipset. */ @@ -273,10 +273,10 @@ static void lid_switch_close(uint64_t tnow) CPRINTF("[%T PB lid close]\n"); debounced_lid_open = 0; - *memmap_switches &= ~EC_LPC_SWITCH_LID_OPEN; + *memmap_switches &= ~EC_SWITCH_LID_OPEN; - lpc_set_host_events(EC_LPC_HOST_EVENT_MASK( - EC_LPC_HOST_EVENT_LID_CLOSED)); + lpc_set_host_events(EC_HOST_EVENT_MASK( + EC_HOST_EVENT_LID_CLOSED)); } @@ -323,11 +323,11 @@ void power_button_interrupt(enum gpio_signal signal) static int power_button_init(void) { /* Set up memory-mapped switch positions */ - memmap_switches = lpc_get_memmap_range() + EC_LPC_MEMMAP_SWITCHES; + memmap_switches = lpc_get_memmap_range() + EC_MEMMAP_SWITCHES; *memmap_switches = 0; if (gpio_get_level(GPIO_LID_SWITCHn) != 0) { debounced_lid_open = 1; - *memmap_switches |= EC_LPC_SWITCH_LID_OPEN; + *memmap_switches |= EC_SWITCH_LID_OPEN; } update_other_switches(); update_backlight(); @@ -353,7 +353,7 @@ static int power_button_init(void) * switch positions. */ set_pwrbtn_to_pch(get_power_button_pressed() ? 0 : 1); if (get_power_button_pressed()) - *memmap_switches |= EC_LPC_SWITCH_POWER_BUTTON_PRESSED; + *memmap_switches |= EC_SWITCH_POWER_BUTTON_PRESSED; } /* Enable interrupts, now that we've initialized */ diff --git a/chip/lm4/pwm.c b/chip/lm4/pwm.c index a5b999c8c2..f7bfe0142e 100644 --- a/chip/lm4/pwm.c +++ b/chip/lm4/pwm.c @@ -10,7 +10,7 @@ #include "gpio.h" #include "hooks.h" #include "lpc.h" -#include "lpc_commands.h" +#include "ec_commands.h" #include "pwm.h" #include "registers.h" #include "task.h" @@ -115,7 +115,7 @@ static void update_lpc_mapped_memory(void) { int i, r; uint16_t *mapped = (uint16_t *)(lpc_get_memmap_range() + - EC_LPC_MEMMAP_FAN); + EC_MEMMAP_FAN); for (i = 0; i < 4; ++i) mapped[i] = 0xffff; @@ -140,7 +140,7 @@ static void check_fan_failure(void) * here should be enough. */ lpc_set_host_events( - EC_LPC_HOST_EVENT_MASK(EC_LPC_HOST_EVENT_THERMAL)); + EC_HOST_EVENT_MASK(EC_HOST_EVENT_THERMAL)); cputs(CC_PWM, "[Fan stalled!]\n"); } } diff --git a/common/charge_state.c b/common/charge_state.c index d98a98dd87..b0ac2130c8 100644 --- a/common/charge_state.c +++ b/common/charge_state.c @@ -15,7 +15,7 @@ #include "console.h" #include "gpio.h" #include "lpc.h" -#include "lpc_commands.h" +#include "ec_commands.h" #include "power_led.h" #include "smart_battery.h" #include "system.h" @@ -46,37 +46,37 @@ static void update_battery_info(void) /* Design Capacity of Full */ battery_design_capacity((int *)(lpc_get_memmap_range() + - EC_LPC_MEMMAP_BATT_DCAP)); + EC_MEMMAP_BATT_DCAP)); /* Design Voltage */ battery_design_voltage((int *)(lpc_get_memmap_range() + - EC_LPC_MEMMAP_BATT_DVLT)); + EC_MEMMAP_BATT_DVLT)); /* Last Full Charge Capacity */ battery_full_charge_capacity((int *)(lpc_get_memmap_range() + - EC_LPC_MEMMAP_BATT_LFCC)); + EC_MEMMAP_BATT_LFCC)); /* Cycle Count */ battery_cycle_count((int *)(lpc_get_memmap_range() + - EC_LPC_MEMMAP_BATT_CCNT)); + EC_MEMMAP_BATT_CCNT)); /* Battery Manufacturer string */ - batt_str = (char *)(lpc_get_memmap_range() + EC_LPC_MEMMAP_BATT_MFGR); - memset(batt_str, 0, EC_LPC_MEMMAP_TEXT_MAX); - battery_manufacturer_name(batt_str, EC_LPC_MEMMAP_TEXT_MAX); + batt_str = (char *)(lpc_get_memmap_range() + EC_MEMMAP_BATT_MFGR); + memset(batt_str, 0, EC_MEMMAP_TEXT_MAX); + battery_manufacturer_name(batt_str, EC_MEMMAP_TEXT_MAX); /* Battery Model string */ - batt_str = (char *)(lpc_get_memmap_range() + EC_LPC_MEMMAP_BATT_MODEL); - memset(batt_str, 0, EC_LPC_MEMMAP_TEXT_MAX); - battery_device_name(batt_str, EC_LPC_MEMMAP_TEXT_MAX); + batt_str = (char *)(lpc_get_memmap_range() + EC_MEMMAP_BATT_MODEL); + memset(batt_str, 0, EC_MEMMAP_TEXT_MAX); + battery_device_name(batt_str, EC_MEMMAP_TEXT_MAX); /* Battery Type string */ - batt_str = (char *)(lpc_get_memmap_range() + EC_LPC_MEMMAP_BATT_TYPE); - battery_device_chemistry(batt_str, EC_LPC_MEMMAP_TEXT_MAX); + batt_str = (char *)(lpc_get_memmap_range() + EC_MEMMAP_BATT_TYPE); + battery_device_chemistry(batt_str, EC_MEMMAP_TEXT_MAX); /* Smart battery serial number is 16 bits */ - batt_str = (char *)(lpc_get_memmap_range() + EC_LPC_MEMMAP_BATT_SERIAL); - memset(batt_str, 0, EC_LPC_MEMMAP_TEXT_MAX); + batt_str = (char *)(lpc_get_memmap_range() + EC_MEMMAP_BATT_SERIAL); + memset(batt_str, 0, EC_MEMMAP_TEXT_MAX); if (battery_serial_number(&batt_serial) == 0) { *batt_str++ = hex2asc(0xf & (batt_serial >> 12)); *batt_str++ = hex2asc(0xf & (batt_serial >> 8)); @@ -134,12 +134,12 @@ static int state_common(struct power_state_context *ctx) rv = charger_post_init(); if (rv) curr->error |= F_CHARGER_INIT; - lpc_set_host_events(EC_LPC_HOST_EVENT_MASK( - EC_LPC_HOST_EVENT_AC_CONNECTED)); + lpc_set_host_events(EC_HOST_EVENT_MASK( + EC_HOST_EVENT_AC_CONNECTED)); } else { /* AC off */ - lpc_set_host_events(EC_LPC_HOST_EVENT_MASK( - EC_LPC_HOST_EVENT_AC_DISCONNECTED)); + lpc_set_host_events(EC_HOST_EVENT_MASK( + EC_HOST_EVENT_AC_DISCONNECTED)); } } @@ -219,16 +219,16 @@ static int state_common(struct power_state_context *ctx) /* Battery charge level low */ if (batt->state_of_charge <= BATTERY_LEVEL_LOW && prev->batt.state_of_charge > BATTERY_LEVEL_LOW) - lpc_set_host_events(EC_LPC_HOST_EVENT_MASK( - EC_LPC_HOST_EVENT_BATTERY_LOW)); + lpc_set_host_events(EC_HOST_EVENT_MASK( + EC_HOST_EVENT_BATTERY_LOW)); /* Battery charge level critical */ if (batt->state_of_charge <= BATTERY_LEVEL_CRITICAL) { *ctx->memmap_batt_flags |= EC_BATT_FLAG_LEVEL_CRITICAL; /* Send battery critical host event */ if (prev->batt.state_of_charge > BATTERY_LEVEL_CRITICAL) - lpc_set_host_events(EC_LPC_HOST_EVENT_MASK( - EC_LPC_HOST_EVENT_BATTERY_CRITICAL)); + lpc_set_host_events(EC_HOST_EVENT_MASK( + EC_HOST_EVENT_BATTERY_CRITICAL)); } else *ctx->memmap_batt_flags &= ~EC_BATT_FLAG_LEVEL_CRITICAL; @@ -287,8 +287,8 @@ static enum power_state state_init(struct power_state_context *ctx) update_battery_info(); /* Send battery event to host */ - lpc_set_host_events(EC_LPC_HOST_EVENT_MASK( - EC_LPC_HOST_EVENT_BATTERY)); + lpc_set_host_events(EC_HOST_EVENT_MASK( + EC_HOST_EVENT_BATTERY)); return PWR_STATE_IDLE; } @@ -486,13 +486,13 @@ void charge_state_machine_task(void) /* Setup LPC direct memmap */ ctx.memmap_batt_volt = (uint32_t *)(lpc_get_memmap_range() + - EC_LPC_MEMMAP_BATT_VOLT); + EC_MEMMAP_BATT_VOLT); ctx.memmap_batt_rate = (uint32_t *)(lpc_get_memmap_range() + - EC_LPC_MEMMAP_BATT_RATE); + EC_MEMMAP_BATT_RATE); ctx.memmap_batt_cap = (uint32_t *)(lpc_get_memmap_range() + - EC_LPC_MEMMAP_BATT_CAP); + EC_MEMMAP_BATT_CAP); ctx.memmap_batt_flags = (uint8_t *)(lpc_get_memmap_range() + - EC_LPC_MEMMAP_BATT_FLAG); + EC_MEMMAP_BATT_FLAG); while (1) { diff --git a/common/flash_commands.c b/common/flash_commands.c index cd4497301c..239a57661f 100644 --- a/common/flash_commands.c +++ b/common/flash_commands.c @@ -201,131 +201,131 @@ DECLARE_CONSOLE_COMMAND(flashwp, command_flash_wp); int flash_command_get_info(uint8_t *data, int *resp_size) { - struct lpc_response_flash_info *r = - (struct lpc_response_flash_info *)data; + struct ec_response_flash_info *r = + (struct ec_response_flash_info *)data; r->flash_size = flash_get_size(); r->write_block_size = flash_get_write_block_size(); r->erase_block_size = flash_get_erase_block_size(); r->protect_block_size = flash_get_protect_block_size(); - *resp_size = sizeof(struct lpc_response_flash_info); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_flash_info); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_FLASH_INFO, flash_command_get_info); +DECLARE_HOST_COMMAND(EC_CMD_FLASH_INFO, flash_command_get_info); #ifdef SUPPORT_CHECKSUM int flash_command_checksum(uint8_t *data, int *resp_size) { - struct lpc_params_flash_checksum *p = - (struct lpc_params_flash_checksum *)data; - struct lpc_response_flash_checksum *r = - (struct lpc_response_flash_checksum *)data; + struct ec_params_flash_checksum *p = + (struct ec_params_flash_checksum *)data; + struct ec_response_flash_checksum *r = + (struct ec_response_flash_checksum *)data; uint8_t cs, byte; int j; for (cs = 0, j = 0; j < p->size; ++j) { if (flash_read(p->offset + j, 1, &byte)) - return EC_LPC_RESULT_ERROR; + return EC_RES_ERROR; BYTE_IN(cs, byte); } r->checksum = cs; - *resp_size = sizeof(struct lpc_response_flash_checksum); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_flash_checksum); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_FLASH_CHECKSUM, flash_command_checksum); +DECLARE_HOST_COMMAND(EC_CMD_FLASH_CHECKSUM, flash_command_checksum); #endif int flash_command_read(uint8_t *data, int *resp_size) { - struct lpc_params_flash_read *p = - (struct lpc_params_flash_read *)data; - struct lpc_response_flash_read *r = - (struct lpc_response_flash_read *)data; + struct ec_params_flash_read *p = + (struct ec_params_flash_read *)data; + struct ec_response_flash_read *r = + (struct ec_response_flash_read *)data; if (p->size > sizeof(r->data)) - return EC_LPC_RESULT_ERROR; + return EC_RES_ERROR; if (flash_read(p->offset, p->size, r->data)) - return EC_LPC_RESULT_ERROR; + return EC_RES_ERROR; - *resp_size = sizeof(struct lpc_response_flash_read); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_flash_read); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_FLASH_READ, flash_command_read); +DECLARE_HOST_COMMAND(EC_CMD_FLASH_READ, flash_command_read); int flash_command_write(uint8_t *data, int *resp_size) { - struct lpc_params_flash_write *p = - (struct lpc_params_flash_write *)data; + struct ec_params_flash_write *p = + (struct ec_params_flash_write *)data; if (p->size > sizeof(p->data)) - return EC_LPC_RESULT_ERROR; + return EC_RES_ERROR; if (system_unsafe_to_overwrite(p->offset, p->size)) - return EC_LPC_RESULT_ACCESS_DENIED; + return EC_RES_ACCESS_DENIED; if (flash_write(p->offset, p->size, p->data)) - return EC_LPC_RESULT_ERROR; + return EC_RES_ERROR; - return EC_LPC_RESULT_SUCCESS; + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_FLASH_WRITE, flash_command_write); +DECLARE_HOST_COMMAND(EC_CMD_FLASH_WRITE, flash_command_write); int flash_command_erase(uint8_t *data, int *resp_size) { - struct lpc_params_flash_erase *p = - (struct lpc_params_flash_erase *)data; + struct ec_params_flash_erase *p = + (struct ec_params_flash_erase *)data; if (system_unsafe_to_overwrite(p->offset, p->size)) - return EC_LPC_RESULT_ACCESS_DENIED; + return EC_RES_ACCESS_DENIED; if (flash_erase(p->offset, p->size)) - return EC_LPC_RESULT_ERROR; + return EC_RES_ERROR; - return EC_LPC_RESULT_SUCCESS; + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_FLASH_ERASE, flash_command_erase); +DECLARE_HOST_COMMAND(EC_CMD_FLASH_ERASE, flash_command_erase); int flash_command_wp_enable(uint8_t *data, int *resp_size) { - struct lpc_params_flash_wp_enable *p = - (struct lpc_params_flash_wp_enable *)data; + struct ec_params_flash_wp_enable *p = + (struct ec_params_flash_wp_enable *)data; return flash_lock_protect(p->enable_wp ? 1 : 0); } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_FLASH_WP_ENABLE, +DECLARE_HOST_COMMAND(EC_CMD_FLASH_WP_ENABLE, flash_command_wp_enable); int flash_command_wp_get_state(uint8_t *data, int *resp_size) { - struct lpc_response_flash_wp_enable *p = - (struct lpc_response_flash_wp_enable *)data; + struct ec_response_flash_wp_enable *p = + (struct ec_response_flash_wp_enable *)data; if (flash_get_protect_lock() & FLASH_PROTECT_LOCK_SET) p->enable_wp = 1; else p->enable_wp = 0; - *resp_size = sizeof(struct lpc_response_flash_wp_enable); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_flash_wp_enable); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_FLASH_WP_GET_STATE, +DECLARE_HOST_COMMAND(EC_CMD_FLASH_WP_GET_STATE, flash_command_wp_get_state); int flash_command_wp_set_range(uint8_t *data, int *resp_size) { - struct lpc_params_flash_wp_range *p = - (struct lpc_params_flash_wp_range *)data; - enum lpc_status ret; + struct ec_params_flash_wp_range *p = + (struct ec_params_flash_wp_range *)data; + enum ec_status ret; if (p->size) ret = flash_set_protect(p->offset, p->size, 1); @@ -334,14 +334,14 @@ int flash_command_wp_set_range(uint8_t *data, int *resp_size) return ret; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_FLASH_WP_SET_RANGE, +DECLARE_HOST_COMMAND(EC_CMD_FLASH_WP_SET_RANGE, flash_command_wp_set_range); int flash_command_wp_get_range(uint8_t *data, int *resp_size) { - struct lpc_response_flash_wp_range *p = - (struct lpc_response_flash_wp_range *)data; + struct ec_response_flash_wp_range *p = + (struct ec_response_flash_wp_range *)data; int pbsize = flash_get_protect_block_size(); int banks = flash_get_size() / pbsize; const uint8_t *blocks; @@ -375,8 +375,8 @@ int flash_command_wp_get_range(uint8_t *data, int *resp_size) p->size = (max - min + 1) * pbsize; } - *resp_size = sizeof(struct lpc_response_flash_wp_range); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_flash_wp_range); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_FLASH_WP_GET_RANGE, +DECLARE_HOST_COMMAND(EC_CMD_FLASH_WP_GET_RANGE, flash_command_wp_get_range); diff --git a/common/host_command.c b/common/host_command.c index 5b202c8248..7e1a2f53d6 100644 --- a/common/host_command.c +++ b/common/host_command.c @@ -9,7 +9,7 @@ #include "host_command.h" #include "link_defs.h" #include "lpc.h" -#include "lpc_commands.h" +#include "ec_commands.h" #include "system.h" #include "task.h" #include "timer.h" @@ -31,10 +31,10 @@ void host_command_received(int slot, int command) /* If this is the reboot command, reboot immediately. This gives * the host processor a way to unwedge the EC even if it's busy with * some other command. */ - if (command == EC_LPC_COMMAND_REBOOT) { + if (command == EC_CMD_REBOOT) { system_reset(1); /* Reset should never return; if it does, post an error */ - host_send_result(slot, EC_LPC_RESULT_ERROR); + host_send_result(slot, EC_RES_ERROR); return; } @@ -47,21 +47,21 @@ void host_command_received(int slot, int command) static int host_command_proto_version(uint8_t *data, int *resp_size) { - struct lpc_response_proto_version *r = - (struct lpc_response_proto_version *)data; + struct ec_response_proto_version *r = + (struct ec_response_proto_version *)data; - r->version = EC_LPC_PROTO_VERSION; + r->version = EC_PROTO_VERSION; - *resp_size = sizeof(struct lpc_response_proto_version); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_proto_version); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_PROTO_VERSION, +DECLARE_HOST_COMMAND(EC_CMD_PROTO_VERSION, host_command_proto_version); static int host_command_hello(uint8_t *data, int *resp_size) { - struct lpc_params_hello *p = (struct lpc_params_hello *)data; - struct lpc_response_hello *r = (struct lpc_response_hello *)data; + struct ec_params_hello *p = (struct ec_params_hello *)data; + struct ec_response_hello *r = (struct ec_response_hello *)data; uint32_t d = p->in_data; CPRINTF("[LPC Hello 0x%08x]\n", d); @@ -78,36 +78,36 @@ static int host_command_hello(uint8_t *data, int *resp_size) CPUTS("[LPC sending hello back]\n"); r->out_data = d + 0x01020304; - *resp_size = sizeof(struct lpc_response_hello); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_hello); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_HELLO, host_command_hello); +DECLARE_HOST_COMMAND(EC_CMD_HELLO, host_command_hello); static int host_command_read_test(uint8_t *data, int *resp_size) { - struct lpc_params_read_test *p = (struct lpc_params_read_test *)data; - struct lpc_response_read_test *r = - (struct lpc_response_read_test *)data; + struct ec_params_read_test *p = (struct ec_params_read_test *)data; + struct ec_response_read_test *r = + (struct ec_response_read_test *)data; int offset = p->offset; int size = p->size / sizeof(uint32_t); int i; if (size > ARRAY_SIZE(r->data)) - return EC_LPC_RESULT_ERROR; + return EC_RES_ERROR; for (i = 0; i < size; i++) r->data[i] = offset + i; - *resp_size = sizeof(struct lpc_response_read_test); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_read_test); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_READ_TEST, host_command_read_test); +DECLARE_HOST_COMMAND(EC_CMD_READ_TEST, host_command_read_test); /* ACPI query event handler. Note that the returned value is NOT actually - * an EC_LPC_RESULT enum; it's 0 if no event was pending, or the 1-based + * an EC_RES enum; it's 0 if no event was pending, or the 1-based * index of the lowest bit which was set. */ static int host_command_acpi_query_event(uint8_t *data, int *resp_size) { @@ -124,7 +124,7 @@ static int host_command_acpi_query_event(uint8_t *data, int *resp_size) /* No events pending */ return 0; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_ACPI_QUERY_EVENT, +DECLARE_HOST_COMMAND(EC_CMD_ACPI_QUERY_EVENT, host_command_acpi_query_event); @@ -155,12 +155,12 @@ static void command_process(int slot) if (cmd) { int size = 0; int res = cmd->handler(data, &size); - if ((res == EC_LPC_RESULT_SUCCESS) && size) + if ((res == EC_RES_SUCCESS) && size) host_send_response(slot, data, size); else host_send_result(slot, res); } else { - host_send_result(slot, EC_LPC_RESULT_INVALID_COMMAND); + host_send_result(slot, EC_RES_INVALID_COMMAND); } } diff --git a/common/host_event_commands.c b/common/host_event_commands.c index d009d5df65..c9cb0e0cc6 100644 --- a/common/host_event_commands.c +++ b/common/host_event_commands.c @@ -62,85 +62,85 @@ DECLARE_CONSOLE_COMMAND(hostevent, command_host_event); static int host_event_get_smi_mask(uint8_t *data, int *resp_size) { - struct lpc_response_host_event_mask *r = - (struct lpc_response_host_event_mask *)data; + struct ec_response_host_event_mask *r = + (struct ec_response_host_event_mask *)data; r->mask = lpc_get_host_event_mask(LPC_HOST_EVENT_SMI); - *resp_size = sizeof(struct lpc_response_host_event_mask); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_host_event_mask); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_HOST_EVENT_GET_SMI_MASK, +DECLARE_HOST_COMMAND(EC_CMD_HOST_EVENT_GET_SMI_MASK, host_event_get_smi_mask); static int host_event_get_sci_mask(uint8_t *data, int *resp_size) { - struct lpc_response_host_event_mask *r = - (struct lpc_response_host_event_mask *)data; + struct ec_response_host_event_mask *r = + (struct ec_response_host_event_mask *)data; r->mask = lpc_get_host_event_mask(LPC_HOST_EVENT_SCI); - *resp_size = sizeof(struct lpc_response_host_event_mask); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_host_event_mask); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_HOST_EVENT_GET_SCI_MASK, +DECLARE_HOST_COMMAND(EC_CMD_HOST_EVENT_GET_SCI_MASK, host_event_get_sci_mask); static int host_event_get_wake_mask(uint8_t *data, int *resp_size) { - struct lpc_response_host_event_mask *r = - (struct lpc_response_host_event_mask *)data; + struct ec_response_host_event_mask *r = + (struct ec_response_host_event_mask *)data; r->mask = lpc_get_host_event_mask(LPC_HOST_EVENT_WAKE); - *resp_size = sizeof(struct lpc_response_host_event_mask); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_host_event_mask); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_HOST_EVENT_GET_WAKE_MASK, +DECLARE_HOST_COMMAND(EC_CMD_HOST_EVENT_GET_WAKE_MASK, host_event_get_wake_mask); static int host_event_set_smi_mask(uint8_t *data, int *resp_size) { - const struct lpc_params_host_event_mask *p = - (const struct lpc_params_host_event_mask *)data; + const struct ec_params_host_event_mask *p = + (const struct ec_params_host_event_mask *)data; lpc_set_host_event_mask(LPC_HOST_EVENT_SMI, p->mask); - return EC_LPC_RESULT_SUCCESS; + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_HOST_EVENT_SET_SMI_MASK, +DECLARE_HOST_COMMAND(EC_CMD_HOST_EVENT_SET_SMI_MASK, host_event_set_smi_mask); static int host_event_set_sci_mask(uint8_t *data, int *resp_size) { - const struct lpc_params_host_event_mask *p = - (const struct lpc_params_host_event_mask *)data; + const struct ec_params_host_event_mask *p = + (const struct ec_params_host_event_mask *)data; lpc_set_host_event_mask(LPC_HOST_EVENT_SCI, p->mask); - return EC_LPC_RESULT_SUCCESS; + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_HOST_EVENT_SET_SCI_MASK, +DECLARE_HOST_COMMAND(EC_CMD_HOST_EVENT_SET_SCI_MASK, host_event_set_sci_mask); static int host_event_set_wake_mask(uint8_t *data, int *resp_size) { - const struct lpc_params_host_event_mask *p = - (const struct lpc_params_host_event_mask *)data; + const struct ec_params_host_event_mask *p = + (const struct ec_params_host_event_mask *)data; lpc_set_host_event_mask(LPC_HOST_EVENT_WAKE, p->mask); - return EC_LPC_RESULT_SUCCESS; + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_HOST_EVENT_SET_WAKE_MASK, +DECLARE_HOST_COMMAND(EC_CMD_HOST_EVENT_SET_WAKE_MASK, host_event_set_wake_mask); static int host_event_clear(uint8_t *data, int *resp_size) { - const struct lpc_params_host_event_mask *p = - (const struct lpc_params_host_event_mask *)data; + const struct ec_params_host_event_mask *p = + (const struct ec_params_host_event_mask *)data; lpc_clear_host_events(p->mask); - return EC_LPC_RESULT_SUCCESS; + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_HOST_EVENT_CLEAR, host_event_clear); +DECLARE_HOST_COMMAND(EC_CMD_HOST_EVENT_CLEAR, host_event_clear); diff --git a/common/keyboard.c b/common/keyboard.c index 198b6a9817..2163de3e00 100644 --- a/common/keyboard.c +++ b/common/keyboard.c @@ -13,7 +13,7 @@ #include "hooks.h" #include "lightbar.h" #include "lpc.h" -#include "lpc_commands.h" +#include "ec_commands.h" #include "registers.h" #include "system.h" #include "task.h" @@ -254,7 +254,7 @@ static void keyboard_wakeup(void) { #ifdef CONFIG_LPC lpc_set_host_events( - EC_LPC_HOST_EVENT_MASK(EC_LPC_HOST_EVENT_KEY_PRESSED)); + EC_HOST_EVENT_MASK(EC_HOST_EVENT_KEY_PRESSED)); #endif } diff --git a/common/lightbar.c b/common/lightbar.c index d2b49c340b..7d762690af 100644 --- a/common/lightbar.c +++ b/common/lightbar.c @@ -685,7 +685,7 @@ static const uint8_t dump_reglist[] = { 0x18, 0x19, 0x1a }; -static void do_cmd_dump(struct lpc_params_lightbar_cmd *ptr) +static void do_cmd_dump(struct ec_params_lightbar_cmd *ptr) { int i; uint8_t reg; @@ -720,13 +720,13 @@ static void do_cmd_rgb(uint8_t led, static int lpc_cmd_lightbar(uint8_t *data, int *resp_size) { - struct lpc_params_lightbar_cmd *ptr = - (struct lpc_params_lightbar_cmd *)data; + struct ec_params_lightbar_cmd *ptr = + (struct ec_params_lightbar_cmd *)data; switch (ptr->in.cmd) { case LIGHTBAR_CMD_DUMP: do_cmd_dump(ptr); - *resp_size = sizeof(struct lpc_params_lightbar_cmd); + *resp_size = sizeof(struct ec_params_lightbar_cmd); break; case LIGHTBAR_CMD_OFF: lightbar_off(); @@ -756,17 +756,17 @@ static int lpc_cmd_lightbar(uint8_t *data, int *resp_size) break; case LIGHTBAR_CMD_GET_SEQ: ptr->out.get_seq.num = current_state; - *resp_size = sizeof(struct lpc_params_lightbar_cmd); + *resp_size = sizeof(struct ec_params_lightbar_cmd); break; default: CPRINTF("[invalid lightbar cmd 0x%x]\n", ptr->in.cmd); - return EC_LPC_RESULT_INVALID_PARAM; + return EC_RES_INVALID_PARAM; } - return EC_LPC_RESULT_SUCCESS; + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_LIGHTBAR_CMD, lpc_cmd_lightbar); +DECLARE_HOST_COMMAND(EC_CMD_LIGHTBAR_CMD, lpc_cmd_lightbar); /****************************************************************************/ @@ -813,7 +813,7 @@ static int command_lightbar(int argc, char **argv) { int i; uint8_t num; - struct lpc_params_lightbar_cmd params; + struct ec_params_lightbar_cmd params; if (1 == argc) { /* no args = dump 'em all */ do_cmd_dump(¶ms); diff --git a/common/pstore_commands.c b/common/pstore_commands.c index 036f5d6b3b..fdd0eaf26c 100644 --- a/common/pstore_commands.c +++ b/common/pstore_commands.c @@ -13,26 +13,26 @@ int pstore_command_get_info(uint8_t *data, int *resp_size) { - struct lpc_response_pstore_info *r = - (struct lpc_response_pstore_info *)data; + struct ec_response_pstore_info *r = + (struct ec_response_pstore_info *)data; ASSERT(EEPROM_BLOCK_START_PSTORE + EEPROM_BLOCK_COUNT_PSTORE <= eeprom_get_block_count()); r->pstore_size = EEPROM_BLOCK_COUNT_PSTORE * eeprom_get_block_size(); r->access_size = sizeof(uint32_t); - *resp_size = sizeof(struct lpc_response_pstore_info); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_pstore_info); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_PSTORE_INFO, pstore_command_get_info); +DECLARE_HOST_COMMAND(EC_CMD_PSTORE_INFO, pstore_command_get_info); int pstore_command_read(uint8_t *data, int *resp_size) { - struct lpc_params_pstore_read *p = - (struct lpc_params_pstore_read *)data; - struct lpc_response_pstore_read *r = - (struct lpc_response_pstore_read *)data; + struct ec_params_pstore_read *p = + (struct ec_params_pstore_read *)data; + struct ec_response_pstore_read *r = + (struct ec_response_pstore_read *)data; char *dest = r->data; int block_size = eeprom_get_block_size(); int block = p->offset / block_size + EEPROM_BLOCK_COUNT_PSTORE; @@ -40,7 +40,7 @@ int pstore_command_read(uint8_t *data, int *resp_size) int bytes_left = p->size; if (p->size > sizeof(r->data)) - return EC_LPC_RESULT_ERROR; + return EC_RES_ERROR; while (bytes_left) { /* Read what we can from the current block */ @@ -48,10 +48,10 @@ int pstore_command_read(uint8_t *data, int *resp_size) if (block >= EEPROM_BLOCK_START_PSTORE + EEPROM_BLOCK_COUNT_PSTORE) - return EC_LPC_RESULT_ERROR; + return EC_RES_ERROR; if (eeprom_read(block, offset, bytes_this, dest)) - return EC_LPC_RESULT_ERROR; + return EC_RES_ERROR; /* Continue to the next block if necessary */ offset = 0; @@ -60,16 +60,16 @@ int pstore_command_read(uint8_t *data, int *resp_size) dest += bytes_this; } - *resp_size = sizeof(struct lpc_response_pstore_read); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_pstore_read); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_PSTORE_READ, pstore_command_read); +DECLARE_HOST_COMMAND(EC_CMD_PSTORE_READ, pstore_command_read); int pstore_command_write(uint8_t *data, int *resp_size) { - struct lpc_params_pstore_write *p = - (struct lpc_params_pstore_write *)data; + struct ec_params_pstore_write *p = + (struct ec_params_pstore_write *)data; const char *src = p->data; int block_size = eeprom_get_block_size(); @@ -78,7 +78,7 @@ int pstore_command_write(uint8_t *data, int *resp_size) int bytes_left = p->size; if (p->size > sizeof(p->data)) - return EC_LPC_RESULT_ERROR; + return EC_RES_ERROR; while (bytes_left) { /* Write what we can to the current block */ @@ -86,10 +86,10 @@ int pstore_command_write(uint8_t *data, int *resp_size) if (block >= EEPROM_BLOCK_START_PSTORE + EEPROM_BLOCK_COUNT_PSTORE) - return EC_LPC_RESULT_ERROR; + return EC_RES_ERROR; if (eeprom_write(block, offset, bytes_this, src)) - return EC_LPC_RESULT_ERROR; + return EC_RES_ERROR; /* Continue to the next block if necessary */ offset = 0; @@ -98,6 +98,6 @@ int pstore_command_write(uint8_t *data, int *resp_size) src += bytes_this; } - return EC_LPC_RESULT_SUCCESS; + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_PSTORE_WRITE, pstore_command_write); +DECLARE_HOST_COMMAND(EC_CMD_PSTORE_WRITE, pstore_command_write); diff --git a/common/pwm_commands.c b/common/pwm_commands.c index 8009cf2ff9..3a35ff8637 100644 --- a/common/pwm_commands.c +++ b/common/pwm_commands.c @@ -12,51 +12,51 @@ int pwm_command_get_fan_rpm(uint8_t *data, int *resp_size) { - struct lpc_response_pwm_get_fan_rpm *r = - (struct lpc_response_pwm_get_fan_rpm *)data; + struct ec_response_pwm_get_fan_rpm *r = + (struct ec_response_pwm_get_fan_rpm *)data; r->rpm = pwm_get_fan_target_rpm(); - *resp_size = sizeof(struct lpc_response_pwm_get_fan_rpm); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_pwm_get_fan_rpm); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_PWM_GET_FAN_RPM, pwm_command_get_fan_rpm); +DECLARE_HOST_COMMAND(EC_CMD_PWM_GET_FAN_RPM, pwm_command_get_fan_rpm); int pwm_command_set_fan_target_rpm(uint8_t *data, int *resp_size) { - struct lpc_params_pwm_set_fan_target_rpm *p = - (struct lpc_params_pwm_set_fan_target_rpm *)data; + struct ec_params_pwm_set_fan_target_rpm *p = + (struct ec_params_pwm_set_fan_target_rpm *)data; #ifdef CONFIG_TASK_THERMAL thermal_toggle_auto_fan_ctrl(0); #endif pwm_set_fan_target_rpm(p->rpm); - return EC_LPC_RESULT_SUCCESS; + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_PWM_SET_FAN_TARGET_RPM, +DECLARE_HOST_COMMAND(EC_CMD_PWM_SET_FAN_TARGET_RPM, pwm_command_set_fan_target_rpm); int pwm_command_get_keyboard_backlight(uint8_t *data, int *resp_size) { - struct lpc_response_pwm_get_keyboard_backlight *r = - (struct lpc_response_pwm_get_keyboard_backlight *)data; + struct ec_response_pwm_get_keyboard_backlight *r = + (struct ec_response_pwm_get_keyboard_backlight *)data; r->percent = pwm_get_keyboard_backlight(); - *resp_size = sizeof(struct lpc_response_pwm_get_keyboard_backlight); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_pwm_get_keyboard_backlight); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_PWM_GET_KEYBOARD_BACKLIGHT, +DECLARE_HOST_COMMAND(EC_CMD_PWM_GET_KEYBOARD_BACKLIGHT, pwm_command_get_keyboard_backlight); int pwm_command_set_keyboard_backlight(uint8_t *data, int *resp_size) { - struct lpc_params_pwm_set_keyboard_backlight *p = - (struct lpc_params_pwm_set_keyboard_backlight *)data; + struct ec_params_pwm_set_keyboard_backlight *p = + (struct ec_params_pwm_set_keyboard_backlight *)data; pwm_set_keyboard_backlight(p->percent); - return EC_LPC_RESULT_SUCCESS; + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_PWM_SET_KEYBOARD_BACKLIGHT, +DECLARE_HOST_COMMAND(EC_CMD_PWM_SET_KEYBOARD_BACKLIGHT, pwm_command_set_keyboard_backlight); diff --git a/common/system_common.c b/common/system_common.c index 0eb82d065c..92bcacdd71 100644 --- a/common/system_common.c +++ b/common/system_common.c @@ -11,7 +11,7 @@ #include "hooks.h" #include "host_command.h" #include "lpc.h" -#include "lpc_commands.h" +#include "ec_commands.h" #include "system.h" #include "task.h" #include "uart.h" @@ -545,8 +545,8 @@ DECLARE_CONSOLE_COMMAND(reboot, command_reboot); static int host_command_get_version(uint8_t *data, int *resp_size) { - struct lpc_response_get_version *r = - (struct lpc_response_get_version *)data; + struct ec_response_get_version *r = + (struct ec_response_get_version *)data; strzcpy(r->version_string_ro, system_get_version(SYSTEM_IMAGE_RO), sizeof(r->version_string_ro)); @@ -557,59 +557,59 @@ static int host_command_get_version(uint8_t *data, int *resp_size) switch (system_get_image_copy()) { case SYSTEM_IMAGE_RO: - r->current_image = EC_LPC_IMAGE_RO; + r->current_image = EC_IMAGE_RO; break; case SYSTEM_IMAGE_RW_A: - r->current_image = EC_LPC_IMAGE_RW_A; + r->current_image = EC_IMAGE_RW_A; break; case SYSTEM_IMAGE_RW_B: - r->current_image = EC_LPC_IMAGE_RW_B; + r->current_image = EC_IMAGE_RW_B; break; default: - r->current_image = EC_LPC_IMAGE_UNKNOWN; + r->current_image = EC_IMAGE_UNKNOWN; break; } - *resp_size = sizeof(struct lpc_response_get_version); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_get_version); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_GET_VERSION, host_command_get_version); +DECLARE_HOST_COMMAND(EC_CMD_GET_VERSION, host_command_get_version); static int host_command_build_info(uint8_t *data, int *resp_size) { - struct lpc_response_get_build_info *r = - (struct lpc_response_get_build_info *)data; + struct ec_response_get_build_info *r = + (struct ec_response_get_build_info *)data; strzcpy(r->build_string, system_get_build_info(), sizeof(r->build_string)); - *resp_size = sizeof(struct lpc_response_get_build_info); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_get_build_info); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_GET_BUILD_INFO, host_command_build_info); +DECLARE_HOST_COMMAND(EC_CMD_GET_BUILD_INFO, host_command_build_info); static int host_command_get_chip_info(uint8_t *data, int *resp_size) { - struct lpc_response_get_chip_info *r = - (struct lpc_response_get_chip_info *)data; + struct ec_response_get_chip_info *r = + (struct ec_response_get_chip_info *)data; strzcpy(r->vendor, system_get_chip_vendor(), sizeof(r->vendor)); strzcpy(r->name, system_get_chip_name(), sizeof(r->name)); strzcpy(r->revision, system_get_chip_revision(), sizeof(r->revision)); - *resp_size = sizeof(struct lpc_response_get_chip_info); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_get_chip_info); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_GET_CHIP_INFO, host_command_get_chip_info); +DECLARE_HOST_COMMAND(EC_CMD_GET_CHIP_INFO, host_command_get_chip_info); #ifdef CONFIG_REBOOT_EC static void clean_busy_bits(void) { #ifdef CONFIG_LPC - host_send_result(0, EC_LPC_RESULT_SUCCESS); - host_send_result(1, EC_LPC_RESULT_SUCCESS); + host_send_result(0, EC_RES_SUCCESS); + host_send_result(1, EC_RES_SUCCESS); #endif } @@ -617,27 +617,27 @@ int host_command_reboot(uint8_t *data, int *resp_size) { enum system_image_copy_t copy; - struct lpc_params_reboot_ec *p = - (struct lpc_params_reboot_ec *)data; + struct ec_params_reboot_ec *p = + (struct ec_params_reboot_ec *)data; int recovery_request = p->reboot_flags & - EC_LPC_COMMAND_REBOOT_BIT_RECOVERY; + EC_CMD_REBOOT_BIT_RECOVERY; /* TODO: (crosbug.com/p/7468) For this command to be allowed, WP must * be disabled. */ switch (p->target) { - case EC_LPC_IMAGE_RO: + case EC_IMAGE_RO: copy = SYSTEM_IMAGE_RO; break; - case EC_LPC_IMAGE_RW_A: + case EC_IMAGE_RW_A: copy = SYSTEM_IMAGE_RW_A; break; - case EC_LPC_IMAGE_RW_B: + case EC_IMAGE_RW_B: copy = SYSTEM_IMAGE_RW_B; break; default: - return EC_LPC_RESULT_ERROR; + return EC_RES_ERROR; } clean_busy_bits(); @@ -650,7 +650,7 @@ int host_command_reboot(uint8_t *data, int *resp_size) * * If we DO get down here, something went wrong in the reboot, so * return error. */ - return EC_LPC_RESULT_ERROR; + return EC_RES_ERROR; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_REBOOT_EC, host_command_reboot); +DECLARE_HOST_COMMAND(EC_CMD_REBOOT_EC, host_command_reboot); #endif /* CONFIG_REBOOT_EC */ diff --git a/common/temp_sensor.c b/common/temp_sensor.c index 013b4f0d87..9f615ae6d3 100644 --- a/common/temp_sensor.c +++ b/common/temp_sensor.c @@ -12,7 +12,7 @@ #include "gpio.h" #include "i2c.h" #include "lpc.h" -#include "lpc_commands.h" +#include "ec_commands.h" #include "peci.h" #include "task.h" #include "temp_sensor.h" @@ -71,7 +71,7 @@ void poll_all_sensors(void) static void update_lpc_mapped_memory(void) { int i, t; - uint8_t *mapped = lpc_get_memmap_range() + EC_LPC_MEMMAP_TEMP_SENSOR; + uint8_t *mapped = lpc_get_memmap_range() + EC_MEMMAP_TEMP_SENSOR; memset(mapped, 0xff, 16); @@ -82,7 +82,7 @@ static void update_lpc_mapped_memory(void) } t = temp_sensor_read(i); if (t != -1) - mapped[i] = t - EC_LPC_TEMP_SENSOR_OFFSET; + mapped[i] = t - EC_TEMP_SENSOR_OFFSET; else mapped[i] = 0xfe; } @@ -126,4 +126,3 @@ static int command_temps(int argc, char **argv) return EC_SUCCESS; } DECLARE_CONSOLE_COMMAND(temps, command_temps); - diff --git a/common/thermal.c b/common/thermal.c index e9296b6433..9aa3e5d066 100644 --- a/common/thermal.c +++ b/common/thermal.c @@ -10,7 +10,7 @@ #include "console.h" #include "gpio.h" #include "lpc.h" -#include "lpc_commands.h" +#include "ec_commands.h" #include "pwm.h" #include "task.h" #include "temp_sensor.h" @@ -89,14 +89,14 @@ int thermal_toggle_auto_fan_ctrl(int auto_fan_on) static void smi_overheated_warning(void) { lpc_set_host_events( - EC_LPC_HOST_EVENT_MASK(EC_LPC_HOST_EVENT_THERMAL_OVERLOAD)); + EC_HOST_EVENT_MASK(EC_HOST_EVENT_THERMAL_OVERLOAD)); } static void smi_sensor_failure_warning(void) { lpc_set_host_events( - EC_LPC_HOST_EVENT_MASK(EC_LPC_HOST_EVENT_THERMAL)); + EC_HOST_EVENT_MASK(EC_HOST_EVENT_THERMAL)); } diff --git a/common/thermal_commands.c b/common/thermal_commands.c index f3476f8348..aedbf63f80 100644 --- a/common/thermal_commands.c +++ b/common/thermal_commands.c @@ -11,40 +11,40 @@ int thermal_command_set_threshold(uint8_t *data, int *resp_size) { - struct lpc_params_thermal_set_threshold *p = - (struct lpc_params_thermal_set_threshold *)data; + struct ec_params_thermal_set_threshold *p = + (struct ec_params_thermal_set_threshold *)data; if (thermal_set_threshold(p->sensor_type, p->threshold_id, p->value)) - return EC_LPC_RESULT_ERROR; - return EC_LPC_RESULT_SUCCESS; + return EC_RES_ERROR; + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_THERMAL_SET_THRESHOLD, +DECLARE_HOST_COMMAND(EC_CMD_THERMAL_SET_THRESHOLD, thermal_command_set_threshold); int thermal_command_get_threshold(uint8_t *data, int *resp_size) { - struct lpc_params_thermal_get_threshold *p = - (struct lpc_params_thermal_get_threshold *)data; - struct lpc_response_thermal_get_threshold *r = - (struct lpc_response_thermal_get_threshold *)data; + struct ec_params_thermal_get_threshold *p = + (struct ec_params_thermal_get_threshold *)data; + struct ec_response_thermal_get_threshold *r = + (struct ec_response_thermal_get_threshold *)data; r->value = thermal_get_threshold(p->sensor_type, p->threshold_id); if (r->value == -1) - return EC_LPC_RESULT_ERROR; + return EC_RES_ERROR; - *resp_size = sizeof(struct lpc_response_thermal_get_threshold); - return EC_LPC_RESULT_SUCCESS; + *resp_size = sizeof(struct ec_response_thermal_get_threshold); + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_THERMAL_GET_THRESHOLD, +DECLARE_HOST_COMMAND(EC_CMD_THERMAL_GET_THRESHOLD, thermal_command_get_threshold); int thermal_command_auto_fan_ctrl(uint8_t *data, int *resp_size) { if (thermal_toggle_auto_fan_ctrl(1)) - return EC_LPC_RESULT_ERROR; - return EC_LPC_RESULT_SUCCESS; + return EC_RES_ERROR; + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_THERMAL_AUTO_FAN_CTRL, +DECLARE_HOST_COMMAND(EC_CMD_THERMAL_AUTO_FAN_CTRL, thermal_command_auto_fan_ctrl); diff --git a/common/usb_charge_commands.c b/common/usb_charge_commands.c index ad0380186d..4e69208622 100644 --- a/common/usb_charge_commands.c +++ b/common/usb_charge_commands.c @@ -17,8 +17,8 @@ int usb_charge_command_set_mode(uint8_t *data, int *resp_size) { - struct lpc_params_usb_charge_set_mode *p = - (struct lpc_params_usb_charge_set_mode *)data; + struct ec_params_usb_charge_set_mode *p = + (struct ec_params_usb_charge_set_mode *)data; int rv; CPRINTF("[Setting USB port %d to mode %d]\n", @@ -26,9 +26,9 @@ int usb_charge_command_set_mode(uint8_t *data, int *resp_size) rv = usb_charge_set_mode(p->usb_port_id, p->mode); if (rv != EC_SUCCESS) - return EC_LPC_RESULT_ERROR; + return EC_RES_ERROR; - return EC_LPC_RESULT_SUCCESS; + return EC_RES_SUCCESS; } -DECLARE_HOST_COMMAND(EC_LPC_COMMAND_USB_CHARGE_SET_MODE, +DECLARE_HOST_COMMAND(EC_CMD_USB_CHARGE_SET_MODE, usb_charge_command_set_mode); diff --git a/include/lpc_commands.h b/include/ec_commands.h index fd93136421..ab0142e81d 100644 --- a/include/lpc_commands.h +++ b/include/ec_commands.h @@ -3,10 +3,10 @@ * found in the LICENSE file. */ -/* LPC command constants for Chrome EC */ +/* Host communication command constants for Chrome EC */ -#ifndef __CROS_EC_LPC_COMMANDS_H -#define __CROS_EC_LPC_COMMANDS_H +#ifndef __CROS_EC_COMMANDS_H +#define __CROS_EC_COMMANDS_H /* During the development stage, the LPC bus has high error bit rate. * Using checksum can detect the error and trigger re-transmit. @@ -15,7 +15,7 @@ #define SUPPORT_CHECKSUM /* Current version of this protocol */ -#define EC_LPC_PROTO_VERSION 0x00000002 +#define EC_PROTO_VERSION 0x00000002 /* I/O addresses for LPC commands */ #define EC_LPC_ADDR_KERNEL_DATA 0x62 @@ -24,7 +24,7 @@ #define EC_LPC_ADDR_USER_DATA 0x200 #define EC_LPC_ADDR_USER_CMD 0x204 #define EC_LPC_ADDR_USER_PARAM 0x880 -#define EC_LPC_PARAM_SIZE 128 /* Size of each param area in bytes */ +#define EC_PARAM_SIZE 128 /* Size of each param area in bytes */ /* EC command register bit functions */ #define EC_LPC_CMDR_DATA (1 << 0) @@ -36,50 +36,50 @@ #define EC_LPC_CMDR_SMI (1 << 6) #define EC_LPC_ADDR_MEMMAP 0x900 -#define EC_LPC_MEMMAP_SIZE 255 /* ACPI IO buffer max is 255 bytes */ -#define EC_LPC_MEMMAP_TEXT_MAX 8 /* Size of a string in the memory map */ +#define EC_MEMMAP_SIZE 255 /* ACPI IO buffer max is 255 bytes */ +#define EC_MEMMAP_TEXT_MAX 8 /* Size of a string in the memory map */ /* The offset address of each type of data in mapped memory. */ -#define EC_LPC_MEMMAP_TEMP_SENSOR 0x00 -#define EC_LPC_MEMMAP_FAN 0x10 -#define EC_LPC_MEMMAP_SWITCHES 0x30 -#define EC_LPC_MEMMAP_HOST_EVENTS 0x34 -#define EC_LPC_MEMMAP_BATT_VOLT 0x40 /* Battery Present Voltage */ -#define EC_LPC_MEMMAP_BATT_RATE 0x44 /* Battery Present Rate */ -#define EC_LPC_MEMMAP_BATT_CAP 0x48 /* Battery Remaining Capacity */ -#define EC_LPC_MEMMAP_BATT_FLAG 0x4c /* Battery State, defined below */ -#define EC_LPC_MEMMAP_BATT_DCAP 0x50 /* Battery Design Capacity */ -#define EC_LPC_MEMMAP_BATT_DVLT 0x54 /* Battery Design Voltage */ -#define EC_LPC_MEMMAP_BATT_LFCC 0x58 /* Battery Last Full Charge Capacity */ -#define EC_LPC_MEMMAP_BATT_CCNT 0x5c /* Battery Cycle Count */ -#define EC_LPC_MEMMAP_BATT_MFGR 0x60 /* Battery Manufacturer String */ -#define EC_LPC_MEMMAP_BATT_MODEL 0x68 /* Battery Model Number String */ -#define EC_LPC_MEMMAP_BATT_SERIAL 0x70 /* Battery Serial Number String */ -#define EC_LPC_MEMMAP_BATT_TYPE 0x78 /* Battery Type String */ - -/* Battery bit flags at EC_LPC_MEMMAP_BATT_FLAG. */ +#define EC_MEMMAP_TEMP_SENSOR 0x00 +#define EC_MEMMAP_FAN 0x10 +#define EC_MEMMAP_SWITCHES 0x30 +#define EC_MEMMAP_HOST_EVENTS 0x34 +#define EC_MEMMAP_BATT_VOLT 0x40 /* Battery Present Voltage */ +#define EC_MEMMAP_BATT_RATE 0x44 /* Battery Present Rate */ +#define EC_MEMMAP_BATT_CAP 0x48 /* Battery Remaining Capacity */ +#define EC_MEMMAP_BATT_FLAG 0x4c /* Battery State, defined below */ +#define EC_MEMMAP_BATT_DCAP 0x50 /* Battery Design Capacity */ +#define EC_MEMMAP_BATT_DVLT 0x54 /* Battery Design Voltage */ +#define EC_MEMMAP_BATT_LFCC 0x58 /* Battery Last Full Charge Capacity */ +#define EC_MEMMAP_BATT_CCNT 0x5c /* Battery Cycle Count */ +#define EC_MEMMAP_BATT_MFGR 0x60 /* Battery Manufacturer String */ +#define EC_MEMMAP_BATT_MODEL 0x68 /* Battery Model Number String */ +#define EC_MEMMAP_BATT_SERIAL 0x70 /* Battery Serial Number String */ +#define EC_MEMMAP_BATT_TYPE 0x78 /* Battery Type String */ + +/* Battery bit flags at EC_MEMMAP_BATT_FLAG. */ #define EC_BATT_FLAG_AC_PRESENT 0x01 #define EC_BATT_FLAG_BATT_PRESENT 0x02 #define EC_BATT_FLAG_DISCHARGING 0x04 #define EC_BATT_FLAG_CHARGING 0x08 #define EC_BATT_FLAG_LEVEL_CRITICAL 0x10 -/* Switch flags at EC_LPC_MEMMAP_SWITCHES */ -#define EC_LPC_SWITCH_LID_OPEN 0x01 -#define EC_LPC_SWITCH_POWER_BUTTON_PRESSED 0x02 -#define EC_LPC_SWITCH_WRITE_PROTECT_DISABLED 0x04 +/* Switch flags at EC_MEMMAP_SWITCHES */ +#define EC_SWITCH_LID_OPEN 0x01 +#define EC_SWITCH_POWER_BUTTON_PRESSED 0x02 +#define EC_SWITCH_WRITE_PROTECT_DISABLED 0x04 /* Recovery requested via keyboard */ -#define EC_LPC_SWITCH_KEYBOARD_RECOVERY 0x08 +#define EC_SWITCH_KEYBOARD_RECOVERY 0x08 /* Recovery requested via dedicated signal (from servo board) */ -#define EC_LPC_SWITCH_DEDICATED_RECOVERY 0x10 +#define EC_SWITCH_DEDICATED_RECOVERY 0x10 /* Fake developer switch (for testing) */ -#define EC_LPC_SWITCH_FAKE_DEVELOPER 0x20 +#define EC_SWITCH_FAKE_DEVELOPER 0x20 /* The offset of temperature value stored in mapped memory. * This allows reporting a temperature range of * 200K to 454K = -73C to 181C. */ -#define EC_LPC_TEMP_SENSOR_OFFSET 200 +#define EC_TEMP_SENSOR_OFFSET 200 /* * This header file is used in coreboot both in C and ACPI code. @@ -114,14 +114,14 @@ #define EC_LPC_STATUS_BUSY_MASK \ (EC_LPC_STATUS_FROM_HOST | EC_LPC_STATUS_PROCESSING) -/* LPC command response codes */ +/* Host command response codes */ /* TODO: move these so they don't overlap SCI/SMI data? */ -enum lpc_status { - EC_LPC_RESULT_SUCCESS = 0, - EC_LPC_RESULT_INVALID_COMMAND = 1, - EC_LPC_RESULT_ERROR = 2, - EC_LPC_RESULT_INVALID_PARAM = 3, - EC_LPC_RESULT_ACCESS_DENIED = 4, +enum ec_status { + EC_RES_SUCCESS = 0, + EC_RES_INVALID_COMMAND = 1, + EC_RES_ERROR = 2, + EC_RES_INVALID_PARAM = 3, + EC_RES_ACCESS_DENIED = 4, }; @@ -131,22 +131,22 @@ enum lpc_status { * item or rearrange the list (it needs to be stable across platforms, not * just within a single compiled instance). */ enum host_event_code { - EC_LPC_HOST_EVENT_LID_CLOSED = 1, - EC_LPC_HOST_EVENT_LID_OPEN = 2, - EC_LPC_HOST_EVENT_POWER_BUTTON = 3, - EC_LPC_HOST_EVENT_AC_CONNECTED = 4, - EC_LPC_HOST_EVENT_AC_DISCONNECTED = 5, - EC_LPC_HOST_EVENT_BATTERY_LOW = 6, - EC_LPC_HOST_EVENT_BATTERY_CRITICAL = 7, - EC_LPC_HOST_EVENT_BATTERY = 8, - EC_LPC_HOST_EVENT_THERMAL_THRESHOLD = 9, - EC_LPC_HOST_EVENT_THERMAL_OVERLOAD = 10, - EC_LPC_HOST_EVENT_THERMAL = 11, - EC_LPC_HOST_EVENT_USB_CHARGER = 12, - EC_LPC_HOST_EVENT_KEY_PRESSED = 13, + EC_HOST_EVENT_LID_CLOSED = 1, + EC_HOST_EVENT_LID_OPEN = 2, + EC_HOST_EVENT_POWER_BUTTON = 3, + EC_HOST_EVENT_AC_CONNECTED = 4, + EC_HOST_EVENT_AC_DISCONNECTED = 5, + EC_HOST_EVENT_BATTERY_LOW = 6, + EC_HOST_EVENT_BATTERY_CRITICAL = 7, + EC_HOST_EVENT_BATTERY = 8, + EC_HOST_EVENT_THERMAL_THRESHOLD = 9, + EC_HOST_EVENT_THERMAL_OVERLOAD = 10, + EC_HOST_EVENT_THERMAL = 11, + EC_HOST_EVENT_USB_CHARGER = 12, + EC_HOST_EVENT_KEY_PRESSED = 13, }; /* Host event mask */ -#define EC_LPC_HOST_EVENT_MASK(event_code) (1 << ((event_code) - 1)) +#define EC_HOST_EVENT_MASK(event_code) (1 << ((event_code) - 1)) /* Notes on commands: * @@ -160,60 +160,60 @@ enum host_event_code { /* Get protocol version, used to deal with non-backward compatible protocol * changes. */ -#define EC_LPC_COMMAND_PROTO_VERSION 0x00 -struct lpc_response_proto_version { +#define EC_CMD_PROTO_VERSION 0x00 +struct ec_response_proto_version { uint32_t version; } __attribute__ ((packed)); /* Hello. This is a simple command to test the EC is responsive to * commands. */ -#define EC_LPC_COMMAND_HELLO 0x01 -struct lpc_params_hello { +#define EC_CMD_HELLO 0x01 +struct ec_params_hello { uint32_t in_data; /* Pass anything here */ } __attribute__ ((packed)); -struct lpc_response_hello { +struct ec_response_hello { uint32_t out_data; /* Output will be in_data + 0x01020304 */ } __attribute__ ((packed)); /* Get version number */ -#define EC_LPC_COMMAND_GET_VERSION 0x02 -enum lpc_current_image { - EC_LPC_IMAGE_UNKNOWN = 0, - EC_LPC_IMAGE_RO, - EC_LPC_IMAGE_RW_A, - EC_LPC_IMAGE_RW_B +#define EC_CMD_GET_VERSION 0x02 +enum ec_current_image { + EC_IMAGE_UNKNOWN = 0, + EC_IMAGE_RO, + EC_IMAGE_RW_A, + EC_IMAGE_RW_B }; -struct lpc_response_get_version { +struct ec_response_get_version { /* Null-terminated version strings for RO, RW-A, RW-B */ char version_string_ro[32]; char version_string_rw_a[32]; char version_string_rw_b[32]; - uint32_t current_image; /* One of lpc_current_image */ + uint32_t current_image; /* One of ec_current_image */ } __attribute__ ((packed)); /* Read test */ -#define EC_LPC_COMMAND_READ_TEST 0x03 -struct lpc_params_read_test { +#define EC_CMD_READ_TEST 0x03 +struct ec_params_read_test { uint32_t offset; /* Starting value for read buffer */ uint32_t size; /* Size to read in bytes */ } __attribute__ ((packed)); -struct lpc_response_read_test { +struct ec_response_read_test { uint32_t data[32]; } __attribute__ ((packed)); /* Get build information */ -#define EC_LPC_COMMAND_GET_BUILD_INFO 0x04 -struct lpc_response_get_build_info { - char build_string[EC_LPC_PARAM_SIZE]; +#define EC_CMD_GET_BUILD_INFO 0x04 +struct ec_response_get_build_info { + char build_string[EC_PARAM_SIZE]; } __attribute__ ((packed)); /* Get chip info */ -#define EC_LPC_COMMAND_GET_CHIP_INFO 0x05 -struct lpc_response_get_chip_info { +#define EC_CMD_GET_CHIP_INFO 0x05 +struct ec_response_get_chip_info { /* Null-terminated strings */ char vendor[32]; char name[32]; @@ -225,11 +225,11 @@ struct lpc_response_get_chip_info { /* Flash commands */ /* Maximum bytes that can be read/written in a single command */ -#define EC_LPC_FLASH_SIZE_MAX 64 +#define EC_FLASH_SIZE_MAX 64 /* Get flash info */ -#define EC_LPC_COMMAND_FLASH_INFO 0x10 -struct lpc_response_flash_info { +#define EC_CMD_FLASH_INFO 0x10 +struct ec_response_flash_info { /* Usable flash size, in bytes */ uint32_t flash_size; /* Write block size. Write offset and size must be a multiple @@ -244,80 +244,80 @@ struct lpc_response_flash_info { } __attribute__ ((packed)); /* Read flash */ -#define EC_LPC_COMMAND_FLASH_READ 0x11 -struct lpc_params_flash_read { +#define EC_CMD_FLASH_READ 0x11 +struct ec_params_flash_read { uint32_t offset; /* Byte offset to read */ uint32_t size; /* Size to read in bytes */ } __attribute__ ((packed)); -struct lpc_response_flash_read { - uint8_t data[EC_LPC_FLASH_SIZE_MAX]; +struct ec_response_flash_read { + uint8_t data[EC_FLASH_SIZE_MAX]; } __attribute__ ((packed)); /* Write flash */ -#define EC_LPC_COMMAND_FLASH_WRITE 0x12 -struct lpc_params_flash_write { +#define EC_CMD_FLASH_WRITE 0x12 +struct ec_params_flash_write { uint32_t offset; /* Byte offset to write */ uint32_t size; /* Size to write in bytes */ - uint8_t data[EC_LPC_FLASH_SIZE_MAX]; + uint8_t data[EC_FLASH_SIZE_MAX]; } __attribute__ ((packed)); /* Erase flash */ -#define EC_LPC_COMMAND_FLASH_ERASE 0x13 -struct lpc_params_flash_erase { +#define EC_CMD_FLASH_ERASE 0x13 +struct ec_params_flash_erase { uint32_t offset; /* Byte offset to erase */ uint32_t size; /* Size to erase in bytes */ } __attribute__ ((packed)); /* Flashmap offset */ -#define EC_LPC_COMMAND_FLASH_GET_FLASHMAP 0x14 -struct lpc_response_flash_flashmap { +#define EC_CMD_FLASH_GET_FLASHMAP 0x14 +struct ec_response_flash_flashmap { uint32_t offset; /* Flashmap offset */ } __attribute__ ((packed)); /* Enable/disable flash write protect */ -#define EC_LPC_COMMAND_FLASH_WP_ENABLE 0x15 -struct lpc_params_flash_wp_enable { +#define EC_CMD_FLASH_WP_ENABLE 0x15 +struct ec_params_flash_wp_enable { uint32_t enable_wp; } __attribute__ ((packed)); /* Get flash write protection commit state */ -#define EC_LPC_COMMAND_FLASH_WP_GET_STATE 0x16 -struct lpc_response_flash_wp_enable { +#define EC_CMD_FLASH_WP_GET_STATE 0x16 +struct ec_response_flash_wp_enable { uint32_t enable_wp; } __attribute__ ((packed)); /* Set/get flash write protection range */ -#define EC_LPC_COMMAND_FLASH_WP_SET_RANGE 0x17 -struct lpc_params_flash_wp_range { +#define EC_CMD_FLASH_WP_SET_RANGE 0x17 +struct ec_params_flash_wp_range { /* Byte offset aligned to info.protect_block_size */ uint32_t offset; /* Size should be multiply of info.protect_block_size */ uint32_t size; } __attribute__ ((packed)); -#define EC_LPC_COMMAND_FLASH_WP_GET_RANGE 0x18 -struct lpc_response_flash_wp_range { +#define EC_CMD_FLASH_WP_GET_RANGE 0x18 +struct ec_response_flash_wp_range { uint32_t offset; uint32_t size; } __attribute__ ((packed)); /* Read flash write protection GPIO pin */ -#define EC_LPC_COMMAND_FLASH_WP_GET_GPIO 0x19 -struct lpc_params_flash_wp_gpio { +#define EC_CMD_FLASH_WP_GET_GPIO 0x19 +struct ec_params_flash_wp_gpio { uint32_t pin_no; } __attribute__ ((packed)); -struct lpc_response_flash_wp_gpio { +struct ec_response_flash_wp_gpio { uint32_t value; } __attribute__ ((packed)); #ifdef SUPPORT_CHECKSUM /* Checksum a range of flash datq */ -#define EC_LPC_COMMAND_FLASH_CHECKSUM 0x1f -struct lpc_params_flash_checksum { +#define EC_CMD_FLASH_CHECKSUM 0x1f +struct ec_params_flash_checksum { uint32_t offset; /* Byte offset to read */ uint32_t size; /* Size to read in bytes */ } __attribute__ ((packed)); -struct lpc_response_flash_checksum { +struct ec_response_flash_checksum { uint8_t checksum; } __attribute__ ((packed)); #define BYTE_IN(sum, byte) do { \ @@ -330,26 +330,26 @@ struct lpc_response_flash_checksum { /* PWM commands */ /* Get fan RPM */ -#define EC_LPC_COMMAND_PWM_GET_FAN_RPM 0x20 -struct lpc_response_pwm_get_fan_rpm { +#define EC_CMD_PWM_GET_FAN_RPM 0x20 +struct ec_response_pwm_get_fan_rpm { uint32_t rpm; } __attribute__ ((packed)); /* Set target fan RPM */ -#define EC_LPC_COMMAND_PWM_SET_FAN_TARGET_RPM 0x21 -struct lpc_params_pwm_set_fan_target_rpm { +#define EC_CMD_PWM_SET_FAN_TARGET_RPM 0x21 +struct ec_params_pwm_set_fan_target_rpm { uint32_t rpm; } __attribute__ ((packed)); /* Get keyboard backlight */ -#define EC_LPC_COMMAND_PWM_GET_KEYBOARD_BACKLIGHT 0x22 -struct lpc_response_pwm_get_keyboard_backlight { +#define EC_CMD_PWM_GET_KEYBOARD_BACKLIGHT 0x22 +struct ec_response_pwm_get_keyboard_backlight { uint8_t percent; } __attribute__ ((packed)); /* Set keyboard backlight */ -#define EC_LPC_COMMAND_PWM_SET_KEYBOARD_BACKLIGHT 0x23 -struct lpc_params_pwm_set_keyboard_backlight { +#define EC_CMD_PWM_SET_KEYBOARD_BACKLIGHT 0x23 +struct ec_params_pwm_set_keyboard_backlight { uint8_t percent; } __attribute__ ((packed)); @@ -358,8 +358,8 @@ struct lpc_params_pwm_set_keyboard_backlight { * command to say "talk to the lightbar", we put the "and tell it to do X" * part into a subcommand. We'll make separate structs for subcommands with * different input args, so that we know how much to expect. */ -#define EC_LPC_COMMAND_LIGHTBAR_CMD 0x28 -struct lpc_params_lightbar_cmd { +#define EC_CMD_LIGHTBAR_CMD 0x28 +struct ec_params_lightbar_cmd { union { union { uint8_t cmd; @@ -402,8 +402,8 @@ struct lpc_params_lightbar_cmd { /* USB charging control commands */ /* Set USB port charging mode */ -#define EC_LPC_COMMAND_USB_CHARGE_SET_MODE 0x30 -struct lpc_params_usb_charge_set_mode { +#define EC_CMD_USB_CHARGE_SET_MODE 0x30 +struct ec_params_usb_charge_set_mode { uint8_t usb_port_id; uint8_t mode; } __attribute__ ((packed)); @@ -412,11 +412,11 @@ struct lpc_params_usb_charge_set_mode { /* Persistent storage for host */ /* Maximum bytes that can be read/written in a single command */ -#define EC_LPC_PSTORE_SIZE_MAX 64 +#define EC_PSTORE_SIZE_MAX 64 /* Get persistent storage info */ -#define EC_LPC_COMMAND_PSTORE_INFO 0x40 -struct lpc_response_pstore_info { +#define EC_CMD_PSTORE_INFO 0x40 +struct ec_response_pstore_info { /* Persistent storage size, in bytes */ uint32_t pstore_size; /* Access size. Read/write offset and size must be a multiple @@ -425,59 +425,59 @@ struct lpc_response_pstore_info { } __attribute__ ((packed)); /* Read persistent storage */ -#define EC_LPC_COMMAND_PSTORE_READ 0x41 -struct lpc_params_pstore_read { +#define EC_CMD_PSTORE_READ 0x41 +struct ec_params_pstore_read { uint32_t offset; /* Byte offset to read */ uint32_t size; /* Size to read in bytes */ } __attribute__ ((packed)); -struct lpc_response_pstore_read { - uint8_t data[EC_LPC_PSTORE_SIZE_MAX]; +struct ec_response_pstore_read { + uint8_t data[EC_PSTORE_SIZE_MAX]; } __attribute__ ((packed)); /* Write persistent storage */ -#define EC_LPC_COMMAND_PSTORE_WRITE 0x42 -struct lpc_params_pstore_write { +#define EC_CMD_PSTORE_WRITE 0x42 +struct ec_params_pstore_write { uint32_t offset; /* Byte offset to write */ uint32_t size; /* Size to write in bytes */ - uint8_t data[EC_LPC_PSTORE_SIZE_MAX]; + uint8_t data[EC_PSTORE_SIZE_MAX]; } __attribute__ ((packed)); /*****************************************************************************/ /* Thermal engine commands */ /* Set thershold value */ -#define EC_LPC_COMMAND_THERMAL_SET_THRESHOLD 0x50 -struct lpc_params_thermal_set_threshold { +#define EC_CMD_THERMAL_SET_THRESHOLD 0x50 +struct ec_params_thermal_set_threshold { uint8_t sensor_type; uint8_t threshold_id; uint16_t value; } __attribute__ ((packed)); /* Get threshold value */ -#define EC_LPC_COMMAND_THERMAL_GET_THRESHOLD 0x51 -struct lpc_params_thermal_get_threshold { +#define EC_CMD_THERMAL_GET_THRESHOLD 0x51 +struct ec_params_thermal_get_threshold { uint8_t sensor_type; uint8_t threshold_id; } __attribute__ ((packed)); -struct lpc_response_thermal_get_threshold { +struct ec_response_thermal_get_threshold { uint16_t value; } __attribute__ ((packed)); /* Toggling automatic fan control */ -#define EC_LPC_COMMAND_THERMAL_AUTO_FAN_CTRL 0x52 +#define EC_CMD_THERMAL_AUTO_FAN_CTRL 0x52 /*****************************************************************************/ /* Matrix KeyBoard Protocol */ /* Read key state */ -#define EC_LPC_COMMAND_MKBP_STATE 0x60 -struct lpc_response_mkbp_state { +#define EC_CMD_MKBP_STATE 0x60 +struct ec_response_mkbp_state { uint8_t cols[32]; } __attribute__ ((packed)); /* Provide information about the matrix : number of rows and columns */ -#define EC_LPC_COMMAND_MKBP_INFO 0x61 -struct lpc_response_mkbp_info { +#define EC_CMD_MKBP_INFO 0x61 +struct ec_response_mkbp_info { uint32_t rows; uint32_t cols; } __attribute__ ((packed)); @@ -487,24 +487,24 @@ struct lpc_response_mkbp_info { /* Host event mask params and response structures, shared by all of the host * event commands below. */ -struct lpc_params_host_event_mask { +struct ec_params_host_event_mask { uint32_t mask; } __attribute__ ((packed)); -struct lpc_response_host_event_mask { +struct ec_response_host_event_mask { uint32_t mask; } __attribute__ ((packed)); -/* These all use lpc_response_host_event_mask */ -#define EC_LPC_COMMAND_HOST_EVENT_GET_SMI_MASK 0x88 -#define EC_LPC_COMMAND_HOST_EVENT_GET_SCI_MASK 0x89 -#define EC_LPC_COMMAND_HOST_EVENT_GET_WAKE_MASK 0x8d +/* These all use ec_response_host_event_mask */ +#define EC_CMD_HOST_EVENT_GET_SMI_MASK 0x88 +#define EC_CMD_HOST_EVENT_GET_SCI_MASK 0x89 +#define EC_CMD_HOST_EVENT_GET_WAKE_MASK 0x8d -/* These all use lpc_params_host_event_mask */ -#define EC_LPC_COMMAND_HOST_EVENT_SET_SMI_MASK 0x8a -#define EC_LPC_COMMAND_HOST_EVENT_SET_SCI_MASK 0x8b -#define EC_LPC_COMMAND_HOST_EVENT_CLEAR 0x8c -#define EC_LPC_COMMAND_HOST_EVENT_SET_WAKE_MASK 0x8e +/* These all use ec_params_host_event_mask */ +#define EC_CMD_HOST_EVENT_SET_SMI_MASK 0x8a +#define EC_CMD_HOST_EVENT_SET_SCI_MASK 0x8b +#define EC_CMD_HOST_EVENT_CLEAR 0x8c +#define EC_CMD_HOST_EVENT_SET_WAKE_MASK 0x8e /*****************************************************************************/ /* Special commands @@ -517,7 +517,7 @@ struct lpc_response_host_event_mask { * This clears the lowest-order bit in the currently pending host events, and * sets the result code to the 1-based index of the bit (event 0x00000001 = 1, * event 0x80000000 = 32), or 0 if no event was pending. */ -#define EC_LPC_COMMAND_ACPI_QUERY_EVENT 0x84 +#define EC_CMD_ACPI_QUERY_EVENT 0x84 /* Reboot * @@ -525,16 +525,16 @@ struct lpc_response_host_event_mask { * reboot command is processed at interrupt level. Note that when the EC * reboots, the host will reboot too, so there is no response to this * command. */ -#define EC_LPC_COMMAND_REBOOT 0xd1 /* Think "die" */ +#define EC_CMD_REBOOT 0xd1 /* Think "die" */ -#define EC_LPC_COMMAND_REBOOT_EC 0xd2 -#define EC_LPC_COMMAND_REBOOT_BIT_RECOVERY (1 << 0) +#define EC_CMD_REBOOT_EC 0xd2 +#define EC_CMD_REBOOT_BIT_RECOVERY (1 << 0) -struct lpc_params_reboot_ec { - uint8_t target; /* enum lpc_current_image */ +struct ec_params_reboot_ec { + uint8_t target; /* enum ec_current_image */ uint8_t reboot_flags; } __attribute__ ((packed)); #endif /* !__ACPI__ */ -#endif /* __CROS_EC_LPC_COMMANDS_H */ +#endif /* __CROS_EC_COMMANDS_H */ diff --git a/include/host_command.h b/include/host_command.h index 7bebbe5e19..245d39a162 100644 --- a/include/host_command.h +++ b/include/host_command.h @@ -9,7 +9,7 @@ #define __CROS_EC_HOST_COMMAND_H #include "common.h" -#include "lpc_commands.h" +#include "ec_commands.h" /* Host command */ struct host_command { diff --git a/util/ectool.c b/util/ectool.c index c395a525af..f908c077b3 100644 --- a/util/ectool.c +++ b/util/ectool.c @@ -13,7 +13,7 @@ #include "battery.h" #include "lightbar.h" -#include "lpc_commands.h" +#include "ec_commands.h" /* Handy tricks */ #define BUILD_ASSERT(cond) ((void)sizeof(char[1 - 2*!(cond)])) @@ -195,7 +195,7 @@ int ec_command(int command, const void *indata, int insize, int data_addr = EC_LPC_ADDR_USER_DATA; int param_addr = EC_LPC_ADDR_USER_PARAM; - if (insize > EC_LPC_PARAM_SIZE || outsize > EC_LPC_PARAM_SIZE) { + if (insize > EC_PARAM_SIZE || outsize > EC_PARAM_SIZE) { fprintf(stderr, "Data size too big\n"); return -1; } @@ -255,14 +255,14 @@ int read_mapped_string(uint8_t offset, char *buf) { int c; - for (c = 0; c < EC_LPC_MEMMAP_TEXT_MAX; c++) { + for (c = 0; c < EC_MEMMAP_TEXT_MAX; c++) { buf[c] = inb(EC_LPC_ADDR_MEMMAP + offset + c); if (buf[c] == 0) return c; } - buf[EC_LPC_MEMMAP_TEXT_MAX-1] = 0; - return EC_LPC_MEMMAP_TEXT_MAX; + buf[EC_MEMMAP_TEXT_MAX-1] = 0; + return EC_MEMMAP_TEXT_MAX; } @@ -294,13 +294,13 @@ void print_help(const char *prog) int cmd_hello(int argc, char *argv[]) { - struct lpc_params_hello p; - struct lpc_response_hello r; + struct ec_params_hello p; + struct ec_response_hello r; int rv; p.in_data = 0xa0b0c0d0; - rv = ec_command(EC_LPC_COMMAND_HELLO, &p, sizeof(p), &r, sizeof(r)); + rv = ec_command(EC_CMD_HELLO, &p, sizeof(p), &r, sizeof(r)); if (rv) return rv; @@ -318,14 +318,14 @@ int cmd_hello(int argc, char *argv[]) int cmd_version(int argc, char *argv[]) { static const char * const fw_copies[] = {"unknown", "RO", "A", "B"}; - struct lpc_response_get_version r; - struct lpc_response_get_build_info r2; + struct ec_response_get_version r; + struct ec_response_get_build_info r2; int rv; - rv = ec_command(EC_LPC_COMMAND_GET_VERSION, NULL, 0, &r, sizeof(r)); + rv = ec_command(EC_CMD_GET_VERSION, NULL, 0, &r, sizeof(r)); if (rv) return rv; - rv = ec_command(EC_LPC_COMMAND_GET_BUILD_INFO, + rv = ec_command(EC_CMD_GET_BUILD_INFO, NULL, 0, &r2, sizeof(r2)); if (rv) return rv; @@ -351,8 +351,8 @@ int cmd_version(int argc, char *argv[]) int cmd_read_test(int argc, char *argv[]) { - struct lpc_params_read_test p; - struct lpc_response_read_test r; + struct ec_params_read_test p; + struct ec_response_read_test r; int offset, size; int errors = 0; int rv; @@ -383,7 +383,7 @@ int cmd_read_test(int argc, char *argv[]) for (i = 0; i < size; i += sizeof(r.data)) { p.offset = offset + i / sizeof(uint32_t); p.size = MIN(size - i, sizeof(r.data)); - rv = ec_command(EC_LPC_COMMAND_READ_TEST, &p, sizeof(p), + rv = ec_command(EC_CMD_READ_TEST, &p, sizeof(p), &r, sizeof(r)); if (rv) { fprintf(stderr, "Read error at offset %d\n", i); @@ -415,25 +415,25 @@ int cmd_read_test(int argc, char *argv[]) int cmd_reboot_ec(int argc, char *argv[]) { - struct lpc_params_reboot_ec p; + struct ec_params_reboot_ec p; int rv; if (argc < 2) { - rv = ec_command(EC_LPC_COMMAND_REBOOT, NULL, 0, NULL, 0); + rv = ec_command(EC_CMD_REBOOT, NULL, 0, NULL, 0); } else if (argc == 2) { if (!strcmp(argv[1], "RO")) { - p.target = EC_LPC_IMAGE_RO; + p.target = EC_IMAGE_RO; } else if (!strcmp(argv[1], "A")) { - p.target = EC_LPC_IMAGE_RW_A; + p.target = EC_IMAGE_RW_A; } else if (!strcmp(argv[1], "B")) { - p.target = EC_LPC_IMAGE_RW_B; + p.target = EC_IMAGE_RW_B; } else { fprintf(stderr, "Not supported firmware copy: %s\n", argv[1]); return -1; } - rv = ec_command(EC_LPC_COMMAND_REBOOT_EC, + rv = ec_command(EC_CMD_REBOOT_EC, &p, sizeof(p), NULL, 0); } else { fprintf(stderr, "Wrong argument count: %d\n", argc); @@ -450,10 +450,10 @@ int cmd_reboot_ec(int argc, char *argv[]) int cmd_flash_info(int argc, char *argv[]) { - struct lpc_response_flash_info r; + struct ec_response_flash_info r; int rv; - rv = ec_command(EC_LPC_COMMAND_FLASH_INFO, NULL, 0, &r, sizeof(r)); + rv = ec_command(EC_CMD_FLASH_INFO, NULL, 0, &r, sizeof(r)); if (rv) return rv; @@ -467,8 +467,8 @@ int cmd_flash_info(int argc, char *argv[]) int cmd_flash_read(int argc, char *argv[]) { - struct lpc_params_flash_read p; - struct lpc_response_flash_read r; + struct ec_params_flash_read p; + struct ec_response_flash_read r; int offset, size; int rv; int i; @@ -499,10 +499,10 @@ int cmd_flash_read(int argc, char *argv[]) } /* Read data in chunks */ - for (i = 0; i < size; i += EC_LPC_FLASH_SIZE_MAX) { + for (i = 0; i < size; i += EC_FLASH_SIZE_MAX) { p.offset = offset + i; - p.size = MIN(size - i, EC_LPC_FLASH_SIZE_MAX); - rv = ec_command(EC_LPC_COMMAND_FLASH_READ, + p.size = MIN(size - i, EC_FLASH_SIZE_MAX); + rv = ec_command(EC_CMD_FLASH_READ, &p, sizeof(p), &r, sizeof(r)); if (rv) { fprintf(stderr, "Read error at offset %d\n", i); @@ -524,7 +524,7 @@ int cmd_flash_read(int argc, char *argv[]) int cmd_flash_write(int argc, char *argv[]) { - struct lpc_params_flash_write p; + struct ec_params_flash_write p; int offset, size; int rv; int i; @@ -549,11 +549,11 @@ int cmd_flash_write(int argc, char *argv[]) printf("Writing to offset %d...\n", offset); /* Write data in chunks */ - for (i = 0; i < size; i += EC_LPC_FLASH_SIZE_MAX) { + for (i = 0; i < size; i += EC_FLASH_SIZE_MAX) { p.offset = offset + i; - p.size = MIN(size - i, EC_LPC_FLASH_SIZE_MAX); + p.size = MIN(size - i, EC_FLASH_SIZE_MAX); memcpy(p.data, buf + i, p.size); - rv = ec_command(EC_LPC_COMMAND_FLASH_WRITE, + rv = ec_command(EC_CMD_FLASH_WRITE, &p, sizeof(p), NULL, 0); if (rv) { fprintf(stderr, "Write error at offset %d\n", i); @@ -570,7 +570,7 @@ int cmd_flash_write(int argc, char *argv[]) int cmd_flash_erase(int argc, char *argv[]) { - struct lpc_params_flash_erase p; + struct ec_params_flash_erase p; char *e; if (argc < 3) { @@ -589,7 +589,7 @@ int cmd_flash_erase(int argc, char *argv[]) } printf("Erasing %d bytes at offset %d...\n", p.size, p.offset); - if (ec_command(EC_LPC_COMMAND_FLASH_ERASE, &p, sizeof(p), NULL, 0)) + if (ec_command(EC_CMD_FLASH_ERASE, &p, sizeof(p), NULL, 0)) return -1; printf("done.\n"); @@ -641,7 +641,7 @@ int cmd_temperature(int argc, char *argv[]) } printf("Reading temperature..."); - rv = read_mapped_mem8(EC_LPC_MEMMAP_TEMP_SENSOR + id); + rv = read_mapped_mem8(EC_MEMMAP_TEMP_SENSOR + id); if (rv == 0xff) { printf("Sensor not present\n"); return -1; @@ -652,7 +652,7 @@ int cmd_temperature(int argc, char *argv[]) printf("Sensor disabled/unpowered\n"); return -1; } else { - printf("%d\n", rv + EC_LPC_TEMP_SENSOR_OFFSET); + printf("%d\n", rv + EC_TEMP_SENSOR_OFFSET); return 0; } } @@ -660,8 +660,8 @@ int cmd_temperature(int argc, char *argv[]) int cmd_thermal_get_threshold(int argc, char *argv[]) { - struct lpc_params_thermal_get_threshold p; - struct lpc_response_thermal_get_threshold r; + struct ec_params_thermal_get_threshold p; + struct ec_response_thermal_get_threshold r; char *e; int rv; @@ -683,7 +683,7 @@ int cmd_thermal_get_threshold(int argc, char *argv[]) return -1; } - rv = ec_command(EC_LPC_COMMAND_THERMAL_GET_THRESHOLD, + rv = ec_command(EC_CMD_THERMAL_GET_THRESHOLD, &p, sizeof(p), &r, sizeof(r)); if (rv) return rv; @@ -700,7 +700,7 @@ int cmd_thermal_get_threshold(int argc, char *argv[]) int cmd_thermal_set_threshold(int argc, char *argv[]) { - struct lpc_params_thermal_set_threshold p; + struct ec_params_thermal_set_threshold p; char *e; int rv; @@ -729,7 +729,7 @@ int cmd_thermal_set_threshold(int argc, char *argv[]) return -1; } - rv = ec_command(EC_LPC_COMMAND_THERMAL_SET_THRESHOLD, + rv = ec_command(EC_CMD_THERMAL_SET_THRESHOLD, &p, sizeof(p), NULL, 0); if (rv) return rv; @@ -745,7 +745,7 @@ int cmd_thermal_auto_fan_ctrl(int argc, char *argv[]) { int rv; - rv = ec_command(EC_LPC_COMMAND_THERMAL_AUTO_FAN_CTRL, + rv = ec_command(EC_CMD_THERMAL_AUTO_FAN_CTRL, NULL, 0, NULL, 0); if (rv) return rv; @@ -759,7 +759,7 @@ int cmd_pwm_get_fan_rpm(int argc, char *argv[]) { int rv; - rv = read_mapped_mem16(EC_LPC_MEMMAP_FAN); + rv = read_mapped_mem16(EC_MEMMAP_FAN); if (rv == 0xffff) return -1; @@ -774,7 +774,7 @@ int cmd_pwm_get_fan_rpm(int argc, char *argv[]) int cmd_pwm_set_fan_rpm(int argc, char *argv[]) { - struct lpc_params_pwm_set_fan_target_rpm p; + struct ec_params_pwm_set_fan_target_rpm p; char *e; int rv; @@ -789,7 +789,7 @@ int cmd_pwm_set_fan_rpm(int argc, char *argv[]) return -1; } - rv = ec_command(EC_LPC_COMMAND_PWM_SET_FAN_TARGET_RPM, + rv = ec_command(EC_CMD_PWM_SET_FAN_TARGET_RPM, &p, sizeof(p), NULL, 0); if (rv) return rv; @@ -801,10 +801,10 @@ int cmd_pwm_set_fan_rpm(int argc, char *argv[]) int cmd_pwm_get_keyboard_backlight(int argc, char *argv[]) { - struct lpc_response_pwm_get_keyboard_backlight r; + struct ec_response_pwm_get_keyboard_backlight r; int rv; - rv = ec_command(EC_LPC_COMMAND_PWM_GET_KEYBOARD_BACKLIGHT, + rv = ec_command(EC_CMD_PWM_GET_KEYBOARD_BACKLIGHT, NULL, 0, &r, sizeof(r)); if (rv) return rv; @@ -817,7 +817,7 @@ int cmd_pwm_get_keyboard_backlight(int argc, char *argv[]) int cmd_pwm_set_keyboard_backlight(int argc, char *argv[]) { - struct lpc_params_pwm_set_keyboard_backlight p; + struct ec_params_pwm_set_keyboard_backlight p; char *e; int rv; @@ -831,7 +831,7 @@ int cmd_pwm_set_keyboard_backlight(int argc, char *argv[]) return -1; } - rv = ec_command(EC_LPC_COMMAND_PWM_SET_KEYBOARD_BACKLIGHT, + rv = ec_command(EC_CMD_PWM_SET_KEYBOARD_BACKLIGHT, &p, sizeof(p), NULL, 0); if (rv) return rv; @@ -856,24 +856,24 @@ static const struct { uint8_t insize; uint8_t outsize; } lb_command_paramcount[] = { - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.dump), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.dump) }, - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.off), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.off) }, - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.on), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.on) }, - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.init), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.init) }, - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.brightness), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.brightness) }, - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.seq), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.seq) }, - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.reg), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.reg) }, - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.rgb), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.rgb) }, - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.get_seq), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.get_seq) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.dump), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.dump) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.off), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.off) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.on), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.on) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.init), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.init) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.brightness), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.brightness) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.seq), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.seq) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.reg), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.reg) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.rgb), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.rgb) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.get_seq), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.get_seq) }, }; static int lb_help(const char *cmd) @@ -903,11 +903,11 @@ static uint8_t lb_find_msg_by_name(const char *str) } static int lb_do_cmd(enum lightbar_command cmd, - struct lpc_params_lightbar_cmd *ptr) + struct ec_params_lightbar_cmd *ptr) { int r; ptr->in.cmd = cmd; - r = ec_command(EC_LPC_COMMAND_LIGHTBAR_CMD, + r = ec_command(EC_CMD_LIGHTBAR_CMD, ptr, lb_command_paramcount[cmd].insize, ptr, lb_command_paramcount[cmd].outsize); return r; @@ -916,7 +916,7 @@ static int lb_do_cmd(enum lightbar_command cmd, static void lb_show_msg_names(void) { int i, current_state; - struct lpc_params_lightbar_cmd param; + struct ec_params_lightbar_cmd param; (void)lb_do_cmd(LIGHTBAR_CMD_GET_SEQ, ¶m); current_state = param.out.get_seq.num; @@ -931,7 +931,7 @@ static void lb_show_msg_names(void) static int cmd_lightbar(int argc, char **argv) { int i, r; - struct lpc_params_lightbar_cmd param; + struct ec_params_lightbar_cmd param; if (1 == argc) { /* no args = dump 'em all */ r = lb_do_cmd(LIGHTBAR_CMD_DUMP, ¶m); @@ -1001,7 +1001,7 @@ static int cmd_lightbar(int argc, char **argv) int cmd_usb_charge_set_mode(int argc, char *argv[]) { - struct lpc_params_usb_charge_set_mode p; + struct ec_params_usb_charge_set_mode p; char *e; int rv; @@ -1023,7 +1023,7 @@ int cmd_usb_charge_set_mode(int argc, char *argv[]) printf("Setting port %d to mode %d...\n", p.usb_port_id, p.mode); - rv = ec_command(EC_LPC_COMMAND_USB_CHARGE_SET_MODE, + rv = ec_command(EC_CMD_USB_CHARGE_SET_MODE, &p, sizeof(p), NULL, 0); if (rv) return rv; @@ -1035,10 +1035,10 @@ int cmd_usb_charge_set_mode(int argc, char *argv[]) int cmd_pstore_info(int argc, char *argv[]) { - struct lpc_response_pstore_info r; + struct ec_response_pstore_info r; int rv; - rv = ec_command(EC_LPC_COMMAND_PSTORE_INFO, NULL, 0, &r, sizeof(r)); + rv = ec_command(EC_CMD_PSTORE_INFO, NULL, 0, &r, sizeof(r)); if (rv) return rv; @@ -1049,8 +1049,8 @@ int cmd_pstore_info(int argc, char *argv[]) int cmd_pstore_read(int argc, char *argv[]) { - struct lpc_params_pstore_read p; - struct lpc_response_pstore_read r; + struct ec_params_pstore_read p; + struct ec_response_pstore_read r; int offset, size; int rv; int i; @@ -1081,10 +1081,10 @@ int cmd_pstore_read(int argc, char *argv[]) } /* Read data in chunks */ - for (i = 0; i < size; i += EC_LPC_PSTORE_SIZE_MAX) { + for (i = 0; i < size; i += EC_PSTORE_SIZE_MAX) { p.offset = offset + i; - p.size = MIN(size - i, EC_LPC_PSTORE_SIZE_MAX); - rv = ec_command(EC_LPC_COMMAND_PSTORE_READ, + p.size = MIN(size - i, EC_PSTORE_SIZE_MAX); + rv = ec_command(EC_CMD_PSTORE_READ, &p, sizeof(p), &r, sizeof(r)); if (rv) { fprintf(stderr, "Read error at offset %d\n", i); @@ -1106,7 +1106,7 @@ int cmd_pstore_read(int argc, char *argv[]) int cmd_pstore_write(int argc, char *argv[]) { - struct lpc_params_pstore_write p; + struct ec_params_pstore_write p; int offset, size; int rv; int i; @@ -1131,11 +1131,11 @@ int cmd_pstore_write(int argc, char *argv[]) printf("Writing to offset %d...\n", offset); /* Write data in chunks */ - for (i = 0; i < size; i += EC_LPC_PSTORE_SIZE_MAX) { + for (i = 0; i < size; i += EC_PSTORE_SIZE_MAX) { p.offset = offset + i; - p.size = MIN(size - i, EC_LPC_PSTORE_SIZE_MAX); + p.size = MIN(size - i, EC_PSTORE_SIZE_MAX); memcpy(p.data, buf + i, p.size); - rv = ec_command(EC_LPC_COMMAND_PSTORE_WRITE, + rv = ec_command(EC_CMD_PSTORE_WRITE, &p, sizeof(p), NULL, 0); if (rv) { fprintf(stderr, "Write error at offset %d\n", i); @@ -1154,7 +1154,7 @@ int cmd_acpi_query_ec(int argc, char *argv[]) { int rv; - rv = ec_command(EC_LPC_COMMAND_ACPI_QUERY_EVENT, NULL, 0, NULL, 0); + rv = ec_command(EC_CMD_ACPI_QUERY_EVENT, NULL, 0, NULL, 0); if (rv) printf("Got host event %d (mask 0x%08x)\n", rv, 1 << (rv - 1)); else @@ -1166,17 +1166,17 @@ int cmd_acpi_query_ec(int argc, char *argv[]) int cmd_host_event_get_raw(int argc, char *argv[]) { printf("Current host events: 0x%08x\n", - read_mapped_mem32(EC_LPC_MEMMAP_HOST_EVENTS)); + read_mapped_mem32(EC_MEMMAP_HOST_EVENTS)); return 0; } int cmd_host_event_get_smi_mask(int argc, char *argv[]) { - struct lpc_response_host_event_mask r; + struct ec_response_host_event_mask r; int rv; - rv = ec_command(EC_LPC_COMMAND_HOST_EVENT_GET_SMI_MASK, + rv = ec_command(EC_CMD_HOST_EVENT_GET_SMI_MASK, NULL, 0, &r, sizeof(r)); if (rv) return rv; @@ -1188,10 +1188,10 @@ int cmd_host_event_get_smi_mask(int argc, char *argv[]) int cmd_host_event_get_sci_mask(int argc, char *argv[]) { - struct lpc_response_host_event_mask r; + struct ec_response_host_event_mask r; int rv; - rv = ec_command(EC_LPC_COMMAND_HOST_EVENT_GET_SCI_MASK, + rv = ec_command(EC_CMD_HOST_EVENT_GET_SCI_MASK, NULL, 0, &r, sizeof(r)); if (rv) return rv; @@ -1203,10 +1203,10 @@ int cmd_host_event_get_sci_mask(int argc, char *argv[]) int cmd_host_event_get_wake_mask(int argc, char *argv[]) { - struct lpc_response_host_event_mask r; + struct ec_response_host_event_mask r; int rv; - rv = ec_command(EC_LPC_COMMAND_HOST_EVENT_GET_WAKE_MASK, + rv = ec_command(EC_CMD_HOST_EVENT_GET_WAKE_MASK, NULL, 0, &r, sizeof(r)); if (rv) return rv; @@ -1218,7 +1218,7 @@ int cmd_host_event_get_wake_mask(int argc, char *argv[]) int cmd_host_event_set_smi_mask(int argc, char *argv[]) { - struct lpc_params_host_event_mask p; + struct ec_params_host_event_mask p; char *e; int rv; @@ -1232,7 +1232,7 @@ int cmd_host_event_set_smi_mask(int argc, char *argv[]) return -1; } - rv = ec_command(EC_LPC_COMMAND_HOST_EVENT_SET_SMI_MASK, + rv = ec_command(EC_CMD_HOST_EVENT_SET_SMI_MASK, &p, sizeof(p), NULL, 0); if (rv) return rv; @@ -1244,7 +1244,7 @@ int cmd_host_event_set_smi_mask(int argc, char *argv[]) int cmd_host_event_set_sci_mask(int argc, char *argv[]) { - struct lpc_params_host_event_mask p; + struct ec_params_host_event_mask p; char *e; int rv; @@ -1258,7 +1258,7 @@ int cmd_host_event_set_sci_mask(int argc, char *argv[]) return -1; } - rv = ec_command(EC_LPC_COMMAND_HOST_EVENT_SET_SCI_MASK, + rv = ec_command(EC_CMD_HOST_EVENT_SET_SCI_MASK, &p, sizeof(p), NULL, 0); if (rv) return rv; @@ -1270,7 +1270,7 @@ int cmd_host_event_set_sci_mask(int argc, char *argv[]) int cmd_host_event_set_wake_mask(int argc, char *argv[]) { - struct lpc_params_host_event_mask p; + struct ec_params_host_event_mask p; char *e; int rv; @@ -1284,7 +1284,7 @@ int cmd_host_event_set_wake_mask(int argc, char *argv[]) return -1; } - rv = ec_command(EC_LPC_COMMAND_HOST_EVENT_SET_WAKE_MASK, + rv = ec_command(EC_CMD_HOST_EVENT_SET_WAKE_MASK, &p, sizeof(p), NULL, 0); if (rv) return rv; @@ -1296,7 +1296,7 @@ int cmd_host_event_set_wake_mask(int argc, char *argv[]) int cmd_host_event_clear(int argc, char *argv[]) { - struct lpc_params_host_event_mask p; + struct ec_params_host_event_mask p; char *e; int rv; @@ -1310,7 +1310,7 @@ int cmd_host_event_clear(int argc, char *argv[]) return -1; } - rv = ec_command(EC_LPC_COMMAND_HOST_EVENT_CLEAR, + rv = ec_command(EC_CMD_HOST_EVENT_CLEAR, &p, sizeof(p), NULL, 0); if (rv) return rv; @@ -1322,18 +1322,18 @@ int cmd_host_event_clear(int argc, char *argv[]) int cmd_switches(int argc, char *argv[]) { - uint8_t s = read_mapped_mem8(EC_LPC_MEMMAP_SWITCHES); + uint8_t s = read_mapped_mem8(EC_MEMMAP_SWITCHES); printf("Current switches: 0x%02x\n", s); printf("Lid switch: %s\n", - (s & EC_LPC_SWITCH_LID_OPEN ? "OPEN" : "CLOSED")); + (s & EC_SWITCH_LID_OPEN ? "OPEN" : "CLOSED")); printf("Power button: %s\n", - (s & EC_LPC_SWITCH_POWER_BUTTON_PRESSED ? "DOWN" : "UP")); + (s & EC_SWITCH_POWER_BUTTON_PRESSED ? "DOWN" : "UP")); printf("Write protect: %sABLED\n", - (s & EC_LPC_SWITCH_WRITE_PROTECT_DISABLED ? "DIS" : "EN")); + (s & EC_SWITCH_WRITE_PROTECT_DISABLED ? "DIS" : "EN")); printf("Keyboard recovery: %sABLED\n", - (s & EC_LPC_SWITCH_KEYBOARD_RECOVERY ? "EN" : "DIS")); + (s & EC_SWITCH_KEYBOARD_RECOVERY ? "EN" : "DIS")); printf("Dedicated recovery: %sABLED\n", - (s & EC_LPC_SWITCH_DEDICATED_RECOVERY ? "EN" : "DIS")); + (s & EC_SWITCH_DEDICATED_RECOVERY ? "EN" : "DIS")); return 0; } @@ -1341,55 +1341,55 @@ int cmd_switches(int argc, char *argv[]) int cmd_battery(int argc, char *argv[]) { - char batt_text[EC_LPC_MEMMAP_TEXT_MAX]; + char batt_text[EC_MEMMAP_TEXT_MAX]; int rv, val; printf("Battery info:\n"); - rv = read_mapped_string(EC_LPC_MEMMAP_BATT_MFGR, batt_text); + rv = read_mapped_string(EC_MEMMAP_BATT_MFGR, batt_text); if (rv) { if (!is_string_printable(batt_text)) goto cmd_error; printf(" OEM name: %s\n", batt_text); } - rv = read_mapped_string(EC_LPC_MEMMAP_BATT_MODEL, batt_text); + rv = read_mapped_string(EC_MEMMAP_BATT_MODEL, batt_text); if (rv) { if (!is_string_printable(batt_text)) goto cmd_error; printf(" Model number: %s\n", batt_text); } - rv = read_mapped_string(EC_LPC_MEMMAP_BATT_TYPE, batt_text); + rv = read_mapped_string(EC_MEMMAP_BATT_TYPE, batt_text); if (rv) { if (!is_string_printable(batt_text)) goto cmd_error; printf(" Chemistry : %s\n", batt_text); } - rv = read_mapped_string(EC_LPC_MEMMAP_BATT_SERIAL, batt_text); + rv = read_mapped_string(EC_MEMMAP_BATT_SERIAL, batt_text); if (rv) { if (!is_string_printable(batt_text)) goto cmd_error; printf(" Serial number: %s\n", batt_text); } - val = read_mapped_mem32(EC_LPC_MEMMAP_BATT_DCAP); + val = read_mapped_mem32(EC_MEMMAP_BATT_DCAP); if (!is_battery_range(val)) goto cmd_error; printf(" Design capacity: %u mAh\n", val); - val = read_mapped_mem32(EC_LPC_MEMMAP_BATT_LFCC); + val = read_mapped_mem32(EC_MEMMAP_BATT_LFCC); if (!is_battery_range(val)) goto cmd_error; printf(" Last full charge: %u mAh\n", val); - val = read_mapped_mem32(EC_LPC_MEMMAP_BATT_DVLT); + val = read_mapped_mem32(EC_MEMMAP_BATT_DVLT); if (!is_battery_range(val)) goto cmd_error; printf(" Design output voltage %u mV\n", val); - val = read_mapped_mem32(EC_LPC_MEMMAP_BATT_DCAP); + val = read_mapped_mem32(EC_MEMMAP_BATT_DCAP); if (!is_battery_range(val)) goto cmd_error; printf(" Design capacity warning %u mAh\n", @@ -1397,7 +1397,7 @@ int cmd_battery(int argc, char *argv[]) printf(" Design capacity low %u mAh\n", val * BATTERY_LEVEL_LOW / 100); - val = read_mapped_mem32(EC_LPC_MEMMAP_BATT_CCNT); + val = read_mapped_mem32(EC_MEMMAP_BATT_CCNT); if (!is_battery_range(val)) goto cmd_error; printf(" Cycle count %u\n", val); @@ -1410,12 +1410,12 @@ cmd_error: int cmd_chipinfo(int argc, char *argv[]) { - struct lpc_response_get_chip_info info; + struct ec_response_get_chip_info info; int rv; printf("Chip info:\n"); - rv = ec_command(EC_LPC_COMMAND_GET_CHIP_INFO, + rv = ec_command(EC_CMD_GET_CHIP_INFO, NULL, 0, &info, sizeof(info)); if (rv) return rv; diff --git a/util/lbplay.c b/util/lbplay.c index 56934ebea2..6e0ceefcba 100644 --- a/util/lbplay.c +++ b/util/lbplay.c @@ -11,7 +11,7 @@ #include <unistd.h> #include "lightbar.h" -#include "lpc_commands.h" +#include "ec_commands.h" /* Handy tricks */ #define BUILD_ASSERT(cond) ((void)sizeof(char[1 - 2*!(cond)])) @@ -43,7 +43,7 @@ static int ec_command(int command, const void *indata, int insize, int data_addr = EC_LPC_ADDR_USER_DATA; int param_addr = EC_LPC_ADDR_USER_PARAM; - if (insize > EC_LPC_PARAM_SIZE || outsize > EC_LPC_PARAM_SIZE) { + if (insize > EC_PARAM_SIZE || outsize > EC_PARAM_SIZE) { fprintf(stderr, "Data size too big\n"); return -1; } @@ -84,32 +84,32 @@ static const struct { uint8_t insize; uint8_t outsize; } lb_command_paramcount[] = { - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.dump), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.dump) }, - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.off), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.off) }, - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.on), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.on) }, - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.init), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.init) }, - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.brightness), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.brightness) }, - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.seq), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.seq) }, - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.reg), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.reg) }, - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.rgb), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.rgb) }, - { sizeof(((struct lpc_params_lightbar_cmd *)0)->in.get_seq), - sizeof(((struct lpc_params_lightbar_cmd *)0)->out.get_seq) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.dump), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.dump) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.off), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.off) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.on), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.on) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.init), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.init) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.brightness), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.brightness) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.seq), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.seq) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.reg), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.reg) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.rgb), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.rgb) }, + { sizeof(((struct ec_params_lightbar_cmd *)0)->in.get_seq), + sizeof(((struct ec_params_lightbar_cmd *)0)->out.get_seq) }, }; static void lb_cmd_noargs(enum lightbar_command cmd) { - struct lpc_params_lightbar_cmd param; + struct ec_params_lightbar_cmd param; param.in.cmd = cmd; - ec_command(EC_LPC_COMMAND_LIGHTBAR_CMD, + ec_command(EC_CMD_LIGHTBAR_CMD, ¶m, lb_command_paramcount[param.in.cmd].insize, ¶m, lb_command_paramcount[param.in.cmd].outsize); } @@ -131,45 +131,45 @@ inline void lightbar_init_vals(void) void lightbar_brightness(int newval) { - struct lpc_params_lightbar_cmd param; + struct ec_params_lightbar_cmd param; param.in.cmd = LIGHTBAR_CMD_BRIGHTNESS; param.in.brightness.num = newval; - ec_command(EC_LPC_COMMAND_LIGHTBAR_CMD, + ec_command(EC_CMD_LIGHTBAR_CMD, ¶m, lb_command_paramcount[param.in.cmd].insize, ¶m, lb_command_paramcount[param.in.cmd].outsize); } void lightbar_sequence(enum lightbar_sequence num) { - struct lpc_params_lightbar_cmd param; + struct ec_params_lightbar_cmd param; param.in.cmd = LIGHTBAR_CMD_SEQ; param.in.seq.num = num; - ec_command(EC_LPC_COMMAND_LIGHTBAR_CMD, + ec_command(EC_CMD_LIGHTBAR_CMD, ¶m, lb_command_paramcount[param.in.cmd].insize, ¶m, lb_command_paramcount[param.in.cmd].outsize); } void lightbar_reg(uint8_t ctrl, uint8_t reg, uint8_t val) { - struct lpc_params_lightbar_cmd param; + struct ec_params_lightbar_cmd param; param.in.cmd = LIGHTBAR_CMD_REG; param.in.reg.ctrl = ctrl; param.in.reg.reg = reg; param.in.reg.value = val; - ec_command(EC_LPC_COMMAND_LIGHTBAR_CMD, + ec_command(EC_CMD_LIGHTBAR_CMD, ¶m, lb_command_paramcount[param.in.cmd].insize, ¶m, lb_command_paramcount[param.in.cmd].outsize); } void lightbar_rgb(int led, int red, int green, int blue) { - struct lpc_params_lightbar_cmd param; + struct ec_params_lightbar_cmd param; param.in.cmd = LIGHTBAR_CMD_RGB; param.in.rgb.led = led; param.in.rgb.red = red; param.in.rgb.green = green; param.in.rgb.blue = blue; - ec_command(EC_LPC_COMMAND_LIGHTBAR_CMD, + ec_command(EC_CMD_LIGHTBAR_CMD, ¶m, lb_command_paramcount[param.in.cmd].insize, ¶m, lb_command_paramcount[param.in.cmd].outsize); } @@ -177,13 +177,13 @@ void lightbar_rgb(int led, int red, int green, int blue) void wait_for_ec_to_stop(void) { int r; - struct lpc_params_lightbar_cmd param; + struct ec_params_lightbar_cmd param; int count = 0; do { usleep(100000); param.in.cmd = LIGHTBAR_CMD_GET_SEQ; - r = ec_command(EC_LPC_COMMAND_LIGHTBAR_CMD, + r = ec_command(EC_CMD_LIGHTBAR_CMD, ¶m, lb_command_paramcount[param.in.cmd].insize, ¶m, |