[thirdparty/kernel/stable.git] / drivers / media / rc / sunxi-cir.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Driver for Allwinner sunXi IR controller
 *
 * Copyright (C) 2014 Alexsey Shestacov <wingrime@linux-sunxi.org>
 * Copyright (C) 2014 Alexander Bersenev <bay@hackerdom.ru>
 *
 * Based on sun5i-ir.c:
 * Copyright (C) 2007-2012 Daniel Wang
 * Allwinner Technology Co., Ltd. <www.allwinnertech.com>
 */

#include <linux/clk.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/of_platform.h>
#include <linux/reset.h>
#include <media/rc-core.h>

#define SUNXI_IR_DEV "sunxi-ir"

/* Registers */
/* IR Control */
#define SUNXI_IR_CTL_REG      0x00
/* Global Enable */
#define REG_CTL_GEN			BIT(0)
/* RX block enable */
#define REG_CTL_RXEN			BIT(1)
/* CIR mode */
#define REG_CTL_MD			(BIT(4) | BIT(5))

/* Rx Config */
#define SUNXI_IR_RXCTL_REG    0x10
/* Pulse Polarity Invert flag */
#define REG_RXCTL_RPPI			BIT(2)

/* Rx Data */
#define SUNXI_IR_RXFIFO_REG   0x20

/* Rx Interrupt Enable */
#define SUNXI_IR_RXINT_REG    0x2C
/* Rx FIFO Overflow */
#define REG_RXINT_ROI_EN		BIT(0)
/* Rx Packet End */
#define REG_RXINT_RPEI_EN		BIT(1)
/* Rx FIFO Data Available */
#define REG_RXINT_RAI_EN		BIT(4)

/* Rx FIFO available byte level */
#define REG_RXINT_RAL(val)    ((val) << 8)

/* Rx Interrupt Status */
#define SUNXI_IR_RXSTA_REG    0x30
/* RX FIFO Get Available Counter */
#define REG_RXSTA_GET_AC(val) (((val) >> 8) & (ir->fifo_size * 2 - 1))
/* Clear all interrupt status value */
#define REG_RXSTA_CLEARALL    0xff

/* IR Sample Config */
#define SUNXI_IR_CIR_REG      0x34
/* CIR_REG register noise threshold */
#define REG_CIR_NTHR(val)    (((val) << 2) & (GENMASK(7, 2)))
/* CIR_REG register idle threshold */
#define REG_CIR_ITHR(val)    (((val) << 8) & (GENMASK(15, 8)))

/* Required frequency for IR0 or IR1 clock in CIR mode (default) */
#define SUNXI_IR_BASE_CLK     8000000
/* Noise threshold in samples  */
#define SUNXI_IR_RXNOISE      1
/* Idle Threshold in samples */
#define SUNXI_IR_RXIDLE       20
/* Time after which device stops sending data in ms */
#define SUNXI_IR_TIMEOUT      120

struct sunxi_ir {
	spinlock_t      ir_lock;
	struct rc_dev   *rc;
	void __iomem    *base;
	int             irq;
	int		fifo_size;
	struct clk      *clk;
	struct clk      *apb_clk;
	struct reset_control *rst;
	const char      *map_name;
};

static irqreturn_t sunxi_ir_irq(int irqno, void *dev_id)
{
	unsigned long status;
	unsigned char dt;
	unsigned int cnt, rc;
	struct sunxi_ir *ir = dev_id;
	struct ir_raw_event rawir = {};

	spin_lock(&ir->ir_lock);

	status = readl(ir->base + SUNXI_IR_RXSTA_REG);

	/* clean all pending statuses */
	writel(status | REG_RXSTA_CLEARALL, ir->base + SUNXI_IR_RXSTA_REG);

	if (status & (REG_RXINT_RAI_EN | REG_RXINT_RPEI_EN)) {
		/* How many messages in fifo */
		rc  = REG_RXSTA_GET_AC(status);
		/* Sanity check */
		rc = rc > ir->fifo_size ? ir->fifo_size : rc;
		/* If we have data */
		for (cnt = 0; cnt < rc; cnt++) {
			/* for each bit in fifo */
			dt = readb(ir->base + SUNXI_IR_RXFIFO_REG);
			rawir.pulse = (dt & 0x80) != 0;
			rawir.duration = ((dt & 0x7f) + 1) *
					 ir->rc->rx_resolution;
			ir_raw_event_store_with_filter(ir->rc, &rawir);
		}
	}

	if (status & REG_RXINT_ROI_EN) {
		ir_raw_event_reset(ir->rc);
	} else if (status & REG_RXINT_RPEI_EN) {
		ir_raw_event_set_idle(ir->rc, true);
		ir_raw_event_handle(ir->rc);
	}

	spin_unlock(&ir->ir_lock);

	return IRQ_HANDLED;
}

