[linux-2.6-block.git] / drivers / reset / reset-sunxi.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Allwinner SoCs Reset Controller driver
 *
 * Copyright 2013 Maxime Ripard
 *
 * Maxime Ripard <maxime.ripard@free-electrons.com>
 */

#include <linux/err.h>
#include <linux/io.h>
#include <linux/init.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/platform_device.h>
#include <linux/reset-controller.h>
#include <linux/reset/reset-simple.h>
#include <linux/reset/sunxi.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/types.h>

static int sunxi_reset_init(struct device_node *np)
{
	struct reset_simple_data *data;
	struct resource res;
	resource_size_t size;
	int ret;

	data = kzalloc(sizeof(*data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	ret = of_address_to_resource(np, 0, &res);
	if (ret)
		goto err_alloc;

	size = resource_size(&res);
	if (!request_mem_region(res.start, size, np->name)) {
		ret = -EBUSY;
		goto err_alloc;
	}

	data->membase = ioremap(res.start, size);
	if (!data->membase) {
		ret = -ENOMEM;
		goto err_alloc;
	}

	spin_lock_init(&data->lock);

	data->rcdev.owner = THIS_MODULE;
	data->rcdev.nr_resets = size * 8;
	data->rcdev.ops = &reset_simple_ops;
	data->rcdev.of_node = np;
	data->active_low = true;

	return reset_controller_register(&data->rcdev);

err_alloc:
	kfree(data);
	return ret;
};

/*
 * These are the reset controller we need to initialize early on in
 * our system, before we can even think of using a regular device
 * driver for it.
 * The controllers that we can register through the regular device
 * model are handled by the simple reset driver directly.
 */
static const struct of_device_id sunxi_early_reset_dt_ids[] __initconst = {
	{ .compatible = "allwinner,sun6i-a31-ahb1-reset", },
	{ /* sentinel */ },
};

void __init sun6i_reset_init(void)
{
	struct device_node *np;

	for_each_matching_node(np, sunxi_early_reset_dt_ids)
		sunxi_reset_init(np);
}
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
8f1ae77f MR	2	/*
	3	* Allwinner SoCs Reset Controller driver
	4	*
	5	* Copyright 2013 Maxime Ripard
	6	*
	7	* Maxime Ripard <maxime.ripard@free-electrons.com>
8f1ae77f MR	8	*/
	9
	10	#include <linux/err.h>
	11	#include <linux/io.h>
c4742ed3	12	#include <linux/init.h>
8f1ae77f MR	13	#include <linux/of.h>
	14	#include <linux/of_address.h>
	15	#include <linux/platform_device.h>
	16	#include <linux/reset-controller.h>
9357b046	17	#include <linux/reset/reset-simple.h>
fdce6078	18	#include <linux/reset/sunxi.h>
8f1ae77f MR	19	#include <linux/slab.h>
	20	#include <linux/spinlock.h>
	21	#include <linux/types.h>
	22
8f1ae77f MR	23	static int sunxi_reset_init(struct device_node *np)
8f1ae77f MR	24	{
e13c205a	25	struct reset_simple_data *data;
8f1ae77f MR	26	struct resource res;
	27	resource_size_t size;
	28	int ret;
	29
	30	data = kzalloc(sizeof(*data), GFP_KERNEL);
	31	if (!data)
	32	return -ENOMEM;
	33
	34	ret = of_address_to_resource(np, 0, &res);
	35	if (ret)
	36	goto err_alloc;
	37
	38	size = resource_size(&res);
	39	if (!request_mem_region(res.start, size, np->name)) {
	40	ret = -EBUSY;
	41	goto err_alloc;
	42	}
	43
	44	data->membase = ioremap(res.start, size);
	45	if (!data->membase) {
	46	ret = -ENOMEM;
	47	goto err_alloc;
	48	}
	49
41544f9f TB	50	spin_lock_init(&data->lock);
41544f9f TB	51
8f1ae77f	52	data->rcdev.owner = THIS_MODULE;
726cc791	53	data->rcdev.nr_resets = size * 8;
e13c205a	54	data->rcdev.ops = &reset_simple_ops;
8f1ae77f	55	data->rcdev.of_node = np;
e13c205a	56	data->active_low = true;
8f1ae77f	57
d1f15aa0	58	return reset_controller_register(&data->rcdev);
8f1ae77f MR	59
	60	err_alloc:
	61	kfree(data);
	62	return ret;
	63	};
	64
	65	/*
	66	* These are the reset controller we need to initialize early on in
	67	* our system, before we can even think of using a regular device
	68	* driver for it.
e13c205a PZ	69	* The controllers that we can register through the regular device
e13c205a PZ	70	* model are handled by the simple reset driver directly.
8f1ae77f	71	*/
fddad17e	72	static const struct of_device_id sunxi_early_reset_dt_ids[] __initconst = {
8f1ae77f MR	73	{ .compatible = "allwinner,sun6i-a31-ahb1-reset", },
	74	{ /* sentinel */ },
	75	};
	76
	77	void __init sun6i_reset_init(void)
	78	{
	79	struct device_node *np;
	80
	81	for_each_matching_node(np, sunxi_early_reset_dt_ids)
	82	sunxi_reset_init(np);
	83	}