es1938.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  Driver for ESS Solo-1 (ES1938, ES1946, ES1969) soundcard
   4 *  Copyright (c) by Jaromir Koutek <miri@punknet.cz>,
   5 *                   Jaroslav Kysela <perex@perex.cz>,
   6 *                   Thomas Sailer <sailer@ife.ee.ethz.ch>,
   7 *                   Abramo Bagnara <abramo@alsa-project.org>,
   8 *                   Markus Gruber <gruber@eikon.tum.de>
   9 * 
  10 * Rewritten from sonicvibes.c source.
  11 *
  12 *  TODO:
  13 *    Rewrite better spinlocks
  14 */
  15
  16/*
  17  NOTES:
  18  - Capture data is written unaligned starting from dma_base + 1 so I need to
  19    disable mmap and to add a copy callback.
  20  - After several cycle of the following:
  21    while : ; do arecord -d1 -f cd -t raw | aplay -f cd ; done
  22    a "playback write error (DMA or IRQ trouble?)" may happen.
  23    This is due to playback interrupts not generated.
  24    I suspect a timing issue.
  25  - Sometimes the interrupt handler is invoked wrongly during playback.
  26    This generates some harmless "Unexpected hw_pointer: wrong interrupt
  27    acknowledge".
  28    I've seen that using small period sizes.
  29    Reproducible with:
  30    mpg123 test.mp3 &
  31    hdparm -t -T /dev/hda
  32*/
  33
  34
  35#include <linux/init.h>
  36#include <linux/interrupt.h>
  37#include <linux/pci.h>
  38#include <linux/slab.h>
  39#include <linux/gameport.h>
  40#include <linux/module.h>
  41#include <linux/delay.h>
  42#include <linux/dma-mapping.h>
  43#include <linux/io.h>
  44#include <sound/core.h>
  45#include <sound/control.h>
  46#include <sound/pcm.h>
  47#include <sound/opl3.h>
  48#include <sound/mpu401.h>
  49#include <sound/initval.h>
  50#include <sound/tlv.h>
  51
  52MODULE_AUTHOR("Jaromir Koutek <miri@punknet.cz>");
  53MODULE_DESCRIPTION("ESS Solo-1");
  54MODULE_LICENSE("GPL");
  55
  56#if IS_REACHABLE(CONFIG_GAMEPORT)
  57#define SUPPORT_JOYSTICK 1
  58#endif
  59
  60static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;	/* Index 0-MAX */
  61static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;	/* ID for this card */
  62static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;	/* Enable this card */
  63
  64module_param_array(index, int, NULL, 0444);
  65MODULE_PARM_DESC(index, "Index value for ESS Solo-1 soundcard.");
  66module_param_array(id, charp, NULL, 0444);
  67MODULE_PARM_DESC(id, "ID string for ESS Solo-1 soundcard.");
  68module_param_array(enable, bool, NULL, 0444);
  69MODULE_PARM_DESC(enable, "Enable ESS Solo-1 soundcard.");
  70
  71#define SLIO_REG(chip, x) ((chip)->io_port + ESSIO_REG_##x)
  72
  73#define SLDM_REG(chip, x) ((chip)->ddma_port + ESSDM_REG_##x)
  74
  75#define SLSB_REG(chip, x) ((chip)->sb_port + ESSSB_REG_##x)
  76
  77#define SL_PCI_LEGACYCONTROL		0x40
  78#define SL_PCI_CONFIG			0x50
  79#define SL_PCI_DDMACONTROL		0x60
  80
  81#define ESSIO_REG_AUDIO2DMAADDR		0
  82#define ESSIO_REG_AUDIO2DMACOUNT	4
  83#define ESSIO_REG_AUDIO2MODE		6
  84#define ESSIO_REG_IRQCONTROL		7
  85
  86#define ESSDM_REG_DMAADDR		0x00
  87#define ESSDM_REG_DMACOUNT		0x04
  88#define ESSDM_REG_DMACOMMAND		0x08
  89#define ESSDM_REG_DMASTATUS		0x08
  90#define ESSDM_REG_DMAMODE		0x0b
  91#define ESSDM_REG_DMACLEAR		0x0d
  92#define ESSDM_REG_DMAMASK		0x0f
  93
  94#define ESSSB_REG_FMLOWADDR		0x00
  95#define ESSSB_REG_FMHIGHADDR		0x02
  96#define ESSSB_REG_MIXERADDR		0x04
  97#define ESSSB_REG_MIXERDATA		0x05
  98
  99#define ESSSB_IREG_AUDIO1		0x14
 100#define ESSSB_IREG_MICMIX		0x1a
 101#define ESSSB_IREG_RECSRC		0x1c
 102#define ESSSB_IREG_MASTER		0x32
 103#define ESSSB_IREG_FM			0x36
 104#define ESSSB_IREG_AUXACD		0x38
 105#define ESSSB_IREG_AUXB			0x3a
 106#define ESSSB_IREG_PCSPEAKER		0x3c
 107#define ESSSB_IREG_LINE			0x3e
 108#define ESSSB_IREG_SPATCONTROL		0x50
 109#define ESSSB_IREG_SPATLEVEL		0x52
 110#define ESSSB_IREG_MASTER_LEFT		0x60
 111#define ESSSB_IREG_MASTER_RIGHT		0x62
 112#define ESSSB_IREG_MPU401CONTROL	0x64
 113#define ESSSB_IREG_MICMIXRECORD		0x68
 114#define ESSSB_IREG_AUDIO2RECORD		0x69
 115#define ESSSB_IREG_AUXACDRECORD		0x6a
 116#define ESSSB_IREG_FMRECORD		0x6b
 117#define ESSSB_IREG_AUXBRECORD		0x6c
 118#define ESSSB_IREG_MONO			0x6d
 119#define ESSSB_IREG_LINERECORD		0x6e
 120#define ESSSB_IREG_MONORECORD		0x6f
 121#define ESSSB_IREG_AUDIO2SAMPLE		0x70
 122#define ESSSB_IREG_AUDIO2MODE		0x71
 123#define ESSSB_IREG_AUDIO2FILTER		0x72
 124#define ESSSB_IREG_AUDIO2TCOUNTL	0x74
 125#define ESSSB_IREG_AUDIO2TCOUNTH	0x76
 126#define ESSSB_IREG_AUDIO2CONTROL1	0x78
 127#define ESSSB_IREG_AUDIO2CONTROL2	0x7a
 128#define ESSSB_IREG_AUDIO2		0x7c
 129
 130#define ESSSB_REG_RESET			0x06
 131
 132#define ESSSB_REG_READDATA		0x0a
 133#define ESSSB_REG_WRITEDATA		0x0c
 134#define ESSSB_REG_READSTATUS		0x0c
 135
 136#define ESSSB_REG_STATUS		0x0e
 137
 138#define ESS_CMD_EXTSAMPLERATE		0xa1
 139#define ESS_CMD_FILTERDIV		0xa2
 140#define ESS_CMD_DMACNTRELOADL		0xa4
 141#define ESS_CMD_DMACNTRELOADH		0xa5
 142#define ESS_CMD_ANALOGCONTROL		0xa8
 143#define ESS_CMD_IRQCONTROL		0xb1
 144#define ESS_CMD_DRQCONTROL		0xb2
 145#define ESS_CMD_RECLEVEL		0xb4
 146#define ESS_CMD_SETFORMAT		0xb6
 147#define ESS_CMD_SETFORMAT2		0xb7
 148#define ESS_CMD_DMACONTROL		0xb8
 149#define ESS_CMD_DMATYPE			0xb9
 150#define ESS_CMD_OFFSETLEFT		0xba	
 151#define ESS_CMD_OFFSETRIGHT		0xbb
 152#define ESS_CMD_READREG			0xc0
 153#define ESS_CMD_ENABLEEXT		0xc6
 154#define ESS_CMD_PAUSEDMA		0xd0
 155#define ESS_CMD_ENABLEAUDIO1		0xd1
 156#define ESS_CMD_STOPAUDIO1		0xd3
 157#define ESS_CMD_AUDIO1STATUS		0xd8
 158#define ESS_CMD_CONTDMA			0xd4
 159#define ESS_CMD_TESTIRQ			0xf2
 160
 161#define ESS_RECSRC_MIC		0
 162#define ESS_RECSRC_AUXACD	2
 163#define ESS_RECSRC_AUXB		5
 164#define ESS_RECSRC_LINE		6
 165#define ESS_RECSRC_NONE		7
 166
 167#define DAC1 0x01
 168#define ADC1 0x02
 169#define DAC2 0x04
 170
 171/*
 172
 173 */
 174
 175#define SAVED_REG_SIZE	32 /* max. number of registers to save */
 176
 177struct es1938 {
 178	int irq;
 179
 180	unsigned long io_port;
 181	unsigned long sb_port;
 182	unsigned long vc_port;
 183	unsigned long mpu_port;
 184	unsigned long game_port;
 185	unsigned long ddma_port;
 186
 187	unsigned char irqmask;
 188	unsigned char revision;
 189
 190	struct snd_kcontrol *hw_volume;
 191	struct snd_kcontrol *hw_switch;
 192	struct snd_kcontrol *master_volume;
 193	struct snd_kcontrol *master_switch;
 194
 195	struct pci_dev *pci;
 196	struct snd_card *card;
 197	struct snd_pcm *pcm;
 198	struct snd_pcm_substream *capture_substream;
 199	struct snd_pcm_substream *playback1_substream;
 200	struct snd_pcm_substream *playback2_substream;
 201	struct snd_rawmidi *rmidi;
 202
 203	unsigned int dma1_size;
 204	unsigned int dma2_size;
 205	unsigned int dma1_start;
 206	unsigned int dma2_start;
 207	unsigned int dma1_shift;
 208	unsigned int dma2_shift;
 209	unsigned int last_capture_dmaaddr;
 210	unsigned int active;
 211
 212	spinlock_t reg_lock;
 213	spinlock_t mixer_lock;
 214        struct snd_info_entry *proc_entry;
 215
 216#ifdef SUPPORT_JOYSTICK
 217	struct gameport *gameport;
 218#endif
 219	unsigned char saved_regs[SAVED_REG_SIZE];
 220};
 221
 222static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id);
 223
 224static const struct pci_device_id snd_es1938_ids[] = {
 225	{ PCI_VDEVICE(ESS, 0x1969), 0, },   /* Solo-1 */
 226	{ 0, }
 227};
 228
 229MODULE_DEVICE_TABLE(pci, snd_es1938_ids);
 230
 231#define RESET_LOOP_TIMEOUT	0x10000
 232#define WRITE_LOOP_TIMEOUT	0x10000
 233#define GET_LOOP_TIMEOUT	0x01000
 234
 235/* -----------------------------------------------------------------
 236 * Write to a mixer register
 237 * -----------------------------------------------------------------*/
 238static void snd_es1938_mixer_write(struct es1938 *chip, unsigned char reg, unsigned char val)
 239{
 240	guard(spinlock_irqsave)(&chip->mixer_lock);
 241	outb(reg, SLSB_REG(chip, MIXERADDR));
 242	outb(val, SLSB_REG(chip, MIXERDATA));
 243	dev_dbg(chip->card->dev, "Mixer reg %02x set to %02x\n", reg, val);
 244}
 245
 246/* -----------------------------------------------------------------
 247 * Read from a mixer register
 248 * -----------------------------------------------------------------*/
 249static int snd_es1938_mixer_read(struct es1938 *chip, unsigned char reg)
 250{
 251	int data;
 252
 253	guard(spinlock_irqsave)(&chip->mixer_lock);
 254	outb(reg, SLSB_REG(chip, MIXERADDR));
 255	data = inb(SLSB_REG(chip, MIXERDATA));
 256	dev_dbg(chip->card->dev, "Mixer reg %02x now is %02x\n", reg, data);
 257	return data;
 258}
 259
 260/* -----------------------------------------------------------------
 261 * Write to some bits of a mixer register (return old value)
 262 * -----------------------------------------------------------------*/
 263static int snd_es1938_mixer_bits(struct es1938 *chip, unsigned char reg,
 264				 unsigned char mask, unsigned char val)
 265{
 266	unsigned char old, new, oval;
 267
 268	guard(spinlock_irqsave)(&chip->mixer_lock);
 269	outb(reg, SLSB_REG(chip, MIXERADDR));
 270	old = inb(SLSB_REG(chip, MIXERDATA));
 271	oval = old & mask;
 272	if (val != oval) {
 273		new = (old & ~mask) | (val & mask);
 274		outb(new, SLSB_REG(chip, MIXERDATA));
 275		dev_dbg(chip->card->dev,
 276			"Mixer reg %02x was %02x, set to %02x\n",
 277			   reg, old, new);
 278	}
 279	return oval;
 280}
 281
 282/* -----------------------------------------------------------------
 283 * Write command to Controller Registers
 284 * -----------------------------------------------------------------*/
 285static void snd_es1938_write_cmd(struct es1938 *chip, unsigned char cmd)
 286{
 287	int i;
 288	unsigned char v;
 289	for (i = 0; i < WRITE_LOOP_TIMEOUT; i++) {
 290		v = inb(SLSB_REG(chip, READSTATUS));
 291		if (!(v & 0x80)) {
 292			outb(cmd, SLSB_REG(chip, WRITEDATA));
 293			return;
 294		}
 295	}
 296	dev_err(chip->card->dev,
 297		"snd_es1938_write_cmd timeout (0x02%x/0x02%x)\n", cmd, v);
 298}
 299
 300/* -----------------------------------------------------------------
 301 * Read the Read Data Buffer
 302 * -----------------------------------------------------------------*/
 303static int snd_es1938_get_byte(struct es1938 *chip)
 304{
 305	int i;
 306	unsigned char v;
 307	for (i = GET_LOOP_TIMEOUT; i; i--) {
 308		v = inb(SLSB_REG(chip, STATUS));
 309		if (v & 0x80)
 310			return inb(SLSB_REG(chip, READDATA));
 311	}
 312	dev_err(chip->card->dev, "get_byte timeout: status 0x02%x\n", v);
 313	return -ENODEV;
 314}
 315
 316/* -----------------------------------------------------------------
 317 * Write value cmd register
 318 * -----------------------------------------------------------------*/
 319static void snd_es1938_write(struct es1938 *chip, unsigned char reg, unsigned char val)
 320{
 321	guard(spinlock_irqsave)(&chip->reg_lock);
 322	snd_es1938_write_cmd(chip, reg);
 323	snd_es1938_write_cmd(chip, val);
 324	dev_dbg(chip->card->dev, "Reg %02x set to %02x\n", reg, val);
 325}
 326
 327/* -----------------------------------------------------------------
 328 * Read data from cmd register and return it
 329 * -----------------------------------------------------------------*/
 330static unsigned char snd_es1938_read(struct es1938 *chip, unsigned char reg)
 331{
 332	unsigned char val;
 333
 334	guard(spinlock_irqsave)(&chip->reg_lock);
 335	snd_es1938_write_cmd(chip, ESS_CMD_READREG);
 336	snd_es1938_write_cmd(chip, reg);
 337	val = snd_es1938_get_byte(chip);
 338	dev_dbg(chip->card->dev, "Reg %02x now is %02x\n", reg, val);
 339	return val;
 340}
 341
 342/* -----------------------------------------------------------------
 343 * Write data to cmd register and return old value
 344 * -----------------------------------------------------------------*/
 345static int snd_es1938_bits(struct es1938 *chip, unsigned char reg, unsigned char mask,
 346			   unsigned char val)
 347{
 348	unsigned char old, new, oval;
 349
 350	guard(spinlock_irqsave)(&chip->reg_lock);
 351	snd_es1938_write_cmd(chip, ESS_CMD_READREG);
 352	snd_es1938_write_cmd(chip, reg);
 353	old = snd_es1938_get_byte(chip);
 354	oval = old & mask;
 355	if (val != oval) {
 356		snd_es1938_write_cmd(chip, reg);
 357		new = (old & ~mask) | (val & mask);
 358		snd_es1938_write_cmd(chip, new);
 359		dev_dbg(chip->card->dev, "Reg %02x was %02x, set to %02x\n",
 360			   reg, old, new);
 361	}
 362	return oval;
 363}
 364
 365/* --------------------------------------------------------------------
 366 * Reset the chip
 367 * --------------------------------------------------------------------*/
 368static void snd_es1938_reset(struct es1938 *chip)
 369{
 370	int i;
 371
 372	outb(3, SLSB_REG(chip, RESET));
 373	inb(SLSB_REG(chip, RESET));
 374	outb(0, SLSB_REG(chip, RESET));
 375	for (i = 0; i < RESET_LOOP_TIMEOUT; i++) {
 376		if (inb(SLSB_REG(chip, STATUS)) & 0x80) {
 377			if (inb(SLSB_REG(chip, READDATA)) == 0xaa)
 378				goto __next;
 379		}
 380	}
 381	dev_err(chip->card->dev, "ESS Solo-1 reset failed\n");
 382
 383     __next:
 384	snd_es1938_write_cmd(chip, ESS_CMD_ENABLEEXT);
 385
 386	/* Demand transfer DMA: 4 bytes per DMA request */
 387	snd_es1938_write(chip, ESS_CMD_DMATYPE, 2);
 388
 389	/* Change behaviour of register A1
 390	   4x oversampling
 391	   2nd channel DAC asynchronous */                                                      
 392	snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2MODE, 0x32);
 393	/* enable/select DMA channel and IRQ channel */
 394	snd_es1938_bits(chip, ESS_CMD_IRQCONTROL, 0xf0, 0x50);
 395	snd_es1938_bits(chip, ESS_CMD_DRQCONTROL, 0xf0, 0x50);
 396	snd_es1938_write_cmd(chip, ESS_CMD_ENABLEAUDIO1);
 397	/* Set spatializer parameters to recommended values */
 398	snd_es1938_mixer_write(chip, 0x54, 0x8f);
 399	snd_es1938_mixer_write(chip, 0x56, 0x95);
 400	snd_es1938_mixer_write(chip, 0x58, 0x94);
 401	snd_es1938_mixer_write(chip, 0x5a, 0x80);
 402}
 403
 404/* --------------------------------------------------------------------
 405 * Reset the FIFOs
 406 * --------------------------------------------------------------------*/
 407static void snd_es1938_reset_fifo(struct es1938 *chip)
 408{
 409	outb(2, SLSB_REG(chip, RESET));
 410	outb(0, SLSB_REG(chip, RESET));
 411}
 412
 413static const struct snd_ratnum clocks[2] = {
 414	{
 415		.num = 793800,
 416		.den_min = 1,
 417		.den_max = 128,
 418		.den_step = 1,
 419	},
 420	{
 421		.num = 768000,
 422		.den_min = 1,
 423		.den_max = 128,
 424		.den_step = 1,
 425	}
 426};
 427
 428static const struct snd_pcm_hw_constraint_ratnums hw_constraints_clocks = {
 429	.nrats = 2,
 430	.rats = clocks,
 431};
 432
 433
 434static void snd_es1938_rate_set(struct es1938 *chip, 
 435				struct snd_pcm_substream *substream,
 436				int mode)
 437{
 438	unsigned int bits, div0;
 439	struct snd_pcm_runtime *runtime = substream->runtime;
 440	if (runtime->rate_num == clocks[0].num)
 441		bits = 128 - runtime->rate_den;
 442	else
 443		bits = 256 - runtime->rate_den;
 444
 445	/* set filter register */
 446	div0 = 256 - 7160000*20/(8*82*runtime->rate);
 447		
 448	if (mode == DAC2) {
 449		snd_es1938_mixer_write(chip, 0x70, bits);
 450		snd_es1938_mixer_write(chip, 0x72, div0);
 451	} else {
 452		snd_es1938_write(chip, 0xA1, bits);
 453		snd_es1938_write(chip, 0xA2, div0);
 454	}
 455}
 456
 457/* --------------------------------------------------------------------
 458 * Configure Solo1 builtin DMA Controller
 459 * --------------------------------------------------------------------*/
 460
 461static void snd_es1938_playback1_setdma(struct es1938 *chip)
 462{
 463	outb(0x00, SLIO_REG(chip, AUDIO2MODE));
 464	outl(chip->dma2_start, SLIO_REG(chip, AUDIO2DMAADDR));
 465	outw(0, SLIO_REG(chip, AUDIO2DMACOUNT));
 466	outw(chip->dma2_size, SLIO_REG(chip, AUDIO2DMACOUNT));
 467}
 468
 469static void snd_es1938_playback2_setdma(struct es1938 *chip)
 470{
 471	/* Enable DMA controller */
 472	outb(0xc4, SLDM_REG(chip, DMACOMMAND));
 473	/* 1. Master reset */
 474	outb(0, SLDM_REG(chip, DMACLEAR));
 475	/* 2. Mask DMA */
 476	outb(1, SLDM_REG(chip, DMAMASK));
 477	outb(0x18, SLDM_REG(chip, DMAMODE));
 478	outl(chip->dma1_start, SLDM_REG(chip, DMAADDR));
 479	outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT));
 480	/* 3. Unmask DMA */
 481	outb(0, SLDM_REG(chip, DMAMASK));
 482}
 483
 484static void snd_es1938_capture_setdma(struct es1938 *chip)
 485{
 486	/* Enable DMA controller */
 487	outb(0xc4, SLDM_REG(chip, DMACOMMAND));
 488	/* 1. Master reset */
 489	outb(0, SLDM_REG(chip, DMACLEAR));
 490	/* 2. Mask DMA */
 491	outb(1, SLDM_REG(chip, DMAMASK));
 492	outb(0x14, SLDM_REG(chip, DMAMODE));
 493	outl(chip->dma1_start, SLDM_REG(chip, DMAADDR));
 494	chip->last_capture_dmaaddr = chip->dma1_start;
 495	outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT));
 496	/* 3. Unmask DMA */
 497	outb(0, SLDM_REG(chip, DMAMASK));
 498}
 499
 500/* ----------------------------------------------------------------------
 501 *
 502 *                           *** PCM part ***
 503 */
 504
 505static int snd_es1938_capture_trigger(struct snd_pcm_substream *substream,
 506				      int cmd)
 507{
 508	struct es1938 *chip = snd_pcm_substream_chip(substream);
 509	int val;
 510	switch (cmd) {
 511	case SNDRV_PCM_TRIGGER_START:
 512	case SNDRV_PCM_TRIGGER_RESUME:
 513		val = 0x0f;
 514		chip->active |= ADC1;
 515		break;
 516	case SNDRV_PCM_TRIGGER_STOP:
 517	case SNDRV_PCM_TRIGGER_SUSPEND:
 518		val = 0x00;
 519		chip->active &= ~ADC1;
 520		break;
 521	default:
 522		return -EINVAL;
 523	}
 524	snd_es1938_write(chip, ESS_CMD_DMACONTROL, val);
 525	return 0;
 526}
 527
 528static int snd_es1938_playback1_trigger(struct snd_pcm_substream *substream,
 529					int cmd)
 530{
 531	struct es1938 *chip = snd_pcm_substream_chip(substream);
 532	switch (cmd) {
 533	case SNDRV_PCM_TRIGGER_START:
 534	case SNDRV_PCM_TRIGGER_RESUME:
 535		/* According to the documentation this should be:
 536		   0x13 but that value may randomly swap stereo channels */
 537                snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0x92);
 538                udelay(10);
 539		snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0x93);
 540                /* This two stage init gives the FIFO -> DAC connection time to
 541                 * settle before first data from DMA flows in.  This should ensure
 542                 * no swapping of stereo channels.  Report a bug if otherwise :-) */
 543		outb(0x0a, SLIO_REG(chip, AUDIO2MODE));
 544		chip->active |= DAC2;
 545		break;
 546	case SNDRV_PCM_TRIGGER_STOP:
 547	case SNDRV_PCM_TRIGGER_SUSPEND:
 548		outb(0, SLIO_REG(chip, AUDIO2MODE));
 549		snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0);
 550		chip->active &= ~DAC2;
 551		break;
 552	default:
 553		return -EINVAL;
 554	}
 555	return 0;
 556}
 557
 558static int snd_es1938_playback2_trigger(struct snd_pcm_substream *substream,
 559					int cmd)
 560{
 561	struct es1938 *chip = snd_pcm_substream_chip(substream);
 562	int val;
 563	switch (cmd) {
 564	case SNDRV_PCM_TRIGGER_START:
 565	case SNDRV_PCM_TRIGGER_RESUME:
 566		val = 5;
 567		chip->active |= DAC1;
 568		break;
 569	case SNDRV_PCM_TRIGGER_STOP:
 570	case SNDRV_PCM_TRIGGER_SUSPEND:
 571		val = 0;
 572		chip->active &= ~DAC1;
 573		break;
 574	default:
 575		return -EINVAL;
 576	}
 577	snd_es1938_write(chip, ESS_CMD_DMACONTROL, val);
 578	return 0;
 579}
 580
 581static int snd_es1938_playback_trigger(struct snd_pcm_substream *substream,
 582				       int cmd)
 583{
 584	switch (substream->number) {
 585	case 0:
 586		return snd_es1938_playback1_trigger(substream, cmd);
 587	case 1:
 588		return snd_es1938_playback2_trigger(substream, cmd);
 589	}
 590	snd_BUG();
 591	return -EINVAL;
 592}
 593
 594/* --------------------------------------------------------------------
 595 * First channel for Extended Mode Audio 1 ADC Operation
 596 * --------------------------------------------------------------------*/
 597static int snd_es1938_capture_prepare(struct snd_pcm_substream *substream)
 598{
 599	struct es1938 *chip = snd_pcm_substream_chip(substream);
 600	struct snd_pcm_runtime *runtime = substream->runtime;
 601	int u, is8, mono;
 602	unsigned int size = snd_pcm_lib_buffer_bytes(substream);
 603	unsigned int count = snd_pcm_lib_period_bytes(substream);
 604
 605	chip->dma1_size = size;
 606	chip->dma1_start = runtime->dma_addr;
 607
 608	mono = (runtime->channels > 1) ? 0 : 1;
 609	is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
 610	u = snd_pcm_format_unsigned(runtime->format);
 611
 612	chip->dma1_shift = 2 - mono - is8;
 613
 614	snd_es1938_reset_fifo(chip);
 615	
 616	/* program type */
 617	snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1));
 618
 619	/* set clock and counters */
 620        snd_es1938_rate_set(chip, substream, ADC1);
 621
 622	count = 0x10000 - count;
 623	snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff);
 624	snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8);
 625
 626	/* initialize and configure ADC */
 627	snd_es1938_write(chip, ESS_CMD_SETFORMAT2, u ? 0x51 : 0x71);
 628	snd_es1938_write(chip, ESS_CMD_SETFORMAT2, 0x90 | 
 629		       (u ? 0x00 : 0x20) | 
 630		       (is8 ? 0x00 : 0x04) | 
 631		       (mono ? 0x40 : 0x08));
 632
 633	//	snd_es1938_reset_fifo(chip);	
 634
 635	/* 11. configure system interrupt controller and DMA controller */
 636	snd_es1938_capture_setdma(chip);
 637
 638	return 0;
 639}
 640
 641
 642/* ------------------------------------------------------------------------------
 643 * Second Audio channel DAC Operation
 644 * ------------------------------------------------------------------------------*/
 645static int snd_es1938_playback1_prepare(struct snd_pcm_substream *substream)
 646{
 647	struct es1938 *chip = snd_pcm_substream_chip(substream);
 648	struct snd_pcm_runtime *runtime = substream->runtime;
 649	int u, is8, mono;
 650	unsigned int size = snd_pcm_lib_buffer_bytes(substream);
 651	unsigned int count = snd_pcm_lib_period_bytes(substream);
 652
 653	chip->dma2_size = size;
 654	chip->dma2_start = runtime->dma_addr;
 655
 656	mono = (runtime->channels > 1) ? 0 : 1;
 657	is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
 658	u = snd_pcm_format_unsigned(runtime->format);
 659
 660	chip->dma2_shift = 2 - mono - is8;
 661
 662        snd_es1938_reset_fifo(chip);
 663
 664	/* set clock and counters */
 665        snd_es1938_rate_set(chip, substream, DAC2);
 666
 667	count >>= 1;
 668	count = 0x10000 - count;
 669	snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTL, count & 0xff);
 670	snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTH, count >> 8);
 671
 672	/* initialize and configure Audio 2 DAC */
 673	snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x40 | (u ? 0 : 4) |
 674			       (mono ? 0 : 2) | (is8 ? 0 : 1));
 675
 676	/* program DMA */
 677	snd_es1938_playback1_setdma(chip);
 678	
 679	return 0;
 680}
 681
 682static int snd_es1938_playback2_prepare(struct snd_pcm_substream *substream)
 683{
 684	struct es1938 *chip = snd_pcm_substream_chip(substream);
 685	struct snd_pcm_runtime *runtime = substream->runtime;
 686	int u, is8, mono;
 687	unsigned int size = snd_pcm_lib_buffer_bytes(substream);
 688	unsigned int count = snd_pcm_lib_period_bytes(substream);
 689
 690	chip->dma1_size = size;
 691	chip->dma1_start = runtime->dma_addr;
 692
 693	mono = (runtime->channels > 1) ? 0 : 1;
 694	is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
 695	u = snd_pcm_format_unsigned(runtime->format);
 696
 697	chip->dma1_shift = 2 - mono - is8;
 698
 699	count = 0x10000 - count;
 700 
 701	/* reset */
 702	snd_es1938_reset_fifo(chip);
 703	
 704	snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1));
 705
 706	/* set clock and counters */
 707        snd_es1938_rate_set(chip, substream, DAC1);
 708	snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff);
 709	snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8);
 710
 711	/* initialized and configure DAC */
 712        snd_es1938_write(chip, ESS_CMD_SETFORMAT, u ? 0x80 : 0x00);
 713        snd_es1938_write(chip, ESS_CMD_SETFORMAT, u ? 0x51 : 0x71);
 714        snd_es1938_write(chip, ESS_CMD_SETFORMAT2, 
 715			 0x90 | (mono ? 0x40 : 0x08) |
 716			 (is8 ? 0x00 : 0x04) | (u ? 0x00 : 0x20));
 717
 718	/* program DMA */
 719	snd_es1938_playback2_setdma(chip);
 720	
 721	return 0;
 722}
 723
 724static int snd_es1938_playback_prepare(struct snd_pcm_substream *substream)
 725{
 726	switch (substream->number) {
 727	case 0:
 728		return snd_es1938_playback1_prepare(substream);
 729	case 1:
 730		return snd_es1938_playback2_prepare(substream);
 731	}
 732	snd_BUG();
 733	return -EINVAL;
 734}
 735
 736/* during the incrementing of dma counters the DMA register reads sometimes
 737   returns garbage. To ensure a valid hw pointer, the following checks which
 738   should be very unlikely to fail are used:
 739   - is the current DMA address in the valid DMA range ?
 740   - is the sum of DMA address and DMA counter pointing to the last DMA byte ?
 741   One can argue this could differ by one byte depending on which register is
 742   updated first, so the implementation below allows for that.
 743*/
 744static snd_pcm_uframes_t snd_es1938_capture_pointer(struct snd_pcm_substream *substream)
 745{
 746	struct es1938 *chip = snd_pcm_substream_chip(substream);
 747	size_t ptr;
 748#if 0
 749	size_t old, new;
 750	/* This stuff is *needed*, don't ask why - AB */
 751	old = inw(SLDM_REG(chip, DMACOUNT));
 752	while ((new = inw(SLDM_REG(chip, DMACOUNT))) != old)
 753		old = new;
 754	ptr = chip->dma1_size - 1 - new;
 755#else
 756	size_t count;
 757	unsigned int diff;
 758
 759	ptr = inl(SLDM_REG(chip, DMAADDR));
 760	count = inw(SLDM_REG(chip, DMACOUNT));
 761	diff = chip->dma1_start + chip->dma1_size - ptr - count;
 762
 763	if (diff > 3 || ptr < chip->dma1_start
 764	      || ptr >= chip->dma1_start+chip->dma1_size)
 765	  ptr = chip->last_capture_dmaaddr;            /* bad, use last saved */
 766	else
 767	  chip->last_capture_dmaaddr = ptr;            /* good, remember it */
 768
 769	ptr -= chip->dma1_start;
 770#endif
 771	return ptr >> chip->dma1_shift;
 772}
 773
 774static snd_pcm_uframes_t snd_es1938_playback1_pointer(struct snd_pcm_substream *substream)
 775{
 776	struct es1938 *chip = snd_pcm_substream_chip(substream);
 777	size_t ptr;
 778#if 1
 779	ptr = chip->dma2_size - inw(SLIO_REG(chip, AUDIO2DMACOUNT));
 780#else
 781	ptr = inl(SLIO_REG(chip, AUDIO2DMAADDR)) - chip->dma2_start;
 782#endif
 783	return ptr >> chip->dma2_shift;
 784}
 785
 786static snd_pcm_uframes_t snd_es1938_playback2_pointer(struct snd_pcm_substream *substream)
 787{
 788	struct es1938 *chip = snd_pcm_substream_chip(substream);
 789	size_t ptr;
 790	size_t old, new;
 791#if 1
 792	/* This stuff is *needed*, don't ask why - AB */
 793	old = inw(SLDM_REG(chip, DMACOUNT));
 794	while ((new = inw(SLDM_REG(chip, DMACOUNT))) != old)
 795		old = new;
 796	ptr = chip->dma1_size - 1 - new;
 797#else
 798	ptr = inl(SLDM_REG(chip, DMAADDR)) - chip->dma1_start;
 799#endif
 800	return ptr >> chip->dma1_shift;
 801}
 802
 803static snd_pcm_uframes_t snd_es1938_playback_pointer(struct snd_pcm_substream *substream)
 804{
 805	switch (substream->number) {
 806	case 0:
 807		return snd_es1938_playback1_pointer(substream);
 808	case 1:
 809		return snd_es1938_playback2_pointer(substream);
 810	}
 811	snd_BUG();
 812	return -EINVAL;
 813}
 814
 815static int snd_es1938_capture_copy(struct snd_pcm_substream *substream,
 816				   int channel, unsigned long pos,
 817				   struct iov_iter *dst, unsigned long count)
 818{
 819	struct snd_pcm_runtime *runtime = substream->runtime;
 820	struct es1938 *chip = snd_pcm_substream_chip(substream);
 821
 822	if (snd_BUG_ON(pos + count > chip->dma1_size))
 823		return -EINVAL;
 824	if (pos + count < chip->dma1_size) {
 825		if (copy_to_iter(runtime->dma_area + pos + 1, count, dst) != count)
 826			return -EFAULT;
 827	} else {
 828		if (copy_to_iter(runtime->dma_area + pos + 1, count - 1, dst) != count - 1)
 829			return -EFAULT;
 830		if (copy_to_iter(runtime->dma_area, 1, dst) != 1)
 831			return -EFAULT;
 832	}
 833	return 0;
 834}
 835
 836/* ----------------------------------------------------------------------
 837 * Audio1 Capture (ADC)
 838 * ----------------------------------------------------------------------*/
 839static const struct snd_pcm_hardware snd_es1938_capture =
 840{
 841	.info =			(SNDRV_PCM_INFO_INTERLEAVED |
 842				SNDRV_PCM_INFO_BLOCK_TRANSFER),
 843	.formats =		(SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
 844				 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
 845	.rates =		SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
 846	.rate_min =		6000,
 847	.rate_max =		48000,
 848	.channels_min =		1,
 849	.channels_max =		2,
 850        .buffer_bytes_max =	0x8000,       /* DMA controller screws on higher values */
 851	.period_bytes_min =	64,
 852	.period_bytes_max =	0x8000,
 853	.periods_min =		1,
 854	.periods_max =		1024,
 855	.fifo_size =		256,
 856};
 857
 858/* -----------------------------------------------------------------------
 859 * Audio2 Playback (DAC)
 860 * -----------------------------------------------------------------------*/
 861static const struct snd_pcm_hardware snd_es1938_playback =
 862{
 863	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
 864				 SNDRV_PCM_INFO_BLOCK_TRANSFER |
 865				 SNDRV_PCM_INFO_MMAP_VALID),
 866	.formats =		(SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
 867				 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
 868	.rates =		SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
 869	.rate_min =		6000,
 870	.rate_max =		48000,
 871	.channels_min =		1,
 872	.channels_max =		2,
 873        .buffer_bytes_max =	0x8000,       /* DMA controller screws on higher values */
 874	.period_bytes_min =	64,
 875	.period_bytes_max =	0x8000,
 876	.periods_min =		1,
 877	.periods_max =		1024,
 878	.fifo_size =		256,
 879};
 880
 881static int snd_es1938_capture_open(struct snd_pcm_substream *substream)
 882{
 883	struct es1938 *chip = snd_pcm_substream_chip(substream);
 884	struct snd_pcm_runtime *runtime = substream->runtime;
 885
 886	if (chip->playback2_substream)
 887		return -EAGAIN;
 888	chip->capture_substream = substream;
 889	runtime->hw = snd_es1938_capture;
 890	snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 891				      &hw_constraints_clocks);
 892	snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
 893	return 0;
 894}
 895
 896static int snd_es1938_playback_open(struct snd_pcm_substream *substream)
 897{
 898	struct es1938 *chip = snd_pcm_substream_chip(substream);
 899	struct snd_pcm_runtime *runtime = substream->runtime;
 900
 901	switch (substream->number) {
 902	case 0:
 903		chip->playback1_substream = substream;
 904		break;
 905	case 1:
 906		if (chip->capture_substream)
 907			return -EAGAIN;
 908		chip->playback2_substream = substream;
 909		break;
 910	default:
 911		snd_BUG();
 912		return -EINVAL;
 913	}
 914	runtime->hw = snd_es1938_playback;
 915	snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 916				      &hw_constraints_clocks);
 917	snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
 918	return 0;
 919}
 920
 921static int snd_es1938_capture_close(struct snd_pcm_substream *substream)
 922{
 923	struct es1938 *chip = snd_pcm_substream_chip(substream);
 924
 925	chip->capture_substream = NULL;
 926	return 0;
 927}
 928
 929static int snd_es1938_playback_close(struct snd_pcm_substream *substream)
 930{
 931	struct es1938 *chip = snd_pcm_substream_chip(substream);
 932
 933	switch (substream->number) {
 934	case 0:
 935		chip->playback1_substream = NULL;
 936		break;
 937	case 1:
 938		chip->playback2_substream = NULL;
 939		break;
 940	default:
 941		snd_BUG();
 942		return -EINVAL;
 943	}
 944	return 0;
 945}
 946
 947static const struct snd_pcm_ops snd_es1938_playback_ops = {
 948	.open =		snd_es1938_playback_open,
 949	.close =	snd_es1938_playback_close,
 950	.prepare =	snd_es1938_playback_prepare,
 951	.trigger =	snd_es1938_playback_trigger,
 952	.pointer =	snd_es1938_playback_pointer,
 953};
 954
 955static const struct snd_pcm_ops snd_es1938_capture_ops = {
 956	.open =		snd_es1938_capture_open,
 957	.close =	snd_es1938_capture_close,
 958	.prepare =	snd_es1938_capture_prepare,
 959	.trigger =	snd_es1938_capture_trigger,
 960	.pointer =	snd_es1938_capture_pointer,
 961	.copy =		snd_es1938_capture_copy,
 962};
 963
 964static int snd_es1938_new_pcm(struct es1938 *chip, int device)
 965{
 966	struct snd_pcm *pcm;
 967	int err;
 968
 969	err = snd_pcm_new(chip->card, "es-1938-1946", device, 2, 1, &pcm);
 970	if (err < 0)
 971		return err;
 972	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_es1938_playback_ops);
 973	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1938_capture_ops);
 974	
 975	pcm->private_data = chip;
 976	pcm->info_flags = 0;
 977	strscpy(pcm->name, "ESS Solo-1");
 978
 979	snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
 980				       &chip->pci->dev, 64*1024, 64*1024);
 981
 982	chip->pcm = pcm;
 983	return 0;
 984}
 985
 986/* -------------------------------------------------------------------
 987 * 
 988 *                       *** Mixer part ***
 989 */
 990
 991static int snd_es1938_info_mux(struct snd_kcontrol *kcontrol,
 992			       struct snd_ctl_elem_info *uinfo)
 993{
 994	static const char * const texts[8] = {
 995		"Mic", "Mic Master", "CD", "AOUT",
 996		"Mic1", "Mix", "Line", "Master"
 997	};
 998
 999	return snd_ctl_enum_info(uinfo, 1, 8, texts);
1000}
1001
1002static int snd_es1938_get_mux(struct snd_kcontrol *kcontrol,
1003			      struct snd_ctl_elem_value *ucontrol)
1004{
1005	struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1006	ucontrol->value.enumerated.item[0] = snd_es1938_mixer_read(chip, 0x1c) & 0x07;
1007	return 0;
1008}
1009
1010static int snd_es1938_put_mux(struct snd_kcontrol *kcontrol,
1011			      struct snd_ctl_elem_value *ucontrol)
1012{
1013	struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1014	unsigned char val = ucontrol->value.enumerated.item[0];
1015	
1016	if (val > 7)
1017		return -EINVAL;
1018	return snd_es1938_mixer_bits(chip, 0x1c, 0x07, val) != val;
1019}
1020
1021#define snd_es1938_info_spatializer_enable	snd_ctl_boolean_mono_info
1022
1023static int snd_es1938_get_spatializer_enable(struct snd_kcontrol *kcontrol,
1024					     struct snd_ctl_elem_value *ucontrol)
1025{
1026	struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1027	unsigned char val = snd_es1938_mixer_read(chip, 0x50);
1028	ucontrol->value.integer.value[0] = !!(val & 8);
1029	return 0;
1030}
1031
1032static int snd_es1938_put_spatializer_enable(struct snd_kcontrol *kcontrol,
1033					     struct snd_ctl_elem_value *ucontrol)
1034{
1035	struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1036	unsigned char oval, nval;
1037	int change;
1038	nval = ucontrol->value.integer.value[0] ? 0x0c : 0x04;
1039	oval = snd_es1938_mixer_read(chip, 0x50) & 0x0c;
1040	change = nval != oval;
1041	if (change) {
1042		snd_es1938_mixer_write(chip, 0x50, nval & ~0x04);
1043		snd_es1938_mixer_write(chip, 0x50, nval);
1044	}
1045	return change;
1046}
1047
1048static int snd_es1938_info_hw_volume(struct snd_kcontrol *kcontrol,
1049				     struct snd_ctl_elem_info *uinfo)
1050{
1051	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1052	uinfo->count = 2;
1053	uinfo->value.integer.min = 0;
1054	uinfo->value.integer.max = 63;
1055	return 0;
1056}
1057
1058static int snd_es1938_get_hw_volume(struct snd_kcontrol *kcontrol,
1059				    struct snd_ctl_elem_value *ucontrol)
1060{
1061	struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1062	ucontrol->value.integer.value[0] = snd_es1938_mixer_read(chip, 0x61) & 0x3f;
1063	ucontrol->value.integer.value[1] = snd_es1938_mixer_read(chip, 0x63) & 0x3f;
1064	return 0;
1065}
1066
1067#define snd_es1938_info_hw_switch		snd_ctl_boolean_stereo_info
1068
1069static int snd_es1938_get_hw_switch(struct snd_kcontrol *kcontrol,
1070				    struct snd_ctl_elem_value *ucontrol)
1071{
1072	struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1073	ucontrol->value.integer.value[0] = !(snd_es1938_mixer_read(chip, 0x61) & 0x40);
1074	ucontrol->value.integer.value[1] = !(snd_es1938_mixer_read(chip, 0x63) & 0x40);
1075	return 0;
1076}
1077
1078static void snd_es1938_hwv_free(struct snd_kcontrol *kcontrol)
1079{
1080	struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1081	chip->master_volume = NULL;
1082	chip->master_switch = NULL;
1083	chip->hw_volume = NULL;
1084	chip->hw_switch = NULL;
1085}
1086
1087static int snd_es1938_reg_bits(struct es1938 *chip, unsigned char reg,
1088			       unsigned char mask, unsigned char val)
1089{
1090	if (reg < 0xa0)
1091		return snd_es1938_mixer_bits(chip, reg, mask, val);
1092	else
1093		return snd_es1938_bits(chip, reg, mask, val);
1094}
1095
1096static int snd_es1938_reg_read(struct es1938 *chip, unsigned char reg)
1097{
1098	if (reg < 0xa0)
1099		return snd_es1938_mixer_read(chip, reg);
1100	else
1101		return snd_es1938_read(chip, reg);
1102}
1103
1104#define ES1938_SINGLE_TLV(xname, xindex, reg, shift, mask, invert, xtlv)    \
1105{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1106  .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,\
1107  .name = xname, .index = xindex, \
1108  .info = snd_es1938_info_single, \
1109  .get = snd_es1938_get_single, .put = snd_es1938_put_single, \
1110  .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24), \
1111  .tlv = { .p = xtlv } }
1112#define ES1938_SINGLE(xname, xindex, reg, shift, mask, invert) \
1113{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1114  .info = snd_es1938_info_single, \
1115  .get = snd_es1938_get_single, .put = snd_es1938_put_single, \
1116  .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
1117
1118static int snd_es1938_info_single(struct snd_kcontrol *kcontrol,
1119				  struct snd_ctl_elem_info *uinfo)
1120{
1121	int mask = (kcontrol->private_value >> 16) & 0xff;
1122
1123	uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1124	uinfo->count = 1;
1125	uinfo->value.integer.min = 0;
1126	uinfo->value.integer.max = mask;
1127	return 0;
1128}
1129
1130static int snd_es1938_get_single(struct snd_kcontrol *kcontrol,
1131				 struct snd_ctl_elem_value *ucontrol)
1132{
1133	struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1134	int reg = kcontrol->private_value & 0xff;
1135	int shift = (kcontrol->private_value >> 8) & 0xff;
1136	int mask = (kcontrol->private_value >> 16) & 0xff;
1137	int invert = (kcontrol->private_value >> 24) & 0xff;
1138	int val;
1139	
1140	val = snd_es1938_reg_read(chip, reg);
1141	ucontrol->value.integer.value[0] = (val >> shift) & mask;
1142	if (invert)
1143		ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1144	return 0;
1145}
1146
1147static int snd_es1938_put_single(struct snd_kcontrol *kcontrol,
1148				 struct snd_ctl_elem_value *ucontrol)
1149{
1150	struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1151	int reg = kcontrol->private_value & 0xff;
1152	int shift = (kcontrol->private_value >> 8) & 0xff;
1153	int mask = (kcontrol->private_value >> 16) & 0xff;
1154	int invert = (kcontrol->private_value >> 24) & 0xff;
1155	unsigned char val;
1156	
1157	val = (ucontrol->value.integer.value[0] & mask);
1158	if (invert)
1159		val = mask - val;
1160	mask <<= shift;
1161	val <<= shift;
1162	return snd_es1938_reg_bits(chip, reg, mask, val) != val;
1163}
1164
1165#define ES1938_DOUBLE_TLV(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert, xtlv) \
1166{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1167  .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,\
1168  .name = xname, .index = xindex, \
1169  .info = snd_es1938_info_double, \
1170  .get = snd_es1938_get_double, .put = snd_es1938_put_double, \
1171  .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22), \
1172  .tlv = { .p = xtlv } }
1173#define ES1938_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
1174{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1175  .info = snd_es1938_info_double, \
1176  .get = snd_es1938_get_double, .put = snd_es1938_put_double, \
1177  .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
1178
1179static int snd_es1938_info_double(struct snd_kcontrol *kcontrol,
1180				  struct snd_ctl_elem_info *uinfo)
1181{
1182	int mask = (kcontrol->private_value >> 24) & 0xff;
1183
1184	uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1185	uinfo->count = 2;
1186	uinfo->value.integer.min = 0;
1187	uinfo->value.integer.max = mask;
1188	return 0;
1189}
1190
1191static int snd_es1938_get_double(struct snd_kcontrol *kcontrol,
1192				 struct snd_ctl_elem_value *ucontrol)
1193{
1194	struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1195	int left_reg = kcontrol->private_value & 0xff;
1196	int right_reg = (kcontrol->private_value >> 8) & 0xff;
1197	int shift_left = (kcontrol->private_value >> 16) & 0x07;
1198	int shift_right = (kcontrol->private_value >> 19) & 0x07;
1199	int mask = (kcontrol->private_value >> 24) & 0xff;
1200	int invert = (kcontrol->private_value >> 22) & 1;
1201	unsigned char left, right;
1202	
1203	left = snd_es1938_reg_read(chip, left_reg);
1204	if (left_reg != right_reg)
1205		right = snd_es1938_reg_read(chip, right_reg);
1206	else
1207		right = left;
1208	ucontrol->value.integer.value[0] = (left >> shift_left) & mask;
1209	ucontrol->value.integer.value[1] = (right >> shift_right) & mask;
1210	if (invert) {
1211		ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1212		ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
1213	}
1214	return 0;
1215}
1216
1217static int snd_es1938_put_double(struct snd_kcontrol *kcontrol,
1218				 struct snd_ctl_elem_value *ucontrol)
1219{
1220	struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1221	int left_reg = kcontrol->private_value & 0xff;
1222	int right_reg = (kcontrol->private_value >> 8) & 0xff;
1223	int shift_left = (kcontrol->private_value >> 16) & 0x07;
1224	int shift_right = (kcontrol->private_value >> 19) & 0x07;
1225	int mask = (kcontrol->private_value >> 24) & 0xff;
1226	int invert = (kcontrol->private_value >> 22) & 1;
1227	int change;
1228	unsigned char val1, val2, mask1, mask2;
1229	
1230	val1 = ucontrol->value.integer.value[0] & mask;
1231	val2 = ucontrol->value.integer.value[1] & mask;
1232	if (invert) {
1233		val1 = mask - val1;
1234		val2 = mask - val2;
1235	}
1236	val1 <<= shift_left;
1237	val2 <<= shift_right;
1238	mask1 = mask << shift_left;
1239	mask2 = mask << shift_right;
1240	if (left_reg != right_reg) {
1241		change = 0;
1242		if (snd_es1938_reg_bits(chip, left_reg, mask1, val1) != val1)
1243			change = 1;
1244		if (snd_es1938_reg_bits(chip, right_reg, mask2, val2) != val2)
1245			change = 1;
1246	} else {
1247		change = (snd_es1938_reg_bits(chip, left_reg, mask1 | mask2, 
1248					      val1 | val2) != (val1 | val2));
1249	}
1250	return change;
1251}
1252
1253static const DECLARE_TLV_DB_RANGE(db_scale_master,
1254	0, 54, TLV_DB_SCALE_ITEM(-3600, 50, 1),
1255	54, 63, TLV_DB_SCALE_ITEM(-900, 100, 0),
1256);
1257
1258static const DECLARE_TLV_DB_RANGE(db_scale_audio1,
1259	0, 8, TLV_DB_SCALE_ITEM(-3300, 300, 1),
1260	8, 15, TLV_DB_SCALE_ITEM(-900, 150, 0),
1261);
1262
1263static const DECLARE_TLV_DB_RANGE(db_scale_audio2,
1264	0, 8, TLV_DB_SCALE_ITEM(-3450, 300, 1),
1265	8, 15, TLV_DB_SCALE_ITEM(-1050, 150, 0),
1266);
1267
1268static const DECLARE_TLV_DB_RANGE(db_scale_mic,
1269	0, 8, TLV_DB_SCALE_ITEM(-2400, 300, 1),
1270	8, 15, TLV_DB_SCALE_ITEM(0, 150, 0),
1271);
1272
1273static const DECLARE_TLV_DB_RANGE(db_scale_line,
1274	0, 8, TLV_DB_SCALE_ITEM(-3150, 300, 1),
1275	8, 15, TLV_DB_SCALE_ITEM(-750, 150, 0),
1276);
1277
1278static const DECLARE_TLV_DB_SCALE(db_scale_capture, 0, 150, 0);
1279
1280static const struct snd_kcontrol_new snd_es1938_controls[] = {
1281ES1938_DOUBLE_TLV("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0,
1282		  db_scale_master),
1283ES1938_DOUBLE("Master Playback Switch", 0, 0x60, 0x62, 6, 6, 1, 1),
1284{
1285	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1286	.name = "Hardware Master Playback Volume",
1287	.access = SNDRV_CTL_ELEM_ACCESS_READ,
1288	.info = snd_es1938_info_hw_volume,
1289	.get = snd_es1938_get_hw_volume,
1290},
1291{
1292	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1293	.access = (SNDRV_CTL_ELEM_ACCESS_READ |
1294		   SNDRV_CTL_ELEM_ACCESS_TLV_READ),
1295	.name = "Hardware Master Playback Switch",
1296	.info = snd_es1938_info_hw_switch,
1297	.get = snd_es1938_get_hw_switch,
1298	.tlv = { .p = db_scale_master },
1299},
1300ES1938_SINGLE("Hardware Volume Split", 0, 0x64, 7, 1, 0),
1301ES1938_DOUBLE_TLV("Line Playback Volume", 0, 0x3e, 0x3e, 4, 0, 15, 0,
1302		  db_scale_line),
1303ES1938_DOUBLE("CD Playback Volume", 0, 0x38, 0x38, 4, 0, 15, 0),
1304ES1938_DOUBLE_TLV("FM Playback Volume", 0, 0x36, 0x36, 4, 0, 15, 0,
1305		  db_scale_mic),
1306ES1938_DOUBLE_TLV("Mono Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0,
1307		  db_scale_line),
1308ES1938_DOUBLE_TLV("Mic Playback Volume", 0, 0x1a, 0x1a, 4, 0, 15, 0,
1309		  db_scale_mic),
1310ES1938_DOUBLE_TLV("Aux Playback Volume", 0, 0x3a, 0x3a, 4, 0, 15, 0,
1311		  db_scale_line),
1312ES1938_DOUBLE_TLV("Capture Volume", 0, 0xb4, 0xb4, 4, 0, 15, 0,
1313		  db_scale_capture),
1314ES1938_SINGLE("Beep Volume", 0, 0x3c, 0, 7, 0),
1315ES1938_SINGLE("Record Monitor", 0, 0xa8, 3, 1, 0),
1316ES1938_SINGLE("Capture Switch", 0, 0x1c, 4, 1, 1),
1317{
1318	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1319	.name = "Capture Source",
1320	.info = snd_es1938_info_mux,
1321	.get = snd_es1938_get_mux,
1322	.put = snd_es1938_put_mux,
1323},
1324ES1938_DOUBLE_TLV("Mono Input Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0,
1325		  db_scale_line),
1326ES1938_DOUBLE_TLV("PCM Capture Volume", 0, 0x69, 0x69, 4, 0, 15, 0,
1327		  db_scale_audio2),
1328ES1938_DOUBLE_TLV("Mic Capture Volume", 0, 0x68, 0x68, 4, 0, 15, 0,
1329		  db_scale_mic),
1330ES1938_DOUBLE_TLV("Line Capture Volume", 0, 0x6e, 0x6e, 4, 0, 15, 0,
1331		  db_scale_line),
1332ES1938_DOUBLE_TLV("FM Capture Volume", 0, 0x6b, 0x6b, 4, 0, 15, 0,
1333		  db_scale_mic),
1334ES1938_DOUBLE_TLV("Mono Capture Volume", 0, 0x6f, 0x6f, 4, 0, 15, 0,
1335		  db_scale_line),
1336ES1938_DOUBLE_TLV("CD Capture Volume", 0, 0x6a, 0x6a, 4, 0, 15, 0,
1337		  db_scale_line),
1338ES1938_DOUBLE_TLV("Aux Capture Volume", 0, 0x6c, 0x6c, 4, 0, 15, 0,
1339		  db_scale_line),
1340ES1938_DOUBLE_TLV("PCM Playback Volume", 0, 0x7c, 0x7c, 4, 0, 15, 0,
1341		  db_scale_audio2),
1342ES1938_DOUBLE_TLV("PCM Playback Volume", 1, 0x14, 0x14, 4, 0, 15, 0,
1343		  db_scale_audio1),
1344ES1938_SINGLE("3D Control - Level", 0, 0x52, 0, 63, 0),
1345{
1346	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1347	.name = "3D Control - Switch",
1348	.info = snd_es1938_info_spatializer_enable,
1349	.get = snd_es1938_get_spatializer_enable,
1350	.put = snd_es1938_put_spatializer_enable,
1351},
1352ES1938_SINGLE("Mic Boost (+26dB)", 0, 0x7d, 3, 1, 0)
1353};
1354
1355
1356/* ---------------------------------------------------------------------------- */
1357/* ---------------------------------------------------------------------------- */
1358
1359/*
1360 * initialize the chip - used by resume callback, too
1361 */
1362static void snd_es1938_chip_init(struct es1938 *chip)
1363{
1364	/* reset chip */
1365	snd_es1938_reset(chip);
1366
1367	/* configure native mode */
1368
1369	/* enable bus master */
1370	pci_set_master(chip->pci);
1371
1372	/* disable legacy audio */
1373	pci_write_config_word(chip->pci, SL_PCI_LEGACYCONTROL, 0x805f);
1374
1375	/* set DDMA base */
1376	pci_write_config_word(chip->pci, SL_PCI_DDMACONTROL, chip->ddma_port | 1);
1377
1378	/* set DMA/IRQ policy */
1379	pci_write_config_dword(chip->pci, SL_PCI_CONFIG, 0);
1380
1381	/* enable Audio 1, Audio 2, MPU401 IRQ and HW volume IRQ*/
1382	outb(0xf0, SLIO_REG(chip, IRQCONTROL));
1383
1384	/* reset DMA */
1385	outb(0, SLDM_REG(chip, DMACLEAR));
1386}
1387
1388/*
1389 * PM support
1390 */
1391
1392static const unsigned char saved_regs[SAVED_REG_SIZE+1] = {
1393	0x14, 0x1a, 0x1c, 0x3a, 0x3c, 0x3e, 0x36, 0x38,
1394	0x50, 0x52, 0x60, 0x61, 0x62, 0x63, 0x64, 0x68,
1395	0x69, 0x6a, 0x6b, 0x6d, 0x6e, 0x6f, 0x7c, 0x7d,
1396	0xa8, 0xb4,
1397};
1398
1399
1400static int es1938_suspend(struct device *dev)
1401{
1402	struct snd_card *card = dev_get_drvdata(dev);
1403	struct es1938 *chip = card->private_data;
1404	const unsigned char *s;
1405	unsigned char *d;
1406
1407	snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1408
1409	/* save mixer-related registers */
1410	for (s = saved_regs, d = chip->saved_regs; *s; s++, d++)
1411		*d = snd_es1938_reg_read(chip, *s);
1412
1413	outb(0x00, SLIO_REG(chip, IRQCONTROL)); /* disable irqs */
1414	if (chip->irq >= 0) {
1415		free_irq(chip->irq, chip);
1416		chip->irq = -1;
1417		card->sync_irq = -1;
1418	}
1419	return 0;
1420}
1421
1422static int es1938_resume(struct device *dev)
1423{
1424	struct pci_dev *pci = to_pci_dev(dev);
1425	struct snd_card *card = dev_get_drvdata(dev);
1426	struct es1938 *chip = card->private_data;
1427	const unsigned char *s;
1428	unsigned char *d;
1429
1430	if (request_irq(pci->irq, snd_es1938_interrupt,
1431			IRQF_SHARED, KBUILD_MODNAME, chip)) {
1432		dev_err(dev, "unable to grab IRQ %d, disabling device\n",
1433			pci->irq);
1434		snd_card_disconnect(card);
1435		return -EIO;
1436	}
1437	chip->irq = pci->irq;
1438	card->sync_irq = chip->irq;
1439	snd_es1938_chip_init(chip);
1440
1441	/* restore mixer-related registers */
1442	for (s = saved_regs, d = chip->saved_regs; *s; s++, d++) {
1443		if (*s < 0xa0)
1444			snd_es1938_mixer_write(chip, *s, *d);
1445		else
1446			snd_es1938_write(chip, *s, *d);
1447	}
1448
1449	snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1450	return 0;
1451}
1452
1453static DEFINE_SIMPLE_DEV_PM_OPS(es1938_pm, es1938_suspend, es1938_resume);
1454
1455#ifdef SUPPORT_JOYSTICK
1456static int snd_es1938_create_gameport(struct es1938 *chip)
1457{
1458	struct gameport *gp;
1459
1460	chip->gameport = gp = gameport_allocate_port();
1461	if (!gp) {
1462		dev_err(chip->card->dev,
1463			"cannot allocate memory for gameport\n");
1464		return -ENOMEM;
1465	}
1466
1467	gameport_set_name(gp, "ES1938");
1468	gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
1469	gameport_set_dev_parent(gp, &chip->pci->dev);
1470	gp->io = chip->game_port;
1471
1472	gameport_register_port(gp);
1473
1474	return 0;
1475}
1476
1477static void snd_es1938_free_gameport(struct es1938 *chip)
1478{
1479	if (chip->gameport) {
1480		gameport_unregister_port(chip->gameport);
1481		chip->gameport = NULL;
1482	}
1483}
1484#else
1485static inline int snd_es1938_create_gameport(struct es1938 *chip) { return -ENOSYS; }
1486static inline void snd_es1938_free_gameport(struct es1938 *chip) { }
1487#endif /* SUPPORT_JOYSTICK */
1488
1489static void snd_es1938_free(struct snd_card *card)
1490{
1491	struct es1938 *chip = card->private_data;
1492
1493	/* disable irqs */
1494	outb(0x00, SLIO_REG(chip, IRQCONTROL));
1495	if (chip->rmidi)
1496		snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0);
1497
1498	snd_es1938_free_gameport(chip);
1499
1500	if (chip->irq >= 0)
1501		free_irq(chip->irq, chip);
1502}
1503
1504static int snd_es1938_create(struct snd_card *card,
1505			     struct pci_dev *pci)
1506{
1507	struct es1938 *chip = card->private_data;
1508	int err;
1509
1510	/* enable PCI device */
1511	err = pcim_enable_device(pci);
1512	if (err < 0)
1513		return err;
1514        /* check, if we can restrict PCI DMA transfers to 24 bits */
1515	if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(24))) {
1516		dev_err(card->dev,
1517			"architecture does not support 24bit PCI busmaster DMA\n");
1518                return -ENXIO;
1519        }
1520
1521	spin_lock_init(&chip->reg_lock);
1522	spin_lock_init(&chip->mixer_lock);
1523	chip->card = card;
1524	chip->pci = pci;
1525	chip->irq = -1;
1526	err = pcim_request_all_regions(pci, "ESS Solo-1");
1527	if (err < 0)
1528		return err;
1529	chip->io_port = pci_resource_start(pci, 0);
1530	chip->sb_port = pci_resource_start(pci, 1);
1531	chip->vc_port = pci_resource_start(pci, 2);
1532	chip->mpu_port = pci_resource_start(pci, 3);
1533	chip->game_port = pci_resource_start(pci, 4);
1534	/* still use non-managed irq handler as it's re-acquired at PM resume */
1535	if (request_irq(pci->irq, snd_es1938_interrupt, IRQF_SHARED,
1536			KBUILD_MODNAME, chip)) {
1537		dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
1538		return -EBUSY;
1539	}
1540	chip->irq = pci->irq;
1541	card->sync_irq = chip->irq;
1542	card->private_free = snd_es1938_free;
1543	dev_dbg(card->dev,
1544		"create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
1545		   chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port);
1546
1547	chip->ddma_port = chip->vc_port + 0x00;		/* fix from Thomas Sailer */
1548
1549	snd_es1938_chip_init(chip);
1550	return 0;
1551}
1552
1553/* --------------------------------------------------------------------
1554 * Interrupt handler
1555 * -------------------------------------------------------------------- */
1556static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id)
1557{
1558	struct es1938 *chip = dev_id;
1559	unsigned char status;
1560	__always_unused unsigned char audiostatus;
1561	int handled = 0;
1562
1563	status = inb(SLIO_REG(chip, IRQCONTROL));
1564#if 0
1565	dev_dbg(chip->card->dev,
1566		"Es1938debug - interrupt status: =0x%x\n", status);
1567#endif
1568	
1569	/* AUDIO 1 */
1570	if (status & 0x10) {
1571#if 0
1572		dev_dbg(chip->card->dev,
1573		       "Es1938debug - AUDIO channel 1 interrupt\n");
1574		dev_dbg(chip->card->dev,
1575		       "Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n",
1576		       inw(SLDM_REG(chip, DMACOUNT)));
1577		dev_dbg(chip->card->dev,
1578		       "Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n",
1579		       inl(SLDM_REG(chip, DMAADDR)));
1580		dev_dbg(chip->card->dev,
1581		       "Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n",
1582		       inl(SLDM_REG(chip, DMASTATUS)));
1583#endif
1584		/* clear irq */
1585		handled = 1;
1586		audiostatus = inb(SLSB_REG(chip, STATUS));
1587		if (chip->active & ADC1)
1588			snd_pcm_period_elapsed(chip->capture_substream);
1589		else if (chip->active & DAC1)
1590			snd_pcm_period_elapsed(chip->playback2_substream);
1591	}
1592	
1593	/* AUDIO 2 */
1594	if (status & 0x20) {
1595#if 0
1596		dev_dbg(chip->card->dev,
1597		       "Es1938debug - AUDIO channel 2 interrupt\n");
1598		dev_dbg(chip->card->dev,
1599		       "Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n",
1600		       inw(SLIO_REG(chip, AUDIO2DMACOUNT)));
1601		dev_dbg(chip->card->dev,
1602		       "Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n",
1603		       inl(SLIO_REG(chip, AUDIO2DMAADDR)));
1604
1605#endif
1606		/* clear irq */
1607		handled = 1;
1608		snd_es1938_mixer_bits(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x80, 0);
1609		if (chip->active & DAC2)
1610			snd_pcm_period_elapsed(chip->playback1_substream);
1611	}
1612
1613	/* Hardware volume */
1614	if (status & 0x40) {
1615		int split = snd_es1938_mixer_read(chip, 0x64) & 0x80;
1616		handled = 1;
1617		snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id);
1618		snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id);
1619		if (!split) {
1620			snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1621				       &chip->master_switch->id);
1622			snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1623				       &chip->master_volume->id);
1624		}
1625		/* ack interrupt */
1626		snd_es1938_mixer_write(chip, 0x66, 0x00);
1627	}
1628
1629	/* MPU401 */
1630	if (status & 0x80) {
1631		// the following line is evil! It switches off MIDI interrupt handling after the first interrupt received.
1632		// replacing the last 0 by 0x40 works for ESS-Solo1, but just doing nothing works as well!
1633		// andreas@flying-snail.de
1634		// snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); /* ack? */
1635		if (chip->rmidi) {
1636			handled = 1;
1637			snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data);
1638		}
1639	}
1640	return IRQ_RETVAL(handled);
1641}
1642
1643#define ES1938_DMA_SIZE 64
1644
1645static int snd_es1938_mixer(struct es1938 *chip)
1646{
1647	struct snd_card *card;
1648	unsigned int idx;
1649	int err;
1650
1651	card = chip->card;
1652
1653	strscpy(card->mixername, "ESS Solo-1");
1654
1655	for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) {
1656		struct snd_kcontrol *kctl;
1657		kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip);
1658		switch (idx) {
1659			case 0:
1660				chip->master_volume = kctl;
1661				kctl->private_free = snd_es1938_hwv_free;
1662				break;
1663			case 1:
1664				chip->master_switch = kctl;
1665				kctl->private_free = snd_es1938_hwv_free;
1666				break;
1667			case 2:
1668				chip->hw_volume = kctl;
1669				kctl->private_free = snd_es1938_hwv_free;
1670				break;
1671			case 3:
1672				chip->hw_switch = kctl;
1673				kctl->private_free = snd_es1938_hwv_free;
1674				break;
1675			}
1676		err = snd_ctl_add(card, kctl);
1677		if (err < 0)
1678			return err;
1679	}
1680	return 0;
1681}
1682       
1683
1684static int __snd_es1938_probe(struct pci_dev *pci,
1685			      const struct pci_device_id *pci_id)
1686{
1687	static int dev;
1688	struct snd_card *card;
1689	struct es1938 *chip;
1690	struct snd_opl3 *opl3;
1691	int idx, err;
1692
1693	if (dev >= SNDRV_CARDS)
1694		return -ENODEV;
1695	if (!enable[dev]) {
1696		dev++;
1697		return -ENOENT;
1698	}
1699
1700	err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
1701				sizeof(*chip), &card);
1702	if (err < 0)
1703		return err;
1704	chip = card->private_data;
1705
1706	for (idx = 0; idx < 5; idx++)
1707		if (pci_resource_start(pci, idx) == 0 ||
1708		    !(pci_resource_flags(pci, idx) & IORESOURCE_IO))
1709			return -ENODEV;
1710
1711	err = snd_es1938_create(card, pci);
1712	if (err < 0)
1713		return err;
1714
1715	strscpy(card->driver, "ES1938");
1716	strscpy(card->shortname, "ESS ES1938 (Solo-1)");
1717	sprintf(card->longname, "%s rev %i, irq %i",
1718		card->shortname,
1719		chip->revision,
1720		chip->irq);
1721
1722	err = snd_es1938_new_pcm(chip, 0);
1723	if (err < 0)
1724		return err;
1725	err = snd_es1938_mixer(chip);
1726	if (err < 0)
1727		return err;
1728	if (snd_opl3_create(card,
1729			    SLSB_REG(chip, FMLOWADDR),
1730			    SLSB_REG(chip, FMHIGHADDR),
1731			    OPL3_HW_OPL3, 1, &opl3) < 0) {
1732		dev_err(card->dev, "OPL3 not detected at 0x%lx\n",
1733			   SLSB_REG(chip, FMLOWADDR));
1734	} else {
1735		err = snd_opl3_timer_new(opl3, 0, 1);
1736		if (err < 0)
1737	                return err;
1738		err = snd_opl3_hwdep_new(opl3, 0, 1, NULL);
1739		if (err < 0)
1740	                return err;
1741	}
1742	if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
1743				chip->mpu_port,
1744				MPU401_INFO_INTEGRATED | MPU401_INFO_IRQ_HOOK,
1745				-1, &chip->rmidi) < 0) {
1746		dev_err(card->dev, "unable to initialize MPU-401\n");
1747	} else {
1748		// this line is vital for MIDI interrupt handling on ess-solo1
1749		// andreas@flying-snail.de
1750		snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0x40);
1751	}
1752
1753	snd_es1938_create_gameport(chip);
1754
1755	err = snd_card_register(card);
1756	if (err < 0)
1757		return err;
1758
1759	pci_set_drvdata(pci, card);
1760	dev++;
1761	return 0;
1762}
1763
1764static int snd_es1938_probe(struct pci_dev *pci,
1765			    const struct pci_device_id *pci_id)
1766{
1767	return snd_card_free_on_error(&pci->dev, __snd_es1938_probe(pci, pci_id));
1768}
1769
1770static struct pci_driver es1938_driver = {
1771	.name = KBUILD_MODNAME,
1772	.id_table = snd_es1938_ids,
1773	.probe = snd_es1938_probe,
1774	.driver = {
1775		.pm = &es1938_pm,
1776	},
1777};
1778
1779module_pci_driver(es1938_driver);