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; 798 unsigned int rsr = atc->pll_rate ? atc->pll_rate : atc->rsr; 799 800 /* first release old resources */ 801 atc_pcm_release_resources(atc, apcm); 802 803 /* Get SRC resource */ 804 desc.multi = apcm->substream->runtime->channels; 805 desc.msr = 1; 806 while (apcm->substream->runtime->rate > (rsr * desc.msr)) 807 desc.msr <<= 1; 808 809 desc.mode = MEMRD; 810 err = src_mgr->get_src(src_mgr, &desc, (struct src **)&apcm->src); 811 if (err) 812 goto error1; 813 814 pitch = atc_get_pitch(apcm->substream->runtime->rate, (rsr * desc.msr)); 815 src = apcm->src; 816 src->ops->set_pitch(src, pitch); 817 src->ops->set_rom(src, select_rom(pitch)); 818 src->ops->set_sf(src, convert_format(apcm->substream->runtime->format, 819 atc->card)); 820 src->ops->set_pm(src, (src->ops->next_interleave(src) != NULL)); 821 src->ops->set_bp(src, 1); 822 823 /* Get AMIXER resource */ 824 n_amixer = (n_amixer < 2) ? 2 : n_amixer; 825 apcm->amixers = kcalloc(n_amixer, sizeof(void *), GFP_KERNEL); 826 if (!apcm->amixers) { 827 err = -ENOMEM; 828 goto error1; 829 } 830 mix_dsc.msr = desc.msr; 831 for (i = 0, apcm->n_amixer = 0; i < n_amixer; i++) { 832 err = amixer_mgr->get_amixer(amixer_mgr, &mix_dsc, 833 (struct amixer **)&apcm->amixers[i]); 834 if (err) 835 goto error1; 836 837 apcm->n_amixer++; 838 } 839 840 /* Set up device virtual mem map */ 841 err = ct_map_audio_buffer(atc, apcm); 842 if (err < 0) 843 goto error1; 844 845 return 0; 846 847 error1: 848 atc_pcm_release_resources(atc, apcm); 849 return err; 850 } 851 852 static int atc_pll_init(struct ct_atc *atc, int rate) 853 { 854 struct hw *hw = atc->hw; 855 int err; 856 err = hw->pll_init(hw, rate); 857 atc->pll_rate = err ? 0 : rate; 858 return err; 859 } 860 861 static int 862 spdif_passthru_playback_setup(struct ct_atc *atc, struct ct_atc_pcm *apcm) 863 { 864 struct dao *dao = container_of(atc->daios[SPDIFOO], struct dao, daio); 865 unsigned int rate = apcm->substream->runtime->rate; 866 unsigned int status; 867 int err = 0; 868 unsigned char iec958_con_fs; 869 870 switch (rate) { 871 case 48000: 872 iec958_con_fs = IEC958_AES3_CON_FS_48000; 873 break; 874 case 44100: 875 iec958_con_fs = IEC958_AES3_CON_FS_44100; 876 break; 877 case 32000: 878 iec958_con_fs = IEC958_AES3_CON_FS_32000; 879 break; 880 default: 881 return -ENOENT; 882 } 883 884 guard(mutex)(&atc->atc_mutex); 885 dao->ops->get_spos(dao, &status); 886 if (((status >> 24) & IEC958_AES3_CON_FS) != iec958_con_fs) { 887 status &= ~(IEC958_AES3_CON_FS << 24); 888 status |= (iec958_con_fs << 24); 889 dao->ops->set_spos(dao, status); 890 dao->ops->commit_write(dao); 891 } 892 if ((rate != atc->pll_rate) && (32000 != rate)) 893 err = atc_pll_init(atc, rate); 894 895 return err; 896 } 897 898 static int 899 spdif_passthru_playback_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm) 900 { 901 struct src *src; 902 struct amixer *amixer; 903 struct dao *dao; 904 int err; 905 int i; 906 907 atc_pcm_release_resources(atc, apcm); 908 909 /* Configure SPDIFOO and PLL to passthrough mode; 910 * determine pll_rate. */ 911 err = spdif_passthru_playback_setup(atc, apcm); 912 if (err) 913 return err; 914 915 /* Get needed resources. */ 916 err = spdif_passthru_playback_get_resources(atc, apcm); 917 if (err) 918 return err; 919 920 /* Connect resources */ 921 src = apcm->src; 922 for (i = 0; i < apcm->n_amixer; i++) { 923 amixer = apcm->amixers[i]; 924 amixer->ops->setup(amixer, &src->rsc, INIT_VOL, NULL); 925 src = src->ops->next_interleave(src); 926 if (!src) 927 src = apcm->src; 928 } 929 /* Connect to SPDIFOO */ 930 scoped_guard(mutex, &atc->atc_mutex) { 931 dao = container_of(atc->daios[SPDIFOO], struct dao, daio); 932 amixer = apcm->amixers[0]; 933 dao->ops->set_left_input(dao, &amixer->rsc); 934 amixer = apcm->amixers[1]; 935 dao->ops->set_right_input(dao, &amixer->rsc); 936 } 937 938 ct_timer_prepare(apcm->timer); 939 940 return 0; 941 } 942 943 static int atc_select_line_in(struct ct_atc *atc) 944 { 945 struct hw *hw = atc->hw; 946 struct ct_mixer *mixer = atc->mixer; 947 struct src *src; 948 949 if (hw->is_adc_source_selected(hw, ADC_LINEIN)) 950 return 0; 951 952 mixer->set_input_left(mixer, MIX_MIC_IN, NULL); 953 mixer->set_input_right(mixer, MIX_MIC_IN, NULL); 954 955 hw->select_adc_source(hw, ADC_LINEIN); 956 957 src = atc->srcs[2]; 958 mixer->set_input_left(mixer, MIX_LINE_IN, &src->rsc); 959 src = atc->srcs[3]; 960 mixer->set_input_right(mixer, MIX_LINE_IN, &src->rsc); 961 962 return 0; 963 } 964 965 static int atc_select_mic_in(struct ct_atc *atc) 966 { 967 struct hw *hw = atc->hw; 968 struct ct_mixer *mixer = atc->mixer; 969 struct src *src; 970 971 if (hw->is_adc_source_selected(hw, ADC_MICIN)) 972 return 0; 973 974 mixer->set_input_left(mixer, MIX_LINE_IN, NULL); 975 mixer->set_input_right(mixer, MIX_LINE_IN, NULL); 976 977 hw->select_adc_source(hw, ADC_MICIN); 978 979 src = atc->srcs[2]; 980 mixer->set_input_left(mixer, MIX_MIC_IN, &src->rsc); 981 src = atc->srcs[3]; 982 mixer->set_input_right(mixer, MIX_MIC_IN, &src->rsc); 983 984 return 0; 985 } 986 987 static inline enum DAIOTYP atc_spdif_in_type(struct ct_atc *atc) 988 { 989 return (atc->model == CTSB073X) ? SPDIFI_BAY : SPDIFIO; 990 } 991 992 static struct capabilities atc_capabilities(struct ct_atc *atc) 993 { 994 struct hw *hw = atc->hw; 995 996 return hw->capabilities(hw); 997 } 998 999 static void atc_dedicated_rca_select(struct ct_atc *atc) 1000 { 1001 struct dao *dao; 1002 struct ct_mixer *mixer = atc->mixer; 1003 struct rsc *rscs[2] = {NULL}; 1004 1005 dao = container_of(atc->daios[atc->rca_state ? RCA : LINEO1], 1006 struct dao, daio); 1007 dao->ops->clear_left_input(dao); 1008 dao->ops->clear_right_input(dao); 1009 1010 mixer->get_output_ports(mixer, MIX_WAVE_FRONT, &rscs[0], &rscs[1]); 1011 dao = container_of(atc->daios[atc->rca_state ? LINEO1 : RCA], 1012 struct dao, daio); 1013 dao->ops->set_left_input(dao, rscs[0]); 1014 dao->ops->set_right_input(dao, rscs[1]); 1015 } 1016 1017 static int atc_output_switch_get(struct ct_atc *atc) 1018 { 1019 struct hw *hw = atc->hw; 1020 1021 return hw->output_switch_get(hw); 1022 } 1023 1024 static int atc_output_switch_put(struct ct_atc *atc, int position) 1025 { 1026 struct hw *hw = atc->hw; 1027 1028 return hw->output_switch_put(hw, position); 1029 } 1030 1031 static int atc_mic_source_switch_get(struct ct_atc *atc) 1032 { 1033 struct hw *hw = atc->hw; 1034 1035 return hw->mic_source_switch_get(hw); 1036 } 1037 1038 static int atc_mic_source_switch_put(struct ct_atc *atc, int position) 1039 { 1040 struct hw *hw = atc->hw; 1041 1042 return hw->mic_source_switch_put(hw, position); 1043 } 1044 1045 static int atc_select_digit_io(struct ct_atc *atc) 1046 { 1047 struct hw *hw = atc->hw; 1048 1049 if (hw->is_adc_source_selected(hw, ADC_NONE)) 1050 return 0; 1051 1052 hw->select_adc_source(hw, ADC_NONE); 1053 1054 return 0; 1055 } 1056 1057 static int atc_daio_unmute(struct ct_atc *atc, unsigned char state, int type) 1058 { 1059 struct daio_mgr *daio_mgr = atc->rsc_mgrs[DAIO]; 1060 1061 if (state) 1062 daio_mgr->daio_enable(daio_mgr, atc->daios[type]); 1063 else 1064 daio_mgr->daio_disable(daio_mgr, atc->daios[type]); 1065 1066 daio_mgr->commit_write(daio_mgr); 1067 1068 return 0; 1069 } 1070 1071 static int 1072 atc_dao_get_status(struct ct_atc *atc, unsigned int *status, int type) 1073 { 1074 struct dao *dao = container_of(atc->daios[type], struct dao, daio); 1075 return dao->ops->get_spos(dao, status); 1076 } 1077 1078 static int 1079 atc_dao_set_status(struct ct_atc *atc, unsigned int status, int type) 1080 { 1081 struct dao *dao = container_of(atc->daios[type], struct dao, daio); 1082 1083 dao->ops->set_spos(dao, status); 1084 dao->ops->commit_write(dao); 1085 return 0; 1086 } 1087 1088 static int atc_line_front_unmute(struct ct_atc *atc, unsigned char state) 1089 { 1090 return atc_daio_unmute(atc, state, LINEO1); 1091 } 1092 1093 static int atc_line_surround_unmute(struct ct_atc *atc, unsigned char state) 1094 { 1095 return atc_daio_unmute(atc, state, LINEO2); 1096 } 1097 1098 static int atc_line_clfe_unmute(struct ct_atc *atc, unsigned char state) 1099 { 1100 return atc_daio_unmute(atc, state, LINEO3); 1101 } 1102 1103 static int atc_line_rear_unmute(struct ct_atc *atc, unsigned char state) 1104 { 1105 return atc_daio_unmute(atc, state, LINEO4); 1106 } 1107 1108 static int atc_line_in_unmute(struct ct_atc *atc, unsigned char state) 1109 { 1110 return atc_daio_unmute(atc, state, LINEIM); 1111 } 1112 1113 static int atc_mic_unmute(struct ct_atc *atc, unsigned char state) 1114 { 1115 return atc_daio_unmute(atc, state, MIC); 1116 } 1117 1118 static int atc_rca_unmute(struct ct_atc *atc, unsigned char state) 1119 { 1120 return atc_daio_unmute(atc, state, RCA); 1121 } 1122 1123 static int atc_spdif_out_unmute(struct ct_atc *atc, unsigned char state) 1124 { 1125 return atc_daio_unmute(atc, state, SPDIFOO); 1126 } 1127 1128 static int atc_spdif_in_unmute(struct ct_atc *atc, unsigned char state) 1129 { 1130 return atc_daio_unmute(atc, state, atc_spdif_in_type(atc)); 1131 } 1132 1133 static int atc_spdif_out_get_status(struct ct_atc *atc, unsigned int *status) 1134 { 1135 return atc_dao_get_status(atc, status, SPDIFOO); 1136 } 1137 1138 static int atc_spdif_out_set_status(struct ct_atc *atc, unsigned int status) 1139 { 1140 return atc_dao_set_status(atc, status, SPDIFOO); 1141 } 1142 1143 static int atc_spdif_out_passthru(struct ct_atc *atc, unsigned char state) 1144 { 1145 struct dao_desc da_dsc = {0}; 1146 struct dao *dao; 1147 int err; 1148 struct ct_mixer *mixer = atc->mixer; 1149 struct rsc *rscs[2] = {NULL}; 1150 unsigned int spos = 0; 1151 1152 guard(mutex)(&atc->atc_mutex); 1153 dao = container_of(atc->daios[SPDIFOO], struct dao, daio); 1154 da_dsc.msr = state ? 1 : atc->msr; 1155 da_dsc.passthru = state ? 1 : 0; 1156 err = dao->ops->reinit(dao, &da_dsc); 1157 if (state) { 1158 spos = IEC958_DEFAULT_CON; 1159 } else { 1160 mixer->get_output_ports(mixer, MIX_SPDIF_OUT, 1161 &rscs[0], &rscs[1]); 1162 dao->ops->set_left_input(dao, rscs[0]); 1163 dao->ops->set_right_input(dao, rscs[1]); 1164 /* Restore PLL to atc->rsr if needed. */ 1165 if (atc->pll_rate != atc->rsr) 1166 err = atc_pll_init(atc, atc->rsr); 1167 } 1168 dao->ops->set_spos(dao, spos); 1169 dao->ops->commit_write(dao); 1170 1171 return err; 1172 } 1173 1174 static int atc_release_resources(struct ct_atc *atc) 1175 { 1176 int i; 1177 struct daio_mgr *daio_mgr = NULL; 1178 struct dao *dao = NULL; 1179 struct daio *daio = NULL; 1180 struct sum_mgr *sum_mgr = NULL; 1181 struct src_mgr *src_mgr = NULL; 1182 struct srcimp_mgr *srcimp_mgr = NULL; 1183 struct srcimp *srcimp = NULL; 1184 struct ct_mixer *mixer = NULL; 1185 1186 /* disconnect internal mixer objects */ 1187 if (atc->mixer) { 1188 mixer = atc->mixer; 1189 mixer->set_input_left(mixer, MIX_LINE_IN, NULL); 1190 mixer->set_input_right(mixer, MIX_LINE_IN, NULL); 1191 mixer->set_input_left(mixer, MIX_MIC_IN, NULL); 1192 mixer->set_input_right(mixer, MIX_MIC_IN, NULL); 1193 mixer->set_input_left(mixer, MIX_SPDIF_IN, NULL); 1194 mixer->set_input_right(mixer, MIX_SPDIF_IN, NULL); 1195 } 1196 1197 if (atc->daios) { 1198 daio_mgr = (struct daio_mgr *)atc->rsc_mgrs[DAIO]; 1199 for (i = 0; i < NUM_DAIOTYP; i++) { 1200 daio = atc->daios[i]; 1201 if (!daio) 1202 continue; 1203 if (daio->output) { 1204 dao = container_of(daio, struct dao, daio); 1205 dao->ops->clear_left_input(dao); 1206 dao->ops->clear_right_input(dao); 1207 } 1208 daio_mgr->put_daio(daio_mgr, daio); 1209 } 1210 kfree(atc->daios); 1211 atc->daios = NULL; 1212 } 1213 1214 if (atc->pcm) { 1215 sum_mgr = atc->rsc_mgrs[SUM]; 1216 for (i = 0; i < NUM_ATC_PCM; i++) 1217 if (atc->pcm[i]) 1218 sum_mgr->put_sum(sum_mgr, atc->pcm[i]); 1219 1220 kfree(atc->pcm); 1221 atc->pcm = NULL; 1222 } 1223 1224 if (atc->srcs) { 1225 src_mgr = atc->rsc_mgrs[SRC]; 1226 for (i = 0; i < NUM_ATC_SRCS; i++) 1227 if (atc->srcs[i]) 1228 src_mgr->put_src(src_mgr, atc->srcs[i]); 1229 1230 kfree(atc->srcs); 1231 atc->srcs = NULL; 1232 } 1233 1234 if (atc->srcimps) { 1235 srcimp_mgr = atc->rsc_mgrs[SRCIMP]; 1236 for (i = 0; i < NUM_ATC_SRCS; i++) { 1237 if (!atc->srcimps[i]) 1238 continue; 1239 srcimp = atc->srcimps[i]; 1240 srcimp->ops->unmap(srcimp); 1241 srcimp_mgr->put_srcimp(srcimp_mgr, atc->srcimps[i]); 1242 } 1243 kfree(atc->srcimps); 1244 atc->srcimps = NULL; 1245 } 1246 1247 return 0; 1248 } 1249 1250 static int ct_atc_destroy(struct ct_atc *atc) 1251 { 1252 int i = 0; 1253 1254 if (!atc) 1255 return 0; 1256 1257 if (atc->timer) { 1258 ct_timer_free(atc->timer); 1259 atc->timer = NULL; 1260 } 1261 1262 atc_release_resources(atc); 1263 1264 /* Destroy internal mixer objects */ 1265 if (atc->mixer) 1266 ct_mixer_destroy(atc->mixer); 1267 1268 for (i = 0; i < NUM_RSCTYP; i++) { 1269 if (rsc_mgr_funcs[i].destroy && atc->rsc_mgrs[i]) 1270 rsc_mgr_funcs[i].destroy(atc->rsc_mgrs[i]); 1271 1272 } 1273 1274 if (atc->hw) 1275 destroy_hw_obj(atc->hw); 1276 1277 /* Destroy device virtual memory manager object */ 1278 if (atc->vm) { 1279 ct_vm_destroy(atc->vm); 1280 atc->vm = NULL; 1281 } 1282 1283 kfree(atc); 1284 1285 return 0; 1286 } 1287 1288 static int atc_dev_free(struct snd_device *dev) 1289 { 1290 struct ct_atc *atc = dev->device_data; 1291 return ct_atc_destroy(atc); 1292 } 1293 1294 static int atc_identify_card(struct ct_atc *atc, unsigned int ssid) 1295 { 1296 const struct snd_pci_quirk *p; 1297 const struct snd_pci_quirk *list; 1298 u16 vendor_id, device_id; 1299 1300 switch (atc->chip_type) { 1301 case ATC20K1: 1302 atc->chip_name = "20K1"; 1303 list = subsys_20k1_list; 1304 break; 1305 case ATC20K2: 1306 atc->chip_name = "20K2"; 1307 list = subsys_20k2_list; 1308 break; 1309 default: 1310 return -ENOENT; 1311 } 1312 if (ssid) { 1313 vendor_id = ssid >> 16; 1314 device_id = ssid & 0xffff; 1315 } else { 1316 vendor_id = atc->pci->subsystem_vendor; 1317 device_id = atc->pci->subsystem_device; 1318 } 1319 p = snd_pci_quirk_lookup_id(vendor_id, device_id, list); 1320 if (p) { 1321 if (p->value < 0) { 1322 dev_err(atc->card->dev, 1323 "Device %04x:%04x is on the denylist\n", 1324 vendor_id, device_id); 1325 return -ENOENT; 1326 } 1327 atc->model = p->value; 1328 } else { 1329 if (atc->chip_type == ATC20K1) 1330 atc->model = CT20K1_UNKNOWN; 1331 else 1332 atc->model = CT20K2_UNKNOWN; 1333 } 1334 atc->model_name = ct_subsys_name[atc->model]; 1335 dev_info(atc->card->dev, "chip %s model %s (%04x:%04x) is found\n", 1336 atc->chip_name, atc->model_name, 1337 vendor_id, device_id); 1338 atc->rca_state = 0; 1339 return 0; 1340 } 1341 1342 int ct_atc_create_alsa_devs(struct ct_atc *atc) 1343 { 1344 enum CTALSADEVS i; 1345 int err; 1346 1347 alsa_dev_funcs[MIXER].public_name = atc->chip_name; 1348 1349 for (i = 0; i < NUM_CTALSADEVS; i++) { 1350 if (!alsa_dev_funcs[i].create) 1351 continue; 1352 1353 err = alsa_dev_funcs[i].create(atc, i, 1354 alsa_dev_funcs[i].public_name); 1355 if (err) { 1356 dev_err(atc->card->dev, 1357 "Creating alsa device %d failed!\n", i); 1358 return err; 1359 } 1360 } 1361 1362 return 0; 1363 } 1364 1365 static int atc_create_hw_devs(struct ct_atc *atc) 1366 { 1367 struct hw *hw; 1368 struct card_conf info = {0}; 1369 int i, err; 1370 1371 err = create_hw_obj(atc->pci, atc->chip_type, atc->model, &hw); 1372 if (err) { 1373 dev_err(atc->card->dev, "Failed to create hw obj!!!\n"); 1374 return err; 1375 } 1376 hw->card = atc->card; 1377 atc->hw = hw; 1378 1379 /* Initialize card hardware. */ 1380 info.rsr = atc->rsr; 1381 info.msr = atc->msr; 1382 info.vm_pgt_phys = atc_get_ptp_phys(atc, 0); 1383 err = hw->card_init(hw, &info); 1384 if (err < 0) 1385 return err; 1386 1387 for (i = 0; i < NUM_RSCTYP; i++) { 1388 if (!rsc_mgr_funcs[i].create) 1389 continue; 1390 1391 err = rsc_mgr_funcs[i].create(atc->hw, &atc->rsc_mgrs[i]); 1392 if (err) { 1393 dev_err(atc->card->dev, 1394 "Failed to create rsc_mgr %d!!!\n", i); 1395 return err; 1396 } 1397 } 1398 1399 return 0; 1400 } 1401 1402 static int atc_get_resources(struct ct_atc *atc) 1403 { 1404 struct daio_desc da_desc = {0}; 1405 struct daio_mgr *daio_mgr; 1406 struct src_desc src_dsc = {0}; 1407 struct src_mgr *src_mgr; 1408 struct srcimp_desc srcimp_dsc = {0}; 1409 struct srcimp_mgr *srcimp_mgr; 1410 struct sum_desc sum_dsc = {0}; 1411 struct sum_mgr *sum_mgr; 1412 struct capabilities cap; 1413 int atc_srcs_limit; 1414 int err, i; 1415 1416 cap = atc->capabilities(atc); 1417 atc_srcs_limit = cap.dedicated_mic ? NUM_ATC_SRCS : 4; 1418 1419 atc->daios = kcalloc(NUM_DAIOTYP, sizeof(void *), GFP_KERNEL); 1420 if (!atc->daios) 1421 return -ENOMEM; 1422 1423 atc->srcs = kcalloc(NUM_ATC_SRCS, sizeof(void *), GFP_KERNEL); 1424 if (!atc->srcs) 1425 return -ENOMEM; 1426 1427 atc->srcimps = kcalloc(NUM_ATC_SRCS, sizeof(void *), GFP_KERNEL); 1428 if (!atc->srcimps) 1429 return -ENOMEM; 1430 1431 atc->pcm = kcalloc(NUM_ATC_PCM, sizeof(void *), GFP_KERNEL); 1432 if (!atc->pcm) 1433 return -ENOMEM; 1434 1435 daio_mgr = (struct daio_mgr *)atc->rsc_mgrs[DAIO]; 1436 da_desc.msr = atc->msr; 1437 for (i = 0; i < NUM_DAIOTYP; i++) { 1438 if (((i == SPDIFIO) && (atc->model == CTSB073X)) || 1439 ((i == SPDIFI_BAY) && (atc->model != CTSB073X)) || 1440 ((i == MIC) && !cap.dedicated_mic) || 1441 ((i == RCA) && !cap.dedicated_rca)) 1442 continue; 1443 da_desc.type = i; 1444 da_desc.output = (i < LINEIM) || (i == RCA); 1445 err = daio_mgr->get_daio(daio_mgr, &da_desc, 1446 (struct daio **)&atc->daios[i]); 1447 if (err) { 1448 dev_err(atc->card->dev, 1449 "Failed to get DAIO resource %d!!!\n", 1450 i); 1451 return err; 1452 } 1453 } 1454 1455 src_mgr = atc->rsc_mgrs[SRC]; 1456 src_dsc.multi = 1; 1457 src_dsc.msr = atc->msr; 1458 src_dsc.mode = ARCRW; 1459 for (i = 0; i < atc_srcs_limit; i++) { 1460 err = src_mgr->get_src(src_mgr, &src_dsc, 1461 (struct src **)&atc->srcs[i]); 1462 if (err) 1463 return err; 1464 } 1465 1466 srcimp_mgr = atc->rsc_mgrs[SRCIMP]; 1467 srcimp_dsc.msr = 8; 1468 for (i = 0; i < atc_srcs_limit; i++) { 1469 err = srcimp_mgr->get_srcimp(srcimp_mgr, &srcimp_dsc, 1470 (struct srcimp **)&atc->srcimps[i]); 1471 if (err) 1472 return err; 1473 } 1474 1475 sum_mgr = atc->rsc_mgrs[SUM]; 1476 sum_dsc.msr = atc->msr; 1477 for (i = 0; i < NUM_ATC_PCM; i++) { 1478 err = sum_mgr->get_sum(sum_mgr, &sum_dsc, 1479 (struct sum **)&atc->pcm[i]); 1480 if (err) 1481 return err; 1482 } 1483 1484 return 0; 1485 } 1486 1487 static void 1488 atc_connect_dai(struct src_mgr *src_mgr, struct dai *dai, 1489 struct src **srcs, struct srcimp **srcimps) 1490 { 1491 struct rsc *rscs[2] = {NULL}; 1492 struct src *src; 1493 struct srcimp *srcimp; 1494 int i = 0; 1495 1496 rscs[0] = &dai->daio.rscl; 1497 rscs[1] = &dai->daio.rscr; 1498 for (i = 0; i < 2; i++) { 1499 src = srcs[i]; 1500 srcimp = srcimps[i]; 1501 srcimp->ops->map(srcimp, src, rscs[i]); 1502 src_mgr->src_disable(src_mgr, src); 1503 } 1504 1505 src_mgr->commit_write(src_mgr); /* Actually disable SRCs */ 1506 1507 src = srcs[0]; 1508 src->ops->set_pm(src, 1); 1509 for (i = 0; i < 2; i++) { 1510 src = srcs[i]; 1511 src->ops->set_state(src, SRC_STATE_RUN); 1512 src->ops->commit_write(src); 1513 src_mgr->src_enable_s(src_mgr, src); 1514 } 1515 1516 dai->ops->set_srt_srcl(dai, &(srcs[0]->rsc)); 1517 dai->ops->set_srt_srcr(dai, &(srcs[1]->rsc)); 1518 1519 dai->ops->set_enb_src(dai, 1); 1520 dai->ops->set_enb_srt(dai, 1); 1521 dai->ops->commit_write(dai); 1522 1523 src_mgr->commit_write(src_mgr); /* Synchronously enable SRCs */ 1524 } 1525 1526 static void atc_connect_resources(struct ct_atc *atc) 1527 { 1528 struct dai *dai; 1529 struct dao *dao; 1530 struct src *src; 1531 struct sum *sum; 1532 struct ct_mixer *mixer; 1533 struct rsc *rscs[2] = {NULL}; 1534 struct capabilities cap; 1535 int i, j; 1536 1537 mixer = atc->mixer; 1538 cap = atc->capabilities(atc); 1539 1540 for (i = MIX_WAVE_FRONT, j = LINEO1; i <= MIX_SPDIF_OUT; i++, j++) { 1541 mixer->get_output_ports(mixer, i, &rscs[0], &rscs[1]); 1542 dao = container_of(atc->daios[j], struct dao, daio); 1543 dao->ops->set_left_input(dao, rscs[0]); 1544 dao->ops->set_right_input(dao, rscs[1]); 1545 } 1546 1547 if (cap.dedicated_rca) { 1548 /* SE-300PCIE has a dedicated DAC for the RCA. */ 1549 atc_dedicated_rca_select(atc); 1550 } 1551 1552 dai = container_of(atc->daios[LINEIM], struct dai, daio); 1553 atc_connect_dai(atc->rsc_mgrs[SRC], dai, 1554 (struct src **)&atc->srcs[2], 1555 (struct srcimp **)&atc->srcimps[2]); 1556 src = atc->srcs[2]; 1557 mixer->set_input_left(mixer, MIX_LINE_IN, &src->rsc); 1558 src = atc->srcs[3]; 1559 mixer->set_input_right(mixer, MIX_LINE_IN, &src->rsc); 1560 1561 if (cap.dedicated_mic) { 1562 /* Titanium HD has a dedicated ADC for the Mic. */ 1563 /* SE-300PCIE has a 4-channel ADC. */ 1564 dai = container_of(atc->daios[MIC], struct dai, daio); 1565 atc_connect_dai(atc->rsc_mgrs[SRC], dai, 1566 (struct src **)&atc->srcs[4], 1567 (struct srcimp **)&atc->srcimps[4]); 1568 src = atc->srcs[4]; 1569 mixer->set_input_left(mixer, MIX_MIC_IN, &src->rsc); 1570 src = atc->srcs[5]; 1571 mixer->set_input_right(mixer, MIX_MIC_IN, &src->rsc); 1572 } 1573 1574 dai = container_of(atc->daios[atc_spdif_in_type(atc)], struct dai, daio); 1575 atc_connect_dai(atc->rsc_mgrs[SRC], dai, 1576 (struct src **)&atc->srcs[0], 1577 (struct srcimp **)&atc->srcimps[0]); 1578 1579 src = atc->srcs[0]; 1580 mixer->set_input_left(mixer, MIX_SPDIF_IN, &src->rsc); 1581 src = atc->srcs[1]; 1582 mixer->set_input_right(mixer, MIX_SPDIF_IN, &src->rsc); 1583 1584 for (i = MIX_PCMI_FRONT, j = 0; i <= MIX_PCMI_SURROUND; i++, j += 2) { 1585 sum = atc->pcm[j]; 1586 mixer->set_input_left(mixer, i, &sum->rsc); 1587 sum = atc->pcm[j+1]; 1588 mixer->set_input_right(mixer, i, &sum->rsc); 1589 } 1590 } 1591 1592 #ifdef CONFIG_PM_SLEEP 1593 static int atc_suspend(struct ct_atc *atc) 1594 { 1595 struct hw *hw = atc->hw; 1596 1597 snd_power_change_state(atc->card, SNDRV_CTL_POWER_D3hot); 1598 1599 atc_release_resources(atc); 1600 1601 hw->suspend(hw); 1602 1603 return 0; 1604 } 1605 1606 static int atc_hw_resume(struct ct_atc *atc) 1607 { 1608 struct hw *hw = atc->hw; 1609 struct card_conf info = {0}; 1610 1611 /* Re-initialize card hardware. */ 1612 info.rsr = atc->rsr; 1613 info.msr = atc->msr; 1614 info.vm_pgt_phys = atc_get_ptp_phys(atc, 0); 1615 return hw->resume(hw, &info); 1616 } 1617 1618 static int atc_resources_resume(struct ct_atc *atc) 1619 { 1620 struct ct_mixer *mixer; 1621 int err = 0; 1622 1623 /* Get resources */ 1624 err = atc_get_resources(atc); 1625 if (err < 0) { 1626 atc_release_resources(atc); 1627 return err; 1628 } 1629 1630 /* Build topology */ 1631 atc_connect_resources(atc); 1632 1633 mixer = atc->mixer; 1634 mixer->resume(mixer); 1635 1636 return 0; 1637 } 1638 1639 static int atc_resume(struct ct_atc *atc) 1640 { 1641 int err = 0; 1642 1643 /* Do hardware resume. */ 1644 err = atc_hw_resume(atc); 1645 if (err < 0) { 1646 dev_err(atc->card->dev, 1647 "pci_enable_device failed, disabling device\n"); 1648 snd_card_disconnect(atc->card); 1649 return err; 1650 } 1651 1652 err = atc_resources_resume(atc); 1653 if (err < 0) 1654 return err; 1655 1656 snd_power_change_state(atc->card, SNDRV_CTL_POWER_D0); 1657 1658 return 0; 1659 } 1660 #endif 1661 1662 static const struct ct_atc atc_preset = { 1663 .map_audio_buffer = ct_map_audio_buffer, 1664 .unmap_audio_buffer = ct_unmap_audio_buffer, 1665 .pcm_playback_prepare = atc_pcm_playback_prepare, 1666 .pcm_release_resources = atc_pcm_release_resources, 1667 .pcm_playback_start = atc_pcm_playback_start, 1668 .pcm_playback_stop = atc_pcm_stop, 1669 .pcm_playback_position = atc_pcm_playback_position, 1670 .pcm_capture_prepare = atc_pcm_capture_prepare, 1671 .pcm_capture_start = atc_pcm_capture_start, 1672 .pcm_capture_stop = atc_pcm_stop, 1673 .pcm_capture_position = atc_pcm_capture_position, 1674 .spdif_passthru_playback_prepare = spdif_passthru_playback_prepare, 1675 .get_ptp_phys = atc_get_ptp_phys, 1676 .select_line_in = atc_select_line_in, 1677 .select_mic_in = atc_select_mic_in, 1678 .select_digit_io = atc_select_digit_io, 1679 .line_front_unmute = atc_line_front_unmute, 1680 .line_surround_unmute = atc_line_surround_unmute, 1681 .line_clfe_unmute = atc_line_clfe_unmute, 1682 .line_rear_unmute = atc_line_rear_unmute, 1683 .line_in_unmute = atc_line_in_unmute, 1684 .mic_unmute = atc_mic_unmute, 1685 .rca_unmute = atc_rca_unmute, 1686 .spdif_out_unmute = atc_spdif_out_unmute, 1687 .spdif_in_unmute = atc_spdif_in_unmute, 1688 .spdif_out_get_status = atc_spdif_out_get_status, 1689 .spdif_out_set_status = atc_spdif_out_set_status, 1690 .spdif_out_passthru = atc_spdif_out_passthru, 1691 .capabilities = atc_capabilities, 1692 .dedicated_rca_select = atc_dedicated_rca_select, 1693 .output_switch_get = atc_output_switch_get, 1694 .output_switch_put = atc_output_switch_put, 1695 .mic_source_switch_get = atc_mic_source_switch_get, 1696 .mic_source_switch_put = atc_mic_source_switch_put, 1697 #ifdef CONFIG_PM_SLEEP 1698 .suspend = atc_suspend, 1699 .resume = atc_resume, 1700 #endif 1701 }; 1702 1703 /** 1704 * ct_atc_create - create and initialize a hardware manager 1705 * @card: corresponding alsa card object 1706 * @pci: corresponding kernel pci device object 1707 * @rsr: reference sampling rate 1708 * @msr: master sampling rate 1709 * @chip_type: CHIPTYP enum values 1710 * @ssid: vendor ID (upper 16 bits) and device ID (lower 16 bits) 1711 * @ratc: return created object address in it 1712 * 1713 * Creates and initializes a hardware manager. 1714 * 1715 * Creates kmallocated ct_atc structure. Initializes hardware. 1716 * Returns 0 if succeeds, or negative error code if fails. 1717 */ 1718 1719 int ct_atc_create(struct snd_card *card, struct pci_dev *pci, 1720 unsigned int rsr, unsigned int msr, 1721 int chip_type, unsigned int ssid, 1722 struct ct_atc **ratc) 1723 { 1724 struct ct_atc *atc; 1725 static const struct snd_device_ops ops = { 1726 .dev_free = atc_dev_free, 1727 }; 1728 int err; 1729 1730 *ratc = NULL; 1731 1732 atc = kzalloc_obj(*atc); 1733 if (!atc) 1734 return -ENOMEM; 1735 1736 /* Set operations */ 1737 *atc = atc_preset; 1738 1739 atc->card = card; 1740 atc->pci = pci; 1741 atc->rsr = rsr; 1742 atc->msr = msr; 1743 atc->chip_type = chip_type; 1744 1745 mutex_init(&atc->atc_mutex); 1746 1747 /* Find card model */ 1748 err = atc_identify_card(atc, ssid); 1749 if (err < 0) { 1750 dev_err(card->dev, "ctatc: Card not recognised\n"); 1751 goto error1; 1752 } 1753 1754 /* Set up device virtual memory management object */ 1755 err = ct_vm_create(&atc->vm, pci); 1756 if (err < 0) 1757 goto error1; 1758 1759 /* Create all atc hw devices */ 1760 err = atc_create_hw_devs(atc); 1761 if (err < 0) 1762 goto error1; 1763 1764 err = ct_mixer_create(atc, (struct ct_mixer **)&atc->mixer); 1765 if (err) { 1766 dev_err(card->dev, "Failed to create mixer obj!!!\n"); 1767 goto error1; 1768 } 1769 1770 /* Get resources */ 1771 err = atc_get_resources(atc); 1772 if (err < 0) 1773 goto error1; 1774 1775 /* Build topology */ 1776 atc_connect_resources(atc); 1777 1778 atc->timer = ct_timer_new(atc); 1779 if (!atc->timer) { 1780 err = -ENOMEM; 1781 goto error1; 1782 } 1783 1784 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, atc, &ops); 1785 if (err < 0) 1786 goto error1; 1787 1788 *ratc = atc; 1789 return 0; 1790 1791 error1: 1792 ct_atc_destroy(atc); 1793 dev_err(card->dev, "Something wrong!!!\n"); 1794 return err; 1795 } 1796