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

source code of linux/sound/soc/sof/ops.h