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