Merge remote-tracking branches 'asoc/topic/adau', 'asoc/topic/adau7002',... (72a04d6b) · Commits · e / devices / android_kernel_teracube_2e

Documentation/devicetree/bindings/sound/adi,adau17x1.txt

+8 −0

Original line number	Diff line number	Diff line
		@@ -13,6 +13,11 @@ Required properties:
		- reg: The i2c address. Value depends on the state of ADDR0
		and ADDR1, as wired in hardware.

		Optional properties:
		- clock-names: If provided must be "mclk".
		- clocks: phandle + clock-specifiers for the clock that provides
		the audio master clock for the device.

		Examples:
		#include <dt-bindings/sound/adau17x1.h>

		@@ -20,5 +25,8 @@ Examples:
		adau1361@38 {
		compatible = "adi,adau1761";
		reg = <0x38>;

		clock-names = "mclk";
		clocks = <&audio_clock>;
		};
		};

Documentation/devicetree/bindings/sound/adi,adau7002.txt

0 → 100644

+19 −0

Original line number	Diff line number	Diff line
		Analog Devices ADAU7002 Stereo PDM-to-I2S/TDM Converter

		Required properties:

		- compatible: Must be "adi,adau7002"

		Optional properties:

		- IOVDD-supply: Phandle and specifier for the power supply providing the IOVDD
		supply as covered in Documentation/devicetree/bindings/regulator/regulator.txt

		If this property is not present it is assumed that the supply pin is
		hardwired to always on.

		Example:
		adau7002: pdm-to-i2s {
		compatible = "adi,adau7002";
		IOVDD-supply = <&supply>;
		};

include/linux/mfd/arizona/core.h

+10 −0

Original line number	Diff line number	Diff line
		@@ -14,6 +14,7 @@
		#define _WM_ARIZONA_CORE_H

		#include <linux/interrupt.h>
		#include <linux/notifier.h>
		#include <linux/regmap.h>
		#include <linux/regulator/consumer.h>
		#include <linux/mfd/arizona/pdata.h>
		@@ -148,8 +149,17 @@ struct arizona {
		uint16_t dac_comp_coeff;
		uint8_t dac_comp_enabled;
		struct mutex dac_comp_lock;

		struct blocking_notifier_head notifier;
		};

		static inline int arizona_call_notifiers(struct arizona *arizona,
		unsigned long event,
		void *data)
		{
		return blocking_notifier_call_chain(&arizona->notifier, event, data);
		}

		int arizona_clk32k_enable(struct arizona *arizona);
		int arizona_clk32k_disable(struct arizona *arizona);

include/sound/compress_driver.h

+5 −0

