sound/soc/sof/ops.h

   1 /* SPDX-License-Identifier: (GPL-2.0 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 {
 151         if (sof_ops(sdev)->suspend)
 152                 return sof_ops(sdev)->suspend(sdev);
 153
 154         return 0;
 155 }
 156
 157 static inline int snd_sof_dsp_runtime_resume(struct snd_sof_dev *sdev)
 158 {
 159         if (sof_ops(sdev)->runtime_resume)
 160                 return sof_ops(sdev)->runtime_resume(sdev);
 161
 162         return 0;
 163 }
 164
 165 static inline int snd_sof_dsp_runtime_suspend(struct snd_sof_dev *sdev)
 166 {
 167         if (sof_ops(sdev)->runtime_suspend)
 168                 return sof_ops(sdev)->runtime_suspend(sdev);
 169
 170         return 0;
 171 }
 172
 173 static inline int snd_sof_dsp_runtime_idle(struct snd_sof_dev *sdev)
 174 {
 175         if (sof_ops(sdev)->runtime_idle)
 176                 return sof_ops(sdev)->runtime_idle(sdev);
 177
 178         return 0;
 179 }
 180
 181 static inline int snd_sof_dsp_hw_params_upon_resume(struct snd_sof_dev *sdev)
 182 {
 183         if (sof_ops(sdev)->set_hw_params_upon_resume)
 184                 return sof_ops(sdev)->set_hw_params_upon_resume(sdev);
 185         return 0;
 186 }
 187
 188 static inline int snd_sof_dsp_set_clk(struct snd_sof_dev *sdev, u32 freq)
 189 {
 190         if (sof_ops(sdev)->set_clk)
 191                 return sof_ops(sdev)->set_clk(sdev, freq);
 192
 193         return 0;
 194 }
 195
 196 static inline int snd_sof_dsp_set_power_state(struct snd_sof_dev *sdev,
 197                                               enum sof_d0_substate substate)
 198 {
 199         if (sof_ops(sdev)->set_power_state)
 200                 return sof_ops(sdev)->set_power_state(sdev, substate);
 201
 202         /* D0 substate is not supported */
 203         return -ENOTSUPP;
 204 }
 205
 206 /* debug */
 207 static inline void snd_sof_dsp_dbg_dump(struct snd_sof_dev *sdev, u32 flags)
 208 {
 209         if (sof_ops(sdev)->dbg_dump)
 210                 return sof_ops(sdev)->dbg_dump(sdev, flags);
 211 }
 212
 213 static inline void snd_sof_ipc_dump(struct snd_sof_dev *sdev)
 214 {
 215         if (sof_ops(sdev)->ipc_dump)
 216                 return sof_ops(sdev)->ipc_dump(sdev);
 217 }
 218
 219 /* register IO */
 220 static inline void snd_sof_dsp_write(struct snd_sof_dev *sdev, u32 bar,
 221                                      u32 offset, u32 value)
 222 {
 223         if (sof_ops(sdev)->write) {
 224                 sof_ops(sdev)->write(sdev, sdev->bar[bar] + offset, value);
 225                 return;
 226         }
 227
 228         dev_err_ratelimited(sdev->dev, "error: %s not defined\n", __func__);
 229 }
 230
 231 static inline void snd_sof_dsp_write64(struct snd_sof_dev *sdev, u32 bar,
 232                                        u32 offset, u64 value)
 233 {
 234         if (sof_ops(sdev)->write64) {
 235                 sof_ops(sdev)->write64(sdev, sdev->bar[bar] + offset, value);
 236                 return;
 237         }
 238
 239         dev_err_ratelimited(sdev->dev, "error: %s not defined\n", __func__);
 240 }
 241
 242 static inline u32 snd_sof_dsp_read(struct snd_sof_dev *sdev, u32 bar,
 243                                    u32 offset)
 244 {
 245         if (sof_ops(sdev)->read)
 246                 return sof_ops(sdev)->read(sdev, sdev->bar[bar] + offset);
 247
 248         dev_err(sdev->dev, "error: %s not defined\n", __func__);
 249         return -ENOTSUPP;
 250 }
 251
 252 static inline u64 snd_sof_dsp_read64(struct snd_sof_dev *sdev, u32 bar,
 253                                      u32 offset)
 254 {
 255         if (sof_ops(sdev)->read64)
 256                 return sof_ops(sdev)->read64(sdev, sdev->bar[bar] + offset);
 257
 258         dev_err(sdev->dev, "error: %s not defined\n", __func__);
 259         return -ENOTSUPP;
 260 }
 261
 262 /* block IO */
 263 static inline void snd_sof_dsp_block_read(struct snd_sof_dev *sdev, u32 bar,
 264                                           u32 offset, void *dest, size_t bytes)
 265 {
 266         sof_ops(sdev)->block_read(sdev, bar, offset, dest, bytes);
 267 }
 268
 269 static inline void snd_sof_dsp_block_write(struct snd_sof_dev *sdev, u32 bar,
 270                                            u32 offset, void *src, size_t bytes)
 271 {
 272         sof_ops(sdev)->block_write(sdev, bar, offset, src, bytes);
 273 }
 274
 275 /* ipc */
 276 static inline int snd_sof_dsp_send_msg(struct snd_sof_dev *sdev,
 277                                        struct snd_sof_ipc_msg *msg)
 278 {
 279         return sof_ops(sdev)->send_msg(sdev, msg);
 280 }
 281
 282 /* host DMA trace */
 283 static inline int snd_sof_dma_trace_init(struct snd_sof_dev *sdev,
 284                                          u32 *stream_tag)
 285 {
 286         if (sof_ops(sdev)->trace_init)
 287                 return sof_ops(sdev)->trace_init(sdev, stream_tag);
 288
 289         return 0;
 290 }
 291
 292 static inline int snd_sof_dma_trace_release(struct snd_sof_dev *sdev)
 293 {
 294         if (sof_ops(sdev)->trace_release)
 295                 return sof_ops(sdev)->trace_release(sdev);
 296
 297         return 0;
 298 }
 299
 300 static inline int snd_sof_dma_trace_trigger(struct snd_sof_dev *sdev, int cmd)
 301 {
 302         if (sof_ops(sdev)->trace_trigger)
 303                 return sof_ops(sdev)->trace_trigger(sdev, cmd);
 304
 305         return 0;
 306 }
 307
 308 /* host PCM ops */
 309 static inline int
 310 snd_sof_pcm_platform_open(struct snd_sof_dev *sdev,
 311                           struct snd_pcm_substream *substream)
 312 {
 313         if (sof_ops(sdev) && sof_ops(sdev)->pcm_open)
 314                 return sof_ops(sdev)->pcm_open(sdev, substream);
 315
 316         return 0;
 317 }
 318
 319 /* disconnect pcm substream to a host stream */
 320 static inline int
 321 snd_sof_pcm_platform_close(struct snd_sof_dev *sdev,
 322                            struct snd_pcm_substream *substream)
 323 {
 324         if (sof_ops(sdev) && sof_ops(sdev)->pcm_close)
 325                 return sof_ops(sdev)->pcm_close(sdev, substream);
 326
 327         return 0;
 328 }
 329
 330 /* host stream hw params */
 331 static inline int
 332 snd_sof_pcm_platform_hw_params(struct snd_sof_dev *sdev,
 333                                struct snd_pcm_substream *substream,
 334                                struct snd_pcm_hw_params *params,
 335                                struct sof_ipc_stream_params *ipc_params)
 336 {
 337         if (sof_ops(sdev) && sof_ops(sdev)->pcm_hw_params)
 338                 return sof_ops(sdev)->pcm_hw_params(sdev, substream,
 339                                                     params, ipc_params);
 340
 341         return 0;
 342 }
 343
 344 /* host stream hw free */
 345 static inline int
 346 snd_sof_pcm_platform_hw_free(struct snd_sof_dev *sdev,
 347                              struct snd_pcm_substream *substream)
 348 {
 349         if (sof_ops(sdev) && sof_ops(sdev)->pcm_hw_free)
 350                 return sof_ops(sdev)->pcm_hw_free(sdev, substream);
 351
 352         return 0;
 353 }
 354
 355 /* host stream trigger */
 356 static inline int
 357 snd_sof_pcm_platform_trigger(struct snd_sof_dev *sdev,
 358                              struct snd_pcm_substream *substream, int cmd)
 359 {
 360         if (sof_ops(sdev) && sof_ops(sdev)->pcm_trigger)
 361                 return sof_ops(sdev)->pcm_trigger(sdev, substream, cmd);
 362
 363         return 0;
 364 }
 365
 366 /* host DSP message data */
 367 static inline void snd_sof_ipc_msg_data(struct snd_sof_dev *sdev,
 368                                         struct snd_pcm_substream *substream,
 369                                         void *p, size_t sz)
 370 {
 371         sof_ops(sdev)->ipc_msg_data(sdev, substream, p, sz);
 372 }
 373
 374 /* host configure DSP HW parameters */
 375 static inline int
 376 snd_sof_ipc_pcm_params(struct snd_sof_dev *sdev,
 377                        struct snd_pcm_substream *substream,
 378                        const struct sof_ipc_pcm_params_reply *reply)
 379 {
 380         return sof_ops(sdev)->ipc_pcm_params(sdev, substream, reply);
 381 }
 382
 383 /* host stream pointer */
 384 static inline snd_pcm_uframes_t
 385 snd_sof_pcm_platform_pointer(struct snd_sof_dev *sdev,
 386                              struct snd_pcm_substream *substream)
 387 {
 388         if (sof_ops(sdev) && sof_ops(sdev)->pcm_pointer)
 389                 return sof_ops(sdev)->pcm_pointer(sdev, substream);
 390
 391         return 0;
 392 }
 393
 394 /* machine driver */
 395 static inline int
 396 snd_sof_machine_register(struct snd_sof_dev *sdev, void *pdata)
 397 {
 398         if (sof_ops(sdev) && sof_ops(sdev)->machine_register)
 399                 return sof_ops(sdev)->machine_register(sdev, pdata);
 400
 401         return 0;
 402 }
 403
 404 static inline void
 405 snd_sof_machine_unregister(struct snd_sof_dev *sdev, void *pdata)
 406 {
 407         if (sof_ops(sdev) && sof_ops(sdev)->machine_unregister)
 408                 sof_ops(sdev)->machine_unregister(sdev, pdata);
 409 }
 410
 411 static inline void
 412 snd_sof_machine_select(struct snd_sof_dev *sdev)
 413 {
 414         if (sof_ops(sdev) && sof_ops(sdev)->machine_select)
 415                 sof_ops(sdev)->machine_select(sdev);
 416 }
 417
 418 static inline void
 419 snd_sof_set_mach_params(const struct snd_soc_acpi_mach *mach,
 420                         struct device *dev)
 421 {
 422         struct snd_sof_dev *sdev = dev_get_drvdata(dev);
 423
 424         if (sof_ops(sdev) && sof_ops(sdev)->set_mach_params)
 425                 sof_ops(sdev)->set_mach_params(mach, dev);
 426 }
 427
 428 static inline const struct snd_sof_dsp_ops
 429 *sof_get_ops(const struct sof_dev_desc *d,
 430              const struct sof_ops_table mach_ops[], int asize)
 431 {
 432         int i;
 433
 434         for (i = 0; i < asize; i++) {
 435                 if (d == mach_ops[i].desc)
 436                         return mach_ops[i].ops;
 437         }
 438
 439         /* not found */
 440         return NULL;
 441 }
 442
 443 /**
 444  * snd_sof_dsp_register_poll_timeout - Periodically poll an address
 445  * until a condition is met or a timeout occurs
 446  * @op: accessor function (takes @addr as its only argument)
 447  * @addr: Address to poll
 448  * @val: Variable to read the value into
 449  * @cond: Break condition (usually involving @val)
 450  * @sleep_us: Maximum time to sleep between reads in us (0
 451  *            tight-loops).  Should be less than ~20ms since usleep_range
 452  *            is used (see Documentation/timers/timers-howto.rst).
 453  * @timeout_us: Timeout in us, 0 means never timeout
 454  *
 455  * Returns 0 on success and -ETIMEDOUT upon a timeout. In either
 456  * case, the last read value at @addr is stored in @val. Must not
 457  * be called from atomic context if sleep_us or timeout_us are used.
 458  *
 459  * This is modelled after the readx_poll_timeout macros in linux/iopoll.h.
 460  */
 461 #define snd_sof_dsp_read_poll_timeout(sdev, bar, offset, val, cond, sleep_us, timeout_us) \
 462 ({ \
 463         u64 __timeout_us = (timeout_us); \
 464         unsigned long __sleep_us = (sleep_us); \
 465         ktime_t __timeout = ktime_add_us(ktime_get(), __timeout_us); \
 466         might_sleep_if((__sleep_us) != 0); \
 467         for (;;) {                                                      \
 468                 (val) = snd_sof_dsp_read(sdev, bar, offset);            \
 469                 if (cond) { \
 470                         dev_dbg(sdev->dev, \
 471                                 "FW Poll Status: reg=%#x successful\n", (val)); \
 472                         break; \
 473                 } \
 474                 if (__timeout_us && \
 475                     ktime_compare(ktime_get(), __timeout) > 0) { \
 476                         (val) = snd_sof_dsp_read(sdev, bar, offset); \
 477                         dev_dbg(sdev->dev, \
 478                                 "FW Poll Status: reg=%#x timedout\n", (val)); \
 479                         break; \
 480                 } \
 481                 if (__sleep_us) \
 482                         usleep_range((__sleep_us >> 2) + 1, __sleep_us); \
 483         } \
 484         (cond) ? 0 : -ETIMEDOUT; \
 485 })
 486
 487 /* This is for registers bits with attribute RWC */
 488 bool snd_sof_pci_update_bits(struct snd_sof_dev *sdev, u32 offset,
 489                              u32 mask, u32 value);
 490
 491 bool snd_sof_dsp_update_bits_unlocked(struct snd_sof_dev *sdev, u32 bar,
 492                                       u32 offset, u32 mask, u32 value);
 493
 494 bool snd_sof_dsp_update_bits64_unlocked(struct snd_sof_dev *sdev, u32 bar,
 495                                         u32 offset, u64 mask, u64 value);
 496
 497 bool snd_sof_dsp_update_bits(struct snd_sof_dev *sdev, u32 bar, u32 offset,
 498                              u32 mask, u32 value);
 499
 500 bool snd_sof_dsp_update_bits64(struct snd_sof_dev *sdev, u32 bar,
 501                                u32 offset, u64 mask, u64 value);
 502
 503 void snd_sof_dsp_update_bits_forced(struct snd_sof_dev *sdev, u32 bar,
 504                                     u32 offset, u32 mask, u32 value);
 505
 506 int snd_sof_dsp_register_poll(struct snd_sof_dev *sdev, u32 bar, u32 offset,
 507                               u32 mask, u32 target, u32 timeout_ms,
 508                               u32 interval_us);
 509
 510 void snd_sof_dsp_panic(struct snd_sof_dev *sdev, u32 offset);
 511 #endif