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 512