static int sunxi_ir_probe(struct platform_device *pdev)
{
	int ret = 0;
	unsigned long tmp = 0;

	struct device *dev = &pdev->dev;
	struct device_node *dn = dev->of_node;
	struct resource *res;
	struct sunxi_ir *ir;
	u32 b_clk_freq = SUNXI_IR_BASE_CLK;

	ir = devm_kzalloc(dev, sizeof(struct sunxi_ir), GFP_KERNEL);
	if (!ir)
		return -ENOMEM;

	spin_lock_init(&ir->ir_lock);

	if (of_device_is_compatible(dn, "allwinner,sun5i-a13-ir"))
		ir->fifo_size = 64;
	else
		ir->fifo_size = 16;

	/* Clock */
	ir->apb_clk = devm_clk_get(dev, "apb");
	if (IS_ERR(ir->apb_clk)) {
		dev_err(dev, "failed to get a apb clock.\n");
		return PTR_ERR(ir->apb_clk);
	}
	ir->clk = devm_clk_get(dev, "ir");
	if (IS_ERR(ir->clk)) {
		dev_err(dev, "failed to get a ir clock.\n");
		return PTR_ERR(ir->clk);
	}

	/* Base clock frequency (optional) */
	of_property_read_u32(dn, "clock-frequency", &b_clk_freq);

	/* Reset (optional) */
	ir->rst = devm_reset_control_get_optional_exclusive(dev, NULL);
	if (IS_ERR(ir->rst))
		return PTR_ERR(ir->rst);
	ret = reset_control_deassert(ir->rst);
	if (ret)
		return ret;

	ret = clk_set_rate(ir->clk, b_clk_freq);
	if (ret) {
		dev_err(dev, "set ir base clock failed!\n");
		goto exit_reset_assert;
	}
	dev_dbg(dev, "set base clock frequency to %d Hz.\n", b_clk_freq);

	if (clk_prepare_enable(ir->apb_clk)) {
		dev_err(dev, "try to enable apb_ir_clk failed\n");
		ret = -EINVAL;
		goto exit_reset_assert;
	}

	if (clk_prepare_enable(ir->clk)) {
		dev_err(dev, "try to enable ir_clk failed\n");
		ret = -EINVAL;
		goto exit_clkdisable_apb_clk;
	}

	/* IO */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	ir->base = devm_ioremap_resource(dev, res);
	if (IS_ERR(ir->base)) {
		dev_err(dev, "failed to map registers\n");
		ret = PTR_ERR(ir->base);
		goto exit_clkdisable_clk;
	}

	ir->rc = rc_allocate_device(RC_DRIVER_IR_RAW);
	if (!ir->rc) {
		dev_err(dev, "failed to allocate device\n");
		ret = -ENOMEM;
		goto exit_clkdisable_clk;
	}

	ir->rc->priv = ir;
	ir->rc->device_name = SUNXI_IR_DEV;
	ir->rc->input_phys = "sunxi-ir/input0";
	ir->rc->input_id.bustype = BUS_HOST;
	ir->rc->input_id.vendor = 0x0001;
	ir->rc->input_id.product = 0x0001;
	ir->rc->input_id.version = 0x0100;
	ir->map_name = of_get_property(dn, "linux,rc-map-name", NULL);
	ir->rc->map_name = ir->map_name ?: RC_MAP_EMPTY;
	ir->rc->dev.parent = dev;
	ir->rc->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
	/* Frequency after IR internal divider with sample period in ns */
	ir->rc->rx_resolution = (1000000000ul / (b_clk_freq / 64));
	ir->rc->timeout = MS_TO_NS(SUNXI_IR_TIMEOUT);
	ir->rc->driver_name = SUNXI_IR_DEV;

	ret = rc_register_device(ir->rc);
	if (ret) {
		dev_err(dev, "failed to register rc device\n");
		goto exit_free_dev;
	}

	platform_set_drvdata(pdev, ir);

	/* IRQ */
	ir->irq = platform_get_irq(pdev, 0);
	if (ir->irq < 0) {
		dev_err(dev, "no irq resource\n");
		ret = ir->irq;
		goto exit_free_dev;
	}

	ret = devm_request_irq(dev, ir->irq, sunxi_ir_irq, 0, SUNXI_IR_DEV, ir);
	if (ret) {
		dev_err(dev, "failed request irq\n");
		goto exit_free_dev;
	}

	/* Enable CIR Mode */
	writel(REG_CTL_MD, ir->base+SUNXI_IR_CTL_REG);

	/* Set noise threshold and idle threshold */
	writel(REG_CIR_NTHR(SUNXI_IR_RXNOISE)|REG_CIR_ITHR(SUNXI_IR_RXIDLE),
	       ir->base + SUNXI_IR_CIR_REG);

	/* Invert Input Signal */
	writel(REG_RXCTL_RPPI, ir->base + SUNXI_IR_RXCTL_REG);

	/* Clear All Rx Interrupt Status */
	writel(REG_RXSTA_CLEARALL, ir->base + SUNXI_IR_RXSTA_REG);

	/*
	 * Enable IRQ on overflow, packet end, FIFO available with trigger
	 * level
	 */
	writel(REG_RXINT_ROI_EN | REG_RXINT_RPEI_EN |
	       REG_RXINT_RAI_EN | REG_RXINT_RAL(ir->fifo_size / 2 - 1),
	       ir->base + SUNXI_IR_RXINT_REG);

	/* Enable IR Module */
	tmp = readl(ir->base + SUNXI_IR_CTL_REG);
	writel(tmp | REG_CTL_GEN | REG_CTL_RXEN, ir->base + SUNXI_IR_CTL_REG);

	dev_info(dev, "initialized sunXi IR driver\n");
	return 0;

exit_free_dev:
	rc_free_device(ir->rc);
exit_clkdisable_clk:
	clk_disable_unprepare(ir->clk);
exit_clkdisable_apb_clk:
	clk_disable_unprepare(ir->apb_clk);
exit_reset_assert:
	reset_control_assert(ir->rst);

	return ret;
}

