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 
sof_ops_init(struct snd_sof_dev * sdev)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 
sof_ops_free(struct snd_sof_dev * sdev)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 */
snd_sof_probe(struct snd_sof_dev * sdev)41 static inline int snd_sof_probe(struct snd_sof_dev *sdev)
42 {
43 	return sof_ops(sdev)->probe(sdev);
44 }
45 
snd_sof_remove(struct snd_sof_dev * sdev)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 
snd_sof_shutdown(struct snd_sof_dev * sdev)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  */
snd_sof_dsp_run(struct snd_sof_dev * sdev)68 static inline int snd_sof_dsp_run(struct snd_sof_dev *sdev)
69 {
70 	return sof_ops(sdev)->run(sdev);
71 }
72 
snd_sof_dsp_stall(struct snd_sof_dev * sdev,unsigned int core_mask)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 
snd_sof_dsp_reset(struct snd_sof_dev * sdev)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 */
snd_sof_dsp_core_get(struct snd_sof_dev * sdev,int core)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 
snd_sof_dsp_core_put(struct snd_sof_dev * sdev,int core)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 */
snd_sof_dsp_pre_fw_run(struct snd_sof_dev * sdev)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 
snd_sof_dsp_post_fw_run(struct snd_sof_dev * sdev)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 */
snd_sof_dsp_parse_platform_ext_manifest(struct snd_sof_dev * sdev,const struct sof_ext_man_elem_header * hdr)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  */
snd_sof_dsp_get_bar_index(struct snd_sof_dev * sdev,u32 type)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 
snd_sof_dsp_get_mailbox_offset(struct snd_sof_dev * sdev)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 
snd_sof_dsp_get_window_offset(struct snd_sof_dev * sdev,u32 id)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 */
snd_sof_dsp_resume(struct snd_sof_dev * sdev)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 
snd_sof_dsp_suspend(struct snd_sof_dev * sdev,u32 target_state)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 
snd_sof_dsp_runtime_resume(struct snd_sof_dev * sdev)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 
snd_sof_dsp_runtime_suspend(struct snd_sof_dev * sdev)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 
snd_sof_dsp_runtime_idle(struct snd_sof_dev * sdev)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 
snd_sof_dsp_hw_params_upon_resume(struct snd_sof_dev * sdev)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 
snd_sof_dsp_set_clk(struct snd_sof_dev * sdev,u32 freq)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
snd_sof_dsp_set_power_state(struct snd_sof_dev * sdev,const struct sof_dsp_power_state * target_state)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 
snd_sof_debugfs_add_region_item(struct snd_sof_dev * sdev,enum snd_sof_fw_blk_type blk_type,u32 offset,size_t size,const char * name,enum sof_debugfs_access_type access_type)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 */
snd_sof_dsp_write(struct snd_sof_dev * sdev,u32 bar,u32 offset,u32 value)305 static inline void snd_sof_dsp_write(struct snd_sof_dev *sdev, u32 bar,
306 				     u32 offset, u32 value)
307 {
308 	if (sof_ops(sdev)->write) {
309 		sof_ops(sdev)->write(sdev, sdev->bar[bar] + offset, value);
310 		return;
311 	}
312 
313 	dev_err_ratelimited(sdev->dev, "error: %s not defined\n", __func__);
314 }
315 
snd_sof_dsp_write64(struct snd_sof_dev * sdev,u32 bar,u32 offset,u64 value)316 static inline void snd_sof_dsp_write64(struct snd_sof_dev *sdev, u32 bar,
317 				       u32 offset, u64 value)
318 {
319 	if (sof_ops(sdev)->write64) {
320 		sof_ops(sdev)->write64(sdev, sdev->bar[bar] + offset, value);
321 		return;
322 	}
323 
324 	dev_err_ratelimited(sdev->dev, "error: %s not defined\n", __func__);
325 }
326 
snd_sof_dsp_read(struct snd_sof_dev * sdev,u32 bar,u32 offset)327 static inline u32 snd_sof_dsp_read(struct snd_sof_dev *sdev, u32 bar,
328 				   u32 offset)
329 {
330 	if (sof_ops(sdev)->read)
331 		return sof_ops(sdev)->read(sdev, sdev->bar[bar] + offset);
332 
333 	dev_err(sdev->dev, "error: %s not defined\n", __func__);
334 	return -ENOTSUPP;
335 }
336 
snd_sof_dsp_read64(struct snd_sof_dev * sdev,u32 bar,u32 offset)337 static inline u64 snd_sof_dsp_read64(struct snd_sof_dev *sdev, u32 bar,
338 				     u32 offset)
339 {
340 	if (sof_ops(sdev)->read64)
341 		return sof_ops(sdev)->read64(sdev, sdev->bar[bar] + offset);
342 
343 	dev_err(sdev->dev, "error: %s not defined\n", __func__);
344 	return -ENOTSUPP;
345 }
346 
347 /* block IO */
snd_sof_dsp_block_read(struct snd_sof_dev * sdev,enum snd_sof_fw_blk_type blk_type,u32 offset,void * dest,size_t bytes)348 static inline int snd_sof_dsp_block_read(struct snd_sof_dev *sdev,
349 					 enum snd_sof_fw_blk_type blk_type,
350 					 u32 offset, void *dest, size_t bytes)
351 {
352 	return sof_ops(sdev)->block_read(sdev, blk_type, offset, dest, bytes);
353 }
354 
snd_sof_dsp_block_write(struct snd_sof_dev * sdev,enum snd_sof_fw_blk_type blk_type,u32 offset,void * src,size_t bytes)355 static inline int snd_sof_dsp_block_write(struct snd_sof_dev *sdev,
356 					  enum snd_sof_fw_blk_type blk_type,
357 					  u32 offset, void *src, size_t bytes)
358 {
359 	return sof_ops(sdev)->block_write(sdev, blk_type, offset, src, bytes);
360 }
361 
362 /* mailbox IO */
snd_sof_dsp_mailbox_read(struct snd_sof_dev * sdev,u32 offset,void * dest,size_t bytes)363 static inline void snd_sof_dsp_mailbox_read(struct snd_sof_dev *sdev,
364 					    u32 offset, void *dest, size_t bytes)
365 {
366 	if (sof_ops(sdev)->mailbox_read)
367 		sof_ops(sdev)->mailbox_read(sdev, offset, dest, bytes);
368 }
369 
snd_sof_dsp_mailbox_write(struct snd_sof_dev * sdev,u32 offset,void * src,size_t bytes)370 static inline void snd_sof_dsp_mailbox_write(struct snd_sof_dev *sdev,
371 					     u32 offset, void *src, size_t bytes)
372 {
373 	if (sof_ops(sdev)->mailbox_write)
374 		sof_ops(sdev)->mailbox_write(sdev, offset, src, bytes);
375 }
376 
377 /* ipc */
snd_sof_dsp_send_msg(struct snd_sof_dev * sdev,struct snd_sof_ipc_msg * msg)378 static inline int snd_sof_dsp_send_msg(struct snd_sof_dev *sdev,
379 				       struct snd_sof_ipc_msg *msg)
380 {
381 	return sof_ops(sdev)->send_msg(sdev, msg);
382 }
383 
384 /* host PCM ops */
385 static inline int
snd_sof_pcm_platform_open(struct snd_sof_dev * sdev,struct snd_pcm_substream * substream)386 snd_sof_pcm_platform_open(struct snd_sof_dev *sdev,
387 			  struct snd_pcm_substream *substream)
388 {
389 	if (sof_ops(sdev) && sof_ops(sdev)->pcm_open)
390 		return sof_ops(sdev)->pcm_open(sdev, substream);
391 
392 	return 0;
393 }
394 
395 /* disconnect pcm substream to a host stream */
396 static inline int
snd_sof_pcm_platform_close(struct snd_sof_dev * sdev,struct snd_pcm_substream * substream)397 snd_sof_pcm_platform_close(struct snd_sof_dev *sdev,
398 			   struct snd_pcm_substream *substream)
399 {
400 	if (sof_ops(sdev) && sof_ops(sdev)->pcm_close)
401 		return sof_ops(sdev)->pcm_close(sdev, substream);
402 
403 	return 0;
404 }
405 
406 /* host stream hw params */
407 static inline int
snd_sof_pcm_platform_hw_params(struct snd_sof_dev * sdev,struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params,struct snd_sof_platform_stream_params * platform_params)408 snd_sof_pcm_platform_hw_params(struct snd_sof_dev *sdev,
409 			       struct snd_pcm_substream *substream,
410 			       struct snd_pcm_hw_params *params,
411 			       struct snd_sof_platform_stream_params *platform_params)
412 {
413 	if (sof_ops(sdev) && sof_ops(sdev)->pcm_hw_params)
414 		return sof_ops(sdev)->pcm_hw_params(sdev, substream, params,
415 						    platform_params);
416 
417 	return 0;
418 }
419 
420 /* host stream hw free */
421 static inline int
snd_sof_pcm_platform_hw_free(struct snd_sof_dev * sdev,struct snd_pcm_substream * substream)422 snd_sof_pcm_platform_hw_free(struct snd_sof_dev *sdev,
423 			     struct snd_pcm_substream *substream)
424 {
425 	if (sof_ops(sdev) && sof_ops(sdev)->pcm_hw_free)
426 		return sof_ops(sdev)->pcm_hw_free(sdev, substream);
427 
428 	return 0;
429 }
430 
431 /* host stream trigger */
432 static inline int
snd_sof_pcm_platform_trigger(struct snd_sof_dev * sdev,struct snd_pcm_substream * substream,int cmd)433 snd_sof_pcm_platform_trigger(struct snd_sof_dev *sdev,
434 			     struct snd_pcm_substream *substream, int cmd)
435 {
436 	if (sof_ops(sdev) && sof_ops(sdev)->pcm_trigger)
437 		return sof_ops(sdev)->pcm_trigger(sdev, substream, cmd);
438 
439 	return 0;
440 }
441 
442 /* Firmware loading */
snd_sof_load_firmware(struct snd_sof_dev * sdev)443 static inline int snd_sof_load_firmware(struct snd_sof_dev *sdev)
444 {
445 	dev_dbg(sdev->dev, "loading firmware\n");
446 
447 	return sof_ops(sdev)->load_firmware(sdev);
448 }
449 
450 /* host DSP message data */
snd_sof_ipc_msg_data(struct snd_sof_dev * sdev,struct snd_pcm_substream * substream,void * p,size_t sz)451 static inline int snd_sof_ipc_msg_data(struct snd_sof_dev *sdev,
452 				       struct snd_pcm_substream *substream,
453 				       void *p, size_t sz)
454 {
455 	return sof_ops(sdev)->ipc_msg_data(sdev, substream, p, sz);
456 }
457 /* host side configuration of the stream's data offset in stream mailbox area */
458 static inline int
snd_sof_set_stream_data_offset(struct snd_sof_dev * sdev,struct snd_pcm_substream * substream,size_t posn_offset)459 snd_sof_set_stream_data_offset(struct snd_sof_dev *sdev,
460 			       struct snd_pcm_substream *substream,
461 			       size_t posn_offset)
462 {
463 	if (sof_ops(sdev) && sof_ops(sdev)->set_stream_data_offset)
464 		return sof_ops(sdev)->set_stream_data_offset(sdev, substream,
465 							     posn_offset);
466 
467 	return 0;
468 }
469 
470 /* host stream pointer */
471 static inline snd_pcm_uframes_t
snd_sof_pcm_platform_pointer(struct snd_sof_dev * sdev,struct snd_pcm_substream * substream)472 snd_sof_pcm_platform_pointer(struct snd_sof_dev *sdev,
473 			     struct snd_pcm_substream *substream)
474 {
475 	if (sof_ops(sdev) && sof_ops(sdev)->pcm_pointer)
476 		return sof_ops(sdev)->pcm_pointer(sdev, substream);
477 
478 	return 0;
479 }
480 
481 /* pcm ack */
snd_sof_pcm_platform_ack(struct snd_sof_dev * sdev,struct snd_pcm_substream * substream)482 static inline int snd_sof_pcm_platform_ack(struct snd_sof_dev *sdev,
483 					   struct snd_pcm_substream *substream)
484 {
485 	if (sof_ops(sdev) && sof_ops(sdev)->pcm_ack)
486 		return sof_ops(sdev)->pcm_ack(sdev, substream);
487 
488 	return 0;
489 }
490 
491 /* machine driver */
492 static inline int
snd_sof_machine_register(struct snd_sof_dev * sdev,void * pdata)493 snd_sof_machine_register(struct snd_sof_dev *sdev, void *pdata)
494 {
495 	if (sof_ops(sdev) && sof_ops(sdev)->machine_register)
496 		return sof_ops(sdev)->machine_register(sdev, pdata);
497 
498 	return 0;
499 }
500 
501 static inline void
snd_sof_machine_unregister(struct snd_sof_dev * sdev,void * pdata)502 snd_sof_machine_unregister(struct snd_sof_dev *sdev, void *pdata)
503 {
504 	if (sof_ops(sdev) && sof_ops(sdev)->machine_unregister)
505 		sof_ops(sdev)->machine_unregister(sdev, pdata);
506 }
507 
508 static inline struct snd_soc_acpi_mach *
snd_sof_machine_select(struct snd_sof_dev * sdev)509 snd_sof_machine_select(struct snd_sof_dev *sdev)
510 {
511 	if (sof_ops(sdev) && sof_ops(sdev)->machine_select)
512 		return sof_ops(sdev)->machine_select(sdev);
513 
514 	return NULL;
515 }
516 
517 static inline void
snd_sof_set_mach_params(struct snd_soc_acpi_mach * mach,struct snd_sof_dev * sdev)518 snd_sof_set_mach_params(struct snd_soc_acpi_mach *mach,
519 			struct snd_sof_dev *sdev)
520 {
521 	if (sof_ops(sdev) && sof_ops(sdev)->set_mach_params)
522 		sof_ops(sdev)->set_mach_params(mach, sdev);
523 }
524 
525 /**
526  * snd_sof_dsp_register_poll_timeout - Periodically poll an address
527  * until a condition is met or a timeout occurs
528  * @op: accessor function (takes @addr as its only argument)
529  * @addr: Address to poll
530  * @val: Variable to read the value into
531  * @cond: Break condition (usually involving @val)
532  * @sleep_us: Maximum time to sleep between reads in us (0
533  *            tight-loops).  Should be less than ~20ms since usleep_range
534  *            is used (see Documentation/timers/timers-howto.rst).
535  * @timeout_us: Timeout in us, 0 means never timeout
536  *
537  * Returns 0 on success and -ETIMEDOUT upon a timeout. In either
538  * case, the last read value at @addr is stored in @val. Must not
539  * be called from atomic context if sleep_us or timeout_us are used.
540  *
541  * This is modelled after the readx_poll_timeout macros in linux/iopoll.h.
542  */
543 #define snd_sof_dsp_read_poll_timeout(sdev, bar, offset, val, cond, sleep_us, timeout_us) \
544 ({ \
545 	u64 __timeout_us = (timeout_us); \
546 	unsigned long __sleep_us = (sleep_us); \
547 	ktime_t __timeout = ktime_add_us(ktime_get(), __timeout_us); \
548 	might_sleep_if((__sleep_us) != 0); \
549 	for (;;) {							\
550 		(val) = snd_sof_dsp_read(sdev, bar, offset);		\
551 		if (cond) { \
552 			dev_dbg(sdev->dev, \
553 				"FW Poll Status: reg[%#x]=%#x successful\n", \
554 				(offset), (val)); \
555 			break; \
556 		} \
557 		if (__timeout_us && \
558 		    ktime_compare(ktime_get(), __timeout) > 0) { \
559 			(val) = snd_sof_dsp_read(sdev, bar, offset); \
560 			dev_dbg(sdev->dev, \
561 				"FW Poll Status: reg[%#x]=%#x timedout\n", \
562 				(offset), (val)); \
563 			break; \
564 		} \
565 		if (__sleep_us) \
566 			usleep_range((__sleep_us >> 2) + 1, __sleep_us); \
567 	} \
568 	(cond) ? 0 : -ETIMEDOUT; \
569 })
570 
571 /* This is for registers bits with attribute RWC */
572 bool snd_sof_pci_update_bits(struct snd_sof_dev *sdev, u32 offset,
573 			     u32 mask, u32 value);
574 
575 bool snd_sof_dsp_update_bits_unlocked(struct snd_sof_dev *sdev, u32 bar,
576 				      u32 offset, u32 mask, u32 value);
577 
578 bool snd_sof_dsp_update_bits64_unlocked(struct snd_sof_dev *sdev, u32 bar,
579 					u32 offset, u64 mask, u64 value);
580 
581 bool snd_sof_dsp_update_bits(struct snd_sof_dev *sdev, u32 bar, u32 offset,
582 			     u32 mask, u32 value);
583 
584 bool snd_sof_dsp_update_bits64(struct snd_sof_dev *sdev, u32 bar,
585 			       u32 offset, u64 mask, u64 value);
586 
587 void snd_sof_dsp_update_bits_forced(struct snd_sof_dev *sdev, u32 bar,
588 				    u32 offset, u32 mask, u32 value);
589 
590 int snd_sof_dsp_register_poll(struct snd_sof_dev *sdev, u32 bar, u32 offset,
591 			      u32 mask, u32 target, u32 timeout_ms,
592 			      u32 interval_us);
593 
594 void snd_sof_dsp_panic(struct snd_sof_dev *sdev, u32 offset, bool non_recoverable);
595 #endif
596