Whitebox
/
u-boot
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

cros_ec: Drop unused CONFIG_DM_CROS_EC

Browse Source 
Since all supported boards enable this option now, we can remove it along
with the old code.

Signed-off-by: Simon Glass <sjg@chromium.org>
master
Simon Glass 9 years ago
parent e96fc7dfc8
commit 60f37fc6aa
10 changed files with 1 additions and 506 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 3
      arch/sandbox/Kconfig
  2. 6
      board/samsung/smdk5420/Kconfig
  3. 30
      common/cros_ec.c
  4. 1
      configs/sandbox_defconfig
  5. 1
      configs/snow_defconfig
  6. 10
      drivers/misc/Kconfig
  7. 240
      drivers/misc/cros_ec.c
  8. 13
      drivers/misc/cros_ec_lpc.c
  9. 73
      drivers/misc/cros_ec_sandbox.c
  10. 130
      include/cros_ec.h

3
arch/sandbox/Kconfig
Unescape View File

@ -19,9 +19,6 @@ config DM_GPIO
config DM_SERIAL
default y
config DM_CROS_EC
default y
config DM_SPI
default y

6
board/samsung/smdk5420/Kconfig
Unescape View File

@ -22,9 +22,6 @@ config SYS_VENDOR
config SYS_CONFIG_NAME
default "peach-pi"
config DM_CROS_EC
default y
endif
if TARGET_PEACH_PIT
@ -38,9 +35,6 @@ config SYS_VENDOR
config SYS_CONFIG_NAME
default "peach-pit"
config DM_CROS_EC
default y
endif
if TARGET_SMDK5420

30
common/cros_ec.c
Unescape View File

@ -15,18 +15,8 @@
DECLARE_GLOBAL_DATA_PTR;
#ifndef CONFIG_DM_CROS_EC
struct local_info {
struct cros_ec_dev *cros_ec_dev; /* Pointer to cros_ec device */
int cros_ec_err; /* Error for cros_ec, 0 if ok */
};
static struct local_info local;
#endif
struct cros_ec_dev *board_get_cros_ec_dev(void)
{
#ifdef CONFIG_DM_CROS_EC
struct udevice *dev;
int ret;
@ -36,30 +26,15 @@ struct cros_ec_dev *board_get_cros_ec_dev(void)
return NULL;
}
return dev_get_uclass_priv(dev);
#else
return local.cros_ec_dev;
#endif
}
static int board_init_cros_ec_devices(const void *blob)
{
#ifndef CONFIG_DM_CROS_EC
local.cros_ec_err = cros_ec_init(blob, &local.cros_ec_dev);
if (local.cros_ec_err)
return -1; /* Will report in board_late_init() */
#endif
return 0;
}
int cros_ec_board_init(void)
{
return board_init_cros_ec_devices(gd->fdt_blob);
return 0;
}
int cros_ec_get_error(void)
{
#ifdef CONFIG_DM_CROS_EC
struct udevice *dev;
int ret;
@ -68,7 +43,4 @@ int cros_ec_get_error(void)
return ret;
return 0;
#else
return local.cros_ec_err;
#endif
}

1
configs/sandbox_defconfig
Unescape View File

@ -6,7 +6,6 @@ CONFIG_FIT_SIGNATURE=y
CONFIG_DM=y
CONFIG_DEFAULT_DEVICE_TREE="sandbox"
CONFIG_CROS_EC=y
CONFIG_DM_CROS_EC=y
CONFIG_CROS_EC_SANDBOX=y
CONFIG_CROS_EC_KEYB=y
CONFIG_CMD_CROS_EC=y

1
configs/snow_defconfig
Unescape View File

@ -4,7 +4,6 @@ CONFIG_ARCH_EXYNOS=y
CONFIG_TARGET_SNOW=y
CONFIG_DEFAULT_DEVICE_TREE="exynos5250-snow"
CONFIG_CROS_EC=y
CONFIG_DM_CROS_EC=y
CONFIG_CROS_EC_I2C=y
CONFIG_CROS_EC_KEYB=y
CONFIG_CMD_CROS_EC=y

