mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-26 03:48:58 +09:00
![Tom Rini](/assets/img/avatar_default.png)
When U-Boot started using SPDX tags we were among the early adopters and there weren't a lot of other examples to borrow from. So we picked the area of the file that usually had a full license text and replaced it with an appropriate SPDX-License-Identifier: entry. Since then, the Linux Kernel has adopted SPDX tags and they place it as the very first line in a file (except where shebangs are used, then it's second line) and with slightly different comment styles than us. In part due to community overlap, in part due to better tag visibility and in part for other minor reasons, switch over to that style. This commit changes all instances where we have a single declared license in the tag as both the before and after are identical in tag contents. There's also a few places where I found we did not have a tag and have introduced one. Signed-off-by: Tom Rini <trini@konsulko.com>
240 lines
6.1 KiB
C
240 lines
6.1 KiB
C
// 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,
|
|
};
|