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 629