[mirror_ubuntu-focal-kernel.git] / drivers / slimbus / stream.c

// SPDX-License-Identifier: GPL-2.0
// Copyright (c) 2018, Linaro Limited

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/slimbus.h>
#include <uapi/sound/asound.h>
#include "slimbus.h"

/**
 * struct segdist_code - Segment Distributions code from
 *	Table 20 of SLIMbus Specs Version 2.0
 *
 * @ratem: Channel Rate Multipler(Segments per Superframe)
 * @seg_interval: Number of slots between the first Slot of Segment
 *		and the first slot of the next  consecutive Segment.
 * @segdist_code: Segment Distribution Code SD[11:0]
 * @seg_offset_mask: Segment offset mask in SD[11:0]
 * @segdist_codes: List of all possible Segmet Distribution codes.
 */
static const struct segdist_code {
	int ratem;
	int seg_interval;
	int segdist_code;
	u32 seg_offset_mask;

} segdist_codes[] = {
	{1,	1536,	0x200,	 0xdff},
	{2,	768,	0x100,	 0xcff},
	{4,	384,	0x080,	 0xc7f},
	{8,	192,	0x040,	 0xc3f},
	{16,	96,	0x020,	 0xc1f},
	{32,	48,	0x010,	 0xc0f},
	{64,	24,	0x008,	 0xc07},
	{128,	12,	0x004,	 0xc03},
	{256,	6,	0x002,	 0xc01},
	{512,	3,	0x001,	 0xc00},
	{3,	512,	0xe00,	 0x1ff},
	{6,	256,	0xd00,	 0x0ff},
	{12,	128,	0xc80,	 0x07f},
	{24,	64,	0xc40,	 0x03f},
	{48,	32,	0xc20,	 0x01f},
	{96,	16,	0xc10,	 0x00f},
	{192,	8,	0xc08,	 0x007},
	{364,	4,	0xc04,	 0x003},
	{768,	2,	0xc02,	 0x001},
};

/*
 * Presence Rate table for all Natural Frequencies
 * The Presence rate of a constant bitrate stream is mean flow rate of the
 * stream expressed in occupied Segments of that Data Channel per second.
 * Table 66 from SLIMbus 2.0 Specs
 *
 * Index of the table corresponds to Presence rate code for the respective rate
 * in the table.
 */
static const int slim_presence_rate_table[] = {
	0, /* Not Indicated */
	12000,
	24000,
	48000,
	96000,
	192000,
	384000,
	768000,
	0, /* Reserved */
	110250,
	220500,
	441000,
	882000,
	176400,
	352800,
	705600,
	4000,
	8000,
	16000,
	32000,
	64000,
	128000,
	256000,
	512000,
};

/*
 * slim_stream_allocate() - Allocate a new SLIMbus Stream
 * @dev:Slim device to be associated with
 * @name: name of the stream
 *
 * This is very first call for SLIMbus streaming, this API will allocate
 * a new SLIMbus stream and return a valid stream runtime pointer for client
 * to use it in subsequent stream apis. state of stream is set to ALLOCATED
 *
 * Return: valid pointer on success and error code on failure.
 * From ASoC DPCM framework, this state is linked to startup() operation.
 */
struct slim_stream_runtime *slim_stream_allocate(struct slim_device *dev,
						 const char *name)
{
	struct slim_stream_runtime *rt;

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

	rt->name = kasprintf(GFP_KERNEL, "slim-%s", name);
	if (!rt->name) {
		kfree(rt);
		return ERR_PTR(-ENOMEM);
	}

	rt->dev = dev;
	spin_lock(&dev->stream_list_lock);
	list_add_tail(&rt->node, &dev->stream_list);
	spin_unlock(&dev->stream_list_lock);

	return rt;
}
EXPORT_SYMBOL_GPL(slim_stream_allocate);

static int slim_connect_port_channel(struct slim_stream_runtime *stream,
				     struct slim_port *port)
{
	struct slim_device *sdev = stream->dev;
	u8 wbuf[2];
	struct slim_val_inf msg = {0, 2, NULL, wbuf, NULL};
	u8 mc = SLIM_MSG_MC_CONNECT_SOURCE;
	DEFINE_SLIM_LDEST_TXN(txn, mc, 6, stream->dev->laddr, &msg);

	if (port->direction == SLIM_PORT_SINK)
		txn.mc = SLIM_MSG_MC_CONNECT_SINK;

