Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7f95de5e authored by Arnd Bergmann's avatar Arnd Bergmann
Browse files

Merge tag 'reset-for-4.17-2' of git://git.pengutronix.de/git/pza/linux into next/drivers 

Pull "Reset controller changes for v4.17, part 2" from Philipp Zabel:

This tag contains reset lookup support, similar to pwm lookups, for legacy
non-DT platforms, a few new reset controls and a Kconfig fix for uniphier
SoCs, as well as a new driver for the STM32MP1 peripheral reset controller.

The reset lookups are merged from a separate, immutable branch, that may
also be merged into the davinci tree.

* tag 'reset-for-4.17-2' of git://git.pengutronix.de/git/pza/linux:
  reset: uniphier: add ethernet reset control support for PXs3
  reset: stm32mp1: Enable stm32mp1 reset driver
  dt-bindings: reset: add STM32MP1 resets
  reset: uniphier: add Pro4/Pro5/PXs2 audio systems reset control
  reset: imx7: add 'depends on HAS_IOMEM' to fix unmet dependency
  reset: modify the way reset lookup works for board files
  reset: add support for non-DT systems
parents f8d6dc78 0089313d

Documentation/devicetree/bindings/reset/st,stm32mp1-rcc.txt

0 → 100644
+6 −0
Original line number Diff line number Diff line 
STMicroelectronics STM32MP1 Peripheral Reset Controller

=======================================================



The RCC IP is both a reset and a clock controller.



Please see Documentation/devicetree/bindings/clock/st,stm32mp1-rcc.txt

drivers/reset/Kconfig

+7 −0
Original line number Diff line number Diff line
@@ -49,6 +49,7 @@ config RESET_HSDK 


config RESET_IMX7

	bool "i.MX7 Reset Driver" if COMPILE_TEST

	depends on HAS_IOMEM

	default SOC_IMX7D

	select MFD_SYSCON

	help
@@ -96,6 +97,12 @@ config RESET_SIMPLE 
	   - Allwinner SoCs

	   - ZTE's zx2967 family



config RESET_STM32MP157

	bool "STM32MP157 Reset Driver" if COMPILE_TEST

	default MACH_STM32MP157

	help

	  This enables the RCC reset controller driver for STM32 MPUs.



config RESET_SUNXI

	bool "Allwinner SoCs Reset Driver" if COMPILE_TEST && !ARCH_SUNXI

	default ARCH_SUNXI

drivers/reset/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ obj-$(CONFIG_RESET_MESON) += reset-meson.o 
obj-$(CONFIG_RESET_OXNAS) += reset-oxnas.o

obj-$(CONFIG_RESET_PISTACHIO) += reset-pistachio.o

obj-$(CONFIG_RESET_SIMPLE) += reset-simple.o

obj-$(CONFIG_RESET_STM32MP157) += reset-stm32mp1.o

obj-$(CONFIG_RESET_SUNXI) += reset-sunxi.o

obj-$(CONFIG_RESET_TI_SCI) += reset-ti-sci.o

obj-$(CONFIG_RESET_TI_SYSCON) += reset-ti-syscon.o

drivers/reset/core.c

+95 −1
Original line number Diff line number Diff line
@@ -23,6 +23,9 @@ 
static DEFINE_MUTEX(reset_list_mutex);

static LIST_HEAD(reset_controller_list);



static DEFINE_MUTEX(reset_lookup_mutex);

static LIST_HEAD(reset_lookup_list);



/**

 * struct reset_control - a reset control

 * @rcdev: a pointer to the reset controller device
@@ -148,6 +151,33 @@ int devm_reset_controller_register(struct device *dev, 
}

EXPORT_SYMBOL_GPL(devm_reset_controller_register);



/**

 * reset_controller_add_lookup - register a set of lookup entries

 * @lookup: array of reset lookup entries

 * @num_entries: number of entries in the lookup array

 */

void reset_controller_add_lookup(struct reset_control_lookup *lookup,

				 unsigned int num_entries)

{

	struct reset_control_lookup *entry;

	unsigned int i;



	mutex_lock(&reset_lookup_mutex);

	for (i = 0; i < num_entries; i++) {

		entry = &lookup[i];



		if (!entry->dev_id || !entry->provider) {

			pr_warn("%s(): reset lookup entry badly specified, skipping\n",

				__func__);

			continue;

		}



		list_add_tail(&entry->list, &reset_lookup_list);

	}

	mutex_unlock(&reset_lookup_mutex);

}

EXPORT_SYMBOL_GPL(reset_controller_add_lookup);



static inline struct reset_control_array *

