1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved. 4 * 5 * @File ctatc.c 6 * 7 * @Brief 8 * This file contains the implementation of the device resource management 9 * object. 10 * 11 * @Author Liu Chun 12 * @Date Mar 28 2008 13 */ 14 15 #include "ctatc.h" 16 #include "ctpcm.h" 17 #include "ctmixer.h" 18 #include "ctsrc.h" 19 #include "ctamixer.h" 20 #include "ctdaio.h" 21 #include "cttimer.h" 22 #include <linux/delay.h> 23 #include <linux/slab.h> 24 #include <sound/pcm.h> 25 #include <sound/control.h> 26 #include <sound/asoundef.h> 27 28 #define NUM_ATC_SRCS 6 29 #define NUM_ATC_PCM (2 * 4) 30 31 #define MONO_SUM_SCALE 0x19a8 /* 2^(-0.5) in 14-bit floating format */ 32 #define MAX_MULTI_CHN 8 33 34 #define IEC958_DEFAULT_CON ((IEC958_AES0_NONAUDIO \ 35 | IEC958_AES0_CON_NOT_COPYRIGHT) \ 36 | ((IEC958_AES1_CON_MIXER \ 37 | IEC958_AES1_CON_ORIGINAL) << 8) \ 38 | (0x10 << 16) \ 39 | ((IEC958_AES3_CON_FS_48000) << 24)) 40 41 static const struct snd_pci_quirk subsys_20k1_list[] = { 42 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, 0x0021, "SB046x", CTSB046X), 43 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, 0x0022, "SB055x", CTSB055X), 44 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, 0x002f, "SB055x", CTSB055X), 45 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, 0x0029, "SB073x", CTSB073X), 46 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, 0x0031, "SB073x", CTSB073X), 47 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_CREATIVE, 0xf000, 0x6000, 48 "UAA", CTUAA), 49 { } /* terminator */ 50 }; 51 52 static const struct snd_pci_quirk subsys_20k2_list[] = { 53 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, PCI_SUBDEVICE_ID_CREATIVE_SB0760, 54 "SB0760", CTSB0760), 55 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, PCI_SUBDEVICE_ID_CREATIVE_SB08801, 56 "SB0880", CTSB0880), 57 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, PCI_SUBDEVICE_ID_CREATIVE_SB08802, 58 "SB0880", CTSB0880), 59 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, PCI_SUBDEVICE_ID_CREATIVE_SB08803, 60 "SB0880", CTSB0880), 61 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, PCI_SUBDEVICE_ID_CREATIVE_SB1270, 62 "SB1270", CTSB1270), 63 SND_PCI_QUIRK(0x160b, 0x0101, "OK0010", CTOK0010), 64 SND_PCI_QUIRK(0x160b, 0x0102, "OK0010", CTOK0010), 65 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_CREATIVE, 0xf000, 66 PCI_SUBDEVICE_ID_CREATIVE_HENDRIX, "HENDRIX", 67 CTHENDRIX), 68 { } /* terminator */ 69 }; 70 71 static const char *ct_subsys_name[NUM_CTCARDS] = { 72 /* 20k1 models */ 73 [CTSB046X] = "SB046x", 74 [CTSB055X] = "SB055x", 75 [CTSB073X] = "SB073x", 76 [CTUAA] = "UAA", 77 [CT20K1_UNKNOWN] = "Unknown", 78 /* 20k2 models */ 79 [CTSB0760] = "SB076x", 80 [CTHENDRIX] = "Hendrix", 81 [CTSB0880] = "SB0880", 82 [CTSB1270] = "SB1270", 83 [CTOK0010] = "OK0010", 84 [CT20K2_UNKNOWN] = "Unknown", 85 }; 86 87 static struct { 88 int (*create)(struct ct_atc *atc, 89 enum CTALSADEVS device, const char *device_name); 90 int (*destroy)(void *alsa_dev); 91 const char *public_name; 92 } alsa_dev_funcs[NUM_CTALSADEVS] = { 93 [FRONT] = { .create = ct_alsa_pcm_create, 94 .destroy = NULL, 95 .public_name = "Front/WaveIn"}, 96 [SURROUND] = { .create = ct_alsa_pcm_create, 97 .destroy = NULL, 98 .public_name = "Surround"}, 99 [CLFE] = { .create = ct_alsa_pcm_create, 100 .destroy = NULL, 101 .public_name = "Center/LFE"}, 102 [SIDE] = { .create = ct_alsa_pcm_create, 103 .destroy = NULL, 104 .public_name = "Side"}, 105 [IEC958] = { .create = ct_alsa_pcm_create, 106 .destroy = NULL, 107 .public_name = "IEC958 Non-audio"}, 108 109 [MIXER] = { .create = ct_alsa_mix_create, 110 .destroy = NULL, 111 .public_name = "Mixer"} 112 }; 113 114 static struct { 115 int (*create)(struct hw *hw, void **rmgr); 116 int (*destroy)(void *mgr); 117 } rsc_mgr_funcs[NUM_RSCTYP] = { 118 [SRC] = { .create = src_mgr_create, 119 .destroy = src_mgr_destroy }, 120 [SRCIMP] = { .create = srcimp_mgr_create, 121 .destroy = srcimp_mgr_destroy }, 122 [AMIXER] = { .create = amixer_mgr_create, 123 .destroy = amixer_mgr_destroy }, 124 [SUM] = { .create = sum_mgr_create, 125 .destroy = sum_mgr_destroy }, 126 [DAIO] = { .create = daio_mgr_create, 127 .destroy = daio_mgr_destroy } 128 }; 129 130 static int 131 atc_pcm_release_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm); 132 133 /* * 134 * Only mono and interleaved modes are supported now. 135 * Always allocates a contiguous channel block. 136 * */ 137 138 static int ct_map_audio_buffer(struct ct_atc *atc, struct ct_atc_pcm *apcm) 139 { 140 struct snd_pcm_runtime *runtime; 141 struct ct_vm *vm; 142 143 if (!apcm->substream) 144 return 0; 145 146 runtime = apcm->substream->runtime; 147 vm = atc->vm; 148 149 apcm->vm_block = vm->map(vm, apcm->substream, runtime->dma_bytes); 150 151 if (!apcm->vm_block) 152 return -ENOENT; 153 154 return 0; 155 } 156 157 static void ct_unmap_audio_buffer(struct ct_atc *atc, struct ct_atc_pcm *apcm) 158 { 159 struct ct_vm *vm; 160 161 if (!apcm->vm_block) 162 return; 163 164 vm = atc->vm; 165 166 vm->unmap(vm, apcm->vm_block); 167 168 apcm->vm_block = NULL; 169 } 170 171 static unsigned long atc_get_ptp_phys(struct ct_atc *atc, int index) 172 { 173 return atc->vm->get_ptp_phys(atc->vm, index); 174 } 175 176 static unsigned int convert_format(snd_pcm_format_t snd_format, 177 struct snd_card *card) 178 { 179 switch (snd_format) { 180 case SNDRV_PCM_FORMAT_U8: 181 return SRC_SF_U8; 182 case SNDRV_PCM_FORMAT_S16_LE: 183 return SRC_SF_S16; 184 case SNDRV_PCM_FORMAT_S24_3LE: 185 return SRC_SF_S24; 186 case SNDRV_PCM_FORMAT_S32_LE: 187 return SRC_SF_S32; 188 case SNDRV_PCM_FORMAT_FLOAT_LE: 189 return SRC_SF_F32; 190 default: 191 dev_err(card->dev, "not recognized snd format is %d\n", 192 snd_format); 193 return SRC_SF_S16; 194 } 195 } 196 197 static unsigned int 198 atc_get_pitch(unsigned int input_rate, unsigned int output_rate) 199 { 200 unsigned int pitch; 201 int b; 202 203 /* get pitch and convert to fixed-point 8.24 format. */ 204 pitch = (input_rate / output_rate) << 24; 205 input_rate %= output_rate; 206 input_rate /= 100; 207 output_rate /= 100; 208 for (b = 31; ((b >= 0) && !(input_rate >> b)); ) 209 b--; 210 211 if (b >= 0) { 212 input_rate <<= (31 - b); 213 input_rate /= output_rate; 214 b = 24 - (31 - b); 215 if (b >= 0) 216 input_rate <<= b; 217 else 218 input_rate >>= -b; 219 220 pitch |= input_rate; 221 } 222 223 return pitch; 224 } 225 226 static int select_rom(unsigned int pitch) 227 { 228 if (pitch > 0x00428f5c && pitch < 0x01b851ec) { 229 /* 0.26 <= pitch <= 1.72 */ 230 return 1; 231 } else if (pitch == 0x01d66666 || pitch == 0x01d66667) { 232 /* pitch == 1.8375 */ 233 return 2; 234 } else if (pitch == 0x02000000) { 235 /* pitch == 2 */ 236 return 3; 237 } else if (pitch <= 0x08000000) { 238 /* 0 <= pitch <= 8 */ 239 return 0; 240 } else { 241 return -ENOENT; 242 } 243 } 244 245 static int atc_pcm_playback_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm) 246 { 247 struct src_mgr *src_mgr = atc->rsc_mgrs[SRC]; 248 struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER]; 249 struct src_desc desc = {0}; 250 struct amixer_desc mix_dsc = {0}; 251 struct src *src; 252 struct amixer *amixer; 253 int err; 254 int n_amixer = apcm->substream->runtime->channels, i = 0; 255 int device = apcm->substream->pcm->device; 256 unsigned int pitch; 257 258 /* first release old resources */ 259 atc_pcm_release_resources(atc, apcm); 260 261 /* Get SRC resource */ 262 desc.multi = apcm->substream->runtime->channels; 263 desc.msr = atc->msr; 264 desc.mode = MEMRD; 265 err = src_mgr->get_src(src_mgr, &desc, (struct src **)&apcm->src); 266 if (err) 267 goto error1; 268 269 pitch = atc_get_pitch(apcm->substream->runtime->rate, 270 (atc->rsr * atc->msr)); 271 src = apcm->src; 272 src->ops->set_pitch(src, pitch); 273 src->ops->set_rom(src, select_rom(pitch)); 274 src->ops->set_sf(src, convert_format(apcm->substream->runtime->format, 275 atc->card)); 276 src->ops->set_pm(src, (src->ops->next_interleave(src) != NULL)); 277 278 /* Get AMIXER resource */ 279 n_amixer = (n_amixer < 2) ? 2 : n_amixer; 280 apcm->amixers = kcalloc(n_amixer, sizeof(void *), GFP_KERNEL); 281 if (!apcm->amixers) { 282 err = -ENOMEM; 283 goto error1; 284 } 285 mix_dsc.msr = atc->msr; 286 for (i = 0, apcm->n_amixer = 0; i < n_amixer; i++) { 287 err = amixer_mgr->get_amixer(amixer_mgr, &mix_dsc, 288 (struct amixer **)&apcm->amixers[i]); 289 if (err) 290 goto error1; 291 292 apcm->n_amixer++; 293 } 294 295 /* Set up device virtual mem map */ 296 err = ct_map_audio_buffer(atc, apcm); 297 if (err < 0) 298 goto error1; 299 300 /* Connect resources */ 301 src = apcm->src; 302 for (i = 0; i < n_amixer; i++) { 303 amixer = apcm->amixers[i]; 304 scoped_guard(mutex, &atc->atc_mutex) { 305 amixer->ops->setup(amixer, &src->rsc, 306 INIT_VOL, atc->pcm[i+device*2]); 307 } 308 src = src->ops->next_interleave(src); 309 if (!src) 310 src = apcm->src; 311 } 312 313 ct_timer_prepare(apcm->timer); 314 315 return 0; 316 317 error1: 318 atc_pcm_release_resources(atc, apcm); 319 return err; 320 } 321 322 static int 323 atc_pcm_release_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm) 324 { 325 struct src_mgr *src_mgr = atc->rsc_mgrs[SRC]; 326 struct srcimp_mgr *srcimp_mgr = atc->rsc_mgrs[SRCIMP]; 327 struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER]; 328 struct sum_mgr *sum_mgr = atc->rsc_mgrs[SUM]; 329 struct srcimp *srcimp; 330 int i; 331 332 if (apcm->srcimps) { 333 for (i = 0; i < apcm->n_srcimp; i++) { 334 srcimp = apcm->srcimps[i]; 335 srcimp->ops->unmap(srcimp); 336 srcimp_mgr->put_srcimp(srcimp_mgr, srcimp); 337 apcm->srcimps[i] = NULL; 338 } 339 kfree(apcm->srcimps); 340 apcm->srcimps = NULL; 341 } 342 343 if (apcm->srccs) { 344 for (i = 0; i < apcm->n_srcc; i++) { 345 src_mgr->put_src(src_mgr, apcm->srccs[i]); 346 apcm->srccs[i] = NULL; 347 } 348 kfree(apcm->srccs); 349 apcm->srccs = NULL; 350 } 351 352 if (apcm->amixers) { 353 for (i = 0; i < apcm->n_amixer; i++) { 354 amixer_mgr->put_amixer(amixer_mgr, apcm->amixers[i]); 355 apcm->amixers[i] = NULL; 356 } 357 kfree(apcm->amixers); 358 apcm->amixers = NULL; 359 } 360 361 if (apcm->mono) { 362 sum_mgr->put_sum(sum_mgr, apcm->mono); 363 apcm->mono = NULL; 364 } 365 366 if (apcm->src) { 367 src_mgr->put_src(src_mgr, apcm->src); 368 apcm->src = NULL; 369 } 370 371 if (apcm->vm_block) { 372 /* Undo device virtual mem map */ 373 ct_unmap_audio_buffer(atc, apcm); 374 apcm->vm_block = NULL; 375 } 376 377 return 0; 378 } 379 380 static int atc_pcm_playback_start(struct ct_atc *atc, struct ct_atc_pcm *apcm) 381 { 382 unsigned int max_cisz; 383 struct src *src = apcm->src; 384 385 if (apcm->started) 386 return 0; 387 apcm->started = 1; 388 389 max_cisz = src->multi * src->rsc.msr; 390 max_cisz = 0x80 * (max_cisz < 8 ? max_cisz : 8); 391 392 src->ops->set_sa(src, apcm->vm_block->addr); 393 src->ops->set_la(src, apcm->vm_block->addr + apcm->vm_block->size); 394 src->ops->set_ca(src, apcm->vm_block->addr + max_cisz); 395 src->ops->set_cisz(src, max_cisz); 396 397 src->ops->set_bm(src, 1); 398 src->ops->set_state(src, SRC_STATE_INIT); 399 src->ops->commit_write(src); 400 401 ct_timer_start(apcm->timer); 402 return 0; 403 } 404 405 static int atc_pcm_stop(struct ct_atc *atc, struct ct_atc_pcm *apcm) 406 { 407 struct src *src; 408 int i; 409 410 ct_timer_stop(apcm->timer); 411 412 src = apcm->src; 413 src->ops->set_bm(src, 0); 414 src->ops->set_state(src, SRC_STATE_OFF); 415 src->ops->commit_write(src); 416 417 if (apcm->srccs) { 418 for (i = 0; i < apcm->n_srcc; i++) { 419 src = apcm->srccs[i]; 420 src->ops->set_bm(src, 0); 421 src->ops->set_state(src, SRC_STATE_OFF); 422 src->ops->commit_write(src); 423 } 424 } 425 426 apcm->started = 0; 427 428 return 0; 429 } 430 431 static int 432 atc_pcm_playback_position(struct ct_atc *atc, struct ct_atc_pcm *apcm) 433 { 434 struct src *src = apcm->src; 435 u32 size, max_cisz; 436 int position; 437 438 if (!src) 439 return 0; 440 position = src->ops->get_ca(src); 441 442 if (position < apcm->vm_block->addr) { 443 dev_dbg(atc->card->dev, 444 "bad ca - ca=0x%08x, vba=0x%08x, vbs=0x%08x\n", 445 position, apcm->vm_block->addr, apcm->vm_block->size); 446 position = apcm->vm_block->addr; 447 } 448 449 size = apcm->vm_block->size; 450 max_cisz = src->multi * src->rsc.msr; 451 max_cisz = 128 * (max_cisz < 8 ? max_cisz : 8); 452 453 return (position + size - max_cisz - apcm->vm_block->addr) % size; 454 } 455 456 struct src_node_conf_t { 457 unsigned int pitch; 458 unsigned int msr:8; 459 unsigned int mix_msr:8; 460 unsigned int imp_msr:8; 461 unsigned int vo:1; 462 }; 463 464 static void setup_src_node_conf(struct ct_atc *atc, struct ct_atc_pcm *apcm, 465 struct src_node_conf_t *conf, int *n_srcc) 466 { 467 unsigned int pitch; 468 469 /* get pitch and convert to fixed-point 8.24 format. */ 470 pitch = atc_get_pitch((atc->rsr * atc->msr), 471 apcm->substream->runtime->rate); 472 *n_srcc = 0; 473 474 if (1 == atc->msr) { /* FIXME: do we really need SRC here if pitch==1 */ 475 *n_srcc = apcm->substream->runtime->channels; 476 conf[0].pitch = pitch; 477 conf[0].mix_msr = conf[0].imp_msr = conf[0].msr = 1; 478 conf[0].vo = 1; 479 } else if (2 <= atc->msr) { 480 if (0x8000000 < pitch) { 481 /* Need two-stage SRCs, SRCIMPs and 482 * AMIXERs for converting format */ 483 conf[0].pitch = (atc->msr << 24); 484 conf[0].msr = conf[0].mix_msr = 1; 485 conf[0].imp_msr = atc->msr; 486 conf[0].vo = 0; 487 conf[1].pitch = atc_get_pitch(atc->rsr, 488 apcm->substream->runtime->rate); 489 conf[1].msr = conf[1].mix_msr = conf[1].imp_msr = 1; 490 conf[1].vo = 1; 491 *n_srcc = apcm->substream->runtime->channels * 2; 492 } else if (0x1000000 < pitch) { 493 /* Need one-stage SRCs, SRCIMPs and 494 * AMIXERs for converting format */ 495 conf[0].pitch = pitch; 496 conf[0].msr = conf[0].mix_msr 497 = conf[0].imp_msr = atc->msr; 498 conf[0].vo = 1; 499 *n_srcc = apcm->substream->runtime->channels; 500 } 501 } 502 } 503 504 static int 505 atc_pcm_capture_get_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm) 506 { 507 struct src_mgr *src_mgr = atc->rsc_mgrs[SRC]; 508 struct srcimp_mgr *srcimp_mgr = atc->rsc_mgrs[SRCIMP]; 509 struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER]; 510 struct sum_mgr *sum_mgr = atc->rsc_mgrs[SUM]; 511 struct src_desc src_dsc = {0}; 512 struct src *src; 513 struct srcimp_desc srcimp_dsc = {0}; 514 struct srcimp *srcimp; 515 struct amixer_desc mix_dsc = {0}; 516 struct sum_desc sum_dsc = {0}; 517 unsigned int pitch; 518 int multi, err, i; 519 int n_srcimp, n_amixer, n_srcc, n_sum; 520 struct src_node_conf_t src_node_conf[2] = {{0} }; 521 522 /* first release old resources */ 523 atc_pcm_release_resources(atc, apcm); 524 525 /* The numbers of converting SRCs and SRCIMPs should be determined 526 * by pitch value. */ 527 528 multi = apcm->substream->runtime->channels; 529 530 /* get pitch and convert to fixed-point 8.24 format. */ 531 pitch = atc_get_pitch((atc->rsr * atc->msr), 532 apcm->substream->runtime->rate); 533 534 setup_src_node_conf(atc, apcm, src_node_conf, &n_srcc); 535 n_sum = (1 == multi) ? 1 : 0; 536 n_amixer = n_sum * 2 + n_srcc; 537 n_srcimp = n_srcc; 538 if ((multi > 1) && (0x8000000 >= pitch)) { 539 /* Need extra AMIXERs and SRCIMPs for special treatment 540 * of interleaved recording of conjugate channels */ 541 n_amixer += multi * atc->msr; 542 n_srcimp += multi * atc->msr; 543 } else { 544 n_srcimp += multi; 545 } 546 547 if (n_srcc) { 548 apcm->srccs = kcalloc(n_srcc, sizeof(void *), GFP_KERNEL); 549 if (!apcm->srccs) 550 return -ENOMEM; 551 } 552 if (n_amixer) { 553 apcm->amixers = kcalloc(n_amixer, sizeof(void *), GFP_KERNEL); 554 if (!apcm->amixers) { 555 err = -ENOMEM; 556 goto error1; 557 } 558 } 559 apcm->srcimps = kcalloc(n_srcimp, sizeof(void *), GFP_KERNEL); 560 if (!apcm->srcimps) { 561 err = -ENOMEM; 562 goto error1; 563 } 564 565 /* Allocate SRCs for sample rate conversion if needed */ 566 src_dsc.multi = 1; 567 src_dsc.mode = ARCRW; 568 for (i = 0, apcm->n_srcc = 0; i < n_srcc; i++) { 569 src_dsc.msr = src_node_conf[i/multi].msr; 570 err = src_mgr->get_src(src_mgr, &src_dsc, 571 (struct src **)&apcm->srccs[i]); 572 if (err) 573 goto error1; 574 575 src = apcm->srccs[i]; 576 pitch = src_node_conf[i/multi].pitch; 577 src->ops->set_pitch(src, pitch); 578 src->ops->set_rom(src, select_rom(pitch)); 579 src->ops->set_vo(src, src_node_conf[i/multi].vo); 580 581 apcm->n_srcc++; 582 } 583 584 /* Allocate AMIXERs for routing SRCs of conversion if needed */ 585 for (i = 0, apcm->n_amixer = 0; i < n_amixer; i++) { 586 if (i < (n_sum*2)) 587 mix_dsc.msr = atc->msr; 588 else if (i < (n_sum*2+n_srcc)) 589 mix_dsc.msr = src_node_conf[(i-n_sum*2)/multi].mix_msr; 590 else 591 mix_dsc.msr = 1; 592 593 err = amixer_mgr->get_amixer(amixer_mgr, &mix_dsc, 594 (struct amixer **)&apcm->amixers[i]); 595 if (err) 596 goto error1; 597 598 apcm->n_amixer++; 599 } 600 601 /* Allocate a SUM resource to mix all input channels together */ 602 sum_dsc.msr = atc->msr; 603 err = sum_mgr->get_sum(sum_mgr, &sum_dsc, (struct sum **)&apcm->mono); 604 if (err) 605 goto error1; 606 607 pitch = atc_get_pitch((atc->rsr * atc->msr), 608 apcm->substream->runtime->rate); 609 /* Allocate SRCIMP resources */ 610 for (i = 0, apcm->n_srcimp = 0; i < n_srcimp; i++) { 611 if (i < (n_srcc)) 612 srcimp_dsc.msr = src_node_conf[i/multi].imp_msr; 613 else if (1 == multi) 614 srcimp_dsc.msr = (pitch <= 0x8000000) ? atc->msr : 1; 615 else 616 srcimp_dsc.msr = 1; 617 618 err = srcimp_mgr->get_srcimp(srcimp_mgr, &srcimp_dsc, &srcimp); 619 if (err) 620 goto error1; 621 622 apcm->srcimps[i] = srcimp; 623 apcm->n_srcimp++; 624 } 625 626 /* Allocate a SRC for writing data to host memory */ 627 src_dsc.multi = apcm->substream->runtime->channels; 628 src_dsc.msr = 1; 629 src_dsc.mode = MEMWR; 630 err = src_mgr->get_src(src_mgr, &src_dsc, (struct src **)&apcm->src); 631 if (err) 632 goto error1; 633 634 src = apcm->src; 635 src->ops->set_pitch(src, pitch); 636 637 /* Set up device virtual mem map */ 638 err = ct_map_audio_buffer(atc, apcm); 639 if (err < 0) 640 goto error1; 641 642 return 0; 643 644 error1: 645 atc_pcm_release_resources(atc, apcm); 646 return err; 647 } 648 649 static int atc_pcm_capture_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm) 650 { 651 struct src *src; 652 struct amixer *amixer; 653 struct srcimp *srcimp; 654 struct ct_mixer *mixer = atc->mixer; 655 struct sum *mono; 656 struct rsc *out_ports[8] = {NULL}; 657 int err, i, j, n_sum, multi; 658 unsigned int pitch; 659 int mix_base = 0, imp_base = 0; 660 661 atc_pcm_release_resources(atc, apcm); 662 663 /* Get needed resources. */ 664 err = atc_pcm_capture_get_resources(atc, apcm); 665 if (err) 666 return err; 667 668 /* Connect resources */ 669 mixer->get_output_ports(mixer, MIX_PCMO_FRONT, 670 &out_ports[0], &out_ports[1]); 671 672 multi = apcm->substream->runtime->channels; 673 if (1 == multi) { 674 mono = apcm->mono; 675 for (i = 0; i < 2; i++) { 676 amixer = apcm->amixers[i]; 677 amixer->ops->setup(amixer, out_ports[i], 678 MONO_SUM_SCALE, mono); 679 } 680 out_ports[0] = &mono->rsc; 681 n_sum = 1; 682 mix_base = n_sum * 2; 683 } 684 685 for (i = 0; i < apcm->n_srcc; i++) { 686 src = apcm->srccs[i]; 687 srcimp = apcm->srcimps[imp_base+i]; 688 amixer = apcm->amixers[mix_base+i]; 689 srcimp->ops->map(srcimp, src, out_ports[i%multi]); 690 amixer->ops->setup(amixer, &src->rsc, INIT_VOL, NULL); 691 out_ports[i%multi] = &amixer->rsc; 692 } 693 694 pitch = atc_get_pitch((atc->rsr * atc->msr), 695 apcm->substream->runtime->rate); 696 697 if ((multi > 1) && (pitch <= 0x8000000)) { 698 /* Special connection for interleaved 699 * recording with conjugate channels */ 700 for (i = 0; i < multi; i++) { 701 out_ports[i]->ops->master(out_ports[i]); 702 for (j = 0; j < atc->msr; j++) { 703 amixer = apcm->amixers[apcm->n_srcc+j*multi+i]; 704 amixer->ops->set_input(amixer, out_ports[i]); 705 amixer->ops->set_scale(amixer, INIT_VOL); 706 amixer->ops->set_sum(amixer, NULL); 707 amixer->ops->commit_raw_write(amixer); 708 out_ports[i]->ops->next_conj(out_ports[i]); 709 710 srcimp = apcm->srcimps[apcm->n_srcc+j*multi+i]; 711 srcimp->ops->map(srcimp, apcm->src, 712 &amixer->rsc); 713 } 714 } 715 } else { 716 for (i = 0; i < multi; i++) { 717 srcimp = apcm->srcimps[apcm->n_srcc+i]; 718 srcimp->ops->map(srcimp, apcm->src, out_ports[i]); 719 } 720 } 721 722 ct_timer_prepare(apcm->timer); 723 724 return 0; 725 } 726 727 static int atc_pcm_capture_start(struct ct_atc *atc, struct ct_atc_pcm *apcm) 728 { 729 struct src *src; 730 struct src_mgr *src_mgr = atc->rsc_mgrs[SRC]; 731 int i, multi; 732 733 if (apcm->started) 734 return 0; 735 736 apcm->started = 1; 737 multi = apcm->substream->runtime->channels; 738 /* Set up converting SRCs */ 739 for (i = 0; i < apcm->n_srcc; i++) { 740 src = apcm->srccs[i]; 741 src->ops->set_pm(src, ((i%multi) != (multi-1))); 742 src_mgr->src_disable(src_mgr, src); 743 } 744 745 /* Set up recording SRC */ 746 src = apcm->src; 747 src->ops->set_sf(src, convert_format(apcm->substream->runtime->format, 748 atc->card)); 749 src->ops->set_sa(src, apcm->vm_block->addr); 750 src->ops->set_la(src, apcm->vm_block->addr + apcm->vm_block->size); 751 src->ops->set_ca(src, apcm->vm_block->addr); 752 src_mgr->src_disable(src_mgr, src); 753 754 /* Disable relevant SRCs firstly */ 755 src_mgr->commit_write(src_mgr); 756 757 /* Enable SRCs respectively */ 758 for (i = 0; i < apcm->n_srcc; i++) { 759 src = apcm->srccs[i]; 760 src->ops->set_state(src, SRC_STATE_RUN); 761 src->ops->commit_write(src); 762 src_mgr->src_enable_s(src_mgr, src); 763 } 764 src = apcm->src; 765 src->ops->set_bm(src, 1); 766 src->ops->set_state(src, SRC_STATE_RUN); 767 src->ops->commit_write(src); 768 src_mgr->src_enable_s(src_mgr, src); 769 770 /* Enable relevant SRCs synchronously */ 771 src_mgr->commit_write(src_mgr); 772 773 ct_timer_start(apcm->timer); 774 return 0; 775 } 776 777 static int 778 atc_pcm_capture_position(struct ct_atc *atc, struct ct_atc_pcm *apcm) 779 { 780 struct src *src = apcm->src; 781 782 if (!src) 783 return 0; 784 return src->ops->get_ca(src) - apcm->vm_block->addr; 785 } 786 787 static int spdif_passthru_playback_get_resources(struct ct_atc *atc, 788 struct ct_atc_pcm *apcm) 789 { 790 struct src_mgr *src_mgr = atc->rsc_mgrs[SRC]; 791 struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER]; 792 struct src_desc desc = {0}; 793 struct amixer_desc mix_dsc = {0}; 794 struct src *src; 795 int err; 796 int n_amixer = apcm->substream->runtime->channels, i; 797 unsigned int pitch, rsr = atc->pll_rate; 798 799 /* first release old resources */ 800 atc_pcm_release_resources(atc, apcm); 801 802 /* Get SRC resource */ 803 desc.multi = apcm->substream->runtime->channels; 804 desc.msr = 1; 805 while (apcm->substream->runtime->rate > (rsr * desc.msr)) 806 desc.msr <<= 1; 807 808 desc.mode = MEMRD; 809 err = src_mgr->get_src(src_mgr, &desc, (struct src **)&apcm->src); 810 if (err) 811 goto error1; 812 813 pitch = atc_get_pitch(apcm->substream->runtime->rate, (rsr * desc.msr)); 814 src = apcm->src; 815 src->ops->set_pitch(src, pitch); 816 src->ops->set_rom(src, select_rom(pitch)); 817 src->ops->set_sf(src, convert_format(apcm->substream->runtime->format, 818 atc->card)); 819 src->ops->set_pm(src, (src->ops->next_interleave(src) != NULL)); 820 src->ops->set_bp(src, 1); 821 822 /* Get AMIXER resource */ 823 n_amixer = (n_amixer < 2) ? 2 : n_amixer; 824 apcm->amixers = kcalloc(n_amixer, sizeof(void *), GFP_KERNEL); 825 if (!apcm->amixers) { 826 err = -ENOMEM; 827 goto error1; 828 } 829 mix_dsc.msr = desc.msr; 830 for (i = 0, apcm->n_amixer = 0; i < n_amixer; i++) { 831 err = amixer_mgr->get_amixer(amixer_mgr, &mix_dsc, 832 (struct amixer **)&apcm->amixers[i]); 833 if (err) 834 goto error1; 835 836 apcm->n_amixer++; 837 } 838 839 /* Set up device virtual mem map */ 840 err = ct_map_audio_buffer(atc, apcm); 841 if (err < 0) 842 goto error1; 843 844 return 0; 845 846 error1: 847 atc_pcm_release_resources(atc, apcm); 848 return err; 849 } 850 851 static int atc_pll_init(struct ct_atc *atc, int rate) 852 { 853 struct hw *hw = atc->hw; 854 int err; 855 err = hw->pll_init(hw, rate); 856 atc->pll_rate = err ? 0 : rate; 857 return err; 858 } 859 860 static int 861 spdif_passthru_playback_setup(struct ct_atc *atc, struct ct_atc_pcm *apcm) 862 { 863 struct dao *dao = container_of(atc->daios[SPDIFOO], struct dao, daio); 864 unsigned int rate = apcm->substream->runtime->rate; 865 unsigned int status; 866 int err = 0; 867 unsigned char iec958_con_fs; 868 869 switch (rate) { 870 case 48000: 871 iec958_con_fs = IEC958_AES3_CON_FS_48000; 872 break; 873 case 44100: 874 iec958_con_fs = IEC958_AES3_CON_FS_44100; 875 break; 876 case 32000: 877 iec958_con_fs = IEC958_AES3_CON_FS_32000; 878 break; 879 default: 880 return -ENOENT; 881 } 882 883 guard(mutex)(&atc->atc_mutex); 884 dao->ops->get_spos(dao, &status); 885 if (((status >> 24) & IEC958_AES3_CON_FS) != iec958_con_fs) { 886 status &= ~(IEC958_AES3_CON_FS << 24); 887 status |= (iec958_con_fs << 24); 888 dao->ops->set_spos(dao, status); 889 dao->ops->commit_write(dao); 890 } 891 if ((rate != atc->pll_rate) && (32000 != rate)) 892 err = atc_pll_init(atc, rate); 893 894 return err; 895 } 896 897 static int 898 spdif_passthru_playback_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm) 899 { 900 struct src *src; 901 struct amixer *amixer; 902 struct dao *dao; 903 int err; 904 int i; 905 906 atc_pcm_release_resources(atc, apcm); 907 908 /* Configure SPDIFOO and PLL to passthrough mode; 909 * determine pll_rate. */ 910 err = spdif_passthru_playback_setup(atc, apcm); 911 if (err) 912 return err; 913 914 /* Get needed resources. */ 915 err = spdif_passthru_playback_get_resources(atc, apcm); 916 if (err) 917 return err; 918 919 /* Connect resources */ 920 src = apcm->src; 921 for (i = 0; i < apcm->n_amixer; i++) { 922 amixer = apcm->amixers[i]; 923 amixer->ops->setup(amixer, &src->rsc, INIT_VOL, NULL); 924 src = src->ops->next_interleave(src); 925 if (!src) 926 src = apcm->src; 927 } 928 /* Connect to SPDIFOO */ 929 scoped_guard(mutex, &atc->atc_mutex) { 930 dao = container_of(atc->daios[SPDIFOO], struct dao, daio); 931 amixer = apcm->amixers[0]; 932 dao->ops->set_left_input(dao, &amixer->rsc); 933 amixer = apcm->amixers[1]; 934 dao->ops->set_right_input(dao, &amixer->rsc); 935 } 936 937 ct_timer_prepare(apcm->timer); 938 939 return 0; 940 } 941 942 static int atc_select_line_in(struct ct_atc *atc) 943 { 944 struct hw *hw = atc->hw; 945 struct ct_mixer *mixer = atc->mixer; 946 struct src *src; 947 948 if (hw->is_adc_source_selected(hw, ADC_LINEIN)) 949 return 0; 950 951 mixer->set_input_left(mixer, MIX_MIC_IN, NULL); 952 mixer->set_input_right(mixer, MIX_MIC_IN, NULL); 953 954 hw->select_adc_source(hw, ADC_LINEIN); 955 956 src = atc->srcs[2]; 957 mixer->set_input_left(mixer, MIX_LINE_IN, &src->rsc); 958 src = atc->srcs[3]; 959 mixer->set_input_right(mixer, MIX_LINE_IN, &src->rsc); 960 961 return 0; 962 } 963 964 static int atc_select_mic_in(struct ct_atc *atc) 965 { 966 struct hw *hw = atc->hw; 967 struct ct_mixer *mixer = atc->mixer; 968 struct src *src; 969 970 if (hw->is_adc_source_selected(hw, ADC_MICIN)) 971 return 0; 972 973 mixer->set_input_left(mixer, MIX_LINE_IN, NULL); 974 mixer->set_input_right(mixer, MIX_LINE_IN, NULL); 975 976 hw->select_adc_source(hw, ADC_MICIN); 977 978 src = atc->srcs[2]; 979 mixer->set_input_left(mixer, MIX_MIC_IN, &src->rsc); 980 src = atc->srcs[3]; 981 mixer->set_input_right(mixer, MIX_MIC_IN, &src->rsc); 982 983 return 0; 984 } 985 986 static struct capabilities atc_capabilities(struct ct_atc *atc) 987 { 988 struct hw *hw = atc->hw; 989 990 return hw->capabilities(hw); 991 } 992 993 static void atc_dedicated_rca_select(struct ct_atc *atc) 994 { 995 struct dao *dao; 996 struct ct_mixer *mixer = atc->mixer; 997 struct rsc *rscs[2] = {NULL}; 998 999 dao = container_of(atc->daios[atc->rca_state ? RCA : LINEO1], 1000 struct dao, daio); 1001 dao->ops->clear_left_input(dao); 1002 dao->ops->clear_right_input(dao); 1003 1004 mixer->get_output_ports(mixer, MIX_WAVE_FRONT, &rscs[0], &rscs[1]); 1005 dao = container_of(atc->daios[atc->rca_state ? LINEO1 : RCA], 1006 struct dao, daio); 1007 dao->ops->set_left_input(dao, rscs[0]); 1008 dao->ops->set_right_input(dao, rscs[1]); 1009 } 1010 1011 static int atc_output_switch_get(struct ct_atc *atc) 1012 { 1013 struct hw *hw = atc->hw; 1014 1015 return hw->output_switch_get(hw); 1016 } 1017 1018 static int atc_output_switch_put(struct ct_atc *atc, int position) 1019 { 1020 struct hw *hw = atc->hw; 1021 1022 return hw->output_switch_put(hw, position); 1023 } 1024 1025 static int atc_mic_source_switch_get(struct ct_atc *atc) 1026 { 1027 struct hw *hw = atc->hw; 1028 1029 return hw->mic_source_switch_get(hw); 1030 } 1031 1032 static int atc_mic_source_switch_put(struct ct_atc *atc, int position) 1033 { 1034 struct hw *hw = atc->hw; 1035 1036 return hw->mic_source_switch_put(hw, position); 1037 } 1038 1039 static int atc_select_digit_io(struct ct_atc *atc) 1040 { 1041 struct hw *hw = atc->hw; 1042 1043 if (hw->is_adc_source_selected(hw, ADC_NONE)) 1044 return 0; 1045 1046 hw->select_adc_source(hw, ADC_NONE); 1047 1048 return 0; 1049 } 1050 1051 static int atc_daio_unmute(struct ct_atc *atc, unsigned char state, int type) 1052 { 1053 struct daio_mgr *daio_mgr = atc->rsc_mgrs[DAIO]; 1054 1055 if (state) 1056 daio_mgr->daio_enable(daio_mgr, atc->daios[type]); 1057 else 1058 daio_mgr->daio_disable(daio_mgr, atc->daios[type]); 1059 1060 daio_mgr->commit_write(daio_mgr); 1061 1062 return 0; 1063 } 1064 1065 static int 1066 atc_dao_get_status(struct ct_atc *atc, unsigned int *status, int type) 1067 { 1068 struct dao *dao = container_of(atc->daios[type], struct dao, daio); 1069 return dao->ops->get_spos(dao, status); 1070 } 1071 1072 static int 1073 atc_dao_set_status(struct ct_atc *atc, unsigned int status, int type) 1074 { 1075 struct dao *dao = container_of(atc->daios[type], struct dao, daio); 1076 1077 dao->ops->set_spos(dao, status); 1078 dao->ops->commit_write(dao); 1079 return 0; 1080 } 1081 1082 static int atc_line_front_unmute(struct ct_atc *atc, unsigned char state) 1083 { 1084 return atc_daio_unmute(atc, state, LINEO1); 1085 } 1086 1087 static int atc_line_surround_unmute(struct ct_atc *atc, unsigned char state) 1088 { 1089 return atc_daio_unmute(atc, state, LINEO2); 1090 } 1091 1092 static int atc_line_clfe_unmute(struct ct_atc *atc, unsigned char state) 1093 { 1094 return atc_daio_unmute(atc, state, LINEO3); 1095 } 1096 1097 static int atc_line_rear_unmute(struct ct_atc *atc, unsigned char state) 1098 { 1099 return atc_daio_unmute(atc, state, LINEO4); 1100 } 1101 1102 static int atc_line_in_unmute(struct ct_atc *atc, unsigned char state) 1103 { 1104 return atc_daio_unmute(atc, state, LINEIM); 1105 } 1106 1107 static int atc_mic_unmute(struct ct_atc *atc, unsigned char state) 1108 { 1109 return atc_daio_unmute(atc, state, MIC); 1110 } 1111 1112 static int atc_rca_unmute(struct ct_atc *atc, unsigned char state) 1113 { 1114 return atc_daio_unmute(atc, state, RCA); 1115 } 1116 1117 static int atc_spdif_out_unmute(struct ct_atc *atc, unsigned char state) 1118 { 1119 return atc_daio_unmute(atc, state, SPDIFOO); 1120 } 1121 1122 static int atc_spdif_in_unmute(struct ct_atc *atc, unsigned char state) 1123 { 1124 return atc_daio_unmute(atc, state, SPDIFIO); 1125 } 1126 1127 static int atc_spdif_out_get_status(struct ct_atc *atc, unsigned int *status) 1128 { 1129 return atc_dao_get_status(atc, status, SPDIFOO); 1130 } 1131 1132 static int atc_spdif_out_set_status(struct ct_atc *atc, unsigned int status) 1133 { 1134 return atc_dao_set_status(atc, status, SPDIFOO); 1135 } 1136 1137 static int atc_spdif_out_passthru(struct ct_atc *atc, unsigned char state) 1138 { 1139 struct dao_desc da_dsc = {0}; 1140 struct dao *dao; 1141 int err; 1142 struct ct_mixer *mixer = atc->mixer; 1143 struct rsc *rscs[2] = {NULL}; 1144 unsigned int spos = 0; 1145 1146 guard(mutex)(&atc->atc_mutex); 1147 dao = container_of(atc->daios[SPDIFOO], struct dao, daio); 1148 da_dsc.msr = state ? 1 : atc->msr; 1149 da_dsc.passthru = state ? 1 : 0; 1150 err = dao->ops->reinit(dao, &da_dsc); 1151 if (state) { 1152 spos = IEC958_DEFAULT_CON; 1153 } else { 1154 mixer->get_output_ports(mixer, MIX_SPDIF_OUT, 1155 &rscs[0], &rscs[1]); 1156 dao->ops->set_left_input(dao, rscs[0]); 1157 dao->ops->set_right_input(dao, rscs[1]); 1158 /* Restore PLL to atc->rsr if needed. */ 1159 if (atc->pll_rate != atc->rsr) 1160 err = atc_pll_init(atc, atc->rsr); 1161 } 1162 dao->ops->set_spos(dao, spos); 1163 dao->ops->commit_write(dao); 1164 1165 return err; 1166 } 1167 1168 static int atc_release_resources(struct ct_atc *atc) 1169 { 1170 int i; 1171 struct daio_mgr *daio_mgr = NULL; 1172 struct dao *dao = NULL; 1173 struct daio *daio = NULL; 1174 struct sum_mgr *sum_mgr = NULL; 1175 struct src_mgr *src_mgr = NULL; 1176 struct srcimp_mgr *srcimp_mgr = NULL; 1177 struct srcimp *srcimp = NULL; 1178 struct ct_mixer *mixer = NULL; 1179 1180 /* disconnect internal mixer objects */ 1181 if (atc->mixer) { 1182 mixer = atc->mixer; 1183 mixer->set_input_left(mixer, MIX_LINE_IN, NULL); 1184 mixer->set_input_right(mixer, MIX_LINE_IN, NULL); 1185 mixer->set_input_left(mixer, MIX_MIC_IN, NULL); 1186 mixer->set_input_right(mixer, MIX_MIC_IN, NULL); 1187 mixer->set_input_left(mixer, MIX_SPDIF_IN, NULL); 1188 mixer->set_input_right(mixer, MIX_SPDIF_IN, NULL); 1189 } 1190 1191 if (atc->daios) { 1192 daio_mgr = (struct daio_mgr *)atc->rsc_mgrs[DAIO]; 1193 for (i = 0; i < NUM_DAIOTYP; i++) { 1194 daio = atc->daios[i]; 1195 if (!daio) 1196 continue; 1197 if (daio->output) { 1198 dao = container_of(daio, struct dao, daio); 1199 dao->ops->clear_left_input(dao); 1200 dao->ops->clear_right_input(dao); 1201 } 1202 daio_mgr->put_daio(daio_mgr, daio); 1203 } 1204 kfree(atc->daios); 1205 atc->daios = NULL; 1206 } 1207 1208 if (atc->pcm) { 1209 sum_mgr = atc->rsc_mgrs[SUM]; 1210 for (i = 0; i < NUM_ATC_PCM; i++) 1211 if (atc->pcm[i]) 1212 sum_mgr->put_sum(sum_mgr, atc->pcm[i]); 1213 1214 kfree(atc->pcm); 1215 atc->pcm = NULL; 1216 } 1217 1218 if (atc->srcs) { 1219 src_mgr = atc->rsc_mgrs[SRC]; 1220 for (i = 0; i < NUM_ATC_SRCS; i++) 1221 if (atc->srcs[i]) 1222 src_mgr->put_src(src_mgr, atc->srcs[i]); 1223 1224 kfree(atc->srcs); 1225 atc->srcs = NULL; 1226 } 1227 1228 if (atc->srcimps) { 1229 srcimp_mgr = atc->rsc_mgrs[SRCIMP]; 1230 for (i = 0; i < NUM_ATC_SRCS; i++) { 1231 if (!atc->srcimps[i]) 1232 continue; 1233 srcimp = atc->srcimps[i]; 1234 srcimp->ops->unmap(srcimp); 1235 srcimp_mgr->put_srcimp(srcimp_mgr, atc->srcimps[i]); 1236 } 1237 kfree(atc->srcimps); 1238 atc->srcimps = NULL; 1239 } 1240 1241 return 0; 1242 } 1243 1244 static int ct_atc_destroy(struct ct_atc *atc) 1245 { 1246 int i = 0; 1247 1248 if (!atc) 1249 return 0; 1250 1251 if (atc->timer) { 1252 ct_timer_free(atc->timer); 1253 atc->timer = NULL; 1254 } 1255 1256 atc_release_resources(atc); 1257 1258 /* Destroy internal mixer objects */ 1259 if (atc->mixer) 1260 ct_mixer_destroy(atc->mixer); 1261 1262 for (i = 0; i < NUM_RSCTYP; i++) { 1263 if (rsc_mgr_funcs[i].destroy && atc->rsc_mgrs[i]) 1264 rsc_mgr_funcs[i].destroy(atc->rsc_mgrs[i]); 1265 1266 } 1267 1268 if (atc->hw) 1269 destroy_hw_obj(atc->hw); 1270 1271 /* Destroy device virtual memory manager object */ 1272 if (atc->vm) { 1273 ct_vm_destroy(atc->vm); 1274 atc->vm = NULL; 1275 } 1276 1277 kfree(atc); 1278 1279 return 0; 1280 } 1281 1282 static int atc_dev_free(struct snd_device *dev) 1283 { 1284 struct ct_atc *atc = dev->device_data; 1285 return ct_atc_destroy(atc); 1286 } 1287 1288 static int atc_identify_card(struct ct_atc *atc, unsigned int ssid) 1289 { 1290 const struct snd_pci_quirk *p; 1291 const struct snd_pci_quirk *list; 1292 u16 vendor_id, device_id; 1293 1294 switch (atc->chip_type) { 1295 case ATC20K1: 1296 atc->chip_name = "20K1"; 1297 list = subsys_20k1_list; 1298 break; 1299 case ATC20K2: 1300 atc->chip_name = "20K2"; 1301 list = subsys_20k2_list; 1302 break; 1303 default: 1304 return -ENOENT; 1305 } 1306 if (ssid) { 1307 vendor_id = ssid >> 16; 1308 device_id = ssid & 0xffff; 1309 } else { 1310 vendor_id = atc->pci->subsystem_vendor; 1311 device_id = atc->pci->subsystem_device; 1312 } 1313 p = snd_pci_quirk_lookup_id(vendor_id, device_id, list); 1314 if (p) { 1315 if (p->value < 0) { 1316 dev_err(atc->card->dev, 1317 "Device %04x:%04x is on the denylist\n", 1318 vendor_id, device_id); 1319 return -ENOENT; 1320 } 1321 atc->model = p->value; 1322 } else { 1323 if (atc->chip_type == ATC20K1) 1324 atc->model = CT20K1_UNKNOWN; 1325 else 1326 atc->model = CT20K2_UNKNOWN; 1327 } 1328 atc->model_name = ct_subsys_name[atc->model]; 1329 dev_info(atc->card->dev, "chip %s model %s (%04x:%04x) is found\n", 1330 atc->chip_name, atc->model_name, 1331 vendor_id, device_id); 1332 atc->rca_state = 0; 1333 return 0; 1334 } 1335 1336 int ct_atc_create_alsa_devs(struct ct_atc *atc) 1337 { 1338 enum CTALSADEVS i; 1339 int err; 1340 1341 alsa_dev_funcs[MIXER].public_name = atc->chip_name; 1342 1343 for (i = 0; i < NUM_CTALSADEVS; i++) { 1344 if (!alsa_dev_funcs[i].create) 1345 continue; 1346 1347 err = alsa_dev_funcs[i].create(atc, i, 1348 alsa_dev_funcs[i].public_name); 1349 if (err) { 1350 dev_err(atc->card->dev, 1351 "Creating alsa device %d failed!\n", i); 1352 return err; 1353 } 1354 } 1355 1356 return 0; 1357 } 1358 1359 static int atc_create_hw_devs(struct ct_atc *atc) 1360 { 1361 struct hw *hw; 1362 struct card_conf info = {0}; 1363 int i, err; 1364 1365 err = create_hw_obj(atc->pci, atc->chip_type, atc->model, &hw); 1366 if (err) { 1367 dev_err(atc->card->dev, "Failed to create hw obj!!!\n"); 1368 return err; 1369 } 1370 hw->card = atc->card; 1371 atc->hw = hw; 1372 1373 /* Initialize card hardware. */ 1374 info.rsr = atc->rsr; 1375 info.msr = atc->msr; 1376 info.vm_pgt_phys = atc_get_ptp_phys(atc, 0); 1377 err = hw->card_init(hw, &info); 1378 if (err < 0) 1379 return err; 1380 1381 for (i = 0; i < NUM_RSCTYP; i++) { 1382 if (!rsc_mgr_funcs[i].create) 1383 continue; 1384 1385 err = rsc_mgr_funcs[i].create(atc->hw, &atc->rsc_mgrs[i]); 1386 if (err) { 1387 dev_err(atc->card->dev, 1388 "Failed to create rsc_mgr %d!!!\n", i); 1389 return err; 1390 } 1391 } 1392 1393 return 0; 1394 } 1395 1396 static int atc_get_resources(struct ct_atc *atc) 1397 { 1398 struct daio_desc da_desc = {0}; 1399 struct daio_mgr *daio_mgr; 1400 struct src_desc src_dsc = {0}; 1401 struct src_mgr *src_mgr; 1402 struct srcimp_desc srcimp_dsc = {0}; 1403 struct srcimp_mgr *srcimp_mgr; 1404 struct sum_desc sum_dsc = {0}; 1405 struct sum_mgr *sum_mgr; 1406 struct capabilities cap; 1407 int err, i; 1408 1409 cap = atc->capabilities(atc); 1410 1411 atc->daios = kcalloc(NUM_DAIOTYP, sizeof(void *), GFP_KERNEL); 1412 if (!atc->daios) 1413 return -ENOMEM; 1414 1415 atc->srcs = kcalloc(NUM_ATC_SRCS, sizeof(void *), GFP_KERNEL); 1416 if (!atc->srcs) 1417 return -ENOMEM; 1418 1419 atc->srcimps = kcalloc(NUM_ATC_SRCS, sizeof(void *), GFP_KERNEL); 1420 if (!atc->srcimps) 1421 return -ENOMEM; 1422 1423 atc->pcm = kcalloc(NUM_ATC_PCM, sizeof(void *), GFP_KERNEL); 1424 if (!atc->pcm) 1425 return -ENOMEM; 1426 1427 daio_mgr = (struct daio_mgr *)atc->rsc_mgrs[DAIO]; 1428 da_desc.msr = atc->msr; 1429 for (i = 0; i < NUM_DAIOTYP; i++) { 1430 if (((i == MIC) && !cap.dedicated_mic) || 1431 ((i == RCA) && !cap.dedicated_rca) || 1432 i == SPDIFI1) 1433 continue; 1434 if (atc->model == CTSB073X && i == SPDIFIO) 1435 da_desc.type = SPDIFI1; 1436 else 1437 da_desc.type = i; 1438 da_desc.output = (i < LINEIM) || (i == RCA); 1439 err = daio_mgr->get_daio(daio_mgr, &da_desc, 1440 (struct daio **)&atc->daios[i]); 1441 if (err) { 1442 dev_err(atc->card->dev, 1443 "Failed to get DAIO resource %d!!!\n", 1444 i); 1445 return err; 1446 } 1447 } 1448 1449 src_mgr = atc->rsc_mgrs[SRC]; 1450 src_dsc.multi = 1; 1451 src_dsc.msr = atc->msr; 1452 src_dsc.mode = ARCRW; 1453 for (i = 0; i < NUM_ATC_SRCS; i++) { 1454 if (((i > 3) && !cap.dedicated_mic)) 1455 continue; 1456 err = src_mgr->get_src(src_mgr, &src_dsc, 1457 (struct src **)&atc->srcs[i]); 1458 if (err) 1459 return err; 1460 } 1461 1462 srcimp_mgr = atc->rsc_mgrs[SRCIMP]; 1463 srcimp_dsc.msr = 8; 1464 for (i = 0; i < NUM_ATC_SRCS; i++) { 1465 if (((i > 3) && !cap.dedicated_mic)) 1466 continue; 1467 err = srcimp_mgr->get_srcimp(srcimp_mgr, &srcimp_dsc, 1468 (struct srcimp **)&atc->srcimps[i]); 1469 if (err) 1470 return err; 1471 } 1472 1473 sum_mgr = atc->rsc_mgrs[SUM]; 1474 sum_dsc.msr = atc->msr; 1475 for (i = 0; i < NUM_ATC_PCM; i++) { 1476 err = sum_mgr->get_sum(sum_mgr, &sum_dsc, 1477 (struct sum **)&atc->pcm[i]); 1478 if (err) 1479 return err; 1480 } 1481 1482 return 0; 1483 } 1484 1485 static void 1486 atc_connect_dai(struct src_mgr *src_mgr, struct dai *dai, 1487 struct src **srcs, struct srcimp **srcimps) 1488 { 1489 struct rsc *rscs[2] = {NULL}; 1490 struct src *src; 1491 struct srcimp *srcimp; 1492 int i = 0; 1493 1494 rscs[0] = &dai->daio.rscl; 1495 rscs[1] = &dai->daio.rscr; 1496 for (i = 0; i < 2; i++) { 1497 src = srcs[i]; 1498 srcimp = srcimps[i]; 1499 srcimp->ops->map(srcimp, src, rscs[i]); 1500 src_mgr->src_disable(src_mgr, src); 1501 } 1502 1503 src_mgr->commit_write(src_mgr); /* Actually disable SRCs */ 1504 1505 src = srcs[0]; 1506 src->ops->set_pm(src, 1); 1507 for (i = 0; i < 2; i++) { 1508 src = srcs[i]; 1509 src->ops->set_state(src, SRC_STATE_RUN); 1510 src->ops->commit_write(src); 1511 src_mgr->src_enable_s(src_mgr, src); 1512 } 1513 1514 dai->ops->set_srt_srcl(dai, &(srcs[0]->rsc)); 1515 dai->ops->set_srt_srcr(dai, &(srcs[1]->rsc)); 1516 1517 dai->ops->set_enb_src(dai, 1); 1518 dai->ops->set_enb_srt(dai, 1); 1519 dai->ops->commit_write(dai); 1520 1521 src_mgr->commit_write(src_mgr); /* Synchronously enable SRCs */ 1522 } 1523 1524 static void atc_connect_resources(struct ct_atc *atc) 1525 { 1526 struct dai *dai; 1527 struct dao *dao; 1528 struct src *src; 1529 struct sum *sum; 1530 struct ct_mixer *mixer; 1531 struct rsc *rscs[2] = {NULL}; 1532 struct capabilities cap; 1533 int i, j; 1534 1535 mixer = atc->mixer; 1536 cap = atc->capabilities(atc); 1537 1538 for (i = MIX_WAVE_FRONT, j = LINEO1; i <= MIX_SPDIF_OUT; i++, j++) { 1539 mixer->get_output_ports(mixer, i, &rscs[0], &rscs[1]); 1540 dao = container_of(atc->daios[j], struct dao, daio); 1541 dao->ops->set_left_input(dao, rscs[0]); 1542 dao->ops->set_right_input(dao, rscs[1]); 1543 } 1544 1545 if (cap.dedicated_rca) { 1546 /* SE-300PCIE has a dedicated DAC for the RCA. */ 1547 atc_dedicated_rca_select(atc); 1548 } 1549 1550 dai = container_of(atc->daios[LINEIM], struct dai, daio); 1551 atc_connect_dai(atc->rsc_mgrs[SRC], dai, 1552 (struct src **)&atc->srcs[2], 1553 (struct srcimp **)&atc->srcimps[2]); 1554 src = atc->srcs[2]; 1555 mixer->set_input_left(mixer, MIX_LINE_IN, &src->rsc); 1556 src = atc->srcs[3]; 1557 mixer->set_input_right(mixer, MIX_LINE_IN, &src->rsc); 1558 1559 if (cap.dedicated_mic) { 1560 /* Titanium HD has a dedicated ADC for the Mic. */ 1561 /* SE-300PCIE has a 4-channel ADC. */ 1562 dai = container_of(atc->daios[MIC], struct dai, daio); 1563 atc_connect_dai(atc->rsc_mgrs[SRC], dai, 1564 (struct src **)&atc->srcs[4], 1565 (struct srcimp **)&atc->srcimps[4]); 1566 src = atc->srcs[4]; 1567 mixer->set_input_left(mixer, MIX_MIC_IN, &src->rsc); 1568 src = atc->srcs[5]; 1569 mixer->set_input_right(mixer, MIX_MIC_IN, &src->rsc); 1570 } 1571 1572 dai = container_of(atc->daios[SPDIFIO], struct dai, daio); 1573 atc_connect_dai(atc->rsc_mgrs[SRC], dai, 1574 (struct src **)&atc->srcs[0], 1575 (struct srcimp **)&atc->srcimps[0]); 1576 1577 src = atc->srcs[0]; 1578 mixer->set_input_left(mixer, MIX_SPDIF_IN, &src->rsc); 1579 src = atc->srcs[1]; 1580 mixer->set_input_right(mixer, MIX_SPDIF_IN, &src->rsc); 1581 1582 for (i = MIX_PCMI_FRONT, j = 0; i <= MIX_PCMI_SURROUND; i++, j += 2) { 1583 sum = atc->pcm[j]; 1584 mixer->set_input_left(mixer, i, &sum->rsc); 1585 sum = atc->pcm[j+1]; 1586 mixer->set_input_right(mixer, i, &sum->rsc); 1587 } 1588 } 1589 1590 #ifdef CONFIG_PM_SLEEP 1591 static int atc_suspend(struct ct_atc *atc) 1592 { 1593 struct hw *hw = atc->hw; 1594 1595 snd_power_change_state(atc->card, SNDRV_CTL_POWER_D3hot); 1596 1597 atc_release_resources(atc); 1598 1599 hw->suspend(hw); 1600 1601 return 0; 1602 } 1603 1604 static int atc_hw_resume(struct ct_atc *atc) 1605 { 1606 struct hw *hw = atc->hw; 1607 struct card_conf info = {0}; 1608 1609 /* Re-initialize card hardware. */ 1610 info.rsr = atc->rsr; 1611 info.msr = atc->msr; 1612 info.vm_pgt_phys = atc_get_ptp_phys(atc, 0); 1613 return hw->resume(hw, &info); 1614 } 1615 1616 static int atc_resources_resume(struct ct_atc *atc) 1617 { 1618 struct ct_mixer *mixer; 1619 int err = 0; 1620 1621 /* Get resources */ 1622 err = atc_get_resources(atc); 1623 if (err < 0) { 1624 atc_release_resources(atc); 1625 return err; 1626 } 1627 1628 /* Build topology */ 1629 atc_connect_resources(atc); 1630 1631 mixer = atc->mixer; 1632 mixer->resume(mixer); 1633 1634 return 0; 1635 } 1636 1637 static int atc_resume(struct ct_atc *atc) 1638 { 1639 int err = 0; 1640 1641 /* Do hardware resume. */ 1642 err = atc_hw_resume(atc); 1643 if (err < 0) { 1644 dev_err(atc->card->dev, 1645 "pci_enable_device failed, disabling device\n"); 1646 snd_card_disconnect(atc->card); 1647 return err; 1648 } 1649 1650 err = atc_resources_resume(atc); 1651 if (err < 0) 1652 return err; 1653 1654 snd_power_change_state(atc->card, SNDRV_CTL_POWER_D0); 1655 1656 return 0; 1657 } 1658 #endif 1659 1660 static const struct ct_atc atc_preset = { 1661 .map_audio_buffer = ct_map_audio_buffer, 1662 .unmap_audio_buffer = ct_unmap_audio_buffer, 1663 .pcm_playback_prepare = atc_pcm_playback_prepare, 1664 .pcm_release_resources = atc_pcm_release_resources, 1665 .pcm_playback_start = atc_pcm_playback_start, 1666 .pcm_playback_stop = atc_pcm_stop, 1667 .pcm_playback_position = atc_pcm_playback_position, 1668 .pcm_capture_prepare = atc_pcm_capture_prepare, 1669 .pcm_capture_start = atc_pcm_capture_start, 1670 .pcm_capture_stop = atc_pcm_stop, 1671 .pcm_capture_position = atc_pcm_capture_position, 1672 .spdif_passthru_playback_prepare = spdif_passthru_playback_prepare, 1673 .get_ptp_phys = atc_get_ptp_phys, 1674 .select_line_in = atc_select_line_in, 1675 .select_mic_in = atc_select_mic_in, 1676 .select_digit_io = atc_select_digit_io, 1677 .line_front_unmute = atc_line_front_unmute, 1678 .line_surround_unmute = atc_line_surround_unmute, 1679 .line_clfe_unmute = atc_line_clfe_unmute, 1680 .line_rear_unmute = atc_line_rear_unmute, 1681 .line_in_unmute = atc_line_in_unmute, 1682 .mic_unmute = atc_mic_unmute, 1683 .rca_unmute = atc_rca_unmute, 1684 .spdif_out_unmute = atc_spdif_out_unmute, 1685 .spdif_in_unmute = atc_spdif_in_unmute, 1686 .spdif_out_get_status = atc_spdif_out_get_status, 1687 .spdif_out_set_status = atc_spdif_out_set_status, 1688 .spdif_out_passthru = atc_spdif_out_passthru, 1689 .capabilities = atc_capabilities, 1690 .dedicated_rca_select = atc_dedicated_rca_select, 1691 .output_switch_get = atc_output_switch_get, 1692 .output_switch_put = atc_output_switch_put, 1693 .mic_source_switch_get = atc_mic_source_switch_get, 1694 .mic_source_switch_put = atc_mic_source_switch_put, 1695 #ifdef CONFIG_PM_SLEEP 1696 .suspend = atc_suspend, 1697 .resume = atc_resume, 1698 #endif 1699 }; 1700 1701 /** 1702 * ct_atc_create - create and initialize a hardware manager 1703 * @card: corresponding alsa card object 1704 * @pci: corresponding kernel pci device object 1705 * @rsr: reference sampling rate 1706 * @msr: master sampling rate 1707 * @chip_type: CHIPTYP enum values 1708 * @ssid: vendor ID (upper 16 bits) and device ID (lower 16 bits) 1709 * @ratc: return created object address in it 1710 * 1711 * Creates and initializes a hardware manager. 1712 * 1713 * Creates kmallocated ct_atc structure. Initializes hardware. 1714 * Returns 0 if succeeds, or negative error code if fails. 1715 */ 1716 1717 int ct_atc_create(struct snd_card *card, struct pci_dev *pci, 1718 unsigned int rsr, unsigned int msr, 1719 int chip_type, unsigned int ssid, 1720 struct ct_atc **ratc) 1721 { 1722 struct ct_atc *atc; 1723 static const struct snd_device_ops ops = { 1724 .dev_free = atc_dev_free, 1725 }; 1726 int err; 1727 1728 *ratc = NULL; 1729 1730 atc = kzalloc_obj(*atc); 1731 if (!atc) 1732 return -ENOMEM; 1733 1734 /* Set operations */ 1735 *atc = atc_preset; 1736 1737 atc->card = card; 1738 atc->pci = pci; 1739 atc->rsr = rsr; 1740 atc->msr = msr; 1741 atc->chip_type = chip_type; 1742 1743 mutex_init(&atc->atc_mutex); 1744 1745 /* Find card model */ 1746 err = atc_identify_card(atc, ssid); 1747 if (err < 0) { 1748 dev_err(card->dev, "ctatc: Card not recognised\n"); 1749 goto error1; 1750 } 1751 1752 /* Set up device virtual memory management object */ 1753 err = ct_vm_create(&atc->vm, pci); 1754 if (err < 0) 1755 goto error1; 1756 1757 /* Create all atc hw devices */ 1758 err = atc_create_hw_devs(atc); 1759 if (err < 0) 1760 goto error1; 1761 1762 err = ct_mixer_create(atc, (struct ct_mixer **)&atc->mixer); 1763 if (err) { 1764 dev_err(card->dev, "Failed to create mixer obj!!!\n"); 1765 goto error1; 1766 } 1767 1768 /* Get resources */ 1769 err = atc_get_resources(atc); 1770 if (err < 0) 1771 goto error1; 1772 1773 /* Build topology */ 1774 atc_connect_resources(atc); 1775 1776 atc->timer = ct_timer_new(atc); 1777 if (!atc->timer) { 1778 err = -ENOMEM; 1779 goto error1; 1780 } 1781 1782 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, atc, &ops); 1783 if (err < 0) 1784 goto error1; 1785 1786 *ratc = atc; 1787 return 0; 1788 1789 error1: 1790 ct_atc_destroy(atc); 1791 dev_err(card->dev, "Something wrong!!!\n"); 1792 return err; 1793 } 1794