From patchwork Fri Dec 20 18:39:42 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Loic Poulain X-Patchwork-Id: 182316 Delivered-To: patch@linaro.org Received: by 2002:a92:1f98:0:0:0:0:0 with SMTP id f24csp889373ilf; Fri, 20 Dec 2019 10:36:50 -0800 (PST) X-Google-Smtp-Source: APXvYqxS8zKFekFkqmsbnTpbkzwjr8fQx1tPwn8Pmnhc3MwT2XnzaS1hfII/vSEhrLxc+2jHSDVf X-Received: by 2002:a9d:7448:: with SMTP id p8mr6178873otk.96.1576867010240; Fri, 20 Dec 2019 10:36:50 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1576867010; cv=none; d=google.com; s=arc-20160816; b=mN4pCVZ1YhyNNw0E1AzM0n+87c15xk/p1ovYxd5pvMIXHJMYavnFcgtOIXQrK9rSiX ISa+9E2l2jWlDK77Hu6YXW9Ew8V4KSjkqcazjyYeawPaNgJbDHtu+4EL+2aEKkFWhsSy vrcLEy/ZGsKTOJnYU8bYWUzMUfbN14zK3gJI+/ZI8x9jA7dMvN/1D8B3Sx3STeTmSahU Uei58VPQ9zFDwBvVdT+02bRNDzRpLigUliwsXq7UIvQ8mwMOMpOEaju7Y4k5QtzdnE1k iH3MdgEUo74D6ovo4UxXUY5ug3m0FL9+DYeCpGQyKpdW88t+W4EiKVOAhaY798osigoi t6Hg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:message-id:date:subject:cc:to:from :dkim-signature; bh=mOk7x3sj9VW+oyf1PKODP54+RHY+kq0+ahEXOTzri+Y=; b=i+R3n3DBtaag5WHbdpTCa5G8XGlVwFMgaB0YqhZssMCrLYoQV4lLBwh97wFYrWWwgg 9ufgXuwNJztRmPDkoGARt/zmKay9MCCI5nFOZ3V2oQLBTQyYmZJljHe25MGJQR23JQNi NoXs9t3QnMCN0phNGr59kAQ+Hga0INeqQcRqBqdL6HRDjgxpiXydHKPVgVIijxWWEDTr Ik/IWOE0sXjRr5Dp9xJLg179Wx+I37AgEw7bX3HB1Y/05grxsg3cLdaeN+6S+q2U/trR m3Mosnsu1GevWAH6EwOmHAm2y9EF6qvmZJFn9ioxS9jBR3dVl5ipRTexCzd4RnXHsdRD G6VA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=d28BNnHl; spf=pass (google.com: best guess record for domain of linux-i2c-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-i2c-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id l20si3816567otr.227.2019.12.20.10.36.50; Fri, 20 Dec 2019 10:36:50 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-i2c-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=d28BNnHl; spf=pass (google.com: best guess record for domain of linux-i2c-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-i2c-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727394AbfLTSgt (ORCPT + 2 others); Fri, 20 Dec 2019 13:36:49 -0500 Received: from mail-wm1-f66.google.com ([209.85.128.66]:52866 "EHLO mail-wm1-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727390AbfLTSgt (ORCPT ); Fri, 20 Dec 2019 13:36:49 -0500 Received: by mail-wm1-f66.google.com with SMTP id p9so9922621wmc.2 for ; Fri, 20 Dec 2019 10:36:45 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id; bh=mOk7x3sj9VW+oyf1PKODP54+RHY+kq0+ahEXOTzri+Y=; b=d28BNnHlzDBQviysL9ys+zJkrCubxIPgv3DWoNoA2Rqz0FWCm8gytRE1LEOk8rAYT0 n3Nmckb8wJNpsXq5hCHhCpu9yZ3EKL0if0X8lF8REO308ToeX8isbl6X4qSGBO7aJbHg aKOsX3V5aGrRb/E8r8plaU6Z6euaZ33fjx7qkfn5Iwp/3L4jT0n1Lp1iaTGRfMzIac1W 1V7m3bwh+ujbv9yjP+4CPNeXrenoL5WRcHySJ0pMoHjU/MXEXB1iUyqLRXYT4EvWSyON HqxhDVk6TQXagGY9hd4SrVZkp3qJNjeUOBs47U7wL3Q/HkWPKFQ6CP/18gYCNbfves/B iDkg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id; bh=mOk7x3sj9VW+oyf1PKODP54+RHY+kq0+ahEXOTzri+Y=; b=ZKwgzV25zd0VdMyoYWrwYanD+bqNnfIcRzjtDd5ZuLz9coSg7OQu+70msKWSivL4zC 2T3mDev34bdzcrcagqOND/2UNg1YN5PA7HuMJQXEC1ve+jj4aLsGkLHmcs5Vo2TXb1us 6fyitWxgH/MUfpUovaMDQd0H6hKP2DCqkpEmefS9Vj1wqF15ckvloEx8mZWi0l4aizkD xwjbUFrm0hnSQvC5gj6/NOUMtsFOqQh4moweLkGqYxPwnDL93AQ3dINyj3ejgwF9jetr HLVTjpZB2Yc5LA40P7g7KircMLUy7HXf4PC352WU095XiQbxgdHGVrIaPotw1D9nxLjE t5gw== X-Gm-Message-State: APjAAAUZm5SpuGNt5gVK9M+NyXaElNhGp0bqLod8S2Q6eLn73syPbeGB LCYGdk6XcbWjMQ3uVDHC+pz9jg== X-Received: by 2002:a05:600c:118a:: with SMTP id i10mr17294501wmf.142.1576867004319; Fri, 20 Dec 2019 10:36:44 -0800 (PST) Received: from localhost.localdomain (amontpellier-657-1-145-216.w83-201.abo.wanadoo.fr. [83.201.136.216]) by smtp.gmail.com with ESMTPSA id v22sm10003628wml.11.2019.12.20.10.36.42 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 20 Dec 2019 10:36:43 -0800 (PST) From: Loic Poulain To: wsa@the-dreams.de, robh+dt@kernel.org Cc: vkoul@kernel.org, todor.too@gmail.com, linux-i2c@vger.kernel.org, Loic Poulain , Todor Tomov Subject: [PATCH 1/2] i2c: Add Qualcomm CCI I2C driver Date: Fri, 20 Dec 2019 19:39:42 +0100 Message-Id: <1576867183-22668-1-git-send-email-loic.poulain@linaro.org> X-Mailer: git-send-email 2.7.4 Sender: linux-i2c-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-i2c@vger.kernel.org This commit adds I2C bus support for the Camera Control Interface (CCI) I2C controller found on the Qualcomm SoC processors. This I2C controller supports two masters and they are registered to the core. CCI versions supported in the driver are MSM8916 and MSM8996. This is a rework of the patch posted by Vinod: https://patchwork.kernel.org/patch/10569961/ With additional fixes + most of the comments addressed. Signed-off-by: Todor Tomov Signed-off-by: Vinod Koul Signed-off-by: Loic Poulain --- drivers/i2c/busses/Kconfig | 10 + drivers/i2c/busses/Makefile | 1 + drivers/i2c/busses/i2c-qcom-cci.c | 853 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 864 insertions(+) create mode 100644 drivers/i2c/busses/i2c-qcom-cci.c -- 2.7.4 diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig index 6a0aa76..807a052 100644 --- a/drivers/i2c/busses/Kconfig +++ b/drivers/i2c/busses/Kconfig @@ -894,6 +894,16 @@ config I2C_QCOM_GENI This driver can also be built as a module. If so, the module will be called i2c-qcom-geni. +config I2C_QCOM_CCI + tristate "Qualcomm Camera Control Interface" + depends on ARCH_QCOM || COMPILE_TEST + help + If you say yes to this option, support will be included for the + built-in camera control interface on the Qualcomm SoCs. + + This driver can also be built as a module. If so, the module + will be called i2c-qcom-cci. + config I2C_QUP tristate "Qualcomm QUP based I2C controller" depends on ARCH_QCOM diff --git a/drivers/i2c/busses/Makefile b/drivers/i2c/busses/Makefile index 3ab8aeb..9028b77 100644 --- a/drivers/i2c/busses/Makefile +++ b/drivers/i2c/busses/Makefile @@ -92,6 +92,7 @@ obj-$(CONFIG_I2C_PUV3) += i2c-puv3.o obj-$(CONFIG_I2C_PXA) += i2c-pxa.o obj-$(CONFIG_I2C_PXA_PCI) += i2c-pxa-pci.o obj-$(CONFIG_I2C_QCOM_GENI) += i2c-qcom-geni.o +obj-$(CONFIG_I2C_QCOM_CCI) += i2c-qcom-cci.o obj-$(CONFIG_I2C_QUP) += i2c-qup.o obj-$(CONFIG_I2C_RIIC) += i2c-riic.o obj-$(CONFIG_I2C_RK3X) += i2c-rk3x.o diff --git a/drivers/i2c/busses/i2c-qcom-cci.c b/drivers/i2c/busses/i2c-qcom-cci.c new file mode 100644 index 0000000..98c319c --- /dev/null +++ b/drivers/i2c/busses/i2c-qcom-cci.c @@ -0,0 +1,853 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2012-2016, The Linux Foundation. All rights reserved. +// Copyright (c) 2017-19 Linaro Limited. + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define CCI_HW_VERSION 0x0 +#define CCI_RESET_CMD 0x004 +#define CCI_RESET_CMD_MASK 0x0f73f3f7 +#define CCI_RESET_CMD_M0_MASK 0x000003f1 +#define CCI_RESET_CMD_M1_MASK 0x0003f001 +#define CCI_QUEUE_START 0x008 +#define CCI_HALT_REQ 0x034 +#define CCI_HALT_REQ_I2C_M0_Q0Q1 BIT(0) +#define CCI_HALT_REQ_I2C_M1_Q0Q1 BIT(1) + +#define CCI_I2C_Mm_SCL_CTL(m) (0x100 + 0x100 * (m)) +#define CCI_I2C_Mm_SDA_CTL_0(m) (0x104 + 0x100 * (m)) +#define CCI_I2C_Mm_SDA_CTL_1(m) (0x108 + 0x100 * (m)) +#define CCI_I2C_Mm_SDA_CTL_2(m) (0x10c + 0x100 * (m)) +#define CCI_I2C_Mm_MISC_CTL(m) (0x110 + 0x100 * (m)) + +#define CCI_I2C_Mm_READ_DATA(m) (0x118 + 0x100 * (m)) +#define CCI_I2C_Mm_READ_BUF_LEVEL(m) (0x11c + 0x100 * (m)) +#define CCI_I2C_Mm_Qn_EXEC_WORD_CNT(m, n) (0x300 + 0x200 * (m) + 0x100 * (n)) +#define CCI_I2C_Mm_Qn_CUR_WORD_CNT(m, n) (0x304 + 0x200 * (m) + 0x100 * (n)) +#define CCI_I2C_Mm_Qn_CUR_CMD(m, n) (0x308 + 0x200 * (m) + 0x100 * (n)) +#define CCI_I2C_Mm_Qn_REPORT_STATUS(m, n) (0x30c + 0x200 * (m) + 0x100 * (n)) +#define CCI_I2C_Mm_Qn_LOAD_DATA(m, n) (0x310 + 0x200 * (m) + 0x100 * (n)) + +#define CCI_IRQ_GLOBAL_CLEAR_CMD 0xc00 +#define CCI_IRQ_MASK_0 0xc04 +#define CCI_IRQ_MASK_0_I2C_M0_RD_DONE BIT(0) +#define CCI_IRQ_MASK_0_I2C_M0_Q0_REPORT BIT(4) +#define CCI_IRQ_MASK_0_I2C_M0_Q1_REPORT BIT(8) +#define CCI_IRQ_MASK_0_I2C_M1_RD_DONE BIT(12) +#define CCI_IRQ_MASK_0_I2C_M1_Q0_REPORT BIT(16) +#define CCI_IRQ_MASK_0_I2C_M1_Q1_REPORT BIT(20) +#define CCI_IRQ_MASK_0_RST_DONE_ACK BIT(24) +#define CCI_IRQ_MASK_0_I2C_M0_Q0Q1_HALT_ACK BIT(25) +#define CCI_IRQ_MASK_0_I2C_M1_Q0Q1_HALT_ACK BIT(26) +#define CCI_IRQ_MASK_0_I2C_M0_ERROR 0x18000ee6 +#define CCI_IRQ_MASK_0_I2C_M1_ERROR 0x60ee6000 +#define CCI_IRQ_CLEAR_0 0xc08 +#define CCI_IRQ_STATUS_0 0xc0c +#define CCI_IRQ_STATUS_0_I2C_M0_RD_DONE BIT(0) +#define CCI_IRQ_STATUS_0_I2C_M0_Q0_REPORT BIT(4) +#define CCI_IRQ_STATUS_0_I2C_M0_Q1_REPORT BIT(8) +#define CCI_IRQ_STATUS_0_I2C_M1_RD_DONE BIT(12) +#define CCI_IRQ_STATUS_0_I2C_M1_Q0_REPORT BIT(16) +#define CCI_IRQ_STATUS_0_I2C_M1_Q1_REPORT BIT(20) +#define CCI_IRQ_STATUS_0_RST_DONE_ACK BIT(24) +#define CCI_IRQ_STATUS_0_I2C_M0_Q0Q1_HALT_ACK BIT(25) +#define CCI_IRQ_STATUS_0_I2C_M1_Q0Q1_HALT_ACK BIT(26) +#define CCI_IRQ_STATUS_0_I2C_M0_ERROR 0x18000ee6 +#define CCI_IRQ_STATUS_0_I2C_M1_ERROR 0x60ee6000 + +#define CCI_TIMEOUT (msecs_to_jiffies(100)) +#define NUM_MASTERS 2 +#define NUM_QUEUES 2 + +/* Max number of resources + 1 for a NULL terminator */ +#define CCI_RES_MAX 6 + + +#define CCI_I2C_SET_PARAM 1 +#define CCI_I2C_WAIT 2 +#define CCI_I2C_WAIT_SYNC 3 +#define CCI_I2C_WAIT_GPIO_EVENT 4 +#define CCI_I2C_TRIG_I2C_EVENT 5 +#define CCI_I2C_LOCK 6 +#define CCI_I2C_UNLOCK 7 +#define CCI_I2C_REPORT 8 +#define CCI_I2C_WRITE 9 +#define CCI_I2C_READ 10 +#define CCI_I2C_WRITE_DISABLE_P 11 +#define CCI_I2C_READ_DISABLE_P 12 + + +#define CCI_I2C_REPORT_IRQ_EN BIT(8) + +enum { + I2C_MODE_STANDARD, + I2C_MODE_FAST, + I2C_MODE_FAST_PLUS, +}; + +enum cci_i2c_queue_t { + QUEUE_0, + QUEUE_1 +}; + +struct cci_res { + char *clock[CCI_RES_MAX]; + u32 clock_rate[CCI_RES_MAX]; +}; + +struct hw_params { + u16 thigh; /* HIGH period of the SCL clock in clock ticks */ + u16 tlow; /* LOW period of the SCL clock */ + u16 tsu_sto; /* set-up time for STOP condition */ + u16 tsu_sta; /* set-up time for a repeated START condition */ + u16 thd_dat; /* data hold time */ + u16 thd_sta; /* hold time (repeated) START condition */ + u16 tbuf; /* bus free time between a STOP and START condition */ + u8 scl_stretch_en; + u16 trdhld; + u16 tsp; /* pulse width of spikes suppressed by the input filter */ +}; + +struct cci; + +struct cci_master { + struct i2c_adapter adap; + u16 master; + u8 mode; + int status; + struct completion irq_complete; + struct cci *cci; +}; + +struct cci_data { + unsigned int num_masters; + struct i2c_adapter_quirks quirks; + u16 queue_size[NUM_QUEUES]; + struct cci_res res; + struct hw_params params[3]; +}; + +struct cci { + struct device *dev; + void __iomem *base; + unsigned int irq; + const struct cci_data *data; + struct clk_bulk_data *clock; + int nclocks; + struct cci_master master[NUM_MASTERS]; +}; + +/** + * cci_clock_set_rate() - Set clock frequency rates + * @nclocks: Number of clocks + * @clock: Clock array + * @clock_freq: Clock frequency rate array + * @dev: Device + * + * Return 0 on success or a negative error code otherwise + */ +static int cci_clock_set_rate(int nclocks, struct clk_bulk_data *clock, + const u32 *clock_freq, struct device *dev) +{ + int i, ret; + long rate; + + for (i = 0; i < nclocks; i++) { + if (clock_freq[i]) { + rate = clk_round_rate(clock[i].clk, clock_freq[i]); + if (rate < 0) { + dev_err(dev, "clk round rate failed: %ld\n", + rate); + return rate; + } + + ret = clk_set_rate(clock[i].clk, clock_freq[i]); + if (ret < 0) { + dev_err(dev, "clk set rate failed: %d\n", ret); + return ret; + } + } + } + + return 0; +} + +static irqreturn_t cci_isr(int irq, void *dev) +{ + struct cci *cci = dev; + u32 val, reset = 0; + int ret = IRQ_NONE; + + val = readl(cci->base + CCI_IRQ_STATUS_0); + writel(val, cci->base + CCI_IRQ_CLEAR_0); + writel(0x1, cci->base + CCI_IRQ_GLOBAL_CLEAR_CMD); + + if (val & CCI_IRQ_STATUS_0_RST_DONE_ACK) { + complete(&cci->master[0].irq_complete); + if (cci->master[1].master) + complete(&cci->master[1].irq_complete); + ret = IRQ_HANDLED; + } + + if (val & CCI_IRQ_STATUS_0_I2C_M0_RD_DONE || + val & CCI_IRQ_STATUS_0_I2C_M0_Q0_REPORT || + val & CCI_IRQ_STATUS_0_I2C_M0_Q1_REPORT) { + cci->master[0].status = 0; + complete(&cci->master[0].irq_complete); + ret = IRQ_HANDLED; + } + + if (val & CCI_IRQ_STATUS_0_I2C_M1_RD_DONE || + val & CCI_IRQ_STATUS_0_I2C_M1_Q0_REPORT || + val & CCI_IRQ_STATUS_0_I2C_M1_Q1_REPORT) { + cci->master[1].status = 0; + complete(&cci->master[1].irq_complete); + ret = IRQ_HANDLED; + } + + if (unlikely(val & CCI_IRQ_STATUS_0_I2C_M0_Q0Q1_HALT_ACK)) { + reset = CCI_RESET_CMD_M0_MASK; + ret = IRQ_HANDLED; + } + + if (unlikely(val & CCI_IRQ_STATUS_0_I2C_M1_Q0Q1_HALT_ACK)) { + reset = CCI_RESET_CMD_M1_MASK; + ret = IRQ_HANDLED; + } + + if (unlikely(reset)) + writel(reset, cci->base + CCI_RESET_CMD); + + if (unlikely(val & CCI_IRQ_STATUS_0_I2C_M0_ERROR)) { + dev_err_ratelimited(cci->dev, "Master 0 error 0x%08x\n", val); + cci->master[0].status = -EIO; + writel(CCI_HALT_REQ_I2C_M0_Q0Q1, cci->base + CCI_HALT_REQ); + ret = IRQ_HANDLED; + } + + if (unlikely(val & CCI_IRQ_STATUS_0_I2C_M1_ERROR)) { + dev_err_ratelimited(cci->dev, "Master 1 error 0x%08x\n", val); + cci->master[1].status = -EIO; + writel(CCI_HALT_REQ_I2C_M1_Q0Q1, cci->base + CCI_HALT_REQ); + ret = IRQ_HANDLED; + } + + return ret; +} + +static int cci_halt(struct cci *cci, u8 master_num) +{ + struct cci_master *master; + u32 val; + + if (master_num > 1) { + dev_err(cci->dev, "Unsupported master idx (%u)\n", master_num); + return -EINVAL; + } + + val = BIT(master_num); + master = &cci->master[master_num]; + + reinit_completion(&master->irq_complete); + writel(val, cci->base + CCI_HALT_REQ); + + if (!wait_for_completion_timeout(&master->irq_complete, CCI_TIMEOUT)) { + dev_err(cci->dev, "CCI halt timeout\n"); + return -ETIMEDOUT; + } + + return 0; +} + +static int cci_reset(struct cci *cci) +{ + /* + * we reset the whole controller, here and for implicity use + * master[0].xxx for waiting on it. + */ + reinit_completion(&cci->master[0].irq_complete); + writel(CCI_RESET_CMD_MASK, cci->base + CCI_RESET_CMD); + + if (!wait_for_completion_timeout(&cci->master[0].irq_complete, + CCI_TIMEOUT)) { + dev_err(cci->dev, "CCI reset timeout\n"); + return -ETIMEDOUT; + } + + return 0; +} + +static int cci_init(struct cci *cci, const struct hw_params *hw) +{ + u32 val = CCI_IRQ_MASK_0_I2C_M0_RD_DONE | + CCI_IRQ_MASK_0_I2C_M0_Q0_REPORT | + CCI_IRQ_MASK_0_I2C_M0_Q1_REPORT | + CCI_IRQ_MASK_0_I2C_M1_RD_DONE | + CCI_IRQ_MASK_0_I2C_M1_Q0_REPORT | + CCI_IRQ_MASK_0_I2C_M1_Q1_REPORT | + CCI_IRQ_MASK_0_RST_DONE_ACK | + CCI_IRQ_MASK_0_I2C_M0_Q0Q1_HALT_ACK | + CCI_IRQ_MASK_0_I2C_M1_Q0Q1_HALT_ACK | + CCI_IRQ_MASK_0_I2C_M0_ERROR | + CCI_IRQ_MASK_0_I2C_M1_ERROR; + int i; + + writel(val, cci->base + CCI_IRQ_MASK_0); + + for (i = 0; i < cci->data->num_masters; i++) { + val = hw->thigh << 16 | hw->tlow; + writel(val, cci->base + CCI_I2C_Mm_SCL_CTL(i)); + + val = hw->tsu_sto << 16 | hw->tsu_sta; + writel(val, cci->base + CCI_I2C_Mm_SDA_CTL_0(i)); + + val = hw->thd_dat << 16 | hw->thd_sta; + writel(val, cci->base + CCI_I2C_Mm_SDA_CTL_1(i)); + + val = hw->tbuf; + writel(val, cci->base + CCI_I2C_Mm_SDA_CTL_2(i)); + + val = hw->scl_stretch_en << 8 | hw->trdhld << 4 | hw->tsp; + writel(val, cci->base + CCI_I2C_Mm_MISC_CTL(i)); + } + + return 0; +} + +static int cci_run_queue(struct cci *cci, u8 master, u8 queue) +{ + u32 val; + int ret; + + val = readl(cci->base + CCI_I2C_Mm_Qn_CUR_WORD_CNT(master, queue)); + writel(val, cci->base + CCI_I2C_Mm_Qn_EXEC_WORD_CNT(master, queue)); + + reinit_completion(&cci->master[master].irq_complete); + val = BIT(master * 2 + queue); + writel(val, cci->base + CCI_QUEUE_START); + + if (!wait_for_completion_timeout(&cci->master[master].irq_complete, + CCI_TIMEOUT)) { + dev_err(cci->dev, "master %d queue %d timeout\n", + master, queue); + + cci_halt(cci, master); + + return -ETIMEDOUT; + } + + ret = cci->master[master].status; + if (ret < 0) + dev_err(cci->dev, "master %d queue %d error %d\n", + master, queue, ret); + + return ret; +} + +static int cci_validate_queue(struct cci *cci, u8 master, u8 queue) +{ + u32 val; + + val = readl(cci->base + CCI_I2C_Mm_Qn_CUR_WORD_CNT(master, queue)); + if (val == cci->data->queue_size[queue]) + return -EINVAL; + + if (!val) + return 0; + + val = CCI_I2C_REPORT | CCI_I2C_REPORT_IRQ_EN; + writel(val, cci->base + CCI_I2C_Mm_Qn_LOAD_DATA(master, queue)); + + return cci_run_queue(cci, master, queue); +} + +static int cci_i2c_read(struct cci *cci, u16 master, + u16 addr, u8 *buf, u16 len) +{ + u32 val, words_read, words_exp; + u8 queue = QUEUE_1; + int i, index = 0, ret; + bool first = true; + + /* + * Call validate queue to make sure queue is empty before starting. + * This is to avoid overflow / underflow of queue. + */ + ret = cci_validate_queue(cci, master, queue); + if (ret < 0) + return ret; + + val = CCI_I2C_SET_PARAM | (addr & 0x7f) << 4; + writel(val, cci->base + CCI_I2C_Mm_Qn_LOAD_DATA(master, queue)); + + val = CCI_I2C_READ | len << 4; + writel(val, cci->base + CCI_I2C_Mm_Qn_LOAD_DATA(master, queue)); + + ret = cci_run_queue(cci, master, queue); + if (ret < 0) + return ret; + + words_read = readl(cci->base + CCI_I2C_Mm_READ_BUF_LEVEL(master)); + words_exp = len / 4 + 1; + if (words_read != words_exp) { + dev_err(cci->dev, "words read = %d, words expected = %d\n", + words_read, words_exp); + return -EIO; + } + + do { + val = readl(cci->base + CCI_I2C_Mm_READ_DATA(master)); + + for (i = 0; i < 4 && index < len; i++) { + if (first) { + first = false; + continue; + } + buf[index++] = (val >> (i * 8)) & 0xff; + } + } while (--words_read); + + return 0; +} + +static int cci_i2c_write(struct cci *cci, u16 master, + u16 addr, u8 *buf, u16 len) +{ + u8 queue = QUEUE_0; + u8 load[12] = { 0 }; + int i = 0, j, ret; + u32 val; + + /* + * Call validate queue to make sure queue is empty before starting. + * This is to avoid overflow / underflow of queue. + */ + ret = cci_validate_queue(cci, master, queue); + if (ret < 0) + return ret; + + val = CCI_I2C_SET_PARAM | (addr & 0x7f) << 4; + writel(val, cci->base + CCI_I2C_Mm_Qn_LOAD_DATA(master, queue)); + + load[i++] = CCI_I2C_WRITE | len << 4; + + for (j = 0; j < len; j++) + load[i++] = buf[j]; + + for (j = 0; j < i; j += 4) { + val = load[j]; + val |= load[j + 1] << 8; + val |= load[j + 2] << 16; + val |= load[j + 3] << 24; + writel(val, cci->base + CCI_I2C_Mm_Qn_LOAD_DATA(master, queue)); + } + + val = CCI_I2C_REPORT | CCI_I2C_REPORT_IRQ_EN; + writel(val, cci->base + CCI_I2C_Mm_Qn_LOAD_DATA(master, queue)); + + return cci_run_queue(cci, master, queue); +} + +static int cci_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num) +{ + struct cci_master *cci_master = i2c_get_adapdata(adap); + struct cci *cci = cci_master->cci; + int i, ret; + + ret = pm_runtime_get_sync(cci->dev); + if (ret < 0) + goto err; + + for (i = 0; i < num; i++) { + if (msgs[i].flags & I2C_M_RD) + ret = cci_i2c_read(cci, cci_master->master, + msgs[i].addr, msgs[i].buf, + msgs[i].len); + else + ret = cci_i2c_write(cci, cci_master->master, + msgs[i].addr, msgs[i].buf, + msgs[i].len); + + if (ret < 0) { + dev_err(cci->dev, "cci i2c xfer error %d", ret); + break; + } + } + + if (!ret) + ret = num; + +err: + pm_runtime_mark_last_busy(cci->dev); + pm_runtime_put_autosuspend(cci->dev); + + return ret; +} + +static u32 cci_func(struct i2c_adapter *adap) +{ + return I2C_FUNC_I2C; +} + +static const struct i2c_algorithm cci_algo = { + .master_xfer = cci_xfer, + .functionality = cci_func, +}; + +static int cci_enable_clocks(struct cci *cci) +{ + int ret; + + ret = clk_bulk_prepare_enable(cci->nclocks, cci->clock); + if (ret < 0) + dev_err(cci->dev, "Bulk clock prepare failed: %d\n", ret); + + return ret; +} + +static void cci_disable_clocks(struct cci *cci) +{ + clk_bulk_disable_unprepare(cci->nclocks, cci->clock); +} + +#ifdef CONFIG_PM +static int cci_suspend_runtime(struct device *dev) +{ + struct cci *cci = dev_get_drvdata(dev); + + dev_dbg(dev, "Supend invoked\n"); + cci_disable_clocks(cci); + return 0; +} + +static int cci_resume_runtime(struct device *dev) +{ + struct cci *cci = dev_get_drvdata(dev); + + dev_dbg(dev, "Resume invoked\n"); + return cci_enable_clocks(cci); +} +#endif + +#ifdef CONFIG_PM_SLEEP +static int cci_suspend(struct device *dev) +{ + if (!pm_runtime_suspended(dev)) + return cci_suspend_runtime(dev); + + return 0; +} + +static int cci_resume(struct device *dev) +{ + cci_resume_runtime(dev); + pm_runtime_mark_last_busy(dev); + pm_request_autosuspend(dev); + + return 0; +} +#endif + +static const struct dev_pm_ops qcom_cci_pm = { + SET_SYSTEM_SLEEP_PM_OPS(cci_suspend, cci_resume) + SET_RUNTIME_PM_OPS(cci_suspend_runtime, cci_resume_runtime, NULL) +}; + +static int cci_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct device_node *of_node = NULL; + struct resource *r; + struct cci *cci; + int ret = 0, i; + u32 val; + + cci = devm_kzalloc(dev, sizeof(*cci), GFP_KERNEL); + if (!cci) + return -ENOMEM; + + cci->dev = dev; + platform_set_drvdata(pdev, cci); + cci->data = device_get_match_data(&pdev->dev); + if (!cci->data) { + dev_err(&pdev->dev, "Driver data is null, abort\n"); + return -EIO; + } + + for (i = 0; i < cci->data->num_masters; i++) { + cci->master[i].adap.quirks = &cci->data->quirks; + cci->master[i].adap.algo = &cci_algo; + cci->master[i].adap.dev.parent = cci->dev; + cci->master[i].master = i; + cci->master[i].cci = cci; + + i2c_set_adapdata(&cci->master[i].adap, &cci->master[i]); + snprintf(cci->master[i].adap.name, + sizeof(cci->master[i].adap.name), + "Qualcomm Camera Control Interface: %d", i); + + /* find the child node for i2c-bus as we are on cci node */ + of_node = of_get_next_available_child(dev->of_node, of_node); + if (!of_node) { + dev_err(dev, "Missing i2c-bus@%d child node\n", i); + return -EINVAL; + } + cci->master[i].adap.dev.of_node = of_node; + + cci->master[i].mode = I2C_MODE_STANDARD; + ret = of_property_read_u32(of_node, "clock-frequency", &val); + if (!ret) { + if (val == 400000) + cci->master[i].mode = I2C_MODE_FAST; + else if (val == 1000000) + cci->master[i].mode = I2C_MODE_FAST_PLUS; + } + + init_completion(&cci->master[i].irq_complete); + } + + /* Memory */ + + r = platform_get_resource(pdev, IORESOURCE_MEM, 0); + cci->base = devm_ioremap_resource(dev, r); + if (IS_ERR(cci->base)) + return PTR_ERR(cci->base); + + /* Interrupt */ + + ret = platform_get_irq(pdev, 0); + if (ret < 0) { + dev_err(dev, "missing IRQ: %d\n", ret); + return ret; + } + cci->irq = ret; + + ret = devm_request_irq(dev, cci->irq, cci_isr, + IRQF_TRIGGER_RISING, dev_name(dev), cci); + if (ret < 0) { + dev_err(dev, "request_irq failed, ret: %d\n", ret); + return ret; + } + + disable_irq(cci->irq); + + /* Clocks */ + + cci->nclocks = 0; + while (cci->data->res.clock[cci->nclocks]) + cci->nclocks++; + + cci->clock = devm_kcalloc(dev, cci->nclocks, + sizeof(*cci->clock), GFP_KERNEL); + if (!cci->clock) + return -ENOMEM; + + for (i = 0; i < cci->nclocks; i++) + cci->clock[i].id = cci->data->res.clock[i]; + + ret = devm_clk_bulk_get(dev, cci->nclocks, cci->clock); + if (ret < 0) + return ret; + + ret = cci_clock_set_rate(cci->nclocks, cci->clock, + cci->data->res.clock_rate, dev); + if (ret < 0) + return ret; + + ret = cci_enable_clocks(cci); + if (ret < 0) + return ret; + + pm_runtime_set_autosuspend_delay(dev, MSEC_PER_SEC); + pm_runtime_use_autosuspend(dev); + pm_runtime_set_active(dev); + pm_runtime_enable(dev); + + val = readl_relaxed(cci->base + CCI_HW_VERSION); + dev_dbg(dev, "%s: CCI HW version = 0x%08x", __func__, val); + + enable_irq(cci->irq); + + ret = cci_reset(cci); + if (ret < 0) + goto error; + + for (i = 0; i < cci->data->num_masters; i++) { + ret = cci_init(cci, &cci->data->params[cci->master[i].mode]); + if (ret < 0) + goto pm_error; + + ret = i2c_add_adapter(&cci->master[i].adap); + if (ret < 0) + goto error_i2c; + } + + return 0; + +error_i2c: + for (; i >= 0; i--) + i2c_del_adapter(&cci->master[i].adap); +pm_error: + pm_runtime_disable(dev); + pm_runtime_set_suspended(dev); +error: + disable_irq(cci->irq); + cci_disable_clocks(cci); + + return ret; +} + +static int cci_remove(struct platform_device *pdev) +{ + struct cci *cci = platform_get_drvdata(pdev); + int i; + + for (i = 0; i < cci->data->num_masters; i++) { + i2c_del_adapter(&cci->master[i].adap); + cci_halt(cci, i); + } + + disable_irq(cci->irq); + pm_runtime_disable(&pdev->dev); + pm_runtime_set_suspended(&pdev->dev); + + return 0; +} + +static const struct cci_data cci_8916_data = { + .num_masters = 1, + .queue_size = { 64, 16 }, + .quirks = { + .max_write_len = 10, + .max_read_len = 12, + }, + .res = { + .clock = { + "camss_top_ahb", + "cci_ahb", + "camss_ahb", + "cci" + }, + .clock_rate = { + 0, + 80000000, + 0, + 19200000 + }, + }, + .params[I2C_MODE_STANDARD] = { + .thigh = 78, + .tlow = 114, + .tsu_sto = 28, + .tsu_sta = 28, + .thd_dat = 10, + .thd_sta = 77, + .tbuf = 118, + .scl_stretch_en = 0, + .trdhld = 6, + .tsp = 1 + }, + .params[I2C_MODE_FAST] = { + .thigh = 20, + .tlow = 28, + .tsu_sto = 21, + .tsu_sta = 21, + .thd_dat = 13, + .thd_sta = 18, + .tbuf = 32, + .scl_stretch_en = 0, + .trdhld = 6, + .tsp = 3 + }, +}; + +static const struct cci_data cci_8996_data = { + .num_masters = 2, + .queue_size = { 64, 16 }, + .quirks = { + .max_write_len = 11, + .max_read_len = 12, + }, + .res = { + .clock = { + "camss_top_ahb", + "cci_ahb", + "camss_ahb", + "cci" + }, + .clock_rate = { + 0, + 0, + 0, + 37500000 + }, + }, + .params[I2C_MODE_STANDARD] = { + .thigh = 201, + .tlow = 174, + .tsu_sto = 204, + .tsu_sta = 231, + .thd_dat = 22, + .thd_sta = 162, + .tbuf = 227, + .scl_stretch_en = 0, + .trdhld = 6, + .tsp = 3 + }, + .params[I2C_MODE_FAST] = { + .thigh = 38, + .tlow = 56, + .tsu_sto = 40, + .tsu_sta = 40, + .thd_dat = 22, + .thd_sta = 35, + .tbuf = 62, + .scl_stretch_en = 0, + .trdhld = 6, + .tsp = 3 + }, + .params[I2C_MODE_FAST_PLUS] = { + .thigh = 16, + .tlow = 22, + .tsu_sto = 17, + .tsu_sta = 18, + .thd_dat = 16, + .thd_sta = 15, + .tbuf = 24, + .scl_stretch_en = 0, + .trdhld = 3, + .tsp = 3 + }, +}; + +static const struct of_device_id cci_dt_match[] = { + { .compatible = "qcom,msm8916-cci", .data = &cci_8916_data}, + { .compatible = "qcom,msm8996-cci", .data = &cci_8996_data}, + {} +}; +MODULE_DEVICE_TABLE(of, cci_dt_match); + +static struct platform_driver qcom_cci_driver = { + .probe = cci_probe, + .remove = cci_remove, + .driver = { + .name = "i2c-qcom-cci", + .of_match_table = cci_dt_match, + .pm = &qcom_cci_pm, + }, +}; + +module_platform_driver(qcom_cci_driver); + +MODULE_DESCRIPTION("Qualcomm Camera Control Interface driver"); +MODULE_AUTHOR("Todor Tomov "); +MODULE_AUTHOR("Loic Poulain "); +MODULE_LICENSE("GPL v2"); From patchwork Fri Dec 20 18:39:43 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Loic Poulain X-Patchwork-Id: 182317 Delivered-To: patch@linaro.org Received: by 2002:a92:1f98:0:0:0:0:0 with SMTP id f24csp891756ilf; Fri, 20 Dec 2019 10:39:13 -0800 (PST) X-Google-Smtp-Source: APXvYqwoRUB0K6anwYiRnf2KI6lF01NFMVzyvFfQqHdmUVCOrUuDA3Vyusz5XojqygyKu5hx2jxV X-Received: by 2002:a9d:4d8d:: with SMTP id u13mr15998478otk.299.1576867153644; Fri, 20 Dec 2019 10:39:13 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1576867153; cv=none; d=google.com; s=arc-20160816; b=QRTBKEtaC7wu7/OIAaw3L3K67wF1CbeXaoLJQZVhLdePUxtGp7E2nsDSYmhtVqekV2 8wDq4nzBH6k1g05bo85lB/TXFszTZOV++4ouoOMiGOzP+ixqfpHO5Kt7H4s+bQxKi441 ShFttx46SQWjQrS6LWecCuPUXb7abWuTqNAJWz7/FDLABegHki4sAK65uACavFmT7sjo 6NcZyFJXO4VhC138iNHwFGXi62oqjztZ0nc7ncad+PtfIAkddaFYD8cZjcAq9wAA0M7j n3a7d14DaiCFM+CXzEo1+G22sbXCS6z3v5aNOv28KDX3rqQo1wXWYdYHt9XIQXFOe9f5 nLXA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature; bh=Jk9kFi+e5gZ+j1wdqppVvCkfskMq3T3NszjuLD9FWJ0=; b=yfccaekLHsHv6gvnpHf1DrZCf3PM+8tjWyvTnhaMs2ddV1Jto2p2AMooarFcHackqp t+yEAS0r+jBJMfXzMZs+pK1nVzkIvs5mzZb8O4Z4BikZkyF/cEQ5GGfyL12soGrw3erC fi+bczl7n9U/Jf32KyU43ETenlSqhodQ/PkZoZVdxiOiXnTftra0ZF7nV59NeQJwxH75 irVGk9jqOqI7t2owkEuc8jmib2664HAyYX2sZZlkhpJGCCAw63FfxKDqg/zKKYlfPVR0 SqBcRy+d4E4RbENW8tqr49zqeMqsjiBBeykiQAStnPYXOm4u7UogTxAjtAo9DeaYiWOS 6bww== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=jaxJEXNV; spf=pass (google.com: best guess record for domain of linux-i2c-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-i2c-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id l20si3816567otr.227.2019.12.20.10.39.13; Fri, 20 Dec 2019 10:39:13 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-i2c-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=jaxJEXNV; spf=pass (google.com: best guess record for domain of linux-i2c-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-i2c-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727404AbfLTSjN (ORCPT + 2 others); Fri, 20 Dec 2019 13:39:13 -0500 Received: from mail-wr1-f65.google.com ([209.85.221.65]:41714 "EHLO mail-wr1-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727390AbfLTSjM (ORCPT ); Fri, 20 Dec 2019 13:39:12 -0500 Received: by mail-wr1-f65.google.com with SMTP id c9so10363404wrw.8 for ; Fri, 20 Dec 2019 10:39:11 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=Jk9kFi+e5gZ+j1wdqppVvCkfskMq3T3NszjuLD9FWJ0=; b=jaxJEXNV1Qe0m6DFAy9KihZpvv1BQr6qpWNvFTMwQxt7HC3CeQs42dAZejwWmFBHdq DypYacEAdFRpxBb2gNWxonDOb4hNLNmYls6Op5F45AnIXKEaVV6JusActWHXZn2891VW 37Pt+Vu4RN7bZDbSuCp0ICLySpYam/B02A0DKShV6YieuXNgdf6kXBM1tcjPDARiVBn4 LkxKZzntgOptn3GVZn9hYg5I9VB15qv0KD4U8Jce048bIVCe4MC4r1o8uAdrO8JXHb9A MkFsz3rLzDQzxfbfuARYYAdwI61WAGFfKZLBZFnt2+6BqQ7WM+AaGhahiOh9mfwj6kQz E4yA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=Jk9kFi+e5gZ+j1wdqppVvCkfskMq3T3NszjuLD9FWJ0=; b=UpMVdjbEtJrPfdLo/dr6glGVnJHe9M58hfWCQAS9RIQzjBVzd3O7xXDVmNZH50PuF4 wU8NF9h4A32Gn92gjqBkgiUNbAqFvgsV/zHlFd9jJoF8tSC/350KqikfSl7lwO7s08E/ cn8PIY6Hc3Zs5nzrscHMJUtN9H9fUY42yLngR+57fCP48w4m1dYsFQBq6loTX3X3x5TJ j9gnItFXl4ZdA7ErFxinVdZ6p5BjuMUG6Hfb+R2/2smlAB8fUZ+y1biCKMaRDqTsnzvf edDPUVw6YnF7hnlEKChzzLVY/8JTHmmRifDFUBKEwEKVV0wFzaDr40VrbZlxhrJ9okQM 4D9A== X-Gm-Message-State: APjAAAUboWVaO93QEJUvKJGEDRMQ2ViYPYVv4Y7EDPyk38lZ/m4VDTpU E262iTbCxrGuAWqLHS/nzt3J5g== X-Received: by 2002:a5d:49c3:: with SMTP id t3mr16735799wrs.113.1576867150800; Fri, 20 Dec 2019 10:39:10 -0800 (PST) Received: from localhost.localdomain (amontpellier-657-1-145-216.w83-201.abo.wanadoo.fr. [83.201.136.216]) by smtp.gmail.com with ESMTPSA id v22sm10003628wml.11.2019.12.20.10.39.09 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 20 Dec 2019 10:39:10 -0800 (PST) From: Loic Poulain To: wsa@the-dreams.de, robh+dt@kernel.org Cc: vkoul@kernel.org, todor.too@gmail.com, linux-i2c@vger.kernel.org, Todor Tomov Subject: [PATCH 2/2] dt-bindings: i2c: Add binding for Qualcomm CCI I2C controller Date: Fri, 20 Dec 2019 19:39:43 +0100 Message-Id: <1576867183-22668-2-git-send-email-loic.poulain@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1576867183-22668-1-git-send-email-loic.poulain@linaro.org> References: <1576867183-22668-1-git-send-email-loic.poulain@linaro.org> Sender: linux-i2c-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-i2c@vger.kernel.org From: Todor Tomov Add DT binding document for Qualcomm Camera Control Interface (CCI) I2C controller. Signed-off-by: Todor Tomov Signed-off-by: Vinod Koul Reviewed-by: Rob Herring --- .../devicetree/bindings/i2c/i2c-qcom-cci.txt | 83 ++++++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 Documentation/devicetree/bindings/i2c/i2c-qcom-cci.txt -- 2.7.4 diff --git a/Documentation/devicetree/bindings/i2c/i2c-qcom-cci.txt b/Documentation/devicetree/bindings/i2c/i2c-qcom-cci.txt new file mode 100644 index 0000000..691c7bd --- /dev/null +++ b/Documentation/devicetree/bindings/i2c/i2c-qcom-cci.txt @@ -0,0 +1,83 @@ +Qualcomm Camera Control Interface (CCI) I2C controller + +PROPERTIES: + +- compatible: + Usage: required + Value type: + Definition: must be one of: + "qcom,msm8916-cci" + "qcom,msm8996-cci" + +- reg + Usage: required + Value type: + Definition: base address CCI I2C controller and length of memory + mapped region. + +- interrupts: + Usage: required + Value type: + Definition: specifies the CCI I2C interrupt. The format of the + specifier is defined by the binding document describing + the node's interrupt parent. + +- clocks: + Usage: required + Value type: + Definition: a list of phandle, should contain an entry for each + entries in clock-names. + +- clock-names + Usage: required + Value type: + Definition: a list of clock names, must include these entries: + "mmss_mmagic_ahb" - on "qcom,msm-8996-cci" only; + "camss_top_ahb"; + "cci_ahb"; + "cci"; + "camss_ahb"; + +- power-domains + Usage: required for "qcom,msm-8996-cci" + Value type: + Definition: + +SUBNODES: + +The CCI provides I2C masters for one or two i2c busses, described as +subdevices named "i2c-bus@0" and "i2c-bus@1". + +PROPERTIES: + +- clock-frequency: + Usage: optional + Value type: + Definition: Desired I2C bus clock frequency in Hz, defaults to 100 + kHz if omitted. + +Example: + + cci@a0c000 { + compatible = "qcom,msm-8996-cci"; + #address-cells = <1>; + #size-cells = <0>; + reg = <0xa0c000 0x1000>; + interrupts = ; + clocks = <&mmcc MMSS_MMAGIC_AHB_CLK>, + <&mmcc CAMSS_TOP_AHB_CLK>, + <&mmcc CAMSS_CCI_AHB_CLK>, + <&mmcc CAMSS_CCI_CLK>, + <&mmcc CAMSS_AHB_CLK>; + clock-names = "mmss_mmagic_ahb", + "camss_top_ahb", + "cci_ahb", + "cci", + "camss_ahb"; + i2c-bus@0 { + clock-frequency = <400000>; + }; + i2c-bus@1 { + clock-frequency = <400000>; + }; + };