xref: /openbmc/linux/sound/soc/sof/ops.h (revision 3bf90eca) 
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 #ifndef __SOUND_SOC_SOF_IO_H
12 #define __SOUND_SOC_SOF_IO_H
13 
14 #include <linux/device.h>
15 #include <linux/interrupt.h>
16 #include <linux/kernel.h>
17 #include <linux/types.h>
18 #include <sound/pcm.h>
19 #include "sof-priv.h"
20 
21 #define sof_ops(sdev) \
22 	((sdev)->pdata->desc->ops)
23 
24 static inline int sof_ops_init(struct snd_sof_dev *sdev)
25 {
26 	if (sdev->pdata->desc->ops_init)
27 		return sdev->pdata->desc->ops_init(sdev);
28 
29 	return 0;
30 }
31 
32 static inline void sof_ops_free(struct snd_sof_dev *sdev)
33 {
34 	if (sdev->pdata->desc->ops_free)
35 		sdev->pdata->desc->ops_free(sdev);
36 }
37 
38 /* Mandatory operations are verified during probing */
39 
40 /* init */
41 static inline int snd_sof_probe(struct snd_sof_dev *sdev)
42 {
43 	return sof_ops(sdev)->probe(sdev);
44 }
45 
46 static inline int snd_sof_remove(struct snd_sof_dev *sdev)
47 {
48 	if (sof_ops(sdev)->remove)
49 		return sof_ops(sdev)->remove(sdev);
50 
51 	return 0;
52 }
53 
54 static inline int snd_sof_shutdown(struct snd_sof_dev *sdev)
55 {
56 	if (sof_ops(sdev)->shutdown)
57 		return sof_ops(sdev)->shutdown(sdev);
58 
59 	return 0;
60 }
61 
62 /* control */
63 
64 /*
65  * snd_sof_dsp_run returns the core mask of the cores that are available
66  * after successful fw boot
67  */
68 static inline int snd_sof_dsp_run(struct snd_sof_dev *sdev)
69 {
70 	return sof_ops(sdev)->run(sdev);
71 }
72 
73 static inline int snd_sof_dsp_stall(struct snd_sof_dev *sdev, unsigned int core_mask)
74 {
75 	if (sof_ops(sdev)->stall)
76 		return sof_ops(sdev)->stall(sdev, core_mask);
77 
78 	return 0;
79 }
80 
81 static inline int snd_sof_dsp_reset(struct snd_sof_dev *sdev)
82 {
83 	if (sof_ops(sdev)->reset)
84 		return sof_ops(sdev)->reset(sdev);
85 
86 	return 0;
87 }
88 
89 /* dsp core get/put */
90 static inline int snd_sof_dsp_core_get(struct snd_sof_dev *sdev, int core)
91 {
92 	if (core > sdev->num_cores - 1) {
93 		dev_err(sdev->dev, "invalid core id: %d for num_cores: %d\n", core,
94 			sdev->num_cores);
95 		return -EINVAL;
96 	}
97 
98 	if (sof_ops(sdev)->core_get) {
99 		int ret;
100 
101 		/* if current ref_count is > 0, increment it and return */
102 		if (sdev->dsp_core_ref_count[core] > 0) {
103 			sdev->dsp_core_ref_count[core]++;
104 			return 0;
105 		}
106 
107 		/* power up the core */
108 		ret = sof_ops(sdev)->core_get(sdev, core);
109 		if (ret < 0)
110 			return ret;
111 
112 		/* increment ref_count */
113 		sdev->dsp_core_ref_count[core]++;
114 
115 		/* and update enabled_cores_mask */
116 		sdev->enabled_cores_mask |= BIT(core);
117 
118 		dev_dbg(sdev->dev, "Core %d powered up\n", core);
119 	}
120 
121 	return 0;
122 }
123 
124 static inline int snd_sof_dsp_core_put(struct snd_sof_dev *sdev, int core)
125 {
126 	if (core > sdev->num_cores - 1) {
127 		dev_err(sdev->dev, "invalid core id: %d for num_cores: %d\n", core,
128 			sdev->num_cores);
129 		return -EINVAL;
130 	}
131 
132 	if (sof_ops(sdev)->core_put) {
133 		int ret;
134 
135 		/* decrement ref_count and return if it is > 0 */
136 		if (--(sdev->dsp_core_ref_count[core]) > 0)
137 			return 0;
138 
139 		/* power down the core */
140 		ret = sof_ops(sdev)->core_put(sdev, core);
141 		if (ret < 0)
142 			return ret;
143 
144 		/* and update enabled_cores_mask */
145 		sdev->enabled_cores_mask &= ~BIT(core);
146 
147 		dev_dbg(sdev->dev, "Core %d powered down\n", core);
148 	}
149 
150 	return 0;
151 }
152 
153 /* pre/post fw load */
154 static inline int snd_sof_dsp_pre_fw_run(struct snd_sof_dev *sdev)
155 {
156 	if (sof_ops(sdev)->pre_fw_run)
157 		return sof_ops(sdev)->pre_fw_run(sdev);
158 
159 	return 0;
160 }
161 
162 static inline int snd_sof_dsp_post_fw_run(struct snd_sof_dev *sdev)
163 {
164 	if (sof_ops(sdev)->post_fw_run)
165 		return sof_ops(sdev)->post_fw_run(sdev);
166 
167 	return 0;
168 }
169 
170 /* parse platform specific extended manifest */
171 static inline int snd_sof_dsp_parse_platform_ext_manifest(struct snd_sof_dev *sdev,
172 							  const struct sof_ext_man_elem_header *hdr)
173 {
174 	if (sof_ops(sdev)->parse_platform_ext_manifest)
175 		return sof_ops(sdev)->parse_platform_ext_manifest(sdev, hdr);
176 
177 	return 0;
178 }
179 
180 /* misc */
181 
182 /**
183  * snd_sof_dsp_get_bar_index - Maps a section type with a BAR index
184  *
185  * @sdev: sof device
186  * @type: section type as described by snd_sof_fw_blk_type
187  *
188  * Returns the corresponding BAR index (a positive integer) or -EINVAL
189  * in case there is no mapping
190  */
191 static inline int snd_sof_dsp_get_bar_index(struct snd_sof_dev *sdev, u32 type)
192 {
193 	if (sof_ops(sdev)->get_bar_index)
194 		return sof_ops(sdev)->get_bar_index(sdev, type);
195 
196 	return sdev->mmio_bar;
197 }
198 
199 static inline int snd_sof_dsp_get_mailbox_offset(struct snd_sof_dev *sdev)
200 {
201 	if (sof_ops(sdev)->get_mailbox_offset)
202 		return sof_ops(sdev)->get_mailbox_offset(sdev);
203 
204 	dev_err(sdev->dev, "error: %s not defined\n", __func__);
205 	return -ENOTSUPP;
206 }
207 
208 static inline int snd_sof_dsp_get_window_offset(struct snd_sof_dev *sdev,
209 						u32 id)
210 {
211 	if (sof_ops(sdev)->get_window_offset)
212 		return sof_ops(sdev)->get_window_offset(sdev, id);
213 
214 	dev_err(sdev->dev, "error: %s not defined\n", __func__);
215 	return -ENOTSUPP;
216 }
217 /* power management */
218 static inline int snd_sof_dsp_resume(struct snd_sof_dev *sdev)
219 {
220 	if (sof_ops(sdev)->resume)
221 		return sof_ops(sdev)->resume(sdev);
222 
223 	return 0;
224 }
225 
226 static inline int snd_sof_dsp_suspend(struct snd_sof_dev *sdev,
227 				      u32 target_state)
228 {
229 	if (sof_ops(sdev)->suspend)
230 		return sof_ops(sdev)->suspend(sdev, target_state);
231 
232 	return 0;
233 }
234 
235 static inline int snd_sof_dsp_runtime_resume(struct snd_sof_dev *sdev)
236 {
237 	if (sof_ops(sdev)->runtime_resume)
238 		return sof_ops(sdev)->runtime_resume(sdev);
239 
240 	return 0;
241 }
242 
243 static inline int snd_sof_dsp_runtime_suspend(struct snd_sof_dev *sdev)
244 {
245 	if (sof_ops(sdev)->runtime_suspend)
246 		return sof_ops(sdev)->runtime_suspend(sdev);
247 
248 	return 0;
249 }
250 
251 static inline int snd_sof_dsp_runtime_idle(struct snd_sof_dev *sdev)
252 {
253 	if (sof_ops(sdev)->runtime_idle)
254 		return sof_ops(sdev)->runtime_idle(sdev);
255 
256 	return 0;
257 }
258 
259 static inline int snd_sof_dsp_hw_params_upon_resume(struct snd_sof_dev *sdev)
260 {
261 	if (sof_ops(sdev)->set_hw_params_upon_resume)
262 		return sof_ops(sdev)->set_hw_params_upon_resume(sdev);
263 	return 0;
264 }
265 
266 static inline int snd_sof_dsp_set_clk(struct snd_sof_dev *sdev, u32 freq)
267 {
268 	if (sof_ops(sdev)->set_clk)
269 		return sof_ops(sdev)->set_clk(sdev, freq);
270 
271 	return 0;
272 }
273 
274 static inline int
275 snd_sof_dsp_set_power_state(struct snd_sof_dev *sdev,
276 			    const struct sof_dsp_power_state *target_state)
277 {
278 	int ret = 0;
279 
280 	mutex_lock(&sdev->power_state_access);
281 
282 	if (sof_ops(sdev)->set_power_state)
283 		ret = sof_ops(sdev)->set_power_state(sdev, target_state);
284 
285 	mutex_unlock(&sdev->power_state_access);
286 
287 	return ret;
288 }
289 
290 /* debug */
291 void snd_sof_dsp_dbg_dump(struct snd_sof_dev *sdev, const char *msg, u32 flags);
292 
293 static inline int snd_sof_debugfs_add_region_item(struct snd_sof_dev *sdev,
294 		enum snd_sof_fw_blk_type blk_type, u32 offset, size_t size,
295 		const char *name, enum sof_debugfs_access_type access_type)
296 {
297 	if (sof_ops(sdev) && sof_ops(sdev)->debugfs_add_region_item)
298 		return sof_ops(sdev)->debugfs_add_region_item(sdev, blk_type, offset,
299 							      size, name, access_type);
300 
301 	return 0;
302 }
303 
304 /* register IO */
305 static inline void snd_sof_dsp_write8(struct snd_sof_dev *sdev, u32 bar,
306 				      u32 offset, u8 value)
307 {
308 	if (sof_ops(sdev)->write8)
309 		sof_ops(sdev)->write8(sdev, sdev->bar[bar] + offset, value);
310 	else
311 		writeb(value,  sdev->bar[bar] + offset);
312 }
313 
314 static inline void snd_sof_dsp_write(struct snd_sof_dev *sdev, u32 bar,
315 				     u32 offset, u32 value)
316 {
317 	if (sof_ops(sdev)->write)
318 		sof_ops(sdev)->write(sdev, sdev->bar[bar] + offset, value);
319 	else
320 		writel(value,  sdev->bar[bar] + offset);
321 }
322 
323 static inline void snd_sof_dsp_write64(struct snd_sof_dev *sdev, u32 bar,
324 				       u32 offset, u64 value)
325 {
326 	if (sof_ops(sdev)->write64)
327 		sof_ops(sdev)->write64(sdev, sdev->bar[bar] + offset, value);
328 	else
329 		writeq(value, sdev->bar[bar] + offset);
330 }
331 
332 static inline u8 snd_sof_dsp_read8(struct snd_sof_dev *sdev, u32 bar,
333 				   u32 offset)
334 {
335 	if (sof_ops(sdev)->read8)
336 		return sof_ops(sdev)->read8(sdev, sdev->bar[bar] + offset);
337 	else
338 		return readb(sdev->bar[bar] + offset);
339 }
340 
341 static inline u32 snd_sof_dsp_read(struct snd_sof_dev *sdev, u32 bar,
342 				   u32 offset)
343 {
344 	if (sof_ops(sdev)->read)
345 		return sof_ops(sdev)->read(sdev, sdev->bar[bar] + offset);
346 	else
347 		return readl(sdev->bar[bar] + offset);
348 }
349 
350 static inline u64 snd_sof_dsp_read64(struct snd_sof_dev *sdev, u32 bar,
351 				     u32 offset)
352 {
353 	if (sof_ops(sdev)->read64)
354 		return sof_ops(sdev)->read64(sdev, sdev->bar[bar] + offset);
355 	else
356 		return readq(sdev->bar[bar] + offset);
357 }
358 
359 static inline void snd_sof_dsp_update8(struct snd_sof_dev *sdev, u32 bar,
360 				       u32 offset, u8 value, u8 mask)
361 {
362 	u8 reg;
363 
364 	reg = snd_sof_dsp_read8(sdev, bar, offset);
365 	reg &= ~mask;
366 	reg |= value;
367 	snd_sof_dsp_write8(sdev, bar, offset, reg);
368 }
369 
370 /* block IO */
371 static inline int snd_sof_dsp_block_read(struct snd_sof_dev *sdev,
372 					 enum snd_sof_fw_blk_type blk_type,
373 					 u32 offset, void *dest, size_t bytes)
374 {
375 	return sof_ops(sdev)->block_read(sdev, blk_type, offset, dest, bytes);
376 }
377 
378 static inline int snd_sof_dsp_block_write(struct snd_sof_dev *sdev,
379 					  enum snd_sof_fw_blk_type blk_type,
380 					  u32 offset, void *src, size_t bytes)
381 {
382 	return sof_ops(sdev)->block_write(sdev, blk_type, offset, src, bytes);
383 }
384 
385 /* mailbox IO */
386 static inline void snd_sof_dsp_mailbox_read(struct snd_sof_dev *sdev,
387 					    u32 offset, void *dest, size_t bytes)
388 {
389 	if (sof_ops(sdev)->mailbox_read)
390 		sof_ops(sdev)->mailbox_read(sdev, offset, dest, bytes);
391 }
392 
393 static inline void snd_sof_dsp_mailbox_write(struct snd_sof_dev *sdev,
394 					     u32 offset, void *src, size_t bytes)
395 {
396 	if (sof_ops(sdev)->mailbox_write)
397 		sof_ops(sdev)->mailbox_write(sdev, offset, src, bytes);
398 }
399 
400 /* ipc */
401 static inline int snd_sof_dsp_send_msg(struct snd_sof_dev *sdev,
402 				       struct snd_sof_ipc_msg *msg)
403 {
404 	return sof_ops(sdev)->send_msg(sdev, msg);
405 }
406 
407 /* host PCM ops */
408 static inline int
409 snd_sof_pcm_platform_open(struct snd_sof_dev *sdev,
410 			  struct snd_pcm_substream *substream)
411 {
412 	if (sof_ops(sdev) && sof_ops(sdev)->pcm_open)
413 		return sof_ops(sdev)->pcm_open(sdev, substream);
414 
415 	return 0;
416 }
417 
418 /* disconnect pcm substream to a host stream */
419 static inline int
420 snd_sof_pcm_platform_close(struct snd_sof_dev *sdev,
421 			   struct snd_pcm_substream *substream)
422 {
423 	if (sof_ops(sdev) && sof_ops(sdev)->pcm_close)
424 		return sof_ops(sdev)->pcm_close(sdev, substream);
425 
426 	return 0;
427 }
428 
429 /* host stream hw params */
430 static inline int
431 snd_sof_pcm_platform_hw_params(struct snd_sof_dev *sdev,
432 			       struct snd_pcm_substream *substream,
433 			       struct snd_pcm_hw_params *params,
434 			       struct snd_sof_platform_stream_params *platform_params)
435 {
436 	if (sof_ops(sdev) && sof_ops(sdev)->pcm_hw_params)
437 		return sof_ops(sdev)->pcm_hw_params(sdev, substream, params,
438 						    platform_params);
439 
440 	return 0;
441 }
442 
443 /* host stream hw free */
444 static inline int
445 snd_sof_pcm_platform_hw_free(struct snd_sof_dev *sdev,
446 			     struct snd_pcm_substream *substream)
447 {
448 	if (sof_ops(sdev) && sof_ops(sdev)->pcm_hw_free)
449 		return sof_ops(sdev)->pcm_hw_free(sdev, substream);
450 
451 	return 0;
452 }
453 
454 /* host stream trigger */
455 static inline int
456 snd_sof_pcm_platform_trigger(struct snd_sof_dev *sdev,
457 			     struct snd_pcm_substream *substream, int cmd)
458 {
459 	if (sof_ops(sdev) && sof_ops(sdev)->pcm_trigger)
460 		return sof_ops(sdev)->pcm_trigger(sdev, substream, cmd);
461 
462 	return 0;
463 }
464 
465 /* Firmware loading */
466 static inline int snd_sof_load_firmware(struct snd_sof_dev *sdev)
467 {
468 	dev_dbg(sdev->dev, "loading firmware\n");
469 
470 	return sof_ops(sdev)->load_firmware(sdev);
471 }
472 
473 /* host DSP message data */
474 static inline int snd_sof_ipc_msg_data(struct snd_sof_dev *sdev,
475 				       struct snd_pcm_substream *substream,
476 				       void *p, size_t sz)
477 {
478 	return sof_ops(sdev)->ipc_msg_data(sdev, substream, p, sz);
479 }
480 /* host side configuration of the stream's data offset in stream mailbox area */
481 static inline int
482 snd_sof_set_stream_data_offset(struct snd_sof_dev *sdev,
483 			       struct snd_pcm_substream *substream,
484 			       size_t posn_offset)
485 {
486 	if (sof_ops(sdev) && sof_ops(sdev)->set_stream_data_offset)
487 		return sof_ops(sdev)->set_stream_data_offset(sdev, substream,
488 							     posn_offset);
489 
490 	return 0;
491 }
492 
493 /* host stream pointer */
494 static inline snd_pcm_uframes_t
495 snd_sof_pcm_platform_pointer(struct snd_sof_dev *sdev,
496 			     struct snd_pcm_substream *substream)
497 {
498 	if (sof_ops(sdev) && sof_ops(sdev)->pcm_pointer)
499 		return sof_ops(sdev)->pcm_pointer(sdev, substream);
500 
501 	return 0;
502 }
503 
504 /* pcm ack */
505 static inline int snd_sof_pcm_platform_ack(struct snd_sof_dev *sdev,
506 					   struct snd_pcm_substream *substream)
507 {
508 	if (sof_ops(sdev) && sof_ops(sdev)->pcm_ack)
509 		return sof_ops(sdev)->pcm_ack(sdev, substream);
510 
511 	return 0;
512 }
513 
514 /* machine driver */
515 static inline int
516 snd_sof_machine_register(struct snd_sof_dev *sdev, void *pdata)
517 {
518 	if (sof_ops(sdev) && sof_ops(sdev)->machine_register)
519 		return sof_ops(sdev)->machine_register(sdev, pdata);
520 
521 	return 0;
522 }
523 
524 static inline void
525 snd_sof_machine_unregister(struct snd_sof_dev *sdev, void *pdata)
526 {
527 	if (sof_ops(sdev) && sof_ops(sdev)->machine_unregister)
528 		sof_ops(sdev)->machine_unregister(sdev, pdata);
529 }
530 
531 static inline struct snd_soc_acpi_mach *
532 snd_sof_machine_select(struct snd_sof_dev *sdev)
533 {
534 	if (sof_ops(sdev) && sof_ops(sdev)->machine_select)
535 		return sof_ops(sdev)->machine_select(sdev);
536 
537 	return NULL;
538 }
539 
540 static inline void
541 snd_sof_set_mach_params(struct snd_soc_acpi_mach *mach,
542 			struct snd_sof_dev *sdev)
543 {
544 	if (sof_ops(sdev) && sof_ops(sdev)->set_mach_params)
545 		sof_ops(sdev)->set_mach_params(mach, sdev);
546 }
547 
548 /**
549  * snd_sof_dsp_register_poll_timeout - Periodically poll an address
550  * until a condition is met or a timeout occurs
551  * @op: accessor function (takes @addr as its only argument)
552  * @addr: Address to poll
553  * @val: Variable to read the value into
554  * @cond: Break condition (usually involving @val)
555  * @sleep_us: Maximum time to sleep between reads in us (0
556  *            tight-loops).  Should be less than ~20ms since usleep_range
557  *            is used (see Documentation/timers/timers-howto.rst).
558  * @timeout_us: Timeout in us, 0 means never timeout
559  *
560  * Returns 0 on success and -ETIMEDOUT upon a timeout. In either
561  * case, the last read value at @addr is stored in @val. Must not
562  * be called from atomic context if sleep_us or timeout_us are used.
563  *
564  * This is modelled after the readx_poll_timeout macros in linux/iopoll.h.
565  */
566 #define snd_sof_dsp_read_poll_timeout(sdev, bar, offset, val, cond, sleep_us, timeout_us) \
567 ({ \
568 	u64 __timeout_us = (timeout_us); \
569 	unsigned long __sleep_us = (sleep_us); \
570 	ktime_t __timeout = ktime_add_us(ktime_get(), __timeout_us); \
571 	might_sleep_if((__sleep_us) != 0); \
572 	for (;;) {							\
573 		(val) = snd_sof_dsp_read(sdev, bar, offset);		\
574 		if (cond) { \
575 			dev_dbg(sdev->dev, \
576 				"FW Poll Status: reg[%#x]=%#x successful\n", \
577 				(offset), (val)); \
578 			break; \
579 		} \
580 		if (__timeout_us && \
581 		    ktime_compare(ktime_get(), __timeout) > 0) { \
582 			(val) = snd_sof_dsp_read(sdev, bar, offset); \
583 			dev_dbg(sdev->dev, \
584 				"FW Poll Status: reg[%#x]=%#x timedout\n", \
585 				(offset), (val)); \
586 			break; \
587 		} \
588 		if (__sleep_us) \
589 			usleep_range((__sleep_us >> 2) + 1, __sleep_us); \
590 	} \
591 	(cond) ? 0 : -ETIMEDOUT; \
592 })
593 
594 /* This is for registers bits with attribute RWC */
595 bool snd_sof_pci_update_bits(struct snd_sof_dev *sdev, u32 offset,
596 			     u32 mask, u32 value);
597 
598 bool snd_sof_dsp_update_bits_unlocked(struct snd_sof_dev *sdev, u32 bar,
599 				      u32 offset, u32 mask, u32 value);
600 
601 bool snd_sof_dsp_update_bits64_unlocked(struct snd_sof_dev *sdev, u32 bar,
602 					u32 offset, u64 mask, u64 value);
603 
604 bool snd_sof_dsp_update_bits(struct snd_sof_dev *sdev, u32 bar, u32 offset,
605 			     u32 mask, u32 value);
606 
607 bool snd_sof_dsp_update_bits64(struct snd_sof_dev *sdev, u32 bar,
608 			       u32 offset, u64 mask, u64 value);
609 
610 void snd_sof_dsp_update_bits_forced(struct snd_sof_dev *sdev, u32 bar,
611 				    u32 offset, u32 mask, u32 value);
612 
613 int snd_sof_dsp_register_poll(struct snd_sof_dev *sdev, u32 bar, u32 offset,
614 			      u32 mask, u32 target, u32 timeout_ms,
615 			      u32 interval_us);
616 
617 void snd_sof_dsp_panic(struct snd_sof_dev *sdev, u32 offset, bool non_recoverable);
618 #endif
619