projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[ALSA] emu10k1 - Add PM support
[deliverable/linux.git] / sound / pci / emu10k1 / p16v.c
CommitLineData
1da177e4
LT		 1/*
2 * Copyright (c) by James Courtier-Dutton <James@superbug.demon.co.uk>
3 * Driver p16v chips
22bc30c8 4 * Version: 0.25
1da177e4
LT		 5 *
6 * FEATURES currently supported:
7 * Output fixed at S32_LE, 2 channel to hw:0,0
8 * Rates: 44.1, 48, 96, 192.
9 *
10 * Changelog:
11 * 0.8
12 * Use separate card based buffer for periods table.
13 * 0.9
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.
17 * 0.10
18 * Fixed missed interrupts.
19 * 0.11
20 * Add Sound card model number and names.
21 * Add Analog volume controls.
22 * 0.12
23 * Corrected playback interrupts. Now interrupt per period, instead of half period.
24 * 0.13
25 * Use single trigger for multichannel.
26 * 0.14
27 * Mic capture now works at fixed: S32_LE, 96000Hz, Stereo.
28 * 0.15
29 * Force buffer_size / period_size == INTEGER.
30 * 0.16
31 * Update p16v.c to work with changed alsa api.
32 * 0.17
33 * Update p16v.c to work with changed alsa api. Removed boot_devs.
34 * 0.18
35 * Merging with snd-emu10k1 driver.
36 * 0.19
37 * One stereo channel at 24bit now works.
38 * 0.20
39 * Added better register defines.
40 * 0.21
41 * Integrated with snd-emu10k1 driver.
42 * 0.22
43 * Removed #if 0 ... #endif
f927c8fc
JCD		 44 * 0.23
45 * Implement different capture rates.
46 * 0.24
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.
22bc30c8
JCD		 51 * 0.25
52 * Include capture buffer sizes.
1da177e4
LT		 53 *
54 * BUGS:
55 * Some stability problems when unloading the snd-p16v kernel module.
56 * --
57 *
58 * TODO:
59 * SPDIF out.
60 * Find out how to change capture sample rates. E.g. To record SPDIF at 48000Hz.
61 * Currently capture fixed at 48000Hz.
62 *
63 * --
64 * GENERAL INFO:
65 * Model: SB0240
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)
71 *
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>
74 *
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.
79 *
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.
84 *
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
88 *
89 */
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>
103#include "p16v.h"
104
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
114
115/* Card IDs:
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
120 *
121 */
122
123 /* hardware definition */
eb4698f3 124static struct snd_pcm_hardware snd_p16v_playback_hw = {
1da177e4
LT		 125 .info = (SNDRV_PCM_INFO_MMAP |
126 SNDRV_PCM_INFO_INTERLEAVED |
127 SNDRV_PCM_INFO_BLOCK_TRANSFER |
09668b44 128 SNDRV_PCM_INFO_RESUME |
1da177e4
LT		 129 SNDRV_PCM_INFO_MMAP_VALID),
130 .formats = SNDRV_PCM_FMTBIT_S32_LE, /* Only supports 24-bit samples padded to 32 bits. */
001f7589
JCD		 131 .rates = SNDRV_PCM_RATE_192000 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_44100,
132 .rate_min = 44100,
1da177e4
LT		 133 .rate_max = 192000,
134 .channels_min = 8,
135 .channels_max = 8,
310bacd2 136 .buffer_bytes_max = ((65536 - 64) * 8),
1da177e4 137 .period_bytes_min = 64,
310bacd2 138 .period_bytes_max = (65536 - 64),
1da177e4
LT		 139 .periods_min = 2,
140 .periods_max = 8,
141 .fifo_size = 0,
142};
143
eb4698f3 144static struct snd_pcm_hardware snd_p16v_capture_hw = {
c7025637
JCD		 145 .info = (SNDRV_PCM_INFO_MMAP |
146 SNDRV_PCM_INFO_INTERLEAVED |
147 SNDRV_PCM_INFO_BLOCK_TRANSFER |
09668b44 148 SNDRV_PCM_INFO_RESUME |
c7025637
JCD		 149 SNDRV_PCM_INFO_MMAP_VALID),
150 .formats = SNDRV_PCM_FMTBIT_S32_LE,
151 .rates = SNDRV_PCM_RATE_192000 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_44100,
152 .rate_min = 44100,
153 .rate_max = 192000,
154 .channels_min = 2,
155 .channels_max = 2,
22bc30c8 156 .buffer_bytes_max = (65536 - 64),
c7025637 157 .period_bytes_min = 64,
22bc30c8 158 .period_bytes_max = (65536 - 128) >> 1, /* size has to be N*64 bytes */
c7025637
JCD		 159 .periods_min = 2,
160 .periods_max = 2,
161 .fifo_size = 0,
6e4abc40
JCD		 162};
163
eb4698f3 164static void snd_p16v_pcm_free_substream(struct snd_pcm_runtime *runtime)
1da177e4 165{
eb4698f3 166 struct snd_emu10k1_pcm *epcm = runtime->private_data;
1da177e4
LT		 167
168 if (epcm) {
169 //snd_printk("epcm free: %p\n", epcm);
170 kfree(epcm);
171 }
172}
173
174/* open_playback callback */
eb4698f3 175static int snd_p16v_pcm_open_playback_channel(struct snd_pcm_substream *substream, int channel_id)
1da177e4 176{
eb4698f3
TI		 177 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
178 struct snd_emu10k1_voice *channel = &(emu->p16v_voices[channel_id]);
179 struct snd_emu10k1_pcm *epcm;
180 struct snd_pcm_runtime *runtime = substream->runtime;
1da177e4
LT		 181 int err;
182
e560d8d8 183 epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
1da177e4
LT		 184 //snd_printk("epcm kcalloc: %p\n", epcm);
185
186 if (epcm == NULL)
187 return -ENOMEM;
188 epcm->emu = emu;
189 epcm->substream = substream;
190 //snd_printk("epcm device=%d, channel_id=%d\n", substream->pcm->device, channel_id);
191
192 runtime->private_data = epcm;
193 runtime->private_free = snd_p16v_pcm_free_substream;
194
195 runtime->hw = snd_p16v_playback_hw;
196
197 channel->emu = emu;
198 channel->number = channel_id;
199
200 channel->use=1;
201 //snd_printk("p16v: open channel_id=%d, channel=%p, use=0x%x\n", channel_id, channel, channel->use);
202 //printk("open:channel_id=%d, chip=%p, channel=%p\n",channel_id, chip, channel);
203 //channel->interrupt = snd_p16v_pcm_channel_interrupt;
204 channel->epcm=epcm;
205 if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
206 return err;
207
208 return 0;
209}
6e4abc40 210/* open_capture callback */
eb4698f3 211static int snd_p16v_pcm_open_capture_channel(struct snd_pcm_substream *substream, int channel_id)
6e4abc40 212{
eb4698f3
TI		 213 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
214 struct snd_emu10k1_voice *channel = &(emu->p16v_capture_voice);
215 struct snd_emu10k1_pcm *epcm;
216 struct snd_pcm_runtime *runtime = substream->runtime;
6e4abc40
JCD		 217 int err;
218
e560d8d8 219 epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
6e4abc40
JCD		 220 //snd_printk("epcm kcalloc: %p\n", epcm);
221
222 if (epcm == NULL)
223 return -ENOMEM;
224 epcm->emu = emu;
225 epcm->substream = substream;
226 //snd_printk("epcm device=%d, channel_id=%d\n", substream->pcm->device, channel_id);
227
228 runtime->private_data = epcm;
229 runtime->private_free = snd_p16v_pcm_free_substream;
230
231 runtime->hw = snd_p16v_capture_hw;
232
233 channel->emu = emu;
234 channel->number = channel_id;
235
236 channel->use=1;
237 //snd_printk("p16v: open channel_id=%d, channel=%p, use=0x%x\n", channel_id, channel, channel->use);
238 //printk("open:channel_id=%d, chip=%p, channel=%p\n",channel_id, chip, channel);
239 //channel->interrupt = snd_p16v_pcm_channel_interrupt;
240 channel->epcm=epcm;
241 if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
242 return err;
243
244 return 0;
245}
246
1da177e4
LT		 247
248/* close callback */
eb4698f3 249static int snd_p16v_pcm_close_playback(struct snd_pcm_substream *substream)
1da177e4 250{
eb4698f3
TI		 251 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
252 //struct snd_pcm_runtime *runtime = substream->runtime;
253 //struct snd_emu10k1_pcm *epcm = runtime->private_data;
6e4abc40
JCD		 254 emu->p16v_voices[substream->pcm->device - emu->p16v_device_offset].use=0;
255 /* FIXME: maybe zero others */
256 return 0;
257}
258
259/* close callback */
eb4698f3 260static int snd_p16v_pcm_close_capture(struct snd_pcm_substream *substream)
6e4abc40 261{
eb4698f3
TI		 262 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
263 //struct snd_pcm_runtime *runtime = substream->runtime;
264 //struct snd_emu10k1_pcm *epcm = runtime->private_data;
6e4abc40
JCD		 265 emu->p16v_capture_voice.use=0;
266 /* FIXME: maybe zero others */
1da177e4
LT		 267 return 0;
268}
269
eb4698f3 270static int snd_p16v_pcm_open_playback_front(struct snd_pcm_substream *substream)
1da177e4
LT		 271{
272 return snd_p16v_pcm_open_playback_channel(substream, PCM_FRONT_CHANNEL);
273}
274
eb4698f3 275static int snd_p16v_pcm_open_capture(struct snd_pcm_substream *substream)
6e4abc40
JCD		 276{
277 // Only using channel 0 for now, but the card has 2 channels.
278 return snd_p16v_pcm_open_capture_channel(substream, 0);
279}
280
1da177e4 281/* hw_params callback */
eb4698f3
TI		 282static int snd_p16v_pcm_hw_params_playback(struct snd_pcm_substream *substream,
283 struct snd_pcm_hw_params *hw_params)
1da177e4
LT		 284{
285 int result;
1da177e4
LT		 286 result = snd_pcm_lib_malloc_pages(substream,
287 params_buffer_bytes(hw_params));
1da177e4
LT		 288 return result;
289}
290
6e4abc40 291/* hw_params callback */
eb4698f3
TI		 292static int snd_p16v_pcm_hw_params_capture(struct snd_pcm_substream *substream,
293 struct snd_pcm_hw_params *hw_params)
6e4abc40
JCD		 294{
295 int result;
296 result = snd_pcm_lib_malloc_pages(substream,
297 params_buffer_bytes(hw_params));
298 return result;
299}
300
301
1da177e4 302/* hw_free callback */
eb4698f3 303static int snd_p16v_pcm_hw_free_playback(struct snd_pcm_substream *substream)
1da177e4
LT		 304{
305 int result;
1da177e4 306 result = snd_pcm_lib_free_pages(substream);
1da177e4
LT		 307 return result;
308}
309
6e4abc40 310/* hw_free callback */
eb4698f3 311static int snd_p16v_pcm_hw_free_capture(struct snd_pcm_substream *substream)
6e4abc40
JCD		 312{
313 int result;
314 result = snd_pcm_lib_free_pages(substream);
315 return result;
316}
317
318
1da177e4 319/* prepare playback callback */
eb4698f3 320static int snd_p16v_pcm_prepare_playback(struct snd_pcm_substream *substream)
1da177e4 321{
eb4698f3
TI		 322 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
323 struct snd_pcm_runtime *runtime = substream->runtime;
1da177e4
LT		 324 int channel = substream->pcm->device - emu->p16v_device_offset;
325 u32 *table_base = (u32 *)(emu->p16v_buffer.area+(8*16*channel));
326 u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size);
327 int i;
328 u32 tmp;
329
330 //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));
331 //snd_printk("dma_addr=%x, dma_area=%p, table_base=%p\n",runtime->dma_addr, runtime->dma_area, table_base);
332 //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);
333 tmp = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, channel);
334 switch (runtime->rate) {
335 case 44100:
001f7589 336 snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, channel, (tmp & ~0xe0e0) | 0x8080);
1da177e4
LT		 337 break;
338 case 96000:
001f7589 339 snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, channel, (tmp & ~0xe0e0) | 0x4040);
1da177e4
LT		 340 break;
341 case 192000:
001f7589 342 snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, channel, (tmp & ~0xe0e0) | 0x2020);
1da177e4 343 break;
001f7589 344 case 48000:
1da177e4 345 default:
001f7589 346 snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, channel, (tmp & ~0xe0e0) | 0x0000);
1da177e4
LT		 347 break;
348 }
349 /* FIXME: Check emu->buffer.size before actually writing to it. */
6e4abc40 350 for(i=0; i < runtime->periods; i++) {
1da177e4
LT		 351 table_base[i*2]=runtime->dma_addr+(i*period_size_bytes);
352 table_base[(i*2)+1]=period_size_bytes<<16;
353 }
354
355 snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_ADDR, channel, emu->p16v_buffer.addr+(8*16*channel));
356 snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_SIZE, channel, (runtime->periods - 1) << 19);
357 snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_PTR, channel, 0);
358 snd_emu10k1_ptr20_write(emu, PLAYBACK_DMA_ADDR, channel, runtime->dma_addr);
310bacd2
JCD		 359 //snd_emu10k1_ptr20_write(emu, PLAYBACK_PERIOD_SIZE, channel, frames_to_bytes(runtime, runtime->period_size)<<16); // buffer size in bytes
360 snd_emu10k1_ptr20_write(emu, PLAYBACK_PERIOD_SIZE, channel, 0); // buffer size in bytes
1da177e4
LT		 361 snd_emu10k1_ptr20_write(emu, PLAYBACK_POINTER, channel, 0);
362 snd_emu10k1_ptr20_write(emu, 0x07, channel, 0x0);
363 snd_emu10k1_ptr20_write(emu, 0x08, channel, 0);
364
365 return 0;
366}
367
6e4abc40 368/* prepare capture callback */
eb4698f3 369static int snd_p16v_pcm_prepare_capture(struct snd_pcm_substream *substream)
6e4abc40 370{
eb4698f3
TI		 371 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
372 struct snd_pcm_runtime *runtime = substream->runtime;
6e4abc40 373 int channel = substream->pcm->device - emu->p16v_device_offset;
c7025637
JCD		 374 u32 tmp;
375 //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));
376 tmp = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, channel);
377 switch (runtime->rate) {
378 case 44100:
379 snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, channel, (tmp & ~0x0e00) | 0x0800);
380 break;
381 case 96000:
382 snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, channel, (tmp & ~0x0e00) | 0x0400);
383 break;
384 case 192000:
385 snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, channel, (tmp & ~0x0e00) | 0x0200);
386 break;
387 case 48000:
388 default:
389 snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, channel, (tmp & ~0x0e00) | 0x0000);
390 break;
391 }
392 /* FIXME: Check emu->buffer.size before actually writing to it. */
6e4abc40
JCD		 393 snd_emu10k1_ptr20_write(emu, 0x13, channel, 0);
394 snd_emu10k1_ptr20_write(emu, CAPTURE_DMA_ADDR, channel, runtime->dma_addr);
395 snd_emu10k1_ptr20_write(emu, CAPTURE_BUFFER_SIZE, channel, frames_to_bytes(runtime, runtime->buffer_size)<<16); // buffer size in bytes
396 snd_emu10k1_ptr20_write(emu, CAPTURE_POINTER, channel, 0);
397 //snd_emu10k1_ptr20_write(emu, CAPTURE_SOURCE, 0x0, 0x333300e4); /* Select MIC or Line in */
398 //snd_emu10k1_ptr20_write(emu, EXTENDED_INT_MASK, 0, snd_emu10k1_ptr20_read(emu, EXTENDED_INT_MASK, 0) | (0x110000<<channel));
399
400 return 0;
401}
402
eb4698f3 403static void snd_p16v_intr_enable(struct snd_emu10k1 *emu, unsigned int intrenb)
1da177e4
LT		 404{
405 unsigned long flags;
406 unsigned int enable;
407
408 spin_lock_irqsave(&emu->emu_lock, flags);
409 enable = inl(emu->port + INTE2) | intrenb;
410 outl(enable, emu->port + INTE2);
411 spin_unlock_irqrestore(&emu->emu_lock, flags);
412}
413
eb4698f3 414static void snd_p16v_intr_disable(struct snd_emu10k1 *emu, unsigned int intrenb)
1da177e4
LT		 415{
416 unsigned long flags;
417 unsigned int disable;
418
419 spin_lock_irqsave(&emu->emu_lock, flags);
420 disable = inl(emu->port + INTE2) & (~intrenb);
421 outl(disable, emu->port + INTE2);
422 spin_unlock_irqrestore(&emu->emu_lock, flags);
423}
424
425/* trigger_playback callback */
eb4698f3 426static int snd_p16v_pcm_trigger_playback(struct snd_pcm_substream *substream,
1da177e4
LT		 427 int cmd)
428{
eb4698f3
TI		 429 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
430 struct snd_pcm_runtime *runtime;
431 struct snd_emu10k1_pcm *epcm;
1da177e4
LT		 432 int channel;
433 int result = 0;
434 struct list_head *pos;
eb4698f3 435 struct snd_pcm_substream *s;
1da177e4
LT		 436 u32 basic = 0;
437 u32 inte = 0;
438 int running=0;
439
440 switch (cmd) {
441 case SNDRV_PCM_TRIGGER_START:
442 running=1;
443 break;
444 case SNDRV_PCM_TRIGGER_STOP:
445 default:
446 running=0;
447 break;
448 }
449 snd_pcm_group_for_each(pos, substream) {
450 s = snd_pcm_group_substream_entry(pos);
451 runtime = s->runtime;
452 epcm = runtime->private_data;
453 channel = substream->pcm->device-emu->p16v_device_offset;
454 //snd_printk("p16v channel=%d\n",channel);
455 epcm->running = running;
456 basic |= (0x1<<channel);
457 inte |= (INTE2_PLAYBACK_CH_0_LOOP<<channel);
458 snd_pcm_trigger_done(s, substream);
459 }
460 //snd_printk("basic=0x%x, inte=0x%x\n",basic, inte);
461
462 switch (cmd) {
463 case SNDRV_PCM_TRIGGER_START:
464 snd_p16v_intr_enable(emu, inte);
465 snd_emu10k1_ptr20_write(emu, BASIC_INTERRUPT, 0, snd_emu10k1_ptr20_read(emu, BASIC_INTERRUPT, 0)| (basic));
466 break;
467 case SNDRV_PCM_TRIGGER_STOP:
468 snd_emu10k1_ptr20_write(emu, BASIC_INTERRUPT, 0, snd_emu10k1_ptr20_read(emu, BASIC_INTERRUPT, 0) & ~(basic));
469 snd_p16v_intr_disable(emu, inte);
470 break;
471 default:
472 result = -EINVAL;
473 break;
474 }
475 return result;
476}
477
6e4abc40 478/* trigger_capture callback */
eb4698f3 479static int snd_p16v_pcm_trigger_capture(struct snd_pcm_substream *substream,
6e4abc40
JCD		 480 int cmd)
481{
eb4698f3
TI		 482 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
483 struct snd_pcm_runtime *runtime = substream->runtime;
484 struct snd_emu10k1_pcm *epcm = runtime->private_data;
6e4abc40
JCD		 485 int channel = 0;
486 int result = 0;
487 u32 inte = INTE2_CAPTURE_CH_0_LOOP | INTE2_CAPTURE_CH_0_HALF_LOOP;
488
489 switch (cmd) {
490 case SNDRV_PCM_TRIGGER_START:
491 snd_p16v_intr_enable(emu, inte);
492 snd_emu10k1_ptr20_write(emu, BASIC_INTERRUPT, 0, snd_emu10k1_ptr20_read(emu, BASIC_INTERRUPT, 0)|(0x100<<channel));
493 epcm->running = 1;
494 break;
495 case SNDRV_PCM_TRIGGER_STOP:
496 snd_emu10k1_ptr20_write(emu, BASIC_INTERRUPT, 0, snd_emu10k1_ptr20_read(emu, BASIC_INTERRUPT, 0) & ~(0x100<<channel));
497 snd_p16v_intr_disable(emu, inte);
498 //snd_emu10k1_ptr20_write(emu, EXTENDED_INT_MASK, 0, snd_emu10k1_ptr20_read(emu, EXTENDED_INT_MASK, 0) & ~(0x110000<<channel));
499 epcm->running = 0;
500 break;
501 default:
502 result = -EINVAL;
503 break;
504 }
505 return result;
506}
507
1da177e4
LT		 508/* pointer_playback callback */
509static snd_pcm_uframes_t
eb4698f3 510snd_p16v_pcm_pointer_playback(struct snd_pcm_substream *substream)
1da177e4 511{
eb4698f3
TI		 512 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
513 struct snd_pcm_runtime *runtime = substream->runtime;
514 struct snd_emu10k1_pcm *epcm = runtime->private_data;
1da177e4
LT		 515 snd_pcm_uframes_t ptr, ptr1, ptr2,ptr3,ptr4 = 0;
516 int channel = substream->pcm->device - emu->p16v_device_offset;
517 if (!epcm->running)
518 return 0;
519
520 ptr3 = snd_emu10k1_ptr20_read(emu, PLAYBACK_LIST_PTR, channel);
521 ptr1 = snd_emu10k1_ptr20_read(emu, PLAYBACK_POINTER, channel);
522 ptr4 = snd_emu10k1_ptr20_read(emu, PLAYBACK_LIST_PTR, channel);
523 if (ptr3 != ptr4) ptr1 = snd_emu10k1_ptr20_read(emu, PLAYBACK_POINTER, channel);
524 ptr2 = bytes_to_frames(runtime, ptr1);
525 ptr2+= (ptr4 >> 3) * runtime->period_size;
526 ptr=ptr2;
527 if (ptr >= runtime->buffer_size)
528 ptr -= runtime->buffer_size;
529
530 return ptr;
531}
532
6e4abc40
JCD		 533/* pointer_capture callback */
534static snd_pcm_uframes_t
eb4698f3 535snd_p16v_pcm_pointer_capture(struct snd_pcm_substream *substream)
6e4abc40 536{
eb4698f3
TI		 537 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
538 struct snd_pcm_runtime *runtime = substream->runtime;
539 struct snd_emu10k1_pcm *epcm = runtime->private_data;
6e4abc40
JCD		 540 snd_pcm_uframes_t ptr, ptr1, ptr2 = 0;
541 int channel = 0;
542
543 if (!epcm->running)
544 return 0;
545
546 ptr1 = snd_emu10k1_ptr20_read(emu, CAPTURE_POINTER, channel);
547 ptr2 = bytes_to_frames(runtime, ptr1);
548 ptr=ptr2;
549 if (ptr >= runtime->buffer_size) {
550 ptr -= runtime->buffer_size;
99b359ba 551 printk(KERN_WARNING "buffer capture limited!\n");
6e4abc40
JCD		 552 }
553 //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);
554
555 return ptr;
556}
557
1da177e4 558/* operators */
eb4698f3 559static struct snd_pcm_ops snd_p16v_playback_front_ops = {
1da177e4
LT		 560 .open = snd_p16v_pcm_open_playback_front,
561 .close = snd_p16v_pcm_close_playback,
562 .ioctl = snd_pcm_lib_ioctl,
563 .hw_params = snd_p16v_pcm_hw_params_playback,
564 .hw_free = snd_p16v_pcm_hw_free_playback,
565 .prepare = snd_p16v_pcm_prepare_playback,
566 .trigger = snd_p16v_pcm_trigger_playback,
567 .pointer = snd_p16v_pcm_pointer_playback,
568};
569
eb4698f3 570static struct snd_pcm_ops snd_p16v_capture_ops = {
6e4abc40
JCD		 571 .open = snd_p16v_pcm_open_capture,
572 .close = snd_p16v_pcm_close_capture,
573 .ioctl = snd_pcm_lib_ioctl,
574 .hw_params = snd_p16v_pcm_hw_params_capture,
575 .hw_free = snd_p16v_pcm_hw_free_capture,
576 .prepare = snd_p16v_pcm_prepare_capture,
577 .trigger = snd_p16v_pcm_trigger_capture,
578 .pointer = snd_p16v_pcm_pointer_capture,
579};
580
581
eb4698f3 582int snd_p16v_free(struct snd_emu10k1 *chip)
1da177e4
LT		 583{
584 // release the data
585 if (chip->p16v_buffer.area) {
586 snd_dma_free_pages(&chip->p16v_buffer);
587 //snd_printk("period lables free: %p\n", &chip->p16v_buffer);
588 }
589 return 0;
590}
591
eb4698f3 592int snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm **rpcm)
1da177e4 593{
eb4698f3
TI		 594 struct snd_pcm *pcm;
595 struct snd_pcm_substream *substream;
1da177e4 596 int err;
6e4abc40 597 int capture=1;
1da177e4
LT		 598
599 //snd_printk("snd_p16v_pcm called. device=%d\n", device);
600 emu->p16v_device_offset = device;
601 if (rpcm)
602 *rpcm = NULL;
6e4abc40 603
1da177e4
LT		 604 if ((err = snd_pcm_new(emu->card, "p16v", device, 1, capture, &pcm)) < 0)
605 return err;
606
607 pcm->private_data = emu;
6e4abc40
JCD		 608 // Single playback 8 channel device.
609 // Single capture 2 channel device.
1da177e4 610 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_p16v_playback_front_ops);
6e4abc40 611 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_p16v_capture_ops);
1da177e4
LT		 612
613 pcm->info_flags = 0;
614 pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
615 strcpy(pcm->name, "p16v");
09668b44 616 emu->pcm_p16v = pcm;
1da177e4
LT		 617
618 for(substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
619 substream;
620 substream = substream->next) {
621 if ((err = snd_pcm_lib_preallocate_pages(substream,
622 SNDRV_DMA_TYPE_DEV,
623 snd_dma_pci_data(emu->pci),
310bacd2 624 ((65536 - 64) * 8), ((65536 - 64) * 8))) < 0)
1da177e4
LT		 625 return err;
626 //snd_printk("preallocate playback substream: err=%d\n", err);
627 }
628
629 for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
630 substream;
631 substream = substream->next) {
632 if ((err = snd_pcm_lib_preallocate_pages(substream,
633 SNDRV_DMA_TYPE_DEV,
634 snd_dma_pci_data(emu->pci),
22bc30c8 635 65536 - 64, 65536 - 64)) < 0)
1da177e4
LT		 636 return err;
637 //snd_printk("preallocate capture substream: err=%d\n", err);
638 }
639
640 if (rpcm)
641 *rpcm = pcm;
642
643 return 0;
644}
645
eb4698f3 646static int snd_p16v_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 647{
648 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
649 uinfo->count = 2;
650 uinfo->value.integer.min = 0;
651 uinfo->value.integer.max = 255;
652 return 0;
653}
654
eb4698f3
TI		 655static int snd_p16v_volume_get(struct snd_kcontrol *kcontrol,
656 struct snd_ctl_elem_value *ucontrol, int reg, int high_low)
1da177e4 657{
eb4698f3 658 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 659 u32 value;
660
661 value = snd_emu10k1_ptr20_read(emu, reg, high_low);
662 if (high_low == 1) {
663 ucontrol->value.integer.value[0] = 0xff - ((value >> 24) & 0xff); /* Left */
664 ucontrol->value.integer.value[1] = 0xff - ((value >> 16) & 0xff); /* Right */
665 } else {
666 ucontrol->value.integer.value[0] = 0xff - ((value >> 8) & 0xff); /* Left */
667 ucontrol->value.integer.value[1] = 0xff - ((value >> 0) & 0xff); /* Right */
668 }
669 return 0;
670}
671
eb4698f3
TI		 672static int snd_p16v_volume_get_spdif_front(struct snd_kcontrol *kcontrol,
673 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 674{
675 int high_low = 0;
676 int reg = PLAYBACK_VOLUME_MIXER7;
677 return snd_p16v_volume_get(kcontrol, ucontrol, reg, high_low);
678}
679
eb4698f3
TI		 680static int snd_p16v_volume_get_spdif_center_lfe(struct snd_kcontrol *kcontrol,
681 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 682{
683 int high_low = 1;
684 int reg = PLAYBACK_VOLUME_MIXER7;
685 return snd_p16v_volume_get(kcontrol, ucontrol, reg, high_low);
686}
eb4698f3
TI		 687static int snd_p16v_volume_get_spdif_unknown(struct snd_kcontrol *kcontrol,
688 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 689{
690 int high_low = 0;
691 int reg = PLAYBACK_VOLUME_MIXER8;
692 return snd_p16v_volume_get(kcontrol, ucontrol, reg, high_low);
693}
eb4698f3
TI		 694static int snd_p16v_volume_get_spdif_rear(struct snd_kcontrol *kcontrol,
695 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 696{
697 int high_low = 1;
698 int reg = PLAYBACK_VOLUME_MIXER8;
699 return snd_p16v_volume_get(kcontrol, ucontrol, reg, high_low);
700}
701
eb4698f3
TI		 702static int snd_p16v_volume_get_analog_front(struct snd_kcontrol *kcontrol,
703 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 704{
705 int high_low = 0;
706 int reg = PLAYBACK_VOLUME_MIXER9;
707 return snd_p16v_volume_get(kcontrol, ucontrol, reg, high_low);
708}
709
eb4698f3
TI		 710static int snd_p16v_volume_get_analog_center_lfe(struct snd_kcontrol *kcontrol,
711 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 712{
713 int high_low = 1;
714 int reg = PLAYBACK_VOLUME_MIXER9;
715 return snd_p16v_volume_get(kcontrol, ucontrol, reg, high_low);
716}
eb4698f3
TI		 717static int snd_p16v_volume_get_analog_rear(struct snd_kcontrol *kcontrol,
718 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 719{
720 int high_low = 1;
721 int reg = PLAYBACK_VOLUME_MIXER10;
722 return snd_p16v_volume_get(kcontrol, ucontrol, reg, high_low);
723}
724
eb4698f3
TI		 725static int snd_p16v_volume_get_analog_unknown(struct snd_kcontrol *kcontrol,
726 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 727{
728 int high_low = 0;
729 int reg = PLAYBACK_VOLUME_MIXER10;
730 return snd_p16v_volume_get(kcontrol, ucontrol, reg, high_low);
731}
732
eb4698f3
TI		 733static int snd_p16v_volume_put(struct snd_kcontrol *kcontrol,
734 struct snd_ctl_elem_value *ucontrol, int reg, int high_low)
1da177e4 735{
eb4698f3 736 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 737 u32 value;
738 value = snd_emu10k1_ptr20_read(emu, reg, 0);
739 //value = value & 0xffff;
740 if (high_low == 1) {
741 value &= 0xffff;
742 value = value | ((0xff - ucontrol->value.integer.value[0]) << 24) | ((0xff - ucontrol->value.integer.value[1]) << 16);
743 } else {
744 value &= 0xffff0000;
745 value = value | ((0xff - ucontrol->value.integer.value[0]) << 8) | ((0xff - ucontrol->value.integer.value[1]) );
746 }
747 snd_emu10k1_ptr20_write(emu, reg, 0, value);
748 return 1;
749}
750
eb4698f3
TI		 751static int snd_p16v_volume_put_spdif_front(struct snd_kcontrol *kcontrol,
752 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 753{
754 int high_low = 0;
755 int reg = PLAYBACK_VOLUME_MIXER7;
756 return snd_p16v_volume_put(kcontrol, ucontrol, reg, high_low);
757}
758
eb4698f3
TI		 759static int snd_p16v_volume_put_spdif_center_lfe(struct snd_kcontrol *kcontrol,
760 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 761{
762 int high_low = 1;
763 int reg = PLAYBACK_VOLUME_MIXER7;
764 return snd_p16v_volume_put(kcontrol, ucontrol, reg, high_low);
765}
766
eb4698f3
TI		 767static int snd_p16v_volume_put_spdif_unknown(struct snd_kcontrol *kcontrol,
768 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 769{
770 int high_low = 0;
771 int reg = PLAYBACK_VOLUME_MIXER8;
772 return snd_p16v_volume_put(kcontrol, ucontrol, reg, high_low);
773}
774
eb4698f3
TI		 775static int snd_p16v_volume_put_spdif_rear(struct snd_kcontrol *kcontrol,
776 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 777{
778 int high_low = 1;
779 int reg = PLAYBACK_VOLUME_MIXER8;
780 return snd_p16v_volume_put(kcontrol, ucontrol, reg, high_low);
781}
782
eb4698f3
TI		 783static int snd_p16v_volume_put_analog_front(struct snd_kcontrol *kcontrol,
784 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 785{
786 int high_low = 0;
787 int reg = PLAYBACK_VOLUME_MIXER9;
788 return snd_p16v_volume_put(kcontrol, ucontrol, reg, high_low);
789}
790
eb4698f3
TI		 791static int snd_p16v_volume_put_analog_center_lfe(struct snd_kcontrol *kcontrol,
792 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 793{
794 int high_low = 1;
795 int reg = PLAYBACK_VOLUME_MIXER9;
796 return snd_p16v_volume_put(kcontrol, ucontrol, reg, high_low);
797}
798
eb4698f3
TI		 799static int snd_p16v_volume_put_analog_rear(struct snd_kcontrol *kcontrol,
800 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 801{
802 int high_low = 1;
803 int reg = PLAYBACK_VOLUME_MIXER10;
804 return snd_p16v_volume_put(kcontrol, ucontrol, reg, high_low);
805}
806
eb4698f3
TI		 807static int snd_p16v_volume_put_analog_unknown(struct snd_kcontrol *kcontrol,
808 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 809{
810 int high_low = 0;
811 int reg = PLAYBACK_VOLUME_MIXER10;
812 return snd_p16v_volume_put(kcontrol, ucontrol, reg, high_low);
813}
814
eb4698f3 815static struct snd_kcontrol_new snd_p16v_volume_control_analog_front =
1da177e4
LT		 816{
817 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3818152e 818 .name = "HD Analog Front Playback Volume",
1da177e4
LT		 819 .info = snd_p16v_volume_info,
820 .get = snd_p16v_volume_get_analog_front,
821 .put = snd_p16v_volume_put_analog_front
822};
823
eb4698f3 824static struct snd_kcontrol_new snd_p16v_volume_control_analog_center_lfe =
1da177e4
LT		 825{
826 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3818152e 827 .name = "HD Analog Center/LFE Playback Volume",
1da177e4
LT		 828 .info = snd_p16v_volume_info,
829 .get = snd_p16v_volume_get_analog_center_lfe,
830 .put = snd_p16v_volume_put_analog_center_lfe
831};
832
eb4698f3 833static struct snd_kcontrol_new snd_p16v_volume_control_analog_unknown =
1da177e4
LT		 834{
835 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3818152e 836 .name = "HD Analog Unknown Playback Volume",
1da177e4
LT		 837 .info = snd_p16v_volume_info,
838 .get = snd_p16v_volume_get_analog_unknown,
839 .put = snd_p16v_volume_put_analog_unknown
840};
841
eb4698f3 842static struct snd_kcontrol_new snd_p16v_volume_control_analog_rear =
1da177e4
LT		 843{
844 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3818152e 845 .name = "HD Analog Rear Playback Volume",
1da177e4
LT		 846 .info = snd_p16v_volume_info,
847 .get = snd_p16v_volume_get_analog_rear,
848 .put = snd_p16v_volume_put_analog_rear
849};
850
eb4698f3 851static struct snd_kcontrol_new snd_p16v_volume_control_spdif_front =
1da177e4
LT		 852{
853 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3818152e 854 .name = "HD SPDIF Front Playback Volume",
1da177e4
LT		 855 .info = snd_p16v_volume_info,
856 .get = snd_p16v_volume_get_spdif_front,
857 .put = snd_p16v_volume_put_spdif_front
858};
859
eb4698f3 860static struct snd_kcontrol_new snd_p16v_volume_control_spdif_center_lfe =
1da177e4
LT		 861{
862 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3818152e 863 .name = "HD SPDIF Center/LFE Playback Volume",
1da177e4
LT		 864 .info = snd_p16v_volume_info,
865 .get = snd_p16v_volume_get_spdif_center_lfe,
866 .put = snd_p16v_volume_put_spdif_center_lfe
867};
868
eb4698f3 869static struct snd_kcontrol_new snd_p16v_volume_control_spdif_unknown =
1da177e4
LT		 870{
871 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3818152e 872 .name = "HD SPDIF Unknown Playback Volume",
1da177e4
LT		 873 .info = snd_p16v_volume_info,
874 .get = snd_p16v_volume_get_spdif_unknown,
875 .put = snd_p16v_volume_put_spdif_unknown
876};
877
eb4698f3 878static struct snd_kcontrol_new snd_p16v_volume_control_spdif_rear =
1da177e4
LT		 879{
880 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3818152e 881 .name = "HD SPDIF Rear Playback Volume",
1da177e4
LT		 882 .info = snd_p16v_volume_info,
883 .get = snd_p16v_volume_get_spdif_rear,
884 .put = snd_p16v_volume_put_spdif_rear
885};
886
eb4698f3 887static int snd_p16v_capture_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
6e4abc40
JCD		 888{
889 static char *texts[8] = { "SPDIF", "I2S", "SRC48", "SRCMulti_SPDIF", "SRCMulti_I2S", "CDIF", "FX", "AC97" };
890
891 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
892 uinfo->count = 1;
893 uinfo->value.enumerated.items = 8;
894 if (uinfo->value.enumerated.item > 7)
895 uinfo->value.enumerated.item = 7;
896 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
897 return 0;
898}
899
eb4698f3
TI		 900static int snd_p16v_capture_source_get(struct snd_kcontrol *kcontrol,
901 struct snd_ctl_elem_value *ucontrol)
6e4abc40 902{
eb4698f3 903 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
6e4abc40
JCD		 904
905 ucontrol->value.enumerated.item[0] = emu->p16v_capture_source;
906 return 0;
907}
908
eb4698f3
TI		 909static int snd_p16v_capture_source_put(struct snd_kcontrol *kcontrol,
910 struct snd_ctl_elem_value *ucontrol)
6e4abc40 911{
eb4698f3 912 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
6e4abc40
JCD		 913 unsigned int val;
914 int change = 0;
915 u32 mask;
916 u32 source;
917
918 val = ucontrol->value.enumerated.item[0] ;
919 change = (emu->p16v_capture_source != val);
920 if (change) {
921 emu->p16v_capture_source = val;
922 source = (val << 28) | (val << 24) | (val << 20) | (val << 16);
923 mask = snd_emu10k1_ptr20_read(emu, BASIC_INTERRUPT, 0) & 0xffff;
924 snd_emu10k1_ptr20_write(emu, BASIC_INTERRUPT, 0, source | mask);
925 }
926 return change;
927}
928
eb4698f3 929static struct snd_kcontrol_new snd_p16v_capture_source __devinitdata =
6e4abc40
JCD		 930{
931 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3818152e 932 .name = "HD source Capture",
6e4abc40
JCD		 933 .info = snd_p16v_capture_source_info,
934 .get = snd_p16v_capture_source_get,
935 .put = snd_p16v_capture_source_put
936};
f927c8fc 937
eb4698f3 938static int snd_p16v_capture_channel_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
f927c8fc
JCD		 939{
940 static char *texts[4] = { "0", "1", "2", "3", };
941
942 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
943 uinfo->count = 1;
944 uinfo->value.enumerated.items = 4;
945 if (uinfo->value.enumerated.item > 3)
946 uinfo->value.enumerated.item = 3;
947 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
948 return 0;
949}
950
eb4698f3
TI		 951static int snd_p16v_capture_channel_get(struct snd_kcontrol *kcontrol,
952 struct snd_ctl_elem_value *ucontrol)
f927c8fc 953{
eb4698f3 954 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
f927c8fc
JCD		 955
956 ucontrol->value.enumerated.item[0] = emu->p16v_capture_channel;
957 return 0;
958}
959
eb4698f3
TI		 960static int snd_p16v_capture_channel_put(struct snd_kcontrol *kcontrol,
961 struct snd_ctl_elem_value *ucontrol)
f927c8fc 962{
eb4698f3 963 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
f927c8fc
JCD		 964 unsigned int val;
965 int change = 0;
966 u32 tmp;
967
968 val = ucontrol->value.enumerated.item[0] ;
969 change = (emu->p16v_capture_channel != val);
970 if (change) {
971 emu->p16v_capture_channel = val;
972 tmp = snd_emu10k1_ptr20_read(emu, CAPTURE_P16V_SOURCE, 0) & 0xfffc;
973 snd_emu10k1_ptr20_write(emu, CAPTURE_P16V_SOURCE, 0, tmp | val);
974 }
975 return change;
976}
977
eb4698f3 978static struct snd_kcontrol_new snd_p16v_capture_channel __devinitdata =
f927c8fc
JCD		 979{
980 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3818152e 981 .name = "HD channel Capture",
f927c8fc
JCD		 982 .info = snd_p16v_capture_channel_info,
983 .get = snd_p16v_capture_channel_get,
984 .put = snd_p16v_capture_channel_put
985};
986
eb4698f3 987int snd_p16v_mixer(struct snd_emu10k1 *emu)
1da177e4
LT		 988{
989 int err;
eb4698f3
TI		 990 struct snd_kcontrol *kctl;
991 struct snd_card *card = emu->card;
1da177e4
LT		 992 if ((kctl = snd_ctl_new1(&snd_p16v_volume_control_analog_front, emu)) == NULL)
993 return -ENOMEM;
994 if ((err = snd_ctl_add(card, kctl)))
995 return err;
996 if ((kctl = snd_ctl_new1(&snd_p16v_volume_control_analog_rear, emu)) == NULL)
997 return -ENOMEM;
998 if ((err = snd_ctl_add(card, kctl)))
999 return err;
1000 if ((kctl = snd_ctl_new1(&snd_p16v_volume_control_analog_center_lfe, emu)) == NULL)
1001 return -ENOMEM;
1002 if ((err = snd_ctl_add(card, kctl)))
1003 return err;
1004 if ((kctl = snd_ctl_new1(&snd_p16v_volume_control_analog_unknown, emu)) == NULL)
1005 return -ENOMEM;
1006 if ((err = snd_ctl_add(card, kctl)))
1007 return err;
1008 if ((kctl = snd_ctl_new1(&snd_p16v_volume_control_spdif_front, emu)) == NULL)
1009 return -ENOMEM;
1010 if ((err = snd_ctl_add(card, kctl)))
1011 return err;
1012 if ((kctl = snd_ctl_new1(&snd_p16v_volume_control_spdif_rear, emu)) == NULL)
1013 return -ENOMEM;
1014 if ((err = snd_ctl_add(card, kctl)))
1015 return err;
1016 if ((kctl = snd_ctl_new1(&snd_p16v_volume_control_spdif_center_lfe, emu)) == NULL)
1017 return -ENOMEM;
1018 if ((err = snd_ctl_add(card, kctl)))
1019 return err;
1020 if ((kctl = snd_ctl_new1(&snd_p16v_volume_control_spdif_unknown, emu)) == NULL)
1021 return -ENOMEM;
1022 if ((err = snd_ctl_add(card, kctl)))
1023 return err;
6e4abc40
JCD		 1024 if ((kctl = snd_ctl_new1(&snd_p16v_capture_source, emu)) == NULL)
1025 return -ENOMEM;
1026 if ((err = snd_ctl_add(card, kctl)))
1027 return err;
f927c8fc
JCD		 1028 if ((kctl = snd_ctl_new1(&snd_p16v_capture_channel, emu)) == NULL)
1029 return -ENOMEM;
1030 if ((err = snd_ctl_add(card, kctl)))
1031 return err;
1da177e4
LT		 1032 return 0;
1033}
1034
09668b44
TI		 1035#ifdef CONFIG_PM
1036
1037#define NUM_CHS 1 /* up to 4, but only first channel is used */
1038
1039int __devinit snd_p16v_alloc_pm_buffer(struct snd_emu10k1 *emu)
1040{
1041 emu->p16v_saved = vmalloc(NUM_CHS * 4 * 0x80);
1042 if (! emu->p16v_saved)
1043 return -ENOMEM;
1044 return 0;
1045}
1046
1047void snd_p16v_free_pm_buffer(struct snd_emu10k1 *emu)
1048{
1049 vfree(emu->p16v_saved);
1050}
1051
1052void snd_p16v_suspend(struct snd_emu10k1 *emu)
1053{
1054 int i, ch;
1055 unsigned int *val;
1056
1057 val = emu->p16v_saved;
1058 for (ch = 0; ch < NUM_CHS; ch++)
1059 for (i = 0; i < 0x80; i++, val++)
1060 *val = snd_emu10k1_ptr20_read(emu, i, ch);
1061}
1062
1063void snd_p16v_resume(struct snd_emu10k1 *emu)
1064{
1065 int i, ch;
1066 unsigned int *val;
1067
1068 val = emu->p16v_saved;
1069 for (ch = 0; ch < NUM_CHS; ch++)
1070 for (i = 0; i < 0x80; i++, val++)
1071 snd_emu10k1_ptr20_write(emu, i, ch, *val);
1072}
1073#endif
Linux kernel - Deliverables
This page took 0.143186 seconds and 5 git commands to generate.