drivers/i2c/at91_i2c.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Atmel I2C driver.
   4  *
   5  * (C) Copyright 2016 Songjun Wu <songjun.wu@atmel.com>
   6  */
   7
   8 #include <malloc.h>
   9 #include <asm/global_data.h>
  10 #include <asm/io.h>
  11 #include <clk.h>
  12 #include <dm.h>
  13 #include <errno.h>
  14 #include <fdtdec.h>
  15 #include <i2c.h>
  16 #include <linux/bitops.h>
  17 #include <mach/clk.h>
  18
  19 #include "at91_i2c.h"
  20
  21 DECLARE_GLOBAL_DATA_PTR;
  22
  23 #define I2C_TIMEOUT_MS  100
  24
  25 static int at91_wait_for_xfer(struct at91_i2c_bus *bus, u32 status)
  26 {
  27         struct at91_i2c_regs *reg = bus->regs;
  28         ulong start_time = get_timer(0);
  29         u32 sr;
  30
  31         bus->status = 0;
  32
  33         do {
  34                 sr = readl(&reg->sr);
  35                 bus->status |= sr;
  36
  37                 if (sr & TWI_SR_NACK)
  38                         return -EREMOTEIO;
  39                 else if (sr & status)
  40                         return 0;
  41         } while (get_timer(start_time) < I2C_TIMEOUT_MS);
  42
  43         return -ETIMEDOUT;
  44 }
  45
  46 static int at91_i2c_xfer_msg(struct at91_i2c_bus *bus, struct i2c_msg *msg)
  47 {
  48         struct at91_i2c_regs *reg = bus->regs;
  49         bool is_read = msg->flags & I2C_M_RD;
  50         u32 i;
  51         int ret = 0;
  52
  53         /* if there is no message to send/receive, just exit quietly */
  54         if (msg->len == 0)
  55                 return ret;
  56
  57         readl(&reg->sr);
  58         if (is_read) {
  59                 writel(TWI_CR_START, &reg->cr);
  60
  61                 for (i = 0; !ret && i < (msg->len - 1); i++) {
  62                         ret = at91_wait_for_xfer(bus, TWI_SR_RXRDY);
  63                         msg->buf[i] = readl(&reg->rhr);
  64                 }
  65
  66                 if (ret)
  67                         goto error;
  68
  69                 writel(TWI_CR_STOP, &reg->cr);
  70
  71                 ret = at91_wait_for_xfer(bus, TWI_SR_RXRDY);
  72                 if (ret)
  73                         goto error;
  74
  75                 msg->buf[i] = readl(&reg->rhr);
  76
  77         } else {
  78                 writel(msg->buf[0], &reg->thr);
  79                 ret = at91_wait_for_xfer(bus, TWI_SR_TXRDY);
  80
  81                 for (i = 1; !ret && (i < msg->len); i++) {
  82                         writel(msg->buf[i], &reg->thr);
  83                         ret = at91_wait_for_xfer(bus, TWI_SR_TXRDY);
  84                 }
  85
  86                 if (ret)
  87                         goto error;
  88
  89                 writel(TWI_CR_STOP, &reg->cr);
  90         }
  91
  92         if (!ret)
  93                 ret = at91_wait_for_xfer(bus, TWI_SR_TXCOMP);
  94
  95         if (ret)
  96                 goto error;
  97
  98         if (bus->status & (TWI_SR_OVRE | TWI_SR_UNRE | TWI_SR_LOCK)) {
  99                 ret = -EIO;
 100                 goto error;
 101         }
 102
 103         return 0;
 104
 105 error:
 106         if (bus->status & TWI_SR_LOCK)
 107                 writel(TWI_CR_LOCKCLR, &reg->cr);
 108
 109         return ret;
 110 }
 111
 112 static int at91_i2c_xfer(struct udevice *dev, struct i2c_msg *msg, int nmsgs)
 113 {
 114         struct at91_i2c_bus *bus = dev_get_priv(dev);
 115         struct at91_i2c_regs *reg = bus->regs;
 116         struct i2c_msg *m_start = msg;
 117         bool is_read;
 118         u32 int_addr_flag = 0;
 119         int ret = 0;
 120
 121         if (nmsgs == 2) {
 122                 int internal_address = 0;
 123                 int i;
 124
 125                 /* 1st msg is put into the internal address, start with 2nd */
 126                 m_start = &msg[1];
 127
 128                 /* the max length of internal address is 3 bytes */
 129                 if (msg->len > 3)
 130                         return -EFAULT;
 131
 132                 for (i = 0; i < msg->len; ++i) {
 133                         const unsigned addr = msg->buf[msg->len - 1 - i];
 134
 135                         internal_address |= addr << (8 * i);
 136                         int_addr_flag += TWI_MMR_IADRSZ_1;
 137                 }
 138
 139                 writel(internal_address, &reg->iadr);
 140         }
 141
 142         is_read = m_start->flags & I2C_M_RD;
 143
 144         writel((m_start->addr << 16) | int_addr_flag |
 145                (is_read ? TWI_MMR_MREAD : 0), &reg->mmr);
 146
 147         ret = at91_i2c_xfer_msg(bus, m_start);
 148
 149         return ret;
 150 }
 151
 152 /*
 153  * Calculate symmetric clock as stated in datasheet:
 154  * twi_clk = F_MAIN / (2 * (cdiv * (1 << ckdiv) + offset))
 155  */
 156 static void at91_calc_i2c_clock(struct udevice *dev, int i2c_clk)
 157 {
 158         struct at91_i2c_bus *bus = dev_get_priv(dev);
 159         const struct at91_i2c_pdata *pdata = bus->pdata;
 160         int offset = pdata->clk_offset;
 161         int max_ckdiv = pdata->clk_max_div;
 162         int ckdiv, cdiv, div;
 163         unsigned long src_rate;
 164
 165         src_rate = bus->bus_clk_rate;
 166
 167         div = max(0, (int)DIV_ROUND_UP(src_rate, 2 * i2c_clk) - offset);
 168         ckdiv = fls(div >> 8);
 169         cdiv = div >> ckdiv;
 170
 171         if (ckdiv > max_ckdiv) {
 172                 ckdiv = max_ckdiv;
 173                 cdiv = 255;
 174         }
 175
 176         bus->speed = DIV_ROUND_UP(src_rate,
 177                                   (cdiv * (1 << ckdiv) + offset) * 2);
 178
 179         bus->cwgr_val = (ckdiv << 16) | (cdiv << 8) | cdiv;
 180 }
 181
 182 static int at91_i2c_enable_clk(struct udevice *dev)
 183 {
 184         struct at91_i2c_bus *bus = dev_get_priv(dev);
 185         struct clk clk;
 186         ulong clk_rate;
 187         int ret;
 188
 189         ret = clk_get_by_index(dev, 0, &clk);
 190         if (ret)
 191                 return -EINVAL;
 192
 193         ret = clk_enable(&clk);
 194         if (ret)
 195                 return ret;
 196
 197         clk_rate = clk_get_rate(&clk);
 198         if (!clk_rate)
 199                 return -EINVAL;
 200
 201         bus->bus_clk_rate = clk_rate;
 202
 203         return 0;
 204 }
 205
 206 static int at91_i2c_set_bus_speed(struct udevice *dev, unsigned int speed)
 207 {
 208         struct at91_i2c_bus *bus = dev_get_priv(dev);
 209
 210         at91_calc_i2c_clock(dev, speed);
 211
 212         writel(bus->cwgr_val, &bus->regs->cwgr);
 213
 214         return 0;
 215 }
 216
 217 int at91_i2c_get_bus_speed(struct udevice *dev)
 218 {
 219         struct at91_i2c_bus *bus = dev_get_priv(dev);
 220
 221         return bus->speed;
 222 }
 223
 224 static int at91_i2c_of_to_plat(struct udevice *dev)
 225 {
 226         const void *blob = gd->fdt_blob;
 227         struct at91_i2c_bus *bus = dev_get_priv(dev);
 228         int node = dev_of_offset(dev);
 229
 230         bus->regs = dev_read_addr_ptr(dev);
 231         bus->pdata = (struct at91_i2c_pdata *)dev_get_driver_data(dev);
 232         bus->clock_frequency = fdtdec_get_int(blob, node,
 233                                               "clock-frequency", 100000);
 234
 235         return 0;
 236 }
 237
 238 static const struct dm_i2c_ops at91_i2c_ops = {
 239         .xfer           = at91_i2c_xfer,
 240         .set_bus_speed  = at91_i2c_set_bus_speed,
 241         .get_bus_speed  = at91_i2c_get_bus_speed,
 242 };
 243
 244 static int at91_i2c_probe(struct udevice *dev)
 245 {
 246         struct at91_i2c_bus *bus = dev_get_priv(dev);
 247         struct at91_i2c_regs *reg = bus->regs;
 248         int ret;
 249
 250         ret = at91_i2c_enable_clk(dev);
 251         if (ret)
 252                 return ret;
 253
 254         writel(TWI_CR_SWRST, &reg->cr);
 255
 256         at91_calc_i2c_clock(dev, bus->clock_frequency);
 257
 258         writel(bus->cwgr_val, &reg->cwgr);
 259         writel(TWI_CR_MSEN, &reg->cr);
 260         writel(TWI_CR_SVDIS, &reg->cr);
 261
 262         return 0;
 263 }
 264
 265 static const struct at91_i2c_pdata at91rm9200_config = {
 266         .clk_max_div = 5,
 267         .clk_offset = 3,
 268 };
 269
 270 static const struct at91_i2c_pdata at91sam9261_config = {
 271         .clk_max_div = 5,
 272         .clk_offset = 4,
 273 };
 274
 275 static const struct at91_i2c_pdata at91sam9260_config = {
 276         .clk_max_div = 7,
 277         .clk_offset = 4,
 278 };
 279
 280 static const struct at91_i2c_pdata at91sam9g20_config = {
 281         .clk_max_div = 7,
 282         .clk_offset = 4,
 283 };
 284
 285 static const struct at91_i2c_pdata at91sam9g10_config = {
 286         .clk_max_div = 7,
 287         .clk_offset = 4,
 288 };
 289
 290 static const struct at91_i2c_pdata at91sam9x5_config = {
 291         .clk_max_div = 7,
 292         .clk_offset = 4,
 293 };
 294
 295 static const struct at91_i2c_pdata sama5d4_config = {
 296         .clk_max_div = 7,
 297         .clk_offset = 4,
 298 };
 299
 300 static const struct at91_i2c_pdata sama5d2_config = {
 301         .clk_max_div = 7,
 302         .clk_offset = 3,
 303 };
 304
 305 static const struct at91_i2c_pdata sam9x60_config = {
 306         .clk_max_div = 7,
 307         .clk_offset = 3,
 308 };
 309
 310 static const struct udevice_id at91_i2c_ids[] = {
 311 { .compatible = "atmel,at91rm9200-i2c", .data = (long)&at91rm9200_config },
 312 { .compatible = "atmel,at91sam9260-i2c", .data = (long)&at91sam9260_config },
 313 { .compatible = "atmel,at91sam9261-i2c", .data = (long)&at91sam9261_config },
 314 { .compatible = "atmel,at91sam9g20-i2c", .data = (long)&at91sam9g20_config },
 315 { .compatible = "atmel,at91sam9g10-i2c", .data = (long)&at91sam9g10_config },
 316 { .compatible = "atmel,at91sam9x5-i2c", .data = (long)&at91sam9x5_config },
 317 { .compatible = "atmel,sama5d4-i2c", .data = (long)&sama5d4_config },
 318 { .compatible = "atmel,sama5d2-i2c", .data = (long)&sama5d2_config },
 319 { .compatible = "microchip,sam9x60-i2c", .data = (long)&sam9x60_config },
 320 { }
 321 };
 322
 323 U_BOOT_DRIVER(i2c_at91) = {
 324         .name   = "i2c_at91",
 325         .id     = UCLASS_I2C,
 326         .of_match = at91_i2c_ids,
 327         .probe = at91_i2c_probe,
 328         .of_to_plat = at91_i2c_of_to_plat,
 329         .per_child_auto = sizeof(struct dm_i2c_chip),
 330         .priv_auto      = sizeof(struct at91_i2c_bus),
 331         .ops    = &at91_i2c_ops,
 332 };