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