Unverified Commit cdd23ae6 authored by Mark Brown's avatar Mark Brown
Browse files

Merge series "Fix reset controls and RPM of NVIDIA Tegra ASoC drivers" from... 

Merge series "Fix reset controls and RPM of NVIDIA Tegra ASoC drivers" from Dmitry Osipenko <digetx@gmail.com>:

Hi,

This series adds missing hardware reset controls to I2S and AC97 drivers,
corrects runtime PM usage and drivers probe/remove order. Currently drivers
happen to work properly because reset is implicitly deasserted by tegra-clk
driver, but clk driver shouldn't touch the resets and we need to fix it
because this breaks other Tegra drivers. Previously we fixed the resets of
the AHUB and HDMI codec drivers, but turned out that we missed the I2C and
AC97 drivers.

Thanks to Paul Fertser for testing the pending clk patches and finding
that audio got broken on Tegra20 AC100 netbook because of the missing I2S
reset.

Changelog:

v5: - After taking another look at the drivers I noticed couple more
      things that could be improved. These new patches correct runtime PM
      and probe/remove order of the drivers:

        ASoC: tegra20: spdif: Correct driver removal order
        ASoC: tegra20: spdif: Remove handing of disabled runtime PM
        ASoC: tegra20: i2s: Add system level suspend-resume callbacks
        ASoC: tegra20: i2s: Correct driver removal order
        ASoC: tegra20: i2s: Use devm_clk_get()
        ASoC: tegra20: i2s: Remove handing of disabled runtime PM
        ASoC: tegra30: i2s: Correct driver removal order
        ASoC: tegra30: i2s: Use devm_clk_get()
        ASoC: tegra30: i2s: Remove handing of disabled runtime PM
        ASoC: tegra30: ahub: Reset global variable
        ASoC: tegra30: ahub: Correct suspend-resume callbacks
        ASoC: tegra30: ahub: Remove handing of disabled runtime PM

v4: - Added missing prototype for reset_control_bulk_put().

v3: - Fixed reset stubs for !CONFIG_RESET_CONTROLLER.

v2: - After some more testing I found that I2S control logic doesn't require
      I2S clock to be enabled for resetting. Hence it's fine to have I2S to
      be reset by parent AHUB driver, so I dropped "tegra30: i2s: Add reset
      control" patch.

    - While I was double-checking resets on Tegra30, I found that that
      Tegra30 I2S driver has a broken runtime PM which doesn't restore
      hardware state on resume and it's lost after AHUB RPM-resume.
      Thus, added this new patch "tegra30: i2s: Restore hardware state
      on runtime PM resume".

    - Added new patches which switch AHUB driver to use reset-bulk API.
      I took the RFC patch from Philipp Zabel, fixed it and added
      devm_reset_control_bulk_optional_get_exclusive_released() that
      will be useful for further Tegra GPU patches. This is a minor
      improvement which makes code cleaner.

Dmitry Osipenko (16):
  ASoC: tegra20: ac97: Add reset control
  ASoC: tegra20: i2s: Add reset control
  ASoC: tegra30: i2s: Restore hardware state on runtime PM resume
  ASoC: tegra30: ahub: Switch to use reset-bulk API
  ASoC: tegra20: spdif: Correct driver removal order
  ASoC: tegra20: spdif: Remove handing of disabled runtime PM
  ASoC: tegra20: i2s: Add system level suspend-resume callbacks
  ASoC: tegra20: i2s: Correct driver removal order
  ASoC: tegra20: i2s: Use devm_clk_get()
  ASoC: tegra20: i2s: Remove handing of disabled runtime PM
  ASoC: tegra30: i2s: Correct driver removal order
  ASoC: tegra30: i2s: Use devm_clk_get()
  ASoC: tegra30: i2s: Remove handing of disabled runtime PM
  ASoC: tegra30: ahub: Reset global variable
  ASoC: tegra30: ahub: Correct suspend-resume callbacks
  ASoC: tegra30: ahub: Remove handing of disabled runtime PM

