?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.25.20
[linux/fpc-iii.git] / sound / pci / es1968.c
blob7d911a18c082ffbbbfab7293693ec070ca5db224
1 /*
2 * Driver for ESS Maestro 1/2/2E Sound Card (started 21.8.99)
3 * Copyright (c) by Matze Braun <MatzeBraun@gmx.de>.
4 * Takashi Iwai <tiwai@suse.de>
5 *
6 * Most of the driver code comes from Zach Brown(zab@redhat.com)
7 * Alan Cox OSS Driver
8 * Rewritted from card-es1938.c source.
9 *
10 * TODO:
11 * Perhaps Synth
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 *
27 *
28 * Notes from Zach Brown about the driver code
29 *
30 * Hardware Description
31 *
32 * A working Maestro setup contains the Maestro chip wired to a
33 * codec or 2. In the Maestro we have the APUs, the ASSP, and the
34 * Wavecache. The APUs can be though of as virtual audio routing
35 * channels. They can take data from a number of sources and perform
36 * basic encodings of the data. The wavecache is a storehouse for
37 * PCM data. Typically it deals with PCI and interracts with the
38 * APUs. The ASSP is a wacky DSP like device that ESS is loth
39 * to release docs on. Thankfully it isn't required on the Maestro
40 * until you start doing insane things like FM emulation and surround
41 * encoding. The codecs are almost always AC-97 compliant codecs,
42 * but it appears that early Maestros may have had PT101 (an ESS
43 * part?) wired to them. The only real difference in the Maestro
44 * families is external goop like docking capability, memory for
45 * the ASSP, and initialization differences.
46 *
47 * Driver Operation
48 *
49 * We only drive the APU/Wavecache as typical DACs and drive the
50 * mixers in the codecs. There are 64 APUs. We assign 6 to each
51 * /dev/dsp? device. 2 channels for output, and 4 channels for
52 * input.
53 *
54 * Each APU can do a number of things, but we only really use
55 * 3 basic functions. For playback we use them to convert PCM
56 * data fetched over PCI by the wavecahche into analog data that
57 * is handed to the codec. One APU for mono, and a pair for stereo.
58 * When in stereo, the combination of smarts in the APU and Wavecache
59 * decide which wavecache gets the left or right channel.
60 *
61 * For record we still use the old overly mono system. For each in
62 * coming channel the data comes in from the codec, through a 'input'
63 * APU, through another rate converter APU, and then into memory via
64 * the wavecache and PCI. If its stereo, we mash it back into LRLR in
65 * software. The pass between the 2 APUs is supposedly what requires us
66 * to have a 512 byte buffer sitting around in wavecache/memory.
67 *
68 * The wavecache makes our life even more fun. First off, it can
69 * only address the first 28 bits of PCI address space, making it
70 * useless on quite a few architectures. Secondly, its insane.
71 * It claims to fetch from 4 regions of PCI space, each 4 meg in length.
72 * But that doesn't really work. You can only use 1 region. So all our
73 * allocations have to be in 4meg of each other. Booo. Hiss.
74 * So we have a module parameter, dsps_order, that is the order of
75 * the number of dsps to provide. All their buffer space is allocated
76 * on open time. The sonicvibes OSS routines we inherited really want
77 * power of 2 buffers, so we have all those next to each other, then
78 * 512 byte regions for the recording wavecaches. This ends up
79 * wasting quite a bit of memory. The only fixes I can see would be
80 * getting a kernel allocator that could work in zones, or figuring out
81 * just how to coerce the WP into doing what we want.
82 *
83 * The indirection of the various registers means we have to spinlock
84 * nearly all register accesses. We have the main register indirection
85 * like the wave cache, maestro registers, etc. Then we have beasts
86 * like the APU interface that is indirect registers gotten at through
87 * the main maestro indirection. Ouch. We spinlock around the actual
88 * ports on a per card basis. This means spinlock activity at each IO
89 * operation, but the only IO operation clusters are in non critical
90 * paths and it makes the code far easier to follow. Interrupts are
91 * blocked while holding the locks because the int handler has to
92 * get at some of them :(. The mixer interface doesn't, however.
93 * We also have an OSS state lock that is thrown around in a few
94 * places.
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
108 #include <sound/core.h>
109 #include <sound/pcm.h>
110 #include <sound/mpu401.h>
111 #include <sound/ac97_codec.h>
112 #include <sound/initval.h>
113
114 #define CARD_NAME "ESS Maestro1/2"
115 #define DRIVER_NAME "ES1968"
116
117 MODULE_DESCRIPTION("ESS Maestro");
118 MODULE_LICENSE("GPL");
119 MODULE_SUPPORTED_DEVICE("{{ESS,Maestro 2e},"
120 "{ESS,Maestro 2},"
121 "{ESS,Maestro 1},"
122 "{TerraTec,DMX}}");
123
124 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
125 #define SUPPORT_JOYSTICK 1
126 #endif
127
128 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 1-MAX */
129 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
130 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */
131 static int total_bufsize[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1024 };
132 static int pcm_substreams_p[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 4 };
133 static int pcm_substreams_c[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1 };
134 static int clock[SNDRV_CARDS];
135 static int use_pm[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2};
136 static int enable_mpu[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2};
137 #ifdef SUPPORT_JOYSTICK
138 static int joystick[SNDRV_CARDS];
139 #endif
140
141 module_param_array(index, int, NULL, 0444);
142 MODULE_PARM_DESC(index, "Index value for " CARD_NAME " soundcard.");
143 module_param_array(id, charp, NULL, 0444);
144 MODULE_PARM_DESC(id, "ID string for " CARD_NAME " soundcard.");
145 module_param_array(enable, bool, NULL, 0444);
146 MODULE_PARM_DESC(enable, "Enable " CARD_NAME " soundcard.");
147 module_param_array(total_bufsize, int, NULL, 0444);
148 MODULE_PARM_DESC(total_bufsize, "Total buffer size in kB.");
149 module_param_array(pcm_substreams_p, int, NULL, 0444);
150 MODULE_PARM_DESC(pcm_substreams_p, "PCM Playback substreams for " CARD_NAME " soundcard.");
151 module_param_array(pcm_substreams_c, int, NULL, 0444);
152 MODULE_PARM_DESC(pcm_substreams_c, "PCM Capture substreams for " CARD_NAME " soundcard.");
153 module_param_array(clock, int, NULL, 0444);
154 MODULE_PARM_DESC(clock, "Clock on " CARD_NAME " soundcard. (0 = auto-detect)");
155 module_param_array(use_pm, int, NULL, 0444);
156 MODULE_PARM_DESC(use_pm, "Toggle power-management. (0 = off, 1 = on, 2 = auto)");
157 module_param_array(enable_mpu, int, NULL, 0444);
158 MODULE_PARM_DESC(enable_mpu, "Enable MPU401. (0 = off, 1 = on, 2 = auto)");
159 #ifdef SUPPORT_JOYSTICK
160 module_param_array(joystick, bool, NULL, 0444);
161 MODULE_PARM_DESC(joystick, "Enable joystick.");
162 #endif
163
164
165 #define NR_APUS 64
166 #define NR_APU_REGS 16
167
168 /* NEC Versas ? */
169 #define NEC_VERSA_SUBID1 0x80581033
170 #define NEC_VERSA_SUBID2 0x803c1033
171
172 /* Mode Flags */
173 #define ESS_FMT_STEREO 0x01
174 #define ESS_FMT_16BIT 0x02
175
176 #define DAC_RUNNING 1
177 #define ADC_RUNNING 2
178
179 /* Values for the ESM_LEGACY_AUDIO_CONTROL */
180
181 #define ESS_DISABLE_AUDIO 0x8000
182 #define ESS_ENABLE_SERIAL_IRQ 0x4000
183 #define IO_ADRESS_ALIAS 0x0020
184 #define MPU401_IRQ_ENABLE 0x0010
185 #define MPU401_IO_ENABLE 0x0008
186 #define GAME_IO_ENABLE 0x0004
187 #define FM_IO_ENABLE 0x0002
188 #define SB_IO_ENABLE 0x0001
189
190 /* Values for the ESM_CONFIG_A */
191
192 #define PIC_SNOOP1 0x4000
193 #define PIC_SNOOP2 0x2000
194 #define SAFEGUARD 0x0800
195 #define DMA_CLEAR 0x0700
196 #define DMA_DDMA 0x0000
197 #define DMA_TDMA 0x0100
198 #define DMA_PCPCI 0x0200
199 #define POST_WRITE 0x0080
200 #define PCI_TIMING 0x0040
201 #define SWAP_LR 0x0020
202 #define SUBTR_DECODE 0x0002
203
204 /* Values for the ESM_CONFIG_B */
205
206 #define SPDIF_CONFB 0x0100
207 #define HWV_CONFB 0x0080
208 #define DEBOUNCE 0x0040
209 #define GPIO_CONFB 0x0020
210 #define CHI_CONFB 0x0010
211 #define IDMA_CONFB 0x0008 /*undoc */
212 #define MIDI_FIX 0x0004 /*undoc */
213 #define IRQ_TO_ISA 0x0001 /*undoc */
214
215 /* Values for Ring Bus Control B */
216 #define RINGB_2CODEC_ID_MASK 0x0003
217 #define RINGB_DIS_VALIDATION 0x0008
218 #define RINGB_EN_SPDIF 0x0010
219 #define RINGB_EN_2CODEC 0x0020
220 #define RINGB_SING_BIT_DUAL 0x0040
221
222 /* ****Port Adresses**** */
223
224 /* Write & Read */
225 #define ESM_INDEX 0x02
226 #define ESM_DATA 0x00
227
228 /* AC97 + RingBus */
229 #define ESM_AC97_INDEX 0x30
230 #define ESM_AC97_DATA 0x32
231 #define ESM_RING_BUS_DEST 0x34
232 #define ESM_RING_BUS_CONTR_A 0x36
233 #define ESM_RING_BUS_CONTR_B 0x38
234 #define ESM_RING_BUS_SDO 0x3A
235
236 /* WaveCache*/
237 #define WC_INDEX 0x10
238 #define WC_DATA 0x12
239 #define WC_CONTROL 0x14
240
241 /* ASSP*/
242 #define ASSP_INDEX 0x80
243 #define ASSP_MEMORY 0x82
244 #define ASSP_DATA 0x84
245 #define ASSP_CONTROL_A 0xA2
246 #define ASSP_CONTROL_B 0xA4
247 #define ASSP_CONTROL_C 0xA6
248 #define ASSP_HOSTW_INDEX 0xA8
249 #define ASSP_HOSTW_DATA 0xAA
250 #define ASSP_HOSTW_IRQ 0xAC
251 /* Midi */
252 #define ESM_MPU401_PORT 0x98
253 /* Others */
254 #define ESM_PORT_HOST_IRQ 0x18
255
256 #define IDR0_DATA_PORT 0x00
257 #define IDR1_CRAM_POINTER 0x01
258 #define IDR2_CRAM_DATA 0x02
259 #define IDR3_WAVE_DATA 0x03
260 #define IDR4_WAVE_PTR_LOW 0x04
261 #define IDR5_WAVE_PTR_HI 0x05
262 #define IDR6_TIMER_CTRL 0x06
263 #define IDR7_WAVE_ROMRAM 0x07
264
265 #define WRITEABLE_MAP 0xEFFFFF
266 #define READABLE_MAP 0x64003F
267
268 /* PCI Register */
269
270 #define ESM_LEGACY_AUDIO_CONTROL 0x40
271 #define ESM_ACPI_COMMAND 0x54
272 #define ESM_CONFIG_A 0x50
273 #define ESM_CONFIG_B 0x52
274 #define ESM_DDMA 0x60
275
276 /* Bob Bits */
277 #define ESM_BOB_ENABLE 0x0001
278 #define ESM_BOB_START 0x0001
279
280 /* Host IRQ Control Bits */
281 #define ESM_RESET_MAESTRO 0x8000
282 #define ESM_RESET_DIRECTSOUND 0x4000
283 #define ESM_HIRQ_ClkRun 0x0100
284 #define ESM_HIRQ_HW_VOLUME 0x0040
285 #define ESM_HIRQ_HARPO 0x0030 /* What's that? */
286 #define ESM_HIRQ_ASSP 0x0010
287 #define ESM_HIRQ_DSIE 0x0004
288 #define ESM_HIRQ_MPU401 0x0002
289 #define ESM_HIRQ_SB 0x0001
290
291 /* Host IRQ Status Bits */
292 #define ESM_MPU401_IRQ 0x02
293 #define ESM_SB_IRQ 0x01
294 #define ESM_SOUND_IRQ 0x04
295 #define ESM_ASSP_IRQ 0x10
296 #define ESM_HWVOL_IRQ 0x40
297
298 #define ESS_SYSCLK 50000000
299 #define ESM_BOB_FREQ 200
300 #define ESM_BOB_FREQ_MAX 800
301
302 #define ESM_FREQ_ESM1 (49152000L / 1024L) /* default rate 48000 */
303 #define ESM_FREQ_ESM2 (50000000L / 1024L)
304
305 /* APU Modes: reg 0x00, bit 4-7 */
306 #define ESM_APU_MODE_SHIFT 4
307 #define ESM_APU_MODE_MASK (0xf << 4)
308 #define ESM_APU_OFF 0x00
309 #define ESM_APU_16BITLINEAR 0x01 /* 16-Bit Linear Sample Player */
310 #define ESM_APU_16BITSTEREO 0x02 /* 16-Bit Stereo Sample Player */
311 #define ESM_APU_8BITLINEAR 0x03 /* 8-Bit Linear Sample Player */
312 #define ESM_APU_8BITSTEREO 0x04 /* 8-Bit Stereo Sample Player */
313 #define ESM_APU_8BITDIFF 0x05 /* 8-Bit Differential Sample Playrer */
314 #define ESM_APU_DIGITALDELAY 0x06 /* Digital Delay Line */
315 #define ESM_APU_DUALTAP 0x07 /* Dual Tap Reader */
316 #define ESM_APU_CORRELATOR 0x08 /* Correlator */
317 #define ESM_APU_INPUTMIXER 0x09 /* Input Mixer */
318 #define ESM_APU_WAVETABLE 0x0A /* Wave Table Mode */
319 #define ESM_APU_SRCONVERTOR 0x0B /* Sample Rate Convertor */
320 #define ESM_APU_16BITPINGPONG 0x0C /* 16-Bit Ping-Pong Sample Player */
321 #define ESM_APU_RESERVED1 0x0D /* Reserved 1 */
322 #define ESM_APU_RESERVED2 0x0E /* Reserved 2 */
323 #define ESM_APU_RESERVED3 0x0F /* Reserved 3 */
324
325 /* reg 0x00 */
326 #define ESM_APU_FILTER_Q_SHIFT 0
327 #define ESM_APU_FILTER_Q_MASK (3 << 0)
328 /* APU Filtey Q Control */
329 #define ESM_APU_FILTER_LESSQ 0x00
330 #define ESM_APU_FILTER_MOREQ 0x03
331
332 #define ESM_APU_FILTER_TYPE_SHIFT 2
333 #define ESM_APU_FILTER_TYPE_MASK (3 << 2)
334 #define ESM_APU_ENV_TYPE_SHIFT 8
335 #define ESM_APU_ENV_TYPE_MASK (3 << 8)
336 #define ESM_APU_ENV_STATE_SHIFT 10
337 #define ESM_APU_ENV_STATE_MASK (3 << 10)
338 #define ESM_APU_END_CURVE (1 << 12)
339 #define ESM_APU_INT_ON_LOOP (1 << 13)
340 #define ESM_APU_DMA_ENABLE (1 << 14)
341
342 /* reg 0x02 */
343 #define ESM_APU_SUBMIX_GROUP_SHIRT 0
344 #define ESM_APU_SUBMIX_GROUP_MASK (7 << 0)
345 #define ESM_APU_SUBMIX_MODE (1 << 3)
346 #define ESM_APU_6dB (1 << 4)
347 #define ESM_APU_DUAL_EFFECT (1 << 5)
348 #define ESM_APU_EFFECT_CHANNELS_SHIFT 6
349 #define ESM_APU_EFFECT_CHANNELS_MASK (3 << 6)
350
351 /* reg 0x03 */
352 #define ESM_APU_STEP_SIZE_MASK 0x0fff
353
354 /* reg 0x04 */
355 #define ESM_APU_PHASE_SHIFT 0
356 #define ESM_APU_PHASE_MASK (0xff << 0)
357 #define ESM_APU_WAVE64K_PAGE_SHIFT 8 /* most 8bit of wave start offset */
358 #define ESM_APU_WAVE64K_PAGE_MASK (0xff << 8)
359
360 /* reg 0x05 - wave start offset */
361 /* reg 0x06 - wave end offset */
362 /* reg 0x07 - wave loop length */
363
364 /* reg 0x08 */
365 #define ESM_APU_EFFECT_GAIN_SHIFT 0
366 #define ESM_APU_EFFECT_GAIN_MASK (0xff << 0)
367 #define ESM_APU_TREMOLO_DEPTH_SHIFT 8
368 #define ESM_APU_TREMOLO_DEPTH_MASK (0xf << 8)
369 #define ESM_APU_TREMOLO_RATE_SHIFT 12
370 #define ESM_APU_TREMOLO_RATE_MASK (0xf << 12)
371
372 /* reg 0x09 */
373 /* bit 0-7 amplitude dest? */
374 #define ESM_APU_AMPLITUDE_NOW_SHIFT 8
375 #define ESM_APU_AMPLITUDE_NOW_MASK (0xff << 8)
376
377 /* reg 0x0a */
378 #define ESM_APU_POLAR_PAN_SHIFT 0
379 #define ESM_APU_POLAR_PAN_MASK (0x3f << 0)
380 /* Polar Pan Control */
381 #define ESM_APU_PAN_CENTER_CIRCLE 0x00
382 #define ESM_APU_PAN_MIDDLE_RADIUS 0x01
383 #define ESM_APU_PAN_OUTSIDE_RADIUS 0x02
384
385 #define ESM_APU_FILTER_TUNING_SHIFT 8
386 #define ESM_APU_FILTER_TUNING_MASK (0xff << 8)
387
388 /* reg 0x0b */
389 #define ESM_APU_DATA_SRC_A_SHIFT 0
390 #define ESM_APU_DATA_SRC_A_MASK (0x7f << 0)
391 #define ESM_APU_INV_POL_A (1 << 7)
392 #define ESM_APU_DATA_SRC_B_SHIFT 8
393 #define ESM_APU_DATA_SRC_B_MASK (0x7f << 8)
394 #define ESM_APU_INV_POL_B (1 << 15)
395
396 #define ESM_APU_VIBRATO_RATE_SHIFT 0
397 #define ESM_APU_VIBRATO_RATE_MASK (0xf << 0)
398 #define ESM_APU_VIBRATO_DEPTH_SHIFT 4
399 #define ESM_APU_VIBRATO_DEPTH_MASK (0xf << 4)
400 #define ESM_APU_VIBRATO_PHASE_SHIFT 8
401 #define ESM_APU_VIBRATO_PHASE_MASK (0xff << 8)
402
403 /* reg 0x0c */
404 #define ESM_APU_RADIUS_SELECT (1 << 6)
405
406 /* APU Filter Control */
407 #define ESM_APU_FILTER_2POLE_LOPASS 0x00
408 #define ESM_APU_FILTER_2POLE_BANDPASS 0x01
409 #define ESM_APU_FILTER_2POLE_HIPASS 0x02
410 #define ESM_APU_FILTER_1POLE_LOPASS 0x03
411 #define ESM_APU_FILTER_1POLE_HIPASS 0x04
412 #define ESM_APU_FILTER_OFF 0x05
413
414 /* APU ATFP Type */
415 #define ESM_APU_ATFP_AMPLITUDE 0x00
416 #define ESM_APU_ATFP_TREMELO 0x01
417 #define ESM_APU_ATFP_FILTER 0x02
418 #define ESM_APU_ATFP_PAN 0x03
419
420 /* APU ATFP Flags */
421 #define ESM_APU_ATFP_FLG_OFF 0x00
422 #define ESM_APU_ATFP_FLG_WAIT 0x01
423 #define ESM_APU_ATFP_FLG_DONE 0x02
424 #define ESM_APU_ATFP_FLG_INPROCESS 0x03
425
426
427 /* capture mixing buffer size */
428 #define ESM_MEM_ALIGN 0x1000
429 #define ESM_MIXBUF_SIZE 0x400
430
431 #define ESM_MODE_PLAY 0
432 #define ESM_MODE_CAPTURE 1
433
434
435 /* APU use in the driver */
436 enum snd_enum_apu_type {
437 ESM_APU_PCM_PLAY,
438 ESM_APU_PCM_CAPTURE,
439 ESM_APU_PCM_RATECONV,
440 ESM_APU_FREE
441 };
442
443 /* chip type */
444 enum {
445 TYPE_MAESTRO, TYPE_MAESTRO2, TYPE_MAESTRO2E
446 };
447
448 /* DMA Hack! */
449 struct esm_memory {
450 struct snd_dma_buffer buf;
451 int empty; /* status */
452 struct list_head list;
453 };
454
455 /* Playback Channel */
456 struct esschan {
457 int running;
458
459 u8 apu[4];
460 u8 apu_mode[4];
461
462 /* playback/capture pcm buffer */
463 struct esm_memory *memory;
464 /* capture mixer buffer */
465 struct esm_memory *mixbuf;
466
467 unsigned int hwptr; /* current hw pointer in bytes */
468 unsigned int count; /* sample counter in bytes */
469 unsigned int dma_size; /* total buffer size in bytes */
470 unsigned int frag_size; /* period size in bytes */
471 unsigned int wav_shift;
472 u16 base[4]; /* offset for ptr */
473
474 /* stereo/16bit flag */
475 unsigned char fmt;
476 int mode; /* playback / capture */
477
478 int bob_freq; /* required timer frequency */
479
480 struct snd_pcm_substream *substream;
481
482 /* linked list */
483 struct list_head list;
484
485 #ifdef CONFIG_PM
486 u16 wc_map[4];
487 #endif
488 };
489
490 struct es1968 {
491 /* Module Config */
492 int total_bufsize; /* in bytes */
493
494 int playback_streams, capture_streams;
495
496 unsigned int clock; /* clock */
497 /* for clock measurement */
498 unsigned int in_measurement: 1;
499 unsigned int measure_apu;
500 unsigned int measure_lastpos;
501 unsigned int measure_count;
502
503 /* buffer */
504 struct snd_dma_buffer dma;
505
506 /* Resources... */
507 int irq;
508 unsigned long io_port;
509 int type;
510 struct pci_dev *pci;
511 struct snd_card *card;
512 struct snd_pcm *pcm;
513 int do_pm; /* power-management enabled */
514
515 /* DMA memory block */
516 struct list_head buf_list;
517
518 /* ALSA Stuff */
519 struct snd_ac97 *ac97;
520 struct snd_kcontrol *master_switch; /* for h/w volume control */
521 struct snd_kcontrol *master_volume;
522
523 struct snd_rawmidi *rmidi;
524
525 spinlock_t reg_lock;
526 spinlock_t ac97_lock;
527 struct tasklet_struct hwvol_tq;
528 unsigned int in_suspend;
529
530 /* Maestro Stuff */
531 u16 maestro_map[32];
532 int bobclient; /* active timer instancs */
533 int bob_freq; /* timer frequency */
534 struct mutex memory_mutex; /* memory lock */
535
536 /* APU states */
537 unsigned char apu[NR_APUS];
538
539 /* active substreams */
540 struct list_head substream_list;
541 spinlock_t substream_lock;
542
543 #ifdef CONFIG_PM
544 u16 apu_map[NR_APUS][NR_APU_REGS];
545 #endif
546
547 #ifdef SUPPORT_JOYSTICK
548 struct gameport *gameport;
549 #endif
550 };
551
552 static irqreturn_t snd_es1968_interrupt(int irq, void *dev_id);
553
554 static struct pci_device_id snd_es1968_ids[] = {
555 /* Maestro 1 */
556 { 0x1285, 0x0100, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_MULTIMEDIA_AUDIO << 8, 0xffff00, TYPE_MAESTRO },
557 /* Maestro 2 */
558 { 0x125d, 0x1968, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_MULTIMEDIA_AUDIO << 8, 0xffff00, TYPE_MAESTRO2 },
559 /* Maestro 2E */
560 { 0x125d, 0x1978, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_MULTIMEDIA_AUDIO << 8, 0xffff00, TYPE_MAESTRO2E },
561 { 0, }
562 };
563
564 MODULE_DEVICE_TABLE(pci, snd_es1968_ids);
565
566 /* *********************
567 * Low Level Funcs! *
568 *********************/
569
570 /* no spinlock */
571 static void __maestro_write(struct es1968 *chip, u16 reg, u16 data)
572 {
573 outw(reg, chip->io_port + ESM_INDEX);
574 outw(data, chip->io_port + ESM_DATA);
575 chip->maestro_map[reg] = data;
576 }
577
578 static inline void maestro_write(struct es1968 *chip, u16 reg, u16 data)
579 {
580 unsigned long flags;
581 spin_lock_irqsave(&chip->reg_lock, flags);
582 __maestro_write(chip, reg, data);
583 spin_unlock_irqrestore(&chip->reg_lock, flags);
584 }
585
586 /* no spinlock */
587 static u16 __maestro_read(struct es1968 *chip, u16 reg)
588 {
589 if (READABLE_MAP & (1 << reg)) {
590 outw(reg, chip->io_port + ESM_INDEX);
591 chip->maestro_map[reg] = inw(chip->io_port + ESM_DATA);
592 }
593 return chip->maestro_map[reg];
594 }
595
596 static inline u16 maestro_read(struct es1968 *chip, u16 reg)
597 {
598 unsigned long flags;
599 u16 result;
600 spin_lock_irqsave(&chip->reg_lock, flags);
601 result = __maestro_read(chip, reg);
602 spin_unlock_irqrestore(&chip->reg_lock, flags);
603 return result;
604 }
605
606 /* Wait for the codec bus to be free */
607 static int snd_es1968_ac97_wait(struct es1968 *chip)
608 {
609 int timeout = 100000;
610
611 while (timeout-- > 0) {
612 if (!(inb(chip->io_port + ESM_AC97_INDEX) & 1))
613 return 0;
614 cond_resched();
615 }
616 snd_printd("es1968: ac97 timeout\n");
617 return 1; /* timeout */
618 }
619
620 static int snd_es1968_ac97_wait_poll(struct es1968 *chip)
621 {
622 int timeout = 100000;
623
624 while (timeout-- > 0) {
625 if (!(inb(chip->io_port + ESM_AC97_INDEX) & 1))
626 return 0;
627 }
628 snd_printd("es1968: ac97 timeout\n");
629 return 1; /* timeout */
630 }
631
632 static void snd_es1968_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short val)
633 {
634 struct es1968 *chip = ac97->private_data;
635 unsigned long flags;
636
637 snd_es1968_ac97_wait(chip);
638
639 /* Write the bus */
640 spin_lock_irqsave(&chip->ac97_lock, flags);
641 outw(val, chip->io_port + ESM_AC97_DATA);
642 /*msleep(1);*/
643 outb(reg, chip->io_port + ESM_AC97_INDEX);
644 /*msleep(1);*/
645 spin_unlock_irqrestore(&chip->ac97_lock, flags);
646 }
647
648 static unsigned short snd_es1968_ac97_read(struct snd_ac97 *ac97, unsigned short reg)
649 {
650 u16 data = 0;
651 struct es1968 *chip = ac97->private_data;
652 unsigned long flags;
653
654 snd_es1968_ac97_wait(chip);
655
656 spin_lock_irqsave(&chip->ac97_lock, flags);
657 outb(reg | 0x80, chip->io_port + ESM_AC97_INDEX);
658 /*msleep(1);*/
659
660 if (!snd_es1968_ac97_wait_poll(chip)) {
661 data = inw(chip->io_port + ESM_AC97_DATA);
662 /*msleep(1);*/
663 }
664 spin_unlock_irqrestore(&chip->ac97_lock, flags);
665
666 return data;
667 }
668
669 /* no spinlock */
670 static void apu_index_set(struct es1968 *chip, u16 index)
671 {
672 int i;
673 __maestro_write(chip, IDR1_CRAM_POINTER, index);
674 for (i = 0; i < 1000; i++)
675 if (__maestro_read(chip, IDR1_CRAM_POINTER) == index)
676 return;
677 snd_printd("es1968: APU register select failed. (Timeout)\n");
678 }
679
680 /* no spinlock */
681 static void apu_data_set(struct es1968 *chip, u16 data)
682 {
683 int i;
684 for (i = 0; i < 1000; i++) {
685 if (__maestro_read(chip, IDR0_DATA_PORT) == data)
686 return;
687 __maestro_write(chip, IDR0_DATA_PORT, data);
688 }
689 snd_printd("es1968: APU register set probably failed (Timeout)!\n");
690 }
691
692 /* no spinlock */
693 static void __apu_set_register(struct es1968 *chip, u16 channel, u8 reg, u16 data)
694 {
695 snd_assert(channel < NR_APUS, return);
696 #ifdef CONFIG_PM
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
704 static 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
712 static u16 __apu_get_register(struct es1968 *chip, u16 channel, u8 reg)
713 {
714 snd_assert(channel < NR_APUS, return 0);
715 reg |= (channel << 4);
716 apu_index_set(chip, reg);
717 return __maestro_read(chip, IDR0_DATA_PORT);
718 }
719
720 static u16 apu_get_register(struct es1968 *chip, u16 channel, u8 reg)
721 {
722 unsigned long flags;
723 u16 v;
724 spin_lock_irqsave(&chip->reg_lock, flags);
725 v = __apu_get_register(chip, channel, reg);
726 spin_unlock_irqrestore(&chip->reg_lock, flags);
727 return v;
728 }
729
730 #if 0 /* ASSP is not supported */
731
732 static void assp_set_register(struct es1968 *chip, u32 reg, u32 value)
733 {
734 unsigned long flags;
735
736 spin_lock_irqsave(&chip->reg_lock, flags);
737 outl(reg, chip->io_port + ASSP_INDEX);
738 outl(value, chip->io_port + ASSP_DATA);
739 spin_unlock_irqrestore(&chip->reg_lock, flags);
740 }
741
742 static u32 assp_get_register(struct es1968 *chip, u32 reg)
743 {
744 unsigned long flags;
745 u32 value;
746
747 spin_lock_irqsave(&chip->reg_lock, flags);
748 outl(reg, chip->io_port + ASSP_INDEX);
749 value = inl(chip->io_port + ASSP_DATA);
750 spin_unlock_irqrestore(&chip->reg_lock, flags);
751
752 return value;
753 }
754
755 #endif
756
757 static void wave_set_register(struct es1968 *chip, u16 reg, u16 value)
758 {
759 unsigned long flags;
760
761 spin_lock_irqsave(&chip->reg_lock, flags);
762 outw(reg, chip->io_port + WC_INDEX);
763 outw(value, chip->io_port + WC_DATA);
764 spin_unlock_irqrestore(&chip->reg_lock, flags);
765 }
766
767 static u16 wave_get_register(struct es1968 *chip, u16 reg)
768 {
769 unsigned long flags;
770 u16 value;
771
772 spin_lock_irqsave(&chip->reg_lock, flags);
773 outw(reg, chip->io_port + WC_INDEX);
774 value = inw(chip->io_port + WC_DATA);
775 spin_unlock_irqrestore(&chip->reg_lock, flags);
776
777 return value;
778 }
779
780 /* *******************
781 * Bob the Timer! *
782 *******************/
783
784 static void snd_es1968_bob_stop(struct es1968 *chip)
785 {
786 u16 reg;
787
788 reg = __maestro_read(chip, 0x11);
789 reg &= ~ESM_BOB_ENABLE;
790 __maestro_write(chip, 0x11, reg);
791 reg = __maestro_read(chip, 0x17);
792 reg &= ~ESM_BOB_START;
793 __maestro_write(chip, 0x17, reg);
794 }
795
796 static void snd_es1968_bob_start(struct es1968 *chip)
797 {
798 int prescale;
799 int divide;
800
801 /* compute ideal interrupt frequency for buffer size & play rate */
802 /* first, find best prescaler value to match freq */
803 for (prescale = 5; prescale < 12; prescale++)
804 if (chip->bob_freq > (ESS_SYSCLK >> (prescale + 9)))
805 break;
806
807 /* next, back off prescaler whilst getting divider into optimum range */
808 divide = 1;
809 while ((prescale > 5) && (divide < 32)) {
810 prescale--;
811 divide <<= 1;
812 }
813 divide >>= 1;
814
815 /* now fine-tune the divider for best match */
816 for (; divide < 31; divide++)
817 if (chip->bob_freq >
818 ((ESS_SYSCLK >> (prescale + 9)) / (divide + 1))) break;
819
820 /* divide = 0 is illegal, but don't let prescale = 4! */
821 if (divide == 0) {
822 divide++;
823 if (prescale > 5)
824 prescale--;
825 } else if (divide > 1)
826 divide--;
827
828 __maestro_write(chip, 6, 0x9000 | (prescale << 5) | divide); /* set reg */
829
830 /* Now set IDR 11/17 */
831 __maestro_write(chip, 0x11, __maestro_read(chip, 0x11) | 1);
832 __maestro_write(chip, 0x17, __maestro_read(chip, 0x17) | 1);
833 }
834
835 /* call with substream spinlock */
836 static void snd_es1968_bob_inc(struct es1968 *chip, int freq)
837 {
838 chip->bobclient++;
839 if (chip->bobclient == 1) {
840 chip->bob_freq = freq;
841 snd_es1968_bob_start(chip);
842 } else if (chip->bob_freq < freq) {
843 snd_es1968_bob_stop(chip);
844 chip->bob_freq = freq;
845 snd_es1968_bob_start(chip);
846 }
847 }
848
849 /* call with substream spinlock */
850 static void snd_es1968_bob_dec(struct es1968 *chip)
851 {
852 chip->bobclient--;
853 if (chip->bobclient <= 0)
854 snd_es1968_bob_stop(chip);
855 else if (chip->bob_freq > ESM_BOB_FREQ) {
856 /* check reduction of timer frequency */
857 int max_freq = ESM_BOB_FREQ;
858 struct esschan *es;
859 list_for_each_entry(es, &chip->substream_list, list) {
860 if (max_freq < es->bob_freq)
861 max_freq = es->bob_freq;
862 }
863 if (max_freq != chip->bob_freq) {
864 snd_es1968_bob_stop(chip);
865 chip->bob_freq = max_freq;
866 snd_es1968_bob_start(chip);
867 }
868 }
869 }
870
871 static int
872 snd_es1968_calc_bob_rate(struct es1968 *chip, struct esschan *es,
873 struct snd_pcm_runtime *runtime)
874 {
875 /* we acquire 4 interrupts per period for precise control.. */
876 int freq = runtime->rate * 4;
877 if (es->fmt & ESS_FMT_STEREO)
878 freq <<= 1;
879 if (es->fmt & ESS_FMT_16BIT)
880 freq <<= 1;
881 freq /= es->frag_size;
882 if (freq < ESM_BOB_FREQ)
883 freq = ESM_BOB_FREQ;
884 else if (freq > ESM_BOB_FREQ_MAX)
885 freq = ESM_BOB_FREQ_MAX;
886 return freq;
887 }
888
889
890 /*************
891 * PCM Part *
892 *************/
893
894 static u32 snd_es1968_compute_rate(struct es1968 *chip, u32 freq)
895 {
896 u32 rate = (freq << 16) / chip->clock;
897 #if 0 /* XXX: do we need this? */
898 if (rate > 0x10000)
899 rate = 0x10000;
900 #endif
901 return rate;
902 }
903
904 /* get current pointer */
905 static inline unsigned int
906 snd_es1968_get_dma_ptr(struct es1968 *chip, struct esschan *es)
907 {
908 unsigned int offset;
909
910 offset = apu_get_register(chip, es->apu[0], 5);
911
912 offset -= es->base[0];
913
914 return (offset & 0xFFFE); /* hardware is in words */
915 }
916
917 static void snd_es1968_apu_set_freq(struct es1968 *chip, int apu, int freq)
918 {
919 apu_set_register(chip, apu, 2,
920 (apu_get_register(chip, apu, 2) & 0x00FF) |
921 ((freq & 0xff) << 8) | 0x10);
922 apu_set_register(chip, apu, 3, freq >> 8);
923 }
924
925 /* spin lock held */
926 static inline void snd_es1968_trigger_apu(struct es1968 *esm, int apu, int mode)
927 {
928 /* set the APU mode */
929 __apu_set_register(esm, apu, 0,
930 (__apu_get_register(esm, apu, 0) & 0xff0f) |
931 (mode << 4));
932 }
933
934 static void snd_es1968_pcm_start(struct es1968 *chip, struct esschan *es)
935 {
936 spin_lock(&chip->reg_lock);
937 __apu_set_register(chip, es->apu[0], 5, es->base[0]);
938 snd_es1968_trigger_apu(chip, es->apu[0], es->apu_mode[0]);
939 if (es->mode == ESM_MODE_CAPTURE) {
940 __apu_set_register(chip, es->apu[2], 5, es->base[2]);
941 snd_es1968_trigger_apu(chip, es->apu[2], es->apu_mode[2]);
942 }
943 if (es->fmt & ESS_FMT_STEREO) {
944 __apu_set_register(chip, es->apu[1], 5, es->base[1]);
945 snd_es1968_trigger_apu(chip, es->apu[1], es->apu_mode[1]);
946 if (es->mode == ESM_MODE_CAPTURE) {
947 __apu_set_register(chip, es->apu[3], 5, es->base[3]);
948 snd_es1968_trigger_apu(chip, es->apu[3], es->apu_mode[3]);
949 }
950 }
951 spin_unlock(&chip->reg_lock);
952 }
953
954 static void snd_es1968_pcm_stop(struct es1968 *chip, struct esschan *es)
955 {
956 spin_lock(&chip->reg_lock);
957 snd_es1968_trigger_apu(chip, es->apu[0], 0);
958 snd_es1968_trigger_apu(chip, es->apu[1], 0);
959 if (es->mode == ESM_MODE_CAPTURE) {
960 snd_es1968_trigger_apu(chip, es->apu[2], 0);
961 snd_es1968_trigger_apu(chip, es->apu[3], 0);
962 }
963 spin_unlock(&chip->reg_lock);
964 }
965
966 /* set the wavecache control reg */
967 static void snd_es1968_program_wavecache(struct es1968 *chip, struct esschan *es,
968 int channel, u32 addr, int capture)
969 {
970 u32 tmpval = (addr - 0x10) & 0xFFF8;
971
972 if (! capture) {
973 if (!(es->fmt & ESS_FMT_16BIT))
974 tmpval |= 4; /* 8bit */
975 if (es->fmt & ESS_FMT_STEREO)
976 tmpval |= 2; /* stereo */
977 }
978
979 /* set the wavecache control reg */
980 wave_set_register(chip, es->apu[channel] << 3, tmpval);
981
982 #ifdef CONFIG_PM
983 es->wc_map[channel] = tmpval;
984 #endif
985 }
986
987
988 static void snd_es1968_playback_setup(struct es1968 *chip, struct esschan *es,
989 struct snd_pcm_runtime *runtime)
990 {
991 u32 pa;
992 int high_apu = 0;
993 int channel, apu;
994 int i, size;
995 unsigned long flags;
996 u32 freq;
997
998 size = es->dma_size >> es->wav_shift;
999
1000 if (es->fmt & ESS_FMT_STEREO)
1001 high_apu++;
1002
1003 for (channel = 0; channel <= high_apu; channel++) {
1004 apu = es->apu[channel];
1005
1006 snd_es1968_program_wavecache(chip, es, channel, es->memory->buf.addr, 0);
1007
1008 /* Offset to PCMBAR */
1009 pa = es->memory->buf.addr;
1010 pa -= chip->dma.addr;
1011 pa >>= 1; /* words */
1012
1013 pa |= 0x00400000; /* System RAM (Bit 22) */
1014
1015 if (es->fmt & ESS_FMT_STEREO) {
1016 /* Enable stereo */
1017 if (channel)
1018 pa |= 0x00800000; /* (Bit 23) */
1019 if (es->fmt & ESS_FMT_16BIT)
1020 pa >>= 1;
1021 }
1022
1023 /* base offset of dma calcs when reading the pointer
1024 on this left one */
1025 es->base[channel] = pa & 0xFFFF;
1026
1027 for (i = 0; i < 16; i++)
1028 apu_set_register(chip, apu, i, 0x0000);
1029
1030 /* Load the buffer into the wave engine */
1031 apu_set_register(chip, apu, 4, ((pa >> 16) & 0xFF) << 8);
1032 apu_set_register(chip, apu, 5, pa & 0xFFFF);
1033 apu_set_register(chip, apu, 6, (pa + size) & 0xFFFF);
1034 /* setting loop == sample len */
1035 apu_set_register(chip, apu, 7, size);
1036
1037 /* clear effects/env.. */
1038 apu_set_register(chip, apu, 8, 0x0000);
1039 /* set amp now to 0xd0 (?), low byte is 'amplitude dest'? */
1040 apu_set_register(chip, apu, 9, 0xD000);
1041
1042 /* clear routing stuff */
1043 apu_set_register(chip, apu, 11, 0x0000);
1044 /* dma on, no envelopes, filter to all 1s) */
1045 apu_set_register(chip, apu, 0, 0x400F);
1046
1047 if (es->fmt & ESS_FMT_16BIT)
1048 es->apu_mode[channel] = ESM_APU_16BITLINEAR;
1049 else
1050 es->apu_mode[channel] = ESM_APU_8BITLINEAR;
1051
1052 if (es->fmt & ESS_FMT_STEREO) {
1053 /* set panning: left or right */
1054 /* Check: different panning. On my Canyon 3D Chipset the
1055 Channels are swapped. I don't know, about the output
1056 to the SPDif Link. Perhaps you have to change this
1057 and not the APU Regs 4-5. */
1058 apu_set_register(chip, apu, 10,
1059 0x8F00 | (channel ? 0 : 0x10));
1060 es->apu_mode[channel] += 1; /* stereo */
1061 } else
1062 apu_set_register(chip, apu, 10, 0x8F08);
1063 }
1064
1065 spin_lock_irqsave(&chip->reg_lock, flags);
1066 /* clear WP interrupts */
1067 outw(1, chip->io_port + 0x04);
1068 /* enable WP ints */
1069 outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ);
1070 spin_unlock_irqrestore(&chip->reg_lock, flags);
1071
1072 freq = runtime->rate;
1073 /* set frequency */
1074 if (freq > 48000)
1075 freq = 48000;
1076 if (freq < 4000)
1077 freq = 4000;
1078
1079 /* hmmm.. */
1080 if (!(es->fmt & ESS_FMT_16BIT) && !(es->fmt & ESS_FMT_STEREO))
1081 freq >>= 1;
1082
1083 freq = snd_es1968_compute_rate(chip, freq);
1084
1085 /* Load the frequency, turn on 6dB */
1086 snd_es1968_apu_set_freq(chip, es->apu[0], freq);
1087 snd_es1968_apu_set_freq(chip, es->apu[1], freq);
1088 }
1089
1090
1091 static void init_capture_apu(struct es1968 *chip, struct esschan *es, int channel,
1092 unsigned int pa, unsigned int bsize,
1093 int mode, int route)
1094 {
1095 int i, apu = es->apu[channel];
1096
1097 es->apu_mode[channel] = mode;
1098
1099 /* set the wavecache control reg */
1100 snd_es1968_program_wavecache(chip, es, channel, pa, 1);
1101
1102 /* Offset to PCMBAR */
1103 pa -= chip->dma.addr;
1104 pa >>= 1; /* words */
1105
1106 /* base offset of dma calcs when reading the pointer
1107 on this left one */
1108 es->base[channel] = pa & 0xFFFF;
1109 pa |= 0x00400000; /* bit 22 -> System RAM */
1110
1111 /* Begin loading the APU */
1112 for (i = 0; i < 16; i++)
1113 apu_set_register(chip, apu, i, 0x0000);
1114
1115 /* need to enable subgroups.. and we should probably
1116 have different groups for different /dev/dsps.. */
1117 apu_set_register(chip, apu, 2, 0x8);
1118
1119 /* Load the buffer into the wave engine */
1120 apu_set_register(chip, apu, 4, ((pa >> 16) & 0xFF) << 8);
1121 apu_set_register(chip, apu, 5, pa & 0xFFFF);
1122 apu_set_register(chip, apu, 6, (pa + bsize) & 0xFFFF);
1123 apu_set_register(chip, apu, 7, bsize);
1124 /* clear effects/env.. */
1125 apu_set_register(chip, apu, 8, 0x00F0);
1126 /* amplitude now? sure. why not. */
1127 apu_set_register(chip, apu, 9, 0x0000);
1128 /* set filter tune, radius, polar pan */
1129 apu_set_register(chip, apu, 10, 0x8F08);
1130 /* route input */
1131 apu_set_register(chip, apu, 11, route);
1132 /* dma on, no envelopes, filter to all 1s) */
1133 apu_set_register(chip, apu, 0, 0x400F);
1134 }
1135
1136 static void snd_es1968_capture_setup(struct es1968 *chip, struct esschan *es,
1137 struct snd_pcm_runtime *runtime)
1138 {
1139 int size;
1140 u32 freq;
1141 unsigned long flags;
1142
1143 size = es->dma_size >> es->wav_shift;
1144
1145 /* APU assignments:
1146 0 = mono/left SRC
1147 1 = right SRC
1148 2 = mono/left Input Mixer
1149 3 = right Input Mixer
1150 */
1151 /* data seems to flow from the codec, through an apu into
1152 the 'mixbuf' bit of page, then through the SRC apu
1153 and out to the real 'buffer'. ok. sure. */
1154
1155 /* input mixer (left/mono) */
1156 /* parallel in crap, see maestro reg 0xC [8-11] */
1157 init_capture_apu(chip, es, 2,
1158 es->mixbuf->buf.addr, ESM_MIXBUF_SIZE/4, /* in words */
1159 ESM_APU_INPUTMIXER, 0x14);
1160 /* SRC (left/mono); get input from inputing apu */
1161 init_capture_apu(chip, es, 0, es->memory->buf.addr, size,
1162 ESM_APU_SRCONVERTOR, es->apu[2]);
1163 if (es->fmt & ESS_FMT_STEREO) {
1164 /* input mixer (right) */
1165 init_capture_apu(chip, es, 3,
1166 es->mixbuf->buf.addr + ESM_MIXBUF_SIZE/2,
1167 ESM_MIXBUF_SIZE/4, /* in words */
1168 ESM_APU_INPUTMIXER, 0x15);
1169 /* SRC (right) */
1170 init_capture_apu(chip, es, 1,
1171 es->memory->buf.addr + size*2, size,
1172 ESM_APU_SRCONVERTOR, es->apu[3]);
1173 }
1174
1175 freq = runtime->rate;
1176 /* Sample Rate conversion APUs don't like 0x10000 for their rate */
1177 if (freq > 47999)
1178 freq = 47999;
1179 if (freq < 4000)
1180 freq = 4000;
1181
1182 freq = snd_es1968_compute_rate(chip, freq);
1183
1184 /* Load the frequency, turn on 6dB */
1185 snd_es1968_apu_set_freq(chip, es->apu[0], freq);
1186 snd_es1968_apu_set_freq(chip, es->apu[1], freq);
1187
1188 /* fix mixer rate at 48khz. and its _must_ be 0x10000. */
1189 freq = 0x10000;
1190 snd_es1968_apu_set_freq(chip, es->apu[2], freq);
1191 snd_es1968_apu_set_freq(chip, es->apu[3], freq);
1192
1193 spin_lock_irqsave(&chip->reg_lock, flags);
1194 /* clear WP interrupts */
1195 outw(1, chip->io_port + 0x04);
1196 /* enable WP ints */
1197 outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ);
1198 spin_unlock_irqrestore(&chip->reg_lock, flags);
1199 }
1200
1201 /*******************
1202 * ALSA Interface *
1203 *******************/
1204
1205 static int snd_es1968_pcm_prepare(struct snd_pcm_substream *substream)
1206 {
1207 struct es1968 *chip = snd_pcm_substream_chip(substream);
1208 struct snd_pcm_runtime *runtime = substream->runtime;
1209 struct esschan *es = runtime->private_data;
1210
1211 es->dma_size = snd_pcm_lib_buffer_bytes(substream);
1212 es->frag_size = snd_pcm_lib_period_bytes(substream);
1213
1214 es->wav_shift = 1; /* maestro handles always 16bit */
1215 es->fmt = 0;
1216 if (snd_pcm_format_width(runtime->format) == 16)
1217 es->fmt |= ESS_FMT_16BIT;
1218 if (runtime->channels > 1) {
1219 es->fmt |= ESS_FMT_STEREO;
1220 if (es->fmt & ESS_FMT_16BIT) /* 8bit is already word shifted */
1221 es->wav_shift++;
1222 }
1223 es->bob_freq = snd_es1968_calc_bob_rate(chip, es, runtime);
1224
1225 switch (es->mode) {
1226 case ESM_MODE_PLAY:
1227 snd_es1968_playback_setup(chip, es, runtime);
1228 break;
1229 case ESM_MODE_CAPTURE:
1230 snd_es1968_capture_setup(chip, es, runtime);
1231 break;
1232 }
1233
1234 return 0;
1235 }
1236
1237 static int snd_es1968_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
1238 {
1239 struct es1968 *chip = snd_pcm_substream_chip(substream);
1240 struct esschan *es = substream->runtime->private_data;
1241
1242 spin_lock(&chip->substream_lock);
1243 switch (cmd) {
1244 case SNDRV_PCM_TRIGGER_START:
1245 case SNDRV_PCM_TRIGGER_RESUME:
1246 if (es->running)
1247 break;
1248 snd_es1968_bob_inc(chip, es->bob_freq);
1249 es->count = 0;
1250 es->hwptr = 0;
1251 snd_es1968_pcm_start(chip, es);
1252 es->running = 1;
1253 break;
1254 case SNDRV_PCM_TRIGGER_STOP:
1255 case SNDRV_PCM_TRIGGER_SUSPEND:
1256 if (! es->running)
1257 break;
1258 snd_es1968_pcm_stop(chip, es);
1259 es->running = 0;
1260 snd_es1968_bob_dec(chip);
1261 break;
1262 }
1263 spin_unlock(&chip->substream_lock);
1264 return 0;
1265 }
1266
1267 static snd_pcm_uframes_t snd_es1968_pcm_pointer(struct snd_pcm_substream *substream)
1268 {
1269 struct es1968 *chip = snd_pcm_substream_chip(substream);
1270 struct esschan *es = substream->runtime->private_data;
1271 unsigned int ptr;
1272
1273 ptr = snd_es1968_get_dma_ptr(chip, es) << es->wav_shift;
1274
1275 return bytes_to_frames(substream->runtime, ptr % es->dma_size);
1276 }
1277
1278 static struct snd_pcm_hardware snd_es1968_playback = {
1279 .info = (SNDRV_PCM_INFO_MMAP |
1280 SNDRV_PCM_INFO_MMAP_VALID |
1281 SNDRV_PCM_INFO_INTERLEAVED |
1282 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1283 /*SNDRV_PCM_INFO_PAUSE |*/
1284 SNDRV_PCM_INFO_RESUME),
1285 .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE,
1286 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
1287 .rate_min = 4000,
1288 .rate_max = 48000,
1289 .channels_min = 1,
1290 .channels_max = 2,
1291 .buffer_bytes_max = 65536,
1292 .period_bytes_min = 256,
1293 .period_bytes_max = 65536,
1294 .periods_min = 1,
1295 .periods_max = 1024,
1296 .fifo_size = 0,
1297 };
1298
1299 static struct snd_pcm_hardware snd_es1968_capture = {
1300 .info = (SNDRV_PCM_INFO_NONINTERLEAVED |
1301 SNDRV_PCM_INFO_MMAP |
1302 SNDRV_PCM_INFO_MMAP_VALID |
1303 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1304 /*SNDRV_PCM_INFO_PAUSE |*/
1305 SNDRV_PCM_INFO_RESUME),
1306 .formats = /*SNDRV_PCM_FMTBIT_U8 |*/ SNDRV_PCM_FMTBIT_S16_LE,
1307 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
1308 .rate_min = 4000,
1309 .rate_max = 48000,
1310 .channels_min = 1,
1311 .channels_max = 2,
1312 .buffer_bytes_max = 65536,
1313 .period_bytes_min = 256,
1314 .period_bytes_max = 65536,
1315 .periods_min = 1,
1316 .periods_max = 1024,
1317 .fifo_size = 0,
1318 };
1319
1320 /* *************************
1321 * DMA memory management *
1322 *************************/
1323
1324 /* Because the Maestro can only take addresses relative to the PCM base address
1325 register :( */
1326
1327 static int calc_available_memory_size(struct es1968 *chip)
1328 {
1329 int max_size = 0;
1330 struct esm_memory *buf;
1331
1332 mutex_lock(&chip->memory_mutex);
1333 list_for_each_entry(buf, &chip->buf_list, list) {
1334 if (buf->empty && buf->buf.bytes > max_size)
1335 max_size = buf->buf.bytes;
1336 }
1337 mutex_unlock(&chip->memory_mutex);
1338 if (max_size >= 128*1024)
1339 max_size = 127*1024;
1340 return max_size;
1341 }
1342
1343 /* allocate a new memory chunk with the specified size */
1344 static struct esm_memory *snd_es1968_new_memory(struct es1968 *chip, int size)
1345 {
1346 struct esm_memory *buf;
1347
1348 size = ALIGN(size, ESM_MEM_ALIGN);
1349 mutex_lock(&chip->memory_mutex);
1350 list_for_each_entry(buf, &chip->buf_list, list) {
1351 if (buf->empty && buf->buf.bytes >= size)
1352 goto __found;
1353 }
1354 mutex_unlock(&chip->memory_mutex);
1355 return NULL;
1356
1357 __found:
1358 if (buf->buf.bytes > size) {
1359 struct esm_memory *chunk = kmalloc(sizeof(*chunk), GFP_KERNEL);
1360 if (chunk == NULL) {
1361 mutex_unlock(&chip->memory_mutex);
1362 return NULL;
1363 }
1364 chunk->buf = buf->buf;
1365 chunk->buf.bytes -= size;
1366 chunk->buf.area += size;
1367 chunk->buf.addr += size;
1368 chunk->empty = 1;
1369 buf->buf.bytes = size;
1370 list_add(&chunk->list, &buf->list);
1371 }
1372 buf->empty = 0;
1373 mutex_unlock(&chip->memory_mutex);
1374 return buf;
1375 }
1376
1377 /* free a memory chunk */
1378 static void snd_es1968_free_memory(struct es1968 *chip, struct esm_memory *buf)
1379 {
1380 struct esm_memory *chunk;
1381
1382 mutex_lock(&chip->memory_mutex);
1383 buf->empty = 1;
1384 if (buf->list.prev != &chip->buf_list) {
1385 chunk = list_entry(buf->list.prev, struct esm_memory, list);
1386 if (chunk->empty) {
1387 chunk->buf.bytes += buf->buf.bytes;
1388 list_del(&buf->list);
1389 kfree(buf);
1390 buf = chunk;
1391 }
1392 }
1393 if (buf->list.next != &chip->buf_list) {
1394 chunk = list_entry(buf->list.next, struct esm_memory, list);
1395 if (chunk->empty) {
1396 buf->buf.bytes += chunk->buf.bytes;
1397 list_del(&chunk->list);
1398 kfree(chunk);
1399 }
1400 }
1401 mutex_unlock(&chip->memory_mutex);
1402 }
1403
1404 static void snd_es1968_free_dmabuf(struct es1968 *chip)
1405 {
1406 struct list_head *p;
1407
1408 if (! chip->dma.area)
1409 return;
1410 snd_dma_reserve_buf(&chip->dma, snd_dma_pci_buf_id(chip->pci));
1411 while ((p = chip->buf_list.next) != &chip->buf_list) {
1412 struct esm_memory *chunk = list_entry(p, struct esm_memory, list);
1413 list_del(p);
1414 kfree(chunk);
1415 }
1416 }
1417
1418 static int __devinit
1419 snd_es1968_init_dmabuf(struct es1968 *chip)
1420 {
1421 int err;
1422 struct esm_memory *chunk;
1423
1424 chip->dma.dev.type = SNDRV_DMA_TYPE_DEV;
1425 chip->dma.dev.dev = snd_dma_pci_data(chip->pci);
1426 if (! snd_dma_get_reserved_buf(&chip->dma, snd_dma_pci_buf_id(chip->pci))) {
1427 err = snd_dma_alloc_pages_fallback(SNDRV_DMA_TYPE_DEV,
1428 snd_dma_pci_data(chip->pci),
1429 chip->total_bufsize, &chip->dma);
1430 if (err < 0 || ! chip->dma.area) {
1431 snd_printk(KERN_ERR "es1968: can't allocate dma pages for size %d\n",
1432 chip->total_bufsize);
1433 return -ENOMEM;
1434 }
1435 if ((chip->dma.addr + chip->dma.bytes - 1) & ~((1 << 28) - 1)) {
1436 snd_dma_free_pages(&chip->dma);
1437 snd_printk(KERN_ERR "es1968: DMA buffer beyond 256MB.\n");
1438 return -ENOMEM;
1439 }
1440 }
1441
1442 INIT_LIST_HEAD(&chip->buf_list);
1443 /* allocate an empty chunk */
1444 chunk = kmalloc(sizeof(*chunk), GFP_KERNEL);
1445 if (chunk == NULL) {
1446 snd_es1968_free_dmabuf(chip);
1447 return -ENOMEM;
1448 }
1449 memset(chip->dma.area, 0, ESM_MEM_ALIGN);
1450 chunk->buf = chip->dma;
1451 chunk->buf.area += ESM_MEM_ALIGN;
1452 chunk->buf.addr += ESM_MEM_ALIGN;
1453 chunk->buf.bytes -= ESM_MEM_ALIGN;
1454 chunk->empty = 1;
1455 list_add(&chunk->list, &chip->buf_list);
1456
1457 return 0;
1458 }
1459
1460 /* setup the dma_areas */
1461 /* buffer is extracted from the pre-allocated memory chunk */
1462 static int snd_es1968_hw_params(struct snd_pcm_substream *substream,
1463 struct snd_pcm_hw_params *hw_params)
1464 {
1465 struct es1968 *chip = snd_pcm_substream_chip(substream);
1466 struct snd_pcm_runtime *runtime = substream->runtime;
1467 struct esschan *chan = runtime->private_data;
1468 int size = params_buffer_bytes(hw_params);
1469
1470 if (chan->memory) {
1471 if (chan->memory->buf.bytes >= size) {
1472 runtime->dma_bytes = size;
1473 return 0;
1474 }
1475 snd_es1968_free_memory(chip, chan->memory);
1476 }
1477 chan->memory = snd_es1968_new_memory(chip, size);
1478 if (chan->memory == NULL) {
1479 // snd_printd("cannot allocate dma buffer: size = %d\n", size);
1480 return -ENOMEM;
1481 }
1482 snd_pcm_set_runtime_buffer(substream, &chan->memory->buf);
1483 return 1; /* area was changed */
1484 }
1485
1486 /* remove dma areas if allocated */
1487 static int snd_es1968_hw_free(struct snd_pcm_substream *substream)
1488 {
1489 struct es1968 *chip = snd_pcm_substream_chip(substream);
1490 struct snd_pcm_runtime *runtime = substream->runtime;
1491 struct esschan *chan;
1492
1493 if (runtime->private_data == NULL)
1494 return 0;
1495 chan = runtime->private_data;
1496 if (chan->memory) {
1497 snd_es1968_free_memory(chip, chan->memory);
1498 chan->memory = NULL;
1499 }
1500 return 0;
1501 }
1502
1503
1504 /*
1505 * allocate APU pair
1506 */
1507 static int snd_es1968_alloc_apu_pair(struct es1968 *chip, int type)
1508 {
1509 int apu;
1510
1511 for (apu = 0; apu < NR_APUS; apu += 2) {
1512 if (chip->apu[apu] == ESM_APU_FREE &&
1513 chip->apu[apu + 1] == ESM_APU_FREE) {
1514 chip->apu[apu] = chip->apu[apu + 1] = type;
1515 return apu;
1516 }
1517 }
1518 return -EBUSY;
1519 }
1520
1521 /*
1522 * release APU pair
1523 */
1524 static void snd_es1968_free_apu_pair(struct es1968 *chip, int apu)
1525 {
1526 chip->apu[apu] = chip->apu[apu + 1] = ESM_APU_FREE;
1527 }
1528
1529
1530 /******************
1531 * PCM open/close *
1532 ******************/
1533
1534 static int snd_es1968_playback_open(struct snd_pcm_substream *substream)
1535 {
1536 struct es1968 *chip = snd_pcm_substream_chip(substream);
1537 struct snd_pcm_runtime *runtime = substream->runtime;
1538 struct esschan *es;
1539 int apu1;
1540
1541 /* search 2 APUs */
1542 apu1 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_PLAY);
1543 if (apu1 < 0)
1544 return apu1;
1545
1546 es = kzalloc(sizeof(*es), GFP_KERNEL);
1547 if (!es) {
1548 snd_es1968_free_apu_pair(chip, apu1);
1549 return -ENOMEM;
1550 }
1551
1552 es->apu[0] = apu1;
1553 es->apu[1] = apu1 + 1;
1554 es->apu_mode[0] = 0;
1555 es->apu_mode[1] = 0;
1556 es->running = 0;
1557 es->substream = substream;
1558 es->mode = ESM_MODE_PLAY;
1559
1560 runtime->private_data = es;
1561 runtime->hw = snd_es1968_playback;
1562 runtime->hw.buffer_bytes_max = runtime->hw.period_bytes_max =
1563 calc_available_memory_size(chip);
1564
1565 spin_lock_irq(&chip->substream_lock);
1566 list_add(&es->list, &chip->substream_list);
1567 spin_unlock_irq(&chip->substream_lock);
1568
1569 return 0;
1570 }
1571
1572 static int snd_es1968_capture_open(struct snd_pcm_substream *substream)
1573 {
1574 struct snd_pcm_runtime *runtime = substream->runtime;
1575 struct es1968 *chip = snd_pcm_substream_chip(substream);
1576 struct esschan *es;
1577 int apu1, apu2;
1578
1579 apu1 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_CAPTURE);
1580 if (apu1 < 0)
1581 return apu1;
1582 apu2 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_RATECONV);
1583 if (apu2 < 0) {
1584 snd_es1968_free_apu_pair(chip, apu1);
1585 return apu2;
1586 }
1587
1588 es = kzalloc(sizeof(*es), GFP_KERNEL);
1589 if (!es) {
1590 snd_es1968_free_apu_pair(chip, apu1);
1591 snd_es1968_free_apu_pair(chip, apu2);
1592 return -ENOMEM;
1593 }
1594
1595 es->apu[0] = apu1;
1596 es->apu[1] = apu1 + 1;
1597 es->apu[2] = apu2;
1598 es->apu[3] = apu2 + 1;
1599 es->apu_mode[0] = 0;
1600 es->apu_mode[1] = 0;
1601 es->apu_mode[2] = 0;
1602 es->apu_mode[3] = 0;
1603 es->running = 0;
1604 es->substream = substream;
1605 es->mode = ESM_MODE_CAPTURE;
1606
1607 /* get mixbuffer */
1608 if ((es->mixbuf = snd_es1968_new_memory(chip, ESM_MIXBUF_SIZE)) == NULL) {
1609 snd_es1968_free_apu_pair(chip, apu1);
1610 snd_es1968_free_apu_pair(chip, apu2);
1611 kfree(es);
1612 return -ENOMEM;
1613 }
1614 memset(es->mixbuf->buf.area, 0, ESM_MIXBUF_SIZE);
1615
1616 runtime->private_data = es;
1617 runtime->hw = snd_es1968_capture;
1618 runtime->hw.buffer_bytes_max = runtime->hw.period_bytes_max =
1619 calc_available_memory_size(chip) - 1024; /* keep MIXBUF size */
1620 snd_pcm_hw_constraint_pow2(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES);
1621
1622 spin_lock_irq(&chip->substream_lock);
1623 list_add(&es->list, &chip->substream_list);
1624 spin_unlock_irq(&chip->substream_lock);
1625
1626 return 0;
1627 }
1628
1629 static int snd_es1968_playback_close(struct snd_pcm_substream *substream)
1630 {
1631 struct es1968 *chip = snd_pcm_substream_chip(substream);
1632 struct esschan *es;
1633
1634 if (substream->runtime->private_data == NULL)
1635 return 0;
1636 es = substream->runtime->private_data;
1637 spin_lock_irq(&chip->substream_lock);
1638 list_del(&es->list);
1639 spin_unlock_irq(&chip->substream_lock);
1640 snd_es1968_free_apu_pair(chip, es->apu[0]);
1641 kfree(es);
1642
1643 return 0;
1644 }
1645
1646 static int snd_es1968_capture_close(struct snd_pcm_substream *substream)
1647 {
1648 struct es1968 *chip = snd_pcm_substream_chip(substream);
1649 struct esschan *es;
1650
1651 if (substream->runtime->private_data == NULL)
1652 return 0;
1653 es = substream->runtime->private_data;
1654 spin_lock_irq(&chip->substream_lock);
1655 list_del(&es->list);
1656 spin_unlock_irq(&chip->substream_lock);
1657 snd_es1968_free_memory(chip, es->mixbuf);
1658 snd_es1968_free_apu_pair(chip, es->apu[0]);
1659 snd_es1968_free_apu_pair(chip, es->apu[2]);
1660 kfree(es);
1661
1662 return 0;
1663 }
1664
1665 static struct snd_pcm_ops snd_es1968_playback_ops = {
1666 .open = snd_es1968_playback_open,
1667 .close = snd_es1968_playback_close,
1668 .ioctl = snd_pcm_lib_ioctl,
1669 .hw_params = snd_es1968_hw_params,
1670 .hw_free = snd_es1968_hw_free,
1671 .prepare = snd_es1968_pcm_prepare,
1672 .trigger = snd_es1968_pcm_trigger,
1673 .pointer = snd_es1968_pcm_pointer,
1674 };
1675
1676 static struct snd_pcm_ops snd_es1968_capture_ops = {
1677 .open = snd_es1968_capture_open,
1678 .close = snd_es1968_capture_close,
1679 .ioctl = snd_pcm_lib_ioctl,
1680 .hw_params = snd_es1968_hw_params,
1681 .hw_free = snd_es1968_hw_free,
1682 .prepare = snd_es1968_pcm_prepare,
1683 .trigger = snd_es1968_pcm_trigger,
1684 .pointer = snd_es1968_pcm_pointer,
1685 };
1686
1687
1688 /*
1689 * measure clock
1690 */
1691 #define CLOCK_MEASURE_BUFSIZE 16768 /* enough large for a single shot */
1692
1693 static void __devinit es1968_measure_clock(struct es1968 *chip)
1694 {
1695 int i, apu;
1696 unsigned int pa, offset, t;
1697 struct esm_memory *memory;
1698 struct timeval start_time, stop_time;
1699
1700 if (chip->clock == 0)
1701 chip->clock = 48000; /* default clock value */
1702
1703 /* search 2 APUs (although one apu is enough) */
1704 if ((apu = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_PLAY)) < 0) {
1705 snd_printk(KERN_ERR "Hmm, cannot find empty APU pair!?\n");
1706 return;
1707 }
1708 if ((memory = snd_es1968_new_memory(chip, CLOCK_MEASURE_BUFSIZE)) == NULL) {
1709 snd_printk(KERN_ERR "cannot allocate dma buffer - using default clock %d\n", 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; /* System RAM (Bit 22) */
1720
1721 /* initialize apu */
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); /* clear WP interrupts */
1736 outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ); /* enable WP ints */
1737 spin_unlock_irq(&chip->reg_lock);
1738
1739 snd_es1968_apu_set_freq(chip, apu, ((unsigned int)48000 << 16) / chip->clock); /* 48000 Hz */
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 do_gettimeofday(&start_time);
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 do_gettimeofday(&stop_time);
1753 snd_es1968_trigger_apu(chip, apu, 0); /* stop */
1754 snd_es1968_bob_dec(chip);
1755 chip->in_measurement = 0;
1756 spin_unlock_irq(&chip->reg_lock);
1757
1758 /* check the current position */
1759 offset -= (pa & 0xffff);
1760 offset &= 0xfffe;
1761 offset += chip->measure_count * (CLOCK_MEASURE_BUFSIZE/2);
1762
1763 t = stop_time.tv_sec - start_time.tv_sec;
1764 t *= 1000000;
1765 if (stop_time.tv_usec < start_time.tv_usec)
1766 t -= start_time.tv_usec - stop_time.tv_usec;
1767 else
1768 t += stop_time.tv_usec - start_time.tv_usec;
1769 if (t == 0) {
1770 snd_printk(KERN_ERR "?? calculation error..\n");
1771 } else {
1772 offset *= 1000;
1773 offset = (offset / t) * 1000 + ((offset % t) * 1000) / t;
1774 if (offset < 47500 || offset > 48500) {
1775 if (offset >= 40000 && offset <= 50000)
1776 chip->clock = (chip->clock * offset) / 48000;
1777 }
1778 printk(KERN_INFO "es1968: clocking to %d\n", chip->clock);
1779 }
1780 snd_es1968_free_memory(chip, memory);
1781 snd_es1968_free_apu_pair(chip, apu);
1782 }
1783
1784
1785 /*
1786 */
1787
1788 static void snd_es1968_pcm_free(struct snd_pcm *pcm)
1789 {
1790 struct es1968 *esm = pcm->private_data;
1791 snd_es1968_free_dmabuf(esm);
1792 esm->pcm = NULL;
1793 }
1794
1795 static int __devinit
1796 snd_es1968_pcm(struct es1968 *chip, int device)
1797 {
1798 struct snd_pcm *pcm;
1799 int err;
1800
1801 /* get DMA buffer */
1802 if ((err = snd_es1968_init_dmabuf(chip)) < 0)
1803 return err;
1804
1805 /* set PCMBAR */
1806 wave_set_register(chip, 0x01FC, chip->dma.addr >> 12);
1807 wave_set_register(chip, 0x01FD, chip->dma.addr >> 12);
1808 wave_set_register(chip, 0x01FE, chip->dma.addr >> 12);
1809 wave_set_register(chip, 0x01FF, chip->dma.addr >> 12);
1810
1811 if ((err = snd_pcm_new(chip->card, "ESS Maestro", device,
1812 chip->playback_streams,
1813 chip->capture_streams, &pcm)) < 0)
1814 return err;
1815
1816 pcm->private_data = chip;
1817 pcm->private_free = snd_es1968_pcm_free;
1818
1819 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_es1968_playback_ops);
1820 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1968_capture_ops);
1821
1822 pcm->info_flags = 0;
1823
1824 strcpy(pcm->name, "ESS Maestro");
1825
1826 chip->pcm = pcm;
1827
1828 return 0;
1829 }
1830
1831 /*
1832 * update pointer
1833 */
1834 static void snd_es1968_update_pcm(struct es1968 *chip, struct esschan *es)
1835 {
1836 unsigned int hwptr;
1837 unsigned int diff;
1838 struct snd_pcm_substream *subs = es->substream;
1839
1840 if (subs == NULL || !es->running)
1841 return;
1842
1843 hwptr = snd_es1968_get_dma_ptr(chip, es) << es->wav_shift;
1844 hwptr %= es->dma_size;
1845
1846 diff = (es->dma_size + hwptr - es->hwptr) % es->dma_size;
1847
1848 es->hwptr = hwptr;
1849 es->count += diff;
1850
1851 if (es->count > es->frag_size) {
1852 spin_unlock(&chip->substream_lock);
1853 snd_pcm_period_elapsed(subs);
1854 spin_lock(&chip->substream_lock);
1855 es->count %= es->frag_size;
1856 }
1857 }
1858
1859 /*
1860 */
1861 static void es1968_update_hw_volume(unsigned long private_data)
1862 {
1863 struct es1968 *chip = (struct es1968 *) private_data;
1864 int x, val;
1865 unsigned long flags;
1866
1867 /* Figure out which volume control button was pushed,
1868 based on differences from the default register
1869 values. */
1870 x = inb(chip->io_port + 0x1c) & 0xee;
1871 /* Reset the volume control registers. */
1872 outb(0x88, chip->io_port + 0x1c);
1873 outb(0x88, chip->io_port + 0x1d);
1874 outb(0x88, chip->io_port + 0x1e);
1875 outb(0x88, chip->io_port + 0x1f);
1876
1877 if (chip->in_suspend)
1878 return;
1879
1880 if (! chip->master_switch || ! chip->master_volume)
1881 return;
1882
1883 /* FIXME: we can't call snd_ac97_* functions since here is in tasklet. */
1884 spin_lock_irqsave(&chip->ac97_lock, flags);
1885 val = chip->ac97->regs[AC97_MASTER];
1886 switch (x) {
1887 case 0x88:
1888 /* mute */
1889 val ^= 0x8000;
1890 chip->ac97->regs[AC97_MASTER] = val;
1891 outw(val, chip->io_port + ESM_AC97_DATA);
1892 outb(AC97_MASTER, chip->io_port + ESM_AC97_INDEX);
1893 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1894 &chip->master_switch->id);
1895 break;
1896 case 0xaa:
1897 /* volume up */
1898 if ((val & 0x7f) > 0)
1899 val--;
1900 if ((val & 0x7f00) > 0)
1901 val -= 0x0100;
1902 chip->ac97->regs[AC97_MASTER] = val;
1903 outw(val, chip->io_port + ESM_AC97_DATA);
1904 outb(AC97_MASTER, chip->io_port + ESM_AC97_INDEX);
1905 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1906 &chip->master_volume->id);
1907 break;
1908 case 0x66:
1909 /* volume down */
1910 if ((val & 0x7f) < 0x1f)
1911 val++;
1912 if ((val & 0x7f00) < 0x1f00)
1913 val += 0x0100;
1914 chip->ac97->regs[AC97_MASTER] = val;
1915 outw(val, chip->io_port + ESM_AC97_DATA);
1916 outb(AC97_MASTER, chip->io_port + ESM_AC97_INDEX);
1917 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1918 &chip->master_volume->id);
1919 break;
1920 }
1921 spin_unlock_irqrestore(&chip->ac97_lock, flags);
1922 }
1923
1924 /*
1925 * interrupt handler
1926 */
1927 static irqreturn_t snd_es1968_interrupt(int irq, void *dev_id)
1928 {
1929 struct es1968 *chip = dev_id;
1930 u32 event;
1931
1932 if (!(event = inb(chip->io_port + 0x1A)))
1933 return IRQ_NONE;
1934
1935 outw(inw(chip->io_port + 4) & 1, chip->io_port + 4);
1936
1937 if (event & ESM_HWVOL_IRQ)
1938 tasklet_hi_schedule(&chip->hwvol_tq); /* we'll do this later */
1939
1940 /* else ack 'em all, i imagine */
1941 outb(0xFF, chip->io_port + 0x1A);
1942
1943 if ((event & ESM_MPU401_IRQ) && chip->rmidi) {
1944 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data);
1945 }
1946
1947 if (event & ESM_SOUND_IRQ) {
1948 struct esschan *es;
1949 spin_lock(&chip->substream_lock);
1950 list_for_each_entry(es, &chip->substream_list, list) {
1951 if (es->running)
1952 snd_es1968_update_pcm(chip, es);
1953 }
1954 spin_unlock(&chip->substream_lock);
1955 if (chip->in_measurement) {
1956 unsigned int curp = __apu_get_register(chip, chip->measure_apu, 5);
1957 if (curp < chip->measure_lastpos)
1958 chip->measure_count++;
1959 chip->measure_lastpos = curp;
1960 }
1961 }
1962
1963 return IRQ_HANDLED;
1964 }
1965
1966 /*
1967 * Mixer stuff
1968 */
1969
1970 static int __devinit
1971 snd_es1968_mixer(struct es1968 *chip)
1972 {
1973 struct snd_ac97_bus *pbus;
1974 struct snd_ac97_template ac97;
1975 struct snd_ctl_elem_id id;
1976 int err;
1977 static struct snd_ac97_bus_ops ops = {
1978 .write = snd_es1968_ac97_write,
1979 .read = snd_es1968_ac97_read,
1980 };
1981
1982 if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &pbus)) < 0)
1983 return err;
1984 pbus->no_vra = 1; /* ES1968 doesn't need VRA */
1985
1986 memset(&ac97, 0, sizeof(ac97));
1987 ac97.private_data = chip;
1988 if ((err = snd_ac97_mixer(pbus, &ac97, &chip->ac97)) < 0)
1989 return err;
1990
1991 /* attach master switch / volumes for h/w volume control */
1992 memset(&id, 0, sizeof(id));
1993 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1994 strcpy(id.name, "Master Playback Switch");
1995 chip->master_switch = snd_ctl_find_id(chip->card, &id);
1996 memset(&id, 0, sizeof(id));
1997 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1998 strcpy(id.name, "Master Playback Volume");
1999 chip->master_volume = snd_ctl_find_id(chip->card, &id);
2000
2001 return 0;
2002 }
2003
2004 /*
2005 * reset ac97 codec
2006 */
2007
2008 static void snd_es1968_ac97_reset(struct es1968 *chip)
2009 {
2010 unsigned long ioaddr = chip->io_port;
2011
2012 unsigned short save_ringbus_a;
2013 unsigned short save_68;
2014 unsigned short w;
2015 unsigned int vend;
2016
2017 /* save configuration */
2018 save_ringbus_a = inw(ioaddr + 0x36);
2019
2020 //outw(inw(ioaddr + 0x38) & 0xfffc, ioaddr + 0x38); /* clear second codec id? */
2021 /* set command/status address i/o to 1st codec */
2022 outw(inw(ioaddr + 0x3a) & 0xfffc, ioaddr + 0x3a);
2023 outw(inw(ioaddr + 0x3c) & 0xfffc, ioaddr + 0x3c);
2024
2025 /* disable ac link */
2026 outw(0x0000, ioaddr + 0x36);
2027 save_68 = inw(ioaddr + 0x68);
2028 pci_read_config_word(chip->pci, 0x58, &w); /* something magical with gpio and bus arb. */
2029 pci_read_config_dword(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2030 if (w & 1)
2031 save_68 |= 0x10;
2032 outw(0xfffe, ioaddr + 0x64); /* unmask gpio 0 */
2033 outw(0x0001, ioaddr + 0x68); /* gpio write */
2034 outw(0x0000, ioaddr + 0x60); /* write 0 to gpio 0 */
2035 udelay(20);
2036 outw(0x0001, ioaddr + 0x60); /* write 1 to gpio 1 */
2037 msleep(20);
2038
2039 outw(save_68 | 0x1, ioaddr + 0x68); /* now restore .. */
2040 outw((inw(ioaddr + 0x38) & 0xfffc) | 0x1, ioaddr + 0x38);
2041 outw((inw(ioaddr + 0x3a) & 0xfffc) | 0x1, ioaddr + 0x3a);
2042 outw((inw(ioaddr + 0x3c) & 0xfffc) | 0x1, ioaddr + 0x3c);
2043
2044 /* now the second codec */
2045 /* disable ac link */
2046 outw(0x0000, ioaddr + 0x36);
2047 outw(0xfff7, ioaddr + 0x64); /* unmask gpio 3 */
2048 save_68 = inw(ioaddr + 0x68);
2049 outw(0x0009, ioaddr + 0x68); /* gpio write 0 & 3 ?? */
2050 outw(0x0001, ioaddr + 0x60); /* write 1 to gpio */
2051 udelay(20);
2052 outw(0x0009, ioaddr + 0x60); /* write 9 to gpio */
2053 msleep(500);
2054 //outw(inw(ioaddr + 0x38) & 0xfffc, ioaddr + 0x38);
2055 outw(inw(ioaddr + 0x3a) & 0xfffc, ioaddr + 0x3a);
2056 outw(inw(ioaddr + 0x3c) & 0xfffc, ioaddr + 0x3c);
2057
2058 #if 0 /* the loop here needs to be much better if we want it.. */
2059 snd_printk(KERN_INFO "trying software reset\n");
2060 /* try and do a software reset */
2061 outb(0x80 | 0x7c, ioaddr + 0x30);
2062 for (w = 0;; w++) {
2063 if ((inw(ioaddr + 0x30) & 1) == 0) {
2064 if (inb(ioaddr + 0x32) != 0)
2065 break;
2066
2067 outb(0x80 | 0x7d, ioaddr + 0x30);
2068 if (((inw(ioaddr + 0x30) & 1) == 0)
2069 && (inb(ioaddr + 0x32) != 0))
2070 break;
2071 outb(0x80 | 0x7f, ioaddr + 0x30);
2072 if (((inw(ioaddr + 0x30) & 1) == 0)
2073 && (inb(ioaddr + 0x32) != 0))
2074 break;
2075 }
2076
2077 if (w > 10000) {
2078 outb(inb(ioaddr + 0x37) | 0x08, ioaddr + 0x37); /* do a software reset */
2079 msleep(500); /* oh my.. */
2080 outb(inb(ioaddr + 0x37) & ~0x08,
2081 ioaddr + 0x37);
2082 udelay(1);
2083 outw(0x80, ioaddr + 0x30);
2084 for (w = 0; w < 10000; w++) {
2085 if ((inw(ioaddr + 0x30) & 1) == 0)
2086 break;
2087 }
2088 }
2089 }
2090 #endif
2091 if (vend == NEC_VERSA_SUBID1 || vend == NEC_VERSA_SUBID2) {
2092 /* turn on external amp? */
2093 outw(0xf9ff, ioaddr + 0x64);
2094 outw(inw(ioaddr + 0x68) | 0x600, ioaddr + 0x68);
2095 outw(0x0209, ioaddr + 0x60);
2096 }
2097
2098 /* restore.. */
2099 outw(save_ringbus_a, ioaddr + 0x36);
2100
2101 /* Turn on the 978 docking chip.
2102 First frob the "master output enable" bit,
2103 then set most of the playback volume control registers to max. */
2104 outb(inb(ioaddr+0xc0)|(1<<5), ioaddr+0xc0);
2105 outb(0xff, ioaddr+0xc3);
2106 outb(0xff, ioaddr+0xc4);
2107 outb(0xff, ioaddr+0xc6);
2108 outb(0xff, ioaddr+0xc8);
2109 outb(0x3f, ioaddr+0xcf);
2110 outb(0x3f, ioaddr+0xd0);
2111 }
2112
2113 static void snd_es1968_reset(struct es1968 *chip)
2114 {
2115 /* Reset */
2116 outw(ESM_RESET_MAESTRO | ESM_RESET_DIRECTSOUND,
2117 chip->io_port + ESM_PORT_HOST_IRQ);
2118 udelay(10);
2119 outw(0x0000, chip->io_port + ESM_PORT_HOST_IRQ);
2120 udelay(10);
2121 }
2122
2123 /*
2124 * initialize maestro chip
2125 */
2126 static void snd_es1968_chip_init(struct es1968 *chip)
2127 {
2128 struct pci_dev *pci = chip->pci;
2129 int i;
2130 unsigned long iobase = chip->io_port;
2131 u16 w;
2132 u32 n;
2133
2134 /* We used to muck around with pci config space that
2135 * we had no business messing with. We don't know enough
2136 * about the machine to know which DMA mode is appropriate,
2137 * etc. We were guessing wrong on some machines and making
2138 * them unhappy. We now trust in the BIOS to do things right,
2139 * which almost certainly means a new host of problems will
2140 * arise with broken BIOS implementations. screw 'em.
2141 * We're already intolerant of machines that don't assign
2142 * IRQs.
2143 */
2144
2145 /* Config Reg A */
2146 pci_read_config_word(pci, ESM_CONFIG_A, &w);
2147
2148 w &= ~DMA_CLEAR; /* Clear DMA bits */
2149 w &= ~(PIC_SNOOP1 | PIC_SNOOP2); /* Clear Pic Snoop Mode Bits */
2150 w &= ~SAFEGUARD; /* Safeguard off */
2151 w |= POST_WRITE; /* Posted write */
2152 w |= PCI_TIMING; /* PCI timing on */
2153 /* XXX huh? claims to be reserved.. */
2154 w &= ~SWAP_LR; /* swap left/right
2155 seems to only have effect on SB
2156 Emulation */
2157 w &= ~SUBTR_DECODE; /* Subtractive decode off */
2158
2159 pci_write_config_word(pci, ESM_CONFIG_A, w);
2160
2161 /* Config Reg B */
2162
2163 pci_read_config_word(pci, ESM_CONFIG_B, &w);
2164
2165 w &= ~(1 << 15); /* Turn off internal clock multiplier */
2166 /* XXX how do we know which to use? */
2167 w &= ~(1 << 14); /* External clock */
2168
2169 w &= ~SPDIF_CONFB; /* disable S/PDIF output */
2170 w |= HWV_CONFB; /* HWV on */
2171 w |= DEBOUNCE; /* Debounce off: easier to push the HW buttons */
2172 w &= ~GPIO_CONFB; /* GPIO 4:5 */
2173 w |= CHI_CONFB; /* Disconnect from the CHI. Enabling this made a dell 7500 work. */
2174 w &= ~IDMA_CONFB; /* IDMA off (undocumented) */
2175 w &= ~MIDI_FIX; /* MIDI fix off (undoc) */
2176 w &= ~(1 << 1); /* reserved, always write 0 */
2177 w &= ~IRQ_TO_ISA; /* IRQ to ISA off (undoc) */
2178
2179 pci_write_config_word(pci, ESM_CONFIG_B, w);
2180
2181 /* DDMA off */
2182
2183 pci_read_config_word(pci, ESM_DDMA, &w);
2184 w &= ~(1 << 0);
2185 pci_write_config_word(pci, ESM_DDMA, w);
2186
2187 /*
2188 * Legacy mode
2189 */
2190
2191 pci_read_config_word(pci, ESM_LEGACY_AUDIO_CONTROL, &w);
2192
2193 w |= ESS_DISABLE_AUDIO; /* Disable Legacy Audio */
2194 w &= ~ESS_ENABLE_SERIAL_IRQ; /* Disable SIRQ */
2195 w &= ~(0x1f); /* disable mpu irq/io, game port, fm, SB */
2196
2197 pci_write_config_word(pci, ESM_LEGACY_AUDIO_CONTROL, w);
2198
2199 /* Set up 978 docking control chip. */
2200 pci_read_config_word(pci, 0x58, &w);
2201 w|=1<<2; /* Enable 978. */
2202 w|=1<<3; /* Turn on 978 hardware volume control. */
2203 w&=~(1<<11); /* Turn on 978 mixer volume control. */
2204 pci_write_config_word(pci, 0x58, w);
2205
2206 /* Sound Reset */
2207
2208 snd_es1968_reset(chip);
2209
2210 /*
2211 * Ring Bus Setup
2212 */
2213
2214 /* setup usual 0x34 stuff.. 0x36 may be chip specific */
2215 outw(0xC090, iobase + ESM_RING_BUS_DEST); /* direct sound, stereo */
2216 udelay(20);
2217 outw(0x3000, iobase + ESM_RING_BUS_CONTR_A); /* enable ringbus/serial */
2218 udelay(20);
2219
2220 /*
2221 * Reset the CODEC
2222 */
2223
2224 snd_es1968_ac97_reset(chip);
2225
2226 /* Ring Bus Control B */
2227
2228 n = inl(iobase + ESM_RING_BUS_CONTR_B);
2229 n &= ~RINGB_EN_SPDIF; /* SPDIF off */
2230 //w |= RINGB_EN_2CODEC; /* enable 2nd codec */
2231 outl(n, iobase + ESM_RING_BUS_CONTR_B);
2232
2233 /* Set hardware volume control registers to midpoints.
2234 We can tell which button was pushed based on how they change. */
2235 outb(0x88, iobase+0x1c);
2236 outb(0x88, iobase+0x1d);
2237 outb(0x88, iobase+0x1e);
2238 outb(0x88, iobase+0x1f);
2239
2240 /* it appears some maestros (dell 7500) only work if these are set,
2241 regardless of wether we use the assp or not. */
2242
2243 outb(0, iobase + ASSP_CONTROL_B);
2244 outb(3, iobase + ASSP_CONTROL_A); /* M: Reserved bits... */
2245 outb(0, iobase + ASSP_CONTROL_C); /* M: Disable ASSP, ASSP IRQ's and FM Port */
2246
2247 /*
2248 * set up wavecache
2249 */
2250 for (i = 0; i < 16; i++) {
2251 /* Write 0 into the buffer area 0x1E0->1EF */
2252 outw(0x01E0 + i, iobase + WC_INDEX);
2253 outw(0x0000, iobase + WC_DATA);
2254
2255 /* The 1.10 test program seem to write 0 into the buffer area
2256 * 0x1D0-0x1DF too.*/
2257 outw(0x01D0 + i, iobase + WC_INDEX);
2258 outw(0x0000, iobase + WC_DATA);
2259 }
2260 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2261 (wave_get_register(chip, IDR7_WAVE_ROMRAM) & 0xFF00));
2262 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2263 wave_get_register(chip, IDR7_WAVE_ROMRAM) | 0x100);
2264 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2265 wave_get_register(chip, IDR7_WAVE_ROMRAM) & ~0x200);
2266 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2267 wave_get_register(chip, IDR7_WAVE_ROMRAM) | ~0x400);
2268
2269
2270 maestro_write(chip, IDR2_CRAM_DATA, 0x0000);
2271 /* Now back to the DirectSound stuff */
2272 /* audio serial configuration.. ? */
2273 maestro_write(chip, 0x08, 0xB004);
2274 maestro_write(chip, 0x09, 0x001B);
2275 maestro_write(chip, 0x0A, 0x8000);
2276 maestro_write(chip, 0x0B, 0x3F37);
2277 maestro_write(chip, 0x0C, 0x0098);
2278
2279 /* parallel in, has something to do with recording :) */
2280 maestro_write(chip, 0x0C,
2281 (maestro_read(chip, 0x0C) & ~0xF000) | 0x8000);
2282 /* parallel out */
2283 maestro_write(chip, 0x0C,
2284 (maestro_read(chip, 0x0C) & ~0x0F00) | 0x0500);
2285
2286 maestro_write(chip, 0x0D, 0x7632);
2287
2288 /* Wave cache control on - test off, sg off,
2289 enable, enable extra chans 1Mb */
2290
2291 w = inw(iobase + WC_CONTROL);
2292
2293 w &= ~0xFA00; /* Seems to be reserved? I don't know */
2294 w |= 0xA000; /* reserved... I don't know */
2295 w &= ~0x0200; /* Channels 56,57,58,59 as Extra Play,Rec Channel enable
2296 Seems to crash the Computer if enabled... */
2297 w |= 0x0100; /* Wave Cache Operation Enabled */
2298 w |= 0x0080; /* Channels 60/61 as Placback/Record enabled */
2299 w &= ~0x0060; /* Clear Wavtable Size */
2300 w |= 0x0020; /* Wavetable Size : 1MB */
2301 /* Bit 4 is reserved */
2302 w &= ~0x000C; /* DMA Stuff? I don't understand what the datasheet means */
2303 /* Bit 1 is reserved */
2304 w &= ~0x0001; /* Test Mode off */
2305
2306 outw(w, iobase + WC_CONTROL);
2307
2308 /* Now clear the APU control ram */
2309 for (i = 0; i < NR_APUS; i++) {
2310 for (w = 0; w < NR_APU_REGS; w++)
2311 apu_set_register(chip, i, w, 0);
2312
2313 }
2314 }
2315
2316 /* Enable IRQ's */
2317 static void snd_es1968_start_irq(struct es1968 *chip)
2318 {
2319 unsigned short w;
2320 w = ESM_HIRQ_DSIE | ESM_HIRQ_HW_VOLUME;
2321 if (chip->rmidi)
2322 w |= ESM_HIRQ_MPU401;
2323 outw(w, chip->io_port + ESM_PORT_HOST_IRQ);
2324 }
2325
2326 #ifdef CONFIG_PM
2327 /*
2328 * PM support
2329 */
2330 static int es1968_suspend(struct pci_dev *pci, pm_message_t state)
2331 {
2332 struct snd_card *card = pci_get_drvdata(pci);
2333 struct es1968 *chip = card->private_data;
2334
2335 if (! chip->do_pm)
2336 return 0;
2337
2338 chip->in_suspend = 1;
2339 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
2340 snd_pcm_suspend_all(chip->pcm);
2341 snd_ac97_suspend(chip->ac97);
2342 snd_es1968_bob_stop(chip);
2343
2344 pci_disable_device(pci);
2345 pci_save_state(pci);
2346 pci_set_power_state(pci, pci_choose_state(pci, state));
2347 return 0;
2348 }
2349
2350 static int es1968_resume(struct pci_dev *pci)
2351 {
2352 struct snd_card *card = pci_get_drvdata(pci);
2353 struct es1968 *chip = card->private_data;
2354 struct esschan *es;
2355
2356 if (! chip->do_pm)
2357 return 0;
2358
2359 /* restore all our config */
2360 pci_set_power_state(pci, PCI_D0);
2361 pci_restore_state(pci);
2362 if (pci_enable_device(pci) < 0) {
2363 printk(KERN_ERR "es1968: pci_enable_device failed, "
2364 "disabling device\n");
2365 snd_card_disconnect(card);
2366 return -EIO;
2367 }
2368 pci_set_master(pci);
2369
2370 snd_es1968_chip_init(chip);
2371
2372 /* need to restore the base pointers.. */
2373 if (chip->dma.addr) {
2374 /* set PCMBAR */
2375 wave_set_register(chip, 0x01FC, chip->dma.addr >> 12);
2376 }
2377
2378 snd_es1968_start_irq(chip);
2379
2380 /* restore ac97 state */
2381 snd_ac97_resume(chip->ac97);
2382
2383 list_for_each_entry(es, &chip->substream_list, list) {
2384 switch (es->mode) {
2385 case ESM_MODE_PLAY:
2386 snd_es1968_playback_setup(chip, es, es->substream->runtime);
2387 break;
2388 case ESM_MODE_CAPTURE:
2389 snd_es1968_capture_setup(chip, es, es->substream->runtime);
2390 break;
2391 }
2392 }
2393
2394 /* start timer again */
2395 if (chip->bobclient)
2396 snd_es1968_bob_start(chip);
2397
2398 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
2399 chip->in_suspend = 0;
2400 return 0;
2401 }
2402 #endif /* CONFIG_PM */
2403
2404 #ifdef SUPPORT_JOYSTICK
2405 #define JOYSTICK_ADDR 0x200
2406 static int __devinit snd_es1968_create_gameport(struct es1968 *chip, int dev)
2407 {
2408 struct gameport *gp;
2409 struct resource *r;
2410 u16 val;
2411
2412 if (!joystick[dev])
2413 return -ENODEV;
2414
2415 r = request_region(JOYSTICK_ADDR, 8, "ES1968 gameport");
2416 if (!r)
2417 return -EBUSY;
2418
2419 chip->gameport = gp = gameport_allocate_port();
2420 if (!gp) {
2421 printk(KERN_ERR "es1968: cannot allocate memory for gameport\n");
2422 release_and_free_resource(r);
2423 return -ENOMEM;
2424 }
2425
2426 pci_read_config_word(chip->pci, ESM_LEGACY_AUDIO_CONTROL, &val);
2427 pci_write_config_word(chip->pci, ESM_LEGACY_AUDIO_CONTROL, val | 0x04);
2428
2429 gameport_set_name(gp, "ES1968 Gameport");
2430 gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
2431 gameport_set_dev_parent(gp, &chip->pci->dev);
2432 gp->io = JOYSTICK_ADDR;
2433 gameport_set_port_data(gp, r);
2434
2435 gameport_register_port(gp);
2436
2437 return 0;
2438 }
2439
2440 static void snd_es1968_free_gameport(struct es1968 *chip)
2441 {
2442 if (chip->gameport) {
2443 struct resource *r = gameport_get_port_data(chip->gameport);
2444
2445 gameport_unregister_port(chip->gameport);
2446 chip->gameport = NULL;
2447
2448 release_and_free_resource(r);
2449 }
2450 }
2451 #else
2452 static inline int snd_es1968_create_gameport(struct es1968 *chip, int dev) { return -ENOSYS; }
2453 static inline void snd_es1968_free_gameport(struct es1968 *chip) { }
2454 #endif
2455
2456 static int snd_es1968_free(struct es1968 *chip)
2457 {
2458 if (chip->io_port) {
2459 synchronize_irq(chip->irq);
2460 outw(1, chip->io_port + 0x04); /* clear WP interrupts */
2461 outw(0, chip->io_port + ESM_PORT_HOST_IRQ); /* disable IRQ */
2462 }
2463
2464 if (chip->irq >= 0)
2465 free_irq(chip->irq, chip);
2466 snd_es1968_free_gameport(chip);
2467 chip->master_switch = NULL;
2468 chip->master_volume = NULL;
2469 pci_release_regions(chip->pci);
2470 pci_disable_device(chip->pci);
2471 kfree(chip);
2472 return 0;
2473 }
2474
2475 static int snd_es1968_dev_free(struct snd_device *device)
2476 {
2477 struct es1968 *chip = device->device_data;
2478 return snd_es1968_free(chip);
2479 }
2480
2481 struct ess_device_list {
2482 unsigned short type; /* chip type */
2483 unsigned short vendor; /* subsystem vendor id */
2484 };
2485
2486 static struct ess_device_list pm_whitelist[] __devinitdata = {
2487 { TYPE_MAESTRO2E, 0x0e11 }, /* Compaq Armada */
2488 { TYPE_MAESTRO2E, 0x1028 },
2489 { TYPE_MAESTRO2E, 0x103c },
2490 { TYPE_MAESTRO2E, 0x1179 },
2491 { TYPE_MAESTRO2E, 0x14c0 }, /* HP omnibook 4150 */
2492 { TYPE_MAESTRO2E, 0x1558 },
2493 };
2494
2495 static struct ess_device_list mpu_blacklist[] __devinitdata = {
2496 { TYPE_MAESTRO2, 0x125d },
2497 };
2498
2499 static int __devinit snd_es1968_create(struct snd_card *card,
2500 struct pci_dev *pci,
2501 int total_bufsize,
2502 int play_streams,
2503 int capt_streams,
2504 int chip_type,
2505 int do_pm,
2506 struct es1968 **chip_ret)
2507 {
2508 static struct snd_device_ops ops = {
2509 .dev_free = snd_es1968_dev_free,
2510 };
2511 struct es1968 *chip;
2512 int i, err;
2513
2514 *chip_ret = NULL;
2515
2516 /* enable PCI device */
2517 if ((err = pci_enable_device(pci)) < 0)
2518 return err;
2519 /* check, if we can restrict PCI DMA transfers to 28 bits */
2520 if (pci_set_dma_mask(pci, DMA_28BIT_MASK) < 0 ||
2521 pci_set_consistent_dma_mask(pci, DMA_28BIT_MASK) < 0) {
2522 snd_printk(KERN_ERR "architecture does not support 28bit PCI busmaster DMA\n");
2523 pci_disable_device(pci);
2524 return -ENXIO;
2525 }
2526
2527 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
2528 if (! chip) {
2529 pci_disable_device(pci);
2530 return -ENOMEM;
2531 }
2532
2533 /* Set Vars */
2534 chip->type = chip_type;
2535 spin_lock_init(&chip->reg_lock);
2536 spin_lock_init(&chip->substream_lock);
2537 INIT_LIST_HEAD(&chip->buf_list);
2538 INIT_LIST_HEAD(&chip->substream_list);
2539 spin_lock_init(&chip->ac97_lock);
2540 mutex_init(&chip->memory_mutex);
2541 tasklet_init(&chip->hwvol_tq, es1968_update_hw_volume, (unsigned long)chip);
2542 chip->card = card;
2543 chip->pci = pci;
2544 chip->irq = -1;
2545 chip->total_bufsize = total_bufsize; /* in bytes */
2546 chip->playback_streams = play_streams;
2547 chip->capture_streams = capt_streams;
2548
2549 if ((err = pci_request_regions(pci, "ESS Maestro")) < 0) {
2550 kfree(chip);
2551 pci_disable_device(pci);
2552 return err;
2553 }
2554 chip->io_port = pci_resource_start(pci, 0);
2555 if (request_irq(pci->irq, snd_es1968_interrupt, IRQF_SHARED,
2556 "ESS Maestro", chip)) {
2557 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
2558 snd_es1968_free(chip);
2559 return -EBUSY;
2560 }
2561 chip->irq = pci->irq;
2562
2563 /* Clear Maestro_map */
2564 for (i = 0; i < 32; i++)
2565 chip->maestro_map[i] = 0;
2566
2567 /* Clear Apu Map */
2568 for (i = 0; i < NR_APUS; i++)
2569 chip->apu[i] = ESM_APU_FREE;
2570
2571 /* just to be sure */
2572 pci_set_master(pci);
2573
2574 if (do_pm > 1) {
2575 /* disable power-management if not on the whitelist */
2576 unsigned short vend;
2577 pci_read_config_word(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2578 for (i = 0; i < (int)ARRAY_SIZE(pm_whitelist); i++) {
2579 if (chip->type == pm_whitelist[i].type &&
2580 vend == pm_whitelist[i].vendor) {
2581 do_pm = 1;
2582 break;
2583 }
2584 }
2585 if (do_pm > 1) {
2586 /* not matched; disabling pm */
2587 printk(KERN_INFO "es1968: not attempting power management.\n");
2588 do_pm = 0;
2589 }
2590 }
2591 chip->do_pm = do_pm;
2592
2593 snd_es1968_chip_init(chip);
2594
2595 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
2596 snd_es1968_free(chip);
2597 return err;
2598 }
2599
2600 snd_card_set_dev(card, &pci->dev);
2601
2602 *chip_ret = chip;
2603
2604 return 0;
2605 }
2606
2607
2608 /*
2609 */
2610 static int __devinit snd_es1968_probe(struct pci_dev *pci,
2611 const struct pci_device_id *pci_id)
2612 {
2613 static int dev;
2614 struct snd_card *card;
2615 struct es1968 *chip;
2616 unsigned int i;
2617 int err;
2618
2619 if (dev >= SNDRV_CARDS)
2620 return -ENODEV;
2621 if (!enable[dev]) {
2622 dev++;
2623 return -ENOENT;
2624 }
2625
2626 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
2627 if (!card)
2628 return -ENOMEM;
2629
2630 if (total_bufsize[dev] < 128)
2631 total_bufsize[dev] = 128;
2632 if (total_bufsize[dev] > 4096)
2633 total_bufsize[dev] = 4096;
2634 if ((err = snd_es1968_create(card, pci,
2635 total_bufsize[dev] * 1024, /* in bytes */
2636 pcm_substreams_p[dev],
2637 pcm_substreams_c[dev],
2638 pci_id->driver_data,
2639 use_pm[dev],
2640 &chip)) < 0) {
2641 snd_card_free(card);
2642 return err;
2643 }
2644 card->private_data = chip;
2645
2646 switch (chip->type) {
2647 case TYPE_MAESTRO2E:
2648 strcpy(card->driver, "ES1978");
2649 strcpy(card->shortname, "ESS ES1978 (Maestro 2E)");
2650 break;
2651 case TYPE_MAESTRO2:
2652 strcpy(card->driver, "ES1968");
2653 strcpy(card->shortname, "ESS ES1968 (Maestro 2)");
2654 break;
2655 case TYPE_MAESTRO:
2656 strcpy(card->driver, "ESM1");
2657 strcpy(card->shortname, "ESS Maestro 1");
2658 break;
2659 }
2660
2661 if ((err = snd_es1968_pcm(chip, 0)) < 0) {
2662 snd_card_free(card);
2663 return err;
2664 }
2665
2666 if ((err = snd_es1968_mixer(chip)) < 0) {
2667 snd_card_free(card);
2668 return err;
2669 }
2670
2671 if (enable_mpu[dev] == 2) {
2672 /* check the black list */
2673 unsigned short vend;
2674 pci_read_config_word(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2675 for (i = 0; i < ARRAY_SIZE(mpu_blacklist); i++) {
2676 if (chip->type == mpu_blacklist[i].type &&
2677 vend == mpu_blacklist[i].vendor) {
2678 enable_mpu[dev] = 0;
2679 break;
2680 }
2681 }
2682 }
2683 if (enable_mpu[dev]) {
2684 if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
2685 chip->io_port + ESM_MPU401_PORT,
2686 MPU401_INFO_INTEGRATED,
2687 chip->irq, 0, &chip->rmidi)) < 0) {
2688 printk(KERN_WARNING "es1968: skipping MPU-401 MIDI support..\n");
2689 }
2690 }
2691
2692 snd_es1968_create_gameport(chip, dev);
2693
2694 snd_es1968_start_irq(chip);
2695
2696 chip->clock = clock[dev];
2697 if (! chip->clock)
2698 es1968_measure_clock(chip);
2699
2700 sprintf(card->longname, "%s at 0x%lx, irq %i",
2701 card->shortname, chip->io_port, chip->irq);
2702
2703 if ((err = snd_card_register(card)) < 0) {
2704 snd_card_free(card);
2705 return err;
2706 }
2707 pci_set_drvdata(pci, card);
2708 dev++;
2709 return 0;
2710 }
2711
2712 static void __devexit snd_es1968_remove(struct pci_dev *pci)
2713 {
2714 snd_card_free(pci_get_drvdata(pci));
2715 pci_set_drvdata(pci, NULL);
2716 }
2717
2718 static struct pci_driver driver = {
2719 .name = "ES1968 (ESS Maestro)",
2720 .id_table = snd_es1968_ids,
2721 .probe = snd_es1968_probe,
2722 .remove = __devexit_p(snd_es1968_remove),
2723 #ifdef CONFIG_PM
2724 .suspend = es1968_suspend,
2725 .resume = es1968_resume,
2726 #endif
2727 };
2728
2729 static int __init alsa_card_es1968_init(void)
2730 {
2731 return pci_register_driver(&driver);
2732 }
2733
2734 static void __exit alsa_card_es1968_exit(void)
2735 {
2736 pci_unregister_driver(&driver);
2737 }
2738
2739 module_init(alsa_card_es1968_init)
2740 module_exit(alsa_card_es1968_exit)
Linux with added FPC-III support