ec.h

Go to the documentation of this file.

/* SPDX-License-Identifier: GPL-2.0-only */
 
/*
 * Mailbox EC communication interface for Google Chrome Embedded Controller.
 */
 
#ifndef _EC_GOOGLE_CHROMEEC_EC_H
#define _EC_GOOGLE_CHROMEEC_EC_H
#include <types.h>
#include <device/device.h>
#include "ec_commands.h"
#include <device/usbc_mux.h>
 
/* Fill in base and size of the IO port resources used. */
void google_chromeec_ioport_range(uint16_t *base, size_t *size);
 
int google_chromeec_i2c_xfer(uint8_t chip, uint8_t addr, int alen,
                             uint8_t *buffer, int len, int is_read);
uint64_t google_chromeec_get_wake_mask(void);
int google_chromeec_set_sci_mask(uint64_t mask);
int google_chromeec_set_smi_mask(uint64_t mask);
int google_chromeec_set_wake_mask(uint64_t mask);
enum host_event_code google_chromeec_get_event(void);
 
/* Check if EC supports feature EC_FEATURE_UNIFIED_WAKE_MASKS */
bool google_chromeec_is_uhepi_supported(void);
int google_ec_running_ro(void);
enum ec_image google_chromeec_get_current_image(void);
void google_chromeec_init(void);
/* Check for the current mux state in EC
 * in: int port physical port number of the type-c port
 * out: uint8_t flags representing the status of the mux such as
 *      usb capability, dp capability, cable type, etc
 */
int google_chromeec_usb_get_pd_mux_info(int port, uint8_t *flags);
/* Poll (up to `timeout_ms` ms) for DisplayPort to be ready
 * Return:      -1: Error. 0: Timeout.
 *              >=1: Bitmask of the ports that DP device is connected
 */
int google_chromeec_wait_for_displayport(long timeout_ms);
/* Poll (up to `timeout_ms` ms) for a Hot-Plug Detect (HPD)
 * event on the specified port.
 * Return: 0 on HPD ready, -1 on timeout */
int google_chromeec_wait_for_dp_hpd(int port, long timeout_ms);
/* Send command to EC to request to enter DisplayPort ALT mode on the
 * specified port.
 * Return: 0 on success, -1 on error */
int google_chromeec_typec_control_enter_dp_mode(int port);
/*
 * Obtain any USB-C mux data needed for the specified port
 * in: int port physical port number of the type-c port
 * out: struct usbc_mux_info mux_info stores USB-C mux data
 * Return: 0 on success, -1 on error
 */
int google_chromeec_get_usbc_mux_info(int port, struct usbc_mux_info *mux_info);
 
/* Device events */
uint64_t google_chromeec_get_device_enabled_events(void);
int google_chromeec_set_device_enabled_events(uint64_t mask);
uint64_t google_chromeec_get_device_current_events(void);
 
int google_chromeec_check_feature(int feature);
uint8_t google_chromeec_calc_checksum(const uint8_t *data, int size);
 
/**
 * google_chromeec_get_board_version() - Get the board version
 * @version: Out parameter to retrieve the board Version
 *
 * Return: 0 on success or -1 on failure/error.
 *
 * This function is used to get the board version information from EC.
 */
int google_chromeec_get_board_version(uint32_t *version);
uint32_t google_chromeec_get_sku_id(void);
int google_chromeec_set_sku_id(uint32_t skuid);
uint64_t  google_chromeec_get_events_b(void);
int google_chromeec_clear_events_b(uint64_t mask);
int google_chromeec_kbbacklight(int percent);
void google_chromeec_post(uint8_t postcode);
int google_chromeec_vbnv_context(int is_read, uint8_t *data, int len);
uint8_t google_chromeec_get_switches(void);
bool google_chromeec_get_ap_watchdog_flag(void);
 
/* Temporary secure storage commands */
int google_chromeec_vstore_supported(void);
int google_chromeec_vstore_info(uint32_t *locked);
int google_chromeec_vstore_read(int slot, uint8_t *data);
int google_chromeec_vstore_write(int slot, uint8_t *data, size_t size);
 
