src/ec/google/wilco/commands.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2
   3 #ifndef EC_GOOGLE_WILCO_COMMANDS_H
   4 #define EC_GOOGLE_WILCO_COMMANDS_H
   5
   6 #include <types.h>
   7
   8 enum {
   9         /* Read and clear power state information */
  10         KB_POWER_SMI = 0x04,
  11         /* Read but do not clear power state information */
  12         KB_POWER_STATUS = 0x05,
  13         /* Inform the EC about the reason host is turning off */
  14         KB_POWER_OFF = 0x08,
  15         /* Control wireless radios */
  16         KB_RADIO_CONTROL = 0x2b,
  17         /* Save PS/2 data before S3 suspend */
  18         KB_SAVE = 0x2f,
  19         /* Restore PS/2 data after S3 resume */
  20         KB_RESTORE = 0x30,
  21         /* Manage the EC control of camera power */
  22         KB_CAMERA = 0x33,
  23         /* Retrieve information about the EC */
  24         KB_EC_INFO = 0x38,
  25         /* Set ACPI mode on or off */
  26         KB_ACPI = 0x3a,
  27         /* Board ID */
  28         KB_BOARD_ID = 0x3d,
  29         /* Change ACPI wake up source */
  30         KB_ACPI_WAKEUP_CHANGE = 0x4a,
  31         /* Manage the EC power button passthru to the host */
  32         KB_POWER_BUTTON_TO_HOST = 0x3e,
  33         /* Manage the EC control of speaker mute */
  34         KB_HW_MUTE_CONTROL = 0x60,
  35         /* Inform the EC that the host is about to enter S3 */
  36         KB_SLP_EN = 0x64,
  37         /* Inform the EC about BIOS boot progress */
  38         KB_BIOS_PROGRESS = 0xc2,
  39         /* Inform the EC that a fatal error occurred */
  40         KB_ERR_CODE = 0x7b,
  41         /* Set CPU ID */
  42         KB_CPU_ID = 0xbf,
  43 };
  44
  45 enum ec_ram_addr {
  46         /* Indicate if EC uses signed firmware */
  47         EC_RAM_SIGNED_FW = 0x5c,
  48         /* Indicate support for S0ix */
  49         EC_RAM_S0IX_SUPPORT = 0xb8,
  50 };
  51
  52 enum set_acpi_mode_cmd {
  53         ACPI_OFF = 0,
  54         ACPI_ON
  55 };
  56
  57 enum bios_progress_code {
  58         BIOS_PROGRESS_BEFORE_MEMORY = 0x00,
  59         BIOS_PROGRESS_MEMORY_INIT = 0x01,
  60         BIOS_PROGRESS_VIDEO_INIT = 0x02,
  61         BIOS_PROGRESS_LOGO_DISPLAYED = 0x03,
  62         BIOS_PROGRESS_POST_COMPLETE = 0x04,
  63 };
  64
  65 enum ec_audio_mute {
  66         AUDIO_MUTE = 0,         /* Mute speakers immediately */
  67         AUDIO_UNMUTE_125MS,     /* Unmute in 125ms */
  68 };
  69
  70 enum ec_radio {
  71         RADIO_WIFI = 0,
  72         RADIO_WWAN,
  73         RADIO_BT,
  74 };
  75
  76 enum ec_radio_action {
  77         RADIO_READ = 1,
  78         RADIO_WRITE,
  79         RADIO_TOGGLE,
  80 };
  81
  82 enum ec_camera {
  83         CAMERA_ON = 0,
  84         CAMERA_OFF
  85 };
  86
  87 enum ec_err_code {
  88         DLED_MEMORY = 0x03,
  89         DLED_PANEL = 0x10,
  90         DLED_ROM = 0x19,
  91 };
  92
  93 /**
  94  * wilco_ec_radio_control() - Control wireless radios.
  95  * @ec_radio: Wireless radio type.
  96  * @state: Turn radio on or off.
  97  * Return: 0 if successful or negative error code on failure.
  98  */
  99 int wilco_ec_radio_control(enum ec_radio radio, uint8_t state);
 100
 101 /*
 102  * EC Information
 103  */
 104
 105 enum get_ec_info_cmd {
 106         GET_EC_LABEL = 0,
 107         GET_EC_SVN_REV,
 108         GET_EC_MODEL_NO,
 109         GET_EC_BUILD_DATE
 110 };
 111
 112 #define EC_INFO_MAX_SIZE 9
 113 struct ec_response_get_ec_info {
 114         char data[EC_INFO_MAX_SIZE]; /* ASCII NUL terminated string */
 115 };
 116
 117 /**
 118  * wilco_ec_get_info
 119  *
 120  * Read a specific information string from the EC and return it in
 121  * the caller-provided buffer of at least EC_INFO_MAX_SIZE bytes.
 122  *
 123  * @cmd:        Information to retrieve
 124  * @info:       Character array of EC_INFO_MAX_SIZE bytes
 125  *
 126  * Returns 0 if successful and resulting string is in 'info'
 127  * Returns -1 if the EC command fails
 128  */
 129 int wilco_ec_get_info(enum get_ec_info_cmd cmd, char *info);
 130
 131 /**
 132  * wilco_ec_print_all_info
 133  *
 134  * Retrieve and print all the information strings from the EC:
 135  *
 136  *  GET_EC_LABEL
 137  *  GET_EC_SVN_REV
 138  *  GET_EC_MODEL_NO
 139  *  GET_EC_BUILD_DATE
 140  */
 141 void wilco_ec_print_all_info(void);
 142
 143 /*
 144  * EC Power State
 145  */
 146
 147 enum ec_power_off_reason {
 148         EC_PWROFF_FLASH = 0x11,
 149         EC_PWROFF_AC_REMOVED = 0x12,
 150         EC_PWROFF_BAT_REMOVED = 0x13,
 151         EC_PWROFF_LOBAT = 0x15,
 152         EC_PWROFF_PWRB_IN_POST = 0x16,
 153         EC_PWROFF_FORCE_IMMEDIATE = 0x18,
 154         EC_PWROFF_WDT = 0x1b,
 155         EC_PWROFF_FORCE_THERMAL = 0x22,
 156         EC_PWROFF_ERR_CODE = 0x23,
 157         EC_PWROFF_PAID_PWRGD = 0x27,
 158         EC_PWROFF_PAID_CPU = 0x28,
 159         EC_PWROFF_PAID_GFX = 0x29,
 160         EC_PWROFF_PAID_CLK = 0x2a,
 161         EC_PWROFF_PAID_NOMEMORY = 0x2b,
 162         EC_PWROFF_PAID_MEMORY_ERR = 0x2c,
 163         EC_PWROFF_PAID_MEMORY_SPD = 0x2d,
 164         EC_SWOFF_ACPI = 0x31,
 165         EC_SWOFF_BOOT_PASSWORD = 0x33,
 166         EC_SWOFF_DISK_PASSWORD = 0x34,
 167         EC_SWOFF_POWER_CYCLE = 0x37,
 168         EC_SWOFF_HARD_RESET = 0x3b,
 169         EC_SWOFF_FSMI = 0x3f,
 170         EC_PWRLOG_THERMTRIP = 0x41,
 171         EC_PWRLOG_NO_S5 = 0x42,
 172         EC_PWROFF_4S_PWRB = 0x44,
 173         EC_PWROFF_ASF2_FORCEOFF = 0x45,
 174         EC_PWROFF_PWRB_THERMAL = 0x48,
 175         EC_PWROFF_AOAC_TIMER = 0x4b,
 176 };
 177
 178 /**
 179  * wilco_ec_power_off
 180  *
 181  * Tell the EC why the host is about to power off.
 182 */
 183 void wilco_ec_power_off(enum ec_power_off_reason reason);
 184
 185 /**
 186  * wilco_ec_slp_en
 187  *
 188  * Tell the EC that the host is entering a sleep state.
 189  */
 190 void wilco_ec_slp_en(void);
 191
 192 enum ec_pm1_state {
 193         EC_PM1_AC_AVAIL = BIT(0),       /* AC available */
 194         EC_PM1_BAT_AVAIL = BIT(1),      /* Battery available */
 195         EC_PM1_LO_BAT1 = BIT(2),        /* Battery 1 low */
 196         EC_PM1_LO_BAT2 = BIT(3),        /* Battery 2 low */
 197         EC_PM1_LID_OPEN = BIT(4),       /* Lid is open */
 198         EC_PM1_LCD_POWER = BIT(5),      /* LCD is powered */
 199         EC_PM1_OVER_TEMP = BIT(6),      /* CPU is over temperature */
 200         EC_PM1_DOCKED = BIT(7),         /* System is docked */
 201 };
 202
 203 enum ec_pm2_state {
 204         EC_PM2_SYS_MB_PCIE = BIT(0),    /* MB has PCIe */
 205         EC_PM2_SYS_MB_SATA = BIT(1),    /* MB has SATA */
 206         EC_PM2_PWRB_PRESSED = BIT(2),   /* Power button is pressed */
 207         EC_PM2_TURBO_MODE = BIT(3),     /* Turbo mode */
 208 };
 209
 210 enum ec_pm3_state {
 211         EC_PM3_BAT1_PRES = BIT(2),      /* Battery 1 is present */
 212         EC_PM3_BAT2_PRES = BIT(3),      /* Battery 2 is present */
 213         EC_PM3_LOWER_PSTATE = BIT(6),   /* EC requests lower P-state */
 214         EC_PM3_CPU_THROTTLE = BIT(7),   /* EC requests CPU throttle */
 215 };
 216
 217 enum ec_pm4_state {
 218         EC_PM4_BAT1_CHG = BIT(0),       /* Battery 1 is being charged */
 219         EC_PM4_BAT2_CHG = BIT(1),       /* Battery 2 is being charged */
 220         EC_PM4_BAT1_PWR = BIT(2),       /* Battery 1 is powering the system */
 221         EC_PM4_BAT2_PWR = BIT(3),       /* Battery 2 is powering the system */
 222         EC_PM4_PANEL_STATE = BIT(5),    /* Panel power state */
 223 };
 224
 225 enum ec_pm5_state {
 226         EC_PM5_INT_HD_SATA = BIT(7),    /* Internal SATA HDD */
 227 };
 228
 229 enum ec_pm6_state {
 230         EC_PM6_WLAN_SWITCH = BIT(0),    /* Wireless switch */
 231         EC_PM6_SYS_MB_MODEM = BIT(1),   /* MB has modem */
 232         EC_PM6_ETH_STATE = BIT(2),      /* Ethernet cable state */
 233         EC_PM6_AC_UPDATE = BIT(3),      /* Update AC information */
 234 };
 235
 236 enum ec_pm1_event {
 237         EC_EV1_PWRB_PRESSED = BIT(0),   /* Power button was pressed */
 238         EC_EV1_HOTKEY_PRESSED = BIT(1), /* Hotkey was pressed */
 239         EC_EV1_STATE_CHANGED = BIT(2),  /* PMx state changed */
 240 };
 241
 242 enum ec_pm2_event {
 243         EC_EV2_ACPI_MONSWITCH = BIT(0), /* Monitor switch status */
 244 };
 245
 246 struct ec_pm_event_state {
 247         uint8_t event[2];               /* ec_pm{1,2}_event */
 248         uint8_t state[6];               /* ec_pm{1,2,3,4,5,6}_state */
 249         uint8_t hotkey;                 /* Hotkey, if pressed */
 250         uint16_t ac_type;               /* AC adapter information */
 251 };
 252
 253 /**
 254  * wilco_ec_get_pm
 255  *
 256  * Retrieve power and event information from the EC.
 257  *
 258  * @pm:         Power event state structure to fill out
 259  * @clear:      Clear EC event state after reading
 260  *
 261  * Returns 0 if EC command was successful
 262  * Returns -1 if EC command failed
 263  */
 264 int wilco_ec_get_pm(struct ec_pm_event_state *pm, bool clear);
 265
 266 /**
 267  * wilco_ec_get_lid_state
 268  *
 269  * Retrieve the lid state without clearing it in the EC.
 270  *
 271  * Returns 1 if the lid is open, 0 if it is closed
 272  * Returns -1 if the EC command failed
 273  */
 274 int wilco_ec_get_lid_state(void);
 275
 276 /**
 277  * wilco_ec_get_board_id
 278  *
 279  * Retrieve the board ID value from the EC.
 280  * @id:         Pointer to variable to store the ID read from the EC.
 281  *
 282  * Returns number of bytes transferred from the EC
 283  * Returns -1 if the EC command failed
 284  */
 285 int wilco_ec_get_board_id(uint8_t *id);
 286
 287 enum ec_wake_change {
 288         WAKE_OFF = 0,
 289         WAKE_ON
 290 };
 291 /**
 292  * wilco_ec_change_wake_source
 293  *
 294  * Change acpi wake up source.
 295  * @source:             Wake up source that can be enabled/disabled.
 296  * @ec_wake_change:     On/off switch.
 297  *
 298  * Returns -1 if the EC command failed
 299  */
 300 int wilco_ec_change_wake(uint8_t source, enum ec_wake_change change);
 301
 302 enum ec_acpi_wake_events {
 303         EC_ACPI_WAKE_PWRB = BIT(0),     /* Wake up by power button */
 304         EC_ACPI_WAKE_LID = BIT(1),      /* Wake up by lid switch */
 305         EC_ACPI_WAKE_RTC = BIT(5),      /* Wake up by RTC */
 306 };
 307
 308 /**
 309  * wilco_ec_signed_fw
 310  *
 311  * Indicate if the EC uses signed firmware.
 312  *
 313  * Returns 1 if EC uses signed firmware, otherwise returns 0
 314  */
 315 int wilco_ec_signed_fw(void);
 316
 317 /**
 318  * wilco_ec_save_post_code
 319  *
 320  * Save this post code as the most recent progress step.  If the boot fails
 321  * and calls die_notify() this post code will be used to send an error code
 322  * to the EC indicating the failure.
 323  *
 324  * @post_code: Post code to save
 325  */
 326 void wilco_ec_save_post_code(uint8_t post_code);
 327
 328 /**
 329  * wilco_ec_set_cpuid
 330  *
 331  * Set CPU ID to EC.
 332  *
 333  * @cpuid:      read CPU ID from cpu_eax(1)
 334  * @cpu_cores:  cores of CPU
 335  * @gpu_cores:  cores of GPU
 336  *
 337  * Returns 0 if EC command was successful
 338  * Returns -1 if EC command failed
 339  */
 340 int wilco_ec_set_cpuid(uint32_t cpuid, uint8_t cpu_cores, uint8_t gpu_cores);
 341
 342 #endif /* EC_GOOGLE_WILCO_COMMANDS_H */