[people/ms/u-boot.git] / drivers / i2c / i2c-gpio.c

/*
 * (C) Copyright 2015, Samsung Electronics
 * Przemyslaw Marczak <p.marczak@samsung.com>
 *
 * This file is based on: drivers/i2c/soft-i2c.c,
 * with added driver-model support and code cleanup.
 */
#include <common.h>
#include <errno.h>
#include <dm.h>
#include <i2c.h>
#include <asm/gpio.h>

#define DEFAULT_UDELAY	5
#define RETRIES		0
#define I2C_ACK		0
#define I2C_NOACK	1

DECLARE_GLOBAL_DATA_PTR;

enum {
	PIN_SDA = 0,
	PIN_SCL,
	PIN_COUNT,
};

struct i2c_gpio_bus {
	/**
	  * udelay - delay [us] between GPIO toggle operations,
	  * which is 1/4 of I2C speed clock period.
	 */
	int udelay;
	 /* sda, scl */
	struct gpio_desc gpios[PIN_COUNT];
};

static int i2c_gpio_sda_get(struct gpio_desc *sda)
{
	return dm_gpio_get_value(sda);
}

static void i2c_gpio_sda_set(struct gpio_desc *sda, int bit)
{
	if (bit)
		dm_gpio_set_dir_flags(sda, GPIOD_IS_IN);
	else
		dm_gpio_set_dir_flags(sda, GPIOD_IS_OUT);
}

static void i2c_gpio_scl_set(struct gpio_desc *scl, int bit)
{
	ulong flags = GPIOD_IS_OUT;

	if (bit)
		flags |= GPIOD_IS_OUT_ACTIVE;
	dm_gpio_set_dir_flags(scl, flags);
}

static void i2c_gpio_write_bit(struct gpio_desc *scl, struct gpio_desc *sda,
			       int delay, uchar bit)
{
	i2c_gpio_scl_set(scl, 0);
	udelay(delay);
	i2c_gpio_sda_set(sda, bit);
	udelay(delay);
	i2c_gpio_scl_set(scl, 1);
	udelay(2 * delay);
}

static int i2c_gpio_read_bit(struct gpio_desc *scl, struct gpio_desc *sda,
			     int delay)
{
	int value;

	i2c_gpio_scl_set(scl, 1);
	udelay(delay);
	value = i2c_gpio_sda_get(sda);
	udelay(delay);
	i2c_gpio_scl_set(scl, 0);
	udelay(2 * delay);

	return value;
}

/* START: High -> Low on SDA while SCL is High */
static void i2c_gpio_send_start(struct gpio_desc *scl, struct gpio_desc *sda,
				int delay)
{
	udelay(delay);
	i2c_gpio_sda_set(sda, 1);
	udelay(delay);
	i2c_gpio_scl_set(scl, 1);
	udelay(delay);
	i2c_gpio_sda_set(sda, 0);
	udelay(delay);
}

/* STOP: Low -> High on SDA while SCL is High */
static void i2c_gpio_send_stop(struct gpio_desc *scl, struct gpio_desc *sda,
			       int delay)
{
	i2c_gpio_scl_set(scl, 0);
	udelay(delay);
	i2c_gpio_sda_set(sda, 0);
	udelay(delay);
	i2c_gpio_scl_set(scl, 1);
	udelay(delay);
	i2c_gpio_sda_set(sda, 1);
	udelay(delay);
}

/* ack should be I2C_ACK or I2C_NOACK */
static void i2c_gpio_send_ack(struct gpio_desc *scl, struct gpio_desc *sda,
			      int delay, int ack)
{
	i2c_gpio_write_bit(scl, sda, delay, ack);
	i2c_gpio_scl_set(scl, 0);
	udelay(delay);
}

/**
 * Send a reset sequence consisting of 9 clocks with the data signal high
 * to clock any confused device back into an idle state.  Also send a
 * <stop> at the end of the sequence for belts & suspenders.
 */
static void i2c_gpio_send_reset(struct gpio_desc *scl, struct gpio_desc *sda,
				int delay)
{
	int j;

	for (j = 0; j < 9; j++)
		i2c_gpio_write_bit(scl, sda, delay, 1);

	i2c_gpio_send_stop(scl, sda, delay);
}