Philipp Zabel (1):
  reset: Add reset_control_bulk API

 drivers/reset/core.c            | 215 ++++++++++++++++++++++
 include/linux/reset.h           | 315 ++++++++++++++++++++++++++++++++
 sound/soc/tegra/tegra20_ac97.c  |  21 +++
 sound/soc/tegra/tegra20_ac97.h  |   1 +
 sound/soc/tegra/tegra20_i2s.c   |  60 +++---
 sound/soc/tegra/tegra20_i2s.h   |   1 +
 sound/soc/tegra/tegra20_spdif.c |  16 +-
 sound/soc/tegra/tegra30_ahub.c  | 168 ++++++-----------
 sound/soc/tegra/tegra30_ahub.h  |   5 +-
 sound/soc/tegra/tegra30_i2s.c   |  65 ++-----
 10 files changed, 667 insertions(+), 200 deletions(-)

--
2.30.2

base-commit: a38fd874
parents ad83b1ad b5571449

drivers/reset/core.c

+215 −0
Original line number Diff line number Diff line
@@ -358,6 +358,30 @@ int reset_control_reset(struct reset_control *rstc) 
}

EXPORT_SYMBOL_GPL(reset_control_reset);



/**

 * reset_control_bulk_reset - reset the controlled devices in order

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset controls set

 *

 * Issue a reset on all provided reset controls, in order.

 *

 * See also: reset_control_reset()

 */

int reset_control_bulk_reset(int num_rstcs,

			     struct reset_control_bulk_data *rstcs)

{

	int ret, i;



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

		ret = reset_control_reset(rstcs[i].rstc);

		if (ret)

			return ret;

	}



	return 0;

}

EXPORT_SYMBOL_GPL(reset_control_bulk_reset);



/**

 * reset_control_rearm - allow shared reset line to be re-triggered"

 * @rstc: reset controller
@@ -461,6 +485,36 @@ int reset_control_assert(struct reset_control *rstc) 
}

EXPORT_SYMBOL_GPL(reset_control_assert);



/**

 * reset_control_bulk_assert - asserts the reset lines in order

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset controls set

 *

 * Assert the reset lines for all provided reset controls, in order.

 * If an assertion fails, already asserted resets are deasserted again.

 *

 * See also: reset_control_assert()

 */

int reset_control_bulk_assert(int num_rstcs,

			      struct reset_control_bulk_data *rstcs)

{

	int ret, i;



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

		ret = reset_control_assert(rstcs[i].rstc);

		if (ret)

			goto err;

	}



	return 0;



err:

	while (i--)

		reset_control_deassert(rstcs[i].rstc);

	return ret;

}

EXPORT_SYMBOL_GPL(reset_control_bulk_assert);



/**

 * reset_control_deassert - deasserts the reset line

 * @rstc: reset controller
@@ -511,6 +565,36 @@ int reset_control_deassert(struct reset_control *rstc) 
}

EXPORT_SYMBOL_GPL(reset_control_deassert);



/**

 * reset_control_bulk_deassert - deasserts the reset lines in reverse order

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset controls set

 *

 * Deassert the reset lines for all provided reset controls, in reverse order.

 * If a deassertion fails, already deasserted resets are asserted again.

 *

 * See also: reset_control_deassert()

 */

int reset_control_bulk_deassert(int num_rstcs,

				struct reset_control_bulk_data *rstcs)

{

	int ret, i;



	for (i = num_rstcs - 1; i >= 0; i--) {

		ret = reset_control_deassert(rstcs[i].rstc);

		if (ret)

			goto err;

	}



	return 0;



err:

	while (i < num_rstcs)

		reset_control_assert(rstcs[i++].rstc);

	return ret;

}

EXPORT_SYMBOL_GPL(reset_control_bulk_deassert);



