mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-09-07 05:13:21 +09:00
![Heiko Schocher](/assets/img/avatar_default.png)
This adds support for clock stretching to the i2c-gpio driver. This is accomplished by switching the GPIO used for the SCL line to an input when it should be driven high, and polling on the SCL line value until it goes high (indicating that the I2C slave is no longer pulling it low). This is enabled by default; for gpios which cannot be configured as inputs, the i2c-gpio,scl-output-only property can be used to fall back to the previous behavior. Signed-off-by: Michael Auchter <michael.auchter@ni.com> Cc: Heiko Schocher <hs@denx.de> Reviewed-by: Heiko Schocher <hs@denx.de>
380 lines
8.3 KiB
C
380 lines
8.3 KiB
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];
|
|
|
|
int (*get_sda)(struct i2c_gpio_bus *bus);
|
|
void (*set_sda)(struct i2c_gpio_bus *bus, int bit);
|
|
void (*set_scl)(struct i2c_gpio_bus *bus, int bit);
|
|
};
|
|
|
|
static int i2c_gpio_sda_get(struct i2c_gpio_bus *bus)
|
|
{
|
|
struct gpio_desc *sda = &bus->gpios[PIN_SDA];
|
|
|
|
return dm_gpio_get_value(sda);
|
|
}
|
|
|
|
static void i2c_gpio_sda_set(struct i2c_gpio_bus *bus, int bit)
|
|
{
|
|
struct gpio_desc *sda = &bus->gpios[PIN_SDA];
|
|
|
|
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 i2c_gpio_bus *bus, int bit)
|
|
{
|
|
struct gpio_desc *scl = &bus->gpios[PIN_SCL];
|
|
int count = 0;
|
|
|
|
if (bit) {
|
|
dm_gpio_set_dir_flags(scl, GPIOD_IS_IN);
|
|
while (!dm_gpio_get_value(scl) && count++ < 100000)
|
|
udelay(1);
|
|
|
|
if (!dm_gpio_get_value(scl))
|
|
pr_err("timeout waiting on slave to release scl\n");
|
|
} else {
|
|
dm_gpio_set_dir_flags(scl, GPIOD_IS_OUT);
|
|
}
|
|
}
|
|
|
|
/* variant for output only gpios which cannot support clock stretching */
|
|
static void i2c_gpio_scl_set_output_only(struct i2c_gpio_bus *bus, int bit)
|
|
{
|
|
struct gpio_desc *scl = &bus->gpios[PIN_SCL];
|
|
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 i2c_gpio_bus *bus, int delay, uchar bit)
|
|
{
|
|
bus->set_scl(bus, 0);
|
|
udelay(delay);
|
|
bus->set_sda(bus, bit);
|
|
udelay(delay);
|
|
bus->set_scl(bus, 1);
|
|
udelay(2 * delay);
|
|
}
|
|
|
|
static int i2c_gpio_read_bit(struct i2c_gpio_bus *bus, int delay)
|
|
{
|
|
int value;
|
|
|
|
bus->set_scl(bus, 1);
|
|
udelay(delay);
|
|
value = bus->get_sda(bus);
|
|
udelay(delay);
|
|
bus->set_scl(bus, 0);
|
|
udelay(2 * delay);
|
|
|
|
return value;
|
|
}
|
|
|
|
/* START: High -> Low on SDA while SCL is High */
|
|
static void i2c_gpio_send_start(struct i2c_gpio_bus *bus, int delay)
|
|
{
|
|
udelay(delay);
|
|
bus->set_sda(bus, 1);
|
|
udelay(delay);
|
|
bus->set_scl(bus, 1);
|
|
udelay(delay);
|
|
bus->set_sda(bus, 0);
|
|
udelay(delay);
|
|
}
|
|
|
|
/* STOP: Low -> High on SDA while SCL is High */
|
|
static void i2c_gpio_send_stop(struct i2c_gpio_bus *bus, int delay)
|
|
{
|
|
bus->set_scl(bus, 0);
|
|
udelay(delay);
|
|
bus->set_sda(bus, 0);
|
|
udelay(delay);
|
|
bus->set_scl(bus, 1);
|
|
udelay(delay);
|
|
bus->set_sda(bus, 1);
|
|
udelay(delay);
|
|
}
|
|
|
|
/* ack should be I2C_ACK or I2C_NOACK */
|
|
static void i2c_gpio_send_ack(struct i2c_gpio_bus *bus, int delay, int ack)
|
|
{
|
|
i2c_gpio_write_bit(bus, delay, ack);
|
|
bus->set_scl(bus, 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 i2c_gpio_bus *bus, int delay)
|
|
{
|
|
int j;
|
|
|
|
for (j = 0; j < 9; j++)
|
|
i2c_gpio_write_bit(bus, delay, 1);
|
|
|
|
i2c_gpio_send_stop(bus, delay);
|
|
}
|
|
|
|
/* Set sda high with low clock, before reading slave data */
|
|
static void i2c_gpio_sda_high(struct i2c_gpio_bus *bus, int delay)
|
|
{
|
|
bus->set_scl(bus, 0);
|
|
udelay(delay);
|
|
bus->set_sda(bus, 1);
|
|
udelay(delay);
|
|
}
|
|
|
|
/* Send 8 bits and look for an acknowledgement */
|
|
static int i2c_gpio_write_byte(struct i2c_gpio_bus *bus, int delay, uchar data)
|
|
{
|
|
int j;
|
|
int nack;
|
|
|
|
for (j = 0; j < 8; j++) {
|
|
i2c_gpio_write_bit(bus, delay, data & 0x80);
|
|
data <<= 1;
|
|
}
|
|
|
|
udelay(delay);
|
|
|
|
/* Look for an <ACK>(negative logic) and return it */
|
|
i2c_gpio_sda_high(bus, delay);
|
|
nack = i2c_gpio_read_bit(bus, 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 i2c_gpio_bus *bus, int delay, int ack)
|
|
{
|
|
int data;
|
|
int j;
|
|
|
|
i2c_gpio_sda_high(bus, delay);
|
|
data = 0;
|
|
for (j = 0; j < 8; j++) {
|
|
data <<= 1;
|
|
data |= i2c_gpio_read_bit(bus, delay);
|
|
}
|
|
i2c_gpio_send_ack(bus, delay, ack);
|
|
|
|
return data;
|
|
}
|
|
|
|
/* send start and the slave chip address */
|
|
int i2c_send_slave_addr(struct i2c_gpio_bus *bus, int delay, uchar chip)
|
|
{
|
|
i2c_gpio_send_start(bus, delay);
|
|
|
|
if (i2c_gpio_write_byte(bus, delay, chip)) {
|
|
i2c_gpio_send_stop(bus, 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)
|
|
{
|
|
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(bus, delay, chip << 1)) {
|
|
debug("i2c_write, no chip responded %02X\n", chip);
|
|
return -EIO;
|
|
}
|
|
|
|
while (len-- > 0) {
|
|
if (i2c_gpio_write_byte(bus, delay, *buffer++))
|
|
failures++;
|
|
}
|
|
|
|
if (!end_with_repeated_start) {
|
|
i2c_gpio_send_stop(bus, delay);
|
|
return failures;
|
|
}
|
|
|
|
if (i2c_send_slave_addr(bus, 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)
|
|
{
|
|
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(bus, delay, len == 0);
|
|
|
|
i2c_gpio_send_stop(bus, 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);
|
|
unsigned int delay = bus->udelay;
|
|
int ret;
|
|
|
|
i2c_gpio_send_start(bus, delay);
|
|
ret = i2c_gpio_write_byte(bus, delay, (chip << 1) | 0);
|
|
i2c_gpio_send_stop(bus, 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);
|
|
|
|
bus->udelay = 1000000 / (speed_hz << 2);
|
|
|
|
i2c_gpio_send_reset(bus, bus->udelay);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int i2c_gpio_drv_probe(struct udevice *dev)
|
|
{
|
|
if (dev_read_bool(dev, "i2c-gpio,deblock")) {
|
|
/* @200kHz 9 clocks = 44us, 62us is ok */
|
|
const unsigned int DELAY_ABORT_SEQ = 62;
|
|
struct i2c_gpio_bus *bus = dev_get_priv(dev);
|
|
|
|
return i2c_deblock_gpio_loop(&bus->gpios[PIN_SDA],
|
|
&bus->gpios[PIN_SCL],
|
|
16, 5, DELAY_ABORT_SEQ);
|
|
}
|
|
|
|
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);
|
|
|
|
bus->get_sda = i2c_gpio_sda_get;
|
|
bus->set_sda = i2c_gpio_sda_set;
|
|
if (fdtdec_get_bool(blob, node, "i2c-gpio,scl-output-only"))
|
|
bus->set_scl = i2c_gpio_scl_set_output_only;
|
|
else
|
|
bus->set_scl = i2c_gpio_scl_set;
|
|
|
|
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,
|
|
.probe = i2c_gpio_drv_probe,
|
|
.ofdata_to_platdata = i2c_gpio_ofdata_to_platdata,
|
|
.priv_auto_alloc_size = sizeof(struct i2c_gpio_bus),
|
|
.ops = &i2c_gpio_ops,
|
|
};
|