1 /* 2 * Chromium OS cros_ec driver - I2C interface 3 * 4 * Copyright (c) 2012 The Chromium OS Authors. 5 * 6 * SPDX-License-Identifier: GPL-2.0+ 7 */ 8 9 /* 10 * The Matrix Keyboard Protocol driver handles talking to the keyboard 11 * controller chip. Mostly this is for keyboard functions, but some other 12 * things have slipped in, so we provide generic services to talk to the 13 * KBC. 14 */ 15 16 #include <common.h> 17 #include <dm.h> 18 #include <i2c.h> 19 #include <cros_ec.h> 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 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 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) 113 { 114 struct cros_ec_dev *dev = dev_get_uclass_priv(udev); 115 struct dm_i2c_chip *chip = dev_get_parent_platdata(udev); 116 struct i2c_msg i2c_msg[2]; 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; 124 int len, csum, ret; 125 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 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 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); 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; 165 } 166 167 *ptr++ = EC_CMD_VERSION0 + cmd_version; 168 *ptr++ = cmd; 169 *ptr++ = dout_len; 170 in_ptr -= 2; /* Expect status, length bytes */ 171 172 memcpy(ptr, dout, dout_len); 173 ptr += dout_len; 174 175 *ptr++ = (uint8_t) 176 cros_ec_calc_checksum(dev->dout, dout_len + 3); 177 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 183 /* Send output data */ 184 cros_ec_dump_data("out", -1, dev->dout, out_bytes); 185 186 ret = dm_i2c_xfer(udev, &i2c_msg[0], 2); 187 if (ret) { 188 debug("%s: Could not execute transfer to %s\n", __func__, 189 udev->name); 190 ret = -1; 191 } 192 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 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; 203 } 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); 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 219 static int cros_ec_probe(struct udevice *dev) 220 { 221 return cros_ec_register(dev); 222 } 223 224 static struct dm_cros_ec_ops cros_ec_ops = { 225 .command = cros_ec_i2c_command, 226 .packet = cros_ec_i2c_packet, 227 }; 228 229 static const struct udevice_id cros_ec_ids[] = { 230 { .compatible = "google,cros-ec-i2c" }, 231 { } 232 }; 233 234 U_BOOT_DRIVER(cros_ec_i2c) = { 235 .name = "cros_ec_i2c", 236 .id = UCLASS_CROS_EC, 237 .of_match = cros_ec_ids, 238 .probe = cros_ec_probe, 239 .ops = &cros_ec_ops, 240 }; 241