drivers/i2c/i2c-gpio.c

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