blob: 0d556b09ad046773818ecdb82b60c4dc0adb93bb [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Driver for ESS Solo-1 (ES1938, ES1946, ES1969) soundcard
3 * Copyright (c) by Jaromir Koutek <miri@punknet.cz>,
4 * Jaroslav Kysela <perex@suse.cz>,
5 * Thomas Sailer <sailer@ife.ee.ethz.ch>,
6 * Abramo Bagnara <abramo@alsa-project.org>,
7 * Markus Gruber <gruber@eikon.tum.de>
8 *
9 * Rewritten from sonicvibes.c source.
10 *
11 * TODO:
12 * Rewrite better spinlocks
13 *
14 *
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
19 *
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 *
29 */
30
31/*
32 NOTES:
33 - Capture data is written unaligned starting from dma_base + 1 so I need to
34 disable mmap and to add a copy callback.
35 - After several cycle of the following:
36 while : ; do arecord -d1 -f cd -t raw | aplay -f cd ; done
37 a "playback write error (DMA or IRQ trouble?)" may happen.
38 This is due to playback interrupts not generated.
39 I suspect a timing issue.
40 - Sometimes the interrupt handler is invoked wrongly during playback.
41 This generates some harmless "Unexpected hw_pointer: wrong interrupt
42 acknowledge".
43 I've seen that using small period sizes.
44 Reproducible with:
45 mpg123 test.mp3 &
46 hdparm -t -T /dev/hda
47*/
48
49
50#include <sound/driver.h>
51#include <linux/init.h>
52#include <linux/interrupt.h>
53#include <linux/pci.h>
54#include <linux/slab.h>
55#include <linux/gameport.h>
56#include <linux/moduleparam.h>
57#include <linux/delay.h>
58#include <sound/core.h>
59#include <sound/control.h>
60#include <sound/pcm.h>
61#include <sound/opl3.h>
62#include <sound/mpu401.h>
63#include <sound/initval.h>
64
65#include <asm/io.h>
66
67MODULE_AUTHOR("Jaromir Koutek <miri@punknet.cz>");
68MODULE_DESCRIPTION("ESS Solo-1");
69MODULE_LICENSE("GPL");
70MODULE_SUPPORTED_DEVICE("{{ESS,ES1938},"
71 "{ESS,ES1946},"
72 "{ESS,ES1969},"
73 "{TerraTec,128i PCI}}");
74
75#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
76#define SUPPORT_JOYSTICK 1
77#endif
78
Linus Torvalds1da177e2005-04-16 15:20:36 -070079static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
80static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
81static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */
82
83module_param_array(index, int, NULL, 0444);
84MODULE_PARM_DESC(index, "Index value for ESS Solo-1 soundcard.");
85module_param_array(id, charp, NULL, 0444);
86MODULE_PARM_DESC(id, "ID string for ESS Solo-1 soundcard.");
87module_param_array(enable, bool, NULL, 0444);
88MODULE_PARM_DESC(enable, "Enable ESS Solo-1 soundcard.");
89
90#define SLIO_REG(chip, x) ((chip)->io_port + ESSIO_REG_##x)
91
92#define SLDM_REG(chip, x) ((chip)->ddma_port + ESSDM_REG_##x)
93
94#define SLSB_REG(chip, x) ((chip)->sb_port + ESSSB_REG_##x)
95
96#define SL_PCI_LEGACYCONTROL 0x40
97#define SL_PCI_CONFIG 0x50
98#define SL_PCI_DDMACONTROL 0x60
99
100#define ESSIO_REG_AUDIO2DMAADDR 0
101#define ESSIO_REG_AUDIO2DMACOUNT 4
102#define ESSIO_REG_AUDIO2MODE 6
103#define ESSIO_REG_IRQCONTROL 7
104
105#define ESSDM_REG_DMAADDR 0x00
106#define ESSDM_REG_DMACOUNT 0x04
107#define ESSDM_REG_DMACOMMAND 0x08
108#define ESSDM_REG_DMASTATUS 0x08
109#define ESSDM_REG_DMAMODE 0x0b
110#define ESSDM_REG_DMACLEAR 0x0d
111#define ESSDM_REG_DMAMASK 0x0f
112
113#define ESSSB_REG_FMLOWADDR 0x00
114#define ESSSB_REG_FMHIGHADDR 0x02
115#define ESSSB_REG_MIXERADDR 0x04
116#define ESSSB_REG_MIXERDATA 0x05
117
118#define ESSSB_IREG_AUDIO1 0x14
119#define ESSSB_IREG_MICMIX 0x1a
120#define ESSSB_IREG_RECSRC 0x1c
121#define ESSSB_IREG_MASTER 0x32
122#define ESSSB_IREG_FM 0x36
123#define ESSSB_IREG_AUXACD 0x38
124#define ESSSB_IREG_AUXB 0x3a
125#define ESSSB_IREG_PCSPEAKER 0x3c
126#define ESSSB_IREG_LINE 0x3e
127#define ESSSB_IREG_SPATCONTROL 0x50
128#define ESSSB_IREG_SPATLEVEL 0x52
129#define ESSSB_IREG_MASTER_LEFT 0x60
130#define ESSSB_IREG_MASTER_RIGHT 0x62
131#define ESSSB_IREG_MPU401CONTROL 0x64
132#define ESSSB_IREG_MICMIXRECORD 0x68
133#define ESSSB_IREG_AUDIO2RECORD 0x69
134#define ESSSB_IREG_AUXACDRECORD 0x6a
135#define ESSSB_IREG_FMRECORD 0x6b
136#define ESSSB_IREG_AUXBRECORD 0x6c
137#define ESSSB_IREG_MONO 0x6d
138#define ESSSB_IREG_LINERECORD 0x6e
139#define ESSSB_IREG_MONORECORD 0x6f
140#define ESSSB_IREG_AUDIO2SAMPLE 0x70
141#define ESSSB_IREG_AUDIO2MODE 0x71
142#define ESSSB_IREG_AUDIO2FILTER 0x72
143#define ESSSB_IREG_AUDIO2TCOUNTL 0x74
144#define ESSSB_IREG_AUDIO2TCOUNTH 0x76
145#define ESSSB_IREG_AUDIO2CONTROL1 0x78
146#define ESSSB_IREG_AUDIO2CONTROL2 0x7a
147#define ESSSB_IREG_AUDIO2 0x7c
148
149#define ESSSB_REG_RESET 0x06
150
151#define ESSSB_REG_READDATA 0x0a
152#define ESSSB_REG_WRITEDATA 0x0c
153#define ESSSB_REG_READSTATUS 0x0c
154
155#define ESSSB_REG_STATUS 0x0e
156
157#define ESS_CMD_EXTSAMPLERATE 0xa1
158#define ESS_CMD_FILTERDIV 0xa2
159#define ESS_CMD_DMACNTRELOADL 0xa4
160#define ESS_CMD_DMACNTRELOADH 0xa5
161#define ESS_CMD_ANALOGCONTROL 0xa8
162#define ESS_CMD_IRQCONTROL 0xb1
163#define ESS_CMD_DRQCONTROL 0xb2
164#define ESS_CMD_RECLEVEL 0xb4
165#define ESS_CMD_SETFORMAT 0xb6
166#define ESS_CMD_SETFORMAT2 0xb7
167#define ESS_CMD_DMACONTROL 0xb8
168#define ESS_CMD_DMATYPE 0xb9
169#define ESS_CMD_OFFSETLEFT 0xba
170#define ESS_CMD_OFFSETRIGHT 0xbb
171#define ESS_CMD_READREG 0xc0
172#define ESS_CMD_ENABLEEXT 0xc6
173#define ESS_CMD_PAUSEDMA 0xd0
174#define ESS_CMD_ENABLEAUDIO1 0xd1
175#define ESS_CMD_STOPAUDIO1 0xd3
176#define ESS_CMD_AUDIO1STATUS 0xd8
177#define ESS_CMD_CONTDMA 0xd4
178#define ESS_CMD_TESTIRQ 0xf2
179
180#define ESS_RECSRC_MIC 0
181#define ESS_RECSRC_AUXACD 2
182#define ESS_RECSRC_AUXB 5
183#define ESS_RECSRC_LINE 6
184#define ESS_RECSRC_NONE 7
185
186#define DAC1 0x01
187#define ADC1 0x02
188#define DAC2 0x04
189
190/*
191
192 */
193
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194#define SAVED_REG_SIZE 32 /* max. number of registers to save */
195
Takashi Iwaie571f592005-11-17 15:04:01 +0100196struct es1938 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 int irq;
198
199 unsigned long io_port;
200 unsigned long sb_port;
201 unsigned long vc_port;
202 unsigned long mpu_port;
203 unsigned long game_port;
204 unsigned long ddma_port;
205
206 unsigned char irqmask;
207 unsigned char revision;
208
Takashi Iwaie571f592005-11-17 15:04:01 +0100209 struct snd_kcontrol *hw_volume;
210 struct snd_kcontrol *hw_switch;
211 struct snd_kcontrol *master_volume;
212 struct snd_kcontrol *master_switch;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
214 struct pci_dev *pci;
Takashi Iwaie571f592005-11-17 15:04:01 +0100215 struct snd_card *card;
216 struct snd_pcm *pcm;
217 struct snd_pcm_substream *capture_substream;
218 struct snd_pcm_substream *playback1_substream;
219 struct snd_pcm_substream *playback2_substream;
220 struct snd_rawmidi *rmidi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
222 unsigned int dma1_size;
223 unsigned int dma2_size;
224 unsigned int dma1_start;
225 unsigned int dma2_start;
226 unsigned int dma1_shift;
227 unsigned int dma2_shift;
228 unsigned int active;
229
230 spinlock_t reg_lock;
231 spinlock_t mixer_lock;
Takashi Iwaie571f592005-11-17 15:04:01 +0100232 struct snd_info_entry *proc_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
234#ifdef SUPPORT_JOYSTICK
235 struct gameport *gameport;
236#endif
237#ifdef CONFIG_PM
238 unsigned char saved_regs[SAVED_REG_SIZE];
239#endif
240};
241
242static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs);
243
244static struct pci_device_id snd_es1938_ids[] = {
245 { 0x125d, 0x1969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* Solo-1 */
246 { 0, }
247};
248
249MODULE_DEVICE_TABLE(pci, snd_es1938_ids);
250
251#define RESET_LOOP_TIMEOUT 0x10000
252#define WRITE_LOOP_TIMEOUT 0x10000
253#define GET_LOOP_TIMEOUT 0x01000
254
255#undef REG_DEBUG
256/* -----------------------------------------------------------------
257 * Write to a mixer register
258 * -----------------------------------------------------------------*/
Takashi Iwaie571f592005-11-17 15:04:01 +0100259static void snd_es1938_mixer_write(struct es1938 *chip, unsigned char reg, unsigned char val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260{
261 unsigned long flags;
262 spin_lock_irqsave(&chip->mixer_lock, flags);
263 outb(reg, SLSB_REG(chip, MIXERADDR));
264 outb(val, SLSB_REG(chip, MIXERDATA));
265 spin_unlock_irqrestore(&chip->mixer_lock, flags);
266#ifdef REG_DEBUG
Takashi Iwai99b359b2005-10-20 18:26:44 +0200267 snd_printk(KERN_DEBUG "Mixer reg %02x set to %02x\n", reg, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268#endif
269}
270
271/* -----------------------------------------------------------------
272 * Read from a mixer register
273 * -----------------------------------------------------------------*/
Takashi Iwaie571f592005-11-17 15:04:01 +0100274static int snd_es1938_mixer_read(struct es1938 *chip, unsigned char reg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275{
276 int data;
277 unsigned long flags;
278 spin_lock_irqsave(&chip->mixer_lock, flags);
279 outb(reg, SLSB_REG(chip, MIXERADDR));
280 data = inb(SLSB_REG(chip, MIXERDATA));
281 spin_unlock_irqrestore(&chip->mixer_lock, flags);
282#ifdef REG_DEBUG
Takashi Iwai99b359b2005-10-20 18:26:44 +0200283 snd_printk(KERN_DEBUG "Mixer reg %02x now is %02x\n", reg, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284#endif
285 return data;
286}
287
288/* -----------------------------------------------------------------
289 * Write to some bits of a mixer register (return old value)
290 * -----------------------------------------------------------------*/
Takashi Iwaie571f592005-11-17 15:04:01 +0100291static int snd_es1938_mixer_bits(struct es1938 *chip, unsigned char reg,
292 unsigned char mask, unsigned char val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293{
294 unsigned long flags;
295 unsigned char old, new, oval;
296 spin_lock_irqsave(&chip->mixer_lock, flags);
297 outb(reg, SLSB_REG(chip, MIXERADDR));
298 old = inb(SLSB_REG(chip, MIXERDATA));
299 oval = old & mask;
300 if (val != oval) {
301 new = (old & ~mask) | (val & mask);
302 outb(new, SLSB_REG(chip, MIXERDATA));
303#ifdef REG_DEBUG
Takashi Iwai99b359b2005-10-20 18:26:44 +0200304 snd_printk(KERN_DEBUG "Mixer reg %02x was %02x, set to %02x\n",
305 reg, old, new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306#endif
307 }
308 spin_unlock_irqrestore(&chip->mixer_lock, flags);
309 return oval;
310}
311
312/* -----------------------------------------------------------------
313 * Write command to Controller Registers
314 * -----------------------------------------------------------------*/
Takashi Iwaie571f592005-11-17 15:04:01 +0100315static void snd_es1938_write_cmd(struct es1938 *chip, unsigned char cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316{
317 int i;
318 unsigned char v;
319 for (i = 0; i < WRITE_LOOP_TIMEOUT; i++) {
320 if (!(v = inb(SLSB_REG(chip, READSTATUS)) & 0x80)) {
321 outb(cmd, SLSB_REG(chip, WRITEDATA));
322 return;
323 }
324 }
Takashi Iwai99b359b2005-10-20 18:26:44 +0200325 printk(KERN_ERR "snd_es1938_write_cmd timeout (0x02%x/0x02%x)\n", cmd, v);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326}
327
328/* -----------------------------------------------------------------
329 * Read the Read Data Buffer
330 * -----------------------------------------------------------------*/
Takashi Iwaie571f592005-11-17 15:04:01 +0100331static int snd_es1938_get_byte(struct es1938 *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332{
333 int i;
334 unsigned char v;
335 for (i = GET_LOOP_TIMEOUT; i; i--)
336 if ((v = inb(SLSB_REG(chip, STATUS))) & 0x80)
337 return inb(SLSB_REG(chip, READDATA));
Takashi Iwai99b359b2005-10-20 18:26:44 +0200338 snd_printk(KERN_ERR "get_byte timeout: status 0x02%x\n", v);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 return -ENODEV;
340}
341
342/* -----------------------------------------------------------------
343 * Write value cmd register
344 * -----------------------------------------------------------------*/
Takashi Iwaie571f592005-11-17 15:04:01 +0100345static void snd_es1938_write(struct es1938 *chip, unsigned char reg, unsigned char val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346{
347 unsigned long flags;
348 spin_lock_irqsave(&chip->reg_lock, flags);
349 snd_es1938_write_cmd(chip, reg);
350 snd_es1938_write_cmd(chip, val);
351 spin_unlock_irqrestore(&chip->reg_lock, flags);
352#ifdef REG_DEBUG
Takashi Iwai99b359b2005-10-20 18:26:44 +0200353 snd_printk(KERN_DEBUG "Reg %02x set to %02x\n", reg, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354#endif
355}
356
357/* -----------------------------------------------------------------
358 * Read data from cmd register and return it
359 * -----------------------------------------------------------------*/
Takashi Iwaie571f592005-11-17 15:04:01 +0100360static unsigned char snd_es1938_read(struct es1938 *chip, unsigned char reg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361{
362 unsigned char val;
363 unsigned long flags;
364 spin_lock_irqsave(&chip->reg_lock, flags);
365 snd_es1938_write_cmd(chip, ESS_CMD_READREG);
366 snd_es1938_write_cmd(chip, reg);
367 val = snd_es1938_get_byte(chip);
368 spin_unlock_irqrestore(&chip->reg_lock, flags);
369#ifdef REG_DEBUG
Takashi Iwai99b359b2005-10-20 18:26:44 +0200370 snd_printk(KERN_DEBUG "Reg %02x now is %02x\n", reg, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371#endif
372 return val;
373}
374
375/* -----------------------------------------------------------------
376 * Write data to cmd register and return old value
377 * -----------------------------------------------------------------*/
Takashi Iwaie571f592005-11-17 15:04:01 +0100378static int snd_es1938_bits(struct es1938 *chip, unsigned char reg, unsigned char mask,
379 unsigned char val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380{
381 unsigned long flags;
382 unsigned char old, new, oval;
383 spin_lock_irqsave(&chip->reg_lock, flags);
384 snd_es1938_write_cmd(chip, ESS_CMD_READREG);
385 snd_es1938_write_cmd(chip, reg);
386 old = snd_es1938_get_byte(chip);
387 oval = old & mask;
388 if (val != oval) {
389 snd_es1938_write_cmd(chip, reg);
390 new = (old & ~mask) | (val & mask);
391 snd_es1938_write_cmd(chip, new);
392#ifdef REG_DEBUG
Takashi Iwai99b359b2005-10-20 18:26:44 +0200393 snd_printk(KERN_DEBUG "Reg %02x was %02x, set to %02x\n",
394 reg, old, new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395#endif
396 }
397 spin_unlock_irqrestore(&chip->reg_lock, flags);
398 return oval;
399}
400
401/* --------------------------------------------------------------------
402 * Reset the chip
403 * --------------------------------------------------------------------*/
Takashi Iwaie571f592005-11-17 15:04:01 +0100404static void snd_es1938_reset(struct es1938 *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405{
406 int i;
407
408 outb(3, SLSB_REG(chip, RESET));
409 inb(SLSB_REG(chip, RESET));
410 outb(0, SLSB_REG(chip, RESET));
411 for (i = 0; i < RESET_LOOP_TIMEOUT; i++) {
412 if (inb(SLSB_REG(chip, STATUS)) & 0x80) {
413 if (inb(SLSB_REG(chip, READDATA)) == 0xaa)
414 goto __next;
415 }
416 }
Takashi Iwai99b359b2005-10-20 18:26:44 +0200417 snd_printk(KERN_ERR "ESS Solo-1 reset failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
419 __next:
420 snd_es1938_write_cmd(chip, ESS_CMD_ENABLEEXT);
421
422 /* Demand transfer DMA: 4 bytes per DMA request */
423 snd_es1938_write(chip, ESS_CMD_DMATYPE, 2);
424
425 /* Change behaviour of register A1
426 4x oversampling
427 2nd channel DAC asynchronous */
428 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2MODE, 0x32);
429 /* enable/select DMA channel and IRQ channel */
430 snd_es1938_bits(chip, ESS_CMD_IRQCONTROL, 0xf0, 0x50);
431 snd_es1938_bits(chip, ESS_CMD_DRQCONTROL, 0xf0, 0x50);
432 snd_es1938_write_cmd(chip, ESS_CMD_ENABLEAUDIO1);
433 /* Set spatializer parameters to recommended values */
434 snd_es1938_mixer_write(chip, 0x54, 0x8f);
435 snd_es1938_mixer_write(chip, 0x56, 0x95);
436 snd_es1938_mixer_write(chip, 0x58, 0x94);
437 snd_es1938_mixer_write(chip, 0x5a, 0x80);
438}
439
440/* --------------------------------------------------------------------
441 * Reset the FIFOs
442 * --------------------------------------------------------------------*/
Takashi Iwaie571f592005-11-17 15:04:01 +0100443static void snd_es1938_reset_fifo(struct es1938 *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444{
445 outb(2, SLSB_REG(chip, RESET));
446 outb(0, SLSB_REG(chip, RESET));
447}
448
Takashi Iwaie571f592005-11-17 15:04:01 +0100449static struct snd_ratnum clocks[2] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 {
451 .num = 793800,
452 .den_min = 1,
453 .den_max = 128,
454 .den_step = 1,
455 },
456 {
457 .num = 768000,
458 .den_min = 1,
459 .den_max = 128,
460 .den_step = 1,
461 }
462};
463
Takashi Iwaie571f592005-11-17 15:04:01 +0100464static struct snd_pcm_hw_constraint_ratnums hw_constraints_clocks = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 .nrats = 2,
466 .rats = clocks,
467};
468
469
Takashi Iwaie571f592005-11-17 15:04:01 +0100470static void snd_es1938_rate_set(struct es1938 *chip,
471 struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 int mode)
473{
474 unsigned int bits, div0;
Takashi Iwaie571f592005-11-17 15:04:01 +0100475 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 if (runtime->rate_num == clocks[0].num)
477 bits = 128 - runtime->rate_den;
478 else
479 bits = 256 - runtime->rate_den;
480
481 /* set filter register */
482 div0 = 256 - 7160000*20/(8*82*runtime->rate);
483
484 if (mode == DAC2) {
485 snd_es1938_mixer_write(chip, 0x70, bits);
486 snd_es1938_mixer_write(chip, 0x72, div0);
487 } else {
488 snd_es1938_write(chip, 0xA1, bits);
489 snd_es1938_write(chip, 0xA2, div0);
490 }
491}
492
493/* --------------------------------------------------------------------
494 * Configure Solo1 builtin DMA Controller
495 * --------------------------------------------------------------------*/
496
Takashi Iwaie571f592005-11-17 15:04:01 +0100497static void snd_es1938_playback1_setdma(struct es1938 *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498{
499 outb(0x00, SLIO_REG(chip, AUDIO2MODE));
500 outl(chip->dma2_start, SLIO_REG(chip, AUDIO2DMAADDR));
501 outw(0, SLIO_REG(chip, AUDIO2DMACOUNT));
502 outw(chip->dma2_size, SLIO_REG(chip, AUDIO2DMACOUNT));
503}
504
Takashi Iwaie571f592005-11-17 15:04:01 +0100505static void snd_es1938_playback2_setdma(struct es1938 *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506{
507 /* Enable DMA controller */
508 outb(0xc4, SLDM_REG(chip, DMACOMMAND));
509 /* 1. Master reset */
510 outb(0, SLDM_REG(chip, DMACLEAR));
511 /* 2. Mask DMA */
512 outb(1, SLDM_REG(chip, DMAMASK));
513 outb(0x18, SLDM_REG(chip, DMAMODE));
514 outl(chip->dma1_start, SLDM_REG(chip, DMAADDR));
515 outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT));
516 /* 3. Unmask DMA */
517 outb(0, SLDM_REG(chip, DMAMASK));
518}
519
Takashi Iwaie571f592005-11-17 15:04:01 +0100520static void snd_es1938_capture_setdma(struct es1938 *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521{
522 /* Enable DMA controller */
523 outb(0xc4, SLDM_REG(chip, DMACOMMAND));
524 /* 1. Master reset */
525 outb(0, SLDM_REG(chip, DMACLEAR));
526 /* 2. Mask DMA */
527 outb(1, SLDM_REG(chip, DMAMASK));
528 outb(0x14, SLDM_REG(chip, DMAMODE));
529 outl(chip->dma1_start, SLDM_REG(chip, DMAADDR));
530 outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT));
531 /* 3. Unmask DMA */
532 outb(0, SLDM_REG(chip, DMAMASK));
533}
534
535/* ----------------------------------------------------------------------
536 *
537 * *** PCM part ***
538 */
539
Takashi Iwaie571f592005-11-17 15:04:01 +0100540static int snd_es1938_capture_trigger(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 int cmd)
542{
Takashi Iwaie571f592005-11-17 15:04:01 +0100543 struct es1938 *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 int val;
545 switch (cmd) {
546 case SNDRV_PCM_TRIGGER_START:
Takashi Iwai93b9f422005-10-10 13:42:24 +0200547 case SNDRV_PCM_TRIGGER_RESUME:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 val = 0x0f;
549 chip->active |= ADC1;
550 break;
551 case SNDRV_PCM_TRIGGER_STOP:
Takashi Iwai93b9f422005-10-10 13:42:24 +0200552 case SNDRV_PCM_TRIGGER_SUSPEND:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 val = 0x00;
554 chip->active &= ~ADC1;
555 break;
556 default:
557 return -EINVAL;
558 }
559 snd_es1938_write(chip, ESS_CMD_DMACONTROL, val);
560 return 0;
561}
562
Takashi Iwaie571f592005-11-17 15:04:01 +0100563static int snd_es1938_playback1_trigger(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 int cmd)
565{
Takashi Iwaie571f592005-11-17 15:04:01 +0100566 struct es1938 *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 switch (cmd) {
568 case SNDRV_PCM_TRIGGER_START:
Takashi Iwai93b9f422005-10-10 13:42:24 +0200569 case SNDRV_PCM_TRIGGER_RESUME:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 /* According to the documentation this should be:
571 0x13 but that value may randomly swap stereo channels */
572 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0x92);
573 udelay(10);
574 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0x93);
575 /* This two stage init gives the FIFO -> DAC connection time to
576 * settle before first data from DMA flows in. This should ensure
577 * no swapping of stereo channels. Report a bug if otherwise :-) */
578 outb(0x0a, SLIO_REG(chip, AUDIO2MODE));
579 chip->active |= DAC2;
580 break;
581 case SNDRV_PCM_TRIGGER_STOP:
Takashi Iwai93b9f422005-10-10 13:42:24 +0200582 case SNDRV_PCM_TRIGGER_SUSPEND:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 outb(0, SLIO_REG(chip, AUDIO2MODE));
584 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0);
585 chip->active &= ~DAC2;
586 break;
587 default:
588 return -EINVAL;
589 }
590 return 0;
591}
592
Takashi Iwaie571f592005-11-17 15:04:01 +0100593static int snd_es1938_playback2_trigger(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 int cmd)
595{
Takashi Iwaie571f592005-11-17 15:04:01 +0100596 struct es1938 *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 int val;
598 switch (cmd) {
599 case SNDRV_PCM_TRIGGER_START:
Takashi Iwai93b9f422005-10-10 13:42:24 +0200600 case SNDRV_PCM_TRIGGER_RESUME:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 val = 5;
602 chip->active |= DAC1;
603 break;
604 case SNDRV_PCM_TRIGGER_STOP:
Takashi Iwai93b9f422005-10-10 13:42:24 +0200605 case SNDRV_PCM_TRIGGER_SUSPEND:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 val = 0;
607 chip->active &= ~DAC1;
608 break;
609 default:
610 return -EINVAL;
611 }
612 snd_es1938_write(chip, ESS_CMD_DMACONTROL, val);
613 return 0;
614}
615
Takashi Iwaie571f592005-11-17 15:04:01 +0100616static int snd_es1938_playback_trigger(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 int cmd)
618{
619 switch (substream->number) {
620 case 0:
621 return snd_es1938_playback1_trigger(substream, cmd);
622 case 1:
623 return snd_es1938_playback2_trigger(substream, cmd);
624 }
625 snd_BUG();
626 return -EINVAL;
627}
628
629/* --------------------------------------------------------------------
630 * First channel for Extended Mode Audio 1 ADC Operation
631 * --------------------------------------------------------------------*/
Takashi Iwaie571f592005-11-17 15:04:01 +0100632static int snd_es1938_capture_prepare(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633{
Takashi Iwaie571f592005-11-17 15:04:01 +0100634 struct es1938 *chip = snd_pcm_substream_chip(substream);
635 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 int u, is8, mono;
637 unsigned int size = snd_pcm_lib_buffer_bytes(substream);
638 unsigned int count = snd_pcm_lib_period_bytes(substream);
639
640 chip->dma1_size = size;
641 chip->dma1_start = runtime->dma_addr;
642
643 mono = (runtime->channels > 1) ? 0 : 1;
644 is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
645 u = snd_pcm_format_unsigned(runtime->format);
646
647 chip->dma1_shift = 2 - mono - is8;
648
649 snd_es1938_reset_fifo(chip);
650
651 /* program type */
652 snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1));
653
654 /* set clock and counters */
655 snd_es1938_rate_set(chip, substream, ADC1);
656
657 count = 0x10000 - count;
658 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff);
659 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8);
660
661 /* initialize and configure ADC */
662 snd_es1938_write(chip, ESS_CMD_SETFORMAT2, u ? 0x51 : 0x71);
663 snd_es1938_write(chip, ESS_CMD_SETFORMAT2, 0x90 |
664 (u ? 0x00 : 0x20) |
665 (is8 ? 0x00 : 0x04) |
666 (mono ? 0x40 : 0x08));
667
668 // snd_es1938_reset_fifo(chip);
669
670 /* 11. configure system interrupt controller and DMA controller */
671 snd_es1938_capture_setdma(chip);
672
673 return 0;
674}
675
676
677/* ------------------------------------------------------------------------------
678 * Second Audio channel DAC Operation
679 * ------------------------------------------------------------------------------*/
Takashi Iwaie571f592005-11-17 15:04:01 +0100680static int snd_es1938_playback1_prepare(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681{
Takashi Iwaie571f592005-11-17 15:04:01 +0100682 struct es1938 *chip = snd_pcm_substream_chip(substream);
683 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 int u, is8, mono;
685 unsigned int size = snd_pcm_lib_buffer_bytes(substream);
686 unsigned int count = snd_pcm_lib_period_bytes(substream);
687
688 chip->dma2_size = size;
689 chip->dma2_start = runtime->dma_addr;
690
691 mono = (runtime->channels > 1) ? 0 : 1;
692 is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
693 u = snd_pcm_format_unsigned(runtime->format);
694
695 chip->dma2_shift = 2 - mono - is8;
696
697 snd_es1938_reset_fifo(chip);
698
699 /* set clock and counters */
700 snd_es1938_rate_set(chip, substream, DAC2);
701
702 count >>= 1;
703 count = 0x10000 - count;
704 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTL, count & 0xff);
705 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTH, count >> 8);
706
707 /* initialize and configure Audio 2 DAC */
Takashi Iwaie571f592005-11-17 15:04:01 +0100708 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x40 | (u ? 0 : 4) |
709 (mono ? 0 : 2) | (is8 ? 0 : 1));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710
711 /* program DMA */
712 snd_es1938_playback1_setdma(chip);
713
714 return 0;
715}
716
Takashi Iwaie571f592005-11-17 15:04:01 +0100717static int snd_es1938_playback2_prepare(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718{
Takashi Iwaie571f592005-11-17 15:04:01 +0100719 struct es1938 *chip = snd_pcm_substream_chip(substream);
720 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 int u, is8, mono;
722 unsigned int size = snd_pcm_lib_buffer_bytes(substream);
723 unsigned int count = snd_pcm_lib_period_bytes(substream);
724
725 chip->dma1_size = size;
726 chip->dma1_start = runtime->dma_addr;
727
728 mono = (runtime->channels > 1) ? 0 : 1;
729 is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
730 u = snd_pcm_format_unsigned(runtime->format);
731
732 chip->dma1_shift = 2 - mono - is8;
733
734 count = 0x10000 - count;
735
736 /* reset */
737 snd_es1938_reset_fifo(chip);
738
739 snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1));
740
741 /* set clock and counters */
742 snd_es1938_rate_set(chip, substream, DAC1);
743 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff);
744 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8);
745
746 /* initialized and configure DAC */
747 snd_es1938_write(chip, ESS_CMD_SETFORMAT, u ? 0x80 : 0x00);
748 snd_es1938_write(chip, ESS_CMD_SETFORMAT, u ? 0x51 : 0x71);
749 snd_es1938_write(chip, ESS_CMD_SETFORMAT2,
750 0x90 | (mono ? 0x40 : 0x08) |
751 (is8 ? 0x00 : 0x04) | (u ? 0x00 : 0x20));
752
753 /* program DMA */
754 snd_es1938_playback2_setdma(chip);
755
756 return 0;
757}
758
Takashi Iwaie571f592005-11-17 15:04:01 +0100759static int snd_es1938_playback_prepare(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760{
761 switch (substream->number) {
762 case 0:
763 return snd_es1938_playback1_prepare(substream);
764 case 1:
765 return snd_es1938_playback2_prepare(substream);
766 }
767 snd_BUG();
768 return -EINVAL;
769}
770
Takashi Iwaie571f592005-11-17 15:04:01 +0100771static snd_pcm_uframes_t snd_es1938_capture_pointer(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772{
Takashi Iwaie571f592005-11-17 15:04:01 +0100773 struct es1938 *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 size_t ptr;
775 size_t old, new;
776#if 1
777 /* This stuff is *needed*, don't ask why - AB */
778 old = inw(SLDM_REG(chip, DMACOUNT));
779 while ((new = inw(SLDM_REG(chip, DMACOUNT))) != old)
780 old = new;
781 ptr = chip->dma1_size - 1 - new;
782#else
783 ptr = inl(SLDM_REG(chip, DMAADDR)) - chip->dma1_start;
784#endif
785 return ptr >> chip->dma1_shift;
786}
787
Takashi Iwaie571f592005-11-17 15:04:01 +0100788static snd_pcm_uframes_t snd_es1938_playback1_pointer(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789{
Takashi Iwaie571f592005-11-17 15:04:01 +0100790 struct es1938 *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 size_t ptr;
792#if 1
793 ptr = chip->dma2_size - inw(SLIO_REG(chip, AUDIO2DMACOUNT));
794#else
795 ptr = inl(SLIO_REG(chip, AUDIO2DMAADDR)) - chip->dma2_start;
796#endif
797 return ptr >> chip->dma2_shift;
798}
799
Takashi Iwaie571f592005-11-17 15:04:01 +0100800static snd_pcm_uframes_t snd_es1938_playback2_pointer(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801{
Takashi Iwaie571f592005-11-17 15:04:01 +0100802 struct es1938 *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 size_t ptr;
804 size_t old, new;
805#if 1
806 /* This stuff is *needed*, don't ask why - AB */
807 old = inw(SLDM_REG(chip, DMACOUNT));
808 while ((new = inw(SLDM_REG(chip, DMACOUNT))) != old)
809 old = new;
810 ptr = chip->dma1_size - 1 - new;
811#else
812 ptr = inl(SLDM_REG(chip, DMAADDR)) - chip->dma1_start;
813#endif
814 return ptr >> chip->dma1_shift;
815}
816
Takashi Iwaie571f592005-11-17 15:04:01 +0100817static snd_pcm_uframes_t snd_es1938_playback_pointer(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818{
819 switch (substream->number) {
820 case 0:
821 return snd_es1938_playback1_pointer(substream);
822 case 1:
823 return snd_es1938_playback2_pointer(substream);
824 }
825 snd_BUG();
826 return -EINVAL;
827}
828
Takashi Iwaie571f592005-11-17 15:04:01 +0100829static int snd_es1938_capture_copy(struct snd_pcm_substream *substream,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 int channel,
831 snd_pcm_uframes_t pos,
832 void __user *dst,
833 snd_pcm_uframes_t count)
834{
Takashi Iwaie571f592005-11-17 15:04:01 +0100835 struct snd_pcm_runtime *runtime = substream->runtime;
836 struct es1938 *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 pos <<= chip->dma1_shift;
838 count <<= chip->dma1_shift;
839 snd_assert(pos + count <= chip->dma1_size, return -EINVAL);
840 if (pos + count < chip->dma1_size) {
841 if (copy_to_user(dst, runtime->dma_area + pos + 1, count))
842 return -EFAULT;
843 } else {
844 if (copy_to_user(dst, runtime->dma_area + pos + 1, count - 1))
845 return -EFAULT;
846 if (put_user(runtime->dma_area[0], ((unsigned char __user *)dst) + count - 1))
847 return -EFAULT;
848 }
849 return 0;
850}
851
852/*
853 * buffer management
854 */
Takashi Iwaie571f592005-11-17 15:04:01 +0100855static int snd_es1938_pcm_hw_params(struct snd_pcm_substream *substream,
856 struct snd_pcm_hw_params *hw_params)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857
858{
859 int err;
860
861 if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
862 return err;
863 return 0;
864}
865
Takashi Iwaie571f592005-11-17 15:04:01 +0100866static int snd_es1938_pcm_hw_free(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867{
868 return snd_pcm_lib_free_pages(substream);
869}
870
871/* ----------------------------------------------------------------------
872 * Audio1 Capture (ADC)
873 * ----------------------------------------------------------------------*/
Takashi Iwaie571f592005-11-17 15:04:01 +0100874static struct snd_pcm_hardware snd_es1938_capture =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875{
876 .info = (SNDRV_PCM_INFO_INTERLEAVED |
877 SNDRV_PCM_INFO_BLOCK_TRANSFER),
Takashi Iwaie571f592005-11-17 15:04:01 +0100878 .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
879 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
881 .rate_min = 6000,
882 .rate_max = 48000,
883 .channels_min = 1,
884 .channels_max = 2,
885 .buffer_bytes_max = 0x8000, /* DMA controller screws on higher values */
886 .period_bytes_min = 64,
887 .period_bytes_max = 0x8000,
888 .periods_min = 1,
889 .periods_max = 1024,
890 .fifo_size = 256,
891};
892
893/* -----------------------------------------------------------------------
894 * Audio2 Playback (DAC)
895 * -----------------------------------------------------------------------*/
Takashi Iwaie571f592005-11-17 15:04:01 +0100896static struct snd_pcm_hardware snd_es1938_playback =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897{
898 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
899 SNDRV_PCM_INFO_BLOCK_TRANSFER |
900 SNDRV_PCM_INFO_MMAP_VALID),
Takashi Iwaie571f592005-11-17 15:04:01 +0100901 .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
902 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
904 .rate_min = 6000,
905 .rate_max = 48000,
906 .channels_min = 1,
907 .channels_max = 2,
908 .buffer_bytes_max = 0x8000, /* DMA controller screws on higher values */
909 .period_bytes_min = 64,
910 .period_bytes_max = 0x8000,
911 .periods_min = 1,
912 .periods_max = 1024,
913 .fifo_size = 256,
914};
915
Takashi Iwaie571f592005-11-17 15:04:01 +0100916static int snd_es1938_capture_open(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917{
Takashi Iwaie571f592005-11-17 15:04:01 +0100918 struct es1938 *chip = snd_pcm_substream_chip(substream);
919 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920
921 if (chip->playback2_substream)
922 return -EAGAIN;
923 chip->capture_substream = substream;
924 runtime->hw = snd_es1938_capture;
925 snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
926 &hw_constraints_clocks);
927 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
928 return 0;
929}
930
Takashi Iwaie571f592005-11-17 15:04:01 +0100931static int snd_es1938_playback_open(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932{
Takashi Iwaie571f592005-11-17 15:04:01 +0100933 struct es1938 *chip = snd_pcm_substream_chip(substream);
934 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935
936 switch (substream->number) {
937 case 0:
938 chip->playback1_substream = substream;
939 break;
940 case 1:
941 if (chip->capture_substream)
942 return -EAGAIN;
943 chip->playback2_substream = substream;
944 break;
945 default:
946 snd_BUG();
947 return -EINVAL;
948 }
949 runtime->hw = snd_es1938_playback;
950 snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
951 &hw_constraints_clocks);
952 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
953 return 0;
954}
955
Takashi Iwaie571f592005-11-17 15:04:01 +0100956static int snd_es1938_capture_close(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957{
Takashi Iwaie571f592005-11-17 15:04:01 +0100958 struct es1938 *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959
960 chip->capture_substream = NULL;
961 return 0;
962}
963
Takashi Iwaie571f592005-11-17 15:04:01 +0100964static int snd_es1938_playback_close(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965{
Takashi Iwaie571f592005-11-17 15:04:01 +0100966 struct es1938 *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967
968 switch (substream->number) {
969 case 0:
970 chip->playback1_substream = NULL;
971 break;
972 case 1:
973 chip->playback2_substream = NULL;
974 break;
975 default:
976 snd_BUG();
977 return -EINVAL;
978 }
979 return 0;
980}
981
Takashi Iwaie571f592005-11-17 15:04:01 +0100982static struct snd_pcm_ops snd_es1938_playback_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 .open = snd_es1938_playback_open,
984 .close = snd_es1938_playback_close,
985 .ioctl = snd_pcm_lib_ioctl,
986 .hw_params = snd_es1938_pcm_hw_params,
987 .hw_free = snd_es1938_pcm_hw_free,
988 .prepare = snd_es1938_playback_prepare,
989 .trigger = snd_es1938_playback_trigger,
990 .pointer = snd_es1938_playback_pointer,
991};
992
Takashi Iwaie571f592005-11-17 15:04:01 +0100993static struct snd_pcm_ops snd_es1938_capture_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 .open = snd_es1938_capture_open,
995 .close = snd_es1938_capture_close,
996 .ioctl = snd_pcm_lib_ioctl,
997 .hw_params = snd_es1938_pcm_hw_params,
998 .hw_free = snd_es1938_pcm_hw_free,
999 .prepare = snd_es1938_capture_prepare,
1000 .trigger = snd_es1938_capture_trigger,
1001 .pointer = snd_es1938_capture_pointer,
1002 .copy = snd_es1938_capture_copy,
1003};
1004
Takashi Iwaie571f592005-11-17 15:04:01 +01001005static int __devinit snd_es1938_new_pcm(struct es1938 *chip, int device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006{
Takashi Iwaie571f592005-11-17 15:04:01 +01001007 struct snd_pcm *pcm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 int err;
1009
1010 if ((err = snd_pcm_new(chip->card, "es-1938-1946", device, 2, 1, &pcm)) < 0)
1011 return err;
1012 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_es1938_playback_ops);
1013 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1938_capture_ops);
1014
1015 pcm->private_data = chip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 pcm->info_flags = 0;
1017 strcpy(pcm->name, "ESS Solo-1");
1018
1019 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
1020 snd_dma_pci_data(chip->pci), 64*1024, 64*1024);
1021
1022 chip->pcm = pcm;
1023 return 0;
1024}
1025
1026/* -------------------------------------------------------------------
1027 *
1028 * *** Mixer part ***
1029 */
1030
Takashi Iwaie571f592005-11-17 15:04:01 +01001031static int snd_es1938_info_mux(struct snd_kcontrol *kcontrol,
1032 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033{
1034 static char *texts[8] = {
1035 "Mic", "Mic Master", "CD", "AOUT",
1036 "Mic1", "Mix", "Line", "Master"
1037 };
1038
1039 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1040 uinfo->count = 1;
1041 uinfo->value.enumerated.items = 8;
1042 if (uinfo->value.enumerated.item > 7)
1043 uinfo->value.enumerated.item = 7;
1044 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1045 return 0;
1046}
1047
Takashi Iwaie571f592005-11-17 15:04:01 +01001048static int snd_es1938_get_mux(struct snd_kcontrol *kcontrol,
1049 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050{
Takashi Iwaie571f592005-11-17 15:04:01 +01001051 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 ucontrol->value.enumerated.item[0] = snd_es1938_mixer_read(chip, 0x1c) & 0x07;
1053 return 0;
1054}
1055
Takashi Iwaie571f592005-11-17 15:04:01 +01001056static int snd_es1938_put_mux(struct snd_kcontrol *kcontrol,
1057 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058{
Takashi Iwaie571f592005-11-17 15:04:01 +01001059 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 unsigned char val = ucontrol->value.enumerated.item[0];
1061
1062 if (val > 7)
1063 return -EINVAL;
1064 return snd_es1938_mixer_bits(chip, 0x1c, 0x07, val) != val;
1065}
1066
Takashi Iwaie571f592005-11-17 15:04:01 +01001067static int snd_es1938_info_spatializer_enable(struct snd_kcontrol *kcontrol,
1068 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069{
1070 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1071 uinfo->count = 1;
1072 uinfo->value.integer.min = 0;
1073 uinfo->value.integer.max = 1;
1074 return 0;
1075}
1076
Takashi Iwaie571f592005-11-17 15:04:01 +01001077static int snd_es1938_get_spatializer_enable(struct snd_kcontrol *kcontrol,
1078 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079{
Takashi Iwaie571f592005-11-17 15:04:01 +01001080 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 unsigned char val = snd_es1938_mixer_read(chip, 0x50);
1082 ucontrol->value.integer.value[0] = !!(val & 8);
1083 return 0;
1084}
1085
Takashi Iwaie571f592005-11-17 15:04:01 +01001086static int snd_es1938_put_spatializer_enable(struct snd_kcontrol *kcontrol,
1087 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088{
Takashi Iwaie571f592005-11-17 15:04:01 +01001089 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 unsigned char oval, nval;
1091 int change;
1092 nval = ucontrol->value.integer.value[0] ? 0x0c : 0x04;
1093 oval = snd_es1938_mixer_read(chip, 0x50) & 0x0c;
1094 change = nval != oval;
1095 if (change) {
1096 snd_es1938_mixer_write(chip, 0x50, nval & ~0x04);
1097 snd_es1938_mixer_write(chip, 0x50, nval);
1098 }
1099 return change;
1100}
1101
Takashi Iwaie571f592005-11-17 15:04:01 +01001102static int snd_es1938_info_hw_volume(struct snd_kcontrol *kcontrol,
1103 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104{
1105 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1106 uinfo->count = 2;
1107 uinfo->value.integer.min = 0;
1108 uinfo->value.integer.max = 63;
1109 return 0;
1110}
1111
Takashi Iwaie571f592005-11-17 15:04:01 +01001112static int snd_es1938_get_hw_volume(struct snd_kcontrol *kcontrol,
1113 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114{
Takashi Iwaie571f592005-11-17 15:04:01 +01001115 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 ucontrol->value.integer.value[0] = snd_es1938_mixer_read(chip, 0x61) & 0x3f;
1117 ucontrol->value.integer.value[1] = snd_es1938_mixer_read(chip, 0x63) & 0x3f;
1118 return 0;
1119}
1120
Takashi Iwaie571f592005-11-17 15:04:01 +01001121static int snd_es1938_info_hw_switch(struct snd_kcontrol *kcontrol,
1122 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123{
1124 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1125 uinfo->count = 2;
1126 uinfo->value.integer.min = 0;
1127 uinfo->value.integer.max = 1;
1128 return 0;
1129}
1130
Takashi Iwaie571f592005-11-17 15:04:01 +01001131static int snd_es1938_get_hw_switch(struct snd_kcontrol *kcontrol,
1132 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133{
Takashi Iwaie571f592005-11-17 15:04:01 +01001134 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135 ucontrol->value.integer.value[0] = !(snd_es1938_mixer_read(chip, 0x61) & 0x40);
1136 ucontrol->value.integer.value[1] = !(snd_es1938_mixer_read(chip, 0x63) & 0x40);
1137 return 0;
1138}
1139
Takashi Iwaie571f592005-11-17 15:04:01 +01001140static void snd_es1938_hwv_free(struct snd_kcontrol *kcontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141{
Takashi Iwaie571f592005-11-17 15:04:01 +01001142 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 chip->master_volume = NULL;
1144 chip->master_switch = NULL;
1145 chip->hw_volume = NULL;
1146 chip->hw_switch = NULL;
1147}
1148
Takashi Iwaie571f592005-11-17 15:04:01 +01001149static int snd_es1938_reg_bits(struct es1938 *chip, unsigned char reg,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 unsigned char mask, unsigned char val)
1151{
1152 if (reg < 0xa0)
1153 return snd_es1938_mixer_bits(chip, reg, mask, val);
1154 else
1155 return snd_es1938_bits(chip, reg, mask, val);
1156}
1157
Takashi Iwaie571f592005-11-17 15:04:01 +01001158static int snd_es1938_reg_read(struct es1938 *chip, unsigned char reg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159{
1160 if (reg < 0xa0)
1161 return snd_es1938_mixer_read(chip, reg);
1162 else
1163 return snd_es1938_read(chip, reg);
1164}
1165
1166#define ES1938_SINGLE(xname, xindex, reg, shift, mask, invert) \
1167{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1168 .info = snd_es1938_info_single, \
1169 .get = snd_es1938_get_single, .put = snd_es1938_put_single, \
1170 .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
1171
Takashi Iwaie571f592005-11-17 15:04:01 +01001172static int snd_es1938_info_single(struct snd_kcontrol *kcontrol,
1173 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174{
1175 int mask = (kcontrol->private_value >> 16) & 0xff;
1176
1177 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1178 uinfo->count = 1;
1179 uinfo->value.integer.min = 0;
1180 uinfo->value.integer.max = mask;
1181 return 0;
1182}
1183
Takashi Iwaie571f592005-11-17 15:04:01 +01001184static int snd_es1938_get_single(struct snd_kcontrol *kcontrol,
1185 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186{
Takashi Iwaie571f592005-11-17 15:04:01 +01001187 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 int reg = kcontrol->private_value & 0xff;
1189 int shift = (kcontrol->private_value >> 8) & 0xff;
1190 int mask = (kcontrol->private_value >> 16) & 0xff;
1191 int invert = (kcontrol->private_value >> 24) & 0xff;
1192 int val;
1193
1194 val = snd_es1938_reg_read(chip, reg);
1195 ucontrol->value.integer.value[0] = (val >> shift) & mask;
1196 if (invert)
1197 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1198 return 0;
1199}
1200
Takashi Iwaie571f592005-11-17 15:04:01 +01001201static int snd_es1938_put_single(struct snd_kcontrol *kcontrol,
1202 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203{
Takashi Iwaie571f592005-11-17 15:04:01 +01001204 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 int reg = kcontrol->private_value & 0xff;
1206 int shift = (kcontrol->private_value >> 8) & 0xff;
1207 int mask = (kcontrol->private_value >> 16) & 0xff;
1208 int invert = (kcontrol->private_value >> 24) & 0xff;
1209 unsigned char val;
1210
1211 val = (ucontrol->value.integer.value[0] & mask);
1212 if (invert)
1213 val = mask - val;
1214 mask <<= shift;
1215 val <<= shift;
1216 return snd_es1938_reg_bits(chip, reg, mask, val) != val;
1217}
1218
1219#define ES1938_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
1220{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1221 .info = snd_es1938_info_double, \
1222 .get = snd_es1938_get_double, .put = snd_es1938_put_double, \
1223 .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
1224
Takashi Iwaie571f592005-11-17 15:04:01 +01001225static int snd_es1938_info_double(struct snd_kcontrol *kcontrol,
1226 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227{
1228 int mask = (kcontrol->private_value >> 24) & 0xff;
1229
1230 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1231 uinfo->count = 2;
1232 uinfo->value.integer.min = 0;
1233 uinfo->value.integer.max = mask;
1234 return 0;
1235}
1236
Takashi Iwaie571f592005-11-17 15:04:01 +01001237static int snd_es1938_get_double(struct snd_kcontrol *kcontrol,
1238 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239{
Takashi Iwaie571f592005-11-17 15:04:01 +01001240 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 int left_reg = kcontrol->private_value & 0xff;
1242 int right_reg = (kcontrol->private_value >> 8) & 0xff;
1243 int shift_left = (kcontrol->private_value >> 16) & 0x07;
1244 int shift_right = (kcontrol->private_value >> 19) & 0x07;
1245 int mask = (kcontrol->private_value >> 24) & 0xff;
1246 int invert = (kcontrol->private_value >> 22) & 1;
1247 unsigned char left, right;
1248
1249 left = snd_es1938_reg_read(chip, left_reg);
1250 if (left_reg != right_reg)
1251 right = snd_es1938_reg_read(chip, right_reg);
1252 else
1253 right = left;
1254 ucontrol->value.integer.value[0] = (left >> shift_left) & mask;
1255 ucontrol->value.integer.value[1] = (right >> shift_right) & mask;
1256 if (invert) {
1257 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1258 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
1259 }
1260 return 0;
1261}
1262
Takashi Iwaie571f592005-11-17 15:04:01 +01001263static int snd_es1938_put_double(struct snd_kcontrol *kcontrol,
1264 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265{
Takashi Iwaie571f592005-11-17 15:04:01 +01001266 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 int left_reg = kcontrol->private_value & 0xff;
1268 int right_reg = (kcontrol->private_value >> 8) & 0xff;
1269 int shift_left = (kcontrol->private_value >> 16) & 0x07;
1270 int shift_right = (kcontrol->private_value >> 19) & 0x07;
1271 int mask = (kcontrol->private_value >> 24) & 0xff;
1272 int invert = (kcontrol->private_value >> 22) & 1;
1273 int change;
1274 unsigned char val1, val2, mask1, mask2;
1275
1276 val1 = ucontrol->value.integer.value[0] & mask;
1277 val2 = ucontrol->value.integer.value[1] & mask;
1278 if (invert) {
1279 val1 = mask - val1;
1280 val2 = mask - val2;
1281 }
1282 val1 <<= shift_left;
1283 val2 <<= shift_right;
1284 mask1 = mask << shift_left;
1285 mask2 = mask << shift_right;
1286 if (left_reg != right_reg) {
1287 change = 0;
1288 if (snd_es1938_reg_bits(chip, left_reg, mask1, val1) != val1)
1289 change = 1;
1290 if (snd_es1938_reg_bits(chip, right_reg, mask2, val2) != val2)
1291 change = 1;
1292 } else {
1293 change = (snd_es1938_reg_bits(chip, left_reg, mask1 | mask2,
1294 val1 | val2) != (val1 | val2));
1295 }
1296 return change;
1297}
1298
Takashi Iwaie571f592005-11-17 15:04:01 +01001299static struct snd_kcontrol_new snd_es1938_controls[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300ES1938_DOUBLE("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0),
1301ES1938_DOUBLE("Master Playback Switch", 0, 0x60, 0x62, 6, 6, 1, 1),
1302{
1303 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1304 .name = "Hardware Master Playback Volume",
1305 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1306 .info = snd_es1938_info_hw_volume,
1307 .get = snd_es1938_get_hw_volume,
1308},
1309{
1310 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1311 .name = "Hardware Master Playback Switch",
1312 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1313 .info = snd_es1938_info_hw_switch,
1314 .get = snd_es1938_get_hw_switch,
1315},
1316ES1938_SINGLE("Hardware Volume Split", 0, 0x64, 7, 1, 0),
1317ES1938_DOUBLE("Line Playback Volume", 0, 0x3e, 0x3e, 4, 0, 15, 0),
1318ES1938_DOUBLE("CD Playback Volume", 0, 0x38, 0x38, 4, 0, 15, 0),
1319ES1938_DOUBLE("FM Playback Volume", 0, 0x36, 0x36, 4, 0, 15, 0),
1320ES1938_DOUBLE("Mono Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1321ES1938_DOUBLE("Mic Playback Volume", 0, 0x1a, 0x1a, 4, 0, 15, 0),
1322ES1938_DOUBLE("Aux Playback Volume", 0, 0x3a, 0x3a, 4, 0, 15, 0),
1323ES1938_DOUBLE("Capture Volume", 0, 0xb4, 0xb4, 4, 0, 15, 0),
1324ES1938_SINGLE("PC Speaker Volume", 0, 0x3c, 0, 7, 0),
1325ES1938_SINGLE("Record Monitor", 0, 0xa8, 3, 1, 0),
1326ES1938_SINGLE("Capture Switch", 0, 0x1c, 4, 1, 1),
1327{
1328 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1329 .name = "Capture Source",
1330 .info = snd_es1938_info_mux,
1331 .get = snd_es1938_get_mux,
1332 .put = snd_es1938_put_mux,
1333},
1334ES1938_DOUBLE("Mono Input Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1335ES1938_DOUBLE("PCM Capture Volume", 0, 0x69, 0x69, 4, 0, 15, 0),
1336ES1938_DOUBLE("Mic Capture Volume", 0, 0x68, 0x68, 4, 0, 15, 0),
1337ES1938_DOUBLE("Line Capture Volume", 0, 0x6e, 0x6e, 4, 0, 15, 0),
1338ES1938_DOUBLE("FM Capture Volume", 0, 0x6b, 0x6b, 4, 0, 15, 0),
1339ES1938_DOUBLE("Mono Capture Volume", 0, 0x6f, 0x6f, 4, 0, 15, 0),
1340ES1938_DOUBLE("CD Capture Volume", 0, 0x6a, 0x6a, 4, 0, 15, 0),
1341ES1938_DOUBLE("Aux Capture Volume", 0, 0x6c, 0x6c, 4, 0, 15, 0),
1342ES1938_DOUBLE("PCM Playback Volume", 0, 0x7c, 0x7c, 4, 0, 15, 0),
1343ES1938_DOUBLE("PCM Playback Volume", 1, 0x14, 0x14, 4, 0, 15, 0),
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 */
Takashi Iwaie571f592005-11-17 15:04:01 +01001362static void snd_es1938_chip_init(struct es1938 *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363{
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#ifdef CONFIG_PM
1389/*
1390 * PM support
1391 */
1392
1393static unsigned char saved_regs[SAVED_REG_SIZE+1] = {
1394 0x14, 0x1a, 0x1c, 0x3a, 0x3c, 0x3e, 0x36, 0x38,
1395 0x50, 0x52, 0x60, 0x61, 0x62, 0x63, 0x64, 0x68,
1396 0x69, 0x6a, 0x6b, 0x6d, 0x6e, 0x6f, 0x7c, 0x7d,
1397 0xa8, 0xb4,
1398};
1399
1400
Takashi Iwaib34a5802005-11-17 16:08:27 +01001401static int es1938_suspend(struct pci_dev *pci, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402{
Takashi Iwaib34a5802005-11-17 16:08:27 +01001403 struct snd_card *card = pci_get_drvdata(pci);
1404 struct es1938 *chip = card->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 unsigned char *s, *d;
1406
Takashi Iwaib34a5802005-11-17 16:08:27 +01001407 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 snd_pcm_suspend_all(chip->pcm);
1409
1410 /* save mixer-related registers */
1411 for (s = saved_regs, d = chip->saved_regs; *s; s++, d++)
1412 *d = snd_es1938_reg_read(chip, *s);
1413
1414 outb(0x00, SLIO_REG(chip, IRQCONTROL)); /* disable irqs */
Takashi Iwai93b9f422005-10-10 13:42:24 +02001415 if (chip->irq >= 0)
Takashi Iwaib34a5802005-11-17 16:08:27 +01001416 free_irq(chip->irq, chip);
1417 pci_disable_device(pci);
1418 pci_save_state(pci);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 return 0;
1420}
1421
Takashi Iwaib34a5802005-11-17 16:08:27 +01001422static int es1938_resume(struct pci_dev *pci)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423{
Takashi Iwaib34a5802005-11-17 16:08:27 +01001424 struct snd_card *card = pci_get_drvdata(pci);
1425 struct es1938 *chip = card->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 unsigned char *s, *d;
1427
Takashi Iwaib34a5802005-11-17 16:08:27 +01001428 pci_restore_state(pci);
1429 pci_enable_device(pci);
1430 request_irq(pci->irq, snd_es1938_interrupt,
Takashi Iwaie571f592005-11-17 15:04:01 +01001431 SA_INTERRUPT|SA_SHIRQ, "ES1938", chip);
Takashi Iwaib34a5802005-11-17 16:08:27 +01001432 chip->irq = pci->irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 snd_es1938_chip_init(chip);
1434
1435 /* restore mixer-related registers */
1436 for (s = saved_regs, d = chip->saved_regs; *s; s++, d++) {
1437 if (*s < 0xa0)
1438 snd_es1938_mixer_write(chip, *s, *d);
1439 else
1440 snd_es1938_write(chip, *s, *d);
1441 }
1442
Takashi Iwaib34a5802005-11-17 16:08:27 +01001443 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 return 0;
1445}
1446#endif /* CONFIG_PM */
1447
1448#ifdef SUPPORT_JOYSTICK
Takashi Iwaie571f592005-11-17 15:04:01 +01001449static int __devinit snd_es1938_create_gameport(struct es1938 *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450{
1451 struct gameport *gp;
1452
1453 chip->gameport = gp = gameport_allocate_port();
1454 if (!gp) {
1455 printk(KERN_ERR "es1938: cannot allocate memory for gameport\n");
1456 return -ENOMEM;
1457 }
1458
1459 gameport_set_name(gp, "ES1938");
1460 gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
1461 gameport_set_dev_parent(gp, &chip->pci->dev);
1462 gp->io = chip->game_port;
1463
1464 gameport_register_port(gp);
1465
1466 return 0;
1467}
1468
Takashi Iwaie571f592005-11-17 15:04:01 +01001469static void snd_es1938_free_gameport(struct es1938 *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470{
1471 if (chip->gameport) {
1472 gameport_unregister_port(chip->gameport);
1473 chip->gameport = NULL;
1474 }
1475}
1476#else
Takashi Iwaie571f592005-11-17 15:04:01 +01001477static inline int snd_es1938_create_gameport(struct es1938 *chip) { return -ENOSYS; }
1478static inline void snd_es1938_free_gameport(struct es1938 *chip) { }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479#endif /* SUPPORT_JOYSTICK */
1480
Takashi Iwaie571f592005-11-17 15:04:01 +01001481static int snd_es1938_free(struct es1938 *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482{
1483 /* disable irqs */
1484 outb(0x00, SLIO_REG(chip, IRQCONTROL));
1485 if (chip->rmidi)
1486 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0);
1487
1488 snd_es1938_free_gameport(chip);
1489
1490 if (chip->irq >= 0)
Takashi Iwaie571f592005-11-17 15:04:01 +01001491 free_irq(chip->irq, chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 pci_release_regions(chip->pci);
1493 pci_disable_device(chip->pci);
1494 kfree(chip);
1495 return 0;
1496}
1497
Takashi Iwaie571f592005-11-17 15:04:01 +01001498static int snd_es1938_dev_free(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499{
Takashi Iwaie571f592005-11-17 15:04:01 +01001500 struct es1938 *chip = device->device_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 return snd_es1938_free(chip);
1502}
1503
Takashi Iwaie571f592005-11-17 15:04:01 +01001504static int __devinit snd_es1938_create(struct snd_card *card,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 struct pci_dev * pci,
Takashi Iwaie571f592005-11-17 15:04:01 +01001506 struct es1938 ** rchip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507{
Takashi Iwaie571f592005-11-17 15:04:01 +01001508 struct es1938 *chip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 int err;
Takashi Iwaie571f592005-11-17 15:04:01 +01001510 static struct snd_device_ops ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 .dev_free = snd_es1938_dev_free,
1512 };
1513
1514 *rchip = NULL;
1515
1516 /* enable PCI device */
1517 if ((err = pci_enable_device(pci)) < 0)
1518 return err;
1519 /* check, if we can restrict PCI DMA transfers to 24 bits */
1520 if (pci_set_dma_mask(pci, 0x00ffffff) < 0 ||
1521 pci_set_consistent_dma_mask(pci, 0x00ffffff) < 0) {
Takashi Iwai99b359b2005-10-20 18:26:44 +02001522 snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 pci_disable_device(pci);
1524 return -ENXIO;
1525 }
1526
Takashi Iwaie560d8d2005-09-09 14:21:46 +02001527 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 if (chip == NULL) {
1529 pci_disable_device(pci);
1530 return -ENOMEM;
1531 }
1532 spin_lock_init(&chip->reg_lock);
1533 spin_lock_init(&chip->mixer_lock);
1534 chip->card = card;
1535 chip->pci = pci;
1536 if ((err = pci_request_regions(pci, "ESS Solo-1")) < 0) {
1537 kfree(chip);
1538 pci_disable_device(pci);
1539 return err;
1540 }
1541 chip->io_port = pci_resource_start(pci, 0);
1542 chip->sb_port = pci_resource_start(pci, 1);
1543 chip->vc_port = pci_resource_start(pci, 2);
1544 chip->mpu_port = pci_resource_start(pci, 3);
1545 chip->game_port = pci_resource_start(pci, 4);
Takashi Iwaie571f592005-11-17 15:04:01 +01001546 if (request_irq(pci->irq, snd_es1938_interrupt, SA_INTERRUPT|SA_SHIRQ,
1547 "ES1938", chip)) {
Takashi Iwai99b359b2005-10-20 18:26:44 +02001548 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 snd_es1938_free(chip);
1550 return -EBUSY;
1551 }
1552 chip->irq = pci->irq;
1553#ifdef ES1938_DDEBUG
Takashi Iwai99b359b2005-10-20 18:26:44 +02001554 snd_printk(KERN_DEBUG "create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port);
1556#endif
1557
1558 chip->ddma_port = chip->vc_port + 0x00; /* fix from Thomas Sailer */
1559
1560 snd_es1938_chip_init(chip);
1561
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1563 snd_es1938_free(chip);
1564 return err;
1565 }
1566
1567 snd_card_set_dev(card, &pci->dev);
1568
1569 *rchip = chip;
1570 return 0;
1571}
1572
1573/* --------------------------------------------------------------------
1574 * Interrupt handler
1575 * -------------------------------------------------------------------- */
1576static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1577{
Takashi Iwaie571f592005-11-17 15:04:01 +01001578 struct es1938 *chip = dev_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 unsigned char status, audiostatus;
1580 int handled = 0;
1581
1582 status = inb(SLIO_REG(chip, IRQCONTROL));
1583#if 0
1584 printk("Es1938debug - interrupt status: =0x%x\n", status);
1585#endif
1586
1587 /* AUDIO 1 */
1588 if (status & 0x10) {
1589#if 0
1590 printk("Es1938debug - AUDIO channel 1 interrupt\n");
Takashi Iwaie571f592005-11-17 15:04:01 +01001591 printk("Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n",
1592 inw(SLDM_REG(chip, DMACOUNT)));
1593 printk("Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n",
1594 inl(SLDM_REG(chip, DMAADDR)));
1595 printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n",
1596 inl(SLDM_REG(chip, DMASTATUS)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597#endif
1598 /* clear irq */
1599 handled = 1;
1600 audiostatus = inb(SLSB_REG(chip, STATUS));
1601 if (chip->active & ADC1)
1602 snd_pcm_period_elapsed(chip->capture_substream);
1603 else if (chip->active & DAC1)
1604 snd_pcm_period_elapsed(chip->playback2_substream);
1605 }
1606
1607 /* AUDIO 2 */
1608 if (status & 0x20) {
1609#if 0
1610 printk("Es1938debug - AUDIO channel 2 interrupt\n");
Takashi Iwaie571f592005-11-17 15:04:01 +01001611 printk("Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n",
1612 inw(SLIO_REG(chip, AUDIO2DMACOUNT)));
1613 printk("Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n",
1614 inl(SLIO_REG(chip, AUDIO2DMAADDR)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615
1616#endif
1617 /* clear irq */
1618 handled = 1;
1619 snd_es1938_mixer_bits(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x80, 0);
1620 if (chip->active & DAC2)
1621 snd_pcm_period_elapsed(chip->playback1_substream);
1622 }
1623
1624 /* Hardware volume */
1625 if (status & 0x40) {
1626 int split = snd_es1938_mixer_read(chip, 0x64) & 0x80;
1627 handled = 1;
1628 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id);
1629 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id);
1630 if (!split) {
Takashi Iwaie571f592005-11-17 15:04:01 +01001631 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1632 &chip->master_switch->id);
1633 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1634 &chip->master_volume->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 }
1636 /* ack interrupt */
1637 snd_es1938_mixer_write(chip, 0x66, 0x00);
1638 }
1639
1640 /* MPU401 */
1641 if (status & 0x80) {
1642 // the following line is evil! It switches off MIDI interrupt handling after the first interrupt received.
1643 // replacing the last 0 by 0x40 works for ESS-Solo1, but just doing nothing works as well!
1644 // andreas@flying-snail.de
1645 // snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); /* ack? */
1646 if (chip->rmidi) {
1647 handled = 1;
1648 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
1649 }
1650 }
1651 return IRQ_RETVAL(handled);
1652}
1653
1654#define ES1938_DMA_SIZE 64
1655
Takashi Iwaie571f592005-11-17 15:04:01 +01001656static int __devinit snd_es1938_mixer(struct es1938 *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657{
Takashi Iwaie571f592005-11-17 15:04:01 +01001658 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 unsigned int idx;
1660 int err;
1661
1662 card = chip->card;
1663
1664 strcpy(card->mixername, "ESS Solo-1");
1665
1666 for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) {
Takashi Iwaie571f592005-11-17 15:04:01 +01001667 struct snd_kcontrol *kctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip);
1669 switch (idx) {
1670 case 0:
1671 chip->master_volume = kctl;
1672 kctl->private_free = snd_es1938_hwv_free;
1673 break;
1674 case 1:
1675 chip->master_switch = kctl;
1676 kctl->private_free = snd_es1938_hwv_free;
1677 break;
1678 case 2:
1679 chip->hw_volume = kctl;
1680 kctl->private_free = snd_es1938_hwv_free;
1681 break;
1682 case 3:
1683 chip->hw_switch = kctl;
1684 kctl->private_free = snd_es1938_hwv_free;
1685 break;
1686 }
1687 if ((err = snd_ctl_add(card, kctl)) < 0)
1688 return err;
1689 }
1690 return 0;
1691}
1692
1693
1694static int __devinit snd_es1938_probe(struct pci_dev *pci,
1695 const struct pci_device_id *pci_id)
1696{
1697 static int dev;
Takashi Iwaie571f592005-11-17 15:04:01 +01001698 struct snd_card *card;
1699 struct es1938 *chip;
1700 struct snd_opl3 *opl3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 int idx, err;
1702
1703 if (dev >= SNDRV_CARDS)
1704 return -ENODEV;
1705 if (!enable[dev]) {
1706 dev++;
1707 return -ENOENT;
1708 }
1709
1710 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
1711 if (card == NULL)
1712 return -ENOMEM;
1713 for (idx = 0; idx < 5; idx++) {
1714 if (pci_resource_start(pci, idx) == 0 ||
1715 !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) {
1716 snd_card_free(card);
1717 return -ENODEV;
1718 }
1719 }
1720 if ((err = snd_es1938_create(card, pci, &chip)) < 0) {
1721 snd_card_free(card);
1722 return err;
1723 }
Takashi Iwaib34a5802005-11-17 16:08:27 +01001724 card->private_data = chip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725
1726 strcpy(card->driver, "ES1938");
1727 strcpy(card->shortname, "ESS ES1938 (Solo-1)");
1728 sprintf(card->longname, "%s rev %i, irq %i",
1729 card->shortname,
1730 chip->revision,
1731 chip->irq);
1732
1733 if ((err = snd_es1938_new_pcm(chip, 0)) < 0) {
1734 snd_card_free(card);
1735 return err;
1736 }
1737 if ((err = snd_es1938_mixer(chip)) < 0) {
1738 snd_card_free(card);
1739 return err;
1740 }
1741 if (snd_opl3_create(card,
1742 SLSB_REG(chip, FMLOWADDR),
1743 SLSB_REG(chip, FMHIGHADDR),
1744 OPL3_HW_OPL3, 1, &opl3) < 0) {
1745 printk(KERN_ERR "es1938: OPL3 not detected at 0x%lx\n",
1746 SLSB_REG(chip, FMLOWADDR));
1747 } else {
1748 if ((err = snd_opl3_timer_new(opl3, 0, 1)) < 0) {
1749 snd_card_free(card);
1750 return err;
1751 }
1752 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
1753 snd_card_free(card);
1754 return err;
1755 }
1756 }
1757 if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
1758 chip->mpu_port, 1, chip->irq, 0, &chip->rmidi) < 0) {
1759 printk(KERN_ERR "es1938: unable to initialize MPU-401\n");
1760 } else {
1761 // this line is vital for MIDI interrupt handling on ess-solo1
1762 // andreas@flying-snail.de
1763 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0x40);
1764 }
1765
1766 snd_es1938_create_gameport(chip);
1767
1768 if ((err = snd_card_register(card)) < 0) {
1769 snd_card_free(card);
1770 return err;
1771 }
1772
1773 pci_set_drvdata(pci, card);
1774 dev++;
1775 return 0;
1776}
1777
1778static void __devexit snd_es1938_remove(struct pci_dev *pci)
1779{
1780 snd_card_free(pci_get_drvdata(pci));
1781 pci_set_drvdata(pci, NULL);
1782}
1783
1784static struct pci_driver driver = {
1785 .name = "ESS ES1938 (Solo-1)",
1786 .id_table = snd_es1938_ids,
1787 .probe = snd_es1938_probe,
1788 .remove = __devexit_p(snd_es1938_remove),
Takashi Iwaib34a5802005-11-17 16:08:27 +01001789#ifdef CONFIG_PM
1790 .suspend = es1938_suspend,
1791 .resume = es1938_resume,
1792#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793};
1794
1795static int __init alsa_card_es1938_init(void)
1796{
Takashi Iwai01d25d42005-04-11 16:58:24 +02001797 return pci_register_driver(&driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798}
1799
1800static void __exit alsa_card_es1938_exit(void)
1801{
1802 pci_unregister_driver(&driver);
1803}
1804
1805module_init(alsa_card_es1938_init)
1806module_exit(alsa_card_es1938_exit)