sound/soc/sof/ops.h

   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 mask, u8 value)
 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_sof_pcm_stream *sps,
 476                                        void *p, size_t sz)
 477 {
 478         return sof_ops(sdev)->ipc_msg_data(sdev, sps, 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_sof_pcm_stream *sps,
 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, sps,
 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 static inline u64 snd_sof_pcm_get_stream_position(struct snd_sof_dev *sdev,
 515                                                   struct snd_soc_component *component,
 516                                                   struct snd_pcm_substream *substream)
 517 {
 518         if (sof_ops(sdev) && sof_ops(sdev)->get_stream_position)
 519                 return sof_ops(sdev)->get_stream_position(sdev, component, substream);
 520
 521         return 0;
 522 }
 523
 524 /* machine driver */
 525 static inline int
 526 snd_sof_machine_register(struct snd_sof_dev *sdev, void *pdata)
 527 {
 528         if (sof_ops(sdev) && sof_ops(sdev)->machine_register)
 529                 return sof_ops(sdev)->machine_register(sdev, pdata);
 530
 531         return 0;
 532 }
 533
 534 static inline void
 535 snd_sof_machine_unregister(struct snd_sof_dev *sdev, void *pdata)
 536 {
 537         if (sof_ops(sdev) && sof_ops(sdev)->machine_unregister)
 538                 sof_ops(sdev)->machine_unregister(sdev, pdata);
 539 }
 540
 541 static inline struct snd_soc_acpi_mach *
 542 snd_sof_machine_select(struct snd_sof_dev *sdev)
 543 {
 544         if (sof_ops(sdev) && sof_ops(sdev)->machine_select)
 545                 return sof_ops(sdev)->machine_select(sdev);
 546
 547         return NULL;
 548 }
 549
 550 static inline void
 551 snd_sof_set_mach_params(struct snd_soc_acpi_mach *mach,
 552                         struct snd_sof_dev *sdev)
 553 {
 554         if (sof_ops(sdev) && sof_ops(sdev)->set_mach_params)
 555                 sof_ops(sdev)->set_mach_params(mach, sdev);
 556 }
 557
 558 /**
 559  * snd_sof_dsp_register_poll_timeout - Periodically poll an address
 560  * until a condition is met or a timeout occurs
 561  * @op: accessor function (takes @addr as its only argument)
 562  * @addr: Address to poll
 563  * @val: Variable to read the value into
 564  * @cond: Break condition (usually involving @val)
 565  * @sleep_us: Maximum time to sleep between reads in us (0
 566  *            tight-loops).  Should be less than ~20ms since usleep_range
 567  *            is used (see Documentation/timers/timers-howto.rst).
 568  * @timeout_us: Timeout in us, 0 means never timeout
 569  *
 570  * Returns 0 on success and -ETIMEDOUT upon a timeout. In either
 571  * case, the last read value at @addr is stored in @val. Must not
 572  * be called from atomic context if sleep_us or timeout_us are used.
 573  *
 574  * This is modelled after the readx_poll_timeout macros in linux/iopoll.h.
 575  */
 576 #define snd_sof_dsp_read_poll_timeout(sdev, bar, offset, val, cond, sleep_us, timeout_us) \
 577 ({ \
 578         u64 __timeout_us = (timeout_us); \
 579         unsigned long __sleep_us = (sleep_us); \
 580         ktime_t __timeout = ktime_add_us(ktime_get(), __timeout_us); \
 581         might_sleep_if((__sleep_us) != 0); \
 582         for (;;) {                                                      \
 583                 (val) = snd_sof_dsp_read(sdev, bar, offset);            \
 584                 if (cond) { \
 585                         dev_dbg(sdev->dev, \
 586                                 "FW Poll Status: reg[%#x]=%#x successful\n", \
 587                                 (offset), (val)); \
 588                         break; \
 589                 } \
 590                 if (__timeout_us && \
 591                     ktime_compare(ktime_get(), __timeout) > 0) { \
 592                         (val) = snd_sof_dsp_read(sdev, bar, offset); \
 593                         dev_dbg(sdev->dev, \
 594                                 "FW Poll Status: reg[%#x]=%#x timedout\n", \
 595                                 (offset), (val)); \
 596                         break; \
 597                 } \
 598                 if (__sleep_us) \
 599                         usleep_range((__sleep_us >> 2) + 1, __sleep_us); \
 600         } \
 601         (cond) ? 0 : -ETIMEDOUT; \
 602 })
 603
 604 /* This is for registers bits with attribute RWC */
 605 bool snd_sof_pci_update_bits(struct snd_sof_dev *sdev, u32 offset,
 606                              u32 mask, u32 value);
 607
 608 bool snd_sof_dsp_update_bits_unlocked(struct snd_sof_dev *sdev, u32 bar,
 609                                       u32 offset, u32 mask, u32 value);
 610
 611 bool snd_sof_dsp_update_bits64_unlocked(struct snd_sof_dev *sdev, u32 bar,
 612                                         u32 offset, u64 mask, u64 value);
 613
 614 bool snd_sof_dsp_update_bits(struct snd_sof_dev *sdev, u32 bar, u32 offset,
 615                              u32 mask, u32 value);
 616
 617 bool snd_sof_dsp_update_bits64(struct snd_sof_dev *sdev, u32 bar,
 618                                u32 offset, u64 mask, u64 value);
 619
 620 void snd_sof_dsp_update_bits_forced(struct snd_sof_dev *sdev, u32 bar,
 621                                     u32 offset, u32 mask, u32 value);
 622
 623 int snd_sof_dsp_register_poll(struct snd_sof_dev *sdev, u32 bar, u32 offset,
 624                               u32 mask, u32 target, u32 timeout_ms,
 625                               u32 interval_us);
 626
 627 void snd_sof_dsp_panic(struct snd_sof_dev *sdev, u32 offset, bool non_recoverable);
 628 #endif