1 /* 2 * Copyright (c) 1999 Cameron Grant <gandalf@vilnya.demon.co.uk> 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 23 * SUCH DAMAGE. 24 * 25 * $FreeBSD: src/sys/dev/sound/pci/solo.c,v 1.9.2.8 2002/04/22 15:49:32 cg Exp $ 26 * $DragonFly: src/sys/dev/sound/pci/solo.c,v 1.3 2003/08/07 21:17:13 dillon Exp $ 27 */ 28 29 #include <dev/sound/pcm/sound.h> 30 31 #include <bus/pci/pcireg.h> 32 #include <bus/pci/pcivar.h> 33 34 #include <dev/sound/isa/sb.h> 35 #include <dev/sound/chip.h> 36 37 #include "mixer_if.h" 38 39 SND_DECLARE_FILE("$DragonFly: src/sys/dev/sound/pci/solo.c,v 1.3 2003/08/07 21:17:13 dillon Exp $"); 40 41 #define SOLO_DEFAULT_BUFSZ 16384 42 #define ABS(x) (((x) < 0)? -(x) : (x)) 43 44 /* if defined, playback always uses the 2nd channel and full duplex works */ 45 #undef ESS18XX_DUPLEX 46 47 /* more accurate clocks and split audio1/audio2 rates */ 48 #define ESS18XX_NEWSPEED 49 50 static u_int32_t ess_playfmt[] = { 51 AFMT_U8, 52 AFMT_STEREO | AFMT_U8, 53 AFMT_S8, 54 AFMT_STEREO | AFMT_S8, 55 AFMT_S16_LE, 56 AFMT_STEREO | AFMT_S16_LE, 57 AFMT_U16_LE, 58 AFMT_STEREO | AFMT_U16_LE, 59 0 60 }; 61 static struct pcmchan_caps ess_playcaps = {5000, 49000, ess_playfmt, 0}; 62 63 /* 64 * Recording output is byte-swapped 65 */ 66 static u_int32_t ess_recfmt[] = { 67 AFMT_U8, 68 AFMT_STEREO | AFMT_U8, 69 AFMT_S8, 70 AFMT_STEREO | AFMT_S8, 71 AFMT_S16_BE, 72 AFMT_STEREO | AFMT_S16_BE, 73 AFMT_U16_BE, 74 AFMT_STEREO | AFMT_U16_BE, 75 0 76 }; 77 static struct pcmchan_caps ess_reccaps = {5000, 49000, ess_recfmt, 0}; 78 79 struct ess_info; 80 81 struct ess_chinfo { 82 struct ess_info *parent; 83 struct pcm_channel *channel; 84 struct snd_dbuf *buffer; 85 int dir, hwch, stopping; 86 u_int32_t fmt, spd, blksz; 87 }; 88 89 struct ess_info { 90 struct resource *io, *sb, *vc, *mpu, *gp; /* I/O address for the board */ 91 struct resource *irq; 92 void *ih; 93 bus_dma_tag_t parent_dmat; 94 95 int simplex_dir, type, duplex:1, newspeed:1, dmasz[2]; 96 unsigned int bufsz; 97 98 struct ess_chinfo pch, rch; 99 }; 100 101 static int ess_rd(struct ess_info *sc, int reg); 102 static void ess_wr(struct ess_info *sc, int reg, u_int8_t val); 103 static int ess_dspready(struct ess_info *sc); 104 static int ess_cmd(struct ess_info *sc, u_char val); 105 static int ess_cmd1(struct ess_info *sc, u_char cmd, int val); 106 static int ess_get_byte(struct ess_info *sc); 107 static void ess_setmixer(struct ess_info *sc, u_int port, u_int value); 108 static int ess_getmixer(struct ess_info *sc, u_int port); 109 static int ess_reset_dsp(struct ess_info *sc); 110 111 static int ess_write(struct ess_info *sc, u_char reg, int val); 112 static int ess_read(struct ess_info *sc, u_char reg); 113 114 static void ess_intr(void *arg); 115 static int ess_setupch(struct ess_info *sc, int ch, int dir, int spd, u_int32_t fmt, int len); 116 static int ess_start(struct ess_chinfo *ch); 117 static int ess_stop(struct ess_chinfo *ch); 118 119 static int ess_dmasetup(struct ess_info *sc, int ch, u_int32_t base, u_int16_t cnt, int dir); 120 static int ess_dmapos(struct ess_info *sc, int ch); 121 static int ess_dmatrigger(struct ess_info *sc, int ch, int go); 122 123 /* 124 * Common code for the midi and pcm functions 125 * 126 * ess_cmd write a single byte to the CMD port. 127 * ess_cmd1 write a CMD + 1 byte arg 128 * ess_cmd2 write a CMD + 2 byte arg 129 * ess_get_byte returns a single byte from the DSP data port 130 * 131 * ess_write is actually ess_cmd1 132 * ess_read access ext. regs via ess_cmd(0xc0, reg) followed by ess_get_byte 133 */ 134 135 static int 136 port_rd(struct resource *port, int regno, int size) 137 { 138 bus_space_tag_t st = rman_get_bustag(port); 139 bus_space_handle_t sh = rman_get_bushandle(port); 140 141 switch (size) { 142 case 1: 143 return bus_space_read_1(st, sh, regno); 144 case 2: 145 return bus_space_read_2(st, sh, regno); 146 case 4: 147 return bus_space_read_4(st, sh, regno); 148 default: 149 return 0xffffffff; 150 } 151 } 152 153 static void 154 port_wr(struct resource *port, int regno, u_int32_t data, int size) 155 { 156 bus_space_tag_t st = rman_get_bustag(port); 157 bus_space_handle_t sh = rman_get_bushandle(port); 158 159 switch (size) { 160 case 1: 161 bus_space_write_1(st, sh, regno, data); 162 break; 163 case 2: 164 bus_space_write_2(st, sh, regno, data); 165 break; 166 case 4: 167 bus_space_write_4(st, sh, regno, data); 168 break; 169 } 170 } 171 172 static int 173 ess_rd(struct ess_info *sc, int reg) 174 { 175 return port_rd(sc->sb, reg, 1); 176 } 177 178 static void 179 ess_wr(struct ess_info *sc, int reg, u_int8_t val) 180 { 181 port_wr(sc->sb, reg, val, 1); 182 } 183 184 static int 185 ess_dspready(struct ess_info *sc) 186 { 187 return ((ess_rd(sc, SBDSP_STATUS) & 0x80) == 0); 188 } 189 190 static int 191 ess_dspwr(struct ess_info *sc, u_char val) 192 { 193 int i; 194 195 for (i = 0; i < 1000; i++) { 196 if (ess_dspready(sc)) { 197 ess_wr(sc, SBDSP_CMD, val); 198 return 1; 199 } 200 if (i > 10) DELAY((i > 100)? 1000 : 10); 201 } 202 printf("ess_dspwr(0x%02x) timed out.\n", val); 203 return 0; 204 } 205 206 static int 207 ess_cmd(struct ess_info *sc, u_char val) 208 { 209 DEB(printf("ess_cmd: %x\n", val)); 210 return ess_dspwr(sc, val); 211 } 212 213 static int 214 ess_cmd1(struct ess_info *sc, u_char cmd, int val) 215 { 216 DEB(printf("ess_cmd1: %x, %x\n", cmd, val)); 217 if (ess_dspwr(sc, cmd)) { 218 return ess_dspwr(sc, val & 0xff); 219 } else return 0; 220 } 221 222 static void 223 ess_setmixer(struct ess_info *sc, u_int port, u_int value) 224 { 225 u_long flags; 226 227 DEB(printf("ess_setmixer: reg=%x, val=%x\n", port, value);) 228 flags = spltty(); 229 ess_wr(sc, SB_MIX_ADDR, (u_char) (port & 0xff)); /* Select register */ 230 DELAY(10); 231 ess_wr(sc, SB_MIX_DATA, (u_char) (value & 0xff)); 232 DELAY(10); 233 splx(flags); 234 } 235 236 static int 237 ess_getmixer(struct ess_info *sc, u_int port) 238 { 239 int val; 240 u_long flags; 241 242 flags = spltty(); 243 ess_wr(sc, SB_MIX_ADDR, (u_char) (port & 0xff)); /* Select register */ 244 DELAY(10); 245 val = ess_rd(sc, SB_MIX_DATA); 246 DELAY(10); 247 splx(flags); 248 249 return val; 250 } 251 252 static int 253 ess_get_byte(struct ess_info *sc) 254 { 255 int i; 256 257 for (i = 1000; i > 0; i--) { 258 if (ess_rd(sc, 0xc) & 0x40) 259 return ess_rd(sc, DSP_READ); 260 else 261 DELAY(20); 262 } 263 return -1; 264 } 265 266 static int 267 ess_write(struct ess_info *sc, u_char reg, int val) 268 { 269 return ess_cmd1(sc, reg, val); 270 } 271 272 static int 273 ess_read(struct ess_info *sc, u_char reg) 274 { 275 return (ess_cmd(sc, 0xc0) && ess_cmd(sc, reg))? ess_get_byte(sc) : -1; 276 } 277 278 static int 279 ess_reset_dsp(struct ess_info *sc) 280 { 281 DEB(printf("ess_reset_dsp\n")); 282 ess_wr(sc, SBDSP_RST, 3); 283 DELAY(100); 284 ess_wr(sc, SBDSP_RST, 0); 285 if (ess_get_byte(sc) != 0xAA) { 286 DEB(printf("ess_reset_dsp failed\n")); 287 /* 288 rman_get_start(d->io_base))); 289 */ 290 return ENXIO; /* Sorry */ 291 } 292 ess_cmd(sc, 0xc6); 293 return 0; 294 } 295 296 static void 297 ess_intr(void *arg) 298 { 299 struct ess_info *sc = (struct ess_info *)arg; 300 int src, pirq = 0, rirq = 0; 301 302 src = 0; 303 if (ess_getmixer(sc, 0x7a) & 0x80) 304 src |= 2; 305 if (ess_rd(sc, 0x0c) & 0x01) 306 src |= 1; 307 308 if (src == 0) 309 return; 310 311 if (sc->duplex) { 312 pirq = (src & sc->pch.hwch)? 1 : 0; 313 rirq = (src & sc->rch.hwch)? 1 : 0; 314 } else { 315 if (sc->simplex_dir == PCMDIR_PLAY) 316 pirq = 1; 317 if (sc->simplex_dir == PCMDIR_REC) 318 rirq = 1; 319 if (!pirq && !rirq) 320 printf("solo: IRQ neither playback nor rec!\n"); 321 } 322 323 DEB(printf("ess_intr: pirq:%d rirq:%d\n",pirq,rirq)); 324 325 if (pirq) { 326 if (sc->pch.stopping) { 327 ess_dmatrigger(sc, sc->pch.hwch, 0); 328 sc->pch.stopping = 0; 329 if (sc->pch.hwch == 1) 330 ess_write(sc, 0xb8, ess_read(sc, 0xb8) & ~0x01); 331 else 332 ess_setmixer(sc, 0x78, ess_getmixer(sc, 0x78) & ~0x03); 333 } 334 chn_intr(sc->pch.channel); 335 } 336 337 if (rirq) { 338 if (sc->rch.stopping) { 339 ess_dmatrigger(sc, sc->rch.hwch, 0); 340 sc->rch.stopping = 0; 341 /* XXX: will this stop audio2? */ 342 ess_write(sc, 0xb8, ess_read(sc, 0xb8) & ~0x01); 343 } 344 chn_intr(sc->rch.channel); 345 } 346 347 if (src & 2) 348 ess_setmixer(sc, 0x7a, ess_getmixer(sc, 0x7a) & ~0x80); 349 if (src & 1) 350 ess_rd(sc, DSP_DATA_AVAIL); 351 } 352 353 /* utility functions for ESS */ 354 static u_int8_t 355 ess_calcspeed8(int *spd) 356 { 357 int speed = *spd; 358 u_int32_t t; 359 360 if (speed > 22000) { 361 t = (795500 + speed / 2) / speed; 362 speed = (795500 + t / 2) / t; 363 t = (256 - t) | 0x80; 364 } else { 365 t = (397700 + speed / 2) / speed; 366 speed = (397700 + t / 2) / t; 367 t = 128 - t; 368 } 369 *spd = speed; 370 return t & 0x000000ff; 371 } 372 373 static u_int8_t 374 ess_calcspeed9(int *spd) 375 { 376 int speed, s0, s1, use0; 377 u_int8_t t0, t1; 378 379 /* rate = source / (256 - divisor) */ 380 /* divisor = 256 - (source / rate) */ 381 speed = *spd; 382 t0 = 128 - (793800 / speed); 383 s0 = 793800 / (128 - t0); 384 385 t1 = 128 - (768000 / speed); 386 s1 = 768000 / (128 - t1); 387 t1 |= 0x80; 388 389 use0 = (ABS(speed - s0) < ABS(speed - s1))? 1 : 0; 390 391 *spd = use0? s0 : s1; 392 return use0? t0 : t1; 393 } 394 395 static u_int8_t 396 ess_calcfilter(int spd) 397 { 398 int cutoff; 399 400 /* cutoff = 7160000 / (256 - divisor) */ 401 /* divisor = 256 - (7160000 / cutoff) */ 402 cutoff = (spd * 9 * 82) / 20; 403 return (256 - (7160000 / cutoff)); 404 } 405 406 static int 407 ess_setupch(struct ess_info *sc, int ch, int dir, int spd, u_int32_t fmt, int len) 408 { 409 int play = (dir == PCMDIR_PLAY)? 1 : 0; 410 int b16 = (fmt & AFMT_16BIT)? 1 : 0; 411 int stereo = (fmt & AFMT_STEREO)? 1 : 0; 412 int unsign = (fmt == AFMT_U8 || fmt == AFMT_U16_LE || fmt == AFMT_U16_BE)? 1 : 0; 413 u_int8_t spdval, fmtval; 414 415 DEB(printf("ess_setupch\n")); 416 spdval = (sc->newspeed)? ess_calcspeed9(&spd) : ess_calcspeed8(&spd); 417 418 sc->simplex_dir = play ? PCMDIR_PLAY : PCMDIR_REC ; 419 420 if (ch == 1) { 421 KASSERT((dir == PCMDIR_PLAY) || (dir == PCMDIR_REC), ("ess_setupch: dir1 bad")); 422 len = -len; 423 /* transfer length low */ 424 ess_write(sc, 0xa4, len & 0x00ff); 425 /* transfer length high */ 426 ess_write(sc, 0xa5, (len & 0xff00) >> 8); 427 /* autoinit, dma dir */ 428 ess_write(sc, 0xb8, 0x04 | (play? 0x00 : 0x0a)); 429 /* mono/stereo */ 430 ess_write(sc, 0xa8, (ess_read(sc, 0xa8) & ~0x03) | (stereo? 0x01 : 0x02)); 431 /* demand mode, 4 bytes/xfer */ 432 ess_write(sc, 0xb9, 0x02); 433 /* sample rate */ 434 ess_write(sc, 0xa1, spdval); 435 /* filter cutoff */ 436 ess_write(sc, 0xa2, ess_calcfilter(spd)); 437 /* setup dac/adc */ 438 /* 439 if (play) 440 ess_write(sc, 0xb6, unsign? 0x80 : 0x00); 441 */ 442 /* mono, b16: signed, load signal */ 443 /* 444 ess_write(sc, 0xb7, 0x51 | (unsign? 0x00 : 0x20)); 445 */ 446 /* setup fifo */ 447 ess_write(sc, 0xb7, 0x91 | (unsign? 0x00 : 0x20) | 448 (b16? 0x04 : 0x00) | 449 (stereo? 0x08 : 0x40)); 450 /* irq control */ 451 ess_write(sc, 0xb1, (ess_read(sc, 0xb1) & 0x0f) | 0x50); 452 /* drq control */ 453 ess_write(sc, 0xb2, (ess_read(sc, 0xb2) & 0x0f) | 0x50); 454 } else if (ch == 2) { 455 KASSERT(dir == PCMDIR_PLAY, ("ess_setupch: dir2 bad")); 456 len >>= 1; 457 len = -len; 458 /* transfer length low */ 459 ess_setmixer(sc, 0x74, len & 0x00ff); 460 /* transfer length high */ 461 ess_setmixer(sc, 0x76, (len & 0xff00) >> 8); 462 /* autoinit, 4 bytes/req */ 463 ess_setmixer(sc, 0x78, 0x10); 464 fmtval = b16 | (stereo << 1) | ((!unsign) << 2); 465 /* enable irq, set format */ 466 ess_setmixer(sc, 0x7a, 0x40 | fmtval); 467 if (sc->newspeed) { 468 /* sample rate */ 469 ess_setmixer(sc, 0x70, spdval); 470 /* filter cutoff */ 471 ess_setmixer(sc, 0x72, ess_calcfilter(spd)); 472 } 473 474 } 475 return 0; 476 } 477 static int 478 ess_start(struct ess_chinfo *ch) 479 { 480 struct ess_info *sc = ch->parent; 481 482 DEB(printf("ess_start\n");); 483 ess_setupch(sc, ch->hwch, ch->dir, ch->spd, ch->fmt, ch->blksz); 484 ch->stopping = 0; 485 if (ch->hwch == 1) { 486 ess_write(sc, 0xb8, ess_read(sc, 0xb8) | 0x01); 487 if (ch->dir == PCMDIR_PLAY) { 488 #if 0 489 DELAY(100000); /* 100 ms */ 490 #endif 491 ess_cmd(sc, 0xd1); 492 } 493 } else 494 ess_setmixer(sc, 0x78, ess_getmixer(sc, 0x78) | 0x03); 495 return 0; 496 } 497 498 static int 499 ess_stop(struct ess_chinfo *ch) 500 { 501 struct ess_info *sc = ch->parent; 502 503 DEB(printf("ess_stop\n")); 504 ch->stopping = 1; 505 if (ch->hwch == 1) 506 ess_write(sc, 0xb8, ess_read(sc, 0xb8) & ~0x04); 507 else 508 ess_setmixer(sc, 0x78, ess_getmixer(sc, 0x78) & ~0x10); 509 DEB(printf("done with stop\n")); 510 return 0; 511 } 512 513 /* -------------------------------------------------------------------- */ 514 /* channel interface for ESS18xx */ 515 static void * 516 esschan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir) 517 { 518 struct ess_info *sc = devinfo; 519 struct ess_chinfo *ch = (dir == PCMDIR_PLAY)? &sc->pch : &sc->rch; 520 521 DEB(printf("esschan_init\n")); 522 ch->parent = sc; 523 ch->channel = c; 524 ch->buffer = b; 525 ch->dir = dir; 526 if (sndbuf_alloc(ch->buffer, sc->parent_dmat, sc->bufsz) == -1) 527 return NULL; 528 ch->hwch = 1; 529 if ((dir == PCMDIR_PLAY) && (sc->duplex)) 530 ch->hwch = 2; 531 return ch; 532 } 533 534 static int 535 esschan_setformat(kobj_t obj, void *data, u_int32_t format) 536 { 537 struct ess_chinfo *ch = data; 538 539 ch->fmt = format; 540 return 0; 541 } 542 543 static int 544 esschan_setspeed(kobj_t obj, void *data, u_int32_t speed) 545 { 546 struct ess_chinfo *ch = data; 547 struct ess_info *sc = ch->parent; 548 549 ch->spd = speed; 550 if (sc->newspeed) 551 ess_calcspeed9(&ch->spd); 552 else 553 ess_calcspeed8(&ch->spd); 554 return ch->spd; 555 } 556 557 static int 558 esschan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize) 559 { 560 struct ess_chinfo *ch = data; 561 562 ch->blksz = blocksize; 563 return ch->blksz; 564 } 565 566 static int 567 esschan_trigger(kobj_t obj, void *data, int go) 568 { 569 struct ess_chinfo *ch = data; 570 struct ess_info *sc = ch->parent; 571 572 DEB(printf("esschan_trigger: %d\n",go)); 573 if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD) 574 return 0; 575 576 switch (go) { 577 case PCMTRIG_START: 578 ess_dmasetup(sc, ch->hwch, vtophys(sndbuf_getbuf(ch->buffer)), sndbuf_getsize(ch->buffer), ch->dir); 579 ess_dmatrigger(sc, ch->hwch, 1); 580 ess_start(ch); 581 break; 582 583 case PCMTRIG_STOP: 584 case PCMTRIG_ABORT: 585 default: 586 ess_stop(ch); 587 break; 588 } 589 return 0; 590 } 591 592 static int 593 esschan_getptr(kobj_t obj, void *data) 594 { 595 struct ess_chinfo *ch = data; 596 struct ess_info *sc = ch->parent; 597 598 return ess_dmapos(sc, ch->hwch); 599 } 600 601 static struct pcmchan_caps * 602 esschan_getcaps(kobj_t obj, void *data) 603 { 604 struct ess_chinfo *ch = data; 605 606 return (ch->dir == PCMDIR_PLAY)? &ess_playcaps : &ess_reccaps; 607 } 608 609 static kobj_method_t esschan_methods[] = { 610 KOBJMETHOD(channel_init, esschan_init), 611 KOBJMETHOD(channel_setformat, esschan_setformat), 612 KOBJMETHOD(channel_setspeed, esschan_setspeed), 613 KOBJMETHOD(channel_setblocksize, esschan_setblocksize), 614 KOBJMETHOD(channel_trigger, esschan_trigger), 615 KOBJMETHOD(channel_getptr, esschan_getptr), 616 KOBJMETHOD(channel_getcaps, esschan_getcaps), 617 { 0, 0 } 618 }; 619 CHANNEL_DECLARE(esschan); 620 621 /************************************************************/ 622 623 static int 624 essmix_init(struct snd_mixer *m) 625 { 626 struct ess_info *sc = mix_getdevinfo(m); 627 628 mix_setrecdevs(m, SOUND_MASK_CD | SOUND_MASK_MIC | SOUND_MASK_LINE | 629 SOUND_MASK_IMIX); 630 631 mix_setdevs(m, SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_LINE | 632 SOUND_MASK_MIC | SOUND_MASK_CD | SOUND_MASK_VOLUME | 633 SOUND_MASK_LINE1); 634 635 ess_setmixer(sc, 0, 0); /* reset */ 636 637 return 0; 638 } 639 640 static int 641 essmix_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right) 642 { 643 struct ess_info *sc = mix_getdevinfo(m); 644 int preg = 0, rreg = 0, l, r; 645 646 l = (left * 15) / 100; 647 r = (right * 15) / 100; 648 switch (dev) { 649 case SOUND_MIXER_SYNTH: 650 preg = 0x36; 651 rreg = 0x6b; 652 break; 653 654 case SOUND_MIXER_PCM: 655 preg = 0x14; 656 rreg = 0x7c; 657 break; 658 659 case SOUND_MIXER_LINE: 660 preg = 0x3e; 661 rreg = 0x6e; 662 break; 663 664 case SOUND_MIXER_MIC: 665 preg = 0x1a; 666 rreg = 0x68; 667 break; 668 669 case SOUND_MIXER_LINE1: 670 preg = 0x3a; 671 rreg = 0x6c; 672 break; 673 674 case SOUND_MIXER_CD: 675 preg = 0x38; 676 rreg = 0x6a; 677 break; 678 679 case SOUND_MIXER_VOLUME: 680 l = left? (left * 63) / 100 : 64; 681 r = right? (right * 63) / 100 : 64; 682 ess_setmixer(sc, 0x60, l); 683 ess_setmixer(sc, 0x62, r); 684 left = (l == 64)? 0 : (l * 100) / 63; 685 right = (r == 64)? 0 : (r * 100) / 63; 686 return left | (right << 8); 687 } 688 689 if (preg) 690 ess_setmixer(sc, preg, (l << 4) | r); 691 if (rreg) 692 ess_setmixer(sc, rreg, (l << 4) | r); 693 694 left = (l * 100) / 15; 695 right = (r * 100) / 15; 696 697 return left | (right << 8); 698 } 699 700 static int 701 essmix_setrecsrc(struct snd_mixer *m, u_int32_t src) 702 { 703 struct ess_info *sc = mix_getdevinfo(m); 704 u_char recdev; 705 706 switch (src) { 707 case SOUND_MASK_CD: 708 recdev = 0x02; 709 break; 710 711 case SOUND_MASK_LINE: 712 recdev = 0x06; 713 break; 714 715 case SOUND_MASK_IMIX: 716 recdev = 0x05; 717 break; 718 719 case SOUND_MASK_MIC: 720 default: 721 recdev = 0x00; 722 src = SOUND_MASK_MIC; 723 break; 724 } 725 726 ess_setmixer(sc, 0x1c, recdev); 727 728 return src; 729 } 730 731 static kobj_method_t solomixer_methods[] = { 732 KOBJMETHOD(mixer_init, essmix_init), 733 KOBJMETHOD(mixer_set, essmix_set), 734 KOBJMETHOD(mixer_setrecsrc, essmix_setrecsrc), 735 { 0, 0 } 736 }; 737 MIXER_DECLARE(solomixer); 738 739 /************************************************************/ 740 741 static int 742 ess_dmasetup(struct ess_info *sc, int ch, u_int32_t base, u_int16_t cnt, int dir) 743 { 744 KASSERT(ch == 1 || ch == 2, ("bad ch")); 745 sc->dmasz[ch - 1] = cnt; 746 if (ch == 1) { 747 port_wr(sc->vc, 0x8, 0xc4, 1); /* command */ 748 port_wr(sc->vc, 0xd, 0xff, 1); /* reset */ 749 port_wr(sc->vc, 0xf, 0x01, 1); /* mask */ 750 port_wr(sc->vc, 0xb, dir == PCMDIR_PLAY? 0x58 : 0x54, 1); /* mode */ 751 port_wr(sc->vc, 0x0, base, 4); 752 port_wr(sc->vc, 0x4, cnt - 1, 2); 753 754 } else if (ch == 2) { 755 port_wr(sc->io, 0x6, 0x08, 1); /* autoinit */ 756 port_wr(sc->io, 0x0, base, 4); 757 port_wr(sc->io, 0x4, cnt, 2); 758 } 759 return 0; 760 } 761 762 static int 763 ess_dmapos(struct ess_info *sc, int ch) 764 { 765 int p = 0, i = 0, j = 0; 766 u_long flags; 767 768 KASSERT(ch == 1 || ch == 2, ("bad ch")); 769 flags = spltty(); 770 if (ch == 1) { 771 772 /* 773 * During recording, this register is known to give back 774 * garbage if it's not quiescent while being read. That's 775 * why we spl, stop the DMA, and try over and over until 776 * adjacent reads are "close", in the right order and not 777 * bigger than is otherwise possible. 778 */ 779 ess_dmatrigger(sc, ch, 0); 780 DELAY(20); 781 do { 782 DELAY(10); 783 if (j > 1) 784 printf("DMA count reg bogus: %04x & %04x\n", 785 i, p); 786 i = port_rd(sc->vc, 0x4, 2) + 1; 787 p = port_rd(sc->vc, 0x4, 2) + 1; 788 } while ((p > sc->dmasz[ch - 1] || i < p || (p - i) > 0x8) && j++ < 1000); 789 ess_dmatrigger(sc, ch, 1); 790 } 791 else if (ch == 2) 792 p = port_rd(sc->io, 0x4, 2); 793 splx(flags); 794 return sc->dmasz[ch - 1] - p; 795 } 796 797 static int 798 ess_dmatrigger(struct ess_info *sc, int ch, int go) 799 { 800 KASSERT(ch == 1 || ch == 2, ("bad ch")); 801 if (ch == 1) 802 port_wr(sc->vc, 0xf, go? 0x00 : 0x01, 1); /* mask */ 803 else if (ch == 2) 804 port_wr(sc->io, 0x6, 0x08 | (go? 0x02 : 0x00), 1); /* autoinit */ 805 return 0; 806 } 807 808 static void 809 ess_release_resources(struct ess_info *sc, device_t dev) 810 { 811 if (sc->irq) { 812 if (sc->ih) 813 bus_teardown_intr(dev, sc->irq, sc->ih); 814 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq); 815 sc->irq = 0; 816 } 817 if (sc->io) { 818 bus_release_resource(dev, SYS_RES_IOPORT, 0 * 4 + PCIR_MAPS, sc->io); 819 sc->io = 0; 820 } 821 822 if (sc->sb) { 823 bus_release_resource(dev, SYS_RES_IOPORT, 1 * 4 + PCIR_MAPS, sc->sb); 824 sc->sb = 0; 825 } 826 827 if (sc->vc) { 828 bus_release_resource(dev, SYS_RES_IOPORT, 2 * 4 + PCIR_MAPS, sc->vc); 829 sc->vc = 0; 830 } 831 832 if (sc->mpu) { 833 bus_release_resource(dev, SYS_RES_IOPORT, 3 * 4 + PCIR_MAPS, sc->mpu); 834 sc->mpu = 0; 835 } 836 837 if (sc->gp) { 838 bus_release_resource(dev, SYS_RES_IOPORT, 4 * 4 + PCIR_MAPS, sc->gp); 839 sc->gp = 0; 840 } 841 842 if (sc->parent_dmat) { 843 bus_dma_tag_destroy(sc->parent_dmat); 844 sc->parent_dmat = 0; 845 } 846 847 free(sc, M_DEVBUF); 848 } 849 850 static int 851 ess_alloc_resources(struct ess_info *sc, device_t dev) 852 { 853 int rid; 854 855 rid = 0 * 4 + PCIR_MAPS; 856 sc->io = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, 1, RF_ACTIVE); 857 858 rid = 1 * 4 + PCIR_MAPS; 859 sc->sb = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, 1, RF_ACTIVE); 860 861 rid = 2 * 4 + PCIR_MAPS; 862 sc->vc = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, 1, RF_ACTIVE); 863 864 rid = 3 * 4 + PCIR_MAPS; 865 sc->mpu = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, 1, RF_ACTIVE); 866 867 rid = 4 * 4 + PCIR_MAPS; 868 sc->gp = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, 1, RF_ACTIVE); 869 870 rid = 0; 871 sc->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1, RF_ACTIVE | RF_SHAREABLE); 872 873 return (sc->irq && sc->io && sc->sb && sc->vc && sc->mpu && sc->gp)? 0 : ENXIO; 874 } 875 876 static int 877 ess_probe(device_t dev) 878 { 879 char *s = NULL; 880 u_int32_t subdev; 881 882 subdev = (pci_get_subdevice(dev) << 16) | pci_get_subvendor(dev); 883 switch (pci_get_devid(dev)) { 884 case 0x1969125d: 885 if (subdev == 0x8888125d) 886 s = "ESS Solo-1E"; 887 else if (subdev == 0x1818125d) 888 s = "ESS Solo-1"; 889 else 890 s = "ESS Solo-1 (unknown vendor)"; 891 break; 892 } 893 894 if (s) 895 device_set_desc(dev, s); 896 return s? 0 : ENXIO; 897 } 898 899 #define PCI_LEGACYCONTROL 0x40 900 #define PCI_CONFIG 0x50 901 #define PCI_DDMACONTROL 0x60 902 903 static int 904 ess_attach(device_t dev) 905 { 906 struct ess_info *sc; 907 char status[SND_STATUSLEN]; 908 u_int16_t ddma; 909 u_int32_t data; 910 911 sc = (struct ess_info *)malloc(sizeof *sc, M_DEVBUF, M_NOWAIT | M_ZERO); 912 if (!sc) 913 return ENXIO; 914 915 data = pci_read_config(dev, PCIR_COMMAND, 2); 916 data |= PCIM_CMD_PORTEN | PCIM_CMD_BUSMASTEREN; 917 pci_write_config(dev, PCIR_COMMAND, data, 2); 918 data = pci_read_config(dev, PCIR_COMMAND, 2); 919 920 if (ess_alloc_resources(sc, dev)) 921 goto no; 922 923 sc->bufsz = pcm_getbuffersize(dev, 4096, SOLO_DEFAULT_BUFSZ, 65536); 924 925 ddma = rman_get_start(sc->vc) | 1; 926 pci_write_config(dev, PCI_LEGACYCONTROL, 0x805f, 2); 927 pci_write_config(dev, PCI_DDMACONTROL, ddma, 2); 928 pci_write_config(dev, PCI_CONFIG, 0, 2); 929 930 if (ess_reset_dsp(sc)) 931 goto no; 932 if (mixer_init(dev, &solomixer_class, sc)) 933 goto no; 934 935 port_wr(sc->io, 0x7, 0xb0, 1); /* enable irqs */ 936 #ifdef ESS18XX_DUPLEX 937 sc->duplex = 1; 938 #else 939 sc->duplex = 0; 940 #endif 941 942 #ifdef ESS18XX_NEWSPEED 943 sc->newspeed = 1; 944 #else 945 sc->newspeed = 0; 946 #endif 947 if (sc->newspeed) 948 ess_setmixer(sc, 0x71, 0x2a); 949 950 snd_setup_intr(dev, sc->irq, 0, ess_intr, sc, &sc->ih); 951 if (!sc->duplex) 952 pcm_setflags(dev, pcm_getflags(dev) | SD_F_SIMPLEX); 953 954 if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/65536, /*boundary*/0, 955 /*lowaddr*/BUS_SPACE_MAXADDR_24BIT, 956 /*highaddr*/BUS_SPACE_MAXADDR, 957 /*filter*/NULL, /*filterarg*/NULL, 958 /*maxsize*/sc->bufsz, /*nsegments*/1, 959 /*maxsegz*/0x3ffff, 960 /*flags*/0, &sc->parent_dmat) != 0) { 961 device_printf(dev, "unable to create dma tag\n"); 962 goto no; 963 } 964 965 snprintf(status, SND_STATUSLEN, "at io 0x%lx,0x%lx,0x%lx irq %ld", 966 rman_get_start(sc->io), rman_get_start(sc->sb), rman_get_start(sc->vc), 967 rman_get_start(sc->irq)); 968 969 if (pcm_register(dev, sc, 1, 1)) 970 goto no; 971 pcm_addchan(dev, PCMDIR_REC, &esschan_class, sc); 972 pcm_addchan(dev, PCMDIR_PLAY, &esschan_class, sc); 973 pcm_setstatus(dev, status); 974 975 return 0; 976 977 no: 978 ess_release_resources(sc, dev); 979 return ENXIO; 980 } 981 982 static int 983 ess_detach(device_t dev) 984 { 985 int r; 986 struct ess_info *sc; 987 988 r = pcm_unregister(dev); 989 if (r) 990 return r; 991 992 sc = pcm_getdevinfo(dev); 993 ess_release_resources(sc, dev); 994 return 0; 995 } 996 997 static device_method_t ess_methods[] = { 998 /* Device interface */ 999 DEVMETHOD(device_probe, ess_probe), 1000 DEVMETHOD(device_attach, ess_attach), 1001 DEVMETHOD(device_detach, ess_detach), 1002 DEVMETHOD(device_resume, bus_generic_resume), 1003 DEVMETHOD(device_suspend, bus_generic_suspend), 1004 1005 { 0, 0 } 1006 }; 1007 1008 static driver_t ess_driver = { 1009 "pcm", 1010 ess_methods, 1011 PCM_SOFTC_SIZE, 1012 }; 1013 1014 DRIVER_MODULE(snd_solo, pci, ess_driver, pcm_devclass, 0, 0); 1015 MODULE_DEPEND(snd_solo, snd_pcm, PCM_MINVER, PCM_PREFVER, PCM_MAXVER); 1016 MODULE_VERSION(snd_solo, 1); 1017 1018 1019 1020