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 /* Mandatory operations are verified during probing */
  25
  26 /* init */
  27 static inline int snd_sof_probe(struct snd_sof_dev *sdev)
  28 {
  29         return sof_ops(sdev)->probe(sdev);
  30 }
  31
  32 static inline int snd_sof_remove(struct snd_sof_dev *sdev)
  33 {
  34         if (sof_ops(sdev)->remove)
  35                 return sof_ops(sdev)->remove(sdev);
  36
  37         return 0;
  38 }
  39
  40 /* control */
  41
  42 /*
  43  * snd_sof_dsp_run returns the core mask of the cores that are available
  44  * after successful fw boot
  45  */
  46 static inline int snd_sof_dsp_run(struct snd_sof_dev *sdev)
  47 {
  48         return sof_ops(sdev)->run(sdev);
  49 }
  50
  51 static inline int snd_sof_dsp_stall(struct snd_sof_dev *sdev)
  52 {
  53         if (sof_ops(sdev)->stall)
  54                 return sof_ops(sdev)->stall(sdev);
  55
  56         return 0;
  57 }
  58
  59 static inline int snd_sof_dsp_reset(struct snd_sof_dev *sdev)
  60 {
  61         if (sof_ops(sdev)->reset)
  62                 return sof_ops(sdev)->reset(sdev);
  63
  64         return 0;
  65 }
  66
  67 /* dsp core power up/power down */
  68 static inline int snd_sof_dsp_core_power_up(struct snd_sof_dev *sdev,
  69                                             unsigned int core_mask)
  70 {
  71         if (sof_ops(sdev)->core_power_up)
  72                 return sof_ops(sdev)->core_power_up(sdev, core_mask);
  73
  74         return 0;
  75 }
  76
  77 static inline int snd_sof_dsp_core_power_down(struct snd_sof_dev *sdev,
  78                                               unsigned int core_mask)
  79 {
  80         if (sof_ops(sdev)->core_power_down)
  81                 return sof_ops(sdev)->core_power_down(sdev, core_mask);
  82
  83         return 0;
  84 }
  85
  86 /* pre/post fw load */
  87 static inline int snd_sof_dsp_pre_fw_run(struct snd_sof_dev *sdev)
  88 {
  89         if (sof_ops(sdev)->pre_fw_run)
  90                 return sof_ops(sdev)->pre_fw_run(sdev);
  91
  92         return 0;
  93 }
  94
  95 static inline int snd_sof_dsp_post_fw_run(struct snd_sof_dev *sdev)
  96 {
  97         if (sof_ops(sdev)->post_fw_run)
  98                 return sof_ops(sdev)->post_fw_run(sdev);
  99
 100         return 0;
 101 }
 102
 103 /* misc */
 104
 105 /**
 106  * snd_sof_dsp_get_bar_index - Maps a section type with a BAR index
 107  *
 108  * @sdev: sof device
 109  * @type: section type as described by snd_sof_fw_blk_type
 110  *
 111  * Returns the corresponding BAR index (a positive integer) or -EINVAL
 112  * in case there is no mapping
 113  */
 114 static inline int snd_sof_dsp_get_bar_index(struct snd_sof_dev *sdev, u32 type)
 115 {
 116         if (sof_ops(sdev)->get_bar_index)
 117                 return sof_ops(sdev)->get_bar_index(sdev, type);
 118
 119         return sdev->mmio_bar;
 120 }
 121
 122 static inline int snd_sof_dsp_get_mailbox_offset(struct snd_sof_dev *sdev)
 123 {
 124         if (sof_ops(sdev)->get_mailbox_offset)
 125                 return sof_ops(sdev)->get_mailbox_offset(sdev);
 126
 127         dev_err(sdev->dev, "error: %s not defined\n", __func__);
 128         return -ENOTSUPP;
 129 }
 130
 131 static inline int snd_sof_dsp_get_window_offset(struct snd_sof_dev *sdev,
 132                                                 u32 id)
 133 {
 134         if (sof_ops(sdev)->get_window_offset)
 135                 return sof_ops(sdev)->get_window_offset(sdev, id);
 136
 137         dev_err(sdev->dev, "error: %s not defined\n", __func__);
 138         return -ENOTSUPP;
 139 }
 140 /* power management */
 141 static inline int snd_sof_dsp_resume(struct snd_sof_dev *sdev)
 142 {
 143         if (sof_ops(sdev)->resume)
 144                 return sof_ops(sdev)->resume(sdev);
 145
 146         return 0;
 147 }
 148
 149 static inline int snd_sof_dsp_suspend(struct snd_sof_dev *sdev,
 150                                       u32 target_state)
 151 {
 152         if (sof_ops(sdev)->suspend)
 153                 return sof_ops(sdev)->suspend(sdev, target_state);
 154
 155         return 0;
 156 }
 157
 158 static inline int snd_sof_dsp_runtime_resume(struct snd_sof_dev *sdev)
 159 {
 160         if (sof_ops(sdev)->runtime_resume)
 161                 return sof_ops(sdev)->runtime_resume(sdev);
 162
 163         return 0;
 164 }
 165
 166 static inline int snd_sof_dsp_runtime_suspend(struct snd_sof_dev *sdev)
 167 {
 168         if (sof_ops(sdev)->runtime_suspend)
 169                 return sof_ops(sdev)->runtime_suspend(sdev);
 170
 171         return 0;
 172 }
 173
 174 static inline int snd_sof_dsp_runtime_idle(struct snd_sof_dev *sdev)
 175 {
 176         if (sof_ops(sdev)->runtime_idle)
 177                 return sof_ops(sdev)->runtime_idle(sdev);
 178
 179         return 0;
 180 }
 181
 182 static inline int snd_sof_dsp_hw_params_upon_resume(struct snd_sof_dev *sdev)
 183 {
 184         if (sof_ops(sdev)->set_hw_params_upon_resume)
 185                 return sof_ops(sdev)->set_hw_params_upon_resume(sdev);
 186         return 0;
 187 }
 188
 189 static inline int snd_sof_dsp_set_clk(struct snd_sof_dev *sdev, u32 freq)
 190 {
 191         if (sof_ops(sdev)->set_clk)
 192                 return sof_ops(sdev)->set_clk(sdev, freq);
 193
 194         return 0;
 195 }
 196
 197 static inline int
 198 snd_sof_dsp_set_power_state(struct snd_sof_dev *sdev,
 199                             const struct sof_dsp_power_state *target_state)
 200 {
 201         if (sof_ops(sdev)->set_power_state)
 202                 return sof_ops(sdev)->set_power_state(sdev, target_state);
 203
 204         /* D0 substate is not supported, do nothing here. */
 205         return 0;
 206 }
 207
 208 /* debug */
 209 static inline void snd_sof_dsp_dbg_dump(struct snd_sof_dev *sdev, u32 flags)
 210 {
 211         if (sof_ops(sdev)->dbg_dump)
 212                 return sof_ops(sdev)->dbg_dump(sdev, flags);
 213 }
 214
 215 static inline void snd_sof_ipc_dump(struct snd_sof_dev *sdev)
 216 {
 217         if (sof_ops(sdev)->ipc_dump)
 218                 return sof_ops(sdev)->ipc_dump(sdev);
 219 }
 220
 221 /* register IO */
 222 static inline void snd_sof_dsp_write(struct snd_sof_dev *sdev, u32 bar,
 223                                      u32 offset, u32 value)
 224 {
 225         if (sof_ops(sdev)->write) {
 226                 sof_ops(sdev)->write(sdev, sdev->bar[bar] + offset, value);
 227                 return;
 228         }
 229
 230         dev_err_ratelimited(sdev->dev, "error: %s not defined\n", __func__);
 231 }
 232
 233 static inline void snd_sof_dsp_write64(struct snd_sof_dev *sdev, u32 bar,
 234                                        u32 offset, u64 value)
 235 {
 236         if (sof_ops(sdev)->write64) {
 237                 sof_ops(sdev)->write64(sdev, sdev->bar[bar] + offset, value);
 238                 return;
 239         }
 240
 241         dev_err_ratelimited(sdev->dev, "error: %s not defined\n", __func__);
 242 }
 243
 244 static inline u32 snd_sof_dsp_read(struct snd_sof_dev *sdev, u32 bar,
 245                                    u32 offset)
 246 {
 247         if (sof_ops(sdev)->read)
 248                 return sof_ops(sdev)->read(sdev, sdev->bar[bar] + offset);
 249
 250         dev_err(sdev->dev, "error: %s not defined\n", __func__);
 251         return -ENOTSUPP;
 252 }
 253
 254 static inline u64 snd_sof_dsp_read64(struct snd_sof_dev *sdev, u32 bar,
 255                                      u32 offset)
 256 {
 257         if (sof_ops(sdev)->read64)
 258                 return sof_ops(sdev)->read64(sdev, sdev->bar[bar] + offset);
 259
 260         dev_err(sdev->dev, "error: %s not defined\n", __func__);
 261         return -ENOTSUPP;
 262 }
 263
 264 /* block IO */
 265 static inline void snd_sof_dsp_block_read(struct snd_sof_dev *sdev, u32 bar,
 266                                           u32 offset, void *dest, size_t bytes)
 267 {
 268         sof_ops(sdev)->block_read(sdev, bar, offset, dest, bytes);
 269 }
 270
 271 static inline void snd_sof_dsp_block_write(struct snd_sof_dev *sdev, u32 bar,
 272                                            u32 offset, void *src, size_t bytes)
 273 {
 274         sof_ops(sdev)->block_write(sdev, bar, offset, src, bytes);
 275 }
 276
 277 /* ipc */
 278 static inline int snd_sof_dsp_send_msg(struct snd_sof_dev *sdev,
 279                                        struct snd_sof_ipc_msg *msg)
 280 {
 281         return sof_ops(sdev)->send_msg(sdev, msg);
 282 }
 283
 284 /* host DMA trace */
 285 static inline int snd_sof_dma_trace_init(struct snd_sof_dev *sdev,
 286                                          u32 *stream_tag)
 287 {
 288         if (sof_ops(sdev)->trace_init)
 289                 return sof_ops(sdev)->trace_init(sdev, stream_tag);
 290
 291         return 0;
 292 }
 293
 294 static inline int snd_sof_dma_trace_release(struct snd_sof_dev *sdev)
 295 {
 296         if (sof_ops(sdev)->trace_release)
 297                 return sof_ops(sdev)->trace_release(sdev);
 298
 299         return 0;
 300 }
 301
 302 static inline int snd_sof_dma_trace_trigger(struct snd_sof_dev *sdev, int cmd)
 303 {
 304         if (sof_ops(sdev)->trace_trigger)
 305                 return sof_ops(sdev)->trace_trigger(sdev, cmd);
 306
 307         return 0;
 308 }
 309
 310 /* host PCM ops */
 311 static inline int
 312 snd_sof_pcm_platform_open(struct snd_sof_dev *sdev,
 313                           struct snd_pcm_substream *substream)
 314 {
 315         if (sof_ops(sdev) && sof_ops(sdev)->pcm_open)
 316                 return sof_ops(sdev)->pcm_open(sdev, substream);
 317
 318         return 0;
 319 }
 320
 321 /* disconnect pcm substream to a host stream */
 322 static inline int
 323 snd_sof_pcm_platform_close(struct snd_sof_dev *sdev,
 324                            struct snd_pcm_substream *substream)
 325 {
 326         if (sof_ops(sdev) && sof_ops(sdev)->pcm_close)
 327                 return sof_ops(sdev)->pcm_close(sdev, substream);
 328
 329         return 0;
 330 }
 331
 332 /* host stream hw params */
 333 static inline int
 334 snd_sof_pcm_platform_hw_params(struct snd_sof_dev *sdev,
 335                                struct snd_pcm_substream *substream,
 336                                struct snd_pcm_hw_params *params,
 337                                struct sof_ipc_stream_params *ipc_params)
 338 {
 339         if (sof_ops(sdev) && sof_ops(sdev)->pcm_hw_params)
 340                 return sof_ops(sdev)->pcm_hw_params(sdev, substream,
 341                                                     params, ipc_params);
 342
 343         return 0;
 344 }
 345
 346 /* host stream hw free */
 347 static inline int
 348 snd_sof_pcm_platform_hw_free(struct snd_sof_dev *sdev,
 349                              struct snd_pcm_substream *substream)
 350 {
 351         if (sof_ops(sdev) && sof_ops(sdev)->pcm_hw_free)
 352                 return sof_ops(sdev)->pcm_hw_free(sdev, substream);
 353
 354         return 0;
 355 }
 356
 357 /* host stream trigger */
 358 static inline int
 359 snd_sof_pcm_platform_trigger(struct snd_sof_dev *sdev,
 360                              struct snd_pcm_substream *substream, int cmd)
 361 {
 362         if (sof_ops(sdev) && sof_ops(sdev)->pcm_trigger)
 363                 return sof_ops(sdev)->pcm_trigger(sdev, substream, cmd);
 364
 365         return 0;
 366 }
 367
 368 /* host DSP message data */
 369 static inline void snd_sof_ipc_msg_data(struct snd_sof_dev *sdev,
 370                                         struct snd_pcm_substream *substream,
 371                                         void *p, size_t sz)
 372 {
 373         sof_ops(sdev)->ipc_msg_data(sdev, substream, p, sz);
 374 }
 375
 376 /* host configure DSP HW parameters */
 377 static inline int
 378 snd_sof_ipc_pcm_params(struct snd_sof_dev *sdev,
 379                        struct snd_pcm_substream *substream,
 380                        const struct sof_ipc_pcm_params_reply *reply)
 381 {
 382         return sof_ops(sdev)->ipc_pcm_params(sdev, substream, reply);
 383 }
 384
 385 /* host stream pointer */
 386 static inline snd_pcm_uframes_t
 387 snd_sof_pcm_platform_pointer(struct snd_sof_dev *sdev,
 388                              struct snd_pcm_substream *substream)
 389 {
 390         if (sof_ops(sdev) && sof_ops(sdev)->pcm_pointer)
 391                 return sof_ops(sdev)->pcm_pointer(sdev, substream);
 392
 393         return 0;
 394 }
 395
 396 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_PROBES)
 397 static inline int
 398 snd_sof_probe_compr_assign(struct snd_sof_dev *sdev,
 399                 struct snd_compr_stream *cstream, struct snd_soc_dai *dai)
 400 {
 401         return sof_ops(sdev)->probe_assign(sdev, cstream, dai);
 402 }
 403
 404 static inline int
 405 snd_sof_probe_compr_free(struct snd_sof_dev *sdev,
 406                 struct snd_compr_stream *cstream, struct snd_soc_dai *dai)
 407 {
 408         return sof_ops(sdev)->probe_free(sdev, cstream, dai);
 409 }
 410
 411 static inline int
 412 snd_sof_probe_compr_set_params(struct snd_sof_dev *sdev,
 413                 struct snd_compr_stream *cstream,
 414                 struct snd_compr_params *params, struct snd_soc_dai *dai)
 415 {
 416         return sof_ops(sdev)->probe_set_params(sdev, cstream, params, dai);
 417 }
 418
 419 static inline int
 420 snd_sof_probe_compr_trigger(struct snd_sof_dev *sdev,
 421                 struct snd_compr_stream *cstream, int cmd,
 422                 struct snd_soc_dai *dai)
 423 {
 424         return sof_ops(sdev)->probe_trigger(sdev, cstream, cmd, dai);
 425 }
 426
 427 static inline int
 428 snd_sof_probe_compr_pointer(struct snd_sof_dev *sdev,
 429                 struct snd_compr_stream *cstream,
 430                 struct snd_compr_tstamp *tstamp, struct snd_soc_dai *dai)
 431 {
 432         if (sof_ops(sdev) && sof_ops(sdev)->probe_pointer)
 433                 return sof_ops(sdev)->probe_pointer(sdev, cstream, tstamp, dai);
 434
 435         return 0;
 436 }
 437 #endif
 438
 439 /* machine driver */
 440 static inline int
 441 snd_sof_machine_register(struct snd_sof_dev *sdev, void *pdata)
 442 {
 443         if (sof_ops(sdev) && sof_ops(sdev)->machine_register)
 444                 return sof_ops(sdev)->machine_register(sdev, pdata);
 445
 446         return 0;
 447 }
 448
 449 static inline void
 450 snd_sof_machine_unregister(struct snd_sof_dev *sdev, void *pdata)
 451 {
 452         if (sof_ops(sdev) && sof_ops(sdev)->machine_unregister)
 453                 sof_ops(sdev)->machine_unregister(sdev, pdata);
 454 }
 455
 456 static inline void
 457 snd_sof_machine_select(struct snd_sof_dev *sdev)
 458 {
 459         if (sof_ops(sdev) && sof_ops(sdev)->machine_select)
 460                 sof_ops(sdev)->machine_select(sdev);
 461 }
 462
 463 static inline void
 464 snd_sof_set_mach_params(const struct snd_soc_acpi_mach *mach,
 465                         struct device *dev)
 466 {
 467         struct snd_sof_dev *sdev = dev_get_drvdata(dev);
 468
 469         if (sof_ops(sdev) && sof_ops(sdev)->set_mach_params)
 470                 sof_ops(sdev)->set_mach_params(mach, dev);
 471 }
 472
 473 static inline const struct snd_sof_dsp_ops
 474 *sof_get_ops(const struct sof_dev_desc *d,
 475              const struct sof_ops_table mach_ops[], int asize)
 476 {
 477         int i;
 478
 479         for (i = 0; i < asize; i++) {
 480                 if (d == mach_ops[i].desc)
 481                         return mach_ops[i].ops;
 482         }
 483
 484         /* not found */
 485         return NULL;
 486 }
 487
 488 /**
 489  * snd_sof_dsp_register_poll_timeout - Periodically poll an address
 490  * until a condition is met or a timeout occurs
 491  * @op: accessor function (takes @addr as its only argument)
 492  * @addr: Address to poll
 493  * @val: Variable to read the value into
 494  * @cond: Break condition (usually involving @val)
 495  * @sleep_us: Maximum time to sleep between reads in us (0
 496  *            tight-loops).  Should be less than ~20ms since usleep_range
 497  *            is used (see Documentation/timers/timers-howto.rst).
 498  * @timeout_us: Timeout in us, 0 means never timeout
 499  *
 500  * Returns 0 on success and -ETIMEDOUT upon a timeout. In either
 501  * case, the last read value at @addr is stored in @val. Must not
 502  * be called from atomic context if sleep_us or timeout_us are used.
 503  *
 504  * This is modelled after the readx_poll_timeout macros in linux/iopoll.h.
 505  */
 506 #define snd_sof_dsp_read_poll_timeout(sdev, bar, offset, val, cond, sleep_us, timeout_us) \
 507 ({ \
 508         u64 __timeout_us = (timeout_us); \
 509         unsigned long __sleep_us = (sleep_us); \
 510         ktime_t __timeout = ktime_add_us(ktime_get(), __timeout_us); \
 511         might_sleep_if((__sleep_us) != 0); \
 512         for (;;) {                                                      \
 513                 (val) = snd_sof_dsp_read(sdev, bar, offset);            \
 514                 if (cond) { \
 515                         dev_dbg(sdev->dev, \
 516                                 "FW Poll Status: reg=%#x successful\n", (val)); \
 517                         break; \
 518                 } \
 519                 if (__timeout_us && \
 520                     ktime_compare(ktime_get(), __timeout) > 0) { \
 521                         (val) = snd_sof_dsp_read(sdev, bar, offset); \
 522                         dev_dbg(sdev->dev, \
 523                                 "FW Poll Status: reg=%#x timedout\n", (val)); \
 524                         break; \
 525                 } \
 526                 if (__sleep_us) \
 527                         usleep_range((__sleep_us >> 2) + 1, __sleep_us); \
 528         } \
 529         (cond) ? 0 : -ETIMEDOUT; \
 530 })
 531
 532 /* This is for registers bits with attribute RWC */
 533 bool snd_sof_pci_update_bits(struct snd_sof_dev *sdev, u32 offset,
 534                              u32 mask, u32 value);
 535
 536 bool snd_sof_dsp_update_bits_unlocked(struct snd_sof_dev *sdev, u32 bar,
 537                                       u32 offset, u32 mask, u32 value);
 538
 539 bool snd_sof_dsp_update_bits64_unlocked(struct snd_sof_dev *sdev, u32 bar,
 540                                         u32 offset, u64 mask, u64 value);
 541
 542 bool snd_sof_dsp_update_bits(struct snd_sof_dev *sdev, u32 bar, u32 offset,
 543                              u32 mask, u32 value);
 544
 545 bool snd_sof_dsp_update_bits64(struct snd_sof_dev *sdev, u32 bar,
 546                                u32 offset, u64 mask, u64 value);
 547
 548 void snd_sof_dsp_update_bits_forced(struct snd_sof_dev *sdev, u32 bar,
 549                                     u32 offset, u32 mask, u32 value);
 550
 551 int snd_sof_dsp_register_poll(struct snd_sof_dev *sdev, u32 bar, u32 offset,
 552                               u32 mask, u32 target, u32 timeout_ms,
 553                               u32 interval_us);
 554
 555 void snd_sof_dsp_panic(struct snd_sof_dev *sdev, u32 offset);
 556 #endif