drivers/i2c/busses/i2c-qcom-cci.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
   3 // Copyright (c) 2017-2022 Linaro Limited.
   4
   5 #include <linux/clk.h>
   6 #include <linux/completion.h>
   7 #include <linux/i2c.h>
   8 #include <linux/io.h>
   9 #include <linux/interrupt.h>
  10 #include <linux/module.h>
  11 #include <linux/of.h>
  12 #include <linux/platform_device.h>
  13 #include <linux/pm_runtime.h>
  14
  15 #define CCI_HW_VERSION                          0x0
  16 #define CCI_RESET_CMD                           0x004
  17 #define CCI_RESET_CMD_MASK                      0x0f73f3f7
  18 #define CCI_RESET_CMD_M0_MASK                   0x000003f1
  19 #define CCI_RESET_CMD_M1_MASK                   0x0003f001
  20 #define CCI_QUEUE_START                         0x008
  21 #define CCI_HALT_REQ                            0x034
  22 #define CCI_HALT_REQ_I2C_M0_Q0Q1                BIT(0)
  23 #define CCI_HALT_REQ_I2C_M1_Q0Q1                BIT(1)
  24
  25 #define CCI_I2C_Mm_SCL_CTL(m)                   (0x100 + 0x100 * (m))
  26 #define CCI_I2C_Mm_SDA_CTL_0(m)                 (0x104 + 0x100 * (m))
  27 #define CCI_I2C_Mm_SDA_CTL_1(m)                 (0x108 + 0x100 * (m))
  28 #define CCI_I2C_Mm_SDA_CTL_2(m)                 (0x10c + 0x100 * (m))
  29 #define CCI_I2C_Mm_MISC_CTL(m)                  (0x110 + 0x100 * (m))
  30
  31 #define CCI_I2C_Mm_READ_DATA(m)                 (0x118 + 0x100 * (m))
  32 #define CCI_I2C_Mm_READ_BUF_LEVEL(m)            (0x11c + 0x100 * (m))
  33 #define CCI_I2C_Mm_Qn_EXEC_WORD_CNT(m, n)       (0x300 + 0x200 * (m) + 0x100 * (n))
  34 #define CCI_I2C_Mm_Qn_CUR_WORD_CNT(m, n)        (0x304 + 0x200 * (m) + 0x100 * (n))
  35 #define CCI_I2C_Mm_Qn_CUR_CMD(m, n)             (0x308 + 0x200 * (m) + 0x100 * (n))
  36 #define CCI_I2C_Mm_Qn_REPORT_STATUS(m, n)       (0x30c + 0x200 * (m) + 0x100 * (n))
  37 #define CCI_I2C_Mm_Qn_LOAD_DATA(m, n)           (0x310 + 0x200 * (m) + 0x100 * (n))
  38
  39 #define CCI_IRQ_GLOBAL_CLEAR_CMD                0xc00
  40 #define CCI_IRQ_MASK_0                          0xc04
  41 #define CCI_IRQ_MASK_0_I2C_M0_RD_DONE           BIT(0)
  42 #define CCI_IRQ_MASK_0_I2C_M0_Q0_REPORT         BIT(4)
  43 #define CCI_IRQ_MASK_0_I2C_M0_Q1_REPORT         BIT(8)
  44 #define CCI_IRQ_MASK_0_I2C_M1_RD_DONE           BIT(12)
  45 #define CCI_IRQ_MASK_0_I2C_M1_Q0_REPORT         BIT(16)
  46 #define CCI_IRQ_MASK_0_I2C_M1_Q1_REPORT         BIT(20)
  47 #define CCI_IRQ_MASK_0_RST_DONE_ACK             BIT(24)
  48 #define CCI_IRQ_MASK_0_I2C_M0_Q0Q1_HALT_ACK     BIT(25)
  49 #define CCI_IRQ_MASK_0_I2C_M1_Q0Q1_HALT_ACK     BIT(26)
  50 #define CCI_IRQ_MASK_0_I2C_M0_ERROR             0x18000ee6
  51 #define CCI_IRQ_MASK_0_I2C_M1_ERROR             0x60ee6000
  52 #define CCI_IRQ_CLEAR_0                         0xc08
  53 #define CCI_IRQ_STATUS_0                        0xc0c
  54 #define CCI_IRQ_STATUS_0_I2C_M0_RD_DONE         BIT(0)
  55 #define CCI_IRQ_STATUS_0_I2C_M0_Q0_REPORT       BIT(4)
  56 #define CCI_IRQ_STATUS_0_I2C_M0_Q1_REPORT       BIT(8)
  57 #define CCI_IRQ_STATUS_0_I2C_M1_RD_DONE         BIT(12)
  58 #define CCI_IRQ_STATUS_0_I2C_M1_Q0_REPORT       BIT(16)
  59 #define CCI_IRQ_STATUS_0_I2C_M1_Q1_REPORT       BIT(20)
  60 #define CCI_IRQ_STATUS_0_RST_DONE_ACK           BIT(24)
  61 #define CCI_IRQ_STATUS_0_I2C_M0_Q0Q1_HALT_ACK   BIT(25)
  62 #define CCI_IRQ_STATUS_0_I2C_M1_Q0Q1_HALT_ACK   BIT(26)
  63 #define CCI_IRQ_STATUS_0_I2C_M0_Q0_NACK_ERR     BIT(27)
  64 #define CCI_IRQ_STATUS_0_I2C_M0_Q1_NACK_ERR     BIT(28)
  65 #define CCI_IRQ_STATUS_0_I2C_M1_Q0_NACK_ERR     BIT(29)
  66 #define CCI_IRQ_STATUS_0_I2C_M1_Q1_NACK_ERR     BIT(30)
  67 #define CCI_IRQ_STATUS_0_I2C_M0_ERROR           0x18000ee6
  68 #define CCI_IRQ_STATUS_0_I2C_M1_ERROR           0x60ee6000
  69
  70 #define CCI_TIMEOUT     (msecs_to_jiffies(100))
  71 #define NUM_MASTERS     2
  72 #define NUM_QUEUES      2
  73
  74 /* Max number of resources + 1 for a NULL terminator */
  75 #define CCI_RES_MAX     6
  76
  77 #define CCI_I2C_SET_PARAM       1
  78 #define CCI_I2C_REPORT          8
  79 #define CCI_I2C_WRITE           9
  80 #define CCI_I2C_READ            10
  81
  82 #define CCI_I2C_REPORT_IRQ_EN   BIT(8)
  83
  84 enum {
  85         I2C_MODE_STANDARD,
  86         I2C_MODE_FAST,
  87         I2C_MODE_FAST_PLUS,
  88 };
  89
  90 enum cci_i2c_queue_t {
  91         QUEUE_0,
  92         QUEUE_1
  93 };
  94
  95 struct hw_params {
  96         u16 thigh; /* HIGH period of the SCL clock in clock ticks */
  97         u16 tlow; /* LOW period of the SCL clock */
  98         u16 tsu_sto; /* set-up time for STOP condition */
  99         u16 tsu_sta; /* set-up time for a repeated START condition */
 100         u16 thd_dat; /* data hold time */
 101         u16 thd_sta; /* hold time (repeated) START condition */
 102         u16 tbuf; /* bus free time between a STOP and START condition */
 103         u8 scl_stretch_en;
 104         u16 trdhld;
 105         u16 tsp; /* pulse width of spikes suppressed by the input filter */
 106 };
 107
 108 struct cci;
 109
 110 struct cci_master {
 111         struct i2c_adapter adap;
 112         u16 master;
 113         u8 mode;
 114         int status;
 115         struct completion irq_complete;
 116         struct cci *cci;
 117 };
 118
 119 struct cci_data {
 120         unsigned int num_masters;
 121         struct i2c_adapter_quirks quirks;
 122         u16 queue_size[NUM_QUEUES];
 123         struct hw_params params[3];
 124 };
 125
 126 struct cci {
 127         struct device *dev;
 128         void __iomem *base;
 129         unsigned int irq;
 130         const struct cci_data *data;
 131         struct clk_bulk_data *clocks;
 132         int nclocks;
 133         struct cci_master master[NUM_MASTERS];
 134 };
 135
 136 static irqreturn_t cci_isr(int irq, void *dev)
 137 {
 138         struct cci *cci = dev;
 139         u32 val, reset = 0;
 140         int ret = IRQ_NONE;
 141
 142         val = readl(cci->base + CCI_IRQ_STATUS_0);
 143         writel(val, cci->base + CCI_IRQ_CLEAR_0);
 144         writel(0x1, cci->base + CCI_IRQ_GLOBAL_CLEAR_CMD);
 145
 146         if (val & CCI_IRQ_STATUS_0_RST_DONE_ACK) {
 147                 complete(&cci->master[0].irq_complete);
 148                 if (cci->master[1].master)
 149                         complete(&cci->master[1].irq_complete);
 150                 ret = IRQ_HANDLED;
 151         }
 152
 153         if (val & CCI_IRQ_STATUS_0_I2C_M0_RD_DONE ||
 154                         val & CCI_IRQ_STATUS_0_I2C_M0_Q0_REPORT ||
 155                         val & CCI_IRQ_STATUS_0_I2C_M0_Q1_REPORT) {
 156                 cci->master[0].status = 0;
 157                 complete(&cci->master[0].irq_complete);
 158                 ret = IRQ_HANDLED;
 159         }
 160
 161         if (val & CCI_IRQ_STATUS_0_I2C_M1_RD_DONE ||
 162                         val & CCI_IRQ_STATUS_0_I2C_M1_Q0_REPORT ||
 163                         val & CCI_IRQ_STATUS_0_I2C_M1_Q1_REPORT) {
 164                 cci->master[1].status = 0;
 165                 complete(&cci->master[1].irq_complete);
 166                 ret = IRQ_HANDLED;
 167         }
 168
 169         if (unlikely(val & CCI_IRQ_STATUS_0_I2C_M0_Q0Q1_HALT_ACK)) {
 170                 reset = CCI_RESET_CMD_M0_MASK;
 171                 ret = IRQ_HANDLED;
 172         }
 173
 174         if (unlikely(val & CCI_IRQ_STATUS_0_I2C_M1_Q0Q1_HALT_ACK)) {
 175                 reset = CCI_RESET_CMD_M1_MASK;
 176                 ret = IRQ_HANDLED;
 177         }
 178
 179         if (unlikely(reset))
 180                 writel(reset, cci->base + CCI_RESET_CMD);
 181
 182         if (unlikely(val & CCI_IRQ_STATUS_0_I2C_M0_ERROR)) {
 183                 if (val & CCI_IRQ_STATUS_0_I2C_M0_Q0_NACK_ERR ||
 184                         val & CCI_IRQ_STATUS_0_I2C_M0_Q1_NACK_ERR)
 185                         cci->master[0].status = -ENXIO;
 186                 else
 187                         cci->master[0].status = -EIO;
 188
 189                 writel(CCI_HALT_REQ_I2C_M0_Q0Q1, cci->base + CCI_HALT_REQ);
 190                 ret = IRQ_HANDLED;
 191         }
 192
 193         if (unlikely(val & CCI_IRQ_STATUS_0_I2C_M1_ERROR)) {
 194                 if (val & CCI_IRQ_STATUS_0_I2C_M1_Q0_NACK_ERR ||
 195                         val & CCI_IRQ_STATUS_0_I2C_M1_Q1_NACK_ERR)
 196                         cci->master[1].status = -ENXIO;
 197                 else
 198                         cci->master[1].status = -EIO;
 199
 200                 writel(CCI_HALT_REQ_I2C_M1_Q0Q1, cci->base + CCI_HALT_REQ);
 201                 ret = IRQ_HANDLED;
 202         }
 203
 204         return ret;
 205 }
 206
 207 static int cci_halt(struct cci *cci, u8 master_num)
 208 {
 209         struct cci_master *master;
 210         u32 val;
 211
 212         if (master_num >= cci->data->num_masters) {
 213                 dev_err(cci->dev, "Unsupported master idx (%u)\n", master_num);
 214                 return -EINVAL;
 215         }
 216
 217         val = BIT(master_num);
 218         master = &cci->master[master_num];
 219
 220         reinit_completion(&master->irq_complete);
 221         writel(val, cci->base + CCI_HALT_REQ);
 222
 223         if (!wait_for_completion_timeout(&master->irq_complete, CCI_TIMEOUT)) {
 224                 dev_err(cci->dev, "CCI halt timeout\n");
 225                 return -ETIMEDOUT;
 226         }
 227
 228         return 0;
 229 }
 230
 231 static int cci_reset(struct cci *cci)
 232 {
 233         /*
 234          * we reset the whole controller, here and for implicity use
 235          * master[0].xxx for waiting on it.
 236          */
 237         reinit_completion(&cci->master[0].irq_complete);
 238         writel(CCI_RESET_CMD_MASK, cci->base + CCI_RESET_CMD);
 239
 240         if (!wait_for_completion_timeout(&cci->master[0].irq_complete,
 241                                          CCI_TIMEOUT)) {
 242                 dev_err(cci->dev, "CCI reset timeout\n");
 243                 return -ETIMEDOUT;
 244         }
 245
 246         return 0;
 247 }
 248
 249 static int cci_init(struct cci *cci)
 250 {
 251         u32 val = CCI_IRQ_MASK_0_I2C_M0_RD_DONE |
 252                         CCI_IRQ_MASK_0_I2C_M0_Q0_REPORT |
 253                         CCI_IRQ_MASK_0_I2C_M0_Q1_REPORT |
 254                         CCI_IRQ_MASK_0_I2C_M1_RD_DONE |
 255                         CCI_IRQ_MASK_0_I2C_M1_Q0_REPORT |
 256                         CCI_IRQ_MASK_0_I2C_M1_Q1_REPORT |
 257                         CCI_IRQ_MASK_0_RST_DONE_ACK |
 258                         CCI_IRQ_MASK_0_I2C_M0_Q0Q1_HALT_ACK |
 259                         CCI_IRQ_MASK_0_I2C_M1_Q0Q1_HALT_ACK |
 260                         CCI_IRQ_MASK_0_I2C_M0_ERROR |
 261                         CCI_IRQ_MASK_0_I2C_M1_ERROR;
 262         int i;
 263
 264         writel(val, cci->base + CCI_IRQ_MASK_0);
 265
 266         for (i = 0; i < cci->data->num_masters; i++) {
 267                 int mode = cci->master[i].mode;
 268                 const struct hw_params *hw;
 269
 270                 if (!cci->master[i].cci)
 271                         continue;
 272
 273                 hw = &cci->data->params[mode];
 274
 275                 val = hw->thigh << 16 | hw->tlow;
 276                 writel(val, cci->base + CCI_I2C_Mm_SCL_CTL(i));
 277
 278                 val = hw->tsu_sto << 16 | hw->tsu_sta;
 279                 writel(val, cci->base + CCI_I2C_Mm_SDA_CTL_0(i));
 280
 281                 val = hw->thd_dat << 16 | hw->thd_sta;
 282                 writel(val, cci->base + CCI_I2C_Mm_SDA_CTL_1(i));
 283
 284                 val = hw->tbuf;
 285                 writel(val, cci->base + CCI_I2C_Mm_SDA_CTL_2(i));
 286
 287                 val = hw->scl_stretch_en << 8 | hw->trdhld << 4 | hw->tsp;
 288                 writel(val, cci->base + CCI_I2C_Mm_MISC_CTL(i));
 289         }
 290
 291         return 0;
 292 }
 293
 294 static int cci_run_queue(struct cci *cci, u8 master, u8 queue)
 295 {
 296         u32 val;
 297
 298         val = readl(cci->base + CCI_I2C_Mm_Qn_CUR_WORD_CNT(master, queue));
 299         writel(val, cci->base + CCI_I2C_Mm_Qn_EXEC_WORD_CNT(master, queue));
 300
 301         reinit_completion(&cci->master[master].irq_complete);
 302         val = BIT(master * 2 + queue);
 303         writel(val, cci->base + CCI_QUEUE_START);
 304
 305         if (!wait_for_completion_timeout(&cci->master[master].irq_complete,
 306                                          CCI_TIMEOUT)) {
 307                 dev_err(cci->dev, "master %d queue %d timeout\n",
 308                         master, queue);
 309                 cci_reset(cci);
 310                 cci_init(cci);
 311                 return -ETIMEDOUT;
 312         }
 313
 314         return cci->master[master].status;
 315 }
 316
 317 static int cci_validate_queue(struct cci *cci, u8 master, u8 queue)
 318 {
 319         u32 val;
 320
 321         val = readl(cci->base + CCI_I2C_Mm_Qn_CUR_WORD_CNT(master, queue));
 322         if (val == cci->data->queue_size[queue])
 323                 return -EINVAL;
 324
 325         if (!val)
 326                 return 0;
 327
 328         val = CCI_I2C_REPORT | CCI_I2C_REPORT_IRQ_EN;
 329         writel(val, cci->base + CCI_I2C_Mm_Qn_LOAD_DATA(master, queue));
 330
 331         return cci_run_queue(cci, master, queue);
 332 }
 333
 334 static int cci_i2c_read(struct cci *cci, u16 master,
 335                         u16 addr, u8 *buf, u16 len)
 336 {
 337         u32 val, words_read, words_exp;
 338         u8 queue = QUEUE_1;
 339         int i, index = 0, ret;
 340         bool first = true;
 341
 342         /*
 343          * Call validate queue to make sure queue is empty before starting.
 344          * This is to avoid overflow / underflow of queue.
 345          */
 346         ret = cci_validate_queue(cci, master, queue);
 347         if (ret < 0)
 348                 return ret;
 349
 350         val = CCI_I2C_SET_PARAM | (addr & 0x7f) << 4;
 351         writel(val, cci->base + CCI_I2C_Mm_Qn_LOAD_DATA(master, queue));
 352
 353         val = CCI_I2C_READ | len << 4;
 354         writel(val, cci->base + CCI_I2C_Mm_Qn_LOAD_DATA(master, queue));
 355
 356         ret = cci_run_queue(cci, master, queue);
 357         if (ret < 0)
 358                 return ret;
 359
 360         words_read = readl(cci->base + CCI_I2C_Mm_READ_BUF_LEVEL(master));
 361         words_exp = len / 4 + 1;
 362         if (words_read != words_exp) {
 363                 dev_err(cci->dev, "words read = %d, words expected = %d\n",
 364                         words_read, words_exp);
 365                 return -EIO;
 366         }
 367
 368         do {
 369                 val = readl(cci->base + CCI_I2C_Mm_READ_DATA(master));
 370
 371                 for (i = 0; i < 4 && index < len; i++) {
 372                         if (first) {
 373                                 /* The LS byte of this register represents the
 374                                  * first byte read from the slave during a read
 375                                  * access.
 376                                  */
 377                                 first = false;
 378                                 continue;
 379                         }
 380                         buf[index++] = (val >> (i * 8)) & 0xff;
 381                 }
 382         } while (--words_read);
 383
 384         return 0;
 385 }
 386
 387 static int cci_i2c_write(struct cci *cci, u16 master,
 388                          u16 addr, u8 *buf, u16 len)
 389 {
 390         u8 queue = QUEUE_0;
 391         u8 load[12] = { 0 };
 392         int i = 0, j, ret;
 393         u32 val;
 394
 395         /*
 396          * Call validate queue to make sure queue is empty before starting.
 397          * This is to avoid overflow / underflow of queue.
 398          */
 399         ret = cci_validate_queue(cci, master, queue);
 400         if (ret < 0)
 401                 return ret;
 402
 403         val = CCI_I2C_SET_PARAM | (addr & 0x7f) << 4;
 404         writel(val, cci->base + CCI_I2C_Mm_Qn_LOAD_DATA(master, queue));
 405
 406         load[i++] = CCI_I2C_WRITE | len << 4;
 407
 408         for (j = 0; j < len; j++)
 409                 load[i++] = buf[j];
 410
 411         for (j = 0; j < i; j += 4) {
 412                 val = load[j];
 413                 val |= load[j + 1] << 8;
 414                 val |= load[j + 2] << 16;
 415                 val |= load[j + 3] << 24;
 416                 writel(val, cci->base + CCI_I2C_Mm_Qn_LOAD_DATA(master, queue));
 417         }
 418
 419         val = CCI_I2C_REPORT | CCI_I2C_REPORT_IRQ_EN;
 420         writel(val, cci->base + CCI_I2C_Mm_Qn_LOAD_DATA(master, queue));
 421
 422         return cci_run_queue(cci, master, queue);
 423 }
 424
 425 static int cci_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
 426 {
 427         struct cci_master *cci_master = i2c_get_adapdata(adap);
 428         struct cci *cci = cci_master->cci;
 429         int i, ret;
 430
 431         ret = pm_runtime_get_sync(cci->dev);
 432         if (ret < 0)
 433                 goto err;
 434
 435         for (i = 0; i < num; i++) {
 436                 if (msgs[i].flags & I2C_M_RD)
 437                         ret = cci_i2c_read(cci, cci_master->master,
 438                                            msgs[i].addr, msgs[i].buf,
 439                                            msgs[i].len);
 440                 else
 441                         ret = cci_i2c_write(cci, cci_master->master,
 442                                             msgs[i].addr, msgs[i].buf,
 443                                             msgs[i].len);
 444
 445                 if (ret < 0)
 446                         break;
 447         }
 448
 449         if (!ret)
 450                 ret = num;
 451
 452 err:
 453         pm_runtime_mark_last_busy(cci->dev);
 454         pm_runtime_put_autosuspend(cci->dev);
 455
 456         return ret;
 457 }
 458
 459 static u32 cci_func(struct i2c_adapter *adap)
 460 {
 461         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 462 }
 463
 464 static const struct i2c_algorithm cci_algo = {
 465         .master_xfer    = cci_xfer,
 466         .functionality  = cci_func,
 467 };
 468
 469 static int cci_enable_clocks(struct cci *cci)
 470 {
 471         return clk_bulk_prepare_enable(cci->nclocks, cci->clocks);
 472 }
 473
 474 static void cci_disable_clocks(struct cci *cci)
 475 {
 476         clk_bulk_disable_unprepare(cci->nclocks, cci->clocks);
 477 }
 478
 479 static int __maybe_unused cci_suspend_runtime(struct device *dev)
 480 {
 481         struct cci *cci = dev_get_drvdata(dev);
 482
 483         cci_disable_clocks(cci);
 484         return 0;
 485 }
 486
 487 static int __maybe_unused cci_resume_runtime(struct device *dev)
 488 {
 489         struct cci *cci = dev_get_drvdata(dev);
 490         int ret;
 491
 492         ret = cci_enable_clocks(cci);
 493         if (ret)
 494                 return ret;
 495
 496         cci_init(cci);
 497         return 0;
 498 }
 499
 500 static int __maybe_unused cci_suspend(struct device *dev)
 501 {
 502         if (!pm_runtime_suspended(dev))
 503                 return cci_suspend_runtime(dev);
 504
 505         return 0;
 506 }
 507
 508 static int __maybe_unused cci_resume(struct device *dev)
 509 {
 510         cci_resume_runtime(dev);
 511         pm_runtime_mark_last_busy(dev);
 512         pm_request_autosuspend(dev);
 513
 514         return 0;
 515 }
 516
 517 static const struct dev_pm_ops qcom_cci_pm = {
 518         SET_SYSTEM_SLEEP_PM_OPS(cci_suspend, cci_resume)
 519         SET_RUNTIME_PM_OPS(cci_suspend_runtime, cci_resume_runtime, NULL)
 520 };
 521
 522 static int cci_probe(struct platform_device *pdev)
 523 {
 524         struct device *dev = &pdev->dev;
 525         struct device_node *child;
 526         struct resource *r;
 527         struct cci *cci;
 528         int ret, i;
 529         u32 val;
 530
 531         cci = devm_kzalloc(dev, sizeof(*cci), GFP_KERNEL);
 532         if (!cci)
 533                 return -ENOMEM;
 534
 535         cci->dev = dev;
 536         platform_set_drvdata(pdev, cci);
 537         cci->data = device_get_match_data(dev);
 538         if (!cci->data)
 539                 return -ENOENT;
 540
 541         for_each_available_child_of_node(dev->of_node, child) {
 542                 struct cci_master *master;
 543                 u32 idx;
 544
 545                 ret = of_property_read_u32(child, "reg", &idx);
 546                 if (ret) {
 547                         dev_err(dev, "%pOF invalid 'reg' property", child);
 548                         continue;
 549                 }
 550
 551                 if (idx >= cci->data->num_masters) {
 552                         dev_err(dev, "%pOF invalid 'reg' value: %u (max is %u)",
 553                                 child, idx, cci->data->num_masters - 1);
 554                         continue;
 555                 }
 556
 557                 master = &cci->master[idx];
 558                 master->adap.quirks = &cci->data->quirks;
 559                 master->adap.algo = &cci_algo;
 560                 master->adap.dev.parent = dev;
 561                 master->adap.dev.of_node = of_node_get(child);
 562                 master->master = idx;
 563                 master->cci = cci;
 564
 565                 i2c_set_adapdata(&master->adap, master);
 566                 snprintf(master->adap.name, sizeof(master->adap.name), "Qualcomm-CCI");
 567
 568                 master->mode = I2C_MODE_STANDARD;
 569                 ret = of_property_read_u32(child, "clock-frequency", &val);
 570                 if (!ret) {
 571                         if (val == I2C_MAX_FAST_MODE_FREQ)
 572                                 master->mode = I2C_MODE_FAST;
 573                         else if (val == I2C_MAX_FAST_MODE_PLUS_FREQ)
 574                                 master->mode = I2C_MODE_FAST_PLUS;
 575                 }
 576
 577                 init_completion(&master->irq_complete);
 578         }
 579
 580         /* Memory */
 581
 582         cci->base = devm_platform_get_and_ioremap_resource(pdev, 0, &r);
 583         if (IS_ERR(cci->base))
 584                 return PTR_ERR(cci->base);
 585
 586         /* Clocks */
 587
 588         ret = devm_clk_bulk_get_all(dev, &cci->clocks);
 589         if (ret < 0)
 590                 return dev_err_probe(dev, ret, "failed to get clocks\n");
 591         else if (!ret)
 592                 return dev_err_probe(dev, -EINVAL, "not enough clocks in DT\n");
 593         cci->nclocks = ret;
 594
 595         ret = cci_enable_clocks(cci);
 596         if (ret < 0)
 597                 return ret;
 598
 599         /* Interrupt */
 600
 601         ret = platform_get_irq(pdev, 0);
 602         if (ret < 0)
 603                 goto disable_clocks;
 604         cci->irq = ret;
 605
 606         ret = devm_request_irq(dev, cci->irq, cci_isr, 0, dev_name(dev), cci);
 607         if (ret < 0) {
 608                 dev_err(dev, "request_irq failed, ret: %d\n", ret);
 609                 goto disable_clocks;
 610         }
 611
 612         val = readl(cci->base + CCI_HW_VERSION);
 613         dev_dbg(dev, "CCI HW version = 0x%08x", val);
 614
 615         ret = cci_reset(cci);
 616         if (ret < 0)
 617                 goto error;
 618
 619         ret = cci_init(cci);
 620         if (ret < 0)
 621                 goto error;
 622
 623         pm_runtime_set_autosuspend_delay(dev, MSEC_PER_SEC);
 624         pm_runtime_use_autosuspend(dev);
 625         pm_runtime_set_active(dev);
 626         pm_runtime_enable(dev);
 627
 628         for (i = 0; i < cci->data->num_masters; i++) {
 629                 if (!cci->master[i].cci)
 630                         continue;
 631
 632                 ret = i2c_add_adapter(&cci->master[i].adap);
 633                 if (ret < 0) {
 634                         of_node_put(cci->master[i].adap.dev.of_node);
 635                         goto error_i2c;
 636                 }
 637         }
 638
 639         return 0;
 640
 641 error_i2c:
 642         pm_runtime_disable(dev);
 643         pm_runtime_dont_use_autosuspend(dev);
 644
 645         for (--i ; i >= 0; i--) {
 646                 if (cci->master[i].cci) {
 647                         i2c_del_adapter(&cci->master[i].adap);
 648                         of_node_put(cci->master[i].adap.dev.of_node);
 649                 }
 650         }
 651 error:
 652         disable_irq(cci->irq);
 653 disable_clocks:
 654         cci_disable_clocks(cci);
 655
 656         return ret;
 657 }
 658
 659 static void cci_remove(struct platform_device *pdev)
 660 {
 661         struct cci *cci = platform_get_drvdata(pdev);
 662         int i;
 663
 664         for (i = 0; i < cci->data->num_masters; i++) {
 665                 if (cci->master[i].cci) {
 666                         i2c_del_adapter(&cci->master[i].adap);
 667                         of_node_put(cci->master[i].adap.dev.of_node);
 668                 }
 669                 cci_halt(cci, i);
 670         }
 671
 672         disable_irq(cci->irq);
 673         pm_runtime_disable(&pdev->dev);
 674         pm_runtime_set_suspended(&pdev->dev);
 675 }
 676
 677 static const struct cci_data cci_v1_data = {
 678         .num_masters = 1,
 679         .queue_size = { 64, 16 },
 680         .quirks = {
 681                 .max_write_len = 10,
 682                 .max_read_len = 12,
 683         },
 684         .params[I2C_MODE_STANDARD] = {
 685                 .thigh = 78,
 686                 .tlow = 114,
 687                 .tsu_sto = 28,
 688                 .tsu_sta = 28,
 689                 .thd_dat = 10,
 690                 .thd_sta = 77,
 691                 .tbuf = 118,
 692                 .scl_stretch_en = 0,
 693                 .trdhld = 6,
 694                 .tsp = 1
 695         },
 696         .params[I2C_MODE_FAST] = {
 697                 .thigh = 20,
 698                 .tlow = 28,
 699                 .tsu_sto = 21,
 700                 .tsu_sta = 21,
 701                 .thd_dat = 13,
 702                 .thd_sta = 18,
 703                 .tbuf = 32,
 704                 .scl_stretch_en = 0,
 705                 .trdhld = 6,
 706                 .tsp = 3
 707         },
 708 };
 709
 710 static const struct cci_data cci_v1_5_data = {
 711         .num_masters = 2,
 712         .queue_size = { 64, 16 },
 713         .quirks = {
 714                 .max_write_len = 10,
 715                 .max_read_len = 12,
 716         },
 717         .params[I2C_MODE_STANDARD] = {
 718                 .thigh = 78,
 719                 .tlow = 114,
 720                 .tsu_sto = 28,
 721                 .tsu_sta = 28,
 722                 .thd_dat = 10,
 723                 .thd_sta = 77,
 724                 .tbuf = 118,
 725                 .scl_stretch_en = 0,
 726                 .trdhld = 6,
 727                 .tsp = 1
 728         },
 729         .params[I2C_MODE_FAST] = {
 730                 .thigh = 20,
 731                 .tlow = 28,
 732                 .tsu_sto = 21,
 733                 .tsu_sta = 21,
 734                 .thd_dat = 13,
 735                 .thd_sta = 18,
 736                 .tbuf = 32,
 737                 .scl_stretch_en = 0,
 738                 .trdhld = 6,
 739                 .tsp = 3
 740         },
 741 };
 742
 743 static const struct cci_data cci_v2_data = {
 744         .num_masters = 2,
 745         .queue_size = { 64, 16 },
 746         .quirks = {
 747                 .max_write_len = 11,
 748                 .max_read_len = 12,
 749         },
 750         .params[I2C_MODE_STANDARD] = {
 751                 .thigh = 201,
 752                 .tlow = 174,
 753                 .tsu_sto = 204,
 754                 .tsu_sta = 231,
 755                 .thd_dat = 22,
 756                 .thd_sta = 162,
 757                 .tbuf = 227,
 758                 .scl_stretch_en = 0,
 759                 .trdhld = 6,
 760                 .tsp = 3
 761         },
 762         .params[I2C_MODE_FAST] = {
 763                 .thigh = 38,
 764                 .tlow = 56,
 765                 .tsu_sto = 40,
 766                 .tsu_sta = 40,
 767                 .thd_dat = 22,
 768                 .thd_sta = 35,
 769                 .tbuf = 62,
 770                 .scl_stretch_en = 0,
 771                 .trdhld = 6,
 772                 .tsp = 3
 773         },
 774         .params[I2C_MODE_FAST_PLUS] = {
 775                 .thigh = 16,
 776                 .tlow = 22,
 777                 .tsu_sto = 17,
 778                 .tsu_sta = 18,
 779                 .thd_dat = 16,
 780                 .thd_sta = 15,
 781                 .tbuf = 24,
 782                 .scl_stretch_en = 0,
 783                 .trdhld = 3,
 784                 .tsp = 3
 785         },
 786 };
 787
 788 static const struct of_device_id cci_dt_match[] = {
 789         { .compatible = "qcom,msm8226-cci", .data = &cci_v1_data},
 790         { .compatible = "qcom,msm8974-cci", .data = &cci_v1_5_data},
 791         { .compatible = "qcom,msm8996-cci", .data = &cci_v2_data},
 792
 793
 794         /*
 795          * Legacy compatibles kept for backwards compatibility.
 796          * Do not add any new ones unless they introduce a new config
 797          */
 798         { .compatible = "qcom,msm8916-cci", .data = &cci_v1_data},
 799         { .compatible = "qcom,sdm845-cci", .data = &cci_v2_data},
 800         { .compatible = "qcom,sm8250-cci", .data = &cci_v2_data},
 801         { .compatible = "qcom,sm8450-cci", .data = &cci_v2_data},
 802         {}
 803 };
 804 MODULE_DEVICE_TABLE(of, cci_dt_match);
 805
 806 static struct platform_driver qcom_cci_driver = {
 807         .probe  = cci_probe,
 808         .remove = cci_remove,
 809         .driver = {
 810                 .name = "i2c-qcom-cci",
 811                 .of_match_table = cci_dt_match,
 812                 .pm = &qcom_cci_pm,
 813         },
 814 };
 815
 816 module_platform_driver(qcom_cci_driver);
 817
 818 MODULE_DESCRIPTION("Qualcomm Camera Control Interface driver");
 819 MODULE_AUTHOR("Todor Tomov <todor.tomov@linaro.org>");
 820 MODULE_AUTHOR("Loic Poulain <loic.poulain@linaro.org>");
 821 MODULE_LICENSE("GPL v2");