1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97#include <asm/io.h>
98#include <linux/delay.h>
99#include <linux/interrupt.h>
100#include <linux/init.h>
101#include <linux/pci.h>
102#include <linux/dma-mapping.h>
103#include <linux/slab.h>
104#include <linux/gameport.h>
105#include <linux/moduleparam.h>
106#include <linux/mutex.h>
107#include <linux/input.h>
108
109#include <sound/core.h>
110#include <sound/pcm.h>
111#include <sound/mpu401.h>
112#include <sound/ac97_codec.h>
113#include <sound/initval.h>
114
115#define CARD_NAME "ESS Maestro1/2"
116#define DRIVER_NAME "ES1968"
117
118MODULE_DESCRIPTION("ESS Maestro");
119MODULE_LICENSE("GPL");
120MODULE_SUPPORTED_DEVICE("{{ESS,Maestro 2e},"
121 "{ESS,Maestro 2},"
122 "{ESS,Maestro 1},"
123 "{TerraTec,DMX}}");
124
125#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
126#define SUPPORT_JOYSTICK 1
127#endif
128
129static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
130static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
131static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
132static int total_bufsize[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1024 };
133static int pcm_substreams_p[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 4 };
134static int pcm_substreams_c[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1 };
135static int clock[SNDRV_CARDS];
136static int use_pm[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2};
137static int enable_mpu[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2};
138#ifdef SUPPORT_JOYSTICK
139static int joystick[SNDRV_CARDS];
140#endif
141
142module_param_array(index, int, NULL, 0444);
143MODULE_PARM_DESC(index, "Index value for " CARD_NAME " soundcard.");
144module_param_array(id, charp, NULL, 0444);
145MODULE_PARM_DESC(id, "ID string for " CARD_NAME " soundcard.");
146module_param_array(enable, bool, NULL, 0444);
147MODULE_PARM_DESC(enable, "Enable " CARD_NAME " soundcard.");
148module_param_array(total_bufsize, int, NULL, 0444);
149MODULE_PARM_DESC(total_bufsize, "Total buffer size in kB.");
150module_param_array(pcm_substreams_p, int, NULL, 0444);
151MODULE_PARM_DESC(pcm_substreams_p, "PCM Playback substreams for " CARD_NAME " soundcard.");
152module_param_array(pcm_substreams_c, int, NULL, 0444);
153MODULE_PARM_DESC(pcm_substreams_c, "PCM Capture substreams for " CARD_NAME " soundcard.");
154module_param_array(clock, int, NULL, 0444);
155MODULE_PARM_DESC(clock, "Clock on " CARD_NAME " soundcard. (0 = auto-detect)");
156module_param_array(use_pm, int, NULL, 0444);
157MODULE_PARM_DESC(use_pm, "Toggle power-management. (0 = off, 1 = on, 2 = auto)");
158module_param_array(enable_mpu, int, NULL, 0444);
159MODULE_PARM_DESC(enable_mpu, "Enable MPU401. (0 = off, 1 = on, 2 = auto)");
160#ifdef SUPPORT_JOYSTICK
161module_param_array(joystick, bool, NULL, 0444);
162MODULE_PARM_DESC(joystick, "Enable joystick.");
163#endif
164
165
166#define NR_APUS 64
167#define NR_APU_REGS 16
168
169
170#define NEC_VERSA_SUBID1 0x80581033
171#define NEC_VERSA_SUBID2 0x803c1033
172
173
174#define ESS_FMT_STEREO 0x01
175#define ESS_FMT_16BIT 0x02
176
177#define DAC_RUNNING 1
178#define ADC_RUNNING 2
179
180
181
182#define ESS_DISABLE_AUDIO 0x8000
183#define ESS_ENABLE_SERIAL_IRQ 0x4000
184#define IO_ADRESS_ALIAS 0x0020
185#define MPU401_IRQ_ENABLE 0x0010
186#define MPU401_IO_ENABLE 0x0008
187#define GAME_IO_ENABLE 0x0004
188#define FM_IO_ENABLE 0x0002
189#define SB_IO_ENABLE 0x0001
190
191
192
193#define PIC_SNOOP1 0x4000
194#define PIC_SNOOP2 0x2000
195#define SAFEGUARD 0x0800
196#define DMA_CLEAR 0x0700
197#define DMA_DDMA 0x0000
198#define DMA_TDMA 0x0100
199#define DMA_PCPCI 0x0200
200#define POST_WRITE 0x0080
201#define PCI_TIMING 0x0040
202#define SWAP_LR 0x0020
203#define SUBTR_DECODE 0x0002
204
205
206
207#define SPDIF_CONFB 0x0100
208#define HWV_CONFB 0x0080
209#define DEBOUNCE 0x0040
210#define GPIO_CONFB 0x0020
211#define CHI_CONFB 0x0010
212#define IDMA_CONFB 0x0008
213#define MIDI_FIX 0x0004
214#define IRQ_TO_ISA 0x0001
215
216
217#define RINGB_2CODEC_ID_MASK 0x0003
218#define RINGB_DIS_VALIDATION 0x0008
219#define RINGB_EN_SPDIF 0x0010
220#define RINGB_EN_2CODEC 0x0020
221#define RINGB_SING_BIT_DUAL 0x0040
222
223
224
225
226#define ESM_INDEX 0x02
227#define ESM_DATA 0x00
228
229
230#define ESM_AC97_INDEX 0x30
231#define ESM_AC97_DATA 0x32
232#define ESM_RING_BUS_DEST 0x34
233#define ESM_RING_BUS_CONTR_A 0x36
234#define ESM_RING_BUS_CONTR_B 0x38
235#define ESM_RING_BUS_SDO 0x3A
236
237
238#define WC_INDEX 0x10
239#define WC_DATA 0x12
240#define WC_CONTROL 0x14
241
242
243#define ASSP_INDEX 0x80
244#define ASSP_MEMORY 0x82
245#define ASSP_DATA 0x84
246#define ASSP_CONTROL_A 0xA2
247#define ASSP_CONTROL_B 0xA4
248#define ASSP_CONTROL_C 0xA6
249#define ASSP_HOSTW_INDEX 0xA8
250#define ASSP_HOSTW_DATA 0xAA
251#define ASSP_HOSTW_IRQ 0xAC
252
253#define ESM_MPU401_PORT 0x98
254
255#define ESM_PORT_HOST_IRQ 0x18
256
257#define IDR0_DATA_PORT 0x00
258#define IDR1_CRAM_POINTER 0x01
259#define IDR2_CRAM_DATA 0x02
260#define IDR3_WAVE_DATA 0x03
261#define IDR4_WAVE_PTR_LOW 0x04
262#define IDR5_WAVE_PTR_HI 0x05
263#define IDR6_TIMER_CTRL 0x06
264#define IDR7_WAVE_ROMRAM 0x07
265
266#define WRITEABLE_MAP 0xEFFFFF
267#define READABLE_MAP 0x64003F
268
269
270
271#define ESM_LEGACY_AUDIO_CONTROL 0x40
272#define ESM_ACPI_COMMAND 0x54
273#define ESM_CONFIG_A 0x50
274#define ESM_CONFIG_B 0x52
275#define ESM_DDMA 0x60
276
277
278#define ESM_BOB_ENABLE 0x0001
279#define ESM_BOB_START 0x0001
280
281
282#define ESM_RESET_MAESTRO 0x8000
283#define ESM_RESET_DIRECTSOUND 0x4000
284#define ESM_HIRQ_ClkRun 0x0100
285#define ESM_HIRQ_HW_VOLUME 0x0040
286#define ESM_HIRQ_HARPO 0x0030
287#define ESM_HIRQ_ASSP 0x0010
288#define ESM_HIRQ_DSIE 0x0004
289#define ESM_HIRQ_MPU401 0x0002
290#define ESM_HIRQ_SB 0x0001
291
292
293#define ESM_MPU401_IRQ 0x02
294#define ESM_SB_IRQ 0x01
295#define ESM_SOUND_IRQ 0x04
296#define ESM_ASSP_IRQ 0x10
297#define ESM_HWVOL_IRQ 0x40
298
299#define ESS_SYSCLK 50000000
300#define ESM_BOB_FREQ 200
301#define ESM_BOB_FREQ_MAX 800
302
303#define ESM_FREQ_ESM1 (49152000L / 1024L)
304#define ESM_FREQ_ESM2 (50000000L / 1024L)
305
306
307#define ESM_APU_MODE_SHIFT 4
308#define ESM_APU_MODE_MASK (0xf << 4)
309#define ESM_APU_OFF 0x00
310#define ESM_APU_16BITLINEAR 0x01
311#define ESM_APU_16BITSTEREO 0x02
312#define ESM_APU_8BITLINEAR 0x03
313#define ESM_APU_8BITSTEREO 0x04
314#define ESM_APU_8BITDIFF 0x05
315#define ESM_APU_DIGITALDELAY 0x06
316#define ESM_APU_DUALTAP 0x07
317#define ESM_APU_CORRELATOR 0x08
318#define ESM_APU_INPUTMIXER 0x09
319#define ESM_APU_WAVETABLE 0x0A
320#define ESM_APU_SRCONVERTOR 0x0B
321#define ESM_APU_16BITPINGPONG 0x0C
322#define ESM_APU_RESERVED1 0x0D
323#define ESM_APU_RESERVED2 0x0E
324#define ESM_APU_RESERVED3 0x0F
325
326
327#define ESM_APU_FILTER_Q_SHIFT 0
328#define ESM_APU_FILTER_Q_MASK (3 << 0)
329
330#define ESM_APU_FILTER_LESSQ 0x00
331#define ESM_APU_FILTER_MOREQ 0x03
332
333#define ESM_APU_FILTER_TYPE_SHIFT 2
334#define ESM_APU_FILTER_TYPE_MASK (3 << 2)
335#define ESM_APU_ENV_TYPE_SHIFT 8
336#define ESM_APU_ENV_TYPE_MASK (3 << 8)
337#define ESM_APU_ENV_STATE_SHIFT 10
338#define ESM_APU_ENV_STATE_MASK (3 << 10)
339#define ESM_APU_END_CURVE (1 << 12)
340#define ESM_APU_INT_ON_LOOP (1 << 13)
341#define ESM_APU_DMA_ENABLE (1 << 14)
342
343
344#define ESM_APU_SUBMIX_GROUP_SHIRT 0
345#define ESM_APU_SUBMIX_GROUP_MASK (7 << 0)
346#define ESM_APU_SUBMIX_MODE (1 << 3)
347#define ESM_APU_6dB (1 << 4)
348#define ESM_APU_DUAL_EFFECT (1 << 5)
349#define ESM_APU_EFFECT_CHANNELS_SHIFT 6
350#define ESM_APU_EFFECT_CHANNELS_MASK (3 << 6)
351
352
353#define ESM_APU_STEP_SIZE_MASK 0x0fff
354
355
356#define ESM_APU_PHASE_SHIFT 0
357#define ESM_APU_PHASE_MASK (0xff << 0)
358#define ESM_APU_WAVE64K_PAGE_SHIFT 8
359#define ESM_APU_WAVE64K_PAGE_MASK (0xff << 8)
360
361
362
363
364
365
366#define ESM_APU_EFFECT_GAIN_SHIFT 0
367#define ESM_APU_EFFECT_GAIN_MASK (0xff << 0)
368#define ESM_APU_TREMOLO_DEPTH_SHIFT 8
369#define ESM_APU_TREMOLO_DEPTH_MASK (0xf << 8)
370#define ESM_APU_TREMOLO_RATE_SHIFT 12
371#define ESM_APU_TREMOLO_RATE_MASK (0xf << 12)
372
373
374
375#define ESM_APU_AMPLITUDE_NOW_SHIFT 8
376#define ESM_APU_AMPLITUDE_NOW_MASK (0xff << 8)
377
378
379#define ESM_APU_POLAR_PAN_SHIFT 0
380#define ESM_APU_POLAR_PAN_MASK (0x3f << 0)
381
382#define ESM_APU_PAN_CENTER_CIRCLE 0x00
383#define ESM_APU_PAN_MIDDLE_RADIUS 0x01
384#define ESM_APU_PAN_OUTSIDE_RADIUS 0x02
385
386#define ESM_APU_FILTER_TUNING_SHIFT 8
387#define ESM_APU_FILTER_TUNING_MASK (0xff << 8)
388
389
390#define ESM_APU_DATA_SRC_A_SHIFT 0
391#define ESM_APU_DATA_SRC_A_MASK (0x7f << 0)
392#define ESM_APU_INV_POL_A (1 << 7)
393#define ESM_APU_DATA_SRC_B_SHIFT 8
394#define ESM_APU_DATA_SRC_B_MASK (0x7f << 8)
395#define ESM_APU_INV_POL_B (1 << 15)
396
397#define ESM_APU_VIBRATO_RATE_SHIFT 0
398#define ESM_APU_VIBRATO_RATE_MASK (0xf << 0)
399#define ESM_APU_VIBRATO_DEPTH_SHIFT 4
400#define ESM_APU_VIBRATO_DEPTH_MASK (0xf << 4)
401#define ESM_APU_VIBRATO_PHASE_SHIFT 8
402#define ESM_APU_VIBRATO_PHASE_MASK (0xff << 8)
403
404
405#define ESM_APU_RADIUS_SELECT (1 << 6)
406
407
408#define ESM_APU_FILTER_2POLE_LOPASS 0x00
409#define ESM_APU_FILTER_2POLE_BANDPASS 0x01
410#define ESM_APU_FILTER_2POLE_HIPASS 0x02
411#define ESM_APU_FILTER_1POLE_LOPASS 0x03
412#define ESM_APU_FILTER_1POLE_HIPASS 0x04
413#define ESM_APU_FILTER_OFF 0x05
414
415
416#define ESM_APU_ATFP_AMPLITUDE 0x00
417#define ESM_APU_ATFP_TREMELO 0x01
418#define ESM_APU_ATFP_FILTER 0x02
419#define ESM_APU_ATFP_PAN 0x03
420
421
422#define ESM_APU_ATFP_FLG_OFF 0x00
423#define ESM_APU_ATFP_FLG_WAIT 0x01
424#define ESM_APU_ATFP_FLG_DONE 0x02
425#define ESM_APU_ATFP_FLG_INPROCESS 0x03
426
427
428
429#define ESM_MEM_ALIGN 0x1000
430#define ESM_MIXBUF_SIZE 0x400
431
432#define ESM_MODE_PLAY 0
433#define ESM_MODE_CAPTURE 1
434
435
436
437enum snd_enum_apu_type {
438 ESM_APU_PCM_PLAY,
439 ESM_APU_PCM_CAPTURE,
440 ESM_APU_PCM_RATECONV,
441 ESM_APU_FREE
442};
443
444
445enum {
446 TYPE_MAESTRO, TYPE_MAESTRO2, TYPE_MAESTRO2E
447};
448
449
450struct esm_memory {
451 struct snd_dma_buffer buf;
452 int empty;
453 struct list_head list;
454};
455
456
457struct esschan {
458 int running;
459
460 u8 apu[4];
461 u8 apu_mode[4];
462
463
464 struct esm_memory *memory;
465
466 struct esm_memory *mixbuf;
467
468 unsigned int hwptr;
469 unsigned int count;
470 unsigned int dma_size;
471 unsigned int frag_size;
472 unsigned int wav_shift;
473 u16 base[4];
474
475
476 unsigned char fmt;
477 int mode;
478
479 int bob_freq;
480
481 struct snd_pcm_substream *substream;
482
483
484 struct list_head list;
485
486#ifdef CONFIG_PM
487 u16 wc_map[4];
488#endif
489};
490
491struct es1968 {
492
493 int total_bufsize;
494
495 int playback_streams, capture_streams;
496
497 unsigned int clock;
498
499 unsigned int in_measurement: 1;
500 unsigned int measure_apu;
501 unsigned int measure_lastpos;
502 unsigned int measure_count;
503
504
505 struct snd_dma_buffer dma;
506
507
508 int irq;
509 unsigned long io_port;
510 int type;
511 struct pci_dev *pci;
512 struct snd_card *card;
513 struct snd_pcm *pcm;
514 int do_pm;
515
516
517 struct list_head buf_list;
518
519
520 struct snd_ac97 *ac97;
521 struct snd_rawmidi *rmidi;
522
523 spinlock_t reg_lock;
524 unsigned int in_suspend;
525
526
527 u16 maestro_map[32];
528 int bobclient;
529 int bob_freq;
530 struct mutex memory_mutex;
531
532
533 unsigned char apu[NR_APUS];
534
535
536 struct list_head substream_list;
537 spinlock_t substream_lock;
538
539#ifdef CONFIG_PM
540 u16 apu_map[NR_APUS][NR_APU_REGS];
541#endif
542
543#ifdef SUPPORT_JOYSTICK
544 struct gameport *gameport;
545#endif
546
547#ifdef CONFIG_SND_ES1968_INPUT
548 struct input_dev *input_dev;
549 char phys[64];
550#else
551 struct snd_kcontrol *master_switch;
552 struct snd_kcontrol *master_volume;
553 spinlock_t ac97_lock;
554 struct tasklet_struct hwvol_tq;
555#endif
556};
557
558static irqreturn_t snd_es1968_interrupt(int irq, void *dev_id);
559
560static DEFINE_PCI_DEVICE_TABLE(snd_es1968_ids) = {
561
562 { 0x1285, 0x0100, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_MULTIMEDIA_AUDIO << 8, 0xffff00, TYPE_MAESTRO },
563
564 { 0x125d, 0x1968, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_MULTIMEDIA_AUDIO << 8, 0xffff00, TYPE_MAESTRO2 },
565
566 { 0x125d, 0x1978, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_MULTIMEDIA_AUDIO << 8, 0xffff00, TYPE_MAESTRO2E },
567 { 0, }
568};
569
570MODULE_DEVICE_TABLE(pci, snd_es1968_ids);
571
572
573
574
575
576
577static void __maestro_write(struct es1968 *chip, u16 reg, u16 data)
578{
579 outw(reg, chip->io_port + ESM_INDEX);
580 outw(data, chip->io_port + ESM_DATA);
581 chip->maestro_map[reg] = data;
582}
583
584static inline void maestro_write(struct es1968 *chip, u16 reg, u16 data)
585{
586 unsigned long flags;
587 spin_lock_irqsave(&chip->reg_lock, flags);
588 __maestro_write(chip, reg, data);
589 spin_unlock_irqrestore(&chip->reg_lock, flags);
590}
591
592
593static u16 __maestro_read(struct es1968 *chip, u16 reg)
594{
595 if (READABLE_MAP & (1 << reg)) {
596 outw(reg, chip->io_port + ESM_INDEX);
597 chip->maestro_map[reg] = inw(chip->io_port + ESM_DATA);
598 }
599 return chip->maestro_map[reg];
600}
601
602static inline u16 maestro_read(struct es1968 *chip, u16 reg)
603{
604 unsigned long flags;
605 u16 result;
606 spin_lock_irqsave(&chip->reg_lock, flags);
607 result = __maestro_read(chip, reg);
608 spin_unlock_irqrestore(&chip->reg_lock, flags);
609 return result;
610}
611
612
613static int snd_es1968_ac97_wait(struct es1968 *chip)
614{
615 int timeout = 100000;
616
617 while (timeout-- > 0) {
618 if (!(inb(chip->io_port + ESM_AC97_INDEX) & 1))
619 return 0;
620 cond_resched();
621 }
622 snd_printd("es1968: ac97 timeout\n");
623 return 1;
624}
625
626static int snd_es1968_ac97_wait_poll(struct es1968 *chip)
627{
628 int timeout = 100000;
629
630 while (timeout-- > 0) {
631 if (!(inb(chip->io_port + ESM_AC97_INDEX) & 1))
632 return 0;
633 }
634 snd_printd("es1968: ac97 timeout\n");
635 return 1;
636}
637
638static void snd_es1968_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short val)
639{
640 struct es1968 *chip = ac97->private_data;
641#ifndef CONFIG_SND_ES1968_INPUT
642 unsigned long flags;
643#endif
644
645 snd_es1968_ac97_wait(chip);
646
647
648#ifndef CONFIG_SND_ES1968_INPUT
649 spin_lock_irqsave(&chip->ac97_lock, flags);
650#endif
651 outw(val, chip->io_port + ESM_AC97_DATA);
652
653 outb(reg, chip->io_port + ESM_AC97_INDEX);
654
655#ifndef CONFIG_SND_ES1968_INPUT
656 spin_unlock_irqrestore(&chip->ac97_lock, flags);
657#endif
658}
659
660static unsigned short snd_es1968_ac97_read(struct snd_ac97 *ac97, unsigned short reg)
661{
662 u16 data = 0;
663 struct es1968 *chip = ac97->private_data;
664#ifndef CONFIG_SND_ES1968_INPUT
665 unsigned long flags;
666#endif
667
668 snd_es1968_ac97_wait(chip);
669
670#ifndef CONFIG_SND_ES1968_INPUT
671 spin_lock_irqsave(&chip->ac97_lock, flags);
672#endif
673 outb(reg | 0x80, chip->io_port + ESM_AC97_INDEX);
674
675
676 if (!snd_es1968_ac97_wait_poll(chip)) {
677 data = inw(chip->io_port + ESM_AC97_DATA);
678
679 }
680#ifndef CONFIG_SND_ES1968_INPUT
681 spin_unlock_irqrestore(&chip->ac97_lock, flags);
682#endif
683
684 return data;
685}
686
687
688static void apu_index_set(struct es1968 *chip, u16 index)
689{
690 int i;
691 __maestro_write(chip, IDR1_CRAM_POINTER, index);
692 for (i = 0; i < 1000; i++)
693 if (__maestro_read(chip, IDR1_CRAM_POINTER) == index)
694 return;
695 snd_printd("es1968: APU register select failed. (Timeout)\n");
696}
697
698
699static void apu_data_set(struct es1968 *chip, u16 data)
700{
701 int i;
702 for (i = 0; i < 1000; i++) {
703 if (__maestro_read(chip, IDR0_DATA_PORT) == data)
704 return;
705 __maestro_write(chip, IDR0_DATA_PORT, data);
706 }
707 snd_printd("es1968: APU register set probably failed (Timeout)!\n");
708}
709
710
711static void __apu_set_register(struct es1968 *chip, u16 channel, u8 reg, u16 data)
712{
713 if (snd_BUG_ON(channel >= NR_APUS))
714 return;
715#ifdef CONFIG_PM
716 chip->apu_map[channel][reg] = data;
717#endif
718 reg |= (channel << 4);
719 apu_index_set(chip, reg);
720 apu_data_set(chip, data);
721}
722
723static void apu_set_register(struct es1968 *chip, u16 channel, u8 reg, u16 data)
724{
725 unsigned long flags;
726 spin_lock_irqsave(&chip->reg_lock, flags);
727 __apu_set_register(chip, channel, reg, data);
728 spin_unlock_irqrestore(&chip->reg_lock, flags);
729}
730
731static u16 __apu_get_register(struct es1968 *chip, u16 channel, u8 reg)
732{
733 if (snd_BUG_ON(channel >= NR_APUS))
734 return 0;
735 reg |= (channel << 4);
736 apu_index_set(chip, reg);
737 return __maestro_read(chip, IDR0_DATA_PORT);
738}
739
740static u16 apu_get_register(struct es1968 *chip, u16 channel, u8 reg)
741{
742 unsigned long flags;
743 u16 v;
744 spin_lock_irqsave(&chip->reg_lock, flags);
745 v = __apu_get_register(chip, channel, reg);
746 spin_unlock_irqrestore(&chip->reg_lock, flags);
747 return v;
748}
749
750#if 0
751
752static void assp_set_register(struct es1968 *chip, u32 reg, u32 value)
753{
754 unsigned long flags;
755
756 spin_lock_irqsave(&chip->reg_lock, flags);
757 outl(reg, chip->io_port + ASSP_INDEX);
758 outl(value, chip->io_port + ASSP_DATA);
759 spin_unlock_irqrestore(&chip->reg_lock, flags);
760}
761
762static u32 assp_get_register(struct es1968 *chip, u32 reg)
763{
764 unsigned long flags;
765 u32 value;
766
767 spin_lock_irqsave(&chip->reg_lock, flags);
768 outl(reg, chip->io_port + ASSP_INDEX);
769 value = inl(chip->io_port + ASSP_DATA);
770 spin_unlock_irqrestore(&chip->reg_lock, flags);
771
772 return value;
773}
774
775#endif
776
777static void wave_set_register(struct es1968 *chip, u16 reg, u16 value)
778{
779 unsigned long flags;
780
781 spin_lock_irqsave(&chip->reg_lock, flags);
782 outw(reg, chip->io_port + WC_INDEX);
783 outw(value, chip->io_port + WC_DATA);
784 spin_unlock_irqrestore(&chip->reg_lock, flags);
785}
786
787static u16 wave_get_register(struct es1968 *chip, u16 reg)
788{
789 unsigned long flags;
790 u16 value;
791
792 spin_lock_irqsave(&chip->reg_lock, flags);
793 outw(reg, chip->io_port + WC_INDEX);
794 value = inw(chip->io_port + WC_DATA);
795 spin_unlock_irqrestore(&chip->reg_lock, flags);
796
797 return value;
798}
799
800
801
802
803
804static void snd_es1968_bob_stop(struct es1968 *chip)
805{
806 u16 reg;
807
808 reg = __maestro_read(chip, 0x11);
809 reg &= ~ESM_BOB_ENABLE;
810 __maestro_write(chip, 0x11, reg);
811 reg = __maestro_read(chip, 0x17);
812 reg &= ~ESM_BOB_START;
813 __maestro_write(chip, 0x17, reg);
814}
815
816static void snd_es1968_bob_start(struct es1968 *chip)
817{
818 int prescale;
819 int divide;
820
821
822
823 for (prescale = 5; prescale < 12; prescale++)
824 if (chip->bob_freq > (ESS_SYSCLK >> (prescale + 9)))
825 break;
826
827
828 divide = 1;
829 while ((prescale > 5) && (divide < 32)) {
830 prescale--;
831 divide <<= 1;
832 }
833 divide >>= 1;
834
835
836 for (; divide < 31; divide++)
837 if (chip->bob_freq >
838 ((ESS_SYSCLK >> (prescale + 9)) / (divide + 1))) break;
839
840
841 if (divide == 0) {
842 divide++;
843 if (prescale > 5)
844 prescale--;
845 } else if (divide > 1)
846 divide--;
847
848 __maestro_write(chip, 6, 0x9000 | (prescale << 5) | divide);
849
850
851 __maestro_write(chip, 0x11, __maestro_read(chip, 0x11) | 1);
852 __maestro_write(chip, 0x17, __maestro_read(chip, 0x17) | 1);
853}
854
855
856static void snd_es1968_bob_inc(struct es1968 *chip, int freq)
857{
858 chip->bobclient++;
859 if (chip->bobclient == 1) {
860 chip->bob_freq = freq;
861 snd_es1968_bob_start(chip);
862 } else if (chip->bob_freq < freq) {
863 snd_es1968_bob_stop(chip);
864 chip->bob_freq = freq;
865 snd_es1968_bob_start(chip);
866 }
867}
868
869
870static void snd_es1968_bob_dec(struct es1968 *chip)
871{
872 chip->bobclient--;
873 if (chip->bobclient <= 0)
874 snd_es1968_bob_stop(chip);
875 else if (chip->bob_freq > ESM_BOB_FREQ) {
876
877 int max_freq = ESM_BOB_FREQ;
878 struct esschan *es;
879 list_for_each_entry(es, &chip->substream_list, list) {
880 if (max_freq < es->bob_freq)
881 max_freq = es->bob_freq;
882 }
883 if (max_freq != chip->bob_freq) {
884 snd_es1968_bob_stop(chip);
885 chip->bob_freq = max_freq;
886 snd_es1968_bob_start(chip);
887 }
888 }
889}
890
891static int
892snd_es1968_calc_bob_rate(struct es1968 *chip, struct esschan *es,
893 struct snd_pcm_runtime *runtime)
894{
895
896 int freq = runtime->rate * 4;
897 if (es->fmt & ESS_FMT_STEREO)
898 freq <<= 1;
899 if (es->fmt & ESS_FMT_16BIT)
900 freq <<= 1;
901 freq /= es->frag_size;
902 if (freq < ESM_BOB_FREQ)
903 freq = ESM_BOB_FREQ;
904 else if (freq > ESM_BOB_FREQ_MAX)
905 freq = ESM_BOB_FREQ_MAX;
906 return freq;
907}
908
909
910
911
912
913
914static u32 snd_es1968_compute_rate(struct es1968 *chip, u32 freq)
915{
916 u32 rate = (freq << 16) / chip->clock;
917#if 0
918 if (rate > 0x10000)
919 rate = 0x10000;
920#endif
921 return rate;
922}
923
924
925static inline unsigned int
926snd_es1968_get_dma_ptr(struct es1968 *chip, struct esschan *es)
927{
928 unsigned int offset;
929
930 offset = apu_get_register(chip, es->apu[0], 5);
931
932 offset -= es->base[0];
933
934 return (offset & 0xFFFE);
935}
936
937static void snd_es1968_apu_set_freq(struct es1968 *chip, int apu, int freq)
938{
939 apu_set_register(chip, apu, 2,
940 (apu_get_register(chip, apu, 2) & 0x00FF) |
941 ((freq & 0xff) << 8) | 0x10);
942 apu_set_register(chip, apu, 3, freq >> 8);
943}
944
945
946static inline void snd_es1968_trigger_apu(struct es1968 *esm, int apu, int mode)
947{
948
949 __apu_set_register(esm, apu, 0,
950 (__apu_get_register(esm, apu, 0) & 0xff0f) |
951 (mode << 4));
952}
953
954static void snd_es1968_pcm_start(struct es1968 *chip, struct esschan *es)
955{
956 spin_lock(&chip->reg_lock);
957 __apu_set_register(chip, es->apu[0], 5, es->base[0]);
958 snd_es1968_trigger_apu(chip, es->apu[0], es->apu_mode[0]);
959 if (es->mode == ESM_MODE_CAPTURE) {
960 __apu_set_register(chip, es->apu[2], 5, es->base[2]);
961 snd_es1968_trigger_apu(chip, es->apu[2], es->apu_mode[2]);
962 }
963 if (es->fmt & ESS_FMT_STEREO) {
964 __apu_set_register(chip, es->apu[1], 5, es->base[1]);
965 snd_es1968_trigger_apu(chip, es->apu[1], es->apu_mode[1]);
966 if (es->mode == ESM_MODE_CAPTURE) {
967 __apu_set_register(chip, es->apu[3], 5, es->base[3]);
968 snd_es1968_trigger_apu(chip, es->apu[3], es->apu_mode[3]);
969 }
970 }
971 spin_unlock(&chip->reg_lock);
972}
973
974static void snd_es1968_pcm_stop(struct es1968 *chip, struct esschan *es)
975{
976 spin_lock(&chip->reg_lock);
977 snd_es1968_trigger_apu(chip, es->apu[0], 0);
978 snd_es1968_trigger_apu(chip, es->apu[1], 0);
979 if (es->mode == ESM_MODE_CAPTURE) {
980 snd_es1968_trigger_apu(chip, es->apu[2], 0);
981 snd_es1968_trigger_apu(chip, es->apu[3], 0);
982 }
983 spin_unlock(&chip->reg_lock);
984}
985
986
987static void snd_es1968_program_wavecache(struct es1968 *chip, struct esschan *es,
988 int channel, u32 addr, int capture)
989{
990 u32 tmpval = (addr - 0x10) & 0xFFF8;
991
992 if (! capture) {
993 if (!(es->fmt & ESS_FMT_16BIT))
994 tmpval |= 4;
995 if (es->fmt & ESS_FMT_STEREO)
996 tmpval |= 2;
997 }
998
999
1000 wave_set_register(chip, es->apu[channel] << 3, tmpval);
1001
1002#ifdef CONFIG_PM
1003 es->wc_map[channel] = tmpval;
1004#endif
1005}
1006
1007
1008static void snd_es1968_playback_setup(struct es1968 *chip, struct esschan *es,
1009 struct snd_pcm_runtime *runtime)
1010{
1011 u32 pa;
1012 int high_apu = 0;
1013 int channel, apu;
1014 int i, size;
1015 unsigned long flags;
1016 u32 freq;
1017
1018 size = es->dma_size >> es->wav_shift;
1019
1020 if (es->fmt & ESS_FMT_STEREO)
1021 high_apu++;
1022
1023 for (channel = 0; channel <= high_apu; channel++) {
1024 apu = es->apu[channel];
1025
1026 snd_es1968_program_wavecache(chip, es, channel, es->memory->buf.addr, 0);
1027
1028
1029 pa = es->memory->buf.addr;
1030 pa -= chip->dma.addr;
1031 pa >>= 1;
1032
1033 pa |= 0x00400000;
1034
1035 if (es->fmt & ESS_FMT_STEREO) {
1036
1037 if (channel)
1038 pa |= 0x00800000;
1039 if (es->fmt & ESS_FMT_16BIT)
1040 pa >>= 1;
1041 }
1042
1043
1044
1045 es->base[channel] = pa & 0xFFFF;
1046
1047 for (i = 0; i < 16; i++)
1048 apu_set_register(chip, apu, i, 0x0000);
1049
1050
1051 apu_set_register(chip, apu, 4, ((pa >> 16) & 0xFF) << 8);
1052 apu_set_register(chip, apu, 5, pa & 0xFFFF);
1053 apu_set_register(chip, apu, 6, (pa + size) & 0xFFFF);
1054
1055 apu_set_register(chip, apu, 7, size);
1056
1057
1058 apu_set_register(chip, apu, 8, 0x0000);
1059
1060 apu_set_register(chip, apu, 9, 0xD000);
1061
1062
1063 apu_set_register(chip, apu, 11, 0x0000);
1064
1065 apu_set_register(chip, apu, 0, 0x400F);
1066
1067 if (es->fmt & ESS_FMT_16BIT)
1068 es->apu_mode[channel] = ESM_APU_16BITLINEAR;
1069 else
1070 es->apu_mode[channel] = ESM_APU_8BITLINEAR;
1071
1072 if (es->fmt & ESS_FMT_STEREO) {
1073
1074
1075
1076
1077
1078 apu_set_register(chip, apu, 10,
1079 0x8F00 | (channel ? 0 : 0x10));
1080 es->apu_mode[channel] += 1;
1081 } else
1082 apu_set_register(chip, apu, 10, 0x8F08);
1083 }
1084
1085 spin_lock_irqsave(&chip->reg_lock, flags);
1086
1087 outw(1, chip->io_port + 0x04);
1088
1089 outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ);
1090 spin_unlock_irqrestore(&chip->reg_lock, flags);
1091
1092 freq = runtime->rate;
1093
1094 if (freq > 48000)
1095 freq = 48000;
1096 if (freq < 4000)
1097 freq = 4000;
1098
1099
1100 if (!(es->fmt & ESS_FMT_16BIT) && !(es->fmt & ESS_FMT_STEREO))
1101 freq >>= 1;
1102
1103 freq = snd_es1968_compute_rate(chip, freq);
1104
1105
1106 snd_es1968_apu_set_freq(chip, es->apu[0], freq);
1107 snd_es1968_apu_set_freq(chip, es->apu[1], freq);
1108}
1109
1110
1111static void init_capture_apu(struct es1968 *chip, struct esschan *es, int channel,
1112 unsigned int pa, unsigned int bsize,
1113 int mode, int route)
1114{
1115 int i, apu = es->apu[channel];
1116
1117 es->apu_mode[channel] = mode;
1118
1119
1120 snd_es1968_program_wavecache(chip, es, channel, pa, 1);
1121
1122
1123 pa -= chip->dma.addr;
1124 pa >>= 1;
1125
1126
1127
1128 es->base[channel] = pa & 0xFFFF;
1129 pa |= 0x00400000;
1130
1131
1132 for (i = 0; i < 16; i++)
1133 apu_set_register(chip, apu, i, 0x0000);
1134
1135
1136
1137 apu_set_register(chip, apu, 2, 0x8);
1138
1139
1140 apu_set_register(chip, apu, 4, ((pa >> 16) & 0xFF) << 8);
1141 apu_set_register(chip, apu, 5, pa & 0xFFFF);
1142 apu_set_register(chip, apu, 6, (pa + bsize) & 0xFFFF);
1143 apu_set_register(chip, apu, 7, bsize);
1144
1145 apu_set_register(chip, apu, 8, 0x00F0);
1146
1147 apu_set_register(chip, apu, 9, 0x0000);
1148
1149 apu_set_register(chip, apu, 10, 0x8F08);
1150
1151 apu_set_register(chip, apu, 11, route);
1152
1153 apu_set_register(chip, apu, 0, 0x400F);
1154}
1155
1156static void snd_es1968_capture_setup(struct es1968 *chip, struct esschan *es,
1157 struct snd_pcm_runtime *runtime)
1158{
1159 int size;
1160 u32 freq;
1161 unsigned long flags;
1162
1163 size = es->dma_size >> es->wav_shift;
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177 init_capture_apu(chip, es, 2,
1178 es->mixbuf->buf.addr, ESM_MIXBUF_SIZE/4,
1179 ESM_APU_INPUTMIXER, 0x14);
1180
1181 init_capture_apu(chip, es, 0, es->memory->buf.addr, size,
1182 ESM_APU_SRCONVERTOR, es->apu[2]);
1183 if (es->fmt & ESS_FMT_STEREO) {
1184
1185 init_capture_apu(chip, es, 3,
1186 es->mixbuf->buf.addr + ESM_MIXBUF_SIZE/2,
1187 ESM_MIXBUF_SIZE/4,
1188 ESM_APU_INPUTMIXER, 0x15);
1189
1190 init_capture_apu(chip, es, 1,
1191 es->memory->buf.addr + size*2, size,
1192 ESM_APU_SRCONVERTOR, es->apu[3]);
1193 }
1194
1195 freq = runtime->rate;
1196
1197 if (freq > 47999)
1198 freq = 47999;
1199 if (freq < 4000)
1200 freq = 4000;
1201
1202 freq = snd_es1968_compute_rate(chip, freq);
1203
1204
1205 snd_es1968_apu_set_freq(chip, es->apu[0], freq);
1206 snd_es1968_apu_set_freq(chip, es->apu[1], freq);
1207
1208
1209 freq = 0x10000;
1210 snd_es1968_apu_set_freq(chip, es->apu[2], freq);
1211 snd_es1968_apu_set_freq(chip, es->apu[3], freq);
1212
1213 spin_lock_irqsave(&chip->reg_lock, flags);
1214
1215 outw(1, chip->io_port + 0x04);
1216
1217 outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ);
1218 spin_unlock_irqrestore(&chip->reg_lock, flags);
1219}
1220
1221
1222
1223
1224
1225static int snd_es1968_pcm_prepare(struct snd_pcm_substream *substream)
1226{
1227 struct es1968 *chip = snd_pcm_substream_chip(substream);
1228 struct snd_pcm_runtime *runtime = substream->runtime;
1229 struct esschan *es = runtime->private_data;
1230
1231 es->dma_size = snd_pcm_lib_buffer_bytes(substream);
1232 es->frag_size = snd_pcm_lib_period_bytes(substream);
1233
1234 es->wav_shift = 1;
1235 es->fmt = 0;
1236 if (snd_pcm_format_width(runtime->format) == 16)
1237 es->fmt |= ESS_FMT_16BIT;
1238 if (runtime->channels > 1) {
1239 es->fmt |= ESS_FMT_STEREO;
1240 if (es->fmt & ESS_FMT_16BIT)
1241 es->wav_shift++;
1242 }
1243 es->bob_freq = snd_es1968_calc_bob_rate(chip, es, runtime);
1244
1245 switch (es->mode) {
1246 case ESM_MODE_PLAY:
1247 snd_es1968_playback_setup(chip, es, runtime);
1248 break;
1249 case ESM_MODE_CAPTURE:
1250 snd_es1968_capture_setup(chip, es, runtime);
1251 break;
1252 }
1253
1254 return 0;
1255}
1256
1257static int snd_es1968_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
1258{
1259 struct es1968 *chip = snd_pcm_substream_chip(substream);
1260 struct esschan *es = substream->runtime->private_data;
1261
1262 spin_lock(&chip->substream_lock);
1263 switch (cmd) {
1264 case SNDRV_PCM_TRIGGER_START:
1265 case SNDRV_PCM_TRIGGER_RESUME:
1266 if (es->running)
1267 break;
1268 snd_es1968_bob_inc(chip, es->bob_freq);
1269 es->count = 0;
1270 es->hwptr = 0;
1271 snd_es1968_pcm_start(chip, es);
1272 es->running = 1;
1273 break;
1274 case SNDRV_PCM_TRIGGER_STOP:
1275 case SNDRV_PCM_TRIGGER_SUSPEND:
1276 if (! es->running)
1277 break;
1278 snd_es1968_pcm_stop(chip, es);
1279 es->running = 0;
1280 snd_es1968_bob_dec(chip);
1281 break;
1282 }
1283 spin_unlock(&chip->substream_lock);
1284 return 0;
1285}
1286
1287static snd_pcm_uframes_t snd_es1968_pcm_pointer(struct snd_pcm_substream *substream)
1288{
1289 struct es1968 *chip = snd_pcm_substream_chip(substream);
1290 struct esschan *es = substream->runtime->private_data;
1291 unsigned int ptr;
1292
1293 ptr = snd_es1968_get_dma_ptr(chip, es) << es->wav_shift;
1294
1295 return bytes_to_frames(substream->runtime, ptr % es->dma_size);
1296}
1297
1298static struct snd_pcm_hardware snd_es1968_playback = {
1299 .info = (SNDRV_PCM_INFO_MMAP |
1300 SNDRV_PCM_INFO_MMAP_VALID |
1301 SNDRV_PCM_INFO_INTERLEAVED |
1302 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1303
1304 SNDRV_PCM_INFO_RESUME),
1305 .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE,
1306 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
1307 .rate_min = 4000,
1308 .rate_max = 48000,
1309 .channels_min = 1,
1310 .channels_max = 2,
1311 .buffer_bytes_max = 65536,
1312 .period_bytes_min = 256,
1313 .period_bytes_max = 65536,
1314 .periods_min = 1,
1315 .periods_max = 1024,
1316 .fifo_size = 0,
1317};
1318
1319static struct snd_pcm_hardware snd_es1968_capture = {
1320 .info = (SNDRV_PCM_INFO_NONINTERLEAVED |
1321 SNDRV_PCM_INFO_MMAP |
1322 SNDRV_PCM_INFO_MMAP_VALID |
1323 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1324
1325 SNDRV_PCM_INFO_RESUME),
1326 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1327 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
1328 .rate_min = 4000,
1329 .rate_max = 48000,
1330 .channels_min = 1,
1331 .channels_max = 2,
1332 .buffer_bytes_max = 65536,
1333 .period_bytes_min = 256,
1334 .period_bytes_max = 65536,
1335 .periods_min = 1,
1336 .periods_max = 1024,
1337 .fifo_size = 0,
1338};
1339
1340
1341
1342
1343
1344
1345
1346
1347static int calc_available_memory_size(struct es1968 *chip)
1348{
1349 int max_size = 0;
1350 struct esm_memory *buf;
1351
1352 mutex_lock(&chip->memory_mutex);
1353 list_for_each_entry(buf, &chip->buf_list, list) {
1354 if (buf->empty && buf->buf.bytes > max_size)
1355 max_size = buf->buf.bytes;
1356 }
1357 mutex_unlock(&chip->memory_mutex);
1358 if (max_size >= 128*1024)
1359 max_size = 127*1024;
1360 return max_size;
1361}
1362
1363
1364static struct esm_memory *snd_es1968_new_memory(struct es1968 *chip, int size)
1365{
1366 struct esm_memory *buf;
1367
1368 size = ALIGN(size, ESM_MEM_ALIGN);
1369 mutex_lock(&chip->memory_mutex);
1370 list_for_each_entry(buf, &chip->buf_list, list) {
1371 if (buf->empty && buf->buf.bytes >= size)
1372 goto __found;
1373 }
1374 mutex_unlock(&chip->memory_mutex);
1375 return NULL;
1376
1377__found:
1378 if (buf->buf.bytes > size) {
1379 struct esm_memory *chunk = kmalloc(sizeof(*chunk), GFP_KERNEL);
1380 if (chunk == NULL) {
1381 mutex_unlock(&chip->memory_mutex);
1382 return NULL;
1383 }
1384 chunk->buf = buf->buf;
1385 chunk->buf.bytes -= size;
1386 chunk->buf.area += size;
1387 chunk->buf.addr += size;
1388 chunk->empty = 1;
1389 buf->buf.bytes = size;
1390 list_add(&chunk->list, &buf->list);
1391 }
1392 buf->empty = 0;
1393 mutex_unlock(&chip->memory_mutex);
1394 return buf;
1395}
1396
1397
1398static void snd_es1968_free_memory(struct es1968 *chip, struct esm_memory *buf)
1399{
1400 struct esm_memory *chunk;
1401
1402 mutex_lock(&chip->memory_mutex);
1403 buf->empty = 1;
1404 if (buf->list.prev != &chip->buf_list) {
1405 chunk = list_entry(buf->list.prev, struct esm_memory, list);
1406 if (chunk->empty) {
1407 chunk->buf.bytes += buf->buf.bytes;
1408 list_del(&buf->list);
1409 kfree(buf);
1410 buf = chunk;
1411 }
1412 }
1413 if (buf->list.next != &chip->buf_list) {
1414 chunk = list_entry(buf->list.next, struct esm_memory, list);
1415 if (chunk->empty) {
1416 buf->buf.bytes += chunk->buf.bytes;
1417 list_del(&chunk->list);
1418 kfree(chunk);
1419 }
1420 }
1421 mutex_unlock(&chip->memory_mutex);
1422}
1423
1424static void snd_es1968_free_dmabuf(struct es1968 *chip)
1425{
1426 struct list_head *p;
1427
1428 if (! chip->dma.area)
1429 return;
1430 snd_dma_reserve_buf(&chip->dma, snd_dma_pci_buf_id(chip->pci));
1431 while ((p = chip->buf_list.next) != &chip->buf_list) {
1432 struct esm_memory *chunk = list_entry(p, struct esm_memory, list);
1433 list_del(p);
1434 kfree(chunk);
1435 }
1436}
1437
1438static int __devinit
1439snd_es1968_init_dmabuf(struct es1968 *chip)
1440{
1441 int err;
1442 struct esm_memory *chunk;
1443
1444 chip->dma.dev.type = SNDRV_DMA_TYPE_DEV;
1445 chip->dma.dev.dev = snd_dma_pci_data(chip->pci);
1446 if (! snd_dma_get_reserved_buf(&chip->dma, snd_dma_pci_buf_id(chip->pci))) {
1447 err = snd_dma_alloc_pages_fallback(SNDRV_DMA_TYPE_DEV,
1448 snd_dma_pci_data(chip->pci),
1449 chip->total_bufsize, &chip->dma);
1450 if (err < 0 || ! chip->dma.area) {
1451 snd_printk(KERN_ERR "es1968: can't allocate dma pages for size %d\n",
1452 chip->total_bufsize);
1453 return -ENOMEM;
1454 }
1455 if ((chip->dma.addr + chip->dma.bytes - 1) & ~((1 << 28) - 1)) {
1456 snd_dma_free_pages(&chip->dma);
1457 snd_printk(KERN_ERR "es1968: DMA buffer beyond 256MB.\n");
1458 return -ENOMEM;
1459 }
1460 }
1461
1462 INIT_LIST_HEAD(&chip->buf_list);
1463
1464 chunk = kmalloc(sizeof(*chunk), GFP_KERNEL);
1465 if (chunk == NULL) {
1466 snd_es1968_free_dmabuf(chip);
1467 return -ENOMEM;
1468 }
1469 memset(chip->dma.area, 0, ESM_MEM_ALIGN);
1470 chunk->buf = chip->dma;
1471 chunk->buf.area += ESM_MEM_ALIGN;
1472 chunk->buf.addr += ESM_MEM_ALIGN;
1473 chunk->buf.bytes -= ESM_MEM_ALIGN;
1474 chunk->empty = 1;
1475 list_add(&chunk->list, &chip->buf_list);
1476
1477 return 0;
1478}
1479
1480
1481
1482static int snd_es1968_hw_params(struct snd_pcm_substream *substream,
1483 struct snd_pcm_hw_params *hw_params)
1484{
1485 struct es1968 *chip = snd_pcm_substream_chip(substream);
1486 struct snd_pcm_runtime *runtime = substream->runtime;
1487 struct esschan *chan = runtime->private_data;
1488 int size = params_buffer_bytes(hw_params);
1489
1490 if (chan->memory) {
1491 if (chan->memory->buf.bytes >= size) {
1492 runtime->dma_bytes = size;
1493 return 0;
1494 }
1495 snd_es1968_free_memory(chip, chan->memory);
1496 }
1497 chan->memory = snd_es1968_new_memory(chip, size);
1498 if (chan->memory == NULL) {
1499
1500 return -ENOMEM;
1501 }
1502 snd_pcm_set_runtime_buffer(substream, &chan->memory->buf);
1503 return 1;
1504}
1505
1506
1507static int snd_es1968_hw_free(struct snd_pcm_substream *substream)
1508{
1509 struct es1968 *chip = snd_pcm_substream_chip(substream);
1510 struct snd_pcm_runtime *runtime = substream->runtime;
1511 struct esschan *chan;
1512
1513 if (runtime->private_data == NULL)
1514 return 0;
1515 chan = runtime->private_data;
1516 if (chan->memory) {
1517 snd_es1968_free_memory(chip, chan->memory);
1518 chan->memory = NULL;
1519 }
1520 return 0;
1521}
1522
1523
1524
1525
1526
1527static int snd_es1968_alloc_apu_pair(struct es1968 *chip, int type)
1528{
1529 int apu;
1530
1531 for (apu = 0; apu < NR_APUS; apu += 2) {
1532 if (chip->apu[apu] == ESM_APU_FREE &&
1533 chip->apu[apu + 1] == ESM_APU_FREE) {
1534 chip->apu[apu] = chip->apu[apu + 1] = type;
1535 return apu;
1536 }
1537 }
1538 return -EBUSY;
1539}
1540
1541
1542
1543
1544static void snd_es1968_free_apu_pair(struct es1968 *chip, int apu)
1545{
1546 chip->apu[apu] = chip->apu[apu + 1] = ESM_APU_FREE;
1547}
1548
1549
1550
1551
1552
1553
1554static int snd_es1968_playback_open(struct snd_pcm_substream *substream)
1555{
1556 struct es1968 *chip = snd_pcm_substream_chip(substream);
1557 struct snd_pcm_runtime *runtime = substream->runtime;
1558 struct esschan *es;
1559 int apu1;
1560
1561
1562 apu1 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_PLAY);
1563 if (apu1 < 0)
1564 return apu1;
1565
1566 es = kzalloc(sizeof(*es), GFP_KERNEL);
1567 if (!es) {
1568 snd_es1968_free_apu_pair(chip, apu1);
1569 return -ENOMEM;
1570 }
1571
1572 es->apu[0] = apu1;
1573 es->apu[1] = apu1 + 1;
1574 es->apu_mode[0] = 0;
1575 es->apu_mode[1] = 0;
1576 es->running = 0;
1577 es->substream = substream;
1578 es->mode = ESM_MODE_PLAY;
1579
1580 runtime->private_data = es;
1581 runtime->hw = snd_es1968_playback;
1582 runtime->hw.buffer_bytes_max = runtime->hw.period_bytes_max =
1583 calc_available_memory_size(chip);
1584
1585 spin_lock_irq(&chip->substream_lock);
1586 list_add(&es->list, &chip->substream_list);
1587 spin_unlock_irq(&chip->substream_lock);
1588
1589 return 0;
1590}
1591
1592static int snd_es1968_capture_open(struct snd_pcm_substream *substream)
1593{
1594 struct snd_pcm_runtime *runtime = substream->runtime;
1595 struct es1968 *chip = snd_pcm_substream_chip(substream);
1596 struct esschan *es;
1597 int apu1, apu2;
1598
1599 apu1 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_CAPTURE);
1600 if (apu1 < 0)
1601 return apu1;
1602 apu2 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_RATECONV);
1603 if (apu2 < 0) {
1604 snd_es1968_free_apu_pair(chip, apu1);
1605 return apu2;
1606 }
1607
1608 es = kzalloc(sizeof(*es), GFP_KERNEL);
1609 if (!es) {
1610 snd_es1968_free_apu_pair(chip, apu1);
1611 snd_es1968_free_apu_pair(chip, apu2);
1612 return -ENOMEM;
1613 }
1614
1615 es->apu[0] = apu1;
1616 es->apu[1] = apu1 + 1;
1617 es->apu[2] = apu2;
1618 es->apu[3] = apu2 + 1;
1619 es->apu_mode[0] = 0;
1620 es->apu_mode[1] = 0;
1621 es->apu_mode[2] = 0;
1622 es->apu_mode[3] = 0;
1623 es->running = 0;
1624 es->substream = substream;
1625 es->mode = ESM_MODE_CAPTURE;
1626
1627
1628 if ((es->mixbuf = snd_es1968_new_memory(chip, ESM_MIXBUF_SIZE)) == NULL) {
1629 snd_es1968_free_apu_pair(chip, apu1);
1630 snd_es1968_free_apu_pair(chip, apu2);
1631 kfree(es);
1632 return -ENOMEM;
1633 }
1634 memset(es->mixbuf->buf.area, 0, ESM_MIXBUF_SIZE);
1635
1636 runtime->private_data = es;
1637 runtime->hw = snd_es1968_capture;
1638 runtime->hw.buffer_bytes_max = runtime->hw.period_bytes_max =
1639 calc_available_memory_size(chip) - 1024;
1640 snd_pcm_hw_constraint_pow2(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES);
1641
1642 spin_lock_irq(&chip->substream_lock);
1643 list_add(&es->list, &chip->substream_list);
1644 spin_unlock_irq(&chip->substream_lock);
1645
1646 return 0;
1647}
1648
1649static int snd_es1968_playback_close(struct snd_pcm_substream *substream)
1650{
1651 struct es1968 *chip = snd_pcm_substream_chip(substream);
1652 struct esschan *es;
1653
1654 if (substream->runtime->private_data == NULL)
1655 return 0;
1656 es = substream->runtime->private_data;
1657 spin_lock_irq(&chip->substream_lock);
1658 list_del(&es->list);
1659 spin_unlock_irq(&chip->substream_lock);
1660 snd_es1968_free_apu_pair(chip, es->apu[0]);
1661 kfree(es);
1662
1663 return 0;
1664}
1665
1666static int snd_es1968_capture_close(struct snd_pcm_substream *substream)
1667{
1668 struct es1968 *chip = snd_pcm_substream_chip(substream);
1669 struct esschan *es;
1670
1671 if (substream->runtime->private_data == NULL)
1672 return 0;
1673 es = substream->runtime->private_data;
1674 spin_lock_irq(&chip->substream_lock);
1675 list_del(&es->list);
1676 spin_unlock_irq(&chip->substream_lock);
1677 snd_es1968_free_memory(chip, es->mixbuf);
1678 snd_es1968_free_apu_pair(chip, es->apu[0]);
1679 snd_es1968_free_apu_pair(chip, es->apu[2]);
1680 kfree(es);
1681
1682 return 0;
1683}
1684
1685static struct snd_pcm_ops snd_es1968_playback_ops = {
1686 .open = snd_es1968_playback_open,
1687 .close = snd_es1968_playback_close,
1688 .ioctl = snd_pcm_lib_ioctl,
1689 .hw_params = snd_es1968_hw_params,
1690 .hw_free = snd_es1968_hw_free,
1691 .prepare = snd_es1968_pcm_prepare,
1692 .trigger = snd_es1968_pcm_trigger,
1693 .pointer = snd_es1968_pcm_pointer,
1694};
1695
1696static struct snd_pcm_ops snd_es1968_capture_ops = {
1697 .open = snd_es1968_capture_open,
1698 .close = snd_es1968_capture_close,
1699 .ioctl = snd_pcm_lib_ioctl,
1700 .hw_params = snd_es1968_hw_params,
1701 .hw_free = snd_es1968_hw_free,
1702 .prepare = snd_es1968_pcm_prepare,
1703 .trigger = snd_es1968_pcm_trigger,
1704 .pointer = snd_es1968_pcm_pointer,
1705};
1706
1707
1708
1709
1710
1711#define CLOCK_MEASURE_BUFSIZE 16768
1712
1713static void __devinit es1968_measure_clock(struct es1968 *chip)
1714{
1715 int i, apu;
1716 unsigned int pa, offset, t;
1717 struct esm_memory *memory;
1718 struct timeval start_time, stop_time;
1719
1720 if (chip->clock == 0)
1721 chip->clock = 48000;
1722
1723
1724 if ((apu = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_PLAY)) < 0) {
1725 snd_printk(KERN_ERR "Hmm, cannot find empty APU pair!?\n");
1726 return;
1727 }
1728 if ((memory = snd_es1968_new_memory(chip, CLOCK_MEASURE_BUFSIZE)) == NULL) {
1729 snd_printk(KERN_ERR "cannot allocate dma buffer - using default clock %d\n", chip->clock);
1730 snd_es1968_free_apu_pair(chip, apu);
1731 return;
1732 }
1733
1734 memset(memory->buf.area, 0, CLOCK_MEASURE_BUFSIZE);
1735
1736 wave_set_register(chip, apu << 3, (memory->buf.addr - 0x10) & 0xfff8);
1737
1738 pa = (unsigned int)((memory->buf.addr - chip->dma.addr) >> 1);
1739 pa |= 0x00400000;
1740
1741
1742 for (i = 0; i < 16; i++)
1743 apu_set_register(chip, apu, i, 0x0000);
1744
1745 apu_set_register(chip, apu, 0, 0x400f);
1746 apu_set_register(chip, apu, 4, ((pa >> 16) & 0xff) << 8);
1747 apu_set_register(chip, apu, 5, pa & 0xffff);
1748 apu_set_register(chip, apu, 6, (pa + CLOCK_MEASURE_BUFSIZE/2) & 0xffff);
1749 apu_set_register(chip, apu, 7, CLOCK_MEASURE_BUFSIZE/2);
1750 apu_set_register(chip, apu, 8, 0x0000);
1751 apu_set_register(chip, apu, 9, 0xD000);
1752 apu_set_register(chip, apu, 10, 0x8F08);
1753 apu_set_register(chip, apu, 11, 0x0000);
1754 spin_lock_irq(&chip->reg_lock);
1755 outw(1, chip->io_port + 0x04);
1756 outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ);
1757 spin_unlock_irq(&chip->reg_lock);
1758
1759 snd_es1968_apu_set_freq(chip, apu, ((unsigned int)48000 << 16) / chip->clock);
1760
1761 chip->in_measurement = 1;
1762 chip->measure_apu = apu;
1763 spin_lock_irq(&chip->reg_lock);
1764 snd_es1968_bob_inc(chip, ESM_BOB_FREQ);
1765 __apu_set_register(chip, apu, 5, pa & 0xffff);
1766 snd_es1968_trigger_apu(chip, apu, ESM_APU_16BITLINEAR);
1767 do_gettimeofday(&start_time);
1768 spin_unlock_irq(&chip->reg_lock);
1769 msleep(50);
1770 spin_lock_irq(&chip->reg_lock);
1771 offset = __apu_get_register(chip, apu, 5);
1772 do_gettimeofday(&stop_time);
1773 snd_es1968_trigger_apu(chip, apu, 0);
1774 snd_es1968_bob_dec(chip);
1775 chip->in_measurement = 0;
1776 spin_unlock_irq(&chip->reg_lock);
1777
1778
1779 offset -= (pa & 0xffff);
1780 offset &= 0xfffe;
1781 offset += chip->measure_count * (CLOCK_MEASURE_BUFSIZE/2);
1782
1783 t = stop_time.tv_sec - start_time.tv_sec;
1784 t *= 1000000;
1785 if (stop_time.tv_usec < start_time.tv_usec)
1786 t -= start_time.tv_usec - stop_time.tv_usec;
1787 else
1788 t += stop_time.tv_usec - start_time.tv_usec;
1789 if (t == 0) {
1790 snd_printk(KERN_ERR "?? calculation error..\n");
1791 } else {
1792 offset *= 1000;
1793 offset = (offset / t) * 1000 + ((offset % t) * 1000) / t;
1794 if (offset < 47500 || offset > 48500) {
1795 if (offset >= 40000 && offset <= 50000)
1796 chip->clock = (chip->clock * offset) / 48000;
1797 }
1798 printk(KERN_INFO "es1968: clocking to %d\n", chip->clock);
1799 }
1800 snd_es1968_free_memory(chip, memory);
1801 snd_es1968_free_apu_pair(chip, apu);
1802}
1803
1804
1805
1806
1807
1808static void snd_es1968_pcm_free(struct snd_pcm *pcm)
1809{
1810 struct es1968 *esm = pcm->private_data;
1811 snd_es1968_free_dmabuf(esm);
1812 esm->pcm = NULL;
1813}
1814
1815static int __devinit
1816snd_es1968_pcm(struct es1968 *chip, int device)
1817{
1818 struct snd_pcm *pcm;
1819 int err;
1820
1821
1822 if ((err = snd_es1968_init_dmabuf(chip)) < 0)
1823 return err;
1824
1825
1826 wave_set_register(chip, 0x01FC, chip->dma.addr >> 12);
1827 wave_set_register(chip, 0x01FD, chip->dma.addr >> 12);
1828 wave_set_register(chip, 0x01FE, chip->dma.addr >> 12);
1829 wave_set_register(chip, 0x01FF, chip->dma.addr >> 12);
1830
1831 if ((err = snd_pcm_new(chip->card, "ESS Maestro", device,
1832 chip->playback_streams,
1833 chip->capture_streams, &pcm)) < 0)
1834 return err;
1835
1836 pcm->private_data = chip;
1837 pcm->private_free = snd_es1968_pcm_free;
1838
1839 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_es1968_playback_ops);
1840 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1968_capture_ops);
1841
1842 pcm->info_flags = 0;
1843
1844 strcpy(pcm->name, "ESS Maestro");
1845
1846 chip->pcm = pcm;
1847
1848 return 0;
1849}
1850
1851
1852
1853static void snd_es1968_suppress_jitter(struct es1968 *chip, struct esschan *es)
1854{
1855 unsigned int cp1;
1856 unsigned int cp2;
1857 unsigned int diff;
1858
1859 cp1 = __apu_get_register(chip, 0, 5);
1860 cp2 = __apu_get_register(chip, 1, 5);
1861 diff = (cp1 > cp2 ? cp1 - cp2 : cp2 - cp1);
1862
1863 if (diff > 1)
1864 __maestro_write(chip, IDR0_DATA_PORT, cp1);
1865}
1866
1867
1868
1869
1870static void snd_es1968_update_pcm(struct es1968 *chip, struct esschan *es)
1871{
1872 unsigned int hwptr;
1873 unsigned int diff;
1874 struct snd_pcm_substream *subs = es->substream;
1875
1876 if (subs == NULL || !es->running)
1877 return;
1878
1879 hwptr = snd_es1968_get_dma_ptr(chip, es) << es->wav_shift;
1880 hwptr %= es->dma_size;
1881
1882 diff = (es->dma_size + hwptr - es->hwptr) % es->dma_size;
1883
1884 es->hwptr = hwptr;
1885 es->count += diff;
1886
1887 if (es->count > es->frag_size) {
1888 spin_unlock(&chip->substream_lock);
1889 snd_pcm_period_elapsed(subs);
1890 spin_lock(&chip->substream_lock);
1891 es->count %= es->frag_size;
1892 }
1893}
1894
1895
1896
1897
1898
1899static void es1968_update_hw_volume(unsigned long private_data)
1900{
1901 struct es1968 *chip = (struct es1968 *) private_data;
1902 int x, val;
1903#ifndef CONFIG_SND_ES1968_INPUT
1904 unsigned long flags;
1905#endif
1906
1907
1908
1909
1910 x = inb(chip->io_port + 0x1c) & 0xee;
1911
1912 outb(0x88, chip->io_port + 0x1c);
1913 outb(0x88, chip->io_port + 0x1d);
1914 outb(0x88, chip->io_port + 0x1e);
1915 outb(0x88, chip->io_port + 0x1f);
1916
1917 if (chip->in_suspend)
1918 return;
1919
1920#ifndef CONFIG_SND_ES1968_INPUT
1921 if (! chip->master_switch || ! chip->master_volume)
1922 return;
1923
1924
1925 spin_lock_irqsave(&chip->ac97_lock, flags);
1926 val = chip->ac97->regs[AC97_MASTER];
1927 switch (x) {
1928 case 0x88:
1929
1930 val ^= 0x8000;
1931 chip->ac97->regs[AC97_MASTER] = val;
1932 outw(val, chip->io_port + ESM_AC97_DATA);
1933 outb(AC97_MASTER, chip->io_port + ESM_AC97_INDEX);
1934 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1935 &chip->master_switch->id);
1936 break;
1937 case 0xaa:
1938
1939 if ((val & 0x7f) > 0)
1940 val--;
1941 if ((val & 0x7f00) > 0)
1942 val -= 0x0100;
1943 chip->ac97->regs[AC97_MASTER] = val;
1944 outw(val, chip->io_port + ESM_AC97_DATA);
1945 outb(AC97_MASTER, chip->io_port + ESM_AC97_INDEX);
1946 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1947 &chip->master_volume->id);
1948 break;
1949 case 0x66:
1950
1951 if ((val & 0x7f) < 0x1f)
1952 val++;
1953 if ((val & 0x7f00) < 0x1f00)
1954 val += 0x0100;
1955 chip->ac97->regs[AC97_MASTER] = val;
1956 outw(val, chip->io_port + ESM_AC97_DATA);
1957 outb(AC97_MASTER, chip->io_port + ESM_AC97_INDEX);
1958 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1959 &chip->master_volume->id);
1960 break;
1961 }
1962 spin_unlock_irqrestore(&chip->ac97_lock, flags);
1963#else
1964 if (!chip->input_dev)
1965 return;
1966
1967 val = 0;
1968 switch (x) {
1969 case 0x88:
1970
1971
1972
1973 val = KEY_MUTE;
1974 break;
1975 case 0xaa:
1976
1977 val = KEY_VOLUMEUP;
1978 break;
1979 case 0x66:
1980
1981 val = KEY_VOLUMEDOWN;
1982 break;
1983 }
1984
1985 if (val) {
1986 input_report_key(chip->input_dev, val, 1);
1987 input_sync(chip->input_dev);
1988 input_report_key(chip->input_dev, val, 0);
1989 input_sync(chip->input_dev);
1990 }
1991#endif
1992}
1993
1994
1995
1996
1997static irqreturn_t snd_es1968_interrupt(int irq, void *dev_id)
1998{
1999 struct es1968 *chip = dev_id;
2000 u32 event;
2001
2002 if (!(event = inb(chip->io_port + 0x1A)))
2003 return IRQ_NONE;
2004
2005 outw(inw(chip->io_port + 4) & 1, chip->io_port + 4);
2006
2007 if (event & ESM_HWVOL_IRQ)
2008#ifdef CONFIG_SND_ES1968_INPUT
2009 es1968_update_hw_volume((unsigned long)chip);
2010#else
2011 tasklet_schedule(&chip->hwvol_tq);
2012#endif
2013
2014
2015 outb(0xFF, chip->io_port + 0x1A);
2016
2017 if ((event & ESM_MPU401_IRQ) && chip->rmidi) {
2018 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data);
2019 }
2020
2021 if (event & ESM_SOUND_IRQ) {
2022 struct esschan *es;
2023 spin_lock(&chip->substream_lock);
2024 list_for_each_entry(es, &chip->substream_list, list) {
2025 if (es->running) {
2026 snd_es1968_update_pcm(chip, es);
2027 if (es->fmt & ESS_FMT_STEREO)
2028 snd_es1968_suppress_jitter(chip, es);
2029 }
2030 }
2031 spin_unlock(&chip->substream_lock);
2032 if (chip->in_measurement) {
2033 unsigned int curp = __apu_get_register(chip, chip->measure_apu, 5);
2034 if (curp < chip->measure_lastpos)
2035 chip->measure_count++;
2036 chip->measure_lastpos = curp;
2037 }
2038 }
2039
2040 return IRQ_HANDLED;
2041}
2042
2043
2044
2045
2046
2047static int __devinit
2048snd_es1968_mixer(struct es1968 *chip)
2049{
2050 struct snd_ac97_bus *pbus;
2051 struct snd_ac97_template ac97;
2052#ifndef CONFIG_SND_ES1968_INPUT
2053 struct snd_ctl_elem_id elem_id;
2054#endif
2055 int err;
2056 static struct snd_ac97_bus_ops ops = {
2057 .write = snd_es1968_ac97_write,
2058 .read = snd_es1968_ac97_read,
2059 };
2060
2061 if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &pbus)) < 0)
2062 return err;
2063 pbus->no_vra = 1;
2064
2065 memset(&ac97, 0, sizeof(ac97));
2066 ac97.private_data = chip;
2067 if ((err = snd_ac97_mixer(pbus, &ac97, &chip->ac97)) < 0)
2068 return err;
2069
2070#ifndef CONFIG_SND_ES1968_INPUT
2071
2072 memset(&elem_id, 0, sizeof(elem_id));
2073 elem_id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2074 strcpy(elem_id.name, "Master Playback Switch");
2075 chip->master_switch = snd_ctl_find_id(chip->card, &elem_id);
2076 memset(&elem_id, 0, sizeof(elem_id));
2077 elem_id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2078 strcpy(elem_id.name, "Master Playback Volume");
2079 chip->master_volume = snd_ctl_find_id(chip->card, &elem_id);
2080#endif
2081
2082 return 0;
2083}
2084
2085
2086
2087
2088
2089static void snd_es1968_ac97_reset(struct es1968 *chip)
2090{
2091 unsigned long ioaddr = chip->io_port;
2092
2093 unsigned short save_ringbus_a;
2094 unsigned short save_68;
2095 unsigned short w;
2096 unsigned int vend;
2097
2098
2099 save_ringbus_a = inw(ioaddr + 0x36);
2100
2101
2102
2103 outw(inw(ioaddr + 0x3a) & 0xfffc, ioaddr + 0x3a);
2104 outw(inw(ioaddr + 0x3c) & 0xfffc, ioaddr + 0x3c);
2105
2106
2107 outw(0x0000, ioaddr + 0x36);
2108 save_68 = inw(ioaddr + 0x68);
2109 pci_read_config_word(chip->pci, 0x58, &w);
2110 pci_read_config_dword(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2111 if (w & 1)
2112 save_68 |= 0x10;
2113 outw(0xfffe, ioaddr + 0x64);
2114 outw(0x0001, ioaddr + 0x68);
2115 outw(0x0000, ioaddr + 0x60);
2116 udelay(20);
2117 outw(0x0001, ioaddr + 0x60);
2118 msleep(20);
2119
2120 outw(save_68 | 0x1, ioaddr + 0x68);
2121 outw((inw(ioaddr + 0x38) & 0xfffc) | 0x1, ioaddr + 0x38);
2122 outw((inw(ioaddr + 0x3a) & 0xfffc) | 0x1, ioaddr + 0x3a);
2123 outw((inw(ioaddr + 0x3c) & 0xfffc) | 0x1, ioaddr + 0x3c);
2124
2125
2126
2127 outw(0x0000, ioaddr + 0x36);
2128 outw(0xfff7, ioaddr + 0x64);
2129 save_68 = inw(ioaddr + 0x68);
2130 outw(0x0009, ioaddr + 0x68);
2131 outw(0x0001, ioaddr + 0x60);
2132 udelay(20);
2133 outw(0x0009, ioaddr + 0x60);
2134 msleep(500);
2135
2136 outw(inw(ioaddr + 0x3a) & 0xfffc, ioaddr + 0x3a);
2137 outw(inw(ioaddr + 0x3c) & 0xfffc, ioaddr + 0x3c);
2138
2139#if 0
2140 snd_printk(KERN_INFO "trying software reset\n");
2141
2142 outb(0x80 | 0x7c, ioaddr + 0x30);
2143 for (w = 0;; w++) {
2144 if ((inw(ioaddr + 0x30) & 1) == 0) {
2145 if (inb(ioaddr + 0x32) != 0)
2146 break;
2147
2148 outb(0x80 | 0x7d, ioaddr + 0x30);
2149 if (((inw(ioaddr + 0x30) & 1) == 0)
2150 && (inb(ioaddr + 0x32) != 0))
2151 break;
2152 outb(0x80 | 0x7f, ioaddr + 0x30);
2153 if (((inw(ioaddr + 0x30) & 1) == 0)
2154 && (inb(ioaddr + 0x32) != 0))
2155 break;
2156 }
2157
2158 if (w > 10000) {
2159 outb(inb(ioaddr + 0x37) | 0x08, ioaddr + 0x37);
2160 msleep(500);
2161 outb(inb(ioaddr + 0x37) & ~0x08,
2162 ioaddr + 0x37);
2163 udelay(1);
2164 outw(0x80, ioaddr + 0x30);
2165 for (w = 0; w < 10000; w++) {
2166 if ((inw(ioaddr + 0x30) & 1) == 0)
2167 break;
2168 }
2169 }
2170 }
2171#endif
2172 if (vend == NEC_VERSA_SUBID1 || vend == NEC_VERSA_SUBID2) {
2173
2174 outw(0xf9ff, ioaddr + 0x64);
2175 outw(inw(ioaddr + 0x68) | 0x600, ioaddr + 0x68);
2176 outw(0x0209, ioaddr + 0x60);
2177 }
2178
2179
2180 outw(save_ringbus_a, ioaddr + 0x36);
2181
2182
2183
2184
2185 outb(inb(ioaddr+0xc0)|(1<<5), ioaddr+0xc0);
2186 outb(0xff, ioaddr+0xc3);
2187 outb(0xff, ioaddr+0xc4);
2188 outb(0xff, ioaddr+0xc6);
2189 outb(0xff, ioaddr+0xc8);
2190 outb(0x3f, ioaddr+0xcf);
2191 outb(0x3f, ioaddr+0xd0);
2192}
2193
2194static void snd_es1968_reset(struct es1968 *chip)
2195{
2196
2197 outw(ESM_RESET_MAESTRO | ESM_RESET_DIRECTSOUND,
2198 chip->io_port + ESM_PORT_HOST_IRQ);
2199 udelay(10);
2200 outw(0x0000, chip->io_port + ESM_PORT_HOST_IRQ);
2201 udelay(10);
2202}
2203
2204
2205
2206
2207static void snd_es1968_chip_init(struct es1968 *chip)
2208{
2209 struct pci_dev *pci = chip->pci;
2210 int i;
2211 unsigned long iobase = chip->io_port;
2212 u16 w;
2213 u32 n;
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227 pci_read_config_word(pci, ESM_CONFIG_A, &w);
2228
2229 w &= ~DMA_CLEAR;
2230 w &= ~(PIC_SNOOP1 | PIC_SNOOP2);
2231 w &= ~SAFEGUARD;
2232 w |= POST_WRITE;
2233 w |= PCI_TIMING;
2234
2235 w &= ~SWAP_LR;
2236
2237
2238 w &= ~SUBTR_DECODE;
2239
2240 pci_write_config_word(pci, ESM_CONFIG_A, w);
2241
2242
2243
2244 pci_read_config_word(pci, ESM_CONFIG_B, &w);
2245
2246 w &= ~(1 << 15);
2247
2248 w &= ~(1 << 14);
2249
2250 w &= ~SPDIF_CONFB;
2251 w |= HWV_CONFB;
2252 w |= DEBOUNCE;
2253 w &= ~GPIO_CONFB;
2254 w |= CHI_CONFB;
2255 w &= ~IDMA_CONFB;
2256 w &= ~MIDI_FIX;
2257 w &= ~(1 << 1);
2258 w &= ~IRQ_TO_ISA;
2259
2260 pci_write_config_word(pci, ESM_CONFIG_B, w);
2261
2262
2263
2264 pci_read_config_word(pci, ESM_DDMA, &w);
2265 w &= ~(1 << 0);
2266 pci_write_config_word(pci, ESM_DDMA, w);
2267
2268
2269
2270
2271
2272 pci_read_config_word(pci, ESM_LEGACY_AUDIO_CONTROL, &w);
2273
2274 w |= ESS_DISABLE_AUDIO;
2275 w &= ~ESS_ENABLE_SERIAL_IRQ;
2276 w &= ~(0x1f);
2277
2278 pci_write_config_word(pci, ESM_LEGACY_AUDIO_CONTROL, w);
2279
2280
2281 pci_read_config_word(pci, 0x58, &w);
2282 w|=1<<2;
2283 w|=1<<3;
2284 w&=~(1<<11);
2285 pci_write_config_word(pci, 0x58, w);
2286
2287
2288
2289 snd_es1968_reset(chip);
2290
2291
2292
2293
2294
2295
2296 outw(0xC090, iobase + ESM_RING_BUS_DEST);
2297 udelay(20);
2298 outw(0x3000, iobase + ESM_RING_BUS_CONTR_A);
2299 udelay(20);
2300
2301
2302
2303
2304
2305 snd_es1968_ac97_reset(chip);
2306
2307
2308
2309 n = inl(iobase + ESM_RING_BUS_CONTR_B);
2310 n &= ~RINGB_EN_SPDIF;
2311
2312 outl(n, iobase + ESM_RING_BUS_CONTR_B);
2313
2314
2315
2316 outb(0x88, iobase+0x1c);
2317 outb(0x88, iobase+0x1d);
2318 outb(0x88, iobase+0x1e);
2319 outb(0x88, iobase+0x1f);
2320
2321
2322
2323
2324 outb(0, iobase + ASSP_CONTROL_B);
2325 outb(3, iobase + ASSP_CONTROL_A);
2326 outb(0, iobase + ASSP_CONTROL_C);
2327
2328
2329
2330
2331 for (i = 0; i < 16; i++) {
2332
2333 outw(0x01E0 + i, iobase + WC_INDEX);
2334 outw(0x0000, iobase + WC_DATA);
2335
2336
2337
2338 outw(0x01D0 + i, iobase + WC_INDEX);
2339 outw(0x0000, iobase + WC_DATA);
2340 }
2341 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2342 (wave_get_register(chip, IDR7_WAVE_ROMRAM) & 0xFF00));
2343 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2344 wave_get_register(chip, IDR7_WAVE_ROMRAM) | 0x100);
2345 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2346 wave_get_register(chip, IDR7_WAVE_ROMRAM) & ~0x200);
2347 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2348 wave_get_register(chip, IDR7_WAVE_ROMRAM) | ~0x400);
2349
2350
2351 maestro_write(chip, IDR2_CRAM_DATA, 0x0000);
2352
2353
2354 maestro_write(chip, 0x08, 0xB004);
2355 maestro_write(chip, 0x09, 0x001B);
2356 maestro_write(chip, 0x0A, 0x8000);
2357 maestro_write(chip, 0x0B, 0x3F37);
2358 maestro_write(chip, 0x0C, 0x0098);
2359
2360
2361 maestro_write(chip, 0x0C,
2362 (maestro_read(chip, 0x0C) & ~0xF000) | 0x8000);
2363
2364 maestro_write(chip, 0x0C,
2365 (maestro_read(chip, 0x0C) & ~0x0F00) | 0x0500);
2366
2367 maestro_write(chip, 0x0D, 0x7632);
2368
2369
2370
2371
2372 w = inw(iobase + WC_CONTROL);
2373
2374 w &= ~0xFA00;
2375 w |= 0xA000;
2376 w &= ~0x0200;
2377
2378 w |= 0x0100;
2379 w |= 0x0080;
2380 w &= ~0x0060;
2381 w |= 0x0020;
2382
2383 w &= ~0x000C;
2384
2385 w &= ~0x0001;
2386
2387 outw(w, iobase + WC_CONTROL);
2388
2389
2390 for (i = 0; i < NR_APUS; i++) {
2391 for (w = 0; w < NR_APU_REGS; w++)
2392 apu_set_register(chip, i, w, 0);
2393
2394 }
2395}
2396
2397
2398static void snd_es1968_start_irq(struct es1968 *chip)
2399{
2400 unsigned short w;
2401 w = ESM_HIRQ_DSIE | ESM_HIRQ_HW_VOLUME;
2402 if (chip->rmidi)
2403 w |= ESM_HIRQ_MPU401;
2404 outb(w, chip->io_port + 0x1A);
2405 outw(w, chip->io_port + ESM_PORT_HOST_IRQ);
2406}
2407
2408#ifdef CONFIG_PM
2409
2410
2411
2412static int es1968_suspend(struct pci_dev *pci, pm_message_t state)
2413{
2414 struct snd_card *card = pci_get_drvdata(pci);
2415 struct es1968 *chip = card->private_data;
2416
2417 if (! chip->do_pm)
2418 return 0;
2419
2420 chip->in_suspend = 1;
2421 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
2422 snd_pcm_suspend_all(chip->pcm);
2423 snd_ac97_suspend(chip->ac97);
2424 snd_es1968_bob_stop(chip);
2425
2426 pci_disable_device(pci);
2427 pci_save_state(pci);
2428 pci_set_power_state(pci, pci_choose_state(pci, state));
2429 return 0;
2430}
2431
2432static int es1968_resume(struct pci_dev *pci)
2433{
2434 struct snd_card *card = pci_get_drvdata(pci);
2435 struct es1968 *chip = card->private_data;
2436 struct esschan *es;
2437
2438 if (! chip->do_pm)
2439 return 0;
2440
2441
2442 pci_set_power_state(pci, PCI_D0);
2443 pci_restore_state(pci);
2444 if (pci_enable_device(pci) < 0) {
2445 printk(KERN_ERR "es1968: pci_enable_device failed, "
2446 "disabling device\n");
2447 snd_card_disconnect(card);
2448 return -EIO;
2449 }
2450 pci_set_master(pci);
2451
2452 snd_es1968_chip_init(chip);
2453
2454
2455 if (chip->dma.addr) {
2456
2457 wave_set_register(chip, 0x01FC, chip->dma.addr >> 12);
2458 }
2459
2460 snd_es1968_start_irq(chip);
2461
2462
2463 snd_ac97_resume(chip->ac97);
2464
2465 list_for_each_entry(es, &chip->substream_list, list) {
2466 switch (es->mode) {
2467 case ESM_MODE_PLAY:
2468 snd_es1968_playback_setup(chip, es, es->substream->runtime);
2469 break;
2470 case ESM_MODE_CAPTURE:
2471 snd_es1968_capture_setup(chip, es, es->substream->runtime);
2472 break;
2473 }
2474 }
2475
2476
2477 if (chip->bobclient)
2478 snd_es1968_bob_start(chip);
2479
2480 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
2481 chip->in_suspend = 0;
2482 return 0;
2483}
2484#endif
2485
2486#ifdef SUPPORT_JOYSTICK
2487#define JOYSTICK_ADDR 0x200
2488static int __devinit snd_es1968_create_gameport(struct es1968 *chip, int dev)
2489{
2490 struct gameport *gp;
2491 struct resource *r;
2492 u16 val;
2493
2494 if (!joystick[dev])
2495 return -ENODEV;
2496
2497 r = request_region(JOYSTICK_ADDR, 8, "ES1968 gameport");
2498 if (!r)
2499 return -EBUSY;
2500
2501 chip->gameport = gp = gameport_allocate_port();
2502 if (!gp) {
2503 printk(KERN_ERR "es1968: cannot allocate memory for gameport\n");
2504 release_and_free_resource(r);
2505 return -ENOMEM;
2506 }
2507
2508 pci_read_config_word(chip->pci, ESM_LEGACY_AUDIO_CONTROL, &val);
2509 pci_write_config_word(chip->pci, ESM_LEGACY_AUDIO_CONTROL, val | 0x04);
2510
2511 gameport_set_name(gp, "ES1968 Gameport");
2512 gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
2513 gameport_set_dev_parent(gp, &chip->pci->dev);
2514 gp->io = JOYSTICK_ADDR;
2515 gameport_set_port_data(gp, r);
2516
2517 gameport_register_port(gp);
2518
2519 return 0;
2520}
2521
2522static void snd_es1968_free_gameport(struct es1968 *chip)
2523{
2524 if (chip->gameport) {
2525 struct resource *r = gameport_get_port_data(chip->gameport);
2526
2527 gameport_unregister_port(chip->gameport);
2528 chip->gameport = NULL;
2529
2530 release_and_free_resource(r);
2531 }
2532}
2533#else
2534static inline int snd_es1968_create_gameport(struct es1968 *chip, int dev) { return -ENOSYS; }
2535static inline void snd_es1968_free_gameport(struct es1968 *chip) { }
2536#endif
2537
2538#ifdef CONFIG_SND_ES1968_INPUT
2539static int __devinit snd_es1968_input_register(struct es1968 *chip)
2540{
2541 struct input_dev *input_dev;
2542 int err;
2543
2544 input_dev = input_allocate_device();
2545 if (!input_dev)
2546 return -ENOMEM;
2547
2548 snprintf(chip->phys, sizeof(chip->phys), "pci-%s/input0",
2549 pci_name(chip->pci));
2550
2551 input_dev->name = chip->card->driver;
2552 input_dev->phys = chip->phys;
2553 input_dev->id.bustype = BUS_PCI;
2554 input_dev->id.vendor = chip->pci->vendor;
2555 input_dev->id.product = chip->pci->device;
2556 input_dev->dev.parent = &chip->pci->dev;
2557
2558 __set_bit(EV_KEY, input_dev->evbit);
2559 __set_bit(KEY_MUTE, input_dev->keybit);
2560 __set_bit(KEY_VOLUMEDOWN, input_dev->keybit);
2561 __set_bit(KEY_VOLUMEUP, input_dev->keybit);
2562
2563 err = input_register_device(input_dev);
2564 if (err) {
2565 input_free_device(input_dev);
2566 return err;
2567 }
2568
2569 chip->input_dev = input_dev;
2570 return 0;
2571}
2572#endif
2573
2574static int snd_es1968_free(struct es1968 *chip)
2575{
2576#ifdef CONFIG_SND_ES1968_INPUT
2577 if (chip->input_dev)
2578 input_unregister_device(chip->input_dev);
2579#endif
2580
2581 if (chip->io_port) {
2582 if (chip->irq >= 0)
2583 synchronize_irq(chip->irq);
2584 outw(1, chip->io_port + 0x04);
2585 outw(0, chip->io_port + ESM_PORT_HOST_IRQ);
2586 }
2587
2588 if (chip->irq >= 0)
2589 free_irq(chip->irq, chip);
2590 snd_es1968_free_gameport(chip);
2591 pci_release_regions(chip->pci);
2592 pci_disable_device(chip->pci);
2593 kfree(chip);
2594 return 0;
2595}
2596
2597static int snd_es1968_dev_free(struct snd_device *device)
2598{
2599 struct es1968 *chip = device->device_data;
2600 return snd_es1968_free(chip);
2601}
2602
2603struct ess_device_list {
2604 unsigned short type;
2605 unsigned short vendor;
2606};
2607
2608static struct ess_device_list pm_whitelist[] __devinitdata = {
2609 { TYPE_MAESTRO2E, 0x0e11 },
2610 { TYPE_MAESTRO2E, 0x1028 },
2611 { TYPE_MAESTRO2E, 0x103c },
2612 { TYPE_MAESTRO2E, 0x1179 },
2613 { TYPE_MAESTRO2E, 0x14c0 },
2614 { TYPE_MAESTRO2E, 0x1558 },
2615};
2616
2617static struct ess_device_list mpu_blacklist[] __devinitdata = {
2618 { TYPE_MAESTRO2, 0x125d },
2619};
2620
2621static int __devinit snd_es1968_create(struct snd_card *card,
2622 struct pci_dev *pci,
2623 int total_bufsize,
2624 int play_streams,
2625 int capt_streams,
2626 int chip_type,
2627 int do_pm,
2628 struct es1968 **chip_ret)
2629{
2630 static struct snd_device_ops ops = {
2631 .dev_free = snd_es1968_dev_free,
2632 };
2633 struct es1968 *chip;
2634 int i, err;
2635
2636 *chip_ret = NULL;
2637
2638
2639 if ((err = pci_enable_device(pci)) < 0)
2640 return err;
2641
2642 if (pci_set_dma_mask(pci, DMA_BIT_MASK(28)) < 0 ||
2643 pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(28)) < 0) {
2644 snd_printk(KERN_ERR "architecture does not support 28bit PCI busmaster DMA\n");
2645 pci_disable_device(pci);
2646 return -ENXIO;
2647 }
2648
2649 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
2650 if (! chip) {
2651 pci_disable_device(pci);
2652 return -ENOMEM;
2653 }
2654
2655
2656 chip->type = chip_type;
2657 spin_lock_init(&chip->reg_lock);
2658 spin_lock_init(&chip->substream_lock);
2659 INIT_LIST_HEAD(&chip->buf_list);
2660 INIT_LIST_HEAD(&chip->substream_list);
2661 mutex_init(&chip->memory_mutex);
2662#ifndef CONFIG_SND_ES1968_INPUT
2663 spin_lock_init(&chip->ac97_lock);
2664 tasklet_init(&chip->hwvol_tq, es1968_update_hw_volume, (unsigned long)chip);
2665#endif
2666 chip->card = card;
2667 chip->pci = pci;
2668 chip->irq = -1;
2669 chip->total_bufsize = total_bufsize;
2670 chip->playback_streams = play_streams;
2671 chip->capture_streams = capt_streams;
2672
2673 if ((err = pci_request_regions(pci, "ESS Maestro")) < 0) {
2674 kfree(chip);
2675 pci_disable_device(pci);
2676 return err;
2677 }
2678 chip->io_port = pci_resource_start(pci, 0);
2679 if (request_irq(pci->irq, snd_es1968_interrupt, IRQF_SHARED,
2680 "ESS Maestro", chip)) {
2681 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
2682 snd_es1968_free(chip);
2683 return -EBUSY;
2684 }
2685 chip->irq = pci->irq;
2686
2687
2688 for (i = 0; i < 32; i++)
2689 chip->maestro_map[i] = 0;
2690
2691
2692 for (i = 0; i < NR_APUS; i++)
2693 chip->apu[i] = ESM_APU_FREE;
2694
2695
2696 pci_set_master(pci);
2697
2698 if (do_pm > 1) {
2699
2700 unsigned short vend;
2701 pci_read_config_word(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2702 for (i = 0; i < (int)ARRAY_SIZE(pm_whitelist); i++) {
2703 if (chip->type == pm_whitelist[i].type &&
2704 vend == pm_whitelist[i].vendor) {
2705 do_pm = 1;
2706 break;
2707 }
2708 }
2709 if (do_pm > 1) {
2710
2711 printk(KERN_INFO "es1968: not attempting power management.\n");
2712 do_pm = 0;
2713 }
2714 }
2715 chip->do_pm = do_pm;
2716
2717 snd_es1968_chip_init(chip);
2718
2719 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
2720 snd_es1968_free(chip);
2721 return err;
2722 }
2723
2724 snd_card_set_dev(card, &pci->dev);
2725
2726 *chip_ret = chip;
2727
2728 return 0;
2729}
2730
2731
2732
2733
2734static int __devinit snd_es1968_probe(struct pci_dev *pci,
2735 const struct pci_device_id *pci_id)
2736{
2737 static int dev;
2738 struct snd_card *card;
2739 struct es1968 *chip;
2740 unsigned int i;
2741 int err;
2742
2743 if (dev >= SNDRV_CARDS)
2744 return -ENODEV;
2745 if (!enable[dev]) {
2746 dev++;
2747 return -ENOENT;
2748 }
2749
2750 err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
2751 if (err < 0)
2752 return err;
2753
2754 if (total_bufsize[dev] < 128)
2755 total_bufsize[dev] = 128;
2756 if (total_bufsize[dev] > 4096)
2757 total_bufsize[dev] = 4096;
2758 if ((err = snd_es1968_create(card, pci,
2759 total_bufsize[dev] * 1024,
2760 pcm_substreams_p[dev],
2761 pcm_substreams_c[dev],
2762 pci_id->driver_data,
2763 use_pm[dev],
2764 &chip)) < 0) {
2765 snd_card_free(card);
2766 return err;
2767 }
2768 card->private_data = chip;
2769
2770 switch (chip->type) {
2771 case TYPE_MAESTRO2E:
2772 strcpy(card->driver, "ES1978");
2773 strcpy(card->shortname, "ESS ES1978 (Maestro 2E)");
2774 break;
2775 case TYPE_MAESTRO2:
2776 strcpy(card->driver, "ES1968");
2777 strcpy(card->shortname, "ESS ES1968 (Maestro 2)");
2778 break;
2779 case TYPE_MAESTRO:
2780 strcpy(card->driver, "ESM1");
2781 strcpy(card->shortname, "ESS Maestro 1");
2782 break;
2783 }
2784
2785 if ((err = snd_es1968_pcm(chip, 0)) < 0) {
2786 snd_card_free(card);
2787 return err;
2788 }
2789
2790 if ((err = snd_es1968_mixer(chip)) < 0) {
2791 snd_card_free(card);
2792 return err;
2793 }
2794
2795 if (enable_mpu[dev] == 2) {
2796
2797 unsigned short vend;
2798 pci_read_config_word(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2799 for (i = 0; i < ARRAY_SIZE(mpu_blacklist); i++) {
2800 if (chip->type == mpu_blacklist[i].type &&
2801 vend == mpu_blacklist[i].vendor) {
2802 enable_mpu[dev] = 0;
2803 break;
2804 }
2805 }
2806 }
2807 if (enable_mpu[dev]) {
2808 if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
2809 chip->io_port + ESM_MPU401_PORT,
2810 MPU401_INFO_INTEGRATED,
2811 chip->irq, 0, &chip->rmidi)) < 0) {
2812 printk(KERN_WARNING "es1968: skipping MPU-401 MIDI support..\n");
2813 }
2814 }
2815
2816 snd_es1968_create_gameport(chip, dev);
2817
2818#ifdef CONFIG_SND_ES1968_INPUT
2819 err = snd_es1968_input_register(chip);
2820 if (err)
2821 snd_printk(KERN_WARNING "Input device registration "
2822 "failed with error %i", err);
2823#endif
2824
2825 snd_es1968_start_irq(chip);
2826
2827 chip->clock = clock[dev];
2828 if (! chip->clock)
2829 es1968_measure_clock(chip);
2830
2831 sprintf(card->longname, "%s at 0x%lx, irq %i",
2832 card->shortname, chip->io_port, chip->irq);
2833
2834 if ((err = snd_card_register(card)) < 0) {
2835 snd_card_free(card);
2836 return err;
2837 }
2838 pci_set_drvdata(pci, card);
2839 dev++;
2840 return 0;
2841}
2842
2843static void __devexit snd_es1968_remove(struct pci_dev *pci)
2844{
2845 snd_card_free(pci_get_drvdata(pci));
2846 pci_set_drvdata(pci, NULL);
2847}
2848
2849static struct pci_driver driver = {
2850 .name = "ES1968 (ESS Maestro)",
2851 .id_table = snd_es1968_ids,
2852 .probe = snd_es1968_probe,
2853 .remove = __devexit_p(snd_es1968_remove),
2854#ifdef CONFIG_PM
2855 .suspend = es1968_suspend,
2856 .resume = es1968_resume,
2857#endif
2858};
2859
2860static int __init alsa_card_es1968_init(void)
2861{
2862 return pci_register_driver(&driver);
2863}
2864
2865static void __exit alsa_card_es1968_exit(void)
2866{
2867 pci_unregister_driver(&driver);
2868}
2869
2870module_init(alsa_card_es1968_init)
2871module_exit(alsa_card_es1968_exit)
2872