From 61022575d3c8b75d07e4f3be3f1616e45767f673 Mon Sep 17 00:00:00 2001 From: Dossym Nurmukhanov Date: Fri, 11 Dec 2020 11:17:39 -0800 Subject: COIL: Use inclusive language for EC-EC communication code Replace with server/client nomenclature BUG=none TEST=build and run on volteer BRANCH=none Signed-off-by: dossym@chromium.org Change-Id: I23fe7de9228a9611b49eef1362bf15159b25aab7 Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/2586038 Reviewed-by: Nicolas Boichat --- board/hammer/board.c | 16 ++++++++-------- board/hammer/ec.tasklist | 2 +- common/charge_state_v2.c | 10 +++++----- common/ec_ec_comm_client.c | 20 ++++++++++---------- common/ec_ec_comm_server.c | 38 +++++++++++++++++++------------------- include/ec_ec_comm_client.h | 34 +++++++++++++++++----------------- include/ec_ec_comm_server.h | 14 +++++++------- 7 files changed, 67 insertions(+), 67 deletions(-) diff --git a/board/hammer/board.c b/board/hammer/board.c index c0bb79b83f..d64d4975ad 100644 --- a/board/hammer/board.c +++ b/board/hammer/board.c @@ -145,15 +145,15 @@ struct keyboard_scan_config keyscan_config = { struct consumer const ec_ec_usart_consumer; static struct usart_config const ec_ec_usart; -struct queue const ec_ec_comm_slave_input = QUEUE_DIRECT(64, uint8_t, +struct queue const ec_ec_comm_server_input = QUEUE_DIRECT(64, uint8_t, ec_ec_usart.producer, ec_ec_usart_consumer); -struct queue const ec_ec_comm_slave_output = QUEUE_DIRECT(64, uint8_t, +struct queue const ec_ec_comm_server_output = QUEUE_DIRECT(64, uint8_t, null_producer, ec_ec_usart.consumer); struct consumer const ec_ec_usart_consumer = { - .queue = &ec_ec_comm_slave_input, + .queue = &ec_ec_comm_server_input, .ops = &((struct consumer_ops const) { - .written = ec_ec_comm_slave_written, + .written = ec_ec_comm_server_written, }), }; @@ -163,8 +163,8 @@ static struct usart_config const ec_ec_usart = usart_tx_interrupt, 115200, USART_CONFIG_FLAG_HDSEL, - ec_ec_comm_slave_input, - ec_ec_comm_slave_output); + ec_ec_comm_server_input, + ec_ec_comm_server_output); #endif /* BOARD_WAND && SECTION_IS_RW */ /****************************************************************************** @@ -184,8 +184,8 @@ static void board_init(void) #ifdef BOARD_WAND /* USB to serial queues */ - queue_init(&ec_ec_comm_slave_input); - queue_init(&ec_ec_comm_slave_output); + queue_init(&ec_ec_comm_server_input); + queue_init(&ec_ec_comm_server_output); /* UART init */ usart_init(&ec_ec_usart); diff --git a/board/hammer/ec.tasklist b/board/hammer/ec.tasklist index ecdb6db120..b568619065 100644 --- a/board/hammer/ec.tasklist +++ b/board/hammer/ec.tasklist @@ -13,7 +13,7 @@ TASK_ALWAYS_RW(TOUCHPAD, touchpad_task, NULL, LARGER_TASK_STACK_SIZE) \ TASK_ALWAYS_RW(CHARGER, charger_task, NULL, LARGER_TASK_STACK_SIZE) \ TASK_ALWAYS (CONSOLE, console_task, NULL, 1024) \ - TASK_ALWAYS_RW(ECCOMM, ec_ec_comm_slave_task, NULL, TASK_STACK_SIZE) \ + TASK_ALWAYS_RW(ECCOMM, ec_ec_comm_server_task, NULL, TASK_STACK_SIZE) \ TASK_NOTEST_RW(KEYSCAN, keyboard_scan_task, NULL, TASK_STACK_SIZE) #elif defined(CONFIG_USB_ISOCHRONOUS) #define CONFIG_TASK_LIST \ diff --git a/common/charge_state_v2.c b/common/charge_state_v2.c index 6734b15569..4bb6eb947a 100644 --- a/common/charge_state_v2.c +++ b/common/charge_state_v2.c @@ -306,11 +306,11 @@ static void update_base_battery_info(void) int flags_changed; int old_full_capacity = bd->full_capacity; - ec_ec_master_base_get_dynamic_info(); + ec_ec_client_base_get_dynamic_info(); flags_changed = (old_flags != bd->flags); /* Fetch static information when flags change. */ if (flags_changed) - ec_ec_master_base_get_static_info(); + ec_ec_client_base_get_static_info(); battery_memmap_refresh(BATT_IDX_BASE); @@ -350,7 +350,7 @@ static int set_base_current(int current_base, int allow_charge_base) const int otg_voltage = db_policy.otg_voltage; int ret; - ret = ec_ec_master_base_charge_control(current_base, + ret = ec_ec_client_base_charge_control(current_base, otg_voltage, allow_charge_base); if (ret) { /* Ignore errors until the base is responsive. */ @@ -560,7 +560,7 @@ static void charge_allocate_input_current_limit(void) if (base_responsive) { /* Base still responsive, put it to sleep. */ CPRINTF("Hibernating base\n"); - ec_ec_master_hibernate(); + ec_ec_client_hibernate(); base_responsive = 0; board_enable_base_power(0); } @@ -2088,7 +2088,7 @@ wait_for_it: #endif #ifdef CONFIG_EC_EC_COMM_BATTERY_SLAVE /* - * On EC-EC slave, do not charge if curr.ac is 0: there + * On EC-EC server, do not charge if curr.ac is 0: there * might still be some external power available but we * do not want to use it for charging. */ diff --git a/common/ec_ec_comm_client.c b/common/ec_ec_comm_client.c index d2602470bc..c92433af8c 100644 --- a/common/ec_ec_comm_client.c +++ b/common/ec_ec_comm_client.c @@ -2,7 +2,7 @@ * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. * - * EC-EC communication, functions and definitions for master. + * EC-EC communication, functions and definitions for client. */ #include "battery.h" @@ -22,11 +22,11 @@ * TODO(b:65697962): The packed structures below do not play well if we force EC * host commands structures to be aligned on 32-bit boundary. There are ways to * fix that, possibly requiring copying data around, or modifying - * uart_alt_pad_write_read API to write the actual slave response to a separate + * uart_alt_pad_write_read API to write the actual server response to a separate * buffer. */ #ifdef CONFIG_HOSTCMD_ALIGNED -#error "Cannot define CONFIG_HOSTCMD_ALIGNED with EC-EC communication master." +#error "Cannot define CONFIG_HOSTCMD_ALIGNED with EC-EC communication client." #endif #define EC_EC_HOSTCMD_VERSION 4 @@ -78,7 +78,7 @@ struct { * crc8 are verified by this function). * * This format is required as the EC-EC UART is half-duplex, and all the - * transmitted data is received back, i.e. the master writes req, then reads + * transmitted data is received back, i.e. the client writes req, then reads * req, followed by resp. * * When a command does not take parameters, param/crc8 must be omitted in @@ -113,12 +113,12 @@ static int write_command(uint16_t command, struct ec_host_response4 *response_header = (void *)&data[tx_length]; - /* RX length is TX length + response from slave. */ + /* RX length is TX length + response from server. */ int rx_length = tx_length + sizeof(*request_header) + ((resp_len > 0) ? (resp_len + 1) : 0); /* - * Make sure there is a gap between each command, so that the slave + * Make sure there is a gap between each command, so that the server * can recover its state machine after each command. * * TODO(b:65697962): We can be much smarter than this, and record the @@ -241,7 +241,7 @@ static int handle_error(const char *func, int ret, int request_result) } #ifdef CONFIG_EC_EC_COMM_BATTERY -int ec_ec_master_base_get_dynamic_info(void) +int ec_ec_client_base_get_dynamic_info(void) { int ret; struct { @@ -281,7 +281,7 @@ int ec_ec_master_base_get_dynamic_info(void) return EC_RES_SUCCESS; } -int ec_ec_master_base_get_static_info(void) +int ec_ec_client_base_get_static_info(void) { int ret; struct { @@ -321,7 +321,7 @@ int ec_ec_master_base_get_static_info(void) return EC_RES_SUCCESS; } -int ec_ec_master_base_charge_control(int max_current, +int ec_ec_client_base_charge_control(int max_current, int otg_voltage, int allow_charging) { @@ -347,7 +347,7 @@ int ec_ec_master_base_charge_control(int max_current, return handle_error(__func__, ret, data.resp.head.result); } -int ec_ec_master_hibernate(void) +int ec_ec_client_hibernate(void) { int ret; struct { diff --git a/common/ec_ec_comm_server.c b/common/ec_ec_comm_server.c index af00f45248..23b5fee139 100644 --- a/common/ec_ec_comm_server.c +++ b/common/ec_ec_comm_server.c @@ -2,7 +2,7 @@ * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. * - * EC-EC communication, task and functions for slave. + * EC-EC communication, task and functions for server. */ #include "common.h" @@ -27,7 +27,7 @@ /* Print extra debugging information */ #undef EXTRA_DEBUG -/* Set if the master allows the slave to charge the battery. */ +/* Set if the client allows the server to charge the battery. */ static int charging_allowed; /* @@ -52,7 +52,7 @@ BUILD_ASSERT(LARGEST_PARAMS_SIZE >= #define COMMAND_TIMEOUT_US (5 * MSEC) -void ec_ec_comm_slave_written(struct consumer const *consumer, size_t count) +void ec_ec_comm_server_written(struct consumer const *consumer, size_t count) { task_wake(TASK_ID_ECCOMM); } @@ -66,13 +66,13 @@ void ec_ec_comm_slave_written(struct consumer const *consumer, size_t count) static void discard_queue(void) { do { - queue_advance_head(&ec_ec_comm_slave_input, - queue_count(&ec_ec_comm_slave_input)); + queue_advance_head(&ec_ec_comm_server_input, + queue_count(&ec_ec_comm_server_input)); usleep(1 * MSEC); - } while (queue_count(&ec_ec_comm_slave_input) > 0); + } while (queue_count(&ec_ec_comm_server_input) > 0); } -/* Write response to master. */ +/* Write response to client. */ static void write_response(uint16_t res, int seq, const void *data, int len) { struct ec_host_response4 header; @@ -89,13 +89,13 @@ static void write_response(uint16_t res, int seq, const void *data, int len) header.reserved = 0; header.header_crc = cros_crc8((uint8_t *)&header, sizeof(header)-1); - QUEUE_ADD_UNITS(&ec_ec_comm_slave_output, + QUEUE_ADD_UNITS(&ec_ec_comm_server_output, (uint8_t *)&header, sizeof(header)); if (len > 0) { - QUEUE_ADD_UNITS(&ec_ec_comm_slave_output, data, len); + QUEUE_ADD_UNITS(&ec_ec_comm_server_output, data, len); crc = cros_crc8(data, len); - QUEUE_ADD_UNITS(&ec_ec_comm_slave_output, &crc, sizeof(crc)); + QUEUE_ADD_UNITS(&ec_ec_comm_server_output, &crc, sizeof(crc)); } } @@ -108,7 +108,7 @@ static int read_data(void *buffer, size_t len, uint32_t start) { uint32_t delta; - while (queue_count(&ec_ec_comm_slave_input) < len) { + while (queue_count(&ec_ec_comm_server_input) < len) { delta = __hw_clock_source_read() - start; if (delta >= COMMAND_TIMEOUT_US) return EC_ERROR_TIMEOUT; @@ -118,7 +118,7 @@ static int read_data(void *buffer, size_t len, uint32_t start) } /* Fetch header */ - QUEUE_REMOVE_UNITS(&ec_ec_comm_slave_input, buffer, len); + QUEUE_REMOVE_UNITS(&ec_ec_comm_server_input, buffer, len); return EC_SUCCESS; } @@ -191,13 +191,13 @@ out: } /* - * On dual-battery slave, we use the charging allowed signal from master to + * On dual-battery server, we use the charging allowed signal from client to * indicate whether external power is present. * - * In most cases, this actually matches the external power status of the master - * (slave battery charging when AC is connected, or discharging when slave - * battery still has enough capacity), with one exception: when we do master to - * slave battery charging (in this case the "external" power is the master). + * In most cases, this actually matches the external power status of the client + * (server battery charging when AC is connected, or discharging when server + * battery still has enough capacity), with one exception: when we do client to + * server battery charging (in this case the "external" power is the client). */ int extpower_is_present(void) { @@ -205,7 +205,7 @@ int extpower_is_present(void) } #endif -void ec_ec_comm_slave_task(void *u) +void ec_ec_comm_server_task(void *u) { struct ec_host_request4 header; /* @@ -219,7 +219,7 @@ void ec_ec_comm_slave_task(void *u) while (1) { task_wait_event(-1); - if (queue_count(&ec_ec_comm_slave_input) == 0) + if (queue_count(&ec_ec_comm_server_input) == 0) continue; /* We got some data, start timeout counter. */ diff --git a/include/ec_ec_comm_client.h b/include/ec_ec_comm_client.h index ccd46a9bc2..9a60daffe4 100644 --- a/include/ec_ec_comm_client.h +++ b/include/ec_ec_comm_client.h @@ -2,57 +2,57 @@ * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. * - * EC-EC communication, functions for master. + * EC-EC communication, functions for client. */ -#ifndef EC_EC_COMM_MASTER_H_ -#define EC_EC_COMM_MASTER_H_ +#ifndef EC_EC_COMM_CLIENT_H_ +#define EC_EC_COMM_CLIENT_H_ #include #include "config.h" /** - * Sends EC_CMD_BATTERY_GET_DYNAMIC command to slave, and writes the + * Sends EC_CMD_BATTERY_GET_DYNAMIC command to server, and writes the * battery dynamic information into battery_dynamic[BATT_IDX_BASE]. * * Leaves battery_dynamic[BATT_IDX_BASE] intact on error: it is the callers * responsibility to clear the data or ignore it. * @return EC_RES_SUCCESS on success, EC_RES_ERROR on communication error, - * else forwards the error code from the slave. + * else forwards the error code from the server. */ -int ec_ec_master_base_get_dynamic_info(void); +int ec_ec_client_base_get_dynamic_info(void); /** - * Sends EC_CMD_BATTERY_GET_STATIC command to slave, and writes the + * Sends EC_CMD_BATTERY_GET_STATIC command to server, and writes the * battery static information into battery_static[BATT_IDX_BASE]. * * Leaves battery_static[BATT_IDX_BASE] intact on error: it is the callers * responsibility to clear the data or ignore it. * * @return EC_RES_SUCCESS on success, EC_RES_ERROR on communication error, - * else forwards the error code from the slave. + * else forwards the error code from the server. */ -int ec_ec_master_base_get_static_info(void); +int ec_ec_client_base_get_static_info(void); /** - * Sends EC_CMD_CHARGER_CONTROL command to slave, with the given parameters + * Sends EC_CMD_CHARGER_CONTROL command to server, with the given parameters * (see ec_commands.h/ec_params_charger_control for description). * * @return EC_RES_SUCCESS on success, EC_RES_ERROR on communication error, - * else forwards the error code from the slave. + * else forwards the error code from the server. */ -int ec_ec_master_base_charge_control(int max_current, +int ec_ec_client_base_charge_control(int max_current, int otg_voltage, int allow_charging); /** - * Sends EC_CMD_REBOOT_EC command to slave, with EC_REBOOT_HIBERNATE parameter. + * Sends EC_CMD_REBOOT_EC command to server, with EC_REBOOT_HIBERNATE parameter. * * @return EC_RES_ERROR on communication error (should always be the case if the - * slave successfully hibernates, as it will not be able to write back the - * response, else forwards the error code from the slave. + * server successfully hibernates, as it will not be able to write back the + * response, else forwards the error code from the server. */ -int ec_ec_master_hibernate(void); +int ec_ec_client_hibernate(void); -#endif /* EC_EC_COMM_MASTER_H_ */ +#endif /* EC_EC_COMM_CLIENT_H_ */ diff --git a/include/ec_ec_comm_server.h b/include/ec_ec_comm_server.h index 19e1912d94..1ed5588666 100644 --- a/include/ec_ec_comm_server.h +++ b/include/ec_ec_comm_server.h @@ -2,19 +2,19 @@ * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. * - * EC-EC communication, functions and definition for slave. + * EC-EC communication, functions and definition for server. */ -#ifndef EC_EC_COMM_SLAVE_H_ -#define EC_EC_COMM_SLAVE_H_ +#ifndef EC_EC_COMM_SERVER_H_ +#define EC_EC_COMM_SERVER_H_ #include #include "consumer.h" #include "queue.h" -extern struct queue const ec_ec_comm_slave_input; -extern struct queue const ec_ec_comm_slave_output; +extern struct queue const ec_ec_comm_server_input; +extern struct queue const ec_ec_comm_server_output; -void ec_ec_comm_slave_written(struct consumer const *consumer, size_t count); +void ec_ec_comm_server_written(struct consumer const *consumer, size_t count); -#endif /* EC_EC_COMM_SLAVE_H_ */ +#endif /* EC_EC_COMM_SERVER_H_ */ -- cgit v1.2.1