1// SPDX-License-Identifier: GPL-2.0
2// Copyright (c) 2011-2017, The Linux Foundation. All rights reserved.
3// Copyright (c) 2018, Linaro Limited
4
5#include <linux/device.h>
6#include <linux/jiffies.h>
7#include <linux/kernel.h>
8#include <linux/kref.h>
9#include <linux/module.h>
10#include <linux/of.h>
11#include <linux/of_platform.h>
12#include <linux/platform_device.h>
13#include <linux/sched.h>
14#include <linux/slab.h>
15#include <linux/soc/qcom/apr.h>
16#include <linux/wait.h>
17#include <sound/asound.h>
18#include "q6adm.h"
19#include "q6afe.h"
20#include "q6core.h"
21#include "q6dsp-common.h"
22#include "q6dsp-errno.h"
23
24#define ADM_CMD_DEVICE_OPEN_V5		0x00010326
25#define ADM_CMDRSP_DEVICE_OPEN_V5	0x00010329
26#define ADM_CMD_DEVICE_CLOSE_V5		0x00010327
27#define ADM_CMD_MATRIX_MAP_ROUTINGS_V5	0x00010325
28
29#define TIMEOUT_MS 1000
30#define RESET_COPP_ID 99
31#define INVALID_COPP_ID 0xFF
32/* Definition for a legacy device session. */
33#define ADM_LEGACY_DEVICE_SESSION	0
34#define ADM_MATRIX_ID_AUDIO_RX		0
35#define ADM_MATRIX_ID_AUDIO_TX		1
36
37struct q6copp {
38	int afe_port;
39	int copp_idx;
40	int id;
41	int topology;
42	int mode;
43	int rate;
44	int bit_width;
45	int channels;
46	int app_type;
47	int acdb_id;
48
49	struct aprv2_ibasic_rsp_result_t result;
50	struct kref refcount;
51	wait_queue_head_t wait;
52	struct list_head node;
53	struct q6adm *adm;
54};
55
56struct q6adm {
57	struct apr_device *apr;
58	struct device *dev;
59	struct q6core_svc_api_info ainfo;
60	unsigned long copp_bitmap[AFE_MAX_PORTS];
61	struct list_head copps_list;
62	spinlock_t copps_list_lock;
63	struct aprv2_ibasic_rsp_result_t result;
64	struct mutex lock;
65	wait_queue_head_t matrix_map_wait;
66};
67
68struct q6adm_cmd_device_open_v5 {
69	u16 flags;
70	u16 mode_of_operation;
71	u16 endpoint_id_1;
72	u16 endpoint_id_2;
73	u32 topology_id;
74	u16 dev_num_channel;
75	u16 bit_width;
76	u32 sample_rate;
77	u8 dev_channel_mapping[8];
78} __packed;
79
80struct q6adm_cmd_matrix_map_routings_v5 {
81	u32 matrix_id;
82	u32 num_sessions;
83} __packed;
84
85struct q6adm_session_map_node_v5 {
86	u16 session_id;
87	u16 num_copps;
88} __packed;
89
90static struct q6copp *q6adm_find_copp(struct q6adm *adm, int port_idx,
91				  int copp_idx)
92{
93	struct q6copp *c;
94	struct q6copp *ret = NULL;
95	unsigned long flags;
96
97	spin_lock_irqsave(&adm->copps_list_lock, flags);
98	list_for_each_entry(c, &adm->copps_list, node) {
99		if ((port_idx == c->afe_port) && (copp_idx == c->copp_idx)) {
100			ret = c;
101			kref_get(&c->refcount);
102			break;
103		}
104	}
105
106	spin_unlock_irqrestore(&adm->copps_list_lock, flags);
107
108	return ret;
109
110}
111
112static void q6adm_free_copp(struct kref *ref)
113{
114	struct q6copp *c = container_of(ref, struct q6copp, refcount);
115	struct q6adm *adm = c->adm;
116	unsigned long flags;
117
118	spin_lock_irqsave(&adm->copps_list_lock, flags);
119	clear_bit(c->copp_idx, &adm->copp_bitmap[c->afe_port]);
120	list_del(&c->node);
121	spin_unlock_irqrestore(&adm->copps_list_lock, flags);
122	kfree(c);
123}
124
125static int q6adm_callback(struct apr_device *adev, struct apr_resp_pkt *data)
126{
127	struct aprv2_ibasic_rsp_result_t *result = data->payload;
128	int port_idx, copp_idx;
129	struct apr_hdr *hdr = &data->hdr;
130	struct q6copp *copp;
131	struct q6adm *adm = dev_get_drvdata(&adev->dev);
132
133	if (!data->payload_size)
134		return 0;
135
136	copp_idx = (hdr->token) & 0XFF;
137	port_idx = ((hdr->token) >> 16) & 0xFF;
138	if (port_idx < 0 || port_idx >= AFE_MAX_PORTS) {
139		dev_err(&adev->dev, "Invalid port idx %d token %d\n",
140		       port_idx, hdr->token);
141		return 0;
142	}
143	if (copp_idx < 0 || copp_idx >= MAX_COPPS_PER_PORT) {
144		dev_err(&adev->dev, "Invalid copp idx %d token %d\n",
145			copp_idx, hdr->token);
146		return 0;
147	}
148
149	switch (hdr->opcode) {
150	case APR_BASIC_RSP_RESULT: {
151		if (result->status != 0) {
152			dev_err(&adev->dev, "cmd = 0x%x return error = 0x%x\n",
153				result->opcode, result->status);
154		}
155		switch (result->opcode) {
156		case ADM_CMD_DEVICE_OPEN_V5:
157		case ADM_CMD_DEVICE_CLOSE_V5:
158			copp = q6adm_find_copp(adm, port_idx, copp_idx);
159			if (!copp)
160				return 0;
161
162			copp->result = *result;
163			wake_up(&copp->wait);
164			kref_put(&copp->refcount, q6adm_free_copp);
165			break;
166		case ADM_CMD_MATRIX_MAP_ROUTINGS_V5:
167			adm->result = *result;
168			wake_up(&adm->matrix_map_wait);
169			break;
170
171		default:
172			dev_err(&adev->dev, "Unknown Cmd: 0x%x\n",
173				result->opcode);
174			break;
175		}
176		return 0;
177	}
178	case ADM_CMDRSP_DEVICE_OPEN_V5: {
179		struct adm_cmd_rsp_device_open_v5 {
180			u32 status;
181			u16 copp_id;
182			u16 reserved;
183		} __packed *open = data->payload;
184
185		copp = q6adm_find_copp(adm, port_idx, copp_idx);
186		if (!copp)
187			return 0;
188
189		if (open->copp_id == INVALID_COPP_ID) {
190			dev_err(&adev->dev, "Invalid coppid rxed %d\n",
191				open->copp_id);
192			copp->result.status = ADSP_EBADPARAM;
193			wake_up(&copp->wait);
194			kref_put(&copp->refcount, q6adm_free_copp);
195			break;
196		}
197		copp->result.opcode = hdr->opcode;
198		copp->id = open->copp_id;
199		wake_up(&copp->wait);
200		kref_put(&copp->refcount, q6adm_free_copp);
201	}
202	break;
203	default:
204		dev_err(&adev->dev, "Unknown cmd:0x%x\n",
205		       hdr->opcode);
206		break;
207	}
208
209	return 0;
210}
211
212static struct q6copp *q6adm_alloc_copp(struct q6adm *adm, int port_idx)
213{
214	struct q6copp *c;
215	int idx;
216
217	idx = find_first_zero_bit(&adm->copp_bitmap[port_idx],
218				  MAX_COPPS_PER_PORT);
219
220	if (idx >= MAX_COPPS_PER_PORT)
221		return ERR_PTR(-EBUSY);
222
223	c = kzalloc(sizeof(*c), GFP_ATOMIC);
224	if (!c)
225		return ERR_PTR(-ENOMEM);
226
227	set_bit(idx, &adm->copp_bitmap[port_idx]);
228	c->copp_idx = idx;
229	c->afe_port = port_idx;
230	c->adm = adm;
231
232	init_waitqueue_head(&c->wait);
233
234	return c;
235}
236
237static int q6adm_apr_send_copp_pkt(struct q6adm *adm, struct q6copp *copp,
238				   struct apr_pkt *pkt, uint32_t rsp_opcode)
239{
240	struct device *dev = adm->dev;
241	uint32_t opcode = pkt->hdr.opcode;
242	int ret;
243
244	mutex_lock(&adm->lock);
245	copp->result.opcode = 0;
246	copp->result.status = 0;
247	ret = apr_send_pkt(adm->apr, pkt);
248	if (ret < 0) {
249		dev_err(dev, "Failed to send APR packet\n");
250		ret = -EINVAL;
251		goto err;
252	}
253
254	/* Wait for the callback with copp id */
255	if (rsp_opcode)
256		ret = wait_event_timeout(copp->wait,
257					 (copp->result.opcode == opcode) ||
258					 (copp->result.opcode == rsp_opcode),
259					 msecs_to_jiffies(TIMEOUT_MS));
260	else
261		ret = wait_event_timeout(copp->wait,
262					 (copp->result.opcode == opcode),
263					 msecs_to_jiffies(TIMEOUT_MS));
264
265	if (!ret) {
266		dev_err(dev, "ADM copp cmd timedout\n");
267		ret = -ETIMEDOUT;
268	} else if (copp->result.status > 0) {
269		dev_err(dev, "DSP returned error[%d]\n",
270			copp->result.status);
271		ret = -EINVAL;
272	}
273
274err:
275	mutex_unlock(&adm->lock);
276	return ret;
277}
278
279static int q6adm_device_close(struct q6adm *adm, struct q6copp *copp,
280			      int port_id, int copp_idx)
281{
282	struct apr_pkt close;
283
284	close.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
285					APR_HDR_LEN(APR_HDR_SIZE),
286					APR_PKT_VER);
287	close.hdr.pkt_size = sizeof(close);
288	close.hdr.src_port = port_id;
289	close.hdr.dest_port = copp->id;
290	close.hdr.token = port_id << 16 | copp_idx;
291	close.hdr.opcode = ADM_CMD_DEVICE_CLOSE_V5;
292
293	return q6adm_apr_send_copp_pkt(adm, copp, &close, 0);
294}
295
296static struct q6copp *q6adm_find_matching_copp(struct q6adm *adm,
297					       int port_id, int topology,
298					       int mode, int rate,
299					       int channel_mode, int bit_width,
300					       int app_type)
301{
302	struct q6copp *c;
303	struct q6copp *ret = NULL;
304	unsigned long flags;
305
306	spin_lock_irqsave(&adm->copps_list_lock, flags);
307
308	list_for_each_entry(c, &adm->copps_list, node) {
309		if ((port_id == c->afe_port) && (topology == c->topology) &&
310		    (mode == c->mode) && (rate == c->rate) &&
311		    (bit_width == c->bit_width) && (app_type == c->app_type)) {
312			ret = c;
313			kref_get(&c->refcount);
314		}
315	}
316	spin_unlock_irqrestore(&adm->copps_list_lock, flags);
317
318	return ret;
319}
320
321static int q6adm_device_open(struct q6adm *adm, struct q6copp *copp,
322			     int port_id, int path, int topology,
323			     int channel_mode, int bit_width, int rate)
324{
325	struct q6adm_cmd_device_open_v5 *open;
326	int afe_port = q6afe_get_port_id(port_id);
327	struct apr_pkt *pkt;
328	void *p;
329	int ret, pkt_size;
330
331	pkt_size = APR_HDR_SIZE + sizeof(*open);
332	p = kzalloc(pkt_size, GFP_KERNEL);
333	if (!p)
334		return -ENOMEM;
335
336	pkt = p;
337	open = p + APR_HDR_SIZE;
338	pkt->hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
339					   APR_HDR_LEN(APR_HDR_SIZE),
340					   APR_PKT_VER);
341	pkt->hdr.pkt_size = pkt_size;
342	pkt->hdr.src_port = afe_port;
343	pkt->hdr.dest_port = afe_port;
344	pkt->hdr.token = port_id << 16 | copp->copp_idx;
345	pkt->hdr.opcode = ADM_CMD_DEVICE_OPEN_V5;
346	open->flags = ADM_LEGACY_DEVICE_SESSION;
347	open->mode_of_operation = path;
348	open->endpoint_id_1 = afe_port;
349	open->topology_id = topology;
350	open->dev_num_channel = channel_mode & 0x00FF;
351	open->bit_width = bit_width;
352	open->sample_rate = rate;
353
354	ret = q6dsp_map_channels(&open->dev_channel_mapping[0],
355				 channel_mode);
356	if (ret)
357		goto err;
358
359	ret = q6adm_apr_send_copp_pkt(adm, copp, pkt,
360				      ADM_CMDRSP_DEVICE_OPEN_V5);
361
362err:
363	kfree(pkt);
364	return ret;
365}
366
367/**
368 * q6adm_open() - open adm and grab a free copp
369 *
370 * @dev: Pointer to adm child device.
371 * @port_id: port id
372 * @path: playback or capture path.
373 * @rate: rate at which copp is required.
374 * @channel_mode: channel mode
375 * @topology: adm topology id
376 * @perf_mode: performace mode.
377 * @bit_width: audio sample bit width
378 * @app_type: Application type.
379 * @acdb_id: ACDB id
380 *
381 * Return: Will be an negative on error or a valid copp pointer on success.
382 */
383struct q6copp *q6adm_open(struct device *dev, int port_id, int path, int rate,
384	       int channel_mode, int topology, int perf_mode,
385	       uint16_t bit_width, int app_type, int acdb_id)
386{
387	struct q6adm *adm = dev_get_drvdata(dev->parent);
388	struct q6copp *copp;
389	unsigned long flags;
390	int ret = 0;
391
392	if (port_id < 0) {
393		dev_err(dev, "Invalid port_id %d\n", port_id);
394		return ERR_PTR(-EINVAL);
395	}
396
397	copp = q6adm_find_matching_copp(adm, port_id, topology, perf_mode,
398				      rate, channel_mode, bit_width, app_type);
399	if (copp) {
400		dev_err(dev, "Found Matching Copp 0x%x\n", copp->copp_idx);
401		return copp;
402	}
403
404	spin_lock_irqsave(&adm->copps_list_lock, flags);
405	copp = q6adm_alloc_copp(adm, port_id);
406	if (IS_ERR(copp)) {
407		spin_unlock_irqrestore(&adm->copps_list_lock, flags);
408		return ERR_CAST(copp);
409	}
410
411	list_add_tail(&copp->node, &adm->copps_list);
412	spin_unlock_irqrestore(&adm->copps_list_lock, flags);
413
414	kref_init(&copp->refcount);
415	copp->topology = topology;
416	copp->mode = perf_mode;
417	copp->rate = rate;
418	copp->channels = channel_mode;
419	copp->bit_width = bit_width;
420	copp->app_type = app_type;
421
422	ret = q6adm_device_open(adm, copp, port_id, path, topology,
423				channel_mode, bit_width, rate);
424	if (ret < 0) {
425		kref_put(&copp->refcount, q6adm_free_copp);
426		return ERR_PTR(ret);
427	}
428
429	return copp;
430}
431EXPORT_SYMBOL_GPL(q6adm_open);
432
433/**
434 * q6adm_get_copp_id() - get copp index
435 *
436 * @copp: Pointer to valid copp
437 *
438 * Return: Will be an negative on error or a valid copp index on success.
439 **/
440int q6adm_get_copp_id(struct q6copp *copp)
441{
442	if (!copp)
443		return -EINVAL;
444
445	return copp->copp_idx;
446}
447EXPORT_SYMBOL_GPL(q6adm_get_copp_id);
448
449/**
450 * q6adm_matrix_map() - Map asm streams and afe ports using payload
451 *
452 * @dev: Pointer to adm child device.
453 * @path: playback or capture path.
454 * @payload_map: map between session id and afe ports.
455 * @perf_mode: Performace mode.
456 *
457 * Return: Will be an negative on error or a zero on success.
458 */
459int q6adm_matrix_map(struct device *dev, int path,
460		     struct route_payload payload_map, int perf_mode)
461{
462	struct q6adm *adm = dev_get_drvdata(dev->parent);
463	struct q6adm_cmd_matrix_map_routings_v5 *route;
464	struct q6adm_session_map_node_v5 *node;
465	struct apr_pkt *pkt;
466	uint16_t *copps_list;
467	int pkt_size, ret, i, copp_idx;
468	void *matrix_map;
469	struct q6copp *copp;
470
471	/* Assumes port_ids have already been validated during adm_open */
472	pkt_size = (APR_HDR_SIZE + sizeof(*route) +  sizeof(*node) +
473		    (sizeof(uint32_t) * payload_map.num_copps));
474
475	matrix_map = kzalloc(pkt_size, GFP_KERNEL);
476	if (!matrix_map)
477		return -ENOMEM;
478
479	pkt = matrix_map;
480	route = matrix_map + APR_HDR_SIZE;
481	node = matrix_map + APR_HDR_SIZE + sizeof(*route);
482	copps_list = matrix_map + APR_HDR_SIZE + sizeof(*route) + sizeof(*node);
483
484	pkt->hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
485					   APR_HDR_LEN(APR_HDR_SIZE),
486					   APR_PKT_VER);
487	pkt->hdr.pkt_size = pkt_size;
488	pkt->hdr.token = 0;
489	pkt->hdr.opcode = ADM_CMD_MATRIX_MAP_ROUTINGS_V5;
490	route->num_sessions = 1;
491
492	switch (path) {
493	case ADM_PATH_PLAYBACK:
494		route->matrix_id = ADM_MATRIX_ID_AUDIO_RX;
495		break;
496	case ADM_PATH_LIVE_REC:
497		route->matrix_id = ADM_MATRIX_ID_AUDIO_TX;
498		break;
499	default:
500		dev_err(dev, "Wrong path set[%d]\n", path);
501		break;
502	}
503
504	node->session_id = payload_map.session_id;
505	node->num_copps = payload_map.num_copps;
506
507	for (i = 0; i < payload_map.num_copps; i++) {
508		int port_idx = payload_map.port_id[i];
509
510		if (port_idx < 0) {
511			dev_err(dev, "Invalid port_id %d\n",
512				payload_map.port_id[i]);
513			kfree(pkt);
514			return -EINVAL;
515		}
516		copp_idx = payload_map.copp_idx[i];
517
518		copp = q6adm_find_copp(adm, port_idx, copp_idx);
519		if (!copp) {
520			kfree(pkt);
521			return -EINVAL;
522		}
523
524		copps_list[i] = copp->id;
525		kref_put(&copp->refcount, q6adm_free_copp);
526	}
527
528	mutex_lock(&adm->lock);
529	adm->result.status = 0;
530	adm->result.opcode = 0;
531
532	ret = apr_send_pkt(adm->apr, pkt);
533	if (ret < 0) {
534		dev_err(dev, "routing for stream %d failed ret %d\n",
535		       payload_map.session_id, ret);
536		goto fail_cmd;
537	}
538	ret = wait_event_timeout(adm->matrix_map_wait,
539				 adm->result.opcode == pkt->hdr.opcode,
540				 msecs_to_jiffies(TIMEOUT_MS));
541	if (!ret) {
542		dev_err(dev, "routing for stream %d failed\n",
543		       payload_map.session_id);
544		ret = -ETIMEDOUT;
545		goto fail_cmd;
546	} else if (adm->result.status > 0) {
547		dev_err(dev, "DSP returned error[%d]\n",
548			adm->result.status);
549		ret = -EINVAL;
550		goto fail_cmd;
551	}
552
553fail_cmd:
554	mutex_unlock(&adm->lock);
555	kfree(pkt);
556	return ret;
557}
558EXPORT_SYMBOL_GPL(q6adm_matrix_map);
559
560/**
561 * q6adm_close() - Close adm copp
562 *
563 * @dev: Pointer to adm child device.
564 * @copp: pointer to previously opened copp
565 *
566 * Return: Will be an negative on error or a zero on success.
567 */
568int q6adm_close(struct device *dev, struct q6copp *copp)
569{
570	struct q6adm *adm = dev_get_drvdata(dev->parent);
571	int ret = 0;
572
573	ret = q6adm_device_close(adm, copp, copp->afe_port, copp->copp_idx);
574	if (ret < 0) {
575		dev_err(adm->dev, "Failed to close copp %d\n", ret);
576		return ret;
577	}
578
579	kref_put(&copp->refcount, q6adm_free_copp);
580
581	return 0;
582}
583EXPORT_SYMBOL_GPL(q6adm_close);
584
585static int q6adm_probe(struct apr_device *adev)
586{
587	struct device *dev = &adev->dev;
588	struct q6adm *adm;
589
590	adm = devm_kzalloc(dev, sizeof(*adm), GFP_KERNEL);
591	if (!adm)
592		return -ENOMEM;
593
594	adm->apr = adev;
595	dev_set_drvdata(dev, adm);
596	adm->dev = dev;
597	q6core_get_svc_api_info(adev->svc_id, &adm->ainfo);
598	mutex_init(&adm->lock);
599	init_waitqueue_head(&adm->matrix_map_wait);
600
601	INIT_LIST_HEAD(&adm->copps_list);
602	spin_lock_init(&adm->copps_list_lock);
603
604	return devm_of_platform_populate(dev);
605}
606
607#ifdef CONFIG_OF
608static const struct of_device_id q6adm_device_id[]  = {
609	{ .compatible = "qcom,q6adm" },
610	{},
611};
612MODULE_DEVICE_TABLE(of, q6adm_device_id);
613#endif
614
615static struct apr_driver qcom_q6adm_driver = {
616	.probe = q6adm_probe,
617	.callback = q6adm_callback,
618	.driver = {
619		.name = "qcom-q6adm",
620		.of_match_table = of_match_ptr(q6adm_device_id),
621	},
622};
623
624module_apr_driver(qcom_q6adm_driver);
625MODULE_DESCRIPTION("Q6 Audio Device Manager");
626MODULE_LICENSE("GPL v2");
627