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