1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3	* Driver for generic ESS AudioDrive ES18xx soundcards
4	* Copyright (c) by Christian Fischbach <fishbach@pool.informatik.rwth-aachen.de>
5	* Copyright (c) by Abramo Bagnara <abramo@alsa-project.org>
6	*/
7	/* GENERAL NOTES:
8	*
9	* BUGS:
10	* - There are pops (we can't delay in trigger function, cause midlevel
11	* often need to trigger down and then up very quickly).
12	* Any ideas?
13	* - Support for 16 bit DMA seems to be broken. I've no hardware to tune it.
14	*/
15
16	/*
17	* ES1868 NOTES:
18	* - The chip has one half duplex pcm (with very limited full duplex support).
19	*
20	* - Duplex stereophonic sound is impossible.
21	* - Record and playback must share the same frequency rate.
22	*
23	* - The driver use dma2 for playback and dma1 for capture.
24	*/
25
26	/*
27	* ES1869 NOTES:
28	*
29	* - there are a first full duplex pcm and a second playback only pcm
30	* (incompatible with first pcm capture)
31	*
32	* - there is support for the capture volume and ESS Spatializer 3D effect.
33	*
34	* - contrarily to some pages in DS_1869.PDF the rates can be set
35	* independently.
36	*
37	* - Zoom Video is implemented by sharing the FM DAC, thus the user can
38	* have either FM playback or Video playback but not both simultaneously.
39	* The Video Playback Switch mixer control toggles this choice.
40	*
41	* BUGS:
42	*
43	* - There is a major trouble I noted:
44	*
45	* using both channel for playback stereo 16 bit samples at 44100 Hz
46	* the second pcm (Audio1) DMA slows down irregularly and sound is garbled.
47	*
48	* The same happens using Audio1 for captureing.
49	*
50	* The Windows driver does not suffer of this (although it use Audio1
51	* only for captureing). I'm unable to discover why.
52	*
53	*/
54
55	/*
56	* ES1879 NOTES:
57	* - When Zoom Video is enabled (reg 0x71 bit 6 toggled on) the PCM playback
58	* seems to be effected (speaker_test plays a lower frequency). Can't find
59	* anything in the datasheet to account for this, so a Video Playback Switch
60	* control has been included to allow ZV to be enabled only when necessary.
61	* Then again on at least one test system the 0x71 bit 6 enable bit is not
62	* needed for ZV, so maybe the datasheet is entirely wrong here.
63	*/
64
65	#include <linux/init.h>
66	#include <linux/err.h>
67	#include <linux/isa.h>
68	#include <linux/pnp.h>
69	#include <linux/isapnp.h>
70	#include <linux/module.h>
71	#include <linux/delay.h>
72	#include <linux/io.h>
73
74	#include <asm/dma.h>
75	#include <sound/core.h>
76	#include <sound/control.h>
77	#include <sound/pcm.h>
78	#include <sound/pcm_params.h>
79	#include <sound/mpu401.h>
80	#include <sound/opl3.h>
81	#define SNDRV_LEGACY_FIND_FREE_IRQ
82	#define SNDRV_LEGACY_FIND_FREE_DMA
83	#include <sound/initval.h>
84
85	struct snd_es18xx {
86	struct snd_card *card;
87	unsigned long port; /* port of ESS chip */
88	unsigned long ctrl_port; /* Control port of ESS chip */
89	int irq; /* IRQ number of ESS chip */
90	int dma1; /* DMA1 */
91	int dma2; /* DMA2 */
92	unsigned short version; /* version of ESS chip */
93	int caps; /* Chip capabilities */
94	unsigned short audio2_vol; /* volume level of audio2 */
95
96	unsigned short active; /* active channel mask */
97	unsigned int dma1_shift;
98	unsigned int dma2_shift;
99
100	struct snd_pcm *pcm;
101	struct snd_pcm_substream *playback_a_substream;
102	struct snd_pcm_substream *capture_a_substream;
103	struct snd_pcm_substream *playback_b_substream;
104
105	struct snd_rawmidi *rmidi;
106
107	struct snd_kcontrol *hw_volume;
108	struct snd_kcontrol *hw_switch;
109	struct snd_kcontrol *master_volume;
110	struct snd_kcontrol *master_switch;
111
112	spinlock_t reg_lock;
113	spinlock_t mixer_lock;
114	#ifdef CONFIG_PM
115	unsigned char pm_reg;
116	#endif
117	#ifdef CONFIG_PNP
118	struct pnp_dev *dev;
119	struct pnp_dev *devc;
120	#endif
121	};
122
123	#define AUDIO1_IRQ 0x01
124	#define AUDIO2_IRQ 0x02
125	#define HWV_IRQ 0x04
126	#define MPU_IRQ 0x08
127
128	#define ES18XX_PCM2 0x0001 /* Has two useable PCM */
129	#define ES18XX_SPATIALIZER 0x0002 /* Has 3D Spatializer */
130	#define ES18XX_RECMIX 0x0004 /* Has record mixer */
131	#define ES18XX_DUPLEX_MONO 0x0008 /* Has mono duplex only */
132	#define ES18XX_DUPLEX_SAME 0x0010 /* Playback and record must share the same rate */
133	#define ES18XX_NEW_RATE 0x0020 /* More precise rate setting */
134	#define ES18XX_AUXB 0x0040 /* AuxB mixer control */
135	#define ES18XX_HWV 0x0080 /* Has separate hardware volume mixer controls*/
136	#define ES18XX_MONO 0x0100 /* Mono_in mixer control */
137	#define ES18XX_I2S 0x0200 /* I2S mixer control */
138	#define ES18XX_MUTEREC 0x0400 /* Record source can be muted */
139	#define ES18XX_CONTROL 0x0800 /* Has control ports */
140	#define ES18XX_GPO_2BIT 0x1000 /* GPO0,1 controlled by PM port */
141
142	/* Power Management */
143	#define ES18XX_PM 0x07
144	#define ES18XX_PM_GPO0 0x01
145	#define ES18XX_PM_GPO1 0x02
146	#define ES18XX_PM_PDR 0x04
147	#define ES18XX_PM_ANA 0x08
148	#define ES18XX_PM_FM 0x020
149	#define ES18XX_PM_SUS 0x080
150
151	/* Lowlevel */
152
153	#define DAC1 0x01
154	#define ADC1 0x02
155	#define DAC2 0x04
156	#define MILLISECOND 10000
157
158	static int snd_es18xx_dsp_command(struct snd_es18xx *chip, unsigned char val)
159	{
160	int i;
161
162	for(i = MILLISECOND; i; i--)
163	if ((inb(port: chip->port + 0x0C) & 0x80) == 0) {
164	outb(value: val, port: chip->port + 0x0C);
165	return 0;
166	}
167	dev_err(chip->card->dev, "dsp_command: timeout (0x%x)\n", val);
168	return -EINVAL;
169	}
170
171	static int snd_es18xx_dsp_get_byte(struct snd_es18xx *chip)
172	{
173	int i;
174
175	for(i = MILLISECOND/10; i; i--)
176	if (inb(port: chip->port + 0x0C) & 0x40)
177	return inb(port: chip->port + 0x0A);
178	dev_err(chip->card->dev, "dsp_get_byte failed: 0x%lx = 0x%x!!!\n",
179	chip->port + 0x0A, inb(chip->port + 0x0A));
180	return -ENODEV;
181	}
182
183	#undef REG_DEBUG
184
185	static int snd_es18xx_write(struct snd_es18xx *chip,
186	unsigned char reg, unsigned char data)
187	{
188	int ret;
189
190	guard(spinlock_irqsave)(l: &chip->reg_lock);
191	ret = snd_es18xx_dsp_command(chip, val: reg);
192	if (ret < 0)
193	return ret;
194	ret = snd_es18xx_dsp_command(chip, val: data);
195	#ifdef REG_DEBUG
196	dev_dbg(chip->card->dev, "Reg %02x set to %02x\n", reg, data);
197	#endif
198	return ret;
199	}
200
201	static int snd_es18xx_read(struct snd_es18xx *chip, unsigned char reg)
202	{
203	int ret, data;
204
205	guard(spinlock_irqsave)(l: &chip->reg_lock);
206	ret = snd_es18xx_dsp_command(chip, val: 0xC0);
207	if (ret < 0)
208	return ret;
209	ret = snd_es18xx_dsp_command(chip, val: reg);
210	if (ret < 0)
211	return ret;
212	data = snd_es18xx_dsp_get_byte(chip);
213	ret = data;
214	#ifdef REG_DEBUG
215	dev_dbg(chip->card->dev, "Reg %02x now is %02x (%d)\n", reg, data, ret);
216	#endif
217	return ret;
218	}
219
220	/* Return old value */
221	static int snd_es18xx_bits(struct snd_es18xx *chip, unsigned char reg,
222	unsigned char mask, unsigned char val)
223	{
224	int ret;
225	unsigned char old, new, oval;
226
227	guard(spinlock_irqsave)(l: &chip->reg_lock);
228	ret = snd_es18xx_dsp_command(chip, val: 0xC0);
229	if (ret < 0)
230	return ret;
231	ret = snd_es18xx_dsp_command(chip, val: reg);
232	if (ret < 0)
233	return ret;
234	ret = snd_es18xx_dsp_get_byte(chip);
235	if (ret < 0)
236	return ret;
237	old = ret;
238	oval = old & mask;
239	if (val != oval) {
240	ret = snd_es18xx_dsp_command(chip, val: reg);
241	if (ret < 0)
242	return ret;
243	new = (old & ~mask) | (val & mask);
244	ret = snd_es18xx_dsp_command(chip, val: new);
245	if (ret < 0)
246	return ret;
247	#ifdef REG_DEBUG
248	dev_dbg(chip->card->dev, "Reg %02x was %02x, set to %02x (%d)\n",
249	reg, old, new, ret);
250	#endif
251	}
252	return oval;
253	}
254
255	static inline void snd_es18xx_mixer_write(struct snd_es18xx *chip,
256	unsigned char reg, unsigned char data)
257	{
258	guard(spinlock_irqsave)(l: &chip->mixer_lock);
259	outb(value: reg, port: chip->port + 0x04);
260	outb(value: data, port: chip->port + 0x05);
261	#ifdef REG_DEBUG
262	dev_dbg(chip->card->dev, "Mixer reg %02x set to %02x\n", reg, data);
263	#endif
264	}
265
266	static inline int snd_es18xx_mixer_read(struct snd_es18xx *chip, unsigned char reg)
267	{
268	int data;
269
270	guard(spinlock_irqsave)(l: &chip->mixer_lock);
271	outb(value: reg, port: chip->port + 0x04);
272	data = inb(port: chip->port + 0x05);
273	#ifdef REG_DEBUG
274	dev_dbg(chip->card->dev, "Mixer reg %02x now is %02x\n", reg, data);
275	#endif
276	return data;
277	}
278
279	/* Return old value */
280	static inline int snd_es18xx_mixer_bits(struct snd_es18xx *chip, unsigned char reg,
281	unsigned char mask, unsigned char val)
282	{
283	unsigned char old, new, oval;
284
285	guard(spinlock_irqsave)(l: &chip->mixer_lock);
286	outb(value: reg, port: chip->port + 0x04);
287	old = inb(port: chip->port + 0x05);
288	oval = old & mask;
289	if (val != oval) {
290	new = (old & ~mask) | (val & mask);
291	outb(value: new, port: chip->port + 0x05);
292	#ifdef REG_DEBUG
293	dev_dbg(chip->card->dev, "Mixer reg %02x was %02x, set to %02x\n",
294	reg, old, new);
295	#endif
296	}
297	return oval;
298	}
299
300	static inline int snd_es18xx_mixer_writable(struct snd_es18xx *chip, unsigned char reg,
301	unsigned char mask)
302	{
303	int old, expected, new;
304
305	guard(spinlock_irqsave)(l: &chip->mixer_lock);
306	outb(value: reg, port: chip->port + 0x04);
307	old = inb(port: chip->port + 0x05);
308	expected = old ^ mask;
309	outb(value: expected, port: chip->port + 0x05);
310	new = inb(port: chip->port + 0x05);
311	#ifdef REG_DEBUG
312	dev_dbg(chip->card->dev, "Mixer reg %02x was %02x, set to %02x, now is %02x\n",
313	reg, old, expected, new);
314	#endif
315	return expected == new;
316	}
317
318
319	static int snd_es18xx_reset(struct snd_es18xx *chip)
320	{
321	int i;
322	outb(value: 0x03, port: chip->port + 0x06);
323	inb(port: chip->port + 0x06);
324	outb(value: 0x00, port: chip->port + 0x06);
325	for(i = 0; i < MILLISECOND && !(inb(port: chip->port + 0x0E) & 0x80); i++);
326	if (inb(port: chip->port + 0x0A) != 0xAA)
327	return -1;
328	return 0;
329	}
330
331	static int snd_es18xx_reset_fifo(struct snd_es18xx *chip)
332	{
333	outb(value: 0x02, port: chip->port + 0x06);
334	inb(port: chip->port + 0x06);
335	outb(value: 0x00, port: chip->port + 0x06);
336	return 0;
337	}
338
339	static const struct snd_ratnum new_clocks[2] = {
340	{
341	.num = 793800,
342	.den_min = 1,
343	.den_max = 128,
344	.den_step = 1,
345	},
346	{
347	.num = 768000,
348	.den_min = 1,
349	.den_max = 128,
350	.den_step = 1,
351	}
352	};
353
354	static const struct snd_pcm_hw_constraint_ratnums new_hw_constraints_clocks = {
355	.nrats = 2,
356	.rats = new_clocks,
357	};
358
359	static const struct snd_ratnum old_clocks[2] = {
360	{
361	.num = 795444,
362	.den_min = 1,
363	.den_max = 128,
364	.den_step = 1,
365	},
366	{
367	.num = 397722,
368	.den_min = 1,
369	.den_max = 128,
370	.den_step = 1,
371	}
372	};
373
374	static const struct snd_pcm_hw_constraint_ratnums old_hw_constraints_clocks = {
375	.nrats = 2,
376	.rats = old_clocks,
377	};
378
379
380	static void snd_es18xx_rate_set(struct snd_es18xx *chip,
381	struct snd_pcm_substream *substream,
382	int mode)
383	{
384	unsigned int bits, div0;
385	struct snd_pcm_runtime *runtime = substream->runtime;
386	if (chip->caps & ES18XX_NEW_RATE) {
387	if (runtime->rate_num == new_clocks[0].num)
388	bits = 128 - runtime->rate_den;
389	else
390	bits = 256 - runtime->rate_den;
391	} else {
392	if (runtime->rate_num == old_clocks[0].num)
393	bits = 256 - runtime->rate_den;
394	else
395	bits = 128 - runtime->rate_den;
396	}
397
398	/* set filter register */
399	div0 = 256 - 7160000*20/(8*82*runtime->rate);
400
401	if ((chip->caps & ES18XX_PCM2) && mode == DAC2) {
402	snd_es18xx_mixer_write(chip, reg: 0x70, data: bits);
403	/*
404	* Comment from kernel oss driver:
405	* FKS: fascinating: 0x72 doesn't seem to work.
406	*/
407	snd_es18xx_write(chip, reg: 0xA2, data: div0);
408	snd_es18xx_mixer_write(chip, reg: 0x72, data: div0);
409	} else {
410	snd_es18xx_write(chip, reg: 0xA1, data: bits);
411	snd_es18xx_write(chip, reg: 0xA2, data: div0);
412	}
413	}
414
415	static int snd_es18xx_playback_hw_params(struct snd_pcm_substream *substream,
416	struct snd_pcm_hw_params *hw_params)
417	{
418	struct snd_es18xx *chip = snd_pcm_substream_chip(substream);
419	int shift;
420
421	shift = 0;
422	if (params_channels(p: hw_params) == 2)
423	shift++;
424	if (snd_pcm_format_width(format: params_format(p: hw_params)) == 16)
425	shift++;
426
427	if (substream->number == 0 && (chip->caps & ES18XX_PCM2)) {
428	if ((chip->caps & ES18XX_DUPLEX_MONO) &&
429	(chip->capture_a_substream) &&
430	params_channels(p: hw_params) != 1) {
431	_snd_pcm_hw_param_setempty(params: hw_params, SNDRV_PCM_HW_PARAM_CHANNELS);
432	return -EBUSY;
433	}
434	chip->dma2_shift = shift;
435	} else {
436	chip->dma1_shift = shift;
437	}
438	return 0;
439	}
440
441	static int snd_es18xx_playback1_prepare(struct snd_es18xx *chip,
442	struct snd_pcm_substream *substream)
443	{
444	struct snd_pcm_runtime *runtime = substream->runtime;
445	unsigned int size = snd_pcm_lib_buffer_bytes(substream);
446	unsigned int count = snd_pcm_lib_period_bytes(substream);
447
448	snd_es18xx_rate_set(chip, substream, DAC2);
449
450	/* Transfer Count Reload */
451	count = 0x10000 - count;
452	snd_es18xx_mixer_write(chip, reg: 0x74, data: count & 0xff);
453	snd_es18xx_mixer_write(chip, reg: 0x76, data: count >> 8);
454
455	/* Set format */
456	snd_es18xx_mixer_bits(chip, reg: 0x7A, mask: 0x07,
457	val: ((runtime->channels == 1) ? 0x00 : 0x02) |
458	(snd_pcm_format_width(format: runtime->format) == 16 ? 0x01 : 0x00) |
459	(snd_pcm_format_unsigned(format: runtime->format) ? 0x00 : 0x04));
460
461	/* Set DMA controller */
462	snd_dma_program(dma: chip->dma2, addr: runtime->dma_addr, size, DMA_MODE_WRITE | DMA_AUTOINIT);
463
464	return 0;
465	}
466
467	static int snd_es18xx_playback1_trigger(struct snd_es18xx *chip,
468	struct snd_pcm_substream *substream,
469	int cmd)
470	{
471	switch (cmd) {
472	case SNDRV_PCM_TRIGGER_START:
473	case SNDRV_PCM_TRIGGER_RESUME:
474	if (chip->active & DAC2)
475	return 0;
476	chip->active |= DAC2;
477	/* Start DMA */
478	if (chip->dma2 >= 4)
479	snd_es18xx_mixer_write(chip, reg: 0x78, data: 0xb3);
480	else
481	snd_es18xx_mixer_write(chip, reg: 0x78, data: 0x93);
482	#ifdef AVOID_POPS
483	/* Avoid pops */
484	mdelay(100);
485	if (chip->caps & ES18XX_PCM2)
486	/* Restore Audio 2 volume */
487	snd_es18xx_mixer_write(chip, 0x7C, chip->audio2_vol);
488	else
489	/* Enable PCM output */
490	snd_es18xx_dsp_command(chip, 0xD1);
491	#endif
492	break;
493	case SNDRV_PCM_TRIGGER_STOP:
494	case SNDRV_PCM_TRIGGER_SUSPEND:
495	if (!(chip->active & DAC2))
496	return 0;
497	chip->active &= ~DAC2;
498	/* Stop DMA */
499	snd_es18xx_mixer_write(chip, reg: 0x78, data: 0x00);
500	#ifdef AVOID_POPS
501	mdelay(25);
502	if (chip->caps & ES18XX_PCM2)
503	/* Set Audio 2 volume to 0 */
504	snd_es18xx_mixer_write(chip, 0x7C, 0);
505	else
506	/* Disable PCM output */
507	snd_es18xx_dsp_command(chip, 0xD3);
508	#endif
509	break;
510	default:
511	return -EINVAL;
512	}
513
514	return 0;
515	}
516
517	static int snd_es18xx_capture_hw_params(struct snd_pcm_substream *substream,
518	struct snd_pcm_hw_params *hw_params)
519	{
520	struct snd_es18xx *chip = snd_pcm_substream_chip(substream);
521	int shift;
522
523	shift = 0;
524	if ((chip->caps & ES18XX_DUPLEX_MONO) &&
525	chip->playback_a_substream &&
526	params_channels(p: hw_params) != 1) {
527	_snd_pcm_hw_param_setempty(params: hw_params, SNDRV_PCM_HW_PARAM_CHANNELS);
528	return -EBUSY;
529	}
530	if (params_channels(p: hw_params) == 2)
531	shift++;
532	if (snd_pcm_format_width(format: params_format(p: hw_params)) == 16)
533	shift++;
534	chip->dma1_shift = shift;
535	return 0;
536	}
537
538	static int snd_es18xx_capture_prepare(struct snd_pcm_substream *substream)
539	{
540	struct snd_es18xx *chip = snd_pcm_substream_chip(substream);
541	struct snd_pcm_runtime *runtime = substream->runtime;
542	unsigned int size = snd_pcm_lib_buffer_bytes(substream);
543	unsigned int count = snd_pcm_lib_period_bytes(substream);
544
545	snd_es18xx_reset_fifo(chip);
546
547	/* Set stereo/mono */
548	snd_es18xx_bits(chip, reg: 0xA8, mask: 0x03, val: runtime->channels == 1 ? 0x02 : 0x01);
549
550	snd_es18xx_rate_set(chip, substream, ADC1);
551
552	/* Transfer Count Reload */
553	count = 0x10000 - count;
554	snd_es18xx_write(chip, reg: 0xA4, data: count & 0xff);
555	snd_es18xx_write(chip, reg: 0xA5, data: count >> 8);
556
557	#ifdef AVOID_POPS
558	mdelay(100);
559	#endif
560
561	/* Set format */
562	snd_es18xx_write(chip, reg: 0xB7,
563	data: snd_pcm_format_unsigned(format: runtime->format) ? 0x51 : 0x71);
564	snd_es18xx_write(chip, reg: 0xB7, data: 0x90 |
565	((runtime->channels == 1) ? 0x40 : 0x08) |
566	(snd_pcm_format_width(format: runtime->format) == 16 ? 0x04 : 0x00) |
567	(snd_pcm_format_unsigned(format: runtime->format) ? 0x00 : 0x20));
568
569	/* Set DMA controller */
570	snd_dma_program(dma: chip->dma1, addr: runtime->dma_addr, size, DMA_MODE_READ | DMA_AUTOINIT);
571
572	return 0;
573	}
574
575	static int snd_es18xx_capture_trigger(struct snd_pcm_substream *substream,
576	int cmd)
577	{
578	struct snd_es18xx *chip = snd_pcm_substream_chip(substream);
579
580	switch (cmd) {
581	case SNDRV_PCM_TRIGGER_START:
582	case SNDRV_PCM_TRIGGER_RESUME:
583	if (chip->active & ADC1)
584	return 0;
585	chip->active |= ADC1;
586	/* Start DMA */
587	snd_es18xx_write(chip, reg: 0xB8, data: 0x0f);
588	break;
589	case SNDRV_PCM_TRIGGER_STOP:
590	case SNDRV_PCM_TRIGGER_SUSPEND:
591	if (!(chip->active & ADC1))
592	return 0;
593	chip->active &= ~ADC1;
594	/* Stop DMA */
595	snd_es18xx_write(chip, reg: 0xB8, data: 0x00);
596	break;
597	default:
598	return -EINVAL;
599	}
600
601	return 0;
602	}
603
604	static int snd_es18xx_playback2_prepare(struct snd_es18xx *chip,
605	struct snd_pcm_substream *substream)
606	{
607	struct snd_pcm_runtime *runtime = substream->runtime;
608	unsigned int size = snd_pcm_lib_buffer_bytes(substream);
609	unsigned int count = snd_pcm_lib_period_bytes(substream);
610
611	snd_es18xx_reset_fifo(chip);
612
613	/* Set stereo/mono */
614	snd_es18xx_bits(chip, reg: 0xA8, mask: 0x03, val: runtime->channels == 1 ? 0x02 : 0x01);
615
616	snd_es18xx_rate_set(chip, substream, DAC1);
617
618	/* Transfer Count Reload */
619	count = 0x10000 - count;
620	snd_es18xx_write(chip, reg: 0xA4, data: count & 0xff);
621	snd_es18xx_write(chip, reg: 0xA5, data: count >> 8);
622
623	/* Set format */
624	snd_es18xx_write(chip, reg: 0xB6,
625	data: snd_pcm_format_unsigned(format: runtime->format) ? 0x80 : 0x00);
626	snd_es18xx_write(chip, reg: 0xB7,
627	data: snd_pcm_format_unsigned(format: runtime->format) ? 0x51 : 0x71);
628	snd_es18xx_write(chip, reg: 0xB7, data: 0x90 |
629	(runtime->channels == 1 ? 0x40 : 0x08) |
630	(snd_pcm_format_width(format: runtime->format) == 16 ? 0x04 : 0x00) |
631	(snd_pcm_format_unsigned(format: runtime->format) ? 0x00 : 0x20));
632
633	/* Set DMA controller */
634	snd_dma_program(dma: chip->dma1, addr: runtime->dma_addr, size, DMA_MODE_WRITE | DMA_AUTOINIT);
635
636	return 0;
637	}
638
639	static int snd_es18xx_playback2_trigger(struct snd_es18xx *chip,
640	struct snd_pcm_substream *substream,
641	int cmd)
642	{
643	switch (cmd) {
644	case SNDRV_PCM_TRIGGER_START:
645	case SNDRV_PCM_TRIGGER_RESUME:
646	if (chip->active & DAC1)
647	return 0;
648	chip->active |= DAC1;
649	/* Start DMA */
650	snd_es18xx_write(chip, reg: 0xB8, data: 0x05);
651	#ifdef AVOID_POPS
652	/* Avoid pops */
653	mdelay(100);
654	/* Enable Audio 1 */
655	snd_es18xx_dsp_command(chip, 0xD1);
656	#endif
657	break;
658	case SNDRV_PCM_TRIGGER_STOP:
659	case SNDRV_PCM_TRIGGER_SUSPEND:
660	if (!(chip->active & DAC1))
661	return 0;
662	chip->active &= ~DAC1;
663	/* Stop DMA */
664	snd_es18xx_write(chip, reg: 0xB8, data: 0x00);
665	#ifdef AVOID_POPS
666	/* Avoid pops */
667	mdelay(25);
668	/* Disable Audio 1 */
669	snd_es18xx_dsp_command(chip, 0xD3);
670	#endif
671	break;
672	default:
673	return -EINVAL;
674	}
675
676	return 0;
677	}
678
679	static int snd_es18xx_playback_prepare(struct snd_pcm_substream *substream)
680	{
681	struct snd_es18xx *chip = snd_pcm_substream_chip(substream);
682	if (substream->number == 0 && (chip->caps & ES18XX_PCM2))
683	return snd_es18xx_playback1_prepare(chip, substream);
684	else
685	return snd_es18xx_playback2_prepare(chip, substream);
686	}
687
688	static int snd_es18xx_playback_trigger(struct snd_pcm_substream *substream,
689	int cmd)
690	{
691	struct snd_es18xx *chip = snd_pcm_substream_chip(substream);
692	if (substream->number == 0 && (chip->caps & ES18XX_PCM2))
693	return snd_es18xx_playback1_trigger(chip, substream, cmd);
694	else
695	return snd_es18xx_playback2_trigger(chip, substream, cmd);
696	}
697
698	static irqreturn_t snd_es18xx_interrupt(int irq, void *dev_id)
699	{
700	struct snd_card *card = dev_id;
701	struct snd_es18xx *chip = card->private_data;
702	unsigned char status;
703
704	if (chip->caps & ES18XX_CONTROL) {
705	/* Read Interrupt status */
706	status = inb(port: chip->ctrl_port + 6);
707	} else {
708	/* Read Interrupt status */
709	status = snd_es18xx_mixer_read(chip, reg: 0x7f) >> 4;
710	}
711	#if 0
712	else {
713	status = 0;
714	if (inb(chip->port + 0x0C) & 0x01)
715	status |= AUDIO1_IRQ;
716	if (snd_es18xx_mixer_read(chip, 0x7A) & 0x80)
717	status |= AUDIO2_IRQ;
718	if ((chip->caps & ES18XX_HWV) &&
719	snd_es18xx_mixer_read(chip, 0x64) & 0x10)
720	status |= HWV_IRQ;
721	}
722	#endif
723
724	/* Audio 1 & Audio 2 */
725	if (status & AUDIO2_IRQ) {
726	if (chip->active & DAC2)
727	snd_pcm_period_elapsed(substream: chip->playback_a_substream);
728	/* ack interrupt */
729	snd_es18xx_mixer_bits(chip, reg: 0x7A, mask: 0x80, val: 0x00);
730	}
731	if (status & AUDIO1_IRQ) {
732	/* ok.. capture is active */
733	if (chip->active & ADC1)
734	snd_pcm_period_elapsed(substream: chip->capture_a_substream);
735	/* ok.. playback2 is active */
736	else if (chip->active & DAC1)
737	snd_pcm_period_elapsed(substream: chip->playback_b_substream);
738	/* ack interrupt */
739	inb(port: chip->port + 0x0E);
740	}
741
742	/* MPU */
743	if ((status & MPU_IRQ) && chip->rmidi)
744	snd_mpu401_uart_interrupt(irq, dev_id: chip->rmidi->private_data);
745
746	/* Hardware volume */
747	if (status & HWV_IRQ) {
748	int split = 0;
749	if (chip->caps & ES18XX_HWV) {
750	split = snd_es18xx_mixer_read(chip, reg: 0x64) & 0x80;
751	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
752	id: &chip->hw_switch->id);
753	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
754	id: &chip->hw_volume->id);
755	}
756	if (!split) {
757	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
758	id: &chip->master_switch->id);
759	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
760	id: &chip->master_volume->id);
761	}
762	/* ack interrupt */
763	snd_es18xx_mixer_write(chip, reg: 0x66, data: 0x00);
764	}
765	return IRQ_HANDLED;
766	}
767
768	static snd_pcm_uframes_t snd_es18xx_playback_pointer(struct snd_pcm_substream *substream)
769	{
770	struct snd_es18xx *chip = snd_pcm_substream_chip(substream);
771	unsigned int size = snd_pcm_lib_buffer_bytes(substream);
772	int pos;
773
774	if (substream->number == 0 && (chip->caps & ES18XX_PCM2)) {
775	if (!(chip->active & DAC2))
776	return 0;
777	pos = snd_dma_pointer(dma: chip->dma2, size);
778	return pos >> chip->dma2_shift;
779	} else {
780	if (!(chip->active & DAC1))
781	return 0;
782	pos = snd_dma_pointer(dma: chip->dma1, size);
783	return pos >> chip->dma1_shift;
784	}
785	}
786
787	static snd_pcm_uframes_t snd_es18xx_capture_pointer(struct snd_pcm_substream *substream)
788	{
789	struct snd_es18xx *chip = snd_pcm_substream_chip(substream);
790	unsigned int size = snd_pcm_lib_buffer_bytes(substream);
791	int pos;
792
793	if (!(chip->active & ADC1))
794	return 0;
795	pos = snd_dma_pointer(dma: chip->dma1, size);
796	return pos >> chip->dma1_shift;
797	}
798
799	static const struct snd_pcm_hardware snd_es18xx_playback =
800	{
801	.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
802	SNDRV_PCM_INFO_RESUME |
803	SNDRV_PCM_INFO_MMAP_VALID),
804	.formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S8 |
805	SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE),
806	.rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
807	.rate_min = 4000,
808	.rate_max = 48000,
809	.channels_min = 1,
810	.channels_max = 2,
811	.buffer_bytes_max = 65536,
812	.period_bytes_min = 64,
813	.period_bytes_max = 65536,
814	.periods_min = 1,
815	.periods_max = 1024,
816	.fifo_size = 0,
817	};
818
819	static const struct snd_pcm_hardware snd_es18xx_capture =
820	{
821	.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
822	SNDRV_PCM_INFO_RESUME |
823	SNDRV_PCM_INFO_MMAP_VALID),
824	.formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S8 |
825	SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE),
826	.rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
827	.rate_min = 4000,
828	.rate_max = 48000,
829	.channels_min = 1,
830	.channels_max = 2,
831	.buffer_bytes_max = 65536,
832	.period_bytes_min = 64,
833	.period_bytes_max = 65536,
834	.periods_min = 1,
835	.periods_max = 1024,
836	.fifo_size = 0,
837	};
838
839	static int snd_es18xx_playback_open(struct snd_pcm_substream *substream)
840	{
841	struct snd_pcm_runtime *runtime = substream->runtime;
842	struct snd_es18xx *chip = snd_pcm_substream_chip(substream);
843
844	if (substream->number == 0 && (chip->caps & ES18XX_PCM2)) {
845	if ((chip->caps & ES18XX_DUPLEX_MONO) &&
846	chip->capture_a_substream &&
847	chip->capture_a_substream->runtime->channels != 1)
848	return -EAGAIN;
849	chip->playback_a_substream = substream;
850	} else if (substream->number <= 1) {
851	if (chip->capture_a_substream)
852	return -EAGAIN;
853	chip->playback_b_substream = substream;
854	} else {
855	snd_BUG();
856	return -EINVAL;
857	}
858	substream->runtime->hw = snd_es18xx_playback;
859	snd_pcm_hw_constraint_ratnums(runtime, cond: 0, SNDRV_PCM_HW_PARAM_RATE,
860	r: (chip->caps & ES18XX_NEW_RATE) ? &new_hw_constraints_clocks : &old_hw_constraints_clocks);
861	return 0;
862	}
863
864	static int snd_es18xx_capture_open(struct snd_pcm_substream *substream)
865	{
866	struct snd_pcm_runtime *runtime = substream->runtime;
867	struct snd_es18xx *chip = snd_pcm_substream_chip(substream);
868
869	if (chip->playback_b_substream)
870	return -EAGAIN;
871	if ((chip->caps & ES18XX_DUPLEX_MONO) &&
872	chip->playback_a_substream &&
873	chip->playback_a_substream->runtime->channels != 1)
874	return -EAGAIN;
875	chip->capture_a_substream = substream;
876	substream->runtime->hw = snd_es18xx_capture;
877	snd_pcm_hw_constraint_ratnums(runtime, cond: 0, SNDRV_PCM_HW_PARAM_RATE,
878	r: (chip->caps & ES18XX_NEW_RATE) ? &new_hw_constraints_clocks : &old_hw_constraints_clocks);
879	return 0;
880	}
881
882	static int snd_es18xx_playback_close(struct snd_pcm_substream *substream)
883	{
884	struct snd_es18xx *chip = snd_pcm_substream_chip(substream);
885
886	if (substream->number == 0 && (chip->caps & ES18XX_PCM2))
887	chip->playback_a_substream = NULL;
888	else
889	chip->playback_b_substream = NULL;
890
891	return 0;
892	}
893
894	static int snd_es18xx_capture_close(struct snd_pcm_substream *substream)
895	{
896	struct snd_es18xx *chip = snd_pcm_substream_chip(substream);
897
898	chip->capture_a_substream = NULL;
899	return 0;
900	}
901
902	/*
903	* MIXER part
904	*/
905
906	/* Record source mux routines:
907	* Depending on the chipset this mux switches between 4, 5, or 8 possible inputs.
908	* bit table for the 4/5 source mux:
909	* reg 1C:
910	* b2 b1 b0 muxSource
911	* x 0 x microphone
912	* 0 1 x CD
913	* 1 1 0 line
914	* 1 1 1 mixer
915	* if it's "mixer" and it's a 5 source mux chipset then reg 7A bit 3 determines
916	* either the play mixer or the capture mixer.
917	*
918	* "map4Source" translates from source number to reg bit pattern
919	* "invMap4Source" translates from reg bit pattern to source number
920	*/
921
922	static int snd_es18xx_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
923	{
924	static const char * const texts5Source[5] = {
925	"Mic", "CD", "Line", "Master", "Mix"
926	};
927	static const char * const texts8Source[8] = {
928	"Mic", "Mic Master", "CD", "AOUT",
929	"Mic1", "Mix", "Line", "Master"
930	};
931	struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol);
932
933	switch (chip->version) {
934	case 0x1868:
935	case 0x1878:
936	return snd_ctl_enum_info(info: uinfo, channels: 1, items: 4, names: texts5Source);
937	case 0x1887:
938	case 0x1888:
939	return snd_ctl_enum_info(info: uinfo, channels: 1, items: 5, names: texts5Source);
940	case 0x1869: /* DS somewhat contradictory for 1869: could be 5 or 8 */
941	case 0x1879:
942	return snd_ctl_enum_info(info: uinfo, channels: 1, items: 8, names: texts8Source);
943	default:
944	return -EINVAL;
945	}
946	}
947
948	static int snd_es18xx_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
949	{
950	static const unsigned char invMap4Source[8] = {0, 0, 1, 1, 0, 0, 2, 3};
951	struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol);
952	int muxSource = snd_es18xx_mixer_read(chip, reg: 0x1c) & 0x07;
953	if (!(chip->version == 0x1869 || chip->version == 0x1879)) {
954	muxSource = invMap4Source[muxSource];
955	if (muxSource==3 &&
956	(chip->version == 0x1887 || chip->version == 0x1888) &&
957	(snd_es18xx_mixer_read(chip, reg: 0x7a) & 0x08)
958	)
959	muxSource = 4;
960	}
961	ucontrol->value.enumerated.item[0] = muxSource;
962	return 0;
963	}
964
965	static int snd_es18xx_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
966	{
967	static const unsigned char map4Source[4] = {0, 2, 6, 7};
968	struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol);
969	unsigned char val = ucontrol->value.enumerated.item[0];
970	unsigned char retVal = 0;
971
972	switch (chip->version) {
973	/* 5 source chips */
974	case 0x1887:
975	case 0x1888:
976	if (val > 4)
977	return -EINVAL;
978	if (val == 4) {
979	retVal = snd_es18xx_mixer_bits(chip, reg: 0x7a, mask: 0x08, val: 0x08) != 0x08;
980	val = 3;
981	} else
982	retVal = snd_es18xx_mixer_bits(chip, reg: 0x7a, mask: 0x08, val: 0x00) != 0x00;
983	fallthrough;
984	/* 4 source chips */
985	case 0x1868:
986	case 0x1878:
987	if (val > 3)
988	return -EINVAL;
989	val = map4Source[val];
990	break;
991	/* 8 source chips */
992	case 0x1869:
993	case 0x1879:
994	if (val > 7)
995	return -EINVAL;
996	break;
997	default:
998	return -EINVAL;
999	}
1000	return (snd_es18xx_mixer_bits(chip, reg: 0x1c, mask: 0x07, val) != val) || retVal;
1001	}
1002
1003	#define snd_es18xx_info_spatializer_enable snd_ctl_boolean_mono_info
1004
1005	static int snd_es18xx_get_spatializer_enable(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1006	{
1007	struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol);
1008	unsigned char val = snd_es18xx_mixer_read(chip, reg: 0x50);
1009	ucontrol->value.integer.value[0] = !!(val & 8);
1010	return 0;
1011	}
1012
1013	static int snd_es18xx_put_spatializer_enable(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1014	{
1015	struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol);
1016	unsigned char oval, nval;
1017	int change;
1018	nval = ucontrol->value.integer.value[0] ? 0x0c : 0x04;
1019	oval = snd_es18xx_mixer_read(chip, reg: 0x50) & 0x0c;
1020	change = nval != oval;
1021	if (change) {
1022	snd_es18xx_mixer_write(chip, reg: 0x50, data: nval & ~0x04);
1023	snd_es18xx_mixer_write(chip, reg: 0x50, data: nval);
1024	}
1025	return change;
1026	}
1027
1028	static int snd_es18xx_info_hw_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1029	{
1030	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1031	uinfo->count = 2;
1032	uinfo->value.integer.min = 0;
1033	uinfo->value.integer.max = 63;
1034	return 0;
1035	}
1036
1037	static int snd_es18xx_get_hw_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1038	{
1039	struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol);
1040	ucontrol->value.integer.value[0] = snd_es18xx_mixer_read(chip, reg: 0x61) & 0x3f;
1041	ucontrol->value.integer.value[1] = snd_es18xx_mixer_read(chip, reg: 0x63) & 0x3f;
1042	return 0;
1043	}
1044
1045	#define snd_es18xx_info_hw_switch snd_ctl_boolean_stereo_info
1046
1047	static int snd_es18xx_get_hw_switch(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1048	{
1049	struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol);
1050	ucontrol->value.integer.value[0] = !(snd_es18xx_mixer_read(chip, reg: 0x61) & 0x40);
1051	ucontrol->value.integer.value[1] = !(snd_es18xx_mixer_read(chip, reg: 0x63) & 0x40);
1052	return 0;
1053	}
1054
1055	static void snd_es18xx_hwv_free(struct snd_kcontrol *kcontrol)
1056	{
1057	struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol);
1058	chip->master_volume = NULL;
1059	chip->master_switch = NULL;
1060	chip->hw_volume = NULL;
1061	chip->hw_switch = NULL;
1062	}
1063
1064	static int snd_es18xx_reg_bits(struct snd_es18xx *chip, unsigned char reg,
1065	unsigned char mask, unsigned char val)
1066	{
1067	if (reg < 0xa0)
1068	return snd_es18xx_mixer_bits(chip, reg, mask, val);
1069	else
1070	return snd_es18xx_bits(chip, reg, mask, val);
1071	}
1072
1073	static int snd_es18xx_reg_read(struct snd_es18xx *chip, unsigned char reg)
1074	{
1075	if (reg < 0xa0)
1076	return snd_es18xx_mixer_read(chip, reg);
1077	else
1078	return snd_es18xx_read(chip, reg);
1079	}
1080
1081	#define ES18XX_SINGLE(xname, xindex, reg, shift, mask, flags) \
1082	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1083	.info = snd_es18xx_info_single, \
1084	.get = snd_es18xx_get_single, .put = snd_es18xx_put_single, \
1085	.private_value = reg | (shift << 8) | (mask << 16) | (flags << 24) }
1086
1087	#define ES18XX_FL_INVERT (1 << 0)
1088	#define ES18XX_FL_PMPORT (1 << 1)
1089
1090	static int snd_es18xx_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1091	{
1092	int mask = (kcontrol->private_value >> 16) & 0xff;
1093
1094	uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1095	uinfo->count = 1;
1096	uinfo->value.integer.min = 0;
1097	uinfo->value.integer.max = mask;
1098	return 0;
1099	}
1100
1101	static int snd_es18xx_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1102	{
1103	struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol);
1104	int reg = kcontrol->private_value & 0xff;
1105	int shift = (kcontrol->private_value >> 8) & 0xff;
1106	int mask = (kcontrol->private_value >> 16) & 0xff;
1107	int invert = (kcontrol->private_value >> 24) & ES18XX_FL_INVERT;
1108	int pm_port = (kcontrol->private_value >> 24) & ES18XX_FL_PMPORT;
1109	int val;
1110
1111	if (pm_port)
1112	val = inb(port: chip->port + ES18XX_PM);
1113	else
1114	val = snd_es18xx_reg_read(chip, reg);
1115	ucontrol->value.integer.value[0] = (val >> shift) & mask;
1116	if (invert)
1117	ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1118	return 0;
1119	}
1120
1121	static int snd_es18xx_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1122	{
1123	struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol);
1124	int reg = kcontrol->private_value & 0xff;
1125	int shift = (kcontrol->private_value >> 8) & 0xff;
1126	int mask = (kcontrol->private_value >> 16) & 0xff;
1127	int invert = (kcontrol->private_value >> 24) & ES18XX_FL_INVERT;
1128	int pm_port = (kcontrol->private_value >> 24) & ES18XX_FL_PMPORT;
1129	unsigned char val;
1130
1131	val = (ucontrol->value.integer.value[0] & mask);
1132	if (invert)
1133	val = mask - val;
1134	mask <<= shift;
1135	val <<= shift;
1136	if (pm_port) {
1137	unsigned char cur = inb(port: chip->port + ES18XX_PM);
1138
1139	if ((cur & mask) == val)
1140	return 0;
1141	outb(value: (cur & ~mask) | val, port: chip->port + ES18XX_PM);
1142	return 1;
1143	}
1144
1145	return snd_es18xx_reg_bits(chip, reg, mask, val) != val;
1146	}
1147
1148	#define ES18XX_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
1149	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1150	.info = snd_es18xx_info_double, \
1151	.get = snd_es18xx_get_double, .put = snd_es18xx_put_double, \
1152	.private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
1153
1154	static int snd_es18xx_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1155	{
1156	int mask = (kcontrol->private_value >> 24) & 0xff;
1157
1158	uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1159	uinfo->count = 2;
1160	uinfo->value.integer.min = 0;
1161	uinfo->value.integer.max = mask;
1162	return 0;
1163	}
1164
1165	static int snd_es18xx_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1166	{
1167	struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol);
1168	int left_reg = kcontrol->private_value & 0xff;
1169	int right_reg = (kcontrol->private_value >> 8) & 0xff;
1170	int shift_left = (kcontrol->private_value >> 16) & 0x07;
1171	int shift_right = (kcontrol->private_value >> 19) & 0x07;
1172	int mask = (kcontrol->private_value >> 24) & 0xff;
1173	int invert = (kcontrol->private_value >> 22) & 1;
1174	unsigned char left, right;
1175
1176	left = snd_es18xx_reg_read(chip, reg: left_reg);
1177	if (left_reg != right_reg)
1178	right = snd_es18xx_reg_read(chip, reg: right_reg);
1179	else
1180	right = left;
1181	ucontrol->value.integer.value[0] = (left >> shift_left) & mask;
1182	ucontrol->value.integer.value[1] = (right >> shift_right) & mask;
1183	if (invert) {
1184	ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1185	ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
1186	}
1187	return 0;
1188	}
1189
1190	static int snd_es18xx_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1191	{
1192	struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol);
1193	int left_reg = kcontrol->private_value & 0xff;
1194	int right_reg = (kcontrol->private_value >> 8) & 0xff;
1195	int shift_left = (kcontrol->private_value >> 16) & 0x07;
1196	int shift_right = (kcontrol->private_value >> 19) & 0x07;
1197	int mask = (kcontrol->private_value >> 24) & 0xff;
1198	int invert = (kcontrol->private_value >> 22) & 1;
1199	int change;
1200	unsigned char val1, val2, mask1, mask2;
1201
1202	val1 = ucontrol->value.integer.value[0] & mask;
1203	val2 = ucontrol->value.integer.value[1] & mask;
1204	if (invert) {
1205	val1 = mask - val1;
1206	val2 = mask - val2;
1207	}
1208	val1 <<= shift_left;
1209	val2 <<= shift_right;
1210	mask1 = mask << shift_left;
1211	mask2 = mask << shift_right;
1212	if (left_reg != right_reg) {
1213	change = 0;
1214	if (snd_es18xx_reg_bits(chip, reg: left_reg, mask: mask1, val: val1) != val1)
1215	change = 1;
1216	if (snd_es18xx_reg_bits(chip, reg: right_reg, mask: mask2, val: val2) != val2)
1217	change = 1;
1218	} else {
1219	change = (snd_es18xx_reg_bits(chip, reg: left_reg, mask: mask1 | mask2,
1220	val: val1 | val2) != (val1 | val2));
1221	}
1222	return change;
1223	}
1224
1225	/* Mixer controls
1226	* These arrays contain setup data for mixer controls.
1227	*
1228	* The controls that are universal to all chipsets are fully initialized
1229	* here.
1230	*/
1231	static const struct snd_kcontrol_new snd_es18xx_base_controls[] = {
1232	ES18XX_DOUBLE("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0),
1233	ES18XX_DOUBLE("Master Playback Switch", 0, 0x60, 0x62, 6, 6, 1, 1),
1234	ES18XX_DOUBLE("Line Playback Volume", 0, 0x3e, 0x3e, 4, 0, 15, 0),
1235	ES18XX_DOUBLE("CD Playback Volume", 0, 0x38, 0x38, 4, 0, 15, 0),
1236	ES18XX_DOUBLE("FM Playback Volume", 0, 0x36, 0x36, 4, 0, 15, 0),
1237	ES18XX_DOUBLE("Mic Playback Volume", 0, 0x1a, 0x1a, 4, 0, 15, 0),
1238	ES18XX_DOUBLE("Aux Playback Volume", 0, 0x3a, 0x3a, 4, 0, 15, 0),
1239	ES18XX_SINGLE("Record Monitor", 0, 0xa8, 3, 1, 0),
1240	ES18XX_DOUBLE("Capture Volume", 0, 0xb4, 0xb4, 4, 0, 15, 0),
1241	{
1242	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1243	.name = "Capture Source",
1244	.info = snd_es18xx_info_mux,
1245	.get = snd_es18xx_get_mux,
1246	.put = snd_es18xx_put_mux,
1247	}
1248	};
1249
1250	static const struct snd_kcontrol_new snd_es18xx_recmix_controls[] = {
1251	ES18XX_DOUBLE("PCM Capture Volume", 0, 0x69, 0x69, 4, 0, 15, 0),
1252	ES18XX_DOUBLE("Mic Capture Volume", 0, 0x68, 0x68, 4, 0, 15, 0),
1253	ES18XX_DOUBLE("Line Capture Volume", 0, 0x6e, 0x6e, 4, 0, 15, 0),
1254	ES18XX_DOUBLE("FM Capture Volume", 0, 0x6b, 0x6b, 4, 0, 15, 0),
1255	ES18XX_DOUBLE("CD Capture Volume", 0, 0x6a, 0x6a, 4, 0, 15, 0),
1256	ES18XX_DOUBLE("Aux Capture Volume", 0, 0x6c, 0x6c, 4, 0, 15, 0)
1257	};
1258
1259	/*
1260	* The chipset specific mixer controls
1261	*/
1262	static const struct snd_kcontrol_new snd_es18xx_opt_speaker =
1263	ES18XX_SINGLE("Beep Playback Volume", 0, 0x3c, 0, 7, 0);
1264
1265	static const struct snd_kcontrol_new snd_es18xx_opt_1869[] = {
1266	ES18XX_SINGLE("Capture Switch", 0, 0x1c, 4, 1, ES18XX_FL_INVERT),
1267	ES18XX_SINGLE("Video Playback Switch", 0, 0x7f, 0, 1, 0),
1268	ES18XX_DOUBLE("Mono Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1269	ES18XX_DOUBLE("Mono Capture Volume", 0, 0x6f, 0x6f, 4, 0, 15, 0)
1270	};
1271
1272	static const struct snd_kcontrol_new snd_es18xx_opt_1878 =
1273	ES18XX_DOUBLE("Video Playback Volume", 0, 0x68, 0x68, 4, 0, 15, 0);
1274
1275	static const struct snd_kcontrol_new snd_es18xx_opt_1879[] = {
1276	ES18XX_SINGLE("Video Playback Switch", 0, 0x71, 6, 1, 0),
1277	ES18XX_DOUBLE("Video Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1278	ES18XX_DOUBLE("Video Capture Volume", 0, 0x6f, 0x6f, 4, 0, 15, 0)
1279	};
1280
1281	static const struct snd_kcontrol_new snd_es18xx_pcm1_controls[] = {
1282	ES18XX_DOUBLE("PCM Playback Volume", 0, 0x14, 0x14, 4, 0, 15, 0),
1283	};
1284
1285	static const struct snd_kcontrol_new snd_es18xx_pcm2_controls[] = {
1286	ES18XX_DOUBLE("PCM Playback Volume", 0, 0x7c, 0x7c, 4, 0, 15, 0),
1287	ES18XX_DOUBLE("PCM Playback Volume", 1, 0x14, 0x14, 4, 0, 15, 0)
1288	};
1289
1290	static const struct snd_kcontrol_new snd_es18xx_spatializer_controls[] = {
1291	ES18XX_SINGLE("3D Control - Level", 0, 0x52, 0, 63, 0),
1292	{
1293	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1294	.name = "3D Control - Switch",
1295	.info = snd_es18xx_info_spatializer_enable,
1296	.get = snd_es18xx_get_spatializer_enable,
1297	.put = snd_es18xx_put_spatializer_enable,
1298	}
1299	};
1300
1301	static const struct snd_kcontrol_new snd_es18xx_micpre1_control =
1302	ES18XX_SINGLE("Mic Boost (+26dB)", 0, 0xa9, 2, 1, 0);
1303
1304	static const struct snd_kcontrol_new snd_es18xx_micpre2_control =
1305	ES18XX_SINGLE("Mic Boost (+26dB)", 0, 0x7d, 3, 1, 0);
1306
1307	static const struct snd_kcontrol_new snd_es18xx_hw_volume_controls[] = {
1308	{
1309	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1310	.name = "Hardware Master Playback Volume",
1311	.access = SNDRV_CTL_ELEM_ACCESS_READ,
1312	.info = snd_es18xx_info_hw_volume,
1313	.get = snd_es18xx_get_hw_volume,
1314	},
1315	{
1316	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1317	.name = "Hardware Master Playback Switch",
1318	.access = SNDRV_CTL_ELEM_ACCESS_READ,
1319	.info = snd_es18xx_info_hw_switch,
1320	.get = snd_es18xx_get_hw_switch,
1321	},
1322	ES18XX_SINGLE("Hardware Master Volume Split", 0, 0x64, 7, 1, 0),
1323	};
1324
1325	static const struct snd_kcontrol_new snd_es18xx_opt_gpo_2bit[] = {
1326	ES18XX_SINGLE("GPO0 Switch", 0, ES18XX_PM, 0, 1, ES18XX_FL_PMPORT),
1327	ES18XX_SINGLE("GPO1 Switch", 0, ES18XX_PM, 1, 1, ES18XX_FL_PMPORT),
1328	};
1329
1330	static int snd_es18xx_config_read(struct snd_es18xx *chip, unsigned char reg)
1331	{
1332	outb(value: reg, port: chip->ctrl_port);
1333	return inb(port: chip->ctrl_port + 1);
1334	}
1335
1336	static void snd_es18xx_config_write(struct snd_es18xx *chip,
1337	unsigned char reg, unsigned char data)
1338	{
1339	/* No need for spinlocks, this function is used only in
1340	otherwise protected init code */
1341	outb(value: reg, port: chip->ctrl_port);
1342	outb(value: data, port: chip->ctrl_port + 1);
1343	#ifdef REG_DEBUG
1344	dev_dbg(chip->card->dev, "Config reg %02x set to %02x\n", reg, data);
1345	#endif
1346	}
1347
1348	static int snd_es18xx_initialize(struct snd_es18xx *chip,
1349	unsigned long mpu_port,
1350	unsigned long fm_port)
1351	{
1352	int mask = 0;
1353
1354	/* enable extended mode */
1355	snd_es18xx_dsp_command(chip, val: 0xC6);
1356	/* Reset mixer registers */
1357	snd_es18xx_mixer_write(chip, reg: 0x00, data: 0x00);
1358
1359	/* Audio 1 DMA demand mode (4 bytes/request) */
1360	snd_es18xx_write(chip, reg: 0xB9, data: 2);
1361	if (chip->caps & ES18XX_CONTROL) {
1362	/* Hardware volume IRQ */
1363	snd_es18xx_config_write(chip, reg: 0x27, data: chip->irq);
1364	if (fm_port > 0 && fm_port != SNDRV_AUTO_PORT) {
1365	/* FM I/O */
1366	snd_es18xx_config_write(chip, reg: 0x62, data: fm_port >> 8);
1367	snd_es18xx_config_write(chip, reg: 0x63, data: fm_port & 0xff);
1368	}
1369	if (mpu_port > 0 && mpu_port != SNDRV_AUTO_PORT) {
1370	/* MPU-401 I/O */
1371	snd_es18xx_config_write(chip, reg: 0x64, data: mpu_port >> 8);
1372	snd_es18xx_config_write(chip, reg: 0x65, data: mpu_port & 0xff);
1373	/* MPU-401 IRQ */
1374	snd_es18xx_config_write(chip, reg: 0x28, data: chip->irq);
1375	}
1376	/* Audio1 IRQ */
1377	snd_es18xx_config_write(chip, reg: 0x70, data: chip->irq);
1378	/* Audio2 IRQ */
1379	snd_es18xx_config_write(chip, reg: 0x72, data: chip->irq);
1380	/* Audio1 DMA */
1381	snd_es18xx_config_write(chip, reg: 0x74, data: chip->dma1);
1382	/* Audio2 DMA */
1383	snd_es18xx_config_write(chip, reg: 0x75, data: chip->dma2);
1384
1385	/* Enable Audio 1 IRQ */
1386	snd_es18xx_write(chip, reg: 0xB1, data: 0x50);
1387	/* Enable Audio 2 IRQ */
1388	snd_es18xx_mixer_write(chip, reg: 0x7A, data: 0x40);
1389	/* Enable Audio 1 DMA */
1390	snd_es18xx_write(chip, reg: 0xB2, data: 0x50);
1391	/* Enable MPU and hardware volume interrupt */
1392	snd_es18xx_mixer_write(chip, reg: 0x64, data: 0x42);
1393	/* Enable ESS wavetable input */
1394	snd_es18xx_mixer_bits(chip, reg: 0x48, mask: 0x10, val: 0x10);
1395	}
1396	else {
1397	int irqmask, dma1mask, dma2mask;
1398	switch (chip->irq) {
1399	case 2:
1400	case 9:
1401	irqmask = 0;
1402	break;
1403	case 5:
1404	irqmask = 1;
1405	break;
1406	case 7:
1407	irqmask = 2;
1408	break;
1409	case 10:
1410	irqmask = 3;
1411	break;
1412	default:
1413	dev_err(chip->card->dev, "invalid irq %d\n", chip->irq);
1414	return -ENODEV;
1415	}
1416	switch (chip->dma1) {
1417	case 0:
1418	dma1mask = 1;
1419	break;
1420	case 1:
1421	dma1mask = 2;
1422	break;
1423	case 3:
1424	dma1mask = 3;
1425	break;
1426	default:
1427	dev_err(chip->card->dev, "invalid dma1 %d\n", chip->dma1);
1428	return -ENODEV;
1429	}
1430	switch (chip->dma2) {
1431	case 0:
1432	dma2mask = 0;
1433	break;
1434	case 1:
1435	dma2mask = 1;
1436	break;
1437	case 3:
1438	dma2mask = 2;
1439	break;
1440	case 5:
1441	dma2mask = 3;
1442	break;
1443	default:
1444	dev_err(chip->card->dev, "invalid dma2 %d\n", chip->dma2);
1445	return -ENODEV;
1446	}
1447
1448	/* Enable and set Audio 1 IRQ */
1449	snd_es18xx_write(chip, reg: 0xB1, data: 0x50 | (irqmask << 2));
1450	/* Enable and set Audio 1 DMA */
1451	snd_es18xx_write(chip, reg: 0xB2, data: 0x50 | (dma1mask << 2));
1452	/* Set Audio 2 DMA */
1453	snd_es18xx_mixer_bits(chip, reg: 0x7d, mask: 0x07, val: 0x04 | dma2mask);
1454	/* Enable Audio 2 IRQ and DMA
1455	Set capture mixer input */
1456	snd_es18xx_mixer_write(chip, reg: 0x7A, data: 0x68);
1457	/* Enable and set hardware volume interrupt */
1458	snd_es18xx_mixer_write(chip, reg: 0x64, data: 0x06);
1459	if (mpu_port > 0 && mpu_port != SNDRV_AUTO_PORT) {
1460	/* MPU401 share irq with audio
1461	Joystick enabled
1462	FM enabled */
1463	snd_es18xx_mixer_write(chip, reg: 0x40,
1464	data: 0x43 | (mpu_port & 0xf0) >> 1);
1465	}
1466	snd_es18xx_mixer_write(chip, reg: 0x7f, data: ((irqmask + 1) << 1) | 0x01);
1467	}
1468	if (chip->caps & ES18XX_NEW_RATE) {
1469	/* Change behaviour of register A1
1470	4x oversampling
1471	2nd channel DAC asynchronous */
1472	snd_es18xx_mixer_write(chip, reg: 0x71, data: 0x32);
1473	}
1474	if (!(chip->caps & ES18XX_PCM2)) {
1475	/* Enable DMA FIFO */
1476	snd_es18xx_write(chip, reg: 0xB7, data: 0x80);
1477	}
1478	if (chip->caps & ES18XX_SPATIALIZER) {
1479	/* Set spatializer parameters to recommended values */
1480	snd_es18xx_mixer_write(chip, reg: 0x54, data: 0x8f);
1481	snd_es18xx_mixer_write(chip, reg: 0x56, data: 0x95);
1482	snd_es18xx_mixer_write(chip, reg: 0x58, data: 0x94);
1483	snd_es18xx_mixer_write(chip, reg: 0x5a, data: 0x80);
1484	}
1485	/* Flip the "enable I2S" bits for those chipsets that need it */
1486	switch (chip->version) {
1487	case 0x1879:
1488	//Leaving I2S enabled on the 1879 screws up the PCM playback (rate effected somehow)
1489	//so a Switch control has been added to toggle this 0x71 bit on/off:
1490	//snd_es18xx_mixer_bits(chip, 0x71, 0x40, 0x40);
1491	/* Note: we fall through on purpose here. */
1492	case 0x1878:
1493	snd_es18xx_config_write(chip, reg: 0x29, data: snd_es18xx_config_read(chip, reg: 0x29) | 0x40);
1494	break;
1495	}
1496	/* Mute input source */
1497	if (chip->caps & ES18XX_MUTEREC)
1498	mask = 0x10;
1499	if (chip->caps & ES18XX_RECMIX)
1500	snd_es18xx_mixer_write(chip, reg: 0x1c, data: 0x05 | mask);
1501	else {
1502	snd_es18xx_mixer_write(chip, reg: 0x1c, data: 0x00 | mask);
1503	snd_es18xx_write(chip, reg: 0xb4, data: 0x00);
1504	}
1505	#ifndef AVOID_POPS
1506	/* Enable PCM output */
1507	snd_es18xx_dsp_command(chip, val: 0xD1);
1508	#endif
1509
1510	return 0;
1511	}
1512
1513	static int snd_es18xx_identify(struct snd_card *card, struct snd_es18xx *chip)
1514	{
1515	int hi,lo;
1516
1517	/* reset */
1518	if (snd_es18xx_reset(chip) < 0) {
1519	dev_err(card->dev, "reset at 0x%lx failed!!!\n", chip->port);
1520	return -ENODEV;
1521	}
1522
1523	snd_es18xx_dsp_command(chip, val: 0xe7);
1524	hi = snd_es18xx_dsp_get_byte(chip);
1525	if (hi < 0) {
1526	return hi;
1527	}
1528	lo = snd_es18xx_dsp_get_byte(chip);
1529	if ((lo & 0xf0) != 0x80) {
1530	return -ENODEV;
1531	}
1532	if (hi == 0x48) {
1533	chip->version = 0x488;
1534	return 0;
1535	}
1536	if (hi != 0x68) {
1537	return -ENODEV;
1538	}
1539	if ((lo & 0x0f) < 8) {
1540	chip->version = 0x688;
1541	return 0;
1542	}
1543
1544	outb(value: 0x40, port: chip->port + 0x04);
1545	udelay(usec: 10);
1546	hi = inb(port: chip->port + 0x05);
1547	udelay(usec: 10);
1548	lo = inb(port: chip->port + 0x05);
1549	if (hi != lo) {
1550	chip->version = hi << 8 | lo;
1551	chip->ctrl_port = inb(port: chip->port + 0x05) << 8;
1552	udelay(usec: 10);
1553	chip->ctrl_port += inb(port: chip->port + 0x05);
1554
1555	if (!devm_request_region(card->dev, chip->ctrl_port, 8,
1556	"ES18xx - CTRL")) {
1557	dev_err(card->dev, "unable go grab port 0x%lx\n", chip->ctrl_port);
1558	return -EBUSY;
1559	}
1560
1561	return 0;
1562	}
1563
1564	/* If has Hardware volume */
1565	if (snd_es18xx_mixer_writable(chip, reg: 0x64, mask: 0x04)) {
1566	/* If has Audio2 */
1567	if (snd_es18xx_mixer_writable(chip, reg: 0x70, mask: 0x7f)) {
1568	/* If has volume count */
1569	if (snd_es18xx_mixer_writable(chip, reg: 0x64, mask: 0x20)) {
1570	chip->version = 0x1887;
1571	} else {
1572	chip->version = 0x1888;
1573	}
1574	} else {
1575	chip->version = 0x1788;
1576	}
1577	}
1578	else
1579	chip->version = 0x1688;
1580	return 0;
1581	}
1582
1583	static int snd_es18xx_probe(struct snd_card *card,
1584	struct snd_es18xx *chip,
1585	unsigned long mpu_port,
1586	unsigned long fm_port)
1587	{
1588	if (snd_es18xx_identify(card, chip) < 0) {
1589	dev_err(card->dev, "[0x%lx] ESS chip not found\n", chip->port);
1590	return -ENODEV;
1591	}
1592
1593	switch (chip->version) {
1594	case 0x1868:
1595	chip->caps = ES18XX_DUPLEX_MONO | ES18XX_DUPLEX_SAME | ES18XX_CONTROL | ES18XX_GPO_2BIT;
1596	break;
1597	case 0x1869:
1598	chip->caps = ES18XX_PCM2 | ES18XX_SPATIALIZER | ES18XX_RECMIX | ES18XX_NEW_RATE | ES18XX_AUXB | ES18XX_MONO | ES18XX_MUTEREC | ES18XX_CONTROL | ES18XX_HWV | ES18XX_GPO_2BIT;
1599	break;
1600	case 0x1878:
1601	chip->caps = ES18XX_DUPLEX_MONO | ES18XX_DUPLEX_SAME | ES18XX_I2S | ES18XX_CONTROL;
1602	break;
1603	case 0x1879:
1604	chip->caps = ES18XX_PCM2 | ES18XX_SPATIALIZER | ES18XX_RECMIX | ES18XX_NEW_RATE | ES18XX_AUXB | ES18XX_I2S | ES18XX_CONTROL | ES18XX_HWV;
1605	break;
1606	case 0x1887:
1607	case 0x1888:
1608	chip->caps = ES18XX_PCM2 | ES18XX_RECMIX | ES18XX_AUXB | ES18XX_DUPLEX_SAME | ES18XX_GPO_2BIT;
1609	break;
1610	default:
1611	dev_err(card->dev, "[0x%lx] unsupported chip ES%x\n",
1612	chip->port, chip->version);
1613	return -ENODEV;
1614	}
1615
1616	dev_dbg(card->dev, "[0x%lx] ESS%x chip found\n", chip->port, chip->version);
1617
1618	if (chip->dma1 == chip->dma2)
1619	chip->caps &= ~(ES18XX_PCM2 | ES18XX_DUPLEX_SAME);
1620
1621	return snd_es18xx_initialize(chip, mpu_port, fm_port);
1622	}
1623
1624	static const struct snd_pcm_ops snd_es18xx_playback_ops = {
1625	.open = snd_es18xx_playback_open,
1626	.close = snd_es18xx_playback_close,
1627	.hw_params = snd_es18xx_playback_hw_params,
1628	.prepare = snd_es18xx_playback_prepare,
1629	.trigger = snd_es18xx_playback_trigger,
1630	.pointer = snd_es18xx_playback_pointer,
1631	};
1632
1633	static const struct snd_pcm_ops snd_es18xx_capture_ops = {
1634	.open = snd_es18xx_capture_open,
1635	.close = snd_es18xx_capture_close,
1636	.hw_params = snd_es18xx_capture_hw_params,
1637	.prepare = snd_es18xx_capture_prepare,
1638	.trigger = snd_es18xx_capture_trigger,
1639	.pointer = snd_es18xx_capture_pointer,
1640	};
1641
1642	static int snd_es18xx_pcm(struct snd_card *card, int device)
1643	{
1644	struct snd_es18xx *chip = card->private_data;
1645	struct snd_pcm *pcm;
1646	char str[16];
1647	int err;
1648
1649	sprintf(buf: str, fmt: "ES%x", chip->version);
1650	if (chip->caps & ES18XX_PCM2)
1651	err = snd_pcm_new(card, id: str, device, playback_count: 2, capture_count: 1, rpcm: &pcm);
1652	else
1653	err = snd_pcm_new(card, id: str, device, playback_count: 1, capture_count: 1, rpcm: &pcm);
1654	if (err < 0)
1655	return err;
1656
1657	snd_pcm_set_ops(pcm, direction: SNDRV_PCM_STREAM_PLAYBACK, ops: &snd_es18xx_playback_ops);
1658	snd_pcm_set_ops(pcm, direction: SNDRV_PCM_STREAM_CAPTURE, ops: &snd_es18xx_capture_ops);
1659
1660	/* global setup */
1661	pcm->private_data = chip;
1662	pcm->info_flags = 0;
1663	if (chip->caps & ES18XX_DUPLEX_SAME)
1664	pcm->info_flags |= SNDRV_PCM_INFO_JOINT_DUPLEX;
1665	if (! (chip->caps & ES18XX_PCM2))
1666	pcm->info_flags |= SNDRV_PCM_INFO_HALF_DUPLEX;
1667	sprintf(buf: pcm->name, fmt: "ESS AudioDrive ES%x", chip->version);
1668	chip->pcm = pcm;
1669
1670	snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV, data: card->dev,
1671	size: 64*1024,
1672	max: chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
1673	return 0;
1674	}
1675
1676	/* Power Management support functions */
1677	#ifdef CONFIG_PM
1678	static int snd_es18xx_suspend(struct snd_card *card, pm_message_t state)
1679	{
1680	struct snd_es18xx *chip = card->private_data;
1681
1682	snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1683
1684	/* power down */
1685	chip->pm_reg = (unsigned char)snd_es18xx_read(chip, ES18XX_PM);
1686	chip->pm_reg |= (ES18XX_PM_FM | ES18XX_PM_SUS);
1687	snd_es18xx_write(chip, ES18XX_PM, data: chip->pm_reg);
1688	snd_es18xx_write(chip, ES18XX_PM, data: chip->pm_reg ^= ES18XX_PM_SUS);
1689
1690	return 0;
1691	}
1692
1693	static int snd_es18xx_resume(struct snd_card *card)
1694	{
1695	struct snd_es18xx *chip = card->private_data;
1696
1697	/* restore PM register, we won't wake till (not 0x07) i/o activity though */
1698	snd_es18xx_write(chip, ES18XX_PM, data: chip->pm_reg ^= ES18XX_PM_FM);
1699
1700	snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1701	return 0;
1702	}
1703	#endif /* CONFIG_PM */
1704
1705	static int snd_es18xx_new_device(struct snd_card *card,
1706	unsigned long port,
1707	unsigned long mpu_port,
1708	unsigned long fm_port,
1709	int irq, int dma1, int dma2)
1710	{
1711	struct snd_es18xx *chip = card->private_data;
1712
1713	chip->card = card;
1714	spin_lock_init(&chip->reg_lock);
1715	spin_lock_init(&chip->mixer_lock);
1716	chip->port = port;
1717	chip->irq = -1;
1718	chip->dma1 = -1;
1719	chip->dma2 = -1;
1720	chip->audio2_vol = 0x00;
1721	chip->active = 0;
1722
1723	if (!devm_request_region(card->dev, port, 16, "ES18xx")) {
1724	dev_err(card->dev, "unable to grab ports 0x%lx-0x%lx\n", port, port + 16 - 1);
1725	return -EBUSY;
1726	}
1727
1728	if (devm_request_irq(dev: card->dev, irq, handler: snd_es18xx_interrupt, irqflags: 0, devname: "ES18xx",
1729	dev_id: (void *) card)) {
1730	dev_err(card->dev, "unable to grab IRQ %d\n", irq);
1731	return -EBUSY;
1732	}
1733	chip->irq = irq;
1734	card->sync_irq = chip->irq;
1735
1736	if (snd_devm_request_dma(dev: card->dev, dma: dma1, name: "ES18xx DMA 1")) {
1737	dev_err(card->dev, "unable to grab DMA1 %d\n", dma1);
1738	return -EBUSY;
1739	}
1740	chip->dma1 = dma1;
1741
1742	if (dma2 != dma1 &&
1743	snd_devm_request_dma(dev: card->dev, dma: dma2, name: "ES18xx DMA 2")) {
1744	dev_err(card->dev, "unable to grab DMA2 %d\n", dma2);
1745	return -EBUSY;
1746	}
1747	chip->dma2 = dma2;
1748
1749	if (snd_es18xx_probe(card, chip, mpu_port, fm_port) < 0)
1750	return -ENODEV;
1751	return 0;
1752	}
1753
1754	static int snd_es18xx_mixer(struct snd_card *card)
1755	{
1756	struct snd_es18xx *chip = card->private_data;
1757	int err;
1758	unsigned int idx;
1759
1760	strscpy(card->mixername, chip->pcm->name);
1761
1762	for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_base_controls); idx++) {
1763	struct snd_kcontrol *kctl;
1764	kctl = snd_ctl_new1(kcontrolnew: &snd_es18xx_base_controls[idx], private_data: chip);
1765	if (chip->caps & ES18XX_HWV) {
1766	switch (idx) {
1767	case 0:
1768	chip->master_volume = kctl;
1769	kctl->private_free = snd_es18xx_hwv_free;
1770	break;
1771	case 1:
1772	chip->master_switch = kctl;
1773	kctl->private_free = snd_es18xx_hwv_free;
1774	break;
1775	}
1776	}
1777	err = snd_ctl_add(card, kcontrol: kctl);
1778	if (err < 0)
1779	return err;
1780	}
1781	if (chip->caps & ES18XX_PCM2) {
1782	for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_pcm2_controls); idx++) {
1783	err = snd_ctl_add(card, kcontrol: snd_ctl_new1(kcontrolnew: &snd_es18xx_pcm2_controls[idx], private_data: chip));
1784	if (err < 0)
1785	return err;
1786	}
1787	} else {
1788	for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_pcm1_controls); idx++) {
1789	err = snd_ctl_add(card, kcontrol: snd_ctl_new1(kcontrolnew: &snd_es18xx_pcm1_controls[idx], private_data: chip));
1790	if (err < 0)
1791	return err;
1792	}
1793	}
1794
1795	if (chip->caps & ES18XX_RECMIX) {
1796	for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_recmix_controls); idx++) {
1797	err = snd_ctl_add(card, kcontrol: snd_ctl_new1(kcontrolnew: &snd_es18xx_recmix_controls[idx], private_data: chip));
1798	if (err < 0)
1799	return err;
1800	}
1801	}
1802	switch (chip->version) {
1803	default:
1804	err = snd_ctl_add(card, kcontrol: snd_ctl_new1(kcontrolnew: &snd_es18xx_micpre1_control, private_data: chip));
1805	if (err < 0)
1806	return err;
1807	break;
1808	case 0x1869:
1809	case 0x1879:
1810	err = snd_ctl_add(card, kcontrol: snd_ctl_new1(kcontrolnew: &snd_es18xx_micpre2_control, private_data: chip));
1811	if (err < 0)
1812	return err;
1813	break;
1814	}
1815	if (chip->caps & ES18XX_SPATIALIZER) {
1816	for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_spatializer_controls); idx++) {
1817	err = snd_ctl_add(card, kcontrol: snd_ctl_new1(kcontrolnew: &snd_es18xx_spatializer_controls[idx], private_data: chip));
1818	if (err < 0)
1819	return err;
1820	}
1821	}
1822	if (chip->caps & ES18XX_HWV) {
1823	for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_hw_volume_controls); idx++) {
1824	struct snd_kcontrol *kctl;
1825	kctl = snd_ctl_new1(kcontrolnew: &snd_es18xx_hw_volume_controls[idx], private_data: chip);
1826	if (idx == 0)
1827	chip->hw_volume = kctl;
1828	else
1829	chip->hw_switch = kctl;
1830	kctl->private_free = snd_es18xx_hwv_free;
1831	err = snd_ctl_add(card, kcontrol: kctl);
1832	if (err < 0)
1833	return err;
1834
1835	}
1836	}
1837	/* finish initializing other chipset specific controls
1838	*/
1839	if (chip->version != 0x1868) {
1840	err = snd_ctl_add(card, kcontrol: snd_ctl_new1(kcontrolnew: &snd_es18xx_opt_speaker,
1841	private_data: chip));
1842	if (err < 0)
1843	return err;
1844	}
1845	if (chip->version == 0x1869) {
1846	for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_opt_1869); idx++) {
1847	err = snd_ctl_add(card,
1848	kcontrol: snd_ctl_new1(kcontrolnew: &snd_es18xx_opt_1869[idx],
1849	private_data: chip));
1850	if (err < 0)
1851	return err;
1852	}
1853	} else if (chip->version == 0x1878) {
1854	err = snd_ctl_add(card, kcontrol: snd_ctl_new1(kcontrolnew: &snd_es18xx_opt_1878,
1855	private_data: chip));
1856	if (err < 0)
1857	return err;
1858	} else if (chip->version == 0x1879) {
1859	for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_opt_1879); idx++) {
1860	err = snd_ctl_add(card,
1861	kcontrol: snd_ctl_new1(kcontrolnew: &snd_es18xx_opt_1879[idx],
1862	private_data: chip));
1863	if (err < 0)
1864	return err;
1865	}
1866	}
1867	if (chip->caps & ES18XX_GPO_2BIT) {
1868	for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_opt_gpo_2bit); idx++) {
1869	err = snd_ctl_add(card,
1870	kcontrol: snd_ctl_new1(kcontrolnew: &snd_es18xx_opt_gpo_2bit[idx],
1871	private_data: chip));
1872	if (err < 0)
1873	return err;
1874	}
1875	}
1876	return 0;
1877	}
1878
1879
1880	/* Card level */
1881
1882	MODULE_AUTHOR("Christian Fischbach <fishbach@pool.informatik.rwth-aachen.de>, Abramo Bagnara <abramo@alsa-project.org>");
1883	MODULE_DESCRIPTION("ESS ES18xx AudioDrive");
1884	MODULE_LICENSE("GPL");
1885
1886	static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
1887	static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
1888	static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */
1889	#ifdef CONFIG_PNP
1890	static bool isapnp[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP;
1891	#endif
1892	static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* 0x220,0x240,0x260,0x280 */
1893	#ifndef CONFIG_PNP
1894	static long mpu_port[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = -1};
1895	#else
1896	static long mpu_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
1897	#endif
1898	static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
1899	static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* 5,7,9,10 */
1900	static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 0,1,3 */
1901	static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 0,1,3 */
1902
1903	module_param_array(index, int, NULL, 0444);
1904	MODULE_PARM_DESC(index, "Index value for ES18xx soundcard.");
1905	module_param_array(id, charp, NULL, 0444);
1906	MODULE_PARM_DESC(id, "ID string for ES18xx soundcard.");
1907	module_param_array(enable, bool, NULL, 0444);
1908	MODULE_PARM_DESC(enable, "Enable ES18xx soundcard.");
1909	#ifdef CONFIG_PNP
1910	module_param_array(isapnp, bool, NULL, 0444);
1911	MODULE_PARM_DESC(isapnp, "PnP detection for specified soundcard.");
1912	#endif
1913	module_param_hw_array(port, long, ioport, NULL, 0444);
1914	MODULE_PARM_DESC(port, "Port # for ES18xx driver.");
1915	module_param_hw_array(mpu_port, long, ioport, NULL, 0444);
1916	MODULE_PARM_DESC(mpu_port, "MPU-401 port # for ES18xx driver.");
1917	module_param_hw_array(fm_port, long, ioport, NULL, 0444);
1918	MODULE_PARM_DESC(fm_port, "FM port # for ES18xx driver.");
1919	module_param_hw_array(irq, int, irq, NULL, 0444);
1920	MODULE_PARM_DESC(irq, "IRQ # for ES18xx driver.");
1921	module_param_hw_array(dma1, int, dma, NULL, 0444);
1922	MODULE_PARM_DESC(dma1, "DMA 1 # for ES18xx driver.");
1923	module_param_hw_array(dma2, int, dma, NULL, 0444);
1924	MODULE_PARM_DESC(dma2, "DMA 2 # for ES18xx driver.");
1925
1926	#ifdef CONFIG_PNP
1927	static int isa_registered;
1928	static int pnp_registered;
1929	static int pnpc_registered;
1930
1931	static const struct pnp_device_id snd_audiodrive_pnpbiosids[] = {
1932	{ .id = "ESS1869" },
1933	{ .id = "ESS1879" },
1934	{ .id = "" } /* end */
1935	};
1936
1937	MODULE_DEVICE_TABLE(pnp, snd_audiodrive_pnpbiosids);
1938
1939	/* PnP main device initialization */
1940	static int snd_audiodrive_pnp_init_main(int dev, struct pnp_dev *pdev)
1941	{
1942	if (pnp_activate_dev(dev: pdev) < 0) {
1943	dev_err(&pdev->dev, "PnP configure failure (out of resources?)\n");
1944	return -EBUSY;
1945	}
1946	/* ok. hack using Vendor-Defined Card-Level registers */
1947	/* skip csn and logdev initialization - already done in isapnp_configure */
1948	if (pnp_device_is_isapnp(pdev)) {
1949	isapnp_cfg_begin(isapnp_card_number(pdev), isapnp_csn_number(pdev));
1950	isapnp_write_byte(idx: 0x27, val: pnp_irq(dev: pdev, bar: 0)); /* Hardware Volume IRQ Number */
1951	if (mpu_port[dev] != SNDRV_AUTO_PORT)
1952	isapnp_write_byte(idx: 0x28, val: pnp_irq(dev: pdev, bar: 0)); /* MPU-401 IRQ Number */
1953	isapnp_write_byte(idx: 0x72, val: pnp_irq(dev: pdev, bar: 0)); /* second IRQ */
1954	isapnp_cfg_end();
1955	}
1956	port[dev] = pnp_port_start(dev: pdev, bar: 0);
1957	fm_port[dev] = pnp_port_start(dev: pdev, bar: 1);
1958	mpu_port[dev] = pnp_port_start(dev: pdev, bar: 2);
1959	dma1[dev] = pnp_dma(dev: pdev, bar: 0);
1960	dma2[dev] = pnp_dma(dev: pdev, bar: 1);
1961	irq[dev] = pnp_irq(dev: pdev, bar: 0);
1962	dev_dbg(&pdev->dev,
1963	"PnP ES18xx: port=0x%lx, fm port=0x%lx, mpu port=0x%lx\n",
1964	port[dev], fm_port[dev], mpu_port[dev]);
1965	dev_dbg(&pdev->dev,
1966	"PnP ES18xx: dma1=%i, dma2=%i, irq=%i\n",
1967	dma1[dev], dma2[dev], irq[dev]);
1968	return 0;
1969	}
1970
1971	static int snd_audiodrive_pnp(int dev, struct snd_es18xx *chip,
1972	struct pnp_dev *pdev)
1973	{
1974	chip->dev = pdev;
1975	if (snd_audiodrive_pnp_init_main(dev, pdev: chip->dev) < 0)
1976	return -EBUSY;
1977	return 0;
1978	}
1979
1980	static const struct pnp_card_device_id snd_audiodrive_pnpids[] = {
1981	/* ESS 1868 (integrated on Compaq dual P-Pro motherboard and Genius 18PnP 3D) */
1982	{ .id = "ESS1868", .devs = { { "ESS1868" }, { "ESS0000" } } },
1983	/* ESS 1868 (integrated on Maxisound Cards) */
1984	{ .id = "ESS1868", .devs = { { "ESS8601" }, { "ESS8600" } } },
1985	/* ESS 1868 (integrated on Maxisound Cards) */
1986	{ .id = "ESS1868", .devs = { { "ESS8611" }, { "ESS8610" } } },
1987	/* ESS ES1869 Plug and Play AudioDrive */
1988	{ .id = "ESS0003", .devs = { { "ESS1869" }, { "ESS0006" } } },
1989	/* ESS 1869 */
1990	{ .id = "ESS1869", .devs = { { "ESS1869" }, { "ESS0006" } } },
1991	/* ESS 1878 */
1992	{ .id = "ESS1878", .devs = { { "ESS1878" }, { "ESS0004" } } },
1993	/* ESS 1879 */
1994	{ .id = "ESS1879", .devs = { { "ESS1879" }, { "ESS0009" } } },
1995	/* --- */
1996	{ .id = "" } /* end */
1997	};
1998
1999	MODULE_DEVICE_TABLE(pnp_card, snd_audiodrive_pnpids);
2000
2001	static int snd_audiodrive_pnpc(int dev, struct snd_es18xx *chip,
2002	struct pnp_card_link *card,
2003	const struct pnp_card_device_id *id)
2004	{
2005	chip->dev = pnp_request_card_device(clink: card, id: id->devs[0].id, NULL);
2006	if (chip->dev == NULL)
2007	return -EBUSY;
2008
2009	chip->devc = pnp_request_card_device(clink: card, id: id->devs[1].id, NULL);
2010	if (chip->devc == NULL)
2011	return -EBUSY;
2012
2013	/* Control port initialization */
2014	if (pnp_activate_dev(dev: chip->devc) < 0) {
2015	dev_err(chip->card->dev,
2016	"PnP control configure failure (out of resources?)\n");
2017	return -EAGAIN;
2018	}
2019	dev_dbg(chip->card->dev, "pnp: port=0x%llx\n",
2020	(unsigned long long)pnp_port_start(chip->devc, 0));
2021	if (snd_audiodrive_pnp_init_main(dev, pdev: chip->dev) < 0)
2022	return -EBUSY;
2023
2024	return 0;
2025	}
2026	#endif /* CONFIG_PNP */
2027
2028	#ifdef CONFIG_PNP
2029	#define is_isapnp_selected(dev) isapnp[dev]
2030	#else
2031	#define is_isapnp_selected(dev) 0
2032	#endif
2033
2034	static int snd_es18xx_card_new(struct device *pdev, int dev,
2035	struct snd_card **cardp)
2036	{
2037	return snd_devm_card_new(parent: pdev, idx: index[dev], xid: id[dev], THIS_MODULE,
2038	extra_size: sizeof(struct snd_es18xx), card_ret: cardp);
2039	}
2040
2041	static int snd_audiodrive_probe(struct snd_card *card, int dev)
2042	{
2043	struct snd_es18xx *chip = card->private_data;
2044	struct snd_opl3 *opl3;
2045	int err;
2046
2047	err = snd_es18xx_new_device(card,
2048	port: port[dev], mpu_port: mpu_port[dev], fm_port: fm_port[dev],
2049	irq: irq[dev], dma1: dma1[dev], dma2: dma2[dev]);
2050	if (err < 0)
2051	return err;
2052
2053	sprintf(buf: card->driver, fmt: "ES%x", chip->version);
2054
2055	sprintf(buf: card->shortname, fmt: "ESS AudioDrive ES%x", chip->version);
2056	if (dma1[dev] != dma2[dev])
2057	sprintf(buf: card->longname, fmt: "%s at 0x%lx, irq %d, dma1 %d, dma2 %d",
2058	card->shortname,
2059	chip->port,
2060	irq[dev], dma1[dev], dma2[dev]);
2061	else
2062	sprintf(buf: card->longname, fmt: "%s at 0x%lx, irq %d, dma %d",
2063	card->shortname,
2064	chip->port,
2065	irq[dev], dma1[dev]);
2066
2067	err = snd_es18xx_pcm(card, device: 0);
2068	if (err < 0)
2069	return err;
2070
2071	err = snd_es18xx_mixer(card);
2072	if (err < 0)
2073	return err;
2074
2075	if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) {
2076	if (snd_opl3_create(card, l_port: fm_port[dev], r_port: fm_port[dev] + 2,
2077	OPL3_HW_OPL3, integrated: 0, opl3: &opl3) < 0) {
2078	dev_warn(card->dev,
2079	"opl3 not detected at 0x%lx\n",
2080	fm_port[dev]);
2081	} else {
2082	err = snd_opl3_hwdep_new(opl3, device: 0, seq_device: 1, NULL);
2083	if (err < 0)
2084	return err;
2085	}
2086	}
2087
2088	if (mpu_port[dev] > 0 && mpu_port[dev] != SNDRV_AUTO_PORT) {
2089	err = snd_mpu401_uart_new(card, device: 0, MPU401_HW_ES18XX,
2090	port: mpu_port[dev], MPU401_INFO_IRQ_HOOK,
2091	irq: -1, rrawmidi: &chip->rmidi);
2092	if (err < 0)
2093	return err;
2094	}
2095
2096	return snd_card_register(card);
2097	}
2098
2099	static int snd_es18xx_isa_match(struct device *pdev, unsigned int dev)
2100	{
2101	return enable[dev] && !is_isapnp_selected(dev);
2102	}
2103
2104	static int snd_es18xx_isa_probe1(int dev, struct device *devptr)
2105	{
2106	struct snd_card *card;
2107	int err;
2108
2109	err = snd_es18xx_card_new(pdev: devptr, dev, cardp: &card);
2110	if (err < 0)
2111	return err;
2112	err = snd_audiodrive_probe(card, dev);
2113	if (err < 0)
2114	return err;
2115	dev_set_drvdata(dev: devptr, data: card);
2116	return 0;
2117	}
2118
2119	static int snd_es18xx_isa_probe(struct device *pdev, unsigned int dev)
2120	{
2121	int err;
2122	static const int possible_irqs[] = {5, 9, 10, 7, 11, 12, -1};
2123	static const int possible_dmas[] = {1, 0, 3, 5, -1};
2124
2125	if (irq[dev] == SNDRV_AUTO_IRQ) {
2126	irq[dev] = snd_legacy_find_free_irq(irq_table: possible_irqs);
2127	if (irq[dev] < 0) {
2128	dev_err(pdev, "unable to find a free IRQ\n");
2129	return -EBUSY;
2130	}
2131	}
2132	if (dma1[dev] == SNDRV_AUTO_DMA) {
2133	dma1[dev] = snd_legacy_find_free_dma(dma_table: possible_dmas);
2134	if (dma1[dev] < 0) {
2135	dev_err(pdev, "unable to find a free DMA1\n");
2136	return -EBUSY;
2137	}
2138	}
2139	if (dma2[dev] == SNDRV_AUTO_DMA) {
2140	dma2[dev] = snd_legacy_find_free_dma(dma_table: possible_dmas);
2141	if (dma2[dev] < 0) {
2142	dev_err(pdev, "unable to find a free DMA2\n");
2143	return -EBUSY;
2144	}
2145	}
2146
2147	if (port[dev] != SNDRV_AUTO_PORT) {
2148	return snd_es18xx_isa_probe1(dev, devptr: pdev);
2149	} else {
2150	static const unsigned long possible_ports[] = {0x220, 0x240, 0x260, 0x280};
2151	int i;
2152	for (i = 0; i < ARRAY_SIZE(possible_ports); i++) {
2153	port[dev] = possible_ports[i];
2154	err = snd_es18xx_isa_probe1(dev, devptr: pdev);
2155	if (! err)
2156	return 0;
2157	}
2158	return err;
2159	}
2160	}
2161
2162	#ifdef CONFIG_PM
2163	static int snd_es18xx_isa_suspend(struct device *dev, unsigned int n,
2164	pm_message_t state)
2165	{
2166	return snd_es18xx_suspend(card: dev_get_drvdata(dev), state);
2167	}
2168
2169	static int snd_es18xx_isa_resume(struct device *dev, unsigned int n)
2170	{
2171	return snd_es18xx_resume(card: dev_get_drvdata(dev));
2172	}
2173	#endif
2174
2175	#define DEV_NAME "es18xx"
2176
2177	static struct isa_driver snd_es18xx_isa_driver = {
2178	.match = snd_es18xx_isa_match,
2179	.probe = snd_es18xx_isa_probe,
2180	#ifdef CONFIG_PM
2181	.suspend = snd_es18xx_isa_suspend,
2182	.resume = snd_es18xx_isa_resume,
2183	#endif
2184	.driver = {
2185	.name = DEV_NAME
2186	},
2187	};
2188
2189
2190	#ifdef CONFIG_PNP
2191	static int snd_audiodrive_pnp_detect(struct pnp_dev *pdev,
2192	const struct pnp_device_id *id)
2193	{
2194	static int dev;
2195	int err;
2196	struct snd_card *card;
2197
2198	if (pnp_device_is_isapnp(pdev))
2199	return -ENOENT; /* we have another procedure - card */
2200	for (; dev < SNDRV_CARDS; dev++) {
2201	if (enable[dev] && isapnp[dev])
2202	break;
2203	}
2204	if (dev >= SNDRV_CARDS)
2205	return -ENODEV;
2206
2207	err = snd_es18xx_card_new(pdev: &pdev->dev, dev, cardp: &card);
2208	if (err < 0)
2209	return err;
2210	err = snd_audiodrive_pnp(dev, chip: card->private_data, pdev);
2211	if (err < 0)
2212	return err;
2213	err = snd_audiodrive_probe(card, dev);
2214	if (err < 0)
2215	return err;
2216	pnp_set_drvdata(pdev, data: card);
2217	dev++;
2218	return 0;
2219	}
2220
2221	#ifdef CONFIG_PM
2222	static int snd_audiodrive_pnp_suspend(struct pnp_dev *pdev, pm_message_t state)
2223	{
2224	return snd_es18xx_suspend(card: pnp_get_drvdata(pdev), state);
2225	}
2226	static int snd_audiodrive_pnp_resume(struct pnp_dev *pdev)
2227	{
2228	return snd_es18xx_resume(card: pnp_get_drvdata(pdev));
2229	}
2230	#endif
2231
2232	static struct pnp_driver es18xx_pnp_driver = {
2233	.name = "es18xx-pnpbios",
2234	.id_table = snd_audiodrive_pnpbiosids,
2235	.probe = snd_audiodrive_pnp_detect,
2236	#ifdef CONFIG_PM
2237	.suspend = snd_audiodrive_pnp_suspend,
2238	.resume = snd_audiodrive_pnp_resume,
2239	#endif
2240	};
2241
2242	static int snd_audiodrive_pnpc_detect(struct pnp_card_link *pcard,
2243	const struct pnp_card_device_id *pid)
2244	{
2245	static int dev;
2246	struct snd_card *card;
2247	int res;
2248
2249	for ( ; dev < SNDRV_CARDS; dev++) {
2250	if (enable[dev] && isapnp[dev])
2251	break;
2252	}
2253	if (dev >= SNDRV_CARDS)
2254	return -ENODEV;
2255
2256	res = snd_es18xx_card_new(pdev: &pcard->card->dev, dev, cardp: &card);
2257	if (res < 0)
2258	return res;
2259
2260	res = snd_audiodrive_pnpc(dev, chip: card->private_data, card: pcard, id: pid);
2261	if (res < 0)
2262	return res;
2263	res = snd_audiodrive_probe(card, dev);
2264	if (res < 0)
2265	return res;
2266
2267	pnp_set_card_drvdata(pcard, data: card);
2268	dev++;
2269	return 0;
2270	}
2271
2272	#ifdef CONFIG_PM
2273	static int snd_audiodrive_pnpc_suspend(struct pnp_card_link *pcard, pm_message_t state)
2274	{
2275	return snd_es18xx_suspend(card: pnp_get_card_drvdata(pcard), state);
2276	}
2277
2278	static int snd_audiodrive_pnpc_resume(struct pnp_card_link *pcard)
2279	{
2280	return snd_es18xx_resume(card: pnp_get_card_drvdata(pcard));
2281	}
2282
2283	#endif
2284
2285	static struct pnp_card_driver es18xx_pnpc_driver = {
2286	.flags = PNP_DRIVER_RES_DISABLE,
2287	.name = "es18xx",
2288	.id_table = snd_audiodrive_pnpids,
2289	.probe = snd_audiodrive_pnpc_detect,
2290	#ifdef CONFIG_PM
2291	.suspend = snd_audiodrive_pnpc_suspend,
2292	.resume = snd_audiodrive_pnpc_resume,
2293	#endif
2294	};
2295	#endif /* CONFIG_PNP */
2296
2297	static int __init alsa_card_es18xx_init(void)
2298	{
2299	int err;
2300
2301	err = isa_register_driver(&snd_es18xx_isa_driver, SNDRV_CARDS);
2302	#ifdef CONFIG_PNP
2303	if (!err)
2304	isa_registered = 1;
2305
2306	err = pnp_register_driver(drv: &es18xx_pnp_driver);
2307	if (!err)
2308	pnp_registered = 1;
2309
2310	err = pnp_register_card_driver(drv: &es18xx_pnpc_driver);
2311	if (!err)
2312	pnpc_registered = 1;
2313
2314	if (isa_registered || pnp_registered)
2315	err = 0;
2316	#endif
2317	return err;
2318	}
2319
2320	static void __exit alsa_card_es18xx_exit(void)
2321	{
2322	#ifdef CONFIG_PNP
2323	if (pnpc_registered)
2324	pnp_unregister_card_driver(drv: &es18xx_pnpc_driver);
2325	if (pnp_registered)
2326	pnp_unregister_driver(drv: &es18xx_pnp_driver);
2327	if (isa_registered)
2328	#endif
2329	isa_unregister_driver(&snd_es18xx_isa_driver);
2330	}
2331
2332	module_init(alsa_card_es18xx_init)
2333	module_exit(alsa_card_es18xx_exit)
2334