1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (c) by Francisco Moraes <fmoraes@nc.rr.com>
4 * Driver EMU10K1X chips
5 *
6 * Parts of this code were adapted from audigyls.c driver which is
7 * Copyright (c) by James Courtier-Dutton <James@superbug.demon.co.uk>
8 *
9 * BUGS:
10 * --
11 *
12 * TODO:
13 *
14 * Chips (SB0200 model):
15 * - EMU10K1X-DBQ
16 * - STAC 9708T
17 */
18#include <linux/init.h>
19#include <linux/interrupt.h>
20#include <linux/pci.h>
21#include <linux/dma-mapping.h>
22#include <linux/slab.h>
23#include <linux/string.h>
24#include <linux/module.h>
25#include <sound/core.h>
26#include <sound/initval.h>
27#include <sound/pcm.h>
28#include <sound/ac97_codec.h>
29#include <sound/info.h>
30#include <sound/rawmidi.h>
31
32MODULE_AUTHOR("Francisco Moraes <fmoraes@nc.rr.com>");
33MODULE_DESCRIPTION("EMU10K1X");
34MODULE_LICENSE("GPL");
35
36// module parameters (see "Module Parameters")
37static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
38static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
39static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
40
41module_param_array(index, int, NULL, 0444);
42MODULE_PARM_DESC(index, "Index value for the EMU10K1X soundcard.");
43module_param_array(id, charp, NULL, 0444);
44MODULE_PARM_DESC(id, "ID string for the EMU10K1X soundcard.");
45module_param_array(enable, bool, NULL, 0444);
46MODULE_PARM_DESC(enable, "Enable the EMU10K1X soundcard.");
47
48
49// some definitions were borrowed from emu10k1 driver as they seem to be the same
50/************************************************************************************************/
51/* PCI function 0 registers, address = <val> + PCIBASE0 */
52/************************************************************************************************/
53
54#define PTR 0x00 /* Indexed register set pointer register */
55 /* NOTE: The CHANNELNUM and ADDRESS words can */
56 /* be modified independently of each other. */
57
58#define DATA 0x04 /* Indexed register set data register */
59
60#define IPR 0x08 /* Global interrupt pending register */
61 /* Clear pending interrupts by writing a 1 to */
62 /* the relevant bits and zero to the other bits */
63#define IPR_MIDITRANSBUFEMPTY 0x00000001 /* MIDI UART transmit buffer empty */
64#define IPR_MIDIRECVBUFEMPTY 0x00000002 /* MIDI UART receive buffer empty */
65#define IPR_CH_0_LOOP 0x00000800 /* Channel 0 loop */
66#define IPR_CH_0_HALF_LOOP 0x00000100 /* Channel 0 half loop */
67#define IPR_CAP_0_LOOP 0x00080000 /* Channel capture loop */
68#define IPR_CAP_0_HALF_LOOP 0x00010000 /* Channel capture half loop */
69
70#define INTE 0x0c /* Interrupt enable register */
71#define INTE_MIDITXENABLE 0x00000001 /* Enable MIDI transmit-buffer-empty interrupts */
72#define INTE_MIDIRXENABLE 0x00000002 /* Enable MIDI receive-buffer-empty interrupts */
73#define INTE_CH_0_LOOP 0x00000800 /* Channel 0 loop */
74#define INTE_CH_0_HALF_LOOP 0x00000100 /* Channel 0 half loop */
75#define INTE_CAP_0_LOOP 0x00080000 /* Channel capture loop */
76#define INTE_CAP_0_HALF_LOOP 0x00010000 /* Channel capture half loop */
77
78#define HCFG 0x14 /* Hardware config register */
79
80#define HCFG_LOCKSOUNDCACHE 0x00000008 /* 1 = Cancel bustmaster accesses to soundcache */
81 /* NOTE: This should generally never be used. */
82#define HCFG_AUDIOENABLE 0x00000001 /* 0 = CODECs transmit zero-valued samples */
83 /* Should be set to 1 when the EMU10K1 is */
84 /* completely initialized. */
85#define GPIO 0x18 /* Defaults: 00001080-Analog, 00001000-SPDIF. */
86
87
88#define AC97DATA 0x1c /* AC97 register set data register (16 bit) */
89
90#define AC97ADDRESS 0x1e /* AC97 register set address register (8 bit) */
91
92/********************************************************************************************************/
93/* Emu10k1x pointer-offset register set, accessed through the PTR and DATA registers */
94/********************************************************************************************************/
95#define PLAYBACK_LIST_ADDR 0x00 /* Base DMA address of a list of pointers to each period/size */
96 /* One list entry: 4 bytes for DMA address,
97 * 4 bytes for period_size << 16.
98 * One list entry is 8 bytes long.
99 * One list entry for each period in the buffer.
100 */
101#define PLAYBACK_LIST_SIZE 0x01 /* Size of list in bytes << 16. E.g. 8 periods -> 0x00380000 */
102#define PLAYBACK_LIST_PTR 0x02 /* Pointer to the current period being played */
103#define PLAYBACK_DMA_ADDR 0x04 /* Playback DMA address */
104#define PLAYBACK_PERIOD_SIZE 0x05 /* Playback period size */
105#define PLAYBACK_POINTER 0x06 /* Playback period pointer. Sample currently in DAC */
106#define PLAYBACK_UNKNOWN1 0x07
107#define PLAYBACK_UNKNOWN2 0x08
108
109/* Only one capture channel supported */
110#define CAPTURE_DMA_ADDR 0x10 /* Capture DMA address */
111#define CAPTURE_BUFFER_SIZE 0x11 /* Capture buffer size */
112#define CAPTURE_POINTER 0x12 /* Capture buffer pointer. Sample currently in ADC */
113#define CAPTURE_UNKNOWN 0x13
114
115/* From 0x20 - 0x3f, last samples played on each channel */
116
117#define TRIGGER_CHANNEL 0x40 /* Trigger channel playback */
118#define TRIGGER_CHANNEL_0 0x00000001 /* Trigger channel 0 */
119#define TRIGGER_CHANNEL_1 0x00000002 /* Trigger channel 1 */
120#define TRIGGER_CHANNEL_2 0x00000004 /* Trigger channel 2 */
121#define TRIGGER_CAPTURE 0x00000100 /* Trigger capture channel */
122
123#define ROUTING 0x41 /* Setup sound routing ? */
124#define ROUTING_FRONT_LEFT 0x00000001
125#define ROUTING_FRONT_RIGHT 0x00000002
126#define ROUTING_REAR_LEFT 0x00000004
127#define ROUTING_REAR_RIGHT 0x00000008
128#define ROUTING_CENTER_LFE 0x00010000
129
130#define SPCS0 0x42 /* SPDIF output Channel Status 0 register */
131
132#define SPCS1 0x43 /* SPDIF output Channel Status 1 register */
133
134#define SPCS2 0x44 /* SPDIF output Channel Status 2 register */
135
136#define SPCS_CLKACCYMASK 0x30000000 /* Clock accuracy */
137#define SPCS_CLKACCY_1000PPM 0x00000000 /* 1000 parts per million */
138#define SPCS_CLKACCY_50PPM 0x10000000 /* 50 parts per million */
139#define SPCS_CLKACCY_VARIABLE 0x20000000 /* Variable accuracy */
140#define SPCS_SAMPLERATEMASK 0x0f000000 /* Sample rate */
141#define SPCS_SAMPLERATE_44 0x00000000 /* 44.1kHz sample rate */
142#define SPCS_SAMPLERATE_48 0x02000000 /* 48kHz sample rate */
143#define SPCS_SAMPLERATE_32 0x03000000 /* 32kHz sample rate */
144#define SPCS_CHANNELNUMMASK 0x00f00000 /* Channel number */
145#define SPCS_CHANNELNUM_UNSPEC 0x00000000 /* Unspecified channel number */
146#define SPCS_CHANNELNUM_LEFT 0x00100000 /* Left channel */
147#define SPCS_CHANNELNUM_RIGHT 0x00200000 /* Right channel */
148#define SPCS_SOURCENUMMASK 0x000f0000 /* Source number */
149#define SPCS_SOURCENUM_UNSPEC 0x00000000 /* Unspecified source number */
150#define SPCS_GENERATIONSTATUS 0x00008000 /* Originality flag (see IEC-958 spec) */
151#define SPCS_CATEGORYCODEMASK 0x00007f00 /* Category code (see IEC-958 spec) */
152#define SPCS_MODEMASK 0x000000c0 /* Mode (see IEC-958 spec) */
153#define SPCS_EMPHASISMASK 0x00000038 /* Emphasis */
154#define SPCS_EMPHASIS_NONE 0x00000000 /* No emphasis */
155#define SPCS_EMPHASIS_50_15 0x00000008 /* 50/15 usec 2 channel */
156#define SPCS_COPYRIGHT 0x00000004 /* Copyright asserted flag -- do not modify */
157#define SPCS_NOTAUDIODATA 0x00000002 /* 0 = Digital audio, 1 = not audio */
158#define SPCS_PROFESSIONAL 0x00000001 /* 0 = Consumer (IEC-958), 1 = pro (AES3-1992) */
159
160#define SPDIF_SELECT 0x45 /* Enables SPDIF or Analogue outputs 0-Analogue, 0x700-SPDIF */
161
162/* This is the MPU port on the card */
163#define MUDATA 0x47
164#define MUCMD 0x48
165#define MUSTAT MUCMD
166
167/* From 0x50 - 0x5f, last samples captured */
168
169/*
170 * The hardware has 3 channels for playback and 1 for capture.
171 * - channel 0 is the front channel
172 * - channel 1 is the rear channel
173 * - channel 2 is the center/lfe channel
174 * Volume is controlled by the AC97 for the front and rear channels by
175 * the PCM Playback Volume, Sigmatel Surround Playback Volume and
176 * Surround Playback Volume. The Sigmatel 4-Speaker Stereo switch affects
177 * the front/rear channel mixing in the REAR OUT jack. When using the
178 * 4-Speaker Stereo, both front and rear channels will be mixed in the
179 * REAR OUT.
180 * The center/lfe channel has no volume control and cannot be muted during
181 * playback.
182 */
183
184struct emu10k1x_voice {
185 struct emu10k1x *emu;
186 int number;
187 int use;
188
189 struct emu10k1x_pcm *epcm;
190};
191
192struct emu10k1x_pcm {
193 struct emu10k1x *emu;
194 struct snd_pcm_substream *substream;
195 struct emu10k1x_voice *voice;
196 unsigned short running;
197};
198
199struct emu10k1x_midi {
200 struct emu10k1x *emu;
201 struct snd_rawmidi *rmidi;
202 struct snd_rawmidi_substream *substream_input;
203 struct snd_rawmidi_substream *substream_output;
204 unsigned int midi_mode;
205 spinlock_t input_lock;
206 spinlock_t output_lock;
207 spinlock_t open_lock;
208 int tx_enable, rx_enable;
209 int port;
210 int ipr_tx, ipr_rx;
211 void (*interrupt)(struct emu10k1x *emu, unsigned int status);
212};
213
214// definition of the chip-specific record
215struct emu10k1x {
216 struct snd_card *card;
217 struct pci_dev *pci;
218
219 unsigned long port;
220 int irq;
221
222 unsigned char revision; /* chip revision */
223 unsigned int serial; /* serial number */
224 unsigned short model; /* subsystem id */
225
226 spinlock_t emu_lock;
227 spinlock_t voice_lock;
228
229 struct snd_ac97 *ac97;
230 struct snd_pcm *pcm;
231
232 struct emu10k1x_voice voices[3];
233 struct emu10k1x_voice capture_voice;
234 u32 spdif_bits[3]; // SPDIF out setup
235
236 struct snd_dma_buffer *dma_buffer;
237
238 struct emu10k1x_midi midi;
239};
240
241/* hardware definition */
242static const struct snd_pcm_hardware snd_emu10k1x_playback_hw = {
243 .info = (SNDRV_PCM_INFO_MMAP |
244 SNDRV_PCM_INFO_INTERLEAVED |
245 SNDRV_PCM_INFO_BLOCK_TRANSFER |
246 SNDRV_PCM_INFO_MMAP_VALID),
247 .formats = SNDRV_PCM_FMTBIT_S16_LE,
248 .rates = SNDRV_PCM_RATE_48000,
249 .rate_min = 48000,
250 .rate_max = 48000,
251 .channels_min = 2,
252 .channels_max = 2,
253 .buffer_bytes_max = (32*1024),
254 .period_bytes_min = 64,
255 .period_bytes_max = (16*1024),
256 .periods_min = 2,
257 .periods_max = 8,
258 .fifo_size = 0,
259};
260
261static const struct snd_pcm_hardware snd_emu10k1x_capture_hw = {
262 .info = (SNDRV_PCM_INFO_MMAP |
263 SNDRV_PCM_INFO_INTERLEAVED |
264 SNDRV_PCM_INFO_BLOCK_TRANSFER |
265 SNDRV_PCM_INFO_MMAP_VALID),
266 .formats = SNDRV_PCM_FMTBIT_S16_LE,
267 .rates = SNDRV_PCM_RATE_48000,
268 .rate_min = 48000,
269 .rate_max = 48000,
270 .channels_min = 2,
271 .channels_max = 2,
272 .buffer_bytes_max = (32*1024),
273 .period_bytes_min = 64,
274 .period_bytes_max = (16*1024),
275 .periods_min = 2,
276 .periods_max = 2,
277 .fifo_size = 0,
278};
279
280static unsigned int snd_emu10k1x_ptr_read(struct emu10k1x * emu,
281 unsigned int reg,
282 unsigned int chn)
283{
284 unsigned int regptr;
285
286 regptr = (reg << 16) | chn;
287
288 guard(spinlock_irqsave)(l: &emu->emu_lock);
289 outl(value: regptr, port: emu->port + PTR);
290 return inl(port: emu->port + DATA);
291}
292
293static void snd_emu10k1x_ptr_write(struct emu10k1x *emu,
294 unsigned int reg,
295 unsigned int chn,
296 unsigned int data)
297{
298 unsigned int regptr;
299
300 regptr = (reg << 16) | chn;
301
302 guard(spinlock_irqsave)(l: &emu->emu_lock);
303 outl(value: regptr, port: emu->port + PTR);
304 outl(value: data, port: emu->port + DATA);
305}
306
307static void snd_emu10k1x_intr_enable(struct emu10k1x *emu, unsigned int intrenb)
308{
309 unsigned int intr_enable;
310
311 guard(spinlock_irqsave)(l: &emu->emu_lock);
312 intr_enable = inl(port: emu->port + INTE) | intrenb;
313 outl(value: intr_enable, port: emu->port + INTE);
314}
315
316static void snd_emu10k1x_intr_disable(struct emu10k1x *emu, unsigned int intrenb)
317{
318 unsigned int intr_enable;
319
320 guard(spinlock_irqsave)(l: &emu->emu_lock);
321 intr_enable = inl(port: emu->port + INTE) & ~intrenb;
322 outl(value: intr_enable, port: emu->port + INTE);
323}
324
325static void snd_emu10k1x_gpio_write(struct emu10k1x *emu, unsigned int value)
326{
327 guard(spinlock_irqsave)(l: &emu->emu_lock);
328 outl(value, port: emu->port + GPIO);
329}
330
331static void snd_emu10k1x_pcm_free_substream(struct snd_pcm_runtime *runtime)
332{
333 kfree(objp: runtime->private_data);
334}
335
336static void snd_emu10k1x_pcm_interrupt(struct emu10k1x *emu, struct emu10k1x_voice *voice)
337{
338 struct emu10k1x_pcm *epcm;
339
340 epcm = voice->epcm;
341 if (!epcm)
342 return;
343 if (epcm->substream == NULL)
344 return;
345#if 0
346 dev_info(emu->card->dev,
347 "IRQ: position = 0x%x, period = 0x%x, size = 0x%x\n",
348 epcm->substream->ops->pointer(epcm->substream),
349 snd_pcm_lib_period_bytes(epcm->substream),
350 snd_pcm_lib_buffer_bytes(epcm->substream));
351#endif
352 snd_pcm_period_elapsed(substream: epcm->substream);
353}
354
355/* open callback */
356static int snd_emu10k1x_playback_open(struct snd_pcm_substream *substream)
357{
358 struct emu10k1x *chip = snd_pcm_substream_chip(substream);
359 struct emu10k1x_pcm *epcm;
360 struct snd_pcm_runtime *runtime = substream->runtime;
361 int err;
362
363 err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
364 if (err < 0)
365 return err;
366 err = snd_pcm_hw_constraint_step(runtime, cond: 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, step: 64);
367 if (err < 0)
368 return err;
369
370 epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
371 if (epcm == NULL)
372 return -ENOMEM;
373 epcm->emu = chip;
374 epcm->substream = substream;
375
376 runtime->private_data = epcm;
377 runtime->private_free = snd_emu10k1x_pcm_free_substream;
378
379 runtime->hw = snd_emu10k1x_playback_hw;
380
381 return 0;
382}
383
384/* close callback */
385static int snd_emu10k1x_playback_close(struct snd_pcm_substream *substream)
386{
387 return 0;
388}
389
390/* hw_params callback */
391static int snd_emu10k1x_pcm_hw_params(struct snd_pcm_substream *substream,
392 struct snd_pcm_hw_params *hw_params)
393{
394 struct snd_pcm_runtime *runtime = substream->runtime;
395 struct emu10k1x_pcm *epcm = runtime->private_data;
396
397 if (! epcm->voice) {
398 epcm->voice = &epcm->emu->voices[substream->pcm->device];
399 epcm->voice->use = 1;
400 epcm->voice->epcm = epcm;
401 }
402
403 return 0;
404}
405
406/* hw_free callback */
407static int snd_emu10k1x_pcm_hw_free(struct snd_pcm_substream *substream)
408{
409 struct snd_pcm_runtime *runtime = substream->runtime;
410 struct emu10k1x_pcm *epcm;
411
412 if (runtime->private_data == NULL)
413 return 0;
414
415 epcm = runtime->private_data;
416
417 if (epcm->voice) {
418 epcm->voice->use = 0;
419 epcm->voice->epcm = NULL;
420 epcm->voice = NULL;
421 }
422
423 return 0;
424}
425
426/* prepare callback */
427static int snd_emu10k1x_pcm_prepare(struct snd_pcm_substream *substream)
428{
429 struct emu10k1x *emu = snd_pcm_substream_chip(substream);
430 struct snd_pcm_runtime *runtime = substream->runtime;
431 struct emu10k1x_pcm *epcm = runtime->private_data;
432 int voice = epcm->voice->number;
433 u32 *table_base = (u32 *)(emu->dma_buffer->area+1024*voice);
434 u32 period_size_bytes = frames_to_bytes(runtime, size: runtime->period_size);
435 int i;
436
437 for(i = 0; i < runtime->periods; i++) {
438 *table_base++=runtime->dma_addr+(i*period_size_bytes);
439 *table_base++=period_size_bytes<<16;
440 }
441
442 snd_emu10k1x_ptr_write(emu, PLAYBACK_LIST_ADDR, chn: voice, data: emu->dma_buffer->addr+1024*voice);
443 snd_emu10k1x_ptr_write(emu, PLAYBACK_LIST_SIZE, chn: voice, data: (runtime->periods - 1) << 19);
444 snd_emu10k1x_ptr_write(emu, PLAYBACK_LIST_PTR, chn: voice, data: 0);
445 snd_emu10k1x_ptr_write(emu, PLAYBACK_POINTER, chn: voice, data: 0);
446 snd_emu10k1x_ptr_write(emu, PLAYBACK_UNKNOWN1, chn: voice, data: 0);
447 snd_emu10k1x_ptr_write(emu, PLAYBACK_UNKNOWN2, chn: voice, data: 0);
448 snd_emu10k1x_ptr_write(emu, PLAYBACK_DMA_ADDR, chn: voice, data: runtime->dma_addr);
449
450 snd_emu10k1x_ptr_write(emu, PLAYBACK_PERIOD_SIZE, chn: voice, data: frames_to_bytes(runtime, size: runtime->period_size)<<16);
451
452 return 0;
453}
454
455/* trigger callback */
456static int snd_emu10k1x_pcm_trigger(struct snd_pcm_substream *substream,
457 int cmd)
458{
459 struct emu10k1x *emu = snd_pcm_substream_chip(substream);
460 struct snd_pcm_runtime *runtime = substream->runtime;
461 struct emu10k1x_pcm *epcm = runtime->private_data;
462 int channel = epcm->voice->number;
463 int result = 0;
464
465 /*
466 dev_dbg(emu->card->dev,
467 "trigger - emu10k1x = 0x%x, cmd = %i, pointer = %d\n",
468 (int)emu, cmd, (int)substream->ops->pointer(substream));
469 */
470
471 switch (cmd) {
472 case SNDRV_PCM_TRIGGER_START:
473 if(runtime->periods == 2)
474 snd_emu10k1x_intr_enable(emu, intrenb: (INTE_CH_0_LOOP | INTE_CH_0_HALF_LOOP) << channel);
475 else
476 snd_emu10k1x_intr_enable(emu, INTE_CH_0_LOOP << channel);
477 epcm->running = 1;
478 snd_emu10k1x_ptr_write(emu, TRIGGER_CHANNEL, chn: 0, data: snd_emu10k1x_ptr_read(emu, TRIGGER_CHANNEL, chn: 0)|(TRIGGER_CHANNEL_0<<channel));
479 break;
480 case SNDRV_PCM_TRIGGER_STOP:
481 epcm->running = 0;
482 snd_emu10k1x_intr_disable(emu, intrenb: (INTE_CH_0_LOOP | INTE_CH_0_HALF_LOOP) << channel);
483 snd_emu10k1x_ptr_write(emu, TRIGGER_CHANNEL, chn: 0, data: snd_emu10k1x_ptr_read(emu, TRIGGER_CHANNEL, chn: 0) & ~(TRIGGER_CHANNEL_0<<channel));
484 break;
485 default:
486 result = -EINVAL;
487 break;
488 }
489 return result;
490}
491
492/* pointer callback */
493static snd_pcm_uframes_t
494snd_emu10k1x_pcm_pointer(struct snd_pcm_substream *substream)
495{
496 struct emu10k1x *emu = snd_pcm_substream_chip(substream);
497 struct snd_pcm_runtime *runtime = substream->runtime;
498 struct emu10k1x_pcm *epcm = runtime->private_data;
499 int channel = epcm->voice->number;
500 snd_pcm_uframes_t ptr = 0, ptr1 = 0, ptr2= 0,ptr3 = 0,ptr4 = 0;
501
502 if (!epcm->running)
503 return 0;
504
505 ptr3 = snd_emu10k1x_ptr_read(emu, PLAYBACK_LIST_PTR, chn: channel);
506 ptr1 = snd_emu10k1x_ptr_read(emu, PLAYBACK_POINTER, chn: channel);
507 ptr4 = snd_emu10k1x_ptr_read(emu, PLAYBACK_LIST_PTR, chn: channel);
508
509 if(ptr4 == 0 && ptr1 == frames_to_bytes(runtime, size: runtime->buffer_size))
510 return 0;
511
512 if (ptr3 != ptr4)
513 ptr1 = snd_emu10k1x_ptr_read(emu, PLAYBACK_POINTER, chn: channel);
514 ptr2 = bytes_to_frames(runtime, size: ptr1);
515 ptr2 += (ptr4 >> 3) * runtime->period_size;
516 ptr = ptr2;
517
518 if (ptr >= runtime->buffer_size)
519 ptr -= runtime->buffer_size;
520
521 return ptr;
522}
523
524/* operators */
525static const struct snd_pcm_ops snd_emu10k1x_playback_ops = {
526 .open = snd_emu10k1x_playback_open,
527 .close = snd_emu10k1x_playback_close,
528 .hw_params = snd_emu10k1x_pcm_hw_params,
529 .hw_free = snd_emu10k1x_pcm_hw_free,
530 .prepare = snd_emu10k1x_pcm_prepare,
531 .trigger = snd_emu10k1x_pcm_trigger,
532 .pointer = snd_emu10k1x_pcm_pointer,
533};
534
535/* open_capture callback */
536static int snd_emu10k1x_pcm_open_capture(struct snd_pcm_substream *substream)
537{
538 struct emu10k1x *chip = snd_pcm_substream_chip(substream);
539 struct emu10k1x_pcm *epcm;
540 struct snd_pcm_runtime *runtime = substream->runtime;
541 int err;
542
543 err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
544 if (err < 0)
545 return err;
546 err = snd_pcm_hw_constraint_step(runtime, cond: 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, step: 64);
547 if (err < 0)
548 return err;
549
550 epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
551 if (epcm == NULL)
552 return -ENOMEM;
553
554 epcm->emu = chip;
555 epcm->substream = substream;
556
557 runtime->private_data = epcm;
558 runtime->private_free = snd_emu10k1x_pcm_free_substream;
559
560 runtime->hw = snd_emu10k1x_capture_hw;
561
562 return 0;
563}
564
565/* close callback */
566static int snd_emu10k1x_pcm_close_capture(struct snd_pcm_substream *substream)
567{
568 return 0;
569}
570
571/* hw_params callback */
572static int snd_emu10k1x_pcm_hw_params_capture(struct snd_pcm_substream *substream,
573 struct snd_pcm_hw_params *hw_params)
574{
575 struct snd_pcm_runtime *runtime = substream->runtime;
576 struct emu10k1x_pcm *epcm = runtime->private_data;
577
578 if (! epcm->voice) {
579 if (epcm->emu->capture_voice.use)
580 return -EBUSY;
581 epcm->voice = &epcm->emu->capture_voice;
582 epcm->voice->epcm = epcm;
583 epcm->voice->use = 1;
584 }
585
586 return 0;
587}
588
589/* hw_free callback */
590static int snd_emu10k1x_pcm_hw_free_capture(struct snd_pcm_substream *substream)
591{
592 struct snd_pcm_runtime *runtime = substream->runtime;
593
594 struct emu10k1x_pcm *epcm;
595
596 if (runtime->private_data == NULL)
597 return 0;
598 epcm = runtime->private_data;
599
600 if (epcm->voice) {
601 epcm->voice->use = 0;
602 epcm->voice->epcm = NULL;
603 epcm->voice = NULL;
604 }
605
606 return 0;
607}
608
609/* prepare capture callback */
610static int snd_emu10k1x_pcm_prepare_capture(struct snd_pcm_substream *substream)
611{
612 struct emu10k1x *emu = snd_pcm_substream_chip(substream);
613 struct snd_pcm_runtime *runtime = substream->runtime;
614
615 snd_emu10k1x_ptr_write(emu, CAPTURE_DMA_ADDR, chn: 0, data: runtime->dma_addr);
616 snd_emu10k1x_ptr_write(emu, CAPTURE_BUFFER_SIZE, chn: 0, data: frames_to_bytes(runtime, size: runtime->buffer_size)<<16); // buffer size in bytes
617 snd_emu10k1x_ptr_write(emu, CAPTURE_POINTER, chn: 0, data: 0);
618 snd_emu10k1x_ptr_write(emu, CAPTURE_UNKNOWN, chn: 0, data: 0);
619
620 return 0;
621}
622
623/* trigger_capture callback */
624static int snd_emu10k1x_pcm_trigger_capture(struct snd_pcm_substream *substream,
625 int cmd)
626{
627 struct emu10k1x *emu = snd_pcm_substream_chip(substream);
628 struct snd_pcm_runtime *runtime = substream->runtime;
629 struct emu10k1x_pcm *epcm = runtime->private_data;
630 int result = 0;
631
632 switch (cmd) {
633 case SNDRV_PCM_TRIGGER_START:
634 snd_emu10k1x_intr_enable(emu, INTE_CAP_0_LOOP |
635 INTE_CAP_0_HALF_LOOP);
636 snd_emu10k1x_ptr_write(emu, TRIGGER_CHANNEL, chn: 0, data: snd_emu10k1x_ptr_read(emu, TRIGGER_CHANNEL, chn: 0)|TRIGGER_CAPTURE);
637 epcm->running = 1;
638 break;
639 case SNDRV_PCM_TRIGGER_STOP:
640 epcm->running = 0;
641 snd_emu10k1x_intr_disable(emu, INTE_CAP_0_LOOP |
642 INTE_CAP_0_HALF_LOOP);
643 snd_emu10k1x_ptr_write(emu, TRIGGER_CHANNEL, chn: 0, data: snd_emu10k1x_ptr_read(emu, TRIGGER_CHANNEL, chn: 0) & ~(TRIGGER_CAPTURE));
644 break;
645 default:
646 result = -EINVAL;
647 break;
648 }
649 return result;
650}
651
652/* pointer_capture callback */
653static snd_pcm_uframes_t
654snd_emu10k1x_pcm_pointer_capture(struct snd_pcm_substream *substream)
655{
656 struct emu10k1x *emu = snd_pcm_substream_chip(substream);
657 struct snd_pcm_runtime *runtime = substream->runtime;
658 struct emu10k1x_pcm *epcm = runtime->private_data;
659 snd_pcm_uframes_t ptr;
660
661 if (!epcm->running)
662 return 0;
663
664 ptr = bytes_to_frames(runtime, size: snd_emu10k1x_ptr_read(emu, CAPTURE_POINTER, chn: 0));
665 if (ptr >= runtime->buffer_size)
666 ptr -= runtime->buffer_size;
667
668 return ptr;
669}
670
671static const struct snd_pcm_ops snd_emu10k1x_capture_ops = {
672 .open = snd_emu10k1x_pcm_open_capture,
673 .close = snd_emu10k1x_pcm_close_capture,
674 .hw_params = snd_emu10k1x_pcm_hw_params_capture,
675 .hw_free = snd_emu10k1x_pcm_hw_free_capture,
676 .prepare = snd_emu10k1x_pcm_prepare_capture,
677 .trigger = snd_emu10k1x_pcm_trigger_capture,
678 .pointer = snd_emu10k1x_pcm_pointer_capture,
679};
680
681static unsigned short snd_emu10k1x_ac97_read(struct snd_ac97 *ac97,
682 unsigned short reg)
683{
684 struct emu10k1x *emu = ac97->private_data;
685
686 guard(spinlock_irqsave)(l: &emu->emu_lock);
687 outb(value: reg, port: emu->port + AC97ADDRESS);
688 return inw(port: emu->port + AC97DATA);
689}
690
691static void snd_emu10k1x_ac97_write(struct snd_ac97 *ac97,
692 unsigned short reg, unsigned short val)
693{
694 struct emu10k1x *emu = ac97->private_data;
695
696 guard(spinlock_irqsave)(l: &emu->emu_lock);
697 outb(value: reg, port: emu->port + AC97ADDRESS);
698 outw(value: val, port: emu->port + AC97DATA);
699}
700
701static int snd_emu10k1x_ac97(struct emu10k1x *chip)
702{
703 struct snd_ac97_bus *pbus;
704 struct snd_ac97_template ac97;
705 int err;
706 static const struct snd_ac97_bus_ops ops = {
707 .write = snd_emu10k1x_ac97_write,
708 .read = snd_emu10k1x_ac97_read,
709 };
710
711 err = snd_ac97_bus(card: chip->card, num: 0, ops: &ops, NULL, rbus: &pbus);
712 if (err < 0)
713 return err;
714 pbus->no_vra = 1; /* we don't need VRA */
715
716 memset(&ac97, 0, sizeof(ac97));
717 ac97.private_data = chip;
718 ac97.scaps = AC97_SCAP_NO_SPDIF;
719 return snd_ac97_mixer(bus: pbus, template: &ac97, rac97: &chip->ac97);
720}
721
722static void snd_emu10k1x_free(struct snd_card *card)
723{
724 struct emu10k1x *chip = card->private_data;
725
726 snd_emu10k1x_ptr_write(emu: chip, TRIGGER_CHANNEL, chn: 0, data: 0);
727 // disable interrupts
728 outl(value: 0, port: chip->port + INTE);
729 // disable audio
730 outl(HCFG_LOCKSOUNDCACHE, port: chip->port + HCFG);
731}
732
733static irqreturn_t snd_emu10k1x_interrupt(int irq, void *dev_id)
734{
735 unsigned int status;
736
737 struct emu10k1x *chip = dev_id;
738 struct emu10k1x_voice *pvoice = chip->voices;
739 int i;
740 int mask;
741
742 status = inl(port: chip->port + IPR);
743
744 if (! status)
745 return IRQ_NONE;
746
747 // capture interrupt
748 if (status & (IPR_CAP_0_LOOP | IPR_CAP_0_HALF_LOOP)) {
749 struct emu10k1x_voice *cap_voice = &chip->capture_voice;
750 if (cap_voice->use)
751 snd_emu10k1x_pcm_interrupt(emu: chip, voice: cap_voice);
752 else
753 snd_emu10k1x_intr_disable(emu: chip,
754 INTE_CAP_0_LOOP |
755 INTE_CAP_0_HALF_LOOP);
756 }
757
758 mask = IPR_CH_0_LOOP|IPR_CH_0_HALF_LOOP;
759 for (i = 0; i < 3; i++) {
760 if (status & mask) {
761 if (pvoice->use)
762 snd_emu10k1x_pcm_interrupt(emu: chip, voice: pvoice);
763 else
764 snd_emu10k1x_intr_disable(emu: chip, intrenb: mask);
765 }
766 pvoice++;
767 mask <<= 1;
768 }
769
770 if (status & (IPR_MIDITRANSBUFEMPTY|IPR_MIDIRECVBUFEMPTY)) {
771 if (chip->midi.interrupt)
772 chip->midi.interrupt(chip, status);
773 else
774 snd_emu10k1x_intr_disable(emu: chip, INTE_MIDITXENABLE|INTE_MIDIRXENABLE);
775 }
776
777 // acknowledge the interrupt if necessary
778 outl(value: status, port: chip->port + IPR);
779
780 /* dev_dbg(chip->card->dev, "interrupt %08x\n", status); */
781 return IRQ_HANDLED;
782}
783
784static const struct snd_pcm_chmap_elem surround_map[] = {
785 { .channels = 2,
786 .map = { SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
787 { }
788};
789
790static const struct snd_pcm_chmap_elem clfe_map[] = {
791 { .channels = 2,
792 .map = { SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE } },
793 { }
794};
795
796static int snd_emu10k1x_pcm(struct emu10k1x *emu, int device)
797{
798 struct snd_pcm *pcm;
799 const struct snd_pcm_chmap_elem *map = NULL;
800 int err;
801 int capture = 0;
802
803 if (device == 0)
804 capture = 1;
805
806 err = snd_pcm_new(card: emu->card, id: "emu10k1x", device, playback_count: 1, capture_count: capture, rpcm: &pcm);
807 if (err < 0)
808 return err;
809
810 pcm->private_data = emu;
811
812 switch(device) {
813 case 0:
814 snd_pcm_set_ops(pcm, direction: SNDRV_PCM_STREAM_PLAYBACK, ops: &snd_emu10k1x_playback_ops);
815 snd_pcm_set_ops(pcm, direction: SNDRV_PCM_STREAM_CAPTURE, ops: &snd_emu10k1x_capture_ops);
816 break;
817 case 1:
818 case 2:
819 snd_pcm_set_ops(pcm, direction: SNDRV_PCM_STREAM_PLAYBACK, ops: &snd_emu10k1x_playback_ops);
820 break;
821 }
822
823 pcm->info_flags = 0;
824 switch(device) {
825 case 0:
826 strscpy(pcm->name, "EMU10K1X Front");
827 map = snd_pcm_std_chmaps;
828 break;
829 case 1:
830 strscpy(pcm->name, "EMU10K1X Rear");
831 map = surround_map;
832 break;
833 case 2:
834 strscpy(pcm->name, "EMU10K1X Center/LFE");
835 map = clfe_map;
836 break;
837 }
838 emu->pcm = pcm;
839
840 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
841 data: &emu->pci->dev, size: 32*1024, max: 32*1024);
842
843 return snd_pcm_add_chmap_ctls(pcm, stream: SNDRV_PCM_STREAM_PLAYBACK, chmap: map, max_channels: 2,
844 private_value: 1 << 2, NULL);
845}
846
847static int snd_emu10k1x_create(struct snd_card *card,
848 struct pci_dev *pci)
849{
850 struct emu10k1x *chip = card->private_data;
851 int err;
852 int ch;
853
854 err = pcim_enable_device(pdev: pci);
855 if (err < 0)
856 return err;
857
858 if (dma_set_mask_and_coherent(dev: &pci->dev, DMA_BIT_MASK(28)) < 0) {
859 dev_err(card->dev, "error to set 28bit mask DMA\n");
860 return -ENXIO;
861 }
862
863 chip->card = card;
864 chip->pci = pci;
865 chip->irq = -1;
866
867 spin_lock_init(&chip->emu_lock);
868 spin_lock_init(&chip->voice_lock);
869
870 err = pcim_request_all_regions(pdev: pci, name: "EMU10K1X");
871 if (err < 0)
872 return err;
873 chip->port = pci_resource_start(pci, 0);
874
875 if (devm_request_irq(dev: &pci->dev, irq: pci->irq, handler: snd_emu10k1x_interrupt,
876 IRQF_SHARED, KBUILD_MODNAME, dev_id: chip)) {
877 dev_err(card->dev, "cannot grab irq %d\n", pci->irq);
878 return -EBUSY;
879 }
880 chip->irq = pci->irq;
881 card->sync_irq = chip->irq;
882 card->private_free = snd_emu10k1x_free;
883
884 chip->dma_buffer = snd_devm_alloc_pages(dev: &pci->dev, SNDRV_DMA_TYPE_DEV,
885 size: 4 * 1024);
886 if (!chip->dma_buffer)
887 return -ENOMEM;
888
889 pci_set_master(dev: pci);
890 /* read revision & serial */
891 chip->revision = pci->revision;
892 pci_read_config_dword(dev: pci, PCI_SUBSYSTEM_VENDOR_ID, val: &chip->serial);
893 pci_read_config_word(dev: pci, PCI_SUBSYSTEM_ID, val: &chip->model);
894 dev_info(card->dev, "Model %04x Rev %08x Serial %08x\n", chip->model,
895 chip->revision, chip->serial);
896
897 outl(value: 0, port: chip->port + INTE);
898
899 for(ch = 0; ch < 3; ch++) {
900 chip->voices[ch].emu = chip;
901 chip->voices[ch].number = ch;
902 }
903
904 /*
905 * Init to 0x02109204 :
906 * Clock accuracy = 0 (1000ppm)
907 * Sample Rate = 2 (48kHz)
908 * Audio Channel = 1 (Left of 2)
909 * Source Number = 0 (Unspecified)
910 * Generation Status = 1 (Original for Cat Code 12)
911 * Cat Code = 12 (Digital Signal Mixer)
912 * Mode = 0 (Mode 0)
913 * Emphasis = 0 (None)
914 * CP = 1 (Copyright unasserted)
915 * AN = 0 (Audio data)
916 * P = 0 (Consumer)
917 */
918 snd_emu10k1x_ptr_write(emu: chip, SPCS0, chn: 0,
919 data: chip->spdif_bits[0] =
920 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
921 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
922 SPCS_GENERATIONSTATUS | 0x00001200 |
923 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
924 snd_emu10k1x_ptr_write(emu: chip, SPCS1, chn: 0,
925 data: chip->spdif_bits[1] =
926 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
927 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
928 SPCS_GENERATIONSTATUS | 0x00001200 |
929 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
930 snd_emu10k1x_ptr_write(emu: chip, SPCS2, chn: 0,
931 data: chip->spdif_bits[2] =
932 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
933 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
934 SPCS_GENERATIONSTATUS | 0x00001200 |
935 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
936
937 snd_emu10k1x_ptr_write(emu: chip, SPDIF_SELECT, chn: 0, data: 0x700); // disable SPDIF
938 snd_emu10k1x_ptr_write(emu: chip, ROUTING, chn: 0, data: 0x1003F); // routing
939 snd_emu10k1x_gpio_write(emu: chip, value: 0x1080); // analog mode
940
941 outl(HCFG_LOCKSOUNDCACHE|HCFG_AUDIOENABLE, port: chip->port+HCFG);
942
943 return 0;
944}
945
946static void snd_emu10k1x_proc_reg_read(struct snd_info_entry *entry,
947 struct snd_info_buffer *buffer)
948{
949 struct emu10k1x *emu = entry->private_data;
950 unsigned long value,value1,value2;
951 int i;
952
953 snd_iprintf(buffer, "Registers:\n\n");
954 for(i = 0; i < 0x20; i+=4) {
955 guard(spinlock_irqsave)(l: &emu->emu_lock);
956 value = inl(port: emu->port + i);
957 snd_iprintf(buffer, "Register %02X: %08lX\n", i, value);
958 }
959 snd_iprintf(buffer, "\nRegisters\n\n");
960 for(i = 0; i <= 0x48; i++) {
961 value = snd_emu10k1x_ptr_read(emu, reg: i, chn: 0);
962 if(i < 0x10 || (i >= 0x20 && i < 0x40)) {
963 value1 = snd_emu10k1x_ptr_read(emu, reg: i, chn: 1);
964 value2 = snd_emu10k1x_ptr_read(emu, reg: i, chn: 2);
965 snd_iprintf(buffer, "%02X: %08lX %08lX %08lX\n", i, value, value1, value2);
966 } else {
967 snd_iprintf(buffer, "%02X: %08lX\n", i, value);
968 }
969 }
970}
971
972static void snd_emu10k1x_proc_reg_write(struct snd_info_entry *entry,
973 struct snd_info_buffer *buffer)
974{
975 struct emu10k1x *emu = entry->private_data;
976 char line[64];
977 unsigned int reg, channel_id , val;
978
979 while (!snd_info_get_line(buffer, line, len: sizeof(line))) {
980 if (sscanf(line, "%x %x %x", &reg, &channel_id, &val) != 3)
981 continue;
982
983 if (reg < 0x49 && channel_id <= 2)
984 snd_emu10k1x_ptr_write(emu, reg, chn: channel_id, data: val);
985 }
986}
987
988static int snd_emu10k1x_proc_init(struct emu10k1x *emu)
989{
990 snd_card_rw_proc_new(card: emu->card, name: "emu10k1x_regs", private_data: emu,
991 read: snd_emu10k1x_proc_reg_read,
992 write: snd_emu10k1x_proc_reg_write);
993 return 0;
994}
995
996#define snd_emu10k1x_shared_spdif_info snd_ctl_boolean_mono_info
997
998static int snd_emu10k1x_shared_spdif_get(struct snd_kcontrol *kcontrol,
999 struct snd_ctl_elem_value *ucontrol)
1000{
1001 struct emu10k1x *emu = snd_kcontrol_chip(kcontrol);
1002
1003 ucontrol->value.integer.value[0] = (snd_emu10k1x_ptr_read(emu, SPDIF_SELECT, chn: 0) == 0x700) ? 0 : 1;
1004
1005 return 0;
1006}
1007
1008static int snd_emu10k1x_shared_spdif_put(struct snd_kcontrol *kcontrol,
1009 struct snd_ctl_elem_value *ucontrol)
1010{
1011 struct emu10k1x *emu = snd_kcontrol_chip(kcontrol);
1012 unsigned int val;
1013
1014 val = ucontrol->value.integer.value[0] ;
1015
1016 if (val) {
1017 // enable spdif output
1018 snd_emu10k1x_ptr_write(emu, SPDIF_SELECT, chn: 0, data: 0x000);
1019 snd_emu10k1x_ptr_write(emu, ROUTING, chn: 0, data: 0x700);
1020 snd_emu10k1x_gpio_write(emu, value: 0x1000);
1021 } else {
1022 // disable spdif output
1023 snd_emu10k1x_ptr_write(emu, SPDIF_SELECT, chn: 0, data: 0x700);
1024 snd_emu10k1x_ptr_write(emu, ROUTING, chn: 0, data: 0x1003F);
1025 snd_emu10k1x_gpio_write(emu, value: 0x1080);
1026 }
1027 return 0;
1028}
1029
1030static const struct snd_kcontrol_new snd_emu10k1x_shared_spdif =
1031{
1032 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1033 .name = "Analog/Digital Output Jack",
1034 .info = snd_emu10k1x_shared_spdif_info,
1035 .get = snd_emu10k1x_shared_spdif_get,
1036 .put = snd_emu10k1x_shared_spdif_put
1037};
1038
1039static int snd_emu10k1x_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1040{
1041 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1042 uinfo->count = 1;
1043 return 0;
1044}
1045
1046static int snd_emu10k1x_spdif_get(struct snd_kcontrol *kcontrol,
1047 struct snd_ctl_elem_value *ucontrol)
1048{
1049 struct emu10k1x *emu = snd_kcontrol_chip(kcontrol);
1050 unsigned int idx = snd_ctl_get_ioffidx(kctl: kcontrol, id: &ucontrol->id);
1051
1052 ucontrol->value.iec958.status[0] = (emu->spdif_bits[idx] >> 0) & 0xff;
1053 ucontrol->value.iec958.status[1] = (emu->spdif_bits[idx] >> 8) & 0xff;
1054 ucontrol->value.iec958.status[2] = (emu->spdif_bits[idx] >> 16) & 0xff;
1055 ucontrol->value.iec958.status[3] = (emu->spdif_bits[idx] >> 24) & 0xff;
1056 return 0;
1057}
1058
1059static int snd_emu10k1x_spdif_get_mask(struct snd_kcontrol *kcontrol,
1060 struct snd_ctl_elem_value *ucontrol)
1061{
1062 ucontrol->value.iec958.status[0] = 0xff;
1063 ucontrol->value.iec958.status[1] = 0xff;
1064 ucontrol->value.iec958.status[2] = 0xff;
1065 ucontrol->value.iec958.status[3] = 0xff;
1066 return 0;
1067}
1068
1069static int snd_emu10k1x_spdif_put(struct snd_kcontrol *kcontrol,
1070 struct snd_ctl_elem_value *ucontrol)
1071{
1072 struct emu10k1x *emu = snd_kcontrol_chip(kcontrol);
1073 unsigned int idx = snd_ctl_get_ioffidx(kctl: kcontrol, id: &ucontrol->id);
1074 int change;
1075 unsigned int val;
1076
1077 val = (ucontrol->value.iec958.status[0] << 0) |
1078 (ucontrol->value.iec958.status[1] << 8) |
1079 (ucontrol->value.iec958.status[2] << 16) |
1080 (ucontrol->value.iec958.status[3] << 24);
1081 change = val != emu->spdif_bits[idx];
1082 if (change) {
1083 snd_emu10k1x_ptr_write(emu, SPCS0 + idx, chn: 0, data: val);
1084 emu->spdif_bits[idx] = val;
1085 }
1086 return change;
1087}
1088
1089static const struct snd_kcontrol_new snd_emu10k1x_spdif_mask_control =
1090{
1091 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1092 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1093 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
1094 .count = 3,
1095 .info = snd_emu10k1x_spdif_info,
1096 .get = snd_emu10k1x_spdif_get_mask
1097};
1098
1099static const struct snd_kcontrol_new snd_emu10k1x_spdif_control =
1100{
1101 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1102 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1103 .count = 3,
1104 .info = snd_emu10k1x_spdif_info,
1105 .get = snd_emu10k1x_spdif_get,
1106 .put = snd_emu10k1x_spdif_put
1107};
1108
1109static int snd_emu10k1x_mixer(struct emu10k1x *emu)
1110{
1111 int err;
1112 struct snd_kcontrol *kctl;
1113 struct snd_card *card = emu->card;
1114
1115 kctl = snd_ctl_new1(kcontrolnew: &snd_emu10k1x_spdif_mask_control, private_data: emu);
1116 if (!kctl)
1117 return -ENOMEM;
1118 err = snd_ctl_add(card, kcontrol: kctl);
1119 if (err)
1120 return err;
1121 kctl = snd_ctl_new1(kcontrolnew: &snd_emu10k1x_shared_spdif, private_data: emu);
1122 if (!kctl)
1123 return -ENOMEM;
1124 err = snd_ctl_add(card, kcontrol: kctl);
1125 if (err)
1126 return err;
1127 kctl = snd_ctl_new1(kcontrolnew: &snd_emu10k1x_spdif_control, private_data: emu);
1128 if (!kctl)
1129 return -ENOMEM;
1130 err = snd_ctl_add(card, kcontrol: kctl);
1131 if (err)
1132 return err;
1133
1134 return 0;
1135}
1136
1137#define EMU10K1X_MIDI_MODE_INPUT (1<<0)
1138#define EMU10K1X_MIDI_MODE_OUTPUT (1<<1)
1139
1140static inline unsigned char mpu401_read(struct emu10k1x *emu, struct emu10k1x_midi *mpu, int idx)
1141{
1142 return (unsigned char)snd_emu10k1x_ptr_read(emu, reg: mpu->port + idx, chn: 0);
1143}
1144
1145static inline void mpu401_write(struct emu10k1x *emu, struct emu10k1x_midi *mpu, int data, int idx)
1146{
1147 snd_emu10k1x_ptr_write(emu, reg: mpu->port + idx, chn: 0, data);
1148}
1149
1150#define mpu401_write_data(emu, mpu, data) mpu401_write(emu, mpu, data, 0)
1151#define mpu401_write_cmd(emu, mpu, data) mpu401_write(emu, mpu, data, 1)
1152#define mpu401_read_data(emu, mpu) mpu401_read(emu, mpu, 0)
1153#define mpu401_read_stat(emu, mpu) mpu401_read(emu, mpu, 1)
1154
1155#define mpu401_input_avail(emu,mpu) (!(mpu401_read_stat(emu,mpu) & 0x80))
1156#define mpu401_output_ready(emu,mpu) (!(mpu401_read_stat(emu,mpu) & 0x40))
1157
1158#define MPU401_RESET 0xff
1159#define MPU401_ENTER_UART 0x3f
1160#define MPU401_ACK 0xfe
1161
1162static void mpu401_clear_rx(struct emu10k1x *emu, struct emu10k1x_midi *mpu)
1163{
1164 int timeout = 100000;
1165 for (; timeout > 0 && mpu401_input_avail(emu, mpu); timeout--)
1166 mpu401_read_data(emu, mpu);
1167#ifdef CONFIG_SND_DEBUG
1168 if (timeout <= 0)
1169 dev_err(emu->card->dev,
1170 "cmd: clear rx timeout (status = 0x%x)\n",
1171 mpu401_read_stat(emu, mpu));
1172#endif
1173}
1174
1175/*
1176
1177 */
1178
1179static void do_emu10k1x_midi_interrupt(struct emu10k1x *emu,
1180 struct emu10k1x_midi *midi, unsigned int status)
1181{
1182 unsigned char byte;
1183
1184 if (midi->rmidi == NULL) {
1185 snd_emu10k1x_intr_disable(emu, intrenb: midi->tx_enable | midi->rx_enable);
1186 return;
1187 }
1188
1189 scoped_guard(spinlock, &midi->input_lock) {
1190 if ((status & midi->ipr_rx) && mpu401_input_avail(emu, midi)) {
1191 if (!(midi->midi_mode & EMU10K1X_MIDI_MODE_INPUT)) {
1192 mpu401_clear_rx(emu, mpu: midi);
1193 } else {
1194 byte = mpu401_read_data(emu, midi);
1195 if (midi->substream_input)
1196 snd_rawmidi_receive(substream: midi->substream_input, buffer: &byte, count: 1);
1197 }
1198 }
1199 }
1200
1201 scoped_guard(spinlock, &midi->output_lock) {
1202 if ((status & midi->ipr_tx) && mpu401_output_ready(emu, midi)) {
1203 if (midi->substream_output &&
1204 snd_rawmidi_transmit(substream: midi->substream_output, buffer: &byte, count: 1) == 1) {
1205 mpu401_write_data(emu, midi, byte);
1206 } else {
1207 snd_emu10k1x_intr_disable(emu, intrenb: midi->tx_enable);
1208 }
1209 }
1210 }
1211}
1212
1213static void snd_emu10k1x_midi_interrupt(struct emu10k1x *emu, unsigned int status)
1214{
1215 do_emu10k1x_midi_interrupt(emu, midi: &emu->midi, status);
1216}
1217
1218static int snd_emu10k1x_midi_cmd(struct emu10k1x * emu,
1219 struct emu10k1x_midi *midi, unsigned char cmd, int ack)
1220{
1221 int timeout, ok;
1222
1223 scoped_guard(spinlock_irqsave, &midi->input_lock) {
1224 mpu401_write_data(emu, midi, 0x00);
1225 /* mpu401_clear_rx(emu, midi); */
1226
1227 mpu401_write_cmd(emu, midi, cmd);
1228 if (ack) {
1229 ok = 0;
1230 timeout = 10000;
1231 while (!ok && timeout-- > 0) {
1232 if (mpu401_input_avail(emu, midi)) {
1233 if (mpu401_read_data(emu, midi) == MPU401_ACK)
1234 ok = 1;
1235 }
1236 }
1237 if (!ok && mpu401_read_data(emu, midi) == MPU401_ACK)
1238 ok = 1;
1239 } else {
1240 ok = 1;
1241 }
1242 }
1243 if (!ok) {
1244 dev_err(emu->card->dev,
1245 "midi_cmd: 0x%x failed at 0x%lx (status = 0x%x, data = 0x%x)!!!\n",
1246 cmd, emu->port,
1247 mpu401_read_stat(emu, midi),
1248 mpu401_read_data(emu, midi));
1249 return 1;
1250 }
1251 return 0;
1252}
1253
1254static int snd_emu10k1x_midi_input_open(struct snd_rawmidi_substream *substream)
1255{
1256 struct emu10k1x *emu;
1257 struct emu10k1x_midi *midi = substream->rmidi->private_data;
1258
1259 emu = midi->emu;
1260 if (snd_BUG_ON(!emu))
1261 return -ENXIO;
1262 scoped_guard(spinlock_irqsave, &midi->open_lock) {
1263 midi->midi_mode |= EMU10K1X_MIDI_MODE_INPUT;
1264 midi->substream_input = substream;
1265 if (midi->midi_mode & EMU10K1X_MIDI_MODE_OUTPUT)
1266 return 0;
1267 }
1268 if (snd_emu10k1x_midi_cmd(emu, midi, MPU401_RESET, ack: 1))
1269 return -EIO;
1270 if (snd_emu10k1x_midi_cmd(emu, midi, MPU401_ENTER_UART, ack: 1))
1271 return -EIO;
1272 return 0;
1273}
1274
1275static int snd_emu10k1x_midi_output_open(struct snd_rawmidi_substream *substream)
1276{
1277 struct emu10k1x *emu;
1278 struct emu10k1x_midi *midi = substream->rmidi->private_data;
1279
1280 emu = midi->emu;
1281 if (snd_BUG_ON(!emu))
1282 return -ENXIO;
1283 scoped_guard(spinlock_irqsave, &midi->open_lock) {
1284 midi->midi_mode |= EMU10K1X_MIDI_MODE_OUTPUT;
1285 midi->substream_output = substream;
1286 if (midi->midi_mode & EMU10K1X_MIDI_MODE_INPUT)
1287 return 0;
1288 }
1289 if (snd_emu10k1x_midi_cmd(emu, midi, MPU401_RESET, ack: 1))
1290 return -EIO;
1291 if (snd_emu10k1x_midi_cmd(emu, midi, MPU401_ENTER_UART, ack: 1))
1292 return -EIO;
1293 return 0;
1294}
1295
1296static int snd_emu10k1x_midi_input_close(struct snd_rawmidi_substream *substream)
1297{
1298 struct emu10k1x *emu;
1299 struct emu10k1x_midi *midi = substream->rmidi->private_data;
1300
1301 emu = midi->emu;
1302 if (snd_BUG_ON(!emu))
1303 return -ENXIO;
1304 scoped_guard(spinlock_irqsave, &midi->open_lock) {
1305 snd_emu10k1x_intr_disable(emu, intrenb: midi->rx_enable);
1306 midi->midi_mode &= ~EMU10K1X_MIDI_MODE_INPUT;
1307 midi->substream_input = NULL;
1308 if (midi->midi_mode & EMU10K1X_MIDI_MODE_OUTPUT)
1309 return 0;
1310 }
1311 return snd_emu10k1x_midi_cmd(emu, midi, MPU401_RESET, ack: 0);
1312}
1313
1314static int snd_emu10k1x_midi_output_close(struct snd_rawmidi_substream *substream)
1315{
1316 struct emu10k1x *emu;
1317 struct emu10k1x_midi *midi = substream->rmidi->private_data;
1318
1319 emu = midi->emu;
1320 if (snd_BUG_ON(!emu))
1321 return -ENXIO;
1322 scoped_guard(spinlock_irqsave, &midi->open_lock) {
1323 snd_emu10k1x_intr_disable(emu, intrenb: midi->tx_enable);
1324 midi->midi_mode &= ~EMU10K1X_MIDI_MODE_OUTPUT;
1325 midi->substream_output = NULL;
1326 if (midi->midi_mode & EMU10K1X_MIDI_MODE_INPUT)
1327 return 0;
1328 }
1329 return snd_emu10k1x_midi_cmd(emu, midi, MPU401_RESET, ack: 0);
1330}
1331
1332static void snd_emu10k1x_midi_input_trigger(struct snd_rawmidi_substream *substream, int up)
1333{
1334 struct emu10k1x *emu;
1335 struct emu10k1x_midi *midi = substream->rmidi->private_data;
1336 emu = midi->emu;
1337 if (snd_BUG_ON(!emu))
1338 return;
1339
1340 if (up)
1341 snd_emu10k1x_intr_enable(emu, intrenb: midi->rx_enable);
1342 else
1343 snd_emu10k1x_intr_disable(emu, intrenb: midi->rx_enable);
1344}
1345
1346static void snd_emu10k1x_midi_output_trigger(struct snd_rawmidi_substream *substream, int up)
1347{
1348 struct emu10k1x *emu;
1349 struct emu10k1x_midi *midi = substream->rmidi->private_data;
1350
1351 emu = midi->emu;
1352 if (snd_BUG_ON(!emu))
1353 return;
1354
1355 if (up) {
1356 int max = 4;
1357 unsigned char byte;
1358
1359 /* try to send some amount of bytes here before interrupts */
1360 scoped_guard(spinlock_irqsave, &midi->output_lock) {
1361 while (max > 0) {
1362 if (mpu401_output_ready(emu, midi)) {
1363 if (!(midi->midi_mode & EMU10K1X_MIDI_MODE_OUTPUT) ||
1364 snd_rawmidi_transmit(substream, buffer: &byte, count: 1) != 1) {
1365 /* no more data */
1366 return;
1367 }
1368 mpu401_write_data(emu, midi, byte);
1369 max--;
1370 } else {
1371 break;
1372 }
1373 }
1374 }
1375 snd_emu10k1x_intr_enable(emu, intrenb: midi->tx_enable);
1376 } else {
1377 snd_emu10k1x_intr_disable(emu, intrenb: midi->tx_enable);
1378 }
1379}
1380
1381/*
1382
1383 */
1384
1385static const struct snd_rawmidi_ops snd_emu10k1x_midi_output =
1386{
1387 .open = snd_emu10k1x_midi_output_open,
1388 .close = snd_emu10k1x_midi_output_close,
1389 .trigger = snd_emu10k1x_midi_output_trigger,
1390};
1391
1392static const struct snd_rawmidi_ops snd_emu10k1x_midi_input =
1393{
1394 .open = snd_emu10k1x_midi_input_open,
1395 .close = snd_emu10k1x_midi_input_close,
1396 .trigger = snd_emu10k1x_midi_input_trigger,
1397};
1398
1399static void snd_emu10k1x_midi_free(struct snd_rawmidi *rmidi)
1400{
1401 struct emu10k1x_midi *midi = rmidi->private_data;
1402 midi->interrupt = NULL;
1403 midi->rmidi = NULL;
1404}
1405
1406static int emu10k1x_midi_init(struct emu10k1x *emu,
1407 struct emu10k1x_midi *midi, int device,
1408 char *name)
1409{
1410 struct snd_rawmidi *rmidi;
1411 int err;
1412
1413 err = snd_rawmidi_new(card: emu->card, id: name, device, output_count: 1, input_count: 1, rmidi: &rmidi);
1414 if (err < 0)
1415 return err;
1416 midi->emu = emu;
1417 spin_lock_init(&midi->open_lock);
1418 spin_lock_init(&midi->input_lock);
1419 spin_lock_init(&midi->output_lock);
1420 strscpy(rmidi->name, name);
1421 snd_rawmidi_set_ops(rmidi, stream: SNDRV_RAWMIDI_STREAM_OUTPUT, ops: &snd_emu10k1x_midi_output);
1422 snd_rawmidi_set_ops(rmidi, stream: SNDRV_RAWMIDI_STREAM_INPUT, ops: &snd_emu10k1x_midi_input);
1423 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
1424 SNDRV_RAWMIDI_INFO_INPUT |
1425 SNDRV_RAWMIDI_INFO_DUPLEX;
1426 rmidi->private_data = midi;
1427 rmidi->private_free = snd_emu10k1x_midi_free;
1428 midi->rmidi = rmidi;
1429 return 0;
1430}
1431
1432static int snd_emu10k1x_midi(struct emu10k1x *emu)
1433{
1434 struct emu10k1x_midi *midi = &emu->midi;
1435 int err;
1436
1437 err = emu10k1x_midi_init(emu, midi, device: 0, name: "EMU10K1X MPU-401 (UART)");
1438 if (err < 0)
1439 return err;
1440
1441 midi->tx_enable = INTE_MIDITXENABLE;
1442 midi->rx_enable = INTE_MIDIRXENABLE;
1443 midi->port = MUDATA;
1444 midi->ipr_tx = IPR_MIDITRANSBUFEMPTY;
1445 midi->ipr_rx = IPR_MIDIRECVBUFEMPTY;
1446 midi->interrupt = snd_emu10k1x_midi_interrupt;
1447 return 0;
1448}
1449
1450static int __snd_emu10k1x_probe(struct pci_dev *pci,
1451 const struct pci_device_id *pci_id)
1452{
1453 static int dev;
1454 struct snd_card *card;
1455 struct emu10k1x *chip;
1456 int err;
1457
1458 if (dev >= SNDRV_CARDS)
1459 return -ENODEV;
1460 if (!enable[dev]) {
1461 dev++;
1462 return -ENOENT;
1463 }
1464
1465 err = snd_devm_card_new(parent: &pci->dev, idx: index[dev], xid: id[dev], THIS_MODULE,
1466 extra_size: sizeof(*chip), card_ret: &card);
1467 if (err < 0)
1468 return err;
1469 chip = card->private_data;
1470
1471 err = snd_emu10k1x_create(card, pci);
1472 if (err < 0)
1473 return err;
1474
1475 err = snd_emu10k1x_pcm(emu: chip, device: 0);
1476 if (err < 0)
1477 return err;
1478 err = snd_emu10k1x_pcm(emu: chip, device: 1);
1479 if (err < 0)
1480 return err;
1481 err = snd_emu10k1x_pcm(emu: chip, device: 2);
1482 if (err < 0)
1483 return err;
1484
1485 err = snd_emu10k1x_ac97(chip);
1486 if (err < 0)
1487 return err;
1488
1489 err = snd_emu10k1x_mixer(emu: chip);
1490 if (err < 0)
1491 return err;
1492
1493 err = snd_emu10k1x_midi(emu: chip);
1494 if (err < 0)
1495 return err;
1496
1497 snd_emu10k1x_proc_init(emu: chip);
1498
1499 strscpy(card->driver, "EMU10K1X");
1500 strscpy(card->shortname, "Dell Sound Blaster Live!");
1501 sprintf(buf: card->longname, fmt: "%s at 0x%lx irq %i",
1502 card->shortname, chip->port, chip->irq);
1503
1504 err = snd_card_register(card);
1505 if (err < 0)
1506 return err;
1507
1508 pci_set_drvdata(pdev: pci, data: card);
1509 dev++;
1510 return 0;
1511}
1512
1513static int snd_emu10k1x_probe(struct pci_dev *pci,
1514 const struct pci_device_id *pci_id)
1515{
1516 return snd_card_free_on_error(dev: &pci->dev, ret: __snd_emu10k1x_probe(pci, pci_id));
1517}
1518
1519// PCI IDs
1520static const struct pci_device_id snd_emu10k1x_ids[] = {
1521 { PCI_VDEVICE(CREATIVE, 0x0006), 0 }, /* Dell OEM version (EMU10K1) */
1522 { 0, }
1523};
1524MODULE_DEVICE_TABLE(pci, snd_emu10k1x_ids);
1525
1526// pci_driver definition
1527static struct pci_driver emu10k1x_driver = {
1528 .name = KBUILD_MODNAME,
1529 .id_table = snd_emu10k1x_ids,
1530 .probe = snd_emu10k1x_probe,
1531};
1532
1533module_pci_driver(emu10k1x_driver);
1534

source code of linux/sound/pci/emu10k1/emu10k1x.c