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
ct_map_audio_buffer(struct ct_atc * atc,struct ct_atc_pcm * apcm)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
ct_unmap_audio_buffer(struct ct_atc * atc,struct ct_atc_pcm * apcm)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
atc_get_ptp_phys(struct ct_atc * atc,int index)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
convert_format(snd_pcm_format_t snd_format,struct snd_card * card)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
atc_get_pitch(unsigned int input_rate,unsigned int output_rate)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
select_rom(unsigned int pitch)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
atc_pcm_playback_prepare(struct ct_atc * atc,struct ct_atc_pcm * apcm)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
atc_pcm_release_resources(struct ct_atc * atc,struct ct_atc_pcm * apcm)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
atc_pcm_playback_start(struct ct_atc * atc,struct ct_atc_pcm * apcm)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
atc_pcm_stop(struct ct_atc * atc,struct ct_atc_pcm * apcm)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
atc_pcm_playback_position(struct ct_atc * atc,struct ct_atc_pcm * apcm)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
setup_src_node_conf(struct ct_atc * atc,struct ct_atc_pcm * apcm,struct src_node_conf_t * conf,int * n_srcc)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
atc_pcm_capture_get_resources(struct ct_atc * atc,struct ct_atc_pcm * apcm)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
atc_pcm_capture_prepare(struct ct_atc * atc,struct ct_atc_pcm * apcm)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
atc_pcm_capture_start(struct ct_atc * atc,struct ct_atc_pcm * apcm)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
atc_pcm_capture_position(struct ct_atc * atc,struct ct_atc_pcm * apcm)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
spdif_passthru_playback_get_resources(struct ct_atc * atc,struct ct_atc_pcm * apcm)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
atc_pll_init(struct ct_atc * atc,int rate)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
spdif_passthru_playback_setup(struct ct_atc * atc,struct ct_atc_pcm * apcm)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
spdif_passthru_playback_prepare(struct ct_atc * atc,struct ct_atc_pcm * apcm)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
atc_select_line_in(struct ct_atc * atc)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
atc_select_mic_in(struct ct_atc * atc)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
atc_spdif_in_type(struct ct_atc * atc)987 static inline enum DAIOTYP atc_spdif_in_type(struct ct_atc *atc)
988 {
989 return (atc->model == CTSB073X) ? SPDIFI_BAY : SPDIFIO;
990 }
991
atc_capabilities(struct ct_atc * atc)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
atc_dedicated_rca_select(struct ct_atc * atc)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
atc_output_switch_get(struct ct_atc * atc)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
atc_output_switch_put(struct ct_atc * atc,int position)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
atc_mic_source_switch_get(struct ct_atc * atc)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
atc_mic_source_switch_put(struct ct_atc * atc,int position)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
atc_select_digit_io(struct ct_atc * atc)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
atc_daio_unmute(struct ct_atc * atc,unsigned char state,int type)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
atc_dao_get_status(struct ct_atc * atc,unsigned int * status,int type)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
atc_dao_set_status(struct ct_atc * atc,unsigned int status,int type)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
atc_line_front_unmute(struct ct_atc * atc,unsigned char state)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
atc_line_surround_unmute(struct ct_atc * atc,unsigned char state)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
atc_line_clfe_unmute(struct ct_atc * atc,unsigned char state)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
atc_line_rear_unmute(struct ct_atc * atc,unsigned char state)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
atc_line_in_unmute(struct ct_atc * atc,unsigned char state)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
atc_mic_unmute(struct ct_atc * atc,unsigned char state)1113 static int atc_mic_unmute(struct ct_atc *atc, unsigned char state)
1114 {
1115 return atc_daio_unmute(atc, state, MIC);
1116 }
1117
atc_rca_unmute(struct ct_atc * atc,unsigned char state)1118 static int atc_rca_unmute(struct ct_atc *atc, unsigned char state)
1119 {
1120 return atc_daio_unmute(atc, state, RCA);
1121 }
1122
atc_spdif_out_unmute(struct ct_atc * atc,unsigned char state)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
atc_spdif_in_unmute(struct ct_atc * atc,unsigned char state)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
atc_spdif_out_get_status(struct ct_atc * atc,unsigned int * status)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
atc_spdif_out_set_status(struct ct_atc * atc,unsigned int status)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
atc_spdif_out_passthru(struct ct_atc * atc,unsigned char state)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
atc_release_resources(struct ct_atc * atc)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
ct_atc_destroy(struct ct_atc * atc)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
atc_dev_free(struct snd_device * dev)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
atc_identify_card(struct ct_atc * atc,unsigned int ssid)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
ct_atc_create_alsa_devs(struct ct_atc * atc)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
atc_create_hw_devs(struct ct_atc * atc)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
atc_get_resources(struct ct_atc * atc)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
atc_connect_dai(struct src_mgr * src_mgr,struct dai * dai,struct src ** srcs,struct srcimp ** srcimps)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
atc_connect_resources(struct ct_atc * atc)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
atc_suspend(struct ct_atc * atc)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
atc_hw_resume(struct ct_atc * atc)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
atc_resources_resume(struct ct_atc * atc)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
atc_resume(struct ct_atc * atc)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
ct_atc_create(struct snd_card * card,struct pci_dev * pci,unsigned int rsr,unsigned int msr,int chip_type,unsigned int ssid,struct ct_atc ** ratc)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