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