img-ir-core.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * ImgTec IR Decoder found in PowerDown Controller.
  4 *
  5 * Copyright 2010-2014 Imagination Technologies Ltd.
  6 *
  7 * This contains core img-ir code for setting up the driver. The two interfaces
  8 * (raw and hardware decode) are handled separately.
  9 */
 10
 11#include <linux/clk.h>
 12#include <linux/init.h>
 13#include <linux/interrupt.h>
 14#include <linux/io.h>
 15#include <linux/module.h>
 16#include <linux/platform_device.h>
 17#include <linux/slab.h>
 18#include <linux/spinlock.h>
 19#include "img-ir.h"
 20
 21static irqreturn_t img_ir_isr(int irq, void *dev_id)
 22{
 23	struct img_ir_priv *priv = dev_id;
 24	u32 irq_status;
 25
 26	spin_lock(&priv->lock);
 27	/* we have to clear irqs before reading */
 28	irq_status = img_ir_read(priv, IMG_IR_IRQ_STATUS);
 29	img_ir_write(priv, IMG_IR_IRQ_CLEAR, irq_status);
 30
 31	/* don't handle valid data irqs if we're only interested in matches */
 32	irq_status &= img_ir_read(priv, IMG_IR_IRQ_ENABLE);
 33
 34	/* hand off edge interrupts to raw decode handler */
 35	if (irq_status & IMG_IR_IRQ_EDGE && img_ir_raw_enabled(&priv->raw))
 36		img_ir_isr_raw(priv, irq_status);
 37
 38	/* hand off hardware match interrupts to hardware decode handler */
 39	if (irq_status & (IMG_IR_IRQ_DATA_MATCH |
 40			  IMG_IR_IRQ_DATA_VALID |
 41			  IMG_IR_IRQ_DATA2_VALID) &&
 42	    img_ir_hw_enabled(&priv->hw))
 43		img_ir_isr_hw(priv, irq_status);
 44
 45	spin_unlock(&priv->lock);
 46	return IRQ_HANDLED;
 47}
 48
 49static void img_ir_setup(struct img_ir_priv *priv)
 50{
 51	/* start off with interrupts disabled */
 52	img_ir_write(priv, IMG_IR_IRQ_ENABLE, 0);
 53
 54	img_ir_setup_raw(priv);
 55	img_ir_setup_hw(priv);
 56
 57	if (!IS_ERR(priv->clk))
 58		clk_prepare_enable(priv->clk);
 59}
 60
 61static void img_ir_ident(struct img_ir_priv *priv)
 62{
 63	u32 core_rev = img_ir_read(priv, IMG_IR_CORE_REV);
 64
 65	dev_info(priv->dev,
 66		 "IMG IR Decoder (%d.%d.%d.%d) probed successfully\n",
 67		 (core_rev & IMG_IR_DESIGNER) >> IMG_IR_DESIGNER_SHIFT,
 68		 (core_rev & IMG_IR_MAJOR_REV) >> IMG_IR_MAJOR_REV_SHIFT,
 69		 (core_rev & IMG_IR_MINOR_REV) >> IMG_IR_MINOR_REV_SHIFT,
 70		 (core_rev & IMG_IR_MAINT_REV) >> IMG_IR_MAINT_REV_SHIFT);
 71	dev_info(priv->dev, "Modes:%s%s\n",
 72		 img_ir_hw_enabled(&priv->hw) ? " hardware" : "",
 73		 img_ir_raw_enabled(&priv->raw) ? " raw" : "");
 74}
 75
 76static int img_ir_probe(struct platform_device *pdev)
 77{
 78	struct img_ir_priv *priv;
 79	int irq, error, error2;
 80
 81	/* Get resources from platform device */
 82	irq = platform_get_irq(pdev, 0);
 83	if (irq < 0)
 84		return irq;
 85
 86	/* Private driver data */
 87	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
 88	if (!priv)
 89		return -ENOMEM;
 90
 91	platform_set_drvdata(pdev, priv);
 92	priv->dev = &pdev->dev;
 93	spin_lock_init(&priv->lock);
 94
 95	/* Ioremap the registers */
 96	priv->reg_base = devm_platform_ioremap_resource(pdev, 0);
 97	if (IS_ERR(priv->reg_base))
 98		return PTR_ERR(priv->reg_base);
 99
100	/* Get core clock */
101	priv->clk = devm_clk_get(&pdev->dev, "core");
102	if (IS_ERR(priv->clk))
103		dev_warn(&pdev->dev, "cannot get core clock resource\n");
104
105	/* Get sys clock */
106	priv->sys_clk = devm_clk_get(&pdev->dev, "sys");
107	if (IS_ERR(priv->sys_clk))
108		dev_warn(&pdev->dev, "cannot get sys clock resource\n");
109	/*
110	 * Enabling the system clock before the register interface is
111	 * accessed. ISR shouldn't get called with Sys Clock disabled,
112	 * hence exiting probe with an error.
113	 */
114	if (!IS_ERR(priv->sys_clk)) {
115		error = clk_prepare_enable(priv->sys_clk);
116		if (error) {
117			dev_err(&pdev->dev, "cannot enable sys clock\n");
118			return error;
119		}
120	}
121
122	/* Set up raw & hw decoder */
123	error = img_ir_probe_raw(priv);
124	error2 = img_ir_probe_hw(priv);
125	if (error && error2) {
126		if (error == -ENODEV)
127			error = error2;
128		goto err_probe;
129	}
130
131	/* Get the IRQ */
132	priv->irq = irq;
133	error = request_irq(priv->irq, img_ir_isr, 0, "img-ir", priv);
134	if (error) {
135		dev_err(&pdev->dev, "cannot register IRQ %u\n",
136			priv->irq);
137		error = -EIO;
138		goto err_irq;
139	}
140
141	img_ir_ident(priv);
142	img_ir_setup(priv);
143
144	return 0;
145
146err_irq:
147	img_ir_remove_hw(priv);
148	img_ir_remove_raw(priv);
149err_probe:
150	if (!IS_ERR(priv->sys_clk))
151		clk_disable_unprepare(priv->sys_clk);
152	return error;
153}
154
155static void img_ir_remove(struct platform_device *pdev)
156{
157	struct img_ir_priv *priv = platform_get_drvdata(pdev);
158
159	free_irq(priv->irq, priv);
160	img_ir_remove_hw(priv);
161	img_ir_remove_raw(priv);
162
163	if (!IS_ERR(priv->clk))
164		clk_disable_unprepare(priv->clk);
165	if (!IS_ERR(priv->sys_clk))
166		clk_disable_unprepare(priv->sys_clk);
167}
168
169static SIMPLE_DEV_PM_OPS(img_ir_pmops, img_ir_suspend, img_ir_resume);
170
171static const struct of_device_id img_ir_match[] = {
172	{ .compatible = "img,ir-rev1" },
173	{}
174};
175MODULE_DEVICE_TABLE(of, img_ir_match);
176
177static struct platform_driver img_ir_driver = {
178	.driver = {
179		.name = "img-ir",
180		.of_match_table	= img_ir_match,
181		.pm = &img_ir_pmops,
182	},
183	.probe = img_ir_probe,
184	.remove = img_ir_remove,
185};
186
187module_platform_driver(img_ir_driver);
188
189MODULE_AUTHOR("Imagination Technologies Ltd.");
190MODULE_DESCRIPTION("ImgTec IR");
191MODULE_LICENSE("GPL");