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 596