/**

 * reset_control_status - returns a negative errno if not supported, a

 * positive value if the reset line is asserted, or zero if the reset
@@ -588,6 +672,36 @@ int reset_control_acquire(struct reset_control *rstc) 
}

EXPORT_SYMBOL_GPL(reset_control_acquire);



/**

 * reset_control_bulk_acquire - acquires reset controls for exclusive use

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset controls set

 *

 * This is used to explicitly acquire reset controls requested with

 * reset_control_bulk_get_exclusive_release() for temporary exclusive use.

 *

 * See also: reset_control_acquire(), reset_control_bulk_release()

 */

int reset_control_bulk_acquire(int num_rstcs,

			       struct reset_control_bulk_data *rstcs)

{

	int ret, i;



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

		ret = reset_control_acquire(rstcs[i].rstc);

		if (ret)

			goto err;

	}



	return 0;



err:

	while (i--)

		reset_control_release(rstcs[i].rstc);

	return ret;

}

EXPORT_SYMBOL_GPL(reset_control_bulk_acquire);



/**

 * reset_control_release() - releases exclusive access to a reset control

 * @rstc: reset control
@@ -610,6 +724,26 @@ void reset_control_release(struct reset_control *rstc) 
}

EXPORT_SYMBOL_GPL(reset_control_release);



/**

 * reset_control_bulk_release() - releases exclusive access to reset controls

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset controls set

 *

 * Releases exclusive access right to reset controls previously obtained by a

 * call to reset_control_bulk_acquire().

 *

 * See also: reset_control_release(), reset_control_bulk_acquire()

 */

void reset_control_bulk_release(int num_rstcs,

				struct reset_control_bulk_data *rstcs)

{

	int i;



	for (i = 0; i < num_rstcs; i++)

		reset_control_release(rstcs[i].rstc);

}

EXPORT_SYMBOL_GPL(reset_control_bulk_release);



static struct reset_control *__reset_control_get_internal(

				struct reset_controller_dev *rcdev,

				unsigned int index, bool shared, bool acquired)
@@ -814,6 +948,32 @@ struct reset_control *__reset_control_get(struct device *dev, const char *id, 
}

EXPORT_SYMBOL_GPL(__reset_control_get);



int __reset_control_bulk_get(struct device *dev, int num_rstcs,

			     struct reset_control_bulk_data *rstcs,

			     bool shared, bool optional, bool acquired)

{

	int ret, i;



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

		rstcs[i].rstc = __reset_control_get(dev, rstcs[i].id, 0,

						    shared, optional, acquired);

		if (IS_ERR(rstcs[i].rstc)) {

			ret = PTR_ERR(rstcs[i].rstc);

			goto err;

		}

	}



	return 0;



err:

	mutex_lock(&reset_list_mutex);

	while (i--)

		__reset_control_put_internal(rstcs[i].rstc);

	mutex_unlock(&reset_list_mutex);

	return ret;

}

EXPORT_SYMBOL_GPL(__reset_control_bulk_get);



static void reset_control_array_put(struct reset_control_array *resets)

{

	int i;
@@ -845,6 +1005,23 @@ void reset_control_put(struct reset_control *rstc) 
}

EXPORT_SYMBOL_GPL(reset_control_put);



/**

 * reset_control_bulk_put - free the reset controllers

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset controls set

 */

void reset_control_bulk_put(int num_rstcs, struct reset_control_bulk_data *rstcs)

{

	mutex_lock(&reset_list_mutex);

	while (num_rstcs--) {

		if (IS_ERR_OR_NULL(rstcs[num_rstcs].rstc))

			continue;

		__reset_control_put_internal(rstcs[num_rstcs].rstc);

	}

	mutex_unlock(&reset_list_mutex);

}

EXPORT_SYMBOL_GPL(reset_control_bulk_put);



static void devm_reset_control_release(struct device *dev, void *res)

