/* Read memmap data through ACPI port 66/62 */
static int read_memmap(u8 *data, u8 offset)
{
if (google_chromeec_wait_ready(EC_LPC_ADDR_ACPI_CMD)) {
printk(BIOS_ERR, "Timeout waiting for EC ready!\n");
return -1;
}
/* Issue the ACPI read command */
write_byte(EC_CMD_ACPI_READ, EC_LPC_ADDR_ACPI_CMD);
if (google_chromeec_wait_ready(EC_LPC_ADDR_ACPI_CMD)) {
printk(BIOS_ERR, "Timeout waiting for EC READ_EVENT!\n");
return -1;
}
/* Write data address */
write_byte(offset + EC_ACPI_MEM_MAPPED_BEGIN, EC_LPC_ADDR_ACPI_DATA);
if (google_chromeec_wait_ready(EC_LPC_ADDR_ACPI_CMD)) {
printk(BIOS_ERR, "Timeout waiting for EC DATA!\n");
return -1;
}
*data = read_byte(EC_LPC_ADDR_ACPI_DATA);
return 0;
}
u8 google_chromeec_get_event(void)
{
if (google_chromeec_wait_ready(EC_LPC_ADDR_ACPI_CMD)) {
printk(BIOS_ERR, "Timeout waiting for EC ready!\n");
return 1;
}
/* Issue the ACPI query-event command */
outb(EC_CMD_ACPI_QUERY_EVENT, EC_LPC_ADDR_ACPI_CMD);
if (google_chromeec_wait_ready(EC_LPC_ADDR_ACPI_CMD)) {
printk(BIOS_ERR, "Timeout waiting for EC QUERY_EVENT!\n");
return 0;
}
/* Event (or 0 if none) is returned directly in the data byte */
return inb(EC_LPC_ADDR_ACPI_DATA);
}
int google_chromeec_command(struct chromeec_command *cec_command)
{
struct ec_lpc_host_args args;
const u8 *d;
u8 *dout;
u8 cmd_code = cec_command->cmd_code;
int csum;
int i;
/* Fill in args */
args.flags = EC_HOST_ARGS_FLAG_FROM_HOST;
args.command_version = cec_command->cmd_version;
args.data_size = cec_command->cmd_size_in;
/* Initialize checksum */
csum = cmd_code + args.flags + args.command_version + args.data_size;
/* Write data and update checksum */
for (i = 0, d = (const u8 *)cec_command->cmd_data_in;
i < cec_command->cmd_size_in; i++, d++) {
outb(*d, EC_LPC_ADDR_HOST_PARAM + i);
csum += *d;
}
/* Finalize checksum and write args */
args.checksum = (u8)csum;
for (i = 0, d = (const u8 *)&args; i < sizeof(args); i++, d++)
outb(*d, EC_LPC_ADDR_HOST_ARGS + i);
/* Issue the command */
outb(cmd_code, EC_LPC_ADDR_HOST_CMD);
if (google_chromeec_wait_ready(EC_LPC_ADDR_HOST_CMD)) {
printk(BIOS_ERR, "Timeout waiting for EC process command %d!\n",
cec_command->cmd_code);
return 1;
}
/* Check result */
cec_command->cmd_code = inb(EC_LPC_ADDR_HOST_DATA);
if (cec_command->cmd_code)
return 1;
/* Read back args */
for (i = 0, dout = (u8 *)&args; i < sizeof(args); i++, dout++)
*dout = inb(EC_LPC_ADDR_HOST_ARGS + i);
/*
* If EC didn't modify args flags, then somehow we sent a new-style
* command to an old EC, which means it would have read its params
* from the wrong place.
*/
if (!(args.flags & EC_HOST_ARGS_FLAG_TO_HOST)) {
printk(BIOS_ERR, "EC protocol mismatch\n");
return 1;
}
if (args.data_size > cec_command->cmd_size_out) {
printk(BIOS_ERR, "EC returned too much data\n");
return 1;
}
cec_command->cmd_size_out = args.data_size;
/* Start calculating response checksum */
csum = cmd_code + args.flags + args.command_version + args.data_size;
/* Read data, if any */
for (i = 0, dout = (u8 *)cec_command->cmd_data_out;
i < args.data_size; i++, dout++) {
*dout = inb(EC_LPC_ADDR_HOST_PARAM + i);
csum += *dout;
}
/* Verify checksum */
if (args.checksum != (u8)csum) {
printk(BIOS_ERR, "EC response has invalid checksum\n");
return 1;
}
return 0;
}
static int google_chromeec_command_v1(struct chromeec_command *cec_command)
{
struct ec_lpc_host_args args;
u8 cmd_code = cec_command->cmd_code;
u8 csum;
/* Fill in args */
args.flags = EC_HOST_ARGS_FLAG_FROM_HOST;
args.command_version = cec_command->cmd_version;
args.data_size = cec_command->cmd_size_in;
/* Initialize checksum */
csum = cmd_code + args.flags + args.command_version + args.data_size;
write_bytes(EC_LPC_ADDR_HOST_PARAM,
cec_command->cmd_size_in,
(u8*)cec_command->cmd_data_in,
&csum);
/* Finalize checksum and write args */
args.checksum = csum;
write_bytes(EC_LPC_ADDR_HOST_ARGS, sizeof(args), (u8*)&args, NULL);
/* Issue the command */
write_byte(cmd_code, EC_LPC_ADDR_HOST_CMD);
if (google_chromeec_wait_ready(EC_LPC_ADDR_HOST_CMD)) {
printk(BIOS_ERR, "Timeout waiting for EC process command %d!\n",
cec_command->cmd_code);
return 1;
}
/* Check result */
cec_command->cmd_code = read_byte(EC_LPC_ADDR_HOST_DATA);
if (cec_command->cmd_code)
return 1;
/* Read back args */
read_bytes(EC_LPC_ADDR_HOST_ARGS, sizeof(args), (u8*)&args, NULL);
/*
* If EC didn't modify args flags, then somehow we sent a new-style
* command to an old EC, which means it would have read its params
* from the wrong place.
*/
if (!(args.flags & EC_HOST_ARGS_FLAG_TO_HOST)) {
printk(BIOS_ERR, "EC protocol mismatch\n");
return 1;
}
if (args.data_size > cec_command->cmd_size_out) {
printk(BIOS_ERR, "EC returned too much data\n");
return 1;
}
cec_command->cmd_size_out = args.data_size;
/* Start calculating response checksum */
csum = cmd_code + args.flags + args.command_version + args.data_size;
/* Read data, if any */
read_bytes(EC_LPC_ADDR_HOST_PARAM,
args.data_size,
cec_command->cmd_data_out,
&csum);
/* Verify checksum */
if (args.checksum != csum) {
printk(BIOS_ERR, "EC response has invalid checksum\n");
return 1;
}
return 0;
}
static int google_chromeec_command_v3(struct chromeec_command *cec_command)
{
struct ec_host_request rq;
struct ec_host_response rs;
const u8 *d;
u8 csum = 0;
int i;
if (cec_command->cmd_size_in + sizeof(rq) > EC_LPC_HOST_PACKET_SIZE) {
printk(BIOS_ERR, "EC cannot send %zu bytes\n",
cec_command->cmd_size_in + sizeof(rq));
return -1;
}
if (cec_command->cmd_size_out > EC_LPC_HOST_PACKET_SIZE) {
printk(BIOS_ERR, "EC cannot receive %d bytes\n",
cec_command->cmd_size_out);
return -1;
}
if (google_chromeec_wait_ready(EC_LPC_ADDR_HOST_CMD)) {
printk(BIOS_ERR, "Timeout waiting for EC start command %d!\n",
cec_command->cmd_code);
return -1;
}
/* Fill in request packet */
rq.struct_version = EC_HOST_REQUEST_VERSION;
rq.checksum = 0;
rq.command = cec_command->cmd_code |
EC_CMD_PASSTHRU_OFFSET(cec_command->cmd_dev_index);
rq.command_version = cec_command->cmd_version;
rq.reserved = 0;
rq.data_len = cec_command->cmd_size_in;
/* Copy data and start checksum */
write_bytes(EC_LPC_ADDR_HOST_PACKET + sizeof(rq),
cec_command->cmd_size_in,
(u8*)cec_command->cmd_data_in,
&csum);
/* Finish checksum */
for (i = 0, d = (const u8 *)&rq; i < sizeof(rq); i++, d++)
csum += *d;
/* Write checksum field so the entire packet sums to 0 */
rq.checksum = -csum;
/* Copy header */
write_bytes(EC_LPC_ADDR_HOST_PACKET, sizeof(rq), (u8*)&rq, NULL);
/* Start the command */
write_byte(EC_COMMAND_PROTOCOL_3, EC_LPC_ADDR_HOST_CMD);
if (google_chromeec_wait_ready(EC_LPC_ADDR_HOST_CMD)) {
printk(BIOS_ERR, "Timeout waiting for EC process command %d!\n",
cec_command->cmd_code);
return -1;
}
/* Check result */
cec_command->cmd_code = read_byte(EC_LPC_ADDR_HOST_DATA);
if (cec_command->cmd_code) {
printk(BIOS_ERR, "EC returned error result code %d\n",
cec_command->cmd_code);
return -i;
}
/* Read back response header and start checksum */
csum = 0;
read_bytes(EC_LPC_ADDR_HOST_PACKET, sizeof(rs), (u8*)&rs, &csum);
if (rs.struct_version != EC_HOST_RESPONSE_VERSION) {
printk(BIOS_ERR, "EC response version mismatch (%d != %d)\n",
rs.struct_version, EC_HOST_RESPONSE_VERSION);
return -1;
}
if (rs.reserved) {
printk(BIOS_ERR, "EC response reserved is %d, should be 0\n",
rs.reserved);
return -1;
}
if (rs.data_len > cec_command->cmd_size_out) {
printk(BIOS_ERR, "EC returned too much data (%d > %d)\n",
rs.data_len, cec_command->cmd_size_out);
return -1;
}
/* Read back data and update checksum */
read_bytes(EC_LPC_ADDR_HOST_PACKET + sizeof(rs),
rs.data_len,
cec_command->cmd_data_out,
&csum);
/* Verify checksum */
if (csum) {
printk(BIOS_ERR, "EC response has invalid checksum\n");
return -1;
}
return 0;
}
