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