10
drivers/misc/Kconfig
Unescape View File

@ -44,16 +44,6 @@ config CROS_EC_SPI
provides a faster and more robust interface than I2C but the bugs
are less interesting.
config DM_CROS_EC
bool "Enable Driver Model for Chrome OS EC"
depends on DM
help
Enable driver model for the Chrome OS EC interface. This
allows the cros_ec SPI driver to operate with CONFIG_DM_SPI
but otherwise makes few changes. Since cros_ec also supports
LPC (which doesn't support driver model yet), a full
conversion is not yet possible.
config CONFIG_FSL_SEC_MON
bool "Enable FSL SEC_MON Driver"
help

240
drivers/misc/cros_ec.c
Unescape View File

@ -41,10 +41,6 @@ enum {
CROS_EC_CMD_HASH_TIMEOUT_MS = 2000,
};
#ifndef CONFIG_DM_CROS_EC
static struct cros_ec_dev static_dev, *last_dev;
#endif
DECLARE_GLOBAL_DATA_PTR;
/* Note: depends on enum ec_current_image */
@ -211,9 +207,7 @@ static int send_command_proto3(struct cros_ec_dev *dev,
const void *dout, int dout_len,
uint8_t **dinp, int din_len)
{
#ifdef CONFIG_DM_CROS_EC
struct dm_cros_ec_ops *ops;
#endif
int out_bytes, in_bytes;
int rv;
@ -228,28 +222,8 @@ static int send_command_proto3(struct cros_ec_dev *dev,
if (in_bytes < 0)
return in_bytes;
#ifdef CONFIG_DM_CROS_EC
ops = dm_cros_ec_get_ops(dev->dev);
rv = ops->packet ? ops->packet(dev->dev, out_bytes, in_bytes) : -ENOSYS;
#else
switch (dev->interface) {
#ifdef CONFIG_CROS_EC_SPI
case CROS_EC_IF_SPI:
rv = cros_ec_spi_packet(dev, out_bytes, in_bytes);
break;
#endif
#ifdef CONFIG_CROS_EC_SANDBOX
case CROS_EC_IF_SANDBOX:
rv = cros_ec_sandbox_packet(dev, out_bytes, in_bytes);
break;
#endif
case CROS_EC_IF_NONE:
/* TODO: support protocol 3 for LPC, I2C; for now fall through */
default:
debug("%s: Unsupported interface\n", __func__);
rv = -1;
}
#endif
if (rv < 0)
return rv;
@ -261,9 +235,7 @@ static int send_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
const void *dout, int dout_len,
uint8_t **dinp, int din_len)
{
#ifdef CONFIG_DM_CROS_EC
struct dm_cros_ec_ops *ops;
#endif
int ret = -1;
/* Handle protocol version 3 support */
@ -272,38 +244,9 @@ static int send_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
dout, dout_len, dinp, din_len);
}
#ifdef CONFIG_DM_CROS_EC
ops = dm_cros_ec_get_ops(dev->dev);
ret = ops->command(dev->dev, cmd, cmd_version,
(const uint8_t *)dout, dout_len, dinp, din_len);
#else
switch (dev->interface) {
#ifdef CONFIG_CROS_EC_SPI
case CROS_EC_IF_SPI:
ret = cros_ec_spi_command(dev, cmd, cmd_version,
(const uint8_t *)dout, dout_len,
dinp, din_len);
break;
#endif
#ifdef CONFIG_CROS_EC_I2C
case CROS_EC_IF_I2C:
ret = cros_ec_i2c_command(dev, cmd, cmd_version,
(const uint8_t *)dout, dout_len,
dinp, din_len);
break;
#endif
#ifdef CONFIG_CROS_EC_LPC
case CROS_EC_IF_LPC:
ret = cros_ec_lpc_command(dev, cmd, cmd_version,
(const uint8_t *)dout, dout_len,
dinp, din_len);
break;
#endif
case CROS_EC_IF_NONE:
default:
ret = -1;
}
#endif
return ret;
}
@ -681,7 +624,6 @@ static int cros_ec_check_version(struct cros_ec_dev *dev)
struct ec_params_hello req;
struct ec_response_hello *resp;
#ifdef CONFIG_DM_CROS_EC
struct dm_cros_ec_ops *ops;
int ret;
@ -691,13 +633,6 @@ static int cros_ec_check_version(struct cros_ec_dev *dev)
if (ret)
return ret;
}
#else
#ifdef CONFIG_CROS_EC_LPC
/* LPC has its own way of doing this */
if (dev->interface == CROS_EC_IF_LPC)
return cros_ec_lpc_check_version(dev);
#endif
#endif
/*
* TODO(sjg@chromium.org).
@ -1027,76 +962,6 @@ int cros_ec_get_ldo(struct cros_ec_dev *dev, uint8_t index, uint8_t *state)
return 0;
}
#ifndef CONFIG_DM_CROS_EC
/**
* Decode EC interface details from the device tree and allocate a suitable
* device.
*
* @param blob Device tree blob
* @param node Node to decode from
* @param devp Returns a pointer to the new allocated device
* @return 0 if ok, -1 on error
*/
static int cros_ec_decode_fdt(const void *blob, int node,
struct cros_ec_dev **devp)
{
enum fdt_compat_id compat;
struct cros_ec_dev *dev;
int parent;
/* See what type of parent we are inside (this is expensive) */
parent = fdt_parent_offset(blob, node);
if (parent < 0) {
debug("%s: Cannot find node parent\n", __func__);
return -1;
}
dev = &static_dev;
dev->node = node;
dev->parent_node = parent;
compat = fdtdec_lookup(blob, parent);
switch (compat) {
#ifdef CONFIG_CROS_EC_SPI
case COMPAT_SAMSUNG_EXYNOS_SPI:
dev->interface = CROS_EC_IF_SPI;
if (cros_ec_spi_decode_fdt(dev, blob))
return -1;
break;
#endif
#ifdef CONFIG_CROS_EC_I2C
case COMPAT_SAMSUNG_S3C2440_I2C:
dev->interface = CROS_EC_IF_I2C;
if (cros_ec_i2c_decode_fdt(dev, blob))
return -1;
break;
#endif
#ifdef CONFIG_CROS_EC_LPC
case COMPAT_INTEL_LPC:
dev->interface = CROS_EC_IF_LPC;
break;
#endif
#ifdef CONFIG_CROS_EC_SANDBOX
case COMPAT_SANDBOX_HOST_EMULATION:
dev->interface = CROS_EC_IF_SANDBOX;
break;
#endif
default:
debug("%s: Unknown compat id %d\n", __func__, compat);
return -1;
}
gpio_request_by_name_nodev(blob, node, "ec-interrupt", 0, &dev->ec_int,
GPIOD_IS_IN);
dev->optimise_flash_write = fdtdec_get_bool(blob, node,
"optimise-flash-write");
*devp = dev;
return 0;
}
#endif
#ifdef CONFIG_DM_CROS_EC
int cros_ec_register(struct udevice *dev)
{
struct cros_ec_dev *cdev = dev_get_uclass_priv(dev);
@ -1125,94 +990,6 @@ int cros_ec_register(struct udevice *dev)
return 0;
}
#else
int cros_ec_init(const void *blob, struct cros_ec_dev **cros_ecp)
{
struct cros_ec_dev *dev;
char id[MSG_BYTES];
#ifdef CONFIG_DM_CROS_EC
struct udevice *udev;
int ret;
ret = uclass_find_device(UCLASS_CROS_EC, 0, &udev);
if (!ret)
device_remove(udev);
ret = uclass_get_device(UCLASS_CROS_EC, 0, &udev);
if (ret)
return ret;
dev = dev_get_uclass_priv(udev);
return 0;
#else
int node = 0;
*cros_ecp = NULL;
do {
node = fdtdec_next_compatible(blob, node,
COMPAT_GOOGLE_CROS_EC);
if (node < 0) {
debug("%s: Node not found\n", __func__);
return 0;
}
} while (!fdtdec_get_is_enabled(blob, node));
if (cros_ec_decode_fdt(blob, node, &dev)) {
debug("%s: Failed to decode device.\n", __func__);
return -CROS_EC_ERR_FDT_DECODE;
}
switch (dev->interface) {
#ifdef CONFIG_CROS_EC_SPI
case CROS_EC_IF_SPI:
if (cros_ec_spi_init(dev, blob)) {
debug("%s: Could not setup SPI interface\n", __func__);
return -CROS_EC_ERR_DEV_INIT;
}
break;
#endif
#ifdef CONFIG_CROS_EC_I2C
case CROS_EC_IF_I2C:
if (cros_ec_i2c_init(dev, blob))
return -CROS_EC_ERR_DEV_INIT;
break;
#endif
#ifdef CONFIG_CROS_EC_LPC
case CROS_EC_IF_LPC:
if (cros_ec_lpc_init(dev, blob))
return -CROS_EC_ERR_DEV_INIT;
break;
#endif
#ifdef CONFIG_CROS_EC_SANDBOX
case CROS_EC_IF_SANDBOX:
if (cros_ec_sandbox_init(dev, blob))
return -CROS_EC_ERR_DEV_INIT;
break;
#endif
case CROS_EC_IF_NONE:
default:
return 0;
}
#endif
if (cros_ec_check_version(dev)) {
debug("%s: Could not detect CROS-EC version\n", __func__);
return -CROS_EC_ERR_CHECK_VERSION;
}
if (cros_ec_read_id(dev, id, sizeof(id))) {
debug("%s: Could not read KBC ID\n", __func__);
return -CROS_EC_ERR_READ_ID;
}
/* Remember this device for use by the cros_ec command */
*cros_ecp = dev;
#ifndef CONFIG_DM_CROS_EC
last_dev = dev;
#endif
debug("Google Chrome EC CROS-EC driver ready, id '%s'\n", id);
return 0;
}
#endif
int cros_ec_decode_region(int argc, char * const argv[])
{
@ -1595,9 +1372,7 @@ static int cros_ec_i2c_passthrough(struct cros_ec_dev *dev, int flag,
static int do_cros_ec(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
struct cros_ec_dev *dev;
#ifdef CONFIG_DM_CROS_EC
struct udevice *udev;
#endif
const char *cmd;
int ret = 0;
@ -1606,15 +1381,11 @@ static int do_cros_ec(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
cmd = argv[1];
if (0 == strcmp("init", cmd)) {
#ifdef CONFIG_DM_CROS_EC
/* Remove any existing device */
ret = uclass_find_device(UCLASS_CROS_EC, 0, &udev);
if (!ret)
device_remove(udev);
ret = uclass_get_device(UCLASS_CROS_EC, 0, &udev);
#else
ret = cros_ec_init(gd->fdt_blob, &dev);
#endif
if (ret) {
printf("Could not init cros_ec device (err %d)\n", ret);
return 1;
@ -1622,21 +1393,12 @@ static int do_cros_ec(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
return 0;
}
#ifdef CONFIG_DM_CROS_EC
ret = uclass_get_device(UCLASS_CROS_EC, 0, &udev);
if (ret) {
printf("Cannot get cros-ec device (err=%d)\n", ret);
return 1;
}
dev = dev_get_uclass_priv(udev);
#else
/* Just use the last allocated device; there should be only one */
if (!last_dev) {
printf("No CROS-EC device available\n");
return 1;
}
dev = last_dev;
#endif
if (0 == strcmp("id", cmd)) {
char id[MSG_BYTES];
@ -1894,10 +1656,8 @@ U_BOOT_CMD(
);
#endif
#ifdef CONFIG_DM_CROS_EC
UCLASS_DRIVER(cros_ec) = {
.id = UCLASS_CROS_EC,
.name = "cros_ec",
.per_device_auto_alloc_size = sizeof(struct cros_ec_dev),
};
#endif

13
drivers/misc/cros_ec_lpc.c
Unescape View File

@ -41,18 +41,11 @@ static int wait_for_sync(struct cros_ec_dev *dev)
return 0;
}
#ifdef CONFIG_DM_CROS_EC
int cros_ec_lpc_command(struct udevice *udev, uint8_t cmd, int cmd_version,
const uint8_t *dout, int dout_len,
uint8_t **dinp, int din_len)
{
struct cros_ec_dev *dev = dev_get_uclass_priv(udev);
#else
int cros_ec_lpc_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
const uint8_t *dout, int dout_len,
uint8_t **dinp, int din_len)
{
#endif
const int cmd_addr = EC_LPC_ADDR_HOST_CMD;
const int data_addr = EC_LPC_ADDR_HOST_DATA;
const int args_addr = EC_LPC_ADDR_HOST_ARGS;
@ -187,11 +180,7 @@ int cros_ec_lpc_init(struct cros_ec_dev *dev, const void *blob)
* seeing whether the EC sets the EC_HOST_ARGS_FLAG_FROM_HOST flag
* in args when it responds.
*/
#ifdef CONFIG_DM_CROS_EC
static int cros_ec_lpc_check_version(struct udevice *dev)
#else
int cros_ec_lpc_check_version(struct cros_ec_dev *dev)
#endif
{
if (inb(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_ID) == 'E' &&
inb(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_ID + 1)
@ -206,7 +195,6 @@ int cros_ec_lpc_check_version(struct cros_ec_dev *dev)
return -1;
}
#ifdef CONFIG_DM_CROS_EC
static int cros_ec_probe(struct udevice *dev)
{
return cros_ec_register(dev);
@ -229,4 +217,3 @@ U_BOOT_DRIVER(cros_ec_lpc) = {
.probe = cros_ec_probe,
.ops = &cros_ec_ops,
};
#endif

73
drivers/misc/cros_ec_sandbox.c
Unescape View File

@ -467,17 +467,10 @@ static int process_cmd(struct ec_state *ec,
return len;
}
#ifdef CONFIG_DM_CROS_EC
int cros_ec_sandbox_packet(struct udevice *udev, int out_bytes, int in_bytes)
{
struct cros_ec_dev *dev = dev_get_uclass_priv(udev);
struct ec_state *ec = dev_get_priv(dev->dev);
#else
int cros_ec_sandbox_packet(struct cros_ec_dev *dev, int out_bytes,
int in_bytes)
{
struct ec_state *ec = &s_state;
#endif
struct ec_host_request *req_hdr = (struct ec_host_request *)dev->dout;
const void *req_data = req_hdr + 1;
struct ec_host_response *resp_hdr = (struct ec_host_response *)dev->din;
@ -500,18 +493,9 @@ int cros_ec_sandbox_packet(struct cros_ec_dev *dev, int out_bytes,
return in_bytes;
}
int cros_ec_sandbox_decode_fdt(struct cros_ec_dev *dev, const void *blob)
{
return 0;
}
void cros_ec_check_keyboard(struct cros_ec_dev *dev)
{
#ifdef CONFIG_DM_CROS_EC
struct ec_state *ec = dev_get_priv(dev->dev);
#else
struct ec_state *ec = &s_state;
#endif
ulong start;
printf("Press keys for EC to detect on reset (ESC=recovery)...");
@ -525,7 +509,6 @@ void cros_ec_check_keyboard(struct cros_ec_dev *dev)
}
}
#ifdef CONFIG_DM_CROS_EC
int cros_ec_probe(struct udevice *dev)
{
struct ec_state *ec = dev->priv;
@ -569,61 +552,6 @@ int cros_ec_probe(struct udevice *dev)
return cros_ec_register(dev);
}
#else
/**
* Initialize sandbox EC emulation.
*
* @param dev CROS_EC device
* @param blob Device tree blob
* @return 0 if ok, -1 on error
*/
int cros_ec_sandbox_init(struct cros_ec_dev *dev, const void *blob)
{
struct ec_state *ec = &s_state;
int node;
int err;
node = fdtdec_next_compatible(blob, 0, COMPAT_GOOGLE_CROS_EC);
if (node < 0) {
debug("Failed to find chrome-ec node'\n");
return -1;
}
err = cros_ec_decode_ec_flash(blob, node, &ec->ec_config);
if (err)
return err;
node = fdtdec_next_compatible(blob, 0, COMPAT_GOOGLE_CROS_EC_KEYB);
if (node < 0) {
debug("%s: No cros_ec keyboard found\n", __func__);
} else if (keyscan_read_fdt_matrix(ec, blob, node)) {
debug("%s: Could not read key matrix\n", __func__);
return -1;
}
/* If we loaded EC data, check that the length matches */
if (ec->flash_data &&
ec->flash_data_len != ec->ec_config.flash.length) {
printf("EC data length is %x, expected %x, discarding data\n",
ec->flash_data_len, ec->ec_config.flash.length);
os_free(ec->flash_data);
ec->flash_data = NULL;
}
/* Otherwise allocate the memory */
if (!ec->flash_data) {
ec->flash_data_len = ec->ec_config.flash.length;
ec->flash_data = os_malloc(ec->flash_data_len);
if (!ec->flash_data)
return -ENOMEM;
}
return 0;
}
#endif
#ifdef CONFIG_DM_CROS_EC
struct dm_cros_ec_ops cros_ec_ops = {
.packet = cros_ec_sandbox_packet,
};
@ -641,4 +569,3 @@ U_BOOT_DRIVER(cros_ec_sandbox) = {
.priv_auto_alloc_size = sizeof(struct ec_state),
.ops = &cros_ec_ops,
};
#endif

130
include/cros_ec.h
Unescape View File

@ -15,31 +15,9 @@
#include <cros_ec_message.h>
#include <asm/gpio.h>
#ifndef CONFIG_DM_CROS_EC
/* Which interface is the device on? */
enum cros_ec_interface_t {
CROS_EC_IF_NONE,
CROS_EC_IF_SPI,
CROS_EC_IF_I2C,
CROS_EC_IF_LPC, /* Intel Low Pin Count interface */
CROS_EC_IF_SANDBOX,
};
#endif
/* Our configuration information */
struct cros_ec_dev {
#ifdef CONFIG_DM_CROS_EC
struct udevice *dev; /* Transport device */
#else
enum cros_ec_interface_t interface;
struct spi_slave *spi; /* Our SPI slave, if using SPI */
int node; /* Our node */
int parent_node; /* Our parent node (interface) */
unsigned int cs; /* Our chip select */
unsigned int addr; /* Device address (for I2C) */
unsigned int bus_num; /* Bus number (for I2C) */
unsigned int max_frequency; /* Maximum interface frequency */
#endif
struct gpio_desc ec_int; /* GPIO used as EC interrupt line */
int protocol_version; /* Protocol version to use */
int optimise_flash_write; /* Don't write erased flash blocks */
@ -240,8 +218,6 @@ int cros_ec_flash_update_rw(struct cros_ec_dev *dev,
*/
struct cros_ec_dev *board_get_cros_ec_dev(void);
#ifdef CONFIG_DM_CROS_EC
struct dm_cros_ec_ops {
int (*check_version)(struct udevice *dev);
int (*command)(struct udevice *dev, uint8_t cmd, int cmd_version,
@ -255,112 +231,6 @@ struct dm_cros_ec_ops {
int cros_ec_register(struct udevice *dev);
#else /* !CONFIG_DM_CROS_EC */
/* Internal interfaces */
int cros_ec_i2c_init(struct cros_ec_dev *dev, const void *blob);
int cros_ec_spi_init(struct cros_ec_dev *dev, const void *blob);
int cros_ec_lpc_init(struct cros_ec_dev *dev, const void *blob);
int cros_ec_sandbox_init(struct cros_ec_dev *dev, const void *blob);
/**
* Read information from the fdt for the i2c cros_ec interface
*
* @param dev CROS-EC device
* @param blob Device tree blob
* @return 0 if ok, -1 if we failed to read all required information
*/
int cros_ec_i2c_decode_fdt(struct cros_ec_dev *dev, const void *blob);
/**
* Read information from the fdt for the spi cros_ec interface
*
* @param dev CROS-EC device
* @param blob Device tree blob
* @return 0 if ok, -1 if we failed to read all required information
*/
int cros_ec_spi_decode_fdt(struct cros_ec_dev *dev, const void *blob);
/**
* Read information from the fdt for the sandbox cros_ec interface
*
* @param dev CROS-EC device
* @param blob Device tree blob
* @return 0 if ok, -1 if we failed to read all required information
*/
int cros_ec_sandbox_decode_fdt(struct cros_ec_dev *dev, const void *blob);
/**
* Check whether the LPC interface supports new-style commands.
*
* LPC has its own way of doing this, which involves checking LPC values
* visible to the host. Do this, and update dev->protocol_version accordingly.
*
* @param dev CROS-EC device to check
*/
int cros_ec_lpc_check_version(struct cros_ec_dev *dev);
/**
* Send a command to an I2C CROS-EC device and return the reply.
*
* This rather complicated function deals with sending both old-style and
* new-style commands. The old ones have just a command byte and arguments.
* The new ones have version, command, arg-len, [args], chksum so are 3 bytes
* longer.
*
* The device's internal input/output buffers are used.
*
* @param dev CROS-EC device
* @param cmd Command to send (EC_CMD_...)
* @param cmd_version Version of command to send (EC_VER_...)
* @param dout Output data (may be NULL If dout_len=0)
* @param dout_len Size of output data in bytes
* @param dinp Returns pointer to response data
* @param din_len Maximum size of response in bytes
* @return number of bytes in response, or -1 on error
*/
int cros_ec_i2c_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
const uint8_t *dout, int dout_len,
uint8_t **dinp, int din_len);
/**
* Send a command to a LPC CROS-EC device and return the reply.
*
* The device's internal input/output buffers are used.
*
* @param dev CROS-EC device
* @param cmd Command to send (EC_CMD_...)
* @param cmd_version Version of command to send (EC_VER_...)
* @param dout Output data (may be NULL If dout_len=0)
* @param dout_len Size of output data in bytes
* @param dinp Returns pointer to response data
* @param din_len Maximum size of response in bytes
* @return number of bytes in response, or -1 on error
*/
int cros_ec_lpc_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
const uint8_t *dout, int dout_len,
uint8_t **dinp, int din_len);
int cros_ec_spi_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
const uint8_t *dout, int dout_len,
uint8_t **dinp, int din_len);
/**
* Send a packet to a CROS-EC device and return the response packet.
*
* Expects the request packet to be stored in dev->dout. Stores the response
* packet in dev->din.
*
* @param dev CROS-EC device
* @param out_bytes Size of request packet to output
* @param in_bytes Maximum size of response packet to receive
* @return number of bytes in response packet, or <0 on error
*/
int cros_ec_spi_packet(struct cros_ec_dev *dev, int out_bytes, int in_bytes);
int cros_ec_sandbox_packet(struct cros_ec_dev *dev, int out_bytes,
int in_bytes);
#endif
/**
* Dump a block of data for a command.
*

Write Preview
Loading…
Cancel
Save