static int sunxi_ir_remove(struct platform_device *pdev)
{
	unsigned long flags;
	struct sunxi_ir *ir = platform_get_drvdata(pdev);

	clk_disable_unprepare(ir->clk);
	clk_disable_unprepare(ir->apb_clk);
	reset_control_assert(ir->rst);

	spin_lock_irqsave(&ir->ir_lock, flags);
	/* disable IR IRQ */
	writel(0, ir->base + SUNXI_IR_RXINT_REG);
	/* clear All Rx Interrupt Status */
	writel(REG_RXSTA_CLEARALL, ir->base + SUNXI_IR_RXSTA_REG);
	/* disable IR */
	writel(0, ir->base + SUNXI_IR_CTL_REG);
	spin_unlock_irqrestore(&ir->ir_lock, flags);

	rc_unregister_device(ir->rc);
	return 0;
}

static const struct of_device_id sunxi_ir_match[] = {
	{ .compatible = "allwinner,sun4i-a10-ir", },
	{ .compatible = "allwinner,sun5i-a13-ir", },
	{},
};
MODULE_DEVICE_TABLE(of, sunxi_ir_match);

static struct platform_driver sunxi_ir_driver = {
	.probe          = sunxi_ir_probe,
	.remove         = sunxi_ir_remove,
	.driver = {
		.name = SUNXI_IR_DEV,
		.of_match_table = sunxi_ir_match,
	},
};

