esm.c revision 1.2
1 /* $NetBSD: esm.c,v 1.2 2001/01/09 06:36:13 lukem Exp $ */ 2 3 /*- 4 * Copyright (c) 2000, 2001 Rene Hexel <rh (at) netbsd.org> 5 * All rights reserved. 6 * 7 * Copyright (c) 2000 Taku YAMAMOTO <taku (at) cent.saitama-u.ac.jp> 8 * All rights reserved. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 * Taku Id: maestro.c,v 1.12 2000/09/06 03:32:34 taku Exp 32 * FreeBSD: /c/ncvs/src/sys/dev/sound/pci/maestro.c,v 1.4 2000/12/18 01:36:35 cg Exp 33 */ 34 35 /* 36 * TODO: 37 * - hardware volume support 38 * - recording 39 * - MIDI support 40 * - joystick support 41 * - power management hooks 42 * 43 * 44 * Credits: 45 * 46 * This code is based on the FreeBSD driver written by Taku YAMAMOTO 47 * 48 * 49 * Original credits from the FreeBSD driver: 50 * 51 * Part of this code (especially in many magic numbers) was heavily inspired 52 * by the Linux driver originally written by 53 * Alan Cox <alan.cox (at) linux.org>, modified heavily by 54 * Zach Brown <zab (at) zabbo.net>. 55 * 56 * busdma()-ize and buffer size reduction were suggested by 57 * Cameron Grant <gandalf (at) vilnya.demon.co.uk>. 58 * Also he showed me the way to use busdma() suite. 59 * 60 * Internal speaker problems on NEC VersaPro's and Dell Inspiron 7500 61 * were looked at by 62 * Munehiro Matsuda <haro (at) tk.kubota.co.jp>, 63 * who brought patches based on the Linux driver with some simplification. 64 */ 65 66 #include <sys/param.h> 67 #include <sys/systm.h> 68 #include <sys/kernel.h> 69 #include <sys/malloc.h> 70 #include <sys/device.h> 71 72 #include <machine/bus.h> 73 74 #include <sys/audioio.h> 75 #include <dev/audio_if.h> 76 #include <dev/mulaw.h> 77 #include <dev/auconv.h> 78 #include <dev/ic/ac97var.h> 79 80 #include <dev/pci/pcidevs.h> 81 #include <dev/pci/pcivar.h> 82 83 #include <dev/pci/esmreg.h> 84 #include <dev/pci/esmvar.h> 85 86 #define PCI_CBIO 0x10 /* Configuration Base I/O Address */ 87 88 /* Debug */ 89 #ifdef AUDIO_DEBUG 90 #define DPRINTF(l,x) do { if (esm_debug & (l)) printf x; } while(0) 91 #define DUMPREG(x) do { if (esm_debug & ESM_DEBUG_REG) \ 92 esm_dump_regs(x); } while(0) 93 int esm_debug = 0xfffc; 94 #define ESM_DEBUG_CODECIO 0x0001 95 #define ESM_DEBUG_IRQ 0x0002 96 #define ESM_DEBUG_DMA 0x0004 97 #define ESM_DEBUG_TIMER 0x0008 98 #define ESM_DEBUG_REG 0x0010 99 #define ESM_DEBUG_PARAM 0x0020 100 #define ESM_DEBUG_APU 0x0040 101 #define ESM_DEBUG_CODEC 0x0080 102 #else 103 #define DPRINTF(x,y) /* nothing */ 104 #define DUMPREG(x) /* nothing */ 105 #endif 106 107 #ifdef DIAGNOSTIC 108 #define RANGE(n, l, h) if ((n) < (l) || (n) >= (h)) \ 109 printf (#n "=%d out of range (%d, %d) in " \ 110 __FILE__ ", line %d\n", (n), (l), (h), __LINE__) 111 #else 112 #define RANGE(x,y,z) /* nothing */ 113 #endif 114 115 #define inline __inline 116 117 static inline void ringbus_setdest(struct esm_softc *, int, int); 118 119 static inline u_int16_t wp_rdreg(struct esm_softc *, u_int16_t); 120 static inline void wp_wrreg(struct esm_softc *, u_int16_t, u_int16_t); 121 static inline u_int16_t wp_rdapu(struct esm_softc *, int, u_int16_t); 122 static inline void wp_wrapu(struct esm_softc *, int, u_int16_t, 123 u_int16_t); 124 static inline void wp_settimer(struct esm_softc *, u_int); 125 static inline void wp_starttimer(struct esm_softc *); 126 static inline void wp_stoptimer(struct esm_softc *); 127 128 static inline u_int16_t wc_rdreg(struct esm_softc *, u_int16_t); 129 static inline void wc_wrreg(struct esm_softc *, u_int16_t, u_int16_t); 130 static inline u_int16_t wc_rdchctl(struct esm_softc *, int); 131 static inline void wc_wrchctl(struct esm_softc *, int, u_int16_t); 132 133 static inline u_int calc_timer_freq(struct esm_chinfo*); 134 static void set_timer(struct esm_softc *); 135 136 static void esmch_set_format(struct esm_chinfo *, 137 struct audio_params *p); 138 139 struct cfattach esm_ca = { 140 sizeof(struct esm_softc), esm_match, esm_attach 141 }; 142 143 struct audio_hw_if esm_hw_if = { 144 esm_open, 145 esm_close, 146 NULL, /* drain */ 147 esm_query_encoding, 148 esm_set_params, 149 esm_round_blocksize, 150 NULL, /* commit_settings */ 151 esm_init_output, 152 NULL, /* init_input */ 153 NULL, /* start_output */ 154 NULL, /* start_input */ 155 esm_halt_output, 156 esm_halt_input, 157 NULL, /* speaker_ctl */ 158 esm_getdev, 159 NULL, /* getfd */ 160 esm_set_port, 161 esm_get_port, 162 esm_query_devinfo, 163 esm_malloc, 164 esm_free, 165 esm_round_buffersize, 166 esm_mappage, 167 esm_get_props, 168 esm_trigger_output, 169 esm_trigger_input 170 }; 171 172 struct audio_device esm_device = { 173 "ESS Maestro", 174 "", 175 "esm" 176 }; 177 178 179 static audio_encoding_t esm_encoding[] = { 180 { 0, AudioEulinear, AUDIO_ENCODING_ULINEAR, 8, 0 }, 181 { 1, AudioEmulaw, AUDIO_ENCODING_ULAW, 8, 182 AUDIO_ENCODINGFLAG_EMULATED }, 183 { 2, AudioEalaw, AUDIO_ENCODING_ALAW, 8, AUDIO_ENCODINGFLAG_EMULATED }, 184 { 3, AudioEslinear, AUDIO_ENCODING_SLINEAR, 8, 0 }, 185 { 4, AudioEslinear_le, AUDIO_ENCODING_SLINEAR_LE, 16, 0 }, 186 { 5, AudioEulinear_le, AUDIO_ENCODING_ULINEAR_LE, 16, 187 AUDIO_ENCODINGFLAG_EMULATED }, 188 { 6, AudioEslinear_be, AUDIO_ENCODING_SLINEAR_BE, 16, 189 AUDIO_ENCODINGFLAG_EMULATED }, 190 { 7, AudioEulinear_be, AUDIO_ENCODING_ULINEAR_BE, 16, 191 AUDIO_ENCODINGFLAG_EMULATED }, 192 }; 193 194 #define MAESTRO_NENCODINGS 8 195 196 #ifdef AUDIO_DEBUG 197 struct esm_reg_info { 198 int offset; /* register offset */ 199 int width; /* 1/2/4 bytes */ 200 } dump_regs[] = { 201 { PORT_WAVCACHE_CTRL, 2 }, 202 { PORT_HOSTINT_CTRL, 2 }, 203 { PORT_HOSTINT_STAT, 2 }, 204 { PORT_HWVOL_VOICE_SHADOW, 1 }, 205 { PORT_HWVOL_VOICE, 1 }, 206 { PORT_HWVOL_MASTER_SHADOW, 1 }, 207 { PORT_HWVOL_MASTER, 1 }, 208 { PORT_RINGBUS_CTRL, 4 }, 209 { PORT_GPIO_DATA, 2 }, 210 { PORT_GPIO_MASK, 2 }, 211 { PORT_GPIO_DIR, 2 }, 212 { PORT_ASSP_CTRL_A, 1 }, 213 { PORT_ASSP_CTRL_B, 1 }, 214 { PORT_ASSP_CTRL_C, 1 }, 215 { PORT_ASSP_INT_STAT, 1 }, 216 { -1, -1 } 217 }; 218 219 static void 220 esm_dump_regs(struct esm_softc *ess) 221 { 222 int i = 0; 223 224 printf("%s registers:", ess->sc_dev.dv_xname); 225 while (dump_regs[i].offset != -1) { 226 if (i % 5 == 0) 227 printf("\n"); 228 printf("0x%2.2x: ", dump_regs[i].offset); 229 switch(dump_regs[i].width) { 230 case 4: 231 printf("%8.8x, ", bus_space_read_4(ess->st, ess->sh, 232 dump_regs[i].offset)); 233 break; 234 case 2: 235 printf("%4.4x, ", bus_space_read_2(ess->st, ess->sh, 236 dump_regs[i].offset)); 237 break; 238 default: 239 printf("%2.2x, ", 240 bus_space_read_1(ess->st, ess->sh, 241 dump_regs[i].offset)); 242 } 243 i++; 244 } 245 printf("\n"); 246 } 247 #endif 248 249 /* ----------------------------- 250 * Subsystems. 251 */ 252 253 /* Codec/Ringbus */ 254 255 /* -------------------------------------------------------------------- */ 256 257 int 258 esm_read_codec(void *sc, u_int8_t regno, u_int16_t *result) 259 { 260 struct esm_softc *ess = sc; 261 unsigned t; 262 263 /* We have to wait for a SAFE time to write addr/data */ 264 for (t = 0; t < 20; t++) { 265 if ((bus_space_read_1(ess->st, ess->sh, PORT_CODEC_STAT) 266 & CODEC_STAT_MASK) != CODEC_STAT_PROGLESS) 267 break; 268 delay(2); /* 20.8us / 13 */ 269 } 270 if (t == 20) 271 printf("%s: esm_read_codec() PROGLESS timed out.\n", 272 ess->sc_dev.dv_xname); 273 274 bus_space_write_1(ess->st, ess->sh, PORT_CODEC_CMD, 275 CODEC_CMD_READ | regno); 276 delay(21); /* AC97 cycle = 20.8usec */ 277 278 /* Wait for data retrieve */ 279 for (t = 0; t < 20; t++) { 280 if ((bus_space_read_1(ess->st, ess->sh, PORT_CODEC_STAT) 281 & CODEC_STAT_MASK) == CODEC_STAT_RW_DONE) 282 break; 283 delay(2); /* 20.8us / 13 */ 284 } 285 if (t == 20) 286 /* Timed out, but perform dummy read. */ 287 printf("%s: esm_read_codec() RW_DONE timed out.\n", 288 ess->sc_dev.dv_xname); 289 290 *result = bus_space_read_2(ess->st, ess->sh, PORT_CODEC_REG); 291 292 return 0; 293 } 294 295 int 296 esm_write_codec(void *sc, u_int8_t regno, u_int16_t data) 297 { 298 struct esm_softc *ess = sc; 299 unsigned t; 300 301 /* We have to wait for a SAFE time to write addr/data */ 302 for (t = 0; t < 20; t++) { 303 if ((bus_space_read_1(ess->st, ess->sh, PORT_CODEC_STAT) 304 & CODEC_STAT_MASK) != CODEC_STAT_PROGLESS) 305 break; 306 delay(2); /* 20.8us / 13 */ 307 } 308 if (t == 20) { 309 /* Timed out. Abort writing. */ 310 printf("%s: esm_write_codec() PROGLESS timed out.\n", 311 ess->sc_dev.dv_xname); 312 return -1; 313 } 314 315 bus_space_write_2(ess->st, ess->sh, PORT_CODEC_REG, data); 316 bus_space_write_1(ess->st, ess->sh, PORT_CODEC_CMD, 317 CODEC_CMD_WRITE | regno); 318 319 return 0; 320 } 321 322 /* -------------------------------------------------------------------- */ 323 324 static inline void 325 ringbus_setdest(struct esm_softc *ess, int src, int dest) 326 { 327 u_int32_t data; 328 329 data = bus_space_read_4(ess->st, ess->sh, PORT_RINGBUS_CTRL); 330 data &= ~(0xfU << src); 331 data |= (0xfU & dest) << src; 332 bus_space_write_4(ess->st, ess->sh, PORT_RINGBUS_CTRL, data); 333 } 334 335 /* Wave Processor */ 336 337 static inline u_int16_t 338 wp_rdreg(struct esm_softc *ess, u_int16_t reg) 339 { 340 bus_space_write_2(ess->st, ess->sh, PORT_DSP_INDEX, reg); 341 return bus_space_read_2(ess->st, ess->sh, PORT_DSP_DATA); 342 } 343 344 static inline void 345 wp_wrreg(struct esm_softc *ess, u_int16_t reg, u_int16_t data) 346 { 347 bus_space_write_2(ess->st, ess->sh, PORT_DSP_INDEX, reg); 348 bus_space_write_2(ess->st, ess->sh, PORT_DSP_DATA, data); 349 } 350 351 static inline void 352 apu_setindex(struct esm_softc *ess, u_int16_t reg) 353 { 354 int t; 355 356 wp_wrreg(ess, WPREG_CRAM_PTR, reg); 357 /* Sometimes WP fails to set apu register index. */ 358 for (t = 0; t < 1000; t++) { 359 if (bus_space_read_2(ess->st, ess->sh, PORT_DSP_DATA) == reg) 360 break; 361 bus_space_write_2(ess->st, ess->sh, PORT_DSP_DATA, reg); 362 } 363 if (t == 1000) 364 printf("%s: apu_setindex() timed out.\n", ess->sc_dev.dv_xname); 365 } 366 367 static inline u_int16_t 368 wp_rdapu(struct esm_softc *ess, int ch, u_int16_t reg) 369 { 370 u_int16_t ret; 371 372 apu_setindex(ess, ((unsigned)ch << 4) + reg); 373 ret = wp_rdreg(ess, WPREG_DATA_PORT); 374 return ret; 375 } 376 377 static inline void 378 wp_wrapu(struct esm_softc *ess, int ch, u_int16_t reg, u_int16_t data) 379 { 380 int t; 381 382 DPRINTF(ESM_DEBUG_APU, 383 ("wp_wrapu(%p, ch=%d, reg=0x%x, data=0x%04x)\n", 384 ess, ch, reg, data)); 385 386 apu_setindex(ess, ((unsigned)ch << 4) + reg); 387 wp_wrreg(ess, WPREG_DATA_PORT, data); 388 for (t = 0; t < 1000; t++) { 389 if (bus_space_read_2(ess->st, ess->sh, PORT_DSP_DATA) == data) 390 break; 391 bus_space_write_2(ess->st, ess->sh, PORT_DSP_DATA, data); 392 } 393 if (t == 1000) 394 printf("%s: wp_wrapu() timed out.\n", ess->sc_dev.dv_xname); 395 } 396 397 static inline void 398 wp_settimer(struct esm_softc *ess, u_int freq) 399 { 400 u_int clock = 48000 << 2; 401 u_int prescale = 0, divide = (freq != 0) ? (clock / freq) : ~0; 402 403 RANGE(divide, WPTIMER_MINDIV, WPTIMER_MAXDIV); 404 405 for (; divide > 32 << 1; divide >>= 1) 406 prescale++; 407 divide = (divide + 1) >> 1; 408 409 for (; prescale < 7 && divide > 2 && !(divide & 1); divide >>= 1) 410 prescale++; 411 412 DPRINTF(ESM_DEBUG_TIMER, 413 ("wp_settimer(%p, %u): clock = %u, prescale = %u, divide = %u\n", 414 ess, freq, clock, prescale, divide)); 415 416 wp_wrreg(ess, WPREG_TIMER_ENABLE, 0); 417 wp_wrreg(ess, WPREG_TIMER_FREQ, 418 (prescale << WP_TIMER_FREQ_PRESCALE_SHIFT) | (divide - 1)); 419 wp_wrreg(ess, WPREG_TIMER_ENABLE, 1); 420 } 421 422 static inline void 423 wp_starttimer(struct esm_softc *ess) 424 { 425 wp_wrreg(ess, WPREG_TIMER_START, 1); 426 } 427 428 static inline void 429 wp_stoptimer(struct esm_softc *ess) 430 { 431 wp_wrreg(ess, WPREG_TIMER_START, 0); 432 bus_space_write_2(ess->st, ess->sh, PORT_INT_STAT, 1); 433 } 434 435 /* WaveCache */ 436 437 static inline u_int16_t 438 wc_rdreg(struct esm_softc *ess, u_int16_t reg) 439 { 440 bus_space_write_2(ess->st, ess->sh, PORT_WAVCACHE_INDEX, reg); 441 return bus_space_read_2(ess->st, ess->sh, PORT_WAVCACHE_DATA); 442 } 443 444 static inline void 445 wc_wrreg(struct esm_softc *ess, u_int16_t reg, u_int16_t data) 446 { 447 bus_space_write_2(ess->st, ess->sh, PORT_WAVCACHE_INDEX, reg); 448 bus_space_write_2(ess->st, ess->sh, PORT_WAVCACHE_DATA, data); 449 } 450 451 static inline u_int16_t 452 wc_rdchctl(struct esm_softc *ess, int ch) 453 { 454 return wc_rdreg(ess, ch << 3); 455 } 456 457 static inline void 458 wc_wrchctl(struct esm_softc *ess, int ch, u_int16_t data) 459 { 460 wc_wrreg(ess, ch << 3, data); 461 } 462 463 /* Power management */ 464 465 void 466 esm_power(struct esm_softc *ess, int status) 467 { 468 u_int8_t data; 469 470 data = pci_conf_read(ess->pc, ess->tag, CONF_PM_PTR); 471 if ((pci_conf_read(ess->pc, ess->tag, data) & 0xff) == PPMI_CID) 472 pci_conf_write(ess->pc, ess->tag, data + PM_CTRL, status); 473 } 474 475 476 /* ----------------------------- 477 * Controller. 478 */ 479 480 int 481 esm_attach_codec(void *sc, struct ac97_codec_if *codec_if) 482 { 483 struct esm_softc *ess = sc; 484 485 ess->codec_if = codec_if; 486 487 return 0; 488 } 489 490 void 491 esm_reset_codec(void *sc) 492 { 493 } 494 495 496 void 497 esm_initcodec(struct esm_softc *ess) 498 { 499 u_int16_t data; 500 501 DPRINTF(ESM_DEBUG_CODEC, ("esm_initcodec(%p)\n", ess)); 502 503 if (bus_space_read_4(ess->st, ess->sh, PORT_RINGBUS_CTRL) 504 & RINGBUS_CTRL_ACLINK_ENABLED) { 505 bus_space_write_4(ess->st, ess->sh, PORT_RINGBUS_CTRL, 0); 506 delay(104); /* 20.8us * (4 + 1) */ 507 } 508 /* XXX - 2nd codec should be looked at. */ 509 bus_space_write_4(ess->st, ess->sh, PORT_RINGBUS_CTRL, 510 RINGBUS_CTRL_AC97_SWRESET); 511 delay(2); 512 bus_space_write_4(ess->st, ess->sh, PORT_RINGBUS_CTRL, 513 RINGBUS_CTRL_ACLINK_ENABLED); 514 delay(21); 515 516 esm_read_codec(ess, 0, &data); 517 if (bus_space_read_1(ess->st, ess->sh, PORT_CODEC_STAT) 518 & CODEC_STAT_MASK) { 519 bus_space_write_4(ess->st, ess->sh, PORT_RINGBUS_CTRL, 0); 520 delay(21); 521 522 /* Try cold reset. */ 523 printf("%s: will perform cold reset.\n", ess->sc_dev.dv_xname); 524 data = bus_space_read_2(ess->st, ess->sh, PORT_GPIO_DIR); 525 if (pci_conf_read(ess->pc, ess->tag, 0x58) & 1) 526 data |= 0x10; 527 data |= 0x009 & 528 ~bus_space_read_2(ess->st, ess->sh, PORT_GPIO_DATA); 529 bus_space_write_2(ess->st, ess->sh, PORT_GPIO_MASK, 0xff6); 530 bus_space_write_2(ess->st, ess->sh, PORT_GPIO_DIR, 531 data | 0x009); 532 bus_space_write_2(ess->st, ess->sh, PORT_GPIO_DATA, 0x000); 533 delay(2); 534 bus_space_write_2(ess->st, ess->sh, PORT_GPIO_DATA, 0x001); 535 delay(1); 536 bus_space_write_2(ess->st, ess->sh, PORT_GPIO_DATA, 0x009); 537 delay(500000); 538 bus_space_write_2(ess->st, ess->sh, PORT_GPIO_DIR, data); 539 delay(84); /* 20.8us * 4 */ 540 bus_space_write_4(ess->st, ess->sh, PORT_RINGBUS_CTRL, 541 RINGBUS_CTRL_ACLINK_ENABLED); 542 delay(21); 543 } 544 } 545 546 void 547 esm_init(struct esm_softc *ess) 548 { 549 /* Reset direct sound. */ 550 bus_space_write_2(ess->st, ess->sh, PORT_HOSTINT_CTRL, 551 HOSTINT_CTRL_DSOUND_RESET); 552 delay(10000); 553 bus_space_write_2(ess->st, ess->sh, PORT_HOSTINT_CTRL, 0); 554 delay(10000); 555 556 /* Enable direct sound interruption. */ 557 bus_space_write_2(ess->st, ess->sh, PORT_HOSTINT_CTRL, 558 HOSTINT_CTRL_DSOUND_INT_ENABLED); 559 560 /* Setup Wave Processor. */ 561 562 /* Enable WaveCache */ 563 wp_wrreg(ess, WPREG_WAVE_ROMRAM, 564 WP_WAVE_VIRTUAL_ENABLED | WP_WAVE_DRAM_ENABLED); 565 bus_space_write_2(ess->st, ess->sh, PORT_WAVCACHE_CTRL, 566 WAVCACHE_ENABLED | WAVCACHE_WTSIZE_4MB); 567 568 /* Setup Codec/Ringbus. */ 569 esm_initcodec(ess); 570 bus_space_write_4(ess->st, ess->sh, PORT_RINGBUS_CTRL, 571 RINGBUS_CTRL_RINGBUS_ENABLED | RINGBUS_CTRL_ACLINK_ENABLED); 572 573 wp_wrreg(ess, WPREG_BASE, 0x8500); /* Parallel I/O */ 574 ringbus_setdest(ess, RINGBUS_SRC_ADC, 575 RINGBUS_DEST_STEREO | RINGBUS_DEST_DSOUND_IN); 576 ringbus_setdest(ess, RINGBUS_SRC_DSOUND, 577 RINGBUS_DEST_STEREO | RINGBUS_DEST_DAC); 578 579 /* Setup ASSP. Needed for Dell Inspiron 7500? */ 580 bus_space_write_1(ess->st, ess->sh, PORT_ASSP_CTRL_B, 0x00); 581 bus_space_write_1(ess->st, ess->sh, PORT_ASSP_CTRL_A, 0x03); 582 bus_space_write_1(ess->st, ess->sh, PORT_ASSP_CTRL_C, 0x00); 583 584 /* 585 * Setup GPIO. 586 * There seems to be speciality with NEC systems. 587 */ 588 switch (PCI_VENDOR(ess->subid)) { 589 case PCI_VENDOR_NEC: 590 switch (PCI_PRODUCT(ess->subid)) { 591 case PCI_PRODUCT_NEC_VERSALX: 592 case PCI_PRODUCT_NEC_VA26D: 593 /* Matthew Braithwaite <matt (at) braithwaite.net> reported 594 * that NEC Versa LX doesn't need GPIO operation. */ 595 bus_space_write_2(ess->st, ess->sh, PORT_GPIO_MASK, 596 0x9ff); 597 bus_space_write_2(ess->st, ess->sh, PORT_GPIO_DIR, 598 bus_space_read_2(ess->st, ess->sh, PORT_GPIO_DIR) | 599 0x600); 600 bus_space_write_2(ess->st, ess->sh, PORT_GPIO_DATA, 601 0x200); 602 break; 603 } 604 break; 605 } 606 607 DUMPREG(ess); 608 } 609 610 611 /* Channel controller. */ 612 613 int 614 esm_init_output (void *sc, void *start, int size) 615 { 616 struct esm_softc *ess = sc; 617 struct esm_dma *p; 618 u_int32_t data; 619 620 for (p = ess->sc_dmas; p && KERNADDR(p) != start; p = p->next) 621 ; 622 if (!p) { 623 printf("%s: esm_init_output: bad addr %p\n", 624 ess->sc_dev.dv_xname, start); 625 return EINVAL; 626 } 627 628 ess->pch.base = DMAADDR(p) & ~0xFFF; 629 630 DPRINTF(ESM_DEBUG_DMA, ("%s: pch.base = 0x%x\n", 631 ess->sc_dev.dv_xname, ess->pch.base)); 632 633 /* set DMA base address */ 634 for (data = WAVCACHE_PCMBAR; data < WAVCACHE_PCMBAR + 4; data++) 635 wc_wrreg(ess, data, ess->pch.base >> WAVCACHE_BASEADDR_SHIFT); 636 637 return 0; 638 } 639 640 641 int 642 esm_trigger_output(void *sc, void *start, void *end, int blksize, 643 void (*intr)(void *), void *arg, struct audio_params *param) 644 { 645 struct esm_softc *ess = sc; 646 struct esm_chinfo *ch = &ess->pch; 647 struct esm_dma *p; 648 int pan = 0, choffset; 649 unsigned speed = ch->sample_rate, offset, wpwa, dv; 650 size_t size; 651 u_int16_t apuch = ch->num << 1; 652 653 DPRINTF(ESM_DEBUG_DMA, 654 ("esm_trigger_output(%p, %p, %p, 0x%x, %p, %p, %p)\n", 655 sc, start, end, blksize, intr, arg, param)); 656 657 #ifdef DIAGNOSTIC 658 if (ess->pactive) { 659 printf("%s: esm_trigger_output: already running", 660 ess->sc_dev.dv_xname); 661 return EINVAL; 662 } 663 #endif 664 665 ess->sc_pintr = intr; 666 ess->sc_parg = arg; 667 for (p = ess->sc_dmas; p && KERNADDR(p) != start; p = p->next) 668 ; 669 if (!p) { 670 printf("%s: esm_trigger_output: bad addr %p\n", 671 ess->sc_dev.dv_xname, start); 672 return EINVAL; 673 } 674 675 ess->pch.blocksize = blksize; 676 ess->pch.apublk = blksize >> 1; 677 ess->pactive = 1; 678 679 size = (size_t)(((caddr_t)end - (caddr_t)start) >> 1); 680 choffset = DMAADDR(p) - ess->pch.base; 681 offset = choffset >> 1; 682 wpwa = APU_USE_SYSMEM | (offset >> 9); 683 684 DPRINTF(ESM_DEBUG_DMA, 685 ("choffs=0x%x, wpwa=0x%x, size=0x%x words\n", 686 choffset, wpwa, size)); 687 688 switch (ch->aputype) { 689 case APUTYPE_16BITSTEREO: 690 ess->pch.apublk >>= 1; 691 wpwa >>= 1; 692 size >>= 1; 693 offset >>= 1; 694 /* FALLTHROUGH */ 695 case APUTYPE_8BITSTEREO: 696 pan = 8; 697 apuch++; 698 break; 699 case APUTYPE_8BITLINEAR: 700 ess->pch.apublk <<= 1; 701 speed >>= 1; 702 break; 703 } 704 705 ess->pch.apubuf = size; 706 ess->pch.nextirq = ess->pch.apublk; 707 708 set_timer(ess); 709 wp_starttimer(ess); 710 711 dv = (((speed % 48000) << 16) + 24000) / 48000 712 + ((speed / 48000) << 16); 713 714 do { 715 wp_wrapu(ess, apuch, APUREG_WAVESPACE, wpwa & 0xff00); 716 wp_wrapu(ess, apuch, APUREG_CURPTR, offset); 717 wp_wrapu(ess, apuch, APUREG_ENDPTR, offset + size); 718 wp_wrapu(ess, apuch, APUREG_LOOPLEN, size - 1); 719 wp_wrapu(ess, apuch, APUREG_AMPLITUDE, 0xe800); 720 wp_wrapu(ess, apuch, APUREG_POSITION, 0x8f00 721 | (RADIUS_CENTERCIRCLE << APU_RADIUS_SHIFT) 722 | ((PAN_FRONT + pan) << APU_PAN_SHIFT)); 723 wp_wrapu(ess, apuch, APUREG_FREQ_LOBYTE, APU_plus6dB 724 | ((dv & 0xff) << APU_FREQ_LOBYTE_SHIFT)); 725 wp_wrapu(ess, apuch, APUREG_FREQ_HIWORD, dv >> 8); 726 727 if (ch->aputype == APUTYPE_16BITSTEREO) 728 wpwa |= APU_STEREO >> 1; 729 pan = -pan; 730 } while (pan < 0 && apuch--); 731 732 wc_wrchctl(ess, apuch, ch->wcreg_tpl); 733 wc_wrchctl(ess, apuch + 1, ch->wcreg_tpl); 734 735 wp_wrapu(ess, apuch, APUREG_APUTYPE, 736 (ch->aputype << APU_APUTYPE_SHIFT) | APU_DMA_ENABLED | 0xf); 737 if (ch->wcreg_tpl & WAVCACHE_CHCTL_STEREO) 738 wp_wrapu(ess, apuch + 1, APUREG_APUTYPE, 739 (ch->aputype << APU_APUTYPE_SHIFT) | APU_DMA_ENABLED | 0xf); 740 741 return 0; 742 } 743 744 745 int 746 esm_trigger_input(void *sc, void *start, void *end, int blksize, 747 void (*intr)(void *), void *arg, struct audio_params *param) 748 { 749 return 0; 750 } 751 752 753 int 754 esm_halt_output(void *sc) 755 { 756 struct esm_softc *ess = sc; 757 struct esm_chinfo *ch = &ess->pch; 758 759 DPRINTF(ESM_DEBUG_PARAM, ("esm_halt_output(%p)\n", sc)); 760 761 wp_wrapu(ess, (ch->num << 1), APUREG_APUTYPE, 762 APUTYPE_INACTIVE << APU_APUTYPE_SHIFT); 763 wp_wrapu(ess, (ch->num << 1) + 1, APUREG_APUTYPE, 764 APUTYPE_INACTIVE << APU_APUTYPE_SHIFT); 765 766 ess->pactive = 0; 767 if (!ess->ractive) 768 wp_stoptimer(ess); 769 770 return 0; 771 } 772 773 774 int 775 esm_halt_input(void *sc) 776 { 777 return 0; 778 } 779 780 781 static inline u_int 782 calc_timer_freq(struct esm_chinfo *ch) 783 { 784 u_int freq; 785 786 freq = (ch->sample_rate + ch->apublk - 1) / ch->apublk; 787 788 DPRINTF(ESM_DEBUG_TIMER, 789 ("calc_timer_freq(%p): rate = %u, blk = 0x%x (0x%x): freq = %u\n", 790 ch, ch->sample_rate, ch->apublk, ch->blocksize, freq)); 791 792 return freq; 793 } 794 795 static void 796 set_timer(struct esm_softc *ess) 797 { 798 unsigned freq = 0, freq2; 799 800 if (ess->pactive) 801 freq = calc_timer_freq(&ess->pch); 802 803 if (ess->ractive) { 804 freq2 = calc_timer_freq(&ess->rch); 805 if (freq2 < freq) 806 freq = freq2; 807 } 808 809 for (; freq < MAESTRO_MINFREQ; freq <<= 1) 810 ; 811 812 if (freq > 0) 813 wp_settimer(ess, freq); 814 } 815 816 817 static void 818 esmch_set_format(struct esm_chinfo *ch, struct audio_params *p) 819 { 820 u_int16_t wcreg_tpl = (ch->base - 16) & WAVCACHE_CHCTL_ADDRTAG_MASK; 821 u_int16_t aputype = APUTYPE_16BITLINEAR; 822 823 if (p->channels == 2) { 824 wcreg_tpl |= WAVCACHE_CHCTL_STEREO; 825 aputype++; 826 } 827 if (p->precision * p->factor == 8) { 828 aputype += 2; 829 if (p->encoding == AUDIO_ENCODING_ULINEAR) 830 wcreg_tpl |= WAVCACHE_CHCTL_U8; 831 } 832 ch->wcreg_tpl = wcreg_tpl; 833 ch->aputype = aputype; 834 ch->sample_rate = p->sample_rate; 835 836 DPRINTF(ESM_DEBUG_PARAM, ("esmch_set_format: " 837 "numch=%d, prec=%d*%d, tpl=0x%x, aputype=%d, rate=%ld\n", 838 p->channels, p->precision, p->factor, wcreg_tpl, aputype, 839 p->sample_rate)); 840 } 841 842 843 /* 844 * Audio interface glue functions 845 */ 846 847 int 848 esm_open(void *sc, int flags) 849 { 850 DPRINTF(ESM_DEBUG_PARAM, ("esm_open(%p, 0x%x)\n", sc, flags)); 851 852 return 0; 853 } 854 855 856 void 857 esm_close(void *sc) 858 { 859 DPRINTF(ESM_DEBUG_PARAM, ("esm_close(%p)\n", sc)); 860 } 861 862 863 int 864 esm_getdev (void *sc, struct audio_device *adp) 865 { 866 *adp = esm_device; 867 return 0; 868 } 869 870 871 int 872 esm_round_blocksize (void *sc, int blk) 873 { 874 DPRINTF(ESM_DEBUG_PARAM, 875 ("esm_round_blocksize(%p, 0x%x)", sc, blk)); 876 877 blk &= ~0x3f; /* keep good alignment */ 878 879 DPRINTF(ESM_DEBUG_PARAM, (" = 0x%x\n", blk)); 880 881 return blk; 882 } 883 884 885 int 886 esm_query_encoding(void *sc, struct audio_encoding *fp) 887 { 888 DPRINTF(ESM_DEBUG_PARAM, 889 ("esm_query_encoding(%p, %d)\n", sc, fp->index)); 890 891 if (fp->index < 0 || fp->index >= MAESTRO_NENCODINGS) 892 return EINVAL; 893 894 *fp = esm_encoding[fp->index]; 895 return 0; 896 } 897 898 899 int 900 esm_set_params(void *sc, int setmode, int usemode, 901 struct audio_params *play, struct audio_params *rec) 902 { 903 struct esm_softc *ess = sc; 904 struct audio_params *p; 905 int mode; 906 907 DPRINTF(ESM_DEBUG_PARAM, 908 ("esm_set_params(%p, 0x%x, 0x%x, %p, %p)\n", 909 sc, setmode, usemode, play, rec)); 910 911 for (mode = AUMODE_RECORD; mode != -1; 912 mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) { 913 if ((setmode & mode) == 0) 914 continue; 915 916 p = mode == AUMODE_PLAY ? play : rec; 917 918 if (p->sample_rate < 4000 || p->sample_rate > 48000 || 919 (p->precision != 8 && p->precision != 16) || 920 (p->channels != 1 && p->channels != 2)) 921 return EINVAL; 922 923 p->factor = 1; 924 p->sw_code = 0; 925 switch (p->encoding) { 926 case AUDIO_ENCODING_SLINEAR_BE: 927 if (p->precision == 16) 928 p->sw_code = swap_bytes; 929 else 930 p->sw_code = change_sign8; 931 break; 932 case AUDIO_ENCODING_SLINEAR_LE: 933 if (p->precision != 16) 934 p->sw_code = change_sign8; 935 break; 936 case AUDIO_ENCODING_ULINEAR_BE: 937 if (p->precision == 16) { 938 if (mode == AUMODE_PLAY) 939 p->sw_code = swap_bytes_change_sign16_le; 940 else 941 p->sw_code = change_sign16_swap_bytes_le; 942 } 943 break; 944 case AUDIO_ENCODING_ULINEAR_LE: 945 if (p->precision == 16) 946 p->sw_code = change_sign16_le; 947 break; 948 case AUDIO_ENCODING_ULAW: 949 if (mode == AUMODE_PLAY) { 950 p->factor = 2; 951 p->sw_code = mulaw_to_slinear16_le; 952 } else 953 p->sw_code = ulinear8_to_mulaw; 954 break; 955 case AUDIO_ENCODING_ALAW: 956 if (mode == AUMODE_PLAY) { 957 p->factor = 2; 958 p->sw_code = alaw_to_slinear16_le; 959 } else 960 p->sw_code = ulinear8_to_alaw; 961 break; 962 default: 963 return EINVAL; 964 } 965 } 966 967 if (setmode & AUMODE_PLAY) 968 esmch_set_format(&ess->pch, play); 969 970 if (setmode & AUMODE_RECORD) 971 esmch_set_format(&ess->rch, rec); 972 973 return 0; 974 } 975 976 977 int 978 esm_set_port(void *sc, mixer_ctrl_t *cp) 979 { 980 struct esm_softc *ess = sc; 981 982 return (ess->codec_if->vtbl->mixer_set_port(ess->codec_if, cp)); 983 } 984 985 986 int 987 esm_get_port(void *sc, mixer_ctrl_t *cp) 988 { 989 struct esm_softc *ess = sc; 990 991 return (ess->codec_if->vtbl->mixer_get_port(ess->codec_if, cp)); 992 } 993 994 995 int 996 esm_query_devinfo(void *sc, mixer_devinfo_t *dip) 997 { 998 struct esm_softc *ess = sc; 999 1000 return (ess->codec_if->vtbl->query_devinfo(ess->codec_if, dip)); 1001 } 1002 1003 1004 void * 1005 esm_malloc(void *sc, int direction, size_t size, int pool, int flags) 1006 { 1007 struct esm_softc *ess = sc; 1008 struct esm_dma *p; 1009 int error; 1010 1011 DPRINTF(ESM_DEBUG_DMA, 1012 ("esm_malloc(%p, %d, 0x%x, 0x%x, 0x%x)", 1013 sc, direction, size, pool, flags)); 1014 1015 p = malloc(sizeof(*p), pool, flags); 1016 if (!p) 1017 return 0; 1018 error = esm_allocmem(ess, size, 16, p); 1019 if (error) { 1020 free(p, pool); 1021 DPRINTF(ESM_DEBUG_DMA, (" = 0 (ENOMEM)\n")); 1022 return 0; 1023 } 1024 p->next = ess->sc_dmas; 1025 ess->sc_dmas = p; 1026 1027 DPRINTF(ESM_DEBUG_DMA, 1028 (": KERNADDR(%p) = %p (DMAADDR 0x%x)\n", p, KERNADDR(p), (int)DMAADDR(p))); 1029 1030 return KERNADDR(p); 1031 } 1032 1033 1034 void 1035 esm_free(void *sc, void *ptr, int pool) 1036 { 1037 struct esm_softc *ess = sc; 1038 struct esm_dma *p, **pp; 1039 1040 DPRINTF(ESM_DEBUG_DMA, 1041 ("esm_free(%p, %p, 0x%x)\n", 1042 sc, ptr, pool)); 1043 1044 for (pp = &ess->sc_dmas; (p = *pp) != NULL; pp = &p->next) { 1045 if (KERNADDR(p) == ptr) { 1046 esm_freemem(ess, p); 1047 *pp = p->next; 1048 free(p, pool); 1049 return; 1050 } 1051 } 1052 } 1053 1054 1055 size_t 1056 esm_round_buffersize(void *sc, int direction, size_t size) 1057 { 1058 return size; 1059 } 1060 1061 1062 paddr_t 1063 esm_mappage(void *sc, void *mem, off_t off, int prot) 1064 { 1065 struct esm_softc *ess = sc; 1066 struct esm_dma *p; 1067 1068 DPRINTF(ESM_DEBUG_DMA, 1069 ("esm_mappage(%p, %p, 0x%lx, 0x%x)\n", 1070 sc, mem, (unsigned long)off, prot)); 1071 1072 if (off < 0) 1073 return (-1); 1074 1075 for (p = ess->sc_dmas; p && KERNADDR(p) != mem; p = p->next) 1076 ; 1077 if (!p) 1078 return (-1); 1079 return bus_dmamem_mmap(ess->dmat, p->segs, p->nsegs, off, 1080 prot, BUS_DMA_WAITOK); 1081 } 1082 1083 1084 int 1085 esm_get_props(void *sc) 1086 { 1087 return AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT | AUDIO_PROP_FULLDUPLEX; 1088 } 1089 1090 1091 /* ----------------------------- 1092 * Bus space. 1093 */ 1094 1095 int 1096 esm_intr(void *sc) 1097 { 1098 struct esm_softc *ess = sc; 1099 u_int16_t status; 1100 u_int16_t pos; 1101 int ret = 0; 1102 1103 status = bus_space_read_1(ess->st, ess->sh, PORT_HOSTINT_STAT); 1104 if (!status) 1105 return 0; 1106 1107 /* Acknowledge all. */ 1108 bus_space_write_2(ess->st, ess->sh, PORT_INT_STAT, 1); 1109 bus_space_write_1(ess->st, ess->sh, PORT_HOSTINT_STAT, 0); 1110 #if 0 /* XXX - HWVOL */ 1111 if (status & HOSTINT_STAT_HWVOL) { 1112 u_int delta; 1113 delta = bus_space_read_1(ess->st, ess->sh, PORT_HWVOL_MASTER) 1114 - 0x88; 1115 if (delta & 0x11) 1116 mixer_set(device_get_softc(ess->dev), 1117 SOUND_MIXER_VOLUME, 0); 1118 else { 1119 mixer_set(device_get_softc(ess->dev), 1120 SOUND_MIXER_VOLUME, 1121 mixer_get(device_get_softc(ess->dev), 1122 SOUND_MIXER_VOLUME) 1123 + ((delta >> 5) & 0x7) - 4 1124 + ((delta << 7) & 0x700) - 0x400); 1125 } 1126 bus_space_write_1(ess->st, ess->sh, PORT_HWVOL_MASTER, 0x88); 1127 ret++; 1128 } 1129 #endif /* XXX - HWVOL */ 1130 1131 if (ess->pactive) { 1132 pos = wp_rdapu(ess, ess->pch.num << 1, APUREG_CURPTR); 1133 1134 DPRINTF(ESM_DEBUG_IRQ, (" %4.4x/%4.4x ", pos, 1135 wp_rdapu(ess, (ess->pch.num<<1)+1, APUREG_CURPTR))); 1136 1137 if (pos >= ess->pch.nextirq && 1138 pos - ess->pch.nextirq < ess->pch.apubuf / 2) { 1139 ess->pch.nextirq += ess->pch.apublk; 1140 1141 if (ess->pch.nextirq >= ess->pch.apubuf) 1142 ess->pch.nextirq = 0; 1143 1144 if (ess->sc_pintr) { 1145 DPRINTF(ESM_DEBUG_IRQ, ("P\n")); 1146 ess->sc_pintr(ess->sc_parg); 1147 } 1148 1149 } 1150 ret++; 1151 } 1152 1153 if (ess->ractive) { 1154 pos = wp_rdapu(ess, ess->rch.num << 1, APUREG_CURPTR); 1155 1156 DPRINTF(ESM_DEBUG_IRQ, (" %4.4x/%4.4x ", pos, 1157 wp_rdapu(ess, (ess->rch.num<<1)+1, APUREG_CURPTR))); 1158 1159 if (pos >= ess->rch.nextirq && 1160 pos - ess->rch.nextirq < ess->rch.apubuf / 2) { 1161 ess->rch.nextirq += ess->rch.apublk; 1162 1163 if (ess->rch.nextirq >= ess->rch.apubuf) 1164 ess->rch.nextirq = 0; 1165 1166 if (ess->sc_rintr) { 1167 DPRINTF(ESM_DEBUG_IRQ, ("R\n")); 1168 ess->sc_rintr(ess->sc_parg); 1169 } 1170 1171 } 1172 ret++; 1173 } 1174 1175 return ret; 1176 } 1177 1178 1179 int 1180 esm_allocmem(struct esm_softc *sc, size_t size, size_t align, 1181 struct esm_dma *p) 1182 { 1183 int error; 1184 1185 p->size = size; 1186 error = bus_dmamem_alloc(sc->dmat, p->size, align, 0, 1187 p->segs, sizeof(p->segs)/sizeof(p->segs[0]), 1188 &p->nsegs, BUS_DMA_NOWAIT); 1189 if (error) 1190 return error; 1191 1192 error = bus_dmamem_map(sc->dmat, p->segs, p->nsegs, p->size, 1193 &p->addr, BUS_DMA_NOWAIT|BUS_DMA_COHERENT); 1194 if (error) 1195 goto free; 1196 1197 error = bus_dmamap_create(sc->dmat, p->size, 1, p->size, 1198 0, BUS_DMA_NOWAIT, &p->map); 1199 if (error) 1200 goto unmap; 1201 1202 error = bus_dmamap_load(sc->dmat, p->map, p->addr, p->size, NULL, 1203 BUS_DMA_NOWAIT); 1204 if (error) 1205 goto destroy; 1206 1207 return 0; 1208 1209 destroy: 1210 bus_dmamap_destroy(sc->dmat, p->map); 1211 unmap: 1212 bus_dmamem_unmap(sc->dmat, p->addr, p->size); 1213 free: 1214 bus_dmamem_free(sc->dmat, p->segs, p->nsegs); 1215 1216 return error; 1217 } 1218 1219 1220 int 1221 esm_freemem(struct esm_softc *sc, struct esm_dma *p) 1222 { 1223 bus_dmamap_unload(sc->dmat, p->map); 1224 bus_dmamap_destroy(sc->dmat, p->map); 1225 bus_dmamem_unmap(sc->dmat, p->addr, p->size); 1226 bus_dmamem_free(sc->dmat, p->segs, p->nsegs); 1227 return 0; 1228 } 1229 1230 1231 int 1232 esm_match(struct device *dev, struct cfdata *match, void *aux) 1233 { 1234 struct pci_attach_args *pa = (struct pci_attach_args *) aux; 1235 1236 switch (PCI_VENDOR(pa->pa_id)) { 1237 case PCI_VENDOR_ESSTECH: 1238 switch (PCI_PRODUCT(pa->pa_id)) { 1239 case PCI_PRODUCT_ESSTECH_MAESTRO1: 1240 case PCI_PRODUCT_ESSTECH_MAESTRO2: 1241 case PCI_PRODUCT_ESSTECH_MAESTRO2E: 1242 return 1; 1243 } 1244 1245 case PCI_VENDOR_ESSTECH2: 1246 switch (PCI_PRODUCT(pa->pa_id)) { 1247 case PCI_PRODUCT_ESSTECH2_MAESTRO1: 1248 return 1; 1249 } 1250 } 1251 return 0; 1252 } 1253 1254 void 1255 esm_attach(struct device *parent, struct device *self, void *aux) 1256 { 1257 struct esm_softc *ess = (struct esm_softc *)self; 1258 struct pci_attach_args *pa = (struct pci_attach_args *)aux; 1259 pci_chipset_tag_t pc = pa->pa_pc; 1260 pcitag_t tag = pa->pa_tag; 1261 pci_intr_handle_t ih; 1262 pcireg_t csr, data; 1263 u_int16_t codec_data; 1264 const char *intrstr; 1265 int revision; 1266 char devinfo[256]; 1267 1268 pci_devinfo(pa->pa_id, pa->pa_class, 0, devinfo); 1269 revision = PCI_REVISION(pa->pa_class); 1270 printf(": %s (rev. 0x%02x)\n", devinfo, revision); 1271 1272 /* Enable the device. */ 1273 csr = pci_conf_read(pc, tag, PCI_COMMAND_STATUS_REG); 1274 pci_conf_write(pc, tag, PCI_COMMAND_STATUS_REG, 1275 csr | PCI_COMMAND_MASTER_ENABLE | PCI_COMMAND_IO_ENABLE); 1276 1277 /* Map I/O register */ 1278 if (pci_mapreg_map(pa, PCI_CBIO, PCI_MAPREG_TYPE_IO, 0, 1279 &ess->st, &ess->sh, NULL, NULL)) { 1280 printf("%s: can't map i/o space\n", ess->sc_dev.dv_xname); 1281 return; 1282 } 1283 1284 /* Initialize softc */ 1285 ess->pch.num = 0; 1286 ess->rch.num = 2; 1287 ess->dmat = pa->pa_dmat; 1288 ess->tag = tag; 1289 ess->pc = pc; 1290 ess->subid = pci_conf_read(pc, tag, PCI_SUBSYS_ID_REG); 1291 1292 /* Map and establish the interrupt. */ 1293 if (pci_intr_map(pa, &ih)) { 1294 printf("%s: can't map interrupt\n", ess->sc_dev.dv_xname); 1295 return; 1296 } 1297 intrstr = pci_intr_string(pc, ih); 1298 ess->ih = pci_intr_establish(pc, ih, IPL_AUDIO, esm_intr, self); 1299 if (ess->ih == NULL) { 1300 printf("%s: can't establish interrupt", ess->sc_dev.dv_xname); 1301 if (intrstr != NULL) 1302 printf(" at %s", intrstr); 1303 printf("\n"); 1304 return; 1305 } 1306 printf("%s: interrupting at %s\n", ess->sc_dev.dv_xname, intrstr); 1307 1308 /* 1309 * Setup PCI config registers 1310 */ 1311 1312 /* set to power state D0 */ 1313 esm_power(ess, PPMI_D0); 1314 delay(100000); 1315 1316 /* Disable all legacy emulations. */ 1317 data = pci_conf_read(pc, tag, CONF_LEGACY); 1318 pci_conf_write(pc, tag, CONF_LEGACY, data | LEGACY_DISABLED); 1319 1320 /* Disconnect from CHI. (Makes Dell inspiron 7500 work?) 1321 * Enable posted write. 1322 * Prefer PCI timing rather than that of ISA. 1323 * Don't swap L/R. */ 1324 data = pci_conf_read(pc, tag, CONF_MAESTRO); 1325 data |= MAESTRO_CHIBUS | MAESTRO_POSTEDWRITE | MAESTRO_DMA_PCITIMING; 1326 data &= ~MAESTRO_SWAP_LR; 1327 pci_conf_write(pc, tag, CONF_MAESTRO, data); 1328 1329 /* initialize sound chip */ 1330 esm_init(ess); 1331 1332 esm_read_codec(ess, 0, &codec_data); 1333 if (codec_data == 0x80) { 1334 printf("%s: PT101 codec detected!\n", ess->sc_dev.dv_xname); 1335 return; 1336 } 1337 1338 /* initialize AC97 host interface */ 1339 ess->host_if.arg = self; 1340 ess->host_if.attach = esm_attach_codec; 1341 ess->host_if.read = esm_read_codec; 1342 ess->host_if.write = esm_write_codec; 1343 ess->host_if.reset = esm_reset_codec; 1344 1345 if (ac97_attach(&ess->host_if) != 0) 1346 return; 1347 1348 audio_attach_mi(&esm_hw_if, self, &ess->sc_dev); 1349 } 1350 1351 #if 0 1352 int 1353 esm_suspend(struct esm_softc *ess) 1354 { 1355 int i, x; 1356 1357 x = splaudio(); 1358 wp_stoptimer(ess); 1359 bus_space_write_2(ess->st, ess->sh, PORT_HOSTINT_CTRL, 0); 1360 1361 esm_halt_output(ess); 1362 esm_halt_input(ess); 1363 splx(x); 1364 1365 /* Power down everything except clock. */ 1366 esm_write_codec(ess, AC97_REG_POWER, 0xdf00); 1367 delay(20); 1368 bus_space_write_4(ess->st, ess->sh, PORT_RINGBUS_CTRL, 0); 1369 delay(1); 1370 esm_power(ess, PPMI_D3); 1371 1372 return 0; 1373 } 1374 1375 1376 int 1377 esm_resume(struct esm_softc *ess) 1378 { 1379 int i, x; 1380 1381 esm_power(ess, PPMI_D0); 1382 delay(100000); 1383 esm_init(ess); 1384 if (mixer_reinit(dev)) { 1385 printf("%s: unable to reinitialize the mixer\n", 1386 ess->sc_dev.dv_xname); 1387 return ENXIO; 1388 } 1389 1390 x = splaudio(); 1391 if (ess->pactive) 1392 esm_start_output(ess); 1393 if (ess->ractive) 1394 esm_start_input(ess); 1395 if (ess->pactive || ess->ractive) { 1396 set_timer(ess); 1397 wp_starttimer(ess); 1398 } 1399 splx(x); 1400 return 0; 1401 } 1402 1403 1404 int 1405 esm_shutdown(struct esm_softc *ess) 1406 { 1407 int i; 1408 1409 wp_stoptimer(ess); 1410 bus_space_write_2(ess->st, ess->sh, PORT_HOSTINT_CTRL, 0); 1411 1412 esm_halt_output(ess); 1413 esm_halt_input(ess); 1414 1415 return 0; 1416 } 1417 #endif 1418
Indexes created Sun Sep 21 20:09:37 GMT 2025