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