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