/* Set sda high with low clock, before reading slave data */
static void i2c_gpio_sda_high(struct gpio_desc *scl, struct gpio_desc *sda,
			      int delay)
{
	i2c_gpio_scl_set(scl, 0);
	udelay(delay);
	i2c_gpio_sda_set(sda, 1);
	udelay(delay);
}

/* Send 8 bits and look for an acknowledgement */
static int i2c_gpio_write_byte(struct gpio_desc *scl, struct gpio_desc *sda,
			       int delay, uchar data)
{
	int j;
	int nack;

	for (j = 0; j < 8; j++) {
		i2c_gpio_write_bit(scl, sda, delay, data & 0x80);
		data <<= 1;
	}

	udelay(delay);

	/* Look for an <ACK>(negative logic) and return it */
	i2c_gpio_sda_high(scl, sda, delay);
	nack = i2c_gpio_read_bit(scl, sda, delay);

	return nack;	/* not a nack is an ack */
}

/**
 * if ack == I2C_ACK, ACK the byte so can continue reading, else
 * send I2C_NOACK to end the read.
 */
static uchar i2c_gpio_read_byte(struct gpio_desc *scl, struct gpio_desc *sda,
				int delay, int ack)
{
	int  data;
	int  j;

	i2c_gpio_sda_high(scl, sda, delay);
	data = 0;
	for (j = 0; j < 8; j++) {
		data <<= 1;
		data |= i2c_gpio_read_bit(scl, sda, delay);
	}
	i2c_gpio_send_ack(scl, sda, delay, ack);

	return data;
}

/* send start and the slave chip address */
int i2c_send_slave_addr(struct gpio_desc *scl, struct gpio_desc *sda, int delay,
			uchar chip)
{
	i2c_gpio_send_start(scl, sda, delay);

	if (i2c_gpio_write_byte(scl, sda, delay, chip)) {
		i2c_gpio_send_stop(scl, sda, delay);
		return -EIO;
	}

	return 0;
}

static int i2c_gpio_write_data(struct i2c_gpio_bus *bus, uchar chip,
			       uchar *buffer, int len,
			       bool end_with_repeated_start)
{
	struct gpio_desc *scl = &bus->gpios[PIN_SCL];
	struct gpio_desc *sda = &bus->gpios[PIN_SDA];
	unsigned int delay = bus->udelay;
	int failures = 0;

	debug("%s: chip %x buffer %p len %d\n", __func__, chip, buffer, len);

	if (i2c_send_slave_addr(scl, sda, delay, chip << 1)) {
		debug("i2c_write, no chip responded %02X\n", chip);
		return -EIO;
	}

	while (len-- > 0) {
		if (i2c_gpio_write_byte(scl, sda, delay, *buffer++))
			failures++;
	}

	if (!end_with_repeated_start) {
		i2c_gpio_send_stop(scl, sda, delay);
		return failures;
	}

	if (i2c_send_slave_addr(scl, sda, delay, (chip << 1) | 0x1)) {
		debug("i2c_write, no chip responded %02X\n", chip);
		return -EIO;
	}

	return failures;
}

static int i2c_gpio_read_data(struct i2c_gpio_bus *bus, uchar chip,
			      uchar *buffer, int len)
{
	struct gpio_desc *scl = &bus->gpios[PIN_SCL];
	struct gpio_desc *sda = &bus->gpios[PIN_SDA];
	unsigned int delay = bus->udelay;

	debug("%s: chip %x buffer: %p len %d\n", __func__, chip, buffer, len);

	while (len-- > 0)
		*buffer++ = i2c_gpio_read_byte(scl, sda, delay, len == 0);

	i2c_gpio_send_stop(scl, sda, delay);

	return 0;
}

