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 // Authors: Liam Girdwood <liam.r.girdwood@linux.intel.com> 9 // Ranjani Sridharan <ranjani.sridharan@linux.intel.com> 10 // Rander Wang <rander.wang@intel.com> 11 // Keyon Jie <yang.jie@linux.intel.com> 12 // 13 14 /* 15 * Hardware interface for generic Intel audio DSP HDA IP 16 */ 17 18 #include <linux/pm_runtime.h> 19 #include <sound/hdaudio_ext.h> 20 #include <sound/hda_register.h> 21 #include <sound/sof.h> 22 #include "../ops.h" 23 #include "../sof-audio.h" 24 #include "hda.h" 25 26 /* 27 * set up one of BDL entries for a stream 28 */ 29 static int hda_setup_bdle(struct snd_sof_dev *sdev, 30 struct snd_dma_buffer *dmab, 31 struct hdac_stream *stream, 32 struct sof_intel_dsp_bdl **bdlp, 33 int offset, int size, int ioc) 34 { 35 struct hdac_bus *bus = sof_to_bus(sdev); 36 struct sof_intel_dsp_bdl *bdl = *bdlp; 37 38 while (size > 0) { 39 dma_addr_t addr; 40 int chunk; 41 42 if (stream->frags >= HDA_DSP_MAX_BDL_ENTRIES) { 43 dev_err(sdev->dev, "error: stream frags exceeded\n"); 44 return -EINVAL; 45 } 46 47 addr = snd_sgbuf_get_addr(dmab, offset); 48 /* program BDL addr */ 49 bdl->addr_l = cpu_to_le32(lower_32_bits(addr)); 50 bdl->addr_h = cpu_to_le32(upper_32_bits(addr)); 51 /* program BDL size */ 52 chunk = snd_sgbuf_get_chunk_size(dmab, offset, size); 53 /* one BDLE should not cross 4K boundary */ 54 if (bus->align_bdle_4k) { 55 u32 remain = 0x1000 - (offset & 0xfff); 56 57 if (chunk > remain) 58 chunk = remain; 59 } 60 bdl->size = cpu_to_le32(chunk); 61 /* only program IOC when the whole segment is processed */ 62 size -= chunk; 63 bdl->ioc = (size || !ioc) ? 0 : cpu_to_le32(0x01); 64 bdl++; 65 stream->frags++; 66 offset += chunk; 67 68 dev_vdbg(sdev->dev, "bdl, frags:%d, chunk size:0x%x;\n", 69 stream->frags, chunk); 70 } 71 72 *bdlp = bdl; 73 return offset; 74 } 75 76 /* 77 * set up Buffer Descriptor List (BDL) for host memory transfer 78 * BDL describes the location of the individual buffers and is little endian. 79 */ 80 int hda_dsp_stream_setup_bdl(struct snd_sof_dev *sdev, 81 struct snd_dma_buffer *dmab, 82 struct hdac_stream *stream) 83 { 84 struct sof_intel_hda_dev *hda = sdev->pdata->hw_pdata; 85 struct sof_intel_dsp_bdl *bdl; 86 int i, offset, period_bytes, periods; 87 int remain, ioc; 88 89 period_bytes = stream->period_bytes; 90 dev_dbg(sdev->dev, "period_bytes:0x%x\n", period_bytes); 91 if (!period_bytes) 92 period_bytes = stream->bufsize; 93 94 periods = stream->bufsize / period_bytes; 95 96 dev_dbg(sdev->dev, "periods:%d\n", periods); 97 98 remain = stream->bufsize % period_bytes; 99 if (remain) 100 periods++; 101 102 /* program the initial BDL entries */ 103 bdl = (struct sof_intel_dsp_bdl *)stream->bdl.area; 104 offset = 0; 105 stream->frags = 0; 106 107 /* 108 * set IOC if don't use position IPC 109 * and period_wakeup needed. 110 */ 111 ioc = hda->no_ipc_position ? 112 !stream->no_period_wakeup : 0; 113 114 for (i = 0; i < periods; i++) { 115 if (i == (periods - 1) && remain) 116 /* set the last small entry */ 117 offset = hda_setup_bdle(sdev, dmab, 118 stream, &bdl, offset, 119 remain, 0); 120 else 121 offset = hda_setup_bdle(sdev, dmab, 122 stream, &bdl, offset, 123 period_bytes, ioc); 124 } 125 126 return offset; 127 } 128 129 int hda_dsp_stream_spib_config(struct snd_sof_dev *sdev, 130 struct hdac_ext_stream *stream, 131 int enable, u32 size) 132 { 133 struct hdac_stream *hstream = &stream->hstream; 134 u32 mask; 135 136 if (!sdev->bar[HDA_DSP_SPIB_BAR]) { 137 dev_err(sdev->dev, "error: address of spib capability is NULL\n"); 138 return -EINVAL; 139 } 140 141 mask = (1 << hstream->index); 142 143 /* enable/disable SPIB for the stream */ 144 snd_sof_dsp_update_bits(sdev, HDA_DSP_SPIB_BAR, 145 SOF_HDA_ADSP_REG_CL_SPBFIFO_SPBFCCTL, mask, 146 enable << hstream->index); 147 148 /* set the SPIB value */ 149 sof_io_write(sdev, stream->spib_addr, size); 150 151 return 0; 152 } 153 154 /* get next unused stream */ 155 struct hdac_ext_stream * 156 hda_dsp_stream_get(struct snd_sof_dev *sdev, int direction) 157 { 158 struct hdac_bus *bus = sof_to_bus(sdev); 159 struct sof_intel_hda_stream *hda_stream; 160 struct hdac_ext_stream *stream = NULL; 161 struct hdac_stream *s; 162 163 spin_lock_irq(&bus->reg_lock); 164 165 /* get an unused stream */ 166 list_for_each_entry(s, &bus->stream_list, list) { 167 if (s->direction == direction && !s->opened) { 168 stream = stream_to_hdac_ext_stream(s); 169 hda_stream = container_of(stream, 170 struct sof_intel_hda_stream, 171 hda_stream); 172 /* check if the host DMA channel is reserved */ 173 if (hda_stream->host_reserved) 174 continue; 175 176 s->opened = true; 177 break; 178 } 179 } 180 181 spin_unlock_irq(&bus->reg_lock); 182 183 /* stream found ? */ 184 if (!stream) 185 dev_err(sdev->dev, "error: no free %s streams\n", 186 direction == SNDRV_PCM_STREAM_PLAYBACK ? 187 "playback" : "capture"); 188 189 /* 190 * Disable DMI Link L1 entry when capture stream is opened. 191 * Workaround to address a known issue with host DMA that results 192 * in xruns during pause/release in capture scenarios. 193 */ 194 if (!IS_ENABLED(CONFIG_SND_SOC_SOF_HDA_ALWAYS_ENABLE_DMI_L1)) 195 if (stream && direction == SNDRV_PCM_STREAM_CAPTURE) 196 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, 197 HDA_VS_INTEL_EM2, 198 HDA_VS_INTEL_EM2_L1SEN, 0); 199 200 return stream; 201 } 202 203 /* free a stream */ 204 int hda_dsp_stream_put(struct snd_sof_dev *sdev, int direction, int stream_tag) 205 { 206 struct hdac_bus *bus = sof_to_bus(sdev); 207 struct hdac_stream *s; 208 bool active_capture_stream = false; 209 bool found = false; 210 211 spin_lock_irq(&bus->reg_lock); 212 213 /* 214 * close stream matching the stream tag 215 * and check if there are any open capture streams. 216 */ 217 list_for_each_entry(s, &bus->stream_list, list) { 218 if (!s->opened) 219 continue; 220 221 if (s->direction == direction && s->stream_tag == stream_tag) { 222 s->opened = false; 223 found = true; 224 } else if (s->direction == SNDRV_PCM_STREAM_CAPTURE) { 225 active_capture_stream = true; 226 } 227 } 228 229 spin_unlock_irq(&bus->reg_lock); 230 231 /* Enable DMI L1 entry if there are no capture streams open */ 232 if (!IS_ENABLED(CONFIG_SND_SOC_SOF_HDA_ALWAYS_ENABLE_DMI_L1)) 233 if (!active_capture_stream) 234 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, 235 HDA_VS_INTEL_EM2, 236 HDA_VS_INTEL_EM2_L1SEN, 237 HDA_VS_INTEL_EM2_L1SEN); 238 239 if (!found) { 240 dev_dbg(sdev->dev, "stream_tag %d not opened!\n", stream_tag); 241 return -ENODEV; 242 } 243 244 return 0; 245 } 246 247 int hda_dsp_stream_trigger(struct snd_sof_dev *sdev, 248 struct hdac_ext_stream *stream, int cmd) 249 { 250 struct hdac_stream *hstream = &stream->hstream; 251 int sd_offset = SOF_STREAM_SD_OFFSET(hstream); 252 u32 dma_start = SOF_HDA_SD_CTL_DMA_START; 253 int ret; 254 u32 run; 255 256 /* cmd must be for audio stream */ 257 switch (cmd) { 258 case SNDRV_PCM_TRIGGER_RESUME: 259 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 260 case SNDRV_PCM_TRIGGER_START: 261 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, SOF_HDA_INTCTL, 262 1 << hstream->index, 263 1 << hstream->index); 264 265 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, 266 sd_offset, 267 SOF_HDA_SD_CTL_DMA_START | 268 SOF_HDA_CL_DMA_SD_INT_MASK, 269 SOF_HDA_SD_CTL_DMA_START | 270 SOF_HDA_CL_DMA_SD_INT_MASK); 271 272 ret = snd_sof_dsp_read_poll_timeout(sdev, 273 HDA_DSP_HDA_BAR, 274 sd_offset, run, 275 ((run & dma_start) == dma_start), 276 HDA_DSP_REG_POLL_INTERVAL_US, 277 HDA_DSP_STREAM_RUN_TIMEOUT); 278 279 if (ret < 0) { 280 dev_err(sdev->dev, 281 "error: %s: cmd %d: timeout on STREAM_SD_OFFSET read\n", 282 __func__, cmd); 283 return ret; 284 } 285 286 hstream->running = true; 287 break; 288 case SNDRV_PCM_TRIGGER_SUSPEND: 289 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 290 case SNDRV_PCM_TRIGGER_STOP: 291 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, 292 sd_offset, 293 SOF_HDA_SD_CTL_DMA_START | 294 SOF_HDA_CL_DMA_SD_INT_MASK, 0x0); 295 296 ret = snd_sof_dsp_read_poll_timeout(sdev, HDA_DSP_HDA_BAR, 297 sd_offset, run, 298 !(run & dma_start), 299 HDA_DSP_REG_POLL_INTERVAL_US, 300 HDA_DSP_STREAM_RUN_TIMEOUT); 301 302 if (ret < 0) { 303 dev_err(sdev->dev, 304 "error: %s: cmd %d: timeout on STREAM_SD_OFFSET read\n", 305 __func__, cmd); 306 return ret; 307 } 308 309 snd_sof_dsp_write(sdev, HDA_DSP_HDA_BAR, sd_offset + 310 SOF_HDA_ADSP_REG_CL_SD_STS, 311 SOF_HDA_CL_DMA_SD_INT_MASK); 312 313 hstream->running = false; 314 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, SOF_HDA_INTCTL, 315 1 << hstream->index, 0x0); 316 break; 317 default: 318 dev_err(sdev->dev, "error: unknown command: %d\n", cmd); 319 return -EINVAL; 320 } 321 322 return 0; 323 } 324 325 /* 326 * prepare for common hdac registers settings, for both code loader 327 * and normal stream. 328 */ 329 int hda_dsp_stream_hw_params(struct snd_sof_dev *sdev, 330 struct hdac_ext_stream *stream, 331 struct snd_dma_buffer *dmab, 332 struct snd_pcm_hw_params *params) 333 { 334 struct hdac_bus *bus = sof_to_bus(sdev); 335 struct hdac_stream *hstream = &stream->hstream; 336 int sd_offset = SOF_STREAM_SD_OFFSET(hstream); 337 int ret, timeout = HDA_DSP_STREAM_RESET_TIMEOUT; 338 u32 dma_start = SOF_HDA_SD_CTL_DMA_START; 339 u32 val, mask; 340 u32 run; 341 342 if (!stream) { 343 dev_err(sdev->dev, "error: no stream available\n"); 344 return -ENODEV; 345 } 346 347 /* decouple host and link DMA */ 348 mask = 0x1 << hstream->index; 349 snd_sof_dsp_update_bits(sdev, HDA_DSP_PP_BAR, SOF_HDA_REG_PP_PPCTL, 350 mask, mask); 351 352 if (!dmab) { 353 dev_err(sdev->dev, "error: no dma buffer allocated!\n"); 354 return -ENODEV; 355 } 356 357 /* clear stream status */ 358 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, sd_offset, 359 SOF_HDA_CL_DMA_SD_INT_MASK | 360 SOF_HDA_SD_CTL_DMA_START, 0); 361 362 ret = snd_sof_dsp_read_poll_timeout(sdev, HDA_DSP_HDA_BAR, 363 sd_offset, run, 364 !(run & dma_start), 365 HDA_DSP_REG_POLL_INTERVAL_US, 366 HDA_DSP_STREAM_RUN_TIMEOUT); 367 368 if (ret < 0) { 369 dev_err(sdev->dev, 370 "error: %s: timeout on STREAM_SD_OFFSET read1\n", 371 __func__); 372 return ret; 373 } 374 375 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, 376 sd_offset + SOF_HDA_ADSP_REG_CL_SD_STS, 377 SOF_HDA_CL_DMA_SD_INT_MASK, 378 SOF_HDA_CL_DMA_SD_INT_MASK); 379 380 /* stream reset */ 381 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, sd_offset, 0x1, 382 0x1); 383 udelay(3); 384 do { 385 val = snd_sof_dsp_read(sdev, HDA_DSP_HDA_BAR, 386 sd_offset); 387 if (val & 0x1) 388 break; 389 } while (--timeout); 390 if (timeout == 0) { 391 dev_err(sdev->dev, "error: stream reset failed\n"); 392 return -ETIMEDOUT; 393 } 394 395 timeout = HDA_DSP_STREAM_RESET_TIMEOUT; 396 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, sd_offset, 0x1, 397 0x0); 398 399 /* wait for hardware to report that stream is out of reset */ 400 udelay(3); 401 do { 402 val = snd_sof_dsp_read(sdev, HDA_DSP_HDA_BAR, 403 sd_offset); 404 if ((val & 0x1) == 0) 405 break; 406 } while (--timeout); 407 if (timeout == 0) { 408 dev_err(sdev->dev, "error: timeout waiting for stream reset\n"); 409 return -ETIMEDOUT; 410 } 411 412 if (hstream->posbuf) 413 *hstream->posbuf = 0; 414 415 /* reset BDL address */ 416 snd_sof_dsp_write(sdev, HDA_DSP_HDA_BAR, 417 sd_offset + SOF_HDA_ADSP_REG_CL_SD_BDLPL, 418 0x0); 419 snd_sof_dsp_write(sdev, HDA_DSP_HDA_BAR, 420 sd_offset + SOF_HDA_ADSP_REG_CL_SD_BDLPU, 421 0x0); 422 423 /* clear stream status */ 424 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, sd_offset, 425 SOF_HDA_CL_DMA_SD_INT_MASK | 426 SOF_HDA_SD_CTL_DMA_START, 0); 427 428 ret = snd_sof_dsp_read_poll_timeout(sdev, HDA_DSP_HDA_BAR, 429 sd_offset, run, 430 !(run & dma_start), 431 HDA_DSP_REG_POLL_INTERVAL_US, 432 HDA_DSP_STREAM_RUN_TIMEOUT); 433 434 if (ret < 0) { 435 dev_err(sdev->dev, 436 "error: %s: timeout on STREAM_SD_OFFSET read2\n", 437 __func__); 438 return ret; 439 } 440 441 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, 442 sd_offset + SOF_HDA_ADSP_REG_CL_SD_STS, 443 SOF_HDA_CL_DMA_SD_INT_MASK, 444 SOF_HDA_CL_DMA_SD_INT_MASK); 445 446 hstream->frags = 0; 447 448 ret = hda_dsp_stream_setup_bdl(sdev, dmab, hstream); 449 if (ret < 0) { 450 dev_err(sdev->dev, "error: set up of BDL failed\n"); 451 return ret; 452 } 453 454 /* program stream tag to set up stream descriptor for DMA */ 455 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, sd_offset, 456 SOF_HDA_CL_SD_CTL_STREAM_TAG_MASK, 457 hstream->stream_tag << 458 SOF_HDA_CL_SD_CTL_STREAM_TAG_SHIFT); 459 460 /* program cyclic buffer length */ 461 snd_sof_dsp_write(sdev, HDA_DSP_HDA_BAR, 462 sd_offset + SOF_HDA_ADSP_REG_CL_SD_CBL, 463 hstream->bufsize); 464 465 /* 466 * Recommended hardware programming sequence for HDAudio DMA format 467 * 468 * 1. Put DMA into coupled mode by clearing PPCTL.PROCEN bit 469 * for corresponding stream index before the time of writing 470 * format to SDxFMT register. 471 * 2. Write SDxFMT 472 * 3. Set PPCTL.PROCEN bit for corresponding stream index to 473 * enable decoupled mode 474 */ 475 476 /* couple host and link DMA, disable DSP features */ 477 snd_sof_dsp_update_bits(sdev, HDA_DSP_PP_BAR, SOF_HDA_REG_PP_PPCTL, 478 mask, 0); 479 480 /* program stream format */ 481 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, 482 sd_offset + 483 SOF_HDA_ADSP_REG_CL_SD_FORMAT, 484 0xffff, hstream->format_val); 485 486 /* decouple host and link DMA, enable DSP features */ 487 snd_sof_dsp_update_bits(sdev, HDA_DSP_PP_BAR, SOF_HDA_REG_PP_PPCTL, 488 mask, mask); 489 490 /* program last valid index */ 491 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, 492 sd_offset + SOF_HDA_ADSP_REG_CL_SD_LVI, 493 0xffff, (hstream->frags - 1)); 494 495 /* program BDL address */ 496 snd_sof_dsp_write(sdev, HDA_DSP_HDA_BAR, 497 sd_offset + SOF_HDA_ADSP_REG_CL_SD_BDLPL, 498 (u32)hstream->bdl.addr); 499 snd_sof_dsp_write(sdev, HDA_DSP_HDA_BAR, 500 sd_offset + SOF_HDA_ADSP_REG_CL_SD_BDLPU, 501 upper_32_bits(hstream->bdl.addr)); 502 503 /* enable position buffer */ 504 if (!(snd_sof_dsp_read(sdev, HDA_DSP_HDA_BAR, SOF_HDA_ADSP_DPLBASE) 505 & SOF_HDA_ADSP_DPLBASE_ENABLE)) { 506 snd_sof_dsp_write(sdev, HDA_DSP_HDA_BAR, SOF_HDA_ADSP_DPUBASE, 507 upper_32_bits(bus->posbuf.addr)); 508 snd_sof_dsp_write(sdev, HDA_DSP_HDA_BAR, SOF_HDA_ADSP_DPLBASE, 509 (u32)bus->posbuf.addr | 510 SOF_HDA_ADSP_DPLBASE_ENABLE); 511 } 512 513 /* set interrupt enable bits */ 514 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, sd_offset, 515 SOF_HDA_CL_DMA_SD_INT_MASK, 516 SOF_HDA_CL_DMA_SD_INT_MASK); 517 518 /* read FIFO size */ 519 if (hstream->direction == SNDRV_PCM_STREAM_PLAYBACK) { 520 hstream->fifo_size = 521 snd_sof_dsp_read(sdev, HDA_DSP_HDA_BAR, 522 sd_offset + 523 SOF_HDA_ADSP_REG_CL_SD_FIFOSIZE); 524 hstream->fifo_size &= 0xffff; 525 hstream->fifo_size += 1; 526 } else { 527 hstream->fifo_size = 0; 528 } 529 530 return ret; 531 } 532 533 int hda_dsp_stream_hw_free(struct snd_sof_dev *sdev, 534 struct snd_pcm_substream *substream) 535 { 536 struct hdac_stream *stream = substream->runtime->private_data; 537 struct hdac_ext_stream *link_dev = container_of(stream, 538 struct hdac_ext_stream, 539 hstream); 540 struct hdac_bus *bus = sof_to_bus(sdev); 541 u32 mask = 0x1 << stream->index; 542 543 spin_lock_irq(&bus->reg_lock); 544 /* couple host and link DMA if link DMA channel is idle */ 545 if (!link_dev->link_locked) 546 snd_sof_dsp_update_bits(sdev, HDA_DSP_PP_BAR, 547 SOF_HDA_REG_PP_PPCTL, mask, 0); 548 spin_unlock_irq(&bus->reg_lock); 549 550 stream->substream = NULL; 551 552 return 0; 553 } 554 555 bool hda_dsp_check_stream_irq(struct snd_sof_dev *sdev) 556 { 557 struct hdac_bus *bus = sof_to_bus(sdev); 558 bool ret = false; 559 u32 status; 560 561 /* The function can be called at irq thread, so use spin_lock_irq */ 562 spin_lock_irq(&bus->reg_lock); 563 564 status = snd_hdac_chip_readl(bus, INTSTS); 565 dev_vdbg(bus->dev, "stream irq, INTSTS status: 0x%x\n", status); 566 567 /* if Register inaccessible, ignore it.*/ 568 if (status != 0xffffffff) 569 ret = true; 570 571 spin_unlock_irq(&bus->reg_lock); 572 573 return ret; 574 } 575 576 static void 577 hda_dsp_set_bytes_transferred(struct hdac_stream *hstream, u64 buffer_size) 578 { 579 u64 prev_pos, pos, num_bytes; 580 581 div64_u64_rem(hstream->curr_pos, buffer_size, &prev_pos); 582 pos = snd_hdac_stream_get_pos_posbuf(hstream); 583 584 if (pos < prev_pos) 585 num_bytes = (buffer_size - prev_pos) + pos; 586 else 587 num_bytes = pos - prev_pos; 588 589 hstream->curr_pos += num_bytes; 590 } 591 592 static bool hda_dsp_stream_check(struct hdac_bus *bus, u32 status) 593 { 594 struct sof_intel_hda_dev *sof_hda = bus_to_sof_hda(bus); 595 struct hdac_stream *s; 596 bool active = false; 597 u32 sd_status; 598 599 list_for_each_entry(s, &bus->stream_list, list) { 600 if (status & BIT(s->index) && s->opened) { 601 sd_status = snd_hdac_stream_readb(s, SD_STS); 602 603 dev_vdbg(bus->dev, "stream %d status 0x%x\n", 604 s->index, sd_status); 605 606 snd_hdac_stream_writeb(s, SD_STS, sd_status); 607 608 active = true; 609 if ((!s->substream && !s->cstream) || 610 !s->running || 611 (sd_status & SOF_HDA_CL_DMA_SD_INT_COMPLETE) == 0) 612 continue; 613 614 /* Inform ALSA only in case not do that with IPC */ 615 if (s->substream && sof_hda->no_ipc_position) { 616 snd_sof_pcm_period_elapsed(s->substream); 617 } else if (s->cstream) { 618 hda_dsp_set_bytes_transferred(s, 619 s->cstream->runtime->buffer_size); 620 snd_compr_fragment_elapsed(s->cstream); 621 } 622 } 623 } 624 625 return active; 626 } 627 628 irqreturn_t hda_dsp_stream_threaded_handler(int irq, void *context) 629 { 630 struct snd_sof_dev *sdev = context; 631 struct hdac_bus *bus = sof_to_bus(sdev); 632 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA) 633 u32 rirb_status; 634 #endif 635 bool active; 636 u32 status; 637 int i; 638 639 /* 640 * Loop 10 times to handle missed interrupts caused by 641 * unsolicited responses from the codec 642 */ 643 for (i = 0, active = true; i < 10 && active; i++) { 644 spin_lock_irq(&bus->reg_lock); 645 646 status = snd_hdac_chip_readl(bus, INTSTS); 647 648 /* check streams */ 649 active = hda_dsp_stream_check(bus, status); 650 651 /* check and clear RIRB interrupt */ 652 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA) 653 if (status & AZX_INT_CTRL_EN) { 654 rirb_status = snd_hdac_chip_readb(bus, RIRBSTS); 655 if (rirb_status & RIRB_INT_MASK) { 656 /* 657 * Clearing the interrupt status here ensures 658 * that no interrupt gets masked after the RIRB 659 * wp is read in snd_hdac_bus_update_rirb. 660 */ 661 snd_hdac_chip_writeb(bus, RIRBSTS, 662 RIRB_INT_MASK); 663 active = true; 664 if (rirb_status & RIRB_INT_RESPONSE) 665 snd_hdac_bus_update_rirb(bus); 666 } 667 } 668 #endif 669 spin_unlock_irq(&bus->reg_lock); 670 } 671 672 return IRQ_HANDLED; 673 } 674 675 int hda_dsp_stream_init(struct snd_sof_dev *sdev) 676 { 677 struct hdac_bus *bus = sof_to_bus(sdev); 678 struct hdac_ext_stream *stream; 679 struct hdac_stream *hstream; 680 struct pci_dev *pci = to_pci_dev(sdev->dev); 681 struct sof_intel_hda_dev *sof_hda = bus_to_sof_hda(bus); 682 int sd_offset; 683 int i, num_playback, num_capture, num_total, ret; 684 u32 gcap; 685 686 gcap = snd_sof_dsp_read(sdev, HDA_DSP_HDA_BAR, SOF_HDA_GCAP); 687 dev_dbg(sdev->dev, "hda global caps = 0x%x\n", gcap); 688 689 /* get stream count from GCAP */ 690 num_capture = (gcap >> 8) & 0x0f; 691 num_playback = (gcap >> 12) & 0x0f; 692 num_total = num_playback + num_capture; 693 694 dev_dbg(sdev->dev, "detected %d playback and %d capture streams\n", 695 num_playback, num_capture); 696 697 if (num_playback >= SOF_HDA_PLAYBACK_STREAMS) { 698 dev_err(sdev->dev, "error: too many playback streams %d\n", 699 num_playback); 700 return -EINVAL; 701 } 702 703 if (num_capture >= SOF_HDA_CAPTURE_STREAMS) { 704 dev_err(sdev->dev, "error: too many capture streams %d\n", 705 num_playback); 706 return -EINVAL; 707 } 708 709 /* 710 * mem alloc for the position buffer 711 * TODO: check position buffer update 712 */ 713 ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev, 714 SOF_HDA_DPIB_ENTRY_SIZE * num_total, 715 &bus->posbuf); 716 if (ret < 0) { 717 dev_err(sdev->dev, "error: posbuffer dma alloc failed\n"); 718 return -ENOMEM; 719 } 720 721 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA) 722 /* mem alloc for the CORB/RIRB ringbuffers */ 723 ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev, 724 PAGE_SIZE, &bus->rb); 725 if (ret < 0) { 726 dev_err(sdev->dev, "error: RB alloc failed\n"); 727 return -ENOMEM; 728 } 729 #endif 730 731 /* create capture streams */ 732 for (i = 0; i < num_capture; i++) { 733 struct sof_intel_hda_stream *hda_stream; 734 735 hda_stream = devm_kzalloc(sdev->dev, sizeof(*hda_stream), 736 GFP_KERNEL); 737 if (!hda_stream) 738 return -ENOMEM; 739 740 hda_stream->sdev = sdev; 741 742 stream = &hda_stream->hda_stream; 743 744 stream->pphc_addr = sdev->bar[HDA_DSP_PP_BAR] + 745 SOF_HDA_PPHC_BASE + SOF_HDA_PPHC_INTERVAL * i; 746 747 stream->pplc_addr = sdev->bar[HDA_DSP_PP_BAR] + 748 SOF_HDA_PPLC_BASE + SOF_HDA_PPLC_MULTI * num_total + 749 SOF_HDA_PPLC_INTERVAL * i; 750 751 /* do we support SPIB */ 752 if (sdev->bar[HDA_DSP_SPIB_BAR]) { 753 stream->spib_addr = sdev->bar[HDA_DSP_SPIB_BAR] + 754 SOF_HDA_SPIB_BASE + SOF_HDA_SPIB_INTERVAL * i + 755 SOF_HDA_SPIB_SPIB; 756 757 stream->fifo_addr = sdev->bar[HDA_DSP_SPIB_BAR] + 758 SOF_HDA_SPIB_BASE + SOF_HDA_SPIB_INTERVAL * i + 759 SOF_HDA_SPIB_MAXFIFO; 760 } 761 762 hstream = &stream->hstream; 763 hstream->bus = bus; 764 hstream->sd_int_sta_mask = 1 << i; 765 hstream->index = i; 766 sd_offset = SOF_STREAM_SD_OFFSET(hstream); 767 hstream->sd_addr = sdev->bar[HDA_DSP_HDA_BAR] + sd_offset; 768 hstream->stream_tag = i + 1; 769 hstream->opened = false; 770 hstream->running = false; 771 hstream->direction = SNDRV_PCM_STREAM_CAPTURE; 772 773 /* memory alloc for stream BDL */ 774 ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev, 775 HDA_DSP_BDL_SIZE, &hstream->bdl); 776 if (ret < 0) { 777 dev_err(sdev->dev, "error: stream bdl dma alloc failed\n"); 778 return -ENOMEM; 779 } 780 hstream->posbuf = (__le32 *)(bus->posbuf.area + 781 (hstream->index) * 8); 782 783 list_add_tail(&hstream->list, &bus->stream_list); 784 } 785 786 /* create playback streams */ 787 for (i = num_capture; i < num_total; i++) { 788 struct sof_intel_hda_stream *hda_stream; 789 790 hda_stream = devm_kzalloc(sdev->dev, sizeof(*hda_stream), 791 GFP_KERNEL); 792 if (!hda_stream) 793 return -ENOMEM; 794 795 hda_stream->sdev = sdev; 796 797 stream = &hda_stream->hda_stream; 798 799 /* we always have DSP support */ 800 stream->pphc_addr = sdev->bar[HDA_DSP_PP_BAR] + 801 SOF_HDA_PPHC_BASE + SOF_HDA_PPHC_INTERVAL * i; 802 803 stream->pplc_addr = sdev->bar[HDA_DSP_PP_BAR] + 804 SOF_HDA_PPLC_BASE + SOF_HDA_PPLC_MULTI * num_total + 805 SOF_HDA_PPLC_INTERVAL * i; 806 807 /* do we support SPIB */ 808 if (sdev->bar[HDA_DSP_SPIB_BAR]) { 809 stream->spib_addr = sdev->bar[HDA_DSP_SPIB_BAR] + 810 SOF_HDA_SPIB_BASE + SOF_HDA_SPIB_INTERVAL * i + 811 SOF_HDA_SPIB_SPIB; 812 813 stream->fifo_addr = sdev->bar[HDA_DSP_SPIB_BAR] + 814 SOF_HDA_SPIB_BASE + SOF_HDA_SPIB_INTERVAL * i + 815 SOF_HDA_SPIB_MAXFIFO; 816 } 817 818 hstream = &stream->hstream; 819 hstream->bus = bus; 820 hstream->sd_int_sta_mask = 1 << i; 821 hstream->index = i; 822 sd_offset = SOF_STREAM_SD_OFFSET(hstream); 823 hstream->sd_addr = sdev->bar[HDA_DSP_HDA_BAR] + sd_offset; 824 hstream->stream_tag = i - num_capture + 1; 825 hstream->opened = false; 826 hstream->running = false; 827 hstream->direction = SNDRV_PCM_STREAM_PLAYBACK; 828 829 /* mem alloc for stream BDL */ 830 ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev, 831 HDA_DSP_BDL_SIZE, &hstream->bdl); 832 if (ret < 0) { 833 dev_err(sdev->dev, "error: stream bdl dma alloc failed\n"); 834 return -ENOMEM; 835 } 836 837 hstream->posbuf = (__le32 *)(bus->posbuf.area + 838 (hstream->index) * 8); 839 840 list_add_tail(&hstream->list, &bus->stream_list); 841 } 842 843 /* store total stream count (playback + capture) from GCAP */ 844 sof_hda->stream_max = num_total; 845 846 return 0; 847 } 848 849 void hda_dsp_stream_free(struct snd_sof_dev *sdev) 850 { 851 struct hdac_bus *bus = sof_to_bus(sdev); 852 struct hdac_stream *s, *_s; 853 struct hdac_ext_stream *stream; 854 struct sof_intel_hda_stream *hda_stream; 855 856 /* free position buffer */ 857 if (bus->posbuf.area) 858 snd_dma_free_pages(&bus->posbuf); 859 860 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA) 861 /* free position buffer */ 862 if (bus->rb.area) 863 snd_dma_free_pages(&bus->rb); 864 #endif 865 866 list_for_each_entry_safe(s, _s, &bus->stream_list, list) { 867 /* TODO: decouple */ 868 869 /* free bdl buffer */ 870 if (s->bdl.area) 871 snd_dma_free_pages(&s->bdl); 872 list_del(&s->list); 873 stream = stream_to_hdac_ext_stream(s); 874 hda_stream = container_of(stream, struct sof_intel_hda_stream, 875 hda_stream); 876 devm_kfree(sdev->dev, hda_stream); 877 } 878 } 879