1 /*
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 <log.h>
13 #include <asm/gpio.h>
14 #include <linux/delay.h>
15
16 #define DEFAULT_UDELAY 5
17 #define RETRIES 0
18 #define I2C_ACK 0
19 #define I2C_NOACK 1
20
21 enum {
22 PIN_SDA = 0,
23 PIN_SCL,
24 PIN_COUNT,
25 };
26
27 struct 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 int (*get_sda)(struct i2c_gpio_bus *bus);
37 void (*set_sda)(struct i2c_gpio_bus *bus, int bit);
38 void (*set_scl)(struct i2c_gpio_bus *bus, int bit);
39 };
40
i2c_gpio_sda_get(struct i2c_gpio_bus * bus)41 static int i2c_gpio_sda_get(struct i2c_gpio_bus *bus)
42 {
43 struct gpio_desc *sda = &bus->gpios[PIN_SDA];
44
45 return dm_gpio_get_value(sda);
46 }
47
i2c_gpio_sda_set(struct i2c_gpio_bus * bus,int bit)48 static void i2c_gpio_sda_set(struct i2c_gpio_bus *bus, int bit)
49 {
50 struct gpio_desc *sda = &bus->gpios[PIN_SDA];
51 ulong flags;
52
53 if (bit)
54 flags = GPIOD_IS_IN;
55 else
56 flags = GPIOD_IS_OUT;
57 dm_gpio_clrset_flags(sda, GPIOD_MASK_DIR, flags);
58 }
59
i2c_gpio_scl_set(struct i2c_gpio_bus * bus,int bit)60 static void i2c_gpio_scl_set(struct i2c_gpio_bus *bus, int bit)
61 {
62 struct gpio_desc *scl = &bus->gpios[PIN_SCL];
63 int count = 0;
64
65 if (bit) {
66 dm_gpio_clrset_flags(scl, GPIOD_MASK_DIR, GPIOD_IS_IN);
67 while (!dm_gpio_get_value(scl) && count++ < 100000)
68 udelay(1);
69
70 if (!dm_gpio_get_value(scl))
71 pr_err("timeout waiting on slave to release scl\n");
72 } else {
73 dm_gpio_clrset_flags(scl, GPIOD_MASK_DIR, GPIOD_IS_OUT);
74 }
75 }
76
77 /* variant for output only gpios which cannot support clock stretching */
i2c_gpio_scl_set_output_only(struct i2c_gpio_bus * bus,int bit)78 static void i2c_gpio_scl_set_output_only(struct i2c_gpio_bus *bus, int bit)
79 {
80 struct gpio_desc *scl = &bus->gpios[PIN_SCL];
81 ulong flags = GPIOD_IS_OUT;
82
83 if (bit)
84 flags |= GPIOD_IS_OUT_ACTIVE;
85 dm_gpio_clrset_flags(scl, GPIOD_MASK_DIR, flags);
86 }
87
i2c_gpio_write_bit(struct i2c_gpio_bus * bus,int delay,uchar bit)88 static void i2c_gpio_write_bit(struct i2c_gpio_bus *bus, int delay, uchar bit)
89 {
90 bus->set_scl(bus, 0);
91 udelay(delay);
92 bus->set_sda(bus, bit);
93 udelay(delay);
94 bus->set_scl(bus, 1);
95 udelay(2 * delay);
96 }
97
i2c_gpio_read_bit(struct i2c_gpio_bus * bus,int delay)98 static int i2c_gpio_read_bit(struct i2c_gpio_bus *bus, int delay)
99 {
100 int value;
101
102 bus->set_scl(bus, 1);
103 udelay(delay);
104 value = bus->get_sda(bus);
105 udelay(delay);
106 bus->set_scl(bus, 0);
107 udelay(2 * delay);
108
109 return value;
110 }
111
112 /* START: High -> Low on SDA while SCL is High */
i2c_gpio_send_start(struct i2c_gpio_bus * bus,int delay)113 static void i2c_gpio_send_start(struct i2c_gpio_bus *bus, int delay)
114 {
115 udelay(delay);
116 bus->set_sda(bus, 1);
117 udelay(delay);
118 bus->set_scl(bus, 1);
119 udelay(delay);
120 bus->set_sda(bus, 0);
121 udelay(delay);
122 }
123
124 /* STOP: Low -> High on SDA while SCL is High */
i2c_gpio_send_stop(struct i2c_gpio_bus * bus,int delay)125 static void i2c_gpio_send_stop(struct i2c_gpio_bus *bus, int delay)
126 {
127 bus->set_scl(bus, 0);
128 udelay(delay);
129 bus->set_sda(bus, 0);
130 udelay(delay);
131 bus->set_scl(bus, 1);
132 udelay(delay);
133 bus->set_sda(bus, 1);
134 udelay(delay);
135 }
136
137 /* ack should be I2C_ACK or I2C_NOACK */
i2c_gpio_send_ack(struct i2c_gpio_bus * bus,int delay,int ack)138 static void i2c_gpio_send_ack(struct i2c_gpio_bus *bus, int delay, int ack)
139 {
140 i2c_gpio_write_bit(bus, delay, ack);
141 bus->set_scl(bus, 0);
142 udelay(delay);
143 }
144
145 /**
146 * Send a reset sequence consisting of 9 clocks with the data signal high
147 * to clock any confused device back into an idle state. Also send a
148 * <stop> at the end of the sequence for belts & suspenders.
149 */
i2c_gpio_send_reset(struct i2c_gpio_bus * bus,int delay)150 static void i2c_gpio_send_reset(struct i2c_gpio_bus *bus, int delay)
151 {
152 int j;
153
154 for (j = 0; j < 9; j++)
155 i2c_gpio_write_bit(bus, delay, 1);
156
157 i2c_gpio_send_stop(bus, delay);
158 }
159
160 /* Set sda high with low clock, before reading slave data */
i2c_gpio_sda_high(struct i2c_gpio_bus * bus,int delay)161 static void i2c_gpio_sda_high(struct i2c_gpio_bus *bus, int delay)
162 {
163 bus->set_scl(bus, 0);
164 udelay(delay);
165 bus->set_sda(bus, 1);
166 udelay(delay);
167 }
168
169 /* Send 8 bits and look for an acknowledgement */
i2c_gpio_write_byte(struct i2c_gpio_bus * bus,int delay,uchar data)170 static int i2c_gpio_write_byte(struct i2c_gpio_bus *bus, int delay, uchar data)
171 {
172 int j;
173 int nack;
174
175 for (j = 0; j < 8; j++) {
176 i2c_gpio_write_bit(bus, delay, data & 0x80);
177 data <<= 1;
178 }
179
180 udelay(delay);
181
182 /* Look for an <ACK>(negative logic) and return it */
183 i2c_gpio_sda_high(bus, delay);
184 nack = i2c_gpio_read_bit(bus, delay);
185
186 return nack; /* not a nack is an ack */
187 }
188
189 /**
190 * if ack == I2C_ACK, ACK the byte so can continue reading, else
191 * send I2C_NOACK to end the read.
192 */
i2c_gpio_read_byte(struct i2c_gpio_bus * bus,int delay,int ack)193 static uchar i2c_gpio_read_byte(struct i2c_gpio_bus *bus, int delay, int ack)
194 {
195 int data;
196 int j;
197
198 i2c_gpio_sda_high(bus, delay);
199 data = 0;
200 for (j = 0; j < 8; j++) {
201 data <<= 1;
202 data |= i2c_gpio_read_bit(bus, delay);
203 }
204 i2c_gpio_send_ack(bus, delay, ack);
205
206 return data;
207 }
208
209 /* send start and the slave chip address */
i2c_send_slave_addr(struct i2c_gpio_bus * bus,int delay,uchar chip)210 int i2c_send_slave_addr(struct i2c_gpio_bus *bus, int delay, uchar chip)
211 {
212 i2c_gpio_send_start(bus, delay);
213
214 if (i2c_gpio_write_byte(bus, delay, chip)) {
215 i2c_gpio_send_stop(bus, delay);
216 return -EIO;
217 }
218
219 return 0;
220 }
221
i2c_gpio_write_data(struct i2c_gpio_bus * bus,uchar chip,uchar * buffer,int len,bool end_with_repeated_start)222 static int i2c_gpio_write_data(struct i2c_gpio_bus *bus, uchar chip,
223 uchar *buffer, int len,
224 bool end_with_repeated_start)
225 {
226 unsigned int delay = bus->udelay;
227 int failures = 0;
228
229 debug("%s: chip %x buffer %p len %d\n", __func__, chip, buffer, len);
230
231 if (i2c_send_slave_addr(bus, delay, chip << 1)) {
232 debug("i2c_write, no chip responded %02X\n", chip);
233 return -EIO;
234 }
235
236 while (len-- > 0) {
237 if (i2c_gpio_write_byte(bus, delay, *buffer++))
238 failures++;
239 }
240
241 if (!end_with_repeated_start) {
242 i2c_gpio_send_stop(bus, delay);
243 return failures;
244 }
245
246 if (i2c_send_slave_addr(bus, delay, (chip << 1) | 0x1)) {
247 debug("i2c_write, no chip responded %02X\n", chip);
248 return -EIO;
249 }
250
251 return failures;
252 }
253
i2c_gpio_read_data(struct i2c_gpio_bus * bus,uchar chip,uchar * buffer,int len)254 static int i2c_gpio_read_data(struct i2c_gpio_bus *bus, uchar chip,
255 uchar *buffer, int len)
256 {
257 unsigned int delay = bus->udelay;
258
259 debug("%s: chip %x buffer: %p len %d\n", __func__, chip, buffer, len);
260
261 while (len-- > 0)
262 *buffer++ = i2c_gpio_read_byte(bus, delay, len == 0);
263
264 i2c_gpio_send_stop(bus, delay);
265
266 return 0;
267 }
268
i2c_gpio_xfer(struct udevice * dev,struct i2c_msg * msg,int nmsgs)269 static int i2c_gpio_xfer(struct udevice *dev, struct i2c_msg *msg, int nmsgs)
270 {
271 struct i2c_gpio_bus *bus = dev_get_priv(dev);
272 int ret;
273
274 for (; nmsgs > 0; nmsgs--, msg++) {
275 bool next_is_read = nmsgs > 1 && (msg[1].flags & I2C_M_RD);
276
277 if (msg->flags & I2C_M_RD) {
278 ret = i2c_gpio_read_data(bus, msg->addr, msg->buf,
279 msg->len);
280 } else {
281 ret = i2c_gpio_write_data(bus, msg->addr, msg->buf,
282 msg->len, next_is_read);
283 }
284
285 if (ret)
286 return -EREMOTEIO;
287 }
288
289 return 0;
290 }
291
i2c_gpio_probe(struct udevice * dev,uint chip,uint chip_flags)292 static int i2c_gpio_probe(struct udevice *dev, uint chip, uint chip_flags)
293 {
294 struct i2c_gpio_bus *bus = dev_get_priv(dev);
295 unsigned int delay = bus->udelay;
296 int ret;
297
298 i2c_gpio_send_start(bus, delay);
299 ret = i2c_gpio_write_byte(bus, delay, (chip << 1) | 0);
300 i2c_gpio_send_stop(bus, delay);
301
302 debug("%s: bus: %d (%s) chip: %x flags: %x ret: %d\n",
303 __func__, dev_seq(dev), dev->name, chip, chip_flags, ret);
304
305 return ret;
306 }
307
i2c_gpio_set_bus_speed(struct udevice * dev,unsigned int speed_hz)308 static int i2c_gpio_set_bus_speed(struct udevice *dev, unsigned int speed_hz)
309 {
310 struct i2c_gpio_bus *bus = dev_get_priv(dev);
311
312 bus->udelay = 1000000 / (speed_hz << 2);
313
314 i2c_gpio_send_reset(bus, bus->udelay);
315
316 return 0;
317 }
318
i2c_gpio_drv_probe(struct udevice * dev)319 static int i2c_gpio_drv_probe(struct udevice *dev)
320 {
321 if (dev_read_bool(dev, "i2c-gpio,deblock")) {
322 /* @200kHz 9 clocks = 44us, 62us is ok */
323 const unsigned int DELAY_ABORT_SEQ = 62;
324 struct i2c_gpio_bus *bus = dev_get_priv(dev);
325
326 return i2c_deblock_gpio_loop(&bus->gpios[PIN_SDA],
327 &bus->gpios[PIN_SCL],
328 16, 5, DELAY_ABORT_SEQ);
329 }
330
331 return 0;
332 }
333
i2c_gpio_of_to_plat(struct udevice * dev)334 static int i2c_gpio_of_to_plat(struct udevice *dev)
335 {
336 struct i2c_gpio_bus *bus = dev_get_priv(dev);
337 int ret;
338
339 ret = gpio_request_list_by_name(dev, "gpios", bus->gpios,
340 ARRAY_SIZE(bus->gpios), 0);
341 if (ret < 0)
342 goto error;
343
344 bus->udelay = dev_read_u32_default(dev, "i2c-gpio,delay-us",
345 DEFAULT_UDELAY);
346
347 bus->get_sda = i2c_gpio_sda_get;
348 bus->set_sda = i2c_gpio_sda_set;
349 if (dev_read_bool(dev, "i2c-gpio,scl-output-only"))
350 bus->set_scl = i2c_gpio_scl_set_output_only;
351 else
352 bus->set_scl = i2c_gpio_scl_set;
353
354 return 0;
355 error:
356 pr_err("Can't get %s gpios! Error: %d", dev->name, ret);
357 return ret;
358 }
359
360 static const struct dm_i2c_ops i2c_gpio_ops = {
361 .xfer = i2c_gpio_xfer,
362 .probe_chip = i2c_gpio_probe,
363 .set_bus_speed = i2c_gpio_set_bus_speed,
364 };
365
366 static const struct udevice_id i2c_gpio_ids[] = {
367 { .compatible = "i2c-gpio" },
368 { }
369 };
370
371 U_BOOT_DRIVER(i2c_gpio) = {
372 .name = "i2c-gpio",
373 .id = UCLASS_I2C,
374 .of_match = i2c_gpio_ids,
375 .probe = i2c_gpio_drv_probe,
376 .of_to_plat = i2c_gpio_of_to_plat,
377 .priv_auto = sizeof(struct i2c_gpio_bus),
378 .ops = &i2c_gpio_ops,
379 };
380