[linux-2.6-block.git] / sound / hda / ext / hdac_ext_stream.c

/*
 *  hdac-ext-stream.c - HD-audio extended stream operations.
 *
 *  Copyright (C) 2015 Intel Corp
 *  Author: Jeeja KP <jeeja.kp@intel.com>
 *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; version 2 of the License.
 *
 *  This program is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#include <linux/delay.h>
#include <linux/slab.h>
#include <sound/pcm.h>
#include <sound/hda_register.h>
#include <sound/hdaudio_ext.h>

/**
 * snd_hdac_ext_stream_init - initialize each stream (aka device)
 * @ebus: HD-audio ext core bus
 * @stream: HD-audio ext core stream object to initialize
 * @idx: stream index number
 * @direction: stream direction (SNDRV_PCM_STREAM_PLAYBACK or SNDRV_PCM_STREAM_CAPTURE)
 * @tag: the tag id to assign
 *
 * initialize the stream, if ppcap is enabled then init those and then
 * invoke hdac stream initialization routine
 */
void snd_hdac_ext_stream_init(struct hdac_ext_bus *ebus,
				struct hdac_ext_stream *stream,
				int idx, int direction, int tag)
{
	struct hdac_bus *bus = &ebus->bus;

	if (ebus->ppcap) {
		stream->pphc_addr = ebus->ppcap + AZX_PPHC_BASE +
				AZX_PPHC_INTERVAL * idx;

		stream->pplc_addr = ebus->ppcap + AZX_PPLC_BASE +
				AZX_PPLC_MULTI * ebus->num_streams +
				AZX_PPLC_INTERVAL * idx;
	}

	stream->decoupled = false;
	snd_hdac_stream_init(bus, &stream->hstream, idx, direction, tag);
}
EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_init);

/**
 * snd_hdac_ext_stream_init_all - create and initialize the stream objects
 *   for an extended hda bus
 * @ebus: HD-audio ext core bus
 * @start_idx: start index for streams
 * @num_stream: number of streams to initialize
 * @dir: direction of streams
 */
int snd_hdac_ext_stream_init_all(struct hdac_ext_bus *ebus, int start_idx,
		int num_stream, int dir)
{
	int stream_tag = 0;
	int i, tag, idx = start_idx;

	for (i = 0; i < num_stream; i++) {
		struct hdac_ext_stream *stream =
				kzalloc(sizeof(*stream), GFP_KERNEL);
		if (!stream)
			return -ENOMEM;
		tag = ++stream_tag;
		snd_hdac_ext_stream_init(ebus, stream, idx, dir, tag);
		idx++;
	}

	return 0;

}
EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_init_all);

/**
 * snd_hdac_stream_free_all - free hdac extended stream objects
 *
 * @ebus: HD-audio ext core bus
 */
void snd_hdac_stream_free_all(struct hdac_ext_bus *ebus)
{
	struct hdac_stream *s;
	struct hdac_ext_stream *stream;
	struct hdac_bus *bus = ebus_to_hbus(ebus);

	while (!list_empty(&bus->stream_list)) {
		s = list_first_entry(&bus->stream_list, struct hdac_stream, list);
		stream = stream_to_hdac_ext_stream(s);
		list_del(&s->list);
		kfree(stream);
	}
}
EXPORT_SYMBOL_GPL(snd_hdac_stream_free_all);

/**
 * snd_hdac_ext_stream_decouple - decouple the hdac stream
 * @ebus: HD-audio ext core bus
 * @stream: HD-audio ext core stream object to initialize
 * @decouple: flag to decouple
 */
void snd_hdac_ext_stream_decouple(struct hdac_ext_bus *ebus,
				struct hdac_ext_stream *stream, bool decouple)
{
	struct hdac_stream *hstream = &stream->hstream;
	struct hdac_bus *bus = &ebus->bus;

	spin_lock_irq(&bus->reg_lock);
	if (decouple)
		snd_hdac_updatel(ebus->ppcap, AZX_REG_PP_PPCTL, 0,
				AZX_PPCTL_PROCEN(hstream->index));
	else
		snd_hdac_updatel(ebus->ppcap, AZX_REG_PP_PPCTL,
					AZX_PPCTL_PROCEN(hstream->index), 0);
	stream->decoupled = decouple;
	spin_unlock_irq(&bus->reg_lock);
}
EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_decouple);

