Tom Rini | 10e4779 | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 2 | /* |
| 3 | * Chromium OS cros_ec driver - I2C interface |
| 4 | * |
| 5 | * Copyright (c) 2012 The Chromium OS Authors. |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 6 | */ |
| 7 | |
| 8 | /* |
| 9 | * The Matrix Keyboard Protocol driver handles talking to the keyboard |
| 10 | * controller chip. Mostly this is for keyboard functions, but some other |
| 11 | * things have slipped in, so we provide generic services to talk to the |
| 12 | * KBC. |
| 13 | */ |
| 14 | |
| 15 | #include <common.h> |
Simon Glass | a1f2603 | 2015-01-26 20:29:40 -0700 | [diff] [blame] | 16 | #include <dm.h> |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 17 | #include <i2c.h> |
| 18 | #include <cros_ec.h> |
Simon Glass | 0f2af88 | 2020-05-10 11:40:05 -0600 | [diff] [blame] | 19 | #include <log.h> |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 20 | |
| 21 | #ifdef DEBUG_TRACE |
| 22 | #define debug_trace(fmt, b...) debug(fmt, #b) |
| 23 | #else |
| 24 | #define debug_trace(fmt, b...) |
| 25 | #endif |
| 26 | |
Moritz Fischer | 874d6b4 | 2017-01-20 12:35:03 -0800 | [diff] [blame] | 27 | /** |
| 28 | * Request format for protocol v3 |
| 29 | * byte 0 0xda (EC_COMMAND_PROTOCOL_3) |
| 30 | * byte 1-8 struct ec_host_request |
| 31 | * byte 10- response data |
| 32 | */ |
| 33 | struct ec_host_request_i2c { |
| 34 | /* Always 0xda to backward compatible with v2 struct */ |
| 35 | uint8_t command_protocol; |
| 36 | struct ec_host_request ec_request; |
| 37 | } __packed; |
| 38 | |
| 39 | /* |
| 40 | * Response format for protocol v3 |
| 41 | * byte 0 result code |
| 42 | * byte 1 packet_length |
| 43 | * byte 2-9 struct ec_host_response |
| 44 | * byte 10- response data |
| 45 | */ |
| 46 | struct ec_host_response_i2c { |
| 47 | uint8_t result; |
| 48 | uint8_t packet_length; |
| 49 | struct ec_host_response ec_response; |
| 50 | } __packed; |
| 51 | |
| 52 | static int cros_ec_i2c_packet(struct udevice *udev, int out_bytes, int in_bytes) |
| 53 | { |
| 54 | struct cros_ec_dev *dev = dev_get_uclass_priv(udev); |
| 55 | struct dm_i2c_chip *chip = dev_get_parent_platdata(udev); |
| 56 | struct ec_host_request_i2c *ec_request_i2c = |
| 57 | (struct ec_host_request_i2c *)dev->dout; |
| 58 | struct ec_host_response_i2c *ec_response_i2c = |
| 59 | (struct ec_host_response_i2c *)dev->din; |
| 60 | struct i2c_msg i2c_msg[2]; |
| 61 | int ret; |
| 62 | |
| 63 | i2c_msg[0].addr = chip->chip_addr; |
| 64 | i2c_msg[0].flags = 0; |
| 65 | i2c_msg[1].addr = chip->chip_addr; |
| 66 | i2c_msg[1].flags = I2C_M_RD; |
| 67 | |
| 68 | /* one extra byte, to indicate v3 */ |
| 69 | i2c_msg[0].len = out_bytes + 1; |
| 70 | i2c_msg[0].buf = dev->dout; |
| 71 | |
| 72 | /* stitch on EC_COMMAND_PROTOCOL_3 */ |
| 73 | memmove(&ec_request_i2c->ec_request, dev->dout, out_bytes); |
| 74 | ec_request_i2c->command_protocol = EC_COMMAND_PROTOCOL_3; |
| 75 | |
| 76 | /* two extra bytes for v3 */ |
| 77 | i2c_msg[1].len = in_bytes + 2; |
| 78 | i2c_msg[1].buf = dev->din; |
| 79 | |
| 80 | ret = dm_i2c_xfer(udev, &i2c_msg[0], 2); |
| 81 | if (ret) { |
| 82 | printf("%s: Could not execute transfer: %d\n", __func__, ret); |
| 83 | return ret; |
| 84 | } |
| 85 | |
| 86 | /* When we send a v3 request to v2 ec, ec won't recognize the 0xda |
| 87 | * (EC_COMMAND_PROTOCOL_3) and will return with status |
| 88 | * EC_RES_INVALID_COMMAND with zero data length |
| 89 | * |
| 90 | * In case of invalid command for v3 protocol the data length |
| 91 | * will be at least sizeof(struct ec_host_response) |
| 92 | */ |
| 93 | if (ec_response_i2c->result == EC_RES_INVALID_COMMAND && |
| 94 | ec_response_i2c->packet_length == 0) |
| 95 | return -EPROTONOSUPPORT; |
| 96 | |
| 97 | if (ec_response_i2c->packet_length < sizeof(struct ec_host_response)) { |
| 98 | printf("%s: response of %u bytes too short; not a full hdr\n", |
| 99 | __func__, ec_response_i2c->packet_length); |
| 100 | return -EBADMSG; |
| 101 | } |
| 102 | |
| 103 | |
| 104 | /* drop result and packet_len */ |
| 105 | memmove(dev->din, &ec_response_i2c->ec_response, in_bytes); |
| 106 | |
| 107 | return in_bytes; |
| 108 | } |
| 109 | |
Simon Glass | a1f2603 | 2015-01-26 20:29:40 -0700 | [diff] [blame] | 110 | static int cros_ec_i2c_command(struct udevice *udev, uint8_t cmd, |
| 111 | int cmd_version, const uint8_t *dout, |
| 112 | int dout_len, uint8_t **dinp, int din_len) |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 113 | { |
Simon Glass | de0977b | 2015-03-05 12:25:20 -0700 | [diff] [blame] | 114 | struct cros_ec_dev *dev = dev_get_uclass_priv(udev); |
Moritz Fischer | 9b606d6 | 2017-01-12 09:47:30 -0800 | [diff] [blame] | 115 | struct dm_i2c_chip *chip = dev_get_parent_platdata(udev); |
| 116 | struct i2c_msg i2c_msg[2]; |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 117 | /* version8, cmd8, arglen8, out8[dout_len], csum8 */ |
| 118 | int out_bytes = dout_len + 4; |
| 119 | /* response8, arglen8, in8[din_len], checksum8 */ |
| 120 | int in_bytes = din_len + 3; |
| 121 | uint8_t *ptr; |
| 122 | /* Receive input data, so that args will be dword aligned */ |
| 123 | uint8_t *in_ptr; |
Randall Spangler | f03e970 | 2014-02-27 13:26:08 -0700 | [diff] [blame] | 124 | int len, csum, ret; |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 125 | |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 126 | /* |
| 127 | * Sanity-check I/O sizes given transaction overhead in internal |
| 128 | * buffers. |
| 129 | */ |
| 130 | if (out_bytes > sizeof(dev->dout)) { |
| 131 | debug("%s: Cannot send %d bytes\n", __func__, dout_len); |
| 132 | return -1; |
| 133 | } |
| 134 | if (in_bytes > sizeof(dev->din)) { |
| 135 | debug("%s: Cannot receive %d bytes\n", __func__, din_len); |
| 136 | return -1; |
| 137 | } |
| 138 | assert(dout_len >= 0); |
| 139 | assert(dinp); |
| 140 | |
Moritz Fischer | 9b606d6 | 2017-01-12 09:47:30 -0800 | [diff] [blame] | 141 | i2c_msg[0].addr = chip->chip_addr; |
| 142 | i2c_msg[0].len = out_bytes; |
| 143 | i2c_msg[0].buf = dev->dout; |
| 144 | i2c_msg[0].flags = 0; |
| 145 | |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 146 | /* |
| 147 | * Copy command and data into output buffer so we can do a single I2C |
| 148 | * burst transaction. |
| 149 | */ |
| 150 | ptr = dev->dout; |
| 151 | |
| 152 | /* |
| 153 | * in_ptr starts of pointing to a dword-aligned input data buffer. |
| 154 | * We decrement it back by the number of header bytes we expect to |
| 155 | * receive, so that the first parameter of the resulting input data |
| 156 | * will be dword aligned. |
| 157 | */ |
| 158 | in_ptr = dev->din + sizeof(int64_t); |
Randall Spangler | f03e970 | 2014-02-27 13:26:08 -0700 | [diff] [blame] | 159 | |
| 160 | if (dev->protocol_version != 2) { |
| 161 | /* Something we don't support */ |
| 162 | debug("%s: Protocol version %d unsupported\n", |
| 163 | __func__, dev->protocol_version); |
| 164 | return -1; |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 165 | } |
Randall Spangler | f03e970 | 2014-02-27 13:26:08 -0700 | [diff] [blame] | 166 | |
| 167 | *ptr++ = EC_CMD_VERSION0 + cmd_version; |
| 168 | *ptr++ = cmd; |
| 169 | *ptr++ = dout_len; |
| 170 | in_ptr -= 2; /* Expect status, length bytes */ |
| 171 | |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 172 | memcpy(ptr, dout, dout_len); |
| 173 | ptr += dout_len; |
| 174 | |
Randall Spangler | f03e970 | 2014-02-27 13:26:08 -0700 | [diff] [blame] | 175 | *ptr++ = (uint8_t) |
| 176 | cros_ec_calc_checksum(dev->dout, dout_len + 3); |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 177 | |
Moritz Fischer | 9b606d6 | 2017-01-12 09:47:30 -0800 | [diff] [blame] | 178 | i2c_msg[1].addr = chip->chip_addr; |
| 179 | i2c_msg[1].len = in_bytes; |
| 180 | i2c_msg[1].buf = in_ptr; |
| 181 | i2c_msg[1].flags = I2C_M_RD; |
| 182 | |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 183 | /* Send output data */ |
| 184 | cros_ec_dump_data("out", -1, dev->dout, out_bytes); |
Moritz Fischer | 9b606d6 | 2017-01-12 09:47:30 -0800 | [diff] [blame] | 185 | |
| 186 | ret = dm_i2c_xfer(udev, &i2c_msg[0], 2); |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 187 | if (ret) { |
Moritz Fischer | 9b606d6 | 2017-01-12 09:47:30 -0800 | [diff] [blame] | 188 | debug("%s: Could not execute transfer to %s\n", __func__, |
Simon Glass | a1f2603 | 2015-01-26 20:29:40 -0700 | [diff] [blame] | 189 | udev->name); |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 190 | ret = -1; |
| 191 | } |
| 192 | |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 193 | if (*in_ptr != EC_RES_SUCCESS) { |
| 194 | debug("%s: Received bad result code %d\n", __func__, *in_ptr); |
| 195 | return -(int)*in_ptr; |
| 196 | } |
| 197 | |
Randall Spangler | f03e970 | 2014-02-27 13:26:08 -0700 | [diff] [blame] | 198 | len = in_ptr[1]; |
| 199 | if (len + 3 > sizeof(dev->din)) { |
| 200 | debug("%s: Received length %#02x too large\n", |
| 201 | __func__, len); |
| 202 | return -1; |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 203 | } |
Randall Spangler | f03e970 | 2014-02-27 13:26:08 -0700 | [diff] [blame] | 204 | csum = cros_ec_calc_checksum(in_ptr, 2 + len); |
| 205 | if (csum != in_ptr[2 + len]) { |
| 206 | debug("%s: Invalid checksum rx %#02x, calced %#02x\n", |
| 207 | __func__, in_ptr[2 + din_len], csum); |
| 208 | return -1; |
| 209 | } |
| 210 | din_len = min(din_len, len); |
| 211 | cros_ec_dump_data("in", -1, in_ptr, din_len + 3); |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 212 | |
| 213 | /* Return pointer to dword-aligned input data, if any */ |
| 214 | *dinp = dev->din + sizeof(int64_t); |
| 215 | |
| 216 | return din_len; |
| 217 | } |
| 218 | |
Simon Glass | a1f2603 | 2015-01-26 20:29:40 -0700 | [diff] [blame] | 219 | static int cros_ec_probe(struct udevice *dev) |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 220 | { |
Simon Glass | a1f2603 | 2015-01-26 20:29:40 -0700 | [diff] [blame] | 221 | return cros_ec_register(dev); |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 222 | } |
| 223 | |
Simon Glass | a1f2603 | 2015-01-26 20:29:40 -0700 | [diff] [blame] | 224 | static struct dm_cros_ec_ops cros_ec_ops = { |
| 225 | .command = cros_ec_i2c_command, |
Moritz Fischer | 874d6b4 | 2017-01-20 12:35:03 -0800 | [diff] [blame] | 226 | .packet = cros_ec_i2c_packet, |
Simon Glass | a1f2603 | 2015-01-26 20:29:40 -0700 | [diff] [blame] | 227 | }; |
Hung-ying Tyan | 6830408 | 2013-05-15 18:27:29 +0800 | [diff] [blame] | 228 | |
Simon Glass | a1f2603 | 2015-01-26 20:29:40 -0700 | [diff] [blame] | 229 | static const struct udevice_id cros_ec_ids[] = { |
Simon Glass | 73f220c | 2015-03-26 09:29:39 -0600 | [diff] [blame] | 230 | { .compatible = "google,cros-ec-i2c" }, |
Simon Glass | a1f2603 | 2015-01-26 20:29:40 -0700 | [diff] [blame] | 231 | { } |
| 232 | }; |
| 233 | |
| 234 | U_BOOT_DRIVER(cros_ec_i2c) = { |
Simon Glass | 73f220c | 2015-03-26 09:29:39 -0600 | [diff] [blame] | 235 | .name = "cros_ec_i2c", |
Simon Glass | a1f2603 | 2015-01-26 20:29:40 -0700 | [diff] [blame] | 236 | .id = UCLASS_CROS_EC, |
| 237 | .of_match = cros_ec_ids, |
| 238 | .probe = cros_ec_probe, |
| 239 | .ops = &cros_ec_ops, |
| 240 | }; |