Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 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

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 DEFINE_PCI_DEVICE_TABLE(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 char *texts[8] = {
1049                 "Mic", "Mic Master", "CD", "AOUT",
1050                 "Mic1", "Mix", "Line", "Master"
1051         };
1052 
1053         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1054         uinfo->count = 1;
1055         uinfo->value.enumerated.items = 8;
1056         if (uinfo->value.enumerated.item > 7)
1057                 uinfo->value.enumerated.item = 7;
1058         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1059         return 0;
1060 }
1061 
1062 static int snd_es1938_get_mux(struct snd_kcontrol *kcontrol,
1063                               struct snd_ctl_elem_value *ucontrol)
1064 {
1065         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1066         ucontrol->value.enumerated.item[0] = snd_es1938_mixer_read(chip, 0x1c) & 0x07;
1067         return 0;
1068 }
1069 
1070 static int snd_es1938_put_mux(struct snd_kcontrol *kcontrol,
1071                               struct snd_ctl_elem_value *ucontrol)
1072 {
1073         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1074         unsigned char val = ucontrol->value.enumerated.item[0];
1075         
1076         if (val > 7)
1077                 return -EINVAL;
1078         return snd_es1938_mixer_bits(chip, 0x1c, 0x07, val) != val;
1079 }
1080 
1081 #define snd_es1938_info_spatializer_enable      snd_ctl_boolean_mono_info
1082 
1083 static int snd_es1938_get_spatializer_enable(struct snd_kcontrol *kcontrol,
1084                                              struct snd_ctl_elem_value *ucontrol)
1085 {
1086         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1087         unsigned char val = snd_es1938_mixer_read(chip, 0x50);
1088         ucontrol->value.integer.value[0] = !!(val & 8);
1089         return 0;
1090 }
1091 
1092 static int snd_es1938_put_spatializer_enable(struct snd_kcontrol *kcontrol,
1093                                              struct snd_ctl_elem_value *ucontrol)
1094 {
1095         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1096         unsigned char oval, nval;
1097         int change;
1098         nval = ucontrol->value.integer.value[0] ? 0x0c : 0x04;
1099         oval = snd_es1938_mixer_read(chip, 0x50) & 0x0c;
1100         change = nval != oval;
1101         if (change) {
1102                 snd_es1938_mixer_write(chip, 0x50, nval & ~0x04);
1103                 snd_es1938_mixer_write(chip, 0x50, nval);
1104         }
1105         return change;
1106 }
1107 
1108 static int snd_es1938_info_hw_volume(struct snd_kcontrol *kcontrol,
1109                                      struct snd_ctl_elem_info *uinfo)
1110 {
1111         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1112         uinfo->count = 2;
1113         uinfo->value.integer.min = 0;
1114         uinfo->value.integer.max = 63;
1115         return 0;
1116 }
1117 
1118 static int snd_es1938_get_hw_volume(struct snd_kcontrol *kcontrol,
1119                                     struct snd_ctl_elem_value *ucontrol)
1120 {
1121         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1122         ucontrol->value.integer.value[0] = snd_es1938_mixer_read(chip, 0x61) & 0x3f;
1123         ucontrol->value.integer.value[1] = snd_es1938_mixer_read(chip, 0x63) & 0x3f;
1124         return 0;
1125 }
1126 
1127 #define snd_es1938_info_hw_switch               snd_ctl_boolean_stereo_info
1128 
1129 static int snd_es1938_get_hw_switch(struct snd_kcontrol *kcontrol,
1130                                     struct snd_ctl_elem_value *ucontrol)
1131 {
1132         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1133         ucontrol->value.integer.value[0] = !(snd_es1938_mixer_read(chip, 0x61) & 0x40);
1134         ucontrol->value.integer.value[1] = !(snd_es1938_mixer_read(chip, 0x63) & 0x40);
1135         return 0;
1136 }
1137 
1138 static void snd_es1938_hwv_free(struct snd_kcontrol *kcontrol)
1139 {
1140         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1141         chip->master_volume = NULL;
1142         chip->master_switch = NULL;
1143         chip->hw_volume = NULL;
1144         chip->hw_switch = NULL;
1145 }
1146 
1147 static int snd_es1938_reg_bits(struct es1938 *chip, unsigned char reg,
1148                                unsigned char mask, unsigned char val)
1149 {
1150         if (reg < 0xa0)
1151                 return snd_es1938_mixer_bits(chip, reg, mask, val);
1152         else
1153                 return snd_es1938_bits(chip, reg, mask, val);
1154 }
1155 
1156 static int snd_es1938_reg_read(struct es1938 *chip, unsigned char reg)
1157 {
1158         if (reg < 0xa0)
1159                 return snd_es1938_mixer_read(chip, reg);
1160         else
1161                 return snd_es1938_read(chip, reg);
1162 }
1163 
1164 #define ES1938_SINGLE_TLV(xname, xindex, reg, shift, mask, invert, xtlv)    \
1165 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1166   .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,\
1167   .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   .tlv = { .p = xtlv } }
1172 #define ES1938_SINGLE(xname, xindex, reg, shift, mask, invert) \
1173 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1174   .info = snd_es1938_info_single, \
1175   .get = snd_es1938_get_single, .put = snd_es1938_put_single, \
1176   .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
1177 
1178 static int snd_es1938_info_single(struct snd_kcontrol *kcontrol,
1179                                   struct snd_ctl_elem_info *uinfo)
1180 {
1181         int mask = (kcontrol->private_value >> 16) & 0xff;
1182 
1183         uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1184         uinfo->count = 1;
1185         uinfo->value.integer.min = 0;
1186         uinfo->value.integer.max = mask;
1187         return 0;
1188 }
1189 
1190 static int snd_es1938_get_single(struct snd_kcontrol *kcontrol,
1191                                  struct snd_ctl_elem_value *ucontrol)
1192 {
1193         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1194         int reg = kcontrol->private_value & 0xff;
1195         int shift = (kcontrol->private_value >> 8) & 0xff;
1196         int mask = (kcontrol->private_value >> 16) & 0xff;
1197         int invert = (kcontrol->private_value >> 24) & 0xff;
1198         int val;
1199         
1200         val = snd_es1938_reg_read(chip, reg);
1201         ucontrol->value.integer.value[0] = (val >> shift) & mask;
1202         if (invert)
1203                 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1204         return 0;
1205 }
1206 
1207 static int snd_es1938_put_single(struct snd_kcontrol *kcontrol,
1208                                  struct snd_ctl_elem_value *ucontrol)
1209 {
1210         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1211         int reg = kcontrol->private_value & 0xff;
1212         int shift = (kcontrol->private_value >> 8) & 0xff;
1213         int mask = (kcontrol->private_value >> 16) & 0xff;
1214         int invert = (kcontrol->private_value >> 24) & 0xff;
1215         unsigned char val;
1216         
1217         val = (ucontrol->value.integer.value[0] & mask);
1218         if (invert)
1219                 val = mask - val;
1220         mask <<= shift;
1221         val <<= shift;
1222         return snd_es1938_reg_bits(chip, reg, mask, val) != val;
1223 }
1224 
1225 #define ES1938_DOUBLE_TLV(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert, xtlv) \
1226 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1227   .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,\
1228   .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   .tlv = { .p = xtlv } }
1233 #define ES1938_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
1234 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1235   .info = snd_es1938_info_double, \
1236   .get = snd_es1938_get_double, .put = snd_es1938_put_double, \
1237   .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
1238 
1239 static int snd_es1938_info_double(struct snd_kcontrol *kcontrol,
1240                                   struct snd_ctl_elem_info *uinfo)
1241 {
1242         int mask = (kcontrol->private_value >> 24) & 0xff;
1243 
1244         uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1245         uinfo->count = 2;
1246         uinfo->value.integer.min = 0;
1247         uinfo->value.integer.max = mask;
1248         return 0;
1249 }
1250 
1251 static int snd_es1938_get_double(struct snd_kcontrol *kcontrol,
1252                                  struct snd_ctl_elem_value *ucontrol)
1253 {
1254         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1255         int left_reg = kcontrol->private_value & 0xff;
1256         int right_reg = (kcontrol->private_value >> 8) & 0xff;
1257         int shift_left = (kcontrol->private_value >> 16) & 0x07;
1258         int shift_right = (kcontrol->private_value >> 19) & 0x07;
1259         int mask = (kcontrol->private_value >> 24) & 0xff;
1260         int invert = (kcontrol->private_value >> 22) & 1;
1261         unsigned char left, right;
1262         
1263         left = snd_es1938_reg_read(chip, left_reg);
1264         if (left_reg != right_reg)
1265                 right = snd_es1938_reg_read(chip, right_reg);
1266         else
1267                 right = left;
1268         ucontrol->value.integer.value[0] = (left >> shift_left) & mask;
1269         ucontrol->value.integer.value[1] = (right >> shift_right) & mask;
1270         if (invert) {
1271                 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1272                 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
1273         }
1274         return 0;
1275 }
1276 
1277 static int snd_es1938_put_double(struct snd_kcontrol *kcontrol,
1278                                  struct snd_ctl_elem_value *ucontrol)
1279 {
1280         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1281         int left_reg = kcontrol->private_value & 0xff;
1282         int right_reg = (kcontrol->private_value >> 8) & 0xff;
1283         int shift_left = (kcontrol->private_value >> 16) & 0x07;
1284         int shift_right = (kcontrol->private_value >> 19) & 0x07;
1285         int mask = (kcontrol->private_value >> 24) & 0xff;
1286         int invert = (kcontrol->private_value >> 22) & 1;
1287         int change;
1288         unsigned char val1, val2, mask1, mask2;
1289         
1290         val1 = ucontrol->value.integer.value[0] & mask;
1291         val2 = ucontrol->value.integer.value[1] & mask;
1292         if (invert) {
1293                 val1 = mask - val1;
1294                 val2 = mask - val2;
1295         }
1296         val1 <<= shift_left;
1297         val2 <<= shift_right;
1298         mask1 = mask << shift_left;
1299         mask2 = mask << shift_right;
1300         if (left_reg != right_reg) {
1301                 change = 0;
1302                 if (snd_es1938_reg_bits(chip, left_reg, mask1, val1) != val1)
1303                         change = 1;
1304                 if (snd_es1938_reg_bits(chip, right_reg, mask2, val2) != val2)
1305                         change = 1;
1306         } else {
1307                 change = (snd_es1938_reg_bits(chip, left_reg, mask1 | mask2, 
1308                                               val1 | val2) != (val1 | val2));
1309         }
1310         return change;
1311 }
1312 
1313 static const DECLARE_TLV_DB_RANGE(db_scale_master,
1314         0, 54, TLV_DB_SCALE_ITEM(-3600, 50, 1),
1315         54, 63, TLV_DB_SCALE_ITEM(-900, 100, 0),
1316 );
1317 
1318 static const DECLARE_TLV_DB_RANGE(db_scale_audio1,
1319         0, 8, TLV_DB_SCALE_ITEM(-3300, 300, 1),
1320         8, 15, TLV_DB_SCALE_ITEM(-900, 150, 0),
1321 );
1322 
1323 static const DECLARE_TLV_DB_RANGE(db_scale_audio2,
1324         0, 8, TLV_DB_SCALE_ITEM(-3450, 300, 1),
1325         8, 15, TLV_DB_SCALE_ITEM(-1050, 150, 0),
1326 );
1327 
1328 static const DECLARE_TLV_DB_RANGE(db_scale_mic,
1329         0, 8, TLV_DB_SCALE_ITEM(-2400, 300, 1),
1330         8, 15, TLV_DB_SCALE_ITEM(0, 150, 0),
1331 );
1332 
1333 static const DECLARE_TLV_DB_RANGE(db_scale_line,
1334         0, 8, TLV_DB_SCALE_ITEM(-3150, 300, 1),
1335         8, 15, TLV_DB_SCALE_ITEM(-750, 150, 0),
1336 );
1337 
1338 static const DECLARE_TLV_DB_SCALE(db_scale_capture, 0, 150, 0);
1339 
1340 static struct snd_kcontrol_new snd_es1938_controls[] = {
1341 ES1938_DOUBLE_TLV("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0,
1342                   db_scale_master),
1343 ES1938_DOUBLE("Master Playback Switch", 0, 0x60, 0x62, 6, 6, 1, 1),
1344 {
1345         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1346         .name = "Hardware Master Playback Volume",
1347         .access = SNDRV_CTL_ELEM_ACCESS_READ,
1348         .info = snd_es1938_info_hw_volume,
1349         .get = snd_es1938_get_hw_volume,
1350 },
1351 {
1352         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1353         .access = (SNDRV_CTL_ELEM_ACCESS_READ |
1354                    SNDRV_CTL_ELEM_ACCESS_TLV_READ),
1355         .name = "Hardware Master Playback Switch",
1356         .info = snd_es1938_info_hw_switch,
1357         .get = snd_es1938_get_hw_switch,
1358         .tlv = { .p = db_scale_master },
1359 },
1360 ES1938_SINGLE("Hardware Volume Split", 0, 0x64, 7, 1, 0),
1361 ES1938_DOUBLE_TLV("Line Playback Volume", 0, 0x3e, 0x3e, 4, 0, 15, 0,
1362                   db_scale_line),
1363 ES1938_DOUBLE("CD Playback Volume", 0, 0x38, 0x38, 4, 0, 15, 0),
1364 ES1938_DOUBLE_TLV("FM Playback Volume", 0, 0x36, 0x36, 4, 0, 15, 0,
1365                   db_scale_mic),
1366 ES1938_DOUBLE_TLV("Mono Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0,
1367                   db_scale_line),
1368 ES1938_DOUBLE_TLV("Mic Playback Volume", 0, 0x1a, 0x1a, 4, 0, 15, 0,
1369                   db_scale_mic),
1370 ES1938_DOUBLE_TLV("Aux Playback Volume", 0, 0x3a, 0x3a, 4, 0, 15, 0,
1371                   db_scale_line),
1372 ES1938_DOUBLE_TLV("Capture Volume", 0, 0xb4, 0xb4, 4, 0, 15, 0,
1373                   db_scale_capture),
1374 ES1938_SINGLE("Beep Volume", 0, 0x3c, 0, 7, 0),
1375 ES1938_SINGLE("Record Monitor", 0, 0xa8, 3, 1, 0),
1376 ES1938_SINGLE("Capture Switch", 0, 0x1c, 4, 1, 1),
1377 {
1378         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1379         .name = "Capture Source",
1380         .info = snd_es1938_info_mux,
1381         .get = snd_es1938_get_mux,
1382         .put = snd_es1938_put_mux,
1383 },
1384 ES1938_DOUBLE_TLV("Mono Input Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0,
1385                   db_scale_line),
1386 ES1938_DOUBLE_TLV("PCM Capture Volume", 0, 0x69, 0x69, 4, 0, 15, 0,
1387                   db_scale_audio2),
1388 ES1938_DOUBLE_TLV("Mic Capture Volume", 0, 0x68, 0x68, 4, 0, 15, 0,
1389                   db_scale_mic),
1390 ES1938_DOUBLE_TLV("Line Capture Volume", 0, 0x6e, 0x6e, 4, 0, 15, 0,
1391                   db_scale_line),
1392 ES1938_DOUBLE_TLV("FM Capture Volume", 0, 0x6b, 0x6b, 4, 0, 15, 0,
1393                   db_scale_mic),
1394 ES1938_DOUBLE_TLV("Mono Capture Volume", 0, 0x6f, 0x6f, 4, 0, 15, 0,
1395                   db_scale_line),
1396 ES1938_DOUBLE_TLV("CD Capture Volume", 0, 0x6a, 0x6a, 4, 0, 15, 0,
1397                   db_scale_line),
1398 ES1938_DOUBLE_TLV("Aux Capture Volume", 0, 0x6c, 0x6c, 4, 0, 15, 0,
1399                   db_scale_line),
1400 ES1938_DOUBLE_TLV("PCM Playback Volume", 0, 0x7c, 0x7c, 4, 0, 15, 0,
1401                   db_scale_audio2),
1402 ES1938_DOUBLE_TLV("PCM Playback Volume", 1, 0x14, 0x14, 4, 0, 15, 0,
1403                   db_scale_audio1),
1404 ES1938_SINGLE("3D Control - Level", 0, 0x52, 0, 63, 0),
1405 {
1406         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1407         .name = "3D Control - Switch",
1408         .info = snd_es1938_info_spatializer_enable,
1409         .get = snd_es1938_get_spatializer_enable,
1410         .put = snd_es1938_put_spatializer_enable,
1411 },
1412 ES1938_SINGLE("Mic Boost (+26dB)", 0, 0x7d, 3, 1, 0)
1413 };
1414 
1415 
1416 /* ---------------------------------------------------------------------------- */
1417 /* ---------------------------------------------------------------------------- */
1418 
1419 /*
1420  * initialize the chip - used by resume callback, too
1421  */
1422 static void snd_es1938_chip_init(struct es1938 *chip)
1423 {
1424         /* reset chip */
1425         snd_es1938_reset(chip);
1426 
1427         /* configure native mode */
1428 
1429         /* enable bus master */
1430         pci_set_master(chip->pci);
1431 
1432         /* disable legacy audio */
1433         pci_write_config_word(chip->pci, SL_PCI_LEGACYCONTROL, 0x805f);
1434 
1435         /* set DDMA base */
1436         pci_write_config_word(chip->pci, SL_PCI_DDMACONTROL, chip->ddma_port | 1);
1437 
1438         /* set DMA/IRQ policy */
1439         pci_write_config_dword(chip->pci, SL_PCI_CONFIG, 0);
1440 
1441         /* enable Audio 1, Audio 2, MPU401 IRQ and HW volume IRQ*/
1442         outb(0xf0, SLIO_REG(chip, IRQCONTROL));
1443 
1444         /* reset DMA */
1445         outb(0, SLDM_REG(chip, DMACLEAR));
1446 }
1447 
1448 #ifdef CONFIG_PM_SLEEP
1449 /*
1450  * PM support
1451  */
1452 
1453 static unsigned char saved_regs[SAVED_REG_SIZE+1] = {
1454         0x14, 0x1a, 0x1c, 0x3a, 0x3c, 0x3e, 0x36, 0x38,
1455         0x50, 0x52, 0x60, 0x61, 0x62, 0x63, 0x64, 0x68,
1456         0x69, 0x6a, 0x6b, 0x6d, 0x6e, 0x6f, 0x7c, 0x7d,
1457         0xa8, 0xb4,
1458 };
1459 
1460 
1461 static int es1938_suspend(struct device *dev)
1462 {
1463         struct pci_dev *pci = to_pci_dev(dev);
1464         struct snd_card *card = dev_get_drvdata(dev);
1465         struct es1938 *chip = card->private_data;
1466         unsigned char *s, *d;
1467 
1468         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1469         snd_pcm_suspend_all(chip->pcm);
1470 
1471         /* save mixer-related registers */
1472         for (s = saved_regs, d = chip->saved_regs; *s; s++, d++)
1473                 *d = snd_es1938_reg_read(chip, *s);
1474 
1475         outb(0x00, SLIO_REG(chip, IRQCONTROL)); /* disable irqs */
1476         if (chip->irq >= 0) {
1477                 free_irq(chip->irq, chip);
1478                 chip->irq = -1;
1479         }
1480         pci_disable_device(pci);
1481         pci_save_state(pci);
1482         pci_set_power_state(pci, PCI_D3hot);
1483         return 0;
1484 }
1485 
1486 static int es1938_resume(struct device *dev)
1487 {
1488         struct pci_dev *pci = to_pci_dev(dev);
1489         struct snd_card *card = dev_get_drvdata(dev);
1490         struct es1938 *chip = card->private_data;
1491         unsigned char *s, *d;
1492 
1493         pci_set_power_state(pci, PCI_D0);
1494         pci_restore_state(pci);
1495         if (pci_enable_device(pci) < 0) {
1496                 dev_err(dev, "pci_enable_device failed, disabling device\n");
1497                 snd_card_disconnect(card);
1498                 return -EIO;
1499         }
1500 
1501         if (request_irq(pci->irq, snd_es1938_interrupt,
1502                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
1503                 dev_err(dev, "unable to grab IRQ %d, disabling device\n",
1504                         pci->irq);
1505                 snd_card_disconnect(card);
1506                 return -EIO;
1507         }
1508         chip->irq = pci->irq;
1509         snd_es1938_chip_init(chip);
1510 
1511         /* restore mixer-related registers */
1512         for (s = saved_regs, d = chip->saved_regs; *s; s++, d++) {
1513                 if (*s < 0xa0)
1514                         snd_es1938_mixer_write(chip, *s, *d);
1515                 else
1516                         snd_es1938_write(chip, *s, *d);
1517         }
1518 
1519         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1520         return 0;
1521 }
1522 
1523 static SIMPLE_DEV_PM_OPS(es1938_pm, es1938_suspend, es1938_resume);
1524 #define ES1938_PM_OPS   &es1938_pm
1525 #else
1526 #define ES1938_PM_OPS   NULL
1527 #endif /* CONFIG_PM_SLEEP */
1528 
1529 #ifdef SUPPORT_JOYSTICK
1530 static int snd_es1938_create_gameport(struct es1938 *chip)
1531 {
1532         struct gameport *gp;
1533 
1534         chip->gameport = gp = gameport_allocate_port();
1535         if (!gp) {
1536                 dev_err(chip->card->dev,
1537                         "cannot allocate memory for gameport\n");
1538                 return -ENOMEM;
1539         }
1540 
1541         gameport_set_name(gp, "ES1938");
1542         gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
1543         gameport_set_dev_parent(gp, &chip->pci->dev);
1544         gp->io = chip->game_port;
1545 
1546         gameport_register_port(gp);
1547 
1548         return 0;
1549 }
1550 
1551 static void snd_es1938_free_gameport(struct es1938 *chip)
1552 {
1553         if (chip->gameport) {
1554                 gameport_unregister_port(chip->gameport);
1555                 chip->gameport = NULL;
1556         }
1557 }
1558 #else
1559 static inline int snd_es1938_create_gameport(struct es1938 *chip) { return -ENOSYS; }
1560 static inline void snd_es1938_free_gameport(struct es1938 *chip) { }
1561 #endif /* SUPPORT_JOYSTICK */
1562 
1563 static int snd_es1938_free(struct es1938 *chip)
1564 {
1565         /* disable irqs */
1566         outb(0x00, SLIO_REG(chip, IRQCONTROL));
1567         if (chip->rmidi)
1568                 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0);
1569 
1570         snd_es1938_free_gameport(chip);
1571 
1572         if (chip->irq >= 0)
1573                 free_irq(chip->irq, chip);
1574         pci_release_regions(chip->pci);
1575         pci_disable_device(chip->pci);
1576         kfree(chip);
1577         return 0;
1578 }
1579 
1580 static int snd_es1938_dev_free(struct snd_device *device)
1581 {
1582         struct es1938 *chip = device->device_data;
1583         return snd_es1938_free(chip);
1584 }
1585 
1586 static int snd_es1938_create(struct snd_card *card,
1587                              struct pci_dev *pci,
1588                              struct es1938 **rchip)
1589 {
1590         struct es1938 *chip;
1591         int err;
1592         static struct snd_device_ops ops = {
1593                 .dev_free =     snd_es1938_dev_free,
1594         };
1595 
1596         *rchip = NULL;
1597 
1598         /* enable PCI device */
1599         if ((err = pci_enable_device(pci)) < 0)
1600                 return err;
1601         /* check, if we can restrict PCI DMA transfers to 24 bits */
1602         if (pci_set_dma_mask(pci, DMA_BIT_MASK(24)) < 0 ||
1603             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(24)) < 0) {
1604                 dev_err(card->dev,
1605                         "architecture does not support 24bit PCI busmaster DMA\n");
1606                 pci_disable_device(pci);
1607                 return -ENXIO;
1608         }
1609 
1610         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1611         if (chip == NULL) {
1612                 pci_disable_device(pci);
1613                 return -ENOMEM;
1614         }
1615         spin_lock_init(&chip->reg_lock);
1616         spin_lock_init(&chip->mixer_lock);
1617         chip->card = card;
1618         chip->pci = pci;
1619         chip->irq = -1;
1620         if ((err = pci_request_regions(pci, "ESS Solo-1")) < 0) {
1621                 kfree(chip);
1622                 pci_disable_device(pci);
1623                 return err;
1624         }
1625         chip->io_port = pci_resource_start(pci, 0);
1626         chip->sb_port = pci_resource_start(pci, 1);
1627         chip->vc_port = pci_resource_start(pci, 2);
1628         chip->mpu_port = pci_resource_start(pci, 3);
1629         chip->game_port = pci_resource_start(pci, 4);
1630         if (request_irq(pci->irq, snd_es1938_interrupt, IRQF_SHARED,
1631                         KBUILD_MODNAME, chip)) {
1632                 dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
1633                 snd_es1938_free(chip);
1634                 return -EBUSY;
1635         }
1636         chip->irq = pci->irq;
1637         dev_dbg(card->dev,
1638                 "create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
1639                    chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port);
1640 
1641         chip->ddma_port = chip->vc_port + 0x00;         /* fix from Thomas Sailer */
1642 
1643         snd_es1938_chip_init(chip);
1644 
1645         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1646                 snd_es1938_free(chip);
1647                 return err;
1648         }
1649 
1650         *rchip = chip;
1651         return 0;
1652 }
1653 
1654 /* --------------------------------------------------------------------
1655  * Interrupt handler
1656  * -------------------------------------------------------------------- */
1657 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id)
1658 {
1659         struct es1938 *chip = dev_id;
1660         unsigned char status, audiostatus;
1661         int handled = 0;
1662 
1663         status = inb(SLIO_REG(chip, IRQCONTROL));
1664 #if 0
1665         dev_dbg(chip->card->dev,
1666                 "Es1938debug - interrupt status: =0x%x\n", status);
1667 #endif
1668         
1669         /* AUDIO 1 */
1670         if (status & 0x10) {
1671 #if 0
1672                 dev_dbg(chip->card->dev,
1673                        "Es1938debug - AUDIO channel 1 interrupt\n");
1674                 dev_dbg(chip->card->dev,
1675                        "Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n",
1676                        inw(SLDM_REG(chip, DMACOUNT)));
1677                 dev_dbg(chip->card->dev,
1678                        "Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n",
1679                        inl(SLDM_REG(chip, DMAADDR)));
1680                 dev_dbg(chip->card->dev,
1681                        "Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n",
1682                        inl(SLDM_REG(chip, DMASTATUS)));
1683 #endif
1684                 /* clear irq */
1685                 handled = 1;
1686                 audiostatus = inb(SLSB_REG(chip, STATUS));
1687                 if (chip->active & ADC1)
1688                         snd_pcm_period_elapsed(chip->capture_substream);
1689                 else if (chip->active & DAC1)
1690                         snd_pcm_period_elapsed(chip->playback2_substream);
1691         }
1692         
1693         /* AUDIO 2 */
1694         if (status & 0x20) {
1695 #if 0
1696                 dev_dbg(chip->card->dev,
1697                        "Es1938debug - AUDIO channel 2 interrupt\n");
1698                 dev_dbg(chip->card->dev,
1699                        "Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n",
1700                        inw(SLIO_REG(chip, AUDIO2DMACOUNT)));
1701                 dev_dbg(chip->card->dev,
1702                        "Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n",
1703                        inl(SLIO_REG(chip, AUDIO2DMAADDR)));
1704 
1705 #endif
1706                 /* clear irq */
1707                 handled = 1;
1708                 snd_es1938_mixer_bits(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x80, 0);
1709                 if (chip->active & DAC2)
1710                         snd_pcm_period_elapsed(chip->playback1_substream);
1711         }
1712 
1713         /* Hardware volume */
1714         if (status & 0x40) {
1715                 int split = snd_es1938_mixer_read(chip, 0x64) & 0x80;
1716                 handled = 1;
1717                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id);
1718                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id);
1719                 if (!split) {
1720                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1721                                        &chip->master_switch->id);
1722                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1723                                        &chip->master_volume->id);
1724                 }
1725                 /* ack interrupt */
1726                 snd_es1938_mixer_write(chip, 0x66, 0x00);
1727         }
1728 
1729         /* MPU401 */
1730         if (status & 0x80) {
1731                 // the following line is evil! It switches off MIDI interrupt handling after the first interrupt received.
1732                 // replacing the last 0 by 0x40 works for ESS-Solo1, but just doing nothing works as well!
1733                 // andreas@flying-snail.de
1734                 // snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); /* ack? */
1735                 if (chip->rmidi) {
1736                         handled = 1;
1737                         snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data);
1738                 }
1739         }
1740         return IRQ_RETVAL(handled);
1741 }
1742 
1743 #define ES1938_DMA_SIZE 64
1744 
1745 static int snd_es1938_mixer(struct es1938 *chip)
1746 {
1747         struct snd_card *card;
1748         unsigned int idx;
1749         int err;
1750 
1751         card = chip->card;
1752 
1753         strcpy(card->mixername, "ESS Solo-1");
1754 
1755         for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) {
1756                 struct snd_kcontrol *kctl;
1757                 kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip);
1758                 switch (idx) {
1759                         case 0:
1760                                 chip->master_volume = kctl;
1761                                 kctl->private_free = snd_es1938_hwv_free;
1762                                 break;
1763                         case 1:
1764                                 chip->master_switch = kctl;
1765                                 kctl->private_free = snd_es1938_hwv_free;
1766                                 break;
1767                         case 2:
1768                                 chip->hw_volume = kctl;
1769                                 kctl->private_free = snd_es1938_hwv_free;
1770                                 break;
1771                         case 3:
1772                                 chip->hw_switch = kctl;
1773                                 kctl->private_free = snd_es1938_hwv_free;
1774                                 break;
1775                         }
1776                 if ((err = snd_ctl_add(card, kctl)) < 0)
1777                         return err;
1778         }
1779         return 0;
1780 }
1781        
1782 
1783 static int snd_es1938_probe(struct pci_dev *pci,
1784                             const struct pci_device_id *pci_id)
1785 {
1786         static int dev;
1787         struct snd_card *card;
1788         struct es1938 *chip;
1789         struct snd_opl3 *opl3;
1790         int idx, err;
1791 
1792         if (dev >= SNDRV_CARDS)
1793                 return -ENODEV;
1794         if (!enable[dev]) {
1795                 dev++;
1796                 return -ENOENT;
1797         }
1798 
1799         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
1800                            0, &card);
1801         if (err < 0)
1802                 return err;
1803         for (idx = 0; idx < 5; idx++) {
1804                 if (pci_resource_start(pci, idx) == 0 ||
1805                     !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) {
1806                         snd_card_free(card);
1807                         return -ENODEV;
1808                 }
1809         }
1810         if ((err = snd_es1938_create(card, pci, &chip)) < 0) {
1811                 snd_card_free(card);
1812                 return err;
1813         }
1814         card->private_data = chip;
1815 
1816         strcpy(card->driver, "ES1938");
1817         strcpy(card->shortname, "ESS ES1938 (Solo-1)");
1818         sprintf(card->longname, "%s rev %i, irq %i",
1819                 card->shortname,
1820                 chip->revision,
1821                 chip->irq);
1822 
1823         if ((err = snd_es1938_new_pcm(chip, 0)) < 0) {
1824                 snd_card_free(card);
1825                 return err;
1826         }
1827         if ((err = snd_es1938_mixer(chip)) < 0) {
1828                 snd_card_free(card);
1829                 return err;
1830         }
1831         if (snd_opl3_create(card,
1832                             SLSB_REG(chip, FMLOWADDR),
1833                             SLSB_REG(chip, FMHIGHADDR),
1834                             OPL3_HW_OPL3, 1, &opl3) < 0) {
1835                 dev_err(card->dev, "OPL3 not detected at 0x%lx\n",
1836                            SLSB_REG(chip, FMLOWADDR));
1837         } else {
1838                 if ((err = snd_opl3_timer_new(opl3, 0, 1)) < 0) {
1839                         snd_card_free(card);
1840                         return err;
1841                 }
1842                 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
1843                         snd_card_free(card);
1844                         return err;
1845                 }
1846         }
1847         if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
1848                                 chip->mpu_port,
1849                                 MPU401_INFO_INTEGRATED | MPU401_INFO_IRQ_HOOK,
1850                                 -1, &chip->rmidi) < 0) {
1851                 dev_err(card->dev, "unable to initialize MPU-401\n");
1852         } else {
1853                 // this line is vital for MIDI interrupt handling on ess-solo1
1854                 // andreas@flying-snail.de
1855                 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0x40);
1856         }
1857 
1858         snd_es1938_create_gameport(chip);
1859 
1860         if ((err = snd_card_register(card)) < 0) {
1861                 snd_card_free(card);
1862                 return err;
1863         }
1864 
1865         pci_set_drvdata(pci, card);
1866         dev++;
1867         return 0;
1868 }
1869 
1870 static void snd_es1938_remove(struct pci_dev *pci)
1871 {
1872         snd_card_free(pci_get_drvdata(pci));
1873 }
1874 
1875 static struct pci_driver es1938_driver = {
1876         .name = KBUILD_MODNAME,
1877         .id_table = snd_es1938_ids,
1878         .probe = snd_es1938_probe,
1879         .remove = snd_es1938_remove,
1880         .driver = {
1881                 .pm = ES1938_PM_OPS,
1882         },
1883 };
1884 
1885 module_pci_driver(es1938_driver);
1886 

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