blob: a8b83c51bc398a61f89377b3305cc9474a14c9e2 [file] [log] [blame]
Przemyslaw Marczakc54473c2015-03-31 18:57:18 +02001/*
2 * (C) Copyright 2015, Samsung Electronics
3 * Przemyslaw Marczak <p.marczak@samsung.com>
4 *
5 * This file is based on: drivers/i2c/soft-i2c.c,
6 * with added driver-model support and code cleanup.
7 */
8#include <common.h>
9#include <errno.h>
10#include <dm.h>
11#include <i2c.h>
12#include <asm/gpio.h>
13
14#define DEFAULT_UDELAY 5
15#define RETRIES 0
16#define I2C_ACK 0
17#define I2C_NOACK 1
18
19DECLARE_GLOBAL_DATA_PTR;
20
21enum {
22 PIN_SDA = 0,
23 PIN_SCL,
24 PIN_COUNT,
25};
26
27struct i2c_gpio_bus {
28 /**
29 * udelay - delay [us] between GPIO toggle operations,
30 * which is 1/4 of I2C speed clock period.
31 */
32 int udelay;
33 /* sda, scl */
34 struct gpio_desc gpios[PIN_COUNT];
35};
36
37static int i2c_gpio_sda_get(struct gpio_desc *sda)
38{
39 return dm_gpio_get_value(sda);
40}
41
42static void i2c_gpio_sda_set(struct gpio_desc *sda, int bit)
43{
Axel Lin76382aa2015-04-26 11:05:38 +080044 if (bit)
Przemyslaw Marczakc54473c2015-03-31 18:57:18 +020045 dm_gpio_set_dir_flags(sda, GPIOD_IS_IN);
Axel Lin76382aa2015-04-26 11:05:38 +080046 else
Przemyslaw Marczakc54473c2015-03-31 18:57:18 +020047 dm_gpio_set_dir_flags(sda, GPIOD_IS_OUT);
Przemyslaw Marczakc54473c2015-03-31 18:57:18 +020048}
49
50static void i2c_gpio_scl_set(struct gpio_desc *scl, int bit)
51{
Axel Lin76382aa2015-04-26 11:05:38 +080052 ulong flags = GPIOD_IS_OUT;
53
54 if (bit)
55 flags |= GPIOD_IS_OUT_ACTIVE;
56 dm_gpio_set_dir_flags(scl, flags);
Przemyslaw Marczakc54473c2015-03-31 18:57:18 +020057}
58
59static void i2c_gpio_write_bit(struct gpio_desc *scl, struct gpio_desc *sda,
60 int delay, uchar bit)
61{
62 i2c_gpio_scl_set(scl, 0);
63 udelay(delay);
64 i2c_gpio_sda_set(sda, bit);
65 udelay(delay);
66 i2c_gpio_scl_set(scl, 1);
67 udelay(2 * delay);
68}
69
70static int i2c_gpio_read_bit(struct gpio_desc *scl, struct gpio_desc *sda,
71 int delay)
72{
73 int value;
74
75 i2c_gpio_scl_set(scl, 1);
76 udelay(delay);
77 value = i2c_gpio_sda_get(sda);
78 udelay(delay);
79 i2c_gpio_scl_set(scl, 0);
80 udelay(2 * delay);
81
82 return value;
83}
84
85/* START: High -> Low on SDA while SCL is High */
86static void i2c_gpio_send_start(struct gpio_desc *scl, struct gpio_desc *sda,
87 int delay)
88{
89 udelay(delay);
90 i2c_gpio_sda_set(sda, 1);
91 udelay(delay);
92 i2c_gpio_scl_set(scl, 1);
93 udelay(delay);
94 i2c_gpio_sda_set(sda, 0);
95 udelay(delay);
96}
97
98/* STOP: Low -> High on SDA while SCL is High */
99static void i2c_gpio_send_stop(struct gpio_desc *scl, struct gpio_desc *sda,
100 int delay)
101{
102 i2c_gpio_scl_set(scl, 0);
103 udelay(delay);
104 i2c_gpio_sda_set(sda, 0);
105 udelay(delay);
106 i2c_gpio_scl_set(scl, 1);
107 udelay(delay);
108 i2c_gpio_sda_set(sda, 1);
109 udelay(delay);
110}
111
112/* ack should be I2C_ACK or I2C_NOACK */
113static void i2c_gpio_send_ack(struct gpio_desc *scl, struct gpio_desc *sda,
114 int delay, int ack)
115{
116 i2c_gpio_write_bit(scl, sda, delay, ack);
117 i2c_gpio_scl_set(scl, 0);
118 udelay(delay);
119}
120
121/**
122 * Send a reset sequence consisting of 9 clocks with the data signal high
123 * to clock any confused device back into an idle state. Also send a
124 * <stop> at the end of the sequence for belts & suspenders.
125 */
126static void i2c_gpio_send_reset(struct gpio_desc *scl, struct gpio_desc *sda,
127 int delay)
128{
129 int j;
130
131 for (j = 0; j < 9; j++)
132 i2c_gpio_write_bit(scl, sda, delay, 1);
133
134 i2c_gpio_send_stop(scl, sda, delay);
135}
136
137/* Set sda high with low clock, before reading slave data */
138static void i2c_gpio_sda_high(struct gpio_desc *scl, struct gpio_desc *sda,
139 int delay)
140{
141 i2c_gpio_scl_set(scl, 0);
142 udelay(delay);
143 i2c_gpio_sda_set(sda, 1);
144 udelay(delay);
145}
146
147/* Send 8 bits and look for an acknowledgement */
148static int i2c_gpio_write_byte(struct gpio_desc *scl, struct gpio_desc *sda,
149 int delay, uchar data)
150{
151 int j;
152 int nack;
153
154 for (j = 0; j < 8; j++) {
155 i2c_gpio_write_bit(scl, sda, delay, data & 0x80);
156 data <<= 1;
157 }
158
159 udelay(delay);
160
161 /* Look for an <ACK>(negative logic) and return it */
162 i2c_gpio_sda_high(scl, sda, delay);
163 nack = i2c_gpio_read_bit(scl, sda, delay);
164
165 return nack; /* not a nack is an ack */
166}
167
168/**
169 * if ack == I2C_ACK, ACK the byte so can continue reading, else
170 * send I2C_NOACK to end the read.
171 */
172static uchar i2c_gpio_read_byte(struct gpio_desc *scl, struct gpio_desc *sda,
173 int delay, int ack)
174{
175 int data;
176 int j;
177
178 i2c_gpio_sda_high(scl, sda, delay);
179 data = 0;
180 for (j = 0; j < 8; j++) {
181 data <<= 1;
182 data |= i2c_gpio_read_bit(scl, sda, delay);
183 }
184 i2c_gpio_send_ack(scl, sda, delay, ack);
185
186 return data;
187}
188
189/* send start and the slave chip address */
190int i2c_send_slave_addr(struct gpio_desc *scl, struct gpio_desc *sda, int delay,
191 uchar chip)
192{
193 i2c_gpio_send_start(scl, sda, delay);
194
195 if (i2c_gpio_write_byte(scl, sda, delay, chip)) {
196 i2c_gpio_send_stop(scl, sda, delay);
197 return -EIO;
198 }
199
200 return 0;
201}
202
203static int i2c_gpio_write_data(struct i2c_gpio_bus *bus, uchar chip,
204 uchar *buffer, int len,
205 bool end_with_repeated_start)
206{
207 struct gpio_desc *scl = &bus->gpios[PIN_SCL];
208 struct gpio_desc *sda = &bus->gpios[PIN_SDA];
209 unsigned int delay = bus->udelay;
210 int failures = 0;
211
212 debug("%s: chip %x buffer %p len %d\n", __func__, chip, buffer, len);
213
214 if (i2c_send_slave_addr(scl, sda, delay, chip << 1)) {
215 debug("i2c_write, no chip responded %02X\n", chip);
216 return -EIO;
217 }
218
219 while (len-- > 0) {
220 if (i2c_gpio_write_byte(scl, sda, delay, *buffer++))
221 failures++;
222 }
223
224 if (!end_with_repeated_start) {
225 i2c_gpio_send_stop(scl, sda, delay);
226 return failures;
227 }
228
229 if (i2c_send_slave_addr(scl, sda, delay, (chip << 1) | 0x1)) {
230 debug("i2c_write, no chip responded %02X\n", chip);
231 return -EIO;
232 }
233
234 return failures;
235}
236
237static int i2c_gpio_read_data(struct i2c_gpio_bus *bus, uchar chip,
238 uchar *buffer, int len)
239{
240 struct gpio_desc *scl = &bus->gpios[PIN_SCL];
241 struct gpio_desc *sda = &bus->gpios[PIN_SDA];
242 unsigned int delay = bus->udelay;
243
244 debug("%s: chip %x buffer: %p len %d\n", __func__, chip, buffer, len);
245
246 while (len-- > 0)
247 *buffer++ = i2c_gpio_read_byte(scl, sda, delay, len == 0);
248
249 i2c_gpio_send_stop(scl, sda, delay);
250
251 return 0;
252}
253
254static int i2c_gpio_xfer(struct udevice *dev, struct i2c_msg *msg, int nmsgs)
255{
256 struct i2c_gpio_bus *bus = dev_get_priv(dev);
257 int ret;
258
259 for (; nmsgs > 0; nmsgs--, msg++) {
260 bool next_is_read = nmsgs > 1 && (msg[1].flags & I2C_M_RD);
261
262 if (msg->flags & I2C_M_RD) {
263 ret = i2c_gpio_read_data(bus, msg->addr, msg->buf,
264 msg->len);
265 } else {
266 ret = i2c_gpio_write_data(bus, msg->addr, msg->buf,
267 msg->len, next_is_read);
268 }
269
270 if (ret)
271 return -EREMOTEIO;
272 }
273
274 return 0;
275}
276
277static int i2c_gpio_probe(struct udevice *dev, uint chip, uint chip_flags)
278{
279 struct i2c_gpio_bus *bus = dev_get_priv(dev);
280 struct gpio_desc *scl = &bus->gpios[PIN_SCL];
281 struct gpio_desc *sda = &bus->gpios[PIN_SDA];
282 unsigned int delay = bus->udelay;
283 int ret;
284
285 i2c_gpio_send_start(scl, sda, delay);
286 ret = i2c_gpio_write_byte(scl, sda, delay, (chip << 1) | 0);
287 i2c_gpio_send_stop(scl, sda, delay);
288
289 debug("%s: bus: %d (%s) chip: %x flags: %x ret: %d\n",
290 __func__, dev->seq, dev->name, chip, chip_flags, ret);
291
292 return ret;
293}
294
295static int i2c_gpio_set_bus_speed(struct udevice *dev, unsigned int speed_hz)
296{
297 struct i2c_gpio_bus *bus = dev_get_priv(dev);
298 struct gpio_desc *scl = &bus->gpios[PIN_SCL];
299 struct gpio_desc *sda = &bus->gpios[PIN_SDA];
300
301 bus->udelay = 1000000 / (speed_hz << 2);
302
303 i2c_gpio_send_reset(scl, sda, bus->udelay);
304
305 return 0;
306}
307
308static int i2c_gpio_ofdata_to_platdata(struct udevice *dev)
309{
310 struct i2c_gpio_bus *bus = dev_get_priv(dev);
311 const void *blob = gd->fdt_blob;
312 int node = dev->of_offset;
313 int ret;
314
315 ret = gpio_request_list_by_name(dev, "gpios", bus->gpios,
316 ARRAY_SIZE(bus->gpios), 0);
317 if (ret < 0)
318 goto error;
319
320 bus->udelay = fdtdec_get_int(blob, node, "i2c-gpio,delay-us",
321 DEFAULT_UDELAY);
322
323 return 0;
324error:
325 error("Can't get %s gpios! Error: %d", dev->name, ret);
326 return ret;
327}
328
329static const struct dm_i2c_ops i2c_gpio_ops = {
330 .xfer = i2c_gpio_xfer,
331 .probe_chip = i2c_gpio_probe,
332 .set_bus_speed = i2c_gpio_set_bus_speed,
333};
334
335static const struct udevice_id i2c_gpio_ids[] = {
336 { .compatible = "i2c-gpio" },
337 { }
338};
339
340U_BOOT_DRIVER(i2c_gpio) = {
341 .name = "i2c-gpio",
342 .id = UCLASS_I2C,
343 .of_match = i2c_gpio_ids,
344 .ofdata_to_platdata = i2c_gpio_ofdata_to_platdata,
345 .priv_auto_alloc_size = sizeof(struct i2c_gpio_bus),
346 .ops = &i2c_gpio_ops,
347};