	wbuf[0] = port->id;
	wbuf[1] = port->ch.id;
	port->ch.state = SLIM_CH_STATE_ASSOCIATED;
	port->state = SLIM_PORT_UNCONFIGURED;

	return slim_do_transfer(sdev->ctrl, &txn);
}

static int slim_disconnect_port(struct slim_stream_runtime *stream,
				struct slim_port *port)
{
	struct slim_device *sdev = stream->dev;
	u8 wbuf[1];
	struct slim_val_inf msg = {0, 1, NULL, wbuf, NULL};
	u8 mc = SLIM_MSG_MC_DISCONNECT_PORT;
	DEFINE_SLIM_LDEST_TXN(txn, mc, 5, stream->dev->laddr, &msg);

	wbuf[0] = port->id;
	port->ch.state = SLIM_CH_STATE_DISCONNECTED;
	port->state = SLIM_PORT_DISCONNECTED;

	return slim_do_transfer(sdev->ctrl, &txn);
}

static int slim_deactivate_remove_channel(struct slim_stream_runtime *stream,
					  struct slim_port *port)
{
	struct slim_device *sdev = stream->dev;
	u8 wbuf[1];
	struct slim_val_inf msg = {0, 1, NULL, wbuf, NULL};
	u8 mc = SLIM_MSG_MC_NEXT_DEACTIVATE_CHANNEL;
	DEFINE_SLIM_LDEST_TXN(txn, mc, 5, stream->dev->laddr, &msg);
	int ret;

	wbuf[0] = port->ch.id;
	ret = slim_do_transfer(sdev->ctrl, &txn);
	if (ret)
		return ret;

	txn.mc = SLIM_MSG_MC_NEXT_REMOVE_CHANNEL;
	port->ch.state = SLIM_CH_STATE_REMOVED;

	return slim_do_transfer(sdev->ctrl, &txn);
}

static int slim_get_prate_code(int rate)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(slim_presence_rate_table); i++) {
		if (rate == slim_presence_rate_table[i])
			return i;
	}

	return -EINVAL;
}

/*
 * slim_stream_prepare() - Prepare a SLIMbus Stream
 *
 * @rt: instance of slim stream runtime to configure
 * @cfg: new configuration for the stream
 *
 * This API will configure SLIMbus stream with config parameters from cfg.
 * return zero on success and error code on failure. From ASoC DPCM framework,
 * this state is linked to hw_params() operation.
 */
int slim_stream_prepare(struct slim_stream_runtime *rt,
			struct slim_stream_config *cfg)
{
	struct slim_controller *ctrl = rt->dev->ctrl;
	struct slim_port *port;
	int num_ports, i, port_id;

	if (rt->ports) {
		dev_err(&rt->dev->dev, "Stream already Prepared\n");
		return -EINVAL;
	}

	num_ports = hweight32(cfg->port_mask);
	rt->ports = kcalloc(num_ports, sizeof(*port), GFP_KERNEL);
	if (!rt->ports)
		return -ENOMEM;

	rt->num_ports = num_ports;
	rt->rate = cfg->rate;
	rt->bps = cfg->bps;
	rt->direction = cfg->direction;

	if (cfg->rate % ctrl->a_framer->superfreq) {
		/*
		 * data rate not exactly multiple of super frame,
		 * use PUSH/PULL protocol
		 */
		if (cfg->direction == SNDRV_PCM_STREAM_PLAYBACK)
			rt->prot = SLIM_PROTO_PUSH;
		else
			rt->prot = SLIM_PROTO_PULL;
	} else {
		rt->prot = SLIM_PROTO_ISO;
	}

	rt->ratem = cfg->rate/ctrl->a_framer->superfreq;

