cros_ec_i2c.c
4.46 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
/*
* Chromium OS cros_ec driver - I2C interface
*
* Copyright (c) 2012 The Chromium OS Authors.
*
* SPDX-License-Identifier: GPL-2.0+
*/
/*
* 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 <i2c.h>
#include <cros_ec.h>
#ifdef DEBUG_TRACE
#define debug_trace(fmt, b...) debug(fmt, #b)
#else
#define debug_trace(fmt, b...)
#endif
int cros_ec_i2c_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
const uint8_t *dout, int dout_len,
uint8_t **dinp, int din_len)
{
int old_bus = 0;
/* 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 ret;
old_bus = i2c_get_bus_num();
/*
* 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);
/*
* 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->cmd_version_is_supported) {
/* Send an old-style command */
*ptr++ = cmd;
out_bytes = dout_len + 1;
in_bytes = din_len + 2;
in_ptr--; /* Expect just a status byte */
} else {
*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;
if (dev->cmd_version_is_supported)
*ptr++ = (uint8_t)
cros_ec_calc_checksum(dev->dout, dout_len + 3);
/* Set to the proper i2c bus */
if (i2c_set_bus_num(dev->bus_num)) {
debug("%s: Cannot change to I2C bus %d\n", __func__,
dev->bus_num);
return -1;
}
/* Send output data */
cros_ec_dump_data("out", -1, dev->dout, out_bytes);
ret = i2c_write(dev->addr, 0, 0, dev->dout, out_bytes);
if (ret) {
debug("%s: Cannot complete I2C write to 0x%x\n",
__func__, dev->addr);
ret = -1;
}
if (!ret) {
ret = i2c_read(dev->addr, 0, 0, in_ptr, in_bytes);
if (ret) {
debug("%s: Cannot complete I2C read from 0x%x\n",
__func__, dev->addr);
ret = -1;
}
}
/* Return to original bus number */
i2c_set_bus_num(old_bus);
if (ret)
return ret;
if (*in_ptr != EC_RES_SUCCESS) {
debug("%s: Received bad result code %d\n", __func__, *in_ptr);
return -(int)*in_ptr;
}
if (dev->cmd_version_is_supported) {
int len, csum;
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);
} else {
cros_ec_dump_data("in (old)", -1, in_ptr, in_bytes);
}
/* Return pointer to dword-aligned input data, if any */
*dinp = dev->din + sizeof(int64_t);
return din_len;
}
int cros_ec_i2c_decode_fdt(struct cros_ec_dev *dev, const void *blob)
{
/* Decode interface-specific FDT params */
dev->max_frequency = fdtdec_get_int(blob, dev->node,
"i2c-max-frequency", 100000);
dev->bus_num = i2c_get_bus_num_fdt(dev->parent_node);
if (dev->bus_num == -1) {
debug("%s: Failed to read bus number\n", __func__);
return -1;
}
dev->addr = fdtdec_get_int(blob, dev->node, "reg", -1);
if (dev->addr == -1) {
debug("%s: Failed to read device address\n", __func__);
return -1;
}
return 0;
}
/**
* Initialize I2C protocol.
*
* @param dev CROS_EC device
* @param blob Device tree blob
* @return 0 if ok, -1 on error
*/
int cros_ec_i2c_init(struct cros_ec_dev *dev, const void *blob)
{
i2c_init(dev->max_frequency, dev->addr);
dev->cmd_version_is_supported = 0;
return 0;
}