?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[ALSA] cs4231-lib: replace common delay loop by function
[linux-2.6/verdex.git] / sound / pci / es1968.c
blob2faf009076bb81c94aedeee60087adedf0aa7304
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 = ALIGN(size, 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
1558 spin_lock_irq(&chip->substream_lock);
1559 list_add(&es->list, &chip->substream_list);
1560 spin_unlock_irq(&chip->substream_lock);
1561
1562 return 0;
1563 }
1564
1565 static int snd_es1968_capture_open(struct snd_pcm_substream *substream)
1566 {
1567 struct snd_pcm_runtime *runtime = substream->runtime;
1568 struct es1968 *chip = snd_pcm_substream_chip(substream);
1569 struct esschan *es;
1570 int apu1, apu2;
1571
1572 apu1 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_CAPTURE);
1573 if (apu1 < 0)
1574 return apu1;
1575 apu2 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_RATECONV);
1576 if (apu2 < 0) {
1577 snd_es1968_free_apu_pair(chip, apu1);
1578 return apu2;
1579 }
1580
1581 es = kzalloc(sizeof(*es), GFP_KERNEL);
1582 if (!es) {
1583 snd_es1968_free_apu_pair(chip, apu1);
1584 snd_es1968_free_apu_pair(chip, apu2);
1585 return -ENOMEM;
1586 }
1587
1588 es->apu[0] = apu1;
1589 es->apu[1] = apu1 + 1;
1590 es->apu[2] = apu2;
1591 es->apu[3] = apu2 + 1;
1592 es->apu_mode[0] = 0;
1593 es->apu_mode[1] = 0;
1594 es->apu_mode[2] = 0;
1595 es->apu_mode[3] = 0;
1596 es->running = 0;
1597 es->substream = substream;
1598 es->mode = ESM_MODE_CAPTURE;
1599
1600 /* get mixbuffer */
1601 if ((es->mixbuf = snd_es1968_new_memory(chip, ESM_MIXBUF_SIZE)) == NULL) {
1602 snd_es1968_free_apu_pair(chip, apu1);
1603 snd_es1968_free_apu_pair(chip, apu2);
1604 kfree(es);
1605 return -ENOMEM;
1606 }
1607 memset(es->mixbuf->buf.area, 0, ESM_MIXBUF_SIZE);
1608
1609 runtime->private_data = es;
1610 runtime->hw = snd_es1968_capture;
1611 runtime->hw.buffer_bytes_max = runtime->hw.period_bytes_max =
1612 calc_available_memory_size(chip) - 1024; /* keep MIXBUF size */
1613 snd_pcm_hw_constraint_pow2(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES);
1614
1615 spin_lock_irq(&chip->substream_lock);
1616 list_add(&es->list, &chip->substream_list);
1617 spin_unlock_irq(&chip->substream_lock);
1618
1619 return 0;
1620 }
1621
1622 static int snd_es1968_playback_close(struct snd_pcm_substream *substream)
1623 {
1624 struct es1968 *chip = snd_pcm_substream_chip(substream);
1625 struct esschan *es;
1626
1627 if (substream->runtime->private_data == NULL)
1628 return 0;
1629 es = substream->runtime->private_data;
1630 spin_lock_irq(&chip->substream_lock);
1631 list_del(&es->list);
1632 spin_unlock_irq(&chip->substream_lock);
1633 snd_es1968_free_apu_pair(chip, es->apu[0]);
1634 kfree(es);
1635
1636 return 0;
1637 }
1638
1639 static int snd_es1968_capture_close(struct snd_pcm_substream *substream)
1640 {
1641 struct es1968 *chip = snd_pcm_substream_chip(substream);
1642 struct esschan *es;
1643
1644 if (substream->runtime->private_data == NULL)
1645 return 0;
1646 es = substream->runtime->private_data;
1647 spin_lock_irq(&chip->substream_lock);
1648 list_del(&es->list);
1649 spin_unlock_irq(&chip->substream_lock);
1650 snd_es1968_free_memory(chip, es->mixbuf);
1651 snd_es1968_free_apu_pair(chip, es->apu[0]);
1652 snd_es1968_free_apu_pair(chip, es->apu[2]);
1653 kfree(es);
1654
1655 return 0;
1656 }
1657
1658 static struct snd_pcm_ops snd_es1968_playback_ops = {
1659 .open = snd_es1968_playback_open,
1660 .close = snd_es1968_playback_close,
1661 .ioctl = snd_pcm_lib_ioctl,
1662 .hw_params = snd_es1968_hw_params,
1663 .hw_free = snd_es1968_hw_free,
1664 .prepare = snd_es1968_pcm_prepare,
1665 .trigger = snd_es1968_pcm_trigger,
1666 .pointer = snd_es1968_pcm_pointer,
1667 };
1668
1669 static struct snd_pcm_ops snd_es1968_capture_ops = {
1670 .open = snd_es1968_capture_open,
1671 .close = snd_es1968_capture_close,
1672 .ioctl = snd_pcm_lib_ioctl,
1673 .hw_params = snd_es1968_hw_params,
1674 .hw_free = snd_es1968_hw_free,
1675 .prepare = snd_es1968_pcm_prepare,
1676 .trigger = snd_es1968_pcm_trigger,
1677 .pointer = snd_es1968_pcm_pointer,
1678 };
1679
1680
1681 /*
1682 * measure clock
1683 */
1684 #define CLOCK_MEASURE_BUFSIZE 16768 /* enough large for a single shot */
1685
1686 static void __devinit es1968_measure_clock(struct es1968 *chip)
1687 {
1688 int i, apu;
1689 unsigned int pa, offset, t;
1690 struct esm_memory *memory;
1691 struct timeval start_time, stop_time;
1692
1693 if (chip->clock == 0)
1694 chip->clock = 48000; /* default clock value */
1695
1696 /* search 2 APUs (although one apu is enough) */
1697 if ((apu = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_PLAY)) < 0) {
1698 snd_printk(KERN_ERR "Hmm, cannot find empty APU pair!?\n");
1699 return;
1700 }
1701 if ((memory = snd_es1968_new_memory(chip, CLOCK_MEASURE_BUFSIZE)) == NULL) {
1702 snd_printk(KERN_ERR "cannot allocate dma buffer - using default clock %d\n", chip->clock);
1703 snd_es1968_free_apu_pair(chip, apu);
1704 return;
1705 }
1706
1707 memset(memory->buf.area, 0, CLOCK_MEASURE_BUFSIZE);
1708
1709 wave_set_register(chip, apu << 3, (memory->buf.addr - 0x10) & 0xfff8);
1710
1711 pa = (unsigned int)((memory->buf.addr - chip->dma.addr) >> 1);
1712 pa |= 0x00400000; /* System RAM (Bit 22) */
1713
1714 /* initialize apu */
1715 for (i = 0; i < 16; i++)
1716 apu_set_register(chip, apu, i, 0x0000);
1717
1718 apu_set_register(chip, apu, 0, 0x400f);
1719 apu_set_register(chip, apu, 4, ((pa >> 16) & 0xff) << 8);
1720 apu_set_register(chip, apu, 5, pa & 0xffff);
1721 apu_set_register(chip, apu, 6, (pa + CLOCK_MEASURE_BUFSIZE/2) & 0xffff);
1722 apu_set_register(chip, apu, 7, CLOCK_MEASURE_BUFSIZE/2);
1723 apu_set_register(chip, apu, 8, 0x0000);
1724 apu_set_register(chip, apu, 9, 0xD000);
1725 apu_set_register(chip, apu, 10, 0x8F08);
1726 apu_set_register(chip, apu, 11, 0x0000);
1727 spin_lock_irq(&chip->reg_lock);
1728 outw(1, chip->io_port + 0x04); /* clear WP interrupts */
1729 outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ); /* enable WP ints */
1730 spin_unlock_irq(&chip->reg_lock);
1731
1732 snd_es1968_apu_set_freq(chip, apu, ((unsigned int)48000 << 16) / chip->clock); /* 48000 Hz */
1733
1734 chip->in_measurement = 1;
1735 chip->measure_apu = apu;
1736 spin_lock_irq(&chip->reg_lock);
1737 snd_es1968_bob_inc(chip, ESM_BOB_FREQ);
1738 __apu_set_register(chip, apu, 5, pa & 0xffff);
1739 snd_es1968_trigger_apu(chip, apu, ESM_APU_16BITLINEAR);
1740 do_gettimeofday(&start_time);
1741 spin_unlock_irq(&chip->reg_lock);
1742 msleep(50);
1743 spin_lock_irq(&chip->reg_lock);
1744 offset = __apu_get_register(chip, apu, 5);
1745 do_gettimeofday(&stop_time);
1746 snd_es1968_trigger_apu(chip, apu, 0); /* stop */
1747 snd_es1968_bob_dec(chip);
1748 chip->in_measurement = 0;
1749 spin_unlock_irq(&chip->reg_lock);
1750
1751 /* check the current position */
1752 offset -= (pa & 0xffff);
1753 offset &= 0xfffe;
1754 offset += chip->measure_count * (CLOCK_MEASURE_BUFSIZE/2);
1755
1756 t = stop_time.tv_sec - start_time.tv_sec;
1757 t *= 1000000;
1758 if (stop_time.tv_usec < start_time.tv_usec)
1759 t -= start_time.tv_usec - stop_time.tv_usec;
1760 else
1761 t += stop_time.tv_usec - start_time.tv_usec;
1762 if (t == 0) {
1763 snd_printk(KERN_ERR "?? calculation error..\n");
1764 } else {
1765 offset *= 1000;
1766 offset = (offset / t) * 1000 + ((offset % t) * 1000) / t;
1767 if (offset < 47500 || offset > 48500) {
1768 if (offset >= 40000 && offset <= 50000)
1769 chip->clock = (chip->clock * offset) / 48000;
1770 }
1771 printk(KERN_INFO "es1968: clocking to %d\n", chip->clock);
1772 }
1773 snd_es1968_free_memory(chip, memory);
1774 snd_es1968_free_apu_pair(chip, apu);
1775 }
1776
1777
1778 /*
1779 */
1780
1781 static void snd_es1968_pcm_free(struct snd_pcm *pcm)
1782 {
1783 struct es1968 *esm = pcm->private_data;
1784 snd_es1968_free_dmabuf(esm);
1785 esm->pcm = NULL;
1786 }
1787
1788 static int __devinit
1789 snd_es1968_pcm(struct es1968 *chip, int device)
1790 {
1791 struct snd_pcm *pcm;
1792 int err;
1793
1794 /* get DMA buffer */
1795 if ((err = snd_es1968_init_dmabuf(chip)) < 0)
1796 return err;
1797
1798 /* set PCMBAR */
1799 wave_set_register(chip, 0x01FC, chip->dma.addr >> 12);
1800 wave_set_register(chip, 0x01FD, chip->dma.addr >> 12);
1801 wave_set_register(chip, 0x01FE, chip->dma.addr >> 12);
1802 wave_set_register(chip, 0x01FF, chip->dma.addr >> 12);
1803
1804 if ((err = snd_pcm_new(chip->card, "ESS Maestro", device,
1805 chip->playback_streams,
1806 chip->capture_streams, &pcm)) < 0)
1807 return err;
1808
1809 pcm->private_data = chip;
1810 pcm->private_free = snd_es1968_pcm_free;
1811
1812 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_es1968_playback_ops);
1813 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1968_capture_ops);
1814
1815 pcm->info_flags = 0;
1816
1817 strcpy(pcm->name, "ESS Maestro");
1818
1819 chip->pcm = pcm;
1820
1821 return 0;
1822 }
1823
1824 /*
1825 * update pointer
1826 */
1827 static void snd_es1968_update_pcm(struct es1968 *chip, struct esschan *es)
1828 {
1829 unsigned int hwptr;
1830 unsigned int diff;
1831 struct snd_pcm_substream *subs = es->substream;
1832
1833 if (subs == NULL || !es->running)
1834 return;
1835
1836 hwptr = snd_es1968_get_dma_ptr(chip, es) << es->wav_shift;
1837 hwptr %= es->dma_size;
1838
1839 diff = (es->dma_size + hwptr - es->hwptr) % es->dma_size;
1840
1841 es->hwptr = hwptr;
1842 es->count += diff;
1843
1844 if (es->count > es->frag_size) {
1845 spin_unlock(&chip->substream_lock);
1846 snd_pcm_period_elapsed(subs);
1847 spin_lock(&chip->substream_lock);
1848 es->count %= es->frag_size;
1849 }
1850 }
1851
1852 /*
1853 */
1854 static void es1968_update_hw_volume(unsigned long private_data)
1855 {
1856 struct es1968 *chip = (struct es1968 *) private_data;
1857 int x, val;
1858 unsigned long flags;
1859
1860 /* Figure out which volume control button was pushed,
1861 based on differences from the default register
1862 values. */
1863 x = inb(chip->io_port + 0x1c) & 0xee;
1864 /* Reset the volume control registers. */
1865 outb(0x88, chip->io_port + 0x1c);
1866 outb(0x88, chip->io_port + 0x1d);
1867 outb(0x88, chip->io_port + 0x1e);
1868 outb(0x88, chip->io_port + 0x1f);
1869
1870 if (chip->in_suspend)
1871 return;
1872
1873 if (! chip->master_switch || ! chip->master_volume)
1874 return;
1875
1876 /* FIXME: we can't call snd_ac97_* functions since here is in tasklet. */
1877 spin_lock_irqsave(&chip->ac97_lock, flags);
1878 val = chip->ac97->regs[AC97_MASTER];
1879 switch (x) {
1880 case 0x88:
1881 /* mute */
1882 val ^= 0x8000;
1883 chip->ac97->regs[AC97_MASTER] = val;
1884 outw(val, chip->io_port + ESM_AC97_DATA);
1885 outb(AC97_MASTER, chip->io_port + ESM_AC97_INDEX);
1886 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1887 &chip->master_switch->id);
1888 break;
1889 case 0xaa:
1890 /* volume up */
1891 if ((val & 0x7f) > 0)
1892 val--;
1893 if ((val & 0x7f00) > 0)
1894 val -= 0x0100;
1895 chip->ac97->regs[AC97_MASTER] = val;
1896 outw(val, chip->io_port + ESM_AC97_DATA);
1897 outb(AC97_MASTER, chip->io_port + ESM_AC97_INDEX);
1898 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1899 &chip->master_volume->id);
1900 break;
1901 case 0x66:
1902 /* volume down */
1903 if ((val & 0x7f) < 0x1f)
1904 val++;
1905 if ((val & 0x7f00) < 0x1f00)
1906 val += 0x0100;
1907 chip->ac97->regs[AC97_MASTER] = val;
1908 outw(val, chip->io_port + ESM_AC97_DATA);
1909 outb(AC97_MASTER, chip->io_port + ESM_AC97_INDEX);
1910 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1911 &chip->master_volume->id);
1912 break;
1913 }
1914 spin_unlock_irqrestore(&chip->ac97_lock, flags);
1915 }
1916
1917 /*
1918 * interrupt handler
1919 */
1920 static irqreturn_t snd_es1968_interrupt(int irq, void *dev_id)
1921 {
1922 struct es1968 *chip = dev_id;
1923 u32 event;
1924
1925 if (!(event = inb(chip->io_port + 0x1A)))
1926 return IRQ_NONE;
1927
1928 outw(inw(chip->io_port + 4) & 1, chip->io_port + 4);
1929
1930 if (event & ESM_HWVOL_IRQ)
1931 tasklet_hi_schedule(&chip->hwvol_tq); /* we'll do this later */
1932
1933 /* else ack 'em all, i imagine */
1934 outb(0xFF, chip->io_port + 0x1A);
1935
1936 if ((event & ESM_MPU401_IRQ) && chip->rmidi) {
1937 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data);
1938 }
1939
1940 if (event & ESM_SOUND_IRQ) {
1941 struct list_head *p;
1942 spin_lock(&chip->substream_lock);
1943 list_for_each(p, &chip->substream_list) {
1944 struct esschan *es = list_entry(p, struct esschan, list);
1945 if (es->running)
1946 snd_es1968_update_pcm(chip, es);
1947 }
1948 spin_unlock(&chip->substream_lock);
1949 if (chip->in_measurement) {
1950 unsigned int curp = __apu_get_register(chip, chip->measure_apu, 5);
1951 if (curp < chip->measure_lastpos)
1952 chip->measure_count++;
1953 chip->measure_lastpos = curp;
1954 }
1955 }
1956
1957 return IRQ_HANDLED;
1958 }
1959
1960 /*
1961 * Mixer stuff
1962 */
1963
1964 static int __devinit
1965 snd_es1968_mixer(struct es1968 *chip)
1966 {
1967 struct snd_ac97_bus *pbus;
1968 struct snd_ac97_template ac97;
1969 struct snd_ctl_elem_id id;
1970 int err;
1971 static struct snd_ac97_bus_ops ops = {
1972 .write = snd_es1968_ac97_write,
1973 .read = snd_es1968_ac97_read,
1974 };
1975
1976 if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &pbus)) < 0)
1977 return err;
1978 pbus->no_vra = 1; /* ES1968 doesn't need VRA */
1979
1980 memset(&ac97, 0, sizeof(ac97));
1981 ac97.private_data = chip;
1982 if ((err = snd_ac97_mixer(pbus, &ac97, &chip->ac97)) < 0)
1983 return err;
1984
1985 /* attach master switch / volumes for h/w volume control */
1986 memset(&id, 0, sizeof(id));
1987 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1988 strcpy(id.name, "Master Playback Switch");
1989 chip->master_switch = snd_ctl_find_id(chip->card, &id);
1990 memset(&id, 0, sizeof(id));
1991 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1992 strcpy(id.name, "Master Playback Volume");
1993 chip->master_volume = snd_ctl_find_id(chip->card, &id);
1994
1995 return 0;
1996 }
1997
1998 /*
1999 * reset ac97 codec
2000 */
2001
2002 static void snd_es1968_ac97_reset(struct es1968 *chip)
2003 {
2004 unsigned long ioaddr = chip->io_port;
2005
2006 unsigned short save_ringbus_a;
2007 unsigned short save_68;
2008 unsigned short w;
2009 unsigned int vend;
2010
2011 /* save configuration */
2012 save_ringbus_a = inw(ioaddr + 0x36);
2013
2014 //outw(inw(ioaddr + 0x38) & 0xfffc, ioaddr + 0x38); /* clear second codec id? */
2015 /* set command/status address i/o to 1st codec */
2016 outw(inw(ioaddr + 0x3a) & 0xfffc, ioaddr + 0x3a);
2017 outw(inw(ioaddr + 0x3c) & 0xfffc, ioaddr + 0x3c);
2018
2019 /* disable ac link */
2020 outw(0x0000, ioaddr + 0x36);
2021 save_68 = inw(ioaddr + 0x68);
2022 pci_read_config_word(chip->pci, 0x58, &w); /* something magical with gpio and bus arb. */
2023 pci_read_config_dword(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2024 if (w & 1)
2025 save_68 |= 0x10;
2026 outw(0xfffe, ioaddr + 0x64); /* unmask gpio 0 */
2027 outw(0x0001, ioaddr + 0x68); /* gpio write */
2028 outw(0x0000, ioaddr + 0x60); /* write 0 to gpio 0 */
2029 udelay(20);
2030 outw(0x0001, ioaddr + 0x60); /* write 1 to gpio 1 */
2031 msleep(20);
2032
2033 outw(save_68 | 0x1, ioaddr + 0x68); /* now restore .. */
2034 outw((inw(ioaddr + 0x38) & 0xfffc) | 0x1, ioaddr + 0x38);
2035 outw((inw(ioaddr + 0x3a) & 0xfffc) | 0x1, ioaddr + 0x3a);
2036 outw((inw(ioaddr + 0x3c) & 0xfffc) | 0x1, ioaddr + 0x3c);
2037
2038 /* now the second codec */
2039 /* disable ac link */
2040 outw(0x0000, ioaddr + 0x36);
2041 outw(0xfff7, ioaddr + 0x64); /* unmask gpio 3 */
2042 save_68 = inw(ioaddr + 0x68);
2043 outw(0x0009, ioaddr + 0x68); /* gpio write 0 & 3 ?? */
2044 outw(0x0001, ioaddr + 0x60); /* write 1 to gpio */
2045 udelay(20);
2046 outw(0x0009, ioaddr + 0x60); /* write 9 to gpio */
2047 msleep(500);
2048 //outw(inw(ioaddr + 0x38) & 0xfffc, ioaddr + 0x38);
2049 outw(inw(ioaddr + 0x3a) & 0xfffc, ioaddr + 0x3a);
2050 outw(inw(ioaddr + 0x3c) & 0xfffc, ioaddr + 0x3c);
2051
2052 #if 0 /* the loop here needs to be much better if we want it.. */
2053 snd_printk(KERN_INFO "trying software reset\n");
2054 /* try and do a software reset */
2055 outb(0x80 | 0x7c, ioaddr + 0x30);
2056 for (w = 0;; w++) {
2057 if ((inw(ioaddr + 0x30) & 1) == 0) {
2058 if (inb(ioaddr + 0x32) != 0)
2059 break;
2060
2061 outb(0x80 | 0x7d, ioaddr + 0x30);
2062 if (((inw(ioaddr + 0x30) & 1) == 0)
2063 && (inb(ioaddr + 0x32) != 0))
2064 break;
2065 outb(0x80 | 0x7f, ioaddr + 0x30);
2066 if (((inw(ioaddr + 0x30) & 1) == 0)
2067 && (inb(ioaddr + 0x32) != 0))
2068 break;
2069 }
2070
2071 if (w > 10000) {
2072 outb(inb(ioaddr + 0x37) | 0x08, ioaddr + 0x37); /* do a software reset */
2073 msleep(500); /* oh my.. */
2074 outb(inb(ioaddr + 0x37) & ~0x08,
2075 ioaddr + 0x37);
2076 udelay(1);
2077 outw(0x80, ioaddr + 0x30);
2078 for (w = 0; w < 10000; w++) {
2079 if ((inw(ioaddr + 0x30) & 1) == 0)
2080 break;
2081 }
2082 }
2083 }
2084 #endif
2085 if (vend == NEC_VERSA_SUBID1 || vend == NEC_VERSA_SUBID2) {
2086 /* turn on external amp? */
2087 outw(0xf9ff, ioaddr + 0x64);
2088 outw(inw(ioaddr + 0x68) | 0x600, ioaddr + 0x68);
2089 outw(0x0209, ioaddr + 0x60);
2090 }
2091
2092 /* restore.. */
2093 outw(save_ringbus_a, ioaddr + 0x36);
2094
2095 /* Turn on the 978 docking chip.
2096 First frob the "master output enable" bit,
2097 then set most of the playback volume control registers to max. */
2098 outb(inb(ioaddr+0xc0)|(1<<5), ioaddr+0xc0);
2099 outb(0xff, ioaddr+0xc3);
2100 outb(0xff, ioaddr+0xc4);
2101 outb(0xff, ioaddr+0xc6);
2102 outb(0xff, ioaddr+0xc8);
2103 outb(0x3f, ioaddr+0xcf);
2104 outb(0x3f, ioaddr+0xd0);
2105 }
2106
2107 static void snd_es1968_reset(struct es1968 *chip)
2108 {
2109 /* Reset */
2110 outw(ESM_RESET_MAESTRO | ESM_RESET_DIRECTSOUND,
2111 chip->io_port + ESM_PORT_HOST_IRQ);
2112 udelay(10);
2113 outw(0x0000, chip->io_port + ESM_PORT_HOST_IRQ);
2114 udelay(10);
2115 }
2116
2117 /*
2118 * initialize maestro chip
2119 */
2120 static void snd_es1968_chip_init(struct es1968 *chip)
2121 {
2122 struct pci_dev *pci = chip->pci;
2123 int i;
2124 unsigned long iobase = chip->io_port;
2125 u16 w;
2126 u32 n;
2127
2128 /* We used to muck around with pci config space that
2129 * we had no business messing with. We don't know enough
2130 * about the machine to know which DMA mode is appropriate,
2131 * etc. We were guessing wrong on some machines and making
2132 * them unhappy. We now trust in the BIOS to do things right,
2133 * which almost certainly means a new host of problems will
2134 * arise with broken BIOS implementations. screw 'em.
2135 * We're already intolerant of machines that don't assign
2136 * IRQs.
2137 */
2138
2139 /* Config Reg A */
2140 pci_read_config_word(pci, ESM_CONFIG_A, &w);
2141
2142 w &= ~DMA_CLEAR; /* Clear DMA bits */
2143 w &= ~(PIC_SNOOP1 | PIC_SNOOP2); /* Clear Pic Snoop Mode Bits */
2144 w &= ~SAFEGUARD; /* Safeguard off */
2145 w |= POST_WRITE; /* Posted write */
2146 w |= PCI_TIMING; /* PCI timing on */
2147 /* XXX huh? claims to be reserved.. */
2148 w &= ~SWAP_LR; /* swap left/right
2149 seems to only have effect on SB
2150 Emulation */
2151 w &= ~SUBTR_DECODE; /* Subtractive decode off */
2152
2153 pci_write_config_word(pci, ESM_CONFIG_A, w);
2154
2155 /* Config Reg B */
2156
2157 pci_read_config_word(pci, ESM_CONFIG_B, &w);
2158
2159 w &= ~(1 << 15); /* Turn off internal clock multiplier */
2160 /* XXX how do we know which to use? */
2161 w &= ~(1 << 14); /* External clock */
2162
2163 w &= ~SPDIF_CONFB; /* disable S/PDIF output */
2164 w |= HWV_CONFB; /* HWV on */
2165 w |= DEBOUNCE; /* Debounce off: easier to push the HW buttons */
2166 w &= ~GPIO_CONFB; /* GPIO 4:5 */
2167 w |= CHI_CONFB; /* Disconnect from the CHI. Enabling this made a dell 7500 work. */
2168 w &= ~IDMA_CONFB; /* IDMA off (undocumented) */
2169 w &= ~MIDI_FIX; /* MIDI fix off (undoc) */
2170 w &= ~(1 << 1); /* reserved, always write 0 */
2171 w &= ~IRQ_TO_ISA; /* IRQ to ISA off (undoc) */
2172
2173 pci_write_config_word(pci, ESM_CONFIG_B, w);
2174
2175 /* DDMA off */
2176
2177 pci_read_config_word(pci, ESM_DDMA, &w);
2178 w &= ~(1 << 0);
2179 pci_write_config_word(pci, ESM_DDMA, w);
2180
2181 /*
2182 * Legacy mode
2183 */
2184
2185 pci_read_config_word(pci, ESM_LEGACY_AUDIO_CONTROL, &w);
2186
2187 w |= ESS_DISABLE_AUDIO; /* Disable Legacy Audio */
2188 w &= ~ESS_ENABLE_SERIAL_IRQ; /* Disable SIRQ */
2189 w &= ~(0x1f); /* disable mpu irq/io, game port, fm, SB */
2190
2191 pci_write_config_word(pci, ESM_LEGACY_AUDIO_CONTROL, w);
2192
2193 /* Set up 978 docking control chip. */
2194 pci_read_config_word(pci, 0x58, &w);
2195 w|=1<<2; /* Enable 978. */
2196 w|=1<<3; /* Turn on 978 hardware volume control. */
2197 w&=~(1<<11); /* Turn on 978 mixer volume control. */
2198 pci_write_config_word(pci, 0x58, w);
2199
2200 /* Sound Reset */
2201
2202 snd_es1968_reset(chip);
2203
2204 /*
2205 * Ring Bus Setup
2206 */
2207
2208 /* setup usual 0x34 stuff.. 0x36 may be chip specific */
2209 outw(0xC090, iobase + ESM_RING_BUS_DEST); /* direct sound, stereo */
2210 udelay(20);
2211 outw(0x3000, iobase + ESM_RING_BUS_CONTR_A); /* enable ringbus/serial */
2212 udelay(20);
2213
2214 /*
2215 * Reset the CODEC
2216 */
2217
2218 snd_es1968_ac97_reset(chip);
2219
2220 /* Ring Bus Control B */
2221
2222 n = inl(iobase + ESM_RING_BUS_CONTR_B);
2223 n &= ~RINGB_EN_SPDIF; /* SPDIF off */
2224 //w |= RINGB_EN_2CODEC; /* enable 2nd codec */
2225 outl(n, iobase + ESM_RING_BUS_CONTR_B);
2226
2227 /* Set hardware volume control registers to midpoints.
2228 We can tell which button was pushed based on how they change. */
2229 outb(0x88, iobase+0x1c);
2230 outb(0x88, iobase+0x1d);
2231 outb(0x88, iobase+0x1e);
2232 outb(0x88, iobase+0x1f);
2233
2234 /* it appears some maestros (dell 7500) only work if these are set,
2235 regardless of wether we use the assp or not. */
2236
2237 outb(0, iobase + ASSP_CONTROL_B);
2238 outb(3, iobase + ASSP_CONTROL_A); /* M: Reserved bits... */
2239 outb(0, iobase + ASSP_CONTROL_C); /* M: Disable ASSP, ASSP IRQ's and FM Port */
2240
2241 /*
2242 * set up wavecache
2243 */
2244 for (i = 0; i < 16; i++) {
2245 /* Write 0 into the buffer area 0x1E0->1EF */
2246 outw(0x01E0 + i, iobase + WC_INDEX);
2247 outw(0x0000, iobase + WC_DATA);
2248
2249 /* The 1.10 test program seem to write 0 into the buffer area
2250 * 0x1D0-0x1DF too.*/
2251 outw(0x01D0 + i, iobase + WC_INDEX);
2252 outw(0x0000, iobase + WC_DATA);
2253 }
2254 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2255 (wave_get_register(chip, IDR7_WAVE_ROMRAM) & 0xFF00));
2256 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2257 wave_get_register(chip, IDR7_WAVE_ROMRAM) | 0x100);
2258 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2259 wave_get_register(chip, IDR7_WAVE_ROMRAM) & ~0x200);
2260 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2261 wave_get_register(chip, IDR7_WAVE_ROMRAM) | ~0x400);
2262
2263
2264 maestro_write(chip, IDR2_CRAM_DATA, 0x0000);
2265 /* Now back to the DirectSound stuff */
2266 /* audio serial configuration.. ? */
2267 maestro_write(chip, 0x08, 0xB004);
2268 maestro_write(chip, 0x09, 0x001B);
2269 maestro_write(chip, 0x0A, 0x8000);
2270 maestro_write(chip, 0x0B, 0x3F37);
2271 maestro_write(chip, 0x0C, 0x0098);
2272
2273 /* parallel in, has something to do with recording :) */
2274 maestro_write(chip, 0x0C,
2275 (maestro_read(chip, 0x0C) & ~0xF000) | 0x8000);
2276 /* parallel out */
2277 maestro_write(chip, 0x0C,
2278 (maestro_read(chip, 0x0C) & ~0x0F00) | 0x0500);
2279
2280 maestro_write(chip, 0x0D, 0x7632);
2281
2282 /* Wave cache control on - test off, sg off,
2283 enable, enable extra chans 1Mb */
2284
2285 w = inw(iobase + WC_CONTROL);
2286
2287 w &= ~0xFA00; /* Seems to be reserved? I don't know */
2288 w |= 0xA000; /* reserved... I don't know */
2289 w &= ~0x0200; /* Channels 56,57,58,59 as Extra Play,Rec Channel enable
2290 Seems to crash the Computer if enabled... */
2291 w |= 0x0100; /* Wave Cache Operation Enabled */
2292 w |= 0x0080; /* Channels 60/61 as Placback/Record enabled */
2293 w &= ~0x0060; /* Clear Wavtable Size */
2294 w |= 0x0020; /* Wavetable Size : 1MB */
2295 /* Bit 4 is reserved */
2296 w &= ~0x000C; /* DMA Stuff? I don't understand what the datasheet means */
2297 /* Bit 1 is reserved */
2298 w &= ~0x0001; /* Test Mode off */
2299
2300 outw(w, iobase + WC_CONTROL);
2301
2302 /* Now clear the APU control ram */
2303 for (i = 0; i < NR_APUS; i++) {
2304 for (w = 0; w < NR_APU_REGS; w++)
2305 apu_set_register(chip, i, w, 0);
2306
2307 }
2308 }
2309
2310 /* Enable IRQ's */
2311 static void snd_es1968_start_irq(struct es1968 *chip)
2312 {
2313 unsigned short w;
2314 w = ESM_HIRQ_DSIE | ESM_HIRQ_HW_VOLUME;
2315 if (chip->rmidi)
2316 w |= ESM_HIRQ_MPU401;
2317 outw(w, chip->io_port + ESM_PORT_HOST_IRQ);
2318 }
2319
2320 #ifdef CONFIG_PM
2321 /*
2322 * PM support
2323 */
2324 static int es1968_suspend(struct pci_dev *pci, pm_message_t state)
2325 {
2326 struct snd_card *card = pci_get_drvdata(pci);
2327 struct es1968 *chip = card->private_data;
2328
2329 if (! chip->do_pm)
2330 return 0;
2331
2332 chip->in_suspend = 1;
2333 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
2334 snd_pcm_suspend_all(chip->pcm);
2335 snd_ac97_suspend(chip->ac97);
2336 snd_es1968_bob_stop(chip);
2337
2338 pci_disable_device(pci);
2339 pci_save_state(pci);
2340 pci_set_power_state(pci, pci_choose_state(pci, state));
2341 return 0;
2342 }
2343
2344 static int es1968_resume(struct pci_dev *pci)
2345 {
2346 struct snd_card *card = pci_get_drvdata(pci);
2347 struct es1968 *chip = card->private_data;
2348 struct list_head *p;
2349
2350 if (! chip->do_pm)
2351 return 0;
2352
2353 /* restore all our config */
2354 pci_set_power_state(pci, PCI_D0);
2355 pci_restore_state(pci);
2356 if (pci_enable_device(pci) < 0) {
2357 printk(KERN_ERR "es1968: pci_enable_device failed, "
2358 "disabling device\n");
2359 snd_card_disconnect(card);
2360 return -EIO;
2361 }
2362 pci_set_master(pci);
2363
2364 snd_es1968_chip_init(chip);
2365
2366 /* need to restore the base pointers.. */
2367 if (chip->dma.addr) {
2368 /* set PCMBAR */
2369 wave_set_register(chip, 0x01FC, chip->dma.addr >> 12);
2370 }
2371
2372 snd_es1968_start_irq(chip);
2373
2374 /* restore ac97 state */
2375 snd_ac97_resume(chip->ac97);
2376
2377 list_for_each(p, &chip->substream_list) {
2378 struct esschan *es = list_entry(p, struct esschan, list);
2379 switch (es->mode) {
2380 case ESM_MODE_PLAY:
2381 snd_es1968_playback_setup(chip, es, es->substream->runtime);
2382 break;
2383 case ESM_MODE_CAPTURE:
2384 snd_es1968_capture_setup(chip, es, es->substream->runtime);
2385 break;
2386 }
2387 }
2388
2389 /* start timer again */
2390 if (chip->bobclient)
2391 snd_es1968_bob_start(chip);
2392
2393 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
2394 chip->in_suspend = 0;
2395 return 0;
2396 }
2397 #endif /* CONFIG_PM */
2398
2399 #ifdef SUPPORT_JOYSTICK
2400 #define JOYSTICK_ADDR 0x200
2401 static int __devinit snd_es1968_create_gameport(struct es1968 *chip, int dev)
2402 {
2403 struct gameport *gp;
2404 struct resource *r;
2405 u16 val;
2406
2407 if (!joystick[dev])
2408 return -ENODEV;
2409
2410 r = request_region(JOYSTICK_ADDR, 8, "ES1968 gameport");
2411 if (!r)
2412 return -EBUSY;
2413
2414 chip->gameport = gp = gameport_allocate_port();
2415 if (!gp) {
2416 printk(KERN_ERR "es1968: cannot allocate memory for gameport\n");
2417 release_and_free_resource(r);
2418 return -ENOMEM;
2419 }
2420
2421 pci_read_config_word(chip->pci, ESM_LEGACY_AUDIO_CONTROL, &val);
2422 pci_write_config_word(chip->pci, ESM_LEGACY_AUDIO_CONTROL, val | 0x04);
2423
2424 gameport_set_name(gp, "ES1968 Gameport");
2425 gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
2426 gameport_set_dev_parent(gp, &chip->pci->dev);
2427 gp->io = JOYSTICK_ADDR;
2428 gameport_set_port_data(gp, r);
2429
2430 gameport_register_port(gp);
2431
2432 return 0;
2433 }
2434
2435 static void snd_es1968_free_gameport(struct es1968 *chip)
2436 {
2437 if (chip->gameport) {
2438 struct resource *r = gameport_get_port_data(chip->gameport);
2439
2440 gameport_unregister_port(chip->gameport);
2441 chip->gameport = NULL;
2442
2443 release_and_free_resource(r);
2444 }
2445 }
2446 #else
2447 static inline int snd_es1968_create_gameport(struct es1968 *chip, int dev) { return -ENOSYS; }
2448 static inline void snd_es1968_free_gameport(struct es1968 *chip) { }
2449 #endif
2450
2451 static int snd_es1968_free(struct es1968 *chip)
2452 {
2453 if (chip->io_port) {
2454 synchronize_irq(chip->irq);
2455 outw(1, chip->io_port + 0x04); /* clear WP interrupts */
2456 outw(0, chip->io_port + ESM_PORT_HOST_IRQ); /* disable IRQ */
2457 }
2458
2459 if (chip->irq >= 0)
2460 free_irq(chip->irq, chip);
2461 snd_es1968_free_gameport(chip);
2462 chip->master_switch = NULL;
2463 chip->master_volume = NULL;
2464 pci_release_regions(chip->pci);
2465 pci_disable_device(chip->pci);
2466 kfree(chip);
2467 return 0;
2468 }
2469
2470 static int snd_es1968_dev_free(struct snd_device *device)
2471 {
2472 struct es1968 *chip = device->device_data;
2473 return snd_es1968_free(chip);
2474 }
2475
2476 struct ess_device_list {
2477 unsigned short type; /* chip type */
2478 unsigned short vendor; /* subsystem vendor id */
2479 };
2480
2481 static struct ess_device_list pm_whitelist[] __devinitdata = {
2482 { TYPE_MAESTRO2E, 0x0e11 }, /* Compaq Armada */
2483 { TYPE_MAESTRO2E, 0x1028 },
2484 { TYPE_MAESTRO2E, 0x103c },
2485 { TYPE_MAESTRO2E, 0x1179 },
2486 { TYPE_MAESTRO2E, 0x14c0 }, /* HP omnibook 4150 */
2487 { TYPE_MAESTRO2E, 0x1558 },
2488 };
2489
2490 static struct ess_device_list mpu_blacklist[] __devinitdata = {
2491 { TYPE_MAESTRO2, 0x125d },
2492 };
2493
2494 static int __devinit snd_es1968_create(struct snd_card *card,
2495 struct pci_dev *pci,
2496 int total_bufsize,
2497 int play_streams,
2498 int capt_streams,
2499 int chip_type,
2500 int do_pm,
2501 struct es1968 **chip_ret)
2502 {
2503 static struct snd_device_ops ops = {
2504 .dev_free = snd_es1968_dev_free,
2505 };
2506 struct es1968 *chip;
2507 int i, err;
2508
2509 *chip_ret = NULL;
2510
2511 /* enable PCI device */
2512 if ((err = pci_enable_device(pci)) < 0)
2513 return err;
2514 /* check, if we can restrict PCI DMA transfers to 28 bits */
2515 if (pci_set_dma_mask(pci, DMA_28BIT_MASK) < 0 ||
2516 pci_set_consistent_dma_mask(pci, DMA_28BIT_MASK) < 0) {
2517 snd_printk(KERN_ERR "architecture does not support 28bit PCI busmaster DMA\n");
2518 pci_disable_device(pci);
2519 return -ENXIO;
2520 }
2521
2522 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
2523 if (! chip) {
2524 pci_disable_device(pci);
2525 return -ENOMEM;
2526 }
2527
2528 /* Set Vars */
2529 chip->type = chip_type;
2530 spin_lock_init(&chip->reg_lock);
2531 spin_lock_init(&chip->substream_lock);
2532 INIT_LIST_HEAD(&chip->buf_list);
2533 INIT_LIST_HEAD(&chip->substream_list);
2534 spin_lock_init(&chip->ac97_lock);
2535 mutex_init(&chip->memory_mutex);
2536 tasklet_init(&chip->hwvol_tq, es1968_update_hw_volume, (unsigned long)chip);
2537 chip->card = card;
2538 chip->pci = pci;
2539 chip->irq = -1;
2540 chip->total_bufsize = total_bufsize; /* in bytes */
2541 chip->playback_streams = play_streams;
2542 chip->capture_streams = capt_streams;
2543
2544 if ((err = pci_request_regions(pci, "ESS Maestro")) < 0) {
2545 kfree(chip);
2546 pci_disable_device(pci);
2547 return err;
2548 }
2549 chip->io_port = pci_resource_start(pci, 0);
2550 if (request_irq(pci->irq, snd_es1968_interrupt, IRQF_SHARED,
2551 "ESS Maestro", chip)) {
2552 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
2553 snd_es1968_free(chip);
2554 return -EBUSY;
2555 }
2556 chip->irq = pci->irq;
2557
2558 /* Clear Maestro_map */
2559 for (i = 0; i < 32; i++)
2560 chip->maestro_map[i] = 0;
2561
2562 /* Clear Apu Map */
2563 for (i = 0; i < NR_APUS; i++)
2564 chip->apu[i] = ESM_APU_FREE;
2565
2566 /* just to be sure */
2567 pci_set_master(pci);
2568
2569 if (do_pm > 1) {
2570 /* disable power-management if not on the whitelist */
2571 unsigned short vend;
2572 pci_read_config_word(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2573 for (i = 0; i < (int)ARRAY_SIZE(pm_whitelist); i++) {
2574 if (chip->type == pm_whitelist[i].type &&
2575 vend == pm_whitelist[i].vendor) {
2576 do_pm = 1;
2577 break;
2578 }
2579 }
2580 if (do_pm > 1) {
2581 /* not matched; disabling pm */
2582 printk(KERN_INFO "es1968: not attempting power management.\n");
2583 do_pm = 0;
2584 }
2585 }
2586 chip->do_pm = do_pm;
2587
2588 snd_es1968_chip_init(chip);
2589
2590 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
2591 snd_es1968_free(chip);
2592 return err;
2593 }
2594
2595 snd_card_set_dev(card, &pci->dev);
2596
2597 *chip_ret = chip;
2598
2599 return 0;
2600 }
2601
2602
2603 /*
2604 */
2605 static int __devinit snd_es1968_probe(struct pci_dev *pci,
2606 const struct pci_device_id *pci_id)
2607 {
2608 static int dev;
2609 struct snd_card *card;
2610 struct es1968 *chip;
2611 unsigned int i;
2612 int err;
2613
2614 if (dev >= SNDRV_CARDS)
2615 return -ENODEV;
2616 if (!enable[dev]) {
2617 dev++;
2618 return -ENOENT;
2619 }
2620
2621 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
2622 if (!card)
2623 return -ENOMEM;
2624
2625 if (total_bufsize[dev] < 128)
2626 total_bufsize[dev] = 128;
2627 if (total_bufsize[dev] > 4096)
2628 total_bufsize[dev] = 4096;
2629 if ((err = snd_es1968_create(card, pci,
2630 total_bufsize[dev] * 1024, /* in bytes */
2631 pcm_substreams_p[dev],
2632 pcm_substreams_c[dev],
2633 pci_id->driver_data,
2634 use_pm[dev],
2635 &chip)) < 0) {
2636 snd_card_free(card);
2637 return err;
2638 }
2639 card->private_data = chip;
2640
2641 switch (chip->type) {
2642 case TYPE_MAESTRO2E:
2643 strcpy(card->driver, "ES1978");
2644 strcpy(card->shortname, "ESS ES1978 (Maestro 2E)");
2645 break;
2646 case TYPE_MAESTRO2:
2647 strcpy(card->driver, "ES1968");
2648 strcpy(card->shortname, "ESS ES1968 (Maestro 2)");
2649 break;
2650 case TYPE_MAESTRO:
2651 strcpy(card->driver, "ESM1");
2652 strcpy(card->shortname, "ESS Maestro 1");
2653 break;
2654 }
2655
2656 if ((err = snd_es1968_pcm(chip, 0)) < 0) {
2657 snd_card_free(card);
2658 return err;
2659 }
2660
2661 if ((err = snd_es1968_mixer(chip)) < 0) {
2662 snd_card_free(card);
2663 return err;
2664 }
2665
2666 if (enable_mpu[dev] == 2) {
2667 /* check the black list */
2668 unsigned short vend;
2669 pci_read_config_word(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2670 for (i = 0; i < ARRAY_SIZE(mpu_blacklist); i++) {
2671 if (chip->type == mpu_blacklist[i].type &&
2672 vend == mpu_blacklist[i].vendor) {
2673 enable_mpu[dev] = 0;
2674 break;
2675 }
2676 }
2677 }
2678 if (enable_mpu[dev]) {
2679 if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
2680 chip->io_port + ESM_MPU401_PORT,
2681 MPU401_INFO_INTEGRATED,
2682 chip->irq, 0, &chip->rmidi)) < 0) {
2683 printk(KERN_WARNING "es1968: skipping MPU-401 MIDI support..\n");
2684 }
2685 }
2686
2687 snd_es1968_create_gameport(chip, dev);
2688
2689 snd_es1968_start_irq(chip);
2690
2691 chip->clock = clock[dev];
2692 if (! chip->clock)
2693 es1968_measure_clock(chip);
2694
2695 sprintf(card->longname, "%s at 0x%lx, irq %i",
2696 card->shortname, chip->io_port, chip->irq);
2697
2698 if ((err = snd_card_register(card)) < 0) {
2699 snd_card_free(card);
2700 return err;
2701 }
2702 pci_set_drvdata(pci, card);
2703 dev++;
2704 return 0;
2705 }
2706
2707 static void __devexit snd_es1968_remove(struct pci_dev *pci)
2708 {
2709 snd_card_free(pci_get_drvdata(pci));
2710 pci_set_drvdata(pci, NULL);
2711 }
2712
2713 static struct pci_driver driver = {
2714 .name = "ES1968 (ESS Maestro)",
2715 .id_table = snd_es1968_ids,
2716 .probe = snd_es1968_probe,
2717 .remove = __devexit_p(snd_es1968_remove),
2718 #ifdef CONFIG_PM
2719 .suspend = es1968_suspend,
2720 .resume = es1968_resume,
2721 #endif
2722 };
2723
2724 static int __init alsa_card_es1968_init(void)
2725 {
2726 return pci_register_driver(&driver);
2727 }
2728
2729 static void __exit alsa_card_es1968_exit(void)
2730 {
2731 pci_unregister_driver(&driver);
2732 }
2733
2734 module_init(alsa_card_es1968_init)
2735 module_exit(alsa_card_es1968_exit)
Verdex Pro support