cros_ec: Clean up multiple EC protocol support
[karo-tx-uboot.git] / drivers / misc / cros_ec_i2c.c
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 <i2c.h>
18 #include <cros_ec.h>
19
20 #ifdef DEBUG_TRACE
21 #define debug_trace(fmt, b...)  debug(fmt, #b)
22 #else
23 #define debug_trace(fmt, b...)
24 #endif
25
26 int cros_ec_i2c_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
27                      const uint8_t *dout, int dout_len,
28                      uint8_t **dinp, int din_len)
29 {
30         int old_bus = 0;
31         /* version8, cmd8, arglen8, out8[dout_len], csum8 */
32         int out_bytes = dout_len + 4;
33         /* response8, arglen8, in8[din_len], checksum8 */
34         int in_bytes = din_len + 3;
35         uint8_t *ptr;
36         /* Receive input data, so that args will be dword aligned */
37         uint8_t *in_ptr;
38         int len, csum, ret;
39
40         old_bus = i2c_get_bus_num();
41
42         /*
43          * Sanity-check I/O sizes given transaction overhead in internal
44          * buffers.
45          */
46         if (out_bytes > sizeof(dev->dout)) {
47                 debug("%s: Cannot send %d bytes\n", __func__, dout_len);
48                 return -1;
49         }
50         if (in_bytes > sizeof(dev->din)) {
51                 debug("%s: Cannot receive %d bytes\n", __func__, din_len);
52                 return -1;
53         }
54         assert(dout_len >= 0);
55         assert(dinp);
56
57         /*
58          * Copy command and data into output buffer so we can do a single I2C
59          * burst transaction.
60          */
61         ptr = dev->dout;
62
63         /*
64          * in_ptr starts of pointing to a dword-aligned input data buffer.
65          * We decrement it back by the number of header bytes we expect to
66          * receive, so that the first parameter of the resulting input data
67          * will be dword aligned.
68          */
69         in_ptr = dev->din + sizeof(int64_t);
70
71         if (dev->protocol_version != 2) {
72                 /* Something we don't support */
73                 debug("%s: Protocol version %d unsupported\n",
74                       __func__, dev->protocol_version);
75                 return -1;
76         }
77
78         *ptr++ = EC_CMD_VERSION0 + cmd_version;
79         *ptr++ = cmd;
80         *ptr++ = dout_len;
81         in_ptr -= 2;    /* Expect status, length bytes */
82
83         memcpy(ptr, dout, dout_len);
84         ptr += dout_len;
85
86         *ptr++ = (uint8_t)
87                 cros_ec_calc_checksum(dev->dout, dout_len + 3);
88
89         /* Set to the proper i2c bus */
90         if (i2c_set_bus_num(dev->bus_num)) {
91                 debug("%s: Cannot change to I2C bus %d\n", __func__,
92                         dev->bus_num);
93                 return -1;
94         }
95
96         /* Send output data */
97         cros_ec_dump_data("out", -1, dev->dout, out_bytes);
98         ret = i2c_write(dev->addr, 0, 0, dev->dout, out_bytes);
99         if (ret) {
100                 debug("%s: Cannot complete I2C write to 0x%x\n",
101                         __func__, dev->addr);
102                 ret = -1;
103         }
104
105         if (!ret) {
106                 ret = i2c_read(dev->addr, 0, 0, in_ptr, in_bytes);
107                 if (ret) {
108                         debug("%s: Cannot complete I2C read from 0x%x\n",
109                                 __func__, dev->addr);
110                         ret = -1;
111                 }
112         }
113
114         /* Return to original bus number */
115         i2c_set_bus_num(old_bus);
116         if (ret)
117                 return ret;
118
119         if (*in_ptr != EC_RES_SUCCESS) {
120                 debug("%s: Received bad result code %d\n", __func__, *in_ptr);
121                 return -(int)*in_ptr;
122         }
123
124         len = in_ptr[1];
125         if (len + 3 > sizeof(dev->din)) {
126                 debug("%s: Received length %#02x too large\n",
127                       __func__, len);
128                 return -1;
129         }
130         csum = cros_ec_calc_checksum(in_ptr, 2 + len);
131         if (csum != in_ptr[2 + len]) {
132                 debug("%s: Invalid checksum rx %#02x, calced %#02x\n",
133                       __func__, in_ptr[2 + din_len], csum);
134                 return -1;
135         }
136         din_len = min(din_len, len);
137         cros_ec_dump_data("in", -1, in_ptr, din_len + 3);
138
139         /* Return pointer to dword-aligned input data, if any */
140         *dinp = dev->din + sizeof(int64_t);
141
142         return din_len;
143 }
144
145 int cros_ec_i2c_decode_fdt(struct cros_ec_dev *dev, const void *blob)
146 {
147         /* Decode interface-specific FDT params */
148         dev->max_frequency = fdtdec_get_int(blob, dev->node,
149                                             "i2c-max-frequency", 100000);
150         dev->bus_num = i2c_get_bus_num_fdt(dev->parent_node);
151         if (dev->bus_num == -1) {
152                 debug("%s: Failed to read bus number\n", __func__);
153                 return -1;
154         }
155         dev->addr = fdtdec_get_int(blob, dev->node, "reg", -1);
156         if (dev->addr == -1) {
157                 debug("%s: Failed to read device address\n", __func__);
158                 return -1;
159         }
160
161         return 0;
162 }
163
164 /**
165  * Initialize I2C protocol.
166  *
167  * @param dev           CROS_EC device
168  * @param blob          Device tree blob
169  * @return 0 if ok, -1 on error
170  */
171 int cros_ec_i2c_init(struct cros_ec_dev *dev, const void *blob)
172 {
173         i2c_init(dev->max_frequency, dev->addr);
174
175         return 0;
176 }