1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
/*
* This file is part of the coreboot project.
*
* Copyright (C) 2012 The Chromium OS Authors. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* Mailbox EC communication interface for Google Chrome Embedded Controller.
*/
#ifndef _EC_GOOGLE_CHROMEEC_EC_H
#define _EC_GOOGLE_CHROMEEC_EC_H
#include <stddef.h>
#include <stdint.h>
#include "ec_commands.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);
u8 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);
void google_chromeec_init(void);
int google_chromeec_pd_get_amode(uint16_t svid);
int google_chromeec_wait_for_displayport(long timeout);
/* 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);
u32 google_chromeec_get_sku_id(void);
int google_chromeec_set_sku_id(u32 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(u8 postcode);
int google_chromeec_vbnv_context(int is_read, uint8_t *data, int len);
uint8_t google_chromeec_get_switches(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 OEM (or SKU) ID from Cros Board Info
*
* @param id [OUT] oem/sku id
* @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_dram_part_num(char *buf, size_t bufsize);
int google_chromeec_cbi_get_oem_name(char *buf, size_t bufsize);
/* 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(u8 port_id, enum usb_charge_mode mode);
int google_chromeec_set_usb_pd_role(u8 port, enum usb_pd_control_role role);
/*
* Retrieve the charger type and max wattage.
*
* @param type charger type
* @param max_watts charger max wattage
* @return non-zero for error, otherwise 0.
*/
int google_chromeec_get_usb_pd_power_info(enum usb_chg_type *type,
u32 *max_watts);
/*
* 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(u16 current_lim,
u16 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);
/**
* 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);
#endif /* _EC_GOOGLE_CHROMEEC_EC_H */
|
