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 	11025,
71 	22050,
72 	44100,
73 	88200,
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  */
slim_stream_allocate(struct slim_device * dev,const char * name)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 
slim_connect_port_channel(struct slim_stream_runtime * stream,struct slim_port * port)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 
slim_disconnect_port(struct slim_stream_runtime * stream,struct slim_port * port)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 
slim_deactivate_remove_channel(struct slim_stream_runtime * stream,struct slim_port * port)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 
slim_get_prate_code(int rate)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  */
slim_stream_prepare(struct slim_stream_runtime * rt,struct slim_stream_config * cfg)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 
slim_define_channel_content(struct slim_stream_runtime * stream,struct slim_port * port)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 
slim_get_segdist_code(int ratem)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 
slim_define_channel(struct slim_stream_runtime * stream,struct slim_port * port)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 
slim_activate_channel(struct slim_stream_runtime * stream,struct slim_port * port)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  */
slim_stream_enable(struct slim_stream_runtime * stream)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  */
slim_stream_disable(struct slim_stream_runtime * stream)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  */
slim_stream_unprepare(struct slim_stream_runtime * stream)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  */
slim_stream_free(struct slim_stream_runtime * stream)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);
478