source: GPL/trunk/alsa-kernel/pci/es1938.c@ 251

Last change on this file since 251 was 77, checked in by vladest, 19 years ago

Provide sources to latest exist binary. See changelog for changes
File size: 53.9 KB
Line 
1/*
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
79static 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
83//module_param_array(index, int, NULL, 0444);
84MODULE_PARM_DESC(index, "Index value for ESS Solo-1 soundcard.");
85//module_param_array(id, charp, NULL, 0444);
86MODULE_PARM_DESC(id, "ID string for ESS Solo-1 soundcard.");
87//module_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
194#define SAVED_REG_SIZE 32 /* max. number of registers to save */
195
196struct es1938 {
197 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
209 struct snd_kcontrol *hw_volume;
210 struct snd_kcontrol *hw_switch;
211 struct snd_kcontrol *master_volume;
212 struct snd_kcontrol *master_switch;
213
214 struct pci_dev *pci;
215 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;
221
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;
232 struct snd_info_entry *proc_entry;
233
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 * -----------------------------------------------------------------*/
259static void snd_es1938_mixer_write(struct es1938 *chip, unsigned char reg, unsigned char val)
260{
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
267 snd_printk(KERN_DEBUG "Mixer reg %02x set to %02x\n", reg, val);
268#endif
269}
270
271/* -----------------------------------------------------------------
272 * Read from a mixer register
273 * -----------------------------------------------------------------*/
274static int snd_es1938_mixer_read(struct es1938 *chip, unsigned char reg)
275{
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
283 snd_printk(KERN_DEBUG "Mixer reg %02x now is %02x\n", reg, data);
284#endif
285 return data;
286}
287
288/* -----------------------------------------------------------------
289 * Write to some bits of a mixer register (return old value)
290 * -----------------------------------------------------------------*/
291static int snd_es1938_mixer_bits(struct es1938 *chip, unsigned char reg,
292 unsigned char mask, unsigned char val)
293{
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
304 snd_printk(KERN_DEBUG "Mixer reg %02x was %02x, set to %02x\n",
305 reg, old, new);
306#endif
307 }
308 spin_unlock_irqrestore(&chip->mixer_lock, flags);
309 return oval;
310}
311
312/* -----------------------------------------------------------------
313 * Write command to Controller Registers
314 * -----------------------------------------------------------------*/
315static void snd_es1938_write_cmd(struct es1938 *chip, unsigned char cmd)
316{
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 }
325 printk(KERN_ERR "snd_es1938_write_cmd timeout (0x02%x/0x02%x)\n", cmd, v);
326}
327
328/* -----------------------------------------------------------------
329 * Read the Read Data Buffer
330 * -----------------------------------------------------------------*/
331static int snd_es1938_get_byte(struct es1938 *chip)
332{
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));
338 snd_printk(KERN_ERR "get_byte timeout: status 0x02%x\n", v);
339 return -ENODEV;
340}
341
342/* -----------------------------------------------------------------
343 * Write value cmd register
344 * -----------------------------------------------------------------*/
345static void snd_es1938_write(struct es1938 *chip, unsigned char reg, unsigned char val)
346{
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
353 snd_printk(KERN_DEBUG "Reg %02x set to %02x\n", reg, val);
354#endif
355}
356
357/* -----------------------------------------------------------------
358 * Read data from cmd register and return it
359 * -----------------------------------------------------------------*/
360static unsigned char snd_es1938_read(struct es1938 *chip, unsigned char reg)
361{
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
370 snd_printk(KERN_DEBUG "Reg %02x now is %02x\n", reg, val);
371#endif
372 return val;
373}
374
375/* -----------------------------------------------------------------
376 * Write data to cmd register and return old value
377 * -----------------------------------------------------------------*/
378static int snd_es1938_bits(struct es1938 *chip, unsigned char reg, unsigned char mask,
379 unsigned char val)
380{
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
393 snd_printk(KERN_DEBUG "Reg %02x was %02x, set to %02x\n",
394 reg, old, new);
395#endif
396 }
397 spin_unlock_irqrestore(&chip->reg_lock, flags);
398 return oval;
399}
400
401/* --------------------------------------------------------------------
402 * Reset the chip
403 * --------------------------------------------------------------------*/
404static void snd_es1938_reset(struct es1938 *chip)
405{
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 }
417 snd_printk(KERN_ERR "ESS Solo-1 reset failed\n");
418
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 * --------------------------------------------------------------------*/
443static void snd_es1938_reset_fifo(struct es1938 *chip)
444{
445 outb(2, SLSB_REG(chip, RESET));
446 outb(0, SLSB_REG(chip, RESET));
447}
448
449static struct snd_ratnum clocks[2] = {
450 {
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
464static struct snd_pcm_hw_constraint_ratnums hw_constraints_clocks = {
465 .nrats = 2,
466 .rats = clocks,
467};
468
469
470static void snd_es1938_rate_set(struct es1938 *chip,
471 struct snd_pcm_substream *substream,
472 int mode)
473{
474 unsigned int bits, div0;
475 struct snd_pcm_runtime *runtime = substream->runtime;
476 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
497static void snd_es1938_playback1_setdma(struct es1938 *chip)
498{
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
505static void snd_es1938_playback2_setdma(struct es1938 *chip)
506{
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
520static void snd_es1938_capture_setdma(struct es1938 *chip)
521{
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
540static int snd_es1938_capture_trigger(struct snd_pcm_substream *substream,
541 int cmd)
542{
543 struct es1938 *chip = snd_pcm_substream_chip(substream);
544 int val;
545 switch (cmd) {
546 case SNDRV_PCM_TRIGGER_START:
547 case SNDRV_PCM_TRIGGER_RESUME:
548 val = 0x0f;
549 chip->active |= ADC1;
550 break;
551 case SNDRV_PCM_TRIGGER_STOP:
552 case SNDRV_PCM_TRIGGER_SUSPEND:
553 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
563static int snd_es1938_playback1_trigger(struct snd_pcm_substream *substream,
564 int cmd)
565{
566 struct es1938 *chip = snd_pcm_substream_chip(substream);
567 switch (cmd) {
568 case SNDRV_PCM_TRIGGER_START:
569 case SNDRV_PCM_TRIGGER_RESUME:
570 /* 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:
582 case SNDRV_PCM_TRIGGER_SUSPEND:
583 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
593static int snd_es1938_playback2_trigger(struct snd_pcm_substream *substream,
594 int cmd)
595{
596 struct es1938 *chip = snd_pcm_substream_chip(substream);
597 int val;
598 switch (cmd) {
599 case SNDRV_PCM_TRIGGER_START:
600 case SNDRV_PCM_TRIGGER_RESUME:
601 val = 5;
602 chip->active |= DAC1;
603 break;
604 case SNDRV_PCM_TRIGGER_STOP:
605 case SNDRV_PCM_TRIGGER_SUSPEND:
606 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
616static int snd_es1938_playback_trigger(struct snd_pcm_substream *substream,
617 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 * --------------------------------------------------------------------*/
632static int snd_es1938_capture_prepare(struct snd_pcm_substream *substream)
633{
634 struct es1938 *chip = snd_pcm_substream_chip(substream);
635 struct snd_pcm_runtime *runtime = substream->runtime;
636 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 * ------------------------------------------------------------------------------*/
680static int snd_es1938_playback1_prepare(struct snd_pcm_substream *substream)
681{
682 struct es1938 *chip = snd_pcm_substream_chip(substream);
683 struct snd_pcm_runtime *runtime = substream->runtime;
684 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 */
708 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x40 | (u ? 0 : 4) |
709 (mono ? 0 : 2) | (is8 ? 0 : 1));
710
711 /* program DMA */
712 snd_es1938_playback1_setdma(chip);
713
714 return 0;
715}
716
717static int snd_es1938_playback2_prepare(struct snd_pcm_substream *substream)
718{
719 struct es1938 *chip = snd_pcm_substream_chip(substream);
720 struct snd_pcm_runtime *runtime = substream->runtime;
721 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
759static int snd_es1938_playback_prepare(struct snd_pcm_substream *substream)
760{
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
771static snd_pcm_uframes_t snd_es1938_capture_pointer(struct snd_pcm_substream *substream)
772{
773 struct es1938 *chip = snd_pcm_substream_chip(substream);
774 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
788static snd_pcm_uframes_t snd_es1938_playback1_pointer(struct snd_pcm_substream *substream)
789{
790 struct es1938 *chip = snd_pcm_substream_chip(substream);
791 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
800static snd_pcm_uframes_t snd_es1938_playback2_pointer(struct snd_pcm_substream *substream)
801{
802 struct es1938 *chip = snd_pcm_substream_chip(substream);
803 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
817static snd_pcm_uframes_t snd_es1938_playback_pointer(struct snd_pcm_substream *substream)
818{
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
829static int snd_es1938_capture_copy(struct snd_pcm_substream *substream,
830 int channel,
831 snd_pcm_uframes_t pos,
832 void __user *dst,
833 snd_pcm_uframes_t count)
834{
835 struct snd_pcm_runtime *runtime = substream->runtime;
836 struct es1938 *chip = snd_pcm_substream_chip(substream);
837 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 */
855static int snd_es1938_pcm_hw_params(struct snd_pcm_substream *substream,
856 struct snd_pcm_hw_params *hw_params)
857
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
866static int snd_es1938_pcm_hw_free(struct snd_pcm_substream *substream)
867{
868 return snd_pcm_lib_free_pages(substream);
869}
870
871/* ----------------------------------------------------------------------
872 * Audio1 Capture (ADC)
873 * ----------------------------------------------------------------------*/
874static struct snd_pcm_hardware snd_es1938_capture =
875{
876 .info = (SNDRV_PCM_INFO_INTERLEAVED |
877 SNDRV_PCM_INFO_BLOCK_TRANSFER),
878 .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
879 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
880 .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 * -----------------------------------------------------------------------*/
896static struct snd_pcm_hardware snd_es1938_playback =
897{
898 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
899 SNDRV_PCM_INFO_BLOCK_TRANSFER |
900 SNDRV_PCM_INFO_MMAP_VALID),
901 .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
902 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
903 .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
916static int snd_es1938_capture_open(struct snd_pcm_substream *substream)
917{
918 struct es1938 *chip = snd_pcm_substream_chip(substream);
919 struct snd_pcm_runtime *runtime = substream->runtime;
920
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
931static int snd_es1938_playback_open(struct snd_pcm_substream *substream)
932{
933 struct es1938 *chip = snd_pcm_substream_chip(substream);
934 struct snd_pcm_runtime *runtime = substream->runtime;
935
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
956static int snd_es1938_capture_close(struct snd_pcm_substream *substream)
957{
958 struct es1938 *chip = snd_pcm_substream_chip(substream);
959
960 chip->capture_substream = NULL;
961 return 0;
962}
963
964static int snd_es1938_playback_close(struct snd_pcm_substream *substream)
965{
966 struct es1938 *chip = snd_pcm_substream_chip(substream);
967
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
982static struct snd_pcm_ops snd_es1938_playback_ops = {
983 .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
993static struct snd_pcm_ops snd_es1938_capture_ops = {
994 .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
1005static int __devinit snd_es1938_new_pcm(struct es1938 *chip, int device)
1006{
1007 struct snd_pcm *pcm;
1008 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;
1016 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
1031static int snd_es1938_info_mux(struct snd_kcontrol *kcontrol,
1032 struct snd_ctl_elem_info *uinfo)
1033{
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
1048static int snd_es1938_get_mux(struct snd_kcontrol *kcontrol,
1049 struct snd_ctl_elem_value *ucontrol)
1050{
1051 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1052 ucontrol->value.enumerated.item[0] = snd_es1938_mixer_read(chip, 0x1c) & 0x07;
1053 return 0;
1054}
1055
1056static int snd_es1938_put_mux(struct snd_kcontrol *kcontrol,
1057 struct snd_ctl_elem_value *ucontrol)
1058{
1059 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1060 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
1067static int snd_es1938_info_spatializer_enable(struct snd_kcontrol *kcontrol,
1068 struct snd_ctl_elem_info *uinfo)
1069{
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
1077static int snd_es1938_get_spatializer_enable(struct snd_kcontrol *kcontrol,
1078 struct snd_ctl_elem_value *ucontrol)
1079{
1080 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1081 unsigned char val = snd_es1938_mixer_read(chip, 0x50);
1082 ucontrol->value.integer.value[0] = !!(val & 8);
1083 return 0;
1084}
1085
1086static int snd_es1938_put_spatializer_enable(struct snd_kcontrol *kcontrol,
1087 struct snd_ctl_elem_value *ucontrol)
1088{
1089 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1090 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
1102static int snd_es1938_info_hw_volume(struct snd_kcontrol *kcontrol,
1103 struct snd_ctl_elem_info *uinfo)
1104{
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
1112static int snd_es1938_get_hw_volume(struct snd_kcontrol *kcontrol,
1113 struct snd_ctl_elem_value *ucontrol)
1114{
1115 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1116 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
1121static int snd_es1938_info_hw_switch(struct snd_kcontrol *kcontrol,
1122 struct snd_ctl_elem_info *uinfo)
1123{
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
1131static int snd_es1938_get_hw_switch(struct snd_kcontrol *kcontrol,
1132 struct snd_ctl_elem_value *ucontrol)
1133{
1134 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1135 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
1140static void snd_es1938_hwv_free(struct snd_kcontrol *kcontrol)
1141{
1142 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1143 chip->master_volume = NULL;
1144 chip->master_switch = NULL;
1145 chip->hw_volume = NULL;
1146 chip->hw_switch = NULL;
1147}
1148
1149static int snd_es1938_reg_bits(struct es1938 *chip, unsigned char reg,
1150 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
1158static int snd_es1938_reg_read(struct es1938 *chip, unsigned char reg)
1159{
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
1172static int snd_es1938_info_single(struct snd_kcontrol *kcontrol,
1173 struct snd_ctl_elem_info *uinfo)
1174{
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
1184static int snd_es1938_get_single(struct snd_kcontrol *kcontrol,
1185 struct snd_ctl_elem_value *ucontrol)
1186{
1187 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1188 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
1201static int snd_es1938_put_single(struct snd_kcontrol *kcontrol,
1202 struct snd_ctl_elem_value *ucontrol)
1203{
1204 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1205 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
1225static int snd_es1938_info_double(struct snd_kcontrol *kcontrol,
1226 struct snd_ctl_elem_info *uinfo)
1227{
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
1237static int snd_es1938_get_double(struct snd_kcontrol *kcontrol,
1238 struct snd_ctl_elem_value *ucontrol)
1239{
1240 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1241 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
1263static int snd_es1938_put_double(struct snd_kcontrol *kcontrol,
1264 struct snd_ctl_elem_value *ucontrol)
1265{
1266 struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1267 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
1299static struct snd_kcontrol_new snd_es1938_controls[] = {
1300ES1938_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 */
1362static void snd_es1938_chip_init(struct es1938 *chip)
1363{
1364 /* reset chip */
1365 snd_es1938_reset(chip);
1366
1367 /* configure native mode */
1368
1369 /* enable bus master */
1370 pci_set_master(chip->pci);
1371
1372 /* disable legacy audio */
1373 pci_write_config_word(chip->pci, SL_PCI_LEGACYCONTROL, 0x805f);
1374
1375 /* set DDMA base */
1376 pci_write_config_word(chip->pci, SL_PCI_DDMACONTROL, chip->ddma_port | 1);
1377
1378 /* set DMA/IRQ policy */
1379 pci_write_config_dword(chip->pci, SL_PCI_CONFIG, 0);
1380
1381 /* enable Audio 1, Audio 2, MPU401 IRQ and HW volume IRQ*/
1382 outb(0xf0, SLIO_REG(chip, IRQCONTROL));
1383
1384 /* reset DMA */
1385 outb(0, SLDM_REG(chip, DMACLEAR));
1386}
1387
1388#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
1401static int es1938_suspend(struct pci_dev *pci, pm_message_t state)
1402{
1403 struct snd_card *card = pci_get_drvdata(pci);
1404 struct es1938 *chip = card->private_data;
1405 unsigned char *s, *d;
1406
1407 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1408 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 */
1415 if (chip->irq >= 0)
1416 free_irq(chip->irq, chip);
1417 pci_disable_device(pci);
1418 pci_save_state(pci);
1419 return 0;
1420}
1421
1422static int es1938_resume(struct pci_dev *pci)
1423{
1424 struct snd_card *card = pci_get_drvdata(pci);
1425 struct es1938 *chip = card->private_data;
1426 unsigned char *s, *d;
1427
1428 pci_restore_state(pci);
1429 pci_enable_device(pci);
1430 request_irq(pci->irq, snd_es1938_interrupt,
1431 SA_INTERRUPT|SA_SHIRQ, "ES1938", chip);
1432 chip->irq = pci->irq;
1433 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
1443 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1444 return 0;
1445}
1446#endif /* CONFIG_PM */
1447
1448#ifdef SUPPORT_JOYSTICK
1449static int __devinit snd_es1938_create_gameport(struct es1938 *chip)
1450{
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
1469static void snd_es1938_free_gameport(struct es1938 *chip)
1470{
1471 if (chip->gameport) {
1472 gameport_unregister_port(chip->gameport);
1473 chip->gameport = NULL;
1474 }
1475}
1476#else
1477static inline int snd_es1938_create_gameport(struct es1938 *chip) { return -ENOSYS; }
1478static inline void snd_es1938_free_gameport(struct es1938 *chip) { }
1479#endif /* SUPPORT_JOYSTICK */
1480
1481static int snd_es1938_free(struct es1938 *chip)
1482{
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)
1491 free_irq(chip->irq, chip);
1492 pci_release_regions(chip->pci);
1493 pci_disable_device(chip->pci);
1494 kfree(chip);
1495 return 0;
1496}
1497
1498static int snd_es1938_dev_free(struct snd_device *device)
1499{
1500 struct es1938 *chip = device->device_data;
1501 return snd_es1938_free(chip);
1502}
1503
1504static int __devinit snd_es1938_create(struct snd_card *card,
1505 struct pci_dev * pci,
1506 struct es1938 ** rchip)
1507{
1508 struct es1938 *chip;
1509 int err;
1510 static struct snd_device_ops ops = {
1511 .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 pci_set_dma_mask(pci, 0x00ffffff);
1521
1522 chip = (struct es1938 *)kzalloc(sizeof(*chip), GFP_KERNEL);
1523 if (chip == NULL) {
1524 pci_disable_device(pci);
1525 return -ENOMEM;
1526 }
1527 spin_lock_init(&chip->reg_lock);
1528 spin_lock_init(&chip->mixer_lock);
1529 chip->card = card;
1530 chip->pci = pci;
1531 if ((err = pci_request_regions(pci, "ESS Solo-1")) < 0) {
1532 kfree(chip);
1533 pci_disable_device(pci);
1534 return err;
1535 }
1536 chip->io_port = pci_resource_start(pci, 0);
1537 chip->sb_port = pci_resource_start(pci, 1);
1538 chip->vc_port = pci_resource_start(pci, 2);
1539 chip->mpu_port = pci_resource_start(pci, 3);
1540 chip->game_port = pci_resource_start(pci, 4);
1541 if (request_irq(pci->irq, snd_es1938_interrupt, SA_INTERRUPT|SA_SHIRQ,
1542 "ES1938", chip)) {
1543 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
1544 snd_es1938_free(chip);
1545 return -EBUSY;
1546 }
1547 chip->irq = pci->irq;
1548#ifdef ES1938_DDEBUG
1549 snd_printk(KERN_DEBUG "create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
1550 chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port);
1551#endif
1552
1553 chip->ddma_port = chip->vc_port + 0x00; /* fix from Thomas Sailer */
1554
1555 snd_es1938_chip_init(chip);
1556
1557 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1558 snd_es1938_free(chip);
1559 return err;
1560 }
1561
1562 snd_card_set_dev(card, &pci->dev);
1563
1564 *rchip = chip;
1565 return 0;
1566}
1567
1568/* --------------------------------------------------------------------
1569 * Interrupt handler
1570 * -------------------------------------------------------------------- */
1571static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1572{
1573 struct es1938 *chip = dev_id;
1574 unsigned char status, audiostatus;
1575 int handled = 0;
1576
1577 status = inb(SLIO_REG(chip, IRQCONTROL));
1578#if 0
1579 printk("Es1938debug - interrupt status: =0x%x\n", status);
1580#endif
1581
1582 /* AUDIO 1 */
1583 if (status & 0x10) {
1584#if 0
1585 printk("Es1938debug - AUDIO channel 1 interrupt\n");
1586 printk("Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n",
1587 inw(SLDM_REG(chip, DMACOUNT)));
1588 printk("Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n",
1589 inl(SLDM_REG(chip, DMAADDR)));
1590 printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n",
1591 inl(SLDM_REG(chip, DMASTATUS)));
1592#endif
1593 /* clear irq */
1594 handled = 1;
1595 audiostatus = inb(SLSB_REG(chip, STATUS));
1596 if (chip->active & ADC1)
1597 snd_pcm_period_elapsed(chip->capture_substream);
1598 else if (chip->active & DAC1)
1599 snd_pcm_period_elapsed(chip->playback2_substream);
1600 }
1601
1602 /* AUDIO 2 */
1603 if (status & 0x20) {
1604#if 0
1605 printk("Es1938debug - AUDIO channel 2 interrupt\n");
1606 printk("Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n",
1607 inw(SLIO_REG(chip, AUDIO2DMACOUNT)));
1608 printk("Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n",
1609 inl(SLIO_REG(chip, AUDIO2DMAADDR)));
1610
1611#endif
1612 /* clear irq */
1613 handled = 1;
1614 snd_es1938_mixer_bits(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x80, 0);
1615 if (chip->active & DAC2)
1616 snd_pcm_period_elapsed(chip->playback1_substream);
1617 }
1618
1619 /* Hardware volume */
1620 if (status & 0x40) {
1621 int split = snd_es1938_mixer_read(chip, 0x64) & 0x80;
1622 handled = 1;
1623 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id);
1624 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id);
1625 if (!split) {
1626 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1627 &chip->master_switch->id);
1628 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1629 &chip->master_volume->id);
1630 }
1631 /* ack interrupt */
1632 snd_es1938_mixer_write(chip, 0x66, 0x00);
1633 }
1634
1635 /* MPU401 */
1636 if (status & 0x80) {
1637 // the following line is evil! It switches off MIDI interrupt handling after the first interrupt received.
1638 // replacing the last 0 by 0x40 works for ESS-Solo1, but just doing nothing works as well!
1639 // andreas@flying-snail.de
1640 // snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); /* ack? */
1641 if (chip->rmidi) {
1642 handled = 1;
1643 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
1644 }
1645 }
1646 return IRQ_RETVAL(handled);
1647}
1648
1649#define ES1938_DMA_SIZE 64
1650
1651static int __devinit snd_es1938_mixer(struct es1938 *chip)
1652{
1653 struct snd_card *card;
1654 unsigned int idx;
1655 int err;
1656
1657 card = chip->card;
1658
1659 strcpy(card->mixername, "ESS Solo-1");
1660
1661 for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) {
1662 struct snd_kcontrol *kctl;
1663 kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip);
1664 switch (idx) {
1665 case 0:
1666 chip->master_volume = kctl;
1667 kctl->private_free = snd_es1938_hwv_free;
1668 break;
1669 case 1:
1670 chip->master_switch = kctl;
1671 kctl->private_free = snd_es1938_hwv_free;
1672 break;
1673 case 2:
1674 chip->hw_volume = kctl;
1675 kctl->private_free = snd_es1938_hwv_free;
1676 break;
1677 case 3:
1678 chip->hw_switch = kctl;
1679 kctl->private_free = snd_es1938_hwv_free;
1680 break;
1681 }
1682 if ((err = snd_ctl_add(card, kctl)) < 0)
1683 return err;
1684 }
1685 return 0;
1686}
1687
1688
1689static int __devinit snd_es1938_probe(struct pci_dev *pci,
1690 const struct pci_device_id *pci_id)
1691{
1692 static int dev;
1693 struct snd_card *card;
1694 struct es1938 *chip;
1695 struct snd_opl3 *opl3;
1696 int idx, err;
1697
1698 if (dev >= SNDRV_CARDS)
1699 return -ENODEV;
1700 if (!enable[dev]) {
1701 dev++;
1702 return -ENOENT;
1703 }
1704
1705 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
1706 if (card == NULL)
1707 return -ENOMEM;
1708 for (idx = 0; idx < 5; idx++) {
1709 if (pci_resource_start(pci, idx) == 0 ||
1710 !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) {
1711 snd_card_free(card);
1712 return -ENODEV;
1713 }
1714 }
1715 if ((err = snd_es1938_create(card, pci, &chip)) < 0) {
1716 snd_card_free(card);
1717 return err;
1718 }
1719 card->private_data = chip;
1720
1721 strcpy(card->driver, "ES1938");
1722 strcpy(card->shortname, "ESS ES1938 (Solo-1)");
1723 sprintf(card->longname, "%s rev %i, irq %i",
1724 card->shortname,
1725 chip->revision,
1726 chip->irq);
1727
1728 if ((err = snd_es1938_new_pcm(chip, 0)) < 0) {
1729 snd_card_free(card);
1730 return err;
1731 }
1732 if ((err = snd_es1938_mixer(chip)) < 0) {
1733 snd_card_free(card);
1734 return err;
1735 }
1736 if (snd_opl3_create(card,
1737 SLSB_REG(chip, FMLOWADDR),
1738 SLSB_REG(chip, FMHIGHADDR),
1739 OPL3_HW_OPL3, 1, &opl3) < 0) {
1740 printk(KERN_ERR "es1938: OPL3 not detected at 0x%lx\n",
1741 SLSB_REG(chip, FMLOWADDR));
1742 } else {
1743 if ((err = snd_opl3_timer_new(opl3, 0, 1)) < 0) {
1744 snd_card_free(card);
1745 return err;
1746 }
1747 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
1748 snd_card_free(card);
1749 return err;
1750 }
1751 }
1752 if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
1753 chip->mpu_port, MPU401_INFO_INTEGRATED,
1754 chip->irq, 0, &chip->rmidi) < 0) {
1755 printk(KERN_ERR "es1938: unable to initialize MPU-401\n");
1756 } else {
1757 // this line is vital for MIDI interrupt handling on ess-solo1
1758 // andreas@flying-snail.de
1759 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0x40);
1760 }
1761
1762 snd_es1938_create_gameport(chip);
1763
1764 if ((err = snd_card_register(card)) < 0) {
1765 snd_card_free(card);
1766 return err;
1767 }
1768
1769 pci_set_drvdata(pci, card);
1770 dev++;
1771 return 0;
1772}
1773
1774static void __devexit snd_es1938_remove(struct pci_dev *pci)
1775{
1776 snd_card_free(pci_get_drvdata(pci));
1777 pci_set_drvdata(pci, NULL);
1778}
1779
1780static struct pci_driver driver = {
1781 .name = "ESS ES1938 (Solo-1)",
1782 .id_table = snd_es1938_ids,
1783 .probe = snd_es1938_probe,
1784 .remove = snd_es1938_remove,
1785#ifdef CONFIG_PM
1786 .suspend = es1938_suspend,
1787 .resume = es1938_resume,
1788#endif
1789};
1790
1791static int __init alsa_card_es1938_init(void)
1792{
1793 return pci_register_driver(&driver);
1794}
1795
1796static void __exit alsa_card_es1938_exit(void)
1797{
1798 pci_unregister_driver(&driver);
1799}
1800
1801module_init(alsa_card_es1938_init)
1802module_exit(alsa_card_es1938_exit)
Note: See TracBrowser for help on using the repository browser.