echoaudio.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 *  ALSA driver for Echoaudio soundcards.
   4 *  Copyright (C) 2003-2004 Giuliano Pochini <pochini@shiny.it>
   5 *  Copyright (C) 2020 Mark Hills <mark@xwax.org>
   6 */
   7
   8#include <linux/module.h>
   9#include <linux/string.h>
  10
  11MODULE_AUTHOR("Giuliano Pochini <pochini@shiny.it>");
  12MODULE_LICENSE("GPL v2");
  13MODULE_DESCRIPTION("Echoaudio " ECHOCARD_NAME " soundcards driver");
  14MODULE_DEVICE_TABLE(pci, snd_echo_ids);
  15
  16static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
  17static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
  18static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
  19
  20module_param_array(index, int, NULL, 0444);
  21MODULE_PARM_DESC(index, "Index value for " ECHOCARD_NAME " soundcard.");
  22module_param_array(id, charp, NULL, 0444);
  23MODULE_PARM_DESC(id, "ID string for " ECHOCARD_NAME " soundcard.");
  24module_param_array(enable, bool, NULL, 0444);
  25MODULE_PARM_DESC(enable, "Enable " ECHOCARD_NAME " soundcard.");
  26
  27static const unsigned int channels_list[10] = {1, 2, 4, 6, 8, 10, 12, 14, 16, 999999};
  28static const DECLARE_TLV_DB_SCALE(db_scale_output_gain, -12800, 100, 1);
  29
  30
  31
  32static int get_firmware(const struct firmware **fw_entry,
  33			struct echoaudio *chip, const short fw_index)
  34{
  35	int err;
  36	char name[30];
  37
  38	if (chip->fw_cache[fw_index]) {
  39		dev_dbg(chip->card->dev,
  40			"firmware requested: %s is cached\n",
  41			card_fw[fw_index].data);
  42		*fw_entry = chip->fw_cache[fw_index];
  43		return 0;
  44	}
  45
  46	dev_dbg(chip->card->dev,
  47		"firmware requested: %s\n", card_fw[fw_index].data);
  48	snprintf(name, sizeof(name), "ea/%s", card_fw[fw_index].data);
  49	err = request_firmware(fw_entry, name, &chip->pci->dev);
  50	if (err < 0)
  51		dev_err(chip->card->dev,
  52			"get_firmware(): Firmware not available (%d)\n", err);
  53	else
  54		chip->fw_cache[fw_index] = *fw_entry;
  55	return err;
  56}
  57
  58
  59
  60static void free_firmware(const struct firmware *fw_entry,
  61			  struct echoaudio *chip)
  62{
  63	dev_dbg(chip->card->dev, "firmware not released (kept in cache)\n");
  64}
  65
  66
  67
  68static void free_firmware_cache(struct echoaudio *chip)
  69{
  70	int i;
  71
  72	for (i = 0; i < 8 ; i++)
  73		if (chip->fw_cache[i]) {
  74			release_firmware(chip->fw_cache[i]);
  75			dev_dbg(chip->card->dev, "release_firmware(%d)\n", i);
  76		}
  77}
  78
  79
  80
  81/******************************************************************************
  82	PCM interface
  83******************************************************************************/
  84
  85static void audiopipe_free(struct snd_pcm_runtime *runtime)
  86{
  87	struct audiopipe *pipe = runtime->private_data;
  88
  89	if (pipe->sgpage.area)
  90		snd_dma_free_pages(&pipe->sgpage);
  91	kfree(pipe);
  92}
  93
  94
  95
  96static int hw_rule_capture_format_by_channels(struct snd_pcm_hw_params *params,
  97					      struct snd_pcm_hw_rule *rule)
  98{
  99	struct snd_interval *c = hw_param_interval(params,
 100						   SNDRV_PCM_HW_PARAM_CHANNELS);
 101	struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
 102	struct snd_mask fmt;
 103
 104	snd_mask_any(&fmt);
 105
 106#ifndef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
 107	/* >=2 channels cannot be S32_BE */
 108	if (c->min == 2) {
 109		fmt.bits[0] &= ~SNDRV_PCM_FMTBIT_S32_BE;
 110		return snd_mask_refine(f, &fmt);
 111	}
 112#endif
 113	/* > 2 channels cannot be U8 and S32_BE */
 114	if (c->min > 2) {
 115		fmt.bits[0] &= ~(SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S32_BE);
 116		return snd_mask_refine(f, &fmt);
 117	}
 118	/* Mono is ok with any format */
 119	return 0;
 120}
 121
 122
 123
 124static int hw_rule_capture_channels_by_format(struct snd_pcm_hw_params *params,
 125					      struct snd_pcm_hw_rule *rule)
 126{
 127	struct snd_interval *c = hw_param_interval(params,
 128						   SNDRV_PCM_HW_PARAM_CHANNELS);
 129	struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
 130	struct snd_interval ch;
 131
 132	snd_interval_any(&ch);
 133
 134	/* S32_BE is mono (and stereo) only */
 135	if (f->bits[0] == SNDRV_PCM_FMTBIT_S32_BE) {
 136		ch.min = 1;
 137#ifdef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
 138		ch.max = 2;
 139#else
 140		ch.max = 1;
 141#endif
 142		ch.integer = 1;
 143		return snd_interval_refine(c, &ch);
 144	}
 145	/* U8 can be only mono or stereo */
 146	if (f->bits[0] == SNDRV_PCM_FMTBIT_U8) {
 147		ch.min = 1;
 148		ch.max = 2;
 149		ch.integer = 1;
 150		return snd_interval_refine(c, &ch);
 151	}
 152	/* S16_LE, S24_3LE and S32_LE support any number of channels. */
 153	return 0;
 154}
 155
 156
 157
 158static int hw_rule_playback_format_by_channels(struct snd_pcm_hw_params *params,
 159					       struct snd_pcm_hw_rule *rule)
 160{
 161	struct snd_interval *c = hw_param_interval(params,
 162						   SNDRV_PCM_HW_PARAM_CHANNELS);
 163	struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
 164	struct snd_mask fmt;
 165	u64 fmask;
 166	snd_mask_any(&fmt);
 167
 168	fmask = fmt.bits[0] + ((u64)fmt.bits[1] << 32);
 169
 170	/* >2 channels must be S16_LE, S24_3LE or S32_LE */
 171	if (c->min > 2) {
 172		fmask &= SNDRV_PCM_FMTBIT_S16_LE |
 173			 SNDRV_PCM_FMTBIT_S24_3LE |
 174			 SNDRV_PCM_FMTBIT_S32_LE;
 175	/* 1 channel must be S32_BE or S32_LE */
 176	} else if (c->max == 1)
 177		fmask &= SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE;
 178#ifndef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
 179	/* 2 channels cannot be S32_BE */
 180	else if (c->min == 2 && c->max == 2)
 181		fmask &= ~SNDRV_PCM_FMTBIT_S32_BE;
 182#endif
 183	else
 184		return 0;
 185
 186	fmt.bits[0] &= (u32)fmask;
 187	fmt.bits[1] &= (u32)(fmask >> 32);
 188	return snd_mask_refine(f, &fmt);
 189}
 190
 191
 192
 193static int hw_rule_playback_channels_by_format(struct snd_pcm_hw_params *params,
 194					       struct snd_pcm_hw_rule *rule)
 195{
 196	struct snd_interval *c = hw_param_interval(params,
 197						   SNDRV_PCM_HW_PARAM_CHANNELS);
 198	struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
 199	struct snd_interval ch;
 200	u64 fmask;
 201
 202	snd_interval_any(&ch);
 203	ch.integer = 1;
 204	fmask = f->bits[0] + ((u64)f->bits[1] << 32);
 205
 206	/* S32_BE is mono (and stereo) only */
 207	if (fmask == SNDRV_PCM_FMTBIT_S32_BE) {
 208		ch.min = 1;
 209#ifdef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
 210		ch.max = 2;
 211#else
 212		ch.max = 1;
 213#endif
 214	/* U8 is stereo only */
 215	} else if (fmask == SNDRV_PCM_FMTBIT_U8)
 216		ch.min = ch.max = 2;
 217	/* S16_LE and S24_3LE must be at least stereo */
 218	else if (!(fmask & ~(SNDRV_PCM_FMTBIT_S16_LE |
 219			       SNDRV_PCM_FMTBIT_S24_3LE)))
 220		ch.min = 2;
 221	else
 222		return 0;
 223
 224	return snd_interval_refine(c, &ch);
 225}
 226
 227
 228
 229/* Since the sample rate is a global setting, do allow the user to change the
 230sample rate only if there is only one pcm device open. */
 231static int hw_rule_sample_rate(struct snd_pcm_hw_params *params,
 232			       struct snd_pcm_hw_rule *rule)
 233{
 234	struct snd_interval *rate = hw_param_interval(params,
 235						      SNDRV_PCM_HW_PARAM_RATE);
 236	struct echoaudio *chip = rule->private;
 237	struct snd_interval fixed;
 238	int err;
 239
 240	guard(mutex)(&chip->mode_mutex);
 241
 242	if (chip->can_set_rate) {
 243		err = 0;
 244	} else {
 245		snd_interval_any(&fixed);
 246		fixed.min = fixed.max = chip->sample_rate;
 247		err = snd_interval_refine(rate, &fixed);
 248	}
 249
 250	return err;
 251}
 252
 253
 254static int pcm_open(struct snd_pcm_substream *substream,
 255		    signed char max_channels)
 256{
 257	struct echoaudio *chip;
 258	struct snd_pcm_runtime *runtime;
 259	struct audiopipe *pipe;
 260	int err, i;
 261
 262	if (max_channels <= 0)
 263		return -EAGAIN;
 264
 265	chip = snd_pcm_substream_chip(substream);
 266	runtime = substream->runtime;
 267
 268	pipe = kzalloc(sizeof(struct audiopipe), GFP_KERNEL);
 269	if (!pipe)
 270		return -ENOMEM;
 271	pipe->index = -1;		/* Not configured yet */
 272
 273	/* Set up hw capabilities and contraints */
 274	memcpy(&pipe->hw, &pcm_hardware_skel, sizeof(struct snd_pcm_hardware));
 275	dev_dbg(chip->card->dev, "max_channels=%d\n", max_channels);
 276	pipe->constr.list = channels_list;
 277	pipe->constr.mask = 0;
 278	for (i = 0; channels_list[i] <= max_channels; i++);
 279	pipe->constr.count = i;
 280	if (pipe->hw.channels_max > max_channels)
 281		pipe->hw.channels_max = max_channels;
 282	if (chip->digital_mode == DIGITAL_MODE_ADAT) {
 283		pipe->hw.rate_max = 48000;
 284		pipe->hw.rates &= SNDRV_PCM_RATE_8000_48000;
 285	}
 286
 287	runtime->hw = pipe->hw;
 288	runtime->private_data = pipe;
 289	runtime->private_free = audiopipe_free;
 290	snd_pcm_set_sync(substream);
 291
 292	/* Only mono and any even number of channels are allowed */
 293	err = snd_pcm_hw_constraint_list(runtime, 0,
 294					 SNDRV_PCM_HW_PARAM_CHANNELS,
 295					 &pipe->constr);
 296	if (err < 0)
 297		return err;
 298
 299	/* All periods should have the same size */
 300	err = snd_pcm_hw_constraint_integer(runtime,
 301					    SNDRV_PCM_HW_PARAM_PERIODS);
 302	if (err < 0)
 303		return err;
 304
 305	/* The hw accesses memory in chunks 32 frames long and they should be
 306	32-bytes-aligned. It's not a requirement, but it seems that IRQs are
 307	generated with a resolution of 32 frames. Thus we need the following */
 308	err = snd_pcm_hw_constraint_step(runtime, 0,
 309					 SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 32);
 310	if (err < 0)
 311		return err;
 312	err = snd_pcm_hw_constraint_step(runtime, 0,
 313					 SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 32);
 314	if (err < 0)
 315		return err;
 316
 317	err = snd_pcm_hw_rule_add(substream->runtime, 0,
 318				  SNDRV_PCM_HW_PARAM_RATE,
 319				  hw_rule_sample_rate, chip,
 320				  SNDRV_PCM_HW_PARAM_RATE, -1);
 321	if (err < 0)
 322		return err;
 323
 324	/* Allocate a page for the scatter-gather list */
 325	err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
 326				  &chip->pci->dev,
 327				  PAGE_SIZE, &pipe->sgpage);
 328	if (err < 0) {
 329		dev_err(chip->card->dev, "s-g list allocation failed\n");
 330		return err;
 331	}
 332
 333	/*
 334	 * Sole ownership required to set the rate
 335	 */
 336
 337	dev_dbg(chip->card->dev, "pcm_open opencount=%d can_set_rate=%d, rate_set=%d",
 338		chip->opencount, chip->can_set_rate, chip->rate_set);
 339
 340	chip->opencount++;
 341	if (chip->opencount > 1 && chip->rate_set)
 342		chip->can_set_rate = 0;
 343
 344	return 0;
 345}
 346
 347
 348
 349static int pcm_analog_in_open(struct snd_pcm_substream *substream)
 350{
 351	struct echoaudio *chip = snd_pcm_substream_chip(substream);
 352	int err;
 353
 354	err = pcm_open(substream,
 355		       num_analog_busses_in(chip) - substream->number);
 356	if (err < 0)
 357		return err;
 358	err = snd_pcm_hw_rule_add(substream->runtime, 0,
 359				  SNDRV_PCM_HW_PARAM_CHANNELS,
 360				  hw_rule_capture_channels_by_format, NULL,
 361				  SNDRV_PCM_HW_PARAM_FORMAT, -1);
 362	if (err < 0)
 363		return err;
 364	err = snd_pcm_hw_rule_add(substream->runtime, 0,
 365				  SNDRV_PCM_HW_PARAM_FORMAT,
 366				  hw_rule_capture_format_by_channels, NULL,
 367				  SNDRV_PCM_HW_PARAM_CHANNELS, -1);
 368	if (err < 0)
 369		return err;
 370
 371	return 0;
 372}
 373
 374
 375
 376static int pcm_analog_out_open(struct snd_pcm_substream *substream)
 377{
 378	struct echoaudio *chip = snd_pcm_substream_chip(substream);
 379	int max_channels, err;
 380
 381#ifdef ECHOCARD_HAS_VMIXER
 382	max_channels = num_pipes_out(chip);
 383#else
 384	max_channels = num_analog_busses_out(chip);
 385#endif
 386	err = pcm_open(substream, max_channels - substream->number);
 387	if (err < 0)
 388		return err;
 389	err = snd_pcm_hw_rule_add(substream->runtime, 0,
 390				  SNDRV_PCM_HW_PARAM_CHANNELS,
 391				  hw_rule_playback_channels_by_format,
 392				  NULL,
 393				  SNDRV_PCM_HW_PARAM_FORMAT, -1);
 394	if (err < 0)
 395		return err;
 396	err = snd_pcm_hw_rule_add(substream->runtime, 0,
 397				  SNDRV_PCM_HW_PARAM_FORMAT,
 398				  hw_rule_playback_format_by_channels,
 399				  NULL,
 400				  SNDRV_PCM_HW_PARAM_CHANNELS, -1);
 401	if (err < 0)
 402		return err;
 403
 404	return 0;
 405}
 406
 407
 408
 409#ifdef ECHOCARD_HAS_DIGITAL_IO
 410
 411static int pcm_digital_in_open(struct snd_pcm_substream *substream)
 412{
 413	struct echoaudio *chip = snd_pcm_substream_chip(substream);
 414	int err, max_channels;
 415
 416	max_channels = num_digital_busses_in(chip) - substream->number;
 417	guard(mutex)(&chip->mode_mutex);
 418	if (chip->digital_mode == DIGITAL_MODE_ADAT)
 419		err = pcm_open(substream, max_channels);
 420	else	/* If the card has ADAT, subtract the 6 channels
 421		 * that S/PDIF doesn't have
 422		 */
 423		err = pcm_open(substream, max_channels - ECHOCARD_HAS_ADAT);
 424
 425	if (err < 0)
 426		return err;
 427
 428	err = snd_pcm_hw_rule_add(substream->runtime, 0,
 429				  SNDRV_PCM_HW_PARAM_CHANNELS,
 430				  hw_rule_capture_channels_by_format, NULL,
 431				  SNDRV_PCM_HW_PARAM_FORMAT, -1);
 432	if (err < 0)
 433		return err;
 434	err = snd_pcm_hw_rule_add(substream->runtime, 0,
 435				  SNDRV_PCM_HW_PARAM_FORMAT,
 436				  hw_rule_capture_format_by_channels, NULL,
 437				  SNDRV_PCM_HW_PARAM_CHANNELS, -1);
 438	if (err < 0)
 439		return err;
 440
 441	return 0;
 442}
 443
 444
 445
 446#ifndef ECHOCARD_HAS_VMIXER	/* See the note in snd_echo_new_pcm() */
 447
 448static int pcm_digital_out_open(struct snd_pcm_substream *substream)
 449{
 450	struct echoaudio *chip = snd_pcm_substream_chip(substream);
 451	int err, max_channels;
 452
 453	max_channels = num_digital_busses_out(chip) - substream->number;
 454	guard(mutex)(&chip->mode_mutex);
 455	if (chip->digital_mode == DIGITAL_MODE_ADAT)
 456		err = pcm_open(substream, max_channels);
 457	else	/* If the card has ADAT, subtract the 6 channels
 458		 * that S/PDIF doesn't have
 459		 */
 460		err = pcm_open(substream, max_channels - ECHOCARD_HAS_ADAT);
 461
 462	if (err < 0)
 463		return err;
 464
 465	err = snd_pcm_hw_rule_add(substream->runtime, 0,
 466				  SNDRV_PCM_HW_PARAM_CHANNELS,
 467				  hw_rule_playback_channels_by_format,
 468				  NULL, SNDRV_PCM_HW_PARAM_FORMAT,
 469				  -1);
 470	if (err < 0)
 471		return err;
 472	err = snd_pcm_hw_rule_add(substream->runtime, 0,
 473				  SNDRV_PCM_HW_PARAM_FORMAT,
 474				  hw_rule_playback_format_by_channels,
 475				  NULL, SNDRV_PCM_HW_PARAM_CHANNELS,
 476				  -1);
 477	if (err < 0)
 478		return err;
 479
 480	return 0;
 481}
 482
 483#endif /* !ECHOCARD_HAS_VMIXER */
 484
 485#endif /* ECHOCARD_HAS_DIGITAL_IO */
 486
 487
 488
 489static int pcm_close(struct snd_pcm_substream *substream)
 490{
 491	struct echoaudio *chip = snd_pcm_substream_chip(substream);
 492
 493	/* Nothing to do here. Audio is already off and pipe will be
 494	 * freed by its callback
 495	 */
 496
 497	guard(mutex)(&chip->mode_mutex);
 498
 499	dev_dbg(chip->card->dev, "pcm_open opencount=%d can_set_rate=%d, rate_set=%d",
 500		chip->opencount, chip->can_set_rate, chip->rate_set);
 501
 502	chip->opencount--;
 503
 504	switch (chip->opencount) {
 505	case 1:
 506		chip->can_set_rate = 1;
 507		break;
 508
 509	case 0:
 510		chip->rate_set = 0;
 511		break;
 512	}
 513
 514	return 0;
 515}
 516
 517
 518
 519/* Channel allocation and scatter-gather list setup */
 520static int init_engine(struct snd_pcm_substream *substream,
 521		       struct snd_pcm_hw_params *hw_params,
 522		       int pipe_index, int interleave)
 523{
 524	struct echoaudio *chip;
 525	int err, per, rest, page, edge, offs;
 526	struct audiopipe *pipe;
 527
 528	chip = snd_pcm_substream_chip(substream);
 529	pipe = (struct audiopipe *) substream->runtime->private_data;
 530
 531	/* Sets up che hardware. If it's already initialized, reset and
 532	 * redo with the new parameters
 533	 */
 534	scoped_guard(spinlock_irq, &chip->lock) {
 535		if (pipe->index >= 0) {
 536			dev_dbg(chip->card->dev, "hwp_ie free(%d)\n", pipe->index);
 537			err = free_pipes(chip, pipe);
 538			snd_BUG_ON(err);
 539			chip->substream[pipe->index] = NULL;
 540		}
 541
 542		err = allocate_pipes(chip, pipe, pipe_index, interleave);
 543		if (err < 0) {
 544			dev_err(chip->card->dev, "allocate_pipes(%d) err=%d\n",
 545				pipe_index, err);
 546			return err;
 547		}
 548	}
 549	dev_dbg(chip->card->dev, "allocate_pipes()=%d\n", pipe_index);
 550
 551	dev_dbg(chip->card->dev,
 552		"pcm_hw_params (bufsize=%dB periods=%d persize=%dB)\n",
 553		params_buffer_bytes(hw_params), params_periods(hw_params),
 554		params_period_bytes(hw_params));
 555
 556	sglist_init(chip, pipe);
 557	edge = PAGE_SIZE;
 558	for (offs = page = per = 0; offs < params_buffer_bytes(hw_params);
 559	     per++) {
 560		rest = params_period_bytes(hw_params);
 561		if (offs + rest > params_buffer_bytes(hw_params))
 562			rest = params_buffer_bytes(hw_params) - offs;
 563		while (rest) {
 564			dma_addr_t addr;
 565			addr = snd_pcm_sgbuf_get_addr(substream, offs);
 566			if (rest <= edge - offs) {
 567				sglist_add_mapping(chip, pipe, addr, rest);
 568				sglist_add_irq(chip, pipe);
 569				offs += rest;
 570				rest = 0;
 571			} else {
 572				sglist_add_mapping(chip, pipe, addr,
 573						   edge - offs);
 574				rest -= edge - offs;
 575				offs = edge;
 576			}
 577			if (offs == edge) {
 578				edge += PAGE_SIZE;
 579				page++;
 580			}
 581		}
 582	}
 583
 584	/* Close the ring buffer */
 585	sglist_wrap(chip, pipe);
 586
 587	/* This stuff is used by the irq handler, so it must be
 588	 * initialized before chip->substream
 589	 */
 590	pipe->last_period = 0;
 591	pipe->last_counter = 0;
 592	pipe->position = 0;
 593	smp_wmb();
 594	chip->substream[pipe_index] = substream;
 595	chip->rate_set = 1;
 596	guard(spinlock_irq)(&chip->lock);
 597	set_sample_rate(chip, hw_params->rate_num / hw_params->rate_den);
 598	return 0;
 599}
 600
 601
 602
 603static int pcm_analog_in_hw_params(struct snd_pcm_substream *substream,
 604				   struct snd_pcm_hw_params *hw_params)
 605{
 606	struct echoaudio *chip = snd_pcm_substream_chip(substream);
 607
 608	return init_engine(substream, hw_params, px_analog_in(chip) +
 609			substream->number, params_channels(hw_params));
 610}
 611
 612
 613
 614static int pcm_analog_out_hw_params(struct snd_pcm_substream *substream,
 615				    struct snd_pcm_hw_params *hw_params)
 616{
 617	return init_engine(substream, hw_params, substream->number,
 618			   params_channels(hw_params));
 619}
 620
 621
 622
 623#ifdef ECHOCARD_HAS_DIGITAL_IO
 624
 625static int pcm_digital_in_hw_params(struct snd_pcm_substream *substream,
 626				    struct snd_pcm_hw_params *hw_params)
 627{
 628	struct echoaudio *chip = snd_pcm_substream_chip(substream);
 629
 630	return init_engine(substream, hw_params, px_digital_in(chip) +
 631			substream->number, params_channels(hw_params));
 632}
 633
 634
 635
 636#ifndef ECHOCARD_HAS_VMIXER	/* See the note in snd_echo_new_pcm() */
 637static int pcm_digital_out_hw_params(struct snd_pcm_substream *substream,
 638				     struct snd_pcm_hw_params *hw_params)
 639{
 640	struct echoaudio *chip = snd_pcm_substream_chip(substream);
 641
 642	return init_engine(substream, hw_params, px_digital_out(chip) +
 643			substream->number, params_channels(hw_params));
 644}
 645#endif /* !ECHOCARD_HAS_VMIXER */
 646
 647#endif /* ECHOCARD_HAS_DIGITAL_IO */
 648
 649
 650
 651static int pcm_hw_free(struct snd_pcm_substream *substream)
 652{
 653	struct echoaudio *chip;
 654	struct audiopipe *pipe;
 655
 656	chip = snd_pcm_substream_chip(substream);
 657	pipe = (struct audiopipe *) substream->runtime->private_data;
 658
 659	guard(spinlock_irq)(&chip->lock);
 660	if (pipe->index >= 0) {
 661		dev_dbg(chip->card->dev, "pcm_hw_free(%d)\n", pipe->index);
 662		free_pipes(chip, pipe);
 663		chip->substream[pipe->index] = NULL;
 664		pipe->index = -1;
 665	}
 666
 667	return 0;
 668}
 669
 670
 671
 672static int pcm_prepare(struct snd_pcm_substream *substream)
 673{
 674	struct echoaudio *chip = snd_pcm_substream_chip(substream);
 675	struct snd_pcm_runtime *runtime = substream->runtime;
 676	struct audioformat format;
 677	int pipe_index = ((struct audiopipe *)runtime->private_data)->index;
 678
 679	dev_dbg(chip->card->dev, "Prepare rate=%d format=%d channels=%d\n",
 680		runtime->rate, runtime->format, runtime->channels);
 681	format.interleave = runtime->channels;
 682	format.data_are_bigendian = 0;
 683	format.mono_to_stereo = 0;
 684	switch (runtime->format) {
 685	case SNDRV_PCM_FORMAT_U8:
 686		format.bits_per_sample = 8;
 687		break;
 688	case SNDRV_PCM_FORMAT_S16_LE:
 689		format.bits_per_sample = 16;
 690		break;
 691	case SNDRV_PCM_FORMAT_S24_3LE:
 692		format.bits_per_sample = 24;
 693		break;
 694	case SNDRV_PCM_FORMAT_S32_BE:
 695		format.data_are_bigendian = 1;
 696		fallthrough;
 697	case SNDRV_PCM_FORMAT_S32_LE:
 698		format.bits_per_sample = 32;
 699		break;
 700	default:
 701		dev_err(chip->card->dev,
 702			"Prepare error: unsupported format %d\n",
 703			runtime->format);
 704		return -EINVAL;
 705	}
 706
 707	if (snd_BUG_ON(pipe_index >= px_num(chip)))
 708		return -EINVAL;
 709
 710	/*
 711	 * We passed checks we can do independently; now take
 712	 * exclusive control
 713	 */
 714
 715	guard(spinlock_irq)(&chip->lock);
 716
 717	if (snd_BUG_ON(!is_pipe_allocated(chip, pipe_index)))
 718		return -EINVAL;
 719
 720	set_audio_format(chip, pipe_index, &format);
 721
 722	return 0;
 723}
 724
 725
 726
 727static int pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 728{
 729	struct echoaudio *chip = snd_pcm_substream_chip(substream);
 730	struct audiopipe *pipe;
 731	int i, err;
 732	u32 channelmask = 0;
 733	struct snd_pcm_substream *s;
 734
 735	snd_pcm_group_for_each_entry(s, substream) {
 736		for (i = 0; i < DSP_MAXPIPES; i++) {
 737			if (s == chip->substream[i]) {
 738				channelmask |= 1 << i;
 739				snd_pcm_trigger_done(s, substream);
 740			}
 741		}
 742	}
 743
 744	guard(spinlock)(&chip->lock);
 745	switch (cmd) {
 746	case SNDRV_PCM_TRIGGER_RESUME:
 747	case SNDRV_PCM_TRIGGER_START:
 748	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 749		for (i = 0; i < DSP_MAXPIPES; i++) {
 750			if (channelmask & (1 << i)) {
 751				pipe = chip->substream[i]->runtime->private_data;
 752				switch (pipe->state) {
 753				case PIPE_STATE_STOPPED:
 754					pipe->last_period = 0;
 755					pipe->last_counter = 0;
 756					pipe->position = 0;
 757					*pipe->dma_counter = 0;
 758					fallthrough;
 759				case PIPE_STATE_PAUSED:
 760					pipe->state = PIPE_STATE_STARTED;
 761					break;
 762				case PIPE_STATE_STARTED:
 763					break;
 764				}
 765			}
 766		}
 767		err = start_transport(chip, channelmask,
 768				      chip->pipe_cyclic_mask);
 769		break;
 770	case SNDRV_PCM_TRIGGER_SUSPEND:
 771	case SNDRV_PCM_TRIGGER_STOP:
 772		for (i = 0; i < DSP_MAXPIPES; i++) {
 773			if (channelmask & (1 << i)) {
 774				pipe = chip->substream[i]->runtime->private_data;
 775				pipe->state = PIPE_STATE_STOPPED;
 776			}
 777		}
 778		err = stop_transport(chip, channelmask);
 779		break;
 780	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 781		for (i = 0; i < DSP_MAXPIPES; i++) {
 782			if (channelmask & (1 << i)) {
 783				pipe = chip->substream[i]->runtime->private_data;
 784				pipe->state = PIPE_STATE_PAUSED;
 785			}
 786		}
 787		err = pause_transport(chip, channelmask);
 788		break;
 789	default:
 790		err = -EINVAL;
 791	}
 792	return err;
 793}
 794
 795
 796
 797static snd_pcm_uframes_t pcm_pointer(struct snd_pcm_substream *substream)
 798{
 799	struct snd_pcm_runtime *runtime = substream->runtime;
 800	struct audiopipe *pipe = runtime->private_data;
 801	u32 counter, step;
 802
 803	/*
 804	 * IRQ handling runs concurrently. Do not share tracking of
 805	 * counter with it, which would race or require locking
 806	 */
 807
 808	counter = le32_to_cpu(*pipe->dma_counter);  /* presumed atomic */
 809
 810	step = counter - pipe->last_counter;  /* handles wrapping */
 811	pipe->last_counter = counter;
 812
 813	/* counter doesn't neccessarily wrap on a multiple of
 814	 * buffer_size, so can't derive the position; must
 815	 * accumulate */
 816
 817	pipe->position += step;
 818	pipe->position %= frames_to_bytes(runtime, runtime->buffer_size); /* wrap */
 819
 820	return bytes_to_frames(runtime, pipe->position);
 821}
 822
 823
 824
 825/* pcm *_ops structures */
 826static const struct snd_pcm_ops analog_playback_ops = {
 827	.open = pcm_analog_out_open,
 828	.close = pcm_close,
 829	.hw_params = pcm_analog_out_hw_params,
 830	.hw_free = pcm_hw_free,
 831	.prepare = pcm_prepare,
 832	.trigger = pcm_trigger,
 833	.pointer = pcm_pointer,
 834};
 835static const struct snd_pcm_ops analog_capture_ops = {
 836	.open = pcm_analog_in_open,
 837	.close = pcm_close,
 838	.hw_params = pcm_analog_in_hw_params,
 839	.hw_free = pcm_hw_free,
 840	.prepare = pcm_prepare,
 841	.trigger = pcm_trigger,
 842	.pointer = pcm_pointer,
 843};
 844#ifdef ECHOCARD_HAS_DIGITAL_IO
 845#ifndef ECHOCARD_HAS_VMIXER
 846static const struct snd_pcm_ops digital_playback_ops = {
 847	.open = pcm_digital_out_open,
 848	.close = pcm_close,
 849	.hw_params = pcm_digital_out_hw_params,
 850	.hw_free = pcm_hw_free,
 851	.prepare = pcm_prepare,
 852	.trigger = pcm_trigger,
 853	.pointer = pcm_pointer,
 854};
 855#endif /* !ECHOCARD_HAS_VMIXER */
 856static const struct snd_pcm_ops digital_capture_ops = {
 857	.open = pcm_digital_in_open,
 858	.close = pcm_close,
 859	.hw_params = pcm_digital_in_hw_params,
 860	.hw_free = pcm_hw_free,
 861	.prepare = pcm_prepare,
 862	.trigger = pcm_trigger,
 863	.pointer = pcm_pointer,
 864};
 865#endif /* ECHOCARD_HAS_DIGITAL_IO */
 866
 867
 868
 869/* Preallocate memory only for the first substream because it's the most
 870 * used one
 871 */
 872static void snd_echo_preallocate_pages(struct snd_pcm *pcm, struct device *dev)
 873{
 874	struct snd_pcm_substream *ss;
 875	int stream;
 876
 877	for (stream = 0; stream < 2; stream++)
 878		for (ss = pcm->streams[stream].substream; ss; ss = ss->next)
 879			snd_pcm_set_managed_buffer(ss, SNDRV_DMA_TYPE_DEV_SG,
 880						   dev,
 881						   ss->number ? 0 : 128<<10,
 882						   256<<10);
 883}
 884
 885
 886
 887/*<--snd_echo_probe() */
 888static int snd_echo_new_pcm(struct echoaudio *chip)
 889{
 890	struct snd_pcm *pcm;
 891	int err;
 892
 893#ifdef ECHOCARD_HAS_VMIXER
 894	/* This card has a Vmixer, that is there is no direct mapping from PCM
 895	streams to physical outputs. The user can mix the streams as he wishes
 896	via control interface and it's possible to send any stream to any
 897	output, thus it makes no sense to keep analog and digital outputs
 898	separated */
 899
 900	/* PCM#0 Virtual outputs and analog inputs */
 901	err = snd_pcm_new(chip->card, "PCM", 0, num_pipes_out(chip),
 902			  num_analog_busses_in(chip), &pcm);
 903	if (err < 0)
 904		return err;
 905	pcm->private_data = chip;
 906	chip->analog_pcm = pcm;
 907	strscpy(pcm->name, chip->card->shortname);
 908	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &analog_playback_ops);
 909	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops);
 910	snd_echo_preallocate_pages(pcm, &chip->pci->dev);
 911
 912#ifdef ECHOCARD_HAS_DIGITAL_IO
 913	/* PCM#1 Digital inputs, no outputs */
 914	err = snd_pcm_new(chip->card, "Digital PCM", 1, 0,
 915			  num_digital_busses_in(chip), &pcm);
 916	if (err < 0)
 917		return err;
 918	pcm->private_data = chip;
 919	chip->digital_pcm = pcm;
 920	strscpy(pcm->name, chip->card->shortname);
 921	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &digital_capture_ops);
 922	snd_echo_preallocate_pages(pcm, &chip->pci->dev);
 923#endif /* ECHOCARD_HAS_DIGITAL_IO */
 924
 925#else /* ECHOCARD_HAS_VMIXER */
 926
 927	/* The card can manage substreams formed by analog and digital channels
 928	at the same time, but I prefer to keep analog and digital channels
 929	separated, because that mixed thing is confusing and useless. So we
 930	register two PCM devices: */
 931
 932	/* PCM#0 Analog i/o */
 933	err = snd_pcm_new(chip->card, "Analog PCM", 0,
 934			  num_analog_busses_out(chip),
 935			  num_analog_busses_in(chip), &pcm);
 936	if (err < 0)
 937		return err;
 938	pcm->private_data = chip;
 939	chip->analog_pcm = pcm;
 940	strscpy(pcm->name, chip->card->shortname);
 941	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &analog_playback_ops);
 942	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops);
 943	snd_echo_preallocate_pages(pcm, &chip->pci->dev);
 944
 945#ifdef ECHOCARD_HAS_DIGITAL_IO
 946	/* PCM#1 Digital i/o */
 947	err = snd_pcm_new(chip->card, "Digital PCM", 1,
 948			  num_digital_busses_out(chip),
 949			  num_digital_busses_in(chip), &pcm);
 950	if (err < 0)
 951		return err;
 952	pcm->private_data = chip;
 953	chip->digital_pcm = pcm;
 954	strscpy(pcm->name, chip->card->shortname);
 955	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &digital_playback_ops);
 956	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &digital_capture_ops);
 957	snd_echo_preallocate_pages(pcm, &chip->pci->dev);
 958#endif /* ECHOCARD_HAS_DIGITAL_IO */
 959
 960#endif /* ECHOCARD_HAS_VMIXER */
 961
 962	return 0;
 963}
 964
 965
 966
 967
 968/******************************************************************************
 969	Control interface
 970******************************************************************************/
 971
 972#if !defined(ECHOCARD_HAS_VMIXER) || defined(ECHOCARD_HAS_LINE_OUT_GAIN)
 973
 974/******************* PCM output volume *******************/
 975static int snd_echo_output_gain_info(struct snd_kcontrol *kcontrol,
 976				     struct snd_ctl_elem_info *uinfo)
 977{
 978	struct echoaudio *chip;
 979
 980	chip = snd_kcontrol_chip(kcontrol);
 981	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 982	uinfo->count = num_busses_out(chip);
 983	uinfo->value.integer.min = ECHOGAIN_MINOUT;
 984	uinfo->value.integer.max = ECHOGAIN_MAXOUT;
 985	return 0;
 986}
 987
 988static int snd_echo_output_gain_get(struct snd_kcontrol *kcontrol,
 989				    struct snd_ctl_elem_value *ucontrol)
 990{
 991	struct echoaudio *chip;
 992	int c;
 993
 994	chip = snd_kcontrol_chip(kcontrol);
 995	for (c = 0; c < num_busses_out(chip); c++)
 996		ucontrol->value.integer.value[c] = chip->output_gain[c];
 997	return 0;
 998}
 999
