Lines Matching defs:atc
82 int (*create)(struct ct_atc *atc,
128 atc_pcm_release_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm);
135 static int ct_map_audio_buffer(struct ct_atc *atc, struct ct_atc_pcm *apcm)
144 vm = atc->vm;
154 static void ct_unmap_audio_buffer(struct ct_atc *atc, struct ct_atc_pcm *apcm)
161 vm = atc->vm;
168 static unsigned long atc_get_ptp_phys(struct ct_atc *atc, int index)
170 return atc->vm->get_ptp_phys(atc->vm, index);
241 static int atc_pcm_playback_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm)
243 struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
244 struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER];
255 atc_pcm_release_resources(atc, apcm);
259 desc.msr = atc->msr;
266 (atc->rsr * atc->msr));
280 mix_dsc.msr = atc->msr;
291 err = ct_map_audio_buffer(atc, apcm);
299 mutex_lock(&atc->atc_mutex);
301 INIT_VOL, atc->pcm[i+device*2]);
302 mutex_unlock(&atc->atc_mutex);
313 atc_pcm_release_resources(atc, apcm);
318 atc_pcm_release_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm)
320 struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
321 struct srcimp_mgr *srcimp_mgr = atc->rsc_mgrs[SRCIMP];
322 struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER];
323 struct sum_mgr *sum_mgr = atc->rsc_mgrs[SUM];
368 ct_unmap_audio_buffer(atc, apcm);
375 static int atc_pcm_playback_start(struct ct_atc *atc, struct ct_atc_pcm *apcm)
400 static int atc_pcm_stop(struct ct_atc *atc, struct ct_atc_pcm *apcm)
427 atc_pcm_playback_position(struct ct_atc *atc, struct ct_atc_pcm *apcm)
452 static void setup_src_node_conf(struct ct_atc *atc, struct ct_atc_pcm *apcm,
458 pitch = atc_get_pitch((atc->rsr * atc->msr),
462 if (1 == atc->msr) {
467 } else if (2 == atc->msr) {
471 conf[0].pitch = (atc->msr << 24);
473 conf[0].imp_msr = atc->msr;
475 conf[1].pitch = atc_get_pitch(atc->rsr,
485 = conf[0].imp_msr = atc->msr;
493 atc_pcm_capture_get_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm)
495 struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
496 struct srcimp_mgr *srcimp_mgr = atc->rsc_mgrs[SRCIMP];
497 struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER];
498 struct sum_mgr *sum_mgr = atc->rsc_mgrs[SUM];
511 atc_pcm_release_resources(atc, apcm);
519 pitch = atc_get_pitch((atc->rsr * atc->msr),
522 setup_src_node_conf(atc, apcm, src_node_conf, &n_srcc);
529 n_amixer += multi * atc->msr;
530 n_srcimp += multi * atc->msr;
575 mix_dsc.msr = atc->msr;
590 sum_dsc.msr = atc->msr;
595 pitch = atc_get_pitch((atc->rsr * atc->msr),
602 srcimp_dsc.msr = (pitch <= 0x8000000) ? atc->msr : 1;
626 err = ct_map_audio_buffer(atc, apcm);
633 atc_pcm_release_resources(atc, apcm);
637 static int atc_pcm_capture_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm)
642 struct ct_mixer *mixer = atc->mixer;
649 atc_pcm_release_resources(atc, apcm);
652 err = atc_pcm_capture_get_resources(atc, apcm);
682 pitch = atc_get_pitch((atc->rsr * atc->msr),
690 for (j = 0; j < atc->msr; j++) {
715 static int atc_pcm_capture_start(struct ct_atc *atc, struct ct_atc_pcm *apcm)
718 struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
765 atc_pcm_capture_position(struct ct_atc *atc, struct ct_atc_pcm *apcm)
774 static int spdif_passthru_playback_get_resources(struct ct_atc *atc,
777 struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
778 struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER];
784 unsigned int pitch, rsr = atc->pll_rate;
787 atc_pcm_release_resources(atc, apcm);
826 err = ct_map_audio_buffer(atc, apcm);
833 atc_pcm_release_resources(atc, apcm);
837 static int atc_pll_init(struct ct_atc *atc, int rate)
839 struct hw *hw = atc->hw;
842 atc->pll_rate = err ? 0 : rate;
847 spdif_passthru_playback_setup(struct ct_atc *atc, struct ct_atc_pcm *apcm)
849 struct dao *dao = container_of(atc->daios[SPDIFOO], struct dao, daio);
869 mutex_lock(&atc->atc_mutex);
877 if ((rate != atc->pll_rate) && (32000 != rate))
878 err = atc_pll_init(atc, rate);
879 mutex_unlock(&atc->atc_mutex);
885 spdif_passthru_playback_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm)
893 atc_pcm_release_resources(atc, apcm);
897 err = spdif_passthru_playback_setup(atc, apcm);
902 err = spdif_passthru_playback_get_resources(atc, apcm);
916 mutex_lock(&atc->atc_mutex);
917 dao = container_of(atc->daios[SPDIFOO], struct dao, daio);
922 mutex_unlock(&atc->atc_mutex);
929 static int atc_select_line_in(struct ct_atc *atc)
931 struct hw *hw = atc->hw;
932 struct ct_mixer *mixer = atc->mixer;
943 src = atc->srcs[2];
945 src = atc->srcs[3];
951 static int atc_select_mic_in(struct ct_atc *atc)
953 struct hw *hw = atc->hw;
954 struct ct_mixer *mixer = atc->mixer;
965 src = atc->srcs[2];
967 src = atc->srcs[3];
973 static int atc_have_digit_io_switch(struct ct_atc *atc)
975 struct hw *hw = atc->hw;
980 static int atc_select_digit_io(struct ct_atc *atc)
982 struct hw *hw = atc->hw;
992 static int atc_daio_unmute(struct ct_atc *atc, unsigned char state, int type)
994 struct daio_mgr *daio_mgr = atc->rsc_mgrs[DAIO];
997 daio_mgr->daio_enable(daio_mgr, atc->daios[type]);
999 daio_mgr->daio_disable(daio_mgr, atc->daios[type]);
1007 atc_dao_get_status(struct ct_atc *atc, unsigned int *status, int type)
1009 struct dao *dao = container_of(atc->daios[type], struct dao, daio);
1014 atc_dao_set_status(struct ct_atc *atc, unsigned int status, int type)
1016 struct dao *dao = container_of(atc->daios[type], struct dao, daio);
1023 static int atc_line_front_unmute(struct ct_atc *atc, unsigned char state)
1025 return atc_daio_unmute(atc, state, LINEO1);
1028 static int atc_line_surround_unmute(struct ct_atc *atc, unsigned char state)
1030 return atc_daio_unmute(atc, state, LINEO2);
1033 static int atc_line_clfe_unmute(struct ct_atc *atc, unsigned char state)
1035 return atc_daio_unmute(atc, state, LINEO3);
1038 static int atc_line_rear_unmute(struct ct_atc *atc, unsigned char state)
1040 return atc_daio_unmute(atc, state, LINEO4);
1043 static int atc_line_in_unmute(struct ct_atc *atc, unsigned char state)
1045 return atc_daio_unmute(atc, state, LINEIM);
1048 static int atc_spdif_out_unmute(struct ct_atc *atc, unsigned char state)
1050 return atc_daio_unmute(atc, state, SPDIFOO);
1053 static int atc_spdif_in_unmute(struct ct_atc *atc, unsigned char state)
1055 return atc_daio_unmute(atc, state, SPDIFIO);
1058 static int atc_spdif_out_get_status(struct ct_atc *atc, unsigned int *status)
1060 return atc_dao_get_status(atc, status, SPDIFOO);
1063 static int atc_spdif_out_set_status(struct ct_atc *atc, unsigned int status)
1065 return atc_dao_set_status(atc, status, SPDIFOO);
1068 static int atc_spdif_out_passthru(struct ct_atc *atc, unsigned char state)
1073 struct ct_mixer *mixer = atc->mixer;
1077 mutex_lock(&atc->atc_mutex);
1078 dao = container_of(atc->daios[SPDIFOO], struct dao, daio);
1079 da_dsc.msr = state ? 1 : atc->msr;
1089 /* Restore PLL to atc->rsr if needed. */
1090 if (atc->pll_rate != atc->rsr)
1091 err = atc_pll_init(atc, atc->rsr);
1095 mutex_unlock(&atc->atc_mutex);
1100 static int atc_release_resources(struct ct_atc *atc)
1114 if (atc->mixer) {
1115 mixer = atc->mixer;
1124 if (atc->daios) {
1125 daio_mgr = (struct daio_mgr *)atc->rsc_mgrs[DAIO];
1126 for (i = 0; i < atc->n_daio; i++) {
1127 daio = atc->daios[i];
1138 kfree(atc->daios);
1139 atc->daios = NULL;
1142 if (atc->pcm) {
1143 sum_mgr = atc->rsc_mgrs[SUM];
1144 for (i = 0; i < atc->n_pcm; i++)
1145 sum_mgr->put_sum(sum_mgr, atc->pcm[i]);
1147 kfree(atc->pcm);
1148 atc->pcm = NULL;
1151 if (atc->srcs) {
1152 src_mgr = atc->rsc_mgrs[SRC];
1153 for (i = 0; i < atc->n_src; i++)
1154 src_mgr->put_src(src_mgr, atc->srcs[i]);
1156 kfree(atc->srcs);
1157 atc->srcs = NULL;
1160 if (atc->srcimps) {
1161 srcimp_mgr = atc->rsc_mgrs[SRCIMP];
1162 for (i = 0; i < atc->n_srcimp; i++) {
1163 srcimp = atc->srcimps[i];
1165 srcimp_mgr->put_srcimp(srcimp_mgr, atc->srcimps[i]);
1167 kfree(atc->srcimps);
1168 atc->srcimps = NULL;
1174 static int ct_atc_destroy(struct ct_atc *atc)
1178 if (!atc)
1181 if (atc->timer) {
1182 ct_timer_free(atc->timer);
1183 atc->timer = NULL;
1186 atc_release_resources(atc);
1189 if (atc->mixer)
1190 ct_mixer_destroy(atc->mixer);
1193 if (rsc_mgr_funcs[i].destroy && atc->rsc_mgrs[i])
1194 rsc_mgr_funcs[i].destroy(atc->rsc_mgrs[i]);
1198 if (atc->hw)
1199 destroy_hw_obj((struct hw *)atc->hw);
1202 if (atc->vm) {
1203 ct_vm_destroy(atc->vm);
1204 atc->vm = NULL;
1207 kfree(atc);
1214 struct ct_atc *atc = dev->device_data;
1215 return ct_atc_destroy(atc);
1218 static int __devinit atc_identify_card(struct ct_atc *atc, unsigned int ssid)
1224 switch (atc->chip_type) {
1226 atc->chip_name = "20K1";
1230 atc->chip_name = "20K2";
1240 vendor_id = atc->pci->subsystem_vendor;
1241 device_id = atc->pci->subsystem_device;
1251 atc->model = p->value;
1253 if (atc->chip_type == ATC20K1)
1254 atc->model = CT20K1_UNKNOWN;
1256 atc->model = CT20K2_UNKNOWN;
1258 atc->model_name = ct_subsys_name[atc->model];
1260 atc->chip_name, atc->model_name,
1265 int __devinit ct_atc_create_alsa_devs(struct ct_atc *atc)
1270 alsa_dev_funcs[MIXER].public_name = atc->chip_name;
1276 err = alsa_dev_funcs[i].create(atc, i,
1288 static int __devinit atc_create_hw_devs(struct ct_atc *atc)
1294 err = create_hw_obj(atc->pci, atc->chip_type, atc->model, &hw);
1299 atc->hw = hw;
1302 info.rsr = atc->rsr;
1303 info.msr = atc->msr;
1304 info.vm_pgt_phys = atc_get_ptp_phys(atc, 0);
1313 err = rsc_mgr_funcs[i].create(atc->hw, &atc->rsc_mgrs[i]);
1324 static int atc_get_resources(struct ct_atc *atc)
1336 atc->daios = kzalloc(sizeof(void *)*(DAIONUM), GFP_KERNEL);
1337 if (!atc->daios)
1340 atc->srcs = kzalloc(sizeof(void *)*(2*2), GFP_KERNEL);
1341 if (!atc->srcs)
1344 atc->srcimps = kzalloc(sizeof(void *)*(2*2), GFP_KERNEL);
1345 if (!atc->srcimps)
1348 atc->pcm = kzalloc(sizeof(void *)*(2*4), GFP_KERNEL);
1349 if (!atc->pcm)
1352 daio_mgr = (struct daio_mgr *)atc->rsc_mgrs[DAIO];
1353 da_desc.msr = atc->msr;
1354 for (i = 0, atc->n_daio = 0; i < DAIONUM-1; i++) {
1357 (struct daio **)&atc->daios[i]);
1363 atc->n_daio++;
1365 if (atc->model == CTSB073X)
1370 (struct daio **)&atc->daios[i]);
1375 atc->n_daio++;
1377 src_mgr = atc->rsc_mgrs[SRC];
1379 src_dsc.msr = atc->msr;
1381 for (i = 0, atc->n_src = 0; i < (2*2); i++) {
1383 (struct src **)&atc->srcs[i]);
1387 atc->n_src++;
1390 srcimp_mgr = atc->rsc_mgrs[SRCIMP];
1392 for (i = 0, atc->n_srcimp = 0; i < (2*1); i++) {
1394 (struct srcimp **)&atc->srcimps[i]);
1398 atc->n_srcimp++;
1403 (struct srcimp **)&atc->srcimps[2*1+i]);
1407 atc->n_srcimp++;
1410 sum_mgr = atc->rsc_mgrs[SUM];
1411 sum_dsc.msr = atc->msr;
1412 for (i = 0, atc->n_pcm = 0; i < (2*4); i++) {
1414 (struct sum **)&atc->pcm[i]);
1418 atc->n_pcm++;
1463 static void atc_connect_resources(struct ct_atc *atc)
1473 mixer = atc->mixer;
1477 dao = container_of(atc->daios[j], struct dao, daio);
1482 dai = container_of(atc->daios[LINEIM], struct dai, daio);
1483 atc_connect_dai(atc->rsc_mgrs[SRC], dai,
1484 (struct src **)&atc->srcs[2],
1485 (struct srcimp **)&atc->srcimps[2]);
1486 src = atc->srcs[2];
1488 src = atc->srcs[3];
1491 dai = container_of(atc->daios[SPDIFIO], struct dai, daio);
1492 atc_connect_dai(atc->rsc_mgrs[SRC], dai,
1493 (struct src **)&atc->srcs[0],
1494 (struct srcimp **)&atc->srcimps[0]);
1496 src = atc->srcs[0];
1498 src = atc->srcs[1];
1502 sum = atc->pcm[j];
1504 sum = atc->pcm[j+1];
1510 static int atc_suspend(struct ct_atc *atc, pm_message_t state)
1513 struct hw *hw = atc->hw;
1515 snd_power_change_state(atc->card, SNDRV_CTL_POWER_D3hot);
1518 if (!atc->pcms[i])
1521 snd_pcm_suspend_all(atc->pcms[i]);
1524 atc_release_resources(atc);
1531 static int atc_hw_resume(struct ct_atc *atc)
1533 struct hw *hw = atc->hw;
1537 info.rsr = atc->rsr;
1538 info.msr = atc->msr;
1539 info.vm_pgt_phys = atc_get_ptp_phys(atc, 0);
1543 static int atc_resources_resume(struct ct_atc *atc)
1549 err = atc_get_resources(atc);
1551 atc_release_resources(atc);
1556 atc_connect_resources(atc);
1558 mixer = atc->mixer;
1564 static int atc_resume(struct ct_atc *atc)
1569 err = atc_hw_resume(atc);
1573 snd_card_disconnect(atc->card);
1577 err = atc_resources_resume(atc);
1581 snd_power_change_state(atc->card, SNDRV_CTL_POWER_D0);
1638 struct ct_atc *atc;
1646 atc = kzalloc(sizeof(*atc), GFP_KERNEL);
1647 if (!atc)
1651 *atc = atc_preset;
1653 atc->card = card;
1654 atc->pci = pci;
1655 atc->rsr = rsr;
1656 atc->msr = msr;
1657 atc->chip_type = chip_type;
1659 mutex_init(&atc->atc_mutex);
1662 err = atc_identify_card(atc, ssid);
1669 err = ct_vm_create(&atc->vm, pci);
1673 /* Create all atc hw devices */
1674 err = atc_create_hw_devs(atc);
1678 err = ct_mixer_create(atc, (struct ct_mixer **)&atc->mixer);
1685 err = atc_get_resources(atc);
1690 atc_connect_resources(atc);
1692 atc->timer = ct_timer_new(atc);
1693 if (!atc->timer)
1696 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, atc, &ops);
1702 *ratc = atc;
1706 ct_atc_destroy(atc);