drivers/i2c/rk_i2c.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2015 Google, Inc
   4  *
   5  * (C) Copyright 2008-2014 Rockchip Electronics
   6  * Peter, Software Engineering, <superpeter.cai@gmail.com>.
   7  */
   8
   9 #include <common.h>
  10 #include <clk.h>
  11 #include <dm.h>
  12 #include <errno.h>
  13 #include <i2c.h>
  14 #include <asm/io.h>
  15 #include <asm/arch-rockchip/clock.h>
  16 #include <asm/arch-rockchip/i2c.h>
  17 #include <asm/arch-rockchip/periph.h>
  18 #include <dm/pinctrl.h>
  19 #include <linux/sizes.h>
  20
  21 /* i2c timerout */
  22 #define I2C_TIMEOUT_MS          100
  23 #define I2C_RETRY_COUNT         3
  24
  25 /* rk i2c fifo max transfer bytes */
  26 #define RK_I2C_FIFO_SIZE        32
  27
  28 struct rk_i2c {
  29         struct clk clk;
  30         struct i2c_regs *regs;
  31         unsigned int speed;
  32 };
  33
  34 enum {
  35         RK_I2C_LEGACY,
  36         RK_I2C_NEW,
  37 };
  38
  39 /**
  40  * @controller_type: i2c controller type
  41  */
  42 struct rk_i2c_soc_data {
  43         int controller_type;
  44 };
  45
  46 static inline void rk_i2c_get_div(int div, int *divh, int *divl)
  47 {
  48         *divl = div / 2;
  49         if (div % 2 == 0)
  50                 *divh = div / 2;
  51         else
  52                 *divh = DIV_ROUND_UP(div, 2);
  53 }
  54
  55 /*
  56  * SCL Divisor = 8 * (CLKDIVL+1 + CLKDIVH+1)
  57  * SCL = PCLK / SCLK Divisor
  58  * i2c_rate = PCLK
  59  */
  60 static void rk_i2c_set_clk(struct rk_i2c *i2c, uint32_t scl_rate)
  61 {
  62         uint32_t i2c_rate;
  63         int div, divl, divh;
  64
  65         /* First get i2c rate from pclk */
  66         i2c_rate = clk_get_rate(&i2c->clk);
  67
  68         div = DIV_ROUND_UP(i2c_rate, scl_rate * 8) - 2;
  69         divh = 0;
  70         divl = 0;
  71         if (div >= 0)
  72                 rk_i2c_get_div(div, &divh, &divl);
  73         writel(I2C_CLKDIV_VAL(divl, divh), &i2c->regs->clkdiv);
  74
  75         debug("rk_i2c_set_clk: i2c rate = %d, scl rate = %d\n", i2c_rate,
  76               scl_rate);
  77         debug("set i2c clk div = %d, divh = %d, divl = %d\n", div, divh, divl);
  78         debug("set clk(I2C_CLKDIV: 0x%08x)\n", readl(&i2c->regs->clkdiv));
  79 }
  80
  81 static void rk_i2c_show_regs(struct i2c_regs *regs)
  82 {
  83 #ifdef DEBUG
  84         uint i;
  85
  86         debug("i2c_con: 0x%08x\n", readl(&regs->con));
  87         debug("i2c_clkdiv: 0x%08x\n", readl(&regs->clkdiv));
  88         debug("i2c_mrxaddr: 0x%08x\n", readl(&regs->mrxaddr));
  89         debug("i2c_mrxraddR: 0x%08x\n", readl(&regs->mrxraddr));
  90         debug("i2c_mtxcnt: 0x%08x\n", readl(&regs->mtxcnt));
  91         debug("i2c_mrxcnt: 0x%08x\n", readl(&regs->mrxcnt));
  92         debug("i2c_ien: 0x%08x\n", readl(&regs->ien));
  93         debug("i2c_ipd: 0x%08x\n", readl(&regs->ipd));
  94         debug("i2c_fcnt: 0x%08x\n", readl(&regs->fcnt));
  95         for (i = 0; i < 8; i++)
  96                 debug("i2c_txdata%d: 0x%08x\n", i, readl(&regs->txdata[i]));
  97         for (i = 0; i < 8; i++)
  98                 debug("i2c_rxdata%d: 0x%08x\n", i, readl(&regs->rxdata[i]));
  99 #endif
 100 }
 101
 102 static int rk_i2c_send_start_bit(struct rk_i2c *i2c)
 103 {
 104         struct i2c_regs *regs = i2c->regs;
 105         ulong start;
 106
 107         debug("I2c Send Start bit.\n");
 108         writel(I2C_IPD_ALL_CLEAN, &regs->ipd);
 109
 110         writel(I2C_CON_EN | I2C_CON_START, &regs->con);
 111         writel(I2C_STARTIEN, &regs->ien);
 112
 113         start = get_timer(0);
 114         while (1) {
 115                 if (readl(&regs->ipd) & I2C_STARTIPD) {
 116                         writel(I2C_STARTIPD, &regs->ipd);
 117                         break;
 118                 }
 119                 if (get_timer(start) > I2C_TIMEOUT_MS) {
 120                         debug("I2C Send Start Bit Timeout\n");
 121                         rk_i2c_show_regs(regs);
 122                         return -ETIMEDOUT;
 123                 }
 124                 udelay(1);
 125         }
 126
 127         return 0;
 128 }
 129
 130 static int rk_i2c_send_stop_bit(struct rk_i2c *i2c)
 131 {
 132         struct i2c_regs *regs = i2c->regs;
 133         ulong start;
 134
 135         debug("I2c Send Stop bit.\n");
 136         writel(I2C_IPD_ALL_CLEAN, &regs->ipd);
 137
 138         writel(I2C_CON_EN | I2C_CON_STOP, &regs->con);
 139         writel(I2C_CON_STOP, &regs->ien);
 140
 141         start = get_timer(0);
 142         while (1) {
 143                 if (readl(&regs->ipd) & I2C_STOPIPD) {
 144                         writel(I2C_STOPIPD, &regs->ipd);
 145                         break;
 146                 }
 147                 if (get_timer(start) > I2C_TIMEOUT_MS) {
 148                         debug("I2C Send Start Bit Timeout\n");
 149                         rk_i2c_show_regs(regs);
 150                         return -ETIMEDOUT;
 151                 }
 152                 udelay(1);
 153         }
 154
 155         return 0;
 156 }
 157
 158 static inline void rk_i2c_disable(struct rk_i2c *i2c)
 159 {
 160         writel(0, &i2c->regs->con);
 161 }
 162
 163 static int rk_i2c_read(struct rk_i2c *i2c, uchar chip, uint reg, uint r_len,
 164                        uchar *buf, uint b_len)
 165 {
 166         struct i2c_regs *regs = i2c->regs;
 167         uchar *pbuf = buf;
 168         uint bytes_remain_len = b_len;
 169         uint bytes_xferred = 0;
 170         uint words_xferred = 0;
 171         ulong start;
 172         uint con = 0;
 173         uint rxdata;
 174         uint i, j;
 175         int err;
 176         bool snd_chunk = false;
 177
 178         debug("rk_i2c_read: chip = %d, reg = %d, r_len = %d, b_len = %d\n",
 179               chip, reg, r_len, b_len);
 180
 181         err = rk_i2c_send_start_bit(i2c);
 182         if (err)
 183                 return err;
 184
 185         writel(I2C_MRXADDR_SET(1, chip << 1 | 1), &regs->mrxaddr);
 186         if (r_len == 0) {
 187                 writel(0, &regs->mrxraddr);
 188         } else if (r_len < 4) {
 189                 writel(I2C_MRXRADDR_SET(r_len, reg), &regs->mrxraddr);
 190         } else {
 191                 debug("I2C Read: addr len %d not supported\n", r_len);
 192                 return -EIO;
 193         }
 194
 195         while (bytes_remain_len) {
 196                 if (bytes_remain_len > RK_I2C_FIFO_SIZE) {
 197                         con = I2C_CON_EN;
 198                         bytes_xferred = 32;
 199                 } else {
 200                         /*
 201                          * The hw can read up to 32 bytes at a time. If we need
 202                          * more than one chunk, send an ACK after the last byte.
 203                          */
 204                         con = I2C_CON_EN | I2C_CON_LASTACK;
 205                         bytes_xferred = bytes_remain_len;
 206                 }
 207                 words_xferred = DIV_ROUND_UP(bytes_xferred, 4);
 208
 209                 /*
 210                  * make sure we are in plain RX mode if we read a second chunk
 211                  */
 212                 if (snd_chunk)
 213                         con |= I2C_CON_MOD(I2C_MODE_RX);
 214                 else
 215                         con |= I2C_CON_MOD(I2C_MODE_TRX);
 216
 217                 writel(con, &regs->con);
 218                 writel(bytes_xferred, &regs->mrxcnt);
 219                 writel(I2C_MBRFIEN | I2C_NAKRCVIEN, &regs->ien);
 220
 221                 start = get_timer(0);
 222                 while (1) {
 223                         if (readl(&regs->ipd) & I2C_NAKRCVIPD) {
 224                                 writel(I2C_NAKRCVIPD, &regs->ipd);
 225                                 err = -EREMOTEIO;
 226                         }
 227                         if (readl(&regs->ipd) & I2C_MBRFIPD) {
 228                                 writel(I2C_MBRFIPD, &regs->ipd);
 229                                 break;
 230                         }
 231                         if (get_timer(start) > I2C_TIMEOUT_MS) {
 232                                 debug("I2C Read Data Timeout\n");
 233                                 err =  -ETIMEDOUT;
 234                                 rk_i2c_show_regs(regs);
 235                                 goto i2c_exit;
 236                         }
 237                         udelay(1);
 238                 }
 239
 240                 for (i = 0; i < words_xferred; i++) {
 241                         rxdata = readl(&regs->rxdata[i]);
 242                         debug("I2c Read RXDATA[%d] = 0x%x\n", i, rxdata);
 243                         for (j = 0; j < 4; j++) {
 244                                 if ((i * 4 + j) == bytes_xferred)
 245                                         break;
 246                                 *pbuf++ = (rxdata >> (j * 8)) & 0xff;
 247                         }
 248                 }
 249
 250                 bytes_remain_len -= bytes_xferred;
 251                 snd_chunk = true;
 252                 debug("I2C Read bytes_remain_len %d\n", bytes_remain_len);
 253         }
 254
 255 i2c_exit:
 256         rk_i2c_disable(i2c);
 257
 258         return err;
 259 }
 260
 261 static int rk_i2c_write(struct rk_i2c *i2c, uchar chip, uint reg, uint r_len,
 262                         uchar *buf, uint b_len)
 263 {
 264         struct i2c_regs *regs = i2c->regs;
 265         int err;
 266         uchar *pbuf = buf;
 267         uint bytes_remain_len = b_len + r_len + 1;
 268         uint bytes_xferred = 0;
 269         uint words_xferred = 0;
 270         ulong start;
 271         uint txdata;
 272         uint i, j;
 273
 274         debug("rk_i2c_write: chip = %d, reg = %d, r_len = %d, b_len = %d\n",
 275               chip, reg, r_len, b_len);
 276         err = rk_i2c_send_start_bit(i2c);
 277         if (err)
 278                 return err;
 279
 280         while (bytes_remain_len) {
 281                 if (bytes_remain_len > RK_I2C_FIFO_SIZE)
 282                         bytes_xferred = RK_I2C_FIFO_SIZE;
 283                 else
 284                         bytes_xferred = bytes_remain_len;
 285                 words_xferred = DIV_ROUND_UP(bytes_xferred, 4);
 286
 287                 for (i = 0; i < words_xferred; i++) {
 288                         txdata = 0;
 289                         for (j = 0; j < 4; j++) {
 290                                 if ((i * 4 + j) == bytes_xferred)
 291                                         break;
 292
 293                                 if (i == 0 && j == 0 && pbuf == buf) {
 294                                         txdata |= (chip << 1);
 295                                 } else if (i == 0 && j <= r_len && pbuf == buf) {
 296                                         txdata |= (reg &
 297                                                 (0xff << ((j - 1) * 8))) << 8;
 298                                 } else {
 299                                         txdata |= (*pbuf++)<<(j * 8);
 300                                 }
 301                         }
 302                         writel(txdata, &regs->txdata[i]);
 303                         debug("I2c Write TXDATA[%d] = 0x%08x\n", i, txdata);
 304                 }
 305
 306                 writel(I2C_CON_EN | I2C_CON_MOD(I2C_MODE_TX), &regs->con);
 307                 writel(bytes_xferred, &regs->mtxcnt);
 308                 writel(I2C_MBTFIEN | I2C_NAKRCVIEN, &regs->ien);
 309
 310                 start = get_timer(0);
 311                 while (1) {
 312                         if (readl(&regs->ipd) & I2C_NAKRCVIPD) {
 313                                 writel(I2C_NAKRCVIPD, &regs->ipd);
 314                                 err = -EREMOTEIO;
 315                         }
 316                         if (readl(&regs->ipd) & I2C_MBTFIPD) {
 317                                 writel(I2C_MBTFIPD, &regs->ipd);
 318                                 break;
 319                         }
 320                         if (get_timer(start) > I2C_TIMEOUT_MS) {
 321                                 debug("I2C Write Data Timeout\n");
 322                                 err =  -ETIMEDOUT;
 323                                 rk_i2c_show_regs(regs);
 324                                 goto i2c_exit;
 325                         }
 326                         udelay(1);
 327                 }
 328
 329                 bytes_remain_len -= bytes_xferred;
 330                 debug("I2C Write bytes_remain_len %d\n", bytes_remain_len);
 331         }
 332
 333 i2c_exit:
 334         rk_i2c_disable(i2c);
 335
 336         return err;
 337 }
 338
 339 static int rockchip_i2c_xfer(struct udevice *bus, struct i2c_msg *msg,
 340                              int nmsgs)
 341 {
 342         struct rk_i2c *i2c = dev_get_priv(bus);
 343         int ret;
 344
 345         debug("i2c_xfer: %d messages\n", nmsgs);
 346         for (; nmsgs > 0; nmsgs--, msg++) {
 347                 debug("i2c_xfer: chip=0x%x, len=0x%x\n", msg->addr, msg->len);
 348                 if (msg->flags & I2C_M_RD) {
 349                         ret = rk_i2c_read(i2c, msg->addr, 0, 0, msg->buf,
 350                                           msg->len);
 351                 } else {
 352                         ret = rk_i2c_write(i2c, msg->addr, 0, 0, msg->buf,
 353                                            msg->len);
 354                 }
 355                 if (ret) {
 356                         debug("i2c_write: error sending\n");
 357                         return -EREMOTEIO;
 358                 }
 359         }
 360
 361         rk_i2c_send_stop_bit(i2c);
 362         rk_i2c_disable(i2c);
 363
 364         return 0;
 365 }
 366
 367 int rockchip_i2c_set_bus_speed(struct udevice *bus, unsigned int speed)
 368 {
 369         struct rk_i2c *i2c = dev_get_priv(bus);
 370
 371         rk_i2c_set_clk(i2c, speed);
 372
 373         return 0;
 374 }
 375
 376 static int rockchip_i2c_ofdata_to_platdata(struct udevice *bus)
 377 {
 378         struct rk_i2c *priv = dev_get_priv(bus);
 379         int ret;
 380
 381         ret = clk_get_by_index(bus, 0, &priv->clk);
 382         if (ret < 0) {
 383                 debug("%s: Could not get clock for %s: %d\n", __func__,
 384                       bus->name, ret);
 385                 return ret;
 386         }
 387
 388         return 0;
 389 }
 390
 391 static int rockchip_i2c_probe(struct udevice *bus)
 392 {
 393         struct rk_i2c *priv = dev_get_priv(bus);
 394         struct rk_i2c_soc_data *soc_data;
 395         struct udevice *pinctrl;
 396         int bus_nr;
 397         int ret;
 398
 399         priv->regs = dev_read_addr_ptr(bus);
 400
 401         soc_data = (struct rk_i2c_soc_data*)dev_get_driver_data(bus);
 402
 403         if (soc_data->controller_type == RK_I2C_LEGACY) {
 404                 ret = dev_read_alias_seq(bus, &bus_nr);
 405                 if (ret < 0) {
 406                         debug("%s: Could not get alias for %s: %d\n",
 407                          __func__, bus->name, ret);
 408                         return ret;
 409                 }
 410
 411                 ret = uclass_get_device(UCLASS_PINCTRL, 0, &pinctrl);
 412                 if (ret) {
 413                         debug("%s: Cannot find pinctrl device\n", __func__);
 414                         return ret;
 415                 }
 416
 417                 /* pinctrl will switch I2C to new type */
 418                 ret = pinctrl_request_noflags(pinctrl, PERIPH_ID_I2C0 + bus_nr);
 419                 if (ret) {
 420                         debug("%s: Failed to switch I2C to new type %s: %d\n",
 421                                 __func__, bus->name, ret);
 422                         return ret;
 423                 }
 424         }
 425
 426         return 0;
 427 }
 428
 429 static const struct dm_i2c_ops rockchip_i2c_ops = {
 430         .xfer           = rockchip_i2c_xfer,
 431         .set_bus_speed  = rockchip_i2c_set_bus_speed,
 432 };
 433
 434 static const struct rk_i2c_soc_data rk3066_soc_data = {
 435         .controller_type = RK_I2C_LEGACY,
 436 };
 437
 438 static const struct rk_i2c_soc_data rk3188_soc_data = {
 439         .controller_type = RK_I2C_LEGACY,
 440 };
 441
 442 static const struct rk_i2c_soc_data rk3228_soc_data = {
 443         .controller_type = RK_I2C_NEW,
 444 };
 445
 446 static const struct rk_i2c_soc_data rk3288_soc_data = {
 447         .controller_type = RK_I2C_NEW,
 448 };
 449
 450 static const struct rk_i2c_soc_data rk3328_soc_data = {
 451         .controller_type = RK_I2C_NEW,
 452 };
 453
 454 static const struct rk_i2c_soc_data rk3399_soc_data = {
 455         .controller_type = RK_I2C_NEW,
 456 };
 457
 458 static const struct udevice_id rockchip_i2c_ids[] = {
 459         {
 460                 .compatible = "rockchip,rk3066-i2c",
 461                 .data = (ulong)&rk3066_soc_data,
 462         },
 463         {
 464                 .compatible = "rockchip,rk3188-i2c",
 465                 .data = (ulong)&rk3188_soc_data,
 466         },
 467         {
 468                 .compatible = "rockchip,rk3228-i2c",
 469                 .data = (ulong)&rk3228_soc_data,
 470         },
 471         {
 472                 .compatible = "rockchip,rk3288-i2c",
 473                 .data = (ulong)&rk3288_soc_data,
 474         },
 475         {
 476                 .compatible = "rockchip,rk3328-i2c",
 477                 .data = (ulong)&rk3328_soc_data,
 478         },
 479         {
 480                 .compatible = "rockchip,rk3399-i2c",
 481                 .data = (ulong)&rk3399_soc_data,
 482         },
 483         { }
 484 };
 485
 486 U_BOOT_DRIVER(i2c_rockchip) = {
 487         .name   = "i2c_rockchip",
 488         .id     = UCLASS_I2C,
 489         .of_match = rockchip_i2c_ids,
 490         .ofdata_to_platdata = rockchip_i2c_ofdata_to_platdata,
 491         .probe  = rockchip_i2c_probe,
 492         .priv_auto_alloc_size = sizeof(struct rk_i2c),
 493         .ops    = &rockchip_i2c_ops,
 494 };