~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/pci/emu10k1/p16v.c

Version: ~ [ linux-5.11 ] ~ [ linux-5.10.17 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.99 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.176 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.221 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.257 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.257 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-or-later
  2 /*
  3  *  Copyright (c) by James Courtier-Dutton <James@superbug.demon.co.uk>
  4  *  Driver p16v chips
  5  *  Version: 0.25
  6  *
  7  *  FEATURES currently supported:
  8  *    Output fixed at S32_LE, 2 channel to hw:0,0
  9  *    Rates: 44.1, 48, 96, 192.
 10  *
 11  *  Changelog:
 12  *  0.8
 13  *    Use separate card based buffer for periods table.
 14  *  0.9
 15  *    Use 2 channel output streams instead of 8 channel.
 16  *       (8 channel output streams might be good for ASIO type output)
 17  *    Corrected speaker output, so Front -> Front etc.
 18  *  0.10
 19  *    Fixed missed interrupts.
 20  *  0.11
 21  *    Add Sound card model number and names.
 22  *    Add Analog volume controls.
 23  *  0.12
 24  *    Corrected playback interrupts. Now interrupt per period, instead of half period.
 25  *  0.13
 26  *    Use single trigger for multichannel.
 27  *  0.14
 28  *    Mic capture now works at fixed: S32_LE, 96000Hz, Stereo.
 29  *  0.15
 30  *    Force buffer_size / period_size == INTEGER.
 31  *  0.16
 32  *    Update p16v.c to work with changed alsa api.
 33  *  0.17
 34  *    Update p16v.c to work with changed alsa api. Removed boot_devs.
 35  *  0.18
 36  *    Merging with snd-emu10k1 driver.
 37  *  0.19
 38  *    One stereo channel at 24bit now works.
 39  *  0.20
 40  *    Added better register defines.
 41  *  0.21
 42  *    Integrated with snd-emu10k1 driver.
 43  *  0.22
 44  *    Removed #if 0 ... #endif
 45  *  0.23
 46  *    Implement different capture rates.
 47  *  0.24
 48  *    Implement different capture source channels.
 49  *    e.g. When HD Capture source is set to SPDIF,
 50  *    setting HD Capture channel to 0 captures from CDROM digital input.
 51  *    setting HD Capture channel to 1 captures from SPDIF in.
 52  *  0.25
 53  *    Include capture buffer sizes.
 54  *
 55  *  BUGS:
 56  *    Some stability problems when unloading the snd-p16v kernel module.
 57  *    --
 58  *
 59  *  TODO:
 60  *    SPDIF out.
 61  *    Find out how to change capture sample rates. E.g. To record SPDIF at 48000Hz.
 62  *    Currently capture fixed at 48000Hz.
 63  *
 64  *    --
 65  *  GENERAL INFO:
 66  *    Model: SB0240
 67  *    P16V Chip: CA0151-DBS
 68  *    Audigy 2 Chip: CA0102-IAT
 69  *    AC97 Codec: STAC 9721
 70  *    ADC: Philips 1361T (Stereo 24bit)
 71  *    DAC: CS4382-K (8-channel, 24bit, 192Khz)
 72  *
 73  *  This code was initially based on code from ALSA's emu10k1x.c which is:
 74  *  Copyright (c) by Francisco Moraes <fmoraes@nc.rr.com>
 75  */
 76 #include <linux/delay.h>
 77 #include <linux/init.h>
 78 #include <linux/interrupt.h>
 79 #include <linux/pci.h>
 80 #include <linux/slab.h>
 81 #include <linux/vmalloc.h>
 82 #include <linux/moduleparam.h>
 83 #include <sound/core.h>
 84 #include <sound/initval.h>
 85 #include <sound/pcm.h>
 86 #include <sound/ac97_codec.h>
 87 #include <sound/info.h>
 88 #include <sound/tlv.h>
 89 #include <sound/emu10k1.h>
 90 #include "p16v.h"
 91 
 92 #define SET_CHANNEL 0  /* Testing channel outputs 0=Front, 1=Center/LFE, 2=Unknown, 3=Rear */
 93 #define PCM_FRONT_CHANNEL 0
 94 #define PCM_REAR_CHANNEL 1
 95 #define PCM_CENTER_LFE_CHANNEL 2
 96 #define PCM_SIDE_CHANNEL 3
 97 #define CONTROL_FRONT_CHANNEL 0
 98 #define CONTROL_REAR_CHANNEL 3
 99 #define CONTROL_CENTER_LFE_CHANNEL 1
100 #define CONTROL_SIDE_CHANNEL 2
101 
102 /* Card IDs:
103  * Class 0401: 1102:0004 (rev 04) Subsystem: 1102:2002 -> Audigy2 ZS 7.1 Model:SB0350
104  * Class 0401: 1102:0004 (rev 04) Subsystem: 1102:1007 -> Audigy2 6.1    Model:SB0240
105  * Class 0401: 1102:0004 (rev 04) Subsystem: 1102:1002 -> Audigy2 Platinum  Model:SB msb0240230009266
106  * Class 0401: 1102:0004 (rev 04) Subsystem: 1102:2007 -> Audigy4 Pro Model:SB0380 M1SB0380472001901E
107  *
108  */
109 
110  /* hardware definition */
111 static const struct snd_pcm_hardware snd_p16v_playback_hw = {
112         .info =                 SNDRV_PCM_INFO_MMAP | 
113                                 SNDRV_PCM_INFO_INTERLEAVED |
114                                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
115                                 SNDRV_PCM_INFO_RESUME |
116                                 SNDRV_PCM_INFO_MMAP_VALID |
117                                 SNDRV_PCM_INFO_SYNC_START,
118         .formats =              SNDRV_PCM_FMTBIT_S32_LE, /* Only supports 24-bit samples padded to 32 bits. */
119         .rates =                SNDRV_PCM_RATE_192000 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_44100, 
120         .rate_min =             44100,
121         .rate_max =             192000,
122         .channels_min =         8, 
123         .channels_max =         8,
124         .buffer_bytes_max =     ((65536 - 64) * 8),
125         .period_bytes_min =     64,
126         .period_bytes_max =     (65536 - 64),
127         .periods_min =          2,
128         .periods_max =          8,
129         .fifo_size =            0,
130 };
131 
132 static const struct snd_pcm_hardware snd_p16v_capture_hw = {
133         .info =                 (SNDRV_PCM_INFO_MMAP |
134                                  SNDRV_PCM_INFO_INTERLEAVED |
135                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
136                                  SNDRV_PCM_INFO_RESUME |
137                                  SNDRV_PCM_INFO_MMAP_VALID),
138         .formats =              SNDRV_PCM_FMTBIT_S32_LE,
139         .rates =                SNDRV_PCM_RATE_192000 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_44100, 
140         .rate_min =             44100,
141         .rate_max =             192000,
142         .channels_min =         2,
143         .channels_max =         2,
144         .buffer_bytes_max =     (65536 - 64),
145         .period_bytes_min =     64,
146         .period_bytes_max =     (65536 - 128) >> 1,  /* size has to be N*64 bytes */
147         .periods_min =          2,
148         .periods_max =          2,
149         .fifo_size =            0,
150 };
151 
152 static void snd_p16v_pcm_free_substream(struct snd_pcm_runtime *runtime)
153 {
154         struct snd_emu10k1_pcm *epcm = runtime->private_data;
155 
156         kfree(epcm);
157 }
158 
159 /* open_playback callback */
160 static int snd_p16v_pcm_open_playback_channel(struct snd_pcm_substream *substream, int channel_id)
161 {
162         struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
163         struct snd_emu10k1_voice *channel = &(emu->p16v_voices[channel_id]);
164         struct snd_emu10k1_pcm *epcm;
165         struct snd_pcm_runtime *runtime = substream->runtime;
166         int err;
167 
168         epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
169         /* dev_dbg(emu->card->dev, "epcm kcalloc: %p\n", epcm); */
170 
171         if (epcm == NULL)
172                 return -ENOMEM;
173         epcm->emu = emu;
174         epcm->substream = substream;
175         /*
176         dev_dbg(emu->card->dev, "epcm device=%d, channel_id=%d\n",
177                    substream->pcm->device, channel_id);
178         */
179         runtime->private_data = epcm;
180         runtime->private_free = snd_p16v_pcm_free_substream;
181   
182         runtime->hw = snd_p16v_playback_hw;
183 
184         channel->emu = emu;
185         channel->number = channel_id;
186 
187         channel->use=1;
188 #if 0 /* debug */
189         dev_dbg(emu->card->dev,
190                    "p16v: open channel_id=%d, channel=%p, use=0x%x\n",
191                    channel_id, channel, channel->use);
192         dev_dbg(emu->card->dev, "open:channel_id=%d, chip=%p, channel=%p\n",
193                channel_id, chip, channel);
194 #endif /* debug */
195         /* channel->interrupt = snd_p16v_pcm_channel_interrupt; */
196         channel->epcm = epcm;
197         if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
198                 return err;
199 
200         runtime->sync.id32[0] = substream->pcm->card->number;
201         runtime->sync.id32[1] = 'P';
202         runtime->sync.id32[2] = 16;
203         runtime->sync.id32[3] = 'V';
204 
205         return 0;
206 }
207 /* open_capture callback */
208 static int snd_p16v_pcm_open_capture_channel(struct snd_pcm_substream *substream, int channel_id)
209 {
210         struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
211         struct snd_emu10k1_voice *channel = &(emu->p16v_capture_voice);
212         struct snd_emu10k1_pcm *epcm;
213         struct snd_pcm_runtime *runtime = substream->runtime;
214         int err;
215 
216         epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
217         /* dev_dbg(emu->card->dev, "epcm kcalloc: %p\n", epcm); */
218 
219         if (epcm == NULL)
220                 return -ENOMEM;
221         epcm->emu = emu;
222         epcm->substream = substream;
223         /*
224         dev_dbg(emu->card->dev, "epcm device=%d, channel_id=%d\n",
225                    substream->pcm->device, channel_id);
226         */
227         runtime->private_data = epcm;
228         runtime->private_free = snd_p16v_pcm_free_substream;
229   
230         runtime->hw = snd_p16v_capture_hw;
231 
232         channel->emu = emu;
233         channel->number = channel_id;
234 
235         channel->use=1;
236 #if 0 /* debug */
237         dev_dbg(emu->card->dev,
238                    "p16v: open channel_id=%d, channel=%p, use=0x%x\n",
239                    channel_id, channel, channel->use);
240         dev_dbg(emu->card->dev, "open:channel_id=%d, chip=%p, channel=%p\n",
241                channel_id, chip, channel);
242 #endif /* debug */
243         /* channel->interrupt = snd_p16v_pcm_channel_interrupt; */
244         channel->epcm = epcm;
245         if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
246                 return err;
247 
248         return 0;
249 }
250 
251 
252 /* close callback */
253 static int snd_p16v_pcm_close_playback(struct snd_pcm_substream *substream)
254 {
255         struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
256         //struct snd_pcm_runtime *runtime = substream->runtime;
257         //struct snd_emu10k1_pcm *epcm = runtime->private_data;
258         emu->p16v_voices[substream->pcm->device - emu->p16v_device_offset].use = 0;
259         /* FIXME: maybe zero others */
260         return 0;
261 }
262 
263 /* close callback */
264 static int snd_p16v_pcm_close_capture(struct snd_pcm_substream *substream)
265 {
266         struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
267         //struct snd_pcm_runtime *runtime = substream->runtime;
268         //struct snd_emu10k1_pcm *epcm = runtime->private_data;
269         emu->p16v_capture_voice.use = 0;
270         /* FIXME: maybe zero others */
271         return 0;
272 }
273 
274 static int snd_p16v_pcm_open_playback_front(struct snd_pcm_substream *substream)
275 {
276         return snd_p16v_pcm_open_playback_channel(substream, PCM_FRONT_CHANNEL);
277 }
278 
279 static int snd_p16v_pcm_open_capture(struct snd_pcm_substream *substream)
280 {
281         // Only using channel 0 for now, but the card has 2 channels.
282         return snd_p16v_pcm_open_capture_channel(substream, 0);
283 }
284 
285 /* hw_params callback */
286 static int snd_p16v_pcm_hw_params_playback(struct snd_pcm_substream *substream,
287                                       struct snd_pcm_hw_params *hw_params)
288 {
289         return snd_pcm_lib_malloc_pages(substream,
290                                         params_buffer_bytes(hw_params));
291 }
292 
293 /* hw_params callback */
294 static int snd_p16v_pcm_hw_params_capture(struct snd_pcm_substream *substream,
295                                       struct snd_pcm_hw_params *hw_params)
296 {
297         return snd_pcm_lib_malloc_pages(substream,
298                                         params_buffer_bytes(hw_params));
299 }
300 
301 
302 /* hw_free callback */
303 static int snd_p16v_pcm_hw_free_playback(struct snd_pcm_substream *substream)
304 {
305         return snd_pcm_lib_free_pages(substream);
306 }
307 
308 /* hw_free callback */
309 static int snd_p16v_pcm_hw_free_capture(struct snd_pcm_substream *substream)
310 {
311         return snd_pcm_lib_free_pages(substream);
312 }
313 
314 
315 /* prepare playback callback */
316 static int snd_p16v_pcm_prepare_playback(struct snd_pcm_substream *substream)
317 {
318         struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
319         struct snd_pcm_runtime *runtime = substream->runtime;
320         int channel = substream->pcm->device - emu->p16v_device_offset;
321         u32 *table_base = (u32 *)(emu->p16v_buffer.area+(8*16*channel));
322         u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size);
323         int i;
324         u32 tmp;
325         
326 #if 0 /* debug */
327         dev_dbg(emu->card->dev,
328                 "prepare:channel_number=%d, rate=%d, "
329                    "format=0x%x, channels=%d, buffer_size=%ld, "
330                    "period_size=%ld, periods=%u, frames_to_bytes=%d\n",
331                    channel, runtime->rate, runtime->format, runtime->channels,
332                    runtime->buffer_size, runtime->period_size,
333                    runtime->periods, frames_to_bytes(runtime, 1));
334         dev_dbg(emu->card->dev,
335                 "dma_addr=%x, dma_area=%p, table_base=%p\n",
336                    runtime->dma_addr, runtime->dma_area, table_base);
337         dev_dbg(emu->card->dev,
338                 "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
339                    emu->p16v_buffer.addr, emu->p16v_buffer.area,
340                    emu->p16v_buffer.bytes);
341 #endif /* debug */
342         tmp = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, channel);
343         switch (runtime->rate) {
344         case 44100:
345           snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, channel, (tmp & ~0xe0e0) | 0x8080);
346           break;
347         case 96000:
348           snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, channel, (tmp & ~0xe0e0) | 0x4040);
349           break;
350         case 192000:
351           snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, channel, (tmp & ~0xe0e0) | 0x2020);
352           break;
353         case 48000:
354         default:
355           snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, channel, (tmp & ~0xe0e0) | 0x0000);
356           break;
357         }
358         /* FIXME: Check emu->buffer.size before actually writing to it. */
359         for(i = 0; i < runtime->periods; i++) {
360                 table_base[i*2]=runtime->dma_addr+(i*period_size_bytes);
361                 table_base[(i*2)+1]=period_size_bytes<<16;
362         }
363  
364         snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_ADDR, channel, emu->p16v_buffer.addr+(8*16*channel));
365         snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_SIZE, channel, (runtime->periods - 1) << 19);
366         snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_PTR, channel, 0);
367         snd_emu10k1_ptr20_write(emu, PLAYBACK_DMA_ADDR, channel, runtime->dma_addr);
368         //snd_emu10k1_ptr20_write(emu, PLAYBACK_PERIOD_SIZE, channel, frames_to_bytes(runtime, runtime->period_size)<<16); // buffer size in bytes
369         snd_emu10k1_ptr20_write(emu, PLAYBACK_PERIOD_SIZE, channel, 0); // buffer size in bytes
370         snd_emu10k1_ptr20_write(emu, PLAYBACK_POINTER, channel, 0);
371         snd_emu10k1_ptr20_write(emu, 0x07, channel, 0x0);
372         snd_emu10k1_ptr20_write(emu, 0x08, channel, 0);
373 
374         return 0;
375 }
376 
377 /* prepare capture callback */
378 static int snd_p16v_pcm_prepare_capture(struct snd_pcm_substream *substream)
379 {
380         struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
381         struct snd_pcm_runtime *runtime = substream->runtime;
382         int channel = substream->pcm->device - emu->p16v_device_offset;
383         u32 tmp;
384 
385         /*
386         dev_dbg(emu->card->dev, "prepare capture:channel_number=%d, rate=%d, "
387                "format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, "
388                "frames_to_bytes=%d\n",
389                channel, runtime->rate, runtime->format, runtime->channels,
390                runtime->buffer_size, runtime->period_size,
391                frames_to_bytes(runtime, 1));
392         */
393         tmp = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, channel);
394         switch (runtime->rate) {
395         case 44100:
396           snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, channel, (tmp & ~0x0e00) | 0x0800);
397           break;
398         case 96000:
399           snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, channel, (tmp & ~0x0e00) | 0x0400);
400           break;
401         case 192000:
402           snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, channel, (tmp & ~0x0e00) | 0x0200);
403           break;
404         case 48000:
405         default:
406           snd_emu10k1_ptr_write(emu, A_SPDIF_SAMPLERATE, channel, (tmp & ~0x0e00) | 0x0000);
407           break;
408         }
409         /* FIXME: Check emu->buffer.size before actually writing to it. */
410         snd_emu10k1_ptr20_write(emu, 0x13, channel, 0);
411         snd_emu10k1_ptr20_write(emu, CAPTURE_DMA_ADDR, channel, runtime->dma_addr);
412         snd_emu10k1_ptr20_write(emu, CAPTURE_BUFFER_SIZE, channel, frames_to_bytes(runtime, runtime->buffer_size) << 16); // buffer size in bytes
413         snd_emu10k1_ptr20_write(emu, CAPTURE_POINTER, channel, 0);
414         //snd_emu10k1_ptr20_write(emu, CAPTURE_SOURCE, 0x0, 0x333300e4); /* Select MIC or Line in */
415         //snd_emu10k1_ptr20_write(emu, EXTENDED_INT_MASK, 0, snd_emu10k1_ptr20_read(emu, EXTENDED_INT_MASK, 0) | (0x110000<<channel));
416 
417         return 0;
418 }
419 
420 static void snd_p16v_intr_enable(struct snd_emu10k1 *emu, unsigned int intrenb)
421 {
422         unsigned long flags;
423         unsigned int enable;
424 
425         spin_lock_irqsave(&emu->emu_lock, flags);
426         enable = inl(emu->port + INTE2) | intrenb;
427         outl(enable, emu->port + INTE2);
428         spin_unlock_irqrestore(&emu->emu_lock, flags);
429 }
430 
431 static void snd_p16v_intr_disable(struct snd_emu10k1 *emu, unsigned int intrenb)
432 {
433         unsigned long flags;
434         unsigned int disable;
435 
436         spin_lock_irqsave(&emu->emu_lock, flags);
437         disable = inl(emu->port + INTE2) & (~intrenb);
438         outl(disable, emu->port + INTE2);
439         spin_unlock_irqrestore(&emu->emu_lock, flags);
440 }
441 
442 /* trigger_playback callback */
443 static int snd_p16v_pcm_trigger_playback(struct snd_pcm_substream *substream,
444                                     int cmd)
445 {
446         struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
447         struct snd_pcm_runtime *runtime;
448         struct snd_emu10k1_pcm *epcm;
449         int channel;
450         int result = 0;
451         struct snd_pcm_substream *s;
452         u32 basic = 0;
453         u32 inte = 0;
454         int running = 0;
455 
456         switch (cmd) {
457         case SNDRV_PCM_TRIGGER_START:
458                 running=1;
459                 break;
460         case SNDRV_PCM_TRIGGER_STOP:
461         default:
462                 running = 0;
463                 break;
464         }
465         snd_pcm_group_for_each_entry(s, substream) {
466                 if (snd_pcm_substream_chip(s) != emu ||
467                     s->stream != SNDRV_PCM_STREAM_PLAYBACK)
468                         continue;
469                 runtime = s->runtime;
470                 epcm = runtime->private_data;
471                 channel = substream->pcm->device-emu->p16v_device_offset;
472                 /* dev_dbg(emu->card->dev, "p16v channel=%d\n", channel); */
473                 epcm->running = running;
474                 basic |= (0x1<<channel);
475                 inte |= (INTE2_PLAYBACK_CH_0_LOOP<<channel);
476                 snd_pcm_trigger_done(s, substream);
477         }
478         /* dev_dbg(emu->card->dev, "basic=0x%x, inte=0x%x\n", basic, inte); */
479 
480         switch (cmd) {
481         case SNDRV_PCM_TRIGGER_START:
482                 snd_p16v_intr_enable(emu, inte);
483                 snd_emu10k1_ptr20_write(emu, BASIC_INTERRUPT, 0, snd_emu10k1_ptr20_read(emu, BASIC_INTERRUPT, 0)| (basic));
484                 break;
485         case SNDRV_PCM_TRIGGER_STOP:
486                 snd_emu10k1_ptr20_write(emu, BASIC_INTERRUPT, 0, snd_emu10k1_ptr20_read(emu, BASIC_INTERRUPT, 0) & ~(basic));
487                 snd_p16v_intr_disable(emu, inte);
488                 break;
489         default:
490                 result = -EINVAL;
491                 break;
492         }
493         return result;
494 }
495 
496 /* trigger_capture callback */
497 static int snd_p16v_pcm_trigger_capture(struct snd_pcm_substream *substream,
498                                    int cmd)
499 {
500         struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
501         struct snd_pcm_runtime *runtime = substream->runtime;
502         struct snd_emu10k1_pcm *epcm = runtime->private_data;
503         int channel = 0;
504         int result = 0;
505         u32 inte = INTE2_CAPTURE_CH_0_LOOP | INTE2_CAPTURE_CH_0_HALF_LOOP;
506 
507         switch (cmd) {
508         case SNDRV_PCM_TRIGGER_START:
509                 snd_p16v_intr_enable(emu, inte);
510                 snd_emu10k1_ptr20_write(emu, BASIC_INTERRUPT, 0, snd_emu10k1_ptr20_read(emu, BASIC_INTERRUPT, 0)|(0x100<<channel));
511                 epcm->running = 1;
512                 break;
513         case SNDRV_PCM_TRIGGER_STOP:
514                 snd_emu10k1_ptr20_write(emu, BASIC_INTERRUPT, 0, snd_emu10k1_ptr20_read(emu, BASIC_INTERRUPT, 0) & ~(0x100<<channel));
515                 snd_p16v_intr_disable(emu, inte);
516                 //snd_emu10k1_ptr20_write(emu, EXTENDED_INT_MASK, 0, snd_emu10k1_ptr20_read(emu, EXTENDED_INT_MASK, 0) & ~(0x110000<<channel));
517                 epcm->running = 0;
518                 break;
519         default:
520                 result = -EINVAL;
521                 break;
522         }
523         return result;
524 }
525 
526 /* pointer_playback callback */
527 static snd_pcm_uframes_t
528 snd_p16v_pcm_pointer_playback(struct snd_pcm_substream *substream)
529 {
530         struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
531         struct snd_pcm_runtime *runtime = substream->runtime;
532         struct snd_emu10k1_pcm *epcm = runtime->private_data;
533         snd_pcm_uframes_t ptr, ptr1, ptr2,ptr3,ptr4 = 0;
534         int channel = substream->pcm->device - emu->p16v_device_offset;
535         if (!epcm->running)
536                 return 0;
537 
538         ptr3 = snd_emu10k1_ptr20_read(emu, PLAYBACK_LIST_PTR, channel);
539         ptr1 = snd_emu10k1_ptr20_read(emu, PLAYBACK_POINTER, channel);
540         ptr4 = snd_emu10k1_ptr20_read(emu, PLAYBACK_LIST_PTR, channel);
541         if (ptr3 != ptr4) ptr1 = snd_emu10k1_ptr20_read(emu, PLAYBACK_POINTER, channel);
542         ptr2 = bytes_to_frames(runtime, ptr1);
543         ptr2+= (ptr4 >> 3) * runtime->period_size;
544         ptr=ptr2;
545         if (ptr >= runtime->buffer_size)
546                 ptr -= runtime->buffer_size;
547 
548         return ptr;
549 }
550 
551 /* pointer_capture callback */
552 static snd_pcm_uframes_t
553 snd_p16v_pcm_pointer_capture(struct snd_pcm_substream *substream)
554 {
555         struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
556         struct snd_pcm_runtime *runtime = substream->runtime;
557         struct snd_emu10k1_pcm *epcm = runtime->private_data;
558         snd_pcm_uframes_t ptr, ptr1, ptr2 = 0;
559         int channel = 0;
560 
561         if (!epcm->running)
562                 return 0;
563 
564         ptr1 = snd_emu10k1_ptr20_read(emu, CAPTURE_POINTER, channel);
565         ptr2 = bytes_to_frames(runtime, ptr1);
566         ptr=ptr2;
567         if (ptr >= runtime->buffer_size) {
568                 ptr -= runtime->buffer_size;
569                 dev_warn(emu->card->dev, "buffer capture limited!\n");
570         }
571         /*
572         dev_dbg(emu->card->dev, "ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, "
573                "buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n",
574                ptr1, ptr2, ptr, (int)runtime->buffer_size,
575                (int)runtime->period_size, (int)runtime->frame_bits,
576                (int)runtime->rate);
577         */
578         return ptr;
579 }
580 
581 /* operators */
582 static const struct snd_pcm_ops snd_p16v_playback_front_ops = {
583         .open =        snd_p16v_pcm_open_playback_front,
584         .close =       snd_p16v_pcm_close_playback,
585         .ioctl =       snd_pcm_lib_ioctl,
586         .hw_params =   snd_p16v_pcm_hw_params_playback,
587         .hw_free =     snd_p16v_pcm_hw_free_playback,
588         .prepare =     snd_p16v_pcm_prepare_playback,
589         .trigger =     snd_p16v_pcm_trigger_playback,
590         .pointer =     snd_p16v_pcm_pointer_playback,
591 };
592 
593 static const struct snd_pcm_ops snd_p16v_capture_ops = {
594         .open =        snd_p16v_pcm_open_capture,
595         .close =       snd_p16v_pcm_close_capture,
596         .ioctl =       snd_pcm_lib_ioctl,
597         .hw_params =   snd_p16v_pcm_hw_params_capture,
598         .hw_free =     snd_p16v_pcm_hw_free_capture,
599         .prepare =     snd_p16v_pcm_prepare_capture,
600         .trigger =     snd_p16v_pcm_trigger_capture,
601         .pointer =     snd_p16v_pcm_pointer_capture,
602 };
603 
604 
605 int snd_p16v_free(struct snd_emu10k1 *chip)
606 {
607         // release the data
608         if (chip->p16v_buffer.area) {
609                 snd_dma_free_pages(&chip->p16v_buffer);
610                 /*
611                 dev_dbg(chip->card->dev, "period lables free: %p\n",
612                            &chip->p16v_buffer);
613                 */
614         }
615         return 0;
616 }
617 
618 int snd_p16v_pcm(struct snd_emu10k1 *emu, int device)
619 {
620         struct snd_pcm *pcm;
621         struct snd_pcm_substream *substream;
622         int err;
623         int capture=1;
624   
625         /* dev_dbg(emu->card->dev, "snd_p16v_pcm called. device=%d\n", device); */
626         emu->p16v_device_offset = device;
627 
628         if ((err = snd_pcm_new(emu->card, "p16v", device, 1, capture, &pcm)) < 0)
629                 return err;
630   
631         pcm->private_data = emu;
632         // Single playback 8 channel device.
633         // Single capture 2 channel device.
634         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_p16v_playback_front_ops);
635         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_p16v_capture_ops);
636 
637         pcm->info_flags = 0;
638         pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
639         strcpy(pcm->name, "p16v");
640         emu->pcm_p16v = pcm;
641 
642         for(substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; 
643             substream; 
644             substream = substream->next) {
645                 snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV,
646                                               snd_dma_pci_data(emu->pci),
647                                               (65536 - 64) * 8,
648                                               (65536 - 64) * 8);
649                 /*
650                 dev_dbg(emu->card->dev,
651                            "preallocate playback substream: err=%d\n", err);
652                 */
653         }
654 
655         for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream; 
656               substream; 
657               substream = substream->next) {
658                 snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV,
659                                               snd_dma_pci_data(emu->pci),
660                                               65536 - 64, 65536 - 64);
661                 /*
662                 dev_dbg(emu->card->dev,
663                            "preallocate capture substream: err=%d\n", err);
664                 */
665         }
666   
667         return 0;
668 }
669 
670 static int snd_p16v_volume_info(struct snd_kcontrol *kcontrol,
671                                 struct snd_ctl_elem_info *uinfo)
672 {
673         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
674         uinfo->count = 2;
675         uinfo->value.integer.min = 0;
676         uinfo->value.integer.max = 255;
677         return 0;
678 }
679 
680 static int snd_p16v_volume_get(struct snd_kcontrol *kcontrol,
681                                struct snd_ctl_elem_value *ucontrol)
682 {
683         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
684         int high_low = (kcontrol->private_value >> 8) & 0xff;
685         int reg = kcontrol->private_value & 0xff;
686         u32 value;
687 
688         value = snd_emu10k1_ptr20_read(emu, reg, high_low);
689         if (high_low) {
690                 ucontrol->value.integer.value[0] = 0xff - ((value >> 24) & 0xff); /* Left */
691                 ucontrol->value.integer.value[1] = 0xff - ((value >> 16) & 0xff); /* Right */
692         } else {
693                 ucontrol->value.integer.value[0] = 0xff - ((value >> 8) & 0xff); /* Left */
694                 ucontrol->value.integer.value[1] = 0xff - ((value >> 0) & 0xff); /* Right */
695         }
696         return 0;
697 }
698 
699 static int snd_p16v_volume_put(struct snd_kcontrol *kcontrol,
700                                struct snd_ctl_elem_value *ucontrol)
701 {
702         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
703         int high_low = (kcontrol->private_value >> 8) & 0xff;
704         int reg = kcontrol->private_value & 0xff;
705         u32 value, oval;
706 
707         oval = value = snd_emu10k1_ptr20_read(emu, reg, 0);
708         if (high_low == 1) {
709                 value &= 0xffff;
710                 value |= ((0xff - ucontrol->value.integer.value[0]) << 24) |
711                         ((0xff - ucontrol->value.integer.value[1]) << 16);
712         } else {
713                 value &= 0xffff0000;
714                 value |= ((0xff - ucontrol->value.integer.value[0]) << 8) |
715                         ((0xff - ucontrol->value.integer.value[1]) );
716         }
717         if (value != oval) {
718                 snd_emu10k1_ptr20_write(emu, reg, 0, value);
719                 return 1;
720         }
721         return 0;
722 }
723 
724 static int snd_p16v_capture_source_info(struct snd_kcontrol *kcontrol,
725                                         struct snd_ctl_elem_info *uinfo)
726 {
727         static const char * const texts[8] = {
728                 "SPDIF", "I2S", "SRC48", "SRCMulti_SPDIF", "SRCMulti_I2S",
729                 "CDIF", "FX", "AC97"
730         };
731 
732         return snd_ctl_enum_info(uinfo, 1, 8, texts);
733 }
734 
735 static int snd_p16v_capture_source_get(struct snd_kcontrol *kcontrol,
736                                         struct snd_ctl_elem_value *ucontrol)
737 {
738         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
739 
740         ucontrol->value.enumerated.item[0] = emu->p16v_capture_source;
741         return 0;
742 }
743 
744 static int snd_p16v_capture_source_put(struct snd_kcontrol *kcontrol,
745                                         struct snd_ctl_elem_value *ucontrol)
746 {
747         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
748         unsigned int val;
749         int change = 0;
750         u32 mask;
751         u32 source;
752 
753         val = ucontrol->value.enumerated.item[0] ;
754         if (val > 7)
755                 return -EINVAL;
756         change = (emu->p16v_capture_source != val);
757         if (change) {
758                 emu->p16v_capture_source = val;
759                 source = (val << 28) | (val << 24) | (val << 20) | (val << 16);
760                 mask = snd_emu10k1_ptr20_read(emu, BASIC_INTERRUPT, 0) & 0xffff;
761                 snd_emu10k1_ptr20_write(emu, BASIC_INTERRUPT, 0, source | mask);
762         }
763         return change;
764 }
765 
766 static int snd_p16v_capture_channel_info(struct snd_kcontrol *kcontrol,
767                                          struct snd_ctl_elem_info *uinfo)
768 {
769         static const char * const texts[4] = { "", "1", "2", "3", };
770 
771         return snd_ctl_enum_info(uinfo, 1, 4, texts);
772 }
773 
774 static int snd_p16v_capture_channel_get(struct snd_kcontrol *kcontrol,
775                                         struct snd_ctl_elem_value *ucontrol)
776 {
777         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
778 
779         ucontrol->value.enumerated.item[0] = emu->p16v_capture_channel;
780         return 0;
781 }
782 
783 static int snd_p16v_capture_channel_put(struct snd_kcontrol *kcontrol,
784                                         struct snd_ctl_elem_value *ucontrol)
785 {
786         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
787         unsigned int val;
788         int change = 0;
789         u32 tmp;
790 
791         val = ucontrol->value.enumerated.item[0] ;
792         if (val > 3)
793                 return -EINVAL;
794         change = (emu->p16v_capture_channel != val);
795         if (change) {
796                 emu->p16v_capture_channel = val;
797                 tmp = snd_emu10k1_ptr20_read(emu, CAPTURE_P16V_SOURCE, 0) & 0xfffc;
798                 snd_emu10k1_ptr20_write(emu, CAPTURE_P16V_SOURCE, 0, tmp | val);
799         }
800         return change;
801 }
802 static const DECLARE_TLV_DB_SCALE(snd_p16v_db_scale1, -5175, 25, 1);
803 
804 #define P16V_VOL(xname,xreg,xhl) { \
805         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
806         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |             \
807                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,               \
808         .info = snd_p16v_volume_info, \
809         .get = snd_p16v_volume_get, \
810         .put = snd_p16v_volume_put, \
811         .tlv = { .p = snd_p16v_db_scale1 },     \
812         .private_value = ((xreg) | ((xhl) << 8)) \
813 }
814 
815 static struct snd_kcontrol_new p16v_mixer_controls[] = {
816         P16V_VOL("HD Analog Front Playback Volume", PLAYBACK_VOLUME_MIXER9, 0),
817         P16V_VOL("HD Analog Rear Playback Volume", PLAYBACK_VOLUME_MIXER10, 1),
818         P16V_VOL("HD Analog Center/LFE Playback Volume", PLAYBACK_VOLUME_MIXER9, 1),
819         P16V_VOL("HD Analog Side Playback Volume", PLAYBACK_VOLUME_MIXER10, 0),
820         P16V_VOL("HD SPDIF Front Playback Volume", PLAYBACK_VOLUME_MIXER7, 0),
821         P16V_VOL("HD SPDIF Rear Playback Volume", PLAYBACK_VOLUME_MIXER8, 1),
822         P16V_VOL("HD SPDIF Center/LFE Playback Volume", PLAYBACK_VOLUME_MIXER7, 1),
823         P16V_VOL("HD SPDIF Side Playback Volume", PLAYBACK_VOLUME_MIXER8, 0),
824         {
825                 .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
826                 .name =         "HD source Capture",
827                 .info =         snd_p16v_capture_source_info,
828                 .get =          snd_p16v_capture_source_get,
829                 .put =          snd_p16v_capture_source_put
830         },
831         {
832                 .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
833                 .name =         "HD channel Capture",
834                 .info =         snd_p16v_capture_channel_info,
835                 .get =          snd_p16v_capture_channel_get,
836                 .put =          snd_p16v_capture_channel_put
837         },
838 };
839 
840 
841 int snd_p16v_mixer(struct snd_emu10k1 *emu)
842 {
843         int i, err;
844         struct snd_card *card = emu->card;
845 
846         for (i = 0; i < ARRAY_SIZE(p16v_mixer_controls); i++) {
847                 if ((err = snd_ctl_add(card, snd_ctl_new1(&p16v_mixer_controls[i],
848                                                           emu))) < 0)
849                         return err;
850         }
851         return 0;
852 }
853 
854 #ifdef CONFIG_PM_SLEEP
855 
856 #define NUM_CHS 1       /* up to 4, but only first channel is used */
857 
858 int snd_p16v_alloc_pm_buffer(struct snd_emu10k1 *emu)
859 {
860         emu->p16v_saved = vmalloc(array_size(NUM_CHS * 4, 0x80));
861         if (! emu->p16v_saved)
862                 return -ENOMEM;
863         return 0;
864 }
865 
866 void snd_p16v_free_pm_buffer(struct snd_emu10k1 *emu)
867 {
868         vfree(emu->p16v_saved);
869 }
870 
871 void snd_p16v_suspend(struct snd_emu10k1 *emu)
872 {
873         int i, ch;
874         unsigned int *val;
875 
876         val = emu->p16v_saved;
877         for (ch = 0; ch < NUM_CHS; ch++)
878                 for (i = 0; i < 0x80; i++, val++)
879                         *val = snd_emu10k1_ptr20_read(emu, i, ch);
880 }
881 
882 void snd_p16v_resume(struct snd_emu10k1 *emu)
883 {
884         int i, ch;
885         unsigned int *val;
886 
887         val = emu->p16v_saved;
888         for (ch = 0; ch < NUM_CHS; ch++)
889                 for (i = 0; i < 0x80; i++, val++)
890                         snd_emu10k1_ptr20_write(emu, i, ch, *val);
891 }
892 #endif
893 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp