2 * Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved.
4 * This source file is released under GPL v2 license (no other versions).
5 * See the COPYING file included in the main directory of this source
6 * distribution for the license terms and conditions.
11 * This file contains the implementation of the device resource management
25 #include <linux/delay.h>
26 #include <linux/slab.h>
27 #include <sound/pcm.h>
28 #include <sound/control.h>
29 #include <sound/asoundef.h>
31 #define MONO_SUM_SCALE 0x19a8 /* 2^(-0.5) in 14-bit floating format */
32 #define MAX_MULTI_CHN 8
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) \
39 | ((IEC958_AES3_CON_FS_48000) << 24))
41 static struct snd_pci_quirk subsys_20k1_list
[] = {
42 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE
, 0x0022, "SB055x", CTSB055X
),
43 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE
, 0x002f, "SB055x", CTSB055X
),
44 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE
, 0x0029, "SB073x", CTSB073X
),
45 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE
, 0x0031, "SB073x", CTSB073X
),
46 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_CREATIVE
, 0xf000, 0x6000,
51 static struct snd_pci_quirk subsys_20k2_list
[] = {
52 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE
, PCI_SUBDEVICE_ID_CREATIVE_SB0760
,
54 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE
, PCI_SUBDEVICE_ID_CREATIVE_SB1270
,
56 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE
, PCI_SUBDEVICE_ID_CREATIVE_SB08801
,
58 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE
, PCI_SUBDEVICE_ID_CREATIVE_SB08802
,
60 SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE
, PCI_SUBDEVICE_ID_CREATIVE_SB08803
,
62 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_CREATIVE
, 0xf000,
63 PCI_SUBDEVICE_ID_CREATIVE_HENDRIX
, "HENDRIX",
68 static const char *ct_subsys_name
[NUM_CTCARDS
] = {
70 [CTSB055X
] = "SB055x",
71 [CTSB073X
] = "SB073x",
73 [CT20K1_UNKNOWN
] = "Unknown",
75 [CTSB0760
] = "SB076x",
76 [CTHENDRIX
] = "Hendrix",
77 [CTSB0880
] = "SB0880",
78 [CTSB1270
] = "SB1270",
79 [CT20K2_UNKNOWN
] = "Unknown",
83 int (*create
)(struct ct_atc
*atc
,
84 enum CTALSADEVS device
, const char *device_name
);
85 int (*destroy
)(void *alsa_dev
);
86 const char *public_name
;
87 } alsa_dev_funcs
[NUM_CTALSADEVS
] = {
88 [FRONT
] = { .create
= ct_alsa_pcm_create
,
90 .public_name
= "Front/WaveIn"},
91 [SURROUND
] = { .create
= ct_alsa_pcm_create
,
93 .public_name
= "Surround"},
94 [CLFE
] = { .create
= ct_alsa_pcm_create
,
96 .public_name
= "Center/LFE"},
97 [SIDE
] = { .create
= ct_alsa_pcm_create
,
99 .public_name
= "Side"},
100 [IEC958
] = { .create
= ct_alsa_pcm_create
,
102 .public_name
= "IEC958 Non-audio"},
104 [MIXER
] = { .create
= ct_alsa_mix_create
,
106 .public_name
= "Mixer"}
109 typedef int (*create_t
)(void *, void **);
110 typedef int (*destroy_t
)(void *);
113 int (*create
)(void *hw
, void **rmgr
);
114 int (*destroy
)(void *mgr
);
115 } rsc_mgr_funcs
[NUM_RSCTYP
] = {
116 [SRC
] = { .create
= (create_t
)src_mgr_create
,
117 .destroy
= (destroy_t
)src_mgr_destroy
},
118 [SRCIMP
] = { .create
= (create_t
)srcimp_mgr_create
,
119 .destroy
= (destroy_t
)srcimp_mgr_destroy
},
120 [AMIXER
] = { .create
= (create_t
)amixer_mgr_create
,
121 .destroy
= (destroy_t
)amixer_mgr_destroy
},
122 [SUM
] = { .create
= (create_t
)sum_mgr_create
,
123 .destroy
= (destroy_t
)sum_mgr_destroy
},
124 [DAIO
] = { .create
= (create_t
)daio_mgr_create
,
125 .destroy
= (destroy_t
)daio_mgr_destroy
}
129 atc_pcm_release_resources(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
);
132 * Only mono and interleaved modes are supported now.
133 * Always allocates a contiguous channel block.
136 static int ct_map_audio_buffer(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
138 struct snd_pcm_runtime
*runtime
;
141 if (!apcm
->substream
)
144 runtime
= apcm
->substream
->runtime
;
147 apcm
->vm_block
= vm
->map(vm
, apcm
->substream
, runtime
->dma_bytes
);
155 static void ct_unmap_audio_buffer(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
164 vm
->unmap(vm
, apcm
->vm_block
);
166 apcm
->vm_block
= NULL
;
169 static unsigned long atc_get_ptp_phys(struct ct_atc
*atc
, int index
)
171 return atc
->vm
->get_ptp_phys(atc
->vm
, index
);
174 static unsigned int convert_format(snd_pcm_format_t snd_format
)
176 switch (snd_format
) {
177 case SNDRV_PCM_FORMAT_U8
:
179 case SNDRV_PCM_FORMAT_S16_LE
:
181 case SNDRV_PCM_FORMAT_S24_3LE
:
183 case SNDRV_PCM_FORMAT_S32_LE
:
185 case SNDRV_PCM_FORMAT_FLOAT_LE
:
188 printk(KERN_ERR
"ctxfi: not recognized snd format is %d \n",
195 atc_get_pitch(unsigned int input_rate
, unsigned int output_rate
)
200 /* get pitch and convert to fixed-point 8.24 format. */
201 pitch
= (input_rate
/ output_rate
) << 24;
202 input_rate
%= output_rate
;
205 for (b
= 31; ((b
>= 0) && !(input_rate
>> b
)); )
209 input_rate
<<= (31 - b
);
210 input_rate
/= output_rate
;
223 static int select_rom(unsigned int pitch
)
225 if (pitch
> 0x00428f5c && pitch
< 0x01b851ec) {
226 /* 0.26 <= pitch <= 1.72 */
228 } else if (pitch
== 0x01d66666 || pitch
== 0x01d66667) {
229 /* pitch == 1.8375 */
231 } else if (pitch
== 0x02000000) {
234 } else if (pitch
<= 0x08000000) {
235 /* 0 <= pitch <= 8 */
242 static int atc_pcm_playback_prepare(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
244 struct src_mgr
*src_mgr
= atc
->rsc_mgrs
[SRC
];
245 struct amixer_mgr
*amixer_mgr
= atc
->rsc_mgrs
[AMIXER
];
246 struct src_desc desc
= {0};
247 struct amixer_desc mix_dsc
= {0};
249 struct amixer
*amixer
;
251 int n_amixer
= apcm
->substream
->runtime
->channels
, i
= 0;
252 int device
= apcm
->substream
->pcm
->device
;
255 /* first release old resources */
256 atc_pcm_release_resources(atc
, apcm
);
258 /* Get SRC resource */
259 desc
.multi
= apcm
->substream
->runtime
->channels
;
262 err
= src_mgr
->get_src(src_mgr
, &desc
, (struct src
**)&apcm
->src
);
266 pitch
= atc_get_pitch(apcm
->substream
->runtime
->rate
,
267 (atc
->rsr
* atc
->msr
));
269 src
->ops
->set_pitch(src
, pitch
);
270 src
->ops
->set_rom(src
, select_rom(pitch
));
271 src
->ops
->set_sf(src
, convert_format(apcm
->substream
->runtime
->format
));
272 src
->ops
->set_pm(src
, (src
->ops
->next_interleave(src
) != NULL
));
274 /* Get AMIXER resource */
275 n_amixer
= (n_amixer
< 2) ? 2 : n_amixer
;
276 apcm
->amixers
= kzalloc(sizeof(void *)*n_amixer
, GFP_KERNEL
);
277 if (!apcm
->amixers
) {
281 mix_dsc
.msr
= atc
->msr
;
282 for (i
= 0, apcm
->n_amixer
= 0; i
< n_amixer
; i
++) {
283 err
= amixer_mgr
->get_amixer(amixer_mgr
, &mix_dsc
,
284 (struct amixer
**)&apcm
->amixers
[i
]);
291 /* Set up device virtual mem map */
292 err
= ct_map_audio_buffer(atc
, apcm
);
296 /* Connect resources */
298 for (i
= 0; i
< n_amixer
; i
++) {
299 amixer
= apcm
->amixers
[i
];
300 mutex_lock(&atc
->atc_mutex
);
301 amixer
->ops
->setup(amixer
, &src
->rsc
,
302 INIT_VOL
, atc
->pcm
[i
+device
*2]);
303 mutex_unlock(&atc
->atc_mutex
);
304 src
= src
->ops
->next_interleave(src
);
309 ct_timer_prepare(apcm
->timer
);
314 atc_pcm_release_resources(atc
, apcm
);
319 atc_pcm_release_resources(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
321 struct src_mgr
*src_mgr
= atc
->rsc_mgrs
[SRC
];
322 struct srcimp_mgr
*srcimp_mgr
= atc
->rsc_mgrs
[SRCIMP
];
323 struct amixer_mgr
*amixer_mgr
= atc
->rsc_mgrs
[AMIXER
];
324 struct sum_mgr
*sum_mgr
= atc
->rsc_mgrs
[SUM
];
325 struct srcimp
*srcimp
;
329 for (i
= 0; i
< apcm
->n_srcimp
; i
++) {
330 srcimp
= apcm
->srcimps
[i
];
331 srcimp
->ops
->unmap(srcimp
);
332 srcimp_mgr
->put_srcimp(srcimp_mgr
, srcimp
);
333 apcm
->srcimps
[i
] = NULL
;
335 kfree(apcm
->srcimps
);
336 apcm
->srcimps
= NULL
;
340 for (i
= 0; i
< apcm
->n_srcc
; i
++) {
341 src_mgr
->put_src(src_mgr
, apcm
->srccs
[i
]);
342 apcm
->srccs
[i
] = NULL
;
349 for (i
= 0; i
< apcm
->n_amixer
; i
++) {
350 amixer_mgr
->put_amixer(amixer_mgr
, apcm
->amixers
[i
]);
351 apcm
->amixers
[i
] = NULL
;
353 kfree(apcm
->amixers
);
354 apcm
->amixers
= NULL
;
358 sum_mgr
->put_sum(sum_mgr
, apcm
->mono
);
363 src_mgr
->put_src(src_mgr
, apcm
->src
);
367 if (apcm
->vm_block
) {
368 /* Undo device virtual mem map */
369 ct_unmap_audio_buffer(atc
, apcm
);
370 apcm
->vm_block
= NULL
;
376 static int atc_pcm_playback_start(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
378 unsigned int max_cisz
;
379 struct src
*src
= apcm
->src
;
385 max_cisz
= src
->multi
* src
->rsc
.msr
;
386 max_cisz
= 0x80 * (max_cisz
< 8 ? max_cisz
: 8);
388 src
->ops
->set_sa(src
, apcm
->vm_block
->addr
);
389 src
->ops
->set_la(src
, apcm
->vm_block
->addr
+ apcm
->vm_block
->size
);
390 src
->ops
->set_ca(src
, apcm
->vm_block
->addr
+ max_cisz
);
391 src
->ops
->set_cisz(src
, max_cisz
);
393 src
->ops
->set_bm(src
, 1);
394 src
->ops
->set_state(src
, SRC_STATE_INIT
);
395 src
->ops
->commit_write(src
);
397 ct_timer_start(apcm
->timer
);
401 static int atc_pcm_stop(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
406 ct_timer_stop(apcm
->timer
);
409 src
->ops
->set_bm(src
, 0);
410 src
->ops
->set_state(src
, SRC_STATE_OFF
);
411 src
->ops
->commit_write(src
);
414 for (i
= 0; i
< apcm
->n_srcc
; i
++) {
415 src
= apcm
->srccs
[i
];
416 src
->ops
->set_bm(src
, 0);
417 src
->ops
->set_state(src
, SRC_STATE_OFF
);
418 src
->ops
->commit_write(src
);
428 atc_pcm_playback_position(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
430 struct src
*src
= apcm
->src
;
436 position
= src
->ops
->get_ca(src
);
438 if (position
< apcm
->vm_block
->addr
) {
439 snd_printdd("ctxfi: bad ca - ca=0x%08x, vba=0x%08x, vbs=0x%08x\n", 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
;
445 max_cisz
= 128 * (max_cisz
< 8 ? max_cisz
: 8);
447 return (position
+ size
- max_cisz
- apcm
->vm_block
->addr
) % size
;
450 struct src_node_conf_t
{
453 unsigned int mix_msr
:8;
454 unsigned int imp_msr
:8;
458 static void setup_src_node_conf(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
,
459 struct src_node_conf_t
*conf
, int *n_srcc
)
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
;
470 conf
[0].pitch
= pitch
;
471 conf
[0].mix_msr
= conf
[0].imp_msr
= conf
[0].msr
= 1;
473 } else if (2 <= atc
->msr
) {
474 if (0x8000000 < pitch
) {
475 /* Need two-stage SRCs, SRCIMPs and
476 * AMIXERs for converting format */
477 conf
[0].pitch
= (atc
->msr
<< 24);
478 conf
[0].msr
= conf
[0].mix_msr
= 1;
479 conf
[0].imp_msr
= atc
->msr
;
481 conf
[1].pitch
= atc_get_pitch(atc
->rsr
,
482 apcm
->substream
->runtime
->rate
);
483 conf
[1].msr
= conf
[1].mix_msr
= conf
[1].imp_msr
= 1;
485 *n_srcc
= apcm
->substream
->runtime
->channels
* 2;
486 } else if (0x1000000 < pitch
) {
487 /* Need one-stage SRCs, SRCIMPs and
488 * AMIXERs for converting format */
489 conf
[0].pitch
= pitch
;
490 conf
[0].msr
= conf
[0].mix_msr
491 = conf
[0].imp_msr
= atc
->msr
;
493 *n_srcc
= apcm
->substream
->runtime
->channels
;
499 atc_pcm_capture_get_resources(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
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
];
505 struct src_desc src_dsc
= {0};
507 struct srcimp_desc srcimp_dsc
= {0};
508 struct srcimp
*srcimp
;
509 struct amixer_desc mix_dsc
= {0};
510 struct sum_desc sum_dsc
= {0};
513 int n_srcimp
, n_amixer
, n_srcc
, n_sum
;
514 struct src_node_conf_t src_node_conf
[2] = {{0} };
516 /* first release old resources */
517 atc_pcm_release_resources(atc
, apcm
);
519 /* The numbers of converting SRCs and SRCIMPs should be determined
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
);
528 setup_src_node_conf(atc
, apcm
, src_node_conf
, &n_srcc
);
529 n_sum
= (1 == multi
) ? 1 : 0;
530 n_amixer
= n_sum
* 2 + n_srcc
;
532 if ((multi
> 1) && (0x8000000 >= pitch
)) {
533 /* Need extra AMIXERs and SRCIMPs for special treatment
534 * of interleaved recording of conjugate channels */
535 n_amixer
+= multi
* atc
->msr
;
536 n_srcimp
+= multi
* atc
->msr
;
542 apcm
->srccs
= kzalloc(sizeof(void *)*n_srcc
, GFP_KERNEL
);
547 apcm
->amixers
= kzalloc(sizeof(void *)*n_amixer
, GFP_KERNEL
);
548 if (!apcm
->amixers
) {
553 apcm
->srcimps
= kzalloc(sizeof(void *)*n_srcimp
, GFP_KERNEL
);
554 if (!apcm
->srcimps
) {
559 /* Allocate SRCs for sample rate conversion if needed */
561 src_dsc
.mode
= ARCRW
;
562 for (i
= 0, apcm
->n_srcc
= 0; i
< n_srcc
; i
++) {
563 src_dsc
.msr
= src_node_conf
[i
/multi
].msr
;
564 err
= src_mgr
->get_src(src_mgr
, &src_dsc
,
565 (struct src
**)&apcm
->srccs
[i
]);
569 src
= apcm
->srccs
[i
];
570 pitch
= src_node_conf
[i
/multi
].pitch
;
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
);
578 /* Allocate AMIXERs for routing SRCs of conversion if needed */
579 for (i
= 0, apcm
->n_amixer
= 0; i
< n_amixer
; i
++) {
581 mix_dsc
.msr
= atc
->msr
;
582 else if (i
< (n_sum
*2+n_srcc
))
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
]);
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
);
603 /* Allocate SRCIMP resources */
604 for (i
= 0, apcm
->n_srcimp
= 0; i
< n_srcimp
; i
++) {
606 srcimp_dsc
.msr
= src_node_conf
[i
/multi
].imp_msr
;
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
;
620 /* Allocate a SRC for writing data to host memory */
621 src_dsc
.multi
= apcm
->substream
->runtime
->channels
;
623 src_dsc
.mode
= MEMWR
;
624 err
= src_mgr
->get_src(src_mgr
, &src_dsc
, (struct src
**)&apcm
->src
);
629 src
->ops
->set_pitch(src
, pitch
);
631 /* Set up device virtual mem map */
632 err
= ct_map_audio_buffer(atc
, apcm
);
639 atc_pcm_release_resources(atc
, apcm
);
643 static int atc_pcm_capture_prepare(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
646 struct amixer
*amixer
;
647 struct srcimp
*srcimp
;
648 struct ct_mixer
*mixer
= atc
->mixer
;
650 struct rsc
*out_ports
[8] = {NULL
};
651 int err
, i
, j
, n_sum
, multi
;
653 int mix_base
= 0, imp_base
= 0;
655 atc_pcm_release_resources(atc
, apcm
);
657 /* Get needed resources. */
658 err
= atc_pcm_capture_get_resources(atc
, apcm
);
662 /* Connect resources */
663 mixer
->get_output_ports(mixer
, MIX_PCMO_FRONT
,
664 &out_ports
[0], &out_ports
[1]);
666 multi
= apcm
->substream
->runtime
->channels
;
669 for (i
= 0; i
< 2; i
++) {
670 amixer
= apcm
->amixers
[i
];
671 amixer
->ops
->setup(amixer
, out_ports
[i
],
672 MONO_SUM_SCALE
, mono
);
674 out_ports
[0] = &mono
->rsc
;
676 mix_base
= n_sum
* 2;
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
);
691 if ((multi
> 1) && (pitch
<= 0x8000000)) {
692 /* Special connection for interleaved
693 * recording with conjugate channels */
694 for (i
= 0; i
< multi
; i
++) {
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
,
710 for (i
= 0; i
< multi
; i
++) {
711 srcimp
= apcm
->srcimps
[apcm
->n_srcc
+i
];
712 srcimp
->ops
->map(srcimp
, apcm
->src
, out_ports
[i
]);
716 ct_timer_prepare(apcm
->timer
);
721 static int atc_pcm_capture_start(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
724 struct src_mgr
*src_mgr
= atc
->rsc_mgrs
[SRC
];
731 multi
= apcm
->substream
->runtime
->channels
;
732 /* Set up converting SRCs */
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
);
739 /* Set up recording SRC */
741 src
->ops
->set_sf(src
, convert_format(apcm
->substream
->runtime
->format
));
742 src
->ops
->set_sa(src
, apcm
->vm_block
->addr
);
743 src
->ops
->set_la(src
, apcm
->vm_block
->addr
+ apcm
->vm_block
->size
);
744 src
->ops
->set_ca(src
, apcm
->vm_block
->addr
);
745 src_mgr
->src_disable(src_mgr
, src
);
747 /* Disable relevant SRCs firstly */
748 src_mgr
->commit_write(src_mgr
);
750 /* Enable SRCs respectively */
751 for (i
= 0; i
< apcm
->n_srcc
; i
++) {
752 src
= apcm
->srccs
[i
];
753 src
->ops
->set_state(src
, SRC_STATE_RUN
);
754 src
->ops
->commit_write(src
);
755 src_mgr
->src_enable_s(src_mgr
, src
);
758 src
->ops
->set_bm(src
, 1);
759 src
->ops
->set_state(src
, SRC_STATE_RUN
);
760 src
->ops
->commit_write(src
);
761 src_mgr
->src_enable_s(src_mgr
, src
);
763 /* Enable relevant SRCs synchronously */
764 src_mgr
->commit_write(src_mgr
);
766 ct_timer_start(apcm
->timer
);
771 atc_pcm_capture_position(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
773 struct src
*src
= apcm
->src
;
777 return src
->ops
->get_ca(src
) - apcm
->vm_block
->addr
;
780 static int spdif_passthru_playback_get_resources(struct ct_atc
*atc
,
781 struct ct_atc_pcm
*apcm
)
783 struct src_mgr
*src_mgr
= atc
->rsc_mgrs
[SRC
];
784 struct amixer_mgr
*amixer_mgr
= atc
->rsc_mgrs
[AMIXER
];
785 struct src_desc desc
= {0};
786 struct amixer_desc mix_dsc
= {0};
789 int n_amixer
= apcm
->substream
->runtime
->channels
, i
;
790 unsigned int pitch
, rsr
= atc
->pll_rate
;
792 /* first release old resources */
793 atc_pcm_release_resources(atc
, apcm
);
795 /* Get SRC resource */
796 desc
.multi
= apcm
->substream
->runtime
->channels
;
798 while (apcm
->substream
->runtime
->rate
> (rsr
* desc
.msr
))
802 err
= src_mgr
->get_src(src_mgr
, &desc
, (struct src
**)&apcm
->src
);
806 pitch
= atc_get_pitch(apcm
->substream
->runtime
->rate
, (rsr
* desc
.msr
));
808 src
->ops
->set_pitch(src
, pitch
);
809 src
->ops
->set_rom(src
, select_rom(pitch
));
810 src
->ops
->set_sf(src
, convert_format(apcm
->substream
->runtime
->format
));
811 src
->ops
->set_pm(src
, (src
->ops
->next_interleave(src
) != NULL
));
812 src
->ops
->set_bp(src
, 1);
814 /* Get AMIXER resource */
815 n_amixer
= (n_amixer
< 2) ? 2 : n_amixer
;
816 apcm
->amixers
= kzalloc(sizeof(void *)*n_amixer
, GFP_KERNEL
);
817 if (!apcm
->amixers
) {
821 mix_dsc
.msr
= desc
.msr
;
822 for (i
= 0, apcm
->n_amixer
= 0; i
< n_amixer
; i
++) {
823 err
= amixer_mgr
->get_amixer(amixer_mgr
, &mix_dsc
,
824 (struct amixer
**)&apcm
->amixers
[i
]);
831 /* Set up device virtual mem map */
832 err
= ct_map_audio_buffer(atc
, apcm
);
839 atc_pcm_release_resources(atc
, apcm
);
843 static int atc_pll_init(struct ct_atc
*atc
, int rate
)
845 struct hw
*hw
= atc
->hw
;
847 err
= hw
->pll_init(hw
, rate
);
848 atc
->pll_rate
= err
? 0 : rate
;
853 spdif_passthru_playback_setup(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
855 struct dao
*dao
= container_of(atc
->daios
[SPDIFOO
], struct dao
, daio
);
856 unsigned int rate
= apcm
->substream
->runtime
->rate
;
859 unsigned char iec958_con_fs
;
863 iec958_con_fs
= IEC958_AES3_CON_FS_48000
;
866 iec958_con_fs
= IEC958_AES3_CON_FS_44100
;
869 iec958_con_fs
= IEC958_AES3_CON_FS_32000
;
875 mutex_lock(&atc
->atc_mutex
);
876 dao
->ops
->get_spos(dao
, &status
);
877 if (((status
>> 24) & IEC958_AES3_CON_FS
) != iec958_con_fs
) {
878 status
&= ~(IEC958_AES3_CON_FS
<< 24);
879 status
|= (iec958_con_fs
<< 24);
880 dao
->ops
->set_spos(dao
, status
);
881 dao
->ops
->commit_write(dao
);
883 if ((rate
!= atc
->pll_rate
) && (32000 != rate
))
884 err
= atc_pll_init(atc
, rate
);
885 mutex_unlock(&atc
->atc_mutex
);
891 spdif_passthru_playback_prepare(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
894 struct amixer
*amixer
;
899 atc_pcm_release_resources(atc
, apcm
);
901 /* Configure SPDIFOO and PLL to passthrough mode;
902 * determine pll_rate. */
903 err
= spdif_passthru_playback_setup(atc
, apcm
);
907 /* Get needed resources. */
908 err
= spdif_passthru_playback_get_resources(atc
, apcm
);
912 /* Connect resources */
914 for (i
= 0; i
< apcm
->n_amixer
; i
++) {
915 amixer
= apcm
->amixers
[i
];
916 amixer
->ops
->setup(amixer
, &src
->rsc
, INIT_VOL
, NULL
);
917 src
= src
->ops
->next_interleave(src
);
921 /* Connect to SPDIFOO */
922 mutex_lock(&atc
->atc_mutex
);
923 dao
= container_of(atc
->daios
[SPDIFOO
], struct dao
, daio
);
924 amixer
= apcm
->amixers
[0];
925 dao
->ops
->set_left_input(dao
, &amixer
->rsc
);
926 amixer
= apcm
->amixers
[1];
927 dao
->ops
->set_right_input(dao
, &amixer
->rsc
);
928 mutex_unlock(&atc
->atc_mutex
);
930 ct_timer_prepare(apcm
->timer
);
935 static int atc_select_line_in(struct ct_atc
*atc
)
937 struct hw
*hw
= atc
->hw
;
938 struct ct_mixer
*mixer
= atc
->mixer
;
941 if (hw
->is_adc_source_selected(hw
, ADC_LINEIN
))
944 mixer
->set_input_left(mixer
, MIX_MIC_IN
, NULL
);
945 mixer
->set_input_right(mixer
, MIX_MIC_IN
, NULL
);
947 hw
->select_adc_source(hw
, ADC_LINEIN
);
950 mixer
->set_input_left(mixer
, MIX_LINE_IN
, &src
->rsc
);
952 mixer
->set_input_right(mixer
, MIX_LINE_IN
, &src
->rsc
);
957 static int atc_select_mic_in(struct ct_atc
*atc
)
959 struct hw
*hw
= atc
->hw
;
960 struct ct_mixer
*mixer
= atc
->mixer
;
963 if (hw
->is_adc_source_selected(hw
, ADC_MICIN
))
966 mixer
->set_input_left(mixer
, MIX_LINE_IN
, NULL
);
967 mixer
->set_input_right(mixer
, MIX_LINE_IN
, NULL
);
969 hw
->select_adc_source(hw
, ADC_MICIN
);
972 mixer
->set_input_left(mixer
, MIX_MIC_IN
, &src
->rsc
);
974 mixer
->set_input_right(mixer
, MIX_MIC_IN
, &src
->rsc
);
979 static struct capabilities
atc_capabilities(struct ct_atc
*atc
)
981 struct hw
*hw
= atc
->hw
;
983 return hw
->capabilities(hw
);
986 static int atc_output_switch_get(struct ct_atc
*atc
)
988 struct hw
*hw
= atc
->hw
;
990 return hw
->output_switch_get(hw
);
993 static int atc_output_switch_put(struct ct_atc
*atc
, int position
)
995 struct hw
*hw
= atc
->hw
;
997 return hw
->output_switch_put(hw
, position
);
1000 static int atc_mic_source_switch_get(struct ct_atc
*atc
)
1002 struct hw
*hw
= atc
->hw
;
1004 return hw
->mic_source_switch_get(hw
);
1007 static int atc_mic_source_switch_put(struct ct_atc
*atc
, int position
)
1009 struct hw
*hw
= atc
->hw
;
1011 return hw
->mic_source_switch_put(hw
, position
);
1014 static int atc_select_digit_io(struct ct_atc
*atc
)
1016 struct hw
*hw
= atc
->hw
;
1018 if (hw
->is_adc_source_selected(hw
, ADC_NONE
))
1021 hw
->select_adc_source(hw
, ADC_NONE
);
1026 static int atc_daio_unmute(struct ct_atc
*atc
, unsigned char state
, int type
)
1028 struct daio_mgr
*daio_mgr
= atc
->rsc_mgrs
[DAIO
];
1031 daio_mgr
->daio_enable(daio_mgr
, atc
->daios
[type
]);
1033 daio_mgr
->daio_disable(daio_mgr
, atc
->daios
[type
]);
1035 daio_mgr
->commit_write(daio_mgr
);
1041 atc_dao_get_status(struct ct_atc
*atc
, unsigned int *status
, int type
)
1043 struct dao
*dao
= container_of(atc
->daios
[type
], struct dao
, daio
);
1044 return dao
->ops
->get_spos(dao
, status
);
1048 atc_dao_set_status(struct ct_atc
*atc
, unsigned int status
, int type
)
1050 struct dao
*dao
= container_of(atc
->daios
[type
], struct dao
, daio
);
1052 dao
->ops
->set_spos(dao
, status
);
1053 dao
->ops
->commit_write(dao
);
1057 static int atc_line_front_unmute(struct ct_atc
*atc
, unsigned char state
)
1059 return atc_daio_unmute(atc
, state
, LINEO1
);
1062 static int atc_line_surround_unmute(struct ct_atc
*atc
, unsigned char state
)
1064 return atc_daio_unmute(atc
, state
, LINEO2
);
1067 static int atc_line_clfe_unmute(struct ct_atc
*atc
, unsigned char state
)
1069 return atc_daio_unmute(atc
, state
, LINEO3
);
1072 static int atc_line_rear_unmute(struct ct_atc
*atc
, unsigned char state
)
1074 return atc_daio_unmute(atc
, state
, LINEO4
);
1077 static int atc_line_in_unmute(struct ct_atc
*atc
, unsigned char state
)
1079 return atc_daio_unmute(atc
, state
, LINEIM
);
1082 static int atc_mic_unmute(struct ct_atc
*atc
, unsigned char state
)
1084 return atc_daio_unmute(atc
, state
, MIC
);
1087 static int atc_spdif_out_unmute(struct ct_atc
*atc
, unsigned char state
)
1089 return atc_daio_unmute(atc
, state
, SPDIFOO
);
1092 static int atc_spdif_in_unmute(struct ct_atc
*atc
, unsigned char state
)
1094 return atc_daio_unmute(atc
, state
, SPDIFIO
);
1097 static int atc_spdif_out_get_status(struct ct_atc
*atc
, unsigned int *status
)
1099 return atc_dao_get_status(atc
, status
, SPDIFOO
);
1102 static int atc_spdif_out_set_status(struct ct_atc
*atc
, unsigned int status
)
1104 return atc_dao_set_status(atc
, status
, SPDIFOO
);
1107 static int atc_spdif_out_passthru(struct ct_atc
*atc
, unsigned char state
)
1109 struct dao_desc da_dsc
= {0};
1112 struct ct_mixer
*mixer
= atc
->mixer
;
1113 struct rsc
*rscs
[2] = {NULL
};
1114 unsigned int spos
= 0;
1116 mutex_lock(&atc
->atc_mutex
);
1117 dao
= container_of(atc
->daios
[SPDIFOO
], struct dao
, daio
);
1118 da_dsc
.msr
= state
? 1 : atc
->msr
;
1119 da_dsc
.passthru
= state
? 1 : 0;
1120 err
= dao
->ops
->reinit(dao
, &da_dsc
);
1122 spos
= IEC958_DEFAULT_CON
;
1124 mixer
->get_output_ports(mixer
, MIX_SPDIF_OUT
,
1125 &rscs
[0], &rscs
[1]);
1126 dao
->ops
->set_left_input(dao
, rscs
[0]);
1127 dao
->ops
->set_right_input(dao
, rscs
[1]);
1128 /* Restore PLL to atc->rsr if needed. */
1129 if (atc
->pll_rate
!= atc
->rsr
)
1130 err
= atc_pll_init(atc
, atc
->rsr
);
1132 dao
->ops
->set_spos(dao
, spos
);
1133 dao
->ops
->commit_write(dao
);
1134 mutex_unlock(&atc
->atc_mutex
);
1139 static int atc_release_resources(struct ct_atc
*atc
)
1142 struct daio_mgr
*daio_mgr
= NULL
;
1143 struct dao
*dao
= NULL
;
1144 struct dai
*dai
= NULL
;
1145 struct daio
*daio
= NULL
;
1146 struct sum_mgr
*sum_mgr
= NULL
;
1147 struct src_mgr
*src_mgr
= NULL
;
1148 struct srcimp_mgr
*srcimp_mgr
= NULL
;
1149 struct srcimp
*srcimp
= NULL
;
1150 struct ct_mixer
*mixer
= NULL
;
1152 /* disconnect internal mixer objects */
1155 mixer
->set_input_left(mixer
, MIX_LINE_IN
, NULL
);
1156 mixer
->set_input_right(mixer
, MIX_LINE_IN
, NULL
);
1157 mixer
->set_input_left(mixer
, MIX_MIC_IN
, NULL
);
1158 mixer
->set_input_right(mixer
, MIX_MIC_IN
, NULL
);
1159 mixer
->set_input_left(mixer
, MIX_SPDIF_IN
, NULL
);
1160 mixer
->set_input_right(mixer
, MIX_SPDIF_IN
, NULL
);
1164 daio_mgr
= (struct daio_mgr
*)atc
->rsc_mgrs
[DAIO
];
1165 for (i
= 0; i
< atc
->n_daio
; i
++) {
1166 daio
= atc
->daios
[i
];
1167 if (daio
->type
< LINEIM
) {
1168 dao
= container_of(daio
, struct dao
, daio
);
1169 dao
->ops
->clear_left_input(dao
);
1170 dao
->ops
->clear_right_input(dao
);
1172 dai
= container_of(daio
, struct dai
, daio
);
1173 /* some thing to do for dai ... */
1175 daio_mgr
->put_daio(daio_mgr
, daio
);
1182 sum_mgr
= atc
->rsc_mgrs
[SUM
];
1183 for (i
= 0; i
< atc
->n_pcm
; i
++)
1184 sum_mgr
->put_sum(sum_mgr
, atc
->pcm
[i
]);
1191 src_mgr
= atc
->rsc_mgrs
[SRC
];
1192 for (i
= 0; i
< atc
->n_src
; i
++)
1193 src_mgr
->put_src(src_mgr
, atc
->srcs
[i
]);
1200 srcimp_mgr
= atc
->rsc_mgrs
[SRCIMP
];
1201 for (i
= 0; i
< atc
->n_srcimp
; i
++) {
1202 srcimp
= atc
->srcimps
[i
];
1203 srcimp
->ops
->unmap(srcimp
);
1204 srcimp_mgr
->put_srcimp(srcimp_mgr
, atc
->srcimps
[i
]);
1206 kfree(atc
->srcimps
);
1207 atc
->srcimps
= NULL
;
1213 static int ct_atc_destroy(struct ct_atc
*atc
)
1221 ct_timer_free(atc
->timer
);
1225 atc_release_resources(atc
);
1227 /* Destroy internal mixer objects */
1229 ct_mixer_destroy(atc
->mixer
);
1231 for (i
= 0; i
< NUM_RSCTYP
; i
++) {
1232 if (rsc_mgr_funcs
[i
].destroy
&& atc
->rsc_mgrs
[i
])
1233 rsc_mgr_funcs
[i
].destroy(atc
->rsc_mgrs
[i
]);
1238 destroy_hw_obj((struct hw
*)atc
->hw
);
1240 /* Destroy device virtual memory manager object */
1242 ct_vm_destroy(atc
->vm
);
1251 static int atc_dev_free(struct snd_device
*dev
)
1253 struct ct_atc
*atc
= dev
->device_data
;
1254 return ct_atc_destroy(atc
);
1257 static int atc_identify_card(struct ct_atc
*atc
, unsigned int ssid
)
1259 const struct snd_pci_quirk
*p
;
1260 const struct snd_pci_quirk
*list
;
1261 u16 vendor_id
, device_id
;
1263 switch (atc
->chip_type
) {
1265 atc
->chip_name
= "20K1";
1266 list
= subsys_20k1_list
;
1269 atc
->chip_name
= "20K2";
1270 list
= subsys_20k2_list
;
1276 vendor_id
= ssid
>> 16;
1277 device_id
= ssid
& 0xffff;
1279 vendor_id
= atc
->pci
->subsystem_vendor
;
1280 device_id
= atc
->pci
->subsystem_device
;
1282 p
= snd_pci_quirk_lookup_id(vendor_id
, device_id
, list
);
1285 printk(KERN_ERR
"ctxfi: "
1286 "Device %04x:%04x is black-listed\n",
1287 vendor_id
, device_id
);
1290 atc
->model
= p
->value
;
1292 if (atc
->chip_type
== ATC20K1
)
1293 atc
->model
= CT20K1_UNKNOWN
;
1295 atc
->model
= CT20K2_UNKNOWN
;
1297 atc
->model_name
= ct_subsys_name
[atc
->model
];
1298 snd_printd("ctxfi: chip %s model %s (%04x:%04x) is found\n",
1299 atc
->chip_name
, atc
->model_name
,
1300 vendor_id
, device_id
);
1304 int ct_atc_create_alsa_devs(struct ct_atc
*atc
)
1309 alsa_dev_funcs
[MIXER
].public_name
= atc
->chip_name
;
1311 for (i
= 0; i
< NUM_CTALSADEVS
; i
++) {
1312 if (!alsa_dev_funcs
[i
].create
)
1315 err
= alsa_dev_funcs
[i
].create(atc
, i
,
1316 alsa_dev_funcs
[i
].public_name
);
1318 printk(KERN_ERR
"ctxfi: "
1319 "Creating alsa device %d failed!\n", i
);
1327 static int atc_create_hw_devs(struct ct_atc
*atc
)
1330 struct card_conf info
= {0};
1333 err
= create_hw_obj(atc
->pci
, atc
->chip_type
, atc
->model
, &hw
);
1335 printk(KERN_ERR
"Failed to create hw obj!!!\n");
1340 /* Initialize card hardware. */
1341 info
.rsr
= atc
->rsr
;
1342 info
.msr
= atc
->msr
;
1343 info
.vm_pgt_phys
= atc_get_ptp_phys(atc
, 0);
1344 err
= hw
->card_init(hw
, &info
);
1348 for (i
= 0; i
< NUM_RSCTYP
; i
++) {
1349 if (!rsc_mgr_funcs
[i
].create
)
1352 err
= rsc_mgr_funcs
[i
].create(atc
->hw
, &atc
->rsc_mgrs
[i
]);
1354 printk(KERN_ERR
"ctxfi: "
1355 "Failed to create rsc_mgr %d!!!\n", i
);
1363 static int atc_get_resources(struct ct_atc
*atc
)
1365 struct daio_desc da_desc
= {0};
1366 struct daio_mgr
*daio_mgr
;
1367 struct src_desc src_dsc
= {0};
1368 struct src_mgr
*src_mgr
;
1369 struct srcimp_desc srcimp_dsc
= {0};
1370 struct srcimp_mgr
*srcimp_mgr
;
1371 struct sum_desc sum_dsc
= {0};
1372 struct sum_mgr
*sum_mgr
;
1373 int err
, i
, num_srcs
, num_daios
;
1375 num_daios
= ((atc
->model
== CTSB1270
) ? 8 : 7);
1376 num_srcs
= ((atc
->model
== CTSB1270
) ? 6 : 4);
1378 atc
->daios
= kzalloc(sizeof(void *)*num_daios
, GFP_KERNEL
);
1382 atc
->srcs
= kzalloc(sizeof(void *)*num_srcs
, GFP_KERNEL
);
1386 atc
->srcimps
= kzalloc(sizeof(void *)*num_srcs
, GFP_KERNEL
);
1390 atc
->pcm
= kzalloc(sizeof(void *)*(2*4), GFP_KERNEL
);
1394 daio_mgr
= (struct daio_mgr
*)atc
->rsc_mgrs
[DAIO
];
1395 da_desc
.msr
= atc
->msr
;
1396 for (i
= 0, atc
->n_daio
= 0; i
< num_daios
; i
++) {
1397 da_desc
.type
= (atc
->model
!= CTSB073X
) ? i
:
1398 ((i
== SPDIFIO
) ? SPDIFI1
: i
);
1399 err
= daio_mgr
->get_daio(daio_mgr
, &da_desc
,
1400 (struct daio
**)&atc
->daios
[i
]);
1402 printk(KERN_ERR
"ctxfi: Failed to get DAIO "
1403 "resource %d!!!\n", i
);
1409 src_mgr
= atc
->rsc_mgrs
[SRC
];
1411 src_dsc
.msr
= atc
->msr
;
1412 src_dsc
.mode
= ARCRW
;
1413 for (i
= 0, atc
->n_src
= 0; i
< num_srcs
; i
++) {
1414 err
= src_mgr
->get_src(src_mgr
, &src_dsc
,
1415 (struct src
**)&atc
->srcs
[i
]);
1422 srcimp_mgr
= atc
->rsc_mgrs
[SRCIMP
];
1424 for (i
= 0, atc
->n_srcimp
= 0; i
< num_srcs
; i
++) {
1425 err
= srcimp_mgr
->get_srcimp(srcimp_mgr
, &srcimp_dsc
,
1426 (struct srcimp
**)&atc
->srcimps
[i
]);
1433 sum_mgr
= atc
->rsc_mgrs
[SUM
];
1434 sum_dsc
.msr
= atc
->msr
;
1435 for (i
= 0, atc
->n_pcm
= 0; i
< (2*4); i
++) {
1436 err
= sum_mgr
->get_sum(sum_mgr
, &sum_dsc
,
1437 (struct sum
**)&atc
->pcm
[i
]);
1448 atc_connect_dai(struct src_mgr
*src_mgr
, struct dai
*dai
,
1449 struct src
**srcs
, struct srcimp
**srcimps
)
1451 struct rsc
*rscs
[2] = {NULL
};
1453 struct srcimp
*srcimp
;
1456 rscs
[0] = &dai
->daio
.rscl
;
1457 rscs
[1] = &dai
->daio
.rscr
;
1458 for (i
= 0; i
< 2; i
++) {
1460 srcimp
= srcimps
[i
];
1461 srcimp
->ops
->map(srcimp
, src
, rscs
[i
]);
1462 src_mgr
->src_disable(src_mgr
, src
);
1465 src_mgr
->commit_write(src_mgr
); /* Actually disable SRCs */
1468 src
->ops
->set_pm(src
, 1);
1469 for (i
= 0; i
< 2; i
++) {
1471 src
->ops
->set_state(src
, SRC_STATE_RUN
);
1472 src
->ops
->commit_write(src
);
1473 src_mgr
->src_enable_s(src_mgr
, src
);
1476 dai
->ops
->set_srt_srcl(dai
, &(srcs
[0]->rsc
));
1477 dai
->ops
->set_srt_srcr(dai
, &(srcs
[1]->rsc
));
1479 dai
->ops
->set_enb_src(dai
, 1);
1480 dai
->ops
->set_enb_srt(dai
, 1);
1481 dai
->ops
->commit_write(dai
);
1483 src_mgr
->commit_write(src_mgr
); /* Synchronously enable SRCs */
1486 static void atc_connect_resources(struct ct_atc
*atc
)
1492 struct ct_mixer
*mixer
;
1493 struct rsc
*rscs
[2] = {NULL
};
1498 for (i
= MIX_WAVE_FRONT
, j
= LINEO1
; i
<= MIX_SPDIF_OUT
; i
++, j
++) {
1499 mixer
->get_output_ports(mixer
, i
, &rscs
[0], &rscs
[1]);
1500 dao
= container_of(atc
->daios
[j
], struct dao
, daio
);
1501 dao
->ops
->set_left_input(dao
, rscs
[0]);
1502 dao
->ops
->set_right_input(dao
, rscs
[1]);
1505 dai
= container_of(atc
->daios
[LINEIM
], struct dai
, daio
);
1506 atc_connect_dai(atc
->rsc_mgrs
[SRC
], dai
,
1507 (struct src
**)&atc
->srcs
[2],
1508 (struct srcimp
**)&atc
->srcimps
[2]);
1510 mixer
->set_input_left(mixer
, MIX_LINE_IN
, &src
->rsc
);
1512 mixer
->set_input_right(mixer
, MIX_LINE_IN
, &src
->rsc
);
1514 if (atc
->model
== CTSB1270
) {
1515 /* Titanium HD has a dedicated ADC for the Mic. */
1516 dai
= container_of(atc
->daios
[MIC
], struct dai
, daio
);
1517 atc_connect_dai(atc
->rsc_mgrs
[SRC
], dai
,
1518 (struct src
**)&atc
->srcs
[4],
1519 (struct srcimp
**)&atc
->srcimps
[4]);
1521 mixer
->set_input_left(mixer
, MIX_MIC_IN
, &src
->rsc
);
1523 mixer
->set_input_right(mixer
, MIX_MIC_IN
, &src
->rsc
);
1526 dai
= container_of(atc
->daios
[SPDIFIO
], struct dai
, daio
);
1527 atc_connect_dai(atc
->rsc_mgrs
[SRC
], dai
,
1528 (struct src
**)&atc
->srcs
[0],
1529 (struct srcimp
**)&atc
->srcimps
[0]);
1532 mixer
->set_input_left(mixer
, MIX_SPDIF_IN
, &src
->rsc
);
1534 mixer
->set_input_right(mixer
, MIX_SPDIF_IN
, &src
->rsc
);
1536 for (i
= MIX_PCMI_FRONT
, j
= 0; i
<= MIX_PCMI_SURROUND
; i
++, j
+= 2) {
1538 mixer
->set_input_left(mixer
, i
, &sum
->rsc
);
1539 sum
= atc
->pcm
[j
+1];
1540 mixer
->set_input_right(mixer
, i
, &sum
->rsc
);
1544 #ifdef CONFIG_PM_SLEEP
1545 static int atc_suspend(struct ct_atc
*atc
)
1548 struct hw
*hw
= atc
->hw
;
1550 snd_power_change_state(atc
->card
, SNDRV_CTL_POWER_D3hot
);
1552 for (i
= FRONT
; i
< NUM_PCMS
; i
++) {
1556 snd_pcm_suspend_all(atc
->pcms
[i
]);
1559 atc_release_resources(atc
);
1566 static int atc_hw_resume(struct ct_atc
*atc
)
1568 struct hw
*hw
= atc
->hw
;
1569 struct card_conf info
= {0};
1571 /* Re-initialize card hardware. */
1572 info
.rsr
= atc
->rsr
;
1573 info
.msr
= atc
->msr
;
1574 info
.vm_pgt_phys
= atc_get_ptp_phys(atc
, 0);
1575 return hw
->resume(hw
, &info
);
1578 static int atc_resources_resume(struct ct_atc
*atc
)
1580 struct ct_mixer
*mixer
;
1584 err
= atc_get_resources(atc
);
1586 atc_release_resources(atc
);
1590 /* Build topology */
1591 atc_connect_resources(atc
);
1594 mixer
->resume(mixer
);
1599 static int atc_resume(struct ct_atc
*atc
)
1603 /* Do hardware resume. */
1604 err
= atc_hw_resume(atc
);
1606 printk(KERN_ERR
"ctxfi: pci_enable_device failed, "
1607 "disabling device\n");
1608 snd_card_disconnect(atc
->card
);
1612 err
= atc_resources_resume(atc
);
1616 snd_power_change_state(atc
->card
, SNDRV_CTL_POWER_D0
);
1622 static struct ct_atc atc_preset
= {
1623 .map_audio_buffer
= ct_map_audio_buffer
,
1624 .unmap_audio_buffer
= ct_unmap_audio_buffer
,
1625 .pcm_playback_prepare
= atc_pcm_playback_prepare
,
1626 .pcm_release_resources
= atc_pcm_release_resources
,
1627 .pcm_playback_start
= atc_pcm_playback_start
,
1628 .pcm_playback_stop
= atc_pcm_stop
,
1629 .pcm_playback_position
= atc_pcm_playback_position
,
1630 .pcm_capture_prepare
= atc_pcm_capture_prepare
,
1631 .pcm_capture_start
= atc_pcm_capture_start
,
1632 .pcm_capture_stop
= atc_pcm_stop
,
1633 .pcm_capture_position
= atc_pcm_capture_position
,
1634 .spdif_passthru_playback_prepare
= spdif_passthru_playback_prepare
,
1635 .get_ptp_phys
= atc_get_ptp_phys
,
1636 .select_line_in
= atc_select_line_in
,
1637 .select_mic_in
= atc_select_mic_in
,
1638 .select_digit_io
= atc_select_digit_io
,
1639 .line_front_unmute
= atc_line_front_unmute
,
1640 .line_surround_unmute
= atc_line_surround_unmute
,
1641 .line_clfe_unmute
= atc_line_clfe_unmute
,
1642 .line_rear_unmute
= atc_line_rear_unmute
,
1643 .line_in_unmute
= atc_line_in_unmute
,
1644 .mic_unmute
= atc_mic_unmute
,
1645 .spdif_out_unmute
= atc_spdif_out_unmute
,
1646 .spdif_in_unmute
= atc_spdif_in_unmute
,
1647 .spdif_out_get_status
= atc_spdif_out_get_status
,
1648 .spdif_out_set_status
= atc_spdif_out_set_status
,
1649 .spdif_out_passthru
= atc_spdif_out_passthru
,
1650 .capabilities
= atc_capabilities
,
1651 .output_switch_get
= atc_output_switch_get
,
1652 .output_switch_put
= atc_output_switch_put
,
1653 .mic_source_switch_get
= atc_mic_source_switch_get
,
1654 .mic_source_switch_put
= atc_mic_source_switch_put
,
1655 #ifdef CONFIG_PM_SLEEP
1656 .suspend
= atc_suspend
,
1657 .resume
= atc_resume
,
1662 * ct_atc_create - create and initialize a hardware manager
1663 * @card: corresponding alsa card object
1664 * @pci: corresponding kernel pci device object
1665 * @ratc: return created object address in it
1667 * Creates and initializes a hardware manager.
1669 * Creates kmallocated ct_atc structure. Initializes hardware.
1670 * Returns 0 if succeeds, or negative error code if fails.
1673 int ct_atc_create(struct snd_card
*card
, struct pci_dev
*pci
,
1674 unsigned int rsr
, unsigned int msr
,
1675 int chip_type
, unsigned int ssid
,
1676 struct ct_atc
**ratc
)
1679 static struct snd_device_ops ops
= {
1680 .dev_free
= atc_dev_free
,
1686 atc
= kzalloc(sizeof(*atc
), GFP_KERNEL
);
1690 /* Set operations */
1697 atc
->chip_type
= chip_type
;
1699 mutex_init(&atc
->atc_mutex
);
1701 /* Find card model */
1702 err
= atc_identify_card(atc
, ssid
);
1704 printk(KERN_ERR
"ctatc: Card not recognised\n");
1708 /* Set up device virtual memory management object */
1709 err
= ct_vm_create(&atc
->vm
, pci
);
1713 /* Create all atc hw devices */
1714 err
= atc_create_hw_devs(atc
);
1718 err
= ct_mixer_create(atc
, (struct ct_mixer
**)&atc
->mixer
);
1720 printk(KERN_ERR
"ctxfi: Failed to create mixer obj!!!\n");
1725 err
= atc_get_resources(atc
);
1729 /* Build topology */
1730 atc_connect_resources(atc
);
1732 atc
->timer
= ct_timer_new(atc
);
1738 err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, atc
, &ops
);
1742 snd_card_set_dev(card
, &pci
->dev
);
1748 ct_atc_destroy(atc
);
1749 printk(KERN_ERR
"ctxfi: Something wrong!!!\n");