Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved.
0004  *
0005  * @File    ctatc.c
0006  *
0007  * @Brief
0008  * This file contains the implementation of the device resource management
0009  * object.
0010  *
0011  * @Author Liu Chun
0012  * @Date Mar 28 2008
0013  */
0014 
0015 #include "ctatc.h"
0016 #include "ctpcm.h"
0017 #include "ctmixer.h"
0018 #include "ctsrc.h"
0019 #include "ctamixer.h"
0020 #include "ctdaio.h"
0021 #include "cttimer.h"
0022 #include <linux/delay.h>
0023 #include <linux/slab.h>
0024 #include <sound/pcm.h>
0025 #include <sound/control.h>
0026 #include <sound/asoundef.h>
0027 
0028 #define MONO_SUM_SCALE  0x19a8  /* 2^(-0.5) in 14-bit floating format */
0029 #define MAX_MULTI_CHN   8
0030 
0031 #define IEC958_DEFAULT_CON ((IEC958_AES0_NONAUDIO \
0032                 | IEC958_AES0_CON_NOT_COPYRIGHT) \
0033                 | ((IEC958_AES1_CON_MIXER \
0034                 | IEC958_AES1_CON_ORIGINAL) << 8) \
0035                 | (0x10 << 16) \
0036                 | ((IEC958_AES3_CON_FS_48000) << 24))
0037 
0038 static const struct snd_pci_quirk subsys_20k1_list[] = {
0039     SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, 0x0021, "SB046x", CTSB046X),
0040     SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, 0x0022, "SB055x", CTSB055X),
0041     SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, 0x002f, "SB055x", CTSB055X),
0042     SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, 0x0029, "SB073x", CTSB073X),
0043     SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, 0x0031, "SB073x", CTSB073X),
0044     SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_CREATIVE, 0xf000, 0x6000,
0045                "UAA", CTUAA),
0046     { } /* terminator */
0047 };
0048 
0049 static const struct snd_pci_quirk subsys_20k2_list[] = {
0050     SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, PCI_SUBDEVICE_ID_CREATIVE_SB0760,
0051               "SB0760", CTSB0760),
0052     SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, PCI_SUBDEVICE_ID_CREATIVE_SB1270,
0053               "SB1270", CTSB1270),
0054     SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, PCI_SUBDEVICE_ID_CREATIVE_SB08801,
0055               "SB0880", CTSB0880),
0056     SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, PCI_SUBDEVICE_ID_CREATIVE_SB08802,
0057               "SB0880", CTSB0880),
0058     SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, PCI_SUBDEVICE_ID_CREATIVE_SB08803,
0059               "SB0880", CTSB0880),
0060     SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_CREATIVE, 0xf000,
0061                PCI_SUBDEVICE_ID_CREATIVE_HENDRIX, "HENDRIX",
0062                CTHENDRIX),
0063     { } /* terminator */
0064 };
0065 
0066 static const char *ct_subsys_name[NUM_CTCARDS] = {
0067     /* 20k1 models */
0068     [CTSB046X]  = "SB046x",
0069     [CTSB055X]  = "SB055x",
0070     [CTSB073X]  = "SB073x",
0071     [CTUAA]     = "UAA",
0072     [CT20K1_UNKNOWN] = "Unknown",
0073     /* 20k2 models */
0074     [CTSB0760]  = "SB076x",
0075     [CTHENDRIX] = "Hendrix",
0076     [CTSB0880]  = "SB0880",
0077     [CTSB1270]      = "SB1270",
0078     [CT20K2_UNKNOWN] = "Unknown",
0079 };
0080 
0081 static struct {
0082     int (*create)(struct ct_atc *atc,
0083             enum CTALSADEVS device, const char *device_name);
0084     int (*destroy)(void *alsa_dev);
0085     const char *public_name;
0086 } alsa_dev_funcs[NUM_CTALSADEVS] = {
0087     [FRONT]     = { .create = ct_alsa_pcm_create,
0088                 .destroy = NULL,
0089                 .public_name = "Front/WaveIn"},
0090     [SURROUND]  = { .create = ct_alsa_pcm_create,
0091                 .destroy = NULL,
0092                 .public_name = "Surround"},
0093     [CLFE]      = { .create = ct_alsa_pcm_create,
0094                 .destroy = NULL,
0095                 .public_name = "Center/LFE"},
0096     [SIDE]      = { .create = ct_alsa_pcm_create,
0097                 .destroy = NULL,
0098                 .public_name = "Side"},
0099     [IEC958]    = { .create = ct_alsa_pcm_create,
0100                 .destroy = NULL,
0101                 .public_name = "IEC958 Non-audio"},
0102 
0103     [MIXER]     = { .create = ct_alsa_mix_create,
0104                 .destroy = NULL,
0105                 .public_name = "Mixer"}
0106 };
0107 
0108 typedef int (*create_t)(struct hw *, void **);
0109 typedef int (*destroy_t)(void *);
0110 
0111 static struct {
0112     int (*create)(struct hw *hw, void **rmgr);
0113     int (*destroy)(void *mgr);
0114 } rsc_mgr_funcs[NUM_RSCTYP] = {
0115     [SRC]       = { .create     = (create_t)src_mgr_create,
0116                 .destroy    = (destroy_t)src_mgr_destroy    },
0117     [SRCIMP]    = { .create     = (create_t)srcimp_mgr_create,
0118                 .destroy    = (destroy_t)srcimp_mgr_destroy },
0119     [AMIXER]    = { .create = (create_t)amixer_mgr_create,
0120                 .destroy    = (destroy_t)amixer_mgr_destroy },
0121     [SUM]       = { .create = (create_t)sum_mgr_create,
0122                 .destroy    = (destroy_t)sum_mgr_destroy    },
0123     [DAIO]      = { .create = (create_t)daio_mgr_create,
0124                 .destroy    = (destroy_t)daio_mgr_destroy   }
0125 };
0126 
0127 static int
0128 atc_pcm_release_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm);
0129 
0130 /* *
0131  * Only mono and interleaved modes are supported now.
0132  * Always allocates a contiguous channel block.
0133  * */
0134 
0135 static int ct_map_audio_buffer(struct ct_atc *atc, struct ct_atc_pcm *apcm)
0136 {
0137     struct snd_pcm_runtime *runtime;
0138     struct ct_vm *vm;
0139 
0140     if (!apcm->substream)
0141         return 0;
0142 
0143     runtime = apcm->substream->runtime;
0144     vm = atc->vm;
0145 
0146     apcm->vm_block = vm->map(vm, apcm->substream, runtime->dma_bytes);
0147 
0148     if (!apcm->vm_block)
0149         return -ENOENT;
0150 
0151     return 0;
0152 }
0153 
0154 static void ct_unmap_audio_buffer(struct ct_atc *atc, struct ct_atc_pcm *apcm)
0155 {
0156     struct ct_vm *vm;
0157 
0158     if (!apcm->vm_block)
0159         return;
0160 
0161     vm = atc->vm;
0162 
0163     vm->unmap(vm, apcm->vm_block);
0164 
0165     apcm->vm_block = NULL;
0166 }
0167 
0168 static unsigned long atc_get_ptp_phys(struct ct_atc *atc, int index)
0169 {
0170     return atc->vm->get_ptp_phys(atc->vm, index);
0171 }
0172 
0173 static unsigned int convert_format(snd_pcm_format_t snd_format,
0174                    struct snd_card *card)
0175 {
0176     switch (snd_format) {
0177     case SNDRV_PCM_FORMAT_U8:
0178         return SRC_SF_U8;
0179     case SNDRV_PCM_FORMAT_S16_LE:
0180         return SRC_SF_S16;
0181     case SNDRV_PCM_FORMAT_S24_3LE:
0182         return SRC_SF_S24;
0183     case SNDRV_PCM_FORMAT_S32_LE:
0184         return SRC_SF_S32;
0185     case SNDRV_PCM_FORMAT_FLOAT_LE:
0186         return SRC_SF_F32;
0187     default:
0188         dev_err(card->dev, "not recognized snd format is %d\n",
0189             snd_format);
0190         return SRC_SF_S16;
0191     }
0192 }
0193 
0194 static unsigned int
0195 atc_get_pitch(unsigned int input_rate, unsigned int output_rate)
0196 {
0197     unsigned int pitch;
0198     int b;
0199 
0200     /* get pitch and convert to fixed-point 8.24 format. */
0201     pitch = (input_rate / output_rate) << 24;
0202     input_rate %= output_rate;
0203     input_rate /= 100;
0204     output_rate /= 100;
0205     for (b = 31; ((b >= 0) && !(input_rate >> b)); )
0206         b--;
0207 
0208     if (b >= 0) {
0209         input_rate <<= (31 - b);
0210         input_rate /= output_rate;
0211         b = 24 - (31 - b);
0212         if (b >= 0)
0213             input_rate <<= b;
0214         else
0215             input_rate >>= -b;
0216 
0217         pitch |= input_rate;
0218     }
0219 
0220     return pitch;
0221 }
0222 
0223 static int select_rom(unsigned int pitch)
0224 {
0225     if (pitch > 0x00428f5c && pitch < 0x01b851ec) {
0226         /* 0.26 <= pitch <= 1.72 */
0227         return 1;
0228     } else if (pitch == 0x01d66666 || pitch == 0x01d66667) {
0229         /* pitch == 1.8375 */
0230         return 2;
0231     } else if (pitch == 0x02000000) {
0232         /* pitch == 2 */
0233         return 3;
0234     } else if (pitch <= 0x08000000) {
0235         /* 0 <= pitch <= 8 */
0236         return 0;
0237     } else {
0238         return -ENOENT;
0239     }
0240 }
0241 
0242 static int atc_pcm_playback_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm)
0243 {
0244     struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
0245     struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER];
0246     struct src_desc desc = {0};
0247     struct amixer_desc mix_dsc = {0};
0248     struct src *src;
0249     struct amixer *amixer;
0250     int err;
0251     int n_amixer = apcm->substream->runtime->channels, i = 0;
0252     int device = apcm->substream->pcm->device;
0253     unsigned int pitch;
0254 
0255     /* first release old resources */
0256     atc_pcm_release_resources(atc, apcm);
0257 
0258     /* Get SRC resource */
0259     desc.multi = apcm->substream->runtime->channels;
0260     desc.msr = atc->msr;
0261     desc.mode = MEMRD;
0262     err = src_mgr->get_src(src_mgr, &desc, (struct src **)&apcm->src);
0263     if (err)
0264         goto error1;
0265 
0266     pitch = atc_get_pitch(apcm->substream->runtime->rate,
0267                         (atc->rsr * atc->msr));
0268     src = apcm->src;
0269     src->ops->set_pitch(src, pitch);
0270     src->ops->set_rom(src, select_rom(pitch));
0271     src->ops->set_sf(src, convert_format(apcm->substream->runtime->format,
0272                          atc->card));
0273     src->ops->set_pm(src, (src->ops->next_interleave(src) != NULL));
0274 
0275     /* Get AMIXER resource */
0276     n_amixer = (n_amixer < 2) ? 2 : n_amixer;
0277     apcm->amixers = kcalloc(n_amixer, sizeof(void *), GFP_KERNEL);
0278     if (!apcm->amixers) {
0279         err = -ENOMEM;
0280         goto error1;
0281     }
0282     mix_dsc.msr = atc->msr;
0283     for (i = 0, apcm->n_amixer = 0; i < n_amixer; i++) {
0284         err = amixer_mgr->get_amixer(amixer_mgr, &mix_dsc,
0285                     (struct amixer **)&apcm->amixers[i]);
0286         if (err)
0287             goto error1;
0288 
0289         apcm->n_amixer++;
0290     }
0291 
0292     /* Set up device virtual mem map */
0293     err = ct_map_audio_buffer(atc, apcm);
0294     if (err < 0)
0295         goto error1;
0296 
0297     /* Connect resources */
0298     src = apcm->src;
0299     for (i = 0; i < n_amixer; i++) {
0300         amixer = apcm->amixers[i];
0301         mutex_lock(&atc->atc_mutex);
0302         amixer->ops->setup(amixer, &src->rsc,
0303                     INIT_VOL, atc->pcm[i+device*2]);
0304         mutex_unlock(&atc->atc_mutex);
0305         src = src->ops->next_interleave(src);
0306         if (!src)
0307             src = apcm->src;
0308     }
0309 
0310     ct_timer_prepare(apcm->timer);
0311 
0312     return 0;
0313 
0314 error1:
0315     atc_pcm_release_resources(atc, apcm);
0316     return err;
0317 }
0318 
0319 static int
0320 atc_pcm_release_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm)
0321 {
0322     struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
0323     struct srcimp_mgr *srcimp_mgr = atc->rsc_mgrs[SRCIMP];
0324     struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER];
0325     struct sum_mgr *sum_mgr = atc->rsc_mgrs[SUM];
0326     struct srcimp *srcimp;
0327     int i;
0328 
0329     if (apcm->srcimps) {
0330         for (i = 0; i < apcm->n_srcimp; i++) {
0331             srcimp = apcm->srcimps[i];
0332             srcimp->ops->unmap(srcimp);
0333             srcimp_mgr->put_srcimp(srcimp_mgr, srcimp);
0334             apcm->srcimps[i] = NULL;
0335         }
0336         kfree(apcm->srcimps);
0337         apcm->srcimps = NULL;
0338     }
0339 
0340     if (apcm->srccs) {
0341         for (i = 0; i < apcm->n_srcc; i++) {
0342             src_mgr->put_src(src_mgr, apcm->srccs[i]);
0343             apcm->srccs[i] = NULL;
0344         }
0345         kfree(apcm->srccs);
0346         apcm->srccs = NULL;
0347     }
0348 
0349     if (apcm->amixers) {
0350         for (i = 0; i < apcm->n_amixer; i++) {
0351             amixer_mgr->put_amixer(amixer_mgr, apcm->amixers[i]);
0352             apcm->amixers[i] = NULL;
0353         }
0354         kfree(apcm->amixers);
0355         apcm->amixers = NULL;
0356     }
0357 
0358     if (apcm->mono) {
0359         sum_mgr->put_sum(sum_mgr, apcm->mono);
0360         apcm->mono = NULL;
0361     }
0362 
0363     if (apcm->src) {
0364         src_mgr->put_src(src_mgr, apcm->src);
0365         apcm->src = NULL;
0366     }
0367 
0368     if (apcm->vm_block) {
0369         /* Undo device virtual mem map */
0370         ct_unmap_audio_buffer(atc, apcm);
0371         apcm->vm_block = NULL;
0372     }
0373 
0374     return 0;
0375 }
0376 
0377 static int atc_pcm_playback_start(struct ct_atc *atc, struct ct_atc_pcm *apcm)
0378 {
0379     unsigned int max_cisz;
0380     struct src *src = apcm->src;
0381 
0382     if (apcm->started)
0383         return 0;
0384     apcm->started = 1;
0385 
0386     max_cisz = src->multi * src->rsc.msr;
0387     max_cisz = 0x80 * (max_cisz < 8 ? max_cisz : 8);
0388 
0389     src->ops->set_sa(src, apcm->vm_block->addr);
0390     src->ops->set_la(src, apcm->vm_block->addr + apcm->vm_block->size);
0391     src->ops->set_ca(src, apcm->vm_block->addr + max_cisz);
0392     src->ops->set_cisz(src, max_cisz);
0393 
0394     src->ops->set_bm(src, 1);
0395     src->ops->set_state(src, SRC_STATE_INIT);
0396     src->ops->commit_write(src);
0397 
0398     ct_timer_start(apcm->timer);
0399     return 0;
0400 }
0401 
0402 static int atc_pcm_stop(struct ct_atc *atc, struct ct_atc_pcm *apcm)
0403 {
0404     struct src *src;
0405     int i;
0406 
0407     ct_timer_stop(apcm->timer);
0408 
0409     src = apcm->src;
0410     src->ops->set_bm(src, 0);
0411     src->ops->set_state(src, SRC_STATE_OFF);
0412     src->ops->commit_write(src);
0413 
0414     if (apcm->srccs) {
0415         for (i = 0; i < apcm->n_srcc; i++) {
0416             src = apcm->srccs[i];
0417             src->ops->set_bm(src, 0);
0418             src->ops->set_state(src, SRC_STATE_OFF);
0419             src->ops->commit_write(src);
0420         }
0421     }
0422 
0423     apcm->started = 0;
0424 
0425     return 0;
0426 }
0427 
0428 static int
0429 atc_pcm_playback_position(struct ct_atc *atc, struct ct_atc_pcm *apcm)
0430 {
0431     struct src *src = apcm->src;
0432     u32 size, max_cisz;
0433     int position;
0434 
0435     if (!src)
0436         return 0;
0437     position = src->ops->get_ca(src);
0438 
0439     if (position < apcm->vm_block->addr) {
0440         dev_dbg(atc->card->dev,
0441             "bad ca - ca=0x%08x, vba=0x%08x, vbs=0x%08x\n",
0442             position, apcm->vm_block->addr, apcm->vm_block->size);
0443         position = apcm->vm_block->addr;
0444     }
0445 
0446     size = apcm->vm_block->size;
0447     max_cisz = src->multi * src->rsc.msr;
0448     max_cisz = 128 * (max_cisz < 8 ? max_cisz : 8);
0449 
0450     return (position + size - max_cisz - apcm->vm_block->addr) % size;
0451 }
0452 
0453 struct src_node_conf_t {
0454     unsigned int pitch;
0455     unsigned int msr:8;
0456     unsigned int mix_msr:8;
0457     unsigned int imp_msr:8;
0458     unsigned int vo:1;
0459 };
0460 
0461 static void setup_src_node_conf(struct ct_atc *atc, struct ct_atc_pcm *apcm,
0462                 struct src_node_conf_t *conf, int *n_srcc)
0463 {
0464     unsigned int pitch;
0465 
0466     /* get pitch and convert to fixed-point 8.24 format. */
0467     pitch = atc_get_pitch((atc->rsr * atc->msr),
0468                 apcm->substream->runtime->rate);
0469     *n_srcc = 0;
0470 
0471     if (1 == atc->msr) { /* FIXME: do we really need SRC here if pitch==1 */
0472         *n_srcc = apcm->substream->runtime->channels;
0473         conf[0].pitch = pitch;
0474         conf[0].mix_msr = conf[0].imp_msr = conf[0].msr = 1;
0475         conf[0].vo = 1;
0476     } else if (2 <= atc->msr) {
0477         if (0x8000000 < pitch) {
0478             /* Need two-stage SRCs, SRCIMPs and
0479              * AMIXERs for converting format */
0480             conf[0].pitch = (atc->msr << 24);
0481             conf[0].msr = conf[0].mix_msr = 1;
0482             conf[0].imp_msr = atc->msr;
0483             conf[0].vo = 0;
0484             conf[1].pitch = atc_get_pitch(atc->rsr,
0485                     apcm->substream->runtime->rate);
0486             conf[1].msr = conf[1].mix_msr = conf[1].imp_msr = 1;
0487             conf[1].vo = 1;
0488             *n_srcc = apcm->substream->runtime->channels * 2;
0489         } else if (0x1000000 < pitch) {
0490             /* Need one-stage SRCs, SRCIMPs and
0491              * AMIXERs for converting format */
0492             conf[0].pitch = pitch;
0493             conf[0].msr = conf[0].mix_msr
0494                     = conf[0].imp_msr = atc->msr;
0495             conf[0].vo = 1;
0496             *n_srcc = apcm->substream->runtime->channels;
0497         }
0498     }
0499 }
0500 
0501 static int
0502 atc_pcm_capture_get_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm)
0503 {
0504     struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
0505     struct srcimp_mgr *srcimp_mgr = atc->rsc_mgrs[SRCIMP];
0506     struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER];
0507     struct sum_mgr *sum_mgr = atc->rsc_mgrs[SUM];
0508     struct src_desc src_dsc = {0};
0509     struct src *src;
0510     struct srcimp_desc srcimp_dsc = {0};
0511     struct srcimp *srcimp;
0512     struct amixer_desc mix_dsc = {0};
0513     struct sum_desc sum_dsc = {0};
0514     unsigned int pitch;
0515     int multi, err, i;
0516     int n_srcimp, n_amixer, n_srcc, n_sum;
0517     struct src_node_conf_t src_node_conf[2] = {{0} };
0518 
0519     /* first release old resources */
0520     atc_pcm_release_resources(atc, apcm);
0521 
0522     /* The numbers of converting SRCs and SRCIMPs should be determined
0523      * by pitch value. */
0524 
0525     multi = apcm->substream->runtime->channels;
0526 
0527     /* get pitch and convert to fixed-point 8.24 format. */
0528     pitch = atc_get_pitch((atc->rsr * atc->msr),
0529                 apcm->substream->runtime->rate);
0530 
0531     setup_src_node_conf(atc, apcm, src_node_conf, &n_srcc);
0532     n_sum = (1 == multi) ? 1 : 0;
0533     n_amixer = n_sum * 2 + n_srcc;
0534     n_srcimp = n_srcc;
0535     if ((multi > 1) && (0x8000000 >= pitch)) {
0536         /* Need extra AMIXERs and SRCIMPs for special treatment
0537          * of interleaved recording of conjugate channels */
0538         n_amixer += multi * atc->msr;
0539         n_srcimp += multi * atc->msr;
0540     } else {
0541         n_srcimp += multi;
0542     }
0543 
0544     if (n_srcc) {
0545         apcm->srccs = kcalloc(n_srcc, sizeof(void *), GFP_KERNEL);
0546         if (!apcm->srccs)
0547             return -ENOMEM;
0548     }
0549     if (n_amixer) {
0550         apcm->amixers = kcalloc(n_amixer, sizeof(void *), GFP_KERNEL);
0551         if (!apcm->amixers) {
0552             err = -ENOMEM;
0553             goto error1;
0554         }
0555     }
0556     apcm->srcimps = kcalloc(n_srcimp, sizeof(void *), GFP_KERNEL);
0557     if (!apcm->srcimps) {
0558         err = -ENOMEM;
0559         goto error1;
0560     }
0561 
0562     /* Allocate SRCs for sample rate conversion if needed */
0563     src_dsc.multi = 1;
0564     src_dsc.mode = ARCRW;
0565     for (i = 0, apcm->n_srcc = 0; i < n_srcc; i++) {
0566         src_dsc.msr = src_node_conf[i/multi].msr;
0567         err = src_mgr->get_src(src_mgr, &src_dsc,
0568                     (struct src **)&apcm->srccs[i]);
0569         if (err)
0570             goto error1;
0571 
0572         src = apcm->srccs[i];
0573         pitch = src_node_conf[i/multi].pitch;
0574         src->ops->set_pitch(src, pitch);
0575         src->ops->set_rom(src, select_rom(pitch));
0576         src->ops->set_vo(src, src_node_conf[i/multi].vo);
0577 
0578         apcm->n_srcc++;
0579     }
0580 
0581     /* Allocate AMIXERs for routing SRCs of conversion if needed */
0582     for (i = 0, apcm->n_amixer = 0; i < n_amixer; i++) {
0583         if (i < (n_sum*2))
0584             mix_dsc.msr = atc->msr;
0585         else if (i < (n_sum*2+n_srcc))
0586             mix_dsc.msr = src_node_conf[(i-n_sum*2)/multi].mix_msr;
0587         else
0588             mix_dsc.msr = 1;
0589 
0590         err = amixer_mgr->get_amixer(amixer_mgr, &mix_dsc,
0591                     (struct amixer **)&apcm->amixers[i]);
0592         if (err)
0593             goto error1;
0594 
0595         apcm->n_amixer++;
0596     }
0597 
0598     /* Allocate a SUM resource to mix all input channels together */
0599     sum_dsc.msr = atc->msr;
0600     err = sum_mgr->get_sum(sum_mgr, &sum_dsc, (struct sum **)&apcm->mono);
0601     if (err)
0602         goto error1;
0603 
0604     pitch = atc_get_pitch((atc->rsr * atc->msr),
0605                 apcm->substream->runtime->rate);
0606     /* Allocate SRCIMP resources */
0607     for (i = 0, apcm->n_srcimp = 0; i < n_srcimp; i++) {
0608         if (i < (n_srcc))
0609             srcimp_dsc.msr = src_node_conf[i/multi].imp_msr;
0610         else if (1 == multi)
0611             srcimp_dsc.msr = (pitch <= 0x8000000) ? atc->msr : 1;
0612         else
0613             srcimp_dsc.msr = 1;
0614 
0615         err = srcimp_mgr->get_srcimp(srcimp_mgr, &srcimp_dsc, &srcimp);
0616         if (err)
0617             goto error1;
0618 
0619         apcm->srcimps[i] = srcimp;
0620         apcm->n_srcimp++;
0621     }
0622 
0623     /* Allocate a SRC for writing data to host memory */
0624     src_dsc.multi = apcm->substream->runtime->channels;
0625     src_dsc.msr = 1;
0626     src_dsc.mode = MEMWR;
0627     err = src_mgr->get_src(src_mgr, &src_dsc, (struct src **)&apcm->src);
0628     if (err)
0629         goto error1;
0630 
0631     src = apcm->src;
0632     src->ops->set_pitch(src, pitch);
0633 
0634     /* Set up device virtual mem map */
0635     err = ct_map_audio_buffer(atc, apcm);
0636     if (err < 0)
0637         goto error1;
0638 
0639     return 0;
0640 
0641 error1:
0642     atc_pcm_release_resources(atc, apcm);
0643     return err;
0644 }
0645 
0646 static int atc_pcm_capture_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm)
0647 {
0648     struct src *src;
0649     struct amixer *amixer;
0650     struct srcimp *srcimp;
0651     struct ct_mixer *mixer = atc->mixer;
0652     struct sum *mono;
0653     struct rsc *out_ports[8] = {NULL};
0654     int err, i, j, n_sum, multi;
0655     unsigned int pitch;
0656     int mix_base = 0, imp_base = 0;
0657 
0658     atc_pcm_release_resources(atc, apcm);
0659 
0660     /* Get needed resources. */
0661     err = atc_pcm_capture_get_resources(atc, apcm);
0662     if (err)
0663         return err;
0664 
0665     /* Connect resources */
0666     mixer->get_output_ports(mixer, MIX_PCMO_FRONT,
0667                 &out_ports[0], &out_ports[1]);
0668 
0669     multi = apcm->substream->runtime->channels;
0670     if (1 == multi) {
0671         mono = apcm->mono;
0672         for (i = 0; i < 2; i++) {
0673             amixer = apcm->amixers[i];
0674             amixer->ops->setup(amixer, out_ports[i],
0675                         MONO_SUM_SCALE, mono);
0676         }
0677         out_ports[0] = &mono->rsc;
0678         n_sum = 1;
0679         mix_base = n_sum * 2;
0680     }
0681 
0682     for (i = 0; i < apcm->n_srcc; i++) {
0683         src = apcm->srccs[i];
0684         srcimp = apcm->srcimps[imp_base+i];
0685         amixer = apcm->amixers[mix_base+i];
0686         srcimp->ops->map(srcimp, src, out_ports[i%multi]);
0687         amixer->ops->setup(amixer, &src->rsc, INIT_VOL, NULL);
0688         out_ports[i%multi] = &amixer->rsc;
0689     }
0690 
0691     pitch = atc_get_pitch((atc->rsr * atc->msr),
0692                 apcm->substream->runtime->rate);
0693 
0694     if ((multi > 1) && (pitch <= 0x8000000)) {
0695         /* Special connection for interleaved
0696          * recording with conjugate channels */
0697         for (i = 0; i < multi; i++) {
0698             out_ports[i]->ops->master(out_ports[i]);
0699             for (j = 0; j < atc->msr; j++) {
0700                 amixer = apcm->amixers[apcm->n_srcc+j*multi+i];
0701                 amixer->ops->set_input(amixer, out_ports[i]);
0702                 amixer->ops->set_scale(amixer, INIT_VOL);
0703                 amixer->ops->set_sum(amixer, NULL);
0704                 amixer->ops->commit_raw_write(amixer);
0705                 out_ports[i]->ops->next_conj(out_ports[i]);
0706 
0707                 srcimp = apcm->srcimps[apcm->n_srcc+j*multi+i];
0708                 srcimp->ops->map(srcimp, apcm->src,
0709                             &amixer->rsc);
0710             }
0711         }
0712     } else {
0713         for (i = 0; i < multi; i++) {
0714             srcimp = apcm->srcimps[apcm->n_srcc+i];
0715             srcimp->ops->map(srcimp, apcm->src, out_ports[i]);
0716         }
0717     }
0718 
0719     ct_timer_prepare(apcm->timer);
0720 
0721     return 0;
0722 }
0723 
0724 static int atc_pcm_capture_start(struct ct_atc *atc, struct ct_atc_pcm *apcm)
0725 {
0726     struct src *src;
0727     struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
0728     int i, multi;
0729 
0730     if (apcm->started)
0731         return 0;
0732 
0733     apcm->started = 1;
0734     multi = apcm->substream->runtime->channels;
0735     /* Set up converting SRCs */
0736     for (i = 0; i < apcm->n_srcc; i++) {
0737         src = apcm->srccs[i];
0738         src->ops->set_pm(src, ((i%multi) != (multi-1)));
0739         src_mgr->src_disable(src_mgr, src);
0740     }
0741 
0742     /*  Set up recording SRC */
0743     src = apcm->src;
0744     src->ops->set_sf(src, convert_format(apcm->substream->runtime->format,
0745                          atc->card));
0746     src->ops->set_sa(src, apcm->vm_block->addr);
0747     src->ops->set_la(src, apcm->vm_block->addr + apcm->vm_block->size);
0748     src->ops->set_ca(src, apcm->vm_block->addr);
0749     src_mgr->src_disable(src_mgr, src);
0750 
0751     /* Disable relevant SRCs firstly */
0752     src_mgr->commit_write(src_mgr);
0753 
0754     /* Enable SRCs respectively */
0755     for (i = 0; i < apcm->n_srcc; i++) {
0756         src = apcm->srccs[i];
0757         src->ops->set_state(src, SRC_STATE_RUN);
0758         src->ops->commit_write(src);
0759         src_mgr->src_enable_s(src_mgr, src);
0760     }
0761     src = apcm->src;
0762     src->ops->set_bm(src, 1);
0763     src->ops->set_state(src, SRC_STATE_RUN);
0764     src->ops->commit_write(src);
0765     src_mgr->src_enable_s(src_mgr, src);
0766 
0767     /* Enable relevant SRCs synchronously */
0768     src_mgr->commit_write(src_mgr);
0769 
0770     ct_timer_start(apcm->timer);
0771     return 0;
0772 }
0773 
0774 static int
0775 atc_pcm_capture_position(struct ct_atc *atc, struct ct_atc_pcm *apcm)
0776 {
0777     struct src *src = apcm->src;
0778 
0779     if (!src)
0780         return 0;
0781     return src->ops->get_ca(src) - apcm->vm_block->addr;
0782 }
0783 
0784 static int spdif_passthru_playback_get_resources(struct ct_atc *atc,
0785                          struct ct_atc_pcm *apcm)
0786 {
0787     struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
0788     struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER];
0789     struct src_desc desc = {0};
0790     struct amixer_desc mix_dsc = {0};
0791     struct src *src;
0792     int err;
0793     int n_amixer = apcm->substream->runtime->channels, i;
0794     unsigned int pitch, rsr = atc->pll_rate;
0795 
0796     /* first release old resources */
0797     atc_pcm_release_resources(atc, apcm);
0798 
0799     /* Get SRC resource */
0800     desc.multi = apcm->substream->runtime->channels;
0801     desc.msr = 1;
0802     while (apcm->substream->runtime->rate > (rsr * desc.msr))
0803         desc.msr <<= 1;
0804 
0805     desc.mode = MEMRD;
0806     err = src_mgr->get_src(src_mgr, &desc, (struct src **)&apcm->src);
0807     if (err)
0808         goto error1;
0809 
0810     pitch = atc_get_pitch(apcm->substream->runtime->rate, (rsr * desc.msr));
0811     src = apcm->src;
0812     src->ops->set_pitch(src, pitch);
0813     src->ops->set_rom(src, select_rom(pitch));
0814     src->ops->set_sf(src, convert_format(apcm->substream->runtime->format,
0815                          atc->card));
0816     src->ops->set_pm(src, (src->ops->next_interleave(src) != NULL));
0817     src->ops->set_bp(src, 1);
0818 
0819     /* Get AMIXER resource */
0820     n_amixer = (n_amixer < 2) ? 2 : n_amixer;
0821     apcm->amixers = kcalloc(n_amixer, sizeof(void *), GFP_KERNEL);
0822     if (!apcm->amixers) {
0823         err = -ENOMEM;
0824         goto error1;
0825     }
0826     mix_dsc.msr = desc.msr;
0827     for (i = 0, apcm->n_amixer = 0; i < n_amixer; i++) {
0828         err = amixer_mgr->get_amixer(amixer_mgr, &mix_dsc,
0829                     (struct amixer **)&apcm->amixers[i]);
0830         if (err)
0831             goto error1;
0832 
0833         apcm->n_amixer++;
0834     }
0835 
0836     /* Set up device virtual mem map */
0837     err = ct_map_audio_buffer(atc, apcm);
0838     if (err < 0)
0839         goto error1;
0840 
0841     return 0;
0842 
0843 error1:
0844     atc_pcm_release_resources(atc, apcm);
0845     return err;
0846 }
0847 
0848 static int atc_pll_init(struct ct_atc *atc, int rate)
0849 {
0850     struct hw *hw = atc->hw;
0851     int err;
0852     err = hw->pll_init(hw, rate);
0853     atc->pll_rate = err ? 0 : rate;
0854     return err;
0855 }
0856 
0857 static int
0858 spdif_passthru_playback_setup(struct ct_atc *atc, struct ct_atc_pcm *apcm)
0859 {
0860     struct dao *dao = container_of(atc->daios[SPDIFOO], struct dao, daio);
0861     unsigned int rate = apcm->substream->runtime->rate;
0862     unsigned int status;
0863     int err = 0;
0864     unsigned char iec958_con_fs;
0865 
0866     switch (rate) {
0867     case 48000:
0868         iec958_con_fs = IEC958_AES3_CON_FS_48000;
0869         break;
0870     case 44100:
0871         iec958_con_fs = IEC958_AES3_CON_FS_44100;
0872         break;
0873     case 32000:
0874         iec958_con_fs = IEC958_AES3_CON_FS_32000;
0875         break;
0876     default:
0877         return -ENOENT;
0878     }
0879 
0880     mutex_lock(&atc->atc_mutex);
0881     dao->ops->get_spos(dao, &status);
0882     if (((status >> 24) & IEC958_AES3_CON_FS) != iec958_con_fs) {
0883         status &= ~(IEC958_AES3_CON_FS << 24);
0884         status |= (iec958_con_fs << 24);
0885         dao->ops->set_spos(dao, status);
0886         dao->ops->commit_write(dao);
0887     }
0888     if ((rate != atc->pll_rate) && (32000 != rate))
0889         err = atc_pll_init(atc, rate);
0890     mutex_unlock(&atc->atc_mutex);
0891 
0892     return err;
0893 }
0894 
0895 static int
0896 spdif_passthru_playback_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm)
0897 {
0898     struct src *src;
0899     struct amixer *amixer;
0900     struct dao *dao;
0901     int err;
0902     int i;
0903 
0904     atc_pcm_release_resources(atc, apcm);
0905 
0906     /* Configure SPDIFOO and PLL to passthrough mode;
0907      * determine pll_rate. */
0908     err = spdif_passthru_playback_setup(atc, apcm);
0909     if (err)
0910         return err;
0911 
0912     /* Get needed resources. */
0913     err = spdif_passthru_playback_get_resources(atc, apcm);
0914     if (err)
0915         return err;
0916 
0917     /* Connect resources */
0918     src = apcm->src;
0919     for (i = 0; i < apcm->n_amixer; i++) {
0920         amixer = apcm->amixers[i];
0921         amixer->ops->setup(amixer, &src->rsc, INIT_VOL, NULL);
0922         src = src->ops->next_interleave(src);
0923         if (!src)
0924             src = apcm->src;
0925     }
0926     /* Connect to SPDIFOO */
0927     mutex_lock(&atc->atc_mutex);
0928     dao = container_of(atc->daios[SPDIFOO], struct dao, daio);
0929     amixer = apcm->amixers[0];
0930     dao->ops->set_left_input(dao, &amixer->rsc);
0931     amixer = apcm->amixers[1];
0932     dao->ops->set_right_input(dao, &amixer->rsc);
0933     mutex_unlock(&atc->atc_mutex);
0934 
0935     ct_timer_prepare(apcm->timer);
0936 
0937     return 0;
0938 }
0939 
0940 static int atc_select_line_in(struct ct_atc *atc)
0941 {
0942     struct hw *hw = atc->hw;
0943     struct ct_mixer *mixer = atc->mixer;
0944     struct src *src;
0945 
0946     if (hw->is_adc_source_selected(hw, ADC_LINEIN))
0947         return 0;
0948 
0949     mixer->set_input_left(mixer, MIX_MIC_IN, NULL);
0950     mixer->set_input_right(mixer, MIX_MIC_IN, NULL);
0951 
0952     hw->select_adc_source(hw, ADC_LINEIN);
0953 
0954     src = atc->srcs[2];
0955     mixer->set_input_left(mixer, MIX_LINE_IN, &src->rsc);
0956     src = atc->srcs[3];
0957     mixer->set_input_right(mixer, MIX_LINE_IN, &src->rsc);
0958 
0959     return 0;
0960 }
0961 
0962 static int atc_select_mic_in(struct ct_atc *atc)
0963 {
0964     struct hw *hw = atc->hw;
0965     struct ct_mixer *mixer = atc->mixer;
0966     struct src *src;
0967 
0968     if (hw->is_adc_source_selected(hw, ADC_MICIN))
0969         return 0;
0970 
0971     mixer->set_input_left(mixer, MIX_LINE_IN, NULL);
0972     mixer->set_input_right(mixer, MIX_LINE_IN, NULL);
0973 
0974     hw->select_adc_source(hw, ADC_MICIN);
0975 
0976     src = atc->srcs[2];
0977     mixer->set_input_left(mixer, MIX_MIC_IN, &src->rsc);
0978     src = atc->srcs[3];
0979     mixer->set_input_right(mixer, MIX_MIC_IN, &src->rsc);
0980 
0981     return 0;
0982 }
0983 
0984 static struct capabilities atc_capabilities(struct ct_atc *atc)
0985 {
0986     struct hw *hw = atc->hw;
0987 
0988     return hw->capabilities(hw);
0989 }
0990 
0991 static int atc_output_switch_get(struct ct_atc *atc)
0992 {
0993     struct hw *hw = atc->hw;
0994 
0995     return hw->output_switch_get(hw);
0996 }
0997 
0998 static int atc_output_switch_put(struct ct_atc *atc, int position)
0999 {
1000     struct hw *hw = atc->hw;
1001 
1002     return hw->output_switch_put(hw, position);
1003 }
1004 
1005 static int atc_mic_source_switch_get(struct ct_atc *atc)
1006 {
1007     struct hw *hw = atc->hw;
1008 
1009     return hw->mic_source_switch_get(hw);
1010 }
1011 
1012 static int atc_mic_source_switch_put(struct ct_atc *atc, int position)
1013 {
1014     struct hw *hw = atc->hw;
1015 
1016     return hw->mic_source_switch_put(hw, position);
1017 }
1018 
1019 static int atc_select_digit_io(struct ct_atc *atc)
1020 {
1021     struct hw *hw = atc->hw;
1022 
1023     if (hw->is_adc_source_selected(hw, ADC_NONE))
1024         return 0;
1025 
1026     hw->select_adc_source(hw, ADC_NONE);
1027 
1028     return 0;
1029 }
1030 
1031 static int atc_daio_unmute(struct ct_atc *atc, unsigned char state, int type)
1032 {
1033     struct daio_mgr *daio_mgr = atc->rsc_mgrs[DAIO];
1034 
1035     if (state)
1036         daio_mgr->daio_enable(daio_mgr, atc->daios[type]);
1037     else
1038         daio_mgr->daio_disable(daio_mgr, atc->daios[type]);
1039 
1040     daio_mgr->commit_write(daio_mgr);
1041 
1042     return 0;
1043 }
1044 
1045 static int
1046 atc_dao_get_status(struct ct_atc *atc, unsigned int *status, int type)
1047 {
1048     struct dao *dao = container_of(atc->daios[type], struct dao, daio);
1049     return dao->ops->get_spos(dao, status);
1050 }
1051 
1052 static int
1053 atc_dao_set_status(struct ct_atc *atc, unsigned int status, int type)
1054 {
1055     struct dao *dao = container_of(atc->daios[type], struct dao, daio);
1056 
1057     dao->ops->set_spos(dao, status);
1058     dao->ops->commit_write(dao);
1059     return 0;
1060 }
1061 
1062 static int atc_line_front_unmute(struct ct_atc *atc, unsigned char state)
1063 {
1064     return atc_daio_unmute(atc, state, LINEO1);
1065 }
1066 
1067 static int atc_line_surround_unmute(struct ct_atc *atc, unsigned char state)
1068 {
1069     return atc_daio_unmute(atc, state, LINEO2);
1070 }
1071 
1072 static int atc_line_clfe_unmute(struct ct_atc *atc, unsigned char state)
1073 {
1074     return atc_daio_unmute(atc, state, LINEO3);
1075 }
1076 
1077 static int atc_line_rear_unmute(struct ct_atc *atc, unsigned char state)
1078 {
1079     return atc_daio_unmute(atc, state, LINEO4);
1080 }
1081 
1082 static int atc_line_in_unmute(struct ct_atc *atc, unsigned char state)
1083 {
1084     return atc_daio_unmute(atc, state, LINEIM);
1085 }
1086 
1087 static int atc_mic_unmute(struct ct_atc *atc, unsigned char state)
1088 {
1089     return atc_daio_unmute(atc, state, MIC);
1090 }
1091 
1092 static int atc_spdif_out_unmute(struct ct_atc *atc, unsigned char state)
1093 {
1094     return atc_daio_unmute(atc, state, SPDIFOO);
1095 }
1096 
1097 static int atc_spdif_in_unmute(struct ct_atc *atc, unsigned char state)
1098 {
1099     return atc_daio_unmute(atc, state, SPDIFIO);
1100 }
1101 
1102 static int atc_spdif_out_get_status(struct ct_atc *atc, unsigned int *status)
1103 {
1104     return atc_dao_get_status(atc, status, SPDIFOO);
1105 }
1106 
1107 static int atc_spdif_out_set_status(struct ct_atc *atc, unsigned int status)
1108 {
1109     return atc_dao_set_status(atc, status, SPDIFOO);
1110 }
1111 
1112 static int atc_spdif_out_passthru(struct ct_atc *atc, unsigned char state)
1113 {
1114     struct dao_desc da_dsc = {0};
1115     struct dao *dao;
1116     int err;
1117     struct ct_mixer *mixer = atc->mixer;
1118     struct rsc *rscs[2] = {NULL};
1119     unsigned int spos = 0;
1120 
1121     mutex_lock(&atc->atc_mutex);
1122     dao = container_of(atc->daios[SPDIFOO], struct dao, daio);
1123     da_dsc.msr = state ? 1 : atc->msr;
1124     da_dsc.passthru = state ? 1 : 0;
1125     err = dao->ops->reinit(dao, &da_dsc);
1126     if (state) {
1127         spos = IEC958_DEFAULT_CON;
1128     } else {
1129         mixer->get_output_ports(mixer, MIX_SPDIF_OUT,
1130                     &rscs[0], &rscs[1]);
1131         dao->ops->set_left_input(dao, rscs[0]);
1132         dao->ops->set_right_input(dao, rscs[1]);
1133         /* Restore PLL to atc->rsr if needed. */
1134         if (atc->pll_rate != atc->rsr)
1135             err = atc_pll_init(atc, atc->rsr);
1136     }
1137     dao->ops->set_spos(dao, spos);
1138     dao->ops->commit_write(dao);
1139     mutex_unlock(&atc->atc_mutex);
1140 
1141     return err;
1142 }
1143 
1144 static int atc_release_resources(struct ct_atc *atc)
1145 {
1146     int i;
1147     struct daio_mgr *daio_mgr = NULL;
1148     struct dao *dao = NULL;
1149     struct daio *daio = NULL;
1150     struct sum_mgr *sum_mgr = NULL;
1151     struct src_mgr *src_mgr = NULL;
1152     struct srcimp_mgr *srcimp_mgr = NULL;
1153     struct srcimp *srcimp = NULL;
1154     struct ct_mixer *mixer = NULL;
1155 
1156     /* disconnect internal mixer objects */
1157     if (atc->mixer) {
1158         mixer = atc->mixer;
1159         mixer->set_input_left(mixer, MIX_LINE_IN, NULL);
1160         mixer->set_input_right(mixer, MIX_LINE_IN, NULL);
1161         mixer->set_input_left(mixer, MIX_MIC_IN, NULL);
1162         mixer->set_input_right(mixer, MIX_MIC_IN, NULL);
1163         mixer->set_input_left(mixer, MIX_SPDIF_IN, NULL);
1164         mixer->set_input_right(mixer, MIX_SPDIF_IN, NULL);
1165     }
1166 
1167     if (atc->daios) {
1168         daio_mgr = (struct daio_mgr *)atc->rsc_mgrs[DAIO];
1169         for (i = 0; i < atc->n_daio; i++) {
1170             daio = atc->daios[i];
1171             if (daio->type < LINEIM) {
1172                 dao = container_of(daio, struct dao, daio);
1173                 dao->ops->clear_left_input(dao);
1174                 dao->ops->clear_right_input(dao);
1175             }
1176             daio_mgr->put_daio(daio_mgr, daio);
1177         }
1178         kfree(atc->daios);
1179         atc->daios = NULL;
1180     }
1181 
1182     if (atc->pcm) {
1183         sum_mgr = atc->rsc_mgrs[SUM];
1184         for (i = 0; i < atc->n_pcm; i++)
1185             sum_mgr->put_sum(sum_mgr, atc->pcm[i]);
1186 
1187         kfree(atc->pcm);
1188         atc->pcm = NULL;
1189     }
1190 
1191     if (atc->srcs) {
1192         src_mgr = atc->rsc_mgrs[SRC];
1193         for (i = 0; i < atc->n_src; i++)
1194             src_mgr->put_src(src_mgr, atc->srcs[i]);
1195 
1196         kfree(atc->srcs);
1197         atc->srcs = NULL;
1198     }
1199 
1200     if (atc->srcimps) {
1201         srcimp_mgr = atc->rsc_mgrs[SRCIMP];
1202         for (i = 0; i < atc->n_srcimp; i++) {
1203             srcimp = atc->srcimps[i];
1204             srcimp->ops->unmap(srcimp);
1205             srcimp_mgr->put_srcimp(srcimp_mgr, atc->srcimps[i]);
1206         }
1207         kfree(atc->srcimps);
1208         atc->srcimps = NULL;
1209     }
1210 
1211     return 0;
1212 }
1213 
1214 static int ct_atc_destroy(struct ct_atc *atc)
1215 {
1216     int i = 0;
1217 
1218     if (!atc)
1219         return 0;
1220 
1221     if (atc->timer) {
1222         ct_timer_free(atc->timer);
1223         atc->timer = NULL;
1224     }
1225 
1226     atc_release_resources(atc);
1227 
1228     /* Destroy internal mixer objects */
1229     if (atc->mixer)
1230         ct_mixer_destroy(atc->mixer);
1231 
1232     for (i = 0; i < NUM_RSCTYP; i++) {
1233         if (rsc_mgr_funcs[i].destroy && atc->rsc_mgrs[i])
1234             rsc_mgr_funcs[i].destroy(atc->rsc_mgrs[i]);
1235 
1236     }
1237 
1238     if (atc->hw)
1239         destroy_hw_obj(atc->hw);
1240 
1241     /* Destroy device virtual memory manager object */
1242     if (atc->vm) {
1243         ct_vm_destroy(atc->vm);
1244         atc->vm = NULL;
1245     }
1246 
1247     kfree(atc);
1248 
1249     return 0;
1250 }
1251 
1252 static int atc_dev_free(struct snd_device *dev)
1253 {
1254     struct ct_atc *atc = dev->device_data;
1255     return ct_atc_destroy(atc);
1256 }
1257 
1258 static int atc_identify_card(struct ct_atc *atc, unsigned int ssid)
1259 {
1260     const struct snd_pci_quirk *p;
1261     const struct snd_pci_quirk *list;
1262     u16 vendor_id, device_id;
1263 
1264     switch (atc->chip_type) {
1265     case ATC20K1:
1266         atc->chip_name = "20K1";
1267         list = subsys_20k1_list;
1268         break;
1269     case ATC20K2:
1270         atc->chip_name = "20K2";
1271         list = subsys_20k2_list;
1272         break;
1273     default:
1274         return -ENOENT;
1275     }
1276     if (ssid) {
1277         vendor_id = ssid >> 16;
1278         device_id = ssid & 0xffff;
1279     } else {
1280         vendor_id = atc->pci->subsystem_vendor;
1281         device_id = atc->pci->subsystem_device;
1282     }
1283     p = snd_pci_quirk_lookup_id(vendor_id, device_id, list);
1284     if (p) {
1285         if (p->value < 0) {
1286             dev_err(atc->card->dev,
1287                 "Device %04x:%04x is on the denylist\n",
1288                 vendor_id, device_id);
1289             return -ENOENT;
1290         }
1291         atc->model = p->value;
1292     } else {
1293         if (atc->chip_type == ATC20K1)
1294             atc->model = CT20K1_UNKNOWN;
1295         else
1296             atc->model = CT20K2_UNKNOWN;
1297     }
1298     atc->model_name = ct_subsys_name[atc->model];
1299     dev_info(atc->card->dev, "chip %s model %s (%04x:%04x) is found\n",
1300            atc->chip_name, atc->model_name,
1301            vendor_id, device_id);
1302     return 0;
1303 }
1304 
1305 int ct_atc_create_alsa_devs(struct ct_atc *atc)
1306 {
1307     enum CTALSADEVS i;
1308     int err;
1309 
1310     alsa_dev_funcs[MIXER].public_name = atc->chip_name;
1311 
1312     for (i = 0; i < NUM_CTALSADEVS; i++) {
1313         if (!alsa_dev_funcs[i].create)
1314             continue;
1315 
1316         err = alsa_dev_funcs[i].create(atc, i,
1317                 alsa_dev_funcs[i].public_name);
1318         if (err) {
1319             dev_err(atc->card->dev,
1320                 "Creating alsa device %d failed!\n", i);
1321             return err;
1322         }
1323     }
1324 
1325     return 0;
1326 }
1327 
1328 static int atc_create_hw_devs(struct ct_atc *atc)
1329 {
1330     struct hw *hw;
1331     struct card_conf info = {0};
1332     int i, err;
1333 
1334     err = create_hw_obj(atc->pci, atc->chip_type, atc->model, &hw);
1335     if (err) {
1336         dev_err(atc->card->dev, "Failed to create hw obj!!!\n");
1337         return err;
1338     }
1339     hw->card = atc->card;
1340     atc->hw = hw;
1341 
1342     /* Initialize card hardware. */
1343     info.rsr = atc->rsr;
1344     info.msr = atc->msr;
1345     info.vm_pgt_phys = atc_get_ptp_phys(atc, 0);
1346     err = hw->card_init(hw, &info);
1347     if (err < 0)
1348         return err;
1349 
1350     for (i = 0; i < NUM_RSCTYP; i++) {
1351         if (!rsc_mgr_funcs[i].create)
1352             continue;
1353 
1354         err = rsc_mgr_funcs[i].create(atc->hw, &atc->rsc_mgrs[i]);
1355         if (err) {
1356             dev_err(atc->card->dev,
1357                 "Failed to create rsc_mgr %d!!!\n", i);
1358             return err;
1359         }
1360     }
1361 
1362     return 0;
1363 }
1364 
1365 static int atc_get_resources(struct ct_atc *atc)
1366 {
1367     struct daio_desc da_desc = {0};
1368     struct daio_mgr *daio_mgr;
1369     struct src_desc src_dsc = {0};
1370     struct src_mgr *src_mgr;
1371     struct srcimp_desc srcimp_dsc = {0};
1372     struct srcimp_mgr *srcimp_mgr;
1373     struct sum_desc sum_dsc = {0};
1374     struct sum_mgr *sum_mgr;
1375     int err, i, num_srcs, num_daios;
1376 
1377     num_daios = ((atc->model == CTSB1270) ? 8 : 7);
1378     num_srcs = ((atc->model == CTSB1270) ? 6 : 4);
1379 
1380     atc->daios = kcalloc(num_daios, sizeof(void *), GFP_KERNEL);
1381     if (!atc->daios)
1382         return -ENOMEM;
1383 
1384     atc->srcs = kcalloc(num_srcs, sizeof(void *), GFP_KERNEL);
1385     if (!atc->srcs)
1386         return -ENOMEM;
1387 
1388     atc->srcimps = kcalloc(num_srcs, sizeof(void *), GFP_KERNEL);
1389     if (!atc->srcimps)
1390         return -ENOMEM;
1391 
1392     atc->pcm = kcalloc(2 * 4, sizeof(void *), GFP_KERNEL);
1393     if (!atc->pcm)
1394         return -ENOMEM;
1395 
1396     daio_mgr = (struct daio_mgr *)atc->rsc_mgrs[DAIO];
1397     da_desc.msr = atc->msr;
1398     for (i = 0, atc->n_daio = 0; i < num_daios; i++) {
1399         da_desc.type = (atc->model != CTSB073X) ? i :
1400                  ((i == SPDIFIO) ? SPDIFI1 : i);
1401         err = daio_mgr->get_daio(daio_mgr, &da_desc,
1402                     (struct daio **)&atc->daios[i]);
1403         if (err) {
1404             dev_err(atc->card->dev,
1405                 "Failed to get DAIO resource %d!!!\n",
1406                 i);
1407             return err;
1408         }
1409         atc->n_daio++;
1410     }
1411 
1412     src_mgr = atc->rsc_mgrs[SRC];
1413     src_dsc.multi = 1;
1414     src_dsc.msr = atc->msr;
1415     src_dsc.mode = ARCRW;
1416     for (i = 0, atc->n_src = 0; i < num_srcs; i++) {
1417         err = src_mgr->get_src(src_mgr, &src_dsc,
1418                     (struct src **)&atc->srcs[i]);
1419         if (err)
1420             return err;
1421 
1422         atc->n_src++;
1423     }
1424 
1425     srcimp_mgr = atc->rsc_mgrs[SRCIMP];
1426     srcimp_dsc.msr = 8;
1427     for (i = 0, atc->n_srcimp = 0; i < num_srcs; i++) {
1428         err = srcimp_mgr->get_srcimp(srcimp_mgr, &srcimp_dsc,
1429                     (struct srcimp **)&atc->srcimps[i]);
1430         if (err)
1431             return err;
1432 
1433         atc->n_srcimp++;
1434     }
1435 
1436     sum_mgr = atc->rsc_mgrs[SUM];
1437     sum_dsc.msr = atc->msr;
1438     for (i = 0, atc->n_pcm = 0; i < (2*4); i++) {
1439         err = sum_mgr->get_sum(sum_mgr, &sum_dsc,
1440                     (struct sum **)&atc->pcm[i]);
1441         if (err)
1442             return err;
1443 
1444         atc->n_pcm++;
1445     }
1446 
1447     return 0;
1448 }
1449 
1450 static void
1451 atc_connect_dai(struct src_mgr *src_mgr, struct dai *dai,
1452         struct src **srcs, struct srcimp **srcimps)
1453 {
1454     struct rsc *rscs[2] = {NULL};
1455     struct src *src;
1456     struct srcimp *srcimp;
1457     int i = 0;
1458 
1459     rscs[0] = &dai->daio.rscl;
1460     rscs[1] = &dai->daio.rscr;
1461     for (i = 0; i < 2; i++) {
1462         src = srcs[i];
1463         srcimp = srcimps[i];
1464         srcimp->ops->map(srcimp, src, rscs[i]);
1465         src_mgr->src_disable(src_mgr, src);
1466     }
1467 
1468     src_mgr->commit_write(src_mgr); /* Actually disable SRCs */
1469 
1470     src = srcs[0];
1471     src->ops->set_pm(src, 1);
1472     for (i = 0; i < 2; i++) {
1473         src = srcs[i];
1474         src->ops->set_state(src, SRC_STATE_RUN);
1475         src->ops->commit_write(src);
1476         src_mgr->src_enable_s(src_mgr, src);
1477     }
1478 
1479     dai->ops->set_srt_srcl(dai, &(srcs[0]->rsc));
1480     dai->ops->set_srt_srcr(dai, &(srcs[1]->rsc));
1481 
1482     dai->ops->set_enb_src(dai, 1);
1483     dai->ops->set_enb_srt(dai, 1);
1484     dai->ops->commit_write(dai);
1485 
1486     src_mgr->commit_write(src_mgr); /* Synchronously enable SRCs */
1487 }
1488 
1489 static void atc_connect_resources(struct ct_atc *atc)
1490 {
1491     struct dai *dai;
1492     struct dao *dao;
1493     struct src *src;
1494     struct sum *sum;
1495     struct ct_mixer *mixer;
1496     struct rsc *rscs[2] = {NULL};
1497     int i, j;
1498 
1499     mixer = atc->mixer;
1500 
1501     for (i = MIX_WAVE_FRONT, j = LINEO1; i <= MIX_SPDIF_OUT; i++, j++) {
1502         mixer->get_output_ports(mixer, i, &rscs[0], &rscs[1]);
1503         dao = container_of(atc->daios[j], struct dao, daio);
1504         dao->ops->set_left_input(dao, rscs[0]);
1505         dao->ops->set_right_input(dao, rscs[1]);
1506     }
1507 
1508     dai = container_of(atc->daios[LINEIM], struct dai, daio);
1509     atc_connect_dai(atc->rsc_mgrs[SRC], dai,
1510             (struct src **)&atc->srcs[2],
1511             (struct srcimp **)&atc->srcimps[2]);
1512     src = atc->srcs[2];
1513     mixer->set_input_left(mixer, MIX_LINE_IN, &src->rsc);
1514     src = atc->srcs[3];
1515     mixer->set_input_right(mixer, MIX_LINE_IN, &src->rsc);
1516 
1517     if (atc->model == CTSB1270) {
1518         /* Titanium HD has a dedicated ADC for the Mic. */
1519         dai = container_of(atc->daios[MIC], struct dai, daio);
1520         atc_connect_dai(atc->rsc_mgrs[SRC], dai,
1521             (struct src **)&atc->srcs[4],
1522             (struct srcimp **)&atc->srcimps[4]);
1523         src = atc->srcs[4];
1524         mixer->set_input_left(mixer, MIX_MIC_IN, &src->rsc);
1525         src = atc->srcs[5];
1526         mixer->set_input_right(mixer, MIX_MIC_IN, &src->rsc);
1527     }
1528 
1529     dai = container_of(atc->daios[SPDIFIO], struct dai, daio);
1530     atc_connect_dai(atc->rsc_mgrs[SRC], dai,
1531             (struct src **)&atc->srcs[0],
1532             (struct srcimp **)&atc->srcimps[0]);
1533 
1534     src = atc->srcs[0];
1535     mixer->set_input_left(mixer, MIX_SPDIF_IN, &src->rsc);
1536     src = atc->srcs[1];
1537     mixer->set_input_right(mixer, MIX_SPDIF_IN, &src->rsc);
1538 
1539     for (i = MIX_PCMI_FRONT, j = 0; i <= MIX_PCMI_SURROUND; i++, j += 2) {
1540         sum = atc->pcm[j];
1541         mixer->set_input_left(mixer, i, &sum->rsc);
1542         sum = atc->pcm[j+1];
1543         mixer->set_input_right(mixer, i, &sum->rsc);
1544     }
1545 }
1546 
1547 #ifdef CONFIG_PM_SLEEP
1548 static int atc_suspend(struct ct_atc *atc)
1549 {
1550     struct hw *hw = atc->hw;
1551 
1552     snd_power_change_state(atc->card, SNDRV_CTL_POWER_D3hot);
1553 
1554     atc_release_resources(atc);
1555 
1556     hw->suspend(hw);
1557 
1558     return 0;
1559 }
1560 
1561 static int atc_hw_resume(struct ct_atc *atc)
1562 {
1563     struct hw *hw = atc->hw;
1564     struct card_conf info = {0};
1565 
1566     /* Re-initialize card hardware. */
1567     info.rsr = atc->rsr;
1568     info.msr = atc->msr;
1569     info.vm_pgt_phys = atc_get_ptp_phys(atc, 0);
1570     return hw->resume(hw, &info);
1571 }
1572 
1573 static int atc_resources_resume(struct ct_atc *atc)
1574 {
1575     struct ct_mixer *mixer;
1576     int err = 0;
1577 
1578     /* Get resources */
1579     err = atc_get_resources(atc);
1580     if (err < 0) {
1581         atc_release_resources(atc);
1582         return err;
1583     }
1584 
1585     /* Build topology */
1586     atc_connect_resources(atc);
1587 
1588     mixer = atc->mixer;
1589     mixer->resume(mixer);
1590 
1591     return 0;
1592 }
1593 
1594 static int atc_resume(struct ct_atc *atc)
1595 {
1596     int err = 0;
1597 
1598     /* Do hardware resume. */
1599     err = atc_hw_resume(atc);
1600     if (err < 0) {
1601         dev_err(atc->card->dev,
1602             "pci_enable_device failed, disabling device\n");
1603         snd_card_disconnect(atc->card);
1604         return err;
1605     }
1606 
1607     err = atc_resources_resume(atc);
1608     if (err < 0)
1609         return err;
1610 
1611     snd_power_change_state(atc->card, SNDRV_CTL_POWER_D0);
1612 
1613     return 0;
1614 }
1615 #endif
1616 
1617 static const struct ct_atc atc_preset = {
1618     .map_audio_buffer = ct_map_audio_buffer,
1619     .unmap_audio_buffer = ct_unmap_audio_buffer,
1620     .pcm_playback_prepare = atc_pcm_playback_prepare,
1621     .pcm_release_resources = atc_pcm_release_resources,
1622     .pcm_playback_start = atc_pcm_playback_start,
1623     .pcm_playback_stop = atc_pcm_stop,
1624     .pcm_playback_position = atc_pcm_playback_position,
1625     .pcm_capture_prepare = atc_pcm_capture_prepare,
1626     .pcm_capture_start = atc_pcm_capture_start,
1627     .pcm_capture_stop = atc_pcm_stop,
1628     .pcm_capture_position = atc_pcm_capture_position,
1629     .spdif_passthru_playback_prepare = spdif_passthru_playback_prepare,
1630     .get_ptp_phys = atc_get_ptp_phys,
1631     .select_line_in = atc_select_line_in,
1632     .select_mic_in = atc_select_mic_in,
1633     .select_digit_io = atc_select_digit_io,
1634     .line_front_unmute = atc_line_front_unmute,
1635     .line_surround_unmute = atc_line_surround_unmute,
1636     .line_clfe_unmute = atc_line_clfe_unmute,
1637     .line_rear_unmute = atc_line_rear_unmute,
1638     .line_in_unmute = atc_line_in_unmute,
1639     .mic_unmute = atc_mic_unmute,
1640     .spdif_out_unmute = atc_spdif_out_unmute,
1641     .spdif_in_unmute = atc_spdif_in_unmute,
1642     .spdif_out_get_status = atc_spdif_out_get_status,
1643     .spdif_out_set_status = atc_spdif_out_set_status,
1644     .spdif_out_passthru = atc_spdif_out_passthru,
1645     .capabilities = atc_capabilities,
1646     .output_switch_get = atc_output_switch_get,
1647     .output_switch_put = atc_output_switch_put,
1648     .mic_source_switch_get = atc_mic_source_switch_get,
1649     .mic_source_switch_put = atc_mic_source_switch_put,
1650 #ifdef CONFIG_PM_SLEEP
1651     .suspend = atc_suspend,
1652     .resume = atc_resume,
1653 #endif
1654 };
1655 
1656 /**
1657  *  ct_atc_create - create and initialize a hardware manager
1658  *  @card: corresponding alsa card object
1659  *  @pci: corresponding kernel pci device object
1660  *  @rsr: reference sampling rate
1661  *  @msr: master sampling rate
1662  *  @chip_type: CHIPTYP enum values
1663  *  @ssid: vendor ID (upper 16 bits) and device ID (lower 16 bits)
1664  *  @ratc: return created object address in it
1665  *
1666  *  Creates and initializes a hardware manager.
1667  *
1668  *  Creates kmallocated ct_atc structure. Initializes hardware.
1669  *  Returns 0 if succeeds, or negative error code if fails.
1670  */
1671 
1672 int ct_atc_create(struct snd_card *card, struct pci_dev *pci,
1673           unsigned int rsr, unsigned int msr,
1674           int chip_type, unsigned int ssid,
1675           struct ct_atc **ratc)
1676 {
1677     struct ct_atc *atc;
1678     static const struct snd_device_ops ops = {
1679         .dev_free = atc_dev_free,
1680     };
1681     int err;
1682 
1683     *ratc = NULL;
1684 
1685     atc = kzalloc(sizeof(*atc), GFP_KERNEL);
1686     if (!atc)
1687         return -ENOMEM;
1688 
1689     /* Set operations */
1690     *atc = atc_preset;
1691 
1692     atc->card = card;
1693     atc->pci = pci;
1694     atc->rsr = rsr;
1695     atc->msr = msr;
1696     atc->chip_type = chip_type;
1697 
1698     mutex_init(&atc->atc_mutex);
1699 
1700     /* Find card model */
1701     err = atc_identify_card(atc, ssid);
1702     if (err < 0) {
1703         dev_err(card->dev, "ctatc: Card not recognised\n");
1704         goto error1;
1705     }
1706 
1707     /* Set up device virtual memory management object */
1708     err = ct_vm_create(&atc->vm, pci);
1709     if (err < 0)
1710         goto error1;
1711 
1712     /* Create all atc hw devices */
1713     err = atc_create_hw_devs(atc);
1714     if (err < 0)
1715         goto error1;
1716 
1717     err = ct_mixer_create(atc, (struct ct_mixer **)&atc->mixer);
1718     if (err) {
1719         dev_err(card->dev, "Failed to create mixer obj!!!\n");
1720         goto error1;
1721     }
1722 
1723     /* Get resources */
1724     err = atc_get_resources(atc);
1725     if (err < 0)
1726         goto error1;
1727 
1728     /* Build topology */
1729     atc_connect_resources(atc);
1730 
1731     atc->timer = ct_timer_new(atc);
1732     if (!atc->timer) {
1733         err = -ENOMEM;
1734         goto error1;
1735     }
1736 
1737     err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, atc, &ops);
1738     if (err < 0)
1739         goto error1;
1740 
1741     *ratc = atc;
1742     return 0;
1743 
1744 error1:
1745     ct_atc_destroy(atc);
1746     dev_err(card->dev, "Something wrong!!!\n");
1747     return err;
1748 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!