{

	reset_control_put(*(struct reset_control **)res);
@@ -874,6 +1051,44 @@ struct reset_control *__devm_reset_control_get(struct device *dev, 
}

EXPORT_SYMBOL_GPL(__devm_reset_control_get);



struct reset_control_bulk_devres {

	int num_rstcs;

	struct reset_control_bulk_data *rstcs;

};



static void devm_reset_control_bulk_release(struct device *dev, void *res)

{

	struct reset_control_bulk_devres *devres = res;



	reset_control_bulk_put(devres->num_rstcs, devres->rstcs);

}



int __devm_reset_control_bulk_get(struct device *dev, int num_rstcs,

				  struct reset_control_bulk_data *rstcs,

				  bool shared, bool optional, bool acquired)

{

	struct reset_control_bulk_devres *ptr;

	int ret;



	ptr = devres_alloc(devm_reset_control_bulk_release, sizeof(*ptr),

			   GFP_KERNEL);

	if (!ptr)

		return -ENOMEM;



	ret = __reset_control_bulk_get(dev, num_rstcs, rstcs, shared, optional, acquired);

	if (ret < 0) {

		devres_free(ptr);

		return ret;

	}



	ptr->num_rstcs = num_rstcs;

	ptr->rstcs = rstcs;

	devres_add(dev, ptr);



	return 0;

}

EXPORT_SYMBOL_GPL(__devm_reset_control_bulk_get);



/**

 * __device_reset - find reset controller associated with the device

 *                  and perform reset

include/linux/reset.h

+315 −0
Original line number Diff line number Diff line
@@ -10,6 +10,21 @@ struct device; 
struct device_node;

struct reset_control;



/**

 * struct reset_control_bulk_data - Data used for bulk reset control operations.

 *

 * @id: reset control consumer ID

 * @rstc: struct reset_control * to store the associated reset control

 *

 * The reset APIs provide a series of reset_control_bulk_*() API calls as

 * a convenience to consumers which require multiple reset controls.

 * This structure is used to manage data for these calls.

 */

struct reset_control_bulk_data {

	const char			*id;

	struct reset_control		*rstc;

};



#ifdef CONFIG_RESET_CONTROLLER



int reset_control_reset(struct reset_control *rstc);
@@ -20,6 +35,12 @@ int reset_control_status(struct reset_control *rstc); 
int reset_control_acquire(struct reset_control *rstc);

void reset_control_release(struct reset_control *rstc);



int reset_control_bulk_reset(int num_rstcs, struct reset_control_bulk_data *rstcs);

int reset_control_bulk_assert(int num_rstcs, struct reset_control_bulk_data *rstcs);

int reset_control_bulk_deassert(int num_rstcs, struct reset_control_bulk_data *rstcs);

int reset_control_bulk_acquire(int num_rstcs, struct reset_control_bulk_data *rstcs);

void reset_control_bulk_release(int num_rstcs, struct reset_control_bulk_data *rstcs);



struct reset_control *__of_reset_control_get(struct device_node *node,

				     const char *id, int index, bool shared,

				     bool optional, bool acquired);
@@ -27,10 +48,18 @@ struct reset_control *__reset_control_get(struct device *dev, const char *id, 
					  int index, bool shared,

					  bool optional, bool acquired);

void reset_control_put(struct reset_control *rstc);

int __reset_control_bulk_get(struct device *dev, int num_rstcs,

			     struct reset_control_bulk_data *rstcs,

			     bool shared, bool optional, bool acquired);

void reset_control_bulk_put(int num_rstcs, struct reset_control_bulk_data *rstcs);



int __device_reset(struct device *dev, bool optional);

struct reset_control *__devm_reset_control_get(struct device *dev,

				     const char *id, int index, bool shared,

				     bool optional, bool acquired);

int __devm_reset_control_bulk_get(struct device *dev, int num_rstcs,

				  struct reset_control_bulk_data *rstcs,

				  bool shared, bool optional, bool acquired);



struct reset_control *devm_reset_control_array_get(struct device *dev,

						   bool shared, bool optional);
@@ -96,6 +125,48 @@ static inline struct reset_control *__reset_control_get( 
	return optional ? NULL : ERR_PTR(-ENOTSUPP);

}



static inline int

reset_control_bulk_reset(int num_rstcs, struct reset_control_bulk_data *rstcs)

{

	return 0;

}



static inline int

reset_control_bulk_assert(int num_rstcs, struct reset_control_bulk_data *rstcs)

{

	return 0;

}



static inline int

reset_control_bulk_deassert(int num_rstcs, struct reset_control_bulk_data *rstcs)

{

	return 0;

}



static inline int

reset_control_bulk_acquire(int num_rstcs, struct reset_control_bulk_data *rstcs)

{

	return 0;

}



static inline void

reset_control_bulk_release(int num_rstcs, struct reset_control_bulk_data *rstcs)

{

}



static inline int

__reset_control_bulk_get(struct device *dev, int num_rstcs,

			 struct reset_control_bulk_data *rstcs,

			 bool shared, bool optional, bool acquired)

{

	return optional ? 0 : -EOPNOTSUPP;

}



static inline void

reset_control_bulk_put(int num_rstcs, struct reset_control_bulk_data *rstcs)

{

}



static inline struct reset_control *__devm_reset_control_get(

					struct device *dev, const char *id,

					int index, bool shared, bool optional,
@@ -104,6 +175,14 @@ static inline struct reset_control *__devm_reset_control_get( 
	return optional ? NULL : ERR_PTR(-ENOTSUPP);

}



static inline int

__devm_reset_control_bulk_get(struct device *dev, int num_rstcs,

			      struct reset_control_bulk_data *rstcs,

			      bool shared, bool optional, bool acquired)

{

	return optional ? 0 : -EOPNOTSUPP;

}



static inline struct reset_control *

devm_reset_control_array_get(struct device *dev, bool shared, bool optional)

{
@@ -155,6 +234,23 @@ __must_check reset_control_get_exclusive(struct device *dev, const char *id) 
	return __reset_control_get(dev, id, 0, false, false, true);

}



/**

 * reset_control_bulk_get_exclusive - Lookup and obtain exclusive references to

 *                                    multiple reset controllers.

 * @dev: device to be reset by the controller

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset line names set

 *

 * Fills the rstcs array with pointers to exclusive reset controls and

 * returns 0, or an IS_ERR() condition containing errno.

 */

static inline int __must_check

reset_control_bulk_get_exclusive(struct device *dev, int num_rstcs,

				 struct reset_control_bulk_data *rstcs)

{

	return __reset_control_bulk_get(dev, num_rstcs, rstcs, false, false, true);

}



/**

 * reset_control_get_exclusive_released - Lookup and obtain a temoprarily

 *                                        exclusive reference to a reset
@@ -176,6 +272,48 @@ __must_check reset_control_get_exclusive_released(struct device *dev, 
	return __reset_control_get(dev, id, 0, false, false, false);

}



/**

 * reset_control_bulk_get_exclusive_released - Lookup and obtain temporarily

 *                                    exclusive references to multiple reset

 *                                    controllers.

 * @dev: device to be reset by the controller

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset line names set

 *

 * Fills the rstcs array with pointers to exclusive reset controls and

 * returns 0, or an IS_ERR() condition containing errno.

 * reset-controls returned by this function must be acquired via

 * reset_control_bulk_acquire() before they can be used and should be released

 * via reset_control_bulk_release() afterwards.

 */

static inline int __must_check

reset_control_bulk_get_exclusive_released(struct device *dev, int num_rstcs,

					  struct reset_control_bulk_data *rstcs)

{

	return __reset_control_bulk_get(dev, num_rstcs, rstcs, false, false, false);

}



/**

 * reset_control_bulk_get_optional_exclusive_released - Lookup and obtain optional

 *                                    temporarily exclusive references to multiple

 *                                    reset controllers.

 * @dev: device to be reset by the controller

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset line names set

 *

 * Optional variant of reset_control_bulk_get_exclusive_released(). If the

 * requested reset is not specified in the device tree, this function returns 0

 * instead of an error and missing rtsc is set to NULL.

 *

 * See reset_control_bulk_get_exclusive_released() for more information.

 */

static inline int __must_check

reset_control_bulk_get_optional_exclusive_released(struct device *dev, int num_rstcs,

						   struct reset_control_bulk_data *rstcs)

{

	return __reset_control_bulk_get(dev, num_rstcs, rstcs, false, true, false);

}



/**

 * reset_control_get_shared - Lookup and obtain a shared reference to a

 *                            reset controller.
@@ -204,6 +342,23 @@ static inline struct reset_control *reset_control_get_shared( 
	return __reset_control_get(dev, id, 0, true, false, false);

}



/**

 * reset_control_bulk_get_shared - Lookup and obtain shared references to

 *                                 multiple reset controllers.

 * @dev: device to be reset by the controller

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset line names set

 *

 * Fills the rstcs array with pointers to shared reset controls and

 * returns 0, or an IS_ERR() condition containing errno.

 */

static inline int __must_check

reset_control_bulk_get_shared(struct device *dev, int num_rstcs,

			      struct reset_control_bulk_data *rstcs)

{

	return __reset_control_bulk_get(dev, num_rstcs, rstcs, true, false, false);

}



/**

 * reset_control_get_optional_exclusive - optional reset_control_get_exclusive()

 * @dev: device to be reset by the controller
@@ -221,6 +376,26 @@ static inline struct reset_control *reset_control_get_optional_exclusive( 
	return __reset_control_get(dev, id, 0, false, true, true);

}



/**

 * reset_control_bulk_get_optional_exclusive - optional

 *                                             reset_control_bulk_get_exclusive()

 * @dev: device to be reset by the controller

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset line names set

 *

 * Optional variant of reset_control_bulk_get_exclusive(). If any of the

 * requested resets are not specified in the device tree, this function sets

 * them to NULL instead of returning an error.

 *

 * See reset_control_bulk_get_exclusive() for more information.

 */

static inline int __must_check

reset_control_bulk_get_optional_exclusive(struct device *dev, int num_rstcs,

					  struct reset_control_bulk_data *rstcs)

{

	return __reset_control_bulk_get(dev, num_rstcs, rstcs, false, true, true);

}



/**

 * reset_control_get_optional_shared - optional reset_control_get_shared()

 * @dev: device to be reset by the controller
@@ -238,6 +413,26 @@ static inline struct reset_control *reset_control_get_optional_shared( 
	return __reset_control_get(dev, id, 0, true, true, false);

}



/**

 * reset_control_bulk_get_optional_shared - optional

 *                                             reset_control_bulk_get_shared()

 * @dev: device to be reset by the controller

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset line names set

 *

 * Optional variant of reset_control_bulk_get_shared(). If the requested resets

 * are not specified in the device tree, this function sets them to NULL

 * instead of returning an error.

 *

 * See reset_control_bulk_get_shared() for more information.

 */

static inline int __must_check

reset_control_bulk_get_optional_shared(struct device *dev, int num_rstcs,

				       struct reset_control_bulk_data *rstcs)

{

	return __reset_control_bulk_get(dev, num_rstcs, rstcs, true, true, false);

}



/**

 * of_reset_control_get_exclusive - Lookup and obtain an exclusive reference

 *                                  to a reset controller.
@@ -343,6 +538,26 @@ __must_check devm_reset_control_get_exclusive(struct device *dev, 
	return __devm_reset_control_get(dev, id, 0, false, false, true);

}



/**

 * devm_reset_control_bulk_get_exclusive - resource managed

 *                                         reset_control_bulk_get_exclusive()

 * @dev: device to be reset by the controller

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset line names set

 *

 * Managed reset_control_bulk_get_exclusive(). For reset controllers returned

 * from this function, reset_control_put() is called automatically on driver

 * detach.

 *

 * See reset_control_bulk_get_exclusive() for more information.

 */

static inline int __must_check

devm_reset_control_bulk_get_exclusive(struct device *dev, int num_rstcs,

				      struct reset_control_bulk_data *rstcs)

{

	return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, false, false, true);

}



/**

 * devm_reset_control_get_exclusive_released - resource managed

 *                                             reset_control_get_exclusive_released()
@@ -362,6 +577,26 @@ __must_check devm_reset_control_get_exclusive_released(struct device *dev, 
	return __devm_reset_control_get(dev, id, 0, false, false, false);

}



/**

 * devm_reset_control_bulk_get_exclusive_released - resource managed

 *                                                  reset_control_bulk_get_exclusive_released()

 * @dev: device to be reset by the controller

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset line names set

 *

 * Managed reset_control_bulk_get_exclusive_released(). For reset controllers

 * returned from this function, reset_control_put() is called automatically on

 * driver detach.

 *

 * See reset_control_bulk_get_exclusive_released() for more information.

 */

static inline int __must_check

devm_reset_control_bulk_get_exclusive_released(struct device *dev, int num_rstcs,

					       struct reset_control_bulk_data *rstcs)

{

	return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, false, false, false);

}