module_platform_driver(sunxi_ir_driver);

MODULE_DESCRIPTION("Allwinner sunXi IR controller driver");
MODULE_AUTHOR("Alexsey Shestacov <wingrime@linux-sunxi.org>");
MODULE_LICENSE("GPL");
Commit	Line	Data
c942fddf	1	// SPDX-License-Identifier: GPL-2.0-or-later
b4e3e59f AB	2	/*
	3	* Driver for Allwinner sunXi IR controller
	4	*
	5	* Copyright (C) 2014 Alexsey Shestacov <wingrime@linux-sunxi.org>
	6	* Copyright (C) 2014 Alexander Bersenev <bay@hackerdom.ru>
	7	*
	8	* Based on sun5i-ir.c:
	9	* Copyright (C) 2007-2012 Daniel Wang
	10	* Allwinner Technology Co., Ltd. <www.allwinnertech.com>
b4e3e59f AB	11	*/
	12
	13	#include <linux/clk.h>
	14	#include <linux/interrupt.h>
	15	#include <linux/module.h>
	16	#include <linux/of_platform.h>
44f8af68	17	#include <linux/reset.h>
b4e3e59f AB	18	#include <media/rc-core.h>
	19
	20	#define SUNXI_IR_DEV "sunxi-ir"
	21
	22	/* Registers */
	23	/* IR Control */
	24	#define SUNXI_IR_CTL_REG 0x00
	25	/* Global Enable */
	26	#define REG_CTL_GEN BIT(0)
	27	/* RX block enable */
	28	#define REG_CTL_RXEN BIT(1)
	29	/* CIR mode */
	30	#define REG_CTL_MD (BIT(4) \| BIT(5))
	31
	32	/* Rx Config */
	33	#define SUNXI_IR_RXCTL_REG 0x10
	34	/* Pulse Polarity Invert flag */
	35	#define REG_RXCTL_RPPI BIT(2)
	36
	37	/* Rx Data */
	38	#define SUNXI_IR_RXFIFO_REG 0x20
	39
	40	/* Rx Interrupt Enable */
	41	#define SUNXI_IR_RXINT_REG 0x2C
	42	/* Rx FIFO Overflow */
	43	#define REG_RXINT_ROI_EN BIT(0)
	44	/* Rx Packet End */
	45	#define REG_RXINT_RPEI_EN BIT(1)
	46	/* Rx FIFO Data Available */
	47	#define REG_RXINT_RAI_EN BIT(4)
	48
	49	/* Rx FIFO available byte level */
a4bca4c7	50	#define REG_RXINT_RAL(val) ((val) << 8)
b4e3e59f AB	51
	52	/* Rx Interrupt Status */
	53	#define SUNXI_IR_RXSTA_REG 0x30
	54	/* RX FIFO Get Available Counter */
a4bca4c7	55	#define REG_RXSTA_GET_AC(val) (((val) >> 8) & (ir->fifo_size * 2 - 1))
b4e3e59f AB	56	/* Clear all interrupt status value */
	57	#define REG_RXSTA_CLEARALL 0xff
	58
	59	/* IR Sample Config */
	60	#define SUNXI_IR_CIR_REG 0x34
	61	/* CIR_REG register noise threshold */
	62	#define REG_CIR_NTHR(val) (((val) << 2) & (GENMASK(7, 2)))
	63	/* CIR_REG register idle threshold */
	64	#define REG_CIR_ITHR(val) (((val) << 8) & (GENMASK(15, 8)))
	65
