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 <linux/delay.h>
91 #include <linux/init.h>
92 #include <linux/interrupt.h>
93 #include <linux/pci.h>
94 #include <linux/slab.h>
95 #include <linux/vmalloc.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/tlv.h>
103 #include <sound/emu10k1.h>
106 #define SET_CHANNEL 0 /* Testing channel outputs 0=Front, 1=Center/LFE, 2=Unknown, 3=Rear */
107 #define PCM_FRONT_CHANNEL 0
108 #define PCM_REAR_CHANNEL 1
109 #define PCM_CENTER_LFE_CHANNEL 2
110 #define PCM_SIDE_CHANNEL 3
111 #define CONTROL_FRONT_CHANNEL 0
112 #define CONTROL_REAR_CHANNEL 3
113 #define CONTROL_CENTER_LFE_CHANNEL 1
114 #define CONTROL_SIDE_CHANNEL 2
117 * Class 0401: 1102:0004 (rev 04) Subsystem: 1102:2002 -> Audigy2 ZS 7.1 Model:SB0350
118 * Class 0401: 1102:0004 (rev 04) Subsystem: 1102:1007 -> Audigy2 6.1 Model:SB0240
119 * Class 0401: 1102:0004 (rev 04) Subsystem: 1102:1002 -> Audigy2 Platinum Model:SB msb0240230009266
120 * Class 0401: 1102:0004 (rev 04) Subsystem: 1102:2007 -> Audigy4 Pro Model:SB0380 M1SB0380472001901E
124 /* hardware definition */
125 static struct snd_pcm_hardware snd_p16v_playback_hw
= {
126 .info
= SNDRV_PCM_INFO_MMAP
|
127 SNDRV_PCM_INFO_INTERLEAVED
|
128 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
129 SNDRV_PCM_INFO_RESUME
|
130 SNDRV_PCM_INFO_MMAP_VALID
|
131 SNDRV_PCM_INFO_SYNC_START
,
132 .formats
= SNDRV_PCM_FMTBIT_S32_LE
, /* Only supports 24-bit samples padded to 32 bits. */
133 .rates
= SNDRV_PCM_RATE_192000
| SNDRV_PCM_RATE_96000
| SNDRV_PCM_RATE_48000
| SNDRV_PCM_RATE_44100
,
138 .buffer_bytes_max
= ((65536 - 64) * 8),
139 .period_bytes_min
= 64,
140 .period_bytes_max
= (65536 - 64),
146 static struct snd_pcm_hardware snd_p16v_capture_hw
= {
147 .info
= (SNDRV_PCM_INFO_MMAP
|
148 SNDRV_PCM_INFO_INTERLEAVED
|
149 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
150 SNDRV_PCM_INFO_RESUME
|
151 SNDRV_PCM_INFO_MMAP_VALID
),
152 .formats
= SNDRV_PCM_FMTBIT_S32_LE
,
153 .rates
= SNDRV_PCM_RATE_192000
| SNDRV_PCM_RATE_96000
| SNDRV_PCM_RATE_48000
| SNDRV_PCM_RATE_44100
,
158 .buffer_bytes_max
= (65536 - 64),
159 .period_bytes_min
= 64,
160 .period_bytes_max
= (65536 - 128) >> 1, /* size has to be N*64 bytes */
166 static void snd_p16v_pcm_free_substream(struct snd_pcm_runtime
*runtime
)
168 struct snd_emu10k1_pcm
*epcm
= runtime
->private_data
;
171 /* snd_printk(KERN_DEBUG "epcm free: %p\n", epcm); */
176 /* open_playback callback */
177 static int snd_p16v_pcm_open_playback_channel(struct snd_pcm_substream
*substream
, int channel_id
)
179 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
180 struct snd_emu10k1_voice
*channel
= &(emu
->p16v_voices
[channel_id
]);
181 struct snd_emu10k1_pcm
*epcm
;
182 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
185 epcm
= kzalloc(sizeof(*epcm
), GFP_KERNEL
);
186 /* snd_printk(KERN_DEBUG "epcm kcalloc: %p\n", epcm); */
191 epcm
->substream
= substream
;
193 snd_printk(KERN_DEBUG "epcm device=%d, channel_id=%d\n",
194 substream->pcm->device, channel_id);
196 runtime
->private_data
= epcm
;
197 runtime
->private_free
= snd_p16v_pcm_free_substream
;
199 runtime
->hw
= snd_p16v_playback_hw
;
202 channel
->number
= channel_id
;
205 /* channel->interrupt = snd_p16v_pcm_channel_interrupt; */
206 channel
->epcm
= epcm
;
207 if ((err
= snd_pcm_hw_constraint_integer(runtime
, SNDRV_PCM_HW_PARAM_PERIODS
)) < 0)
210 runtime
->sync
.id32
[0] = substream
->pcm
->card
->number
;
211 runtime
->sync
.id32
[1] = 'P';
212 runtime
->sync
.id32
[2] = 16;
213 runtime
->sync
.id32
[3] = 'V';
217 /* open_capture callback */
218 static int snd_p16v_pcm_open_capture_channel(struct snd_pcm_substream
*substream
, int channel_id
)
220 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
221 struct snd_emu10k1_voice
*channel
= &(emu
->p16v_capture_voice
);
222 struct snd_emu10k1_pcm
*epcm
;
223 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
226 epcm
= kzalloc(sizeof(*epcm
), GFP_KERNEL
);
227 /* snd_printk(KERN_DEBUG "epcm kcalloc: %p\n", epcm); */
232 epcm
->substream
= substream
;
234 snd_printk(KERN_DEBUG "epcm device=%d, channel_id=%d\n",
235 substream->pcm->device, channel_id);
237 runtime
->private_data
= epcm
;
238 runtime
->private_free
= snd_p16v_pcm_free_substream
;
240 runtime
->hw
= snd_p16v_capture_hw
;
243 channel
->number
= channel_id
;
246 /* channel->interrupt = snd_p16v_pcm_channel_interrupt; */
247 channel
->epcm
= epcm
;
248 if ((err
= snd_pcm_hw_constraint_integer(runtime
, SNDRV_PCM_HW_PARAM_PERIODS
)) < 0)
256 static int snd_p16v_pcm_close_playback(struct snd_pcm_substream
*substream
)
258 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
259 //struct snd_pcm_runtime *runtime = substream->runtime;
260 //struct snd_emu10k1_pcm *epcm = runtime->private_data;
261 emu
->p16v_voices
[substream
->pcm
->device
- emu
->p16v_device_offset
].use
= 0;
266 static int snd_p16v_pcm_close_capture(struct snd_pcm_substream
*substream
)
268 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
269 //struct snd_pcm_runtime *runtime = substream->runtime;
270 //struct snd_emu10k1_pcm *epcm = runtime->private_data;
271 emu
->p16v_capture_voice
.use
= 0;
275 static int snd_p16v_pcm_open_playback_front(struct snd_pcm_substream
*substream
)
277 return snd_p16v_pcm_open_playback_channel(substream
, PCM_FRONT_CHANNEL
);
280 static int snd_p16v_pcm_open_capture(struct snd_pcm_substream
*substream
)
282 // Only using channel 0 for now, but the card has 2 channels.
283 return snd_p16v_pcm_open_capture_channel(substream
, 0);
286 /* hw_params callback */
287 static int snd_p16v_pcm_hw_params_playback(struct snd_pcm_substream
*substream
,
288 struct snd_pcm_hw_params
*hw_params
)
291 result
= snd_pcm_lib_malloc_pages(substream
,
292 params_buffer_bytes(hw_params
));
296 /* hw_params callback */
297 static int snd_p16v_pcm_hw_params_capture(struct snd_pcm_substream
*substream
,
298 struct snd_pcm_hw_params
*hw_params
)
301 result
= snd_pcm_lib_malloc_pages(substream
,
302 params_buffer_bytes(hw_params
));
307 /* hw_free callback */
308 static int snd_p16v_pcm_hw_free_playback(struct snd_pcm_substream
*substream
)
311 result
= snd_pcm_lib_free_pages(substream
);
315 /* hw_free callback */
316 static int snd_p16v_pcm_hw_free_capture(struct snd_pcm_substream
*substream
)
319 result
= snd_pcm_lib_free_pages(substream
);
324 /* prepare playback callback */
325 static int snd_p16v_pcm_prepare_playback(struct snd_pcm_substream
*substream
)
327 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
328 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
329 int channel
= substream
->pcm
->device
- emu
->p16v_device_offset
;
330 u32
*table_base
= (u32
*)(emu
->p16v_buffer
.area
+(8*16*channel
));
331 u32 period_size_bytes
= frames_to_bytes(runtime
, runtime
->period_size
);
335 tmp
= snd_emu10k1_ptr_read(emu
, A_SPDIF_SAMPLERATE
, channel
);
336 switch (runtime
->rate
) {
338 snd_emu10k1_ptr_write(emu
, A_SPDIF_SAMPLERATE
, channel
, (tmp
& ~0xe0e0) | 0x8080);
341 snd_emu10k1_ptr_write(emu
, A_SPDIF_SAMPLERATE
, channel
, (tmp
& ~0xe0e0) | 0x4040);
344 snd_emu10k1_ptr_write(emu
, A_SPDIF_SAMPLERATE
, channel
, (tmp
& ~0xe0e0) | 0x2020);
348 snd_emu10k1_ptr_write(emu
, A_SPDIF_SAMPLERATE
, channel
, (tmp
& ~0xe0e0) | 0x0000);
351 for(i
= 0; i
< runtime
->periods
; i
++) {
352 table_base
[i
*2]=runtime
->dma_addr
+(i
*period_size_bytes
);
353 table_base
[(i
*2)+1]=period_size_bytes
<<16;
356 snd_emu10k1_ptr20_write(emu
, PLAYBACK_LIST_ADDR
, channel
, emu
->p16v_buffer
.addr
+(8*16*channel
));
357 snd_emu10k1_ptr20_write(emu
, PLAYBACK_LIST_SIZE
, channel
, (runtime
->periods
- 1) << 19);
358 snd_emu10k1_ptr20_write(emu
, PLAYBACK_LIST_PTR
, channel
, 0);
359 snd_emu10k1_ptr20_write(emu
, PLAYBACK_DMA_ADDR
, channel
, runtime
->dma_addr
);
360 //snd_emu10k1_ptr20_write(emu, PLAYBACK_PERIOD_SIZE, channel, frames_to_bytes(runtime, runtime->period_size)<<16); // buffer size in bytes
361 snd_emu10k1_ptr20_write(emu
, PLAYBACK_PERIOD_SIZE
, channel
, 0); // buffer size in bytes
362 snd_emu10k1_ptr20_write(emu
, PLAYBACK_POINTER
, channel
, 0);
363 snd_emu10k1_ptr20_write(emu
, 0x07, channel
, 0x0);
364 snd_emu10k1_ptr20_write(emu
, 0x08, channel
, 0);
369 /* prepare capture callback */
370 static int snd_p16v_pcm_prepare_capture(struct snd_pcm_substream
*substream
)
372 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
373 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
374 int channel
= substream
->pcm
->device
- emu
->p16v_device_offset
;
378 printk(KERN_DEBUG "prepare capture:channel_number=%d, rate=%d, "
379 "format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, "
380 "frames_to_bytes=%d\n",
381 channel, runtime->rate, runtime->format, runtime->channels,
382 runtime->buffer_size, runtime->period_size,
383 frames_to_bytes(runtime, 1));
385 tmp
= snd_emu10k1_ptr_read(emu
, A_SPDIF_SAMPLERATE
, channel
);
386 switch (runtime
->rate
) {
388 snd_emu10k1_ptr_write(emu
, A_SPDIF_SAMPLERATE
, channel
, (tmp
& ~0x0e00) | 0x0800);
391 snd_emu10k1_ptr_write(emu
, A_SPDIF_SAMPLERATE
, channel
, (tmp
& ~0x0e00) | 0x0400);
394 snd_emu10k1_ptr_write(emu
, A_SPDIF_SAMPLERATE
, channel
, (tmp
& ~0x0e00) | 0x0200);
398 snd_emu10k1_ptr_write(emu
, A_SPDIF_SAMPLERATE
, channel
, (tmp
& ~0x0e00) | 0x0000);
401 snd_emu10k1_ptr20_write(emu
, 0x13, channel
, 0);
402 snd_emu10k1_ptr20_write(emu
, CAPTURE_DMA_ADDR
, channel
, runtime
->dma_addr
);
403 snd_emu10k1_ptr20_write(emu
, CAPTURE_BUFFER_SIZE
, channel
, frames_to_bytes(runtime
, runtime
->buffer_size
) << 16); // buffer size in bytes
404 snd_emu10k1_ptr20_write(emu
, CAPTURE_POINTER
, channel
, 0);
405 //snd_emu10k1_ptr20_write(emu, CAPTURE_SOURCE, 0x0, 0x333300e4); /* Select MIC or Line in */
406 //snd_emu10k1_ptr20_write(emu, EXTENDED_INT_MASK, 0, snd_emu10k1_ptr20_read(emu, EXTENDED_INT_MASK, 0) | (0x110000<<channel));
411 static void snd_p16v_intr_enable(struct snd_emu10k1
*emu
, unsigned int intrenb
)
416 spin_lock_irqsave(&emu
->emu_lock
, flags
);
417 enable
= inl(emu
->port
+ INTE2
) | intrenb
;
418 outl(enable
, emu
->port
+ INTE2
);
419 spin_unlock_irqrestore(&emu
->emu_lock
, flags
);
422 static void snd_p16v_intr_disable(struct snd_emu10k1
*emu
, unsigned int intrenb
)
425 unsigned int disable
;
427 spin_lock_irqsave(&emu
->emu_lock
, flags
);
428 disable
= inl(emu
->port
+ INTE2
) & (~intrenb
);
429 outl(disable
, emu
->port
+ INTE2
);
430 spin_unlock_irqrestore(&emu
->emu_lock
, flags
);
433 /* trigger_playback callback */
434 static int snd_p16v_pcm_trigger_playback(struct snd_pcm_substream
*substream
,
437 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
438 struct snd_pcm_runtime
*runtime
;
439 struct snd_emu10k1_pcm
*epcm
;
442 struct snd_pcm_substream
*s
;
448 case SNDRV_PCM_TRIGGER_START
:
451 case SNDRV_PCM_TRIGGER_STOP
:
456 snd_pcm_group_for_each_entry(s
, substream
) {
457 if (snd_pcm_substream_chip(s
) != emu
||
458 s
->stream
!= SNDRV_PCM_STREAM_PLAYBACK
)
460 runtime
= s
->runtime
;
461 epcm
= runtime
->private_data
;
462 channel
= substream
->pcm
->device
-emu
->p16v_device_offset
;
463 /* snd_printk(KERN_DEBUG "p16v channel=%d\n", channel); */
464 epcm
->running
= running
;
465 basic
|= (0x1<<channel
);
466 inte
|= (INTE2_PLAYBACK_CH_0_LOOP
<<channel
);
467 snd_pcm_trigger_done(s
, substream
);
469 /* snd_printk(KERN_DEBUG "basic=0x%x, inte=0x%x\n", basic, inte); */
472 case SNDRV_PCM_TRIGGER_START
:
473 snd_p16v_intr_enable(emu
, inte
);
474 snd_emu10k1_ptr20_write(emu
, BASIC_INTERRUPT
, 0, snd_emu10k1_ptr20_read(emu
, BASIC_INTERRUPT
, 0)| (basic
));
476 case SNDRV_PCM_TRIGGER_STOP
:
477 snd_emu10k1_ptr20_write(emu
, BASIC_INTERRUPT
, 0, snd_emu10k1_ptr20_read(emu
, BASIC_INTERRUPT
, 0) & ~(basic
));
478 snd_p16v_intr_disable(emu
, inte
);
487 /* trigger_capture callback */
488 static int snd_p16v_pcm_trigger_capture(struct snd_pcm_substream
*substream
,
491 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
492 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
493 struct snd_emu10k1_pcm
*epcm
= runtime
->private_data
;
496 u32 inte
= INTE2_CAPTURE_CH_0_LOOP
| INTE2_CAPTURE_CH_0_HALF_LOOP
;
499 case SNDRV_PCM_TRIGGER_START
:
500 snd_p16v_intr_enable(emu
, inte
);
501 snd_emu10k1_ptr20_write(emu
, BASIC_INTERRUPT
, 0, snd_emu10k1_ptr20_read(emu
, BASIC_INTERRUPT
, 0)|(0x100<<channel
));
504 case SNDRV_PCM_TRIGGER_STOP
:
505 snd_emu10k1_ptr20_write(emu
, BASIC_INTERRUPT
, 0, snd_emu10k1_ptr20_read(emu
, BASIC_INTERRUPT
, 0) & ~(0x100<<channel
));
506 snd_p16v_intr_disable(emu
, inte
);
507 //snd_emu10k1_ptr20_write(emu, EXTENDED_INT_MASK, 0, snd_emu10k1_ptr20_read(emu, EXTENDED_INT_MASK, 0) & ~(0x110000<<channel));
517 /* pointer_playback callback */
518 static snd_pcm_uframes_t
519 snd_p16v_pcm_pointer_playback(struct snd_pcm_substream
*substream
)
521 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
522 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
523 struct snd_emu10k1_pcm
*epcm
= runtime
->private_data
;
524 snd_pcm_uframes_t ptr
, ptr1
, ptr2
,ptr3
,ptr4
= 0;
525 int channel
= substream
->pcm
->device
- emu
->p16v_device_offset
;
529 ptr3
= snd_emu10k1_ptr20_read(emu
, PLAYBACK_LIST_PTR
, channel
);
530 ptr1
= snd_emu10k1_ptr20_read(emu
, PLAYBACK_POINTER
, channel
);
531 ptr4
= snd_emu10k1_ptr20_read(emu
, PLAYBACK_LIST_PTR
, channel
);
532 if (ptr3
!= ptr4
) ptr1
= snd_emu10k1_ptr20_read(emu
, PLAYBACK_POINTER
, channel
);
533 ptr2
= bytes_to_frames(runtime
, ptr1
);
534 ptr2
+= (ptr4
>> 3) * runtime
->period_size
;
536 if (ptr
>= runtime
->buffer_size
)
537 ptr
-= runtime
->buffer_size
;
542 /* pointer_capture callback */
543 static snd_pcm_uframes_t
544 snd_p16v_pcm_pointer_capture(struct snd_pcm_substream
*substream
)
546 struct snd_emu10k1
*emu
= snd_pcm_substream_chip(substream
);
547 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
548 struct snd_emu10k1_pcm
*epcm
= runtime
->private_data
;
549 snd_pcm_uframes_t ptr
, ptr1
, ptr2
= 0;
555 ptr1
= snd_emu10k1_ptr20_read(emu
, CAPTURE_POINTER
, channel
);
556 ptr2
= bytes_to_frames(runtime
, ptr1
);
558 if (ptr
>= runtime
->buffer_size
) {
559 ptr
-= runtime
->buffer_size
;
560 printk(KERN_WARNING
"buffer capture limited!\n");
563 printk(KERN_DEBUG "ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, "
564 "buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n",
565 ptr1, ptr2, ptr, (int)runtime->buffer_size,
566 (int)runtime->period_size, (int)runtime->frame_bits,
573 static struct snd_pcm_ops snd_p16v_playback_front_ops
= {
574 .open
= snd_p16v_pcm_open_playback_front
,
575 .close
= snd_p16v_pcm_close_playback
,
576 .ioctl
= snd_pcm_lib_ioctl
,
577 .hw_params
= snd_p16v_pcm_hw_params_playback
,
578 .hw_free
= snd_p16v_pcm_hw_free_playback
,
579 .prepare
= snd_p16v_pcm_prepare_playback
,
580 .trigger
= snd_p16v_pcm_trigger_playback
,
581 .pointer
= snd_p16v_pcm_pointer_playback
,
584 static struct snd_pcm_ops snd_p16v_capture_ops
= {
585 .open
= snd_p16v_pcm_open_capture
,
586 .close
= snd_p16v_pcm_close_capture
,
587 .ioctl
= snd_pcm_lib_ioctl
,
588 .hw_params
= snd_p16v_pcm_hw_params_capture
,
589 .hw_free
= snd_p16v_pcm_hw_free_capture
,
590 .prepare
= snd_p16v_pcm_prepare_capture
,
591 .trigger
= snd_p16v_pcm_trigger_capture
,
592 .pointer
= snd_p16v_pcm_pointer_capture
,
596 int snd_p16v_free(struct snd_emu10k1
*chip
)
599 if (chip
->p16v_buffer
.area
) {
600 snd_dma_free_pages(&chip
->p16v_buffer
);
602 snd_printk(KERN_DEBUG "period lables free: %p\n",
609 int __devinit
snd_p16v_pcm(struct snd_emu10k1
*emu
, int device
, struct snd_pcm
**rpcm
)
612 struct snd_pcm_substream
*substream
;
616 /* snd_printk(KERN_DEBUG "snd_p16v_pcm called. device=%d\n", device); */
617 emu
->p16v_device_offset
= device
;
621 if ((err
= snd_pcm_new(emu
->card
, "p16v", device
, 1, capture
, &pcm
)) < 0)
624 pcm
->private_data
= emu
;
625 // Single playback 8 channel device.
626 // Single capture 2 channel device.
627 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_p16v_playback_front_ops
);
628 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_p16v_capture_ops
);
631 pcm
->dev_subclass
= SNDRV_PCM_SUBCLASS_GENERIC_MIX
;
632 strcpy(pcm
->name
, "p16v");
635 for(substream
= pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream
;
637 substream
= substream
->next
) {
638 if ((err
= snd_pcm_lib_preallocate_pages(substream
,
640 snd_dma_pci_data(emu
->pci
),
641 ((65536 - 64) * 8), ((65536 - 64) * 8))) < 0)
644 snd_printk(KERN_DEBUG
645 "preallocate playback substream: err=%d\n", err);
649 for (substream
= pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
;
651 substream
= substream
->next
) {
652 if ((err
= snd_pcm_lib_preallocate_pages(substream
,
654 snd_dma_pci_data(emu
->pci
),
655 65536 - 64, 65536 - 64)) < 0)
658 snd_printk(KERN_DEBUG
659 "preallocate capture substream: err=%d\n", err);
669 static int snd_p16v_volume_info(struct snd_kcontrol
*kcontrol
,
670 struct snd_ctl_elem_info
*uinfo
)
672 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
674 uinfo
->value
.integer
.min
= 0;
675 uinfo
->value
.integer
.max
= 255;
679 static int snd_p16v_volume_get(struct snd_kcontrol
*kcontrol
,
680 struct snd_ctl_elem_value
*ucontrol
)
682 struct snd_emu10k1
*emu
= snd_kcontrol_chip(kcontrol
);
683 int high_low
= (kcontrol
->private_value
>> 8) & 0xff;
684 int reg
= kcontrol
->private_value
& 0xff;
687 value
= snd_emu10k1_ptr20_read(emu
, reg
, high_low
);
689 ucontrol
->value
.integer
.value
[0] = 0xff - ((value
>> 24) & 0xff); /* Left */
690 ucontrol
->value
.integer
.value
[1] = 0xff - ((value
>> 16) & 0xff); /* Right */
692 ucontrol
->value
.integer
.value
[0] = 0xff - ((value
>> 8) & 0xff); /* Left */
693 ucontrol
->value
.integer
.value
[1] = 0xff - ((value
>> 0) & 0xff); /* Right */
698 static int snd_p16v_volume_put(struct snd_kcontrol
*kcontrol
,
699 struct snd_ctl_elem_value
*ucontrol
)
701 struct snd_emu10k1
*emu
= snd_kcontrol_chip(kcontrol
);
702 int high_low
= (kcontrol
->private_value
>> 8) & 0xff;
703 int reg
= kcontrol
->private_value
& 0xff;
706 oval
= value
= snd_emu10k1_ptr20_read(emu
, reg
, 0);
709 value
|= ((0xff - ucontrol
->value
.integer
.value
[0]) << 24) |
710 ((0xff - ucontrol
->value
.integer
.value
[1]) << 16);
713 value
|= ((0xff - ucontrol
->value
.integer
.value
[0]) << 8) |
714 ((0xff - ucontrol
->value
.integer
.value
[1]) );
717 snd_emu10k1_ptr20_write(emu
, reg
, 0, value
);
723 static int snd_p16v_capture_source_info(struct snd_kcontrol
*kcontrol
,
724 struct snd_ctl_elem_info
*uinfo
)
726 static char *texts
[8] = {
727 "SPDIF", "I2S", "SRC48", "SRCMulti_SPDIF", "SRCMulti_I2S",
731 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
733 uinfo
->value
.enumerated
.items
= 8;
734 if (uinfo
->value
.enumerated
.item
> 7)
735 uinfo
->value
.enumerated
.item
= 7;
736 strcpy(uinfo
->value
.enumerated
.name
, texts
[uinfo
->value
.enumerated
.item
]);
740 static int snd_p16v_capture_source_get(struct snd_kcontrol
*kcontrol
,
741 struct snd_ctl_elem_value
*ucontrol
)
743 struct snd_emu10k1
*emu
= snd_kcontrol_chip(kcontrol
);
745 ucontrol
->value
.enumerated
.item
[0] = emu
->p16v_capture_source
;
749 static int snd_p16v_capture_source_put(struct snd_kcontrol
*kcontrol
,
750 struct snd_ctl_elem_value
*ucontrol
)
752 struct snd_emu10k1
*emu
= snd_kcontrol_chip(kcontrol
);
758 val
= ucontrol
->value
.enumerated
.item
[0] ;
761 change
= (emu
->p16v_capture_source
!= val
);
763 emu
->p16v_capture_source
= val
;
764 source
= (val
<< 28) | (val
<< 24) | (val
<< 20) | (val
<< 16);
765 mask
= snd_emu10k1_ptr20_read(emu
, BASIC_INTERRUPT
, 0) & 0xffff;
766 snd_emu10k1_ptr20_write(emu
, BASIC_INTERRUPT
, 0, source
| mask
);
771 static int snd_p16v_capture_channel_info(struct snd_kcontrol
*kcontrol
,
772 struct snd_ctl_elem_info
*uinfo
)
774 static char *texts
[4] = { "0", "1", "2", "3", };
776 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
778 uinfo
->value
.enumerated
.items
= 4;
779 if (uinfo
->value
.enumerated
.item
> 3)
780 uinfo
->value
.enumerated
.item
= 3;
781 strcpy(uinfo
->value
.enumerated
.name
, texts
[uinfo
->value
.enumerated
.item
]);
785 static int snd_p16v_capture_channel_get(struct snd_kcontrol
*kcontrol
,
786 struct snd_ctl_elem_value
*ucontrol
)
788 struct snd_emu10k1
*emu
= snd_kcontrol_chip(kcontrol
);
790 ucontrol
->value
.enumerated
.item
[0] = emu
->p16v_capture_channel
;
794 static int snd_p16v_capture_channel_put(struct snd_kcontrol
*kcontrol
,
795 struct snd_ctl_elem_value
*ucontrol
)
797 struct snd_emu10k1
*emu
= snd_kcontrol_chip(kcontrol
);
802 val
= ucontrol
->value
.enumerated
.item
[0] ;
805 change
= (emu
->p16v_capture_channel
!= val
);
807 emu
->p16v_capture_channel
= val
;
808 tmp
= snd_emu10k1_ptr20_read(emu
, CAPTURE_P16V_SOURCE
, 0) & 0xfffc;
809 snd_emu10k1_ptr20_write(emu
, CAPTURE_P16V_SOURCE
, 0, tmp
| val
);
813 static const DECLARE_TLV_DB_SCALE(snd_p16v_db_scale1
, -5175, 25, 1);
815 #define P16V_VOL(xname,xreg,xhl) { \
816 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
817 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
818 SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
819 .info = snd_p16v_volume_info, \
820 .get = snd_p16v_volume_get, \
821 .put = snd_p16v_volume_put, \
822 .tlv = { .p = snd_p16v_db_scale1 }, \
823 .private_value = ((xreg) | ((xhl) << 8)) \
826 static struct snd_kcontrol_new p16v_mixer_controls
[] __devinitdata
= {
827 P16V_VOL("HD Analog Front Playback Volume", PLAYBACK_VOLUME_MIXER9
, 0),
828 P16V_VOL("HD Analog Rear Playback Volume", PLAYBACK_VOLUME_MIXER10
, 1),
829 P16V_VOL("HD Analog Center/LFE Playback Volume", PLAYBACK_VOLUME_MIXER9
, 1),
830 P16V_VOL("HD Analog Side Playback Volume", PLAYBACK_VOLUME_MIXER10
, 0),
831 P16V_VOL("HD SPDIF Front Playback Volume", PLAYBACK_VOLUME_MIXER7
, 0),
832 P16V_VOL("HD SPDIF Rear Playback Volume", PLAYBACK_VOLUME_MIXER8
, 1),
833 P16V_VOL("HD SPDIF Center/LFE Playback Volume", PLAYBACK_VOLUME_MIXER7
, 1),
834 P16V_VOL("HD SPDIF Side Playback Volume", PLAYBACK_VOLUME_MIXER8
, 0),
836 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
837 .name
= "HD source Capture",
838 .info
= snd_p16v_capture_source_info
,
839 .get
= snd_p16v_capture_source_get
,
840 .put
= snd_p16v_capture_source_put
843 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
844 .name
= "HD channel Capture",
845 .info
= snd_p16v_capture_channel_info
,
846 .get
= snd_p16v_capture_channel_get
,
847 .put
= snd_p16v_capture_channel_put
852 int __devinit
snd_p16v_mixer(struct snd_emu10k1
*emu
)
855 struct snd_card
*card
= emu
->card
;
857 for (i
= 0; i
< ARRAY_SIZE(p16v_mixer_controls
); i
++) {
858 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&p16v_mixer_controls
[i
],
867 #define NUM_CHS 1 /* up to 4, but only first channel is used */
869 int __devinit
snd_p16v_alloc_pm_buffer(struct snd_emu10k1
*emu
)
871 emu
->p16v_saved
= vmalloc(NUM_CHS
* 4 * 0x80);
872 if (! emu
->p16v_saved
)
877 void snd_p16v_free_pm_buffer(struct snd_emu10k1
*emu
)
879 vfree(emu
->p16v_saved
);
882 void snd_p16v_suspend(struct snd_emu10k1
*emu
)
887 val
= emu
->p16v_saved
;
888 for (ch
= 0; ch
< NUM_CHS
; ch
++)
889 for (i
= 0; i
< 0x80; i
++, val
++)
890 *val
= snd_emu10k1_ptr20_read(emu
, i
, ch
);
893 void snd_p16v_resume(struct snd_emu10k1
*emu
)
898 val
= emu
->p16v_saved
;
899 for (ch
= 0; ch
< NUM_CHS
; ch
++)
900 for (i
= 0; i
< 0x80; i
++, val
++)
901 snd_emu10k1_ptr20_write(emu
, i
, ch
, *val
);