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