	i = 0;
	for_each_set_bit(port_id, &cfg->port_mask, SLIM_DEVICE_MAX_PORTS) {
		port = &rt->ports[i];
		port->state = SLIM_PORT_DISCONNECTED;
		port->id = port_id;
		port->ch.prrate = slim_get_prate_code(cfg->rate);
		port->ch.id = cfg->chs[i];
		port->ch.data_fmt = SLIM_CH_DATA_FMT_NOT_DEFINED;
		port->ch.aux_fmt = SLIM_CH_AUX_FMT_NOT_APPLICABLE;
		port->ch.state = SLIM_CH_STATE_ALLOCATED;

		if (cfg->direction == SNDRV_PCM_STREAM_PLAYBACK)
			port->direction = SLIM_PORT_SINK;
		else
			port->direction = SLIM_PORT_SOURCE;

		slim_connect_port_channel(rt, port);
		i++;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(slim_stream_prepare);

static int slim_define_channel_content(struct slim_stream_runtime *stream,
				       struct slim_port *port)
{
	struct slim_device *sdev = stream->dev;
	u8 wbuf[4];
	struct slim_val_inf msg = {0, 4, NULL, wbuf, NULL};
	u8 mc = SLIM_MSG_MC_NEXT_DEFINE_CONTENT;
	DEFINE_SLIM_LDEST_TXN(txn, mc, 8, stream->dev->laddr, &msg);

	wbuf[0] = port->ch.id;
	wbuf[1] = port->ch.prrate;

	/* Frequency Locked for ISO Protocol */
	if (stream->prot != SLIM_PROTO_ISO)
		wbuf[1] |= SLIM_CHANNEL_CONTENT_FL;

	wbuf[2] = port->ch.data_fmt | (port->ch.aux_fmt << 4);
	wbuf[3] = stream->bps/SLIM_SLOT_LEN_BITS;
	port->ch.state = SLIM_CH_STATE_CONTENT_DEFINED;

	return slim_do_transfer(sdev->ctrl, &txn);
}

static int slim_get_segdist_code(int ratem)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(segdist_codes); i++) {
		if (segdist_codes[i].ratem == ratem)
			return segdist_codes[i].segdist_code;
	}

	return -EINVAL;
}

static int slim_define_channel(struct slim_stream_runtime *stream,
				       struct slim_port *port)
{
	struct slim_device *sdev = stream->dev;
	u8 wbuf[4];
	struct slim_val_inf msg = {0, 4, NULL, wbuf, NULL};
	u8 mc = SLIM_MSG_MC_NEXT_DEFINE_CHANNEL;
	DEFINE_SLIM_LDEST_TXN(txn, mc, 8, stream->dev->laddr, &msg);

	port->ch.seg_dist = slim_get_segdist_code(stream->ratem);

	wbuf[0] = port->ch.id;
	wbuf[1] = port->ch.seg_dist & 0xFF;
	wbuf[2] = (stream->prot << 4) | ((port->ch.seg_dist & 0xF00) >> 8);
	if (stream->prot == SLIM_PROTO_ISO)
		wbuf[3] = stream->bps/SLIM_SLOT_LEN_BITS;
	else
		wbuf[3] = stream->bps/SLIM_SLOT_LEN_BITS + 1;

	port->ch.state = SLIM_CH_STATE_DEFINED;

	return slim_do_transfer(sdev->ctrl, &txn);
}

static int slim_activate_channel(struct slim_stream_runtime *stream,
				 struct slim_port *port)
{
	struct slim_device *sdev = stream->dev;
	u8 wbuf[1];
	struct slim_val_inf msg = {0, 1, NULL, wbuf, NULL};
	u8 mc = SLIM_MSG_MC_NEXT_ACTIVATE_CHANNEL;
	DEFINE_SLIM_LDEST_TXN(txn, mc, 5, stream->dev->laddr, &msg);

	txn.msg->num_bytes = 1;
	txn.msg->wbuf = wbuf;
	wbuf[0] = port->ch.id;
	port->ch.state = SLIM_CH_STATE_ACTIVE;

	return slim_do_transfer(sdev->ctrl, &txn);
}

/*
 * slim_stream_enable() - Enable a prepared SLIMbus Stream
 *
 * @stream: instance of slim stream runtime to enable
 *
 * This API will enable all the ports and channels associated with
 * SLIMbus stream
 *
 * Return: zero on success and error code on failure. From ASoC DPCM framework,
 * this state is linked to trigger() start operation.
 */
int slim_stream_enable(struct slim_stream_runtime *stream)
{
	DEFINE_SLIM_BCAST_TXN(txn, SLIM_MSG_MC_BEGIN_RECONFIGURATION,
				3, SLIM_LA_MANAGER, NULL);
	struct slim_controller *ctrl = stream->dev->ctrl;
	int ret, i;

	if (ctrl->enable_stream) {
		ret = ctrl->enable_stream(stream);
		if (ret)
			return ret;

		for (i = 0; i < stream->num_ports; i++)
			stream->ports[i].ch.state = SLIM_CH_STATE_ACTIVE;

		return ret;
	}

	ret = slim_do_transfer(ctrl, &txn);
	if (ret)
		return ret;

	/* define channels first before activating them */
	for (i = 0; i < stream->num_ports; i++) {
		struct slim_port *port = &stream->ports[i];

		slim_define_channel(stream, port);
		slim_define_channel_content(stream, port);
	}

	for (i = 0; i < stream->num_ports; i++) {
		struct slim_port *port = &stream->ports[i];

		slim_activate_channel(stream, port);
		port->state = SLIM_PORT_CONFIGURED;
	}
	txn.mc = SLIM_MSG_MC_RECONFIGURE_NOW;

	return slim_do_transfer(ctrl, &txn);
}
EXPORT_SYMBOL_GPL(slim_stream_enable);

