ctatc.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved.
   4 *
   5 * @File    ctatc.c
   6 *
   7 * @Brief
   8 * This file contains the implementation of the device resource management
   9 * object.
  10 *
  11 * @Author Liu Chun
  12 * @Date Mar 28 2008
  13 */
  14
  15#include "ctatc.h"
  16#include "ctpcm.h"
  17#include "ctmixer.h"
  18#include "ctsrc.h"
  19#include "ctamixer.h"
  20#include "ctdaio.h"
  21#include "cttimer.h"
  22#include <linux/delay.h>
  23#include <linux/slab.h>
  24#include <sound/pcm.h>
  25#include <sound/control.h>
  26#include <sound/asoundef.h>
  27
  28#define NUM_ATC_SRCS	6
  29#define NUM_ATC_PCM		(2 * 4)
  30
  31#define MONO_SUM_SCALE	0x19a8	/* 2^(-0.5) in 14-bit floating format */
  32#define MAX_MULTI_CHN	8
  33
  34#define IEC958_DEFAULT_CON ((IEC958_AES0_NONAUDIO \
  35			    | IEC958_AES0_CON_NOT_COPYRIGHT) \
  36			    | ((IEC958_AES1_CON_MIXER \
  37			    | IEC958_AES1_CON_ORIGINAL) << 8) \
  38			    | (0x10 << 16) \
  39			    | ((IEC958_AES3_CON_FS_48000) << 24))
  40
  41static const struct snd_pci_quirk subsys_20k1_list[] = {
  42	SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, 0x0021, "SB046x", CTSB046X),
  43	SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, 0x0022, "SB055x", CTSB055X),
  44	SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, 0x002f, "SB055x", CTSB055X),
  45	SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, 0x0029, "SB073x", CTSB073X),
  46	SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, 0x0031, "SB073x", CTSB073X),
  47	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_CREATIVE, 0xf000, 0x6000,
  48			   "UAA", CTUAA),
  49	{ } /* terminator */
  50};
  51
  52static const struct snd_pci_quirk subsys_20k2_list[] = {
  53	SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, PCI_SUBDEVICE_ID_CREATIVE_SB0760,
  54		      "SB0760", CTSB0760),
  55	SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, PCI_SUBDEVICE_ID_CREATIVE_SB08801,
  56		      "SB0880", CTSB0880),
  57	SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, PCI_SUBDEVICE_ID_CREATIVE_SB08802,
  58		      "SB0880", CTSB0880),
  59	SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, PCI_SUBDEVICE_ID_CREATIVE_SB08803,
  60		      "SB0880", CTSB0880),
  61	SND_PCI_QUIRK(PCI_VENDOR_ID_CREATIVE, PCI_SUBDEVICE_ID_CREATIVE_SB1270,
  62		      "SB1270", CTSB1270),
  63	SND_PCI_QUIRK(0x160b, 0x0101, "OK0010", CTOK0010),
  64	SND_PCI_QUIRK(0x160b, 0x0102, "OK0010", CTOK0010),
  65	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_CREATIVE, 0xf000,
  66			   PCI_SUBDEVICE_ID_CREATIVE_HENDRIX, "HENDRIX",
  67			   CTHENDRIX),
  68	{ } /* terminator */
  69};
  70
  71static const char *ct_subsys_name[NUM_CTCARDS] = {
  72	/* 20k1 models */
  73	[CTSB046X]	= "SB046x",
  74	[CTSB055X]	= "SB055x",
  75	[CTSB073X]	= "SB073x",
  76	[CTUAA]		= "UAA",
  77	[CT20K1_UNKNOWN] = "Unknown",
  78	/* 20k2 models */
  79	[CTSB0760]	= "SB076x",
  80	[CTHENDRIX]	= "Hendrix",
  81	[CTSB0880]	= "SB0880",
  82	[CTSB1270]	= "SB1270",
  83	[CTOK0010]	= "OK0010",
  84	[CT20K2_UNKNOWN] = "Unknown",
  85};
  86
  87static struct {
  88	int (*create)(struct ct_atc *atc,
  89			enum CTALSADEVS device, const char *device_name);
  90	int (*destroy)(void *alsa_dev);
  91	const char *public_name;
  92} alsa_dev_funcs[NUM_CTALSADEVS] = {
  93	[FRONT]		= { .create = ct_alsa_pcm_create,
  94			    .destroy = NULL,
  95			    .public_name = "Front/WaveIn"},
  96	[SURROUND]	= { .create = ct_alsa_pcm_create,
  97			    .destroy = NULL,
  98			    .public_name = "Surround"},
  99	[CLFE]		= { .create = ct_alsa_pcm_create,
 100			    .destroy = NULL,
 101			    .public_name = "Center/LFE"},
 102	[SIDE]		= { .create = ct_alsa_pcm_create,
 103			    .destroy = NULL,
 104			    .public_name = "Side"},
 105	[IEC958]	= { .create = ct_alsa_pcm_create,
 106			    .destroy = NULL,
 107			    .public_name = "IEC958 Non-audio"},
 108
 109	[MIXER]		= { .create = ct_alsa_mix_create,
 110			    .destroy = NULL,
 111			    .public_name = "Mixer"}
 112};
 113
 114static struct {
 115	int (*create)(struct hw *hw, void **rmgr);
 116	int (*destroy)(void *mgr);
 117} rsc_mgr_funcs[NUM_RSCTYP] = {
 118	[SRC] 		= { .create 	= src_mgr_create,
 119			    .destroy 	= src_mgr_destroy	},
 120	[SRCIMP] 	= { .create 	= srcimp_mgr_create,
 121			    .destroy 	= srcimp_mgr_destroy	},
 122	[AMIXER]	= { .create	= amixer_mgr_create,
 123			    .destroy	= amixer_mgr_destroy	},
 124	[SUM]		= { .create	= sum_mgr_create,
 125			    .destroy	= sum_mgr_destroy	},
 126	[DAIO]		= { .create	= daio_mgr_create,
 127			    .destroy	= daio_mgr_destroy	}
 128};
 129
 130static int
 131atc_pcm_release_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm);
 132
 133/* *
 134 * Only mono and interleaved modes are supported now.
 135 * Always allocates a contiguous channel block.
 136 * */
 137
 138static int ct_map_audio_buffer(struct ct_atc *atc, struct ct_atc_pcm *apcm)
 139{
 140	struct snd_pcm_runtime *runtime;
 141	struct ct_vm *vm;
 142
 143	if (!apcm->substream)
 144		return 0;
 145
 146	runtime = apcm->substream->runtime;
 147	vm = atc->vm;
 148
 149	apcm->vm_block = vm->map(vm, apcm->substream, runtime->dma_bytes);
 150
 151	if (!apcm->vm_block)
 152		return -ENOENT;
 153
 154	return 0;
 155}
 156
 157static void ct_unmap_audio_buffer(struct ct_atc *atc, struct ct_atc_pcm *apcm)
 158{
 159	struct ct_vm *vm;
 160
 161	if (!apcm->vm_block)
 162		return;
 163
 164	vm = atc->vm;
 165
 166	vm->unmap(vm, apcm->vm_block);
 167
 168	apcm->vm_block = NULL;
 169}
 170
 171static unsigned long atc_get_ptp_phys(struct ct_atc *atc, int index)
 172{
 173	return atc->vm->get_ptp_phys(atc->vm, index);
 174}
 175
 176static unsigned int convert_format(snd_pcm_format_t snd_format,
 177				   struct snd_card *card)
 178{
 179	switch (snd_format) {
 180	case SNDRV_PCM_FORMAT_U8:
 181		return SRC_SF_U8;
 182	case SNDRV_PCM_FORMAT_S16_LE:
 183		return SRC_SF_S16;
 184	case SNDRV_PCM_FORMAT_S24_3LE:
 185		return SRC_SF_S24;
 186	case SNDRV_PCM_FORMAT_S32_LE:
 187		return SRC_SF_S32;
 188	case SNDRV_PCM_FORMAT_FLOAT_LE:
 189		return SRC_SF_F32;
 190	default:
 191		dev_err(card->dev, "not recognized snd format is %d\n",
 192			snd_format);
 193		return SRC_SF_S16;
 194	}
 195}
 196
 197static unsigned int
 198atc_get_pitch(unsigned int input_rate, unsigned int output_rate)
 199{
 200	unsigned int pitch;
 201	int b;
 202
 203	/* get pitch and convert to fixed-point 8.24 format. */
 204	pitch = (input_rate / output_rate) << 24;
 205	input_rate %= output_rate;
 206	input_rate /= 100;
 207	output_rate /= 100;
 208	for (b = 31; ((b >= 0) && !(input_rate >> b)); )
 209		b--;
 210
 211	if (b >= 0) {
 212		input_rate <<= (31 - b);
 213		input_rate /= output_rate;
 214		b = 24 - (31 - b);
 215		if (b >= 0)
 216			input_rate <<= b;
 217		else
 218			input_rate >>= -b;
 219
 220		pitch |= input_rate;
 221	}
 222
 223	return pitch;
 224}
 225
 226static int select_rom(unsigned int pitch)
 227{
 228	if (pitch > 0x00428f5c && pitch < 0x01b851ec) {
 229		/* 0.26 <= pitch <= 1.72 */
 230		return 1;
 231	} else if (pitch == 0x01d66666 || pitch == 0x01d66667) {
 232		/* pitch == 1.8375 */
 233		return 2;
 234	} else if (pitch == 0x02000000) {
 235		/* pitch == 2 */
 236		return 3;
 237	} else if (pitch <= 0x08000000) {
 238		/* 0 <= pitch <= 8 */
 239		return 0;
 240	} else {
 241		return -ENOENT;
 242	}
 243}
 244
 245static int atc_pcm_playback_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm)
 246{
 247	struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
 248	struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER];
 249	struct src_desc desc = {0};
 250	struct amixer_desc mix_dsc = {0};
 251	struct src *src;
 252	struct amixer *amixer;
 253	int err;
 254	int n_amixer = apcm->substream->runtime->channels, i = 0;
 255	int device = apcm->substream->pcm->device;
 256	unsigned int pitch;
 257
 258	/* first release old resources */
 259	atc_pcm_release_resources(atc, apcm);
 260
 261	/* Get SRC resource */
 262	desc.multi = apcm->substream->runtime->channels;
 263	desc.msr = atc->msr;
 264	desc.mode = MEMRD;
 265	err = src_mgr->get_src(src_mgr, &desc, (struct src **)&apcm->src);
 266	if (err)
 267		goto error1;
 268
 269	pitch = atc_get_pitch(apcm->substream->runtime->rate,
 270						(atc->rsr * atc->msr));
 271	src = apcm->src;
 272	src->ops->set_pitch(src, pitch);
 273	src->ops->set_rom(src, select_rom(pitch));
 274	src->ops->set_sf(src, convert_format(apcm->substream->runtime->format,
 275					     atc->card));
 276	src->ops->set_pm(src, (src->ops->next_interleave(src) != NULL));
 277
 278	/* Get AMIXER resource */
 279	n_amixer = (n_amixer < 2) ? 2 : n_amixer;
 280	apcm->amixers = kcalloc(n_amixer, sizeof(void *), GFP_KERNEL);
 281	if (!apcm->amixers) {
 282		err = -ENOMEM;
 283		goto error1;
 284	}
 285	mix_dsc.msr = atc->msr;
 286	for (i = 0, apcm->n_amixer = 0; i < n_amixer; i++) {
 287		err = amixer_mgr->get_amixer(amixer_mgr, &mix_dsc,
 288					(struct amixer **)&apcm->amixers[i]);
 289		if (err)
 290			goto error1;
 291
 292		apcm->n_amixer++;
 293	}
 294
 295	/* Set up device virtual mem map */
 296	err = ct_map_audio_buffer(atc, apcm);
 297	if (err < 0)
 298		goto error1;
 299
 300	/* Connect resources */
 301	src = apcm->src;
 302	for (i = 0; i < n_amixer; i++) {
 303		amixer = apcm->amixers[i];
 304		scoped_guard(mutex, &atc->atc_mutex) {
 305			amixer->ops->setup(amixer, &src->rsc,
 306					   INIT_VOL, atc->pcm[i+device*2]);
 307		}
 308		src = src->ops->next_interleave(src);
 309		if (!src)
 310			src = apcm->src;
 311	}
 312
 313	ct_timer_prepare(apcm->timer);
 314
 315	return 0;
 316
 317error1:
 318	atc_pcm_release_resources(atc, apcm);
 319	return err;
 320}
 321
 322static int
 323atc_pcm_release_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm)
 324{
 325	struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
 326	struct srcimp_mgr *srcimp_mgr = atc->rsc_mgrs[SRCIMP];
 327	struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER];
 328	struct sum_mgr *sum_mgr = atc->rsc_mgrs[SUM];
 329	struct srcimp *srcimp;
 330	int i;
 331
 332	if (apcm->srcimps) {
 333		for (i = 0; i < apcm->n_srcimp; i++) {
 334			srcimp = apcm->srcimps[i];
 335			srcimp->ops->unmap(srcimp);
 336			srcimp_mgr->put_srcimp(srcimp_mgr, srcimp);
 337			apcm->srcimps[i] = NULL;
 338		}
 339		kfree(apcm->srcimps);
 340		apcm->srcimps = NULL;
 341	}
 342
 343	if (apcm->srccs) {
 344		for (i = 0; i < apcm->n_srcc; i++) {
 345			src_mgr->put_src(src_mgr, apcm->srccs[i]);
 346			apcm->srccs[i] = NULL;
 347		}
 348		kfree(apcm->srccs);
 349		apcm->srccs = NULL;
 350	}
 351
 352	if (apcm->amixers) {
 353		for (i = 0; i < apcm->n_amixer; i++) {
 354			amixer_mgr->put_amixer(amixer_mgr, apcm->amixers[i]);
 355			apcm->amixers[i] = NULL;
 356		}
 357		kfree(apcm->amixers);
 358		apcm->amixers = NULL;
 359	}
 360
 361	if (apcm->mono) {
 362		sum_mgr->put_sum(sum_mgr, apcm->mono);
 363		apcm->mono = NULL;
 364	}
 365
 366	if (apcm->src) {
 367		src_mgr->put_src(src_mgr, apcm->src);
 368		apcm->src = NULL;
 369	}
 370
 371	if (apcm->vm_block) {
 372		/* Undo device virtual mem map */
 373		ct_unmap_audio_buffer(atc, apcm);
 374		apcm->vm_block = NULL;
 375	}
 376
 377	return 0;
 378}
 379
 380static int atc_pcm_playback_start(struct ct_atc *atc, struct ct_atc_pcm *apcm)
 381{
 382	unsigned int max_cisz;
 383	struct src *src = apcm->src;
 384
 385	if (apcm->started)
 386		return 0;
 387	apcm->started = 1;
 388
 389	max_cisz = src->multi * src->rsc.msr;
 390	max_cisz = 0x80 * (max_cisz < 8 ? max_cisz : 8);
 391
 392	src->ops->set_sa(src, apcm->vm_block->addr);
 393	src->ops->set_la(src, apcm->vm_block->addr + apcm->vm_block->size);
 394	src->ops->set_ca(src, apcm->vm_block->addr + max_cisz);
 395	src->ops->set_cisz(src, max_cisz);
 396
 397	src->ops->set_bm(src, 1);
 398	src->ops->set_state(src, SRC_STATE_INIT);
 399	src->ops->commit_write(src);
 400
 401	ct_timer_start(apcm->timer);
 402	return 0;
 403}
 404
 405static int atc_pcm_stop(struct ct_atc *atc, struct ct_atc_pcm *apcm)
 406{
 407	struct src *src;
 408	int i;
 409
 410	ct_timer_stop(apcm->timer);
 411
 412	src = apcm->src;
 413	src->ops->set_bm(src, 0);
 414	src->ops->set_state(src, SRC_STATE_OFF);
 415	src->ops->commit_write(src);
 416
 417	if (apcm->srccs) {
 418		for (i = 0; i < apcm->n_srcc; i++) {
 419			src = apcm->srccs[i];
 420			src->ops->set_bm(src, 0);
 421			src->ops->set_state(src, SRC_STATE_OFF);
 422			src->ops->commit_write(src);
 423		}
 424	}
 425
 426	apcm->started = 0;
 427
 428	return 0;
 429}
 430
 431static int
 432atc_pcm_playback_position(struct ct_atc *atc, struct ct_atc_pcm *apcm)
 433{
 434	struct src *src = apcm->src;
 435	u32 size, max_cisz;
 436	int position;
 437
 438	if (!src)
 439		return 0;
 440	position = src->ops->get_ca(src);
 441
 442	if (position < apcm->vm_block->addr) {
 443		dev_dbg(atc->card->dev,
 444			"bad ca - ca=0x%08x, vba=0x%08x, vbs=0x%08x\n",
 445			position, apcm->vm_block->addr, apcm->vm_block->size);
 446		position = apcm->vm_block->addr;
 447	}
 448
 449	size = apcm->vm_block->size;
 450	max_cisz = src->multi * src->rsc.msr;
 451	max_cisz = 128 * (max_cisz < 8 ? max_cisz : 8);
 452
 453	return (position + size - max_cisz - apcm->vm_block->addr) % size;
 454}
 455
 456struct src_node_conf_t {
 457	unsigned int pitch;
 458	unsigned int msr:8;
 459	unsigned int mix_msr:8;
 460	unsigned int imp_msr:8;
 461	unsigned int vo:1;
 462};
 463
 464static void setup_src_node_conf(struct ct_atc *atc, struct ct_atc_pcm *apcm,
 465				struct src_node_conf_t *conf, int *n_srcc)
 466{
 467	unsigned int pitch;
 468
 469	/* get pitch and convert to fixed-point 8.24 format. */
 470	pitch = atc_get_pitch((atc->rsr * atc->msr),
 471				apcm->substream->runtime->rate);
 472	*n_srcc = 0;
 473
 474	if (1 == atc->msr) { /* FIXME: do we really need SRC here if pitch==1 */
 475		*n_srcc = apcm->substream->runtime->channels;
 476		conf[0].pitch = pitch;
 477		conf[0].mix_msr = conf[0].imp_msr = conf[0].msr = 1;
 478		conf[0].vo = 1;
 479	} else if (2 <= atc->msr) {
 480		if (0x8000000 < pitch) {
 481			/* Need two-stage SRCs, SRCIMPs and
 482			 * AMIXERs for converting format */
 483			conf[0].pitch = (atc->msr << 24);
 484			conf[0].msr = conf[0].mix_msr = 1;
 485			conf[0].imp_msr = atc->msr;
 486			conf[0].vo = 0;
 487			conf[1].pitch = atc_get_pitch(atc->rsr,
 488					apcm->substream->runtime->rate);
 489			conf[1].msr = conf[1].mix_msr = conf[1].imp_msr = 1;
 490			conf[1].vo = 1;
 491			*n_srcc = apcm->substream->runtime->channels * 2;
 492		} else if (0x1000000 < pitch) {
 493			/* Need one-stage SRCs, SRCIMPs and
 494			 * AMIXERs for converting format */
 495			conf[0].pitch = pitch;
 496			conf[0].msr = conf[0].mix_msr
 497				    = conf[0].imp_msr = atc->msr;
 498			conf[0].vo = 1;
 499			*n_srcc = apcm->substream->runtime->channels;
 500		}
 501	}
 502}
 503
 504static int
 505atc_pcm_capture_get_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm)
 506{
 507	struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
 508	struct srcimp_mgr *srcimp_mgr = atc->rsc_mgrs[SRCIMP];
 509	struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER];
 510	struct sum_mgr *sum_mgr = atc->rsc_mgrs[SUM];
 511	struct src_desc src_dsc = {0};
 512	struct src *src;
 513	struct srcimp_desc srcimp_dsc = {0};
 514	struct srcimp *srcimp;
 515	struct amixer_desc mix_dsc = {0};
 516	struct sum_desc sum_dsc = {0};
 517	unsigned int pitch;
 518	int multi, err, i;
 519	int n_srcimp, n_amixer, n_srcc, n_sum;
 520	struct src_node_conf_t src_node_conf[2] = {{0} };
 521
 522	/* first release old resources */
 523	atc_pcm_release_resources(atc, apcm);
 524
 525	/* The numbers of converting SRCs and SRCIMPs should be determined
 526	 * by pitch value. */
 527
 528	multi = apcm->substream->runtime->channels;
 529
 530	/* get pitch and convert to fixed-point 8.24 format. */
 531	pitch = atc_get_pitch((atc->rsr * atc->msr),
 532				apcm->substream->runtime->rate);
 533
 534	setup_src_node_conf(atc, apcm, src_node_conf, &n_srcc);
 535	n_sum = (1 == multi) ? 1 : 0;
 536	n_amixer = n_sum * 2 + n_srcc;
 537	n_srcimp = n_srcc;
 538	if ((multi > 1) && (0x8000000 >= pitch)) {
 539		/* Need extra AMIXERs and SRCIMPs for special treatment
 540		 * of interleaved recording of conjugate channels */
 541		n_amixer += multi * atc->msr;
 542		n_srcimp += multi * atc->msr;
 543	} else {
 544		n_srcimp += multi;
 545	}
 546
 547	if (n_srcc) {
 548		apcm->srccs = kcalloc(n_srcc, sizeof(void *), GFP_KERNEL);
 549		if (!apcm->srccs)
 550			return -ENOMEM;
 551	}
 552	if (n_amixer) {
 553		apcm->amixers = kcalloc(n_amixer, sizeof(void *), GFP_KERNEL);
 554		if (!apcm->amixers) {
 555			err = -ENOMEM;
 556			goto error1;
 557		}
 558	}
 559	apcm->srcimps = kcalloc(n_srcimp, sizeof(void *), GFP_KERNEL);
 560	if (!apcm->srcimps) {
 561		err = -ENOMEM;
 562		goto error1;
 563	}
 564
 565	/* Allocate SRCs for sample rate conversion if needed */
 566	src_dsc.multi = 1;
 567	src_dsc.mode = ARCRW;
 568	for (i = 0, apcm->n_srcc = 0; i < n_srcc; i++) {
 569		src_dsc.msr = src_node_conf[i/multi].msr;
 570		err = src_mgr->get_src(src_mgr, &src_dsc,
 571					(struct src **)&apcm->srccs[i]);
 572		if (err)
 573			goto error1;
 574
 575		src = apcm->srccs[i];
 576		pitch = src_node_conf[i/multi].pitch;
 577		src->ops->set_pitch(src, pitch);
 578		src->ops->set_rom(src, select_rom(pitch));
 579		src->ops->set_vo(src, src_node_conf[i/multi].vo);
 580
 581		apcm->n_srcc++;
 582	}
 583
 584	/* Allocate AMIXERs for routing SRCs of conversion if needed */
 585	for (i = 0, apcm->n_amixer = 0; i < n_amixer; i++) {
 586		if (i < (n_sum*2))
 587			mix_dsc.msr = atc->msr;
 588		else if (i < (n_sum*2+n_srcc))
 589			mix_dsc.msr = src_node_conf[(i-n_sum*2)/multi].mix_msr;
 590		else
 591			mix_dsc.msr = 1;
 592
 593		err = amixer_mgr->get_amixer(amixer_mgr, &mix_dsc,
 594					(struct amixer **)&apcm->amixers[i]);
 595		if (err)
 596			goto error1;
 597
 598		apcm->n_amixer++;
 599	}
 600
 601	/* Allocate a SUM resource to mix all input channels together */
 602	sum_dsc.msr = atc->msr;
 603	err = sum_mgr->get_sum(sum_mgr, &sum_dsc, (struct sum **)&apcm->mono);
 604	if (err)
 605		goto error1;
 606
 607	pitch = atc_get_pitch((atc->rsr * atc->msr),
 608				apcm->substream->runtime->rate);
 609	/* Allocate SRCIMP resources */
 610	for (i = 0, apcm->n_srcimp = 0; i < n_srcimp; i++) {
 611		if (i < (n_srcc))
 612			srcimp_dsc.msr = src_node_conf[i/multi].imp_msr;
 613		else if (1 == multi)
 614			srcimp_dsc.msr = (pitch <= 0x8000000) ? atc->msr : 1;
 615		else
 616			srcimp_dsc.msr = 1;
 617
 618		err = srcimp_mgr->get_srcimp(srcimp_mgr, &srcimp_dsc, &srcimp);
 619		if (err)
 620			goto error1;
 621
 622		apcm->srcimps[i] = srcimp;
 623		apcm->n_srcimp++;
 624	}
 625
 626	/* Allocate a SRC for writing data to host memory */
 627	src_dsc.multi = apcm->substream->runtime->channels;
 628	src_dsc.msr = 1;
 629	src_dsc.mode = MEMWR;
 630	err = src_mgr->get_src(src_mgr, &src_dsc, (struct src **)&apcm->src);
 631	if (err)
 632		goto error1;
 633
 634	src = apcm->src;
 635	src->ops->set_pitch(src, pitch);
 636
 637	/* Set up device virtual mem map */
 638	err = ct_map_audio_buffer(atc, apcm);
 639	if (err < 0)
 640		goto error1;
 641
 642	return 0;
 643
 644error1:
 645	atc_pcm_release_resources(atc, apcm);
 646	return err;
 647}
 648
 649static int atc_pcm_capture_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm)
 650{
 651	struct src *src;
 652	struct amixer *amixer;
 653	struct srcimp *srcimp;
 654	struct ct_mixer *mixer = atc->mixer;
 655	struct sum *mono;
 656	struct rsc *out_ports[8] = {NULL};
 657	int err, i, j, n_sum, multi;
 658	unsigned int pitch;
 659	int mix_base = 0, imp_base = 0;
 660
 661	atc_pcm_release_resources(atc, apcm);
 662
 663	/* Get needed resources. */
 664	err = atc_pcm_capture_get_resources(atc, apcm);
 665	if (err)
 666		return err;
 667
 668	/* Connect resources */
 669	mixer->get_output_ports(mixer, MIX_PCMO_FRONT,
 670				&out_ports[0], &out_ports[1]);
 671
 672	multi = apcm->substream->runtime->channels;
 673	if (1 == multi) {
 674		mono = apcm->mono;
 675		for (i = 0; i < 2; i++) {
 676			amixer = apcm->amixers[i];
 677			amixer->ops->setup(amixer, out_ports[i],
 678						MONO_SUM_SCALE, mono);
 679		}
 680		out_ports[0] = &mono->rsc;
 681		n_sum = 1;
 682		mix_base = n_sum * 2;
 683	}
 684
 685	for (i = 0; i < apcm->n_srcc; i++) {
 686		src = apcm->srccs[i];
 687		srcimp = apcm->srcimps[imp_base+i];
 688		amixer = apcm->amixers[mix_base+i];
 689		srcimp->ops->map(srcimp, src, out_ports[i%multi]);
 690		amixer->ops->setup(amixer, &src->rsc, INIT_VOL, NULL);
 691		out_ports[i%multi] = &amixer->rsc;
 692	}
 693
 694	pitch = atc_get_pitch((atc->rsr * atc->msr),
 695				apcm->substream->runtime->rate);
 696
 697	if ((multi > 1) && (pitch <= 0x8000000)) {
 698		/* Special connection for interleaved
 699		 * recording with conjugate channels */
 700		for (i = 0; i < multi; i++) {
 701			out_ports[i]->ops->master(out_ports[i]);
 702			for (j = 0; j < atc->msr; j++) {
 703				amixer = apcm->amixers[apcm->n_srcc+j*multi+i];
 704				amixer->ops->set_input(amixer, out_ports[i]);
 705				amixer->ops->set_scale(amixer, INIT_VOL);
 706				amixer->ops->set_sum(amixer, NULL);
 707				amixer->ops->commit_raw_write(amixer);
 708				out_ports[i]->ops->next_conj(out_ports[i]);
 709
 710				srcimp = apcm->srcimps[apcm->n_srcc+j*multi+i];
 711				srcimp->ops->map(srcimp, apcm->src,
 712							&amixer->rsc);
 713			}
 714		}
 715	} else {
 716		for (i = 0; i < multi; i++) {
 717			srcimp = apcm->srcimps[apcm->n_srcc+i];
 718			srcimp->ops->map(srcimp, apcm->src, out_ports[i]);
 719		}
 720	}
 721
 722	ct_timer_prepare(apcm->timer);
 723
 724	return 0;
 725}
 726
 727static int atc_pcm_capture_start(struct ct_atc *atc, struct ct_atc_pcm *apcm)
 728{
 729	struct src *src;
 730	struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
 731	int i, multi;
 732
 733	if (apcm->started)
 734		return 0;
 735
 736	apcm->started = 1;
 737	multi = apcm->substream->runtime->channels;
 738	/* Set up converting SRCs */
 739	for (i = 0; i < apcm->n_srcc; i++) {
 740		src = apcm->srccs[i];
 741		src->ops->set_pm(src, ((i%multi) != (multi-1)));
 742		src_mgr->src_disable(src_mgr, src);
 743	}
 744
 745	/*  Set up recording SRC */
 746	src = apcm->src;
 747	src->ops->set_sf(src, convert_format(apcm->substream->runtime->format,
 748					     atc->card));
 749	src->ops->set_sa(src, apcm->vm_block->addr);
 750	src->ops->set_la(src, apcm->vm_block->addr + apcm->vm_block->size);
 751	src->ops->set_ca(src, apcm->vm_block->addr);
 752	src_mgr->src_disable(src_mgr, src);
 753
 754	/* Disable relevant SRCs firstly */
 755	src_mgr->commit_write(src_mgr);
 756
 757	/* Enable SRCs respectively */
 758	for (i = 0; i < apcm->n_srcc; i++) {
 759		src = apcm->srccs[i];
 760		src->ops->set_state(src, SRC_STATE_RUN);
 761		src->ops->commit_write(src);
 762		src_mgr->src_enable_s(src_mgr, src);
 763	}
 764	src = apcm->src;
 765	src->ops->set_bm(src, 1);
 766	src->ops->set_state(src, SRC_STATE_RUN);
 767	src->ops->commit_write(src);
 768	src_mgr->src_enable_s(src_mgr, src);
 769
 770	/* Enable relevant SRCs synchronously */
 771	src_mgr->commit_write(src_mgr);
 772
 773	ct_timer_start(apcm->timer);
 774	return 0;
 775}
 776
 777static int
 778atc_pcm_capture_position(struct ct_atc *atc, struct ct_atc_pcm *apcm)
 779{
 780	struct src *src = apcm->src;
 781
 782	if (!src)
 783		return 0;
 784	return src->ops->get_ca(src) - apcm->vm_block->addr;
 785}
 786
 787static int spdif_passthru_playback_get_resources(struct ct_atc *atc,
 788						 struct ct_atc_pcm *apcm)
 789{
 790	struct src_mgr *src_mgr = atc->rsc_mgrs[SRC];
 791	struct amixer_mgr *amixer_mgr = atc->rsc_mgrs[AMIXER];
 792	struct src_desc desc = {0};
 793	struct amixer_desc mix_dsc = {0};
 794	struct src *src;
 795	int err;
 796	int n_amixer = apcm->substream->runtime->channels, i;
 797	unsigned int pitch, rsr = atc->pll_rate;
 798
 799	/* first release old resources */
 800	atc_pcm_release_resources(atc, apcm);
 801
 802	/* Get SRC resource */
 803	desc.multi = apcm->substream->runtime->channels;
 804	desc.msr = 1;
 805	while (apcm->substream->runtime->rate > (rsr * desc.msr))
 806		desc.msr <<= 1;
 807
 808	desc.mode = MEMRD;
 809	err = src_mgr->get_src(src_mgr, &desc, (struct src **)&apcm->src);
 810	if (err)
 811		goto error1;
 812
 813	pitch = atc_get_pitch(apcm->substream->runtime->rate, (rsr * desc.msr));
 814	src = apcm->src;
 815	src->ops->set_pitch(src, pitch);
 816	src->ops->set_rom(src, select_rom(pitch));
 817	src->ops->set_sf(src, convert_format(apcm->substream->runtime->format,
 818					     atc->card));
 819	src->ops->set_pm(src, (src->ops->next_interleave(src) != NULL));
 820	src->ops->set_bp(src, 1);
 821
 822	/* Get AMIXER resource */
 823	n_amixer = (n_amixer < 2) ? 2 : n_amixer;
 824	apcm->amixers = kcalloc(n_amixer, sizeof(void *), GFP_KERNEL);
 825	if (!apcm->amixers) {
 826		err = -ENOMEM;
 827		goto error1;
 828	}
 829	mix_dsc.msr = desc.msr;
 830	for (i = 0, apcm->n_amixer = 0; i < n_amixer; i++) {
 831		err = amixer_mgr->get_amixer(amixer_mgr, &mix_dsc,
 832					(struct amixer **)&apcm->amixers[i]);
 833		if (err)
 834			goto error1;
 835
 836		apcm->n_amixer++;
 837	}
 838
 839	/* Set up device virtual mem map */
 840	err = ct_map_audio_buffer(atc, apcm);
 841	if (err < 0)
 842		goto error1;
 843
 844	return 0;
 845
 846error1:
 847	atc_pcm_release_resources(atc, apcm);
 848	return err;
 849}
 850
 851static int atc_pll_init(struct ct_atc *atc, int rate)
 852{
 853	struct hw *hw = atc->hw;
 854	int err;
 855	err = hw->pll_init(hw, rate);
 856	atc->pll_rate = err ? 0 : rate;
 857	return err;
 858}
 859
 860static int
 861spdif_passthru_playback_setup(struct ct_atc *atc, struct ct_atc_pcm *apcm)
 862{
 863	struct dao *dao = container_of(atc->daios[SPDIFOO], struct dao, daio);
 864	unsigned int rate = apcm->substream->runtime->rate;
 865	unsigned int status;
 866	int err = 0;
 867	unsigned char iec958_con_fs;
 868
 869	switch (rate) {
 870	case 48000:
 871		iec958_con_fs = IEC958_AES3_CON_FS_48000;
 872		break;
 873	case 44100:
 874		iec958_con_fs = IEC958_AES3_CON_FS_44100;
 875		break;
 876	case 32000:
 877		iec958_con_fs = IEC958_AES3_CON_FS_32000;
 878		break;
 879	default:
 880		return -ENOENT;
 881	}
 882
 883	guard(mutex)(&atc->atc_mutex);
 884	dao->ops->get_spos(dao, &status);
 885	if (((status >> 24) & IEC958_AES3_CON_FS) != iec958_con_fs) {
 886		status &= ~(IEC958_AES3_CON_FS << 24);
 887		status |= (iec958_con_fs << 24);
 888		dao->ops->set_spos(dao, status);
 889		dao->ops->commit_write(dao);
 890	}
 891	if ((rate != atc->pll_rate) && (32000 != rate))
 892		err = atc_pll_init(atc, rate);
 893
 894	return err;
 895}
 896
 897static int
 898spdif_passthru_playback_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm)
 899{
 900	struct src *src;
 901	struct amixer *amixer;
 902	struct dao *dao;
 903	int err;
 904	int i;
 905
 906	atc_pcm_release_resources(atc, apcm);
 907
 908	/* Configure SPDIFOO and PLL to passthrough mode;
 909	 * determine pll_rate. */
 910	err = spdif_passthru_playback_setup(atc, apcm);
 911	if (err)
 912		return err;
 913
 914	/* Get needed resources. */
 915	err = spdif_passthru_playback_get_resources(atc, apcm);
 916	if (err)
 917		return err;
 918
 919	/* Connect resources */
 920	src = apcm->src;
 921	for (i = 0; i < apcm->n_amixer; i++) {
 922		amixer = apcm->amixers[i];
 923		amixer->ops->setup(amixer, &src->rsc, INIT_VOL, NULL);
 924		src = src->ops->next_interleave(src);
 925		if (!src)
 926			src = apcm->src;
 927	}
 928	/* Connect to SPDIFOO */
 929	scoped_guard(mutex, &atc->atc_mutex) {
 930		dao = container_of(atc->daios[SPDIFOO], struct dao, daio);
 931		amixer = apcm->amixers[0];
 932		dao->ops->set_left_input(dao, &amixer->rsc);
 933		amixer = apcm->amixers[1];
 934		dao->ops->set_right_input(dao, &amixer->rsc);
 935	}
 936
 937	ct_timer_prepare(apcm->timer);
 938
 939	return 0;
 940}
 941
 942static int atc_select_line_in(struct ct_atc *atc)
 943{
 944	struct hw *hw = atc->hw;
 945	struct ct_mixer *mixer = atc->mixer;
 946	struct src *src;
 947
 948	if (hw->is_adc_source_selected(hw, ADC_LINEIN))
 949		return 0;
 950
 951	mixer->set_input_left(mixer, MIX_MIC_IN, NULL);
 952	mixer->set_input_right(mixer, MIX_MIC_IN, NULL);
 953
 954	hw->select_adc_source(hw, ADC_LINEIN);
 955
 956	src = atc->srcs[2];
 957	mixer->set_input_left(mixer, MIX_LINE_IN, &src->rsc);
 958	src = atc->srcs[3];
 959	mixer->set_input_right(mixer, MIX_LINE_IN, &src->rsc);
 960
 961	return 0;
 962}
 963
 964static int atc_select_mic_in(struct ct_atc *atc)
 965{
 966	struct hw *hw = atc->hw;
 967	struct ct_mixer *mixer = atc->mixer;
 968	struct src *src;
 969
 970	if (hw->is_adc_source_selected(hw, ADC_MICIN))
 971		return 0;
 972
 973	mixer->set_input_left(mixer, MIX_LINE_IN, NULL);
 974	mixer->set_input_right(mixer, MIX_LINE_IN, NULL);
 975
 976	hw->select_adc_source(hw, ADC_MICIN);
 977
 978	src = atc->srcs[2];
 979	mixer->set_input_left(mixer, MIX_MIC_IN, &src->rsc);
 980	src = atc->srcs[3];
 981	mixer->set_input_right(mixer, MIX_MIC_IN, &src->rsc);
 982
 983	return 0;
 984}
 985
 986static struct capabilities atc_capabilities(struct ct_atc *atc)
 987{
 988	struct hw *hw = atc->hw;
 989
 990	return hw->capabilities(hw);
 991}
 992
 993static void atc_dedicated_rca_select(struct ct_atc *atc)
 994{
 995	struct dao *dao;
 996	struct ct_mixer *mixer = atc->mixer;
 997	struct rsc *rscs[2] = {NULL};
 998
 999	dao = container_of(atc->daios[atc->rca_state ? RCA : LINEO1],
1000		struct dao, daio);
1001	dao->ops->clear_left_input(dao);
1002	dao->ops->clear_right_input(dao);
1003
1004	mixer->get_output_ports(mixer, MIX_WAVE_FRONT, &rscs[0], &rscs[1]);
1005	dao = container_of(atc->daios[atc->rca_state ? LINEO1 : RCA],
1006		struct dao, daio);
1007	dao->ops->set_left_input(dao, rscs[0]);
1008	dao->ops->set_right_input(dao, rscs[1]);
1009}
1010
1011static int atc_output_switch_get(struct ct_atc *atc)
1012{
1013	struct hw *hw = atc->hw;
1014
1015	return hw->output_switch_get(hw);
1016}
1017
1018static int atc_output_switch_put(struct ct_atc *atc, int position)
1019{
1020	struct hw *hw = atc->hw;
1021
1022	return hw->output_switch_put(hw, position);
1023}
1024
1025static int atc_mic_source_switch_get(struct ct_atc *atc)
1026{
1027	struct hw *hw = atc->hw;
1028
1029	return hw->mic_source_switch_get(hw);
1030}
1031
1032static int atc_mic_source_switch_put(struct ct_atc *atc, int position)
1033{
1034	struct hw *hw = atc->hw;
1035
1036	return hw->mic_source_switch_put(hw, position);
1037}
1038
1039static int atc_select_digit_io(struct ct_atc *atc)
1040{
1041	struct hw *hw = atc->hw;
1042
1043	if (hw->is_adc_source_selected(hw, ADC_NONE))
1044		return 0;
1045
1046	hw->select_adc_source(hw, ADC_NONE);
1047
1048	return 0;
1049}
1050
1051static int atc_daio_unmute(struct ct_atc *atc, unsigned char state, int type)
1052{
1053	struct daio_mgr *daio_mgr = atc->rsc_mgrs[DAIO];
1054
1055	if (state)
1056		daio_mgr->daio_enable(daio_mgr, atc->daios[type]);
1057	else
1058		daio_mgr->daio_disable(daio_mgr, atc->daios[type]);
1059
1060	daio_mgr->commit_write(daio_mgr);
1061
1062	return 0;
1063}
1064
1065static int
1066atc_dao_get_status(struct ct_atc *atc, unsigned int *status, int type)
1067{
1068	struct dao *dao = container_of(atc->daios[type], struct dao, daio);
1069	return dao->ops->get_spos(dao, status);
1070}
1071
1072static int
1073atc_dao_set_status(struct ct_atc *atc, unsigned int status, int type)
1074{
1075	struct dao *dao = container_of(atc->daios[type], struct dao, daio);
1076
1077	dao->ops->set_spos(dao, status);
1078	dao->ops->commit_write(dao);
1079	return 0;
1080}
1081
1082static int atc_line_front_unmute(struct ct_atc *atc, unsigned char state)
1083{
1084	return atc_daio_unmute(atc, state, LINEO1);
1085}
1086
1087static int atc_line_surround_unmute(struct ct_atc *atc, unsigned char state)
1088{
1089	return atc_daio_unmute(atc, state, LINEO2);
1090}
1091
1092static int atc_line_clfe_unmute(struct ct_atc *atc, unsigned char state)
1093{
1094	return atc_daio_unmute(atc, state, LINEO3);
1095}
1096
1097static int atc_line_rear_unmute(struct ct_atc *atc, unsigned char state)
1098{
1099	return atc_daio_unmute(atc, state, LINEO4);
1100}
1101
1102static int atc_line_in_unmute(struct ct_atc *atc, unsigned char state)
1103{
1104	return atc_daio_unmute(atc, state, LINEIM);
1105}
1106
1107static int atc_mic_unmute(struct ct_atc *atc, unsigned char state)
1108{
1109	return atc_daio_unmute(atc, state, MIC);
1110}
1111
1112static int atc_rca_unmute(struct ct_atc *atc, unsigned char state)
1113{
1114	return atc_daio_unmute(atc, state, RCA);
1115}
1116
1117static int atc_spdif_out_unmute(struct ct_atc *atc, unsigned char state)
1118{
1119	return atc_daio_unmute(atc, state, SPDIFOO);
1120}
1121
1122static int atc_spdif_in_unmute(struct ct_atc *atc, unsigned char state)
1123{
1124	return atc_daio_unmute(atc, state, SPDIFIO);
1125}
1126
1127static int atc_spdif_out_get_status(struct ct_atc *atc, unsigned int *status)
1128{
1129	return atc_dao_get_status(atc, status, SPDIFOO);
1130}
1131
1132static int atc_spdif_out_set_status(struct ct_atc *atc, unsigned int status)
1133{
1134	return atc_dao_set_status(atc, status, SPDIFOO);
1135}
1136
1137static int atc_spdif_out_passthru(struct ct_atc *atc, unsigned char state)
1138{
1139	struct dao_desc da_dsc = {0};
1140	struct dao *dao;
1141	int err;
1142	struct ct_mixer *mixer = atc->mixer;
1143	struct rsc *rscs[2] = {NULL};
1144	unsigned int spos = 0;
1145
1146	guard(mutex)(&atc->atc_mutex);
1147	dao = container_of(atc->daios[SPDIFOO], struct dao, daio);
1148	da_dsc.msr = state ? 1 : atc->msr;
1149	da_dsc.passthru = state ? 1 : 0;
1150	err = dao->ops->reinit(dao, &da_dsc);
1151	if (state) {
1152		spos = IEC958_DEFAULT_CON;
1153	} else {
1154		mixer->get_output_ports(mixer, MIX_SPDIF_OUT,
1155					&rscs[0], &rscs[1]);
1156		dao->ops->set_left_input(dao, rscs[0]);
1157		dao->ops->set_right_input(dao, rscs[1]);
1158		/* Restore PLL to atc->rsr if needed. */
1159		if (atc->pll_rate != atc->rsr)
1160			err = atc_pll_init(atc, atc->rsr);
1161	}
1162	dao->ops->set_spos(dao, spos);
1163	dao->ops->commit_write(dao);
1164
1165	return err;
1166}
1167
1168static int atc_release_resources(struct ct_atc *atc)
1169{
1170	int i;
1171	struct daio_mgr *daio_mgr = NULL;
1172	struct dao *dao = NULL;
1173	struct daio *daio = NULL;
1174	struct sum_mgr *sum_mgr = NULL;
1175	struct src_mgr *src_mgr = NULL;
1176	struct srcimp_mgr *srcimp_mgr = NULL;
1177	struct srcimp *srcimp = NULL;
1178	struct ct_mixer *mixer = NULL;
1179
1180	/* disconnect internal mixer objects */
1181	if (atc->mixer) {
1182		mixer = atc->mixer;
1183		mixer->set_input_left(mixer, MIX_LINE_IN, NULL);
1184		mixer->set_input_right(mixer, MIX_LINE_IN, NULL);
1185		mixer->set_input_left(mixer, MIX_MIC_IN, NULL);
1186		mixer->set_input_right(mixer, MIX_MIC_IN, NULL);
1187		mixer->set_input_left(mixer, MIX_SPDIF_IN, NULL);
1188		mixer->set_input_right(mixer, MIX_SPDIF_IN, NULL);
1189	}
1190
1191	if (atc->daios) {
1192		daio_mgr = (struct daio_mgr *)atc->rsc_mgrs[DAIO];
1193		for (i = 0; i < NUM_DAIOTYP; i++) {
1194			daio = atc->daios[i];
1195			if (!daio)
1196				continue;
1197			if (daio->output) {
1198				dao = container_of(daio, struct dao, daio);
1199				dao->ops->clear_left_input(dao);
1200				dao->ops->clear_right_input(dao);
1201			}
1202			daio_mgr->put_daio(daio_mgr, daio);
1203		}
1204		kfree(atc->daios);
1205		atc->daios = NULL;
1206	}
1207
1208	if (atc->pcm) {
1209		sum_mgr = atc->rsc_mgrs[SUM];
1210		for (i = 0; i < NUM_ATC_PCM; i++)
1211			if (atc->pcm[i])
1212				sum_mgr->put_sum(sum_mgr, atc->pcm[i]);
1213
1214		kfree(atc->pcm);
1215		atc->pcm = NULL;
1216	}
1217
1218	if (atc->srcs) {
1219		src_mgr = atc->rsc_mgrs[SRC];
1220		for (i = 0; i < NUM_ATC_SRCS; i++)
1221			if (atc->srcs[i])
1222				src_mgr->put_src(src_mgr, atc->srcs[i]);
1223
1224		kfree(atc->srcs);
1225		atc->srcs = NULL;
1226	}
1227
1228	if (atc->srcimps) {
1229		srcimp_mgr = atc->rsc_mgrs[SRCIMP];
1230		for (i = 0; i < NUM_ATC_SRCS; i++) {
1231			if (!atc->srcimps[i])
1232				continue;
1233			srcimp = atc->srcimps[i];
1234			srcimp->ops->unmap(srcimp);
1235			srcimp_mgr->put_srcimp(srcimp_mgr, atc->srcimps[i]);
1236		}
1237		kfree(atc->srcimps);
1238		atc->srcimps = NULL;
1239	}
1240
1241	return 0;
1242}
1243
1244static int ct_atc_destroy(struct ct_atc *atc)
1245{
1246	int i = 0;
1247
1248	if (!atc)
1249		return 0;
1250
1251	if (atc->timer) {
1252		ct_timer_free(atc->timer);
1253		atc->timer = NULL;
1254	}
1255
1256	atc_release_resources(atc);
1257
1258	/* Destroy internal mixer objects */
1259	if (atc->mixer)
1260		ct_mixer_destroy(atc->mixer);
1261
1262	for (i = 0; i < NUM_RSCTYP; i++) {
1263		if (rsc_mgr_funcs[i].destroy && atc->rsc_mgrs[i])
1264			rsc_mgr_funcs[i].destroy(atc->rsc_mgrs[i]);
1265
1266	}
1267
1268	if (atc->hw)
1269		destroy_hw_obj(atc->hw);
1270
1271	/* Destroy device virtual memory manager object */
1272	if (atc->vm) {
1273		ct_vm_destroy(atc->vm);
1274		atc->vm = NULL;
1275	}
1276
1277	kfree(atc);
1278
1279	return 0;
1280}
1281
1282static int atc_dev_free(struct snd_device *dev)
1283{
1284	struct ct_atc *atc = dev->device_data;
1285	return ct_atc_destroy(atc);
1286}
1287
1288static int atc_identify_card(struct ct_atc *atc, unsigned int ssid)
1289{
1290	const struct snd_pci_quirk *p;
1291	const struct snd_pci_quirk *list;
1292	u16 vendor_id, device_id;
1293
1294	switch (atc->chip_type) {
1295	case ATC20K1:
1296		atc->chip_name = "20K1";
1297		list = subsys_20k1_list;
1298		break;
1299	case ATC20K2:
1300		atc->chip_name = "20K2";
1301		list = subsys_20k2_list;
1302		break;
1303	default:
1304		return -ENOENT;
1305	}
1306	if (ssid) {
1307		vendor_id = ssid >> 16;
1308		device_id = ssid & 0xffff;
1309	} else {
1310		vendor_id = atc->pci->subsystem_vendor;
1311		device_id = atc->pci->subsystem_device;
1312	}
1313	p = snd_pci_quirk_lookup_id(vendor_id, device_id, list);
1314	if (p) {
1315		if (p->value < 0) {
1316			dev_err(atc->card->dev,
1317				"Device %04x:%04x is on the denylist\n",
1318				vendor_id, device_id);
1319			return -ENOENT;
1320		}
1321		atc->model = p->value;
1322	} else {
1323		if (atc->chip_type == ATC20K1)
1324			atc->model = CT20K1_UNKNOWN;
1325		else
1326			atc->model = CT20K2_UNKNOWN;
1327	}
1328	atc->model_name = ct_subsys_name[atc->model];
1329	dev_info(atc->card->dev, "chip %s model %s (%04x:%04x) is found\n",
1330		   atc->chip_name, atc->model_name,
1331		   vendor_id, device_id);
1332	atc->rca_state = 0;
1333	return 0;
1334}
1335
1336int ct_atc_create_alsa_devs(struct ct_atc *atc)
1337{
1338	enum CTALSADEVS i;
1339	int err;
1340
1341	alsa_dev_funcs[MIXER].public_name = atc->chip_name;
1342
1343	for (i = 0; i < NUM_CTALSADEVS; i++) {
1344		if (!alsa_dev_funcs[i].create)
1345			continue;
1346
1347		err = alsa_dev_funcs[i].create(atc, i,
1348				alsa_dev_funcs[i].public_name);
1349		if (err) {
1350			dev_err(atc->card->dev,
1351				"Creating alsa device %d failed!\n", i);
1352			return err;
1353		}
1354	}
1355
1356	return 0;
1357}
1358
1359static int atc_create_hw_devs(struct ct_atc *atc)
1360{
1361	struct hw *hw;
1362	struct card_conf info = {0};
1363	int i, err;
1364
1365	err = create_hw_obj(atc->pci, atc->chip_type, atc->model, &hw);
1366	if (err) {
1367		dev_err(atc->card->dev, "Failed to create hw obj!!!\n");
1368		return err;
1369	}
1370	hw->card = atc->card;
1371	atc->hw = hw;
1372
1373	/* Initialize card hardware. */
1374	info.rsr = atc->rsr;
1375	info.msr = atc->msr;
1376	info.vm_pgt_phys = atc_get_ptp_phys(atc, 0);
1377	err = hw->card_init(hw, &info);
1378	if (err < 0)
1379		return err;
1380
1381	for (i = 0; i < NUM_RSCTYP; i++) {
1382		if (!rsc_mgr_funcs[i].create)
1383			continue;
1384
1385		err = rsc_mgr_funcs[i].create(atc->hw, &atc->rsc_mgrs[i]);
1386		if (err) {
1387			dev_err(atc->card->dev,
1388				"Failed to create rsc_mgr %d!!!\n", i);
1389			return err;
1390		}
1391	}
1392
1393	return 0;
1394}
1395
1396static int atc_get_resources(struct ct_atc *atc)
1397{
1398	struct daio_desc da_desc = {0};
1399	struct daio_mgr *daio_mgr;
1400	struct src_desc src_dsc = {0};
1401	struct src_mgr *src_mgr;
1402	struct srcimp_desc srcimp_dsc = {0};
1403	struct srcimp_mgr *srcimp_mgr;
1404	struct sum_desc sum_dsc = {0};
1405	struct sum_mgr *sum_mgr;
1406	struct capabilities cap;
1407	int err, i;
1408
1409	cap = atc->capabilities(atc);
1410
1411	atc->daios = kcalloc(NUM_DAIOTYP, sizeof(void *), GFP_KERNEL);
1412	if (!atc->daios)
1413		return -ENOMEM;
1414
1415	atc->srcs = kcalloc(NUM_ATC_SRCS, sizeof(void *), GFP_KERNEL);
1416	if (!atc->srcs)
1417		return -ENOMEM;
1418
1419	atc->srcimps = kcalloc(NUM_ATC_SRCS, sizeof(void *), GFP_KERNEL);
1420	if (!atc->srcimps)
1421		return -ENOMEM;
1422
1423	atc->pcm = kcalloc(NUM_ATC_PCM, sizeof(void *), GFP_KERNEL);
1424	if (!atc->pcm)
1425		return -ENOMEM;
1426
1427	daio_mgr = (struct daio_mgr *)atc->rsc_mgrs[DAIO];
1428	da_desc.msr = atc->msr;
1429	for (i = 0; i < NUM_DAIOTYP; i++) {
1430		if (((i == MIC) && !cap.dedicated_mic) ||
1431		    ((i == RCA) && !cap.dedicated_rca) ||
1432		    i == SPDIFI1)
1433			continue;
1434		if (atc->model == CTSB073X && i == SPDIFIO)
1435			da_desc.type = SPDIFI1;
1436		else
1437			da_desc.type = i;
1438		da_desc.output = (i < LINEIM) || (i == RCA);
1439		err = daio_mgr->get_daio(daio_mgr, &da_desc,
1440					(struct daio **)&atc->daios[i]);
1441		if (err) {
1442			dev_err(atc->card->dev,
1443				"Failed to get DAIO resource %d!!!\n",
1444				i);
1445			return err;
1446		}
1447	}
1448
1449	src_mgr = atc->rsc_mgrs[SRC];
1450	src_dsc.multi = 1;
1451	src_dsc.msr = atc->msr;
1452	src_dsc.mode = ARCRW;
1453	for (i = 0; i < NUM_ATC_SRCS; i++) {
1454		if (((i > 3) && !cap.dedicated_mic))
1455			continue;
1456		err = src_mgr->get_src(src_mgr, &src_dsc,
1457					(struct src **)&atc->srcs[i]);
1458		if (err)
1459			return err;
1460	}
1461
1462	srcimp_mgr = atc->rsc_mgrs[SRCIMP];
1463	srcimp_dsc.msr = 8;
1464	for (i = 0; i < NUM_ATC_SRCS; i++) {
1465		if (((i > 3) && !cap.dedicated_mic))
1466			continue;
1467		err = srcimp_mgr->get_srcimp(srcimp_mgr, &srcimp_dsc,
1468					(struct srcimp **)&atc->srcimps[i]);
1469		if (err)
1470			return err;
1471	}
1472
1473	sum_mgr = atc->rsc_mgrs[SUM];
1474	sum_dsc.msr = atc->msr;
1475	for (i = 0; i < NUM_ATC_PCM; i++) {
1476		err = sum_mgr->get_sum(sum_mgr, &sum_dsc,
1477					(struct sum **)&atc->pcm[i]);
1478		if (err)
1479			return err;
1480	}
1481
1482	return 0;
1483}
1484
1485static void
1486atc_connect_dai(struct src_mgr *src_mgr, struct dai *dai,
1487		struct src **srcs, struct srcimp **srcimps)
1488{
1489	struct rsc *rscs[2] = {NULL};
1490	struct src *src;
1491	struct srcimp *srcimp;
1492	int i = 0;
1493
1494	rscs[0] = &dai->daio.rscl;
1495	rscs[1] = &dai->daio.rscr;
1496	for (i = 0; i < 2; i++) {
1497		src = srcs[i];
1498		srcimp = srcimps[i];
1499		srcimp->ops->map(srcimp, src, rscs[i]);
1500		src_mgr->src_disable(src_mgr, src);
1501	}
1502
1503	src_mgr->commit_write(src_mgr); /* Actually disable SRCs */
1504
1505	src = srcs[0];
1506	src->ops->set_pm(src, 1);
1507	for (i = 0; i < 2; i++) {
1508		src = srcs[i];
1509		src->ops->set_state(src, SRC_STATE_RUN);
1510		src->ops->commit_write(src);
1511		src_mgr->src_enable_s(src_mgr, src);
1512	}
1513
1514	dai->ops->set_srt_srcl(dai, &(srcs[0]->rsc));
1515	dai->ops->set_srt_srcr(dai, &(srcs[1]->rsc));
1516
1517	dai->ops->set_enb_src(dai, 1);
1518	dai->ops->set_enb_srt(dai, 1);
1519	dai->ops->commit_write(dai);
1520
1521	src_mgr->commit_write(src_mgr); /* Synchronously enable SRCs */
1522}
1523
1524static void atc_connect_resources(struct ct_atc *atc)
1525{
1526	struct dai *dai;
1527	struct dao *dao;
1528	struct src *src;
1529	struct sum *sum;
1530	struct ct_mixer *mixer;
1531	struct rsc *rscs[2] = {NULL};
1532	struct capabilities cap;
1533	int i, j;
1534
1535	mixer = atc->mixer;
1536	cap = atc->capabilities(atc);
1537
1538	for (i = MIX_WAVE_FRONT, j = LINEO1; i <= MIX_SPDIF_OUT; i++, j++) {
1539		mixer->get_output_ports(mixer, i, &rscs[0], &rscs[1]);
1540		dao = container_of(atc->daios[j], struct dao, daio);
1541		dao->ops->set_left_input(dao, rscs[0]);
1542		dao->ops->set_right_input(dao, rscs[1]);
1543	}
1544
1545	if (cap.dedicated_rca) {
1546		/* SE-300PCIE has a dedicated DAC for the RCA. */
1547		atc_dedicated_rca_select(atc);
1548	}
1549
1550	dai = container_of(atc->daios[LINEIM], struct dai, daio);
1551	atc_connect_dai(atc->rsc_mgrs[SRC], dai,
1552			(struct src **)&atc->srcs[2],
1553			(struct srcimp **)&atc->srcimps[2]);
1554	src = atc->srcs[2];
1555	mixer->set_input_left(mixer, MIX_LINE_IN, &src->rsc);
1556	src = atc->srcs[3];
1557	mixer->set_input_right(mixer, MIX_LINE_IN, &src->rsc);
1558
1559	if (cap.dedicated_mic) {
1560		/* Titanium HD has a dedicated ADC for the Mic. */
1561		/* SE-300PCIE has a 4-channel ADC. */
1562		dai = container_of(atc->daios[MIC], struct dai, daio);
1563		atc_connect_dai(atc->rsc_mgrs[SRC], dai,
1564			(struct src **)&atc->srcs[4],
1565			(struct srcimp **)&atc->srcimps[4]);
1566		src = atc->srcs[4];
1567		mixer->set_input_left(mixer, MIX_MIC_IN, &src->rsc);
1568		src = atc->srcs[5];
1569		mixer->set_input_right(mixer, MIX_MIC_IN, &src->rsc);
1570	}
1571
1572	dai = container_of(atc->daios[SPDIFIO], struct dai, daio);
1573	atc_connect_dai(atc->rsc_mgrs[SRC], dai,
1574			(struct src **)&atc->srcs[0],
1575			(struct srcimp **)&atc->srcimps[0]);
1576
1577	src = atc->srcs[0];
1578	mixer->set_input_left(mixer, MIX_SPDIF_IN, &src->rsc);
1579	src = atc->srcs[1];
1580	mixer->set_input_right(mixer, MIX_SPDIF_IN, &src->rsc);
1581
1582	for (i = MIX_PCMI_FRONT, j = 0; i <= MIX_PCMI_SURROUND; i++, j += 2) {
1583		sum = atc->pcm[j];
1584		mixer->set_input_left(mixer, i, &sum->rsc);
1585		sum = atc->pcm[j+1];
1586		mixer->set_input_right(mixer, i, &sum->rsc);
1587	}
1588}
1589
1590#ifdef CONFIG_PM_SLEEP
1591static int atc_suspend(struct ct_atc *atc)
1592{
1593	struct hw *hw = atc->hw;
1594
1595	snd_power_change_state(atc->card, SNDRV_CTL_POWER_D3hot);
1596
1597	atc_release_resources(atc);
1598
1599	hw->suspend(hw);
1600
1601	return 0;
1602}
1603
1604static int atc_hw_resume(struct ct_atc *atc)
1605{
1606	struct hw *hw = atc->hw;
1607	struct card_conf info = {0};
1608
1609	/* Re-initialize card hardware. */
1610	info.rsr = atc->rsr;
1611	info.msr = atc->msr;
1612	info.vm_pgt_phys = atc_get_ptp_phys(atc, 0);
1613	return hw->resume(hw, &info);
1614}
1615
1616static int atc_resources_resume(struct ct_atc *atc)
1617{
1618	struct ct_mixer *mixer;
1619	int err = 0;
1620
1621	/* Get resources */
1622	err = atc_get_resources(atc);
1623	if (err < 0) {
1624		atc_release_resources(atc);
1625		return err;
1626	}
1627
1628	/* Build topology */
1629	atc_connect_resources(atc);
1630
1631	mixer = atc->mixer;
1632	mixer->resume(mixer);
1633
1634	return 0;
1635}
1636
1637static int atc_resume(struct ct_atc *atc)
1638{
1639	int err = 0;
1640
1641	/* Do hardware resume. */
1642	err = atc_hw_resume(atc);
1643	if (err < 0) {
1644		dev_err(atc->card->dev,
1645			"pci_enable_device failed, disabling device\n");
1646		snd_card_disconnect(atc->card);
1647		return err;
1648	}
1649
1650	err = atc_resources_resume(atc);
1651	if (err < 0)
1652		return err;
1653
1654	snd_power_change_state(atc->card, SNDRV_CTL_POWER_D0);
1655
1656	return 0;
1657}
1658#endif
1659
1660static const struct ct_atc atc_preset = {
1661	.map_audio_buffer = ct_map_audio_buffer,
1662	.unmap_audio_buffer = ct_unmap_audio_buffer,
1663	.pcm_playback_prepare = atc_pcm_playback_prepare,
1664	.pcm_release_resources = atc_pcm_release_resources,
1665	.pcm_playback_start = atc_pcm_playback_start,
1666	.pcm_playback_stop = atc_pcm_stop,
1667	.pcm_playback_position = atc_pcm_playback_position,
1668	.pcm_capture_prepare = atc_pcm_capture_prepare,
1669	.pcm_capture_start = atc_pcm_capture_start,
1670	.pcm_capture_stop = atc_pcm_stop,
1671	.pcm_capture_position = atc_pcm_capture_position,
1672	.spdif_passthru_playback_prepare = spdif_passthru_playback_prepare,
1673	.get_ptp_phys = atc_get_ptp_phys,
1674	.select_line_in = atc_select_line_in,
1675	.select_mic_in = atc_select_mic_in,
1676	.select_digit_io = atc_select_digit_io,
1677	.line_front_unmute = atc_line_front_unmute,
1678	.line_surround_unmute = atc_line_surround_unmute,
1679	.line_clfe_unmute = atc_line_clfe_unmute,
1680	.line_rear_unmute = atc_line_rear_unmute,
1681	.line_in_unmute = atc_line_in_unmute,
1682	.mic_unmute = atc_mic_unmute,
1683	.rca_unmute = atc_rca_unmute,
1684	.spdif_out_unmute = atc_spdif_out_unmute,
1685	.spdif_in_unmute = atc_spdif_in_unmute,
1686	.spdif_out_get_status = atc_spdif_out_get_status,
1687	.spdif_out_set_status = atc_spdif_out_set_status,
1688	.spdif_out_passthru = atc_spdif_out_passthru,
1689	.capabilities = atc_capabilities,
1690	.dedicated_rca_select = atc_dedicated_rca_select,
1691	.output_switch_get = atc_output_switch_get,
1692	.output_switch_put = atc_output_switch_put,
1693	.mic_source_switch_get = atc_mic_source_switch_get,
1694	.mic_source_switch_put = atc_mic_source_switch_put,
1695#ifdef CONFIG_PM_SLEEP
1696	.suspend = atc_suspend,
1697	.resume = atc_resume,
1698#endif
1699};
1700
1701/**
1702 *  ct_atc_create - create and initialize a hardware manager
1703 *  @card: corresponding alsa card object
1704 *  @pci: corresponding kernel pci device object
1705 *  @rsr: reference sampling rate
1706 *  @msr: master sampling rate
1707 *  @chip_type: CHIPTYP enum values
1708 *  @ssid: vendor ID (upper 16 bits) and device ID (lower 16 bits)
1709 *  @ratc: return created object address in it
1710 *
1711 *  Creates and initializes a hardware manager.
1712 *
1713 *  Creates kmallocated ct_atc structure. Initializes hardware.
1714 *  Returns 0 if succeeds, or negative error code if fails.
1715 */
1716
1717int ct_atc_create(struct snd_card *card, struct pci_dev *pci,
1718		  unsigned int rsr, unsigned int msr,
1719		  int chip_type, unsigned int ssid,
1720		  struct ct_atc **ratc)
1721{
1722	struct ct_atc *atc;
1723	static const struct snd_device_ops ops = {
1724		.dev_free = atc_dev_free,
1725	};
1726	int err;
1727
1728	*ratc = NULL;
1729
1730	atc = kzalloc(sizeof(*atc), GFP_KERNEL);
1731	if (!atc)
1732		return -ENOMEM;
1733
1734	/* Set operations */
1735	*atc = atc_preset;
1736
1737	atc->card = card;
1738	atc->pci = pci;
1739	atc->rsr = rsr;
1740	atc->msr = msr;
1741	atc->chip_type = chip_type;
1742
1743	mutex_init(&atc->atc_mutex);
1744
1745	/* Find card model */
1746	err = atc_identify_card(atc, ssid);
1747	if (err < 0) {
1748		dev_err(card->dev, "ctatc: Card not recognised\n");
1749		goto error1;
1750	}
1751
1752	/* Set up device virtual memory management object */
1753	err = ct_vm_create(&atc->vm, pci);
1754	if (err < 0)
1755		goto error1;
1756
1757	/* Create all atc hw devices */
1758	err = atc_create_hw_devs(atc);
1759	if (err < 0)
1760		goto error1;
1761
1762	err = ct_mixer_create(atc, (struct ct_mixer **)&atc->mixer);
1763	if (err) {
1764		dev_err(card->dev, "Failed to create mixer obj!!!\n");
1765		goto error1;
1766	}
1767
1768	/* Get resources */
1769	err = atc_get_resources(atc);
1770	if (err < 0)
1771		goto error1;
1772
1773	/* Build topology */
1774	atc_connect_resources(atc);
1775
1776	atc->timer = ct_timer_new(atc);
1777	if (!atc->timer) {
1778		err = -ENOMEM;
1779		goto error1;
1780	}
1781
1782	err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, atc, &ops);
1783	if (err < 0)
1784		goto error1;
1785
1786	*ratc = atc;
1787	return 0;
1788
1789error1:
1790	ct_atc_destroy(atc);
1791	dev_err(card->dev, "Something wrong!!!\n");
1792	return err;
1793}