Lines Matching +full:hw +full:- +full:channels
1 // SPDX-License-Identifier: GPL-2.0-only
28 #define MONO_SUM_SCALE 0x19a8 /* 2^(-0.5) in 14-bit floating format */
101 .public_name = "IEC958 Non-audio"},
109 int (*create)(struct hw *hw, void **rmgr);
137 if (!apcm->substream)
140 runtime = apcm->substream->runtime;
141 vm = atc->vm;
143 apcm->vm_block = vm->map(vm, apcm->substream, runtime->dma_bytes);
145 if (!apcm->vm_block)
146 return -ENOENT;
155 if (!apcm->vm_block)
158 vm = atc->vm;
160 vm->unmap(vm, apcm->vm_block);
162 apcm->vm_block = NULL;
167 return atc->vm->get_ptp_phys(atc->vm, index);
185 dev_err(card->dev, "not recognized snd format is %d\n",
197 /* get pitch and convert to fixed-point 8.24 format. */
203 b--;
206 input_rate <<= (31 - b);
208 b = 24 - (31 - b);
212 input_rate >>= -b;
235 return -ENOENT;
241 struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
242 struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER];
248 int n_amixer = apcm->substream->runtime->channels, i = 0;
249 int device = apcm->substream->pcm->device;
256 desc.multi = apcm->substream->runtime->channels;
257 desc.msr = atc->msr;
259 err = src_mgr->get_src(src_mgr, &desc, (struct src **)&apcm->src);
263 pitch = atc_get_pitch(apcm->substream->runtime->rate,
264 (atc->rsr * atc->msr));
265 src = apcm->src;
266 src->ops->set_pitch(src, pitch);
267 src->ops->set_rom(src, select_rom(pitch));
268 src->ops->set_sf(src, convert_format(apcm->substream->runtime->format,
269 atc->card));
270 src->ops->set_pm(src, (src->ops->next_interleave(src) != NULL));
274 apcm->amixers = kcalloc(n_amixer, sizeof(void *), GFP_KERNEL);
275 if (!apcm->amixers) {
276 err = -ENOMEM;
279 mix_dsc.msr = atc->msr;
280 for (i = 0, apcm->n_amixer = 0; i < n_amixer; i++) {
281 err = amixer_mgr->get_amixer(amixer_mgr, &mix_dsc,
282 (struct amixer **)&apcm->amixers[i]);
286 apcm->n_amixer++;
295 src = apcm->src;
297 amixer = apcm->amixers[i];
298 scoped_guard(mutex, &atc->atc_mutex) {
299 amixer->ops->setup(amixer, &src->rsc,
300 INIT_VOL, atc->pcm[i+device*2]);
302 src = src->ops->next_interleave(src);
304 src = apcm->src;
307 ct_timer_prepare(apcm->timer);
319 struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
320 struct srcimp_mgr *srcimp_mgr = atc->rsc_mgrs[SRCIMP];
321 struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER];
322 struct sum_mgr *sum_mgr = atc->rsc_mgrs[SUM];
326 if (apcm->srcimps) {
327 for (i = 0; i < apcm->n_srcimp; i++) {
328 srcimp = apcm->srcimps[i];
329 srcimp->ops->unmap(srcimp);
330 srcimp_mgr->put_srcimp(srcimp_mgr, srcimp);
331 apcm->srcimps[i] = NULL;
333 kfree(apcm->srcimps);
334 apcm->srcimps = NULL;
337 if (apcm->srccs) {
338 for (i = 0; i < apcm->n_srcc; i++) {
339 src_mgr->put_src(src_mgr, apcm->srccs[i]);
340 apcm->srccs[i] = NULL;
342 kfree(apcm->srccs);
343 apcm->srccs = NULL;
346 if (apcm->amixers) {
347 for (i = 0; i < apcm->n_amixer; i++) {
348 amixer_mgr->put_amixer(amixer_mgr, apcm->amixers[i]);
349 apcm->amixers[i] = NULL;
351 kfree(apcm->amixers);
352 apcm->amixers = NULL;
355 if (apcm->mono) {
356 sum_mgr->put_sum(sum_mgr, apcm->mono);
357 apcm->mono = NULL;
360 if (apcm->src) {
361 src_mgr->put_src(src_mgr, apcm->src);
362 apcm->src = NULL;
365 if (apcm->vm_block) {
368 apcm->vm_block = NULL;
377 struct src *src = apcm->src;
379 if (apcm->started)
381 apcm->started = 1;
383 max_cisz = src->multi * src->rsc.msr;
386 src->ops->set_sa(src, apcm->vm_block->addr);
387 src->ops->set_la(src, apcm->vm_block->addr + apcm->vm_block->size);
388 src->ops->set_ca(src, apcm->vm_block->addr + max_cisz);
389 src->ops->set_cisz(src, max_cisz);
391 src->ops->set_bm(src, 1);
392 src->ops->set_state(src, SRC_STATE_INIT);
393 src->ops->commit_write(src);
395 ct_timer_start(apcm->timer);
404 ct_timer_stop(apcm->timer);
406 src = apcm->src;
407 src->ops->set_bm(src, 0);
408 src->ops->set_state(src, SRC_STATE_OFF);
409 src->ops->commit_write(src);
411 if (apcm->srccs) {
412 for (i = 0; i < apcm->n_srcc; i++) {
413 src = apcm->srccs[i];
414 src->ops->set_bm(src, 0);
415 src->ops->set_state(src, SRC_STATE_OFF);
416 src->ops->commit_write(src);
420 apcm->started = 0;
428 struct src *src = apcm->src;
434 position = src->ops->get_ca(src);
436 if (position < apcm->vm_block->addr) {
437 dev_dbg(atc->card->dev,
438 "bad ca - ca=0x%08x, vba=0x%08x, vbs=0x%08x\n",
439 position, apcm->vm_block->addr, apcm->vm_block->size);
440 position = apcm->vm_block->addr;
443 size = apcm->vm_block->size;
444 max_cisz = src->multi * src->rsc.msr;
447 return (position + size - max_cisz - apcm->vm_block->addr) % size;
463 /* get pitch and convert to fixed-point 8.24 format. */
464 pitch = atc_get_pitch((atc->rsr * atc->msr),
465 apcm->substream->runtime->rate);
468 if (1 == atc->msr) { /* FIXME: do we really need SRC here if pitch==1 */
469 *n_srcc = apcm->substream->runtime->channels;
473 } else if (2 <= atc->msr) {
475 /* Need two-stage SRCs, SRCIMPs and
477 conf[0].pitch = (atc->msr << 24);
479 conf[0].imp_msr = atc->msr;
481 conf[1].pitch = atc_get_pitch(atc->rsr,
482 apcm->substream->runtime->rate);
485 *n_srcc = apcm->substream->runtime->channels * 2;
487 /* Need one-stage SRCs, SRCIMPs and
491 = conf[0].imp_msr = atc->msr;
493 *n_srcc = apcm->substream->runtime->channels;
501 struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
502 struct srcimp_mgr *srcimp_mgr = atc->rsc_mgrs[SRCIMP];
503 struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER];
504 struct sum_mgr *sum_mgr = atc->rsc_mgrs[SUM];
522 multi = apcm->substream->runtime->channels;
524 /* get pitch and convert to fixed-point 8.24 format. */
525 pitch = atc_get_pitch((atc->rsr * atc->msr),
526 apcm->substream->runtime->rate);
534 * of interleaved recording of conjugate channels */
535 n_amixer += multi * atc->msr;
536 n_srcimp += multi * atc->msr;
542 apcm->srccs = kcalloc(n_srcc, sizeof(void *), GFP_KERNEL);
543 if (!apcm->srccs)
544 return -ENOMEM;
547 apcm->amixers = kcalloc(n_amixer, sizeof(void *), GFP_KERNEL);
548 if (!apcm->amixers) {
549 err = -ENOMEM;
553 apcm->srcimps = kcalloc(n_srcimp, sizeof(void *), GFP_KERNEL);
554 if (!apcm->srcimps) {
555 err = -ENOMEM;
562 for (i = 0, apcm->n_srcc = 0; i < n_srcc; i++) {
564 err = src_mgr->get_src(src_mgr, &src_dsc,
565 (struct src **)&apcm->srccs[i]);
569 src = apcm->srccs[i];
571 src->ops->set_pitch(src, pitch);
572 src->ops->set_rom(src, select_rom(pitch));
573 src->ops->set_vo(src, src_node_conf[i/multi].vo);
575 apcm->n_srcc++;
579 for (i = 0, apcm->n_amixer = 0; i < n_amixer; i++) {
581 mix_dsc.msr = atc->msr;
583 mix_dsc.msr = src_node_conf[(i-n_sum*2)/multi].mix_msr;
587 err = amixer_mgr->get_amixer(amixer_mgr, &mix_dsc,
588 (struct amixer **)&apcm->amixers[i]);
592 apcm->n_amixer++;
595 /* Allocate a SUM resource to mix all input channels together */
596 sum_dsc.msr = atc->msr;
597 err = sum_mgr->get_sum(sum_mgr, &sum_dsc, (struct sum **)&apcm->mono);
601 pitch = atc_get_pitch((atc->rsr * atc->msr),
602 apcm->substream->runtime->rate);
604 for (i = 0, apcm->n_srcimp = 0; i < n_srcimp; i++) {
608 srcimp_dsc.msr = (pitch <= 0x8000000) ? atc->msr : 1;
612 err = srcimp_mgr->get_srcimp(srcimp_mgr, &srcimp_dsc, &srcimp);
616 apcm->srcimps[i] = srcimp;
617 apcm->n_srcimp++;
621 src_dsc.multi = apcm->substream->runtime->channels;
624 err = src_mgr->get_src(src_mgr, &src_dsc, (struct src **)&apcm->src);
628 src = apcm->src;
629 src->ops->set_pitch(src, pitch);
648 struct ct_mixer *mixer = atc->mixer;
663 mixer->get_output_ports(mixer, MIX_PCMO_FRONT,
666 multi = apcm->substream->runtime->channels;
668 mono = apcm->mono;
670 amixer = apcm->amixers[i];
671 amixer->ops->setup(amixer, out_ports[i],
674 out_ports[0] = &mono->rsc;
679 for (i = 0; i < apcm->n_srcc; i++) {
680 src = apcm->srccs[i];
681 srcimp = apcm->srcimps[imp_base+i];
682 amixer = apcm->amixers[mix_base+i];
683 srcimp->ops->map(srcimp, src, out_ports[i%multi]);
684 amixer->ops->setup(amixer, &src->rsc, INIT_VOL, NULL);
685 out_ports[i%multi] = &amixer->rsc;
688 pitch = atc_get_pitch((atc->rsr * atc->msr),
689 apcm->substream->runtime->rate);
693 * recording with conjugate channels */
695 out_ports[i]->ops->master(out_ports[i]);
696 for (j = 0; j < atc->msr; j++) {
697 amixer = apcm->amixers[apcm->n_srcc+j*multi+i];
698 amixer->ops->set_input(amixer, out_ports[i]);
699 amixer->ops->set_scale(amixer, INIT_VOL);
700 amixer->ops->set_sum(amixer, NULL);
701 amixer->ops->commit_raw_write(amixer);
702 out_ports[i]->ops->next_conj(out_ports[i]);
704 srcimp = apcm->srcimps[apcm->n_srcc+j*multi+i];
705 srcimp->ops->map(srcimp, apcm->src,
706 &amixer->rsc);
711 srcimp = apcm->srcimps[apcm->n_srcc+i];
712 srcimp->ops->map(srcimp, apcm->src, out_ports[i]);
716 ct_timer_prepare(apcm->timer);
724 struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
727 if (apcm->started)
730 apcm->started = 1;
731 multi = apcm->substream->runtime->channels;
733 for (i = 0; i < apcm->n_srcc; i++) {
734 src = apcm->srccs[i];
735 src->ops->set_pm(src, ((i%multi) != (multi-1)));
736 src_mgr->src_disable(src_mgr, src);
740 src = apcm->src;
741 src->ops->set_sf(src, convert_format(apcm->substream->runtime->format,
742 atc->card));
743 src->ops->set_sa(src, apcm->vm_block->addr);
744 src->ops->set_la(src, apcm->vm_block->addr + apcm->vm_block->size);
745 src->ops->set_ca(src, apcm->vm_block->addr);
746 src_mgr->src_disable(src_mgr, src);
749 src_mgr->commit_write(src_mgr);
752 for (i = 0; i < apcm->n_srcc; i++) {
753 src = apcm->srccs[i];
754 src->ops->set_state(src, SRC_STATE_RUN);
755 src->ops->commit_write(src);
756 src_mgr->src_enable_s(src_mgr, src);
758 src = apcm->src;
759 src->ops->set_bm(src, 1);
760 src->ops->set_state(src, SRC_STATE_RUN);
761 src->ops->commit_write(src);
762 src_mgr->src_enable_s(src_mgr, src);
765 src_mgr->commit_write(src_mgr);
767 ct_timer_start(apcm->timer);
774 struct src *src = apcm->src;
778 return src->ops->get_ca(src) - apcm->vm_block->addr;
784 struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
785 struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER];
790 int n_amixer = apcm->substream->runtime->channels, i;
791 unsigned int pitch, rsr = atc->pll_rate;
797 desc.multi = apcm->substream->runtime->channels;
799 while (apcm->substream->runtime->rate > (rsr * desc.msr))
803 err = src_mgr->get_src(src_mgr, &desc, (struct src **)&apcm->src);
807 pitch = atc_get_pitch(apcm->substream->runtime->rate, (rsr * desc.msr));
808 src = apcm->src;
809 src->ops->set_pitch(src, pitch);
810 src->ops->set_rom(src, select_rom(pitch));
811 src->ops->set_sf(src, convert_format(apcm->substream->runtime->format,
812 atc->card));
813 src->ops->set_pm(src, (src->ops->next_interleave(src) != NULL));
814 src->ops->set_bp(src, 1);
818 apcm->amixers = kcalloc(n_amixer, sizeof(void *), GFP_KERNEL);
819 if (!apcm->amixers) {
820 err = -ENOMEM;
824 for (i = 0, apcm->n_amixer = 0; i < n_amixer; i++) {
825 err = amixer_mgr->get_amixer(amixer_mgr, &mix_dsc,
826 (struct amixer **)&apcm->amixers[i]);
830 apcm->n_amixer++;
847 struct hw *hw = atc->hw;
849 err = hw->pll_init(hw, rate);
850 atc->pll_rate = err ? 0 : rate;
857 struct dao *dao = container_of(atc->daios[SPDIFOO], struct dao, daio);
858 unsigned int rate = apcm->substream->runtime->rate;
874 return -ENOENT;
877 guard(mutex)(&atc->atc_mutex);
878 dao->ops->get_spos(dao, &status);
882 dao->ops->set_spos(dao, status);
883 dao->ops->commit_write(dao);
885 if ((rate != atc->pll_rate) && (32000 != rate))
914 src = apcm->src;
915 for (i = 0; i < apcm->n_amixer; i++) {
916 amixer = apcm->amixers[i];
917 amixer->ops->setup(amixer, &src->rsc, INIT_VOL, NULL);
918 src = src->ops->next_interleave(src);
920 src = apcm->src;
923 scoped_guard(mutex, &atc->atc_mutex) {
924 dao = container_of(atc->daios[SPDIFOO], struct dao, daio);
925 amixer = apcm->amixers[0];
926 dao->ops->set_left_input(dao, &amixer->rsc);
927 amixer = apcm->amixers[1];
928 dao->ops->set_right_input(dao, &amixer->rsc);
931 ct_timer_prepare(apcm->timer);
938 struct hw *hw = atc->hw;
939 struct ct_mixer *mixer = atc->mixer;
942 if (hw->is_adc_source_selected(hw, ADC_LINEIN))
945 mixer->set_input_left(mixer, MIX_MIC_IN, NULL);
946 mixer->set_input_right(mixer, MIX_MIC_IN, NULL);
948 hw->select_adc_source(hw, ADC_LINEIN);
950 src = atc->srcs[2];
951 mixer->set_input_left(mixer, MIX_LINE_IN, &src->rsc);
952 src = atc->srcs[3];
953 mixer->set_input_right(mixer, MIX_LINE_IN, &src->rsc);
960 struct hw *hw = atc->hw;
961 struct ct_mixer *mixer = atc->mixer;
964 if (hw->is_adc_source_selected(hw, ADC_MICIN))
967 mixer->set_input_left(mixer, MIX_LINE_IN, NULL);
968 mixer->set_input_right(mixer, MIX_LINE_IN, NULL);
970 hw->select_adc_source(hw, ADC_MICIN);
972 src = atc->srcs[2];
973 mixer->set_input_left(mixer, MIX_MIC_IN, &src->rsc);
974 src = atc->srcs[3];
975 mixer->set_input_right(mixer, MIX_MIC_IN, &src->rsc);
982 struct hw *hw = atc->hw;
984 return hw->capabilities(hw);
989 struct hw *hw = atc->hw;
991 return hw->output_switch_get(hw);
996 struct hw *hw = atc->hw;
998 return hw->output_switch_put(hw, position);
1003 struct hw *hw = atc->hw;
1005 return hw->mic_source_switch_get(hw);
1010 struct hw *hw = atc->hw;
1012 return hw->mic_source_switch_put(hw, position);
1017 struct hw *hw = atc->hw;
1019 if (hw->is_adc_source_selected(hw, ADC_NONE))
1022 hw->select_adc_source(hw, ADC_NONE);
1029 struct daio_mgr *daio_mgr = atc->rsc_mgrs[DAIO];
1032 daio_mgr->daio_enable(daio_mgr, atc->daios[type]);
1034 daio_mgr->daio_disable(daio_mgr, atc->daios[type]);
1036 daio_mgr->commit_write(daio_mgr);
1044 struct dao *dao = container_of(atc->daios[type], struct dao, daio);
1045 return dao->ops->get_spos(dao, status);
1051 struct dao *dao = container_of(atc->daios[type], struct dao, daio);
1053 dao->ops->set_spos(dao, status);
1054 dao->ops->commit_write(dao);
1113 struct ct_mixer *mixer = atc->mixer;
1117 guard(mutex)(&atc->atc_mutex);
1118 dao = container_of(atc->daios[SPDIFOO], struct dao, daio);
1119 da_dsc.msr = state ? 1 : atc->msr;
1121 err = dao->ops->reinit(dao, &da_dsc);
1125 mixer->get_output_ports(mixer, MIX_SPDIF_OUT,
1127 dao->ops->set_left_input(dao, rscs[0]);
1128 dao->ops->set_right_input(dao, rscs[1]);
1129 /* Restore PLL to atc->rsr if needed. */
1130 if (atc->pll_rate != atc->rsr)
1131 err = atc_pll_init(atc, atc->rsr);
1133 dao->ops->set_spos(dao, spos);
1134 dao->ops->commit_write(dao);
1152 if (atc->mixer) {
1153 mixer = atc->mixer;
1154 mixer->set_input_left(mixer, MIX_LINE_IN, NULL);
1155 mixer->set_input_right(mixer, MIX_LINE_IN, NULL);
1156 mixer->set_input_left(mixer, MIX_MIC_IN, NULL);
1157 mixer->set_input_right(mixer, MIX_MIC_IN, NULL);
1158 mixer->set_input_left(mixer, MIX_SPDIF_IN, NULL);
1159 mixer->set_input_right(mixer, MIX_SPDIF_IN, NULL);
1162 if (atc->daios) {
1163 daio_mgr = (struct daio_mgr *)atc->rsc_mgrs[DAIO];
1164 for (i = 0; i < atc->n_daio; i++) {
1165 daio = atc->daios[i];
1166 if (daio->type < LINEIM) {
1168 dao->ops->clear_left_input(dao);
1169 dao->ops->clear_right_input(dao);
1171 daio_mgr->put_daio(daio_mgr, daio);
1173 kfree(atc->daios);
1174 atc->daios = NULL;
1177 if (atc->pcm) {
1178 sum_mgr = atc->rsc_mgrs[SUM];
1179 for (i = 0; i < atc->n_pcm; i++)
1180 sum_mgr->put_sum(sum_mgr, atc->pcm[i]);
1182 kfree(atc->pcm);
1183 atc->pcm = NULL;
1186 if (atc->srcs) {
1187 src_mgr = atc->rsc_mgrs[SRC];
1188 for (i = 0; i < atc->n_src; i++)
1189 src_mgr->put_src(src_mgr, atc->srcs[i]);
1191 kfree(atc->srcs);
1192 atc->srcs = NULL;
1195 if (atc->srcimps) {
1196 srcimp_mgr = atc->rsc_mgrs[SRCIMP];
1197 for (i = 0; i < atc->n_srcimp; i++) {
1198 srcimp = atc->srcimps[i];
1199 srcimp->ops->unmap(srcimp);
1200 srcimp_mgr->put_srcimp(srcimp_mgr, atc->srcimps[i]);
1202 kfree(atc->srcimps);
1203 atc->srcimps = NULL;
1216 if (atc->timer) {
1217 ct_timer_free(atc->timer);
1218 atc->timer = NULL;
1224 if (atc->mixer)
1225 ct_mixer_destroy(atc->mixer);
1228 if (rsc_mgr_funcs[i].destroy && atc->rsc_mgrs[i])
1229 rsc_mgr_funcs[i].destroy(atc->rsc_mgrs[i]);
1233 if (atc->hw)
1234 destroy_hw_obj(atc->hw);
1237 if (atc->vm) {
1238 ct_vm_destroy(atc->vm);
1239 atc->vm = NULL;
1249 struct ct_atc *atc = dev->device_data;
1259 switch (atc->chip_type) {
1261 atc->chip_name = "20K1";
1265 atc->chip_name = "20K2";
1269 return -ENOENT;
1275 vendor_id = atc->pci->subsystem_vendor;
1276 device_id = atc->pci->subsystem_device;
1280 if (p->value < 0) {
1281 dev_err(atc->card->dev,
1284 return -ENOENT;
1286 atc->model = p->value;
1288 if (atc->chip_type == ATC20K1)
1289 atc->model = CT20K1_UNKNOWN;
1291 atc->model = CT20K2_UNKNOWN;
1293 atc->model_name = ct_subsys_name[atc->model];
1294 dev_info(atc->card->dev, "chip %s model %s (%04x:%04x) is found\n",
1295 atc->chip_name, atc->model_name,
1305 alsa_dev_funcs[MIXER].public_name = atc->chip_name;
1314 dev_err(atc->card->dev,
1325 struct hw *hw;
1329 err = create_hw_obj(atc->pci, atc->chip_type, atc->model, &hw);
1331 dev_err(atc->card->dev, "Failed to create hw obj!!!\n");
1334 hw->card = atc->card;
1335 atc->hw = hw;
1338 info.rsr = atc->rsr;
1339 info.msr = atc->msr;
1341 err = hw->card_init(hw, &info);
1349 err = rsc_mgr_funcs[i].create(atc->hw, &atc->rsc_mgrs[i]);
1351 dev_err(atc->card->dev,
1372 num_daios = ((atc->model == CTSB1270) ? 8 : 7);
1373 num_srcs = ((atc->model == CTSB1270) ? 6 : 4);
1375 atc->daios = kcalloc(num_daios, sizeof(void *), GFP_KERNEL);
1376 if (!atc->daios)
1377 return -ENOMEM;
1379 atc->srcs = kcalloc(num_srcs, sizeof(void *), GFP_KERNEL);
1380 if (!atc->srcs)
1381 return -ENOMEM;
1383 atc->srcimps = kcalloc(num_srcs, sizeof(void *), GFP_KERNEL);
1384 if (!atc->srcimps)
1385 return -ENOMEM;
1387 atc->pcm = kcalloc(2 * 4, sizeof(void *), GFP_KERNEL);
1388 if (!atc->pcm)
1389 return -ENOMEM;
1391 daio_mgr = (struct daio_mgr *)atc->rsc_mgrs[DAIO];
1392 da_desc.msr = atc->msr;
1393 for (i = 0, atc->n_daio = 0; i < num_daios; i++) {
1394 da_desc.type = (atc->model != CTSB073X) ? i :
1396 err = daio_mgr->get_daio(daio_mgr, &da_desc,
1397 (struct daio **)&atc->daios[i]);
1399 dev_err(atc->card->dev,
1404 atc->n_daio++;
1407 src_mgr = atc->rsc_mgrs[SRC];
1409 src_dsc.msr = atc->msr;
1411 for (i = 0, atc->n_src = 0; i < num_srcs; i++) {
1412 err = src_mgr->get_src(src_mgr, &src_dsc,
1413 (struct src **)&atc->srcs[i]);
1417 atc->n_src++;
1420 srcimp_mgr = atc->rsc_mgrs[SRCIMP];
1422 for (i = 0, atc->n_srcimp = 0; i < num_srcs; i++) {
1423 err = srcimp_mgr->get_srcimp(srcimp_mgr, &srcimp_dsc,
1424 (struct srcimp **)&atc->srcimps[i]);
1428 atc->n_srcimp++;
1431 sum_mgr = atc->rsc_mgrs[SUM];
1432 sum_dsc.msr = atc->msr;
1433 for (i = 0, atc->n_pcm = 0; i < (2*4); i++) {
1434 err = sum_mgr->get_sum(sum_mgr, &sum_dsc,
1435 (struct sum **)&atc->pcm[i]);
1439 atc->n_pcm++;
1454 rscs[0] = &dai->daio.rscl;
1455 rscs[1] = &dai->daio.rscr;
1459 srcimp->ops->map(srcimp, src, rscs[i]);
1460 src_mgr->src_disable(src_mgr, src);
1463 src_mgr->commit_write(src_mgr); /* Actually disable SRCs */
1466 src->ops->set_pm(src, 1);
1469 src->ops->set_state(src, SRC_STATE_RUN);
1470 src->ops->commit_write(src);
1471 src_mgr->src_enable_s(src_mgr, src);
1474 dai->ops->set_srt_srcl(dai, &(srcs[0]->rsc));
1475 dai->ops->set_srt_srcr(dai, &(srcs[1]->rsc));
1477 dai->ops->set_enb_src(dai, 1);
1478 dai->ops->set_enb_srt(dai, 1);
1479 dai->ops->commit_write(dai);
1481 src_mgr->commit_write(src_mgr); /* Synchronously enable SRCs */
1494 mixer = atc->mixer;
1497 mixer->get_output_ports(mixer, i, &rscs[0], &rscs[1]);
1498 dao = container_of(atc->daios[j], struct dao, daio);
1499 dao->ops->set_left_input(dao, rscs[0]);
1500 dao->ops->set_right_input(dao, rscs[1]);
1503 dai = container_of(atc->daios[LINEIM], struct dai, daio);
1504 atc_connect_dai(atc->rsc_mgrs[SRC], dai,
1505 (struct src **)&atc->srcs[2],
1506 (struct srcimp **)&atc->srcimps[2]);
1507 src = atc->srcs[2];
1508 mixer->set_input_left(mixer, MIX_LINE_IN, &src->rsc);
1509 src = atc->srcs[3];
1510 mixer->set_input_right(mixer, MIX_LINE_IN, &src->rsc);
1512 if (atc->model == CTSB1270) {
1514 dai = container_of(atc->daios[MIC], struct dai, daio);
1515 atc_connect_dai(atc->rsc_mgrs[SRC], dai,
1516 (struct src **)&atc->srcs[4],
1517 (struct srcimp **)&atc->srcimps[4]);
1518 src = atc->srcs[4];
1519 mixer->set_input_left(mixer, MIX_MIC_IN, &src->rsc);
1520 src = atc->srcs[5];
1521 mixer->set_input_right(mixer, MIX_MIC_IN, &src->rsc);
1524 dai = container_of(atc->daios[SPDIFIO], struct dai, daio);
1525 atc_connect_dai(atc->rsc_mgrs[SRC], dai,
1526 (struct src **)&atc->srcs[0],
1527 (struct srcimp **)&atc->srcimps[0]);
1529 src = atc->srcs[0];
1530 mixer->set_input_left(mixer, MIX_SPDIF_IN, &src->rsc);
1531 src = atc->srcs[1];
1532 mixer->set_input_right(mixer, MIX_SPDIF_IN, &src->rsc);
1535 sum = atc->pcm[j];
1536 mixer->set_input_left(mixer, i, &sum->rsc);
1537 sum = atc->pcm[j+1];
1538 mixer->set_input_right(mixer, i, &sum->rsc);
1545 struct hw *hw = atc->hw;
1547 snd_power_change_state(atc->card, SNDRV_CTL_POWER_D3hot);
1551 hw->suspend(hw);
1558 struct hw *hw = atc->hw;
1561 /* Re-initialize card hardware. */
1562 info.rsr = atc->rsr;
1563 info.msr = atc->msr;
1565 return hw->resume(hw, &info);
1583 mixer = atc->mixer;
1584 mixer->resume(mixer);
1596 dev_err(atc->card->dev,
1598 snd_card_disconnect(atc->card);
1606 snd_power_change_state(atc->card, SNDRV_CTL_POWER_D0);
1652 * ct_atc_create - create and initialize a hardware manager
1682 return -ENOMEM;
1687 atc->card = card;
1688 atc->pci = pci;
1689 atc->rsr = rsr;
1690 atc->msr = msr;
1691 atc->chip_type = chip_type;
1693 mutex_init(&atc->atc_mutex);
1698 dev_err(card->dev, "ctatc: Card not recognised\n");
1703 err = ct_vm_create(&atc->vm, pci);
1707 /* Create all atc hw devices */
1712 err = ct_mixer_create(atc, (struct ct_mixer **)&atc->mixer);
1714 dev_err(card->dev, "Failed to create mixer obj!!!\n");
1726 atc->timer = ct_timer_new(atc);
1727 if (!atc->timer) {
1728 err = -ENOMEM;
1741 dev_err(card->dev, "Something wrong!!!\n");