/**

 * devm_reset_control_get_optional_exclusive_released - resource managed

 *                                                      reset_control_get_optional_exclusive_released()
@@ -381,6 +616,26 @@ __must_check devm_reset_control_get_optional_exclusive_released(struct device *d 
	return __devm_reset_control_get(dev, id, 0, false, true, false);

}



/**

 * devm_reset_control_bulk_get_optional_exclusive_released - resource managed

 *                                                           reset_control_bulk_optional_get_exclusive_released()

 * @dev: device to be reset by the controller

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset line names set

 *

 * Managed reset_control_bulk_optional_get_exclusive_released(). For reset

 * controllers returned from this function, reset_control_put() is called

 * automatically on driver detach.

 *

 * See reset_control_bulk_optional_get_exclusive_released() for more information.

 */

static inline int __must_check

devm_reset_control_bulk_get_optional_exclusive_released(struct device *dev, int num_rstcs,

							struct reset_control_bulk_data *rstcs)

{

	return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, false, true, false);

}



/**

 * devm_reset_control_get_shared - resource managed reset_control_get_shared()

 * @dev: device to be reset by the controller
@@ -396,6 +651,26 @@ static inline struct reset_control *devm_reset_control_get_shared( 
	return __devm_reset_control_get(dev, id, 0, true, false, false);

}



/**

 * devm_reset_control_bulk_get_shared - resource managed

 *                                      reset_control_bulk_get_shared()

 * @dev: device to be reset by the controller

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset line names set

 *

 * Managed reset_control_bulk_get_shared(). For reset controllers returned

 * from this function, reset_control_put() is called automatically on driver

 * detach.

 *

 * See reset_control_bulk_get_shared() for more information.

 */

