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