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