static int i2c_gpio_xfer(struct udevice *dev, struct i2c_msg *msg, int nmsgs)
{
	struct i2c_gpio_bus *bus = dev_get_priv(dev);
	int ret;

	for (; nmsgs > 0; nmsgs--, msg++) {
		bool next_is_read = nmsgs > 1 && (msg[1].flags & I2C_M_RD);

		if (msg->flags & I2C_M_RD) {
			ret = i2c_gpio_read_data(bus, msg->addr, msg->buf,
						 msg->len);
		} else {
			ret = i2c_gpio_write_data(bus, msg->addr, msg->buf,
						  msg->len, next_is_read);
		}

		if (ret)
			return -EREMOTEIO;
	}

	return 0;
}

static int i2c_gpio_probe(struct udevice *dev, uint chip, uint chip_flags)
{
	struct i2c_gpio_bus *bus = dev_get_priv(dev);
	struct gpio_desc *scl = &bus->gpios[PIN_SCL];
	struct gpio_desc *sda = &bus->gpios[PIN_SDA];
	unsigned int delay = bus->udelay;
	int ret;

	i2c_gpio_send_start(scl, sda, delay);
	ret = i2c_gpio_write_byte(scl, sda, delay, (chip << 1) | 0);
	i2c_gpio_send_stop(scl, sda, delay);

	debug("%s: bus: %d (%s) chip: %x flags: %x ret: %d\n",
	      __func__, dev->seq, dev->name, chip, chip_flags, ret);

	return ret;
}

static int i2c_gpio_set_bus_speed(struct udevice *dev, unsigned int speed_hz)
{
	struct i2c_gpio_bus *bus = dev_get_priv(dev);
	struct gpio_desc *scl = &bus->gpios[PIN_SCL];
	struct gpio_desc *sda = &bus->gpios[PIN_SDA];

	bus->udelay = 1000000 / (speed_hz << 2);

	i2c_gpio_send_reset(scl, sda, bus->udelay);

	return 0;
}

static int i2c_gpio_ofdata_to_platdata(struct udevice *dev)
{
	struct i2c_gpio_bus *bus = dev_get_priv(dev);
	const void *blob = gd->fdt_blob;
	int node = dev_of_offset(dev);
	int ret;

	ret = gpio_request_list_by_name(dev, "gpios", bus->gpios,
					ARRAY_SIZE(bus->gpios), 0);
	if (ret < 0)
		goto error;

	bus->udelay = fdtdec_get_int(blob, node, "i2c-gpio,delay-us",
				     DEFAULT_UDELAY);

	return 0;
error:
	pr_err("Can't get %s gpios! Error: %d", dev->name, ret);
	return ret;
}

static const struct dm_i2c_ops i2c_gpio_ops = {
	.xfer		= i2c_gpio_xfer,
	.probe_chip	= i2c_gpio_probe,
	.set_bus_speed	= i2c_gpio_set_bus_speed,
};

static const struct udevice_id i2c_gpio_ids[] = {
	{ .compatible = "i2c-gpio" },
	{ }
};

U_BOOT_DRIVER(i2c_gpio) = {
	.name	= "i2c-gpio",
	.id	= UCLASS_I2C,
	.of_match = i2c_gpio_ids,
	.ofdata_to_platdata = i2c_gpio_ofdata_to_platdata,
	.priv_auto_alloc_size = sizeof(struct i2c_gpio_bus),
	.ops	= &i2c_gpio_ops,
};
Commit	Line	Data
c54473cb PM	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	{
76382aa2	44	if (bit)
c54473cb	45	dm_gpio_set_dir_flags(sda, GPIOD_IS_IN);
76382aa2	46	else
c54473cb	47	dm_gpio_set_dir_flags(sda, GPIOD_IS_OUT);
c54473cb PM	48	}
	49
	50	static void i2c_gpio_scl_set(struct gpio_desc *scl, int bit)
	51	{
76382aa2 AL	52	ulong flags = GPIOD_IS_OUT;
	53
	54	if (bit)
	55	flags \|= GPIOD_IS_OUT_ACTIVE;
	56	dm_gpio_set_dir_flags(scl, flags);
c54473cb PM	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;
e160f7d4	312	int node = dev_of_offset(dev);
c54473cb PM	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:
9b643e31	325	pr_err("Can't get %s gpios! Error: %d", dev->name, ret);
c54473cb PM	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	};