2 * Copyright (c) by James Courtier-Dutton <James@superbug.demon.co.uk>
6 * FEATURES currently supported:
7 * Output fixed at S32_LE, 2 channel to hw:0,0
8 * Rates: 44.1, 48, 96, 192.
12 * Use separate card based buffer for periods table.
14 * Use 2 channel output streams instead of 8 channel.
15 * (8 channel output streams might be good for ASIO type output)
16 * Corrected speaker output, so Front -> Front etc.
18 * Fixed missed interrupts.
20 * Add Sound card model number and names.
21 * Add Analog volume controls.
23 * Corrected playback interrupts. Now interrupt per period, instead of half period.
25 * Use single trigger for multichannel.
27 * Mic capture now works at fixed: S32_LE, 96000Hz, Stereo.
29 * Force buffer_size / period_size == INTEGER.
31 * Update p16v.c to work with changed alsa api.
33 * Update p16v.c to work with changed alsa api. Removed boot_devs.
35 * Merging with snd-emu10k1 driver.
37 * One stereo channel at 24bit now works.
39 * Added better register defines.
41 * Integrated with snd-emu10k1 driver.
43 * Removed #if 0 ... #endif
45 * Implement different capture rates.
47 * Implement different capture source channels.
48 * e.g. When HD Capture source is set to SPDIF,
49 * setting HD Capture channel to 0 captures from CDROM digital input.
50 * setting HD Capture channel to 1 captures from SPDIF in.
52 * Include capture buffer sizes.
55 * Some stability problems when unloading the snd-p16v kernel module.
60 * Find out how to change capture sample rates. E.g. To record SPDIF at 48000Hz.
61 * Currently capture fixed at 48000Hz.
66 * P16V Chip: CA0151-DBS
67 * Audigy 2 Chip: CA0102-IAT
68 * AC97 Codec: STAC 9721
69 * ADC: Philips 1361T (Stereo 24bit)
70 * DAC: CS4382-K (8-channel, 24bit, 192Khz)
72 * This code was initally based on code from ALSA's emu10k1x.c which is:
73 * Copyright (c) by Francisco Moraes <fmoraes@nc.rr.com>
75 * This program is free software; you can redistribute it and/or modify
76 * it under the terms of the GNU General Public License as published by
77 * the Free Software Foundation; either version 2 of the License, or
78 * (at your option) any later version.
80 * This program is distributed in the hope that it will be useful,
81 * but WITHOUT ANY WARRANTY; without even the implied warranty of
82 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
83 * GNU General Public License for more details.
85 * You should have received a copy of the GNU General Public License
86 * along with this program; if not, write to the Free Software
87 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
90 #include <sound/driver.h>
91 #include <linux/delay.h>
92 #include <linux/init.h>
93 #include <linux/interrupt.h>
94 #include <linux/pci.h>
95 #include <linux/slab.h>
96 #include <linux/moduleparam.h>
97 #include <sound/core.h>
98 #include <sound/initval.h>
99 #include <sound/pcm.h>
100 #include <sound/ac97_codec.h>
101 #include <sound/info.h>
102 #include <sound/emu10k1.h>
105 #define SET_CHANNEL 0 /* Testing channel outputs 0=Front, 1=Center/LFE, 2=Unknown, 3=Rear */
106 #define PCM_FRONT_CHANNEL 0
107 #define PCM_REAR_CHANNEL 1
108 #define PCM_CENTER_LFE_CHANNEL 2
109 #define PCM_UNKNOWN_CHANNEL 3
110 #define CONTROL_FRONT_CHANNEL 0
111 #define CONTROL_REAR_CHANNEL 3
112 #define CONTROL_CENTER_LFE_CHANNEL 1
113 #define CONTROL_UNKNOWN_CHANNEL 2
116 * Class 0401: 1102:0004 (rev 04) Subsystem: 1102:2002 -> Audigy2 ZS 7.1 Model:SB0350
117 * Class 0401: 1102:0004 (rev 04) Subsystem: 1102:1007 -> Audigy2 6.1 Model:SB0240
118 * Class 0401: 1102:0004 (rev 04) Subsystem: 1102:1002 -> Audigy2 Platinum Model:SB msb0240230009266
119 * Class 0401: 1102:0004 (rev 04) Subsystem: 1102:2007 -> Audigy4 Pro Model:SB0380 M1SB0380472001901E
123 /* hardware definition */
124 static struct snd_pcm_hardware snd_p16v_playback_hw
= {
125 .info
= (SNDRV_PCM_INFO_MMAP
|
126 SNDRV_PCM_INFO_INTERLEAVED
|
127 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
128 SNDRV_PCM_INFO_MMAP_VALID
),
129 .formats
= SNDRV_PCM_FMTBIT_S32_LE
, /* Only supports 24-bit samples padded to 32 bits. */
130 .rates
= SNDRV_PCM_RATE_192000
| SNDRV_PCM_RATE_96000
| SNDRV_PCM_RATE_48000
| SNDRV_PCM_RATE_44100
,
135 .buffer_bytes_max
= ((65536 - 64) * 8),
136 .period_bytes_min
= 64,
137 .period_bytes_max
= (65536 - 64),
143 static struct snd_pcm_hardware snd_p16v_capture_hw
= {
144 .info
= (SNDRV_PCM_INFO_MMAP
|
145 SNDRV_PCM_INFO_INTERLEAVED
|
146 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
147 SNDRV_PCM_INFO_MMAP_VALID
),
148 .formats
= SNDRV_PCM_FMTBIT_S32_LE
,
149 .rates
= SNDRV_PCM_RATE_192000
| SNDRV_PCM_RATE_96000
| SNDRV_PCM_RATE_48000
| SNDRV_PCM_RATE_44100
,
154 .buffer_bytes_max
= (65536 - 64),
155 .period_bytes_min
= 64,
156 .period_bytes_max
= (65536 - 128) >> 1, /* size has to be N*64 bytes */
162 static void snd_p16v_pcm_free_substream(struct snd_pcm_runtime
*runtime
)
164 struct snd_emu10k1_pcm
*epcm
= runtime
->private_data
;
167 //snd_printk("epcm free: %p\n", epcm);
172 /* open_playback callback */
173 static int snd_p16v_pcm_open_playback_channel(struct snd_pcm_substream
*substream
, int channel_id
)
175 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
176 struct snd_emu10k1_voice
*channel
= &(emu
->p16v_voices
[channel_id
]);
177 struct snd_emu10k1_pcm
*epcm
;
178 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
181 epcm
= kzalloc(sizeof(*epcm
), GFP_KERNEL
);
182 //snd_printk("epcm kcalloc: %p\n", epcm);
187 epcm
->substream
= substream
;
188 //snd_printk("epcm device=%d, channel_id=%d\n", substream->pcm->device, channel_id);
190 runtime
->private_data
= epcm
;
191 runtime
->private_free
= snd_p16v_pcm_free_substream
;
193 runtime
->hw
= snd_p16v_playback_hw
;
196 channel
->number
= channel_id
;
199 //snd_printk("p16v: open channel_id=%d, channel=%p, use=0x%x\n", channel_id, channel, channel->use);
200 //printk("open:channel_id=%d, chip=%p, channel=%p\n",channel_id, chip, channel);
201 //channel->interrupt = snd_p16v_pcm_channel_interrupt;
203 if ((err
= snd_pcm_hw_constraint_integer(runtime
, SNDRV_PCM_HW_PARAM_PERIODS
)) < 0)
208 /* open_capture callback */
209 static int snd_p16v_pcm_open_capture_channel(struct snd_pcm_substream
*substream
, int channel_id
)
211 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
212 struct snd_emu10k1_voice
*channel
= &(emu
->p16v_capture_voice
);
213 struct snd_emu10k1_pcm
*epcm
;
214 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
217 epcm
= kzalloc(sizeof(*epcm
), GFP_KERNEL
);
218 //snd_printk("epcm kcalloc: %p\n", epcm);
223 epcm
->substream
= substream
;
224 //snd_printk("epcm device=%d, channel_id=%d\n", substream->pcm->device, channel_id);
226 runtime
->private_data
= epcm
;
227 runtime
->private_free
= snd_p16v_pcm_free_substream
;
229 runtime
->hw
= snd_p16v_capture_hw
;
232 channel
->number
= channel_id
;
235 //snd_printk("p16v: open channel_id=%d, channel=%p, use=0x%x\n", channel_id, channel, channel->use);
236 //printk("open:channel_id=%d, chip=%p, channel=%p\n",channel_id, chip, channel);
237 //channel->interrupt = snd_p16v_pcm_channel_interrupt;
239 if ((err
= snd_pcm_hw_constraint_integer(runtime
, SNDRV_PCM_HW_PARAM_PERIODS
)) < 0)
247 static int snd_p16v_pcm_close_playback(struct snd_pcm_substream
*substream
)
249 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
250 //struct snd_pcm_runtime *runtime = substream->runtime;
251 //struct snd_emu10k1_pcm *epcm = runtime->private_data;
252 emu
->p16v_voices
[substream
->pcm
->device
- emu
->p16v_device_offset
].use
=0;
253 /* FIXME: maybe zero others */
258 static int snd_p16v_pcm_close_capture(struct snd_pcm_substream
*substream
)
260 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
261 //struct snd_pcm_runtime *runtime = substream->runtime;
262 //struct snd_emu10k1_pcm *epcm = runtime->private_data;
263 emu
->p16v_capture_voice
.use
=0;
264 /* FIXME: maybe zero others */
268 static int snd_p16v_pcm_open_playback_front(struct snd_pcm_substream
*substream
)
270 return snd_p16v_pcm_open_playback_channel(substream
, PCM_FRONT_CHANNEL
);
273 static int snd_p16v_pcm_open_capture(struct snd_pcm_substream
*substream
)
275 // Only using channel 0 for now, but the card has 2 channels.
276 return snd_p16v_pcm_open_capture_channel(substream
, 0);
279 /* hw_params callback */
280 static int snd_p16v_pcm_hw_params_playback(struct snd_pcm_substream
*substream
,
281 struct snd_pcm_hw_params
*hw_params
)
284 result
= snd_pcm_lib_malloc_pages(substream
,
285 params_buffer_bytes(hw_params
));
289 /* hw_params callback */
290 static int snd_p16v_pcm_hw_params_capture(struct snd_pcm_substream
*substream
,
291 struct snd_pcm_hw_params
*hw_params
)
294 result
= snd_pcm_lib_malloc_pages(substream
,
295 params_buffer_bytes(hw_params
));
300 /* hw_free callback */
301 static int snd_p16v_pcm_hw_free_playback(struct snd_pcm_substream
*substream
)
304 result
= snd_pcm_lib_free_pages(substream
);
308 /* hw_free callback */
309 static int snd_p16v_pcm_hw_free_capture(struct snd_pcm_substream
*substream
)
312 result
= snd_pcm_lib_free_pages(substream
);
317 /* prepare playback callback */
318 static int snd_p16v_pcm_prepare_playback(struct snd_pcm_substream
*substream
)
320 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
321 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
322 int channel
= substream
->pcm
->device
- emu
->p16v_device_offset
;
323 u32
*table_base
= (u32
*)(emu
->p16v_buffer
.area
+(8*16*channel
));
324 u32 period_size_bytes
= frames_to_bytes(runtime
, runtime
->period_size
);
328 //snd_printk("prepare:channel_number=%d, rate=%d, format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, periods=%u, frames_to_bytes=%d\n",channel, runtime->rate, runtime->format, runtime->channels, runtime->buffer_size, runtime->period_size, runtime->periods, frames_to_bytes(runtime, 1));
329 //snd_printk("dma_addr=%x, dma_area=%p, table_base=%p\n",runtime->dma_addr, runtime->dma_area, table_base);
330 //snd_printk("dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",emu->p16v_buffer.addr, emu->p16v_buffer.area, emu->p16v_buffer.bytes);
331 tmp
= snd_emu10k1_ptr_read(emu
, A_SPDIF_SAMPLERATE
, channel
);
332 switch (runtime
->rate
) {
334 snd_emu10k1_ptr_write(emu
, A_SPDIF_SAMPLERATE
, channel
, (tmp
& ~0xe0e0) | 0x8080);
337 snd_emu10k1_ptr_write(emu
, A_SPDIF_SAMPLERATE
, channel
, (tmp
& ~0xe0e0) | 0x4040);
340 snd_emu10k1_ptr_write(emu
, A_SPDIF_SAMPLERATE
, channel
, (tmp
& ~0xe0e0) | 0x2020);
344 snd_emu10k1_ptr_write(emu
, A_SPDIF_SAMPLERATE
, channel
, (tmp
& ~0xe0e0) | 0x0000);
347 /* FIXME: Check emu->buffer.size before actually writing to it. */
348 for(i
=0; i
< runtime
->periods
; i
++) {
349 table_base
[i
*2]=runtime
->dma_addr
+(i
*period_size_bytes
);
350 table_base
[(i
*2)+1]=period_size_bytes
<<16;
353 snd_emu10k1_ptr20_write(emu
, PLAYBACK_LIST_ADDR
, channel
, emu
->p16v_buffer
.addr
+(8*16*channel
));
354 snd_emu10k1_ptr20_write(emu
, PLAYBACK_LIST_SIZE
, channel
, (runtime
->periods
- 1) << 19);
355 snd_emu10k1_ptr20_write(emu
, PLAYBACK_LIST_PTR
, channel
, 0);
356 snd_emu10k1_ptr20_write(emu
, PLAYBACK_DMA_ADDR
, channel
, runtime
->dma_addr
);
357 //snd_emu10k1_ptr20_write(emu, PLAYBACK_PERIOD_SIZE, channel, frames_to_bytes(runtime, runtime->period_size)<<16); // buffer size in bytes
358 snd_emu10k1_ptr20_write(emu
, PLAYBACK_PERIOD_SIZE
, channel
, 0); // buffer size in bytes
359 snd_emu10k1_ptr20_write(emu
, PLAYBACK_POINTER
, channel
, 0);
360 snd_emu10k1_ptr20_write(emu
, 0x07, channel
, 0x0);
361 snd_emu10k1_ptr20_write(emu
, 0x08, channel
, 0);
366 /* prepare capture callback */
367 static int snd_p16v_pcm_prepare_capture(struct snd_pcm_substream
*substream
)
369 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
370 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
371 int channel
= substream
->pcm
->device
- emu
->p16v_device_offset
;
373 //printk("prepare capture:channel_number=%d, rate=%d, format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, frames_to_bytes=%d\n",channel, runtime->rate, runtime->format, runtime->channels, runtime->buffer_size, runtime->period_size, frames_to_bytes(runtime, 1));
374 tmp
= snd_emu10k1_ptr_read(emu
, A_SPDIF_SAMPLERATE
, channel
);
375 switch (runtime
->rate
) {
377 snd_emu10k1_ptr_write(emu
, A_SPDIF_SAMPLERATE
, channel
, (tmp
& ~0x0e00) | 0x0800);
380 snd_emu10k1_ptr_write(emu
, A_SPDIF_SAMPLERATE
, channel
, (tmp
& ~0x0e00) | 0x0400);
383 snd_emu10k1_ptr_write(emu
, A_SPDIF_SAMPLERATE
, channel
, (tmp
& ~0x0e00) | 0x0200);
387 snd_emu10k1_ptr_write(emu
, A_SPDIF_SAMPLERATE
, channel
, (tmp
& ~0x0e00) | 0x0000);
390 /* FIXME: Check emu->buffer.size before actually writing to it. */
391 snd_emu10k1_ptr20_write(emu
, 0x13, channel
, 0);
392 snd_emu10k1_ptr20_write(emu
, CAPTURE_DMA_ADDR
, channel
, runtime
->dma_addr
);
393 snd_emu10k1_ptr20_write(emu
, CAPTURE_BUFFER_SIZE
, channel
, frames_to_bytes(runtime
, runtime
->buffer_size
)<<16); // buffer size in bytes
394 snd_emu10k1_ptr20_write(emu
, CAPTURE_POINTER
, channel
, 0);
395 //snd_emu10k1_ptr20_write(emu, CAPTURE_SOURCE, 0x0, 0x333300e4); /* Select MIC or Line in */
396 //snd_emu10k1_ptr20_write(emu, EXTENDED_INT_MASK, 0, snd_emu10k1_ptr20_read(emu, EXTENDED_INT_MASK, 0) | (0x110000<<channel));
401 static void snd_p16v_intr_enable(struct snd_emu10k1
*emu
, unsigned int intrenb
)
406 spin_lock_irqsave(&emu
->emu_lock
, flags
);
407 enable
= inl(emu
->port
+ INTE2
) | intrenb
;
408 outl(enable
, emu
->port
+ INTE2
);
409 spin_unlock_irqrestore(&emu
->emu_lock
, flags
);
412 static void snd_p16v_intr_disable(struct snd_emu10k1
*emu
, unsigned int intrenb
)
415 unsigned int disable
;
417 spin_lock_irqsave(&emu
->emu_lock
, flags
);
418 disable
= inl(emu
->port
+ INTE2
) & (~intrenb
);
419 outl(disable
, emu
->port
+ INTE2
);
420 spin_unlock_irqrestore(&emu
->emu_lock
, flags
);
423 /* trigger_playback callback */
424 static int snd_p16v_pcm_trigger_playback(struct snd_pcm_substream
*substream
,
427 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
428 struct snd_pcm_runtime
*runtime
;
429 struct snd_emu10k1_pcm
*epcm
;
432 struct list_head
*pos
;
433 struct snd_pcm_substream
*s
;
439 case SNDRV_PCM_TRIGGER_START
:
442 case SNDRV_PCM_TRIGGER_STOP
:
447 snd_pcm_group_for_each(pos
, substream
) {
448 s
= snd_pcm_group_substream_entry(pos
);
449 runtime
= s
->runtime
;
450 epcm
= runtime
->private_data
;
451 channel
= substream
->pcm
->device
-emu
->p16v_device_offset
;
452 //snd_printk("p16v channel=%d\n",channel);
453 epcm
->running
= running
;
454 basic
|= (0x1<<channel
);
455 inte
|= (INTE2_PLAYBACK_CH_0_LOOP
<<channel
);
456 snd_pcm_trigger_done(s
, substream
);
458 //snd_printk("basic=0x%x, inte=0x%x\n",basic, inte);
461 case SNDRV_PCM_TRIGGER_START
:
462 snd_p16v_intr_enable(emu
, inte
);
463 snd_emu10k1_ptr20_write(emu
, BASIC_INTERRUPT
, 0, snd_emu10k1_ptr20_read(emu
, BASIC_INTERRUPT
, 0)| (basic
));
465 case SNDRV_PCM_TRIGGER_STOP
:
466 snd_emu10k1_ptr20_write(emu
, BASIC_INTERRUPT
, 0, snd_emu10k1_ptr20_read(emu
, BASIC_INTERRUPT
, 0) & ~(basic
));
467 snd_p16v_intr_disable(emu
, inte
);
476 /* trigger_capture callback */
477 static int snd_p16v_pcm_trigger_capture(struct snd_pcm_substream
*substream
,
480 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
481 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
482 struct snd_emu10k1_pcm
*epcm
= runtime
->private_data
;
485 u32 inte
= INTE2_CAPTURE_CH_0_LOOP
| INTE2_CAPTURE_CH_0_HALF_LOOP
;
488 case SNDRV_PCM_TRIGGER_START
:
489 snd_p16v_intr_enable(emu
, inte
);
490 snd_emu10k1_ptr20_write(emu
, BASIC_INTERRUPT
, 0, snd_emu10k1_ptr20_read(emu
, BASIC_INTERRUPT
, 0)|(0x100<<channel
));
493 case SNDRV_PCM_TRIGGER_STOP
:
494 snd_emu10k1_ptr20_write(emu
, BASIC_INTERRUPT
, 0, snd_emu10k1_ptr20_read(emu
, BASIC_INTERRUPT
, 0) & ~(0x100<<channel
));
495 snd_p16v_intr_disable(emu
, inte
);
496 //snd_emu10k1_ptr20_write(emu, EXTENDED_INT_MASK, 0, snd_emu10k1_ptr20_read(emu, EXTENDED_INT_MASK, 0) & ~(0x110000<<channel));
506 /* pointer_playback callback */
507 static snd_pcm_uframes_t
508 snd_p16v_pcm_pointer_playback(struct snd_pcm_substream
*substream
)
510 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
511 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
512 struct snd_emu10k1_pcm
*epcm
= runtime
->private_data
;
513 snd_pcm_uframes_t ptr
, ptr1
, ptr2
,ptr3
,ptr4
= 0;
514 int channel
= substream
->pcm
->device
- emu
->p16v_device_offset
;
518 ptr3
= snd_emu10k1_ptr20_read(emu
, PLAYBACK_LIST_PTR
, channel
);
519 ptr1
= snd_emu10k1_ptr20_read(emu
, PLAYBACK_POINTER
, channel
);
520 ptr4
= snd_emu10k1_ptr20_read(emu
, PLAYBACK_LIST_PTR
, channel
);
521 if (ptr3
!= ptr4
) ptr1
= snd_emu10k1_ptr20_read(emu
, PLAYBACK_POINTER
, channel
);
522 ptr2
= bytes_to_frames(runtime
, ptr1
);
523 ptr2
+= (ptr4
>> 3) * runtime
->period_size
;
525 if (ptr
>= runtime
->buffer_size
)
526 ptr
-= runtime
->buffer_size
;
531 /* pointer_capture callback */
532 static snd_pcm_uframes_t
533 snd_p16v_pcm_pointer_capture(struct snd_pcm_substream
*substream
)
535 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
536 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
537 struct snd_emu10k1_pcm
*epcm
= runtime
->private_data
;
538 snd_pcm_uframes_t ptr
, ptr1
, ptr2
= 0;
544 ptr1
= snd_emu10k1_ptr20_read(emu
, CAPTURE_POINTER
, channel
);
545 ptr2
= bytes_to_frames(runtime
, ptr1
);
547 if (ptr
>= runtime
->buffer_size
) {
548 ptr
-= runtime
->buffer_size
;
549 printk(KERN_WARNING
"buffer capture limited!\n");
551 //printk("ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n", ptr1, ptr2, ptr, (int)runtime->buffer_size, (int)runtime->period_size, (int)runtime->frame_bits, (int)runtime->rate);
557 static struct snd_pcm_ops snd_p16v_playback_front_ops
= {
558 .open
= snd_p16v_pcm_open_playback_front
,
559 .close
= snd_p16v_pcm_close_playback
,
560 .ioctl
= snd_pcm_lib_ioctl
,
561 .hw_params
= snd_p16v_pcm_hw_params_playback
,
562 .hw_free
= snd_p16v_pcm_hw_free_playback
,
563 .prepare
= snd_p16v_pcm_prepare_playback
,
564 .trigger
= snd_p16v_pcm_trigger_playback
,
565 .pointer
= snd_p16v_pcm_pointer_playback
,
568 static struct snd_pcm_ops snd_p16v_capture_ops
= {
569 .open
= snd_p16v_pcm_open_capture
,
570 .close
= snd_p16v_pcm_close_capture
,
571 .ioctl
= snd_pcm_lib_ioctl
,
572 .hw_params
= snd_p16v_pcm_hw_params_capture
,
573 .hw_free
= snd_p16v_pcm_hw_free_capture
,
574 .prepare
= snd_p16v_pcm_prepare_capture
,
575 .trigger
= snd_p16v_pcm_trigger_capture
,
576 .pointer
= snd_p16v_pcm_pointer_capture
,
580 int snd_p16v_free(struct snd_emu10k1
*chip
)
583 if (chip
->p16v_buffer
.area
) {
584 snd_dma_free_pages(&chip
->p16v_buffer
);
585 //snd_printk("period lables free: %p\n", &chip->p16v_buffer);
590 int snd_p16v_pcm(struct snd_emu10k1
*emu
, int device
, struct snd_pcm
**rpcm
)
593 struct snd_pcm_substream
*substream
;
597 //snd_printk("snd_p16v_pcm called. device=%d\n", device);
598 emu
->p16v_device_offset
= device
;
602 if ((err
= snd_pcm_new(emu
->card
, "p16v", device
, 1, capture
, &pcm
)) < 0)
605 pcm
->private_data
= emu
;
606 // Single playback 8 channel device.
607 // Single capture 2 channel device.
608 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_p16v_playback_front_ops
);
609 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_p16v_capture_ops
);
612 pcm
->dev_subclass
= SNDRV_PCM_SUBCLASS_GENERIC_MIX
;
613 strcpy(pcm
->name
, "p16v");
616 for(substream
= pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream
;
618 substream
= substream
->next
) {
619 if ((err
= snd_pcm_lib_preallocate_pages(substream
,
621 snd_dma_pci_data(emu
->pci
),
622 ((65536 - 64) * 8), ((65536 - 64) * 8))) < 0)
624 //snd_printk("preallocate playback substream: err=%d\n", err);
627 for (substream
= pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
;
629 substream
= substream
->next
) {
630 if ((err
= snd_pcm_lib_preallocate_pages(substream
,
632 snd_dma_pci_data(emu
->pci
),
633 65536 - 64, 65536 - 64)) < 0)
635 //snd_printk("preallocate capture substream: err=%d\n", err);
644 static int snd_p16v_volume_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
646 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
648 uinfo
->value
.integer
.min
= 0;
649 uinfo
->value
.integer
.max
= 255;
653 static int snd_p16v_volume_get(struct snd_kcontrol
*kcontrol
,
654 struct snd_ctl_elem_value
*ucontrol
, int reg
, int high_low
)
656 struct snd_emu10k1
*emu
= snd_kcontrol_chip(kcontrol
);
659 value
= snd_emu10k1_ptr20_read(emu
, reg
, high_low
);
661 ucontrol
->value
.integer
.value
[0] = 0xff - ((value
>> 24) & 0xff); /* Left */
662 ucontrol
->value
.integer
.value
[1] = 0xff - ((value
>> 16) & 0xff); /* Right */
664 ucontrol
->value
.integer
.value
[0] = 0xff - ((value
>> 8) & 0xff); /* Left */
665 ucontrol
->value
.integer
.value
[1] = 0xff - ((value
>> 0) & 0xff); /* Right */
670 static int snd_p16v_volume_get_spdif_front(struct snd_kcontrol
*kcontrol
,
671 struct snd_ctl_elem_value
*ucontrol
)
674 int reg
= PLAYBACK_VOLUME_MIXER7
;
675 return snd_p16v_volume_get(kcontrol
, ucontrol
, reg
, high_low
);
678 static int snd_p16v_volume_get_spdif_center_lfe(struct snd_kcontrol
*kcontrol
,
679 struct snd_ctl_elem_value
*ucontrol
)
682 int reg
= PLAYBACK_VOLUME_MIXER7
;
683 return snd_p16v_volume_get(kcontrol
, ucontrol
, reg
, high_low
);
685 static int snd_p16v_volume_get_spdif_unknown(struct snd_kcontrol
*kcontrol
,
686 struct snd_ctl_elem_value
*ucontrol
)
689 int reg
= PLAYBACK_VOLUME_MIXER8
;
690 return snd_p16v_volume_get(kcontrol
, ucontrol
, reg
, high_low
);
692 static int snd_p16v_volume_get_spdif_rear(struct snd_kcontrol
*kcontrol
,
693 struct snd_ctl_elem_value
*ucontrol
)
696 int reg
= PLAYBACK_VOLUME_MIXER8
;
697 return snd_p16v_volume_get(kcontrol
, ucontrol
, reg
, high_low
);
700 static int snd_p16v_volume_get_analog_front(struct snd_kcontrol
*kcontrol
,
701 struct snd_ctl_elem_value
*ucontrol
)
704 int reg
= PLAYBACK_VOLUME_MIXER9
;
705 return snd_p16v_volume_get(kcontrol
, ucontrol
, reg
, high_low
);
708 static int snd_p16v_volume_get_analog_center_lfe(struct snd_kcontrol
*kcontrol
,
709 struct snd_ctl_elem_value
*ucontrol
)
712 int reg
= PLAYBACK_VOLUME_MIXER9
;
713 return snd_p16v_volume_get(kcontrol
, ucontrol
, reg
, high_low
);
715 static int snd_p16v_volume_get_analog_rear(struct snd_kcontrol
*kcontrol
,
716 struct snd_ctl_elem_value
*ucontrol
)
719 int reg
= PLAYBACK_VOLUME_MIXER10
;
720 return snd_p16v_volume_get(kcontrol
, ucontrol
, reg
, high_low
);
723 static int snd_p16v_volume_get_analog_unknown(struct snd_kcontrol
*kcontrol
,
724 struct snd_ctl_elem_value
*ucontrol
)
727 int reg
= PLAYBACK_VOLUME_MIXER10
;
728 return snd_p16v_volume_get(kcontrol
, ucontrol
, reg
, high_low
);
731 static int snd_p16v_volume_put(struct snd_kcontrol
*kcontrol
,
732 struct snd_ctl_elem_value
*ucontrol
, int reg
, int high_low
)
734 struct snd_emu10k1
*emu
= snd_kcontrol_chip(kcontrol
);
736 value
= snd_emu10k1_ptr20_read(emu
, reg
, 0);
737 //value = value & 0xffff;
740 value
= value
| ((0xff - ucontrol
->value
.integer
.value
[0]) << 24) | ((0xff - ucontrol
->value
.integer
.value
[1]) << 16);
743 value
= value
| ((0xff - ucontrol
->value
.integer
.value
[0]) << 8) | ((0xff - ucontrol
->value
.integer
.value
[1]) );
745 snd_emu10k1_ptr20_write(emu
, reg
, 0, value
);
749 static int snd_p16v_volume_put_spdif_front(struct snd_kcontrol
*kcontrol
,
750 struct snd_ctl_elem_value
*ucontrol
)
753 int reg
= PLAYBACK_VOLUME_MIXER7
;
754 return snd_p16v_volume_put(kcontrol
, ucontrol
, reg
, high_low
);
757 static int snd_p16v_volume_put_spdif_center_lfe(struct snd_kcontrol
*kcontrol
,
758 struct snd_ctl_elem_value
*ucontrol
)
761 int reg
= PLAYBACK_VOLUME_MIXER7
;
762 return snd_p16v_volume_put(kcontrol
, ucontrol
, reg
, high_low
);
765 static int snd_p16v_volume_put_spdif_unknown(struct snd_kcontrol
*kcontrol
,
766 struct snd_ctl_elem_value
*ucontrol
)
769 int reg
= PLAYBACK_VOLUME_MIXER8
;
770 return snd_p16v_volume_put(kcontrol
, ucontrol
, reg
, high_low
);
773 static int snd_p16v_volume_put_spdif_rear(struct snd_kcontrol
*kcontrol
,
774 struct snd_ctl_elem_value
*ucontrol
)
777 int reg
= PLAYBACK_VOLUME_MIXER8
;
778 return snd_p16v_volume_put(kcontrol
, ucontrol
, reg
, high_low
);
781 static int snd_p16v_volume_put_analog_front(struct snd_kcontrol
*kcontrol
,
782 struct snd_ctl_elem_value
*ucontrol
)
785 int reg
= PLAYBACK_VOLUME_MIXER9
;
786 return snd_p16v_volume_put(kcontrol
, ucontrol
, reg
, high_low
);
789 static int snd_p16v_volume_put_analog_center_lfe(struct snd_kcontrol
*kcontrol
,
790 struct snd_ctl_elem_value
*ucontrol
)
793 int reg
= PLAYBACK_VOLUME_MIXER9
;
794 return snd_p16v_volume_put(kcontrol
, ucontrol
, reg
, high_low
);
797 static int snd_p16v_volume_put_analog_rear(struct snd_kcontrol
*kcontrol
,
798 struct snd_ctl_elem_value
*ucontrol
)
801 int reg
= PLAYBACK_VOLUME_MIXER10
;
802 return snd_p16v_volume_put(kcontrol
, ucontrol
, reg
, high_low
);
805 static int snd_p16v_volume_put_analog_unknown(struct snd_kcontrol
*kcontrol
,
806 struct snd_ctl_elem_value
*ucontrol
)
809 int reg
= PLAYBACK_VOLUME_MIXER10
;
810 return snd_p16v_volume_put(kcontrol
, ucontrol
, reg
, high_low
);
813 static struct snd_kcontrol_new snd_p16v_volume_control_analog_front
=
815 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
816 .name
= "HD Analog Front Playback Volume",
817 .info
= snd_p16v_volume_info
,
818 .get
= snd_p16v_volume_get_analog_front
,
819 .put
= snd_p16v_volume_put_analog_front
822 static struct snd_kcontrol_new snd_p16v_volume_control_analog_center_lfe
=
824 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
825 .name
= "HD Analog Center/LFE Playback Volume",
826 .info
= snd_p16v_volume_info
,
827 .get
= snd_p16v_volume_get_analog_center_lfe
,
828 .put
= snd_p16v_volume_put_analog_center_lfe
831 static struct snd_kcontrol_new snd_p16v_volume_control_analog_unknown
=
833 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
834 .name
= "HD Analog Unknown Playback Volume",
835 .info
= snd_p16v_volume_info
,
836 .get
= snd_p16v_volume_get_analog_unknown
,
837 .put
= snd_p16v_volume_put_analog_unknown
840 static struct snd_kcontrol_new snd_p16v_volume_control_analog_rear
=
842 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
843 .name
= "HD Analog Rear Playback Volume",
844 .info
= snd_p16v_volume_info
,
845 .get
= snd_p16v_volume_get_analog_rear
,
846 .put
= snd_p16v_volume_put_analog_rear
849 static struct snd_kcontrol_new snd_p16v_volume_control_spdif_front
=
851 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
852 .name
= "HD SPDIF Front Playback Volume",
853 .info
= snd_p16v_volume_info
,
854 .get
= snd_p16v_volume_get_spdif_front
,
855 .put
= snd_p16v_volume_put_spdif_front
858 static struct snd_kcontrol_new snd_p16v_volume_control_spdif_center_lfe
=
860 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
861 .name
= "HD SPDIF Center/LFE Playback Volume",
862 .info
= snd_p16v_volume_info
,
863 .get
= snd_p16v_volume_get_spdif_center_lfe
,
864 .put
= snd_p16v_volume_put_spdif_center_lfe
867 static struct snd_kcontrol_new snd_p16v_volume_control_spdif_unknown
=
869 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
870 .name
= "HD SPDIF Unknown Playback Volume",
871 .info
= snd_p16v_volume_info
,
872 .get
= snd_p16v_volume_get_spdif_unknown
,
873 .put
= snd_p16v_volume_put_spdif_unknown
876 static struct snd_kcontrol_new snd_p16v_volume_control_spdif_rear
=
878 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
879 .name
= "HD SPDIF Rear Playback Volume",
880 .info
= snd_p16v_volume_info
,
881 .get
= snd_p16v_volume_get_spdif_rear
,
882 .put
= snd_p16v_volume_put_spdif_rear
885 static int snd_p16v_capture_source_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
887 static char *texts
[8] = { "SPDIF", "I2S", "SRC48", "SRCMulti_SPDIF", "SRCMulti_I2S", "CDIF", "FX", "AC97" };
889 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
891 uinfo
->value
.enumerated
.items
= 8;
892 if (uinfo
->value
.enumerated
.item
> 7)
893 uinfo
->value
.enumerated
.item
= 7;
894 strcpy(uinfo
->value
.enumerated
.name
, texts
[uinfo
->value
.enumerated
.item
]);
898 static int snd_p16v_capture_source_get(struct snd_kcontrol
*kcontrol
,
899 struct snd_ctl_elem_value
*ucontrol
)
901 struct snd_emu10k1
*emu
= snd_kcontrol_chip(kcontrol
);
903 ucontrol
->value
.enumerated
.item
[0] = emu
->p16v_capture_source
;
907 static int snd_p16v_capture_source_put(struct snd_kcontrol
*kcontrol
,
908 struct snd_ctl_elem_value
*ucontrol
)
910 struct snd_emu10k1
*emu
= snd_kcontrol_chip(kcontrol
);
916 val
= ucontrol
->value
.enumerated
.item
[0] ;
917 change
= (emu
->p16v_capture_source
!= val
);
919 emu
->p16v_capture_source
= val
;
920 source
= (val
<< 28) | (val
<< 24) | (val
<< 20) | (val
<< 16);
921 mask
= snd_emu10k1_ptr20_read(emu
, BASIC_INTERRUPT
, 0) & 0xffff;
922 snd_emu10k1_ptr20_write(emu
, BASIC_INTERRUPT
, 0, source
| mask
);
927 static struct snd_kcontrol_new snd_p16v_capture_source __devinitdata
=
929 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
930 .name
= "HD source Capture",
931 .info
= snd_p16v_capture_source_info
,
932 .get
= snd_p16v_capture_source_get
,
933 .put
= snd_p16v_capture_source_put
936 static int snd_p16v_capture_channel_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
938 static char *texts
[4] = { "0", "1", "2", "3", };
940 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
942 uinfo
->value
.enumerated
.items
= 4;
943 if (uinfo
->value
.enumerated
.item
> 3)
944 uinfo
->value
.enumerated
.item
= 3;
945 strcpy(uinfo
->value
.enumerated
.name
, texts
[uinfo
->value
.enumerated
.item
]);
949 static int snd_p16v_capture_channel_get(struct snd_kcontrol
*kcontrol
,
950 struct snd_ctl_elem_value
*ucontrol
)
952 struct snd_emu10k1
*emu
= snd_kcontrol_chip(kcontrol
);
954 ucontrol
->value
.enumerated
.item
[0] = emu
->p16v_capture_channel
;
958 static int snd_p16v_capture_channel_put(struct snd_kcontrol
*kcontrol
,
959 struct snd_ctl_elem_value
*ucontrol
)
961 struct snd_emu10k1
*emu
= snd_kcontrol_chip(kcontrol
);
966 val
= ucontrol
->value
.enumerated
.item
[0] ;
967 change
= (emu
->p16v_capture_channel
!= val
);
969 emu
->p16v_capture_channel
= val
;
970 tmp
= snd_emu10k1_ptr20_read(emu
, CAPTURE_P16V_SOURCE
, 0) & 0xfffc;
971 snd_emu10k1_ptr20_write(emu
, CAPTURE_P16V_SOURCE
, 0, tmp
| val
);
976 static struct snd_kcontrol_new snd_p16v_capture_channel __devinitdata
=
978 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
979 .name
= "HD channel Capture",
980 .info
= snd_p16v_capture_channel_info
,
981 .get
= snd_p16v_capture_channel_get
,
982 .put
= snd_p16v_capture_channel_put
985 int snd_p16v_mixer(struct snd_emu10k1
*emu
)
988 struct snd_kcontrol
*kctl
;
989 struct snd_card
*card
= emu
->card
;
990 if ((kctl
= snd_ctl_new1(&snd_p16v_volume_control_analog_front
, emu
)) == NULL
)
992 if ((err
= snd_ctl_add(card
, kctl
)))
994 if ((kctl
= snd_ctl_new1(&snd_p16v_volume_control_analog_rear
, emu
)) == NULL
)
996 if ((err
= snd_ctl_add(card
, kctl
)))
998 if ((kctl
= snd_ctl_new1(&snd_p16v_volume_control_analog_center_lfe
, emu
)) == NULL
)
1000 if ((err
= snd_ctl_add(card
, kctl
)))
1002 if ((kctl
= snd_ctl_new1(&snd_p16v_volume_control_analog_unknown
, emu
)) == NULL
)
1004 if ((err
= snd_ctl_add(card
, kctl
)))
1006 if ((kctl
= snd_ctl_new1(&snd_p16v_volume_control_spdif_front
, emu
)) == NULL
)
1008 if ((err
= snd_ctl_add(card
, kctl
)))
1010 if ((kctl
= snd_ctl_new1(&snd_p16v_volume_control_spdif_rear
, emu
)) == NULL
)
1012 if ((err
= snd_ctl_add(card
, kctl
)))
1014 if ((kctl
= snd_ctl_new1(&snd_p16v_volume_control_spdif_center_lfe
, emu
)) == NULL
)
1016 if ((err
= snd_ctl_add(card
, kctl
)))
1018 if ((kctl
= snd_ctl_new1(&snd_p16v_volume_control_spdif_unknown
, emu
)) == NULL
)
1020 if ((err
= snd_ctl_add(card
, kctl
)))
1022 if ((kctl
= snd_ctl_new1(&snd_p16v_capture_source
, emu
)) == NULL
)
1024 if ((err
= snd_ctl_add(card
, kctl
)))
1026 if ((kctl
= snd_ctl_new1(&snd_p16v_capture_channel
, emu
)) == NULL
)
1028 if ((err
= snd_ctl_add(card
, kctl
)))