1000static int snd_echo_output_gain_put(struct snd_kcontrol *kcontrol,
1001				    struct snd_ctl_elem_value *ucontrol)
1002{
1003	struct echoaudio *chip;
1004	int c, changed, gain;
1005
1006	changed = 0;
1007	chip = snd_kcontrol_chip(kcontrol);
1008	guard(spinlock_irq)(&chip->lock);
1009	for (c = 0; c < num_busses_out(chip); c++) {
1010		gain = ucontrol->value.integer.value[c];
1011		/* Ignore out of range values */
1012		if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1013			continue;
1014		if (chip->output_gain[c] != gain) {
1015			set_output_gain(chip, c, gain);
1016			changed = 1;
1017		}
1018	}
1019	if (changed)
1020		update_output_line_level(chip);
1021	return changed;
1022}
1023
1024#ifdef ECHOCARD_HAS_LINE_OUT_GAIN
1025/* On the Mia this one controls the line-out volume */
1026static const struct snd_kcontrol_new snd_echo_line_output_gain = {
1027	.name = "Line Playback Volume",
1028	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1029	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1030		  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1031	.info = snd_echo_output_gain_info,
1032	.get = snd_echo_output_gain_get,
1033	.put = snd_echo_output_gain_put,
1034	.tlv = {.p = db_scale_output_gain},
1035};
1036#else
1037static const struct snd_kcontrol_new snd_echo_pcm_output_gain = {
1038	.name = "PCM Playback Volume",
1039	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1040	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1041	.info = snd_echo_output_gain_info,
1042	.get = snd_echo_output_gain_get,
1043	.put = snd_echo_output_gain_put,
1044	.tlv = {.p = db_scale_output_gain},
1045};
1046#endif
1047
1048#endif /* !ECHOCARD_HAS_VMIXER || ECHOCARD_HAS_LINE_OUT_GAIN */
1049
1050
1051
1052#ifdef ECHOCARD_HAS_INPUT_GAIN
1053
1054/******************* Analog input volume *******************/
1055static int snd_echo_input_gain_info(struct snd_kcontrol *kcontrol,
1056				    struct snd_ctl_elem_info *uinfo)
1057{
1058	struct echoaudio *chip;
1059
1060	chip = snd_kcontrol_chip(kcontrol);
1061	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1062	uinfo->count = num_analog_busses_in(chip);
1063	uinfo->value.integer.min = ECHOGAIN_MININP;
1064	uinfo->value.integer.max = ECHOGAIN_MAXINP;
1065	return 0;
1066}
1067
1068static int snd_echo_input_gain_get(struct snd_kcontrol *kcontrol,
1069				   struct snd_ctl_elem_value *ucontrol)
1070{
1071	struct echoaudio *chip;
1072	int c;
1073
1074	chip = snd_kcontrol_chip(kcontrol);
1075	for (c = 0; c < num_analog_busses_in(chip); c++)
1076		ucontrol->value.integer.value[c] = chip->input_gain[c];
1077	return 0;
1078}
1079
1080static int snd_echo_input_gain_put(struct snd_kcontrol *kcontrol,
1081				   struct snd_ctl_elem_value *ucontrol)
1082{
1083	struct echoaudio *chip;
1084	int c, gain, changed;
1085
1086	changed = 0;
1087	chip = snd_kcontrol_chip(kcontrol);
1088	guard(spinlock_irq)(&chip->lock);
1089	for (c = 0; c < num_analog_busses_in(chip); c++) {
1090		gain = ucontrol->value.integer.value[c];
1091		/* Ignore out of range values */
1092		if (gain < ECHOGAIN_MININP || gain > ECHOGAIN_MAXINP)
1093			continue;
1094		if (chip->input_gain[c] != gain) {
1095			set_input_gain(chip, c, gain);
1096			changed = 1;
1097		}
1098	}
1099	if (changed)
1100		update_input_line_level(chip);
1101	return changed;
1102}
1103
1104static const DECLARE_TLV_DB_SCALE(db_scale_input_gain, -2500, 50, 0);
1105
1106static const struct snd_kcontrol_new snd_echo_line_input_gain = {
1107	.name = "Line Capture Volume",
1108	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1109	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1110	.info = snd_echo_input_gain_info,
1111	.get = snd_echo_input_gain_get,
1112	.put = snd_echo_input_gain_put,
1113	.tlv = {.p = db_scale_input_gain},
1114};
1115
1116#endif /* ECHOCARD_HAS_INPUT_GAIN */
1117
1118
1119
1120#ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
1121
1122/************ Analog output nominal level (+4dBu / -10dBV) ***************/
1123static int snd_echo_output_nominal_info (struct snd_kcontrol *kcontrol,
1124					 struct snd_ctl_elem_info *uinfo)
1125{
1126	struct echoaudio *chip;
1127
1128	chip = snd_kcontrol_chip(kcontrol);
1129	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1130	uinfo->count = num_analog_busses_out(chip);
1131	uinfo->value.integer.min = 0;
1132	uinfo->value.integer.max = 1;
1133	return 0;
1134}
1135
1136static int snd_echo_output_nominal_get(struct snd_kcontrol *kcontrol,
1137				       struct snd_ctl_elem_value *ucontrol)
1138{
1139	struct echoaudio *chip;
1140	int c;
1141
1142	chip = snd_kcontrol_chip(kcontrol);
1143	for (c = 0; c < num_analog_busses_out(chip); c++)
1144		ucontrol->value.integer.value[c] = chip->nominal_level[c];
1145	return 0;
1146}
1147
1148static int snd_echo_output_nominal_put(struct snd_kcontrol *kcontrol,
1149				       struct snd_ctl_elem_value *ucontrol)
1150{
1151	struct echoaudio *chip;
1152	int c, changed;
1153
1154	changed = 0;
1155	chip = snd_kcontrol_chip(kcontrol);
1156	guard(spinlock_irq)(&chip->lock);
1157	for (c = 0; c < num_analog_busses_out(chip); c++) {
1158		if (chip->nominal_level[c] != ucontrol->value.integer.value[c]) {
1159			set_nominal_level(chip, c,
1160					  ucontrol->value.integer.value[c]);
1161			changed = 1;
1162		}
1163	}
1164	if (changed)
1165		update_output_line_level(chip);
1166	return changed;
1167}
1168
1169static const struct snd_kcontrol_new snd_echo_output_nominal_level = {
1170	.name = "Line Playback Switch (-10dBV)",
1171	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1172	.info = snd_echo_output_nominal_info,
1173	.get = snd_echo_output_nominal_get,
1174	.put = snd_echo_output_nominal_put,
1175};
1176
1177#endif /* ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL */
1178
1179
1180
1181#ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
1182
1183/*************** Analog input nominal level (+4dBu / -10dBV) ***************/
1184static int snd_echo_input_nominal_info(struct snd_kcontrol *kcontrol,
1185				       struct snd_ctl_elem_info *uinfo)
1186{
1187	struct echoaudio *chip;
1188
1189	chip = snd_kcontrol_chip(kcontrol);
1190	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1191	uinfo->count = num_analog_busses_in(chip);
1192	uinfo->value.integer.min = 0;
1193	uinfo->value.integer.max = 1;
1194	return 0;
1195}
1196
1197static int snd_echo_input_nominal_get(struct snd_kcontrol *kcontrol,
1198				      struct snd_ctl_elem_value *ucontrol)
1199{
1200	struct echoaudio *chip;
1201	int c;
1202
1203	chip = snd_kcontrol_chip(kcontrol);
1204	for (c = 0; c < num_analog_busses_in(chip); c++)
1205		ucontrol->value.integer.value[c] =
1206			chip->nominal_level[bx_analog_in(chip) + c];
1207	return 0;
1208}
1209
1210static int snd_echo_input_nominal_put(struct snd_kcontrol *kcontrol,
1211				      struct snd_ctl_elem_value *ucontrol)
1212{
1213	struct echoaudio *chip;
1214	int c, changed;
1215
1216	changed = 0;
1217	chip = snd_kcontrol_chip(kcontrol);
1218	guard(spinlock_irq)(&chip->lock);
1219	for (c = 0; c < num_analog_busses_in(chip); c++) {
1220		if (chip->nominal_level[bx_analog_in(chip) + c] !=
1221		    ucontrol->value.integer.value[c]) {
1222			set_nominal_level(chip, bx_analog_in(chip) + c,
1223					  ucontrol->value.integer.value[c]);
1224			changed = 1;
1225		}
1226	}
1227	if (changed)
1228		update_output_line_level(chip);	/* "Output" is not a mistake
1229						 * here.
1230						 */
1231	return changed;
1232}
1233
1234static const struct snd_kcontrol_new snd_echo_intput_nominal_level = {
1235	.name = "Line Capture Switch (-10dBV)",
1236	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1237	.info = snd_echo_input_nominal_info,
1238	.get = snd_echo_input_nominal_get,
1239	.put = snd_echo_input_nominal_put,
1240};
1241
1242#endif /* ECHOCARD_HAS_INPUT_NOMINAL_LEVEL */
1243
1244
1245
1246#ifdef ECHOCARD_HAS_MONITOR
1247
1248/******************* Monitor mixer *******************/
1249static int snd_echo_mixer_info(struct snd_kcontrol *kcontrol,
1250			       struct snd_ctl_elem_info *uinfo)
1251{
1252	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1253	uinfo->count = 1;
1254	uinfo->value.integer.min = ECHOGAIN_MINOUT;
1255	uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1256	return 0;
1257}
1258
1259static int snd_echo_mixer_get(struct snd_kcontrol *kcontrol,
1260			      struct snd_ctl_elem_value *ucontrol)
1261{
1262	struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1263	unsigned int out = ucontrol->id.index / num_busses_in(chip);
1264	unsigned int in = ucontrol->id.index % num_busses_in(chip);
1265
1266	if (out >= ECHO_MAXAUDIOOUTPUTS || in >= ECHO_MAXAUDIOINPUTS)
1267		return -EINVAL;
1268
1269	ucontrol->value.integer.value[0] = chip->monitor_gain[out][in];
1270	return 0;
1271}
1272
1273static int snd_echo_mixer_put(struct snd_kcontrol *kcontrol,
1274			      struct snd_ctl_elem_value *ucontrol)
1275{
1276	struct echoaudio *chip;
1277	int changed,  gain;
1278	unsigned int out, in;
1279
1280	changed = 0;
1281	chip = snd_kcontrol_chip(kcontrol);
1282	out = ucontrol->id.index / num_busses_in(chip);
1283	in = ucontrol->id.index % num_busses_in(chip);
1284	if (out >= ECHO_MAXAUDIOOUTPUTS || in >= ECHO_MAXAUDIOINPUTS)
1285		return -EINVAL;
1286	gain = ucontrol->value.integer.value[0];
1287	if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1288		return -EINVAL;
1289	if (chip->monitor_gain[out][in] != gain) {
1290		guard(spinlock_irq)(&chip->lock);
1291		set_monitor_gain(chip, out, in, gain);
1292		update_output_line_level(chip);
1293		changed = 1;
1294	}
1295	return changed;
1296}
1297
1298static struct snd_kcontrol_new snd_echo_monitor_mixer = {
1299	.name = "Monitor Mixer Volume",
1300	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1301	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1302	.info = snd_echo_mixer_info,
1303	.get = snd_echo_mixer_get,
1304	.put = snd_echo_mixer_put,
1305	.tlv = {.p = db_scale_output_gain},
1306};
1307
1308#endif /* ECHOCARD_HAS_MONITOR */
1309
1310
1311
1312#ifdef ECHOCARD_HAS_VMIXER
1313
1314/******************* Vmixer *******************/
1315static int snd_echo_vmixer_info(struct snd_kcontrol *kcontrol,
1316				struct snd_ctl_elem_info *uinfo)
1317{
1318	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1319	uinfo->count = 1;
1320	uinfo->value.integer.min = ECHOGAIN_MINOUT;
1321	uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1322	return 0;
1323}
1324
1325static int snd_echo_vmixer_get(struct snd_kcontrol *kcontrol,
1326			       struct snd_ctl_elem_value *ucontrol)
1327{
1328	struct echoaudio *chip;
1329
1330	chip = snd_kcontrol_chip(kcontrol);
1331	ucontrol->value.integer.value[0] =
1332		chip->vmixer_gain[ucontrol->id.index / num_pipes_out(chip)]
1333			[ucontrol->id.index % num_pipes_out(chip)];
1334	return 0;
1335}
1336
1337static int snd_echo_vmixer_put(struct snd_kcontrol *kcontrol,
1338			       struct snd_ctl_elem_value *ucontrol)
1339{
1340	struct echoaudio *chip;
1341	int gain, changed;
1342	short vch, out;
1343
1344	changed = 0;
1345	chip = snd_kcontrol_chip(kcontrol);
1346	out = ucontrol->id.index / num_pipes_out(chip);
1347	vch = ucontrol->id.index % num_pipes_out(chip);
1348	gain = ucontrol->value.integer.value[0];
1349	if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1350		return -EINVAL;
1351	if (chip->vmixer_gain[out][vch] != ucontrol->value.integer.value[0]) {
1352		guard(spinlock_irq)(&chip->lock);
1353		set_vmixer_gain(chip, out, vch, ucontrol->value.integer.value[0]);
1354		update_vmixer_level(chip);
1355		changed = 1;
1356	}
1357	return changed;
1358}
1359
1360static struct snd_kcontrol_new snd_echo_vmixer = {
1361	.name = "VMixer Volume",
1362	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1363	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1364	.info = snd_echo_vmixer_info,
1365	.get = snd_echo_vmixer_get,
1366	.put = snd_echo_vmixer_put,
1367	.tlv = {.p = db_scale_output_gain},
1368};
1369
1370#endif /* ECHOCARD_HAS_VMIXER */
1371
1372
1373
1374#ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
1375
1376/******************* Digital mode switch *******************/
1377static int snd_echo_digital_mode_info(struct snd_kcontrol *kcontrol,
1378				      struct snd_ctl_elem_info *uinfo)
1379{
1380	static const char * const names[4] = {
1381		"S/PDIF Coaxial", "S/PDIF Optical", "ADAT Optical",
1382		"S/PDIF Cdrom"
1383	};
1384	struct echoaudio *chip;
1385
1386	chip = snd_kcontrol_chip(kcontrol);
1387	return snd_ctl_enum_info(uinfo, 1, chip->num_digital_modes, names);
1388}
1389
1390static int snd_echo_digital_mode_get(struct snd_kcontrol *kcontrol,
1391				     struct snd_ctl_elem_value *ucontrol)
1392{
1393	struct echoaudio *chip;
1394	int i, mode;
1395
1396	chip = snd_kcontrol_chip(kcontrol);
1397	mode = chip->digital_mode;
1398	for (i = chip->num_digital_modes - 1; i >= 0; i--)
1399		if (mode == chip->digital_mode_list[i]) {
1400			ucontrol->value.enumerated.item[0] = i;
1401			break;
1402		}
1403	return 0;
1404}
1405
1406static int snd_echo_digital_mode_put(struct snd_kcontrol *kcontrol,
1407				     struct snd_ctl_elem_value *ucontrol)
1408{
1409	struct echoaudio *chip;
1410	int changed;
1411	unsigned short emode, dmode;
1412
1413	changed = 0;
1414	chip = snd_kcontrol_chip(kcontrol);
1415
1416	emode = ucontrol->value.enumerated.item[0];
1417	if (emode >= chip->num_digital_modes)
1418		return -EINVAL;
1419	dmode = chip->digital_mode_list[emode];
1420
1421	if (dmode != chip->digital_mode) {
1422		/* mode_mutex is required to make this operation atomic wrt
1423		pcm_digital_*_open() and set_input_clock() functions. */
1424		guard(mutex)(&chip->mode_mutex);
1425
1426		/* Do not allow the user to change the digital mode when a pcm
1427		device is open because it also changes the number of channels
1428		and the allowed sample rates */
1429		if (chip->opencount) {
1430			changed = -EAGAIN;
1431		} else {
1432			changed = set_digital_mode(chip, dmode);
1433			/* If we had to change the clock source, report it */
1434			if (changed > 0 && chip->clock_src_ctl) {
1435				snd_ctl_notify(chip->card,
1436					       SNDRV_CTL_EVENT_MASK_VALUE,
1437					       &chip->clock_src_ctl->id);
1438				dev_dbg(chip->card->dev,
1439					"SDM() =%d\n", changed);
1440			}
1441			if (changed >= 0)
1442				changed = 1;	/* No errors */
1443		}
1444	}
1445	return changed;
1446}
1447
1448static const struct snd_kcontrol_new snd_echo_digital_mode_switch = {
1449	.name = "Digital mode Switch",
1450	.iface = SNDRV_CTL_ELEM_IFACE_CARD,
1451	.info = snd_echo_digital_mode_info,
1452	.get = snd_echo_digital_mode_get,
1453	.put = snd_echo_digital_mode_put,
1454};
1455
1456#endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
1457
1458
1459
1460#ifdef ECHOCARD_HAS_DIGITAL_IO
1461
1462/******************* S/PDIF mode switch *******************/
1463static int snd_echo_spdif_mode_info(struct snd_kcontrol *kcontrol,
1464				    struct snd_ctl_elem_info *uinfo)
1465{
1466	static const char * const names[2] = {"Consumer", "Professional"};
1467
1468	return snd_ctl_enum_info(uinfo, 1, 2, names);
1469}
1470
1471static int snd_echo_spdif_mode_get(struct snd_kcontrol *kcontrol,
1472				   struct snd_ctl_elem_value *ucontrol)
1473{
1474	struct echoaudio *chip;
1475
1476	chip = snd_kcontrol_chip(kcontrol);
1477	ucontrol->value.enumerated.item[0] = !!chip->professional_spdif;
1478	return 0;
1479}
1480
1481static int snd_echo_spdif_mode_put(struct snd_kcontrol *kcontrol,
1482				   struct snd_ctl_elem_value *ucontrol)
1483{
1484	struct echoaudio *chip;
1485	int mode;
1486
1487	chip = snd_kcontrol_chip(kcontrol);
1488	mode = !!ucontrol->value.enumerated.item[0];
1489	if (mode != chip->professional_spdif) {
1490		guard(spinlock_irq)(&chip->lock);
1491		set_professional_spdif(chip, mode);
1492		return 1;
1493	}
1494	return 0;
1495}
1496
1497static const struct snd_kcontrol_new snd_echo_spdif_mode_switch = {
1498	.name = "S/PDIF mode Switch",
1499	.iface = SNDRV_CTL_ELEM_IFACE_CARD,
1500	.info = snd_echo_spdif_mode_info,
1501	.get = snd_echo_spdif_mode_get,
1502	.put = snd_echo_spdif_mode_put,
1503};
1504
1505#endif /* ECHOCARD_HAS_DIGITAL_IO */
1506
1507
1508
1509#ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
1510
1511/******************* Select input clock source *******************/
1512static int snd_echo_clock_source_info(struct snd_kcontrol *kcontrol,
1513				      struct snd_ctl_elem_info *uinfo)
1514{
1515	static const char * const names[8] = {
1516		"Internal", "Word", "Super", "S/PDIF", "ADAT", "ESync",
1517		"ESync96", "MTC"
1518	};
1519	struct echoaudio *chip;
1520
1521	chip = snd_kcontrol_chip(kcontrol);
1522	return snd_ctl_enum_info(uinfo, 1, chip->num_clock_sources, names);
1523}
1524
1525static int snd_echo_clock_source_get(struct snd_kcontrol *kcontrol,
1526				     struct snd_ctl_elem_value *ucontrol)
1527{
1528	struct echoaudio *chip;
1529	int i, clock;
1530
1531	chip = snd_kcontrol_chip(kcontrol);
1532	clock = chip->input_clock;
1533
1534	for (i = 0; i < chip->num_clock_sources; i++)
1535		if (clock == chip->clock_source_list[i])
1536			ucontrol->value.enumerated.item[0] = i;
1537
1538	return 0;
1539}
1540
1541static int snd_echo_clock_source_put(struct snd_kcontrol *kcontrol,
1542				     struct snd_ctl_elem_value *ucontrol)
1543{
1544	struct echoaudio *chip;
1545	int changed;
1546	unsigned int eclock, dclock;
1547
1548	changed = 0;
1549	chip = snd_kcontrol_chip(kcontrol);
1550	eclock = ucontrol->value.enumerated.item[0];
1551	if (eclock >= chip->input_clock_types)
1552		return -EINVAL;
1553	dclock = chip->clock_source_list[eclock];
1554	if (chip->input_clock != dclock) {
1555		guard(mutex)(&chip->mode_mutex);
1556		guard(spinlock_irq)(&chip->lock);
1557		changed = set_input_clock(chip, dclock);
1558		if (!changed)
1559			changed = 1;	/* no errors */
1560	}
1561
1562	if (changed < 0)
1563		dev_dbg(chip->card->dev,
1564			"seticlk val%d err 0x%x\n", dclock, changed);
1565
1566	return changed;
1567}
1568
1569static const struct snd_kcontrol_new snd_echo_clock_source_switch = {
1570	.name = "Sample Clock Source",
1571	.iface = SNDRV_CTL_ELEM_IFACE_PCM,
1572	.info = snd_echo_clock_source_info,
1573	.get = snd_echo_clock_source_get,
1574	.put = snd_echo_clock_source_put,
1575};
1576
1577#endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
1578
1579
1580
1581#ifdef ECHOCARD_HAS_PHANTOM_POWER
1582
1583/******************* Phantom power switch *******************/
1584#define snd_echo_phantom_power_info	snd_ctl_boolean_mono_info
1585
1586static int snd_echo_phantom_power_get(struct snd_kcontrol *kcontrol,
1587				      struct snd_ctl_elem_value *ucontrol)
1588{
1589	struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1590
1591	ucontrol->value.integer.value[0] = chip->phantom_power;
1592	return 0;
1593}
1594
1595static int snd_echo_phantom_power_put(struct snd_kcontrol *kcontrol,
1596				      struct snd_ctl_elem_value *ucontrol)
1597{
1598	struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1599	int power, changed = 0;
1600
1601	power = !!ucontrol->value.integer.value[0];
1602	if (chip->phantom_power != power) {
1603		guard(spinlock_irq)(&chip->lock);
1604		changed = set_phantom_power(chip, power);
1605		if (changed == 0)
1606			changed = 1;	/* no errors */
1607	}
1608	return changed;
1609}
1610
1611static const struct snd_kcontrol_new snd_echo_phantom_power_switch = {
1612	.name = "Phantom power Switch",
1613	.iface = SNDRV_CTL_ELEM_IFACE_CARD,
1614	.info = snd_echo_phantom_power_info,
1615	.get = snd_echo_phantom_power_get,
1616	.put = snd_echo_phantom_power_put,
1617};
1618
1619#endif /* ECHOCARD_HAS_PHANTOM_POWER */
1620
1621
1622
1623#ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
1624
1625/******************* Digital input automute switch *******************/
1626#define snd_echo_automute_info		snd_ctl_boolean_mono_info
1627
1628static int snd_echo_automute_get(struct snd_kcontrol *kcontrol,
1629				 struct snd_ctl_elem_value *ucontrol)
1630{
1631	struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1632
1633	ucontrol->value.integer.value[0] = chip->digital_in_automute;
1634	return 0;
1635}
1636
1637static int snd_echo_automute_put(struct snd_kcontrol *kcontrol,
1638				 struct snd_ctl_elem_value *ucontrol)
1639{
1640	struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1641	int automute, changed = 0;
1642
1643	automute = !!ucontrol->value.integer.value[0];
1644	if (chip->digital_in_automute != automute) {
1645		guard(spinlock_irq)(&chip->lock);
1646		changed = set_input_auto_mute(chip, automute);
1647		if (changed == 0)
1648			changed = 1;	/* no errors */
1649	}
1650	return changed;
1651}
1652
1653static const struct snd_kcontrol_new snd_echo_automute_switch = {
1654	.name = "Digital Capture Switch (automute)",
1655	.iface = SNDRV_CTL_ELEM_IFACE_CARD,
1656	.info = snd_echo_automute_info,
1657	.get = snd_echo_automute_get,
1658	.put = snd_echo_automute_put,
1659};
1660
1661#endif /* ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE */
1662
1663
1664
1665/******************* VU-meters switch *******************/
1666#define snd_echo_vumeters_switch_info		snd_ctl_boolean_mono_info
1667
1668static int snd_echo_vumeters_switch_put(struct snd_kcontrol *kcontrol,
1669					struct snd_ctl_elem_value *ucontrol)
1670{
1671	struct echoaudio *chip;
1672
1673	chip = snd_kcontrol_chip(kcontrol);
1674	guard(spinlock_irq)(&chip->lock);
1675	set_meters_on(chip, ucontrol->value.integer.value[0]);
1676	return 1;
1677}
1678
1679static const struct snd_kcontrol_new snd_echo_vumeters_switch = {
1680	.name = "VU-meters Switch",
1681	.iface = SNDRV_CTL_ELEM_IFACE_CARD,
1682	.access = SNDRV_CTL_ELEM_ACCESS_WRITE,
1683	.info = snd_echo_vumeters_switch_info,
1684	.put = snd_echo_vumeters_switch_put,
1685};
1686
1687
1688
1689/***** Read VU-meters (input, output, analog and digital together) *****/
1690static int snd_echo_vumeters_info(struct snd_kcontrol *kcontrol,
1691				  struct snd_ctl_elem_info *uinfo)
1692{
1693	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1694	uinfo->count = 96;
1695	uinfo->value.integer.min = ECHOGAIN_MINOUT;
1696	uinfo->value.integer.max = 0;
1697	return 0;
1698}
1699
1700static int snd_echo_vumeters_get(struct snd_kcontrol *kcontrol,
1701				 struct snd_ctl_elem_value *ucontrol)
1702{
1703	struct echoaudio *chip;
1704
1705	chip = snd_kcontrol_chip(kcontrol);
1706	get_audio_meters(chip, ucontrol->value.integer.value);
1707	return 0;
1708}
1709
1710static const struct snd_kcontrol_new snd_echo_vumeters = {
1711	.name = "VU-meters",
1712	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1713	.access = SNDRV_CTL_ELEM_ACCESS_READ |
1714		  SNDRV_CTL_ELEM_ACCESS_VOLATILE |
1715		  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1716	.info = snd_echo_vumeters_info,
1717	.get = snd_echo_vumeters_get,
1718	.tlv = {.p = db_scale_output_gain},
1719};
1720
1721
1722
1723/*** Channels info - it exports informations about the number of channels ***/
1724static int snd_echo_channels_info_info(struct snd_kcontrol *kcontrol,
1725				       struct snd_ctl_elem_info *uinfo)
1726{
1727	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1728	uinfo->count = 6;
1729	uinfo->value.integer.min = 0;
1730	uinfo->value.integer.max = 1 << ECHO_CLOCK_NUMBER;
1731	return 0;
1732}
1733
1734static int snd_echo_channels_info_get(struct snd_kcontrol *kcontrol,
1735				      struct snd_ctl_elem_value *ucontrol)
1736{
1737	struct echoaudio *chip;
1738	int detected, clocks, bit, src;
1739
1740	chip = snd_kcontrol_chip(kcontrol);
1741	ucontrol->value.integer.value[0] = num_busses_in(chip);
1742	ucontrol->value.integer.value[1] = num_analog_busses_in(chip);
1743	ucontrol->value.integer.value[2] = num_busses_out(chip);
1744	ucontrol->value.integer.value[3] = num_analog_busses_out(chip);
1745	ucontrol->value.integer.value[4] = num_pipes_out(chip);
1746
1747	/* Compute the bitmask of the currently valid input clocks */
1748	detected = detect_input_clocks(chip);
1749	clocks = 0;
1750	src = chip->num_clock_sources - 1;
1751	for (bit = ECHO_CLOCK_NUMBER - 1; bit >= 0; bit--)
1752		if (detected & (1 << bit))
1753			for (; src >= 0; src--)
1754				if (bit == chip->clock_source_list[src]) {
1755					clocks |= 1 << src;
1756					break;
1757				}
1758	ucontrol->value.integer.value[5] = clocks;
1759
1760	return 0;
1761}
1762
1763static const struct snd_kcontrol_new snd_echo_channels_info = {
1764	.name = "Channels info",
1765	.iface = SNDRV_CTL_ELEM_IFACE_HWDEP,
1766	.access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1767	.info = snd_echo_channels_info_info,
1768	.get = snd_echo_channels_info_get,
1769};
1770
1771
1772
1773
1774/******************************************************************************
1775	IRQ Handling
1776******************************************************************************/
1777/* Check if a period has elapsed since last interrupt
1778 *
1779 * Don't make any updates to state; PCM core handles this with the
1780 * correct locks.
1781 *
1782 * \return true if a period has elapsed, otherwise false
1783 */
1784static bool period_has_elapsed(struct snd_pcm_substream *substream)
1785{
1786	struct snd_pcm_runtime *runtime = substream->runtime;
1787	struct audiopipe *pipe = runtime->private_data;
1788	u32 counter, step;
1789	size_t period_bytes;
1790
1791	if (pipe->state != PIPE_STATE_STARTED)
1792		return false;
1793
1794	period_bytes = frames_to_bytes(runtime, runtime->period_size);
1795
1796	counter = le32_to_cpu(*pipe->dma_counter);  /* presumed atomic */
1797
1798	step = counter - pipe->last_period;  /* handles wrapping */
1799	step -= step % period_bytes;  /* acknowledge whole periods only */
1800
1801	if (step == 0)
1802		return false;  /* haven't advanced a whole period yet */
1803
1804	pipe->last_period += step;  /* used exclusively by us */
1805	return true;
1806}
1807
1808static irqreturn_t snd_echo_interrupt(int irq, void *dev_id)
1809{
1810	struct echoaudio *chip = dev_id;
1811	int ss, st;
1812
1813	spin_lock(&chip->lock);
1814	st = service_irq(chip);
1815	if (st < 0) {
1816		spin_unlock(&chip->lock);
1817		return IRQ_NONE;
1818	}
1819	/* The hardware doesn't tell us which substream caused the irq,
1820	thus we have to check all running substreams. */
1821	for (ss = 0; ss < DSP_MAXPIPES; ss++) {
1822		struct snd_pcm_substream *substream;
1823
1824		substream = chip->substream[ss];
1825		if (substream && period_has_elapsed(substream)) {
1826			spin_unlock(&chip->lock);
1827			snd_pcm_period_elapsed(substream);
1828			spin_lock(&chip->lock);
1829		}
1830	}
1831	spin_unlock(&chip->lock);
1832
1833#ifdef ECHOCARD_HAS_MIDI
1834	if (st > 0 && chip->midi_in) {
1835		snd_rawmidi_receive(chip->midi_in, chip->midi_buffer, st);
1836		dev_dbg(chip->card->dev, "rawmidi_iread=%d\n", st);
1837	}
1838#endif
1839	return IRQ_HANDLED;
1840}
1841
1842
1843
1844
1845/******************************************************************************
1846	Module construction / destruction
1847******************************************************************************/
1848
1849static void snd_echo_free(struct snd_card *card)
1850{
1851	struct echoaudio *chip = card->private_data;
1852
1853	if (chip->comm_page)
1854		rest_in_peace(chip);
1855
1856	if (chip->irq >= 0)
1857		free_irq(chip->irq, chip);
1858
1859	/* release chip data */
1860	free_firmware_cache(chip);
1861}
1862
1863/* <--snd_echo_probe() */
1864static int snd_echo_create(struct snd_card *card,
1865			   struct pci_dev *pci)
1866{
1867	struct echoaudio *chip = card->private_data;
1868	int err;
1869	size_t sz;
1870
1871	pci_write_config_byte(pci, PCI_LATENCY_TIMER, 0xC0);
1872
1873	err = pcim_enable_device(pci);
1874	if (err < 0)
1875		return err;
1876	pci_set_master(pci);
1877
1878	/* Allocate chip if needed */
1879	spin_lock_init(&chip->lock);
1880	chip->card = card;
1881	chip->pci = pci;
1882	chip->irq = -1;
1883	chip->opencount = 0;
1884	mutex_init(&chip->mode_mutex);
1885	chip->can_set_rate = 1;
1886
1887	/* PCI resource allocation */
1888	err = pcim_request_all_regions(pci, ECHOCARD_NAME);
1889	if (err < 0)
1890		return err;
1891
1892	chip->dsp_registers_phys = pci_resource_start(pci, 0);
1893	sz = pci_resource_len(pci, 0);
1894	if (sz > PAGE_SIZE)
1895		sz = PAGE_SIZE;		/* We map only the required part */
1896
1897	chip->dsp_registers = devm_ioremap(&pci->dev, chip->dsp_registers_phys, sz);
1898	if (!chip->dsp_registers) {
1899		dev_err(chip->card->dev, "ioremap failed\n");
1900		return -ENOMEM;
1901	}
1902
1903	if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
1904			KBUILD_MODNAME, chip)) {
1905		dev_err(chip->card->dev, "cannot grab irq\n");
1906		return -EBUSY;
1907	}
1908	chip->irq = pci->irq;
1909	card->sync_irq = chip->irq;
1910	dev_dbg(card->dev, "pci=%p irq=%d subdev=%04x Init hardware...\n",
1911		chip->pci, chip->irq, chip->pci->subsystem_device);
1912
1913	card->private_free = snd_echo_free;
1914
1915	/* Create the DSP comm page - this is the area of memory used for most
1916	of the communication with the DSP, which accesses it via bus mastering */
1917	chip->commpage_dma_buf =
1918		snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV,
1919				     sizeof(struct comm_page));
1920	if (!chip->commpage_dma_buf)
1921		return -ENOMEM;
1922	chip->comm_page_phys = chip->commpage_dma_buf->addr;
1923	chip->comm_page = (struct comm_page *)chip->commpage_dma_buf->area;
1924
1925	err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
1926	if (err >= 0)
1927		err = set_mixer_defaults(chip);
1928	if (err < 0) {
1929		dev_err(card->dev, "init_hw err=%d\n", err);
1930		return err;
1931	}
1932
1933	return 0;
1934}
1935
1936/* constructor */
1937static int __snd_echo_probe(struct pci_dev *pci,
1938			    const struct pci_device_id *pci_id)
1939{
1940	static int dev;
1941	struct snd_card *card;
1942	struct echoaudio *chip;
1943	char *dsp;
1944	int err;
1945
1946	if (dev >= SNDRV_CARDS)
1947		return -ENODEV;
1948	if (!enable[dev]) {
1949		dev++;
1950		return -ENOENT;
1951	}
1952
1953	err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
1954				sizeof(*chip), &card);
1955	if (err < 0)
1956		return err;
1957	chip = card->private_data;
1958
1959	err = snd_echo_create(card, pci);
1960	if (err < 0)
1961		return err;
1962
1963	strscpy(card->driver, "Echo_" ECHOCARD_NAME);
1964	strscpy(card->shortname, chip->card_name);
1965
1966	dsp = "56301";
1967	if (pci_id->device == 0x3410)
1968		dsp = "56361";
1969
1970	sprintf(card->longname, "%s rev.%d (DSP%s) at 0x%lx irq %i",
1971		card->shortname, pci_id->subdevice & 0x000f, dsp,
1972		chip->dsp_registers_phys, chip->irq);
1973
1974	err = snd_echo_new_pcm(chip);
1975	if (err < 0) {
1976		dev_err(chip->card->dev, "new pcm error %d\n", err);
1977		return err;
1978	}
1979
1980#ifdef ECHOCARD_HAS_MIDI
1981	if (chip->has_midi) {	/* Some Mia's do not have midi */
1982		err = snd_echo_midi_create(card, chip);
1983		if (err < 0) {
1984			dev_err(chip->card->dev, "new midi error %d\n", err);
1985			return err;
1986		}
1987	}
1988#endif
1989
1990#ifdef ECHOCARD_HAS_VMIXER
1991	snd_echo_vmixer.count = num_pipes_out(chip) * num_busses_out(chip);
1992	err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vmixer, chip));
1993	if (err < 0)
1994		return err;
1995#ifdef ECHOCARD_HAS_LINE_OUT_GAIN
1996	err = snd_ctl_add(chip->card,
1997			  snd_ctl_new1(&snd_echo_line_output_gain, chip));
1998	if (err < 0)
1999		return err;
2000#endif
2001#else /* ECHOCARD_HAS_VMIXER */
2002	err = snd_ctl_add(chip->card,
2003			  snd_ctl_new1(&snd_echo_pcm_output_gain, chip));
2004	if (err < 0)
2005		return err;
2006#endif /* ECHOCARD_HAS_VMIXER */
2007
2008#ifdef ECHOCARD_HAS_INPUT_GAIN
2009	err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_input_gain, chip));
2010	if (err < 0)
2011		return err;
2012#endif
2013
2014#ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
2015	if (!chip->hasnt_input_nominal_level) {
2016		err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_intput_nominal_level, chip));
2017		if (err < 0)
2018			return err;
2019	}
2020#endif
2021
2022#ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
2023	err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_output_nominal_level, chip));
2024	if (err < 0)
2025		return err;
2026#endif
2027
2028	err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters_switch, chip));
2029	if (err < 0)
2030		return err;
2031
2032	err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters, chip));
2033	if (err < 0)
2034		return err;
2035
2036#ifdef ECHOCARD_HAS_MONITOR
2037	snd_echo_monitor_mixer.count = num_busses_in(chip) * num_busses_out(chip);
2038	err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_monitor_mixer, chip));
2039	if (err < 0)
2040		return err;
2041#endif
2042
2043#ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
2044	err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_automute_switch, chip));
2045	if (err < 0)
2046		return err;
2047#endif
2048
2049	err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_channels_info, chip));
2050	if (err < 0)
2051		return err;
2052
2053#ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
2054	/* Creates a list of available digital modes */
2055	chip->num_digital_modes = 0;
2056	for (int i = 0; i < 6; i++)
2057		if (chip->digital_modes & (1 << i))
2058			chip->digital_mode_list[chip->num_digital_modes++] = i;
2059
2060	err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_digital_mode_switch, chip));
2061	if (err < 0)
2062		return err;
2063#endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
2064
2065#ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
2066	/* Creates a list of available clock sources */
2067	chip->num_clock_sources = 0;
2068	for (int i = 0; i < 10; i++)
2069		if (chip->input_clock_types & (1 << i))
2070			chip->clock_source_list[chip->num_clock_sources++] = i;
2071
2072	if (chip->num_clock_sources > 1) {
2073		chip->clock_src_ctl = snd_ctl_new1(&snd_echo_clock_source_switch, chip);
2074		err = snd_ctl_add(chip->card, chip->clock_src_ctl);
2075		if (err < 0)
2076			return err;
2077	}
2078#endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
2079
2080#ifdef ECHOCARD_HAS_DIGITAL_IO
2081	err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_spdif_mode_switch, chip));
2082	if (err < 0)
2083		return err;
2084#endif
2085
2086#ifdef ECHOCARD_HAS_PHANTOM_POWER
2087	if (chip->has_phantom_power) {
2088		err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_phantom_power_switch, chip));
2089		if (err < 0)
2090			return err;
2091	}
2092#endif
2093
2094	err = snd_card_register(card);
2095	if (err < 0)
2096		return err;
2097	dev_info(card->dev, "Card registered: %s\n", card->longname);
2098
2099	pci_set_drvdata(pci, chip);
2100	dev++;
2101	return 0;
2102}
2103
2104static int snd_echo_probe(struct pci_dev *pci,
2105			  const struct pci_device_id *pci_id)
2106{
2107	return snd_card_free_on_error(&pci->dev, __snd_echo_probe(pci, pci_id));
2108}
2109
2110
2111static int snd_echo_suspend(struct device *dev)
2112{
2113	struct echoaudio *chip = dev_get_drvdata(dev);
2114
2115#ifdef ECHOCARD_HAS_MIDI
2116	/* This call can sleep */
2117	if (chip->midi_out)
2118		snd_echo_midi_output_trigger(chip->midi_out, 0);
2119#endif
2120	scoped_guard(spinlock_irq, &chip->lock) {
2121		if (wait_handshake(chip))
2122			return -EIO;
2123		clear_handshake(chip);
2124		if (send_vector(chip, DSP_VC_GO_COMATOSE) < 0)
2125			return -EIO;
2126	}
2127
2128	chip->dsp_code = NULL;
2129	free_irq(chip->irq, chip);
2130	chip->irq = -1;
2131	chip->card->sync_irq = -1;
2132	return 0;
2133}
2134
2135
2136
2137static int snd_echo_resume(struct device *dev)
2138{
2139	struct pci_dev *pci = to_pci_dev(dev);
2140	struct echoaudio *chip = dev_get_drvdata(dev);
2141	struct comm_page *commpage, *commpage_bak;
2142	u32 pipe_alloc_mask;
2143	int err;
2144
2145	commpage = chip->comm_page;
2146	commpage_bak = kmemdup(commpage, sizeof(*commpage), GFP_KERNEL);
2147	if (commpage_bak == NULL)
2148		return -ENOMEM;
2149
2150	err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
2151	if (err < 0) {
2152		kfree(commpage_bak);
2153		dev_err(dev, "resume init_hw err=%d\n", err);
2154		return err;
2155	}
2156
2157	/* Temporarily set chip->pipe_alloc_mask=0 otherwise
2158	 * restore_dsp_settings() fails.
2159	 */
2160	pipe_alloc_mask = chip->pipe_alloc_mask;
2161	chip->pipe_alloc_mask = 0;
2162	err = restore_dsp_rettings(chip);
2163	chip->pipe_alloc_mask = pipe_alloc_mask;
2164	if (err < 0) {
2165		kfree(commpage_bak);
2166		return err;
2167	}
2168
2169	memcpy(&commpage->audio_format, &commpage_bak->audio_format,
2170		sizeof(commpage->audio_format));
2171	memcpy(&commpage->sglist_addr, &commpage_bak->sglist_addr,
2172		sizeof(commpage->sglist_addr));
2173	memcpy(&commpage->midi_output, &commpage_bak->midi_output,
2174		sizeof(commpage->midi_output));
2175	kfree(commpage_bak);
2176
2177	if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
2178			KBUILD_MODNAME, chip)) {
2179		dev_err(chip->card->dev, "cannot grab irq\n");
2180		return -EBUSY;
2181	}
2182	chip->irq = pci->irq;
2183	chip->card->sync_irq = chip->irq;
2184	dev_dbg(dev, "resume irq=%d\n", chip->irq);
2185
2186#ifdef ECHOCARD_HAS_MIDI
2187	if (chip->midi_input_enabled)
2188		enable_midi_input(chip, true);
2189	if (chip->midi_out)
2190		snd_echo_midi_output_trigger(chip->midi_out, 1);
2191#endif
2192
2193	return 0;
2194}
2195
2196static DEFINE_SIMPLE_DEV_PM_OPS(snd_echo_pm, snd_echo_suspend, snd_echo_resume);
2197
2198/******************************************************************************
2199	Everything starts and ends here
2200******************************************************************************/
2201
2202/* pci_driver definition */
2203static struct pci_driver echo_driver = {
2204	.name = KBUILD_MODNAME,
2205	.id_table = snd_echo_ids,
2206	.probe = snd_echo_probe,
2207	.driver = {
2208		.pm = &snd_echo_pm,
2209	},
2210};
2211
2212module_pci_driver(echo_driver);