/*
 * slim_stream_disable() - Disable a SLIMbus Stream
 *
 * @stream: instance of slim stream runtime to disable
 *
 * This API will disable all the ports and channels associated with
 * SLIMbus stream
 *
 * Return: zero on success and error code on failure. From ASoC DPCM framework,
 * this state is linked to trigger() pause operation.
 */
int slim_stream_disable(struct slim_stream_runtime *stream)
{
	DEFINE_SLIM_BCAST_TXN(txn, SLIM_MSG_MC_BEGIN_RECONFIGURATION,
				3, SLIM_LA_MANAGER, NULL);
	struct slim_controller *ctrl = stream->dev->ctrl;
	int ret, i;

	if (ctrl->disable_stream)
		ctrl->disable_stream(stream);

	ret = slim_do_transfer(ctrl, &txn);
	if (ret)
		return ret;

	for (i = 0; i < stream->num_ports; i++)
		slim_deactivate_remove_channel(stream, &stream->ports[i]);

	txn.mc = SLIM_MSG_MC_RECONFIGURE_NOW;

	return slim_do_transfer(ctrl, &txn);
}
EXPORT_SYMBOL_GPL(slim_stream_disable);

/*
 * slim_stream_unprepare() - Un-prepare a SLIMbus Stream
 *
 * @stream: instance of slim stream runtime to unprepare
 *
 * This API will un allocate all the ports and channels associated with
 * SLIMbus stream
 *
 * Return: zero on success and error code on failure. From ASoC DPCM framework,
 * this state is linked to trigger() stop operation.
 */
int slim_stream_unprepare(struct slim_stream_runtime *stream)
{
	int i;

	for (i = 0; i < stream->num_ports; i++)
		slim_disconnect_port(stream, &stream->ports[i]);

	kfree(stream->ports);
	stream->ports = NULL;
	stream->num_ports = 0;

	return 0;
}
EXPORT_SYMBOL_GPL(slim_stream_unprepare);

/*
 * slim_stream_free() - Free a SLIMbus Stream
 *
 * @stream: instance of slim stream runtime to free
 *
 * This API will un allocate all the memory associated with
 * slim stream runtime, user is not allowed to make an dereference
 * to stream after this call.
 *
 * Return: zero on success and error code on failure. From ASoC DPCM framework,
 * this state is linked to shutdown() operation.
 */