10e71206	66	/* Required frequency for IR0 or IR1 clock in CIR mode (default) */
b4e3e59f	67	#define SUNXI_IR_BASE_CLK 8000000
b4e3e59f AB	68	/* Noise threshold in samples */
	69	#define SUNXI_IR_RXNOISE 1
	70	/* Idle Threshold in samples */
	71	#define SUNXI_IR_RXIDLE 20
	72	/* Time after which device stops sending data in ms */
	73	#define SUNXI_IR_TIMEOUT 120
	74
	75	struct sunxi_ir {
	76	spinlock_t ir_lock;
	77	struct rc_dev *rc;
	78	void __iomem *base;
	79	int irq;
a4bca4c7	80	int fifo_size;
b4e3e59f AB	81	struct clk *clk;
b4e3e59f AB	82	struct clk *apb_clk;
44f8af68	83	struct reset_control *rst;
b4e3e59f AB	84	const char *map_name;
	85	};
	86
	87	static irqreturn_t sunxi_ir_irq(int irqno, void *dev_id)
	88	{
	89	unsigned long status;
	90	unsigned char dt;
	91	unsigned int cnt, rc;
	92	struct sunxi_ir *ir = dev_id;
183e19f5	93	struct ir_raw_event rawir = {};
b4e3e59f AB	94
	95	spin_lock(&ir->ir_lock);
	96
	97	status = readl(ir->base + SUNXI_IR_RXSTA_REG);
	98
	99	/* clean all pending statuses */
	100	writel(status \| REG_RXSTA_CLEARALL, ir->base + SUNXI_IR_RXSTA_REG);
	101
a4bca4c7	102	if (status & (REG_RXINT_RAI_EN \| REG_RXINT_RPEI_EN)) {
b4e3e59f AB	103	/* How many messages in fifo */
	104	rc = REG_RXSTA_GET_AC(status);
	105	/* Sanity check */
a4bca4c7	106	rc = rc > ir->fifo_size ? ir->fifo_size : rc;
b4e3e59f AB	107	/* If we have data */
	108	for (cnt = 0; cnt < rc; cnt++) {
	109	/* for each bit in fifo */
	110	dt = readb(ir->base + SUNXI_IR_RXFIFO_REG);
	111	rawir.pulse = (dt & 0x80) != 0;
10e71206 PR	112	rawir.duration = ((dt & 0x7f) + 1) *
10e71206 PR	113	ir->rc->rx_resolution;
b4e3e59f AB	114	ir_raw_event_store_with_filter(ir->rc, &rawir);
	115	}
	116	}
	117
	118	if (status & REG_RXINT_ROI_EN) {
	119	ir_raw_event_reset(ir->rc);
	120	} else if (status & REG_RXINT_RPEI_EN) {
	121	ir_raw_event_set_idle(ir->rc, true);
	122	ir_raw_event_handle(ir->rc);
	123	}
	124
	125	spin_unlock(&ir->ir_lock);
	126
	127	return IRQ_HANDLED;
	128	}
	129
	130	static int sunxi_ir_probe(struct platform_device *pdev)
	131	{
	132	int ret = 0;
	133	unsigned long tmp = 0;
	134
	135	struct device *dev = &pdev->dev;
	136	struct device_node *dn = dev->of_node;
	137	struct resource *res;
	138	struct sunxi_ir *ir;
10e71206	139	u32 b_clk_freq = SUNXI_IR_BASE_CLK;
b4e3e59f AB	140
	141	ir = devm_kzalloc(dev, sizeof(struct sunxi_ir), GFP_KERNEL);
	142	if (!ir)
	143	return -ENOMEM;
	144
768acf46 CYT	145	spin_lock_init(&ir->ir_lock);
768acf46 CYT	146
a4bca4c7 HG	147	if (of_device_is_compatible(dn, "allwinner,sun5i-a13-ir"))
	148	ir->fifo_size = 64;
	149	else
	150	ir->fifo_size = 16;
	151
b4e3e59f AB	152	/* Clock */
	153	ir->apb_clk = devm_clk_get(dev, "apb");
	154	if (IS_ERR(ir->apb_clk)) {
	155	dev_err(dev, "failed to get a apb clock.\n");
	156	return PTR_ERR(ir->apb_clk);
	157	}
	158	ir->clk = devm_clk_get(dev, "ir");
	159	if (IS_ERR(ir->clk)) {
	160	dev_err(dev, "failed to get a ir clock.\n");
	161	return PTR_ERR(ir->clk);
	162	}
	163
10e71206 PR	164	/* Base clock frequency (optional) */
	165	of_property_read_u32(dn, "clock-frequency", &b_clk_freq);
	166
44f8af68	167	/* Reset (optional) */
a2df9d06	168	ir->rst = devm_reset_control_get_optional_exclusive(dev, NULL);
c3d4fb0f PZ	169	if (IS_ERR(ir->rst))
	170	return PTR_ERR(ir->rst);
	171	ret = reset_control_deassert(ir->rst);
	172	if (ret)
	173	return ret;
44f8af68	174
10e71206	175	ret = clk_set_rate(ir->clk, b_clk_freq);
b4e3e59f AB	176	if (ret) {
b4e3e59f AB	177	dev_err(dev, "set ir base clock failed!\n");
44f8af68	178	goto exit_reset_assert;
b4e3e59f	179	}
10e71206	180	dev_dbg(dev, "set base clock frequency to %d Hz.\n", b_clk_freq);
b4e3e59f AB	181
	182	if (clk_prepare_enable(ir->apb_clk)) {
	183	dev_err(dev, "try to enable apb_ir_clk failed\n");
44f8af68 HG	184	ret = -EINVAL;
44f8af68 HG	185	goto exit_reset_assert;
b4e3e59f AB	186	}
	187
	188	if (clk_prepare_enable(ir->clk)) {
	189	dev_err(dev, "try to enable ir_clk failed\n");
	190	ret = -EINVAL;
	191	goto exit_clkdisable_apb_clk;
	192	}
	193
	194	/* IO */
	195	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	196	ir->base = devm_ioremap_resource(dev, res);
	197	if (IS_ERR(ir->base)) {
	198	dev_err(dev, "failed to map registers\n");
	199	ret = PTR_ERR(ir->base);
	200	goto exit_clkdisable_clk;
	201	}
	202
0f7499fd	203	ir->rc = rc_allocate_device(RC_DRIVER_IR_RAW);
b4e3e59f AB	204	if (!ir->rc) {
	205	dev_err(dev, "failed to allocate device\n");
	206	ret = -ENOMEM;
	207	goto exit_clkdisable_clk;
	208	}
	209
	210	ir->rc->priv = ir;
518f4b26	211	ir->rc->device_name = SUNXI_IR_DEV;
b4e3e59f AB	212	ir->rc->input_phys = "sunxi-ir/input0";
	213	ir->rc->input_id.bustype = BUS_HOST;
	214	ir->rc->input_id.vendor = 0x0001;
	215	ir->rc->input_id.product = 0x0001;
	216	ir->rc->input_id.version = 0x0100;
	217	ir->map_name = of_get_property(dn, "linux,rc-map-name", NULL);
	218	ir->rc->map_name = ir->map_name ?: RC_MAP_EMPTY;
	219	ir->rc->dev.parent = dev;
6d741bfe	220	ir->rc->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
10e71206 PR	221	/* Frequency after IR internal divider with sample period in ns */
10e71206 PR	222	ir->rc->rx_resolution = (1000000000ul / (b_clk_freq / 64));
b4e3e59f AB	223	ir->rc->timeout = MS_TO_NS(SUNXI_IR_TIMEOUT);
	224	ir->rc->driver_name = SUNXI_IR_DEV;
	225
	226	ret = rc_register_device(ir->rc);
	227	if (ret) {
	228	dev_err(dev, "failed to register rc device\n");
	229	goto exit_free_dev;
	230	}
	231
	232	platform_set_drvdata(pdev, ir);
	233
	234	/* IRQ */
	235	ir->irq = platform_get_irq(pdev, 0);
	236	if (ir->irq < 0) {
	237	dev_err(dev, "no irq resource\n");
	238	ret = ir->irq;
	239	goto exit_free_dev;
	240	}
	241
	242	ret = devm_request_irq(dev, ir->irq, sunxi_ir_irq, 0, SUNXI_IR_DEV, ir);
	243	if (ret) {
	244	dev_err(dev, "failed request irq\n");
	245	goto exit_free_dev;
	246	}
	247
	248	/* Enable CIR Mode */
	249	writel(REG_CTL_MD, ir->base+SUNXI_IR_CTL_REG);
	250
	251	/* Set noise threshold and idle threshold */
	252	writel(REG_CIR_NTHR(SUNXI_IR_RXNOISE)\|REG_CIR_ITHR(SUNXI_IR_RXIDLE),
	253	ir->base + SUNXI_IR_CIR_REG);
	254
	255	/* Invert Input Signal */
	256	writel(REG_RXCTL_RPPI, ir->base + SUNXI_IR_RXCTL_REG);
	257
	258	/* Clear All Rx Interrupt Status */
	259	writel(REG_RXSTA_CLEARALL, ir->base + SUNXI_IR_RXSTA_REG);
	260
	261	/*
	262	* Enable IRQ on overflow, packet end, FIFO available with trigger
	263	* level
	264	*/
	265	writel(REG_RXINT_ROI_EN \| REG_RXINT_RPEI_EN \|
a4bca4c7	266	REG_RXINT_RAI_EN \| REG_RXINT_RAL(ir->fifo_size / 2 - 1),
b4e3e59f AB	267	ir->base + SUNXI_IR_RXINT_REG);
	268
	269	/* Enable IR Module */
	270	tmp = readl(ir->base + SUNXI_IR_CTL_REG);
	271	writel(tmp \| REG_CTL_GEN \| REG_CTL_RXEN, ir->base + SUNXI_IR_CTL_REG);
	272
	273	dev_info(dev, "initialized sunXi IR driver\n");
	274	return 0;
	275
	276	exit_free_dev:
	277	rc_free_device(ir->rc);
	278	exit_clkdisable_clk:
	279	clk_disable_unprepare(ir->clk);
	280	exit_clkdisable_apb_clk:
	281	clk_disable_unprepare(ir->apb_clk);
44f8af68	282	exit_reset_assert:
c3d4fb0f	283	reset_control_assert(ir->rst);
b4e3e59f AB	284
	285	return ret;
	286	}
	287
	288	static int sunxi_ir_remove(struct platform_device *pdev)
	289	{
	290	unsigned long flags;
	291	struct sunxi_ir *ir = platform_get_drvdata(pdev);
	292
	293	clk_disable_unprepare(ir->clk);
	294	clk_disable_unprepare(ir->apb_clk);
c3d4fb0f	295	reset_control_assert(ir->rst);
b4e3e59f AB	296
	297	spin_lock_irqsave(&ir->ir_lock, flags);
	298	/* disable IR IRQ */
	299	writel(0, ir->base + SUNXI_IR_RXINT_REG);
	300	/* clear All Rx Interrupt Status */
	301	writel(REG_RXSTA_CLEARALL, ir->base + SUNXI_IR_RXSTA_REG);
	302	/* disable IR */
	303	writel(0, ir->base + SUNXI_IR_CTL_REG);
	304	spin_unlock_irqrestore(&ir->ir_lock, flags);
	305
	306	rc_unregister_device(ir->rc);
	307	return 0;
	308	}
	309
	310	static const struct of_device_id sunxi_ir_match[] = {
	311	{ .compatible = "allwinner,sun4i-a10-ir", },
a4bca4c7	312	{ .compatible = "allwinner,sun5i-a13-ir", },
b4e3e59f AB	313	{},
b4e3e59f AB	314	};
ea05e8b4	315	MODULE_DEVICE_TABLE(of, sunxi_ir_match);
b4e3e59f AB	316
	317	static struct platform_driver sunxi_ir_driver = {
	318	.probe = sunxi_ir_probe,
	319	.remove = sunxi_ir_remove,
	320	.driver = {
	321	.name = SUNXI_IR_DEV,
b4e3e59f AB	322	.of_match_table = sunxi_ir_match,
	323	},
	324	};
	325
	326	module_platform_driver(sunxi_ir_driver);
	327
	328	MODULE_DESCRIPTION("Allwinner sunXi IR controller driver");
	329	MODULE_AUTHOR("Alexsey Shestacov <wingrime@linux-sunxi.org>");
	330	MODULE_LICENSE("GPL");