/**
 * snd_hdac_ext_linkstream_start - start a stream
 * @stream: HD-audio ext core stream to start
 */
void snd_hdac_ext_link_stream_start(struct hdac_ext_stream *stream)
{
	snd_hdac_updatel(stream->pplc_addr, AZX_REG_PPLCCTL, 0, AZX_PPLCCTL_RUN);
}
EXPORT_SYMBOL_GPL(snd_hdac_ext_link_stream_start);

/**
 * snd_hdac_ext_link_stream_clear - stop a stream DMA
 * @stream: HD-audio ext core stream to stop
 */
void snd_hdac_ext_link_stream_clear(struct hdac_ext_stream *stream)
{
	snd_hdac_updatel(stream->pplc_addr, AZX_REG_PPLCCTL, AZX_PPLCCTL_RUN, 0);
}
EXPORT_SYMBOL_GPL(snd_hdac_ext_link_stream_clear);

/**
 * snd_hdac_ext_link_stream_reset - reset a stream
 * @stream: HD-audio ext core stream to reset
 */
void snd_hdac_ext_link_stream_reset(struct hdac_ext_stream *stream)
{
	unsigned char val;
	int timeout;

	snd_hdac_ext_link_stream_clear(stream);

	snd_hdac_updatel(stream->pplc_addr, AZX_REG_PPLCCTL, 0, AZX_PPLCCTL_STRST);
	udelay(3);
	timeout = 50;
	do {
		val = readl(stream->pplc_addr + AZX_REG_PPLCCTL) &
				AZX_PPLCCTL_STRST;
		if (val)
			break;
		udelay(3);
	} while (--timeout);
	val &= ~AZX_PPLCCTL_STRST;
	writel(val, stream->pplc_addr + AZX_REG_PPLCCTL);
	udelay(3);

	timeout = 50;
	/* waiting for hardware to report that the stream is out of reset */
	do {
		val = readl(stream->pplc_addr + AZX_REG_PPLCCTL) & AZX_PPLCCTL_STRST;
		if (!val)
			break;
		udelay(3);
	} while (--timeout);

}
EXPORT_SYMBOL_GPL(snd_hdac_ext_link_stream_reset);

/**
 * snd_hdac_ext_link_stream_setup -  set up the SD for streaming
 * @stream: HD-audio ext core stream to set up
 * @fmt: stream format
 */
int snd_hdac_ext_link_stream_setup(struct hdac_ext_stream *stream, int fmt)
{
	struct hdac_stream *hstream = &stream->hstream;
	unsigned int val;

	/* make sure the run bit is zero for SD */
	snd_hdac_ext_link_stream_clear(stream);
	/* program the stream_tag */
	val = readl(stream->pplc_addr + AZX_REG_PPLCCTL);
	val = (val & ~AZX_PPLCCTL_STRM_MASK) |
		(hstream->stream_tag << AZX_PPLCCTL_STRM_SHIFT);
	writel(val, stream->pplc_addr + AZX_REG_PPLCCTL);

	/* program the stream format */
	writew(fmt, stream->pplc_addr + AZX_REG_PPLCFMT);

	return 0;
}
EXPORT_SYMBOL_GPL(snd_hdac_ext_link_stream_setup);

/**
 * snd_hdac_ext_link_set_stream_id - maps stream id to link output
 * @link: HD-audio ext link to set up
 * @stream: stream id
 */
void snd_hdac_ext_link_set_stream_id(struct hdac_ext_link *link,
				 int stream)
{
	snd_hdac_updatew(link->ml_addr, AZX_REG_ML_LOSIDV, (1 << stream), 0);
}
EXPORT_SYMBOL_GPL(snd_hdac_ext_link_set_stream_id);

/**
 * snd_hdac_ext_link_clear_stream_id - maps stream id to link output
 * @link: HD-audio ext link to set up
 * @stream: stream id
 */
