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