int slim_stream_free(struct slim_stream_runtime *stream)
{
	struct slim_device *sdev = stream->dev;

	spin_lock(&sdev->stream_list_lock);
	list_del(&stream->node);
	spin_unlock(&sdev->stream_list_lock);

	kfree(stream->name);
	kfree(stream);

	return 0;
}
EXPORT_SYMBOL_GPL(slim_stream_free);
Commit	Line	Data
abb9c9b8 SK	1	// SPDX-License-Identifier: GPL-2.0
	2	// Copyright (c) 2018, Linaro Limited
	3
	4	#include <linux/kernel.h>
	5	#include <linux/errno.h>
	6	#include <linux/slab.h>
	7	#include <linux/list.h>
	8	#include <linux/slimbus.h>
	9	#include <uapi/sound/asound.h>
	10	#include "slimbus.h"
	11
	12	/**
	13	* struct segdist_code - Segment Distributions code from
	14	* Table 20 of SLIMbus Specs Version 2.0
	15	*
	16	* @ratem: Channel Rate Multipler(Segments per Superframe)
	17	* @seg_interval: Number of slots between the first Slot of Segment
	18	* and the first slot of the next consecutive Segment.
	19	* @segdist_code: Segment Distribution Code SD[11:0]
	20	* @seg_offset_mask: Segment offset mask in SD[11:0]
	21	* @segdist_codes: List of all possible Segmet Distribution codes.
	22	*/
	23	static const struct segdist_code {
	24	int ratem;
	25	int seg_interval;
	26	int segdist_code;
	27	u32 seg_offset_mask;
	28
	29	} segdist_codes[] = {
	30	{1, 1536, 0x200, 0xdff},
	31	{2, 768, 0x100, 0xcff},
	32	{4, 384, 0x080, 0xc7f},
	33	{8, 192, 0x040, 0xc3f},
	34	{16, 96, 0x020, 0xc1f},
	35	{32, 48, 0x010, 0xc0f},
	36	{64, 24, 0x008, 0xc07},
	37	{128, 12, 0x004, 0xc03},
	38	{256, 6, 0x002, 0xc01},
	39	{512, 3, 0x001, 0xc00},
	40	{3, 512, 0xe00, 0x1ff},
	41	{6, 256, 0xd00, 0x0ff},
	42	{12, 128, 0xc80, 0x07f},
	43	{24, 64, 0xc40, 0x03f},
	44	{48, 32, 0xc20, 0x01f},
	45	{96, 16, 0xc10, 0x00f},
	46	{192, 8, 0xc08, 0x007},
	47	{364, 4, 0xc04, 0x003},
	48	{768, 2, 0xc02, 0x001},
	49	};
	50
	51	/*
	52	* Presence Rate table for all Natural Frequencies
	53	* The Presence rate of a constant bitrate stream is mean flow rate of the
	54	* stream expressed in occupied Segments of that Data Channel per second.
	55	* Table 66 from SLIMbus 2.0 Specs
	56	*
	57	* Index of the table corresponds to Presence rate code for the respective rate
	58	* in the table.
	59	*/
	60	static const int slim_presence_rate_table[] = {
	61	0, /* Not Indicated */
	62	12000,
	63	24000,
	64	48000,
65	96000,
66	192000,
67	384000,
68	768000,
69	0, /* Reserved */
70	110250,
71	220500,
72	441000,
73	882000,
74	176400,
75	352800,
76	705600,
77	4000,
78	8000,
79	16000,
80	32000,
81	64000,
82	128000,
83	256000,
84	512000,
85	};
86
87	/*
88	* slim_stream_allocate() - Allocate a new SLIMbus Stream
89	* @dev:Slim device to be associated with
90	* @name: name of the stream
91	*
92	* This is very first call for SLIMbus streaming, this API will allocate
93	* a new SLIMbus stream and return a valid stream runtime pointer for client
94	* to use it in subsequent stream apis. state of stream is set to ALLOCATED
95	*
96	* Return: valid pointer on success and error code on failure.
97	* From ASoC DPCM framework, this state is linked to startup() operation.
98	*/
99	struct slim_stream_runtime slim_stream_allocate(struct slim_device dev,
100	const char *name)
101	{
102	struct slim_stream_runtime *rt;
103
104	rt = kzalloc(sizeof(*rt), GFP_KERNEL);
105	if (!rt)
106	return ERR_PTR(-ENOMEM);
107
108	rt->name = kasprintf(GFP_KERNEL, "slim-%s", name);
109	if (!rt->name) {
110	kfree(rt);
111	return ERR_PTR(-ENOMEM);
112	}
113
114	rt->dev = dev;
115	spin_lock(&dev->stream_list_lock);
116	list_add_tail(&rt->node, &dev->stream_list);
117	spin_unlock(&dev->stream_list_lock);
118
119	return rt;
120	}
121	EXPORT_SYMBOL_GPL(slim_stream_allocate);
122
123	static int slim_connect_port_channel(struct slim_stream_runtime *stream,
124	struct slim_port *port)
125	{
126	struct slim_device *sdev = stream->dev;
127	u8 wbuf[2];
128	struct slim_val_inf msg = {0, 2, NULL, wbuf, NULL};
129	u8 mc = SLIM_MSG_MC_CONNECT_SOURCE;
130	DEFINE_SLIM_LDEST_TXN(txn, mc, 6, stream->dev->laddr, &msg);
131
132	if (port->direction == SLIM_PORT_SINK)
133	txn.mc = SLIM_MSG_MC_CONNECT_SINK;
134
135	wbuf[0] = port->id;
136	wbuf[1] = port->ch.id;
137	port->ch.state = SLIM_CH_STATE_ASSOCIATED;
138	port->state = SLIM_PORT_UNCONFIGURED;
139
140	return slim_do_transfer(sdev->ctrl, &txn);
141	}
142
143	static int slim_disconnect_port(struct slim_stream_runtime *stream,
144	struct slim_port *port)
145	{
146	struct slim_device *sdev = stream->dev;
147	u8 wbuf[1];
148	struct slim_val_inf msg = {0, 1, NULL, wbuf, NULL};
149	u8 mc = SLIM_MSG_MC_DISCONNECT_PORT;
150	DEFINE_SLIM_LDEST_TXN(txn, mc, 5, stream->dev->laddr, &msg);
151
152	wbuf[0] = port->id;
153	port->ch.state = SLIM_CH_STATE_DISCONNECTED;
154	port->state = SLIM_PORT_DISCONNECTED;
155
156	return slim_do_transfer(sdev->ctrl, &txn);
157	}
158
159	static int slim_deactivate_remove_channel(struct slim_stream_runtime *stream,
160	struct slim_port *port)
161	{
162	struct slim_device *sdev = stream->dev;
163	u8 wbuf[1];
164	struct slim_val_inf msg = {0, 1, NULL, wbuf, NULL};
165	u8 mc = SLIM_MSG_MC_NEXT_DEACTIVATE_CHANNEL;
166	DEFINE_SLIM_LDEST_TXN(txn, mc, 5, stream->dev->laddr, &msg);
167	int ret;
168
169	wbuf[0] = port->ch.id;
170	ret = slim_do_transfer(sdev->ctrl, &txn);
171	if (ret)
172	return ret;
173
174	txn.mc = SLIM_MSG_MC_NEXT_REMOVE_CHANNEL;
175	port->ch.state = SLIM_CH_STATE_REMOVED;
176
177	return slim_do_transfer(sdev->ctrl, &txn);
178	}
179
180	static int slim_get_prate_code(int rate)
181	{
182	int i;
183
184	for (i = 0; i < ARRAY_SIZE(slim_presence_rate_table); i++) {
185	if (rate == slim_presence_rate_table[i])
186	return i;
187	}
188
189	return -EINVAL;
190	}
191
192	/*
193	* slim_stream_prepare() - Prepare a SLIMbus Stream
194	*
195	* @rt: instance of slim stream runtime to configure
196	* @cfg: new configuration for the stream
197	*
198	* This API will configure SLIMbus stream with config parameters from cfg.
199	* return zero on success and error code on failure. From ASoC DPCM framework,
200	* this state is linked to hw_params() operation.
201	*/
202	int slim_stream_prepare(struct slim_stream_runtime *rt,
203	struct slim_stream_config *cfg)
204	{
205	struct slim_controller *ctrl = rt->dev->ctrl;
206	struct slim_port *port;
207	int num_ports, i, port_id;
208
209	if (rt->ports) {
210	dev_err(&rt->dev->dev, "Stream already Prepared\n");
211	return -EINVAL;
212	}
213
214	num_ports = hweight32(cfg->port_mask);
215	rt->ports = kcalloc(num_ports, sizeof(*port), GFP_KERNEL);
216	if (!rt->ports)
217	return -ENOMEM;
218
219	rt->num_ports = num_ports;
220	rt->rate = cfg->rate;
221	rt->bps = cfg->bps;
222	rt->direction = cfg->direction;
223
224	if (cfg->rate % ctrl->a_framer->superfreq) {
225	/*
226	* data rate not exactly multiple of super frame,
227	* use PUSH/PULL protocol
228	*/
229	if (cfg->direction == SNDRV_PCM_STREAM_PLAYBACK)
230	rt->prot = SLIM_PROTO_PUSH;
231	else
232	rt->prot = SLIM_PROTO_PULL;
233	} else {
234	rt->prot = SLIM_PROTO_ISO;
235	}
236
237	rt->ratem = cfg->rate/ctrl->a_framer->superfreq;
238
239	i = 0;
240	for_each_set_bit(port_id, &cfg->port_mask, SLIM_DEVICE_MAX_PORTS) {
241	port = &rt->ports[i];
242	port->state = SLIM_PORT_DISCONNECTED;
243	port->id = port_id;
244	port->ch.prrate = slim_get_prate_code(cfg->rate);
245	port->ch.id = cfg->chs[i];
246	port->ch.data_fmt = SLIM_CH_DATA_FMT_NOT_DEFINED;
247	port->ch.aux_fmt = SLIM_CH_AUX_FMT_NOT_APPLICABLE;
248	port->ch.state = SLIM_CH_STATE_ALLOCATED;
249
250	if (cfg->direction == SNDRV_PCM_STREAM_PLAYBACK)
251	port->direction = SLIM_PORT_SINK;
252	else
253	port->direction = SLIM_PORT_SOURCE;
254
255	slim_connect_port_channel(rt, port);
256	i++;
257	}
258
259	return 0;
260	}
261	EXPORT_SYMBOL_GPL(slim_stream_prepare);
262
263	static int slim_define_channel_content(struct slim_stream_runtime *stream,
264	struct slim_port *port)
265	{
266	struct slim_device *sdev = stream->dev;
267	u8 wbuf[4];
268	struct slim_val_inf msg = {0, 4, NULL, wbuf, NULL};
269	u8 mc = SLIM_MSG_MC_NEXT_DEFINE_CONTENT;
270	DEFINE_SLIM_LDEST_TXN(txn, mc, 8, stream->dev->laddr, &msg);
271
272	wbuf[0] = port->ch.id;
273	wbuf[1] = port->ch.prrate;
274
275	/* Frequency Locked for ISO Protocol */
276	if (stream->prot != SLIM_PROTO_ISO)
277	wbuf[1] \|= SLIM_CHANNEL_CONTENT_FL;
278
279	wbuf[2] = port->ch.data_fmt \| (port->ch.aux_fmt << 4);
280	wbuf[3] = stream->bps/SLIM_SLOT_LEN_BITS;
281	port->ch.state = SLIM_CH_STATE_CONTENT_DEFINED;
282
283	return slim_do_transfer(sdev->ctrl, &txn);
284	}
285
286	static int slim_get_segdist_code(int ratem)
287	{
288	int i;
289
290	for (i = 0; i < ARRAY_SIZE(segdist_codes); i++) {
291	if (segdist_codes[i].ratem == ratem)
292	return segdist_codes[i].segdist_code;
293	}
294
295	return -EINVAL;
296	}
297
298	static int slim_define_channel(struct slim_stream_runtime *stream,
299	struct slim_port *port)
300	{
301	struct slim_device *sdev = stream->dev;
302	u8 wbuf[4];
303	struct slim_val_inf msg = {0, 4, NULL, wbuf, NULL};
304	u8 mc = SLIM_MSG_MC_NEXT_DEFINE_CHANNEL;
305	DEFINE_SLIM_LDEST_TXN(txn, mc, 8, stream->dev->laddr, &msg);
306
307	port->ch.seg_dist = slim_get_segdist_code(stream->ratem);
308
309	wbuf[0] = port->ch.id;
310	wbuf[1] = port->ch.seg_dist & 0xFF;
311	wbuf[2] = (stream->prot << 4) \| ((port->ch.seg_dist & 0xF00) >> 8);
312	if (stream->prot == SLIM_PROTO_ISO)
313	wbuf[3] = stream->bps/SLIM_SLOT_LEN_BITS;
314	else
315	wbuf[3] = stream->bps/SLIM_SLOT_LEN_BITS + 1;
316
317	port->ch.state = SLIM_CH_STATE_DEFINED;
318
319	return slim_do_transfer(sdev->ctrl, &txn);
320	}
321
322	static int slim_activate_channel(struct slim_stream_runtime *stream,
323	struct slim_port *port)
324	{
325	struct slim_device *sdev = stream->dev;
326	u8 wbuf[1];
327	struct slim_val_inf msg = {0, 1, NULL, wbuf, NULL};
328	u8 mc = SLIM_MSG_MC_NEXT_ACTIVATE_CHANNEL;
329	DEFINE_SLIM_LDEST_TXN(txn, mc, 5, stream->dev->laddr, &msg);
330
331	txn.msg->num_bytes = 1;
332	txn.msg->wbuf = wbuf;
333	wbuf[0] = port->ch.id;
334	port->ch.state = SLIM_CH_STATE_ACTIVE;
335
336	return slim_do_transfer(sdev->ctrl, &txn);
337	}
338
339	/*
340	* slim_stream_enable() - Enable a prepared SLIMbus Stream
341	*
342	* @stream: instance of slim stream runtime to enable
343	*
344	* This API will enable all the ports and channels associated with
345	* SLIMbus stream
346	*
347	* Return: zero on success and error code on failure. From ASoC DPCM framework,
348	* this state is linked to trigger() start operation.
349	*/
350	int slim_stream_enable(struct slim_stream_runtime *stream)
351	{
352	DEFINE_SLIM_BCAST_TXN(txn, SLIM_MSG_MC_BEGIN_RECONFIGURATION,
353	3, SLIM_LA_MANAGER, NULL);
354	struct slim_controller *ctrl = stream->dev->ctrl;
355	int ret, i;
356
357	if (ctrl->enable_stream) {
358	ret = ctrl->enable_stream(stream);
359	if (ret)
360	return ret;
361
362	for (i = 0; i < stream->num_ports; i++)
363	stream->ports[i].ch.state = SLIM_CH_STATE_ACTIVE;
364
365	return ret;
366	}
367
368	ret = slim_do_transfer(ctrl, &txn);
369	if (ret)
370	return ret;
371
372	/* define channels first before activating them */
373	for (i = 0; i < stream->num_ports; i++) {
374	struct slim_port *port = &stream->ports[i];
375
376	slim_define_channel(stream, port);
377	slim_define_channel_content(stream, port);
378	}
379
380	for (i = 0; i < stream->num_ports; i++) {
381	struct slim_port *port = &stream->ports[i];
382
383	slim_activate_channel(stream, port);
384	port->state = SLIM_PORT_CONFIGURED;
385	}
386	txn.mc = SLIM_MSG_MC_RECONFIGURE_NOW;
387
388	return slim_do_transfer(ctrl, &txn);
389	}
390	EXPORT_SYMBOL_GPL(slim_stream_enable);
391
392	/*
393	* slim_stream_disable() - Disable a SLIMbus Stream
394	*
395	* @stream: instance of slim stream runtime to disable
396	*
397	* This API will disable all the ports and channels associated with
398	* SLIMbus stream
399	*
400	* Return: zero on success and error code on failure. From ASoC DPCM framework,
401	* this state is linked to trigger() pause operation.
402	*/
403	int slim_stream_disable(struct slim_stream_runtime *stream)
404	{
405	DEFINE_SLIM_BCAST_TXN(txn, SLIM_MSG_MC_BEGIN_RECONFIGURATION,
406	3, SLIM_LA_MANAGER, NULL);
407	struct slim_controller *ctrl = stream->dev->ctrl;
408	int ret, i;
409
410	if (ctrl->disable_stream)
411	ctrl->disable_stream(stream);
412
413	ret = slim_do_transfer(ctrl, &txn);
414	if (ret)
415	return ret;
416
417	for (i = 0; i < stream->num_ports; i++)
418	slim_deactivate_remove_channel(stream, &stream->ports[i]);
419
420	txn.mc = SLIM_MSG_MC_RECONFIGURE_NOW;
421
422	return slim_do_transfer(ctrl, &txn);
423	}
424	EXPORT_SYMBOL_GPL(slim_stream_disable);
425
426	/*
427	* slim_stream_unprepare() - Un-prepare a SLIMbus Stream
428	*
429	* @stream: instance of slim stream runtime to unprepare
430	*
431	* This API will un allocate all the ports and channels associated with
432	* SLIMbus stream
433	*
434	* Return: zero on success and error code on failure. From ASoC DPCM framework,
435	* this state is linked to trigger() stop operation.
436	*/
437	int slim_stream_unprepare(struct slim_stream_runtime *stream)
438	{
439	int i;
440
441	for (i = 0; i < stream->num_ports; i++)
442	slim_disconnect_port(stream, &stream->ports[i]);
443
444	kfree(stream->ports);
445	stream->ports = NULL;
446	stream->num_ports = 0;
447
448	return 0;
449	}
450	EXPORT_SYMBOL_GPL(slim_stream_unprepare);
451
452	/*
453	* slim_stream_free() - Free a SLIMbus Stream
454	*
455	* @stream: instance of slim stream runtime to free
456	*
457	* This API will un allocate all the memory associated with
458	* slim stream runtime, user is not allowed to make an dereference
459	* to stream after this call.
460	*
461	* Return: zero on success and error code on failure. From ASoC DPCM framework,
462	* this state is linked to shutdown() operation.
463	*/
464	int slim_stream_free(struct slim_stream_runtime *stream)
465	{
466	struct slim_device *sdev = stream->dev;
467
468	spin_lock(&sdev->stream_list_lock);
469	list_del(&stream->node);
470	spin_unlock(&sdev->stream_list_lock);
471
472	kfree(stream->name);
473	kfree(stream);
474
475	return 0;
476	}
477	EXPORT_SYMBOL_GPL(slim_stream_free);