Blame view
drivers/misc/cros_ec_i2c.c
6.13 KB
83d290c56
|
1 |
// SPDX-License-Identifier: GPL-2.0+ |
78764a4e1
|
2 3 4 5 |
/* * Chromium OS cros_ec driver - I2C interface * * Copyright (c) 2012 The Chromium OS Authors. |
78764a4e1
|
6 7 8 9 10 11 12 13 14 15 |
*/ /* * 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> |
85df958ce
|
16 |
#include <dm.h> |
78764a4e1
|
17 18 19 20 21 22 23 24 |
#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 |
147f785f6
|
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 |
/** * 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 ", __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 ", __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; } |
85df958ce
|
109 110 111 |
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) |
78764a4e1
|
112 |
{ |
e564f054a
|
113 |
struct cros_ec_dev *dev = dev_get_uclass_priv(udev); |
e9b25f2ea
|
114 115 |
struct dm_i2c_chip *chip = dev_get_parent_platdata(udev); struct i2c_msg i2c_msg[2]; |
78764a4e1
|
116 117 118 119 120 121 122 |
/* 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; |
e8c126623
|
123 |
int len, csum, ret; |
78764a4e1
|
124 |
|
78764a4e1
|
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 |
/* * Sanity-check I/O sizes given transaction overhead in internal * buffers. */ if (out_bytes > sizeof(dev->dout)) { debug("%s: Cannot send %d bytes ", __func__, dout_len); return -1; } if (in_bytes > sizeof(dev->din)) { debug("%s: Cannot receive %d bytes ", __func__, din_len); return -1; } assert(dout_len >= 0); assert(dinp); |
e9b25f2ea
|
141 142 143 144 |
i2c_msg[0].addr = chip->chip_addr; i2c_msg[0].len = out_bytes; i2c_msg[0].buf = dev->dout; i2c_msg[0].flags = 0; |
78764a4e1
|
145 146 147 148 149 150 151 152 153 154 155 156 157 |
/* * 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); |
e8c126623
|
158 159 160 161 162 163 164 |
if (dev->protocol_version != 2) { /* Something we don't support */ debug("%s: Protocol version %d unsupported ", __func__, dev->protocol_version); return -1; |
78764a4e1
|
165 |
} |
e8c126623
|
166 167 168 169 170 |
*ptr++ = EC_CMD_VERSION0 + cmd_version; *ptr++ = cmd; *ptr++ = dout_len; in_ptr -= 2; /* Expect status, length bytes */ |
78764a4e1
|
171 172 |
memcpy(ptr, dout, dout_len); ptr += dout_len; |
e8c126623
|
173 174 |
*ptr++ = (uint8_t) cros_ec_calc_checksum(dev->dout, dout_len + 3); |
78764a4e1
|
175 |
|
e9b25f2ea
|
176 177 178 179 |
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; |
78764a4e1
|
180 181 |
/* Send output data */ cros_ec_dump_data("out", -1, dev->dout, out_bytes); |
e9b25f2ea
|
182 183 |
ret = dm_i2c_xfer(udev, &i2c_msg[0], 2); |
78764a4e1
|
184 |
if (ret) { |
e9b25f2ea
|
185 186 |
debug("%s: Could not execute transfer to %s ", __func__, |
85df958ce
|
187 |
udev->name); |
78764a4e1
|
188 189 |
ret = -1; } |
78764a4e1
|
190 191 192 193 194 |
if (*in_ptr != EC_RES_SUCCESS) { debug("%s: Received bad result code %d ", __func__, *in_ptr); return -(int)*in_ptr; } |
e8c126623
|
195 196 197 198 199 200 |
len = in_ptr[1]; if (len + 3 > sizeof(dev->din)) { debug("%s: Received length %#02x too large ", __func__, len); return -1; |
78764a4e1
|
201 |
} |
e8c126623
|
202 203 204 205 206 207 208 209 210 |
csum = cros_ec_calc_checksum(in_ptr, 2 + len); if (csum != in_ptr[2 + len]) { debug("%s: Invalid checksum rx %#02x, calced %#02x ", __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); |
78764a4e1
|
211 212 213 214 215 216 |
/* Return pointer to dword-aligned input data, if any */ *dinp = dev->din + sizeof(int64_t); return din_len; } |
85df958ce
|
217 |
static int cros_ec_probe(struct udevice *dev) |
78764a4e1
|
218 |
{ |
85df958ce
|
219 |
return cros_ec_register(dev); |
78764a4e1
|
220 |
} |
85df958ce
|
221 222 |
static struct dm_cros_ec_ops cros_ec_ops = { .command = cros_ec_i2c_command, |
147f785f6
|
223 |
.packet = cros_ec_i2c_packet, |
85df958ce
|
224 225 226 |
}; static const struct udevice_id cros_ec_ids[] = { |
3fbb78711
|
227 |
{ .compatible = "google,cros-ec-i2c" }, |
85df958ce
|
228 229 230 231 |
{ } }; U_BOOT_DRIVER(cros_ec_i2c) = { |
3fbb78711
|
232 |
.name = "cros_ec_i2c", |
85df958ce
|
233 234 235 236 237 |
.id = UCLASS_CROS_EC, .of_match = cros_ec_ids, .probe = cros_ec_probe, .ops = &cros_ec_ops, }; |