Original line number	Diff line number	Diff line
		@@ -68,6 +68,7 @@ struct snd_compr_runtime {
		* @ops: pointer to DSP callbacks
		* @runtime: pointer to runtime structure
		* @device: device pointer
		* @error_work: delayed work used when closing the stream due to an error
		* @direction: stream direction, playback/recording
		* @metadata_set: metadata set flag, true when set
		* @next_track: has userspace signal next track transition, true when set
		@@ -78,6 +79,7 @@ struct snd_compr_stream {
		struct snd_compr_ops *ops;
		struct snd_compr_runtime *runtime;
		struct snd_compr *device;
		struct delayed_work error_work;
		enum snd_compr_direction direction;
		bool metadata_set;
		bool next_track;
		@@ -187,4 +189,7 @@ static inline void snd_compr_drain_notify(struct snd_compr_stream *stream)
		wake_up(&stream->runtime->sleep);
		}

		int snd_compr_stop_error(struct snd_compr_stream *stream,
		snd_pcm_state_t state);

		#endif

sound/core/compress_offload.c

+65 −2

Original line number	Diff line number	Diff line
		@@ -67,6 +67,8 @@ struct snd_compr_file {
		struct snd_compr_stream stream;
		};

		static void error_delayed_work(struct work_struct *work);

		/*
		* a note on stream states used:
		* we use following states in the compressed core
		@@ -123,6 +125,9 @@ static int snd_compr_open(struct inode inode, struct file f)
		snd_card_unref(compr->card);
		return -ENOMEM;
		}

		INIT_DELAYED_WORK(&data->stream.error_work, error_delayed_work);

		data->stream.ops = compr->ops;
		data->stream.direction = dirn;
		data->stream.private_data = compr->private_data;
		@@ -153,6 +158,8 @@ static int snd_compr_free(struct inode inode, struct file f)
		struct snd_compr_file *data = f->private_data;
		struct snd_compr_runtime *runtime = data->stream.runtime;

		cancel_delayed_work_sync(&data->stream.error_work);

		switch (runtime->state) {
		case SNDRV_PCM_STATE_RUNNING:
		case SNDRV_PCM_STATE_DRAINING:
		@@ -237,6 +244,15 @@ snd_compr_ioctl_avail(struct snd_compr_stream *stream, unsigned long arg)
		avail = snd_compr_calc_avail(stream, &ioctl_avail);
		ioctl_avail.avail = avail;

		switch (stream->runtime->state) {
		case SNDRV_PCM_STATE_OPEN:
		return -EBADFD;
		case SNDRV_PCM_STATE_XRUN:
		return -EPIPE;
		default:
		break;
		}

		if (copy_to_user((__u64 __user *)arg,
		&ioctl_avail, sizeof(ioctl_avail)))
		return -EFAULT;
		@@ -346,11 +362,13 @@ static ssize_t snd_compr_read(struct file f, char __user buf,
		switch (stream->runtime->state) {
		case SNDRV_PCM_STATE_OPEN:
		case SNDRV_PCM_STATE_PREPARED:
		case SNDRV_PCM_STATE_XRUN:
		case SNDRV_PCM_STATE_SUSPENDED:
		case SNDRV_PCM_STATE_DISCONNECTED:
		retval = -EBADFD;
		goto out;
		case SNDRV_PCM_STATE_XRUN:
		retval = -EPIPE;
		goto out;
		}

		avail = snd_compr_get_avail(stream);
		@@ -399,10 +417,16 @@ static unsigned int snd_compr_poll(struct file f, poll_table wait)
		stream = &data->stream;

		mutex_lock(&stream->device->lock);
		if (stream->runtime->state == SNDRV_PCM_STATE_OPEN) {

		switch (stream->runtime->state) {
		case SNDRV_PCM_STATE_OPEN:
		case SNDRV_PCM_STATE_XRUN:
		retval = snd_compr_get_poll(stream) \| POLLERR;
		goto out;
		default:
		break;
		}

		poll_wait(f, &stream->runtime->sleep, wait);

		avail = snd_compr_get_avail(stream);
		@@ -697,6 +721,45 @@ static int snd_compr_stop(struct snd_compr_stream *stream)
		return retval;
		}

		static void error_delayed_work(struct work_struct *work)
		{
		struct snd_compr_stream *stream;

		stream = container_of(work, struct snd_compr_stream, error_work.work);

		mutex_lock(&stream->device->lock);

		stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_STOP);
		wake_up(&stream->runtime->sleep);

		mutex_unlock(&stream->device->lock);
		}

		/*
		* snd_compr_stop_error: Report a fatal error on a stream
		* @stream: pointer to stream
		* @state: state to transition the stream to
		*
		* Stop the stream and set its state.
		*
		* Should be called with compressed device lock held.
		*/
		int snd_compr_stop_error(struct snd_compr_stream *stream,
		snd_pcm_state_t state)
		{
		if (stream->runtime->state == state)
		return 0;

		stream->runtime->state = state;

		pr_debug("Changing state to: %d\n", state);

		queue_delayed_work(system_power_efficient_wq, &stream->error_work, 0);

		return 0;
		}
		EXPORT_SYMBOL_GPL(snd_compr_stop_error);

		static int snd_compress_wait_for_drain(struct snd_compr_stream *stream)
		{
		int ret;