static inline int __must_check

devm_reset_control_bulk_get_shared(struct device *dev, int num_rstcs,

				   struct reset_control_bulk_data *rstcs)

{

	return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, true, false, false);

}



/**

 * devm_reset_control_get_optional_exclusive - resource managed

 *                                             reset_control_get_optional_exclusive()
@@ -414,6 +689,26 @@ static inline struct reset_control *devm_reset_control_get_optional_exclusive( 
	return __devm_reset_control_get(dev, id, 0, false, true, true);

}



/**

 * devm_reset_control_bulk_get_optional_exclusive - resource managed

 *                                                  reset_control_bulk_get_optional_exclusive()

 * @dev: device to be reset by the controller

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset line names set

 *

 * Managed reset_control_bulk_get_optional_exclusive(). For reset controllers

 * returned from this function, reset_control_put() is called automatically on

 * driver detach.

 *

 * See reset_control_bulk_get_optional_exclusive() for more information.

 */

static inline int __must_check

devm_reset_control_bulk_get_optional_exclusive(struct device *dev, int num_rstcs,

					       struct reset_control_bulk_data *rstcs)

{

	return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, true, false, true);

}



/**

 * devm_reset_control_get_optional_shared - resource managed

 *                                          reset_control_get_optional_shared()
@@ -432,6 +727,26 @@ static inline struct reset_control *devm_reset_control_get_optional_shared( 
	return __devm_reset_control_get(dev, id, 0, true, true, false);

}



/**

 * devm_reset_control_bulk_get_optional_shared - resource managed

 *                                               reset_control_bulk_get_optional_shared()

 * @dev: device to be reset by the controller

 * @num_rstcs: number of entries in rstcs array

 * @rstcs: array of struct reset_control_bulk_data with reset line names set

 *

 * Managed reset_control_bulk_get_optional_shared(). For reset controllers

 * returned from this function, reset_control_put() is called automatically on

 * driver detach.

 *

 * See reset_control_bulk_get_optional_shared() for more information.

 */