void snd_hdac_ext_link_clear_stream_id(struct hdac_ext_link *link,
				 int stream)
{
	snd_hdac_updatew(link->ml_addr, AZX_REG_ML_LOSIDV, 0, (1 << stream));
}
EXPORT_SYMBOL_GPL(snd_hdac_ext_link_clear_stream_id);

static struct hdac_ext_stream *
hdac_ext_link_stream_assign(struct hdac_ext_bus *ebus,
				struct snd_pcm_substream *substream)
{
	struct hdac_ext_stream *res = NULL;
	struct hdac_stream *stream = NULL;
	struct hdac_bus *hbus = &ebus->bus;

	if (!ebus->ppcap) {
		dev_err(hbus->dev, "stream type not supported\n");
		return NULL;
	}

	list_for_each_entry(stream, &hbus->stream_list, list) {
		struct hdac_ext_stream *hstream = container_of(stream,
						struct hdac_ext_stream,
						hstream);
		if (stream->direction != substream->stream)
			continue;

		/* check if decoupled stream and not in use is available */
		if (hstream->decoupled && !hstream->link_locked) {
			res = hstream;
			break;
		}

		if (!hstream->link_locked) {
			snd_hdac_ext_stream_decouple(ebus, hstream, true);
			res = hstream;
			break;
		}
	}
	if (res) {
		spin_lock_irq(&hbus->reg_lock);
		res->link_locked = 1;
		res->link_substream = substream;
		spin_unlock_irq(&hbus->reg_lock);
	}
	return res;
}

static struct hdac_ext_stream *
hdac_ext_host_stream_assign(struct hdac_ext_bus *ebus,
				struct snd_pcm_substream *substream)
{
	struct hdac_ext_stream *res = NULL;
	struct hdac_stream *stream = NULL;
	struct hdac_bus *hbus = &ebus->bus;
	int key;

	if (!ebus->ppcap) {
		dev_err(hbus->dev, "stream type not supported\n");
		return NULL;
	}

	/* make a non-zero unique key for the substream */
	key = (substream->pcm->device << 16) | (substream->number << 2) |
			(substream->stream + 1);

	list_for_each_entry(stream, &hbus->stream_list, list) {
		struct hdac_ext_stream *hstream = container_of(stream,
						struct hdac_ext_stream,
						hstream);
		if (stream->direction != substream->stream)
			continue;

		if (!stream->opened) {
			if (!hstream->decoupled)
				snd_hdac_ext_stream_decouple(ebus, hstream, true);
			res = hstream;
			break;
		}
	}
	if (res) {
		spin_lock_irq(&hbus->reg_lock);
		res->hstream.opened = 1;
		res->hstream.running = 0;
		res->hstream.assigned_key = key;
		res->hstream.substream = substream;
		spin_unlock_irq(&hbus->reg_lock);
	}

	return res;
}

/**
 * snd_hdac_ext_stream_assign - assign a stream for the PCM
 * @ebus: HD-audio ext core bus
 * @substream: PCM substream to assign
 * @type: type of stream (coupled, host or link stream)
 *
 * This assigns the stream based on the type (coupled/host/link), for the
 * given PCM substream, assigns it and returns the stream object
 *
 * coupled: Looks for an unused stream
 * host: Looks for an unused decoupled host stream
 * link: Looks for an unused decoupled link stream
 *
 * If no stream is free, returns NULL. The function tries to keep using
 * the same stream object when it's used beforehand.  when a stream is
 * decoupled, it becomes a host stream and link stream.
 */
struct hdac_ext_stream *snd_hdac_ext_stream_assign(struct hdac_ext_bus *ebus,
					   struct snd_pcm_substream *substream,
					   int type)
{
	struct hdac_ext_stream *hstream = NULL;
	struct hdac_stream *stream = NULL;
	struct hdac_bus *hbus = &ebus->bus;

	switch (type) {
	case HDAC_EXT_STREAM_TYPE_COUPLED:
		stream = snd_hdac_stream_assign(hbus, substream);
		if (stream)
			hstream = container_of(stream,
					struct hdac_ext_stream, hstream);
		return hstream;

	case HDAC_EXT_STREAM_TYPE_HOST:
		return hdac_ext_host_stream_assign(ebus, substream);

	case HDAC_EXT_STREAM_TYPE_LINK:
		return hdac_ext_link_stream_assign(ebus, substream);

	default:
		return NULL;
	}
}
EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_assign);

