?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[IPX]: Fix typo, ipxhdr() --> ipx_hdr()
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / sound / pci / es1938.c
blob0d556b09ad046773818ecdb82b60c4dc0adb93bb
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 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
76 #define SUPPORT_JOYSTICK 1
77 #endif
78
79 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
80 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
81 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */
82
83 module_param_array(index, int, NULL, 0444);
84 MODULE_PARM_DESC(index, "Index value for ESS Solo-1 soundcard.");
85 module_param_array(id, charp, NULL, 0444);
86 MODULE_PARM_DESC(id, "ID string for ESS Solo-1 soundcard.");
87 module_param_array(enable, bool, NULL, 0444);
88 MODULE_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
196 struct 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
242 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs);
243
244 static 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
249 MODULE_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 * -----------------------------------------------------------------*/
259 static 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 * -----------------------------------------------------------------*/
274 static 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 * -----------------------------------------------------------------*/
291 static 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 * -----------------------------------------------------------------*/
315 static 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 * -----------------------------------------------------------------*/
331 static 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 * -----------------------------------------------------------------*/
345 static 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 * -----------------------------------------------------------------*/
360 static 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 * -----------------------------------------------------------------*/
378 static 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 * --------------------------------------------------------------------*/
404 static 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 * --------------------------------------------------------------------*/
443 static 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
449 static 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
464 static struct snd_pcm_hw_constraint_ratnums hw_constraints_clocks = {
465 .nrats = 2,
466 .rats = clocks,
467 };
468
469
470 static 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
497 static 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
505 static 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
520 static 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
540 static 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
563 static 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
593 static 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
616 static 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 * --------------------------------------------------------------------*/
632 static 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 * ------------------------------------------------------------------------------*/
680 static 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
717 static 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
759 static 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
771 static 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
788 static 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
800 static 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
817 static 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
829 static 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 */
855 static 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
866 static 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 * ----------------------------------------------------------------------*/
874 static 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 * -----------------------------------------------------------------------*/
896 static 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
916 static 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
931 static 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
956 static 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
964 static 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
982 static 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
993 static 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
1005 static 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
1031 static 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
1048 static 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
1056 static 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
1067 static 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
1077 static 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
1086 static 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
1102 static 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
1112 static 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
1121 static 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
1131 static 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
1140 static 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
1149 static 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
1158 static 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
1172 static 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
1184 static 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
1201 static 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
1225 static 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
1237 static 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
1263 static 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
1299 static struct snd_kcontrol_new snd_es1938_controls[] = {
1300 ES1938_DOUBLE("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0),
1301 ES1938_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 },
1316 ES1938_SINGLE("Hardware Volume Split", 0, 0x64, 7, 1, 0),
1317 ES1938_DOUBLE("Line Playback Volume", 0, 0x3e, 0x3e, 4, 0, 15, 0),
1318 ES1938_DOUBLE("CD Playback Volume", 0, 0x38, 0x38, 4, 0, 15, 0),
1319 ES1938_DOUBLE("FM Playback Volume", 0, 0x36, 0x36, 4, 0, 15, 0),
1320 ES1938_DOUBLE("Mono Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1321 ES1938_DOUBLE("Mic Playback Volume", 0, 0x1a, 0x1a, 4, 0, 15, 0),
1322 ES1938_DOUBLE("Aux Playback Volume", 0, 0x3a, 0x3a, 4, 0, 15, 0),
1323 ES1938_DOUBLE("Capture Volume", 0, 0xb4, 0xb4, 4, 0, 15, 0),
1324 ES1938_SINGLE("PC Speaker Volume", 0, 0x3c, 0, 7, 0),
1325 ES1938_SINGLE("Record Monitor", 0, 0xa8, 3, 1, 0),
1326 ES1938_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 },
1334 ES1938_DOUBLE("Mono Input Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1335 ES1938_DOUBLE("PCM Capture Volume", 0, 0x69, 0x69, 4, 0, 15, 0),
1336 ES1938_DOUBLE("Mic Capture Volume", 0, 0x68, 0x68, 4, 0, 15, 0),
1337 ES1938_DOUBLE("Line Capture Volume", 0, 0x6e, 0x6e, 4, 0, 15, 0),
1338 ES1938_DOUBLE("FM Capture Volume", 0, 0x6b, 0x6b, 4, 0, 15, 0),
1339 ES1938_DOUBLE("Mono Capture Volume", 0, 0x6f, 0x6f, 4, 0, 15, 0),
1340 ES1938_DOUBLE("CD Capture Volume", 0, 0x6a, 0x6a, 4, 0, 15, 0),
1341 ES1938_DOUBLE("Aux Capture Volume", 0, 0x6c, 0x6c, 4, 0, 15, 0),
1342 ES1938_DOUBLE("PCM Playback Volume", 0, 0x7c, 0x7c, 4, 0, 15, 0),
1343 ES1938_DOUBLE("PCM Playback Volume", 1, 0x14, 0x14, 4, 0, 15, 0),
1344 ES1938_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 },
1352 ES1938_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 */
1362 static 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
1393 static 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
1401 static 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
1422 static 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
1449 static 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
1469 static 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
1477 static inline int snd_es1938_create_gameport(struct es1938 *chip) { return -ENOSYS; }
1478 static inline void snd_es1938_free_gameport(struct es1938 *chip) { }
1479 #endif /* SUPPORT_JOYSTICK */
1480
1481 static 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
1498 static 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
1504 static 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 if (pci_set_dma_mask(pci, 0x00ffffff) < 0 ||
1521 pci_set_consistent_dma_mask(pci, 0x00ffffff) < 0) {
1522 snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n");
1523 pci_disable_device(pci);
1524 return -ENXIO;
1525 }
1526
1527 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1528 if (chip == NULL) {
1529 pci_disable_device(pci);
1530 return -ENOMEM;
1531 }
1532 spin_lock_init(&chip->reg_lock);
1533 spin_lock_init(&chip->mixer_lock);
1534 chip->card = card;
1535 chip->pci = pci;
1536 if ((err = pci_request_regions(pci, "ESS Solo-1")) < 0) {
1537 kfree(chip);
1538 pci_disable_device(pci);
1539 return err;
1540 }
1541 chip->io_port = pci_resource_start(pci, 0);
1542 chip->sb_port = pci_resource_start(pci, 1);
1543 chip->vc_port = pci_resource_start(pci, 2);
1544 chip->mpu_port = pci_resource_start(pci, 3);
1545 chip->game_port = pci_resource_start(pci, 4);
1546 if (request_irq(pci->irq, snd_es1938_interrupt, SA_INTERRUPT|SA_SHIRQ,
1547 "ES1938", chip)) {
1548 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
1549 snd_es1938_free(chip);
1550 return -EBUSY;
1551 }
1552 chip->irq = pci->irq;
1553 #ifdef ES1938_DDEBUG
1554 snd_printk(KERN_DEBUG "create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
1555 chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port);
1556 #endif
1557
1558 chip->ddma_port = chip->vc_port + 0x00; /* fix from Thomas Sailer */
1559
1560 snd_es1938_chip_init(chip);
1561
1562 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1563 snd_es1938_free(chip);
1564 return err;
1565 }
1566
1567 snd_card_set_dev(card, &pci->dev);
1568
1569 *rchip = chip;
1570 return 0;
1571 }
1572
1573 /* --------------------------------------------------------------------
1574 * Interrupt handler
1575 * -------------------------------------------------------------------- */
1576 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1577 {
1578 struct es1938 *chip = dev_id;
1579 unsigned char status, audiostatus;
1580 int handled = 0;
1581
1582 status = inb(SLIO_REG(chip, IRQCONTROL));
1583 #if 0
1584 printk("Es1938debug - interrupt status: =0x%x\n", status);
1585 #endif
1586
1587 /* AUDIO 1 */
1588 if (status & 0x10) {
1589 #if 0
1590 printk("Es1938debug - AUDIO channel 1 interrupt\n");
1591 printk("Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n",
1592 inw(SLDM_REG(chip, DMACOUNT)));
1593 printk("Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n",
1594 inl(SLDM_REG(chip, DMAADDR)));
1595 printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n",
1596 inl(SLDM_REG(chip, DMASTATUS)));
1597 #endif
1598 /* clear irq */
1599 handled = 1;
1600 audiostatus = inb(SLSB_REG(chip, STATUS));
1601 if (chip->active & ADC1)
1602 snd_pcm_period_elapsed(chip->capture_substream);
1603 else if (chip->active & DAC1)
1604 snd_pcm_period_elapsed(chip->playback2_substream);
1605 }
1606
1607 /* AUDIO 2 */
1608 if (status & 0x20) {
1609 #if 0
1610 printk("Es1938debug - AUDIO channel 2 interrupt\n");
1611 printk("Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n",
1612 inw(SLIO_REG(chip, AUDIO2DMACOUNT)));
1613 printk("Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n",
1614 inl(SLIO_REG(chip, AUDIO2DMAADDR)));
1615
1616 #endif
1617 /* clear irq */
1618 handled = 1;
1619 snd_es1938_mixer_bits(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x80, 0);
1620 if (chip->active & DAC2)
1621 snd_pcm_period_elapsed(chip->playback1_substream);
1622 }
1623
1624 /* Hardware volume */
1625 if (status & 0x40) {
1626 int split = snd_es1938_mixer_read(chip, 0x64) & 0x80;
1627 handled = 1;
1628 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id);
1629 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id);
1630 if (!split) {
1631 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1632 &chip->master_switch->id);
1633 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1634 &chip->master_volume->id);
1635 }
1636 /* ack interrupt */
1637 snd_es1938_mixer_write(chip, 0x66, 0x00);
1638 }
1639
1640 /* MPU401 */
1641 if (status & 0x80) {
1642 // the following line is evil! It switches off MIDI interrupt handling after the first interrupt received.
1643 // replacing the last 0 by 0x40 works for ESS-Solo1, but just doing nothing works as well!
1644 // andreas@flying-snail.de
1645 // snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); /* ack? */
1646 if (chip->rmidi) {
1647 handled = 1;
1648 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
1649 }
1650 }
1651 return IRQ_RETVAL(handled);
1652 }
1653
1654 #define ES1938_DMA_SIZE 64
1655
1656 static int __devinit snd_es1938_mixer(struct es1938 *chip)
1657 {
1658 struct snd_card *card;
1659 unsigned int idx;
1660 int err;
1661
1662 card = chip->card;
1663
1664 strcpy(card->mixername, "ESS Solo-1");
1665
1666 for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) {
1667 struct snd_kcontrol *kctl;
1668 kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip);
1669 switch (idx) {
1670 case 0:
1671 chip->master_volume = kctl;
1672 kctl->private_free = snd_es1938_hwv_free;
1673 break;
1674 case 1:
1675 chip->master_switch = kctl;
1676 kctl->private_free = snd_es1938_hwv_free;
1677 break;
1678 case 2:
1679 chip->hw_volume = kctl;
1680 kctl->private_free = snd_es1938_hwv_free;
1681 break;
1682 case 3:
1683 chip->hw_switch = kctl;
1684 kctl->private_free = snd_es1938_hwv_free;
1685 break;
1686 }
1687 if ((err = snd_ctl_add(card, kctl)) < 0)
1688 return err;
1689 }
1690 return 0;
1691 }
1692
1693
1694 static int __devinit snd_es1938_probe(struct pci_dev *pci,
1695 const struct pci_device_id *pci_id)
1696 {
1697 static int dev;
1698 struct snd_card *card;
1699 struct es1938 *chip;
1700 struct snd_opl3 *opl3;
1701 int idx, err;
1702
1703 if (dev >= SNDRV_CARDS)
1704 return -ENODEV;
1705 if (!enable[dev]) {
1706 dev++;
1707 return -ENOENT;
1708 }
1709
1710 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
1711 if (card == NULL)
1712 return -ENOMEM;
1713 for (idx = 0; idx < 5; idx++) {
1714 if (pci_resource_start(pci, idx) == 0 ||
1715 !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) {
1716 snd_card_free(card);
1717 return -ENODEV;
1718 }
1719 }
1720 if ((err = snd_es1938_create(card, pci, &chip)) < 0) {
1721 snd_card_free(card);
1722 return err;
1723 }
1724 card->private_data = chip;
1725
1726 strcpy(card->driver, "ES1938");
1727 strcpy(card->shortname, "ESS ES1938 (Solo-1)");
1728 sprintf(card->longname, "%s rev %i, irq %i",
1729 card->shortname,
1730 chip->revision,
1731 chip->irq);
1732
1733 if ((err = snd_es1938_new_pcm(chip, 0)) < 0) {
1734 snd_card_free(card);
1735 return err;
1736 }
1737 if ((err = snd_es1938_mixer(chip)) < 0) {
1738 snd_card_free(card);
1739 return err;
1740 }
1741 if (snd_opl3_create(card,
1742 SLSB_REG(chip, FMLOWADDR),
1743 SLSB_REG(chip, FMHIGHADDR),
1744 OPL3_HW_OPL3, 1, &opl3) < 0) {
1745 printk(KERN_ERR "es1938: OPL3 not detected at 0x%lx\n",
1746 SLSB_REG(chip, FMLOWADDR));
1747 } else {
1748 if ((err = snd_opl3_timer_new(opl3, 0, 1)) < 0) {
1749 snd_card_free(card);
1750 return err;
1751 }
1752 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
1753 snd_card_free(card);
1754 return err;
1755 }
1756 }
1757 if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
1758 chip->mpu_port, 1, chip->irq, 0, &chip->rmidi) < 0) {
1759 printk(KERN_ERR "es1938: unable to initialize MPU-401\n");
1760 } else {
1761 // this line is vital for MIDI interrupt handling on ess-solo1
1762 // andreas@flying-snail.de
1763 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0x40);
1764 }
1765
1766 snd_es1938_create_gameport(chip);
1767
1768 if ((err = snd_card_register(card)) < 0) {
1769 snd_card_free(card);
1770 return err;
1771 }
1772
1773 pci_set_drvdata(pci, card);
1774 dev++;
1775 return 0;
1776 }
1777
1778 static void __devexit snd_es1938_remove(struct pci_dev *pci)
1779 {
1780 snd_card_free(pci_get_drvdata(pci));
1781 pci_set_drvdata(pci, NULL);
1782 }
1783
1784 static struct pci_driver driver = {
1785 .name = "ESS ES1938 (Solo-1)",
1786 .id_table = snd_es1938_ids,
1787 .probe = snd_es1938_probe,
1788 .remove = __devexit_p(snd_es1938_remove),
1789 #ifdef CONFIG_PM
1790 .suspend = es1938_suspend,
1791 .resume = es1938_resume,
1792 #endif
1793 };
1794
1795 static int __init alsa_card_es1938_init(void)
1796 {
1797 return pci_register_driver(&driver);
1798 }
1799
1800 static void __exit alsa_card_es1938_exit(void)
1801 {
1802 pci_unregister_driver(&driver);
1803 }
1804
1805 module_init(alsa_card_es1938_init)
1806 module_exit(alsa_card_es1938_exit)
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree