1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
2 //
3 // This file is provided under a dual BSD/GPLv2 license.  When using or
4 // redistributing this file, you may do so under either license.
5 //
6 // Copyright(c) 2018 Intel Corporation. All rights reserved.
7 //
8 // Author: Liam Girdwood <liam.r.girdwood@linux.intel.com>
9 //
10 
11 #include <linux/firmware.h>
12 #include <linux/module.h>
13 #include <sound/soc.h>
14 #include <sound/sof.h>
15 #include "sof-priv.h"
16 #include "ops.h"
17 
18 #define CREATE_TRACE_POINTS
19 #include <trace/events/sof.h>
20 
21 /* see SOF_DBG_ flags */
22 static int sof_core_debug =  IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_ENABLE_FIRMWARE_TRACE);
23 module_param_named(sof_debug, sof_core_debug, int, 0444);
24 MODULE_PARM_DESC(sof_debug, "SOF core debug options (0x0 all off)");
25 
26 /* SOF defaults if not provided by the platform in ms */
27 #define TIMEOUT_DEFAULT_IPC_MS  500
28 #define TIMEOUT_DEFAULT_BOOT_MS 2000
29 
30 /**
31  * sof_debug_check_flag - check if a given flag(s) is set in sof_core_debug
32  * @mask: Flag or combination of flags to check
33  *
34  * Returns true if all bits set in mask is also set in sof_core_debug, otherwise
35  * false
36  */
sof_debug_check_flag(int mask)37 bool sof_debug_check_flag(int mask)
38 {
39 	if ((sof_core_debug & mask) == mask)
40 		return true;
41 
42 	return false;
43 }
44 EXPORT_SYMBOL(sof_debug_check_flag);
45 
46 /*
47  * FW Panic/fault handling.
48  */
49 
50 struct sof_panic_msg {
51 	u32 id;
52 	const char *msg;
53 };
54 
55 /* standard FW panic types */
56 static const struct sof_panic_msg panic_msg[] = {
57 	{SOF_IPC_PANIC_MEM, "out of memory"},
58 	{SOF_IPC_PANIC_WORK, "work subsystem init failed"},
59 	{SOF_IPC_PANIC_IPC, "IPC subsystem init failed"},
60 	{SOF_IPC_PANIC_ARCH, "arch init failed"},
61 	{SOF_IPC_PANIC_PLATFORM, "platform init failed"},
62 	{SOF_IPC_PANIC_TASK, "scheduler init failed"},
63 	{SOF_IPC_PANIC_EXCEPTION, "runtime exception"},
64 	{SOF_IPC_PANIC_DEADLOCK, "deadlock"},
65 	{SOF_IPC_PANIC_STACK, "stack overflow"},
66 	{SOF_IPC_PANIC_IDLE, "can't enter idle"},
67 	{SOF_IPC_PANIC_WFI, "invalid wait state"},
68 	{SOF_IPC_PANIC_ASSERT, "assertion failed"},
69 };
70 
71 /**
72  * sof_print_oops_and_stack - Handle the printing of DSP oops and stack trace
73  * @sdev: Pointer to the device's sdev
74  * @level: prink log level to use for the printing
75  * @panic_code: the panic code
76  * @tracep_code: tracepoint code
77  * @oops: Pointer to DSP specific oops data
78  * @panic_info: Pointer to the received panic information message
79  * @stack: Pointer to the call stack data
80  * @stack_words: Number of words in the stack data
81  *
82  * helper to be called from .dbg_dump callbacks. No error code is
83  * provided, it's left as an exercise for the caller of .dbg_dump
84  * (typically IPC or loader)
85  */
sof_print_oops_and_stack(struct snd_sof_dev * sdev,const char * level,u32 panic_code,u32 tracep_code,void * oops,struct sof_ipc_panic_info * panic_info,void * stack,size_t stack_words)86 void sof_print_oops_and_stack(struct snd_sof_dev *sdev, const char *level,
87 			      u32 panic_code, u32 tracep_code, void *oops,
88 			      struct sof_ipc_panic_info *panic_info,
89 			      void *stack, size_t stack_words)
90 {
91 	u32 code;
92 	int i;
93 
94 	/* is firmware dead ? */
95 	if ((panic_code & SOF_IPC_PANIC_MAGIC_MASK) != SOF_IPC_PANIC_MAGIC) {
96 		dev_printk(level, sdev->dev, "unexpected fault %#010x trace %#010x\n",
97 			   panic_code, tracep_code);
98 		return; /* no fault ? */
99 	}
100 
101 	code = panic_code & (SOF_IPC_PANIC_MAGIC_MASK | SOF_IPC_PANIC_CODE_MASK);
102 
103 	for (i = 0; i < ARRAY_SIZE(panic_msg); i++) {
104 		if (panic_msg[i].id == code) {
105 			dev_printk(level, sdev->dev, "reason: %s (%#x)\n",
106 				   panic_msg[i].msg, code & SOF_IPC_PANIC_CODE_MASK);
107 			dev_printk(level, sdev->dev, "trace point: %#010x\n", tracep_code);
108 			goto out;
109 		}
110 	}
111 
112 	/* unknown error */
113 	dev_printk(level, sdev->dev, "unknown panic code: %#x\n",
114 		   code & SOF_IPC_PANIC_CODE_MASK);
115 	dev_printk(level, sdev->dev, "trace point: %#010x\n", tracep_code);
116 
117 out:
118 	dev_printk(level, sdev->dev, "panic at %s:%d\n", panic_info->filename,
119 		   panic_info->linenum);
120 	sof_oops(sdev, level, oops);
121 	sof_stack(sdev, level, oops, stack, stack_words);
122 }
123 EXPORT_SYMBOL(sof_print_oops_and_stack);
124 
125 /* Helper to manage DSP state */
sof_set_fw_state(struct snd_sof_dev * sdev,enum sof_fw_state new_state)126 void sof_set_fw_state(struct snd_sof_dev *sdev, enum sof_fw_state new_state)
127 {
128 	if (sdev->fw_state == new_state)
129 		return;
130 
131 	dev_dbg(sdev->dev, "fw_state change: %d -> %d\n", sdev->fw_state, new_state);
132 	sdev->fw_state = new_state;
133 
134 	switch (new_state) {
135 	case SOF_FW_BOOT_NOT_STARTED:
136 	case SOF_FW_BOOT_COMPLETE:
137 	case SOF_FW_CRASHED:
138 		sof_client_fw_state_dispatcher(sdev);
139 		fallthrough;
140 	default:
141 		break;
142 	}
143 }
144 EXPORT_SYMBOL(sof_set_fw_state);
145 
146 /*
147  *			FW Boot State Transition Diagram
148  *
149  *    +----------------------------------------------------------------------+
150  *    |									     |
151  * ------------------	     ------------------				     |
152  * |		    |	     |		      |				     |
153  * |   BOOT_FAILED  |<-------|  READY_FAILED  |				     |
154  * |		    |<--+    |	              |	   ------------------	     |
155  * ------------------	|    ------------------	   |		    |	     |
156  *	^		|	    ^		   |	CRASHED	    |---+    |
157  *	|		|	    |		   |		    |	|    |
158  * (FW Boot Timeout)	|	(FW_READY FAIL)	   ------------------	|    |
159  *	|		|	    |		     ^			|    |
160  *	|		|	    |		     |(DSP Panic)	|    |
161  * ------------------	|	    |		   ------------------	|    |
162  * |		    |	|	    |		   |		    |	|    |
163  * |   IN_PROGRESS  |---------------+------------->|    COMPLETE    |	|    |
164  * |		    | (FW Boot OK)   (FW_READY OK) |		    |	|    |
165  * ------------------	|			   ------------------	|    |
166  *	^		|				|		|    |
167  *	|		|				|		|    |
168  * (FW Loading OK)	|			(System Suspend/Runtime Suspend)
169  *	|		|				|		|    |
170  *	|	(FW Loading Fail)			|		|    |
171  * ------------------	|	------------------	|		|    |
172  * |		    |	|	|		 |<-----+		|    |
173  * |   PREPARE	    |---+	|   NOT_STARTED  |<---------------------+    |
174  * |		    |		|		 |<--------------------------+
175  * ------------------		------------------
176  *    |	    ^			    |	   ^
177  *    |	    |			    |	   |
178  *    |	    +-----------------------+	   |
179  *    |		(DSP Probe OK)		   |
180  *    |					   |
181  *    |					   |
182  *    +------------------------------------+
183  *	(System Suspend/Runtime Suspend)
184  */
185 
sof_probe_continue(struct snd_sof_dev * sdev)186 static int sof_probe_continue(struct snd_sof_dev *sdev)
187 {
188 	struct snd_sof_pdata *plat_data = sdev->pdata;
189 	int ret;
190 
191 	/* probe the DSP hardware */
192 	ret = snd_sof_probe(sdev);
193 	if (ret < 0) {
194 		dev_err(sdev->dev, "error: failed to probe DSP %d\n", ret);
195 		goto probe_err;
196 	}
197 
198 	sof_set_fw_state(sdev, SOF_FW_BOOT_PREPARE);
199 
200 	/* check machine info */
201 	ret = sof_machine_check(sdev);
202 	if (ret < 0) {
203 		dev_err(sdev->dev, "error: failed to get machine info %d\n",
204 			ret);
205 		goto dsp_err;
206 	}
207 
208 	/* set up platform component driver */
209 	snd_sof_new_platform_drv(sdev);
210 
211 	if (sdev->dspless_mode_selected) {
212 		sof_set_fw_state(sdev, SOF_DSPLESS_MODE);
213 		goto skip_dsp_init;
214 	}
215 
216 	/* register any debug/trace capabilities */
217 	ret = snd_sof_dbg_init(sdev);
218 	if (ret < 0) {
219 		/*
220 		 * debugfs issues are suppressed in snd_sof_dbg_init() since
221 		 * we cannot rely on debugfs
222 		 * here we trap errors due to memory allocation only.
223 		 */
224 		dev_err(sdev->dev, "error: failed to init DSP trace/debug %d\n",
225 			ret);
226 		goto dbg_err;
227 	}
228 
229 	/* init the IPC */
230 	sdev->ipc = snd_sof_ipc_init(sdev);
231 	if (!sdev->ipc) {
232 		ret = -ENOMEM;
233 		dev_err(sdev->dev, "error: failed to init DSP IPC %d\n", ret);
234 		goto ipc_err;
235 	}
236 
237 	/* load the firmware */
238 	ret = snd_sof_load_firmware(sdev);
239 	if (ret < 0) {
240 		dev_err(sdev->dev, "error: failed to load DSP firmware %d\n",
241 			ret);
242 		sof_set_fw_state(sdev, SOF_FW_BOOT_FAILED);
243 		goto fw_load_err;
244 	}
245 
246 	sof_set_fw_state(sdev, SOF_FW_BOOT_IN_PROGRESS);
247 
248 	/*
249 	 * Boot the firmware. The FW boot status will be modified
250 	 * in snd_sof_run_firmware() depending on the outcome.
251 	 */
252 	ret = snd_sof_run_firmware(sdev);
253 	if (ret < 0) {
254 		dev_err(sdev->dev, "error: failed to boot DSP firmware %d\n",
255 			ret);
256 		sof_set_fw_state(sdev, SOF_FW_BOOT_FAILED);
257 		goto fw_run_err;
258 	}
259 
260 	if (sof_debug_check_flag(SOF_DBG_ENABLE_TRACE)) {
261 		sdev->fw_trace_is_supported = true;
262 
263 		/* init firmware tracing */
264 		ret = sof_fw_trace_init(sdev);
265 		if (ret < 0) {
266 			/* non fatal */
267 			dev_warn(sdev->dev, "failed to initialize firmware tracing %d\n",
268 				 ret);
269 		}
270 	} else {
271 		dev_dbg(sdev->dev, "SOF firmware trace disabled\n");
272 	}
273 
274 skip_dsp_init:
275 	/* hereafter all FW boot flows are for PM reasons */
276 	sdev->first_boot = false;
277 
278 	/* now register audio DSP platform driver and dai */
279 	ret = devm_snd_soc_register_component(sdev->dev, &sdev->plat_drv,
280 					      sof_ops(sdev)->drv,
281 					      sof_ops(sdev)->num_drv);
282 	if (ret < 0) {
283 		dev_err(sdev->dev,
284 			"error: failed to register DSP DAI driver %d\n", ret);
285 		goto fw_trace_err;
286 	}
287 
288 	ret = snd_sof_machine_register(sdev, plat_data);
289 	if (ret < 0) {
290 		dev_err(sdev->dev,
291 			"error: failed to register machine driver %d\n", ret);
292 		goto fw_trace_err;
293 	}
294 
295 	ret = sof_register_clients(sdev);
296 	if (ret < 0) {
297 		dev_err(sdev->dev, "failed to register clients %d\n", ret);
298 		goto sof_machine_err;
299 	}
300 
301 	/*
302 	 * Some platforms in SOF, ex: BYT, may not have their platform PM
303 	 * callbacks set. Increment the usage count so as to
304 	 * prevent the device from entering runtime suspend.
305 	 */
306 	if (!sof_ops(sdev)->runtime_suspend || !sof_ops(sdev)->runtime_resume)
307 		pm_runtime_get_noresume(sdev->dev);
308 
309 	if (plat_data->sof_probe_complete)
310 		plat_data->sof_probe_complete(sdev->dev);
311 
312 	sdev->probe_completed = true;
313 
314 	return 0;
315 
316 sof_machine_err:
317 	snd_sof_machine_unregister(sdev, plat_data);
318 fw_trace_err:
319 	sof_fw_trace_free(sdev);
320 fw_run_err:
321 	snd_sof_fw_unload(sdev);
322 fw_load_err:
323 	snd_sof_ipc_free(sdev);
324 ipc_err:
325 dbg_err:
326 	snd_sof_free_debug(sdev);
327 dsp_err:
328 	snd_sof_remove(sdev);
329 probe_err:
330 	sof_ops_free(sdev);
331 
332 	/* all resources freed, update state to match */
333 	sof_set_fw_state(sdev, SOF_FW_BOOT_NOT_STARTED);
334 	sdev->first_boot = true;
335 
336 	return ret;
337 }
338 
sof_probe_work(struct work_struct * work)339 static void sof_probe_work(struct work_struct *work)
340 {
341 	struct snd_sof_dev *sdev =
342 		container_of(work, struct snd_sof_dev, probe_work);
343 	int ret;
344 
345 	ret = sof_probe_continue(sdev);
346 	if (ret < 0) {
347 		/* errors cannot be propagated, log */
348 		dev_err(sdev->dev, "error: %s failed err: %d\n", __func__, ret);
349 	}
350 }
351 
snd_sof_device_probe(struct device * dev,struct snd_sof_pdata * plat_data)352 int snd_sof_device_probe(struct device *dev, struct snd_sof_pdata *plat_data)
353 {
354 	struct snd_sof_dev *sdev;
355 	int ret;
356 
357 	sdev = devm_kzalloc(dev, sizeof(*sdev), GFP_KERNEL);
358 	if (!sdev)
359 		return -ENOMEM;
360 
361 	/* initialize sof device */
362 	sdev->dev = dev;
363 
364 	/* initialize default DSP power state */
365 	sdev->dsp_power_state.state = SOF_DSP_PM_D0;
366 
367 	sdev->pdata = plat_data;
368 	sdev->first_boot = true;
369 	dev_set_drvdata(dev, sdev);
370 
371 	if (sof_core_debug)
372 		dev_info(dev, "sof_debug value: %#x\n", sof_core_debug);
373 
374 	if (sof_debug_check_flag(SOF_DBG_DSPLESS_MODE)) {
375 		if (plat_data->desc->dspless_mode_supported) {
376 			dev_info(dev, "Switching to DSPless mode\n");
377 			sdev->dspless_mode_selected = true;
378 		} else {
379 			dev_info(dev, "DSPless mode is not supported by the platform\n");
380 		}
381 	}
382 
383 	/* check IPC support */
384 	if (!(BIT(plat_data->ipc_type) & plat_data->desc->ipc_supported_mask)) {
385 		dev_err(dev, "ipc_type %d is not supported on this platform, mask is %#x\n",
386 			plat_data->ipc_type, plat_data->desc->ipc_supported_mask);
387 		return -EINVAL;
388 	}
389 
390 	/* init ops, if necessary */
391 	ret = sof_ops_init(sdev);
392 	if (ret < 0)
393 		return ret;
394 
395 	/* check all mandatory ops */
396 	if (!sof_ops(sdev) || !sof_ops(sdev)->probe) {
397 		sof_ops_free(sdev);
398 		dev_err(dev, "missing mandatory ops\n");
399 		return -EINVAL;
400 	}
401 
402 	if (!sdev->dspless_mode_selected &&
403 	    (!sof_ops(sdev)->run || !sof_ops(sdev)->block_read ||
404 	     !sof_ops(sdev)->block_write || !sof_ops(sdev)->send_msg ||
405 	     !sof_ops(sdev)->load_firmware || !sof_ops(sdev)->ipc_msg_data)) {
406 		sof_ops_free(sdev);
407 		dev_err(dev, "missing mandatory DSP ops\n");
408 		return -EINVAL;
409 	}
410 
411 	INIT_LIST_HEAD(&sdev->pcm_list);
412 	INIT_LIST_HEAD(&sdev->kcontrol_list);
413 	INIT_LIST_HEAD(&sdev->widget_list);
414 	INIT_LIST_HEAD(&sdev->pipeline_list);
415 	INIT_LIST_HEAD(&sdev->dai_list);
416 	INIT_LIST_HEAD(&sdev->dai_link_list);
417 	INIT_LIST_HEAD(&sdev->route_list);
418 	INIT_LIST_HEAD(&sdev->ipc_client_list);
419 	INIT_LIST_HEAD(&sdev->ipc_rx_handler_list);
420 	INIT_LIST_HEAD(&sdev->fw_state_handler_list);
421 	spin_lock_init(&sdev->ipc_lock);
422 	spin_lock_init(&sdev->hw_lock);
423 	mutex_init(&sdev->power_state_access);
424 	mutex_init(&sdev->ipc_client_mutex);
425 	mutex_init(&sdev->client_event_handler_mutex);
426 
427 	/* set default timeouts if none provided */
428 	if (plat_data->desc->ipc_timeout == 0)
429 		sdev->ipc_timeout = TIMEOUT_DEFAULT_IPC_MS;
430 	else
431 		sdev->ipc_timeout = plat_data->desc->ipc_timeout;
432 	if (plat_data->desc->boot_timeout == 0)
433 		sdev->boot_timeout = TIMEOUT_DEFAULT_BOOT_MS;
434 	else
435 		sdev->boot_timeout = plat_data->desc->boot_timeout;
436 
437 	sof_set_fw_state(sdev, SOF_FW_BOOT_NOT_STARTED);
438 
439 	if (IS_ENABLED(CONFIG_SND_SOC_SOF_PROBE_WORK_QUEUE)) {
440 		INIT_WORK(&sdev->probe_work, sof_probe_work);
441 		schedule_work(&sdev->probe_work);
442 		return 0;
443 	}
444 
445 	return sof_probe_continue(sdev);
446 }
447 EXPORT_SYMBOL(snd_sof_device_probe);
448 
snd_sof_device_probe_completed(struct device * dev)449 bool snd_sof_device_probe_completed(struct device *dev)
450 {
451 	struct snd_sof_dev *sdev = dev_get_drvdata(dev);
452 
453 	return sdev->probe_completed;
454 }
455 EXPORT_SYMBOL(snd_sof_device_probe_completed);
456 
snd_sof_device_remove(struct device * dev)457 int snd_sof_device_remove(struct device *dev)
458 {
459 	struct snd_sof_dev *sdev = dev_get_drvdata(dev);
460 	struct snd_sof_pdata *pdata = sdev->pdata;
461 	int ret;
462 	bool aborted = false;
463 
464 	if (IS_ENABLED(CONFIG_SND_SOC_SOF_PROBE_WORK_QUEUE))
465 		aborted = cancel_work_sync(&sdev->probe_work);
466 
467 	/*
468 	 * Unregister any registered client device first before IPC and debugfs
469 	 * to allow client drivers to be removed cleanly
470 	 */
471 	sof_unregister_clients(sdev);
472 
473 	/*
474 	 * Unregister machine driver. This will unbind the snd_card which
475 	 * will remove the component driver and unload the topology
476 	 * before freeing the snd_card.
477 	 */
478 	snd_sof_machine_unregister(sdev, pdata);
479 
480 	if (sdev->fw_state > SOF_FW_BOOT_NOT_STARTED) {
481 		sof_fw_trace_free(sdev);
482 		ret = snd_sof_dsp_power_down_notify(sdev);
483 		if (ret < 0)
484 			dev_warn(dev, "error: %d failed to prepare DSP for device removal",
485 				 ret);
486 
487 		snd_sof_ipc_free(sdev);
488 		snd_sof_free_debug(sdev);
489 		snd_sof_remove(sdev);
490 		sof_ops_free(sdev);
491 	} else if (aborted) {
492 		/* probe_work never ran */
493 		sof_ops_free(sdev);
494 	}
495 
496 	/* release firmware */
497 	snd_sof_fw_unload(sdev);
498 
499 	return 0;
500 }
501 EXPORT_SYMBOL(snd_sof_device_remove);
502 
snd_sof_device_shutdown(struct device * dev)503 int snd_sof_device_shutdown(struct device *dev)
504 {
505 	struct snd_sof_dev *sdev = dev_get_drvdata(dev);
506 
507 	if (IS_ENABLED(CONFIG_SND_SOC_SOF_PROBE_WORK_QUEUE))
508 		cancel_work_sync(&sdev->probe_work);
509 
510 	if (sdev->fw_state == SOF_FW_BOOT_COMPLETE) {
511 		sof_fw_trace_free(sdev);
512 		return snd_sof_shutdown(sdev);
513 	}
514 
515 	return 0;
516 }
517 EXPORT_SYMBOL(snd_sof_device_shutdown);
518 
519 MODULE_AUTHOR("Liam Girdwood");
520 MODULE_DESCRIPTION("Sound Open Firmware (SOF) Core");
521 MODULE_LICENSE("Dual BSD/GPL");
522 MODULE_ALIAS("platform:sof-audio");
523 MODULE_IMPORT_NS(SND_SOC_SOF_CLIENT);
524