/* Issue reboot command to EC with specified type and flags. Returns 0 on
   success, < 0 otherwise. */
int google_chromeec_reboot(int dev_idx, enum ec_reboot_cmd type, uint8_t flags);
 
/**
 * Get data from Cros Board Info
 *
 * @param id/fw_config/buf [OUT] value from CBI.
 * @return 0 on success or negative integer for errors.
 */
int google_chromeec_cbi_get_oem_id(uint32_t *id);
int google_chromeec_cbi_get_sku_id(uint32_t *id);
int google_chromeec_cbi_get_fw_config(uint64_t *fw_config);
int google_chromeec_cbi_get_dram_part_num(char *buf, size_t bufsize);
int google_chromeec_cbi_get_oem_name(char *buf, size_t bufsize);
/* version may be stored in CBI as a smaller integer width, but the EC code
   handles it correctly. */
int google_chromeec_cbi_get_board_version(uint32_t *version);
int google_chromeec_cbi_get_ssfc(uint32_t *ssfc);
 
#define CROS_SKU_UNKNOWN        0xFFFFFFFF
#define CROS_SKU_UNPROVISIONED  0x7FFFFFFF
/* Returns CROS_SKU_UNKNOWN on failure. */
uint32_t google_chromeec_get_board_sku(void);
const char *google_chromeec_smbios_system_sku(void);
 
/* MEC uses 0x800/0x804 as register/index pair, thus an 8-byte resource. */
#define MEC_EMI_BASE            0x800
#define MEC_EMI_SIZE            8
 
/* For MEC, access ranges 0x800 thru 0x9ff using EMI interface instead of LPC */
#define MEC_EMI_RANGE_START EC_HOST_CMD_REGION0
#define MEC_EMI_RANGE_END   (EC_LPC_ADDR_MEMMAP + EC_MEMMAP_SIZE)
 
int google_chromeec_set_usb_charge_mode(uint8_t port_id, enum usb_charge_mode mode);
int google_chromeec_set_usb_pd_role(uint8_t port, enum usb_pd_control_role role);
/*
 * Retrieve the charger type and max wattage.
 *
 * @param type      charger type
 * @param current_max charger max current
 * @param voltage_max charger max voltage
 * @return non-zero for error, otherwise 0.
 */
int google_chromeec_get_usb_pd_power_info(enum usb_chg_type *type,
                                          uint16_t *current_max, uint16_t *voltage_max);
 
/*
 * Set max current and voltage of a dedicated charger.
 *
 * @param current_lim Max current in mA
 * @param voltage_lim Max voltage in mV
 * @return non-zero for error, otherwise 0.
 */
int google_chromeec_override_dedicated_charger_limit(uint16_t current_lim,
                                                     uint16_t voltage_lim);
 
/* internal structure to send a command to the EC and wait for response. */
struct chromeec_command {
        uint16_t    cmd_code;     /* command code in, status out */
        uint8_t     cmd_version;  /* command version */
        const void* cmd_data_in;  /* command data, if any */
        void*       cmd_data_out; /* command response, if any */
        uint16_t    cmd_size_in;  /* size of command data */
        uint16_t    cmd_size_out; /* expected size of command response in,
                                   * actual received size out */
        int         cmd_dev_index;/* device index for passthru */
};
 
/*
 * There are transport level constraints for sending protov3 packets. Because
 * of this provide a way for the generic protocol layer to request buffers
 * so that there is zero copying being done through the layers.
 *
 * Request the buffer provided the size. If 'req' is non-zero then the
 * buffer requested is for EC requests. Otherwise it's for responses. Return
 * non-NULL on success, NULL on error.
 */
void *crosec_get_buffer(size_t size, int req);
 
/*
 * The lower level transport works on the buffers handed out to the
 * upper level. Therefore, only the size of the request and response
 * are required.
 */
typedef int (*crosec_io_t)(size_t req_size, size_t resp_size, void *context);
int crosec_command_proto(struct chromeec_command *cec_command,
                         crosec_io_t crosec_io, void *context);
 
