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