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 24static 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 32static 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 */ 41static inline int snd_sof_probe_early(struct snd_sof_dev *sdev) 42{ 43 if (sof_ops(sdev)->probe_early) 44 return sof_ops(sdev)->probe_early(sdev); 45 46 return 0; 47} 48 49static inline int snd_sof_probe(struct snd_sof_dev *sdev) 50{ 51 return sof_ops(sdev)->probe(sdev); 52} 53 54static inline void snd_sof_remove(struct snd_sof_dev *sdev) 55{ 56 if (sof_ops(sdev)->remove) 57 sof_ops(sdev)->remove(sdev); 58} 59 60static inline void snd_sof_remove_late(struct snd_sof_dev *sdev) 61{ 62 if (sof_ops(sdev)->remove_late) 63 sof_ops(sdev)->remove_late(sdev); 64} 65 66static inline int snd_sof_shutdown(struct snd_sof_dev *sdev) 67{ 68 if (sof_ops(sdev)->shutdown) 69 return sof_ops(sdev)->shutdown(sdev); 70 71 return 0; 72} 73 74/* control */ 75 76/* 77 * snd_sof_dsp_run returns the core mask of the cores that are available 78 * after successful fw boot 79 */ 80static inline int snd_sof_dsp_run(struct snd_sof_dev *sdev) 81{ 82 return sof_ops(sdev)->run(sdev); 83} 84 85static inline int snd_sof_dsp_stall(struct snd_sof_dev *sdev, unsigned int core_mask) 86{ 87 if (sof_ops(sdev)->stall) 88 return sof_ops(sdev)->stall(sdev, core_mask); 89 90 return 0; 91} 92 93static inline int snd_sof_dsp_reset(struct snd_sof_dev *sdev) 94{ 95 if (sof_ops(sdev)->reset) 96 return sof_ops(sdev)->reset(sdev); 97 98 return 0; 99} 100 101/* dsp core get/put */ 102static inline int snd_sof_dsp_core_get(struct snd_sof_dev *sdev, int core) 103{ 104 if (core > sdev->num_cores - 1) { 105 dev_err(sdev->dev, "invalid core id: %d for num_cores: %d\n", core, 106 sdev->num_cores); 107 return -EINVAL; 108 } 109 110 if (sof_ops(sdev)->core_get) { 111 int ret; 112 113 /* if current ref_count is > 0, increment it and return */ 114 if (sdev->dsp_core_ref_count[core] > 0) { 115 sdev->dsp_core_ref_count[core]++; 116 return 0; 117 } 118 119 /* power up the core */ 120 ret = sof_ops(sdev)->core_get(sdev, core); 121 if (ret < 0) 122 return ret; 123 124 /* increment ref_count */ 125 sdev->dsp_core_ref_count[core]++; 126 127 /* and update enabled_cores_mask */ 128 sdev->enabled_cores_mask |= BIT(core); 129 130 dev_dbg(sdev->dev, "Core %d powered up\n", core); 131 } 132 133 return 0; 134} 135 136static inline int snd_sof_dsp_core_put(struct snd_sof_dev *sdev, int core) 137{ 138 if (core > sdev->num_cores - 1) { 139 dev_err(sdev->dev, "invalid core id: %d for num_cores: %d\n", core, 140 sdev->num_cores); 141 return -EINVAL; 142 } 143 144 if (sof_ops(sdev)->core_put) { 145 int ret; 146 147 /* decrement ref_count and return if it is > 0 */ 148 if (--(sdev->dsp_core_ref_count[core]) > 0) 149 return 0; 150 151 /* power down the core */ 152 ret = sof_ops(sdev)->core_put(sdev, core); 153 if (ret < 0) 154 return ret; 155 156 /* and update enabled_cores_mask */ 157 sdev->enabled_cores_mask &= ~BIT(core); 158 159 dev_dbg(sdev->dev, "Core %d powered down\n", core); 160 } 161 162 return 0; 163} 164 165/* pre/post fw load */ 166static inline int snd_sof_dsp_pre_fw_run(struct snd_sof_dev *sdev) 167{ 168 if (sof_ops(sdev)->pre_fw_run) 169 return sof_ops(sdev)->pre_fw_run(sdev); 170 171 return 0; 172} 173 174static inline int snd_sof_dsp_post_fw_run(struct snd_sof_dev *sdev) 175{ 176 if (sof_ops(sdev)->post_fw_run) 177 return sof_ops(sdev)->post_fw_run(sdev); 178 179 return 0; 180} 181 182/* parse platform specific extended manifest */ 183static inline int snd_sof_dsp_parse_platform_ext_manifest(struct snd_sof_dev *sdev, 184 const struct sof_ext_man_elem_header *hdr) 185{ 186 if (sof_ops(sdev)->parse_platform_ext_manifest) 187 return sof_ops(sdev)->parse_platform_ext_manifest(sdev, hdr); 188 189 return 0; 190} 191 192/* misc */ 193 194/** 195 * snd_sof_dsp_get_bar_index - Maps a section type with a BAR index 196 * 197 * @sdev: sof device 198 * @type: section type as described by snd_sof_fw_blk_type 199 * 200 * Returns the corresponding BAR index (a positive integer) or -EINVAL 201 * in case there is no mapping 202 */ 203static inline int snd_sof_dsp_get_bar_index(struct snd_sof_dev *sdev, u32 type) 204{ 205 if (sof_ops(sdev)->get_bar_index) 206 return sof_ops(sdev)->get_bar_index(sdev, type); 207 208 return sdev->mmio_bar; 209} 210 211static inline int snd_sof_dsp_get_mailbox_offset(struct snd_sof_dev *sdev) 212{ 213 if (sof_ops(sdev)->get_mailbox_offset) 214 return sof_ops(sdev)->get_mailbox_offset(sdev); 215 216 dev_err(sdev->dev, "error: %s not defined\n", __func__); 217 return -EOPNOTSUPP; 218} 219 220static inline int snd_sof_dsp_get_window_offset(struct snd_sof_dev *sdev, 221 u32 id) 222{ 223 if (sof_ops(sdev)->get_window_offset) 224 return sof_ops(sdev)->get_window_offset(sdev, id); 225 226 dev_err(sdev->dev, "error: %s not defined\n", __func__); 227 return -EOPNOTSUPP; 228} 229/* power management */ 230static inline int snd_sof_dsp_resume(struct snd_sof_dev *sdev) 231{ 232 if (sof_ops(sdev)->resume) 233 return sof_ops(sdev)->resume(sdev); 234 235 return 0; 236} 237 238static inline int snd_sof_dsp_suspend(struct snd_sof_dev *sdev, 239 u32 target_state) 240{ 241 if (sof_ops(sdev)->suspend) 242 return sof_ops(sdev)->suspend(sdev, target_state); 243 244 return 0; 245} 246 247static inline int snd_sof_dsp_runtime_resume(struct snd_sof_dev *sdev) 248{ 249 if (sof_ops(sdev)->runtime_resume) 250 return sof_ops(sdev)->runtime_resume(sdev); 251 252 return 0; 253} 254 255static inline int snd_sof_dsp_runtime_suspend(struct snd_sof_dev *sdev) 256{ 257 if (sof_ops(sdev)->runtime_suspend) 258 return sof_ops(sdev)->runtime_suspend(sdev); 259 260 return 0; 261} 262 263static inline int snd_sof_dsp_runtime_idle(struct snd_sof_dev *sdev) 264{ 265 if (sof_ops(sdev)->runtime_idle) 266 return sof_ops(sdev)->runtime_idle(sdev); 267 268 return 0; 269} 270 271static inline int snd_sof_dsp_hw_params_upon_resume(struct snd_sof_dev *sdev) 272{ 273 if (sof_ops(sdev)->set_hw_params_upon_resume) 274 return sof_ops(sdev)->set_hw_params_upon_resume(sdev); 275 return 0; 276} 277 278static inline int snd_sof_dsp_set_clk(struct snd_sof_dev *sdev, u32 freq) 279{ 280 if (sof_ops(sdev)->set_clk) 281 return sof_ops(sdev)->set_clk(sdev, freq); 282 283 return 0; 284} 285 286static inline int 287snd_sof_dsp_set_power_state(struct snd_sof_dev *sdev, 288 const struct sof_dsp_power_state *target_state) 289{ 290 int ret = 0; 291 292 mutex_lock(&sdev->power_state_access); 293 294 if (sof_ops(sdev)->set_power_state) 295 ret = sof_ops(sdev)->set_power_state(sdev, target_state); 296 297 mutex_unlock(&sdev->power_state_access); 298 299 return ret; 300} 301 302/* debug */ 303void snd_sof_dsp_dbg_dump(struct snd_sof_dev *sdev, const char *msg, u32 flags); 304 305static inline int snd_sof_debugfs_add_region_item(struct snd_sof_dev *sdev, 306 enum snd_sof_fw_blk_type blk_type, u32 offset, size_t size, 307 const char *name, enum sof_debugfs_access_type access_type) 308{ 309 if (sof_ops(sdev) && sof_ops(sdev)->debugfs_add_region_item) 310 return sof_ops(sdev)->debugfs_add_region_item(sdev, blk_type, offset, 311 size, name, access_type); 312 313 return 0; 314} 315 316/* register IO */ 317static inline void snd_sof_dsp_write8(struct snd_sof_dev *sdev, u32 bar, 318 u32 offset, u8 value) 319{ 320 if (sof_ops(sdev)->write8) 321 sof_ops(sdev)->write8(sdev, sdev->bar[bar] + offset, value); 322 else 323 writeb(value, sdev->bar[bar] + offset); 324} 325 326static inline void snd_sof_dsp_write(struct snd_sof_dev *sdev, u32 bar, 327 u32 offset, u32 value) 328{ 329 if (sof_ops(sdev)->write) 330 sof_ops(sdev)->write(sdev, sdev->bar[bar] + offset, value); 331 else 332 writel(value, sdev->bar[bar] + offset); 333} 334 335static inline void snd_sof_dsp_write64(struct snd_sof_dev *sdev, u32 bar, 336 u32 offset, u64 value) 337{ 338 if (sof_ops(sdev)->write64) 339 sof_ops(sdev)->write64(sdev, sdev->bar[bar] + offset, value); 340 else 341 writeq(value, sdev->bar[bar] + offset); 342} 343 344static inline u8 snd_sof_dsp_read8(struct snd_sof_dev *sdev, u32 bar, 345 u32 offset) 346{ 347 if (sof_ops(sdev)->read8) 348 return sof_ops(sdev)->read8(sdev, sdev->bar[bar] + offset); 349 else 350 return readb(sdev->bar[bar] + offset); 351} 352 353static inline u32 snd_sof_dsp_read(struct snd_sof_dev *sdev, u32 bar, 354 u32 offset) 355{ 356 if (sof_ops(sdev)->read) 357 return sof_ops(sdev)->read(sdev, sdev->bar[bar] + offset); 358 else 359 return readl(sdev->bar[bar] + offset); 360} 361 362static inline u64 snd_sof_dsp_read64(struct snd_sof_dev *sdev, u32 bar, 363 u32 offset) 364{ 365 if (sof_ops(sdev)->read64) 366 return sof_ops(sdev)->read64(sdev, sdev->bar[bar] + offset); 367 else 368 return readq(sdev->bar[bar] + offset); 369} 370 371static inline void snd_sof_dsp_update8(struct snd_sof_dev *sdev, u32 bar, 372 u32 offset, u8 mask, u8 value) 373{ 374 u8 reg; 375 376 reg = snd_sof_dsp_read8(sdev, bar, offset); 377 reg &= ~mask; 378 reg |= value; 379 snd_sof_dsp_write8(sdev, bar, offset, reg); 380} 381 382/* block IO */ 383static inline int snd_sof_dsp_block_read(struct snd_sof_dev *sdev, 384 enum snd_sof_fw_blk_type blk_type, 385 u32 offset, void *dest, size_t bytes) 386{ 387 return sof_ops(sdev)->block_read(sdev, blk_type, offset, dest, bytes); 388} 389 390static inline int snd_sof_dsp_block_write(struct snd_sof_dev *sdev, 391 enum snd_sof_fw_blk_type blk_type, 392 u32 offset, void *src, size_t bytes) 393{ 394 return sof_ops(sdev)->block_write(sdev, blk_type, offset, src, bytes); 395} 396 397/* mailbox IO */ 398static inline void snd_sof_dsp_mailbox_read(struct snd_sof_dev *sdev, 399 u32 offset, void *dest, size_t bytes) 400{ 401 if (sof_ops(sdev)->mailbox_read) 402 sof_ops(sdev)->mailbox_read(sdev, offset, dest, bytes); 403} 404 405static inline void snd_sof_dsp_mailbox_write(struct snd_sof_dev *sdev, 406 u32 offset, void *src, size_t bytes) 407{ 408 if (sof_ops(sdev)->mailbox_write) 409 sof_ops(sdev)->mailbox_write(sdev, offset, src, bytes); 410} 411 412/* ipc */ 413static inline int snd_sof_dsp_send_msg(struct snd_sof_dev *sdev, 414 struct snd_sof_ipc_msg *msg) 415{ 416 return sof_ops(sdev)->send_msg(sdev, msg); 417} 418 419/* host PCM ops */ 420static inline int 421snd_sof_pcm_platform_open(struct snd_sof_dev *sdev, 422 struct snd_pcm_substream *substream) 423{ 424 if (sof_ops(sdev) && sof_ops(sdev)->pcm_open) 425 return sof_ops(sdev)->pcm_open(sdev, substream); 426 427 return 0; 428} 429 430/* disconnect pcm substream to a host stream */ 431static inline int 432snd_sof_pcm_platform_close(struct snd_sof_dev *sdev, 433 struct snd_pcm_substream *substream) 434{ 435 if (sof_ops(sdev) && sof_ops(sdev)->pcm_close) 436 return sof_ops(sdev)->pcm_close(sdev, substream); 437 438 return 0; 439} 440 441/* host stream hw params */ 442static inline int 443snd_sof_pcm_platform_hw_params(struct snd_sof_dev *sdev, 444 struct snd_pcm_substream *substream, 445 struct snd_pcm_hw_params *params, 446 struct snd_sof_platform_stream_params *platform_params) 447{ 448 if (sof_ops(sdev) && sof_ops(sdev)->pcm_hw_params) 449 return sof_ops(sdev)->pcm_hw_params(sdev, substream, params, 450 platform_params); 451 452 return 0; 453} 454 455/* host stream hw free */ 456static inline int 457snd_sof_pcm_platform_hw_free(struct snd_sof_dev *sdev, 458 struct snd_pcm_substream *substream) 459{ 460 if (sof_ops(sdev) && sof_ops(sdev)->pcm_hw_free) 461 return sof_ops(sdev)->pcm_hw_free(sdev, substream); 462 463 return 0; 464} 465 466/* host stream trigger */ 467static inline int 468snd_sof_pcm_platform_trigger(struct snd_sof_dev *sdev, 469 struct snd_pcm_substream *substream, int cmd) 470{ 471 if (sof_ops(sdev) && sof_ops(sdev)->pcm_trigger) 472 return sof_ops(sdev)->pcm_trigger(sdev, substream, cmd); 473 474 return 0; 475} 476 477/* Firmware loading */ 478static inline int snd_sof_load_firmware(struct snd_sof_dev *sdev) 479{ 480 dev_dbg(sdev->dev, "loading firmware\n"); 481 482 return sof_ops(sdev)->load_firmware(sdev); 483} 484 485/* host DSP message data */ 486static inline int snd_sof_ipc_msg_data(struct snd_sof_dev *sdev, 487 struct snd_sof_pcm_stream *sps, 488 void *p, size_t sz) 489{ 490 return sof_ops(sdev)->ipc_msg_data(sdev, sps, p, sz); 491} 492/* host side configuration of the stream's data offset in stream mailbox area */ 493static inline int 494snd_sof_set_stream_data_offset(struct snd_sof_dev *sdev, 495 struct snd_sof_pcm_stream *sps, 496 size_t posn_offset) 497{ 498 if (sof_ops(sdev) && sof_ops(sdev)->set_stream_data_offset) 499 return sof_ops(sdev)->set_stream_data_offset(sdev, sps, 500 posn_offset); 501 502 return 0; 503} 504 505/* host stream pointer */ 506static inline snd_pcm_uframes_t 507snd_sof_pcm_platform_pointer(struct snd_sof_dev *sdev, 508 struct snd_pcm_substream *substream) 509{ 510 if (sof_ops(sdev) && sof_ops(sdev)->pcm_pointer) 511 return sof_ops(sdev)->pcm_pointer(sdev, substream); 512 513 return 0; 514} 515 516/* pcm ack */ 517static inline int snd_sof_pcm_platform_ack(struct snd_sof_dev *sdev, 518 struct snd_pcm_substream *substream) 519{ 520 if (sof_ops(sdev) && sof_ops(sdev)->pcm_ack) 521 return sof_ops(sdev)->pcm_ack(sdev, substream); 522 523 return 0; 524} 525 526static inline u64 527snd_sof_pcm_get_dai_frame_counter(struct snd_sof_dev *sdev, 528 struct snd_soc_component *component, 529 struct snd_pcm_substream *substream) 530{ 531 if (sof_ops(sdev) && sof_ops(sdev)->get_dai_frame_counter) 532 return sof_ops(sdev)->get_dai_frame_counter(sdev, component, 533 substream); 534 535 return 0; 536} 537 538static inline u64 539snd_sof_pcm_get_host_byte_counter(struct snd_sof_dev *sdev, 540 struct snd_soc_component *component, 541 struct snd_pcm_substream *substream) 542{ 543 if (sof_ops(sdev) && sof_ops(sdev)->get_host_byte_counter) 544 return sof_ops(sdev)->get_host_byte_counter(sdev, component, 545 substream); 546 547 return 0; 548} 549 550/* machine driver */ 551static inline int 552snd_sof_machine_register(struct snd_sof_dev *sdev, void *pdata) 553{ 554 if (sof_ops(sdev) && sof_ops(sdev)->machine_register) 555 return sof_ops(sdev)->machine_register(sdev, pdata); 556 557 return 0; 558} 559 560static inline void 561snd_sof_machine_unregister(struct snd_sof_dev *sdev, void *pdata) 562{ 563 if (sof_ops(sdev) && sof_ops(sdev)->machine_unregister) 564 sof_ops(sdev)->machine_unregister(sdev, pdata); 565} 566 567static inline struct snd_soc_acpi_mach * 568snd_sof_machine_select(struct snd_sof_dev *sdev) 569{ 570 if (sof_ops(sdev) && sof_ops(sdev)->machine_select) 571 return sof_ops(sdev)->machine_select(sdev); 572 573 return NULL; 574} 575 576static inline void 577snd_sof_set_mach_params(struct snd_soc_acpi_mach *mach, 578 struct snd_sof_dev *sdev) 579{ 580 if (sof_ops(sdev) && sof_ops(sdev)->set_mach_params) 581 sof_ops(sdev)->set_mach_params(mach, sdev); 582} 583 584static inline bool 585snd_sof_is_chain_dma_supported(struct snd_sof_dev *sdev, u32 dai_type) 586{ 587 if (sof_ops(sdev) && sof_ops(sdev)->is_chain_dma_supported) 588 return sof_ops(sdev)->is_chain_dma_supported(sdev, dai_type); 589 590 return false; 591} 592 593/** 594 * snd_sof_dsp_register_poll_timeout - Periodically poll an address 595 * until a condition is met or a timeout occurs 596 * @op: accessor function (takes @addr as its only argument) 597 * @addr: Address to poll 598 * @val: Variable to read the value into 599 * @cond: Break condition (usually involving @val) 600 * @sleep_us: Maximum time to sleep between reads in us (0 601 * tight-loops). Should be less than ~20ms since usleep_range 602 * is used (see Documentation/timers/timers-howto.rst). 603 * @timeout_us: Timeout in us, 0 means never timeout 604 * 605 * Returns 0 on success and -ETIMEDOUT upon a timeout. In either 606 * case, the last read value at @addr is stored in @val. Must not 607 * be called from atomic context if sleep_us or timeout_us are used. 608 * 609 * This is modelled after the readx_poll_timeout macros in linux/iopoll.h. 610 */ 611#define snd_sof_dsp_read_poll_timeout(sdev, bar, offset, val, cond, sleep_us, timeout_us) \ 612({ \ 613 u64 __timeout_us = (timeout_us); \ 614 unsigned long __sleep_us = (sleep_us); \ 615 ktime_t __timeout = ktime_add_us(ktime_get(), __timeout_us); \ 616 might_sleep_if((__sleep_us) != 0); \ 617 for (;;) { \ 618 (val) = snd_sof_dsp_read(sdev, bar, offset); \ 619 if (cond) { \ 620 dev_dbg(sdev->dev, \ 621 "FW Poll Status: reg[%#x]=%#x successful\n", \ 622 (offset), (val)); \ 623 break; \ 624 } \ 625 if (__timeout_us && \ 626 ktime_compare(ktime_get(), __timeout) > 0) { \ 627 (val) = snd_sof_dsp_read(sdev, bar, offset); \ 628 dev_dbg(sdev->dev, \ 629 "FW Poll Status: reg[%#x]=%#x timedout\n", \ 630 (offset), (val)); \ 631 break; \ 632 } \ 633 if (__sleep_us) \ 634 usleep_range((__sleep_us >> 2) + 1, __sleep_us); \ 635 } \ 636 (cond) ? 0 : -ETIMEDOUT; \ 637}) 638 639/* This is for registers bits with attribute RWC */ 640bool snd_sof_pci_update_bits(struct snd_sof_dev *sdev, u32 offset, 641 u32 mask, u32 value); 642 643bool snd_sof_dsp_update_bits_unlocked(struct snd_sof_dev *sdev, u32 bar, 644 u32 offset, u32 mask, u32 value); 645 646bool snd_sof_dsp_update_bits64_unlocked(struct snd_sof_dev *sdev, u32 bar, 647 u32 offset, u64 mask, u64 value); 648 649bool snd_sof_dsp_update_bits(struct snd_sof_dev *sdev, u32 bar, u32 offset, 650 u32 mask, u32 value); 651 652bool snd_sof_dsp_update_bits64(struct snd_sof_dev *sdev, u32 bar, 653 u32 offset, u64 mask, u64 value); 654 655void snd_sof_dsp_update_bits_forced(struct snd_sof_dev *sdev, u32 bar, 656 u32 offset, u32 mask, u32 value); 657 658int snd_sof_dsp_register_poll(struct snd_sof_dev *sdev, u32 bar, u32 offset, 659 u32 mask, u32 target, u32 timeout_ms, 660 u32 interval_us); 661 662void snd_sof_dsp_panic(struct snd_sof_dev *sdev, u32 offset, bool non_recoverable); 663#endif 664