static inline int __must_check

devm_reset_control_bulk_get_optional_shared(struct device *dev, int num_rstcs,

					    struct reset_control_bulk_data *rstcs)

{

	return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, true, true, false);

}



/**

 * devm_reset_control_get_exclusive_by_index - resource managed

 *                                             reset_control_get_exclusive()

sound/soc/tegra/tegra20_ac97.c

+21 −0
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
#include <linux/platform_device.h>

#include <linux/pm_runtime.h>

#include <linux/regmap.h>

#include <linux/reset.h>

#include <linux/slab.h>

#include <sound/core.h>

#include <sound/pcm.h>
@@ -313,6 +314,12 @@ static int tegra20_ac97_platform_probe(struct platform_device *pdev) 
	}

	dev_set_drvdata(&pdev->dev, ac97);



	ac97->reset = devm_reset_control_get_exclusive(&pdev->dev, "ac97");

	if (IS_ERR(ac97->reset)) {

		dev_err(&pdev->dev, "Can't retrieve ac97 reset\n");

		return PTR_ERR(ac97->reset);

	}



	ac97->clk_ac97 = devm_clk_get(&pdev->dev, NULL);

	if (IS_ERR(ac97->clk_ac97)) {

		dev_err(&pdev->dev, "Can't retrieve ac97 clock\n");
@@ -364,12 +371,26 @@ static int tegra20_ac97_platform_probe(struct platform_device *pdev) 
	ac97->playback_dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;

	ac97->playback_dma_data.maxburst = 4;



	ret = reset_control_assert(ac97->reset);

	if (ret) {

		dev_err(&pdev->dev, "Failed to assert AC'97 reset: %d\n", ret);

		goto err_clk_put;

	}



	ret = clk_prepare_enable(ac97->clk_ac97);

	if (ret) {

		dev_err(&pdev->dev, "clk_enable failed: %d\n", ret);

		goto err_clk_put;

	}



	usleep_range(10, 100);



	ret = reset_control_deassert(ac97->reset);

	if (ret) {

		dev_err(&pdev->dev, "Failed to deassert AC'97 reset: %d\n", ret);

		goto err_clk_disable_unprepare;

	}



	ret = snd_soc_set_ac97_ops(&tegra20_ac97_ops);

	if (ret) {

		dev_err(&pdev->dev, "Failed to set AC'97 ops: %d\n", ret);

sound/soc/tegra/tegra20_ac97.h

+1 −0
Original line number Diff line number Diff line
@@ -78,6 +78,7 @@ struct tegra20_ac97 { 
	struct clk *clk_ac97;

	struct snd_dmaengine_dai_dma_data capture_dma_data;

	struct snd_dmaengine_dai_dma_data playback_dma_data;

	struct reset_control *reset;

	struct regmap *regmap;

	int reset_gpio;

	int sync_gpio;

sound/soc/tegra/tegra20_i2s.c

+38 −22

File changed.

Preview size limit exceeded, changes collapsed.