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