~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/pci/es1938.c

Version: ~ [ linux-5.6 ] ~ [ linux-5.5.13 ] ~ [ linux-5.4.28 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.113 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp