GK SDK 源码库: XMIPCLinuxV100R005C00SPC030 (kernel/tools/open_source excluded)
This commit is contained in:
@@ -0,0 +1,239 @@
|
||||
// SPDX-License-Identifier: GPL-2.0+
|
||||
/*
|
||||
* Chromium OS cros_ec driver - I2C interface
|
||||
*
|
||||
* Copyright (c) 2012 The Chromium OS Authors.
|
||||
*/
|
||||
|
||||
/*
|
||||
* The Matrix Keyboard Protocol driver handles talking to the keyboard
|
||||
* controller chip. Mostly this is for keyboard functions, but some other
|
||||
* things have slipped in, so we provide generic services to talk to the
|
||||
* KBC.
|
||||
*/
|
||||
|
||||
#include <common.h>
|
||||
#include <dm.h>
|
||||
#include <i2c.h>
|
||||
#include <cros_ec.h>
|
||||
|
||||
#ifdef DEBUG_TRACE
|
||||
#define debug_trace(fmt, b...) debug(fmt, #b)
|
||||
#else
|
||||
#define debug_trace(fmt, b...)
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Request format for protocol v3
|
||||
* byte 0 0xda (EC_COMMAND_PROTOCOL_3)
|
||||
* byte 1-8 struct ec_host_request
|
||||
* byte 10- response data
|
||||
*/
|
||||
struct ec_host_request_i2c {
|
||||
/* Always 0xda to backward compatible with v2 struct */
|
||||
uint8_t command_protocol;
|
||||
struct ec_host_request ec_request;
|
||||
} __packed;
|
||||
|
||||
/*
|
||||
* Response format for protocol v3
|
||||
* byte 0 result code
|
||||
* byte 1 packet_length
|
||||
* byte 2-9 struct ec_host_response
|
||||
* byte 10- response data
|
||||
*/
|
||||
struct ec_host_response_i2c {
|
||||
uint8_t result;
|
||||
uint8_t packet_length;
|
||||
struct ec_host_response ec_response;
|
||||
} __packed;
|
||||
|
||||
static int cros_ec_i2c_packet(struct udevice *udev, int out_bytes, int in_bytes)
|
||||
{
|
||||
struct cros_ec_dev *dev = dev_get_uclass_priv(udev);
|
||||
struct dm_i2c_chip *chip = dev_get_parent_platdata(udev);
|
||||
struct ec_host_request_i2c *ec_request_i2c =
|
||||
(struct ec_host_request_i2c *)dev->dout;
|
||||
struct ec_host_response_i2c *ec_response_i2c =
|
||||
(struct ec_host_response_i2c *)dev->din;
|
||||
struct i2c_msg i2c_msg[2];
|
||||
int ret;
|
||||
|
||||
i2c_msg[0].addr = chip->chip_addr;
|
||||
i2c_msg[0].flags = 0;
|
||||
i2c_msg[1].addr = chip->chip_addr;
|
||||
i2c_msg[1].flags = I2C_M_RD;
|
||||
|
||||
/* one extra byte, to indicate v3 */
|
||||
i2c_msg[0].len = out_bytes + 1;
|
||||
i2c_msg[0].buf = dev->dout;
|
||||
|
||||
/* stitch on EC_COMMAND_PROTOCOL_3 */
|
||||
memmove(&ec_request_i2c->ec_request, dev->dout, out_bytes);
|
||||
ec_request_i2c->command_protocol = EC_COMMAND_PROTOCOL_3;
|
||||
|
||||
/* two extra bytes for v3 */
|
||||
i2c_msg[1].len = in_bytes + 2;
|
||||
i2c_msg[1].buf = dev->din;
|
||||
|
||||
ret = dm_i2c_xfer(udev, &i2c_msg[0], 2);
|
||||
if (ret) {
|
||||
printf("%s: Could not execute transfer: %d\n", __func__, ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* When we send a v3 request to v2 ec, ec won't recognize the 0xda
|
||||
* (EC_COMMAND_PROTOCOL_3) and will return with status
|
||||
* EC_RES_INVALID_COMMAND with zero data length
|
||||
*
|
||||
* In case of invalid command for v3 protocol the data length
|
||||
* will be at least sizeof(struct ec_host_response)
|
||||
*/
|
||||
if (ec_response_i2c->result == EC_RES_INVALID_COMMAND &&
|
||||
ec_response_i2c->packet_length == 0)
|
||||
return -EPROTONOSUPPORT;
|
||||
|
||||
if (ec_response_i2c->packet_length < sizeof(struct ec_host_response)) {
|
||||
printf("%s: response of %u bytes too short; not a full hdr\n",
|
||||
__func__, ec_response_i2c->packet_length);
|
||||
return -EBADMSG;
|
||||
}
|
||||
|
||||
|
||||
/* drop result and packet_len */
|
||||
memmove(dev->din, &ec_response_i2c->ec_response, in_bytes);
|
||||
|
||||
return in_bytes;
|
||||
}
|
||||
|
||||
static int cros_ec_i2c_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);
|
||||
struct dm_i2c_chip *chip = dev_get_parent_platdata(udev);
|
||||
struct i2c_msg i2c_msg[2];
|
||||
/* version8, cmd8, arglen8, out8[dout_len], csum8 */
|
||||
int out_bytes = dout_len + 4;
|
||||
/* response8, arglen8, in8[din_len], checksum8 */
|
||||
int in_bytes = din_len + 3;
|
||||
uint8_t *ptr;
|
||||
/* Receive input data, so that args will be dword aligned */
|
||||
uint8_t *in_ptr;
|
||||
int len, csum, ret;
|
||||
|
||||
/*
|
||||
* Sanity-check I/O sizes given transaction overhead in internal
|
||||
* buffers.
|
||||
*/
|
||||
if (out_bytes > sizeof(dev->dout)) {
|
||||
debug("%s: Cannot send %d bytes\n", __func__, dout_len);
|
||||
return -1;
|
||||
}
|
||||
if (in_bytes > sizeof(dev->din)) {
|
||||
debug("%s: Cannot receive %d bytes\n", __func__, din_len);
|
||||
return -1;
|
||||
}
|
||||
assert(dout_len >= 0);
|
||||
assert(dinp);
|
||||
|
||||
i2c_msg[0].addr = chip->chip_addr;
|
||||
i2c_msg[0].len = out_bytes;
|
||||
i2c_msg[0].buf = dev->dout;
|
||||
i2c_msg[0].flags = 0;
|
||||
|
||||
/*
|
||||
* Copy command and data into output buffer so we can do a single I2C
|
||||
* burst transaction.
|
||||
*/
|
||||
ptr = dev->dout;
|
||||
|
||||
/*
|
||||
* in_ptr starts of pointing to a dword-aligned input data buffer.
|
||||
* We decrement it back by the number of header bytes we expect to
|
||||
* receive, so that the first parameter of the resulting input data
|
||||
* will be dword aligned.
|
||||
*/
|
||||
in_ptr = dev->din + sizeof(int64_t);
|
||||
|
||||
if (dev->protocol_version != 2) {
|
||||
/* Something we don't support */
|
||||
debug("%s: Protocol version %d unsupported\n",
|
||||
__func__, dev->protocol_version);
|
||||
return -1;
|
||||
}
|
||||
|
||||
*ptr++ = EC_CMD_VERSION0 + cmd_version;
|
||||
*ptr++ = cmd;
|
||||
*ptr++ = dout_len;
|
||||
in_ptr -= 2; /* Expect status, length bytes */
|
||||
|
||||
memcpy(ptr, dout, dout_len);
|
||||
ptr += dout_len;
|
||||
|
||||
*ptr++ = (uint8_t)
|
||||
cros_ec_calc_checksum(dev->dout, dout_len + 3);
|
||||
|
||||
i2c_msg[1].addr = chip->chip_addr;
|
||||
i2c_msg[1].len = in_bytes;
|
||||
i2c_msg[1].buf = in_ptr;
|
||||
i2c_msg[1].flags = I2C_M_RD;
|
||||
|
||||
/* Send output data */
|
||||
cros_ec_dump_data("out", -1, dev->dout, out_bytes);
|
||||
|
||||
ret = dm_i2c_xfer(udev, &i2c_msg[0], 2);
|
||||
if (ret) {
|
||||
debug("%s: Could not execute transfer to %s\n", __func__,
|
||||
udev->name);
|
||||
ret = -1;
|
||||
}
|
||||
|
||||
if (*in_ptr != EC_RES_SUCCESS) {
|
||||
debug("%s: Received bad result code %d\n", __func__, *in_ptr);
|
||||
return -(int)*in_ptr;
|
||||
}
|
||||
|
||||
len = in_ptr[1];
|
||||
if (len + 3 > sizeof(dev->din)) {
|
||||
debug("%s: Received length %#02x too large\n",
|
||||
__func__, len);
|
||||
return -1;
|
||||
}
|
||||
csum = cros_ec_calc_checksum(in_ptr, 2 + len);
|
||||
if (csum != in_ptr[2 + len]) {
|
||||
debug("%s: Invalid checksum rx %#02x, calced %#02x\n",
|
||||
__func__, in_ptr[2 + din_len], csum);
|
||||
return -1;
|
||||
}
|
||||
din_len = min(din_len, len);
|
||||
cros_ec_dump_data("in", -1, in_ptr, din_len + 3);
|
||||
|
||||
/* Return pointer to dword-aligned input data, if any */
|
||||
*dinp = dev->din + sizeof(int64_t);
|
||||
|
||||
return din_len;
|
||||
}
|
||||
|
||||
static int cros_ec_probe(struct udevice *dev)
|
||||
{
|
||||
return cros_ec_register(dev);
|
||||
}
|
||||
|
||||
static struct dm_cros_ec_ops cros_ec_ops = {
|
||||
.command = cros_ec_i2c_command,
|
||||
.packet = cros_ec_i2c_packet,
|
||||
};
|
||||
|
||||
static const struct udevice_id cros_ec_ids[] = {
|
||||
{ .compatible = "google,cros-ec-i2c" },
|
||||
{ }
|
||||
};
|
||||
|
||||
U_BOOT_DRIVER(cros_ec_i2c) = {
|
||||
.name = "cros_ec_i2c",
|
||||
.id = UCLASS_CROS_EC,
|
||||
.of_match = cros_ec_ids,
|
||||
.probe = cros_ec_probe,
|
||||
.ops = &cros_ec_ops,
|
||||
};
|
||||
Reference in New Issue
Block a user