[linux-2.6-block.git] / drivers / irqchip / irq-gic-pm.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2016 NVIDIA CORPORATION, All Rights Reserved.
 */
#include <linux/module.h>
#include <linux/clk.h>
#include <linux/of_device.h>
#include <linux/of_irq.h>
#include <linux/irqchip/arm-gic.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/slab.h>

struct gic_clk_data {
	unsigned int num_clocks;
	const char *const *clocks;
};

struct gic_chip_pm {
	struct gic_chip_data *chip_data;
	const struct gic_clk_data *clk_data;
	struct clk_bulk_data *clks;
};

static int gic_runtime_resume(struct device *dev)
{
	struct gic_chip_pm *chip_pm = dev_get_drvdata(dev);
	struct gic_chip_data *gic = chip_pm->chip_data;
	const struct gic_clk_data *data = chip_pm->clk_data;
	int ret;

	ret = clk_bulk_prepare_enable(data->num_clocks, chip_pm->clks);
	if (ret) {
		dev_err(dev, "clk_enable failed: %d\n", ret);
		return ret;
	}

	/*
	 * On the very first resume, the pointer to chip_pm->chip_data
	 * will be NULL and this is intentional, because we do not
	 * want to restore the GIC on the very first resume. So if
	 * the pointer is not valid just return.
	 */
	if (!gic)
		return 0;

	gic_dist_restore(gic);
	gic_cpu_restore(gic);

	return 0;
}

static int gic_runtime_suspend(struct device *dev)
{
	struct gic_chip_pm *chip_pm = dev_get_drvdata(dev);
	struct gic_chip_data *gic = chip_pm->chip_data;
	const struct gic_clk_data *data = chip_pm->clk_data;

	gic_dist_save(gic);
	gic_cpu_save(gic);

	clk_bulk_disable_unprepare(data->num_clocks, chip_pm->clks);

	return 0;
}

static int gic_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	const struct gic_clk_data *data;
	struct gic_chip_pm *chip_pm;
	int ret, irq, i;

	data = of_device_get_match_data(&pdev->dev);
	if (!data) {
		dev_err(&pdev->dev, "no device match found\n");
		return -ENODEV;
	}

	chip_pm = devm_kzalloc(dev, sizeof(*chip_pm), GFP_KERNEL);
	if (!chip_pm)
		return -ENOMEM;

	irq = irq_of_parse_and_map(dev->of_node, 0);
	if (!irq) {
		dev_err(dev, "no parent interrupt found!\n");
		return -EINVAL;
	}

	chip_pm->clks = devm_kcalloc(dev, data->num_clocks,
				     sizeof(*chip_pm->clks), GFP_KERNEL);
	if (!chip_pm->clks)
		return -ENOMEM;

	for (i = 0; i < data->num_clocks; i++)
		chip_pm->clks[i].id = data->clocks[i];

	ret = devm_clk_bulk_get(dev, data->num_clocks, chip_pm->clks);
	if (ret)
		goto irq_dispose;

	chip_pm->clk_data = data;
	dev_set_drvdata(dev, chip_pm);

	pm_runtime_enable(dev);

	ret = pm_runtime_get_sync(dev);
	if (ret < 0)
		goto rpm_disable;

	ret = gic_of_init_child(dev, &chip_pm->chip_data, irq);
	if (ret)
		goto rpm_put;

	pm_runtime_put(dev);

	dev_info(dev, "GIC IRQ controller registered\n");

	return 0;

rpm_put:
	pm_runtime_put_sync(dev);
rpm_disable:
	pm_runtime_disable(dev);
irq_dispose:
	irq_dispose_mapping(irq);

	return ret;
}

static const struct dev_pm_ops gic_pm_ops = {
	SET_RUNTIME_PM_OPS(gic_runtime_suspend,
			   gic_runtime_resume, NULL)
	SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
				     pm_runtime_force_resume)
};

static const char * const gic400_clocks[] = {
	"clk",
};

static const struct gic_clk_data gic400_data = {
	.num_clocks = ARRAY_SIZE(gic400_clocks),
	.clocks = gic400_clocks,
};

static const struct of_device_id gic_match[] = {
	{ .compatible = "nvidia,tegra210-agic",	.data = &gic400_data },
	{},
};
MODULE_DEVICE_TABLE(of, gic_match);

static struct platform_driver gic_driver = {
	.probe		= gic_probe,
	.driver		= {
		.name	= "gic",
		.of_match_table	= gic_match,
		.pm	= &gic_pm_ops,
	}
};

builtin_platform_driver(gic_driver);
Commit	Line	Data
caab277b	1	// SPDX-License-Identifier: GPL-2.0-only
9c8edddf JH	2	/*
9c8edddf JH	3	* Copyright (C) 2016 NVIDIA CORPORATION, All Rights Reserved.
9c8edddf JH	4	*/
	5	#include <linux/module.h>
	6	#include <linux/clk.h>
	7	#include <linux/of_device.h>
	8	#include <linux/of_irq.h>
	9	#include <linux/irqchip/arm-gic.h>
	10	#include <linux/platform_device.h>
9c8edddf JH	11	#include <linux/pm_runtime.h>
	12	#include <linux/slab.h>
	13
	14	struct gic_clk_data {
	15	unsigned int num_clocks;
	16	const char const clocks;
	17	};
	18
fe00f890 SP	19	struct gic_chip_pm {
	20	struct gic_chip_data *chip_data;
	21	const struct gic_clk_data *clk_data;
	22	struct clk_bulk_data *clks;
	23	};
	24
