2 * Copyright (c) by Francisco Moraes <fmoraes@nc.rr.com>
3 * Driver EMU10K1X chips
5 * Parts of this code were adapted from audigyls.c driver which is
6 * Copyright (c) by James Courtier-Dutton <James@superbug.demon.co.uk>
13 * Chips (SB0200 model):
17 * This program is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License as published by
19 * the Free Software Foundation; either version 2 of the License, or
20 * (at your option) any later version.
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
27 * You should have received a copy of the GNU General Public License
28 * along with this program; if not, write to the Free Software
29 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
32 #include <linux/init.h>
33 #include <linux/interrupt.h>
34 #include <linux/pci.h>
35 #include <linux/dma-mapping.h>
36 #include <linux/slab.h>
37 #include <linux/module.h>
38 #include <sound/core.h>
39 #include <sound/initval.h>
40 #include <sound/pcm.h>
41 #include <sound/ac97_codec.h>
42 #include <sound/info.h>
43 #include <sound/rawmidi.h>
45 MODULE_AUTHOR("Francisco Moraes <fmoraes@nc.rr.com>");
46 MODULE_DESCRIPTION("EMU10K1X");
47 MODULE_LICENSE("GPL");
48 MODULE_SUPPORTED_DEVICE("{{Dell Creative Labs,SB Live!}");
50 // module parameters (see "Module Parameters")
51 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
;
52 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
;
53 static bool enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_PNP
;
55 module_param_array(index
, int, NULL
, 0444);
56 MODULE_PARM_DESC(index
, "Index value for the EMU10K1X soundcard.");
57 module_param_array(id
, charp
, NULL
, 0444);
58 MODULE_PARM_DESC(id
, "ID string for the EMU10K1X soundcard.");
59 module_param_array(enable
, bool, NULL
, 0444);
60 MODULE_PARM_DESC(enable
, "Enable the EMU10K1X soundcard.");
63 // some definitions were borrowed from emu10k1 driver as they seem to be the same
64 /************************************************************************************************/
65 /* PCI function 0 registers, address = <val> + PCIBASE0 */
66 /************************************************************************************************/
68 #define PTR 0x00 /* Indexed register set pointer register */
69 /* NOTE: The CHANNELNUM and ADDRESS words can */
70 /* be modified independently of each other. */
72 #define DATA 0x04 /* Indexed register set data register */
74 #define IPR 0x08 /* Global interrupt pending register */
75 /* Clear pending interrupts by writing a 1 to */
76 /* the relevant bits and zero to the other bits */
77 #define IPR_MIDITRANSBUFEMPTY 0x00000001 /* MIDI UART transmit buffer empty */
78 #define IPR_MIDIRECVBUFEMPTY 0x00000002 /* MIDI UART receive buffer empty */
79 #define IPR_CH_0_LOOP 0x00000800 /* Channel 0 loop */
80 #define IPR_CH_0_HALF_LOOP 0x00000100 /* Channel 0 half loop */
81 #define IPR_CAP_0_LOOP 0x00080000 /* Channel capture loop */
82 #define IPR_CAP_0_HALF_LOOP 0x00010000 /* Channel capture half loop */
84 #define INTE 0x0c /* Interrupt enable register */
85 #define INTE_MIDITXENABLE 0x00000001 /* Enable MIDI transmit-buffer-empty interrupts */
86 #define INTE_MIDIRXENABLE 0x00000002 /* Enable MIDI receive-buffer-empty interrupts */
87 #define INTE_CH_0_LOOP 0x00000800 /* Channel 0 loop */
88 #define INTE_CH_0_HALF_LOOP 0x00000100 /* Channel 0 half loop */
89 #define INTE_CAP_0_LOOP 0x00080000 /* Channel capture loop */
90 #define INTE_CAP_0_HALF_LOOP 0x00010000 /* Channel capture half loop */
92 #define HCFG 0x14 /* Hardware config register */
94 #define HCFG_LOCKSOUNDCACHE 0x00000008 /* 1 = Cancel bustmaster accesses to soundcache */
95 /* NOTE: This should generally never be used. */
96 #define HCFG_AUDIOENABLE 0x00000001 /* 0 = CODECs transmit zero-valued samples */
97 /* Should be set to 1 when the EMU10K1 is */
98 /* completely initialized. */
99 #define GPIO 0x18 /* Defaults: 00001080-Analog, 00001000-SPDIF. */
102 #define AC97DATA 0x1c /* AC97 register set data register (16 bit) */
104 #define AC97ADDRESS 0x1e /* AC97 register set address register (8 bit) */
106 /********************************************************************************************************/
107 /* Emu10k1x pointer-offset register set, accessed through the PTR and DATA registers */
108 /********************************************************************************************************/
109 #define PLAYBACK_LIST_ADDR 0x00 /* Base DMA address of a list of pointers to each period/size */
110 /* One list entry: 4 bytes for DMA address,
111 * 4 bytes for period_size << 16.
112 * One list entry is 8 bytes long.
113 * One list entry for each period in the buffer.
115 #define PLAYBACK_LIST_SIZE 0x01 /* Size of list in bytes << 16. E.g. 8 periods -> 0x00380000 */
116 #define PLAYBACK_LIST_PTR 0x02 /* Pointer to the current period being played */
117 #define PLAYBACK_DMA_ADDR 0x04 /* Playback DMA address */
118 #define PLAYBACK_PERIOD_SIZE 0x05 /* Playback period size */
119 #define PLAYBACK_POINTER 0x06 /* Playback period pointer. Sample currently in DAC */
120 #define PLAYBACK_UNKNOWN1 0x07
121 #define PLAYBACK_UNKNOWN2 0x08
123 /* Only one capture channel supported */
124 #define CAPTURE_DMA_ADDR 0x10 /* Capture DMA address */
125 #define CAPTURE_BUFFER_SIZE 0x11 /* Capture buffer size */
126 #define CAPTURE_POINTER 0x12 /* Capture buffer pointer. Sample currently in ADC */
127 #define CAPTURE_UNKNOWN 0x13
129 /* From 0x20 - 0x3f, last samples played on each channel */
131 #define TRIGGER_CHANNEL 0x40 /* Trigger channel playback */
132 #define TRIGGER_CHANNEL_0 0x00000001 /* Trigger channel 0 */
133 #define TRIGGER_CHANNEL_1 0x00000002 /* Trigger channel 1 */
134 #define TRIGGER_CHANNEL_2 0x00000004 /* Trigger channel 2 */
135 #define TRIGGER_CAPTURE 0x00000100 /* Trigger capture channel */
137 #define ROUTING 0x41 /* Setup sound routing ? */
138 #define ROUTING_FRONT_LEFT 0x00000001
139 #define ROUTING_FRONT_RIGHT 0x00000002
140 #define ROUTING_REAR_LEFT 0x00000004
141 #define ROUTING_REAR_RIGHT 0x00000008
142 #define ROUTING_CENTER_LFE 0x00010000
144 #define SPCS0 0x42 /* SPDIF output Channel Status 0 register */
146 #define SPCS1 0x43 /* SPDIF output Channel Status 1 register */
148 #define SPCS2 0x44 /* SPDIF output Channel Status 2 register */
150 #define SPCS_CLKACCYMASK 0x30000000 /* Clock accuracy */
151 #define SPCS_CLKACCY_1000PPM 0x00000000 /* 1000 parts per million */
152 #define SPCS_CLKACCY_50PPM 0x10000000 /* 50 parts per million */
153 #define SPCS_CLKACCY_VARIABLE 0x20000000 /* Variable accuracy */
154 #define SPCS_SAMPLERATEMASK 0x0f000000 /* Sample rate */
155 #define SPCS_SAMPLERATE_44 0x00000000 /* 44.1kHz sample rate */
156 #define SPCS_SAMPLERATE_48 0x02000000 /* 48kHz sample rate */
157 #define SPCS_SAMPLERATE_32 0x03000000 /* 32kHz sample rate */
158 #define SPCS_CHANNELNUMMASK 0x00f00000 /* Channel number */
159 #define SPCS_CHANNELNUM_UNSPEC 0x00000000 /* Unspecified channel number */
160 #define SPCS_CHANNELNUM_LEFT 0x00100000 /* Left channel */
161 #define SPCS_CHANNELNUM_RIGHT 0x00200000 /* Right channel */
162 #define SPCS_SOURCENUMMASK 0x000f0000 /* Source number */
163 #define SPCS_SOURCENUM_UNSPEC 0x00000000 /* Unspecified source number */
164 #define SPCS_GENERATIONSTATUS 0x00008000 /* Originality flag (see IEC-958 spec) */
165 #define SPCS_CATEGORYCODEMASK 0x00007f00 /* Category code (see IEC-958 spec) */
166 #define SPCS_MODEMASK 0x000000c0 /* Mode (see IEC-958 spec) */
167 #define SPCS_EMPHASISMASK 0x00000038 /* Emphasis */
168 #define SPCS_EMPHASIS_NONE 0x00000000 /* No emphasis */
169 #define SPCS_EMPHASIS_50_15 0x00000008 /* 50/15 usec 2 channel */
170 #define SPCS_COPYRIGHT 0x00000004 /* Copyright asserted flag -- do not modify */
171 #define SPCS_NOTAUDIODATA 0x00000002 /* 0 = Digital audio, 1 = not audio */
172 #define SPCS_PROFESSIONAL 0x00000001 /* 0 = Consumer (IEC-958), 1 = pro (AES3-1992) */
174 #define SPDIF_SELECT 0x45 /* Enables SPDIF or Analogue outputs 0-Analogue, 0x700-SPDIF */
176 /* This is the MPU port on the card */
181 /* From 0x50 - 0x5f, last samples captured */
184 * The hardware has 3 channels for playback and 1 for capture.
185 * - channel 0 is the front channel
186 * - channel 1 is the rear channel
187 * - channel 2 is the center/lfe channel
188 * Volume is controlled by the AC97 for the front and rear channels by
189 * the PCM Playback Volume, Sigmatel Surround Playback Volume and
190 * Surround Playback Volume. The Sigmatel 4-Speaker Stereo switch affects
191 * the front/rear channel mixing in the REAR OUT jack. When using the
192 * 4-Speaker Stereo, both front and rear channels will be mixed in the
194 * The center/lfe channel has no volume control and cannot be muted during
198 struct emu10k1x_voice
{
199 struct emu10k1x
*emu
;
203 struct emu10k1x_pcm
*epcm
;
206 struct emu10k1x_pcm
{
207 struct emu10k1x
*emu
;
208 struct snd_pcm_substream
*substream
;
209 struct emu10k1x_voice
*voice
;
210 unsigned short running
;
213 struct emu10k1x_midi
{
214 struct emu10k1x
*emu
;
215 struct snd_rawmidi
*rmidi
;
216 struct snd_rawmidi_substream
*substream_input
;
217 struct snd_rawmidi_substream
*substream_output
;
218 unsigned int midi_mode
;
219 spinlock_t input_lock
;
220 spinlock_t output_lock
;
221 spinlock_t open_lock
;
222 int tx_enable
, rx_enable
;
225 void (*interrupt
)(struct emu10k1x
*emu
, unsigned int status
);
228 // definition of the chip-specific record
230 struct snd_card
*card
;
234 struct resource
*res_port
;
237 unsigned char revision
; /* chip revision */
238 unsigned int serial
; /* serial number */
239 unsigned short model
; /* subsystem id */
242 spinlock_t voice_lock
;
244 struct snd_ac97
*ac97
;
247 struct emu10k1x_voice voices
[3];
248 struct emu10k1x_voice capture_voice
;
249 u32 spdif_bits
[3]; // SPDIF out setup
251 struct snd_dma_buffer dma_buffer
;
253 struct emu10k1x_midi midi
;
256 /* hardware definition */
257 static struct snd_pcm_hardware snd_emu10k1x_playback_hw
= {
258 .info
= (SNDRV_PCM_INFO_MMAP
|
259 SNDRV_PCM_INFO_INTERLEAVED
|
260 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
261 SNDRV_PCM_INFO_MMAP_VALID
),
262 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
263 .rates
= SNDRV_PCM_RATE_48000
,
268 .buffer_bytes_max
= (32*1024),
269 .period_bytes_min
= 64,
270 .period_bytes_max
= (16*1024),
276 static struct snd_pcm_hardware snd_emu10k1x_capture_hw
= {
277 .info
= (SNDRV_PCM_INFO_MMAP
|
278 SNDRV_PCM_INFO_INTERLEAVED
|
279 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
280 SNDRV_PCM_INFO_MMAP_VALID
),
281 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
282 .rates
= SNDRV_PCM_RATE_48000
,
287 .buffer_bytes_max
= (32*1024),
288 .period_bytes_min
= 64,
289 .period_bytes_max
= (16*1024),
295 static unsigned int snd_emu10k1x_ptr_read(struct emu10k1x
* emu
,
300 unsigned int regptr
, val
;
302 regptr
= (reg
<< 16) | chn
;
304 spin_lock_irqsave(&emu
->emu_lock
, flags
);
305 outl(regptr
, emu
->port
+ PTR
);
306 val
= inl(emu
->port
+ DATA
);
307 spin_unlock_irqrestore(&emu
->emu_lock
, flags
);
311 static void snd_emu10k1x_ptr_write(struct emu10k1x
*emu
,
319 regptr
= (reg
<< 16) | chn
;
321 spin_lock_irqsave(&emu
->emu_lock
, flags
);
322 outl(regptr
, emu
->port
+ PTR
);
323 outl(data
, emu
->port
+ DATA
);
324 spin_unlock_irqrestore(&emu
->emu_lock
, flags
);
327 static void snd_emu10k1x_intr_enable(struct emu10k1x
*emu
, unsigned int intrenb
)
330 unsigned int intr_enable
;
332 spin_lock_irqsave(&emu
->emu_lock
, flags
);
333 intr_enable
= inl(emu
->port
+ INTE
) | intrenb
;
334 outl(intr_enable
, emu
->port
+ INTE
);
335 spin_unlock_irqrestore(&emu
->emu_lock
, flags
);
338 static void snd_emu10k1x_intr_disable(struct emu10k1x
*emu
, unsigned int intrenb
)
341 unsigned int intr_enable
;
343 spin_lock_irqsave(&emu
->emu_lock
, flags
);
344 intr_enable
= inl(emu
->port
+ INTE
) & ~intrenb
;
345 outl(intr_enable
, emu
->port
+ INTE
);
346 spin_unlock_irqrestore(&emu
->emu_lock
, flags
);
349 static void snd_emu10k1x_gpio_write(struct emu10k1x
*emu
, unsigned int value
)
353 spin_lock_irqsave(&emu
->emu_lock
, flags
);
354 outl(value
, emu
->port
+ GPIO
);
355 spin_unlock_irqrestore(&emu
->emu_lock
, flags
);
358 static void snd_emu10k1x_pcm_free_substream(struct snd_pcm_runtime
*runtime
)
360 kfree(runtime
->private_data
);
363 static void snd_emu10k1x_pcm_interrupt(struct emu10k1x
*emu
, struct emu10k1x_voice
*voice
)
365 struct emu10k1x_pcm
*epcm
;
367 if ((epcm
= voice
->epcm
) == NULL
)
369 if (epcm
->substream
== NULL
)
372 snd_printk(KERN_INFO
"IRQ: position = 0x%x, period = 0x%x, size = 0x%x\n",
373 epcm
->substream
->ops
->pointer(epcm
->substream
),
374 snd_pcm_lib_period_bytes(epcm
->substream
),
375 snd_pcm_lib_buffer_bytes(epcm
->substream
));
377 snd_pcm_period_elapsed(epcm
->substream
);
381 static int snd_emu10k1x_playback_open(struct snd_pcm_substream
*substream
)
383 struct emu10k1x
*chip
= snd_pcm_substream_chip(substream
);
384 struct emu10k1x_pcm
*epcm
;
385 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
388 if ((err
= snd_pcm_hw_constraint_integer(runtime
, SNDRV_PCM_HW_PARAM_PERIODS
)) < 0) {
391 if ((err
= snd_pcm_hw_constraint_step(runtime
, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES
, 64)) < 0)
394 epcm
= kzalloc(sizeof(*epcm
), GFP_KERNEL
);
398 epcm
->substream
= substream
;
400 runtime
->private_data
= epcm
;
401 runtime
->private_free
= snd_emu10k1x_pcm_free_substream
;
403 runtime
->hw
= snd_emu10k1x_playback_hw
;
409 static int snd_emu10k1x_playback_close(struct snd_pcm_substream
*substream
)
414 /* hw_params callback */
415 static int snd_emu10k1x_pcm_hw_params(struct snd_pcm_substream
*substream
,
416 struct snd_pcm_hw_params
*hw_params
)
418 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
419 struct emu10k1x_pcm
*epcm
= runtime
->private_data
;
422 epcm
->voice
= &epcm
->emu
->voices
[substream
->pcm
->device
];
423 epcm
->voice
->use
= 1;
424 epcm
->voice
->epcm
= epcm
;
427 return snd_pcm_lib_malloc_pages(substream
,
428 params_buffer_bytes(hw_params
));
431 /* hw_free callback */
432 static int snd_emu10k1x_pcm_hw_free(struct snd_pcm_substream
*substream
)
434 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
435 struct emu10k1x_pcm
*epcm
;
437 if (runtime
->private_data
== NULL
)
440 epcm
= runtime
->private_data
;
443 epcm
->voice
->use
= 0;
444 epcm
->voice
->epcm
= NULL
;
448 return snd_pcm_lib_free_pages(substream
);
451 /* prepare callback */
452 static int snd_emu10k1x_pcm_prepare(struct snd_pcm_substream
*substream
)
454 struct emu10k1x
*emu
= snd_pcm_substream_chip(substream
);
455 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
456 struct emu10k1x_pcm
*epcm
= runtime
->private_data
;
457 int voice
= epcm
->voice
->number
;
458 u32
*table_base
= (u32
*)(emu
->dma_buffer
.area
+1024*voice
);
459 u32 period_size_bytes
= frames_to_bytes(runtime
, runtime
->period_size
);
462 for(i
= 0; i
< runtime
->periods
; i
++) {
463 *table_base
++=runtime
->dma_addr
+(i
*period_size_bytes
);
464 *table_base
++=period_size_bytes
<<16;
467 snd_emu10k1x_ptr_write(emu
, PLAYBACK_LIST_ADDR
, voice
, emu
->dma_buffer
.addr
+1024*voice
);
468 snd_emu10k1x_ptr_write(emu
, PLAYBACK_LIST_SIZE
, voice
, (runtime
->periods
- 1) << 19);
469 snd_emu10k1x_ptr_write(emu
, PLAYBACK_LIST_PTR
, voice
, 0);
470 snd_emu10k1x_ptr_write(emu
, PLAYBACK_POINTER
, voice
, 0);
471 snd_emu10k1x_ptr_write(emu
, PLAYBACK_UNKNOWN1
, voice
, 0);
472 snd_emu10k1x_ptr_write(emu
, PLAYBACK_UNKNOWN2
, voice
, 0);
473 snd_emu10k1x_ptr_write(emu
, PLAYBACK_DMA_ADDR
, voice
, runtime
->dma_addr
);
475 snd_emu10k1x_ptr_write(emu
, PLAYBACK_PERIOD_SIZE
, voice
, frames_to_bytes(runtime
, runtime
->period_size
)<<16);
480 /* trigger callback */
481 static int snd_emu10k1x_pcm_trigger(struct snd_pcm_substream
*substream
,
484 struct emu10k1x
*emu
= snd_pcm_substream_chip(substream
);
485 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
486 struct emu10k1x_pcm
*epcm
= runtime
->private_data
;
487 int channel
= epcm
->voice
->number
;
490 // snd_printk(KERN_INFO "trigger - emu10k1x = 0x%x, cmd = %i, pointer = %d\n", (int)emu, cmd, (int)substream->ops->pointer(substream));
493 case SNDRV_PCM_TRIGGER_START
:
494 if(runtime
->periods
== 2)
495 snd_emu10k1x_intr_enable(emu
, (INTE_CH_0_LOOP
| INTE_CH_0_HALF_LOOP
) << channel
);
497 snd_emu10k1x_intr_enable(emu
, INTE_CH_0_LOOP
<< channel
);
499 snd_emu10k1x_ptr_write(emu
, TRIGGER_CHANNEL
, 0, snd_emu10k1x_ptr_read(emu
, TRIGGER_CHANNEL
, 0)|(TRIGGER_CHANNEL_0
<<channel
));
501 case SNDRV_PCM_TRIGGER_STOP
:
503 snd_emu10k1x_intr_disable(emu
, (INTE_CH_0_LOOP
| INTE_CH_0_HALF_LOOP
) << channel
);
504 snd_emu10k1x_ptr_write(emu
, TRIGGER_CHANNEL
, 0, snd_emu10k1x_ptr_read(emu
, TRIGGER_CHANNEL
, 0) & ~(TRIGGER_CHANNEL_0
<<channel
));
513 /* pointer callback */
514 static snd_pcm_uframes_t
515 snd_emu10k1x_pcm_pointer(struct snd_pcm_substream
*substream
)
517 struct emu10k1x
*emu
= snd_pcm_substream_chip(substream
);
518 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
519 struct emu10k1x_pcm
*epcm
= runtime
->private_data
;
520 int channel
= epcm
->voice
->number
;
521 snd_pcm_uframes_t ptr
= 0, ptr1
= 0, ptr2
= 0,ptr3
= 0,ptr4
= 0;
526 ptr3
= snd_emu10k1x_ptr_read(emu
, PLAYBACK_LIST_PTR
, channel
);
527 ptr1
= snd_emu10k1x_ptr_read(emu
, PLAYBACK_POINTER
, channel
);
528 ptr4
= snd_emu10k1x_ptr_read(emu
, PLAYBACK_LIST_PTR
, channel
);
530 if(ptr4
== 0 && ptr1
== frames_to_bytes(runtime
, runtime
->buffer_size
))
534 ptr1
= snd_emu10k1x_ptr_read(emu
, PLAYBACK_POINTER
, channel
);
535 ptr2
= bytes_to_frames(runtime
, ptr1
);
536 ptr2
+= (ptr4
>> 3) * runtime
->period_size
;
539 if (ptr
>= runtime
->buffer_size
)
540 ptr
-= runtime
->buffer_size
;
546 static struct snd_pcm_ops snd_emu10k1x_playback_ops
= {
547 .open
= snd_emu10k1x_playback_open
,
548 .close
= snd_emu10k1x_playback_close
,
549 .ioctl
= snd_pcm_lib_ioctl
,
550 .hw_params
= snd_emu10k1x_pcm_hw_params
,
551 .hw_free
= snd_emu10k1x_pcm_hw_free
,
552 .prepare
= snd_emu10k1x_pcm_prepare
,
553 .trigger
= snd_emu10k1x_pcm_trigger
,
554 .pointer
= snd_emu10k1x_pcm_pointer
,
557 /* open_capture callback */
558 static int snd_emu10k1x_pcm_open_capture(struct snd_pcm_substream
*substream
)
560 struct emu10k1x
*chip
= snd_pcm_substream_chip(substream
);
561 struct emu10k1x_pcm
*epcm
;
562 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
565 if ((err
= snd_pcm_hw_constraint_integer(runtime
, SNDRV_PCM_HW_PARAM_PERIODS
)) < 0)
567 if ((err
= snd_pcm_hw_constraint_step(runtime
, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES
, 64)) < 0)
570 epcm
= kzalloc(sizeof(*epcm
), GFP_KERNEL
);
575 epcm
->substream
= substream
;
577 runtime
->private_data
= epcm
;
578 runtime
->private_free
= snd_emu10k1x_pcm_free_substream
;
580 runtime
->hw
= snd_emu10k1x_capture_hw
;
586 static int snd_emu10k1x_pcm_close_capture(struct snd_pcm_substream
*substream
)
591 /* hw_params callback */
592 static int snd_emu10k1x_pcm_hw_params_capture(struct snd_pcm_substream
*substream
,
593 struct snd_pcm_hw_params
*hw_params
)
595 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
596 struct emu10k1x_pcm
*epcm
= runtime
->private_data
;
599 if (epcm
->emu
->capture_voice
.use
)
601 epcm
->voice
= &epcm
->emu
->capture_voice
;
602 epcm
->voice
->epcm
= epcm
;
603 epcm
->voice
->use
= 1;
606 return snd_pcm_lib_malloc_pages(substream
,
607 params_buffer_bytes(hw_params
));
610 /* hw_free callback */
611 static int snd_emu10k1x_pcm_hw_free_capture(struct snd_pcm_substream
*substream
)
613 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
615 struct emu10k1x_pcm
*epcm
;
617 if (runtime
->private_data
== NULL
)
619 epcm
= runtime
->private_data
;
622 epcm
->voice
->use
= 0;
623 epcm
->voice
->epcm
= NULL
;
627 return snd_pcm_lib_free_pages(substream
);
630 /* prepare capture callback */
631 static int snd_emu10k1x_pcm_prepare_capture(struct snd_pcm_substream
*substream
)
633 struct emu10k1x
*emu
= snd_pcm_substream_chip(substream
);
634 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
636 snd_emu10k1x_ptr_write(emu
, CAPTURE_DMA_ADDR
, 0, runtime
->dma_addr
);
637 snd_emu10k1x_ptr_write(emu
, CAPTURE_BUFFER_SIZE
, 0, frames_to_bytes(runtime
, runtime
->buffer_size
)<<16); // buffer size in bytes
638 snd_emu10k1x_ptr_write(emu
, CAPTURE_POINTER
, 0, 0);
639 snd_emu10k1x_ptr_write(emu
, CAPTURE_UNKNOWN
, 0, 0);
644 /* trigger_capture callback */
645 static int snd_emu10k1x_pcm_trigger_capture(struct snd_pcm_substream
*substream
,
648 struct emu10k1x
*emu
= snd_pcm_substream_chip(substream
);
649 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
650 struct emu10k1x_pcm
*epcm
= runtime
->private_data
;
654 case SNDRV_PCM_TRIGGER_START
:
655 snd_emu10k1x_intr_enable(emu
, INTE_CAP_0_LOOP
|
656 INTE_CAP_0_HALF_LOOP
);
657 snd_emu10k1x_ptr_write(emu
, TRIGGER_CHANNEL
, 0, snd_emu10k1x_ptr_read(emu
, TRIGGER_CHANNEL
, 0)|TRIGGER_CAPTURE
);
660 case SNDRV_PCM_TRIGGER_STOP
:
662 snd_emu10k1x_intr_disable(emu
, INTE_CAP_0_LOOP
|
663 INTE_CAP_0_HALF_LOOP
);
664 snd_emu10k1x_ptr_write(emu
, TRIGGER_CHANNEL
, 0, snd_emu10k1x_ptr_read(emu
, TRIGGER_CHANNEL
, 0) & ~(TRIGGER_CAPTURE
));
673 /* pointer_capture callback */
674 static snd_pcm_uframes_t
675 snd_emu10k1x_pcm_pointer_capture(struct snd_pcm_substream
*substream
)
677 struct emu10k1x
*emu
= snd_pcm_substream_chip(substream
);
678 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
679 struct emu10k1x_pcm
*epcm
= runtime
->private_data
;
680 snd_pcm_uframes_t ptr
;
685 ptr
= bytes_to_frames(runtime
, snd_emu10k1x_ptr_read(emu
, CAPTURE_POINTER
, 0));
686 if (ptr
>= runtime
->buffer_size
)
687 ptr
-= runtime
->buffer_size
;
692 static struct snd_pcm_ops snd_emu10k1x_capture_ops
= {
693 .open
= snd_emu10k1x_pcm_open_capture
,
694 .close
= snd_emu10k1x_pcm_close_capture
,
695 .ioctl
= snd_pcm_lib_ioctl
,
696 .hw_params
= snd_emu10k1x_pcm_hw_params_capture
,
697 .hw_free
= snd_emu10k1x_pcm_hw_free_capture
,
698 .prepare
= snd_emu10k1x_pcm_prepare_capture
,
699 .trigger
= snd_emu10k1x_pcm_trigger_capture
,
700 .pointer
= snd_emu10k1x_pcm_pointer_capture
,
703 static unsigned short snd_emu10k1x_ac97_read(struct snd_ac97
*ac97
,
706 struct emu10k1x
*emu
= ac97
->private_data
;
710 spin_lock_irqsave(&emu
->emu_lock
, flags
);
711 outb(reg
, emu
->port
+ AC97ADDRESS
);
712 val
= inw(emu
->port
+ AC97DATA
);
713 spin_unlock_irqrestore(&emu
->emu_lock
, flags
);
717 static void snd_emu10k1x_ac97_write(struct snd_ac97
*ac97
,
718 unsigned short reg
, unsigned short val
)
720 struct emu10k1x
*emu
= ac97
->private_data
;
723 spin_lock_irqsave(&emu
->emu_lock
, flags
);
724 outb(reg
, emu
->port
+ AC97ADDRESS
);
725 outw(val
, emu
->port
+ AC97DATA
);
726 spin_unlock_irqrestore(&emu
->emu_lock
, flags
);
729 static int snd_emu10k1x_ac97(struct emu10k1x
*chip
)
731 struct snd_ac97_bus
*pbus
;
732 struct snd_ac97_template ac97
;
734 static struct snd_ac97_bus_ops ops
= {
735 .write
= snd_emu10k1x_ac97_write
,
736 .read
= snd_emu10k1x_ac97_read
,
739 if ((err
= snd_ac97_bus(chip
->card
, 0, &ops
, NULL
, &pbus
)) < 0)
741 pbus
->no_vra
= 1; /* we don't need VRA */
743 memset(&ac97
, 0, sizeof(ac97
));
744 ac97
.private_data
= chip
;
745 ac97
.scaps
= AC97_SCAP_NO_SPDIF
;
746 return snd_ac97_mixer(pbus
, &ac97
, &chip
->ac97
);
749 static int snd_emu10k1x_free(struct emu10k1x
*chip
)
751 snd_emu10k1x_ptr_write(chip
, TRIGGER_CHANNEL
, 0, 0);
752 // disable interrupts
753 outl(0, chip
->port
+ INTE
);
755 outl(HCFG_LOCKSOUNDCACHE
, chip
->port
+ HCFG
);
757 /* release the irq */
759 free_irq(chip
->irq
, chip
);
761 // release the i/o port
762 release_and_free_resource(chip
->res_port
);
765 if (chip
->dma_buffer
.area
) {
766 snd_dma_free_pages(&chip
->dma_buffer
);
769 pci_disable_device(chip
->pci
);
776 static int snd_emu10k1x_dev_free(struct snd_device
*device
)
778 struct emu10k1x
*chip
= device
->device_data
;
779 return snd_emu10k1x_free(chip
);
782 static irqreturn_t
snd_emu10k1x_interrupt(int irq
, void *dev_id
)
786 struct emu10k1x
*chip
= dev_id
;
787 struct emu10k1x_voice
*pvoice
= chip
->voices
;
791 status
= inl(chip
->port
+ IPR
);
797 if (status
& (IPR_CAP_0_LOOP
| IPR_CAP_0_HALF_LOOP
)) {
798 struct emu10k1x_voice
*cap_voice
= &chip
->capture_voice
;
800 snd_emu10k1x_pcm_interrupt(chip
, cap_voice
);
802 snd_emu10k1x_intr_disable(chip
,
804 INTE_CAP_0_HALF_LOOP
);
807 mask
= IPR_CH_0_LOOP
|IPR_CH_0_HALF_LOOP
;
808 for (i
= 0; i
< 3; i
++) {
811 snd_emu10k1x_pcm_interrupt(chip
, pvoice
);
813 snd_emu10k1x_intr_disable(chip
, mask
);
819 if (status
& (IPR_MIDITRANSBUFEMPTY
|IPR_MIDIRECVBUFEMPTY
)) {
820 if (chip
->midi
.interrupt
)
821 chip
->midi
.interrupt(chip
, status
);
823 snd_emu10k1x_intr_disable(chip
, INTE_MIDITXENABLE
|INTE_MIDIRXENABLE
);
826 // acknowledge the interrupt if necessary
827 outl(status
, chip
->port
+ IPR
);
829 // snd_printk(KERN_INFO "interrupt %08x\n", status);
833 static int __devinit
snd_emu10k1x_pcm(struct emu10k1x
*emu
, int device
, struct snd_pcm
**rpcm
)
844 if ((err
= snd_pcm_new(emu
->card
, "emu10k1x", device
, 1, capture
, &pcm
)) < 0)
847 pcm
->private_data
= emu
;
851 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_emu10k1x_playback_ops
);
852 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_emu10k1x_capture_ops
);
856 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_emu10k1x_playback_ops
);
863 strcpy(pcm
->name
, "EMU10K1X Front");
866 strcpy(pcm
->name
, "EMU10K1X Rear");
869 strcpy(pcm
->name
, "EMU10K1X Center/LFE");
874 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_DEV
,
875 snd_dma_pci_data(emu
->pci
),
884 static int __devinit
snd_emu10k1x_create(struct snd_card
*card
,
886 struct emu10k1x
**rchip
)
888 struct emu10k1x
*chip
;
891 static struct snd_device_ops ops
= {
892 .dev_free
= snd_emu10k1x_dev_free
,
897 if ((err
= pci_enable_device(pci
)) < 0)
899 if (pci_set_dma_mask(pci
, DMA_BIT_MASK(28)) < 0 ||
900 pci_set_consistent_dma_mask(pci
, DMA_BIT_MASK(28)) < 0) {
901 snd_printk(KERN_ERR
"error to set 28bit mask DMA\n");
902 pci_disable_device(pci
);
906 chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
908 pci_disable_device(pci
);
916 spin_lock_init(&chip
->emu_lock
);
917 spin_lock_init(&chip
->voice_lock
);
919 chip
->port
= pci_resource_start(pci
, 0);
920 if ((chip
->res_port
= request_region(chip
->port
, 8,
921 "EMU10K1X")) == NULL
) {
922 snd_printk(KERN_ERR
"emu10k1x: cannot allocate the port 0x%lx\n", chip
->port
);
923 snd_emu10k1x_free(chip
);
927 if (request_irq(pci
->irq
, snd_emu10k1x_interrupt
,
928 IRQF_SHARED
, KBUILD_MODNAME
, chip
)) {
929 snd_printk(KERN_ERR
"emu10k1x: cannot grab irq %d\n", pci
->irq
);
930 snd_emu10k1x_free(chip
);
933 chip
->irq
= pci
->irq
;
935 if(snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(pci
),
936 4 * 1024, &chip
->dma_buffer
) < 0) {
937 snd_emu10k1x_free(chip
);
942 /* read revision & serial */
943 chip
->revision
= pci
->revision
;
944 pci_read_config_dword(pci
, PCI_SUBSYSTEM_VENDOR_ID
, &chip
->serial
);
945 pci_read_config_word(pci
, PCI_SUBSYSTEM_ID
, &chip
->model
);
946 snd_printk(KERN_INFO
"Model %04x Rev %08x Serial %08x\n", chip
->model
,
947 chip
->revision
, chip
->serial
);
949 outl(0, chip
->port
+ INTE
);
951 for(ch
= 0; ch
< 3; ch
++) {
952 chip
->voices
[ch
].emu
= chip
;
953 chip
->voices
[ch
].number
= ch
;
957 * Init to 0x02109204 :
958 * Clock accuracy = 0 (1000ppm)
959 * Sample Rate = 2 (48kHz)
960 * Audio Channel = 1 (Left of 2)
961 * Source Number = 0 (Unspecified)
962 * Generation Status = 1 (Original for Cat Code 12)
963 * Cat Code = 12 (Digital Signal Mixer)
965 * Emphasis = 0 (None)
966 * CP = 1 (Copyright unasserted)
967 * AN = 0 (Audio data)
970 snd_emu10k1x_ptr_write(chip
, SPCS0
, 0,
971 chip
->spdif_bits
[0] =
972 SPCS_CLKACCY_1000PPM
| SPCS_SAMPLERATE_48
|
973 SPCS_CHANNELNUM_LEFT
| SPCS_SOURCENUM_UNSPEC
|
974 SPCS_GENERATIONSTATUS
| 0x00001200 |
975 0x00000000 | SPCS_EMPHASIS_NONE
| SPCS_COPYRIGHT
);
976 snd_emu10k1x_ptr_write(chip
, SPCS1
, 0,
977 chip
->spdif_bits
[1] =
978 SPCS_CLKACCY_1000PPM
| SPCS_SAMPLERATE_48
|
979 SPCS_CHANNELNUM_LEFT
| SPCS_SOURCENUM_UNSPEC
|
980 SPCS_GENERATIONSTATUS
| 0x00001200 |
981 0x00000000 | SPCS_EMPHASIS_NONE
| SPCS_COPYRIGHT
);
982 snd_emu10k1x_ptr_write(chip
, SPCS2
, 0,
983 chip
->spdif_bits
[2] =
984 SPCS_CLKACCY_1000PPM
| SPCS_SAMPLERATE_48
|
985 SPCS_CHANNELNUM_LEFT
| SPCS_SOURCENUM_UNSPEC
|
986 SPCS_GENERATIONSTATUS
| 0x00001200 |
987 0x00000000 | SPCS_EMPHASIS_NONE
| SPCS_COPYRIGHT
);
989 snd_emu10k1x_ptr_write(chip
, SPDIF_SELECT
, 0, 0x700); // disable SPDIF
990 snd_emu10k1x_ptr_write(chip
, ROUTING
, 0, 0x1003F); // routing
991 snd_emu10k1x_gpio_write(chip
, 0x1080); // analog mode
993 outl(HCFG_LOCKSOUNDCACHE
|HCFG_AUDIOENABLE
, chip
->port
+HCFG
);
995 if ((err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
,
997 snd_emu10k1x_free(chip
);
1004 static void snd_emu10k1x_proc_reg_read(struct snd_info_entry
*entry
,
1005 struct snd_info_buffer
*buffer
)
1007 struct emu10k1x
*emu
= entry
->private_data
;
1008 unsigned long value
,value1
,value2
;
1009 unsigned long flags
;
1012 snd_iprintf(buffer
, "Registers:\n\n");
1013 for(i
= 0; i
< 0x20; i
+=4) {
1014 spin_lock_irqsave(&emu
->emu_lock
, flags
);
1015 value
= inl(emu
->port
+ i
);
1016 spin_unlock_irqrestore(&emu
->emu_lock
, flags
);
1017 snd_iprintf(buffer
, "Register %02X: %08lX\n", i
, value
);
1019 snd_iprintf(buffer
, "\nRegisters\n\n");
1020 for(i
= 0; i
<= 0x48; i
++) {
1021 value
= snd_emu10k1x_ptr_read(emu
, i
, 0);
1022 if(i
< 0x10 || (i
>= 0x20 && i
< 0x40)) {
1023 value1
= snd_emu10k1x_ptr_read(emu
, i
, 1);
1024 value2
= snd_emu10k1x_ptr_read(emu
, i
, 2);
1025 snd_iprintf(buffer
, "%02X: %08lX %08lX %08lX\n", i
, value
, value1
, value2
);
1027 snd_iprintf(buffer
, "%02X: %08lX\n", i
, value
);
1032 static void snd_emu10k1x_proc_reg_write(struct snd_info_entry
*entry
,
1033 struct snd_info_buffer
*buffer
)
1035 struct emu10k1x
*emu
= entry
->private_data
;
1037 unsigned int reg
, channel_id
, val
;
1039 while (!snd_info_get_line(buffer
, line
, sizeof(line
))) {
1040 if (sscanf(line
, "%x %x %x", ®
, &channel_id
, &val
) != 3)
1043 if (reg
< 0x49 && val
<= 0xffffffff && channel_id
<= 2)
1044 snd_emu10k1x_ptr_write(emu
, reg
, channel_id
, val
);
1048 static int __devinit
snd_emu10k1x_proc_init(struct emu10k1x
* emu
)
1050 struct snd_info_entry
*entry
;
1052 if(! snd_card_proc_new(emu
->card
, "emu10k1x_regs", &entry
)) {
1053 snd_info_set_text_ops(entry
, emu
, snd_emu10k1x_proc_reg_read
);
1054 entry
->c
.text
.write
= snd_emu10k1x_proc_reg_write
;
1055 entry
->mode
|= S_IWUSR
;
1056 entry
->private_data
= emu
;
1062 #define snd_emu10k1x_shared_spdif_info snd_ctl_boolean_mono_info
1064 static int snd_emu10k1x_shared_spdif_get(struct snd_kcontrol
*kcontrol
,
1065 struct snd_ctl_elem_value
*ucontrol
)
1067 struct emu10k1x
*emu
= snd_kcontrol_chip(kcontrol
);
1069 ucontrol
->value
.integer
.value
[0] = (snd_emu10k1x_ptr_read(emu
, SPDIF_SELECT
, 0) == 0x700) ? 0 : 1;
1074 static int snd_emu10k1x_shared_spdif_put(struct snd_kcontrol
*kcontrol
,
1075 struct snd_ctl_elem_value
*ucontrol
)
1077 struct emu10k1x
*emu
= snd_kcontrol_chip(kcontrol
);
1081 val
= ucontrol
->value
.integer
.value
[0] ;
1084 // enable spdif output
1085 snd_emu10k1x_ptr_write(emu
, SPDIF_SELECT
, 0, 0x000);
1086 snd_emu10k1x_ptr_write(emu
, ROUTING
, 0, 0x700);
1087 snd_emu10k1x_gpio_write(emu
, 0x1000);
1089 // disable spdif output
1090 snd_emu10k1x_ptr_write(emu
, SPDIF_SELECT
, 0, 0x700);
1091 snd_emu10k1x_ptr_write(emu
, ROUTING
, 0, 0x1003F);
1092 snd_emu10k1x_gpio_write(emu
, 0x1080);
1097 static struct snd_kcontrol_new snd_emu10k1x_shared_spdif __devinitdata
=
1099 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1100 .name
= "Analog/Digital Output Jack",
1101 .info
= snd_emu10k1x_shared_spdif_info
,
1102 .get
= snd_emu10k1x_shared_spdif_get
,
1103 .put
= snd_emu10k1x_shared_spdif_put
1106 static int snd_emu10k1x_spdif_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
1108 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
1113 static int snd_emu10k1x_spdif_get(struct snd_kcontrol
*kcontrol
,
1114 struct snd_ctl_elem_value
*ucontrol
)
1116 struct emu10k1x
*emu
= snd_kcontrol_chip(kcontrol
);
1117 unsigned int idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
1119 ucontrol
->value
.iec958
.status
[0] = (emu
->spdif_bits
[idx
] >> 0) & 0xff;
1120 ucontrol
->value
.iec958
.status
[1] = (emu
->spdif_bits
[idx
] >> 8) & 0xff;
1121 ucontrol
->value
.iec958
.status
[2] = (emu
->spdif_bits
[idx
] >> 16) & 0xff;
1122 ucontrol
->value
.iec958
.status
[3] = (emu
->spdif_bits
[idx
] >> 24) & 0xff;
1126 static int snd_emu10k1x_spdif_get_mask(struct snd_kcontrol
*kcontrol
,
1127 struct snd_ctl_elem_value
*ucontrol
)
1129 ucontrol
->value
.iec958
.status
[0] = 0xff;
1130 ucontrol
->value
.iec958
.status
[1] = 0xff;
1131 ucontrol
->value
.iec958
.status
[2] = 0xff;
1132 ucontrol
->value
.iec958
.status
[3] = 0xff;
1136 static int snd_emu10k1x_spdif_put(struct snd_kcontrol
*kcontrol
,
1137 struct snd_ctl_elem_value
*ucontrol
)
1139 struct emu10k1x
*emu
= snd_kcontrol_chip(kcontrol
);
1140 unsigned int idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
1144 val
= (ucontrol
->value
.iec958
.status
[0] << 0) |
1145 (ucontrol
->value
.iec958
.status
[1] << 8) |
1146 (ucontrol
->value
.iec958
.status
[2] << 16) |
1147 (ucontrol
->value
.iec958
.status
[3] << 24);
1148 change
= val
!= emu
->spdif_bits
[idx
];
1150 snd_emu10k1x_ptr_write(emu
, SPCS0
+ idx
, 0, val
);
1151 emu
->spdif_bits
[idx
] = val
;
1156 static struct snd_kcontrol_new snd_emu10k1x_spdif_mask_control
=
1158 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
1159 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
1160 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,MASK
),
1162 .info
= snd_emu10k1x_spdif_info
,
1163 .get
= snd_emu10k1x_spdif_get_mask
1166 static struct snd_kcontrol_new snd_emu10k1x_spdif_control
=
1168 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
1169 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,DEFAULT
),
1171 .info
= snd_emu10k1x_spdif_info
,
1172 .get
= snd_emu10k1x_spdif_get
,
1173 .put
= snd_emu10k1x_spdif_put
1176 static int __devinit
snd_emu10k1x_mixer(struct emu10k1x
*emu
)
1179 struct snd_kcontrol
*kctl
;
1180 struct snd_card
*card
= emu
->card
;
1182 if ((kctl
= snd_ctl_new1(&snd_emu10k1x_spdif_mask_control
, emu
)) == NULL
)
1184 if ((err
= snd_ctl_add(card
, kctl
)))
1186 if ((kctl
= snd_ctl_new1(&snd_emu10k1x_shared_spdif
, emu
)) == NULL
)
1188 if ((err
= snd_ctl_add(card
, kctl
)))
1190 if ((kctl
= snd_ctl_new1(&snd_emu10k1x_spdif_control
, emu
)) == NULL
)
1192 if ((err
= snd_ctl_add(card
, kctl
)))
1198 #define EMU10K1X_MIDI_MODE_INPUT (1<<0)
1199 #define EMU10K1X_MIDI_MODE_OUTPUT (1<<1)
1201 static inline unsigned char mpu401_read(struct emu10k1x
*emu
, struct emu10k1x_midi
*mpu
, int idx
)
1203 return (unsigned char)snd_emu10k1x_ptr_read(emu
, mpu
->port
+ idx
, 0);
1206 static inline void mpu401_write(struct emu10k1x
*emu
, struct emu10k1x_midi
*mpu
, int data
, int idx
)
1208 snd_emu10k1x_ptr_write(emu
, mpu
->port
+ idx
, 0, data
);
1211 #define mpu401_write_data(emu, mpu, data) mpu401_write(emu, mpu, data, 0)
1212 #define mpu401_write_cmd(emu, mpu, data) mpu401_write(emu, mpu, data, 1)
1213 #define mpu401_read_data(emu, mpu) mpu401_read(emu, mpu, 0)
1214 #define mpu401_read_stat(emu, mpu) mpu401_read(emu, mpu, 1)
1216 #define mpu401_input_avail(emu,mpu) (!(mpu401_read_stat(emu,mpu) & 0x80))
1217 #define mpu401_output_ready(emu,mpu) (!(mpu401_read_stat(emu,mpu) & 0x40))
1219 #define MPU401_RESET 0xff
1220 #define MPU401_ENTER_UART 0x3f
1221 #define MPU401_ACK 0xfe
1223 static void mpu401_clear_rx(struct emu10k1x
*emu
, struct emu10k1x_midi
*mpu
)
1225 int timeout
= 100000;
1226 for (; timeout
> 0 && mpu401_input_avail(emu
, mpu
); timeout
--)
1227 mpu401_read_data(emu
, mpu
);
1228 #ifdef CONFIG_SND_DEBUG
1230 snd_printk(KERN_ERR
"cmd: clear rx timeout (status = 0x%x)\n", mpu401_read_stat(emu
, mpu
));
1238 static void do_emu10k1x_midi_interrupt(struct emu10k1x
*emu
,
1239 struct emu10k1x_midi
*midi
, unsigned int status
)
1243 if (midi
->rmidi
== NULL
) {
1244 snd_emu10k1x_intr_disable(emu
, midi
->tx_enable
| midi
->rx_enable
);
1248 spin_lock(&midi
->input_lock
);
1249 if ((status
& midi
->ipr_rx
) && mpu401_input_avail(emu
, midi
)) {
1250 if (!(midi
->midi_mode
& EMU10K1X_MIDI_MODE_INPUT
)) {
1251 mpu401_clear_rx(emu
, midi
);
1253 byte
= mpu401_read_data(emu
, midi
);
1254 if (midi
->substream_input
)
1255 snd_rawmidi_receive(midi
->substream_input
, &byte
, 1);
1258 spin_unlock(&midi
->input_lock
);
1260 spin_lock(&midi
->output_lock
);
1261 if ((status
& midi
->ipr_tx
) && mpu401_output_ready(emu
, midi
)) {
1262 if (midi
->substream_output
&&
1263 snd_rawmidi_transmit(midi
->substream_output
, &byte
, 1) == 1) {
1264 mpu401_write_data(emu
, midi
, byte
);
1266 snd_emu10k1x_intr_disable(emu
, midi
->tx_enable
);
1269 spin_unlock(&midi
->output_lock
);
1272 static void snd_emu10k1x_midi_interrupt(struct emu10k1x
*emu
, unsigned int status
)
1274 do_emu10k1x_midi_interrupt(emu
, &emu
->midi
, status
);
1277 static int snd_emu10k1x_midi_cmd(struct emu10k1x
* emu
,
1278 struct emu10k1x_midi
*midi
, unsigned char cmd
, int ack
)
1280 unsigned long flags
;
1283 spin_lock_irqsave(&midi
->input_lock
, flags
);
1284 mpu401_write_data(emu
, midi
, 0x00);
1285 /* mpu401_clear_rx(emu, midi); */
1287 mpu401_write_cmd(emu
, midi
, cmd
);
1291 while (!ok
&& timeout
-- > 0) {
1292 if (mpu401_input_avail(emu
, midi
)) {
1293 if (mpu401_read_data(emu
, midi
) == MPU401_ACK
)
1297 if (!ok
&& mpu401_read_data(emu
, midi
) == MPU401_ACK
)
1302 spin_unlock_irqrestore(&midi
->input_lock
, flags
);
1304 snd_printk(KERN_ERR
"midi_cmd: 0x%x failed at 0x%lx (status = 0x%x, data = 0x%x)!!!\n",
1306 mpu401_read_stat(emu
, midi
),
1307 mpu401_read_data(emu
, midi
));
1313 static int snd_emu10k1x_midi_input_open(struct snd_rawmidi_substream
*substream
)
1315 struct emu10k1x
*emu
;
1316 struct emu10k1x_midi
*midi
= substream
->rmidi
->private_data
;
1317 unsigned long flags
;
1320 if (snd_BUG_ON(!emu
))
1322 spin_lock_irqsave(&midi
->open_lock
, flags
);
1323 midi
->midi_mode
|= EMU10K1X_MIDI_MODE_INPUT
;
1324 midi
->substream_input
= substream
;
1325 if (!(midi
->midi_mode
& EMU10K1X_MIDI_MODE_OUTPUT
)) {
1326 spin_unlock_irqrestore(&midi
->open_lock
, flags
);
1327 if (snd_emu10k1x_midi_cmd(emu
, midi
, MPU401_RESET
, 1))
1329 if (snd_emu10k1x_midi_cmd(emu
, midi
, MPU401_ENTER_UART
, 1))
1332 spin_unlock_irqrestore(&midi
->open_lock
, flags
);
1340 static int snd_emu10k1x_midi_output_open(struct snd_rawmidi_substream
*substream
)
1342 struct emu10k1x
*emu
;
1343 struct emu10k1x_midi
*midi
= substream
->rmidi
->private_data
;
1344 unsigned long flags
;
1347 if (snd_BUG_ON(!emu
))
1349 spin_lock_irqsave(&midi
->open_lock
, flags
);
1350 midi
->midi_mode
|= EMU10K1X_MIDI_MODE_OUTPUT
;
1351 midi
->substream_output
= substream
;
1352 if (!(midi
->midi_mode
& EMU10K1X_MIDI_MODE_INPUT
)) {
1353 spin_unlock_irqrestore(&midi
->open_lock
, flags
);
1354 if (snd_emu10k1x_midi_cmd(emu
, midi
, MPU401_RESET
, 1))
1356 if (snd_emu10k1x_midi_cmd(emu
, midi
, MPU401_ENTER_UART
, 1))
1359 spin_unlock_irqrestore(&midi
->open_lock
, flags
);
1367 static int snd_emu10k1x_midi_input_close(struct snd_rawmidi_substream
*substream
)
1369 struct emu10k1x
*emu
;
1370 struct emu10k1x_midi
*midi
= substream
->rmidi
->private_data
;
1371 unsigned long flags
;
1375 if (snd_BUG_ON(!emu
))
1377 spin_lock_irqsave(&midi
->open_lock
, flags
);
1378 snd_emu10k1x_intr_disable(emu
, midi
->rx_enable
);
1379 midi
->midi_mode
&= ~EMU10K1X_MIDI_MODE_INPUT
;
1380 midi
->substream_input
= NULL
;
1381 if (!(midi
->midi_mode
& EMU10K1X_MIDI_MODE_OUTPUT
)) {
1382 spin_unlock_irqrestore(&midi
->open_lock
, flags
);
1383 err
= snd_emu10k1x_midi_cmd(emu
, midi
, MPU401_RESET
, 0);
1385 spin_unlock_irqrestore(&midi
->open_lock
, flags
);
1390 static int snd_emu10k1x_midi_output_close(struct snd_rawmidi_substream
*substream
)
1392 struct emu10k1x
*emu
;
1393 struct emu10k1x_midi
*midi
= substream
->rmidi
->private_data
;
1394 unsigned long flags
;
1398 if (snd_BUG_ON(!emu
))
1400 spin_lock_irqsave(&midi
->open_lock
, flags
);
1401 snd_emu10k1x_intr_disable(emu
, midi
->tx_enable
);
1402 midi
->midi_mode
&= ~EMU10K1X_MIDI_MODE_OUTPUT
;
1403 midi
->substream_output
= NULL
;
1404 if (!(midi
->midi_mode
& EMU10K1X_MIDI_MODE_INPUT
)) {
1405 spin_unlock_irqrestore(&midi
->open_lock
, flags
);
1406 err
= snd_emu10k1x_midi_cmd(emu
, midi
, MPU401_RESET
, 0);
1408 spin_unlock_irqrestore(&midi
->open_lock
, flags
);
1413 static void snd_emu10k1x_midi_input_trigger(struct snd_rawmidi_substream
*substream
, int up
)
1415 struct emu10k1x
*emu
;
1416 struct emu10k1x_midi
*midi
= substream
->rmidi
->private_data
;
1418 if (snd_BUG_ON(!emu
))
1422 snd_emu10k1x_intr_enable(emu
, midi
->rx_enable
);
1424 snd_emu10k1x_intr_disable(emu
, midi
->rx_enable
);
1427 static void snd_emu10k1x_midi_output_trigger(struct snd_rawmidi_substream
*substream
, int up
)
1429 struct emu10k1x
*emu
;
1430 struct emu10k1x_midi
*midi
= substream
->rmidi
->private_data
;
1431 unsigned long flags
;
1434 if (snd_BUG_ON(!emu
))
1441 /* try to send some amount of bytes here before interrupts */
1442 spin_lock_irqsave(&midi
->output_lock
, flags
);
1444 if (mpu401_output_ready(emu
, midi
)) {
1445 if (!(midi
->midi_mode
& EMU10K1X_MIDI_MODE_OUTPUT
) ||
1446 snd_rawmidi_transmit(substream
, &byte
, 1) != 1) {
1448 spin_unlock_irqrestore(&midi
->output_lock
, flags
);
1451 mpu401_write_data(emu
, midi
, byte
);
1457 spin_unlock_irqrestore(&midi
->output_lock
, flags
);
1458 snd_emu10k1x_intr_enable(emu
, midi
->tx_enable
);
1460 snd_emu10k1x_intr_disable(emu
, midi
->tx_enable
);
1468 static struct snd_rawmidi_ops snd_emu10k1x_midi_output
=
1470 .open
= snd_emu10k1x_midi_output_open
,
1471 .close
= snd_emu10k1x_midi_output_close
,
1472 .trigger
= snd_emu10k1x_midi_output_trigger
,
1475 static struct snd_rawmidi_ops snd_emu10k1x_midi_input
=
1477 .open
= snd_emu10k1x_midi_input_open
,
1478 .close
= snd_emu10k1x_midi_input_close
,
1479 .trigger
= snd_emu10k1x_midi_input_trigger
,
1482 static void snd_emu10k1x_midi_free(struct snd_rawmidi
*rmidi
)
1484 struct emu10k1x_midi
*midi
= rmidi
->private_data
;
1485 midi
->interrupt
= NULL
;
1489 static int __devinit
emu10k1x_midi_init(struct emu10k1x
*emu
,
1490 struct emu10k1x_midi
*midi
, int device
, char *name
)
1492 struct snd_rawmidi
*rmidi
;
1495 if ((err
= snd_rawmidi_new(emu
->card
, name
, device
, 1, 1, &rmidi
)) < 0)
1498 spin_lock_init(&midi
->open_lock
);
1499 spin_lock_init(&midi
->input_lock
);
1500 spin_lock_init(&midi
->output_lock
);
1501 strcpy(rmidi
->name
, name
);
1502 snd_rawmidi_set_ops(rmidi
, SNDRV_RAWMIDI_STREAM_OUTPUT
, &snd_emu10k1x_midi_output
);
1503 snd_rawmidi_set_ops(rmidi
, SNDRV_RAWMIDI_STREAM_INPUT
, &snd_emu10k1x_midi_input
);
1504 rmidi
->info_flags
|= SNDRV_RAWMIDI_INFO_OUTPUT
|
1505 SNDRV_RAWMIDI_INFO_INPUT
|
1506 SNDRV_RAWMIDI_INFO_DUPLEX
;
1507 rmidi
->private_data
= midi
;
1508 rmidi
->private_free
= snd_emu10k1x_midi_free
;
1509 midi
->rmidi
= rmidi
;
1513 static int __devinit
snd_emu10k1x_midi(struct emu10k1x
*emu
)
1515 struct emu10k1x_midi
*midi
= &emu
->midi
;
1518 if ((err
= emu10k1x_midi_init(emu
, midi
, 0, "EMU10K1X MPU-401 (UART)")) < 0)
1521 midi
->tx_enable
= INTE_MIDITXENABLE
;
1522 midi
->rx_enable
= INTE_MIDIRXENABLE
;
1523 midi
->port
= MUDATA
;
1524 midi
->ipr_tx
= IPR_MIDITRANSBUFEMPTY
;
1525 midi
->ipr_rx
= IPR_MIDIRECVBUFEMPTY
;
1526 midi
->interrupt
= snd_emu10k1x_midi_interrupt
;
1530 static int __devinit
snd_emu10k1x_probe(struct pci_dev
*pci
,
1531 const struct pci_device_id
*pci_id
)
1534 struct snd_card
*card
;
1535 struct emu10k1x
*chip
;
1538 if (dev
>= SNDRV_CARDS
)
1545 err
= snd_card_create(index
[dev
], id
[dev
], THIS_MODULE
, 0, &card
);
1549 if ((err
= snd_emu10k1x_create(card
, pci
, &chip
)) < 0) {
1550 snd_card_free(card
);
1554 if ((err
= snd_emu10k1x_pcm(chip
, 0, NULL
)) < 0) {
1555 snd_card_free(card
);
1558 if ((err
= snd_emu10k1x_pcm(chip
, 1, NULL
)) < 0) {
1559 snd_card_free(card
);
1562 if ((err
= snd_emu10k1x_pcm(chip
, 2, NULL
)) < 0) {
1563 snd_card_free(card
);
1567 if ((err
= snd_emu10k1x_ac97(chip
)) < 0) {
1568 snd_card_free(card
);
1572 if ((err
= snd_emu10k1x_mixer(chip
)) < 0) {
1573 snd_card_free(card
);
1577 if ((err
= snd_emu10k1x_midi(chip
)) < 0) {
1578 snd_card_free(card
);
1582 snd_emu10k1x_proc_init(chip
);
1584 strcpy(card
->driver
, "EMU10K1X");
1585 strcpy(card
->shortname
, "Dell Sound Blaster Live!");
1586 sprintf(card
->longname
, "%s at 0x%lx irq %i",
1587 card
->shortname
, chip
->port
, chip
->irq
);
1589 snd_card_set_dev(card
, &pci
->dev
);
1591 if ((err
= snd_card_register(card
)) < 0) {
1592 snd_card_free(card
);
1596 pci_set_drvdata(pci
, card
);
1601 static void __devexit
snd_emu10k1x_remove(struct pci_dev
*pci
)
1603 snd_card_free(pci_get_drvdata(pci
));
1604 pci_set_drvdata(pci
, NULL
);
1608 static DEFINE_PCI_DEVICE_TABLE(snd_emu10k1x_ids
) = {
1609 { PCI_VDEVICE(CREATIVE
, 0x0006), 0 }, /* Dell OEM version (EMU10K1) */
1612 MODULE_DEVICE_TABLE(pci
, snd_emu10k1x_ids
);
1614 // pci_driver definition
1615 static struct pci_driver driver
= {
1616 .name
= KBUILD_MODNAME
,
1617 .id_table
= snd_emu10k1x_ids
,
1618 .probe
= snd_emu10k1x_probe
,
1619 .remove
= __devexit_p(snd_emu10k1x_remove
),
1622 // initialization of the module
1623 static int __init
alsa_card_emu10k1x_init(void)
1625 return pci_register_driver(&driver
);
1628 // clean up the module
1629 static void __exit
alsa_card_emu10k1x_exit(void)
1631 pci_unregister_driver(&driver
);
1634 module_init(alsa_card_emu10k1x_init
)
1635 module_exit(alsa_card_emu10k1x_exit
)