Version:  2.0.40 2.2.26 2.4.37 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19

Linux/sound/pci/es1938.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us