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_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
 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
 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
 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 */
 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
 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 */
 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
 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 */
 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
 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
 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
 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
 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
 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 */
 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 */
 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
 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
 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 */
 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
 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
 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 *
 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
 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