/**
 * snd_hdac_ext_stream_release - release the assigned stream
 * @stream: HD-audio ext core stream to release
 * @type: type of stream (coupled, host or link stream)
 *
 * Release the stream that has been assigned by snd_hdac_ext_stream_assign().
 */
void snd_hdac_ext_stream_release(struct hdac_ext_stream *stream, int type)
{
	struct hdac_bus *bus = stream->hstream.bus;
	struct hdac_ext_bus *ebus = hbus_to_ebus(bus);

	switch (type) {
	case HDAC_EXT_STREAM_TYPE_COUPLED:
		snd_hdac_stream_release(&stream->hstream);
		break;

	case HDAC_EXT_STREAM_TYPE_HOST:
		if (stream->decoupled) {
			snd_hdac_ext_stream_decouple(ebus, stream, false);
			snd_hdac_stream_release(&stream->hstream);
		}
		break;

	case HDAC_EXT_STREAM_TYPE_LINK:
		if (stream->decoupled)
			snd_hdac_ext_stream_decouple(ebus, stream, false);
		spin_lock_irq(&bus->reg_lock);
		stream->link_locked = 0;
		stream->link_substream = NULL;
		spin_unlock_irq(&bus->reg_lock);
		break;

	default:
		dev_dbg(bus->dev, "Invalid type %d\n", type);
	}

}
EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_release);

/**
 * snd_hdac_ext_stream_spbcap_enable - enable SPIB for a stream
 * @ebus: HD-audio ext core bus
 * @enable: flag to enable/disable SPIB
 * @index: stream index for which SPIB need to be enabled
 */
void snd_hdac_ext_stream_spbcap_enable(struct hdac_ext_bus *ebus,
				 bool enable, int index)
{
	u32 mask = 0;
	u32 register_mask = 0;
	struct hdac_bus *bus = &ebus->bus;

	if (!ebus->spbcap) {
		dev_err(bus->dev, "Address of SPB capability is NULL");
		return;
	}

	mask |= (1 << index);

	register_mask = snd_hdac_chip_readl(bus, SPB_SPBFCCTL);

	mask |= register_mask;

	if (enable)
		snd_hdac_updatel(ebus->spbcap, AZX_REG_SPB_SPBFCCTL, 0, mask);
	else
		snd_hdac_updatel(ebus->spbcap, AZX_REG_SPB_SPBFCCTL, mask, 0);
}
EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_spbcap_enable);

/**
 * snd_hdac_ext_stop_streams - stop all stream if running
 * @ebus: HD-audio ext core bus
 */
void snd_hdac_ext_stop_streams(struct hdac_ext_bus *ebus)
{
	struct hdac_bus *bus = ebus_to_hbus(ebus);
	struct hdac_stream *stream;

	if (bus->chip_init) {
		list_for_each_entry(stream, &bus->stream_list, list)
			snd_hdac_stream_stop(stream);
		snd_hdac_bus_stop_chip(bus);
	}
}
EXPORT_SYMBOL_GPL(snd_hdac_ext_stop_streams);
Commit	Line	Data
df203a4e JK	1	/*
	2	* hdac-ext-stream.c - HD-audio extended stream operations.
	3	*
	4	* Copyright (C) 2015 Intel Corp
	5	* Author: Jeeja KP <jeeja.kp@intel.com>
	6	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; version 2 of the License.
	11	*
	12	* This program is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* General Public License for more details.
	16	*
	17	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	18	*/
	19
	20	#include <linux/delay.h>
