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