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
21 #include "cthardware.h"
25 #include <linux/delay.h>
26 #include <sound/pcm.h>
27 #include <sound/control.h>
28 #include <sound/asoundef.h>
30 #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 const struct ct_atc_chip_sub_details atc_sub_details
[NUM_CTCARDS
] = {
42 [CTSB0760
] = {.subsys
= PCI_SUBDEVICE_ID_CREATIVE_SB0760
,
43 .nm_model
= "SB076x"},
44 [CTHENDRIX
] = {.subsys
= PCI_SUBDEVICE_ID_CREATIVE_HENDRIX
,
45 .nm_model
= "Hendrix"},
46 [CTSB08801
] = {.subsys
= PCI_SUBDEVICE_ID_CREATIVE_SB08801
,
47 .nm_model
= "SB0880"},
48 [CTSB08802
] = {.subsys
= PCI_SUBDEVICE_ID_CREATIVE_SB08802
,
49 .nm_model
= "SB0880"},
50 [CTSB08803
] = {.subsys
= PCI_SUBDEVICE_ID_CREATIVE_SB08803
,
54 static struct ct_atc_chip_details atc_chip_details
[] = {
55 {.vendor
= PCI_VENDOR_ID_CREATIVE
,
56 .device
= PCI_DEVICE_ID_CREATIVE_20K1
,
58 .nm_card
= "X-Fi 20k1"},
59 {.vendor
= PCI_VENDOR_ID_CREATIVE
,
60 .device
= PCI_DEVICE_ID_CREATIVE_20K2
,
61 .sub_details
= atc_sub_details
,
62 .nm_card
= "X-Fi 20k2"},
67 int (*create
)(struct ct_atc
*atc
,
68 enum CTALSADEVS device
, const char *device_name
);
69 int (*destroy
)(void *alsa_dev
);
70 const char *public_name
;
71 } alsa_dev_funcs
[NUM_CTALSADEVS
] = {
72 [FRONT
] = { .create
= ct_alsa_pcm_create
,
74 .public_name
= "Front/WaveIn"},
75 [SURROUND
] = { .create
= ct_alsa_pcm_create
,
77 .public_name
= "Surround"},
78 [CLFE
] = { .create
= ct_alsa_pcm_create
,
80 .public_name
= "Center/LFE"},
81 [SIDE
] = { .create
= ct_alsa_pcm_create
,
83 .public_name
= "Side"},
84 [IEC958
] = { .create
= ct_alsa_pcm_create
,
86 .public_name
= "IEC958 Non-audio"},
88 [MIXER
] = { .create
= ct_alsa_mix_create
,
90 .public_name
= "Mixer"}
93 typedef int (*create_t
)(void *, void **);
94 typedef int (*destroy_t
)(void *);
97 int (*create
)(void *hw
, void **rmgr
);
98 int (*destroy
)(void *mgr
);
99 } rsc_mgr_funcs
[NUM_RSCTYP
] = {
100 [SRC
] = { .create
= (create_t
)src_mgr_create
,
101 .destroy
= (destroy_t
)src_mgr_destroy
},
102 [SRCIMP
] = { .create
= (create_t
)srcimp_mgr_create
,
103 .destroy
= (destroy_t
)srcimp_mgr_destroy
},
104 [AMIXER
] = { .create
= (create_t
)amixer_mgr_create
,
105 .destroy
= (destroy_t
)amixer_mgr_destroy
},
106 [SUM
] = { .create
= (create_t
)sum_mgr_create
,
107 .destroy
= (destroy_t
)sum_mgr_destroy
},
108 [DAIO
] = { .create
= (create_t
)daio_mgr_create
,
109 .destroy
= (destroy_t
)daio_mgr_destroy
}
113 atc_pcm_release_resources(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
);
116 * Only mono and interleaved modes are supported now.
117 * Always allocates a contiguous channel block.
120 static int ct_map_audio_buffer(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
122 struct snd_pcm_runtime
*runtime
;
125 if (NULL
== apcm
->substream
)
128 runtime
= apcm
->substream
->runtime
;
131 apcm
->vm_block
= vm
->map(vm
, apcm
->substream
, runtime
->dma_bytes
);
133 if (NULL
== apcm
->vm_block
)
139 static void ct_unmap_audio_buffer(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
143 if (NULL
== apcm
->vm_block
)
148 vm
->unmap(vm
, apcm
->vm_block
);
150 apcm
->vm_block
= NULL
;
153 static unsigned long atc_get_ptp_phys(struct ct_atc
*atc
, int index
)
157 unsigned long phys_addr
;
160 kvirt_addr
= vm
->get_ptp_virt(vm
, index
);
161 if (kvirt_addr
== NULL
)
164 phys_addr
= virt_to_phys(kvirt_addr
);
169 static unsigned int convert_format(snd_pcm_format_t snd_format
)
171 switch (snd_format
) {
172 case SNDRV_PCM_FORMAT_U8
:
174 case SNDRV_PCM_FORMAT_S16_LE
:
176 case SNDRV_PCM_FORMAT_S24_3LE
:
178 case SNDRV_PCM_FORMAT_S32_LE
:
180 case SNDRV_PCM_FORMAT_FLOAT_LE
:
183 printk(KERN_ERR
"ctxfi: not recognized snd format is %d \n",
190 atc_get_pitch(unsigned int input_rate
, unsigned int output_rate
)
192 unsigned int pitch
= 0;
195 /* get pitch and convert to fixed-point 8.24 format. */
196 pitch
= (input_rate
/ output_rate
) << 24;
197 input_rate
%= output_rate
;
200 for (b
= 31; ((b
>= 0) && !(input_rate
>> b
)); )
204 input_rate
<<= (31 - b
);
205 input_rate
/= output_rate
;
218 static int select_rom(unsigned int pitch
)
220 if ((pitch
> 0x00428f5c) && (pitch
< 0x01b851ec)) {
221 /* 0.26 <= pitch <= 1.72 */
223 } else if ((0x01d66666 == pitch
) || (0x01d66667 == pitch
)) {
224 /* pitch == 1.8375 */
226 } else if (0x02000000 == pitch
) {
229 } else if ((pitch
>= 0x0) && (pitch
<= 0x08000000)) {
230 /* 0 <= pitch <= 8 */
237 static int atc_pcm_playback_prepare(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
239 struct src_mgr
*src_mgr
= atc
->rsc_mgrs
[SRC
];
240 struct amixer_mgr
*amixer_mgr
= atc
->rsc_mgrs
[AMIXER
];
241 struct src_desc desc
= {0};
242 struct amixer_desc mix_dsc
= {0};
243 struct src
*src
= NULL
;
244 struct amixer
*amixer
= NULL
;
246 int n_amixer
= apcm
->substream
->runtime
->channels
, i
= 0;
247 int device
= apcm
->substream
->pcm
->device
;
248 unsigned int pitch
= 0;
251 if (NULL
!= apcm
->src
) {
252 /* Prepared pcm playback */
256 /* first release old resources */
257 atc
->pcm_release_resources(atc
, apcm
);
259 /* Get SRC resource */
260 desc
.multi
= apcm
->substream
->runtime
->channels
;
263 err
= src_mgr
->get_src(src_mgr
, &desc
, (struct src
**)&apcm
->src
);
267 pitch
= atc_get_pitch(apcm
->substream
->runtime
->rate
,
268 (atc
->rsr
* atc
->msr
));
270 src
->ops
->set_pitch(src
, pitch
);
271 src
->ops
->set_rom(src
, select_rom(pitch
));
272 src
->ops
->set_sf(src
, convert_format(apcm
->substream
->runtime
->format
));
273 src
->ops
->set_pm(src
, (src
->ops
->next_interleave(src
) != NULL
));
275 /* Get AMIXER resource */
276 n_amixer
= (n_amixer
< 2) ? 2 : n_amixer
;
277 apcm
->amixers
= kzalloc(sizeof(void *)*n_amixer
, GFP_KERNEL
);
278 if (NULL
== apcm
->amixers
) {
282 mix_dsc
.msr
= atc
->msr
;
283 for (i
= 0, apcm
->n_amixer
= 0; i
< n_amixer
; i
++) {
284 err
= amixer_mgr
->get_amixer(amixer_mgr
, &mix_dsc
,
285 (struct amixer
**)&apcm
->amixers
[i
]);
292 /* Set up device virtual mem map */
293 err
= ct_map_audio_buffer(atc
, apcm
);
297 /* Connect resources */
299 for (i
= 0; i
< n_amixer
; i
++) {
300 amixer
= apcm
->amixers
[i
];
301 spin_lock_irqsave(&atc
->atc_lock
, flags
);
302 amixer
->ops
->setup(amixer
, &src
->rsc
,
303 INIT_VOL
, atc
->pcm
[i
+device
*2]);
304 spin_unlock_irqrestore(&atc
->atc_lock
, flags
);
305 src
= src
->ops
->next_interleave(src
);
313 atc_pcm_release_resources(atc
, apcm
);
318 atc_pcm_release_resources(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
320 struct src_mgr
*src_mgr
= atc
->rsc_mgrs
[SRC
];
321 struct srcimp_mgr
*srcimp_mgr
= atc
->rsc_mgrs
[SRCIMP
];
322 struct amixer_mgr
*amixer_mgr
= atc
->rsc_mgrs
[AMIXER
];
323 struct sum_mgr
*sum_mgr
= atc
->rsc_mgrs
[SUM
];
324 struct srcimp
*srcimp
= NULL
;
327 if (NULL
!= apcm
->srcimps
) {
328 for (i
= 0; i
< apcm
->n_srcimp
; i
++) {
329 srcimp
= apcm
->srcimps
[i
];
330 srcimp
->ops
->unmap(srcimp
);
331 srcimp_mgr
->put_srcimp(srcimp_mgr
, srcimp
);
332 apcm
->srcimps
[i
] = NULL
;
334 kfree(apcm
->srcimps
);
335 apcm
->srcimps
= NULL
;
338 if (NULL
!= apcm
->srccs
) {
339 for (i
= 0; i
< apcm
->n_srcc
; i
++) {
340 src_mgr
->put_src(src_mgr
, apcm
->srccs
[i
]);
341 apcm
->srccs
[i
] = NULL
;
347 if (NULL
!= apcm
->amixers
) {
348 for (i
= 0; i
< apcm
->n_amixer
; i
++) {
349 amixer_mgr
->put_amixer(amixer_mgr
, apcm
->amixers
[i
]);
350 apcm
->amixers
[i
] = NULL
;
352 kfree(apcm
->amixers
);
353 apcm
->amixers
= NULL
;
356 if (NULL
!= apcm
->mono
) {
357 sum_mgr
->put_sum(sum_mgr
, apcm
->mono
);
361 if (NULL
!= apcm
->src
) {
362 src_mgr
->put_src(src_mgr
, apcm
->src
);
366 if (NULL
!= apcm
->vm_block
) {
367 /* Undo device virtual mem map */
368 ct_unmap_audio_buffer(atc
, apcm
);
369 apcm
->vm_block
= NULL
;
375 static int atc_pcm_playback_start(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
377 unsigned int max_cisz
= 0;
378 struct src
*src
= apcm
->src
;
380 max_cisz
= src
->multi
* src
->rsc
.msr
;
381 max_cisz
= 0x80 * (max_cisz
< 8 ? max_cisz
: 8);
383 src
->ops
->set_sa(src
, apcm
->vm_block
->addr
);
384 src
->ops
->set_la(src
, apcm
->vm_block
->addr
+ apcm
->vm_block
->size
);
385 src
->ops
->set_ca(src
, apcm
->vm_block
->addr
+ max_cisz
);
386 src
->ops
->set_cisz(src
, max_cisz
);
388 src
->ops
->set_bm(src
, 1);
389 src
->ops
->set_state(src
, SRC_STATE_INIT
);
390 src
->ops
->commit_write(src
);
395 static int atc_pcm_stop(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
397 struct src
*src
= NULL
;
401 src
->ops
->set_bm(src
, 0);
402 src
->ops
->set_state(src
, SRC_STATE_OFF
);
403 src
->ops
->commit_write(src
);
405 if (NULL
!= apcm
->srccs
) {
406 for (i
= 0; i
< apcm
->n_srcc
; i
++) {
407 src
= apcm
->srccs
[i
];
408 src
->ops
->set_bm(src
, 0);
409 src
->ops
->set_state(src
, SRC_STATE_OFF
);
410 src
->ops
->commit_write(src
);
420 atc_pcm_playback_position(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
422 struct src
*src
= apcm
->src
;
423 u32 size
= 0, max_cisz
= 0;
426 position
= src
->ops
->get_ca(src
);
428 size
= apcm
->vm_block
->size
;
429 max_cisz
= src
->multi
* src
->rsc
.msr
;
430 max_cisz
= 128 * (max_cisz
< 8 ? max_cisz
: 8);
432 return (position
+ size
- max_cisz
- apcm
->vm_block
->addr
) % size
;
435 struct src_node_conf_t
{
438 unsigned int mix_msr
:8;
439 unsigned int imp_msr
:8;
443 static void setup_src_node_conf(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
,
444 struct src_node_conf_t
*conf
, int *n_srcc
)
446 unsigned int pitch
= 0;
448 /* get pitch and convert to fixed-point 8.24 format. */
449 pitch
= atc_get_pitch((atc
->rsr
* atc
->msr
),
450 apcm
->substream
->runtime
->rate
);
454 *n_srcc
= apcm
->substream
->runtime
->channels
;
455 conf
[0].pitch
= pitch
;
456 conf
[0].mix_msr
= conf
[0].imp_msr
= conf
[0].msr
= 1;
458 } else if (2 == atc
->msr
) {
459 if (0x8000000 < pitch
) {
460 /* Need two-stage SRCs, SRCIMPs and
461 * AMIXERs for converting format */
462 conf
[0].pitch
= (atc
->msr
<< 24);
463 conf
[0].msr
= conf
[0].mix_msr
= 1;
464 conf
[0].imp_msr
= atc
->msr
;
466 conf
[1].pitch
= atc_get_pitch(atc
->rsr
,
467 apcm
->substream
->runtime
->rate
);
468 conf
[1].msr
= conf
[1].mix_msr
= conf
[1].imp_msr
= 1;
470 *n_srcc
= apcm
->substream
->runtime
->channels
* 2;
471 } else if (0x1000000 < pitch
) {
472 /* Need one-stage SRCs, SRCIMPs and
473 * AMIXERs for converting format */
474 conf
[0].pitch
= pitch
;
475 conf
[0].msr
= conf
[0].mix_msr
476 = conf
[0].imp_msr
= atc
->msr
;
478 *n_srcc
= apcm
->substream
->runtime
->channels
;
484 atc_pcm_capture_get_resources(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
486 struct src_mgr
*src_mgr
= atc
->rsc_mgrs
[SRC
];
487 struct srcimp_mgr
*srcimp_mgr
= atc
->rsc_mgrs
[SRCIMP
];
488 struct amixer_mgr
*amixer_mgr
= atc
->rsc_mgrs
[AMIXER
];
489 struct sum_mgr
*sum_mgr
= atc
->rsc_mgrs
[SUM
];
490 struct src_desc src_dsc
= {0};
491 struct src
*src
= NULL
;
492 struct srcimp_desc srcimp_dsc
= {0};
493 struct srcimp
*srcimp
= NULL
;
494 struct amixer_desc mix_dsc
= {0};
495 struct sum_desc sum_dsc
= {0};
496 unsigned int pitch
= 0;
497 int multi
= 0, err
= 0, i
= 0;
498 int n_srcimp
= 0, n_amixer
= 0, n_srcc
= 0, n_sum
= 0;
499 struct src_node_conf_t src_node_conf
[2] = {{0} };
501 /* first release old resources */
502 atc
->pcm_release_resources(atc
, apcm
);
504 /* The numbers of converting SRCs and SRCIMPs should be determined
507 multi
= apcm
->substream
->runtime
->channels
;
509 /* get pitch and convert to fixed-point 8.24 format. */
510 pitch
= atc_get_pitch((atc
->rsr
* atc
->msr
),
511 apcm
->substream
->runtime
->rate
);
513 setup_src_node_conf(atc
, apcm
, src_node_conf
, &n_srcc
);
514 n_sum
= (1 == multi
) ? 1 : 0;
515 n_amixer
+= n_sum
* 2 + n_srcc
;
517 if ((multi
> 1) && (0x8000000 >= pitch
)) {
518 /* Need extra AMIXERs and SRCIMPs for special treatment
519 * of interleaved recording of conjugate channels */
520 n_amixer
+= multi
* atc
->msr
;
521 n_srcimp
+= multi
* atc
->msr
;
527 apcm
->srccs
= kzalloc(sizeof(void *)*n_srcc
, GFP_KERNEL
);
528 if (NULL
== apcm
->srccs
)
532 apcm
->amixers
= kzalloc(sizeof(void *)*n_amixer
, GFP_KERNEL
);
533 if (NULL
== apcm
->amixers
) {
538 apcm
->srcimps
= kzalloc(sizeof(void *)*n_srcimp
, GFP_KERNEL
);
539 if (NULL
== apcm
->srcimps
) {
544 /* Allocate SRCs for sample rate conversion if needed */
546 src_dsc
.mode
= ARCRW
;
547 for (i
= 0, apcm
->n_srcc
= 0; i
< n_srcc
; i
++) {
548 src_dsc
.msr
= src_node_conf
[i
/multi
].msr
;
549 err
= src_mgr
->get_src(src_mgr
, &src_dsc
,
550 (struct src
**)&apcm
->srccs
[i
]);
554 src
= apcm
->srccs
[i
];
555 pitch
= src_node_conf
[i
/multi
].pitch
;
556 src
->ops
->set_pitch(src
, pitch
);
557 src
->ops
->set_rom(src
, select_rom(pitch
));
558 src
->ops
->set_vo(src
, src_node_conf
[i
/multi
].vo
);
563 /* Allocate AMIXERs for routing SRCs of conversion if needed */
564 for (i
= 0, apcm
->n_amixer
= 0; i
< n_amixer
; i
++) {
566 mix_dsc
.msr
= atc
->msr
;
567 else if (i
< (n_sum
*2+n_srcc
))
568 mix_dsc
.msr
= src_node_conf
[(i
-n_sum
*2)/multi
].mix_msr
;
572 err
= amixer_mgr
->get_amixer(amixer_mgr
, &mix_dsc
,
573 (struct amixer
**)&apcm
->amixers
[i
]);
580 /* Allocate a SUM resource to mix all input channels together */
581 sum_dsc
.msr
= atc
->msr
;
582 err
= sum_mgr
->get_sum(sum_mgr
, &sum_dsc
, (struct sum
**)&apcm
->mono
);
586 pitch
= atc_get_pitch((atc
->rsr
* atc
->msr
),
587 apcm
->substream
->runtime
->rate
);
588 /* Allocate SRCIMP resources */
589 for (i
= 0, apcm
->n_srcimp
= 0; i
< n_srcimp
; i
++) {
591 srcimp_dsc
.msr
= src_node_conf
[i
/multi
].imp_msr
;
593 srcimp_dsc
.msr
= (pitch
<= 0x8000000) ? atc
->msr
: 1;
597 err
= srcimp_mgr
->get_srcimp(srcimp_mgr
, &srcimp_dsc
, &srcimp
);
601 apcm
->srcimps
[i
] = srcimp
;
605 /* Allocate a SRC for writing data to host memory */
606 src_dsc
.multi
= apcm
->substream
->runtime
->channels
;
608 src_dsc
.mode
= MEMWR
;
609 err
= src_mgr
->get_src(src_mgr
, &src_dsc
, (struct src
**)&apcm
->src
);
614 src
->ops
->set_pitch(src
, pitch
);
616 /* Set up device virtual mem map */
617 err
= ct_map_audio_buffer(atc
, apcm
);
624 atc_pcm_release_resources(atc
, apcm
);
628 static int atc_pcm_capture_prepare(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
630 struct src
*src
= NULL
;
631 struct amixer
*amixer
= NULL
;
632 struct srcimp
*srcimp
= NULL
;
633 struct ct_mixer
*mixer
= atc
->mixer
;
634 struct sum
*mono
= NULL
;
635 struct rsc
*out_ports
[8] = {NULL
};
636 int err
= 0, i
= 0, j
= 0, n_sum
= 0, multi
= 0;
637 unsigned int pitch
= 0;
638 int mix_base
= 0, imp_base
= 0;
640 if (NULL
!= apcm
->src
) {
641 /* Prepared pcm capture */
645 /* Get needed resources. */
646 err
= atc_pcm_capture_get_resources(atc
, apcm
);
650 /* Connect resources */
651 mixer
->get_output_ports(mixer
, MIX_PCMO_FRONT
,
652 &out_ports
[0], &out_ports
[1]);
654 multi
= apcm
->substream
->runtime
->channels
;
657 for (i
= 0; i
< 2; i
++) {
658 amixer
= apcm
->amixers
[i
];
659 amixer
->ops
->setup(amixer
, out_ports
[i
],
660 MONO_SUM_SCALE
, mono
);
662 out_ports
[0] = &mono
->rsc
;
664 mix_base
= n_sum
* 2;
667 for (i
= 0; i
< apcm
->n_srcc
; i
++) {
668 src
= apcm
->srccs
[i
];
669 srcimp
= apcm
->srcimps
[imp_base
+i
];
670 amixer
= apcm
->amixers
[mix_base
+i
];
671 srcimp
->ops
->map(srcimp
, src
, out_ports
[i
%multi
]);
672 amixer
->ops
->setup(amixer
, &src
->rsc
, INIT_VOL
, NULL
);
673 out_ports
[i
%multi
] = &amixer
->rsc
;
676 pitch
= atc_get_pitch((atc
->rsr
* atc
->msr
),
677 apcm
->substream
->runtime
->rate
);
679 if ((multi
> 1) && (pitch
<= 0x8000000)) {
680 /* Special connection for interleaved
681 * recording with conjugate channels */
682 for (i
= 0; i
< multi
; i
++) {
683 out_ports
[i
]->ops
->master(out_ports
[i
]);
684 for (j
= 0; j
< atc
->msr
; j
++) {
685 amixer
= apcm
->amixers
[apcm
->n_srcc
+j
*multi
+i
];
686 amixer
->ops
->set_input(amixer
, out_ports
[i
]);
687 amixer
->ops
->set_scale(amixer
, INIT_VOL
);
688 amixer
->ops
->set_sum(amixer
, NULL
);
689 amixer
->ops
->commit_raw_write(amixer
);
690 out_ports
[i
]->ops
->next_conj(out_ports
[i
]);
692 srcimp
= apcm
->srcimps
[apcm
->n_srcc
+j
*multi
+i
];
693 srcimp
->ops
->map(srcimp
, apcm
->src
,
698 for (i
= 0; i
< multi
; i
++) {
699 srcimp
= apcm
->srcimps
[apcm
->n_srcc
+i
];
700 srcimp
->ops
->map(srcimp
, apcm
->src
, out_ports
[i
]);
707 static int atc_pcm_capture_start(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
709 struct src
*src
= NULL
;
710 struct src_mgr
*src_mgr
= atc
->rsc_mgrs
[SRC
];
711 int i
= 0, multi
= 0;
717 multi
= apcm
->substream
->runtime
->channels
;
718 /* Set up converting SRCs */
719 for (i
= 0; i
< apcm
->n_srcc
; i
++) {
720 src
= apcm
->srccs
[i
];
721 src
->ops
->set_pm(src
, ((i
%multi
) != (multi
-1)));
722 src_mgr
->src_disable(src_mgr
, src
);
725 /* Set up recording SRC */
727 src
->ops
->set_sf(src
, convert_format(apcm
->substream
->runtime
->format
));
728 src
->ops
->set_sa(src
, apcm
->vm_block
->addr
);
729 src
->ops
->set_la(src
, apcm
->vm_block
->addr
+ apcm
->vm_block
->size
);
730 src
->ops
->set_ca(src
, apcm
->vm_block
->addr
);
731 src_mgr
->src_disable(src_mgr
, src
);
733 /* Disable relevant SRCs firstly */
734 src_mgr
->commit_write(src_mgr
);
736 /* Enable SRCs respectively */
737 for (i
= 0; i
< apcm
->n_srcc
; i
++) {
738 src
= apcm
->srccs
[i
];
739 src
->ops
->set_state(src
, SRC_STATE_RUN
);
740 src
->ops
->commit_write(src
);
741 src_mgr
->src_enable_s(src_mgr
, src
);
744 src
->ops
->set_bm(src
, 1);
745 src
->ops
->set_state(src
, SRC_STATE_RUN
);
746 src
->ops
->commit_write(src
);
747 src_mgr
->src_enable_s(src_mgr
, src
);
749 /* Enable relevant SRCs synchronously */
750 src_mgr
->commit_write(src_mgr
);
756 atc_pcm_capture_position(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
758 struct src
*src
= apcm
->src
;
760 return src
->ops
->get_ca(src
) - apcm
->vm_block
->addr
;
763 static int spdif_passthru_playback_get_resources(struct ct_atc
*atc
,
764 struct ct_atc_pcm
*apcm
)
766 struct src_mgr
*src_mgr
= atc
->rsc_mgrs
[SRC
];
767 struct amixer_mgr
*amixer_mgr
= atc
->rsc_mgrs
[AMIXER
];
768 struct src_desc desc
= {0};
769 struct amixer_desc mix_dsc
= {0};
770 struct src
*src
= NULL
;
772 int n_amixer
= apcm
->substream
->runtime
->channels
, i
= 0;
773 unsigned int pitch
= 0, rsr
= atc
->pll_rate
;
775 /* first release old resources */
776 atc
->pcm_release_resources(atc
, apcm
);
778 /* Get SRC resource */
779 desc
.multi
= apcm
->substream
->runtime
->channels
;
781 while (apcm
->substream
->runtime
->rate
> (rsr
* desc
.msr
))
785 err
= src_mgr
->get_src(src_mgr
, &desc
, (struct src
**)&apcm
->src
);
789 pitch
= atc_get_pitch(apcm
->substream
->runtime
->rate
, (rsr
* desc
.msr
));
791 src
->ops
->set_pitch(src
, pitch
);
792 src
->ops
->set_rom(src
, select_rom(pitch
));
793 src
->ops
->set_sf(src
, convert_format(apcm
->substream
->runtime
->format
));
794 src
->ops
->set_pm(src
, (src
->ops
->next_interleave(src
) != NULL
));
795 src
->ops
->set_bp(src
, 1);
797 /* Get AMIXER resource */
798 n_amixer
= (n_amixer
< 2) ? 2 : n_amixer
;
799 apcm
->amixers
= kzalloc(sizeof(void *)*n_amixer
, GFP_KERNEL
);
800 if (NULL
== apcm
->amixers
) {
804 mix_dsc
.msr
= desc
.msr
;
805 for (i
= 0, apcm
->n_amixer
= 0; i
< n_amixer
; i
++) {
806 err
= amixer_mgr
->get_amixer(amixer_mgr
, &mix_dsc
,
807 (struct amixer
**)&apcm
->amixers
[i
]);
814 /* Set up device virtual mem map */
815 err
= ct_map_audio_buffer(atc
, apcm
);
822 atc_pcm_release_resources(atc
, apcm
);
827 spdif_passthru_playback_setup(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
829 struct dao
*dao
= container_of(atc
->daios
[SPDIFOO
], struct dao
, daio
);
831 unsigned int rate
= apcm
->substream
->runtime
->rate
;
832 unsigned int status
= 0;
834 unsigned char iec958_con_fs
= 0;
838 iec958_con_fs
= IEC958_AES3_CON_FS_48000
;
841 iec958_con_fs
= IEC958_AES3_CON_FS_44100
;
844 iec958_con_fs
= IEC958_AES3_CON_FS_32000
;
850 spin_lock_irqsave(&atc
->atc_lock
, flags
);
851 dao
->ops
->get_spos(dao
, &status
);
852 if (((status
>> 24) & IEC958_AES3_CON_FS
) != iec958_con_fs
) {
853 status
&= ((~IEC958_AES3_CON_FS
) << 24);
854 status
|= (iec958_con_fs
<< 24);
855 dao
->ops
->set_spos(dao
, status
);
856 dao
->ops
->commit_write(dao
);
858 if ((rate
!= atc
->pll_rate
) && (32000 != rate
)) {
859 err
= ((struct hw
*)atc
->hw
)->pll_init(atc
->hw
, rate
);
860 atc
->pll_rate
= err
? 0 : rate
;
862 spin_unlock_irqrestore(&atc
->atc_lock
, flags
);
868 spdif_passthru_playback_prepare(struct ct_atc
*atc
, struct ct_atc_pcm
*apcm
)
870 struct src
*src
= NULL
;
871 struct amixer
*amixer
= NULL
;
872 struct dao
*dao
= NULL
;
877 if (NULL
!= apcm
->src
)
880 /* Configure SPDIFOO and PLL to passthrough mode;
881 * determine pll_rate. */
882 err
= spdif_passthru_playback_setup(atc
, apcm
);
886 /* Get needed resources. */
887 err
= spdif_passthru_playback_get_resources(atc
, apcm
);
891 /* Connect resources */
893 for (i
= 0; i
< apcm
->n_amixer
; i
++) {
894 amixer
= apcm
->amixers
[i
];
895 amixer
->ops
->setup(amixer
, &src
->rsc
, INIT_VOL
, NULL
);
896 src
= src
->ops
->next_interleave(src
);
900 /* Connect to SPDIFOO */
901 spin_lock_irqsave(&atc
->atc_lock
, flags
);
902 dao
= container_of(atc
->daios
[SPDIFOO
], struct dao
, daio
);
903 amixer
= apcm
->amixers
[0];
904 dao
->ops
->set_left_input(dao
, &amixer
->rsc
);
905 amixer
= apcm
->amixers
[1];
906 dao
->ops
->set_right_input(dao
, &amixer
->rsc
);
907 spin_unlock_irqrestore(&atc
->atc_lock
, flags
);
912 static int atc_select_line_in(struct ct_atc
*atc
)
914 struct hw
*hw
= atc
->hw
;
915 struct ct_mixer
*mixer
= atc
->mixer
;
916 struct src
*src
= NULL
;
918 if (hw
->is_adc_source_selected(hw
, ADC_LINEIN
))
921 mixer
->set_input_left(mixer
, MIX_MIC_IN
, NULL
);
922 mixer
->set_input_right(mixer
, MIX_MIC_IN
, NULL
);
924 hw
->select_adc_source(hw
, ADC_LINEIN
);
927 mixer
->set_input_left(mixer
, MIX_LINE_IN
, &src
->rsc
);
929 mixer
->set_input_right(mixer
, MIX_LINE_IN
, &src
->rsc
);
934 static int atc_select_mic_in(struct ct_atc
*atc
)
936 struct hw
*hw
= atc
->hw
;
937 struct ct_mixer
*mixer
= atc
->mixer
;
938 struct src
*src
= NULL
;
940 if (hw
->is_adc_source_selected(hw
, ADC_MICIN
))
943 mixer
->set_input_left(mixer
, MIX_LINE_IN
, NULL
);
944 mixer
->set_input_right(mixer
, MIX_LINE_IN
, NULL
);
946 hw
->select_adc_source(hw
, ADC_MICIN
);
949 mixer
->set_input_left(mixer
, MIX_MIC_IN
, &src
->rsc
);
951 mixer
->set_input_right(mixer
, MIX_MIC_IN
, &src
->rsc
);
956 static int atc_have_digit_io_switch(struct ct_atc
*atc
)
958 struct hw
*hw
= atc
->hw
;
960 return hw
->have_digit_io_switch(hw
);
963 static int atc_select_digit_io(struct ct_atc
*atc
)
965 struct hw
*hw
= atc
->hw
;
967 if (hw
->is_adc_source_selected(hw
, ADC_NONE
))
970 hw
->select_adc_source(hw
, ADC_NONE
);
975 static int atc_daio_unmute(struct ct_atc
*atc
, unsigned char state
, int type
)
977 struct daio_mgr
*daio_mgr
= atc
->rsc_mgrs
[DAIO
];
980 daio_mgr
->daio_enable(daio_mgr
, atc
->daios
[type
]);
982 daio_mgr
->daio_disable(daio_mgr
, atc
->daios
[type
]);
984 daio_mgr
->commit_write(daio_mgr
);
990 atc_dao_get_status(struct ct_atc
*atc
, unsigned int *status
, int type
)
992 struct dao
*dao
= container_of(atc
->daios
[type
], struct dao
, daio
);
993 return dao
->ops
->get_spos(dao
, status
);
997 atc_dao_set_status(struct ct_atc
*atc
, unsigned int status
, int type
)
999 struct dao
*dao
= container_of(atc
->daios
[type
], struct dao
, daio
);
1001 dao
->ops
->set_spos(dao
, status
);
1002 dao
->ops
->commit_write(dao
);
1006 static int atc_line_front_unmute(struct ct_atc
*atc
, unsigned char state
)
1008 return atc_daio_unmute(atc
, state
, LINEO1
);
1011 static int atc_line_surround_unmute(struct ct_atc
*atc
, unsigned char state
)
1013 return atc_daio_unmute(atc
, state
, LINEO4
);
1016 static int atc_line_clfe_unmute(struct ct_atc
*atc
, unsigned char state
)
1018 return atc_daio_unmute(atc
, state
, LINEO3
);
1021 static int atc_line_rear_unmute(struct ct_atc
*atc
, unsigned char state
)
1023 return atc_daio_unmute(atc
, state
, LINEO2
);
1026 static int atc_line_in_unmute(struct ct_atc
*atc
, unsigned char state
)
1028 return atc_daio_unmute(atc
, state
, LINEIM
);
1031 static int atc_spdif_out_unmute(struct ct_atc
*atc
, unsigned char state
)
1033 return atc_daio_unmute(atc
, state
, SPDIFOO
);
1036 static int atc_spdif_in_unmute(struct ct_atc
*atc
, unsigned char state
)
1038 return atc_daio_unmute(atc
, state
, SPDIFIO
);
1041 static int atc_spdif_out_get_status(struct ct_atc
*atc
, unsigned int *status
)
1043 return atc_dao_get_status(atc
, status
, SPDIFOO
);
1046 static int atc_spdif_out_set_status(struct ct_atc
*atc
, unsigned int status
)
1048 return atc_dao_set_status(atc
, status
, SPDIFOO
);
1051 static int atc_spdif_out_passthru(struct ct_atc
*atc
, unsigned char state
)
1053 unsigned long flags
;
1054 struct dao_desc da_dsc
= {0};
1055 struct dao
*dao
= NULL
;
1057 struct ct_mixer
*mixer
= atc
->mixer
;
1058 struct rsc
*rscs
[2] = {NULL
};
1059 unsigned int spos
= 0;
1061 spin_lock_irqsave(&atc
->atc_lock
, flags
);
1062 dao
= container_of(atc
->daios
[SPDIFOO
], struct dao
, daio
);
1063 da_dsc
.msr
= state
? 1 : atc
->msr
;
1064 da_dsc
.passthru
= state
? 1 : 0;
1065 err
= dao
->ops
->reinit(dao
, &da_dsc
);
1067 spos
= IEC958_DEFAULT_CON
;
1069 mixer
->get_output_ports(mixer
, MIX_SPDIF_OUT
,
1070 &rscs
[0], &rscs
[1]);
1071 dao
->ops
->set_left_input(dao
, rscs
[0]);
1072 dao
->ops
->set_right_input(dao
, rscs
[1]);
1073 /* Restore PLL to atc->rsr if needed. */
1074 if (atc
->pll_rate
!= atc
->rsr
) {
1075 err
= ((struct hw
*)atc
->hw
)->pll_init(atc
->hw
,
1077 atc
->pll_rate
= err
? 0 : atc
->rsr
;
1080 dao
->ops
->set_spos(dao
, spos
);
1081 dao
->ops
->commit_write(dao
);
1082 spin_unlock_irqrestore(&atc
->atc_lock
, flags
);
1087 static int ct_atc_destroy(struct ct_atc
*atc
)
1089 struct daio_mgr
*daio_mgr
= NULL
;
1090 struct dao
*dao
= NULL
;
1091 struct dai
*dai
= NULL
;
1092 struct daio
*daio
= NULL
;
1093 struct sum_mgr
*sum_mgr
= NULL
;
1094 struct src_mgr
*src_mgr
= NULL
;
1095 struct srcimp_mgr
*srcimp_mgr
= NULL
;
1096 struct srcimp
*srcimp
= NULL
;
1097 struct ct_mixer
*mixer
= NULL
;
1103 /* Stop hardware and disable all interrupts */
1104 if (NULL
!= atc
->hw
)
1105 ((struct hw
*)atc
->hw
)->card_stop(atc
->hw
);
1107 /* Destroy internal mixer objects */
1108 if (NULL
!= atc
->mixer
) {
1110 mixer
->set_input_left(mixer
, MIX_LINE_IN
, NULL
);
1111 mixer
->set_input_right(mixer
, MIX_LINE_IN
, NULL
);
1112 mixer
->set_input_left(mixer
, MIX_MIC_IN
, NULL
);
1113 mixer
->set_input_right(mixer
, MIX_MIC_IN
, NULL
);
1114 mixer
->set_input_left(mixer
, MIX_SPDIF_IN
, NULL
);
1115 mixer
->set_input_right(mixer
, MIX_SPDIF_IN
, NULL
);
1116 ct_mixer_destroy(atc
->mixer
);
1119 if (NULL
!= atc
->daios
) {
1120 daio_mgr
= (struct daio_mgr
*)atc
->rsc_mgrs
[DAIO
];
1121 for (i
= 0; i
< atc
->n_daio
; i
++) {
1122 daio
= atc
->daios
[i
];
1123 if (daio
->type
< LINEIM
) {
1124 dao
= container_of(daio
, struct dao
, daio
);
1125 dao
->ops
->clear_left_input(dao
);
1126 dao
->ops
->clear_right_input(dao
);
1128 dai
= container_of(daio
, struct dai
, daio
);
1129 /* some thing to do for dai ... */
1131 daio_mgr
->put_daio(daio_mgr
, daio
);
1136 if (NULL
!= atc
->pcm
) {
1137 sum_mgr
= atc
->rsc_mgrs
[SUM
];
1138 for (i
= 0; i
< atc
->n_pcm
; i
++)
1139 sum_mgr
->put_sum(sum_mgr
, atc
->pcm
[i
]);
1144 if (NULL
!= atc
->srcs
) {
1145 src_mgr
= atc
->rsc_mgrs
[SRC
];
1146 for (i
= 0; i
< atc
->n_src
; i
++)
1147 src_mgr
->put_src(src_mgr
, atc
->srcs
[i
]);
1152 if (NULL
!= atc
->srcimps
) {
1153 srcimp_mgr
= atc
->rsc_mgrs
[SRCIMP
];
1154 for (i
= 0; i
< atc
->n_srcimp
; i
++) {
1155 srcimp
= atc
->srcimps
[i
];
1156 srcimp
->ops
->unmap(srcimp
);
1157 srcimp_mgr
->put_srcimp(srcimp_mgr
, atc
->srcimps
[i
]);
1159 kfree(atc
->srcimps
);
1162 for (i
= 0; i
< NUM_RSCTYP
; i
++) {
1163 if ((NULL
!= rsc_mgr_funcs
[i
].destroy
) &&
1164 (NULL
!= atc
->rsc_mgrs
[i
]))
1165 rsc_mgr_funcs
[i
].destroy(atc
->rsc_mgrs
[i
]);
1169 if (NULL
!= atc
->hw
)
1170 destroy_hw_obj((struct hw
*)atc
->hw
);
1172 /* Destroy device virtual memory manager object */
1173 if (NULL
!= atc
->vm
) {
1174 ct_vm_destroy(atc
->vm
);
1183 static int atc_dev_free(struct snd_device
*dev
)
1185 struct ct_atc
*atc
= dev
->device_data
;
1186 return ct_atc_destroy(atc
);
1189 static int atc_identify_card(struct ct_atc
*atc
)
1193 struct pci_dev
*pci
= atc
->pci
;
1194 const struct ct_atc_chip_details
*d
;
1197 subsys
= pci
->subsystem_device
;
1198 revision
= pci
->revision
;
1199 atc
->chip_details
= NULL
;
1200 atc
->model
= NUM_CTCARDS
;
1201 for (d
= atc_chip_details
; d
->vendor
; d
++) {
1202 if (d
->vendor
!= pci
->vendor
|| d
->device
!= pci
->device
)
1205 if (NULL
== d
->sub_details
) {
1206 atc
->chip_details
= d
;
1209 for (i
= 0; i
< NUM_CTCARDS
; i
++) {
1210 if ((d
->sub_details
[i
].subsys
== subsys
) ||
1211 (((subsys
& 0x6000) == 0x6000) &&
1212 ((d
->sub_details
[i
].subsys
& 0x6000) == 0x6000))) {
1217 if (i
>= NUM_CTCARDS
)
1220 atc
->chip_details
= d
;
1222 /* not take revision into consideration now */
1230 static int ct_create_alsa_devs(struct ct_atc
*atc
)
1233 struct hw
*hw
= atc
->hw
;
1236 switch (hw
->get_chip_type(hw
)) {
1238 alsa_dev_funcs
[MIXER
].public_name
= "20K1";
1241 alsa_dev_funcs
[MIXER
].public_name
= "20K2";
1244 alsa_dev_funcs
[MIXER
].public_name
= "Unknown";
1248 for (i
= 0; i
< NUM_CTALSADEVS
; i
++) {
1249 if (NULL
== alsa_dev_funcs
[i
].create
)
1252 err
= alsa_dev_funcs
[i
].create(atc
, i
,
1253 alsa_dev_funcs
[i
].public_name
);
1255 printk(KERN_ERR
"ctxfi: "
1256 "Creating alsa device %d failed!\n", i
);
1264 static int atc_create_hw_devs(struct ct_atc
*atc
)
1266 struct hw
*hw
= NULL
;
1267 struct card_conf info
= {0};
1270 err
= create_hw_obj(atc
->pci
, &hw
);
1272 printk(KERN_ERR
"Failed to create hw obj!!!\n");
1277 /* Initialize card hardware. */
1278 info
.rsr
= atc
->rsr
;
1279 info
.msr
= atc
->msr
;
1280 info
.vm_pgt_phys
= atc_get_ptp_phys(atc
, 0);
1281 err
= hw
->card_init(hw
, &info
);
1285 for (i
= 0; i
< NUM_RSCTYP
; i
++) {
1286 if (NULL
== rsc_mgr_funcs
[i
].create
)
1289 err
= rsc_mgr_funcs
[i
].create(atc
->hw
, &atc
->rsc_mgrs
[i
]);
1291 printk(KERN_ERR
"ctxfi: "
1292 "Failed to create rsc_mgr %d!!!\n", i
);
1300 static int atc_get_resources(struct ct_atc
*atc
)
1302 struct daio_desc da_desc
= {0};
1303 struct daio_mgr
*daio_mgr
= NULL
;
1304 struct src_desc src_dsc
= {0};
1305 struct src_mgr
*src_mgr
= NULL
;
1306 struct srcimp_desc srcimp_dsc
= {0};
1307 struct srcimp_mgr
*srcimp_mgr
= NULL
;
1308 struct sum_desc sum_dsc
= {0};
1309 struct sum_mgr
*sum_mgr
= NULL
;
1311 unsigned short subsys_id
;
1313 atc
->daios
= kzalloc(sizeof(void *)*(DAIONUM
), GFP_KERNEL
);
1314 if (NULL
== atc
->daios
)
1317 atc
->srcs
= kzalloc(sizeof(void *)*(2*2), GFP_KERNEL
);
1318 if (NULL
== atc
->srcs
)
1321 atc
->srcimps
= kzalloc(sizeof(void *)*(2*2), GFP_KERNEL
);
1322 if (NULL
== atc
->srcimps
)
1325 atc
->pcm
= kzalloc(sizeof(void *)*(2*4), GFP_KERNEL
);
1326 if (NULL
== atc
->pcm
)
1329 daio_mgr
= (struct daio_mgr
*)atc
->rsc_mgrs
[DAIO
];
1330 da_desc
.msr
= atc
->msr
;
1331 for (i
= 0, atc
->n_daio
= 0; i
< DAIONUM
-1; i
++) {
1333 err
= daio_mgr
->get_daio(daio_mgr
, &da_desc
,
1334 (struct daio
**)&atc
->daios
[i
]);
1336 printk(KERN_ERR
"ctxfi: Failed to get DAIO "
1337 "resource %d!!!\n", i
);
1342 subsys_id
= atc
->pci
->subsystem_device
;
1343 if ((subsys_id
== 0x0029) || (subsys_id
== 0x0031)) {
1345 da_desc
.type
= SPDIFI1
;
1347 da_desc
.type
= SPDIFIO
;
1349 err
= daio_mgr
->get_daio(daio_mgr
, &da_desc
,
1350 (struct daio
**)&atc
->daios
[i
]);
1352 printk(KERN_ERR
"ctxfi: Failed to get S/PDIF-in resource!!!\n");
1357 src_mgr
= atc
->rsc_mgrs
[SRC
];
1359 src_dsc
.msr
= atc
->msr
;
1360 src_dsc
.mode
= ARCRW
;
1361 for (i
= 0, atc
->n_src
= 0; i
< (2*2); i
++) {
1362 err
= src_mgr
->get_src(src_mgr
, &src_dsc
,
1363 (struct src
**)&atc
->srcs
[i
]);
1370 srcimp_mgr
= atc
->rsc_mgrs
[SRCIMP
];
1371 srcimp_dsc
.msr
= 8; /* SRCIMPs for S/PDIFIn SRT */
1372 for (i
= 0, atc
->n_srcimp
= 0; i
< (2*1); i
++) {
1373 err
= srcimp_mgr
->get_srcimp(srcimp_mgr
, &srcimp_dsc
,
1374 (struct srcimp
**)&atc
->srcimps
[i
]);
1380 srcimp_dsc
.msr
= 8; /* SRCIMPs for LINE/MICIn SRT */
1381 for (i
= 0; i
< (2*1); i
++) {
1382 err
= srcimp_mgr
->get_srcimp(srcimp_mgr
, &srcimp_dsc
,
1383 (struct srcimp
**)&atc
->srcimps
[2*1+i
]);
1390 sum_mgr
= atc
->rsc_mgrs
[SUM
];
1391 sum_dsc
.msr
= atc
->msr
;
1392 for (i
= 0, atc
->n_pcm
= 0; i
< (2*4); i
++) {
1393 err
= sum_mgr
->get_sum(sum_mgr
, &sum_dsc
,
1394 (struct sum
**)&atc
->pcm
[i
]);
1401 err
= ct_mixer_create(atc
, (struct ct_mixer
**)&atc
->mixer
);
1403 printk(KERN_ERR
"ctxfi: Failed to create mixer obj!!!\n");
1411 atc_connect_dai(struct src_mgr
*src_mgr
, struct dai
*dai
,
1412 struct src
**srcs
, struct srcimp
**srcimps
)
1414 struct rsc
*rscs
[2] = {NULL
};
1415 struct src
*src
= NULL
;
1416 struct srcimp
*srcimp
= NULL
;
1419 rscs
[0] = &dai
->daio
.rscl
;
1420 rscs
[1] = &dai
->daio
.rscr
;
1421 for (i
= 0; i
< 2; i
++) {
1423 srcimp
= srcimps
[i
];
1424 srcimp
->ops
->map(srcimp
, src
, rscs
[i
]);
1425 src_mgr
->src_disable(src_mgr
, src
);
1428 src_mgr
->commit_write(src_mgr
); /* Actually disable SRCs */
1431 src
->ops
->set_pm(src
, 1);
1432 for (i
= 0; i
< 2; i
++) {
1434 src
->ops
->set_state(src
, SRC_STATE_RUN
);
1435 src
->ops
->commit_write(src
);
1436 src_mgr
->src_enable_s(src_mgr
, src
);
1439 dai
->ops
->set_srt_srcl(dai
, &(srcs
[0]->rsc
));
1440 dai
->ops
->set_srt_srcr(dai
, &(srcs
[1]->rsc
));
1442 dai
->ops
->set_enb_src(dai
, 1);
1443 dai
->ops
->set_enb_srt(dai
, 1);
1444 dai
->ops
->commit_write(dai
);
1446 src_mgr
->commit_write(src_mgr
); /* Synchronously enable SRCs */
1449 static void atc_connect_resources(struct ct_atc
*atc
)
1451 struct dai
*dai
= NULL
;
1452 struct dao
*dao
= NULL
;
1453 struct src
*src
= NULL
;
1454 struct sum
*sum
= NULL
;
1455 struct ct_mixer
*mixer
= NULL
;
1456 struct rsc
*rscs
[2] = {NULL
};
1461 for (i
= MIX_WAVE_FRONT
, j
= LINEO1
; i
<= MIX_SPDIF_OUT
; i
++, j
++) {
1462 mixer
->get_output_ports(mixer
, i
, &rscs
[0], &rscs
[1]);
1463 dao
= container_of(atc
->daios
[j
], struct dao
, daio
);
1464 dao
->ops
->set_left_input(dao
, rscs
[0]);
1465 dao
->ops
->set_right_input(dao
, rscs
[1]);
1468 dai
= container_of(atc
->daios
[LINEIM
], struct dai
, daio
);
1469 atc_connect_dai(atc
->rsc_mgrs
[SRC
], dai
,
1470 (struct src
**)&atc
->srcs
[2],
1471 (struct srcimp
**)&atc
->srcimps
[2]);
1473 mixer
->set_input_left(mixer
, MIX_LINE_IN
, &src
->rsc
);
1475 mixer
->set_input_right(mixer
, MIX_LINE_IN
, &src
->rsc
);
1477 dai
= container_of(atc
->daios
[SPDIFIO
], struct dai
, daio
);
1478 atc_connect_dai(atc
->rsc_mgrs
[SRC
], dai
,
1479 (struct src
**)&atc
->srcs
[0],
1480 (struct srcimp
**)&atc
->srcimps
[0]);
1483 mixer
->set_input_left(mixer
, MIX_SPDIF_IN
, &src
->rsc
);
1485 mixer
->set_input_right(mixer
, MIX_SPDIF_IN
, &src
->rsc
);
1487 for (i
= MIX_PCMI_FRONT
, j
= 0; i
<= MIX_PCMI_SURROUND
; i
++, j
+= 2) {
1489 mixer
->set_input_left(mixer
, i
, &sum
->rsc
);
1490 sum
= atc
->pcm
[j
+1];
1491 mixer
->set_input_right(mixer
, i
, &sum
->rsc
);
1495 static void atc_set_ops(struct ct_atc
*atc
)
1497 /* Set operations */
1498 atc
->map_audio_buffer
= ct_map_audio_buffer
;
1499 atc
->unmap_audio_buffer
= ct_unmap_audio_buffer
;
1500 atc
->pcm_playback_prepare
= atc_pcm_playback_prepare
;
1501 atc
->pcm_release_resources
= atc_pcm_release_resources
;
1502 atc
->pcm_playback_start
= atc_pcm_playback_start
;
1503 atc
->pcm_playback_stop
= atc_pcm_stop
;
1504 atc
->pcm_playback_position
= atc_pcm_playback_position
;
1505 atc
->pcm_capture_prepare
= atc_pcm_capture_prepare
;
1506 atc
->pcm_capture_start
= atc_pcm_capture_start
;
1507 atc
->pcm_capture_stop
= atc_pcm_stop
;
1508 atc
->pcm_capture_position
= atc_pcm_capture_position
;
1509 atc
->spdif_passthru_playback_prepare
= spdif_passthru_playback_prepare
;
1510 atc
->get_ptp_phys
= atc_get_ptp_phys
;
1511 atc
->select_line_in
= atc_select_line_in
;
1512 atc
->select_mic_in
= atc_select_mic_in
;
1513 atc
->select_digit_io
= atc_select_digit_io
;
1514 atc
->line_front_unmute
= atc_line_front_unmute
;
1515 atc
->line_surround_unmute
= atc_line_surround_unmute
;
1516 atc
->line_clfe_unmute
= atc_line_clfe_unmute
;
1517 atc
->line_rear_unmute
= atc_line_rear_unmute
;
1518 atc
->line_in_unmute
= atc_line_in_unmute
;
1519 atc
->spdif_out_unmute
= atc_spdif_out_unmute
;
1520 atc
->spdif_in_unmute
= atc_spdif_in_unmute
;
1521 atc
->spdif_out_get_status
= atc_spdif_out_get_status
;
1522 atc
->spdif_out_set_status
= atc_spdif_out_set_status
;
1523 atc
->spdif_out_passthru
= atc_spdif_out_passthru
;
1524 atc
->have_digit_io_switch
= atc_have_digit_io_switch
;
1528 * ct_atc_create - create and initialize a hardware manager
1529 * @card: corresponding alsa card object
1530 * @pci: corresponding kernel pci device object
1531 * @ratc: return created object address in it
1533 * Creates and initializes a hardware manager.
1535 * Creates kmallocated ct_atc structure. Initializes hardware.
1536 * Returns 0 if suceeds, or negative error code if fails.
1539 int ct_atc_create(struct snd_card
*card
, struct pci_dev
*pci
,
1540 unsigned int rsr
, unsigned int msr
, struct ct_atc
**ratc
)
1542 struct ct_atc
*atc
= NULL
;
1543 static struct snd_device_ops ops
= {
1544 .dev_free
= atc_dev_free
,
1550 atc
= kzalloc(sizeof(*atc
), GFP_KERNEL
);
1559 /* Set operations */
1562 spin_lock_init(&atc
->atc_lock
);
1564 /* Find card model */
1565 err
= atc_identify_card(atc
);
1567 printk(KERN_ERR
"ctatc: Card not recognised\n");
1571 /* Set up device virtual memory management object */
1572 err
= ct_vm_create(&atc
->vm
);
1576 /* Create all atc hw devices */
1577 err
= atc_create_hw_devs(atc
);
1582 err
= atc_get_resources(atc
);
1586 /* Build topology */
1587 atc_connect_resources(atc
);
1589 atc
->create_alsa_devs
= ct_create_alsa_devs
;
1591 err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, atc
, &ops
);
1595 snd_card_set_dev(card
, &pci
->dev
);
1601 ct_atc_destroy(atc
);
1602 printk(KERN_ERR
"ctxfi: Something wrong!!!\n");