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