/**
 * Performs light verification of the EC<->AP communication channel.
 *
 * @return              0 on success, -1 on error
 */
int google_chromeec_hello(void);
 
/**
 * Send a command to a CrOS EC
 *
 * @param cec_command: CrOS EC command to send
 * @return 0 for success. Non-zero for error.
 */
int google_chromeec_command(struct chromeec_command *cec_command);
 
struct google_chromeec_event_info {
        uint64_t log_events;
        uint64_t sci_events;
        uint64_t smi_events;
        uint64_t s3_wake_events;
        uint64_t s3_device_events;
        uint64_t s5_wake_events;
        uint64_t s0ix_wake_events;
};
void google_chromeec_events_init(const struct google_chromeec_event_info *info,
                                        bool is_s3_wakeup);
 
/*
 * Get next available MKBP event in ec_response_get_next_event. Returns 0 on
 * success, < 0 otherwise.
 */
int google_chromeec_get_mkbp_event(struct ec_response_get_next_event *event);
 
/* Log host events to eventlog based on the mask provided. */
void google_chromeec_log_events(uint64_t mask);
 
/**
 * Protect/un-protect EC flash regions.
 *
 * @param mask          Set/clear the requested bits in 'flags'
 * @param flags         Flash protection flags
 * @param resp          Pointer to response structure
 * @return              0 on success, -1 on error
 */
int google_chromeec_flash_protect(uint32_t mask, uint32_t flags,
                                  struct ec_response_flash_protect *resp);
/**
 * Calculate image hash for vboot.
 *
 * @param hash_type     The hash types supported by the EC for vboot
 * @param offset        The offset to start hashing in flash
 * @param resp          Pointer to response structure
 * @return              0 on success, -1 on error
 */
int google_chromeec_start_vboot_hash(enum ec_vboot_hash_type hash_type,
                                     uint32_t offset,
                                     struct ec_response_vboot_hash *resp);
/**
 * Return the EC's vboot image hash.
 *
 * @param offset        Get hash for flash region beginning here
 * @param resp          Pointer to response structure
 * @return              0 on success, -1 on error
 *
 */
int google_chromeec_get_vboot_hash(uint32_t offset,
                                   struct ec_response_vboot_hash *resp);
 
/**
 * Get offset and size of the specified EC flash region.
 *
 * @param region        Which region of EC flash
 * @param offset        Gets filled with region's offset
 * @param size          Gets filled with region's size
 * @return              0 on success, -1 on error
 */
int google_chromeec_flash_region_info(enum ec_flash_region region,
                                      uint32_t *offset, uint32_t *size);
/**
 * Erase a region of EC flash.
 *
 * @param offset        Where to begin erasing
 * @param size          Size of area to erase
 * @return              0 on success, -1 on error
 */
int google_chromeec_flash_erase(uint32_t region_offset, uint32_t region_size);
 
/**
 * Return information about the entire flash.
 *
 * @param info          Pointer to response structure
 * @return              0 on success, -1 on error
 */
int google_chromeec_flash_info(struct ec_response_flash_info *info);
 
/**
 * Write a block into EC flash.
 *
 * @param data          Pointer to data to write to flash, prefixed by a
 *                      struct ec_params_flash_write
 * @param offset        Offset to begin writing data
 * @param size          Number of bytes to be written to flash from data
 * @return              0 on success, -1 on error
 */
int google_chromeec_flash_write_block(const uint8_t *data, uint32_t size);
 
/**
 * Verify flash using EFS if available.
 *
 * @param region        Which flash region to verify
 * @return              0 on success, -1 on error
 */
int google_chromeec_efs_verify(enum ec_flash_region region);
 
/**
 * Command EC to perform battery cutoff.
 *
 * @param flags         Flags to pass to the EC
 * @return              0 on success, -1 on error
 */
int google_chromeec_battery_cutoff(uint8_t flags);
 
/**
 * Check if the EC is requesting the system to limit input power.
 *
 * @param limit_power   If successful, limit_power is 1 if EC is requesting
 *                      input power limits, otherwise 0.
 * @return              0 on success, -1 on error
 */