e7a3484d	21	#include <linux/slab.h>
df203a4e JK	22	#include <sound/pcm.h>
	23	#include <sound/hda_register.h>
	24	#include <sound/hdaudio_ext.h>
	25
	26	/**
	27	* snd_hdac_ext_stream_init - initialize each stream (aka device)
	28	* @ebus: HD-audio ext core bus
	29	* @stream: HD-audio ext core stream object to initialize
	30	* @idx: stream index number
	31	* @direction: stream direction (SNDRV_PCM_STREAM_PLAYBACK or SNDRV_PCM_STREAM_CAPTURE)
	32	* @tag: the tag id to assign
	33	*
	34	* initialize the stream, if ppcap is enabled then init those and then
	35	* invoke hdac stream initialization routine
	36	*/
	37	void snd_hdac_ext_stream_init(struct hdac_ext_bus *ebus,
	38	struct hdac_ext_stream *stream,
	39	int idx, int direction, int tag)
	40	{
	41	struct hdac_bus *bus = &ebus->bus;
	42
	43	if (ebus->ppcap) {
	44	stream->pphc_addr = ebus->ppcap + AZX_PPHC_BASE +
	45	AZX_PPHC_INTERVAL * idx;
	46
	47	stream->pplc_addr = ebus->ppcap + AZX_PPLC_BASE +
	48	AZX_PPLC_MULTI * ebus->num_streams +
	49	AZX_PPLC_INTERVAL * idx;
	50	}
	51
	52	stream->decoupled = false;
	53	snd_hdac_stream_init(bus, &stream->hstream, idx, direction, tag);
	54	}
	55	EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_init);
	56
e7a3484d VK	57	/**
	58	* snd_hdac_ext_stream_init_all - create and initialize the stream objects
	59	* for an extended hda bus
	60	* @ebus: HD-audio ext core bus
	61	* @start_idx: start index for streams
	62	* @num_stream: number of streams to initialize
	63	* @dir: direction of streams
	64	*/
	65	int snd_hdac_ext_stream_init_all(struct hdac_ext_bus *ebus, int start_idx,
	66	int num_stream, int dir)
	67	{
	68	int stream_tag = 0;
	69	int i, tag, idx = start_idx;
	70
	71	for (i = 0; i < num_stream; i++) {
	72	struct hdac_ext_stream *stream =
	73	kzalloc(sizeof(*stream), GFP_KERNEL);
	74	if (!stream)
	75	return -ENOMEM;
	76	tag = ++stream_tag;
	77	snd_hdac_ext_stream_init(ebus, stream, idx, dir, tag);
	78	idx++;
	79	}
	80
	81	return 0;
	82
	83	}
	84	EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_init_all);
	85
	86	/**
	87	* snd_hdac_stream_free_all - free hdac extended stream objects
	88	*
	89	* @ebus: HD-audio ext core bus
	90	*/
	91	void snd_hdac_stream_free_all(struct hdac_ext_bus *ebus)
	92	{
	93	struct hdac_stream *s;
	94	struct hdac_ext_stream *stream;
	95	struct hdac_bus *bus = ebus_to_hbus(ebus);
	96
	97	while (!list_empty(&bus->stream_list)) {
	98	s = list_first_entry(&bus->stream_list, struct hdac_stream, list);
	99	stream = stream_to_hdac_ext_stream(s);
	100	list_del(&s->list);
	101	kfree(stream);
	102	}
	103	}
	104	EXPORT_SYMBOL_GPL(snd_hdac_stream_free_all);
	105
