Merge tag 'tegra-for-5.2-soc' of... (990d4322) · Commits · 戴 / test

drivers/reset/core.c

+166 −14

Original line number	Diff line number	Diff line
		@@ -34,6 +34,7 @@ static LIST_HEAD(reset_lookup_list);
		* @id: ID of the reset controller in the reset
		* controller device
		* @refcnt: Number of gets of this reset_control
		* @acquired: Only one reset_control may be acquired for a given rcdev and id.
		* @shared: Is this a shared (1), or an exclusive (0) reset_control?
		* @deassert_cnt: Number of times this reset line has been deasserted
		* @triggered_count: Number of times this reset line has been reset. Currently
		@@ -45,6 +46,7 @@ struct reset_control {
		struct list_head list;
		unsigned int id;
		struct kref refcnt;
		bool acquired;
		bool shared;
		bool array;
		atomic_t deassert_count;
		@@ -63,6 +65,17 @@ struct reset_control_array {
		struct reset_control *rstc[];
		};

		static const char rcdev_name(struct reset_controller_dev rcdev)
		{
		if (rcdev->dev)
		return dev_name(rcdev->dev);

		if (rcdev->of_node)
		return rcdev->of_node->full_name;

		return NULL;
		}

		/**
		* of_reset_simple_xlate - translate reset_spec to the reset line number
		* @rcdev: a pointer to the reset controller device
		@@ -232,6 +245,34 @@ err:
		return ret;
		}

		static int reset_control_array_acquire(struct reset_control_array *resets)
		{
		unsigned int i;
		int err;

		for (i = 0; i < resets->num_rstcs; i++) {
		err = reset_control_acquire(resets->rstc[i]);
		if (err < 0)
		goto release;
		}

		return 0;

		release:
		while (i--)
		reset_control_release(resets->rstc[i]);

		return err;
		}

		static void reset_control_array_release(struct reset_control_array *resets)
		{
		unsigned int i;

		for (i = 0; i < resets->num_rstcs; i++)
		reset_control_release(resets->rstc[i]);
		}

		static inline bool reset_control_is_array(struct reset_control *rstc)
		{
		return rstc->array;
		@@ -272,6 +313,9 @@ int reset_control_reset(struct reset_control *rstc)

		if (atomic_inc_return(&rstc->triggered_count) != 1)
		return 0;
		} else {
		if (!rstc->acquired)
		return -EPERM;
		}

		ret = rstc->rcdev->ops->reset(rstc->rcdev, rstc->id);
		@@ -334,6 +378,12 @@ int reset_control_assert(struct reset_control *rstc)
		*/
		if (!rstc->rcdev->ops->assert)
		return -ENOTSUPP;

		if (!rstc->acquired) {
		WARN(1, "reset %s (ID: %u) is not acquired\n",
		rcdev_name(rstc->rcdev), rstc->id);
		return -EPERM;
		}
		}

		return rstc->rcdev->ops->assert(rstc->rcdev, rstc->id);
		@@ -369,6 +419,12 @@ int reset_control_deassert(struct reset_control *rstc)

		if (atomic_inc_return(&rstc->deassert_count) != 1)
		return 0;
		} else {
		if (!rstc->acquired) {
		WARN(1, "reset %s (ID: %u) is not acquired\n",
		rcdev_name(rstc->rcdev), rstc->id);
		return -EPERM;
		}
		}

		/*
		@@ -406,9 +462,87 @@ int reset_control_status(struct reset_control *rstc)
		}
		EXPORT_SYMBOL_GPL(reset_control_status);

		/**
		* reset_control_acquire() - acquires a reset control for exclusive use
		* @rstc: reset control
		*
		* This is used to explicitly acquire a reset control for exclusive use. Note
		* that exclusive resets are requested as acquired by default. In order for a
		* second consumer to be able to control the reset, the first consumer has to
		* release it first. Typically the easiest way to achieve this is to call the
		* reset_control_get_exclusive_released() to obtain an instance of the reset
		* control. Such reset controls are not acquired by default.
		*
		* Consumers implementing shared access to an exclusive reset need to follow
		* a specific protocol in order to work together. Before consumers can change
		* a reset they must acquire exclusive access using reset_control_acquire().
		* After they are done operating the reset, they must release exclusive access
		* with a call to reset_control_release(). Consumers are not granted exclusive
		* access to the reset as long as another consumer hasn't released a reset.
		*
		* See also: reset_control_release()
		*/
		int reset_control_acquire(struct reset_control *rstc)
		{
		struct reset_control *rc;

		if (!rstc)
		return 0;

		if (WARN_ON(IS_ERR(rstc)))
		return -EINVAL;

		if (reset_control_is_array(rstc))
		return reset_control_array_acquire(rstc_to_array(rstc));

		mutex_lock(&reset_list_mutex);

		if (rstc->acquired) {
		mutex_unlock(&reset_list_mutex);
		return 0;
		}

		list_for_each_entry(rc, &rstc->rcdev->reset_control_head, list) {
		if (rstc != rc && rstc->id == rc->id) {
		if (rc->acquired) {
		mutex_unlock(&reset_list_mutex);
		return -EBUSY;
		}
		}
		}

		rstc->acquired = true;

		mutex_unlock(&reset_list_mutex);
		return 0;
		}
		EXPORT_SYMBOL_GPL(reset_control_acquire);

		/**
		* reset_control_release() - releases exclusive access to a reset control
		* @rstc: reset control
		*
		* Releases exclusive access right to a reset control previously obtained by a
		* call to reset_control_acquire(). Until a consumer calls this function, no
		* other consumers will be granted exclusive access.
		*
		* See also: reset_control_acquire()
		*/
		void reset_control_release(struct reset_control *rstc)
		{
		if (!rstc \|\| WARN_ON(IS_ERR(rstc)))
		return;

		if (reset_control_is_array(rstc))
		reset_control_array_release(rstc_to_array(rstc));
		else
		rstc->acquired = false;
		}
		EXPORT_SYMBOL_GPL(reset_control_release);

		static struct reset_control *__reset_control_get_internal(
		struct reset_controller_dev *rcdev,
		unsigned int index, bool shared)
		unsigned int index, bool shared, bool acquired)
		{
		struct reset_control *rstc;

		@@ -416,6 +550,14 @@ static struct reset_control *__reset_control_get_internal(

		list_for_each_entry(rstc, &rcdev->reset_control_head, list) {
		if (rstc->id == index) {
		/*
		* Allow creating a secondary exclusive reset_control
		* that is initially not acquired for an already
		* controlled reset line.
		*/
		if (!rstc->shared && !shared && !acquired)
		break;

		if (WARN_ON(!rstc->shared \|\| !shared))
		return ERR_PTR(-EBUSY);

		@@ -434,6 +576,7 @@ static struct reset_control *__reset_control_get_internal(
		list_add(&rstc->list, &rcdev->reset_control_head);
		rstc->id = index;
		kref_init(&rstc->refcnt);
		rstc->acquired = acquired;
		rstc->shared = shared;

		return rstc;
		@@ -461,7 +604,7 @@ static void __reset_control_put_internal(struct reset_control *rstc)

		struct reset_control __of_reset_control_get(struct device_node node,
		const char *id, int index, bool shared,
		bool optional)
		bool optional, bool acquired)
		{
		struct reset_control *rstc;
		struct reset_controller_dev r, rcdev;
		@@ -514,7 +657,7 @@ struct reset_control __of_reset_control_get(struct device_node node,
		}

		/* reset_list_mutex also protects the rcdev's reset_control list */
		rstc = __reset_control_get_internal(rcdev, rstc_id, shared);
		rstc = __reset_control_get_internal(rcdev, rstc_id, shared, acquired);

		out:
		mutex_unlock(&reset_list_mutex);
		@@ -544,7 +687,7 @@ __reset_controller_by_name(const char *name)

		static struct reset_control *
		__reset_control_get_from_lookup(struct device dev, const char con_id,
		bool shared, bool optional)
		bool shared, bool optional, bool acquired)
		{
		const struct reset_control_lookup *lookup;
		struct reset_controller_dev *rcdev;
		@@ -574,7 +717,7 @@ __reset_control_get_from_lookup(struct device dev, const char con_id,

		rstc = __reset_control_get_internal(rcdev,
		lookup->index,
		shared);
		shared, acquired);
		mutex_unlock(&reset_list_mutex);
		break;
		}
		@@ -589,13 +732,18 @@ __reset_control_get_from_lookup(struct device dev, const char con_id,
		}

		struct reset_control __reset_control_get(struct device dev, const char *id,
		int index, bool shared, bool optional)
		int index, bool shared, bool optional,
		bool acquired)
		{
		if (WARN_ON(shared && acquired))
		return ERR_PTR(-EINVAL);

		if (dev->of_node)
		return __of_reset_control_get(dev->of_node, id, index, shared,
		optional);
		optional, acquired);

		return __reset_control_get_from_lookup(dev, id, shared, optional);
		return __reset_control_get_from_lookup(dev, id, shared, optional,
		acquired);
		}
		EXPORT_SYMBOL_GPL(__reset_control_get);

		@@ -636,7 +784,7 @@ static void devm_reset_control_release(struct device dev, void res)

		struct reset_control __devm_reset_control_get(struct device dev,
		const char *id, int index, bool shared,
		bool optional)
		bool optional, bool acquired)
		{
		struct reset_control *ptr, rstc;

		@@ -645,7 +793,7 @@ struct reset_control __devm_reset_control_get(struct device dev,
		if (!ptr)
		return ERR_PTR(-ENOMEM);

		rstc = __reset_control_get(dev, id, index, shared, optional);
		rstc = __reset_control_get(dev, id, index, shared, optional, acquired);
		if (!IS_ERR(rstc)) {
		*ptr = rstc;
		devres_add(dev, ptr);
		@@ -672,7 +820,7 @@ int __device_reset(struct device *dev, bool optional)
		struct reset_control *rstc;
		int ret;

		rstc = __reset_control_get(dev, NULL, 0, 0, optional);
		rstc = __reset_control_get(dev, NULL, 0, 0, optional, true);
		if (IS_ERR(rstc))
		return PTR_ERR(rstc);

		@@ -716,12 +864,15 @@ static int of_reset_control_get_count(struct device_node *node)
		* @np: device node for the device that requests the reset controls array
		* @shared: whether reset controls are shared or not
		* @optional: whether it is optional to get the reset controls
		* @acquired: only one reset control may be acquired for a given controller
		* and ID
		*
		* Returns pointer to allocated reset_control_array on success or
		* error on failure
		*/
		struct reset_control *
		of_reset_control_array_get(struct device_node *np, bool shared, bool optional)
		of_reset_control_array_get(struct device_node *np, bool shared, bool optional,
		bool acquired)
		{
		struct reset_control_array *resets;
		struct reset_control *rstc;
		@@ -736,7 +887,8 @@ of_reset_control_array_get(struct device_node *np, bool shared, bool optional)
		return ERR_PTR(-ENOMEM);

		for (i = 0; i < num; i++) {
		rstc = __of_reset_control_get(np, NULL, i, shared, optional);
		rstc = __of_reset_control_get(np, NULL, i, shared, optional,
		acquired);
		if (IS_ERR(rstc))
		goto err_rst;
		resets->rstc[i] = rstc;
		@@ -783,7 +935,7 @@ devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
		if (!devres)
		return ERR_PTR(-ENOMEM);

		rstc = of_reset_control_array_get(dev->of_node, shared, optional);
		rstc = of_reset_control_array_get(dev->of_node, shared, optional, true);
		if (IS_ERR(rstc)) {
		devres_free(devres);
		return rstc;

drivers/soc/tegra/pmc.c

+134 −37

Original line number	Diff line number	Diff line
		@@ -268,6 +268,14 @@ static const char * const tegra186_reset_levels[] = {
		};

		static const char * const tegra30_reset_sources[] = {
		"POWER_ON_RESET",
		"WATCHDOG",
		"SENSOR",
		"SW_MAIN",
		"LP0"
		};

		static const char * const tegra210_reset_sources[] = {
		"POWER_ON_RESET",
		"WATCHDOG",
		"SENSOR",
		@@ -656,10 +664,15 @@ static int tegra_genpd_power_on(struct generic_pm_domain *domain)
		int err;

		err = tegra_powergate_power_up(pg, true);
		if (err)
		if (err) {
		dev_err(dev, "failed to turn on PM domain %s: %d\n",
		pg->genpd.name, err);
		goto out;
		}

		reset_control_release(pg->reset);

		out:
		return err;
		}

		@@ -669,10 +682,18 @@ static int tegra_genpd_power_off(struct generic_pm_domain *domain)
		struct device *dev = pg->pmc->dev;
		int err;

		err = reset_control_acquire(pg->reset);
		if (err < 0) {
		pr_err("failed to acquire resets: %d\n", err);
		return err;
		}

		err = tegra_powergate_power_down(pg);
		if (err)
		if (err) {
		dev_err(dev, "failed to turn off PM domain %s: %d\n",
		pg->genpd.name, err);
		reset_control_release(pg->reset);
		}

		return err;
		}
		@@ -937,38 +958,53 @@ static int tegra_powergate_of_get_resets(struct tegra_powergate *pg,
		struct device *dev = pg->pmc->dev;
		int err;

		pg->reset = of_reset_control_array_get_exclusive(np);
		pg->reset = of_reset_control_array_get_exclusive_released(np);
		if (IS_ERR(pg->reset)) {
		err = PTR_ERR(pg->reset);
		dev_err(dev, "failed to get device resets: %d\n", err);
		return err;
		}

		if (off)
		err = reset_control_acquire(pg->reset);
		if (err < 0) {
		pr_err("failed to acquire resets: %d\n", err);
		goto out;
		}

		if (off) {
		err = reset_control_assert(pg->reset);
		else
		} else {
		err = reset_control_deassert(pg->reset);
		if (err < 0)
		goto out;

		if (err)
		reset_control_release(pg->reset);
		}

		out:
		if (err) {
		reset_control_release(pg->reset);
		reset_control_put(pg->reset);
		}

		return err;
		}

		static void tegra_powergate_add(struct tegra_pmc pmc, struct device_node np)
		static int tegra_powergate_add(struct tegra_pmc pmc, struct device_node np)
		{
		struct device *dev = pmc->dev;
		struct tegra_powergate *pg;
		int id, err;
		int id, err = 0;
		bool off;

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

		id = tegra_powergate_lookup(pmc, np->name);
		if (id < 0) {
		dev_err(dev, "powergate lookup failed for %pOFn: %d\n", np, id);
		err = -ENODEV;
		goto free_mem;
		}

		@@ -1021,7 +1057,7 @@ static void tegra_powergate_add(struct tegra_pmc pmc, struct device_node np)

		dev_dbg(dev, "added PM domain %s\n", pg->genpd.name);

		return;
		return 0;

		remove_genpd:
		pm_genpd_remove(&pg->genpd);
		@@ -1040,25 +1076,67 @@ set_available:

		free_mem:
		kfree(pg);

		return err;
		}

		static void tegra_powergate_init(struct tegra_pmc *pmc,
		static int tegra_powergate_init(struct tegra_pmc *pmc,
		struct device_node *parent)
		{
		struct device_node np, child;
		unsigned int i;
		int err = 0;

		/* Create a bitmap of the available and valid partitions */
		for (i = 0; i < pmc->soc->num_powergates; i++)
		if (pmc->soc->powergates[i])
		set_bit(i, pmc->powergates_available);
		np = of_get_child_by_name(parent, "powergates");
		if (!np)
		return 0;

		for_each_child_of_node(np, child) {
		err = tegra_powergate_add(pmc, child);
		if (err < 0) {
		of_node_put(child);
		break;
		}
		}

		of_node_put(np);

		return err;
		}

		static void tegra_powergate_remove(struct generic_pm_domain *genpd)
		{
		struct tegra_powergate *pg = to_powergate(genpd);

		reset_control_put(pg->reset);

		while (pg->num_clks--)
		clk_put(pg->clks[pg->num_clks]);

		kfree(pg->clks);

		set_bit(pg->id, pmc->powergates_available);

		kfree(pg);
		}

		static void tegra_powergate_remove_all(struct device_node *parent)
		{
		struct generic_pm_domain *genpd;
		struct device_node np, child;

		np = of_get_child_by_name(parent, "powergates");
		if (!np)
		return;

		for_each_child_of_node(np, child)
		tegra_powergate_add(pmc, child);
		for_each_child_of_node(np, child) {
		of_genpd_del_provider(child);

		genpd = of_genpd_remove_last(child);
		if (IS_ERR(genpd))
		continue;

		tegra_powergate_remove(genpd);
		}

		of_node_put(np);
		}
		@@ -1709,13 +1787,16 @@ static int tegra_pmc_pinctrl_init(struct tegra_pmc *pmc)
		static ssize_t reset_reason_show(struct device *dev,
		struct device_attribute attr, char buf)
		{
		u32 value, rst_src;
		u32 value;

		value = tegra_pmc_readl(pmc, pmc->soc->regs->rst_status);
		rst_src = (value & pmc->soc->regs->rst_source_mask) >>
		pmc->soc->regs->rst_source_shift;
		value &= pmc->soc->regs->rst_source_mask;
		value >>= pmc->soc->regs->rst_source_shift;

		if (WARN_ON(value >= pmc->soc->num_reset_sources))
		return sprintf(buf, "%s\n", "UNKNOWN");

		return sprintf(buf, "%s\n", pmc->soc->reset_sources[rst_src]);
		return sprintf(buf, "%s\n", pmc->soc->reset_sources[value]);
		}

		static DEVICE_ATTR_RO(reset_reason);
		@@ -1723,13 +1804,16 @@ static DEVICE_ATTR_RO(reset_reason);
		static ssize_t reset_level_show(struct device *dev,
		struct device_attribute attr, char buf)
		{
		u32 value, rst_lvl;
		u32 value;

		value = tegra_pmc_readl(pmc, pmc->soc->regs->rst_status);
		rst_lvl = (value & pmc->soc->regs->rst_level_mask) >>
		pmc->soc->regs->rst_level_shift;
		value &= pmc->soc->regs->rst_level_mask;
		value >>= pmc->soc->regs->rst_level_shift;

		return sprintf(buf, "%s\n", pmc->soc->reset_levels[rst_lvl]);
		if (WARN_ON(value >= pmc->soc->num_reset_levels))
		return sprintf(buf, "%s\n", "UNKNOWN");

		return sprintf(buf, "%s\n", pmc->soc->reset_levels[value]);
		}

		static DEVICE_ATTR_RO(reset_level);
		@@ -1999,7 +2083,7 @@ static int tegra_pmc_probe(struct platform_device *pdev)
		if (IS_ENABLED(CONFIG_DEBUG_FS)) {
		err = tegra_powergate_debugfs_init();
		if (err < 0)
		return err;
		goto cleanup_sysfs;
		}

		err = register_restart_handler(&tegra_pmc_restart_handler);
		@@ -2013,9 +2097,13 @@ static int tegra_pmc_probe(struct platform_device *pdev)
		if (err)
		goto cleanup_restart_handler;

		err = tegra_powergate_init(pmc, pdev->dev.of_node);
		if (err < 0)
		goto cleanup_powergates;

		err = tegra_pmc_irq_init(pmc);
		if (err < 0)
		goto cleanup_restart_handler;
		goto cleanup_powergates;

		mutex_lock(&pmc->powergates_lock);
		iounmap(pmc->base);
		@@ -2026,10 +2114,15 @@ static int tegra_pmc_probe(struct platform_device *pdev)

		return 0;

		cleanup_powergates:
		tegra_powergate_remove_all(pdev->dev.of_node);
		cleanup_restart_handler:
		unregister_restart_handler(&tegra_pmc_restart_handler);
		cleanup_debugfs:
		debugfs_remove(pmc->debugfs);
		cleanup_sysfs:
		device_remove_file(&pdev->dev, &dev_attr_reset_reason);
		device_remove_file(&pdev->dev, &dev_attr_reset_level);
		return err;
		}

		@@ -2185,7 +2278,7 @@ static const struct tegra_pmc_soc tegra30_pmc_soc = {
		.init = tegra20_pmc_init,
		.setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
		.reset_sources = tegra30_reset_sources,
		.num_reset_sources = 5,
		.num_reset_sources = ARRAY_SIZE(tegra30_reset_sources),
		.reset_levels = NULL,
		.num_reset_levels = 0,
		};
		@@ -2236,7 +2329,7 @@ static const struct tegra_pmc_soc tegra114_pmc_soc = {
		.init = tegra20_pmc_init,
		.setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
		.reset_sources = tegra30_reset_sources,
		.num_reset_sources = 5,
		.num_reset_sources = ARRAY_SIZE(tegra30_reset_sources),
		.reset_levels = NULL,
		.num_reset_levels = 0,
		};
		@@ -2347,7 +2440,7 @@ static const struct tegra_pmc_soc tegra124_pmc_soc = {
		.init = tegra20_pmc_init,
		.setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
		.reset_sources = tegra30_reset_sources,
		.num_reset_sources = 5,
		.num_reset_sources = ARRAY_SIZE(tegra30_reset_sources),
		.reset_levels = NULL,
		.num_reset_levels = 0,
		};
		@@ -2452,8 +2545,8 @@ static const struct tegra_pmc_soc tegra210_pmc_soc = {
		.regs = &tegra20_pmc_regs,
		.init = tegra20_pmc_init,
		.setup_irq_polarity = tegra20_pmc_setup_irq_polarity,
		.reset_sources = tegra30_reset_sources,
		.num_reset_sources = 5,
		.reset_sources = tegra210_reset_sources,
		.num_reset_sources = ARRAY_SIZE(tegra210_reset_sources),
		.reset_levels = NULL,
		.num_reset_levels = 0,
		};
		@@ -2578,9 +2671,9 @@ static const struct tegra_pmc_soc tegra186_pmc_soc = {
		.init = NULL,
		.setup_irq_polarity = tegra186_pmc_setup_irq_polarity,
		.reset_sources = tegra186_reset_sources,
		.num_reset_sources = 14,
		.num_reset_sources = ARRAY_SIZE(tegra186_reset_sources),
		.reset_levels = tegra186_reset_levels,
		.num_reset_levels = 3,
		.num_reset_levels = ARRAY_SIZE(tegra186_reset_levels),
		.num_wake_events = ARRAY_SIZE(tegra186_wake_events),
		.wake_events = tegra186_wake_events,
		};
		@@ -2719,6 +2812,7 @@ static int __init tegra_pmc_early_init(void)
		const struct of_device_id *match;
		struct device_node *np;
		struct resource regs;
		unsigned int i;
		bool invert;

		mutex_init(&pmc->powergates_lock);
		@@ -2775,7 +2869,10 @@ static int __init tegra_pmc_early_init(void)
		if (pmc->soc->maybe_tz_only)
		pmc->tz_only = tegra_pmc_detect_tz_only(pmc);

		tegra_powergate_init(pmc, np);
		/* Create a bitmap of the available and valid partitions */
		for (i = 0; i < pmc->soc->num_powergates; i++)
		if (pmc->soc->powergates[i])
		set_bit(i, pmc->powergates_available);

		/*
		* Invert the interrupt polarity if a PMC device tree node

drivers/usb/dwc3/dwc3-of-simple.c

+2 −1

Original line number	Diff line number	Diff line
		@@ -107,7 +107,8 @@ static int dwc3_of_simple_probe(struct platform_device *pdev)
		simple->pulse_resets = true;
		}

		simple->resets = of_reset_control_array_get(np, shared_resets, true);
		simple->resets = of_reset_control_array_get(np, shared_resets, true,
		true);
		if (IS_ERR(simple->resets)) {
		ret = PTR_ERR(simple->resets);
		dev_err(dev, "failed to get device resets, err=%d\n", ret);

include/linux/reset.h

+87 −26

File changed.

Preview size limit exceeded, changes collapsed.

Admin message