blob: 0fa0cf8d6d7d2778fe9932c8b3fc9c726de4cdc0 [file] [log] [blame]
/*
* This file is part of the coreboot project.
*
* Copyright (C) 2013 Google Inc. 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.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <arch/io.h>
#include <console/console.h>
#include <delay.h>
#include <device/pnp.h>
#include <pc80/keyboard.h>
#include <stdint.h>
#include <stdlib.h>
#include "chip.h"
#include "ec.h"
#include "ec_commands.h"
/*
* Read bytes from a given LPC-mapped address.
*
* @port: Base read address
* @length: Number of bytes to read
* @dest: Destination buffer
* @csum: Optional parameter, sums data read
*/
static void read_bytes(u16 port, unsigned int length, u8 *dest, u8 *csum)
{
int i;
for (i = 0; i < length; ++i) {
dest[i] = inb(port + i);
if (csum)
*csum += dest[i];
}
}
/* Read single byte and return byte read */
static inline u8 read_byte(u16 port)
{
u8 byte;
read_bytes(port, 1, &byte, NULL);
return byte;
}
/*
* Write bytes to a given LPC-mapped address.
*
* @port: Base write address
* @length: Number of bytes to write
* @msg: Write data buffer
* @csum: Optional parameter, sums data written
*/
static void write_bytes(u16 port, unsigned int length, u8 *msg, u8 *csum)
{
int i;
for (i = 0; i < length; ++i) {
outb(msg[i], port + i);
if (csum)
*csum += msg[i];
}
}
/* Write single byte and return byte written */
static inline u8 write_byte(u8 val, u16 port)
{
u8 byte = val;
write_bytes(port, 1, &byte, NULL);
return byte;
}
static int google_chromeec_wait_ready(u16 port)
{
u8 ec_status = read_byte(port);
u32 time_count = 0;
/*
* One second is more than plenty for any EC operation to complete
* (and the bus accessing/code execution) overhead will make the
* timeout even longer.
*/
#define MAX_EC_TIMEOUT_US 1000000
while (ec_status &
(EC_LPC_CMDR_PENDING | EC_LPC_CMDR_BUSY)) {
udelay(1);
if (time_count++ == MAX_EC_TIMEOUT_US)
return -1;
ec_status = read_byte(port);
}
return 0;
}
#if CONFIG_EC_GOOGLE_CHROMEEC_ACPI_MEMMAP
/* 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;
}
#endif
static int google_chromeec_command_version(void)
{
u8 id1, id2, flags;
#if CONFIG_EC_GOOGLE_CHROMEEC_ACPI_MEMMAP
if (read_memmap(&id1, EC_MEMMAP_ID) ||
read_memmap(&id2, EC_MEMMAP_ID + 1) ||
read_memmap(&flags, EC_MEMMAP_HOST_CMD_FLAGS)) {
printk(BIOS_ERR, "Error reading memmap data.\n");
return -1;
}
#else
id1 = read_byte(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_ID);
id2 = read_byte(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_ID + 1);
flags = read_byte(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_HOST_CMD_FLAGS);
#endif
if (id1 != 'E' || id2 != 'C') {
printk(BIOS_ERR, "Missing Chromium EC memory map.\n");
return -1;
}
if (flags & EC_HOST_CMD_FLAG_VERSION_3) {
return EC_HOST_CMD_FLAG_VERSION_3;
} else if (flags & EC_HOST_CMD_FLAG_LPC_ARGS_SUPPORTED) {
return EC_HOST_CMD_FLAG_LPC_ARGS_SUPPORTED;
} else {
printk(BIOS_ERR,
"Chromium EC command version unsupported\n");
return -1;
}
}
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;
}
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;
}
#ifdef __PRE_RAM__
int google_chromeec_command(struct chromeec_command *cec_command)
{
switch (google_chromeec_command_version()) {
case EC_HOST_CMD_FLAG_VERSION_3:
return google_chromeec_command_v3(cec_command);
case EC_HOST_CMD_FLAG_LPC_ARGS_SUPPORTED:
return google_chromeec_command_v1(cec_command);
}
return -1;
}
#else /* !__PRE_RAM__ */
int google_chromeec_command(struct chromeec_command *cec_command)
{
static int command_version = 0;
if (command_version <= 0)
command_version = google_chromeec_command_version();
switch (command_version) {
case EC_HOST_CMD_FLAG_VERSION_3:
return google_chromeec_command_v3(cec_command);
case EC_HOST_CMD_FLAG_LPC_ARGS_SUPPORTED:
return google_chromeec_command_v1(cec_command);
}
return -1;
}
#ifndef __SMM__
static void lpc_ec_init(struct device *dev)
{
if (!dev->enabled)
return;
pc_keyboard_init();
google_chromeec_init();
}
static void lpc_ec_read_resources(struct device *dev)
{
/* Nothing, but this function avoids an error on serial console. */
}
static void lpc_ec_enable_resources(struct device *dev)
{
/* Nothing, but this function avoids an error on serial console. */
}
static struct device_operations ops = {
.init = lpc_ec_init,
.read_resources = lpc_ec_read_resources,
.enable_resources = lpc_ec_enable_resources
};
static struct pnp_info pnp_dev_info[] = {
{ &ops, 0, 0, { 0, 0 }, }
};
static void enable_dev(struct device *dev)
{
pnp_enable_devices(dev, &pnp_ops, ARRAY_SIZE(pnp_dev_info),
pnp_dev_info);
}
struct chip_operations ec_google_chromeec_ops = {
CHIP_NAME("Google Chrome EC")
.enable_dev = enable_dev,
};
#endif /* __SMM__ */
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 */
write_byte(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 read_byte(EC_LPC_ADDR_ACPI_DATA);
}
#endif