df203a4e JK	106	/**
	107	* snd_hdac_ext_stream_decouple - decouple the hdac stream
	108	* @ebus: HD-audio ext core bus
	109	* @stream: HD-audio ext core stream object to initialize
	110	* @decouple: flag to decouple
	111	*/
	112	void snd_hdac_ext_stream_decouple(struct hdac_ext_bus *ebus,
	113	struct hdac_ext_stream *stream, bool decouple)
	114	{
	115	struct hdac_stream *hstream = &stream->hstream;
	116	struct hdac_bus *bus = &ebus->bus;
	117
	118	spin_lock_irq(&bus->reg_lock);
	119	if (decouple)
	120	snd_hdac_updatel(ebus->ppcap, AZX_REG_PP_PPCTL, 0,
	121	AZX_PPCTL_PROCEN(hstream->index));
	122	else
	123	snd_hdac_updatel(ebus->ppcap, AZX_REG_PP_PPCTL,
	124	AZX_PPCTL_PROCEN(hstream->index), 0);
	125	stream->decoupled = decouple;
	126	spin_unlock_irq(&bus->reg_lock);
	127	}
	128	EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_decouple);
	129
	130	/**
	131	* snd_hdac_ext_linkstream_start - start a stream
	132	* @stream: HD-audio ext core stream to start
	133	*/
	134	void snd_hdac_ext_link_stream_start(struct hdac_ext_stream *stream)
	135	{
	136	snd_hdac_updatel(stream->pplc_addr, AZX_REG_PPLCCTL, 0, AZX_PPLCCTL_RUN);
	137	}
	138	EXPORT_SYMBOL_GPL(snd_hdac_ext_link_stream_start);
	139
	140	/**
	141	* snd_hdac_ext_link_stream_clear - stop a stream DMA
	142	* @stream: HD-audio ext core stream to stop
	143	*/
	144	void snd_hdac_ext_link_stream_clear(struct hdac_ext_stream *stream)
	145	{
	146	snd_hdac_updatel(stream->pplc_addr, AZX_REG_PPLCCTL, AZX_PPLCCTL_RUN, 0);
	147	}
	148	EXPORT_SYMBOL_GPL(snd_hdac_ext_link_stream_clear);
	149
	150	/**
	151	* snd_hdac_ext_link_stream_reset - reset a stream
	152	* @stream: HD-audio ext core stream to reset
	153	*/
	154	void snd_hdac_ext_link_stream_reset(struct hdac_ext_stream *stream)
	155	{
	156	unsigned char val;
	157	int timeout;
	158
	159	snd_hdac_ext_link_stream_clear(stream);
	160
	161	snd_hdac_updatel(stream->pplc_addr, AZX_REG_PPLCCTL, 0, AZX_PPLCCTL_STRST);
	162	udelay(3);
	163	timeout = 50;
	164	do {
	165	val = readl(stream->pplc_addr + AZX_REG_PPLCCTL) &
	166	AZX_PPLCCTL_STRST;
	167	if (val)
	168	break;
	169	udelay(3);
170	} while (--timeout);
171	val &= ~AZX_PPLCCTL_STRST;
172	writel(val, stream->pplc_addr + AZX_REG_PPLCCTL);
173	udelay(3);
174
175	timeout = 50;
176	/* waiting for hardware to report that the stream is out of reset */
177	do {
178	val = readl(stream->pplc_addr + AZX_REG_PPLCCTL) & AZX_PPLCCTL_STRST;
179	if (!val)
180	break;
181	udelay(3);
182	} while (--timeout);
183
184	}
185	EXPORT_SYMBOL_GPL(snd_hdac_ext_link_stream_reset);
186
187	/**
188	* snd_hdac_ext_link_stream_setup - set up the SD for streaming
189	* @stream: HD-audio ext core stream to set up
190	* @fmt: stream format
191	*/
192	int snd_hdac_ext_link_stream_setup(struct hdac_ext_stream *stream, int fmt)
193	{
194	struct hdac_stream *hstream = &stream->hstream;
195	unsigned int val;
196
197	/* make sure the run bit is zero for SD */
198	snd_hdac_ext_link_stream_clear(stream);
199	/* program the stream_tag */
200	val = readl(stream->pplc_addr + AZX_REG_PPLCCTL);
201	val = (val & ~AZX_PPLCCTL_STRM_MASK) \|
202	(hstream->stream_tag << AZX_PPLCCTL_STRM_SHIFT);
203	writel(val, stream->pplc_addr + AZX_REG_PPLCCTL);
204
205	/* program the stream format */
206	writew(fmt, stream->pplc_addr + AZX_REG_PPLCFMT);
207
208	return 0;
209	}
210	EXPORT_SYMBOL_GPL(snd_hdac_ext_link_stream_setup);
211
212	/**
213	* snd_hdac_ext_link_set_stream_id - maps stream id to link output
214	* @link: HD-audio ext link to set up
215	* @stream: stream id
216	*/
217	void snd_hdac_ext_link_set_stream_id(struct hdac_ext_link *link,
218	int stream)
219	{
220	snd_hdac_updatew(link->ml_addr, AZX_REG_ML_LOSIDV, (1 << stream), 0);
221	}
222	EXPORT_SYMBOL_GPL(snd_hdac_ext_link_set_stream_id);
223
224	/**
225	* snd_hdac_ext_link_clear_stream_id - maps stream id to link output
226	* @link: HD-audio ext link to set up
227	* @stream: stream id
228	*/
229	void snd_hdac_ext_link_clear_stream_id(struct hdac_ext_link *link,
230	int stream)
231	{
232	snd_hdac_updatew(link->ml_addr, AZX_REG_ML_LOSIDV, 0, (1 << stream));
233	}
234	EXPORT_SYMBOL_GPL(snd_hdac_ext_link_clear_stream_id);
235
236	static struct hdac_ext_stream *
237	hdac_ext_link_stream_assign(struct hdac_ext_bus *ebus,
238	struct snd_pcm_substream *substream)
239	{
240	struct hdac_ext_stream *res = NULL;
241	struct hdac_stream *stream = NULL;
242	struct hdac_bus *hbus = &ebus->bus;
243
244	if (!ebus->ppcap) {
245	dev_err(hbus->dev, "stream type not supported\n");
246	return NULL;
247	}
248
249	list_for_each_entry(stream, &hbus->stream_list, list) {
250	struct hdac_ext_stream *hstream = container_of(stream,
251	struct hdac_ext_stream,
252	hstream);
253	if (stream->direction != substream->stream)
254	continue;
255
256	/* check if decoupled stream and not in use is available */
257	if (hstream->decoupled && !hstream->link_locked) {
258	res = hstream;
259	break;
260	}
261
262	if (!hstream->link_locked) {
263	snd_hdac_ext_stream_decouple(ebus, hstream, true);
264	res = hstream;
265	break;
266	}
267	}
268	if (res) {
269	spin_lock_irq(&hbus->reg_lock);
270	res->link_locked = 1;
271	res->link_substream = substream;
272	spin_unlock_irq(&hbus->reg_lock);
273	}
274	return res;
275	}
276
277	static struct hdac_ext_stream *
278	hdac_ext_host_stream_assign(struct hdac_ext_bus *ebus,
279	struct snd_pcm_substream *substream)
280	{
281	struct hdac_ext_stream *res = NULL;
282	struct hdac_stream *stream = NULL;
283	struct hdac_bus *hbus = &ebus->bus;
284	int key;
285
286	if (!ebus->ppcap) {
287	dev_err(hbus->dev, "stream type not supported\n");
288	return NULL;
289	}
290
291	/* make a non-zero unique key for the substream */
292	key = (substream->pcm->device << 16) \| (substream->number << 2) \|
293	(substream->stream + 1);
294
295	list_for_each_entry(stream, &hbus->stream_list, list) {
296	struct hdac_ext_stream *hstream = container_of(stream,
297	struct hdac_ext_stream,
298	hstream);
299	if (stream->direction != substream->stream)
300	continue;
301
9b06dc93	302	if (!stream->opened) {
df203a4e JK	303	if (!hstream->decoupled)
	304	snd_hdac_ext_stream_decouple(ebus, hstream, true);
	305	res = hstream;
	306	break;
	307	}
	308	}
	309	if (res) {
	310	spin_lock_irq(&hbus->reg_lock);
	311	res->hstream.opened = 1;
	312	res->hstream.running = 0;
	313	res->hstream.assigned_key = key;
	314	res->hstream.substream = substream;
	315	spin_unlock_irq(&hbus->reg_lock);
	316	}
	317
	318	return res;
	319	}
	320
	321	/**
	322	* snd_hdac_ext_stream_assign - assign a stream for the PCM
	323	* @ebus: HD-audio ext core bus
	324	* @substream: PCM substream to assign
	325	* @type: type of stream (coupled, host or link stream)
	326	*
	327	* This assigns the stream based on the type (coupled/host/link), for the
	328	* given PCM substream, assigns it and returns the stream object
	329	*
	330	* coupled: Looks for an unused stream
	331	* host: Looks for an unused decoupled host stream
	332	* link: Looks for an unused decoupled link stream
	333	*
	334	* If no stream is free, returns NULL. The function tries to keep using
	335	* the same stream object when it's used beforehand. when a stream is
	336	* decoupled, it becomes a host stream and link stream.
	337	*/
	338	struct hdac_ext_stream snd_hdac_ext_stream_assign(struct hdac_ext_bus ebus,
	339	struct snd_pcm_substream *substream,
	340	int type)
	341	{
	342	struct hdac_ext_stream *hstream = NULL;
	343	struct hdac_stream *stream = NULL;
	344	struct hdac_bus *hbus = &ebus->bus;
	345
	346	switch (type) {
	347	case HDAC_EXT_STREAM_TYPE_COUPLED:
	348	stream = snd_hdac_stream_assign(hbus, substream);
	349	if (stream)
	350	hstream = container_of(stream,
	351	struct hdac_ext_stream, hstream);
	352	return hstream;
	353
	354	case HDAC_EXT_STREAM_TYPE_HOST:
	355	return hdac_ext_host_stream_assign(ebus, substream);
	356
	357	case HDAC_EXT_STREAM_TYPE_LINK:
	358	return hdac_ext_link_stream_assign(ebus, substream);
	359
	360	default:
	361	return NULL;
	362	}
	363	}
	364	EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_assign);
	365
	366	/**
367	* snd_hdac_ext_stream_release - release the assigned stream
368	* @stream: HD-audio ext core stream to release
369	* @type: type of stream (coupled, host or link stream)
370	*
371	* Release the stream that has been assigned by snd_hdac_ext_stream_assign().
372	*/
373	void snd_hdac_ext_stream_release(struct hdac_ext_stream *stream, int type)
374	{
375	struct hdac_bus *bus = stream->hstream.bus;
376	struct hdac_ext_bus *ebus = hbus_to_ebus(bus);
377
378	switch (type) {
379	case HDAC_EXT_STREAM_TYPE_COUPLED:
380	snd_hdac_stream_release(&stream->hstream);
381	break;
382
383	case HDAC_EXT_STREAM_TYPE_HOST:
384	if (stream->decoupled) {
385	snd_hdac_ext_stream_decouple(ebus, stream, false);
386	snd_hdac_stream_release(&stream->hstream);
387	}
388	break;
389
390	case HDAC_EXT_STREAM_TYPE_LINK:
391	if (stream->decoupled)
392	snd_hdac_ext_stream_decouple(ebus, stream, false);
393	spin_lock_irq(&bus->reg_lock);
394	stream->link_locked = 0;
395	stream->link_substream = NULL;
396	spin_unlock_irq(&bus->reg_lock);
397	break;
398
399	default:
400	dev_dbg(bus->dev, "Invalid type %d\n", type);
401	}
402
403	}
404	EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_release);
405
406	/**
407	* snd_hdac_ext_stream_spbcap_enable - enable SPIB for a stream
408	* @ebus: HD-audio ext core bus
409	* @enable: flag to enable/disable SPIB
410	* @index: stream index for which SPIB need to be enabled
411	*/
412	void snd_hdac_ext_stream_spbcap_enable(struct hdac_ext_bus *ebus,
413	bool enable, int index)
414	{
415	u32 mask = 0;
416	u32 register_mask = 0;
417	struct hdac_bus *bus = &ebus->bus;
418
419	if (!ebus->spbcap) {
420	dev_err(bus->dev, "Address of SPB capability is NULL");
421	return;
422	}
423
424	mask \|= (1 << index);
425
426	register_mask = snd_hdac_chip_readl(bus, SPB_SPBFCCTL);
427
428	mask \|= register_mask;
429
430	if (enable)
431	snd_hdac_updatel(ebus->spbcap, AZX_REG_SPB_SPBFCCTL, 0, mask);
432	else
433	snd_hdac_updatel(ebus->spbcap, AZX_REG_SPB_SPBFCCTL, mask, 0);
434	}
435	EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_spbcap_enable);
436
437	/**
438	* snd_hdac_ext_stop_streams - stop all stream if running
439	* @ebus: HD-audio ext core bus
440	*/
441	void snd_hdac_ext_stop_streams(struct hdac_ext_bus *ebus)
442	{
443	struct hdac_bus *bus = ebus_to_hbus(ebus);
444	struct hdac_stream *stream;
445
446	if (bus->chip_init) {
447	list_for_each_entry(stream, &bus->stream_list, list)
448	snd_hdac_stream_stop(stream);
449	snd_hdac_bus_stop_chip(bus);
450	}
451	}
452	EXPORT_SYMBOL_GPL(snd_hdac_ext_stop_streams);