1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * C-Media CMI8788 driver - PCM code 4 * 5 * Copyright (c) Clemens Ladisch <clemens@ladisch.de> 6 */ 7 8 #include <linux/pci.h> 9 #include <sound/control.h> 10 #include <sound/core.h> 11 #include <sound/pcm.h> 12 #include <sound/pcm_params.h> 13 #include "oxygen.h" 14 15 /* most DMA channels have a 16-bit counter for 32-bit words */ 16 #define BUFFER_BYTES_MAX ((1 << 16) * 4) 17 /* the multichannel DMA channel has a 24-bit counter */ 18 #define BUFFER_BYTES_MAX_MULTICH ((1 << 24) * 4) 19 20 #define FIFO_BYTES 256 21 #define FIFO_BYTES_MULTICH 1024 22 23 #define PERIOD_BYTES_MIN 64 24 25 #define DEFAULT_BUFFER_BYTES (BUFFER_BYTES_MAX / 2) 26 #define DEFAULT_BUFFER_BYTES_MULTICH (1024 * 1024) 27 28 static const struct snd_pcm_hardware oxygen_stereo_hardware = { 29 .info = SNDRV_PCM_INFO_MMAP | 30 SNDRV_PCM_INFO_MMAP_VALID | 31 SNDRV_PCM_INFO_INTERLEAVED | 32 SNDRV_PCM_INFO_PAUSE | 33 SNDRV_PCM_INFO_SYNC_START | 34 SNDRV_PCM_INFO_NO_PERIOD_WAKEUP, 35 .formats = SNDRV_PCM_FMTBIT_S16_LE | 36 SNDRV_PCM_FMTBIT_S32_LE, 37 .rates = SNDRV_PCM_RATE_32000 | 38 SNDRV_PCM_RATE_44100 | 39 SNDRV_PCM_RATE_48000 | 40 SNDRV_PCM_RATE_64000 | 41 SNDRV_PCM_RATE_88200 | 42 SNDRV_PCM_RATE_96000 | 43 SNDRV_PCM_RATE_176400 | 44 SNDRV_PCM_RATE_192000, 45 .rate_min = 32000, 46 .rate_max = 192000, 47 .channels_min = 2, 48 .channels_max = 2, 49 .buffer_bytes_max = BUFFER_BYTES_MAX, 50 .period_bytes_min = PERIOD_BYTES_MIN, 51 .period_bytes_max = BUFFER_BYTES_MAX, 52 .periods_min = 1, 53 .periods_max = BUFFER_BYTES_MAX / PERIOD_BYTES_MIN, 54 .fifo_size = FIFO_BYTES, 55 }; 56 static const struct snd_pcm_hardware oxygen_multichannel_hardware = { 57 .info = SNDRV_PCM_INFO_MMAP | 58 SNDRV_PCM_INFO_MMAP_VALID | 59 SNDRV_PCM_INFO_INTERLEAVED | 60 SNDRV_PCM_INFO_PAUSE | 61 SNDRV_PCM_INFO_SYNC_START | 62 SNDRV_PCM_INFO_NO_PERIOD_WAKEUP, 63 .formats = SNDRV_PCM_FMTBIT_S16_LE | 64 SNDRV_PCM_FMTBIT_S32_LE, 65 .rates = SNDRV_PCM_RATE_32000 | 66 SNDRV_PCM_RATE_44100 | 67 SNDRV_PCM_RATE_48000 | 68 SNDRV_PCM_RATE_64000 | 69 SNDRV_PCM_RATE_88200 | 70 SNDRV_PCM_RATE_96000 | 71 SNDRV_PCM_RATE_176400 | 72 SNDRV_PCM_RATE_192000, 73 .rate_min = 32000, 74 .rate_max = 192000, 75 .channels_min = 2, 76 .channels_max = 8, 77 .buffer_bytes_max = BUFFER_BYTES_MAX_MULTICH, 78 .period_bytes_min = PERIOD_BYTES_MIN, 79 .period_bytes_max = BUFFER_BYTES_MAX_MULTICH, 80 .periods_min = 1, 81 .periods_max = BUFFER_BYTES_MAX_MULTICH / PERIOD_BYTES_MIN, 82 .fifo_size = FIFO_BYTES_MULTICH, 83 }; 84 static const struct snd_pcm_hardware oxygen_ac97_hardware = { 85 .info = SNDRV_PCM_INFO_MMAP | 86 SNDRV_PCM_INFO_MMAP_VALID | 87 SNDRV_PCM_INFO_INTERLEAVED | 88 SNDRV_PCM_INFO_PAUSE | 89 SNDRV_PCM_INFO_SYNC_START | 90 SNDRV_PCM_INFO_NO_PERIOD_WAKEUP, 91 .formats = SNDRV_PCM_FMTBIT_S16_LE, 92 .rates = SNDRV_PCM_RATE_48000, 93 .rate_min = 48000, 94 .rate_max = 48000, 95 .channels_min = 2, 96 .channels_max = 2, 97 .buffer_bytes_max = BUFFER_BYTES_MAX, 98 .period_bytes_min = PERIOD_BYTES_MIN, 99 .period_bytes_max = BUFFER_BYTES_MAX, 100 .periods_min = 1, 101 .periods_max = BUFFER_BYTES_MAX / PERIOD_BYTES_MIN, 102 .fifo_size = FIFO_BYTES, 103 }; 104 105 static const struct snd_pcm_hardware *const oxygen_hardware[PCM_COUNT] = { 106 [PCM_A] = &oxygen_stereo_hardware, 107 [PCM_B] = &oxygen_stereo_hardware, 108 [PCM_C] = &oxygen_stereo_hardware, 109 [PCM_SPDIF] = &oxygen_stereo_hardware, 110 [PCM_MULTICH] = &oxygen_multichannel_hardware, 111 [PCM_AC97] = &oxygen_ac97_hardware, 112 }; 113 114 static inline unsigned int 115 oxygen_substream_channel(struct snd_pcm_substream *substream) 116 { 117 return (unsigned int)(uintptr_t)substream->runtime->private_data; 118 } 119 120 static int oxygen_open(struct snd_pcm_substream *substream, 121 unsigned int channel) 122 { 123 struct oxygen *chip = snd_pcm_substream_chip(substream); 124 struct snd_pcm_runtime *runtime = substream->runtime; 125 int err; 126 127 runtime->private_data = (void *)(uintptr_t)channel; 128 if (channel == PCM_B && chip->has_ac97_1 && 129 (chip->model.device_config & CAPTURE_2_FROM_AC97_1)) 130 runtime->hw = oxygen_ac97_hardware; 131 else 132 runtime->hw = *oxygen_hardware[channel]; 133 switch (channel) { 134 case PCM_C: 135 if (chip->model.device_config & CAPTURE_1_FROM_SPDIF) { 136 runtime->hw.rates &= ~(SNDRV_PCM_RATE_32000 | 137 SNDRV_PCM_RATE_64000); 138 runtime->hw.rate_min = 44100; 139 } 140 /* fall through */ 141 case PCM_A: 142 case PCM_B: 143 runtime->hw.fifo_size = 0; 144 break; 145 case PCM_MULTICH: 146 runtime->hw.channels_max = chip->model.dac_channels_pcm; 147 break; 148 } 149 if (chip->model.pcm_hardware_filter) 150 chip->model.pcm_hardware_filter(channel, &runtime->hw); 151 err = snd_pcm_hw_constraint_step(runtime, 0, 152 SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 32); 153 if (err < 0) 154 return err; 155 err = snd_pcm_hw_constraint_step(runtime, 0, 156 SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 32); 157 if (err < 0) 158 return err; 159 if (runtime->hw.formats & SNDRV_PCM_FMTBIT_S32_LE) { 160 err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24); 161 if (err < 0) 162 return err; 163 } 164 if (runtime->hw.channels_max > 2) { 165 err = snd_pcm_hw_constraint_step(runtime, 0, 166 SNDRV_PCM_HW_PARAM_CHANNELS, 167 2); 168 if (err < 0) 169 return err; 170 } 171 snd_pcm_set_sync(substream); 172 chip->streams[channel] = substream; 173 174 mutex_lock(&chip->mutex); 175 chip->pcm_active |= 1 << channel; 176 if (channel == PCM_SPDIF) { 177 chip->spdif_pcm_bits = chip->spdif_bits; 178 chip->controls[CONTROL_SPDIF_PCM]->vd[0].access &= 179 ~SNDRV_CTL_ELEM_ACCESS_INACTIVE; 180 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE | 181 SNDRV_CTL_EVENT_MASK_INFO, 182 &chip->controls[CONTROL_SPDIF_PCM]->id); 183 } 184 mutex_unlock(&chip->mutex); 185 186 return 0; 187 } 188 189 static int oxygen_rec_a_open(struct snd_pcm_substream *substream) 190 { 191 return oxygen_open(substream, PCM_A); 192 } 193 194 static int oxygen_rec_b_open(struct snd_pcm_substream *substream) 195 { 196 return oxygen_open(substream, PCM_B); 197 } 198 199 static int oxygen_rec_c_open(struct snd_pcm_substream *substream) 200 { 201 return oxygen_open(substream, PCM_C); 202 } 203 204 static int oxygen_spdif_open(struct snd_pcm_substream *substream) 205 { 206 return oxygen_open(substream, PCM_SPDIF); 207 } 208 209 static int oxygen_multich_open(struct snd_pcm_substream *substream) 210 { 211 return oxygen_open(substream, PCM_MULTICH); 212 } 213 214 static int oxygen_ac97_open(struct snd_pcm_substream *substream) 215 { 216 return oxygen_open(substream, PCM_AC97); 217 } 218 219 static int oxygen_close(struct snd_pcm_substream *substream) 220 { 221 struct oxygen *chip = snd_pcm_substream_chip(substream); 222 unsigned int channel = oxygen_substream_channel(substream); 223 224 mutex_lock(&chip->mutex); 225 chip->pcm_active &= ~(1 << channel); 226 if (channel == PCM_SPDIF) { 227 chip->controls[CONTROL_SPDIF_PCM]->vd[0].access |= 228 SNDRV_CTL_ELEM_ACCESS_INACTIVE; 229 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE | 230 SNDRV_CTL_EVENT_MASK_INFO, 231 &chip->controls[CONTROL_SPDIF_PCM]->id); 232 } 233 if (channel == PCM_SPDIF || channel == PCM_MULTICH) 234 oxygen_update_spdif_source(chip); 235 mutex_unlock(&chip->mutex); 236 237 chip->streams[channel] = NULL; 238 return 0; 239 } 240 241 static unsigned int oxygen_format(struct snd_pcm_hw_params *hw_params) 242 { 243 if (params_format(hw_params) == SNDRV_PCM_FORMAT_S32_LE) 244 return OXYGEN_FORMAT_24; 245 else 246 return OXYGEN_FORMAT_16; 247 } 248 249 static unsigned int oxygen_rate(struct snd_pcm_hw_params *hw_params) 250 { 251 switch (params_rate(hw_params)) { 252 case 32000: 253 return OXYGEN_RATE_32000; 254 case 44100: 255 return OXYGEN_RATE_44100; 256 default: /* 48000 */ 257 return OXYGEN_RATE_48000; 258 case 64000: 259 return OXYGEN_RATE_64000; 260 case 88200: 261 return OXYGEN_RATE_88200; 262 case 96000: 263 return OXYGEN_RATE_96000; 264 case 176400: 265 return OXYGEN_RATE_176400; 266 case 192000: 267 return OXYGEN_RATE_192000; 268 } 269 } 270 271 static unsigned int oxygen_i2s_bits(struct snd_pcm_hw_params *hw_params) 272 { 273 if (params_format(hw_params) == SNDRV_PCM_FORMAT_S32_LE) 274 return OXYGEN_I2S_BITS_24; 275 else 276 return OXYGEN_I2S_BITS_16; 277 } 278 279 static unsigned int oxygen_play_channels(struct snd_pcm_hw_params *hw_params) 280 { 281 switch (params_channels(hw_params)) { 282 default: /* 2 */ 283 return OXYGEN_PLAY_CHANNELS_2; 284 case 4: 285 return OXYGEN_PLAY_CHANNELS_4; 286 case 6: 287 return OXYGEN_PLAY_CHANNELS_6; 288 case 8: 289 return OXYGEN_PLAY_CHANNELS_8; 290 } 291 } 292 293 static const unsigned int channel_base_registers[PCM_COUNT] = { 294 [PCM_A] = OXYGEN_DMA_A_ADDRESS, 295 [PCM_B] = OXYGEN_DMA_B_ADDRESS, 296 [PCM_C] = OXYGEN_DMA_C_ADDRESS, 297 [PCM_SPDIF] = OXYGEN_DMA_SPDIF_ADDRESS, 298 [PCM_MULTICH] = OXYGEN_DMA_MULTICH_ADDRESS, 299 [PCM_AC97] = OXYGEN_DMA_AC97_ADDRESS, 300 }; 301 302 static int oxygen_hw_params(struct snd_pcm_substream *substream, 303 struct snd_pcm_hw_params *hw_params) 304 { 305 struct oxygen *chip = snd_pcm_substream_chip(substream); 306 unsigned int channel = oxygen_substream_channel(substream); 307 308 oxygen_write32(chip, channel_base_registers[channel], 309 (u32)substream->runtime->dma_addr); 310 if (channel == PCM_MULTICH) { 311 oxygen_write32(chip, OXYGEN_DMA_MULTICH_COUNT, 312 params_buffer_bytes(hw_params) / 4 - 1); 313 oxygen_write32(chip, OXYGEN_DMA_MULTICH_TCOUNT, 314 params_period_bytes(hw_params) / 4 - 1); 315 } else { 316 oxygen_write16(chip, channel_base_registers[channel] + 4, 317 params_buffer_bytes(hw_params) / 4 - 1); 318 oxygen_write16(chip, channel_base_registers[channel] + 6, 319 params_period_bytes(hw_params) / 4 - 1); 320 } 321 return 0; 322 } 323 324 static u16 get_mclk(struct oxygen *chip, unsigned int channel, 325 struct snd_pcm_hw_params *params) 326 { 327 unsigned int mclks, shift; 328 329 if (channel == PCM_MULTICH) 330 mclks = chip->model.dac_mclks; 331 else 332 mclks = chip->model.adc_mclks; 333 334 if (params_rate(params) <= 48000) 335 shift = 0; 336 else if (params_rate(params) <= 96000) 337 shift = 2; 338 else 339 shift = 4; 340 341 return OXYGEN_I2S_MCLK(mclks >> shift); 342 } 343 344 static int oxygen_rec_a_hw_params(struct snd_pcm_substream *substream, 345 struct snd_pcm_hw_params *hw_params) 346 { 347 struct oxygen *chip = snd_pcm_substream_chip(substream); 348 int err; 349 350 err = oxygen_hw_params(substream, hw_params); 351 if (err < 0) 352 return err; 353 354 spin_lock_irq(&chip->reg_lock); 355 oxygen_write8_masked(chip, OXYGEN_REC_FORMAT, 356 oxygen_format(hw_params) << OXYGEN_REC_FORMAT_A_SHIFT, 357 OXYGEN_REC_FORMAT_A_MASK); 358 oxygen_write16_masked(chip, OXYGEN_I2S_A_FORMAT, 359 oxygen_rate(hw_params) | 360 chip->model.adc_i2s_format | 361 get_mclk(chip, PCM_A, hw_params) | 362 oxygen_i2s_bits(hw_params), 363 OXYGEN_I2S_RATE_MASK | 364 OXYGEN_I2S_FORMAT_MASK | 365 OXYGEN_I2S_MCLK_MASK | 366 OXYGEN_I2S_BITS_MASK); 367 spin_unlock_irq(&chip->reg_lock); 368 369 mutex_lock(&chip->mutex); 370 chip->model.set_adc_params(chip, hw_params); 371 mutex_unlock(&chip->mutex); 372 return 0; 373 } 374 375 static int oxygen_rec_b_hw_params(struct snd_pcm_substream *substream, 376 struct snd_pcm_hw_params *hw_params) 377 { 378 struct oxygen *chip = snd_pcm_substream_chip(substream); 379 int is_ac97; 380 int err; 381 382 err = oxygen_hw_params(substream, hw_params); 383 if (err < 0) 384 return err; 385 386 is_ac97 = chip->has_ac97_1 && 387 (chip->model.device_config & CAPTURE_2_FROM_AC97_1); 388 389 spin_lock_irq(&chip->reg_lock); 390 oxygen_write8_masked(chip, OXYGEN_REC_FORMAT, 391 oxygen_format(hw_params) << OXYGEN_REC_FORMAT_B_SHIFT, 392 OXYGEN_REC_FORMAT_B_MASK); 393 if (!is_ac97) 394 oxygen_write16_masked(chip, OXYGEN_I2S_B_FORMAT, 395 oxygen_rate(hw_params) | 396 chip->model.adc_i2s_format | 397 get_mclk(chip, PCM_B, hw_params) | 398 oxygen_i2s_bits(hw_params), 399 OXYGEN_I2S_RATE_MASK | 400 OXYGEN_I2S_FORMAT_MASK | 401 OXYGEN_I2S_MCLK_MASK | 402 OXYGEN_I2S_BITS_MASK); 403 spin_unlock_irq(&chip->reg_lock); 404 405 if (!is_ac97) { 406 mutex_lock(&chip->mutex); 407 chip->model.set_adc_params(chip, hw_params); 408 mutex_unlock(&chip->mutex); 409 } 410 return 0; 411 } 412 413 static int oxygen_rec_c_hw_params(struct snd_pcm_substream *substream, 414 struct snd_pcm_hw_params *hw_params) 415 { 416 struct oxygen *chip = snd_pcm_substream_chip(substream); 417 bool is_spdif; 418 int err; 419 420 err = oxygen_hw_params(substream, hw_params); 421 if (err < 0) 422 return err; 423 424 is_spdif = chip->model.device_config & CAPTURE_1_FROM_SPDIF; 425 426 spin_lock_irq(&chip->reg_lock); 427 oxygen_write8_masked(chip, OXYGEN_REC_FORMAT, 428 oxygen_format(hw_params) << OXYGEN_REC_FORMAT_C_SHIFT, 429 OXYGEN_REC_FORMAT_C_MASK); 430 if (!is_spdif) 431 oxygen_write16_masked(chip, OXYGEN_I2S_C_FORMAT, 432 oxygen_rate(hw_params) | 433 chip->model.adc_i2s_format | 434 get_mclk(chip, PCM_B, hw_params) | 435 oxygen_i2s_bits(hw_params), 436 OXYGEN_I2S_RATE_MASK | 437 OXYGEN_I2S_FORMAT_MASK | 438 OXYGEN_I2S_MCLK_MASK | 439 OXYGEN_I2S_BITS_MASK); 440 spin_unlock_irq(&chip->reg_lock); 441 442 if (!is_spdif) { 443 mutex_lock(&chip->mutex); 444 chip->model.set_adc_params(chip, hw_params); 445 mutex_unlock(&chip->mutex); 446 } 447 return 0; 448 } 449 450 static int oxygen_spdif_hw_params(struct snd_pcm_substream *substream, 451 struct snd_pcm_hw_params *hw_params) 452 { 453 struct oxygen *chip = snd_pcm_substream_chip(substream); 454 int err; 455 456 err = oxygen_hw_params(substream, hw_params); 457 if (err < 0) 458 return err; 459 460 mutex_lock(&chip->mutex); 461 spin_lock_irq(&chip->reg_lock); 462 oxygen_clear_bits32(chip, OXYGEN_SPDIF_CONTROL, 463 OXYGEN_SPDIF_OUT_ENABLE); 464 oxygen_write8_masked(chip, OXYGEN_PLAY_FORMAT, 465 oxygen_format(hw_params) << OXYGEN_SPDIF_FORMAT_SHIFT, 466 OXYGEN_SPDIF_FORMAT_MASK); 467 oxygen_write32_masked(chip, OXYGEN_SPDIF_CONTROL, 468 oxygen_rate(hw_params) << OXYGEN_SPDIF_OUT_RATE_SHIFT, 469 OXYGEN_SPDIF_OUT_RATE_MASK); 470 oxygen_update_spdif_source(chip); 471 spin_unlock_irq(&chip->reg_lock); 472 mutex_unlock(&chip->mutex); 473 return 0; 474 } 475 476 static int oxygen_multich_hw_params(struct snd_pcm_substream *substream, 477 struct snd_pcm_hw_params *hw_params) 478 { 479 struct oxygen *chip = snd_pcm_substream_chip(substream); 480 int err; 481 482 err = oxygen_hw_params(substream, hw_params); 483 if (err < 0) 484 return err; 485 486 mutex_lock(&chip->mutex); 487 spin_lock_irq(&chip->reg_lock); 488 oxygen_write8_masked(chip, OXYGEN_PLAY_CHANNELS, 489 oxygen_play_channels(hw_params), 490 OXYGEN_PLAY_CHANNELS_MASK); 491 oxygen_write8_masked(chip, OXYGEN_PLAY_FORMAT, 492 oxygen_format(hw_params) << OXYGEN_MULTICH_FORMAT_SHIFT, 493 OXYGEN_MULTICH_FORMAT_MASK); 494 oxygen_write16_masked(chip, OXYGEN_I2S_MULTICH_FORMAT, 495 oxygen_rate(hw_params) | 496 chip->model.dac_i2s_format | 497 get_mclk(chip, PCM_MULTICH, hw_params) | 498 oxygen_i2s_bits(hw_params), 499 OXYGEN_I2S_RATE_MASK | 500 OXYGEN_I2S_FORMAT_MASK | 501 OXYGEN_I2S_MCLK_MASK | 502 OXYGEN_I2S_BITS_MASK); 503 oxygen_update_spdif_source(chip); 504 spin_unlock_irq(&chip->reg_lock); 505 506 chip->model.set_dac_params(chip, hw_params); 507 oxygen_update_dac_routing(chip); 508 mutex_unlock(&chip->mutex); 509 return 0; 510 } 511 512 static int oxygen_hw_free(struct snd_pcm_substream *substream) 513 { 514 struct oxygen *chip = snd_pcm_substream_chip(substream); 515 unsigned int channel = oxygen_substream_channel(substream); 516 unsigned int channel_mask = 1 << channel; 517 518 spin_lock_irq(&chip->reg_lock); 519 chip->interrupt_mask &= ~channel_mask; 520 oxygen_write16(chip, OXYGEN_INTERRUPT_MASK, chip->interrupt_mask); 521 522 oxygen_set_bits8(chip, OXYGEN_DMA_FLUSH, channel_mask); 523 oxygen_clear_bits8(chip, OXYGEN_DMA_FLUSH, channel_mask); 524 spin_unlock_irq(&chip->reg_lock); 525 526 return 0; 527 } 528 529 static int oxygen_spdif_hw_free(struct snd_pcm_substream *substream) 530 { 531 struct oxygen *chip = snd_pcm_substream_chip(substream); 532 533 spin_lock_irq(&chip->reg_lock); 534 oxygen_clear_bits32(chip, OXYGEN_SPDIF_CONTROL, 535 OXYGEN_SPDIF_OUT_ENABLE); 536 spin_unlock_irq(&chip->reg_lock); 537 return oxygen_hw_free(substream); 538 } 539 540 static int oxygen_prepare(struct snd_pcm_substream *substream) 541 { 542 struct oxygen *chip = snd_pcm_substream_chip(substream); 543 unsigned int channel = oxygen_substream_channel(substream); 544 unsigned int channel_mask = 1 << channel; 545 546 spin_lock_irq(&chip->reg_lock); 547 oxygen_set_bits8(chip, OXYGEN_DMA_FLUSH, channel_mask); 548 oxygen_clear_bits8(chip, OXYGEN_DMA_FLUSH, channel_mask); 549 550 if (substream->runtime->no_period_wakeup) 551 chip->interrupt_mask &= ~channel_mask; 552 else 553 chip->interrupt_mask |= channel_mask; 554 oxygen_write16(chip, OXYGEN_INTERRUPT_MASK, chip->interrupt_mask); 555 spin_unlock_irq(&chip->reg_lock); 556 return 0; 557 } 558 559 static int oxygen_trigger(struct snd_pcm_substream *substream, int cmd) 560 { 561 struct oxygen *chip = snd_pcm_substream_chip(substream); 562 struct snd_pcm_substream *s; 563 unsigned int mask = 0; 564 int pausing; 565 566 switch (cmd) { 567 case SNDRV_PCM_TRIGGER_STOP: 568 case SNDRV_PCM_TRIGGER_START: 569 case SNDRV_PCM_TRIGGER_SUSPEND: 570 pausing = 0; 571 break; 572 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 573 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 574 pausing = 1; 575 break; 576 default: 577 return -EINVAL; 578 } 579 580 snd_pcm_group_for_each_entry(s, substream) { 581 if (snd_pcm_substream_chip(s) == chip) { 582 mask |= 1 << oxygen_substream_channel(s); 583 snd_pcm_trigger_done(s, substream); 584 } 585 } 586 587 spin_lock(&chip->reg_lock); 588 if (!pausing) { 589 if (cmd == SNDRV_PCM_TRIGGER_START) 590 chip->pcm_running |= mask; 591 else 592 chip->pcm_running &= ~mask; 593 oxygen_write8(chip, OXYGEN_DMA_STATUS, chip->pcm_running); 594 } else { 595 if (cmd == SNDRV_PCM_TRIGGER_PAUSE_PUSH) 596 oxygen_set_bits8(chip, OXYGEN_DMA_PAUSE, mask); 597 else 598 oxygen_clear_bits8(chip, OXYGEN_DMA_PAUSE, mask); 599 } 600 spin_unlock(&chip->reg_lock); 601 return 0; 602 } 603 604 static snd_pcm_uframes_t oxygen_pointer(struct snd_pcm_substream *substream) 605 { 606 struct oxygen *chip = snd_pcm_substream_chip(substream); 607 struct snd_pcm_runtime *runtime = substream->runtime; 608 unsigned int channel = oxygen_substream_channel(substream); 609 u32 curr_addr; 610 611 /* no spinlock, this read should be atomic */ 612 curr_addr = oxygen_read32(chip, channel_base_registers[channel]); 613 return bytes_to_frames(runtime, curr_addr - (u32)runtime->dma_addr); 614 } 615 616 static const struct snd_pcm_ops oxygen_rec_a_ops = { 617 .open = oxygen_rec_a_open, 618 .close = oxygen_close, 619 .hw_params = oxygen_rec_a_hw_params, 620 .hw_free = oxygen_hw_free, 621 .prepare = oxygen_prepare, 622 .trigger = oxygen_trigger, 623 .pointer = oxygen_pointer, 624 }; 625 626 static const struct snd_pcm_ops oxygen_rec_b_ops = { 627 .open = oxygen_rec_b_open, 628 .close = oxygen_close, 629 .hw_params = oxygen_rec_b_hw_params, 630 .hw_free = oxygen_hw_free, 631 .prepare = oxygen_prepare, 632 .trigger = oxygen_trigger, 633 .pointer = oxygen_pointer, 634 }; 635 636 static const struct snd_pcm_ops oxygen_rec_c_ops = { 637 .open = oxygen_rec_c_open, 638 .close = oxygen_close, 639 .hw_params = oxygen_rec_c_hw_params, 640 .hw_free = oxygen_hw_free, 641 .prepare = oxygen_prepare, 642 .trigger = oxygen_trigger, 643 .pointer = oxygen_pointer, 644 }; 645 646 static const struct snd_pcm_ops oxygen_spdif_ops = { 647 .open = oxygen_spdif_open, 648 .close = oxygen_close, 649 .hw_params = oxygen_spdif_hw_params, 650 .hw_free = oxygen_spdif_hw_free, 651 .prepare = oxygen_prepare, 652 .trigger = oxygen_trigger, 653 .pointer = oxygen_pointer, 654 }; 655 656 static const struct snd_pcm_ops oxygen_multich_ops = { 657 .open = oxygen_multich_open, 658 .close = oxygen_close, 659 .hw_params = oxygen_multich_hw_params, 660 .hw_free = oxygen_hw_free, 661 .prepare = oxygen_prepare, 662 .trigger = oxygen_trigger, 663 .pointer = oxygen_pointer, 664 }; 665 666 static const struct snd_pcm_ops oxygen_ac97_ops = { 667 .open = oxygen_ac97_open, 668 .close = oxygen_close, 669 .hw_params = oxygen_hw_params, 670 .hw_free = oxygen_hw_free, 671 .prepare = oxygen_prepare, 672 .trigger = oxygen_trigger, 673 .pointer = oxygen_pointer, 674 }; 675 676 int oxygen_pcm_init(struct oxygen *chip) 677 { 678 struct snd_pcm *pcm; 679 int outs, ins; 680 int err; 681 682 outs = !!(chip->model.device_config & PLAYBACK_0_TO_I2S); 683 ins = !!(chip->model.device_config & (CAPTURE_0_FROM_I2S_1 | 684 CAPTURE_0_FROM_I2S_2)); 685 if (outs | ins) { 686 err = snd_pcm_new(chip->card, "Multichannel", 687 0, outs, ins, &pcm); 688 if (err < 0) 689 return err; 690 if (outs) 691 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 692 &oxygen_multich_ops); 693 if (chip->model.device_config & CAPTURE_0_FROM_I2S_1) 694 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, 695 &oxygen_rec_a_ops); 696 else if (chip->model.device_config & CAPTURE_0_FROM_I2S_2) 697 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, 698 &oxygen_rec_b_ops); 699 pcm->private_data = chip; 700 strcpy(pcm->name, "Multichannel"); 701 if (outs) 702 snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream, 703 SNDRV_DMA_TYPE_DEV, 704 &chip->pci->dev, 705 DEFAULT_BUFFER_BYTES_MULTICH, 706 BUFFER_BYTES_MAX_MULTICH); 707 if (ins) 708 snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream, 709 SNDRV_DMA_TYPE_DEV, 710 &chip->pci->dev, 711 DEFAULT_BUFFER_BYTES, 712 BUFFER_BYTES_MAX); 713 } 714 715 outs = !!(chip->model.device_config & PLAYBACK_1_TO_SPDIF); 716 ins = !!(chip->model.device_config & CAPTURE_1_FROM_SPDIF); 717 if (outs | ins) { 718 err = snd_pcm_new(chip->card, "Digital", 1, outs, ins, &pcm); 719 if (err < 0) 720 return err; 721 if (outs) 722 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 723 &oxygen_spdif_ops); 724 if (ins) 725 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, 726 &oxygen_rec_c_ops); 727 pcm->private_data = chip; 728 strcpy(pcm->name, "Digital"); 729 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV, 730 &chip->pci->dev, 731 DEFAULT_BUFFER_BYTES, 732 BUFFER_BYTES_MAX); 733 } 734 735 if (chip->has_ac97_1) { 736 outs = !!(chip->model.device_config & PLAYBACK_2_TO_AC97_1); 737 ins = !!(chip->model.device_config & CAPTURE_2_FROM_AC97_1); 738 } else { 739 outs = 0; 740 ins = !!(chip->model.device_config & CAPTURE_2_FROM_I2S_2); 741 } 742 if (outs | ins) { 743 err = snd_pcm_new(chip->card, outs ? "AC97" : "Analog2", 744 2, outs, ins, &pcm); 745 if (err < 0) 746 return err; 747 if (outs) { 748 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 749 &oxygen_ac97_ops); 750 oxygen_write8_masked(chip, OXYGEN_REC_ROUTING, 751 OXYGEN_REC_B_ROUTE_AC97_1, 752 OXYGEN_REC_B_ROUTE_MASK); 753 } 754 if (ins) 755 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, 756 &oxygen_rec_b_ops); 757 pcm->private_data = chip; 758 strcpy(pcm->name, outs ? "Front Panel" : "Analog 2"); 759 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV, 760 &chip->pci->dev, 761 DEFAULT_BUFFER_BYTES, 762 BUFFER_BYTES_MAX); 763 } 764 765 ins = !!(chip->model.device_config & CAPTURE_3_FROM_I2S_3); 766 if (ins) { 767 err = snd_pcm_new(chip->card, "Analog3", 3, 0, ins, &pcm); 768 if (err < 0) 769 return err; 770 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, 771 &oxygen_rec_c_ops); 772 oxygen_write8_masked(chip, OXYGEN_REC_ROUTING, 773 OXYGEN_REC_C_ROUTE_I2S_ADC_3, 774 OXYGEN_REC_C_ROUTE_MASK); 775 pcm->private_data = chip; 776 strcpy(pcm->name, "Analog 3"); 777 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV, 778 &chip->pci->dev, 779 DEFAULT_BUFFER_BYTES, 780 BUFFER_BYTES_MAX); 781 } 782 return 0; 783 } 784