drivers/i2c/busses/i2c-uniphier.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2015 Masahiro Yamada <yamada.masahiro@socionext.com>
   4  */
   5
   6 #include <linux/clk.h>
   7 #include <linux/i2c.h>
   8 #include <linux/interrupt.h>
   9 #include <linux/io.h>
  10 #include <linux/module.h>
  11 #include <linux/platform_device.h>
  12
  13 #define UNIPHIER_I2C_DTRM       0x00    /* TX register */
  14 #define     UNIPHIER_I2C_DTRM_IRQEN     BIT(11) /* enable interrupt */
  15 #define     UNIPHIER_I2C_DTRM_STA       BIT(10) /* start condition */
  16 #define     UNIPHIER_I2C_DTRM_STO       BIT(9)  /* stop condition */
  17 #define     UNIPHIER_I2C_DTRM_NACK      BIT(8)  /* do not return ACK */
  18 #define     UNIPHIER_I2C_DTRM_RD        BIT(0)  /* read transaction */
  19 #define UNIPHIER_I2C_DREC       0x04    /* RX register */
  20 #define     UNIPHIER_I2C_DREC_MST       BIT(14) /* 1 = master, 0 = slave */
  21 #define     UNIPHIER_I2C_DREC_TX        BIT(13) /* 1 = transmit, 0 = receive */
  22 #define     UNIPHIER_I2C_DREC_STS       BIT(12) /* stop condition detected */
  23 #define     UNIPHIER_I2C_DREC_LRB       BIT(11) /* no ACK */
  24 #define     UNIPHIER_I2C_DREC_LAB       BIT(9)  /* arbitration lost */
  25 #define     UNIPHIER_I2C_DREC_BBN       BIT(8)  /* bus not busy */
  26 #define UNIPHIER_I2C_MYAD       0x08    /* slave address */
  27 #define UNIPHIER_I2C_CLK        0x0c    /* clock frequency control */
  28 #define UNIPHIER_I2C_BRST       0x10    /* bus reset */
  29 #define     UNIPHIER_I2C_BRST_FOEN      BIT(1)  /* normal operation */
  30 #define     UNIPHIER_I2C_BRST_RSCL      BIT(0)  /* release SCL */
  31 #define UNIPHIER_I2C_HOLD       0x14    /* hold time control */
  32 #define UNIPHIER_I2C_BSTS       0x18    /* bus status monitor */
  33 #define     UNIPHIER_I2C_BSTS_SDA       BIT(1)  /* readback of SDA line */
  34 #define     UNIPHIER_I2C_BSTS_SCL       BIT(0)  /* readback of SCL line */
  35 #define UNIPHIER_I2C_NOISE      0x1c    /* noise filter control */
  36 #define UNIPHIER_I2C_SETUP      0x20    /* setup time control */
  37
  38 #define UNIPHIER_I2C_DEFAULT_SPEED      100000
  39 #define UNIPHIER_I2C_MAX_SPEED          400000
  40
  41 struct uniphier_i2c_priv {
  42         struct completion comp;
  43         struct i2c_adapter adap;
  44         void __iomem *membase;
  45         struct clk *clk;
  46         unsigned int busy_cnt;
  47         unsigned int clk_cycle;
  48 };
  49
  50 static irqreturn_t uniphier_i2c_interrupt(int irq, void *dev_id)
  51 {
  52         struct uniphier_i2c_priv *priv = dev_id;
  53
  54         /*
  55          * This hardware uses edge triggered interrupt.  Do not touch the
  56          * hardware registers in this handler to make sure to catch the next
  57          * interrupt edge.  Just send a complete signal and return.
  58          */
  59         complete(&priv->comp);
  60
  61         return IRQ_HANDLED;
  62 }
  63
  64 static int uniphier_i2c_xfer_byte(struct i2c_adapter *adap, u32 txdata,
  65                                   u32 *rxdatap)
  66 {
  67         struct uniphier_i2c_priv *priv = i2c_get_adapdata(adap);
  68         unsigned long time_left;
  69         u32 rxdata;
  70
  71         reinit_completion(&priv->comp);
  72
  73         txdata |= UNIPHIER_I2C_DTRM_IRQEN;
  74         dev_dbg(&adap->dev, "write data: 0x%04x\n", txdata);
  75         writel(txdata, priv->membase + UNIPHIER_I2C_DTRM);
  76
  77         time_left = wait_for_completion_timeout(&priv->comp, adap->timeout);
  78         if (unlikely(!time_left)) {
  79                 dev_err(&adap->dev, "transaction timeout\n");
  80                 return -ETIMEDOUT;
  81         }
  82
  83         rxdata = readl(priv->membase + UNIPHIER_I2C_DREC);
  84         dev_dbg(&adap->dev, "read data: 0x%04x\n", rxdata);
  85
  86         if (rxdatap)
  87                 *rxdatap = rxdata;
  88
  89         return 0;
  90 }
  91
  92 static int uniphier_i2c_send_byte(struct i2c_adapter *adap, u32 txdata)
  93 {
  94         u32 rxdata;
  95         int ret;
  96
  97         ret = uniphier_i2c_xfer_byte(adap, txdata, &rxdata);
  98         if (ret)
  99                 return ret;
 100
 101         if (unlikely(rxdata & UNIPHIER_I2C_DREC_LAB)) {
 102                 dev_dbg(&adap->dev, "arbitration lost\n");
 103                 return -EAGAIN;
 104         }
 105         if (unlikely(rxdata & UNIPHIER_I2C_DREC_LRB)) {
 106                 dev_dbg(&adap->dev, "could not get ACK\n");
 107                 return -ENXIO;
 108         }
 109
 110         return 0;
 111 }
 112
 113 static int uniphier_i2c_tx(struct i2c_adapter *adap, u16 addr, u16 len,
 114                            const u8 *buf)
 115 {
 116         int ret;
 117
 118         dev_dbg(&adap->dev, "start condition\n");
 119         ret = uniphier_i2c_send_byte(adap, addr << 1 |
 120                                      UNIPHIER_I2C_DTRM_STA |
 121                                      UNIPHIER_I2C_DTRM_NACK);
 122         if (ret)
 123                 return ret;
 124
 125         while (len--) {
 126                 ret = uniphier_i2c_send_byte(adap,
 127                                              UNIPHIER_I2C_DTRM_NACK | *buf++);
 128                 if (ret)
 129                         return ret;
 130         }
 131
 132         return 0;
 133 }
 134
 135 static int uniphier_i2c_rx(struct i2c_adapter *adap, u16 addr, u16 len,
 136                            u8 *buf)
 137 {
 138         int ret;
 139
 140         dev_dbg(&adap->dev, "start condition\n");
 141         ret = uniphier_i2c_send_byte(adap, addr << 1 |
 142                                      UNIPHIER_I2C_DTRM_STA |
 143                                      UNIPHIER_I2C_DTRM_NACK |
 144                                      UNIPHIER_I2C_DTRM_RD);
 145         if (ret)
 146                 return ret;
 147
 148         while (len--) {
 149                 u32 rxdata;
 150
 151                 ret = uniphier_i2c_xfer_byte(adap,
 152                                              len ? 0 : UNIPHIER_I2C_DTRM_NACK,
 153                                              &rxdata);
 154                 if (ret)
 155                         return ret;
 156                 *buf++ = rxdata;
 157         }
 158
 159         return 0;
 160 }
 161
 162 static int uniphier_i2c_stop(struct i2c_adapter *adap)
 163 {
 164         dev_dbg(&adap->dev, "stop condition\n");
 165         return uniphier_i2c_send_byte(adap, UNIPHIER_I2C_DTRM_STO |
 166                                       UNIPHIER_I2C_DTRM_NACK);
 167 }
 168
 169 static int uniphier_i2c_master_xfer_one(struct i2c_adapter *adap,
 170                                         struct i2c_msg *msg, bool stop)
 171 {
 172         bool is_read = msg->flags & I2C_M_RD;
 173         bool recovery = false;
 174         int ret;
 175
 176         dev_dbg(&adap->dev, "%s: addr=0x%02x, len=%d, stop=%d\n",
 177                 is_read ? "receive" : "transmit", msg->addr, msg->len, stop);
 178
 179         if (is_read)
 180                 ret = uniphier_i2c_rx(adap, msg->addr, msg->len, msg->buf);
 181         else
 182                 ret = uniphier_i2c_tx(adap, msg->addr, msg->len, msg->buf);
 183
 184         if (ret == -EAGAIN) /* could not acquire bus. bail out without STOP */
 185                 return ret;
 186
 187         if (ret == -ETIMEDOUT) {
 188                 /* This error is fatal.  Needs recovery. */
 189                 stop = false;
 190                 recovery = true;
 191         }
 192
 193         if (stop) {
 194                 int ret2 = uniphier_i2c_stop(adap);
 195
 196                 if (ret2) {
 197                         /* Failed to issue STOP.  The bus needs recovery. */
 198                         recovery = true;
 199                         ret = ret ?: ret2;
 200                 }
 201         }
 202
 203         if (recovery)
 204                 i2c_recover_bus(adap);
 205
 206         return ret;
 207 }
 208
 209 static int uniphier_i2c_check_bus_busy(struct i2c_adapter *adap)
 210 {
 211         struct uniphier_i2c_priv *priv = i2c_get_adapdata(adap);
 212
 213         if (!(readl(priv->membase + UNIPHIER_I2C_DREC) &
 214                                                 UNIPHIER_I2C_DREC_BBN)) {
 215                 if (priv->busy_cnt++ > 3) {
 216                         /*
 217                          * If bus busy continues too long, it is probably
 218                          * in a wrong state.  Try bus recovery.
 219                          */
 220                         i2c_recover_bus(adap);
 221                         priv->busy_cnt = 0;
 222                 }
 223
 224                 return -EAGAIN;
 225         }
 226
 227         priv->busy_cnt = 0;
 228         return 0;
 229 }
 230
 231 static int uniphier_i2c_master_xfer(struct i2c_adapter *adap,
 232                                     struct i2c_msg *msgs, int num)
 233 {
 234         struct i2c_msg *msg, *emsg = msgs + num;
 235         int ret;
 236
 237         ret = uniphier_i2c_check_bus_busy(adap);
 238         if (ret)
 239                 return ret;
 240
 241         for (msg = msgs; msg < emsg; msg++) {
 242                 /* Emit STOP if it is the last message or I2C_M_STOP is set. */
 243                 bool stop = (msg + 1 == emsg) || (msg->flags & I2C_M_STOP);
 244
 245                 ret = uniphier_i2c_master_xfer_one(adap, msg, stop);
 246                 if (ret)
 247                         return ret;
 248         }
 249
 250         return num;
 251 }
 252
 253 static u32 uniphier_i2c_functionality(struct i2c_adapter *adap)
 254 {
 255         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 256 }
 257
 258 static const struct i2c_algorithm uniphier_i2c_algo = {
 259         .master_xfer = uniphier_i2c_master_xfer,
 260         .functionality = uniphier_i2c_functionality,
 261 };
 262
 263 static void uniphier_i2c_reset(struct uniphier_i2c_priv *priv, bool reset_on)
 264 {
 265         u32 val = UNIPHIER_I2C_BRST_RSCL;
 266
 267         val |= reset_on ? 0 : UNIPHIER_I2C_BRST_FOEN;
 268         writel(val, priv->membase + UNIPHIER_I2C_BRST);
 269 }
 270
 271 static int uniphier_i2c_get_scl(struct i2c_adapter *adap)
 272 {
 273         struct uniphier_i2c_priv *priv = i2c_get_adapdata(adap);
 274
 275         return !!(readl(priv->membase + UNIPHIER_I2C_BSTS) &
 276                                                         UNIPHIER_I2C_BSTS_SCL);
 277 }
 278
 279 static void uniphier_i2c_set_scl(struct i2c_adapter *adap, int val)
 280 {
 281         struct uniphier_i2c_priv *priv = i2c_get_adapdata(adap);
 282
 283         writel(val ? UNIPHIER_I2C_BRST_RSCL : 0,
 284                priv->membase + UNIPHIER_I2C_BRST);
 285 }
 286
 287 static int uniphier_i2c_get_sda(struct i2c_adapter *adap)
 288 {
 289         struct uniphier_i2c_priv *priv = i2c_get_adapdata(adap);
 290
 291         return !!(readl(priv->membase + UNIPHIER_I2C_BSTS) &
 292                                                         UNIPHIER_I2C_BSTS_SDA);
 293 }
 294
 295 static void uniphier_i2c_unprepare_recovery(struct i2c_adapter *adap)
 296 {
 297         uniphier_i2c_reset(i2c_get_adapdata(adap), false);
 298 }
 299
 300 static struct i2c_bus_recovery_info uniphier_i2c_bus_recovery_info = {
 301         .recover_bus = i2c_generic_scl_recovery,
 302         .get_scl = uniphier_i2c_get_scl,
 303         .set_scl = uniphier_i2c_set_scl,
 304         .get_sda = uniphier_i2c_get_sda,
 305         .unprepare_recovery = uniphier_i2c_unprepare_recovery,
 306 };
 307
 308 static void uniphier_i2c_hw_init(struct uniphier_i2c_priv *priv)
 309 {
 310         unsigned int cyc = priv->clk_cycle;
 311
 312         uniphier_i2c_reset(priv, true);
 313
 314         /*
 315          * Bit30-16: clock cycles of tLOW.
 316          *  Standard-mode: tLOW = 4.7 us, tHIGH = 4.0 us
 317          *  Fast-mode:     tLOW = 1.3 us, tHIGH = 0.6 us
 318          * "tLow/tHIGH = 5/4" meets both.
 319          */
 320         writel((cyc * 5 / 9 << 16) | cyc, priv->membase + UNIPHIER_I2C_CLK);
 321
 322         uniphier_i2c_reset(priv, false);
 323 }
 324
 325 static int uniphier_i2c_probe(struct platform_device *pdev)
 326 {
 327         struct device *dev = &pdev->dev;
 328         struct uniphier_i2c_priv *priv;
 329         struct resource *regs;
 330         u32 bus_speed;
 331         unsigned long clk_rate;
 332         int irq, ret;
 333
 334         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 335         if (!priv)
 336                 return -ENOMEM;
 337
 338         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 339         priv->membase = devm_ioremap_resource(dev, regs);
 340         if (IS_ERR(priv->membase))
 341                 return PTR_ERR(priv->membase);
 342
 343         irq = platform_get_irq(pdev, 0);
 344         if (irq < 0) {
 345                 dev_err(dev, "failed to get IRQ number\n");
 346                 return irq;
 347         }
 348
 349         if (of_property_read_u32(dev->of_node, "clock-frequency", &bus_speed))
 350                 bus_speed = UNIPHIER_I2C_DEFAULT_SPEED;
 351
 352         if (!bus_speed || bus_speed > UNIPHIER_I2C_MAX_SPEED) {
 353                 dev_err(dev, "invalid clock-frequency %d\n", bus_speed);
 354                 return -EINVAL;
 355         }
 356
 357         priv->clk = devm_clk_get(dev, NULL);
 358         if (IS_ERR(priv->clk)) {
 359                 dev_err(dev, "failed to get clock\n");
 360                 return PTR_ERR(priv->clk);
 361         }
 362
 363         ret = clk_prepare_enable(priv->clk);
 364         if (ret)
 365                 return ret;
 366
 367         clk_rate = clk_get_rate(priv->clk);
 368         if (!clk_rate) {
 369                 dev_err(dev, "input clock rate should not be zero\n");
 370                 ret = -EINVAL;
 371                 goto disable_clk;
 372         }
 373
 374         priv->clk_cycle = clk_rate / bus_speed;
 375         init_completion(&priv->comp);
 376         priv->adap.owner = THIS_MODULE;
 377         priv->adap.algo = &uniphier_i2c_algo;
 378         priv->adap.dev.parent = dev;
 379         priv->adap.dev.of_node = dev->of_node;
 380         strlcpy(priv->adap.name, "UniPhier I2C", sizeof(priv->adap.name));
 381         priv->adap.bus_recovery_info = &uniphier_i2c_bus_recovery_info;
 382         i2c_set_adapdata(&priv->adap, priv);
 383         platform_set_drvdata(pdev, priv);
 384
 385         uniphier_i2c_hw_init(priv);
 386
 387         ret = devm_request_irq(dev, irq, uniphier_i2c_interrupt, 0, pdev->name,
 388                                priv);
 389         if (ret) {
 390                 dev_err(dev, "failed to request irq %d\n", irq);
 391                 goto disable_clk;
 392         }
 393
 394         ret = i2c_add_adapter(&priv->adap);
 395 disable_clk:
 396         if (ret)
 397                 clk_disable_unprepare(priv->clk);
 398
 399         return ret;
 400 }
 401
 402 static int uniphier_i2c_remove(struct platform_device *pdev)
 403 {
 404         struct uniphier_i2c_priv *priv = platform_get_drvdata(pdev);
 405
 406         i2c_del_adapter(&priv->adap);
 407         clk_disable_unprepare(priv->clk);
 408
 409         return 0;
 410 }
 411
 412 static int __maybe_unused uniphier_i2c_suspend(struct device *dev)
 413 {
 414         struct uniphier_i2c_priv *priv = dev_get_drvdata(dev);
 415
 416         clk_disable_unprepare(priv->clk);
 417
 418         return 0;
 419 }
 420
 421 static int __maybe_unused uniphier_i2c_resume(struct device *dev)
 422 {
 423         struct uniphier_i2c_priv *priv = dev_get_drvdata(dev);
 424         int ret;
 425
 426         ret = clk_prepare_enable(priv->clk);
 427         if (ret)
 428                 return ret;
 429
 430         uniphier_i2c_hw_init(priv);
 431
 432         return 0;
 433 }
 434
 435 static const struct dev_pm_ops uniphier_i2c_pm_ops = {
 436         SET_SYSTEM_SLEEP_PM_OPS(uniphier_i2c_suspend, uniphier_i2c_resume)
 437 };
 438
 439 static const struct of_device_id uniphier_i2c_match[] = {
 440         { .compatible = "socionext,uniphier-i2c" },
 441         { /* sentinel */ }
 442 };
 443 MODULE_DEVICE_TABLE(of, uniphier_i2c_match);
 444
 445 static struct platform_driver uniphier_i2c_drv = {
 446         .probe  = uniphier_i2c_probe,
 447         .remove = uniphier_i2c_remove,
 448         .driver = {
 449                 .name  = "uniphier-i2c",
 450                 .of_match_table = uniphier_i2c_match,
 451                 .pm = &uniphier_i2c_pm_ops,
 452         },
 453 };
 454 module_platform_driver(uniphier_i2c_drv);
 455
 456 MODULE_AUTHOR("Masahiro Yamada <yamada.masahiro@socionext.com>");
 457 MODULE_DESCRIPTION("UniPhier I2C bus driver");
 458 MODULE_LICENSE("GPL");