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