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