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 };