From mboxrd@z Thu Jan  1 00:00:00 1970
Return-path: <linux-media-owner@vger.kernel.org>
Received: from lb1-smtp-cloud3.xs4all.net ([194.109.24.22]:38051 "EHLO
	lb1-smtp-cloud3.xs4all.net" rhost-flags-OK-OK-OK-OK)
	by vger.kernel.org with ESMTP id S1752438AbcD2JjS (ORCPT
	<rfc822;linux-media@vger.kernel.org>);
	Fri, 29 Apr 2016 05:39:18 -0400
From: Hans Verkuil <hverkuil@xs4all.nl>
To: linux-media@vger.kernel.org
Cc: tomi.valkeinen@ti.com, dri-devel@lists.freedesktop.org,
	Hans Verkuil <hans.verkuil@cisco.com>
Subject: [RFC PATCH 2/3] omap4: add CEC support
Date: Fri, 29 Apr 2016 11:39:05 +0200
Message-Id: <1461922746-17521-3-git-send-email-hverkuil@xs4all.nl>
In-Reply-To: <1461922746-17521-1-git-send-email-hverkuil@xs4all.nl>
References: <1461922746-17521-1-git-send-email-hverkuil@xs4all.nl>
Sender: linux-media-owner@vger.kernel.org
List-ID: <linux-media.vger.kernel.org>

From: Hans Verkuil <hans.verkuil@cisco.com>

Signed-off-by: Hans Verkuil <hans.verkuil@cisco.com>
---
 arch/arm/boot/dts/omap4-panda-a4.dts   |   2 +-
 arch/arm/boot/dts/omap4-panda-es.dts   |   2 +-
 arch/arm/boot/dts/omap4.dtsi           |   5 +-
 drivers/gpu/drm/omapdrm/dss/Kconfig    |   8 +
 drivers/gpu/drm/omapdrm/dss/Makefile   |   3 +
 drivers/gpu/drm/omapdrm/dss/hdmi.h     |  62 ++++++-
 drivers/gpu/drm/omapdrm/dss/hdmi4.c    |  39 +++-
 drivers/gpu/drm/omapdrm/dss/hdmi_cec.c | 329 +++++++++++++++++++++++++++++++++
 8 files changed, 441 insertions(+), 9 deletions(-)
 create mode 100644 drivers/gpu/drm/omapdrm/dss/hdmi_cec.c

diff --git a/arch/arm/boot/dts/omap4-panda-a4.dts b/arch/arm/boot/dts/omap4-panda-a4.dts
index 78d3631..f0c1020 100644
--- a/arch/arm/boot/dts/omap4-panda-a4.dts
+++ b/arch/arm/boot/dts/omap4-panda-a4.dts
@@ -13,7 +13,7 @@
 /* Pandaboard Rev A4+ have external pullups on SCL & SDA */
 &dss_hdmi_pins {
 	pinctrl-single,pins = <
-		OMAP4_IOPAD(0x09a, PIN_INPUT_PULLUP | MUX_MODE0)	/* hdmi_cec.hdmi_cec */
+		OMAP4_IOPAD(0x09a, PIN_INPUT | MUX_MODE0)	/* hdmi_cec.hdmi_cec */
 		OMAP4_IOPAD(0x09c, PIN_INPUT | MUX_MODE0)		/* hdmi_scl.hdmi_scl */
 		OMAP4_IOPAD(0x09e, PIN_INPUT | MUX_MODE0)		/* hdmi_sda.hdmi_sda */
 		>;
diff --git a/arch/arm/boot/dts/omap4-panda-es.dts b/arch/arm/boot/dts/omap4-panda-es.dts
index 119f8e6..940fe4f 100644
--- a/arch/arm/boot/dts/omap4-panda-es.dts
+++ b/arch/arm/boot/dts/omap4-panda-es.dts
@@ -34,7 +34,7 @@
 /* PandaboardES has external pullups on SCL & SDA */
 &dss_hdmi_pins {
 	pinctrl-single,pins = <
-		OMAP4_IOPAD(0x09a, PIN_INPUT_PULLUP | MUX_MODE0)	/* hdmi_cec.hdmi_cec */
+		OMAP4_IOPAD(0x09a, PIN_INPUT | MUX_MODE0)		/* hdmi_cec.hdmi_cec */
 		OMAP4_IOPAD(0x09c, PIN_INPUT | MUX_MODE0)		/* hdmi_scl.hdmi_scl */
 		OMAP4_IOPAD(0x09e, PIN_INPUT | MUX_MODE0)		/* hdmi_sda.hdmi_sda */
 		>;
diff --git a/arch/arm/boot/dts/omap4.dtsi b/arch/arm/boot/dts/omap4.dtsi
index 2bd9c83..1bb490f 100644
--- a/arch/arm/boot/dts/omap4.dtsi
+++ b/arch/arm/boot/dts/omap4.dtsi
@@ -1006,8 +1006,9 @@
 				reg = <0x58006000 0x200>,
 				      <0x58006200 0x100>,
 				      <0x58006300 0x100>,
-				      <0x58006400 0x1000>;
-				reg-names = "wp", "pll", "phy", "core";
+				      <0x58006400 0x900>,
+				      <0x58006D00 0x100>;
+				reg-names = "wp", "pll", "phy", "core", "cec";
 				interrupts = <GIC_SPI 101 IRQ_TYPE_LEVEL_HIGH>;
 				status = "disabled";
 				ti,hwmods = "dss_hdmi";
diff --git a/drivers/gpu/drm/omapdrm/dss/Kconfig b/drivers/gpu/drm/omapdrm/dss/Kconfig
index d1fa730..69638e9 100644
--- a/drivers/gpu/drm/omapdrm/dss/Kconfig
+++ b/drivers/gpu/drm/omapdrm/dss/Kconfig
@@ -71,9 +71,17 @@ config OMAP4_DSS_HDMI
 	bool "HDMI support for OMAP4"
         default y
 	select OMAP2_DSS_HDMI_COMMON
+	select MEDIA_CEC_EDID
 	help
 	  HDMI support for OMAP4 based SoCs.
 
+config OMAP2_DSS_HDMI_CEC
+	bool "Enable HDMI CEC support for OMAP4"
+	depends on OMAP4_DSS_HDMI && MEDIA_CEC
+	default y
+	---help---
+	  When selected the HDMI transmitter will support the CEC feature.
+
 config OMAP5_DSS_HDMI
 	bool "HDMI support for OMAP5"
 	default n
diff --git a/drivers/gpu/drm/omapdrm/dss/Makefile b/drivers/gpu/drm/omapdrm/dss/Makefile
index b651ec9..37eb597 100644
--- a/drivers/gpu/drm/omapdrm/dss/Makefile
+++ b/drivers/gpu/drm/omapdrm/dss/Makefile
@@ -10,6 +10,9 @@ omapdss-$(CONFIG_OMAP2_DSS_SDI) += sdi.o
 omapdss-$(CONFIG_OMAP2_DSS_DSI) += dsi.o
 omapdss-$(CONFIG_OMAP2_DSS_HDMI_COMMON) += hdmi_common.o hdmi_wp.o hdmi_pll.o \
 	hdmi_phy.o
+ifeq ($(CONFIG_OMAP2_DSS_HDMI_CEC),y)
+  omapdss-$(CONFIG_OMAP2_DSS_HDMI_COMMON) += hdmi_cec.o
+endif
 omapdss-$(CONFIG_OMAP4_DSS_HDMI) += hdmi4.o hdmi4_core.o
 omapdss-$(CONFIG_OMAP5_DSS_HDMI) += hdmi5.o hdmi5_core.o
 ccflags-$(CONFIG_OMAP2_DSS_DEBUG) += -DDEBUG
diff --git a/drivers/gpu/drm/omapdrm/dss/hdmi.h b/drivers/gpu/drm/omapdrm/dss/hdmi.h
index 53616b0..7cf8a91 100644
--- a/drivers/gpu/drm/omapdrm/dss/hdmi.h
+++ b/drivers/gpu/drm/omapdrm/dss/hdmi.h
@@ -24,6 +24,7 @@
 #include <linux/platform_device.h>
 #include <linux/hdmi.h>
 #include <video/omapdss.h>
+#include <media/cec.h>
 
 #include "dss.h"
 
@@ -83,6 +84,31 @@
 #define HDMI_TXPHY_PAD_CFG_CTRL			0xC
 #define HDMI_TXPHY_BIST_CONTROL			0x1C
 
+/* HDMI CEC */
+#define HDMI_CEC_DEV_ID                         0x0
+#define HDMI_CEC_SPEC                           0x4
+#define HDMI_CEC_DBG_3                          0x1C
+#define HDMI_CEC_TX_INIT                        0x20
+#define HDMI_CEC_TX_DEST                        0x24
+#define HDMI_CEC_SETUP                          0x38
+#define HDMI_CEC_TX_COMMAND                     0x3C
+#define HDMI_CEC_TX_OPERAND                     0x40
+#define HDMI_CEC_TRANSMIT_DATA                  0x7C
+#define HDMI_CEC_CA_7_0                         0x88
+#define HDMI_CEC_CA_15_8                        0x8C
+#define HDMI_CEC_INT_STATUS_0                   0x98
+#define HDMI_CEC_INT_STATUS_1                   0x9C
+#define HDMI_CEC_INT_ENABLE_0                   0x90
+#define HDMI_CEC_INT_ENABLE_1                   0x94
+#define HDMI_CEC_RX_CONTROL                     0xB0
+#define HDMI_CEC_RX_COUNT                       0xB4
+#define HDMI_CEC_RX_CMD_HEADER                  0xB8
+#define HDMI_CEC_RX_COMMAND                     0xBC
+#define HDMI_CEC_RX_OPERAND                     0xC0
+
+#define HDMI_CEC_TX_FIFO_INT_MASK		0x64
+#define HDMI_CEC_RETRANSMIT_CNT_INT_MASK	0x2
+
 enum hdmi_pll_pwr {
 	HDMI_PLLPWRCMD_ALLOFF = 0,
 	HDMI_PLLPWRCMD_PLLONLY = 1,
@@ -250,6 +276,12 @@ struct hdmi_phy_data {
 	u8 lane_polarity[4];
 };
 
+struct hdmi_cec_data {
+	void __iomem *base;
+	struct cec_adapter *adap;
+	u16 phys_addr;
+};
+
 struct hdmi_core_data {
 	void __iomem *base;
 };
@@ -319,6 +351,33 @@ void hdmi_phy_dump(struct hdmi_phy_data *phy, struct seq_file *s);
 int hdmi_phy_init(struct platform_device *pdev, struct hdmi_phy_data *phy);
 int hdmi_phy_parse_lanes(struct hdmi_phy_data *phy, const u32 *lanes);
 
+/* HDMI CEC funcs */
+#ifdef CONFIG_OMAP2_DSS_HDMI_CEC
+void hdmi_cec_set_phys_addr(struct hdmi_cec_data *cec, u16 pa);
+void hdmi_cec_irq(struct hdmi_cec_data *cec);
+int hdmi_cec_init(struct platform_device *pdev, struct hdmi_cec_data *cec);
+void hdmi_cec_uninit(struct hdmi_cec_data *cec);
+#else
+static inline void hdmi_cec_set_phys_addr(struct hdmi_cec_data *cec, u16 pa)
+{
+}
+
+static inline void hdmi_cec_irq(struct hdmi_cec_data *cec)
+{
+}
+
+static inline int hdmi_cec_init(struct platform_device *pdev,
+				struct hdmi_cec_data *cec)
+{
+	cec->phys_addr = CEC_PHYS_ADDR_INVALID;
+	return 0;
+}
+
+static inline void hdmi_cec_uninit(struct hdmi_cec_data *cec)
+{
+}
+#endif
+
 /* HDMI common funcs */
 int hdmi_parse_lanes_of(struct platform_device *pdev, struct device_node *ep,
 	struct hdmi_phy_data *phy);
@@ -344,6 +403,7 @@ struct omap_hdmi {
 	struct hdmi_wp_data	wp;
 	struct hdmi_pll_data	pll;
 	struct hdmi_phy_data	phy;
+	struct hdmi_cec_data	cec;
 	struct hdmi_core_data	core;
 
 	struct hdmi_config cfg;
@@ -361,7 +421,7 @@ struct omap_hdmi {
 	bool audio_configured;
 	struct omap_dss_audio audio_config;
 
-	/* This lock should be taken when booleans bellow are touched. */
+	/* This lock should be taken when booleans below are touched. */
 	spinlock_t audio_playing_lock;
 	bool audio_playing;
 	bool display_enabled;
diff --git a/drivers/gpu/drm/omapdrm/dss/hdmi4.c b/drivers/gpu/drm/omapdrm/dss/hdmi4.c
index f892ae15..47a60bf 100644
--- a/drivers/gpu/drm/omapdrm/dss/hdmi4.c
+++ b/drivers/gpu/drm/omapdrm/dss/hdmi4.c
@@ -34,6 +34,7 @@
 #include <linux/regulator/consumer.h>
 #include <linux/component.h>
 #include <video/omapdss.h>
+#include <media/cec-edid.h>
 #include <sound/omap-hdmi-audio.h>
 
 #include "hdmi4_core.h"
@@ -69,14 +70,15 @@ static void hdmi_runtime_put(void)
 
 static irqreturn_t hdmi_irq_handler(int irq, void *data)
 {
-	struct hdmi_wp_data *wp = data;
+	struct omap_hdmi *hdmi = data;
+	struct hdmi_wp_data *wp = &hdmi->wp;
 	u32 irqstatus;
 
 	irqstatus = hdmi_wp_get_irqstatus(wp);
 	hdmi_wp_set_irqstatus(wp, irqstatus);
 
 	if ((irqstatus & HDMI_IRQ_LINK_CONNECT) &&
-			irqstatus & HDMI_IRQ_LINK_DISCONNECT) {
+	    (irqstatus & HDMI_IRQ_LINK_DISCONNECT)) {
 		/*
 		 * If we get both connect and disconnect interrupts at the same
 		 * time, turn off the PHY, clear interrupts, and restart, which
@@ -94,6 +96,13 @@ static irqreturn_t hdmi_irq_handler(int irq, void *data)
 	} else if (irqstatus & HDMI_IRQ_LINK_DISCONNECT) {
 		hdmi_wp_set_phy_pwr(wp, HDMI_PHYPWRCMD_LDOON);
 	}
+	if (irqstatus & HDMI_IRQ_CORE) {
+		u32 intr4 = hdmi_read_reg(hdmi->core.base, HDMI_CORE_SYS_INTR4);
+
+		hdmi_write_reg(hdmi->core.base, HDMI_CORE_SYS_INTR4, intr4);
+		if (intr4 & 8)
+			hdmi_cec_irq(&hdmi->cec);
+	}
 
 	return IRQ_HANDLED;
 }
@@ -213,6 +222,12 @@ static int hdmi_power_on_full(struct omap_dss_device *dssdev)
 
 	hdmi4_configure(&hdmi.core, &hdmi.wp, &hdmi.cfg);
 
+	/* Initialize CEC clock divider */
+	/* CEC needs 2MHz clock hence set the devider to 24 to get
+	   48/24=2MHz clock */
+	REG_FLD_MOD(hdmi.wp.base, HDMI_WP_CLK, 0x18, 5, 0);
+	hdmi_cec_set_phys_addr(&hdmi.cec, hdmi.cec.phys_addr);
+
 	/* bypass TV gamma table */
 	dispc_enable_gamma_table(0);
 
@@ -228,7 +243,11 @@ static int hdmi_power_on_full(struct omap_dss_device *dssdev)
 		goto err_vid_enable;
 
 	hdmi_wp_set_irqenable(wp,
-		HDMI_IRQ_LINK_CONNECT | HDMI_IRQ_LINK_DISCONNECT);
+		HDMI_IRQ_LINK_CONNECT | HDMI_IRQ_LINK_DISCONNECT |
+		HDMI_IRQ_CORE);
+
+	/* Unmask CEC interrupt */
+	REG_FLD_MOD(hdmi.core.base, HDMI_CORE_SYS_INTR_UNMASK4, 0x1, 3, 3);
 
 	return 0;
 
@@ -250,6 +269,8 @@ static void hdmi_power_off_full(struct omap_dss_device *dssdev)
 	enum omap_channel channel = dssdev->dispc_channel;
 
 	hdmi_wp_clear_irqenable(&hdmi.wp, 0xffffffff);
+	hdmi.cec.phys_addr = CEC_PHYS_ADDR_INVALID;
+	hdmi_cec_set_phys_addr(&hdmi.cec, hdmi.cec.phys_addr);
 
 	hdmi_wp_video_stop(&hdmi.wp);
 
@@ -488,6 +509,10 @@ static int hdmi_read_edid(struct omap_dss_device *dssdev,
 	}
 
 	r = read_edid(edid, len);
+	if (r >= 256)
+		hdmi.cec.phys_addr = cec_get_edid_phys_addr(edid, r, NULL);
+	else
+		hdmi.cec.phys_addr = CEC_PHYS_ADDR_INVALID;
 
 	if (need_enable)
 		hdmi_core_disable(dssdev);
@@ -724,6 +749,10 @@ static int hdmi4_bind(struct device *dev, struct device *master, void *data)
 	if (r)
 		goto err;
 
+	r = hdmi_cec_init(pdev, &hdmi.cec);
+	if (r)
+		goto err;
+
 	irq = platform_get_irq(pdev, 0);
 	if (irq < 0) {
 		DSSERR("platform_get_irq failed\n");
@@ -733,7 +762,7 @@ static int hdmi4_bind(struct device *dev, struct device *master, void *data)
 
 	r = devm_request_threaded_irq(&pdev->dev, irq,
 			NULL, hdmi_irq_handler,
-			IRQF_ONESHOT, "OMAP HDMI", &hdmi.wp);
+			IRQF_ONESHOT, "OMAP HDMI", &hdmi);
 	if (r) {
 		DSSERR("HDMI IRQ request failed\n");
 		goto err;
@@ -768,6 +797,8 @@ static void hdmi4_unbind(struct device *dev, struct device *master, void *data)
 
 	hdmi_uninit_output(pdev);
 
+	hdmi_cec_uninit(&hdmi.cec);
+
 	hdmi_pll_uninit(&hdmi.pll);
 
 	pm_runtime_disable(&pdev->dev);
diff --git a/drivers/gpu/drm/omapdrm/dss/hdmi_cec.c b/drivers/gpu/drm/omapdrm/dss/hdmi_cec.c
new file mode 100644
index 0000000..d4309df
--- /dev/null
+++ b/drivers/gpu/drm/omapdrm/dss/hdmi_cec.c
@@ -0,0 +1,329 @@
+/*
+ * HDMI CEC
+ *
+ * Based on the CEC code from hdmi_ti_4xxx_ip.c from Android.
+ *
+ * Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com/
+ * Authors: Yong Zhi
+ *	Mythri pk <mythripk@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <video/omapdss.h>
+
+#include "dss.h"
+#include "hdmi.h"
+
+#define HDMI_CORE_CEC_RETRY    200
+
+void hdmi_cec_transmit_fifo_empty(struct hdmi_cec_data *cec, u32 stat1)
+{
+	if (stat1 & 2) {
+		u32 dbg3 = hdmi_read_reg(cec->base, HDMI_CEC_DBG_3);
+
+		cec_transmit_done(cec->adap,
+				  CEC_TX_STATUS_NACK | CEC_TX_STATUS_MAX_RETRIES,
+				  0, (dbg3 >> 4) & 7, 0, 0);
+	} else if (stat1 & 1) {
+		cec_transmit_done(cec->adap,
+				  CEC_TX_STATUS_ARB_LOST | CEC_TX_STATUS_MAX_RETRIES,
+				  0, 0, 0, 0);
+	} else if (stat1 == 0) {
+		cec_transmit_done(cec->adap, CEC_TX_STATUS_OK,
+				  0, 0, 0, 0);
+	}
+}
+
+void hdmi_cec_received_msg(struct hdmi_cec_data *cec)
+{
+	u32 cnt = hdmi_read_reg(cec->base, HDMI_CEC_RX_COUNT) & 0xff;
+
+	/* While there are CEC frames in the FIFO */
+	while (cnt & 0x70) {
+		/* and the frame doesn't have an error */
+		if (!(cnt & 0x80)) {
+			struct cec_msg msg = {};
+			unsigned int i;
+
+			/* then read the message */
+			msg.len = cnt & 0xf;
+			msg.msg[0] = hdmi_read_reg(cec->base, HDMI_CEC_RX_CMD_HEADER) & 0xff;
+			msg.msg[1] = hdmi_read_reg(cec->base, HDMI_CEC_RX_COMMAND) & 0xff;
+			for (i = 0; i < msg.len; i++)
+				msg.msg[2 + i] =
+					hdmi_read_reg(cec->base, HDMI_CEC_RX_OPERAND + i * 4) & 0xff;
+			msg.len += 2;
+			cec_received_msg(cec->adap, &msg);
+		}
+		/* Clear the current frame from the FIFO */
+		hdmi_write_reg(cec->base, HDMI_CEC_RX_CONTROL, 1);
+		/* Wait until the current frame is cleared */
+		while (hdmi_read_reg(cec->base, HDMI_CEC_RX_CONTROL) & 1)
+			udelay(1);
+		/*
+		 * Re-read the count register and loop to see if there are
+		 * more messages in the FIFO.
+		 */
+		cnt = hdmi_read_reg(cec->base, HDMI_CEC_RX_COUNT) & 0xff;
+	}
+}
+
+void hdmi_cec_irq(struct hdmi_cec_data *cec)
+{
+	u32 stat0 = hdmi_read_reg(cec->base, HDMI_CEC_INT_STATUS_0);
+	u32 stat1 = hdmi_read_reg(cec->base, HDMI_CEC_INT_STATUS_1);
+
+	hdmi_write_reg(cec->base, HDMI_CEC_INT_STATUS_0, stat0);
+	hdmi_write_reg(cec->base, HDMI_CEC_INT_STATUS_1, stat1);
+
+	if (stat0 & 0x02)
+		hdmi_cec_received_msg(cec);
+	if (stat0 & 0x40)
+		REG_FLD_MOD(cec->base, HDMI_CEC_DBG_3, 0x1, 7, 7);
+	else if (stat0 & 0x24)
+		hdmi_cec_transmit_fifo_empty(cec, stat1);
+	if (stat1 & 2) {
+		u32 dbg3 = hdmi_read_reg(cec->base, HDMI_CEC_DBG_3);
+
+		cec_transmit_done(cec->adap,
+				  CEC_TX_STATUS_NACK | CEC_TX_STATUS_MAX_RETRIES,
+				  0, (dbg3 >> 4) & 7, 0, 0);
+	} else if (stat1 & 1) {
+		cec_transmit_done(cec->adap,
+				  CEC_TX_STATUS_ARB_LOST | CEC_TX_STATUS_MAX_RETRIES,
+				  0, 0, 0, 0);
+	}
+	if (stat1 & 0x3)
+		REG_FLD_MOD(cec->base, HDMI_CEC_DBG_3, 0x1, 7, 7);
+}
+
+static int hdmi_cec_adap_enable(struct cec_adapter *adap, bool enable)
+{
+	struct hdmi_cec_data *cec = adap->priv;
+	int retry = HDMI_CORE_CEC_RETRY;
+	int temp;
+
+	/* Clear TX FIFO */
+	REG_FLD_MOD(cec->base, HDMI_CEC_DBG_3, 0x1, 7, 7);
+	while (retry) {
+		temp = hdmi_read_reg(cec->base, HDMI_CEC_DBG_3);
+		if (FLD_GET(temp, 7, 7) == 0)
+			break;
+		retry--;
+	}
+	if (retry == 0x0) {
+		pr_err("Could not clear TX FIFO");
+		return -EBUSY;
+	}
+
+	/* Clear RX FIFO */
+	hdmi_write_reg(cec->base, HDMI_CEC_RX_CONTROL, 0x3);
+	retry = HDMI_CORE_CEC_RETRY;
+	while (retry) {
+		temp = hdmi_read_reg(cec->base, HDMI_CEC_RX_CONTROL);
+		if (FLD_GET(temp, 1, 0) == 0)
+			break;
+		retry--;
+	}
+	if (retry == 0x0) {
+		pr_err("Could not clear RX FIFO");
+		return -EBUSY;
+	}
+
+	/* Clear CEC interrupts */
+	hdmi_write_reg(cec->base, HDMI_CEC_INT_STATUS_1,
+		hdmi_read_reg(cec->base, HDMI_CEC_INT_STATUS_1));
+	hdmi_write_reg(cec->base, HDMI_CEC_INT_STATUS_0,
+		hdmi_read_reg(cec->base, HDMI_CEC_INT_STATUS_0));
+
+	/* Enable HDMI core interrupts */
+	if (enable) {
+		/* Enable CEC interrupts */
+		/* Transmit FIFO full/empty event */
+		/* Receiver FIFO not empty event */
+		hdmi_write_reg(cec->base, HDMI_CEC_INT_ENABLE_0, 0x26);
+		/* Frame retransmit count exceeded event */
+		hdmi_write_reg(cec->base, HDMI_CEC_INT_ENABLE_1, 0x0f);
+	} else {
+		hdmi_write_reg(cec->base, HDMI_CEC_INT_ENABLE_0, 0);
+		hdmi_write_reg(cec->base, HDMI_CEC_INT_ENABLE_1, 0);
+		return 0;
+	}
+
+	/* Remove BYpass mode */
+
+	/* cec calibration enable (self clearing) */
+	hdmi_write_reg(cec->base, HDMI_CEC_SETUP, 0x03);
+	msleep(10);
+	hdmi_write_reg(cec->base, HDMI_CEC_SETUP, 0x04);
+
+	temp = hdmi_read_reg(cec->base, HDMI_CEC_SETUP);
+	if (FLD_GET(temp, 4, 4) != 0) {
+		temp = FLD_MOD(temp, 0, 4, 4);
+		hdmi_write_reg(cec->base, HDMI_CEC_SETUP, temp);
+
+		/*
+		 * If we enabled CEC in middle of a CEC messages on CEC n/w,
+		 * we could have start bit irregularity and/or short
+		 * pulse event. Clear them now.
+		 */
+		temp = hdmi_read_reg(cec->base, HDMI_CEC_INT_STATUS_1);
+		temp = FLD_MOD(0x0, 0x5, 2, 0);
+		hdmi_write_reg(cec->base, HDMI_CEC_INT_STATUS_1, temp);
+	}
+	return 0;
+}
+
+static int hdmi_cec_adap_log_addr(struct cec_adapter *adap, u8 log_addr)
+{
+	struct hdmi_cec_data *cec = adap->priv;
+	u32 v;
+
+	if (log_addr == CEC_LOG_ADDR_INVALID) {
+		hdmi_write_reg(cec->base, HDMI_CEC_CA_7_0, 0);
+		hdmi_write_reg(cec->base, HDMI_CEC_CA_15_8, 0);
+		return 0;
+	}
+	if (log_addr <= 7) {
+		v = hdmi_read_reg(cec->base, HDMI_CEC_CA_7_0);
+		v |= 1 << log_addr;
+		hdmi_write_reg(cec->base, HDMI_CEC_CA_7_0, v);
+	} else {
+		v = hdmi_read_reg(cec->base, HDMI_CEC_CA_15_8);
+		v |= 1 << (log_addr - 8);
+		hdmi_write_reg(cec->base, HDMI_CEC_CA_15_8, v);
+	}
+	return 0;
+}
+
+static int hdmi_cec_adap_transmit(struct cec_adapter *adap, u8 attempts,
+				   u32 signal_free_time, struct cec_msg *msg)
+{
+	struct hdmi_cec_data *cec = adap->priv;
+	u32 retry = HDMI_CORE_CEC_RETRY;
+	u32 temp, i = 0;
+
+	/*
+	 * 1. Flush TX FIFO - required as change of initiator ID / destination
+	 *    ID while TX is in progress could result in corrupted message.
+	 * 2. Clear interrupt status registers for TX.
+	 * 3. Set initiator Address, set retry count
+	 * 4. Set Destination Address
+	 * 5. Clear TX interrupt flags - if required
+	 * 6. Set the command
+	 * 7. Transmit
+	 * 8. Check for NACK / ACK - report the same.
+	 */
+
+	/* Clear TX FIFO */
+	REG_FLD_MOD(cec->base, HDMI_CEC_DBG_3, 1, 7, 7);
+
+	while (retry) {
+		temp = hdmi_read_reg(cec->base, HDMI_CEC_DBG_3);
+		if (FLD_GET(temp, 7, 7) == 0)
+			break;
+		udelay(10);
+		retry--;
+	}
+	if (retry == 0x0) {
+		pr_err("Could not clear TX FIFO");
+		pr_err("\n FIFO Reset - retry  : %d - was %d\n",
+			retry, HDMI_CORE_CEC_RETRY);
+		return -EIO;
+	}
+
+	/* Clear TX interrupts */
+	hdmi_write_reg(cec->base, HDMI_CEC_INT_STATUS_0,
+		       HDMI_CEC_TX_FIFO_INT_MASK);
+
+	hdmi_write_reg(cec->base, HDMI_CEC_INT_STATUS_1,
+		       HDMI_CEC_RETRANSMIT_CNT_INT_MASK);
+
+	/* Set the retry count */
+	REG_FLD_MOD(cec->base, HDMI_CEC_DBG_3, attempts - 1, 6, 4);
+
+	/* Set the initiator addresses */
+	hdmi_write_reg(cec->base, HDMI_CEC_TX_INIT, cec_msg_initiator(msg));
+
+	/* Set destination id */
+	temp = cec_msg_destination(msg);
+	if (msg->len == 1)
+		temp |= 0x80;
+	hdmi_write_reg(cec->base, HDMI_CEC_TX_DEST, temp);
+	if (msg->len == 1)
+		return 0;
+
+	/* Setup command and arguments for the command */
+	hdmi_write_reg(cec->base, HDMI_CEC_TX_COMMAND, msg->msg[1]);
+
+	for (i = 0; i < msg->len - 2; i++)
+		hdmi_write_reg(cec->base, HDMI_CEC_TX_OPERAND + i * 4,
+			       msg->msg[2 + i]);
+
+	/* Operand count */
+	hdmi_write_reg(cec->base, HDMI_CEC_TRANSMIT_DATA,
+		       (msg->len - 2) | 0x10);
+	return 0;
+}
+
+void hdmi_cec_set_phys_addr(struct hdmi_cec_data *cec, u16 pa)
+{
+	cec_s_phys_addr(cec->adap, pa, false);
+}
+
+const struct cec_adap_ops hdmi_cec_adap_ops = {
+	.adap_enable = hdmi_cec_adap_enable,
+	.adap_log_addr = hdmi_cec_adap_log_addr,
+	.adap_transmit = hdmi_cec_adap_transmit,
+};
+
+int hdmi_cec_init(struct platform_device *pdev, struct hdmi_cec_data *cec)
+{
+	struct resource *res;
+	u32 caps = CEC_CAP_TRANSMIT | CEC_CAP_LOG_ADDRS |
+		CEC_CAP_PASSTHROUGH | CEC_CAP_RC;
+	unsigned int ret;
+
+	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cec");
+	if (!res) {
+		DSSERR("can't get CEC mem resource\n");
+		return -EINVAL;
+	}
+
+	cec->base = devm_ioremap_resource(&pdev->dev, res);
+	if (IS_ERR(cec->base)) {
+		DSSERR("can't ioremap TX CEC\n");
+		return PTR_ERR(cec->base);
+	}
+
+	cec->adap = cec_allocate_adapter(&hdmi_cec_adap_ops, cec,
+		"omap4", caps, CEC_MAX_LOG_ADDRS, &pdev->dev);
+	ret = PTR_ERR_OR_ZERO(cec->adap);
+	if (ret < 0)
+		return ret;
+	cec->phys_addr = CEC_PHYS_ADDR_INVALID;
+	ret = cec_register_adapter(cec->adap);
+	if (ret < 0) {
+		cec_delete_adapter(cec->adap);
+		return ret;
+	}
+	return 0;
+}
+
+void hdmi_cec_uninit(struct hdmi_cec_data *cec)
+{
+	cec_unregister_adapter(cec->adap);
+}
-- 
2.8.1


From mboxrd@z Thu Jan  1 00:00:00 1970
From: Hans Verkuil <hverkuil@xs4all.nl>
Subject: [RFC PATCH 2/3] omap4: add CEC support
Date: Fri, 29 Apr 2016 11:39:05 +0200
Message-ID: <1461922746-17521-3-git-send-email-hverkuil@xs4all.nl>
References: <1461922746-17521-1-git-send-email-hverkuil@xs4all.nl>
Mime-Version: 1.0
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: base64
Return-path: <dri-devel-bounces@lists.freedesktop.org>
Received: from lb1-smtp-cloud3.xs4all.net (lb1-smtp-cloud3.xs4all.net
 [194.109.24.22])
 by gabe.freedesktop.org (Postfix) with ESMTPS id BEF5B6EE97
 for <dri-devel@lists.freedesktop.org>; Fri, 29 Apr 2016 09:39:16 +0000 (UTC)
In-Reply-To: <1461922746-17521-1-git-send-email-hverkuil@xs4all.nl>
List-Unsubscribe: <https://lists.freedesktop.org/mailman/options/dri-devel>,
 <mailto:dri-devel-request@lists.freedesktop.org?subject=unsubscribe>
List-Archive: <https://lists.freedesktop.org/archives/dri-devel>
List-Post: <mailto:dri-devel@lists.freedesktop.org>
List-Help: <mailto:dri-devel-request@lists.freedesktop.org?subject=help>
List-Subscribe: <https://lists.freedesktop.org/mailman/listinfo/dri-devel>,
 <mailto:dri-devel-request@lists.freedesktop.org?subject=subscribe>
Errors-To: dri-devel-bounces@lists.freedesktop.org
Sender: "dri-devel" <dri-devel-bounces@lists.freedesktop.org>
To: linux-media@vger.kernel.org
Cc: tomi.valkeinen@ti.com, Hans Verkuil <hans.verkuil@cisco.com>, dri-devel@lists.freedesktop.org
List-Id: dri-devel@lists.freedesktop.org
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