rstc_to_array(struct reset_control *rstc) {

	return container_of(rstc, struct reset_control_array, base);
@@ -493,6 +523,70 @@ struct reset_control *__of_reset_control_get(struct device_node *node, 
}

EXPORT_SYMBOL_GPL(__of_reset_control_get);



static struct reset_controller_dev *

__reset_controller_by_name(const char *name)

{

	struct reset_controller_dev *rcdev;



	lockdep_assert_held(&reset_list_mutex);



	list_for_each_entry(rcdev, &reset_controller_list, list) {

		if (!rcdev->dev)

			continue;



		if (!strcmp(name, dev_name(rcdev->dev)))

			return rcdev;

	}



	return NULL;

}



static struct reset_control *

__reset_control_get_from_lookup(struct device *dev, const char *con_id,

				bool shared, bool optional)

{

	const struct reset_control_lookup *lookup;

	struct reset_controller_dev *rcdev;

	const char *dev_id = dev_name(dev);

	struct reset_control *rstc = NULL;



	if (!dev)

		return ERR_PTR(-EINVAL);



	mutex_lock(&reset_lookup_mutex);



	list_for_each_entry(lookup, &reset_lookup_list, list) {

		if (strcmp(lookup->dev_id, dev_id))

			continue;



		if ((!con_id && !lookup->con_id) ||

		    ((con_id && lookup->con_id) &&

		     !strcmp(con_id, lookup->con_id))) {

			mutex_lock(&reset_list_mutex);

			rcdev = __reset_controller_by_name(lookup->provider);

			if (!rcdev) {

				mutex_unlock(&reset_list_mutex);

				mutex_unlock(&reset_lookup_mutex);

				/* Reset provider may not be ready yet. */

				return ERR_PTR(-EPROBE_DEFER);

			}



			rstc = __reset_control_get_internal(rcdev,

							    lookup->index,

							    shared);

			mutex_unlock(&reset_list_mutex);

			break;

		}

	}



	mutex_unlock(&reset_lookup_mutex);



	if (!rstc)

		return optional ? NULL : ERR_PTR(-ENOENT);



	return rstc;

}



struct reset_control *__reset_control_get(struct device *dev, const char *id,

					  int index, bool shared, bool optional)

{
@@ -500,7 +594,7 @@ struct reset_control *__reset_control_get(struct device *dev, const char *id, 
		return __of_reset_control_get(dev->of_node, id, index, shared,

					      optional);



	return optional ? NULL : ERR_PTR(-EINVAL);

	return __reset_control_get_from_lookup(dev, id, shared, optional);

}

EXPORT_SYMBOL_GPL(__reset_control_get);

drivers/reset/reset-stm32mp1.c

0 → 100644
+115 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * Copyright (C) STMicroelectronics 2018 - All Rights Reserved

 * Author: Gabriel Fernandez <gabriel.fernandez@st.com> for STMicroelectronics.

 */



#include <linux/device.h>

#include <linux/err.h>

#include <linux/io.h>

#include <linux/of.h>

#include <linux/platform_device.h>

#include <linux/reset-controller.h>



#define CLR_OFFSET 0x4



struct stm32_reset_data {

	struct reset_controller_dev	rcdev;

	void __iomem			*membase;

};



static inline struct stm32_reset_data *

to_stm32_reset_data(struct reset_controller_dev *rcdev)

{

	return container_of(rcdev, struct stm32_reset_data, rcdev);

}



static int stm32_reset_update(struct reset_controller_dev *rcdev,

			      unsigned long id, bool assert)

{

	struct stm32_reset_data *data = to_stm32_reset_data(rcdev);

	int reg_width = sizeof(u32);

	int bank = id / (reg_width * BITS_PER_BYTE);

	int offset = id % (reg_width * BITS_PER_BYTE);

	void __iomem *addr;



	addr = data->membase + (bank * reg_width);

	if (!assert)

		addr += CLR_OFFSET;



	writel(BIT(offset), addr);



	return 0;

}



static int stm32_reset_assert(struct reset_controller_dev *rcdev,

			      unsigned long id)

{

	return stm32_reset_update(rcdev, id, true);

}



static int stm32_reset_deassert(struct reset_controller_dev *rcdev,

				unsigned long id)

{

	return stm32_reset_update(rcdev, id, false);

}



static int stm32_reset_status(struct reset_controller_dev *rcdev,

			      unsigned long id)

{

	struct stm32_reset_data *data = to_stm32_reset_data(rcdev);

	int reg_width = sizeof(u32);

	int bank = id / (reg_width * BITS_PER_BYTE);

	int offset = id % (reg_width * BITS_PER_BYTE);

	u32 reg;



	reg = readl(data->membase + (bank * reg_width));



	return !!(reg & BIT(offset));

}



static const struct reset_control_ops stm32_reset_ops = {

	.assert		= stm32_reset_assert,

	.deassert	= stm32_reset_deassert,

	.status		= stm32_reset_status,

};



static const struct of_device_id stm32_reset_dt_ids[] = {

	{ .compatible = "st,stm32mp1-rcc"},

	{ /* sentinel */ },

};



static int stm32_reset_probe(struct platform_device *pdev)

{

	struct device *dev = &pdev->dev;

	struct stm32_reset_data *data;

	void __iomem *membase;

	struct resource *res;



	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);

	if (!data)

		return -ENOMEM;



	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	membase = devm_ioremap_resource(dev, res);

	if (IS_ERR(membase))

		return PTR_ERR(membase);



	data->membase = membase;

	data->rcdev.owner = THIS_MODULE;

	data->rcdev.nr_resets = resource_size(res) * BITS_PER_BYTE;

	data->rcdev.ops = &stm32_reset_ops;

	data->rcdev.of_node = dev->of_node;



	return devm_reset_controller_register(dev, &data->rcdev);

}



static struct platform_driver stm32_reset_driver = {

	.probe	= stm32_reset_probe,

	.driver = {

		.name		= "stm32mp1-reset",

		.of_match_table	= stm32_reset_dt_ids,

	},

};



builtin_platform_driver(stm32_reset_driver);