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 snd_assert(channel < NR_APUS, return); 696 #ifdef CONFIG_PM 697 chip->apu_map[channel][reg] = data; 698 #endif 699 reg |= (channel << 4); 700 apu_index_set(chip, reg); 701 apu_data_set(chip, data); 702 } 703 704 static void apu_set_register(struct es1968 *chip, u16 channel, u8 reg, u16 data) 705 { 706 unsigned long flags; 707 spin_lock_irqsave(&chip->reg_lock, flags); 708 __apu_set_register(chip, channel, reg, data); 709 spin_unlock_irqrestore(&chip->reg_lock, flags); 710 } 711 712 static u16 __apu_get_register(struct es1968 *chip, u16 channel, u8 reg) 713 { 714 snd_assert(channel < NR_APUS, return 0); 715 reg |= (channel << 4); 716 apu_index_set(chip, reg); 717 return __maestro_read(chip, IDR0_DATA_PORT); 718 } 719 720 static u16 apu_get_register(struct es1968 *chip, u16 channel, u8 reg) 721 { 722 unsigned long flags; 723 u16 v; 724 spin_lock_irqsave(&chip->reg_lock, flags); 725 v = __apu_get_register(chip, channel, reg); 726 spin_unlock_irqrestore(&chip->reg_lock, flags); 727 return v; 728 } 729 730 #if 0 /* ASSP is not supported */ 731 732 static void assp_set_register(struct es1968 *chip, u32 reg, u32 value) 733 { 734 unsigned long flags; 735 736 spin_lock_irqsave(&chip->reg_lock, flags); 737 outl(reg, chip->io_port + ASSP_INDEX); 738 outl(value, chip->io_port + ASSP_DATA); 739 spin_unlock_irqrestore(&chip->reg_lock, flags); 740 } 741 742 static u32 assp_get_register(struct es1968 *chip, u32 reg) 743 { 744 unsigned long flags; 745 u32 value; 746 747 spin_lock_irqsave(&chip->reg_lock, flags); 748 outl(reg, chip->io_port + ASSP_INDEX); 749 value = inl(chip->io_port + ASSP_DATA); 750 spin_unlock_irqrestore(&chip->reg_lock, flags); 751 752 return value; 753 } 754 755 #endif 756 757 static void wave_set_register(struct es1968 *chip, u16 reg, u16 value) 758 { 759 unsigned long flags; 760 761 spin_lock_irqsave(&chip->reg_lock, flags); 762 outw(reg, chip->io_port + WC_INDEX); 763 outw(value, chip->io_port + WC_DATA); 764 spin_unlock_irqrestore(&chip->reg_lock, flags); 765 } 766 767 static u16 wave_get_register(struct es1968 *chip, u16 reg) 768 { 769 unsigned long flags; 770 u16 value; 771 772 spin_lock_irqsave(&chip->reg_lock, flags); 773 outw(reg, chip->io_port + WC_INDEX); 774 value = inw(chip->io_port + WC_DATA); 775 spin_unlock_irqrestore(&chip->reg_lock, flags); 776 777 return value; 778 } 779 780 /* ******************* 781 * Bob the Timer! * 782 *******************/ 783 784 static void snd_es1968_bob_stop(struct es1968 *chip) 785 { 786 u16 reg; 787 788 reg = __maestro_read(chip, 0x11); 789 reg &= ~ESM_BOB_ENABLE; 790 __maestro_write(chip, 0x11, reg); 791 reg = __maestro_read(chip, 0x17); 792 reg &= ~ESM_BOB_START; 793 __maestro_write(chip, 0x17, reg); 794 } 795 796 static void snd_es1968_bob_start(struct es1968 *chip) 797 { 798 int prescale; 799 int divide; 800 801 /* compute ideal interrupt frequency for buffer size & play rate */ 802 /* first, find best prescaler value to match freq */ 803 for (prescale = 5; prescale < 12; prescale++) 804 if (chip->bob_freq > (ESS_SYSCLK >> (prescale + 9))) 805 break; 806 807 /* next, back off prescaler whilst getting divider into optimum range */ 808 divide = 1; 809 while ((prescale > 5) && (divide < 32)) { 810 prescale--; 811 divide <<= 1; 812 } 813 divide >>= 1; 814 815 /* now fine-tune the divider for best match */ 816 for (; divide < 31; divide++) 817 if (chip->bob_freq > 818 ((ESS_SYSCLK >> (prescale + 9)) / (divide + 1))) break; 819 820 /* divide = 0 is illegal, but don't let prescale = 4! */ 821 if (divide == 0) { 822 divide++; 823 if (prescale > 5) 824 prescale--; 825 } else if (divide > 1) 826 divide--; 827 828 __maestro_write(chip, 6, 0x9000 | (prescale << 5) | divide); /* set reg */ 829 830 /* Now set IDR 11/17 */ 831 __maestro_write(chip, 0x11, __maestro_read(chip, 0x11) | 1); 832 __maestro_write(chip, 0x17, __maestro_read(chip, 0x17) | 1); 833 } 834 835 /* call with substream spinlock */ 836 static void snd_es1968_bob_inc(struct es1968 *chip, int freq) 837 { 838 chip->bobclient++; 839 if (chip->bobclient == 1) { 840 chip->bob_freq = freq; 841 snd_es1968_bob_start(chip); 842 } else if (chip->bob_freq < freq) { 843 snd_es1968_bob_stop(chip); 844 chip->bob_freq = freq; 845 snd_es1968_bob_start(chip); 846 } 847 } 848 849 /* call with substream spinlock */ 850 static void snd_es1968_bob_dec(struct es1968 *chip) 851 { 852 chip->bobclient--; 853 if (chip->bobclient <= 0) 854 snd_es1968_bob_stop(chip); 855 else if (chip->bob_freq > ESM_BOB_FREQ) { 856 /* check reduction of timer frequency */ 857 int max_freq = ESM_BOB_FREQ; 858 struct esschan *es; 859 list_for_each_entry(es, &chip->substream_list, list) { 860 if (max_freq < es->bob_freq) 861 max_freq = es->bob_freq; 862 } 863 if (max_freq != chip->bob_freq) { 864 snd_es1968_bob_stop(chip); 865 chip->bob_freq = max_freq; 866 snd_es1968_bob_start(chip); 867 } 868 } 869 } 870 871 static int 872 snd_es1968_calc_bob_rate(struct es1968 *chip, struct esschan *es, 873 struct snd_pcm_runtime *runtime) 874 { 875 /* we acquire 4 interrupts per period for precise control.. */ 876 int freq = runtime->rate * 4; 877 if (es->fmt & ESS_FMT_STEREO) 878 freq <<= 1; 879 if (es->fmt & ESS_FMT_16BIT) 880 freq <<= 1; 881 freq /= es->frag_size; 882 if (freq < ESM_BOB_FREQ) 883 freq = ESM_BOB_FREQ; 884 else if (freq > ESM_BOB_FREQ_MAX) 885 freq = ESM_BOB_FREQ_MAX; 886 return freq; 887 } 888 889 890 /************* 891 * PCM Part * 892 *************/ 893 894 static u32 snd_es1968_compute_rate(struct es1968 *chip, u32 freq) 895 { 896 u32 rate = (freq << 16) / chip->clock; 897 #if 0 /* XXX: do we need this? */ 898 if (rate > 0x10000) 899 rate = 0x10000; 900 #endif 901 return rate; 902 } 903 904 /* get current pointer */ 905 static inline unsigned int 906 snd_es1968_get_dma_ptr(struct es1968 *chip, struct esschan *es) 907 { 908 unsigned int offset; 909 910 offset = apu_get_register(chip, es->apu[0], 5); 911 912 offset -= es->base[0]; 913 914 return (offset & 0xFFFE); /* hardware is in words */ 915 } 916 917 static void snd_es1968_apu_set_freq(struct es1968 *chip, int apu, int freq) 918 { 919 apu_set_register(chip, apu, 2, 920 (apu_get_register(chip, apu, 2) & 0x00FF) | 921 ((freq & 0xff) << 8) | 0x10); 922 apu_set_register(chip, apu, 3, freq >> 8); 923 } 924 925 /* spin lock held */ 926 static inline void snd_es1968_trigger_apu(struct es1968 *esm, int apu, int mode) 927 { 928 /* set the APU mode */ 929 __apu_set_register(esm, apu, 0, 930 (__apu_get_register(esm, apu, 0) & 0xff0f) | 931 (mode << 4)); 932 } 933 934 static void snd_es1968_pcm_start(struct es1968 *chip, struct esschan *es) 935 { 936 spin_lock(&chip->reg_lock); 937 __apu_set_register(chip, es->apu[0], 5, es->base[0]); 938 snd_es1968_trigger_apu(chip, es->apu[0], es->apu_mode[0]); 939 if (es->mode == ESM_MODE_CAPTURE) { 940 __apu_set_register(chip, es->apu[2], 5, es->base[2]); 941 snd_es1968_trigger_apu(chip, es->apu[2], es->apu_mode[2]); 942 } 943 if (es->fmt & ESS_FMT_STEREO) { 944 __apu_set_register(chip, es->apu[1], 5, es->base[1]); 945 snd_es1968_trigger_apu(chip, es->apu[1], es->apu_mode[1]); 946 if (es->mode == ESM_MODE_CAPTURE) { 947 __apu_set_register(chip, es->apu[3], 5, es->base[3]); 948 snd_es1968_trigger_apu(chip, es->apu[3], es->apu_mode[3]); 949 } 950 } 951 spin_unlock(&chip->reg_lock); 952 } 953 954 static void snd_es1968_pcm_stop(struct es1968 *chip, struct esschan *es) 955 { 956 spin_lock(&chip->reg_lock); 957 snd_es1968_trigger_apu(chip, es->apu[0], 0); 958 snd_es1968_trigger_apu(chip, es->apu[1], 0); 959 if (es->mode == ESM_MODE_CAPTURE) { 960 snd_es1968_trigger_apu(chip, es->apu[2], 0); 961 snd_es1968_trigger_apu(chip, es->apu[3], 0); 962 } 963 spin_unlock(&chip->reg_lock); 964 } 965 966 /* set the wavecache control reg */ 967 static void snd_es1968_program_wavecache(struct es1968 *chip, struct esschan *es, 968 int channel, u32 addr, int capture) 969 { 970 u32 tmpval = (addr - 0x10) & 0xFFF8; 971 972 if (! capture) { 973 if (!(es->fmt & ESS_FMT_16BIT)) 974 tmpval |= 4; /* 8bit */ 975 if (es->fmt & ESS_FMT_STEREO) 976 tmpval |= 2; /* stereo */ 977 } 978 979 /* set the wavecache control reg */ 980 wave_set_register(chip, es->apu[channel] << 3, tmpval); 981 982 #ifdef CONFIG_PM 983 es->wc_map[channel] = tmpval; 984 #endif 985 } 986 987 988 static void snd_es1968_playback_setup(struct es1968 *chip, struct esschan *es, 989 struct snd_pcm_runtime *runtime) 990 { 991 u32 pa; 992 int high_apu = 0; 993 int channel, apu; 994 int i, size; 995 unsigned long flags; 996 u32 freq; 997 998 size = es->dma_size >> es->wav_shift; 999 1000 if (es->fmt & ESS_FMT_STEREO) 1001 high_apu++; 1002 1003 for (channel = 0; channel <= high_apu; channel++) { 1004 apu = es->apu[channel]; 1005 1006 snd_es1968_program_wavecache(chip, es, channel, es->memory->buf.addr, 0); 1007 1008 /* Offset to PCMBAR */ 1009 pa = es->memory->buf.addr; 1010 pa -= chip->dma.addr; 1011 pa >>= 1; /* words */ 1012 1013 pa |= 0x00400000; /* System RAM (Bit 22) */ 1014 1015 if (es->fmt & ESS_FMT_STEREO) { 1016 /* Enable stereo */ 1017 if (channel) 1018 pa |= 0x00800000; /* (Bit 23) */ 1019 if (es->fmt & ESS_FMT_16BIT) 1020 pa >>= 1; 1021 } 1022 1023 /* base offset of dma calcs when reading the pointer 1024 on this left one */ 1025 es->base[channel] = pa & 0xFFFF; 1026 1027 for (i = 0; i < 16; i++) 1028 apu_set_register(chip, apu, i, 0x0000); 1029 1030 /* Load the buffer into the wave engine */ 1031 apu_set_register(chip, apu, 4, ((pa >> 16) & 0xFF) << 8); 1032 apu_set_register(chip, apu, 5, pa & 0xFFFF); 1033 apu_set_register(chip, apu, 6, (pa + size) & 0xFFFF); 1034 /* setting loop == sample len */ 1035 apu_set_register(chip, apu, 7, size); 1036 1037 /* clear effects/env.. */ 1038 apu_set_register(chip, apu, 8, 0x0000); 1039 /* set amp now to 0xd0 (?), low byte is 'amplitude dest'? */ 1040 apu_set_register(chip, apu, 9, 0xD000); 1041 1042 /* clear routing stuff */ 1043 apu_set_register(chip, apu, 11, 0x0000); 1044 /* dma on, no envelopes, filter to all 1s) */ 1045 apu_set_register(chip, apu, 0, 0x400F); 1046 1047 if (es->fmt & ESS_FMT_16BIT) 1048 es->apu_mode[channel] = ESM_APU_16BITLINEAR; 1049 else 1050 es->apu_mode[channel] = ESM_APU_8BITLINEAR; 1051 1052 if (es->fmt & ESS_FMT_STEREO) { 1053 /* set panning: left or right */ 1054 /* Check: different panning. On my Canyon 3D Chipset the 1055 Channels are swapped. I don't know, about the output 1056 to the SPDif Link. Perhaps you have to change this 1057 and not the APU Regs 4-5. */ 1058 apu_set_register(chip, apu, 10, 1059 0x8F00 | (channel ? 0 : 0x10)); 1060 es->apu_mode[channel] += 1; /* stereo */ 1061 } else 1062 apu_set_register(chip, apu, 10, 0x8F08); 1063 } 1064 1065 spin_lock_irqsave(&chip->reg_lock, flags); 1066 /* clear WP interrupts */ 1067 outw(1, chip->io_port + 0x04); 1068 /* enable WP ints */ 1069 outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ); 1070 spin_unlock_irqrestore(&chip->reg_lock, flags); 1071 1072 freq = runtime->rate; 1073 /* set frequency */ 1074 if (freq > 48000) 1075 freq = 48000; 1076 if (freq < 4000) 1077 freq = 4000; 1078 1079 /* hmmm.. */ 1080 if (!(es->fmt & ESS_FMT_16BIT) && !(es->fmt & ESS_FMT_STEREO)) 1081 freq >>= 1; 1082 1083 freq = snd_es1968_compute_rate(chip, freq); 1084 1085 /* Load the frequency, turn on 6dB */ 1086 snd_es1968_apu_set_freq(chip, es->apu[0], freq); 1087 snd_es1968_apu_set_freq(chip, es->apu[1], freq); 1088 } 1089 1090 1091 static void init_capture_apu(struct es1968 *chip, struct esschan *es, int channel, 1092 unsigned int pa, unsigned int bsize, 1093 int mode, int route) 1094 { 1095 int i, apu = es->apu[channel]; 1096 1097 es->apu_mode[channel] = mode; 1098 1099 /* set the wavecache control reg */ 1100 snd_es1968_program_wavecache(chip, es, channel, pa, 1); 1101 1102 /* Offset to PCMBAR */ 1103 pa -= chip->dma.addr; 1104 pa >>= 1; /* words */ 1105 1106 /* base offset of dma calcs when reading the pointer 1107 on this left one */ 1108 es->base[channel] = pa & 0xFFFF; 1109 pa |= 0x00400000; /* bit 22 -> System RAM */ 1110 1111 /* Begin loading the APU */ 1112 for (i = 0; i < 16; i++) 1113 apu_set_register(chip, apu, i, 0x0000); 1114 1115 /* need to enable subgroups.. and we should probably 1116 have different groups for different /dev/dsps.. */ 1117 apu_set_register(chip, apu, 2, 0x8); 1118 1119 /* Load the buffer into the wave engine */ 1120 apu_set_register(chip, apu, 4, ((pa >> 16) & 0xFF) << 8); 1121 apu_set_register(chip, apu, 5, pa & 0xFFFF); 1122 apu_set_register(chip, apu, 6, (pa + bsize) & 0xFFFF); 1123 apu_set_register(chip, apu, 7, bsize); 1124 /* clear effects/env.. */ 1125 apu_set_register(chip, apu, 8, 0x00F0); 1126 /* amplitude now? sure. why not. */ 1127 apu_set_register(chip, apu, 9, 0x0000); 1128 /* set filter tune, radius, polar pan */ 1129 apu_set_register(chip, apu, 10, 0x8F08); 1130 /* route input */ 1131 apu_set_register(chip, apu, 11, route); 1132 /* dma on, no envelopes, filter to all 1s) */ 1133 apu_set_register(chip, apu, 0, 0x400F); 1134 } 1135 1136 static void snd_es1968_capture_setup(struct es1968 *chip, struct esschan *es, 1137 struct snd_pcm_runtime *runtime) 1138 { 1139 int size; 1140 u32 freq; 1141 unsigned long flags; 1142 1143 size = es->dma_size >> es->wav_shift; 1144 1145 /* APU assignments: 1146 0 = mono/left SRC 1147 1 = right SRC 1148 2 = mono/left Input Mixer 1149 3 = right Input Mixer 1150 */ 1151 /* data seems to flow from the codec, through an apu into 1152 the 'mixbuf' bit of page, then through the SRC apu 1153 and out to the real 'buffer'. ok. sure. */ 1154 1155 /* input mixer (left/mono) */ 1156 /* parallel in crap, see maestro reg 0xC [8-11] */ 1157 init_capture_apu(chip, es, 2, 1158 es->mixbuf->buf.addr, ESM_MIXBUF_SIZE/4, /* in words */ 1159 ESM_APU_INPUTMIXER, 0x14); 1160 /* SRC (left/mono); get input from inputing apu */ 1161 init_capture_apu(chip, es, 0, es->memory->buf.addr, size, 1162 ESM_APU_SRCONVERTOR, es->apu[2]); 1163 if (es->fmt & ESS_FMT_STEREO) { 1164 /* input mixer (right) */ 1165 init_capture_apu(chip, es, 3, 1166 es->mixbuf->buf.addr + ESM_MIXBUF_SIZE/2, 1167 ESM_MIXBUF_SIZE/4, /* in words */ 1168 ESM_APU_INPUTMIXER, 0x15); 1169 /* SRC (right) */ 1170 init_capture_apu(chip, es, 1, 1171 es->memory->buf.addr + size*2, size, 1172 ESM_APU_SRCONVERTOR, es->apu[3]); 1173 } 1174 1175 freq = runtime->rate; 1176 /* Sample Rate conversion APUs don't like 0x10000 for their rate */ 1177 if (freq > 47999) 1178 freq = 47999; 1179 if (freq < 4000) 1180 freq = 4000; 1181 1182 freq = snd_es1968_compute_rate(chip, freq); 1183 1184 /* Load the frequency, turn on 6dB */ 1185 snd_es1968_apu_set_freq(chip, es->apu[0], freq); 1186 snd_es1968_apu_set_freq(chip, es->apu[1], freq); 1187 1188 /* fix mixer rate at 48khz. and its _must_ be 0x10000. */ 1189 freq = 0x10000; 1190 snd_es1968_apu_set_freq(chip, es->apu[2], freq); 1191 snd_es1968_apu_set_freq(chip, es->apu[3], freq); 1192 1193 spin_lock_irqsave(&chip->reg_lock, flags); 1194 /* clear WP interrupts */ 1195 outw(1, chip->io_port + 0x04); 1196 /* enable WP ints */ 1197 outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ); 1198 spin_unlock_irqrestore(&chip->reg_lock, flags); 1199 } 1200 1201 /******************* 1202 * ALSA Interface * 1203 *******************/ 1204 1205 static int snd_es1968_pcm_prepare(struct snd_pcm_substream *substream) 1206 { 1207 struct es1968 *chip = snd_pcm_substream_chip(substream); 1208 struct snd_pcm_runtime *runtime = substream->runtime; 1209 struct esschan *es = runtime->private_data; 1210 1211 es->dma_size = snd_pcm_lib_buffer_bytes(substream); 1212 es->frag_size = snd_pcm_lib_period_bytes(substream); 1213 1214 es->wav_shift = 1; /* maestro handles always 16bit */ 1215 es->fmt = 0; 1216 if (snd_pcm_format_width(runtime->format) == 16) 1217 es->fmt |= ESS_FMT_16BIT; 1218 if (runtime->channels > 1) { 1219 es->fmt |= ESS_FMT_STEREO; 1220 if (es->fmt & ESS_FMT_16BIT) /* 8bit is already word shifted */ 1221 es->wav_shift++; 1222 } 1223 es->bob_freq = snd_es1968_calc_bob_rate(chip, es, runtime); 1224 1225 switch (es->mode) { 1226 case ESM_MODE_PLAY: 1227 snd_es1968_playback_setup(chip, es, runtime); 1228 break; 1229 case ESM_MODE_CAPTURE: 1230 snd_es1968_capture_setup(chip, es, runtime); 1231 break; 1232 } 1233 1234 return 0; 1235 } 1236 1237 static int snd_es1968_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 1238 { 1239 struct es1968 *chip = snd_pcm_substream_chip(substream); 1240 struct esschan *es = substream->runtime->private_data; 1241 1242 spin_lock(&chip->substream_lock); 1243 switch (cmd) { 1244 case SNDRV_PCM_TRIGGER_START: 1245 case SNDRV_PCM_TRIGGER_RESUME: 1246 if (es->running) 1247 break; 1248 snd_es1968_bob_inc(chip, es->bob_freq); 1249 es->count = 0; 1250 es->hwptr = 0; 1251 snd_es1968_pcm_start(chip, es); 1252 es->running = 1; 1253 break; 1254 case SNDRV_PCM_TRIGGER_STOP: 1255 case SNDRV_PCM_TRIGGER_SUSPEND: 1256 if (! es->running) 1257 break; 1258 snd_es1968_pcm_stop(chip, es); 1259 es->running = 0; 1260 snd_es1968_bob_dec(chip); 1261 break; 1262 } 1263 spin_unlock(&chip->substream_lock); 1264 return 0; 1265 } 1266 1267 static snd_pcm_uframes_t snd_es1968_pcm_pointer(struct snd_pcm_substream *substream) 1268 { 1269 struct es1968 *chip = snd_pcm_substream_chip(substream); 1270 struct esschan *es = substream->runtime->private_data; 1271 unsigned int ptr; 1272 1273 ptr = snd_es1968_get_dma_ptr(chip, es) << es->wav_shift; 1274 1275 return bytes_to_frames(substream->runtime, ptr % es->dma_size); 1276 } 1277 1278 static struct snd_pcm_hardware snd_es1968_playback = { 1279 .info = (SNDRV_PCM_INFO_MMAP | 1280 SNDRV_PCM_INFO_MMAP_VALID | 1281 SNDRV_PCM_INFO_INTERLEAVED | 1282 SNDRV_PCM_INFO_BLOCK_TRANSFER | 1283 /*SNDRV_PCM_INFO_PAUSE |*/ 1284 SNDRV_PCM_INFO_RESUME), 1285 .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE, 1286 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, 1287 .rate_min = 4000, 1288 .rate_max = 48000, 1289 .channels_min = 1, 1290 .channels_max = 2, 1291 .buffer_bytes_max = 65536, 1292 .period_bytes_min = 256, 1293 .period_bytes_max = 65536, 1294 .periods_min = 1, 1295 .periods_max = 1024, 1296 .fifo_size = 0, 1297 }; 1298 1299 static struct snd_pcm_hardware snd_es1968_capture = { 1300 .info = (SNDRV_PCM_INFO_NONINTERLEAVED | 1301 SNDRV_PCM_INFO_MMAP | 1302 SNDRV_PCM_INFO_MMAP_VALID | 1303 SNDRV_PCM_INFO_BLOCK_TRANSFER | 1304 /*SNDRV_PCM_INFO_PAUSE |*/ 1305 SNDRV_PCM_INFO_RESUME), 1306 .formats = /*SNDRV_PCM_FMTBIT_U8 |*/ SNDRV_PCM_FMTBIT_S16_LE, 1307 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, 1308 .rate_min = 4000, 1309 .rate_max = 48000, 1310 .channels_min = 1, 1311 .channels_max = 2, 1312 .buffer_bytes_max = 65536, 1313 .period_bytes_min = 256, 1314 .period_bytes_max = 65536, 1315 .periods_min = 1, 1316 .periods_max = 1024, 1317 .fifo_size = 0, 1318 }; 1319 1320 /* ************************* 1321 * DMA memory management * 1322 *************************/ 1323 1324 /* Because the Maestro can only take addresses relative to the PCM base address 1325 register :( */ 1326 1327 static int calc_available_memory_size(struct es1968 *chip) 1328 { 1329 int max_size = 0; 1330 struct esm_memory *buf; 1331 1332 mutex_lock(&chip->memory_mutex); 1333 list_for_each_entry(buf, &chip->buf_list, list) { 1334 if (buf->empty && buf->buf.bytes > max_size) 1335 max_size = buf->buf.bytes; 1336 } 1337 mutex_unlock(&chip->memory_mutex); 1338 if (max_size >= 128*1024) 1339 max_size = 127*1024; 1340 return max_size; 1341 } 1342 1343 /* allocate a new memory chunk with the specified size */ 1344 static struct esm_memory *snd_es1968_new_memory(struct es1968 *chip, int size) 1345 { 1346 struct esm_memory *buf; 1347 1348 size = ALIGN(size, ESM_MEM_ALIGN); 1349 mutex_lock(&chip->memory_mutex); 1350 list_for_each_entry(buf, &chip->buf_list, list) { 1351 if (buf->empty && buf->buf.bytes >= size) 1352 goto __found; 1353 } 1354 mutex_unlock(&chip->memory_mutex); 1355 return NULL; 1356 1357 __found: 1358 if (buf->buf.bytes > size) { 1359 struct esm_memory *chunk = kmalloc(sizeof(*chunk), GFP_KERNEL); 1360 if (chunk == NULL) { 1361 mutex_unlock(&chip->memory_mutex); 1362 return NULL; 1363 } 1364 chunk->buf = buf->buf; 1365 chunk->buf.bytes -= size; 1366 chunk->buf.area += size; 1367 chunk->buf.addr += size; 1368 chunk->empty = 1; 1369 buf->buf.bytes = size; 1370 list_add(&chunk->list, &buf->list); 1371 } 1372 buf->empty = 0; 1373 mutex_unlock(&chip->memory_mutex); 1374 return buf; 1375 } 1376 1377 /* free a memory chunk */ 1378 static void snd_es1968_free_memory(struct es1968 *chip, struct esm_memory *buf) 1379 { 1380 struct esm_memory *chunk; 1381 1382 mutex_lock(&chip->memory_mutex); 1383 buf->empty = 1; 1384 if (buf->list.prev != &chip->buf_list) { 1385 chunk = list_entry(buf->list.prev, struct esm_memory, list); 1386 if (chunk->empty) { 1387 chunk->buf.bytes += buf->buf.bytes; 1388 list_del(&buf->list); 1389 kfree(buf); 1390 buf = chunk; 1391 } 1392 } 1393 if (buf->list.next != &chip->buf_list) { 1394 chunk = list_entry(buf->list.next, struct esm_memory, list); 1395 if (chunk->empty) { 1396 buf->buf.bytes += chunk->buf.bytes; 1397 list_del(&chunk->list); 1398 kfree(chunk); 1399 } 1400 } 1401 mutex_unlock(&chip->memory_mutex); 1402 } 1403 1404 static void snd_es1968_free_dmabuf(struct es1968 *chip) 1405 { 1406 struct list_head *p; 1407 1408 if (! chip->dma.area) 1409 return; 1410 snd_dma_reserve_buf(&chip->dma, snd_dma_pci_buf_id(chip->pci)); 1411 while ((p = chip->buf_list.next) != &chip->buf_list) { 1412 struct esm_memory *chunk = list_entry(p, struct esm_memory, list); 1413 list_del(p); 1414 kfree(chunk); 1415 } 1416 } 1417 1418 static int __devinit 1419 snd_es1968_init_dmabuf(struct es1968 *chip) 1420 { 1421 int err; 1422 struct esm_memory *chunk; 1423 1424 chip->dma.dev.type = SNDRV_DMA_TYPE_DEV; 1425 chip->dma.dev.dev = snd_dma_pci_data(chip->pci); 1426 if (! snd_dma_get_reserved_buf(&chip->dma, snd_dma_pci_buf_id(chip->pci))) { 1427 err = snd_dma_alloc_pages_fallback(SNDRV_DMA_TYPE_DEV, 1428 snd_dma_pci_data(chip->pci), 1429 chip->total_bufsize, &chip->dma); 1430 if (err < 0 || ! chip->dma.area) { 1431 snd_printk(KERN_ERR "es1968: can't allocate dma pages for size %d\n", 1432 chip->total_bufsize); 1433 return -ENOMEM; 1434 } 1435 if ((chip->dma.addr + chip->dma.bytes - 1) & ~((1 << 28) - 1)) { 1436 snd_dma_free_pages(&chip->dma); 1437 snd_printk(KERN_ERR "es1968: DMA buffer beyond 256MB.\n"); 1438 return -ENOMEM; 1439 } 1440 } 1441 1442 INIT_LIST_HEAD(&chip->buf_list); 1443 /* allocate an empty chunk */ 1444 chunk = kmalloc(sizeof(*chunk), GFP_KERNEL); 1445 if (chunk == NULL) { 1446 snd_es1968_free_dmabuf(chip); 1447 return -ENOMEM; 1448 } 1449 memset(chip->dma.area, 0, ESM_MEM_ALIGN); 1450 chunk->buf = chip->dma; 1451 chunk->buf.area += ESM_MEM_ALIGN; 1452 chunk->buf.addr += ESM_MEM_ALIGN; 1453 chunk->buf.bytes -= ESM_MEM_ALIGN; 1454 chunk->empty = 1; 1455 list_add(&chunk->list, &chip->buf_list); 1456 1457 return 0; 1458 } 1459 1460 /* setup the dma_areas */ 1461 /* buffer is extracted from the pre-allocated memory chunk */ 1462 static int snd_es1968_hw_params(struct snd_pcm_substream *substream, 1463 struct snd_pcm_hw_params *hw_params) 1464 { 1465 struct es1968 *chip = snd_pcm_substream_chip(substream); 1466 struct snd_pcm_runtime *runtime = substream->runtime; 1467 struct esschan *chan = runtime->private_data; 1468 int size = params_buffer_bytes(hw_params); 1469 1470 if (chan->memory) { 1471 if (chan->memory->buf.bytes >= size) { 1472 runtime->dma_bytes = size; 1473 return 0; 1474 } 1475 snd_es1968_free_memory(chip, chan->memory); 1476 } 1477 chan->memory = snd_es1968_new_memory(chip, size); 1478 if (chan->memory == NULL) { 1479 // snd_printd("cannot allocate dma buffer: size = %d\n", size); 1480 return -ENOMEM; 1481 } 1482 snd_pcm_set_runtime_buffer(substream, &chan->memory->buf); 1483 return 1; /* area was changed */ 1484 } 1485 1486 /* remove dma areas if allocated */ 1487 static int snd_es1968_hw_free(struct snd_pcm_substream *substream) 1488 { 1489 struct es1968 *chip = snd_pcm_substream_chip(substream); 1490 struct snd_pcm_runtime *runtime = substream->runtime; 1491 struct esschan *chan; 1492 1493 if (runtime->private_data == NULL) 1494 return 0; 1495 chan = runtime->private_data; 1496 if (chan->memory) { 1497 snd_es1968_free_memory(chip, chan->memory); 1498 chan->memory = NULL; 1499 } 1500 return 0; 1501 } 1502 1503 1504 /* 1505 * allocate APU pair 1506 */ 1507 static int snd_es1968_alloc_apu_pair(struct es1968 *chip, int type) 1508 { 1509 int apu; 1510 1511 for (apu = 0; apu < NR_APUS; apu += 2) { 1512 if (chip->apu[apu] == ESM_APU_FREE && 1513 chip->apu[apu + 1] == ESM_APU_FREE) { 1514 chip->apu[apu] = chip->apu[apu + 1] = type; 1515 return apu; 1516 } 1517 } 1518 return -EBUSY; 1519 } 1520 1521 /* 1522 * release APU pair 1523 */ 1524 static void snd_es1968_free_apu_pair(struct es1968 *chip, int apu) 1525 { 1526 chip->apu[apu] = chip->apu[apu + 1] = ESM_APU_FREE; 1527 } 1528 1529 1530 /****************** 1531 * PCM open/close * 1532 ******************/ 1533 1534 static int snd_es1968_playback_open(struct snd_pcm_substream *substream) 1535 { 1536 struct es1968 *chip = snd_pcm_substream_chip(substream); 1537 struct snd_pcm_runtime *runtime = substream->runtime; 1538 struct esschan *es; 1539 int apu1; 1540 1541 /* search 2 APUs */ 1542 apu1 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_PLAY); 1543 if (apu1 < 0) 1544 return apu1; 1545 1546 es = kzalloc(sizeof(*es), GFP_KERNEL); 1547 if (!es) { 1548 snd_es1968_free_apu_pair(chip, apu1); 1549 return -ENOMEM; 1550 } 1551 1552 es->apu[0] = apu1; 1553 es->apu[1] = apu1 + 1; 1554 es->apu_mode[0] = 0; 1555 es->apu_mode[1] = 0; 1556 es->running = 0; 1557 es->substream = substream; 1558 es->mode = ESM_MODE_PLAY; 1559 1560 runtime->private_data = es; 1561 runtime->hw = snd_es1968_playback; 1562 runtime->hw.buffer_bytes_max = runtime->hw.period_bytes_max = 1563 calc_available_memory_size(chip); 1564 1565 spin_lock_irq(&chip->substream_lock); 1566 list_add(&es->list, &chip->substream_list); 1567 spin_unlock_irq(&chip->substream_lock); 1568 1569 return 0; 1570 } 1571 1572 static int snd_es1968_capture_open(struct snd_pcm_substream *substream) 1573 { 1574 struct snd_pcm_runtime *runtime = substream->runtime; 1575 struct es1968 *chip = snd_pcm_substream_chip(substream); 1576 struct esschan *es; 1577 int apu1, apu2; 1578 1579 apu1 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_CAPTURE); 1580 if (apu1 < 0) 1581 return apu1; 1582 apu2 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_RATECONV); 1583 if (apu2 < 0) { 1584 snd_es1968_free_apu_pair(chip, apu1); 1585 return apu2; 1586 } 1587 1588 es = kzalloc(sizeof(*es), GFP_KERNEL); 1589 if (!es) { 1590 snd_es1968_free_apu_pair(chip, apu1); 1591 snd_es1968_free_apu_pair(chip, apu2); 1592 return -ENOMEM; 1593 } 1594 1595 es->apu[0] = apu1; 1596 es->apu[1] = apu1 + 1; 1597 es->apu[2] = apu2; 1598 es->apu[3] = apu2 + 1; 1599 es->apu_mode[0] = 0; 1600 es->apu_mode[1] = 0; 1601 es->apu_mode[2] = 0; 1602 es->apu_mode[3] = 0; 1603 es->running = 0; 1604 es->substream = substream; 1605 es->mode = ESM_MODE_CAPTURE; 1606 1607 /* get mixbuffer */ 1608 if ((es->mixbuf = snd_es1968_new_memory(chip, ESM_MIXBUF_SIZE)) == NULL) { 1609 snd_es1968_free_apu_pair(chip, apu1); 1610 snd_es1968_free_apu_pair(chip, apu2); 1611 kfree(es); 1612 return -ENOMEM; 1613 } 1614 memset(es->mixbuf->buf.area, 0, ESM_MIXBUF_SIZE); 1615 1616 runtime->private_data = es; 1617 runtime->hw = snd_es1968_capture; 1618 runtime->hw.buffer_bytes_max = runtime->hw.period_bytes_max = 1619 calc_available_memory_size(chip) - 1024; /* keep MIXBUF size */ 1620 snd_pcm_hw_constraint_pow2(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES); 1621 1622 spin_lock_irq(&chip->substream_lock); 1623 list_add(&es->list, &chip->substream_list); 1624 spin_unlock_irq(&chip->substream_lock); 1625 1626 return 0; 1627 } 1628 1629 static int snd_es1968_playback_close(struct snd_pcm_substream *substream) 1630 { 1631 struct es1968 *chip = snd_pcm_substream_chip(substream); 1632 struct esschan *es; 1633 1634 if (substream->runtime->private_data == NULL) 1635 return 0; 1636 es = substream->runtime->private_data; 1637 spin_lock_irq(&chip->substream_lock); 1638 list_del(&es->list); 1639 spin_unlock_irq(&chip->substream_lock); 1640 snd_es1968_free_apu_pair(chip, es->apu[0]); 1641 kfree(es); 1642 1643 return 0; 1644 } 1645 1646 static int snd_es1968_capture_close(struct snd_pcm_substream *substream) 1647 { 1648 struct es1968 *chip = snd_pcm_substream_chip(substream); 1649 struct esschan *es; 1650 1651 if (substream->runtime->private_data == NULL) 1652 return 0; 1653 es = substream->runtime->private_data; 1654 spin_lock_irq(&chip->substream_lock); 1655 list_del(&es->list); 1656 spin_unlock_irq(&chip->substream_lock); 1657 snd_es1968_free_memory(chip, es->mixbuf); 1658 snd_es1968_free_apu_pair(chip, es->apu[0]); 1659 snd_es1968_free_apu_pair(chip, es->apu[2]); 1660 kfree(es); 1661 1662 return 0; 1663 } 1664 1665 static struct snd_pcm_ops snd_es1968_playback_ops = { 1666 .open = snd_es1968_playback_open, 1667 .close = snd_es1968_playback_close, 1668 .ioctl = snd_pcm_lib_ioctl, 1669 .hw_params = snd_es1968_hw_params, 1670 .hw_free = snd_es1968_hw_free, 1671 .prepare = snd_es1968_pcm_prepare, 1672 .trigger = snd_es1968_pcm_trigger, 1673 .pointer = snd_es1968_pcm_pointer, 1674 }; 1675 1676 static struct snd_pcm_ops snd_es1968_capture_ops = { 1677 .open = snd_es1968_capture_open, 1678 .close = snd_es1968_capture_close, 1679 .ioctl = snd_pcm_lib_ioctl, 1680 .hw_params = snd_es1968_hw_params, 1681 .hw_free = snd_es1968_hw_free, 1682 .prepare = snd_es1968_pcm_prepare, 1683 .trigger = snd_es1968_pcm_trigger, 1684 .pointer = snd_es1968_pcm_pointer, 1685 }; 1686 1687 1688 /* 1689 * measure clock 1690 */ 1691 #define CLOCK_MEASURE_BUFSIZE 16768 /* enough large for a single shot */ 1692 1693 static void __devinit es1968_measure_clock(struct es1968 *chip) 1694 { 1695 int i, apu; 1696 unsigned int pa, offset, t; 1697 struct esm_memory *memory; 1698 struct timeval start_time, stop_time; 1699 1700 if (chip->clock == 0) 1701 chip->clock = 48000; /* default clock value */ 1702 1703 /* search 2 APUs (although one apu is enough) */ 1704 if ((apu = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_PLAY)) < 0) { 1705 snd_printk(KERN_ERR "Hmm, cannot find empty APU pair!?\n"); 1706 return; 1707 } 1708 if ((memory = snd_es1968_new_memory(chip, CLOCK_MEASURE_BUFSIZE)) == NULL) { 1709 snd_printk(KERN_ERR "cannot allocate dma buffer - using default clock %d\n", chip->clock); 1710 snd_es1968_free_apu_pair(chip, apu); 1711 return; 1712 } 1713 1714 memset(memory->buf.area, 0, CLOCK_MEASURE_BUFSIZE); 1715 1716 wave_set_register(chip, apu << 3, (memory->buf.addr - 0x10) & 0xfff8); 1717 1718 pa = (unsigned int)((memory->buf.addr - chip->dma.addr) >> 1); 1719 pa |= 0x00400000; /* System RAM (Bit 22) */ 1720 1721 /* initialize apu */ 1722 for (i = 0; i < 16; i++) 1723 apu_set_register(chip, apu, i, 0x0000); 1724 1725 apu_set_register(chip, apu, 0, 0x400f); 1726 apu_set_register(chip, apu, 4, ((pa >> 16) & 0xff) << 8); 1727 apu_set_register(chip, apu, 5, pa & 0xffff); 1728 apu_set_register(chip, apu, 6, (pa + CLOCK_MEASURE_BUFSIZE/2) & 0xffff); 1729 apu_set_register(chip, apu, 7, CLOCK_MEASURE_BUFSIZE/2); 1730 apu_set_register(chip, apu, 8, 0x0000); 1731 apu_set_register(chip, apu, 9, 0xD000); 1732 apu_set_register(chip, apu, 10, 0x8F08); 1733 apu_set_register(chip, apu, 11, 0x0000); 1734 spin_lock_irq(&chip->reg_lock); 1735 outw(1, chip->io_port + 0x04); /* clear WP interrupts */ 1736 outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ); /* enable WP ints */ 1737 spin_unlock_irq(&chip->reg_lock); 1738 1739 snd_es1968_apu_set_freq(chip, apu, ((unsigned int)48000 << 16) / chip->clock); /* 48000 Hz */ 1740 1741 chip->in_measurement = 1; 1742 chip->measure_apu = apu; 1743 spin_lock_irq(&chip->reg_lock); 1744 snd_es1968_bob_inc(chip, ESM_BOB_FREQ); 1745 __apu_set_register(chip, apu, 5, pa & 0xffff); 1746 snd_es1968_trigger_apu(chip, apu, ESM_APU_16BITLINEAR); 1747 do_gettimeofday(&start_time); 1748 spin_unlock_irq(&chip->reg_lock); 1749 msleep(50); 1750 spin_lock_irq(&chip->reg_lock); 1751 offset = __apu_get_register(chip, apu, 5); 1752 do_gettimeofday(&stop_time); 1753 snd_es1968_trigger_apu(chip, apu, 0); /* stop */ 1754 snd_es1968_bob_dec(chip); 1755 chip->in_measurement = 0; 1756 spin_unlock_irq(&chip->reg_lock); 1757 1758 /* check the current position */ 1759 offset -= (pa & 0xffff); 1760 offset &= 0xfffe; 1761 offset += chip->measure_count * (CLOCK_MEASURE_BUFSIZE/2); 1762 1763 t = stop_time.tv_sec - start_time.tv_sec; 1764 t *= 1000000; 1765 if (stop_time.tv_usec < start_time.tv_usec) 1766 t -= start_time.tv_usec - stop_time.tv_usec; 1767 else 1768 t += stop_time.tv_usec - start_time.tv_usec; 1769 if (t == 0) { 1770 snd_printk(KERN_ERR "?? calculation error..\n"); 1771 } else { 1772 offset *= 1000; 1773 offset = (offset / t) * 1000 + ((offset % t) * 1000) / t; 1774 if (offset < 47500 || offset > 48500) { 1775 if (offset >= 40000 && offset <= 50000) 1776 chip->clock = (chip->clock * offset) / 48000; 1777 } 1778 printk(KERN_INFO "es1968: clocking to %d\n", chip->clock); 1779 } 1780 snd_es1968_free_memory(chip, memory); 1781 snd_es1968_free_apu_pair(chip, apu); 1782 } 1783 1784 1785 /* 1786 */ 1787 1788 static void snd_es1968_pcm_free(struct snd_pcm *pcm) 1789 { 1790 struct es1968 *esm = pcm->private_data; 1791 snd_es1968_free_dmabuf(esm); 1792 esm->pcm = NULL; 1793 } 1794 1795 static int __devinit 1796 snd_es1968_pcm(struct es1968 *chip, int device) 1797 { 1798 struct snd_pcm *pcm; 1799 int err; 1800 1801 /* get DMA buffer */ 1802 if ((err = snd_es1968_init_dmabuf(chip)) < 0) 1803 return err; 1804 1805 /* set PCMBAR */ 1806 wave_set_register(chip, 0x01FC, chip->dma.addr >> 12); 1807 wave_set_register(chip, 0x01FD, chip->dma.addr >> 12); 1808 wave_set_register(chip, 0x01FE, chip->dma.addr >> 12); 1809 wave_set_register(chip, 0x01FF, chip->dma.addr >> 12); 1810 1811 if ((err = snd_pcm_new(chip->card, "ESS Maestro", device, 1812 chip->playback_streams, 1813 chip->capture_streams, &pcm)) < 0) 1814 return err; 1815 1816 pcm->private_data = chip; 1817 pcm->private_free = snd_es1968_pcm_free; 1818 1819 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_es1968_playback_ops); 1820 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1968_capture_ops); 1821 1822 pcm->info_flags = 0; 1823 1824 strcpy(pcm->name, "ESS Maestro"); 1825 1826 chip->pcm = pcm; 1827 1828 return 0; 1829 } 1830 /* 1831 * suppress jitter on some maestros when playing stereo 1832 */ 1833 static void snd_es1968_suppress_jitter(struct es1968 *chip, struct esschan *es) 1834 { 1835 unsigned int cp1; 1836 unsigned int cp2; 1837 unsigned int diff; 1838 1839 cp1 = __apu_get_register(chip, 0, 5); 1840 cp2 = __apu_get_register(chip, 1, 5); 1841 diff = (cp1 > cp2 ? cp1 - cp2 : cp2 - cp1); 1842 1843 if (diff > 1) 1844 __maestro_write(chip, IDR0_DATA_PORT, cp1); 1845 } 1846 1847 /* 1848 * update pointer 1849 */ 1850 static void snd_es1968_update_pcm(struct es1968 *chip, struct esschan *es) 1851 { 1852 unsigned int hwptr; 1853 unsigned int diff; 1854 struct snd_pcm_substream *subs = es->substream; 1855 1856 if (subs == NULL || !es->running) 1857 return; 1858 1859 hwptr = snd_es1968_get_dma_ptr(chip, es) << es->wav_shift; 1860 hwptr %= es->dma_size; 1861 1862 diff = (es->dma_size + hwptr - es->hwptr) % es->dma_size; 1863 1864 es->hwptr = hwptr; 1865 es->count += diff; 1866 1867 if (es->count > es->frag_size) { 1868 spin_unlock(&chip->substream_lock); 1869 snd_pcm_period_elapsed(subs); 1870 spin_lock(&chip->substream_lock); 1871 es->count %= es->frag_size; 1872 } 1873 } 1874 1875 /* 1876 */ 1877 static void es1968_update_hw_volume(unsigned long private_data) 1878 { 1879 struct es1968 *chip = (struct es1968 *) private_data; 1880 int x, val; 1881 unsigned long flags; 1882 1883 /* Figure out which volume control button was pushed, 1884 based on differences from the default register 1885 values. */ 1886 x = inb(chip->io_port + 0x1c) & 0xee; 1887 /* Reset the volume control registers. */ 1888 outb(0x88, chip->io_port + 0x1c); 1889 outb(0x88, chip->io_port + 0x1d); 1890 outb(0x88, chip->io_port + 0x1e); 1891 outb(0x88, chip->io_port + 0x1f); 1892 1893 if (chip->in_suspend) 1894 return; 1895 1896 if (! chip->master_switch || ! chip->master_volume) 1897 return; 1898 1899 /* FIXME: we can't call snd_ac97_* functions since here is in tasklet. */ 1900 spin_lock_irqsave(&chip->ac97_lock, flags); 1901 val = chip->ac97->regs[AC97_MASTER]; 1902 switch (x) { 1903 case 0x88: 1904 /* mute */ 1905 val ^= 0x8000; 1906 chip->ac97->regs[AC97_MASTER] = val; 1907 outw(val, chip->io_port + ESM_AC97_DATA); 1908 outb(AC97_MASTER, chip->io_port + ESM_AC97_INDEX); 1909 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 1910 &chip->master_switch->id); 1911 break; 1912 case 0xaa: 1913 /* volume up */ 1914 if ((val & 0x7f) > 0) 1915 val--; 1916 if ((val & 0x7f00) > 0) 1917 val -= 0x0100; 1918 chip->ac97->regs[AC97_MASTER] = val; 1919 outw(val, chip->io_port + ESM_AC97_DATA); 1920 outb(AC97_MASTER, chip->io_port + ESM_AC97_INDEX); 1921 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 1922 &chip->master_volume->id); 1923 break; 1924 case 0x66: 1925 /* volume down */ 1926 if ((val & 0x7f) < 0x1f) 1927 val++; 1928 if ((val & 0x7f00) < 0x1f00) 1929 val += 0x0100; 1930 chip->ac97->regs[AC97_MASTER] = val; 1931 outw(val, chip->io_port + ESM_AC97_DATA); 1932 outb(AC97_MASTER, chip->io_port + ESM_AC97_INDEX); 1933 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 1934 &chip->master_volume->id); 1935 break; 1936 } 1937 spin_unlock_irqrestore(&chip->ac97_lock, flags); 1938 } 1939 1940 /* 1941 * interrupt handler 1942 */ 1943 static irqreturn_t snd_es1968_interrupt(int irq, void *dev_id) 1944 { 1945 struct es1968 *chip = dev_id; 1946 u32 event; 1947 1948 if (!(event = inb(chip->io_port + 0x1A))) 1949 return IRQ_NONE; 1950 1951 outw(inw(chip->io_port + 4) & 1, chip->io_port + 4); 1952 1953 if (event & ESM_HWVOL_IRQ) 1954 tasklet_hi_schedule(&chip->hwvol_tq); /* we'll do this later */ 1955 1956 /* else ack 'em all, i imagine */ 1957 outb(0xFF, chip->io_port + 0x1A); 1958 1959 if ((event & ESM_MPU401_IRQ) && chip->rmidi) { 1960 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data); 1961 } 1962 1963 if (event & ESM_SOUND_IRQ) { 1964 struct esschan *es; 1965 spin_lock(&chip->substream_lock); 1966 list_for_each_entry(es, &chip->substream_list, list) { 1967 if (es->running) { 1968 snd_es1968_update_pcm(chip, es); 1969 if (es->fmt & ESS_FMT_STEREO) 1970 snd_es1968_suppress_jitter(chip, es); 1971 } 1972 } 1973 spin_unlock(&chip->substream_lock); 1974 if (chip->in_measurement) { 1975 unsigned int curp = __apu_get_register(chip, chip->measure_apu, 5); 1976 if (curp < chip->measure_lastpos) 1977 chip->measure_count++; 1978 chip->measure_lastpos = curp; 1979 } 1980 } 1981 1982 return IRQ_HANDLED; 1983 } 1984 1985 /* 1986 * Mixer stuff 1987 */ 1988 1989 static int __devinit 1990 snd_es1968_mixer(struct es1968 *chip) 1991 { 1992 struct snd_ac97_bus *pbus; 1993 struct snd_ac97_template ac97; 1994 struct snd_ctl_elem_id elem_id; 1995 int err; 1996 static struct snd_ac97_bus_ops ops = { 1997 .write = snd_es1968_ac97_write, 1998 .read = snd_es1968_ac97_read, 1999 }; 2000 2001 if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &pbus)) < 0) 2002 return err; 2003 pbus->no_vra = 1; /* ES1968 doesn't need VRA */ 2004 2005 memset(&ac97, 0, sizeof(ac97)); 2006 ac97.private_data = chip; 2007 if ((err = snd_ac97_mixer(pbus, &ac97, &chip->ac97)) < 0) 2008 return err; 2009 2010 /* attach master switch / volumes for h/w volume control */ 2011 memset(&elem_id, 0, sizeof(elem_id)); 2012 elem_id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 2013 strcpy(elem_id.name, "Master Playback Switch"); 2014 chip->master_switch = snd_ctl_find_id(chip->card, &elem_id); 2015 memset(&elem_id, 0, sizeof(elem_id)); 2016 elem_id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 2017 strcpy(elem_id.name, "Master Playback Volume"); 2018 chip->master_volume = snd_ctl_find_id(chip->card, &elem_id); 2019 2020 return 0; 2021 } 2022 2023 /* 2024 * reset ac97 codec 2025 */ 2026 2027 static void snd_es1968_ac97_reset(struct es1968 *chip) 2028 { 2029 unsigned long ioaddr = chip->io_port; 2030 2031 unsigned short save_ringbus_a; 2032 unsigned short save_68; 2033 unsigned short w; 2034 unsigned int vend; 2035 2036 /* save configuration */ 2037 save_ringbus_a = inw(ioaddr + 0x36); 2038 2039 //outw(inw(ioaddr + 0x38) & 0xfffc, ioaddr + 0x38); /* clear second codec id? */ 2040 /* set command/status address i/o to 1st codec */ 2041 outw(inw(ioaddr + 0x3a) & 0xfffc, ioaddr + 0x3a); 2042 outw(inw(ioaddr + 0x3c) & 0xfffc, ioaddr + 0x3c); 2043 2044 /* disable ac link */ 2045 outw(0x0000, ioaddr + 0x36); 2046 save_68 = inw(ioaddr + 0x68); 2047 pci_read_config_word(chip->pci, 0x58, &w); /* something magical with gpio and bus arb. */ 2048 pci_read_config_dword(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend); 2049 if (w & 1) 2050 save_68 |= 0x10; 2051 outw(0xfffe, ioaddr + 0x64); /* unmask gpio 0 */ 2052 outw(0x0001, ioaddr + 0x68); /* gpio write */ 2053 outw(0x0000, ioaddr + 0x60); /* write 0 to gpio 0 */ 2054 udelay(20); 2055 outw(0x0001, ioaddr + 0x60); /* write 1 to gpio 1 */ 2056 msleep(20); 2057 2058 outw(save_68 | 0x1, ioaddr + 0x68); /* now restore .. */ 2059 outw((inw(ioaddr + 0x38) & 0xfffc) | 0x1, ioaddr + 0x38); 2060 outw((inw(ioaddr + 0x3a) & 0xfffc) | 0x1, ioaddr + 0x3a); 2061 outw((inw(ioaddr + 0x3c) & 0xfffc) | 0x1, ioaddr + 0x3c); 2062 2063 /* now the second codec */ 2064 /* disable ac link */ 2065 outw(0x0000, ioaddr + 0x36); 2066 outw(0xfff7, ioaddr + 0x64); /* unmask gpio 3 */ 2067 save_68 = inw(ioaddr + 0x68); 2068 outw(0x0009, ioaddr + 0x68); /* gpio write 0 & 3 ?? */ 2069 outw(0x0001, ioaddr + 0x60); /* write 1 to gpio */ 2070 udelay(20); 2071 outw(0x0009, ioaddr + 0x60); /* write 9 to gpio */ 2072 msleep(500); 2073 //outw(inw(ioaddr + 0x38) & 0xfffc, ioaddr + 0x38); 2074 outw(inw(ioaddr + 0x3a) & 0xfffc, ioaddr + 0x3a); 2075 outw(inw(ioaddr + 0x3c) & 0xfffc, ioaddr + 0x3c); 2076 2077 #if 0 /* the loop here needs to be much better if we want it.. */ 2078 snd_printk(KERN_INFO "trying software reset\n"); 2079 /* try and do a software reset */ 2080 outb(0x80 | 0x7c, ioaddr + 0x30); 2081 for (w = 0;; w++) { 2082 if ((inw(ioaddr + 0x30) & 1) == 0) { 2083 if (inb(ioaddr + 0x32) != 0) 2084 break; 2085 2086 outb(0x80 | 0x7d, ioaddr + 0x30); 2087 if (((inw(ioaddr + 0x30) & 1) == 0) 2088 && (inb(ioaddr + 0x32) != 0)) 2089 break; 2090 outb(0x80 | 0x7f, ioaddr + 0x30); 2091 if (((inw(ioaddr + 0x30) & 1) == 0) 2092 && (inb(ioaddr + 0x32) != 0)) 2093 break; 2094 } 2095 2096 if (w > 10000) { 2097 outb(inb(ioaddr + 0x37) | 0x08, ioaddr + 0x37); /* do a software reset */ 2098 msleep(500); /* oh my.. */ 2099 outb(inb(ioaddr + 0x37) & ~0x08, 2100 ioaddr + 0x37); 2101 udelay(1); 2102 outw(0x80, ioaddr + 0x30); 2103 for (w = 0; w < 10000; w++) { 2104 if ((inw(ioaddr + 0x30) & 1) == 0) 2105 break; 2106 } 2107 } 2108 } 2109 #endif 2110 if (vend == NEC_VERSA_SUBID1 || vend == NEC_VERSA_SUBID2) { 2111 /* turn on external amp? */ 2112 outw(0xf9ff, ioaddr + 0x64); 2113 outw(inw(ioaddr + 0x68) | 0x600, ioaddr + 0x68); 2114 outw(0x0209, ioaddr + 0x60); 2115 } 2116 2117 /* restore.. */ 2118 outw(save_ringbus_a, ioaddr + 0x36); 2119 2120 /* Turn on the 978 docking chip. 2121 First frob the "master output enable" bit, 2122 then set most of the playback volume control registers to max. */ 2123 outb(inb(ioaddr+0xc0)|(1<<5), ioaddr+0xc0); 2124 outb(0xff, ioaddr+0xc3); 2125 outb(0xff, ioaddr+0xc4); 2126 outb(0xff, ioaddr+0xc6); 2127 outb(0xff, ioaddr+0xc8); 2128 outb(0x3f, ioaddr+0xcf); 2129 outb(0x3f, ioaddr+0xd0); 2130 } 2131 2132 static void snd_es1968_reset(struct es1968 *chip) 2133 { 2134 /* Reset */ 2135 outw(ESM_RESET_MAESTRO | ESM_RESET_DIRECTSOUND, 2136 chip->io_port + ESM_PORT_HOST_IRQ); 2137 udelay(10); 2138 outw(0x0000, chip->io_port + ESM_PORT_HOST_IRQ); 2139 udelay(10); 2140 } 2141 2142 /* 2143 * initialize maestro chip 2144 */ 2145 static void snd_es1968_chip_init(struct es1968 *chip) 2146 { 2147 struct pci_dev *pci = chip->pci; 2148 int i; 2149 unsigned long iobase = chip->io_port; 2150 u16 w; 2151 u32 n; 2152 2153 /* We used to muck around with pci config space that 2154 * we had no business messing with. We don't know enough 2155 * about the machine to know which DMA mode is appropriate, 2156 * etc. We were guessing wrong on some machines and making 2157 * them unhappy. We now trust in the BIOS to do things right, 2158 * which almost certainly means a new host of problems will 2159 * arise with broken BIOS implementations. screw 'em. 2160 * We're already intolerant of machines that don't assign 2161 * IRQs. 2162 */ 2163 2164 /* Config Reg A */ 2165 pci_read_config_word(pci, ESM_CONFIG_A, &w); 2166 2167 w &= ~DMA_CLEAR; /* Clear DMA bits */ 2168 w &= ~(PIC_SNOOP1 | PIC_SNOOP2); /* Clear Pic Snoop Mode Bits */ 2169 w &= ~SAFEGUARD; /* Safeguard off */ 2170 w |= POST_WRITE; /* Posted write */ 2171 w |= PCI_TIMING; /* PCI timing on */ 2172 /* XXX huh? claims to be reserved.. */ 2173 w &= ~SWAP_LR; /* swap left/right 2174 seems to only have effect on SB 2175 Emulation */ 2176 w &= ~SUBTR_DECODE; /* Subtractive decode off */ 2177 2178 pci_write_config_word(pci, ESM_CONFIG_A, w); 2179 2180 /* Config Reg B */ 2181 2182 pci_read_config_word(pci, ESM_CONFIG_B, &w); 2183 2184 w &= ~(1 << 15); /* Turn off internal clock multiplier */ 2185 /* XXX how do we know which to use? */ 2186 w &= ~(1 << 14); /* External clock */ 2187 2188 w &= ~SPDIF_CONFB; /* disable S/PDIF output */ 2189 w |= HWV_CONFB; /* HWV on */ 2190 w |= DEBOUNCE; /* Debounce off: easier to push the HW buttons */ 2191 w &= ~GPIO_CONFB; /* GPIO 4:5 */ 2192 w |= CHI_CONFB; /* Disconnect from the CHI. Enabling this made a dell 7500 work. */ 2193 w &= ~IDMA_CONFB; /* IDMA off (undocumented) */ 2194 w &= ~MIDI_FIX; /* MIDI fix off (undoc) */ 2195 w &= ~(1 << 1); /* reserved, always write 0 */ 2196 w &= ~IRQ_TO_ISA; /* IRQ to ISA off (undoc) */ 2197 2198 pci_write_config_word(pci, ESM_CONFIG_B, w); 2199 2200 /* DDMA off */ 2201 2202 pci_read_config_word(pci, ESM_DDMA, &w); 2203 w &= ~(1 << 0); 2204 pci_write_config_word(pci, ESM_DDMA, w); 2205 2206 /* 2207 * Legacy mode 2208 */ 2209 2210 pci_read_config_word(pci, ESM_LEGACY_AUDIO_CONTROL, &w); 2211 2212 w |= ESS_DISABLE_AUDIO; /* Disable Legacy Audio */ 2213 w &= ~ESS_ENABLE_SERIAL_IRQ; /* Disable SIRQ */ 2214 w &= ~(0x1f); /* disable mpu irq/io, game port, fm, SB */ 2215 2216 pci_write_config_word(pci, ESM_LEGACY_AUDIO_CONTROL, w); 2217 2218 /* Set up 978 docking control chip. */ 2219 pci_read_config_word(pci, 0x58, &w); 2220 w|=1<<2; /* Enable 978. */ 2221 w|=1<<3; /* Turn on 978 hardware volume control. */ 2222 w&=~(1<<11); /* Turn on 978 mixer volume control. */ 2223 pci_write_config_word(pci, 0x58, w); 2224 2225 /* Sound Reset */ 2226 2227 snd_es1968_reset(chip); 2228 2229 /* 2230 * Ring Bus Setup 2231 */ 2232 2233 /* setup usual 0x34 stuff.. 0x36 may be chip specific */ 2234 outw(0xC090, iobase + ESM_RING_BUS_DEST); /* direct sound, stereo */ 2235 udelay(20); 2236 outw(0x3000, iobase + ESM_RING_BUS_CONTR_A); /* enable ringbus/serial */ 2237 udelay(20); 2238 2239 /* 2240 * Reset the CODEC 2241 */ 2242 2243 snd_es1968_ac97_reset(chip); 2244 2245 /* Ring Bus Control B */ 2246 2247 n = inl(iobase + ESM_RING_BUS_CONTR_B); 2248 n &= ~RINGB_EN_SPDIF; /* SPDIF off */ 2249 //w |= RINGB_EN_2CODEC; /* enable 2nd codec */ 2250 outl(n, iobase + ESM_RING_BUS_CONTR_B); 2251 2252 /* Set hardware volume control registers to midpoints. 2253 We can tell which button was pushed based on how they change. */ 2254 outb(0x88, iobase+0x1c); 2255 outb(0x88, iobase+0x1d); 2256 outb(0x88, iobase+0x1e); 2257 outb(0x88, iobase+0x1f); 2258 2259 /* it appears some maestros (dell 7500) only work if these are set, 2260 regardless of wether we use the assp or not. */ 2261 2262 outb(0, iobase + ASSP_CONTROL_B); 2263 outb(3, iobase + ASSP_CONTROL_A); /* M: Reserved bits... */ 2264 outb(0, iobase + ASSP_CONTROL_C); /* M: Disable ASSP, ASSP IRQ's and FM Port */ 2265 2266 /* 2267 * set up wavecache 2268 */ 2269 for (i = 0; i < 16; i++) { 2270 /* Write 0 into the buffer area 0x1E0->1EF */ 2271 outw(0x01E0 + i, iobase + WC_INDEX); 2272 outw(0x0000, iobase + WC_DATA); 2273 2274 /* The 1.10 test program seem to write 0 into the buffer area 2275 * 0x1D0-0x1DF too.*/ 2276 outw(0x01D0 + i, iobase + WC_INDEX); 2277 outw(0x0000, iobase + WC_DATA); 2278 } 2279 wave_set_register(chip, IDR7_WAVE_ROMRAM, 2280 (wave_get_register(chip, IDR7_WAVE_ROMRAM) & 0xFF00)); 2281 wave_set_register(chip, IDR7_WAVE_ROMRAM, 2282 wave_get_register(chip, IDR7_WAVE_ROMRAM) | 0x100); 2283 wave_set_register(chip, IDR7_WAVE_ROMRAM, 2284 wave_get_register(chip, IDR7_WAVE_ROMRAM) & ~0x200); 2285 wave_set_register(chip, IDR7_WAVE_ROMRAM, 2286 wave_get_register(chip, IDR7_WAVE_ROMRAM) | ~0x400); 2287 2288 2289 maestro_write(chip, IDR2_CRAM_DATA, 0x0000); 2290 /* Now back to the DirectSound stuff */ 2291 /* audio serial configuration.. ? */ 2292 maestro_write(chip, 0x08, 0xB004); 2293 maestro_write(chip, 0x09, 0x001B); 2294 maestro_write(chip, 0x0A, 0x8000); 2295 maestro_write(chip, 0x0B, 0x3F37); 2296 maestro_write(chip, 0x0C, 0x0098); 2297 2298 /* parallel in, has something to do with recording :) */ 2299 maestro_write(chip, 0x0C, 2300 (maestro_read(chip, 0x0C) & ~0xF000) | 0x8000); 2301 /* parallel out */ 2302 maestro_write(chip, 0x0C, 2303 (maestro_read(chip, 0x0C) & ~0x0F00) | 0x0500); 2304 2305 maestro_write(chip, 0x0D, 0x7632); 2306 2307 /* Wave cache control on - test off, sg off, 2308 enable, enable extra chans 1Mb */ 2309 2310 w = inw(iobase + WC_CONTROL); 2311 2312 w &= ~0xFA00; /* Seems to be reserved? I don't know */ 2313 w |= 0xA000; /* reserved... I don't know */ 2314 w &= ~0x0200; /* Channels 56,57,58,59 as Extra Play,Rec Channel enable 2315 Seems to crash the Computer if enabled... */ 2316 w |= 0x0100; /* Wave Cache Operation Enabled */ 2317 w |= 0x0080; /* Channels 60/61 as Placback/Record enabled */ 2318 w &= ~0x0060; /* Clear Wavtable Size */ 2319 w |= 0x0020; /* Wavetable Size : 1MB */ 2320 /* Bit 4 is reserved */ 2321 w &= ~0x000C; /* DMA Stuff? I don't understand what the datasheet means */ 2322 /* Bit 1 is reserved */ 2323 w &= ~0x0001; /* Test Mode off */ 2324 2325 outw(w, iobase + WC_CONTROL); 2326 2327 /* Now clear the APU control ram */ 2328 for (i = 0; i < NR_APUS; i++) { 2329 for (w = 0; w < NR_APU_REGS; w++) 2330 apu_set_register(chip, i, w, 0); 2331 2332 } 2333 } 2334 2335 /* Enable IRQ's */ 2336 static void snd_es1968_start_irq(struct es1968 *chip) 2337 { 2338 unsigned short w; 2339 w = ESM_HIRQ_DSIE | ESM_HIRQ_HW_VOLUME; 2340 if (chip->rmidi) 2341 w |= ESM_HIRQ_MPU401; 2342 outw(w, chip->io_port + ESM_PORT_HOST_IRQ); 2343 } 2344 2345 #ifdef CONFIG_PM 2346 /* 2347 * PM support 2348 */ 2349 static int es1968_suspend(struct pci_dev *pci, pm_message_t state) 2350 { 2351 struct snd_card *card = pci_get_drvdata(pci); 2352 struct es1968 *chip = card->private_data; 2353 2354 if (! chip->do_pm) 2355 return 0; 2356 2357 chip->in_suspend = 1; 2358 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); 2359 snd_pcm_suspend_all(chip->pcm); 2360 snd_ac97_suspend(chip->ac97); 2361 snd_es1968_bob_stop(chip); 2362 2363 pci_disable_device(pci); 2364 pci_save_state(pci); 2365 pci_set_power_state(pci, pci_choose_state(pci, state)); 2366 return 0; 2367 } 2368 2369 static int es1968_resume(struct pci_dev *pci) 2370 { 2371 struct snd_card *card = pci_get_drvdata(pci); 2372 struct es1968 *chip = card->private_data; 2373 struct esschan *es; 2374 2375 if (! chip->do_pm) 2376 return 0; 2377 2378 /* restore all our config */ 2379 pci_set_power_state(pci, PCI_D0); 2380 pci_restore_state(pci); 2381 if (pci_enable_device(pci) < 0) { 2382 printk(KERN_ERR "es1968: pci_enable_device failed, " 2383 "disabling device\n"); 2384 snd_card_disconnect(card); 2385 return -EIO; 2386 } 2387 pci_set_master(pci); 2388 2389 snd_es1968_chip_init(chip); 2390 2391 /* need to restore the base pointers.. */ 2392 if (chip->dma.addr) { 2393 /* set PCMBAR */ 2394 wave_set_register(chip, 0x01FC, chip->dma.addr >> 12); 2395 } 2396 2397 snd_es1968_start_irq(chip); 2398 2399 /* restore ac97 state */ 2400 snd_ac97_resume(chip->ac97); 2401 2402 list_for_each_entry(es, &chip->substream_list, list) { 2403 switch (es->mode) { 2404 case ESM_MODE_PLAY: 2405 snd_es1968_playback_setup(chip, es, es->substream->runtime); 2406 break; 2407 case ESM_MODE_CAPTURE: 2408 snd_es1968_capture_setup(chip, es, es->substream->runtime); 2409 break; 2410 } 2411 } 2412 2413 /* start timer again */ 2414 if (chip->bobclient) 2415 snd_es1968_bob_start(chip); 2416 2417 snd_power_change_state(card, SNDRV_CTL_POWER_D0); 2418 chip->in_suspend = 0; 2419 return 0; 2420 } 2421 #endif /* CONFIG_PM */ 2422 2423 #ifdef SUPPORT_JOYSTICK 2424 #define JOYSTICK_ADDR 0x200 2425 static int __devinit snd_es1968_create_gameport(struct es1968 *chip, int dev) 2426 { 2427 struct gameport *gp; 2428 struct resource *r; 2429 u16 val; 2430 2431 if (!joystick[dev]) 2432 return -ENODEV; 2433 2434 r = request_region(JOYSTICK_ADDR, 8, "ES1968 gameport"); 2435 if (!r) 2436 return -EBUSY; 2437 2438 chip->gameport = gp = gameport_allocate_port(); 2439 if (!gp) { 2440 printk(KERN_ERR "es1968: cannot allocate memory for gameport\n"); 2441 release_and_free_resource(r); 2442 return -ENOMEM; 2443 } 2444 2445 pci_read_config_word(chip->pci, ESM_LEGACY_AUDIO_CONTROL, &val); 2446 pci_write_config_word(chip->pci, ESM_LEGACY_AUDIO_CONTROL, val | 0x04); 2447 2448 gameport_set_name(gp, "ES1968 Gameport"); 2449 gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci)); 2450 gameport_set_dev_parent(gp, &chip->pci->dev); 2451 gp->io = JOYSTICK_ADDR; 2452 gameport_set_port_data(gp, r); 2453 2454 gameport_register_port(gp); 2455 2456 return 0; 2457 } 2458 2459 static void snd_es1968_free_gameport(struct es1968 *chip) 2460 { 2461 if (chip->gameport) { 2462 struct resource *r = gameport_get_port_data(chip->gameport); 2463 2464 gameport_unregister_port(chip->gameport); 2465 chip->gameport = NULL; 2466 2467 release_and_free_resource(r); 2468 } 2469 } 2470 #else 2471 static inline int snd_es1968_create_gameport(struct es1968 *chip, int dev) { return -ENOSYS; } 2472 static inline void snd_es1968_free_gameport(struct es1968 *chip) { } 2473 #endif 2474 2475 static int snd_es1968_free(struct es1968 *chip) 2476 { 2477 if (chip->io_port) { 2478 if (chip->irq >= 0) 2479 synchronize_irq(chip->irq); 2480 outw(1, chip->io_port + 0x04); /* clear WP interrupts */ 2481 outw(0, chip->io_port + ESM_PORT_HOST_IRQ); /* disable IRQ */ 2482 } 2483 2484 if (chip->irq >= 0) 2485 free_irq(chip->irq, chip); 2486 snd_es1968_free_gameport(chip); 2487 chip->master_switch = NULL; 2488 chip->master_volume = NULL; 2489 pci_release_regions(chip->pci); 2490 pci_disable_device(chip->pci); 2491 kfree(chip); 2492 return 0; 2493 } 2494 2495 static int snd_es1968_dev_free(struct snd_device *device) 2496 { 2497 struct es1968 *chip = device->device_data; 2498 return snd_es1968_free(chip); 2499 } 2500 2501 struct ess_device_list { 2502 unsigned short type; /* chip type */ 2503 unsigned short vendor; /* subsystem vendor id */ 2504 }; 2505 2506 static struct ess_device_list pm_whitelist[] __devinitdata = { 2507 { TYPE_MAESTRO2E, 0x0e11 }, /* Compaq Armada */ 2508 { TYPE_MAESTRO2E, 0x1028 }, 2509 { TYPE_MAESTRO2E, 0x103c }, 2510 { TYPE_MAESTRO2E, 0x1179 }, 2511 { TYPE_MAESTRO2E, 0x14c0 }, /* HP omnibook 4150 */ 2512 { TYPE_MAESTRO2E, 0x1558 }, 2513 }; 2514 2515 static struct ess_device_list mpu_blacklist[] __devinitdata = { 2516 { TYPE_MAESTRO2, 0x125d }, 2517 }; 2518 2519 static int __devinit snd_es1968_create(struct snd_card *card, 2520 struct pci_dev *pci, 2521 int total_bufsize, 2522 int play_streams, 2523 int capt_streams, 2524 int chip_type, 2525 int do_pm, 2526 struct es1968 **chip_ret) 2527 { 2528 static struct snd_device_ops ops = { 2529 .dev_free = snd_es1968_dev_free, 2530 }; 2531 struct es1968 *chip; 2532 int i, err; 2533 2534 *chip_ret = NULL; 2535 2536 /* enable PCI device */ 2537 if ((err = pci_enable_device(pci)) < 0) 2538 return err; 2539 /* check, if we can restrict PCI DMA transfers to 28 bits */ 2540 if (pci_set_dma_mask(pci, DMA_28BIT_MASK) < 0 || 2541 pci_set_consistent_dma_mask(pci, DMA_28BIT_MASK) < 0) { 2542 snd_printk(KERN_ERR "architecture does not support 28bit PCI busmaster DMA\n"); 2543 pci_disable_device(pci); 2544 return -ENXIO; 2545 } 2546 2547 chip = kzalloc(sizeof(*chip), GFP_KERNEL); 2548 if (! chip) { 2549 pci_disable_device(pci); 2550 return -ENOMEM; 2551 } 2552 2553 /* Set Vars */ 2554 chip->type = chip_type; 2555 spin_lock_init(&chip->reg_lock); 2556 spin_lock_init(&chip->substream_lock); 2557 INIT_LIST_HEAD(&chip->buf_list); 2558 INIT_LIST_HEAD(&chip->substream_list); 2559 spin_lock_init(&chip->ac97_lock); 2560 mutex_init(&chip->memory_mutex); 2561 tasklet_init(&chip->hwvol_tq, es1968_update_hw_volume, (unsigned long)chip); 2562 chip->card = card; 2563 chip->pci = pci; 2564 chip->irq = -1; 2565 chip->total_bufsize = total_bufsize; /* in bytes */ 2566 chip->playback_streams = play_streams; 2567 chip->capture_streams = capt_streams; 2568 2569 if ((err = pci_request_regions(pci, "ESS Maestro")) < 0) { 2570 kfree(chip); 2571 pci_disable_device(pci); 2572 return err; 2573 } 2574 chip->io_port = pci_resource_start(pci, 0); 2575 if (request_irq(pci->irq, snd_es1968_interrupt, IRQF_SHARED, 2576 "ESS Maestro", chip)) { 2577 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); 2578 snd_es1968_free(chip); 2579 return -EBUSY; 2580 } 2581 chip->irq = pci->irq; 2582 2583 /* Clear Maestro_map */ 2584 for (i = 0; i < 32; i++) 2585 chip->maestro_map[i] = 0; 2586 2587 /* Clear Apu Map */ 2588 for (i = 0; i < NR_APUS; i++) 2589 chip->apu[i] = ESM_APU_FREE; 2590 2591 /* just to be sure */ 2592 pci_set_master(pci); 2593 2594 if (do_pm > 1) { 2595 /* disable power-management if not on the whitelist */ 2596 unsigned short vend; 2597 pci_read_config_word(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend); 2598 for (i = 0; i < (int)ARRAY_SIZE(pm_whitelist); i++) { 2599 if (chip->type == pm_whitelist[i].type && 2600 vend == pm_whitelist[i].vendor) { 2601 do_pm = 1; 2602 break; 2603 } 2604 } 2605 if (do_pm > 1) { 2606 /* not matched; disabling pm */ 2607 printk(KERN_INFO "es1968: not attempting power management.\n"); 2608 do_pm = 0; 2609 } 2610 } 2611 chip->do_pm = do_pm; 2612 2613 snd_es1968_chip_init(chip); 2614 2615 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { 2616 snd_es1968_free(chip); 2617 return err; 2618 } 2619 2620 snd_card_set_dev(card, &pci->dev); 2621 2622 *chip_ret = chip; 2623 2624 return 0; 2625 } 2626 2627 2628 /* 2629 */ 2630 static int __devinit snd_es1968_probe(struct pci_dev *pci, 2631 const struct pci_device_id *pci_id) 2632 { 2633 static int dev; 2634 struct snd_card *card; 2635 struct es1968 *chip; 2636 unsigned int i; 2637 int err; 2638 2639 if (dev >= SNDRV_CARDS) 2640 return -ENODEV; 2641 if (!enable[dev]) { 2642 dev++; 2643 return -ENOENT; 2644 } 2645 2646 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); 2647 if (!card) 2648 return -ENOMEM; 2649 2650 if (total_bufsize[dev] < 128) 2651 total_bufsize[dev] = 128; 2652 if (total_bufsize[dev] > 4096) 2653 total_bufsize[dev] = 4096; 2654 if ((err = snd_es1968_create(card, pci, 2655 total_bufsize[dev] * 1024, /* in bytes */ 2656 pcm_substreams_p[dev], 2657 pcm_substreams_c[dev], 2658 pci_id->driver_data, 2659 use_pm[dev], 2660 &chip)) < 0) { 2661 snd_card_free(card); 2662 return err; 2663 } 2664 card->private_data = chip; 2665 2666 switch (chip->type) { 2667 case TYPE_MAESTRO2E: 2668 strcpy(card->driver, "ES1978"); 2669 strcpy(card->shortname, "ESS ES1978 (Maestro 2E)"); 2670 break; 2671 case TYPE_MAESTRO2: 2672 strcpy(card->driver, "ES1968"); 2673 strcpy(card->shortname, "ESS ES1968 (Maestro 2)"); 2674 break; 2675 case TYPE_MAESTRO: 2676 strcpy(card->driver, "ESM1"); 2677 strcpy(card->shortname, "ESS Maestro 1"); 2678 break; 2679 } 2680 2681 if ((err = snd_es1968_pcm(chip, 0)) < 0) { 2682 snd_card_free(card); 2683 return err; 2684 } 2685 2686 if ((err = snd_es1968_mixer(chip)) < 0) { 2687 snd_card_free(card); 2688 return err; 2689 } 2690 2691 if (enable_mpu[dev] == 2) { 2692 /* check the black list */ 2693 unsigned short vend; 2694 pci_read_config_word(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend); 2695 for (i = 0; i < ARRAY_SIZE(mpu_blacklist); i++) { 2696 if (chip->type == mpu_blacklist[i].type && 2697 vend == mpu_blacklist[i].vendor) { 2698 enable_mpu[dev] = 0; 2699 break; 2700 } 2701 } 2702 } 2703 if (enable_mpu[dev]) { 2704 if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401, 2705 chip->io_port + ESM_MPU401_PORT, 2706 MPU401_INFO_INTEGRATED, 2707 chip->irq, 0, &chip->rmidi)) < 0) { 2708 printk(KERN_WARNING "es1968: skipping MPU-401 MIDI support..\n"); 2709 } 2710 } 2711 2712 snd_es1968_create_gameport(chip, dev); 2713 2714 snd_es1968_start_irq(chip); 2715 2716 chip->clock = clock[dev]; 2717 if (! chip->clock) 2718 es1968_measure_clock(chip); 2719 2720 sprintf(card->longname, "%s at 0x%lx, irq %i", 2721 card->shortname, chip->io_port, chip->irq); 2722 2723 if ((err = snd_card_register(card)) < 0) { 2724 snd_card_free(card); 2725 return err; 2726 } 2727 pci_set_drvdata(pci, card); 2728 dev++; 2729 return 0; 2730 } 2731 2732 static void __devexit snd_es1968_remove(struct pci_dev *pci) 2733 { 2734 snd_card_free(pci_get_drvdata(pci)); 2735 pci_set_drvdata(pci, NULL); 2736 } 2737 2738 static struct pci_driver driver = { 2739 .name = "ES1968 (ESS Maestro)", 2740 .id_table = snd_es1968_ids, 2741 .probe = snd_es1968_probe, 2742 .remove = __devexit_p(snd_es1968_remove), 2743 #ifdef CONFIG_PM 2744 .suspend = es1968_suspend, 2745 .resume = es1968_resume, 2746 #endif 2747 }; 2748 2749 static int __init alsa_card_es1968_init(void) 2750 { 2751 return pci_register_driver(&driver); 2752 } 2753 2754 static void __exit alsa_card_es1968_exit(void) 2755 { 2756 pci_unregister_driver(&driver); 2757 } 2758 2759 module_init(alsa_card_es1968_init) 2760 module_exit(alsa_card_es1968_exit) 2761