9c8edddf JH	25	static int gic_runtime_resume(struct device *dev)
9c8edddf JH	26	{
fe00f890 SP	27	struct gic_chip_pm *chip_pm = dev_get_drvdata(dev);
	28	struct gic_chip_data *gic = chip_pm->chip_data;
	29	const struct gic_clk_data *data = chip_pm->clk_data;
9c8edddf JH	30	int ret;
9c8edddf JH	31
fe00f890 SP	32	ret = clk_bulk_prepare_enable(data->num_clocks, chip_pm->clks);
	33	if (ret) {
	34	dev_err(dev, "clk_enable failed: %d\n", ret);
9c8edddf	35	return ret;
fe00f890	36	}
9c8edddf JH	37
9c8edddf JH	38	/*
fe00f890	39	* On the very first resume, the pointer to chip_pm->chip_data
9c8edddf JH	40	* will be NULL and this is intentional, because we do not
	41	* want to restore the GIC on the very first resume. So if
	42	* the pointer is not valid just return.
	43	*/
	44	if (!gic)
	45	return 0;
	46
	47	gic_dist_restore(gic);
	48	gic_cpu_restore(gic);
	49
	50	return 0;
	51	}
	52
	53	static int gic_runtime_suspend(struct device *dev)
	54	{
fe00f890 SP	55	struct gic_chip_pm *chip_pm = dev_get_drvdata(dev);
	56	struct gic_chip_data *gic = chip_pm->chip_data;
	57	const struct gic_clk_data *data = chip_pm->clk_data;
9c8edddf JH	58
	59	gic_dist_save(gic);
	60	gic_cpu_save(gic);
	61
fe00f890	62	clk_bulk_disable_unprepare(data->num_clocks, chip_pm->clks);
9c8edddf JH	63
9c8edddf JH	64	return 0;
9c8edddf JH	65	}
	66
	67	static int gic_probe(struct platform_device *pdev)
	68	{
	69	struct device *dev = &pdev->dev;
	70	const struct gic_clk_data *data;
fe00f890 SP	71	struct gic_chip_pm *chip_pm;
fe00f890 SP	72	int ret, irq, i;
9c8edddf JH	73
	74	data = of_device_get_match_data(&pdev->dev);
	75	if (!data) {
	76	dev_err(&pdev->dev, "no device match found\n");
	77	return -ENODEV;
	78	}
	79
fe00f890 SP	80	chip_pm = devm_kzalloc(dev, sizeof(*chip_pm), GFP_KERNEL);
	81	if (!chip_pm)
	82	return -ENOMEM;
	83
9c8edddf JH	84	irq = irq_of_parse_and_map(dev->of_node, 0);
	85	if (!irq) {
	86	dev_err(dev, "no parent interrupt found!\n");
	87	return -EINVAL;
	88	}
	89
fe00f890 SP	90	chip_pm->clks = devm_kcalloc(dev, data->num_clocks,
	91	sizeof(*chip_pm->clks), GFP_KERNEL);
	92	if (!chip_pm->clks)
	93	return -ENOMEM;
	94
	95	for (i = 0; i < data->num_clocks; i++)
	96	chip_pm->clks[i].id = data->clocks[i];
	97
	98	ret = devm_clk_bulk_get(dev, data->num_clocks, chip_pm->clks);
9c8edddf JH	99	if (ret)
	100	goto irq_dispose;
	101
fe00f890 SP	102	chip_pm->clk_data = data;
	103	dev_set_drvdata(dev, chip_pm);
	104
9c8edddf JH	105	pm_runtime_enable(dev);
	106
	107	ret = pm_runtime_get_sync(dev);
	108	if (ret < 0)
	109	goto rpm_disable;
	110
fe00f890	111	ret = gic_of_init_child(dev, &chip_pm->chip_data, irq);
9c8edddf JH	112	if (ret)
	113	goto rpm_put;
	114
9c8edddf JH	115	pm_runtime_put(dev);
	116
	117	dev_info(dev, "GIC IRQ controller registered\n");
	118
	119	return 0;
	120
	121	rpm_put:
	122	pm_runtime_put_sync(dev);
	123	rpm_disable:
	124	pm_runtime_disable(dev);
9c8edddf JH	125	irq_dispose:
	126	irq_dispose_mapping(irq);
	127
	128	return ret;
	129	}
	130
	131	static const struct dev_pm_ops gic_pm_ops = {
	132	SET_RUNTIME_PM_OPS(gic_runtime_suspend,
	133	gic_runtime_resume, NULL)
960164f7 SP	134	SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
960164f7 SP	135	pm_runtime_force_resume)
9c8edddf JH	136	};
	137
	138	static const char * const gic400_clocks[] = {
	139	"clk",
	140	};
	141
	142	static const struct gic_clk_data gic400_data = {
	143	.num_clocks = ARRAY_SIZE(gic400_clocks),
	144	.clocks = gic400_clocks,
	145	};
	146
	147	static const struct of_device_id gic_match[] = {
	148	{ .compatible = "nvidia,tegra210-agic", .data = &gic400_data },
	149	{},
	150	};
	151	MODULE_DEVICE_TABLE(of, gic_match);
	152
	153	static struct platform_driver gic_driver = {
	154	.probe = gic_probe,
	155	.driver = {
	156	.name = "gic",
	157	.of_match_table = gic_match,
	158	.pm = &gic_pm_ops,
	159	}
	160	};
	161
	162	builtin_platform_driver(gic_driver);