int google_chromeec_read_limit_power_request(int *limit_power);
 
/**
 * Get information about the protocol that the EC speaks.
 *
 * @param resp          Filled with host command protocol information.
 * @return              0 on success, -1 on error
 */
int google_chromeec_get_protocol_info(
        struct ec_response_get_protocol_info *resp);
 
/**
 * Get available versions of the specified command.
 *
 * @param command       Command ID
 * @param pmask         Pointer to version mask
 * @return              0 on success, -1 on error
 */
int google_chromeec_get_cmd_versions(int command, uint32_t *pmask);
 
/**
 * Get number of PD-capable USB ports from EC.
 *
 * @param *num_ports    If successful, num_ports is the number
 *                      of PD-capable USB ports according to the EC.
 * @return              0 on success, -1 on error
 */
int google_chromeec_get_num_pd_ports(unsigned int *num_ports);
 
/* Structure representing the capabilities of a USB-PD port */
struct usb_pd_port_caps {
        enum ec_pd_power_role_caps power_role_cap;
        enum ec_pd_try_power_role_caps try_power_role_cap;
        enum ec_pd_data_role_caps data_role_cap;
        enum ec_pd_port_location port_location;
};
 
/**
 * Get role-based capabilities for a USB-PD port
 *
 * @param port                  Which port to get information about
 * @param *power_role_cap       The power-role capability of the port
 * @param *try_power_role_cap   The Try-power-role capability of the port
 * @param *data_role_cap        The data role capability of the port
 * @param *port_location        Location of the port on the device
 * @return                      0 on success, -1 on error
 */
int google_chromeec_get_pd_port_caps(int port,
                                struct usb_pd_port_caps *port_caps);
 
/**
 * Get the keyboard configuration / layout information from EC
 *
 * @param *keybd        If successful, this is filled with EC filled parameters
 * @return              0 on success, -1 on error
 */
int google_chromeec_get_keybd_config(struct ec_response_keybd_config *keybd);
 
/**
 * Send EC command to perform AP reset
 *
 * @return      0 on success, -1 on error
 */
int google_chromeec_ap_reset(void);
 
/**
 * Configure the regulator as enabled / disabled.
 *
 * @param index         Regulator ID
 * @param enable        Set to enable / disable the regulator
 * @return              0 on success, -1 on error
 */
int google_chromeec_regulator_enable(uint32_t index, uint8_t enable);
 
/**
 * Query if the regulator is enabled.
 *
 * @param index         Regulator ID
 * @param *enabled      If successful, enabled indicates enable/disable status.
 * @return              0 on success, -1 on error
 */
int google_chromeec_regulator_is_enabled(uint32_t index, uint8_t *enabled);
 
/**
 * Set voltage for the voltage regulator within the range specified.
 *
 * @param index         Regulator ID
 * @param min_mv        Minimum voltage
 * @param max_mv        Maximum voltage
 * @return              0 on success, -1 on error
 */
int google_chromeec_regulator_set_voltage(uint32_t index, uint32_t min_mv,
                                          uint32_t max_mv);
 
/**
 * Get the currently configured voltage for the voltage regulator.
 *
 * @param index         Regulator ID
 * @param *voltage_mv   If successful, voltage_mv is filled with current voltage
 * @return              0 on success, -1 on error
 */
int google_chromeec_regulator_get_voltage(uint32_t index, uint32_t *voltage_mv);
 
#if CONFIG(HAVE_ACPI_TABLES)
/**
 * Writes USB Type-C PD related information to the SSDT
 *
 * @param dev                   EC device
 */
void google_chromeec_fill_ssdt_generator(const struct device *dev);
 
/**
 * Returns the ACPI name for the EC device.
 *
 * @param dev                   EC device
 */
const char *google_chromeec_acpi_name(const struct device *dev);
 
#endif /* HAVE_ACPI_TABLES */
 
#endif /* _EC_GOOGLE_CHROMEEC_EC_H */