]> git.sur5r.net Git - u-boot/blob - drivers/i2c/i2c-gpio.c
Merge git://git.denx.de/u-boot-ubi
[u-boot] / drivers / i2c / i2c-gpio.c
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 <asm/gpio.h>
13
14 #define DEFAULT_UDELAY  5
15 #define RETRIES         0
16 #define I2C_ACK         0
17 #define I2C_NOACK       1
18
19 DECLARE_GLOBAL_DATA_PTR;
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
37 static int i2c_gpio_sda_get(struct gpio_desc *sda)
38 {
39         return dm_gpio_get_value(sda);
40 }
41
42 static void i2c_gpio_sda_set(struct gpio_desc *sda, int bit)
43 {
44         if (bit)
45                 dm_gpio_set_dir_flags(sda, GPIOD_IS_IN);
46         else
47                 dm_gpio_set_dir_flags(sda, GPIOD_IS_OUT);
48 }
49
50 static void i2c_gpio_scl_set(struct gpio_desc *scl, int bit)
51 {
52         ulong flags = GPIOD_IS_OUT;
53
54         if (bit)
55                 flags |= GPIOD_IS_OUT_ACTIVE;
56         dm_gpio_set_dir_flags(scl, flags);
57 }
58
59 static 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
70 static 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 */
86 static 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 */
99 static 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 */
113 static 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  */
126 static 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 */
138 static 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 */
148 static 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  */
172 static 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 */
190 int 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
203 static 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
237 static 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
254 static 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
277 static 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
295 static 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
308 static 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(dev);
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;
324 error:
325         pr_err("Can't get %s gpios! Error: %d", dev->name, ret);
326         return ret;
327 }
328
329 static 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
335 static const struct udevice_id i2c_gpio_ids[] = {
336         { .compatible = "i2c-gpio" },
337         { }
338 };
339
340 U_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 };