xref: /openbmc/u-boot/drivers/i2c/i2c-gpio.c (revision 002e9108)
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 
i2c_gpio_sda_get(struct gpio_desc * sda)37 static int i2c_gpio_sda_get(struct gpio_desc *sda)
38 {
39 	return dm_gpio_get_value(sda);
40 }
41 
i2c_gpio_sda_set(struct gpio_desc * sda,int bit)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 
i2c_gpio_scl_set(struct gpio_desc * scl,int bit)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 
i2c_gpio_write_bit(struct gpio_desc * scl,struct gpio_desc * sda,int delay,uchar bit)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 
i2c_gpio_read_bit(struct gpio_desc * scl,struct gpio_desc * sda,int delay)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 */
i2c_gpio_send_start(struct gpio_desc * scl,struct gpio_desc * sda,int delay)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 */
i2c_gpio_send_stop(struct gpio_desc * scl,struct gpio_desc * sda,int delay)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 */
i2c_gpio_send_ack(struct gpio_desc * scl,struct gpio_desc * sda,int delay,int ack)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  */
i2c_gpio_send_reset(struct gpio_desc * scl,struct gpio_desc * sda,int delay)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 */
i2c_gpio_sda_high(struct gpio_desc * scl,struct gpio_desc * sda,int delay)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 */
i2c_gpio_write_byte(struct gpio_desc * scl,struct gpio_desc * sda,int delay,uchar data)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  */
i2c_gpio_read_byte(struct gpio_desc * scl,struct gpio_desc * sda,int delay,int ack)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 */
i2c_send_slave_addr(struct gpio_desc * scl,struct gpio_desc * sda,int delay,uchar chip)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 
i2c_gpio_write_data(struct i2c_gpio_bus * bus,uchar chip,uchar * buffer,int len,bool end_with_repeated_start)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 
i2c_gpio_read_data(struct i2c_gpio_bus * bus,uchar chip,uchar * buffer,int len)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 
i2c_gpio_xfer(struct udevice * dev,struct i2c_msg * msg,int nmsgs)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 
i2c_gpio_probe(struct udevice * dev,uint chip,uint chip_flags)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 
i2c_gpio_set_bus_speed(struct udevice * dev,unsigned int speed_hz)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 
i2c_gpio_ofdata_to_platdata(struct udevice * dev)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 };
348