sb16.c revision 149948
1/*- 2 * Copyright (c) 1999 Cameron Grant <cg@freebsd.org> 3 * Copyright 1997,1998 Luigi Rizzo. 4 * 5 * Derived from files in the Voxware 3.5 distribution, 6 * Copyright by Hannu Savolainen 1994, under the same copyright 7 * conditions. 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 32#include <dev/sound/pcm/sound.h> 33 34#include <dev/sound/isa/sb.h> 35#include <dev/sound/chip.h> 36 37#include <isa/isavar.h> 38 39#include "mixer_if.h" 40 41SND_DECLARE_FILE("$FreeBSD: head/sys/dev/sound/isa/sb16.c 149948 2005-09-10 17:33:58Z netchild $"); 42 43#define SB16_BUFFSIZE 4096 44#define PLAIN_SB16(x) ((((x)->bd_flags) & (BD_F_SB16|BD_F_SB16X)) == BD_F_SB16) 45 46static u_int32_t sb16_fmt8[] = { 47 AFMT_U8, 48 AFMT_STEREO | AFMT_U8, 49 0 50}; 51static struct pcmchan_caps sb16_caps8 = {5000, 45000, sb16_fmt8, 0}; 52 53static u_int32_t sb16_fmt16[] = { 54 AFMT_S16_LE, 55 AFMT_STEREO | AFMT_S16_LE, 56 0 57}; 58static struct pcmchan_caps sb16_caps16 = {5000, 45000, sb16_fmt16, 0}; 59 60static u_int32_t sb16x_fmt[] = { 61 AFMT_U8, 62 AFMT_STEREO | AFMT_U8, 63 AFMT_S16_LE, 64 AFMT_STEREO | AFMT_S16_LE, 65 0 66}; 67static struct pcmchan_caps sb16x_caps = {5000, 49000, sb16x_fmt, 0}; 68 69struct sb_info; 70 71struct sb_chinfo { 72 struct sb_info *parent; 73 struct pcm_channel *channel; 74 struct snd_dbuf *buffer; 75 int dir, run, dch; 76 u_int32_t fmt, spd, blksz; 77}; 78 79struct sb_info { 80 struct resource *io_base; /* I/O address for the board */ 81 struct resource *irq; 82 struct resource *drq1; 83 struct resource *drq2; 84 void *ih; 85 bus_dma_tag_t parent_dmat; 86 87 unsigned int bufsize; 88 int bd_id; 89 u_long bd_flags; /* board-specific flags */ 90 int prio, prio16; 91 struct sb_chinfo pch, rch; 92 device_t parent_dev; 93}; 94 95#if 0 96static void sb_lock(struct sb_info *sb); 97static void sb_unlock(struct sb_info *sb); 98static int sb_rd(struct sb_info *sb, int reg); 99static void sb_wr(struct sb_info *sb, int reg, u_int8_t val); 100static int sb_cmd(struct sb_info *sb, u_char val); 101/* static int sb_cmd1(struct sb_info *sb, u_char cmd, int val); */ 102static int sb_cmd2(struct sb_info *sb, u_char cmd, int val); 103static u_int sb_get_byte(struct sb_info *sb); 104static void sb_setmixer(struct sb_info *sb, u_int port, u_int value); 105static int sb_getmixer(struct sb_info *sb, u_int port); 106static int sb_reset_dsp(struct sb_info *sb); 107 108static void sb_intr(void *arg); 109#endif 110 111/* 112 * Common code for the midi and pcm functions 113 * 114 * sb_cmd write a single byte to the CMD port. 115 * sb_cmd1 write a CMD + 1 byte arg 116 * sb_cmd2 write a CMD + 2 byte arg 117 * sb_get_byte returns a single byte from the DSP data port 118 */ 119 120static void 121sb_lock(struct sb_info *sb) { 122 123 sbc_lock(device_get_softc(sb->parent_dev)); 124} 125 126static void 127sb_lockassert(struct sb_info *sb) { 128 129 sbc_lockassert(device_get_softc(sb->parent_dev)); 130} 131 132static void 133sb_unlock(struct sb_info *sb) { 134 135 sbc_unlock(device_get_softc(sb->parent_dev)); 136} 137 138static int 139port_rd(struct resource *port, int off) 140{ 141 return bus_space_read_1(rman_get_bustag(port), rman_get_bushandle(port), off); 142} 143 144static void 145port_wr(struct resource *port, int off, u_int8_t data) 146{ 147 bus_space_write_1(rman_get_bustag(port), rman_get_bushandle(port), off, data); 148} 149 150static int 151sb_rd(struct sb_info *sb, int reg) 152{ 153 return port_rd(sb->io_base, reg); 154} 155 156static void 157sb_wr(struct sb_info *sb, int reg, u_int8_t val) 158{ 159 port_wr(sb->io_base, reg, val); 160} 161 162static int 163sb_dspwr(struct sb_info *sb, u_char val) 164{ 165 int i; 166 167 for (i = 0; i < 1000; i++) { 168 if ((sb_rd(sb, SBDSP_STATUS) & 0x80)) 169 DELAY((i > 100)? 1000 : 10); 170 else { 171 sb_wr(sb, SBDSP_CMD, val); 172 return 1; 173 } 174 } 175#if __FreeBSD_version > 500000 176 if (curthread->td_intr_nesting_level == 0) 177 printf("sb_dspwr(0x%02x) timed out.\n", val); 178#endif 179 return 0; 180} 181 182static int 183sb_cmd(struct sb_info *sb, u_char val) 184{ 185#if 0 186 printf("sb_cmd: %x\n", val); 187#endif 188 return sb_dspwr(sb, val); 189} 190 191/* 192static int 193sb_cmd1(struct sb_info *sb, u_char cmd, int val) 194{ 195#if 0 196 printf("sb_cmd1: %x, %x\n", cmd, val); 197#endif 198 if (sb_dspwr(sb, cmd)) { 199 return sb_dspwr(sb, val & 0xff); 200 } else return 0; 201} 202*/ 203 204static int 205sb_cmd2(struct sb_info *sb, u_char cmd, int val) 206{ 207 int r; 208 209#if 0 210 printf("sb_cmd2: %x, %x\n", cmd, val); 211#endif 212 sb_lockassert(sb); 213 r = 0; 214 if (sb_dspwr(sb, cmd)) { 215 if (sb_dspwr(sb, val & 0xff)) { 216 if (sb_dspwr(sb, (val >> 8) & 0xff)) { 217 r = 1; 218 } 219 } 220 } 221 222 return r; 223} 224 225/* 226 * in the SB, there is a set of indirect "mixer" registers with 227 * address at offset 4, data at offset 5 228 */ 229static void 230sb_setmixer(struct sb_info *sb, u_int port, u_int value) 231{ 232 sb_lock(sb); 233 sb_wr(sb, SB_MIX_ADDR, (u_char) (port & 0xff)); /* Select register */ 234 DELAY(10); 235 sb_wr(sb, SB_MIX_DATA, (u_char) (value & 0xff)); 236 DELAY(10); 237 sb_unlock(sb); 238} 239 240static int 241sb_getmixer(struct sb_info *sb, u_int port) 242{ 243 int val; 244 245 sb_lockassert(sb); 246 sb_wr(sb, SB_MIX_ADDR, (u_char) (port & 0xff)); /* Select register */ 247 DELAY(10); 248 val = sb_rd(sb, SB_MIX_DATA); 249 DELAY(10); 250 251 return val; 252} 253 254static u_int 255sb_get_byte(struct sb_info *sb) 256{ 257 int i; 258 259 for (i = 1000; i > 0; i--) { 260 if (sb_rd(sb, DSP_DATA_AVAIL) & 0x80) 261 return sb_rd(sb, DSP_READ); 262 else 263 DELAY(20); 264 } 265 return 0xffff; 266} 267 268static int 269sb_reset_dsp(struct sb_info *sb) 270{ 271 u_char b; 272 273 sb_lockassert(sb); 274 sb_wr(sb, SBDSP_RST, 3); 275 DELAY(100); 276 sb_wr(sb, SBDSP_RST, 0); 277 b = sb_get_byte(sb); 278 if (b != 0xAA) { 279 DEB(printf("sb_reset_dsp 0x%lx failed\n", 280 rman_get_start(sb->io_base))); 281 return ENXIO; /* Sorry */ 282 } 283 return 0; 284} 285 286/************************************************************/ 287 288struct sb16_mixent { 289 int reg; 290 int bits; 291 int ofs; 292 int stereo; 293}; 294 295static const struct sb16_mixent sb16_mixtab[32] = { 296 [SOUND_MIXER_VOLUME] = { 0x30, 5, 3, 1 }, 297 [SOUND_MIXER_PCM] = { 0x32, 5, 3, 1 }, 298 [SOUND_MIXER_SYNTH] = { 0x34, 5, 3, 1 }, 299 [SOUND_MIXER_CD] = { 0x36, 5, 3, 1 }, 300 [SOUND_MIXER_LINE] = { 0x38, 5, 3, 1 }, 301 [SOUND_MIXER_MIC] = { 0x3a, 5, 3, 0 }, 302 [SOUND_MIXER_SPEAKER] = { 0x3b, 5, 3, 0 }, 303 [SOUND_MIXER_IGAIN] = { 0x3f, 2, 6, 1 }, 304 [SOUND_MIXER_OGAIN] = { 0x41, 2, 6, 1 }, 305 [SOUND_MIXER_TREBLE] = { 0x44, 4, 4, 1 }, 306 [SOUND_MIXER_BASS] = { 0x46, 4, 4, 1 }, 307 [SOUND_MIXER_LINE1] = { 0x52, 5, 3, 1 } 308}; 309 310static int 311sb16mix_init(struct snd_mixer *m) 312{ 313 struct sb_info *sb = mix_getdevinfo(m); 314 315 mix_setdevs(m, SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_SPEAKER | 316 SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD | 317 SOUND_MASK_IGAIN | SOUND_MASK_OGAIN | SOUND_MASK_LINE1 | 318 SOUND_MASK_VOLUME | SOUND_MASK_BASS | SOUND_MASK_TREBLE); 319 320 mix_setrecdevs(m, SOUND_MASK_SYNTH | SOUND_MASK_LINE | 321 SOUND_MASK_LINE1 | SOUND_MASK_MIC | SOUND_MASK_CD); 322 323 sb_setmixer(sb, 0x3c, 0x1f); /* make all output active */ 324 325 sb_setmixer(sb, 0x3d, 0); /* make all inputs-l off */ 326 sb_setmixer(sb, 0x3e, 0); /* make all inputs-r off */ 327 328 return 0; 329} 330 331static int 332rel2abs_volume(int x, int max) 333{ 334 int temp; 335 336 temp = ((x * max) + 50) / 100; 337 if (temp > max) 338 temp = max; 339 else if (temp < 0) 340 temp = 0; 341 return (temp); 342} 343 344static int 345sb16mix_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right) 346{ 347 struct sb_info *sb = mix_getdevinfo(m); 348 const struct sb16_mixent *e; 349 int max; 350 351 e = &sb16_mixtab[dev]; 352 max = (1 << e->bits) - 1; 353 354 left = rel2abs_volume(left, max); 355 right = rel2abs_volume(right, max); 356 357 sb_setmixer(sb, e->reg, left << e->ofs); 358 if (e->stereo) 359 sb_setmixer(sb, e->reg + 1, right << e->ofs); 360 else 361 right = left; 362 363 left = (left * 100) / max; 364 right = (right * 100) / max; 365 366 return left | (right << 8); 367} 368 369static int 370sb16mix_setrecsrc(struct snd_mixer *m, u_int32_t src) 371{ 372 struct sb_info *sb = mix_getdevinfo(m); 373 u_char recdev; 374 375 recdev = 0; 376 if (src & SOUND_MASK_MIC) 377 recdev |= 0x01; /* mono mic */ 378 379 if (src & SOUND_MASK_CD) 380 recdev |= 0x06; /* l+r cd */ 381 382 if (src & SOUND_MASK_LINE) 383 recdev |= 0x18; /* l+r line */ 384 385 if (src & SOUND_MASK_SYNTH) 386 recdev |= 0x60; /* l+r midi */ 387 388 sb_setmixer(sb, SB16_IMASK_L, recdev); 389 sb_setmixer(sb, SB16_IMASK_R, recdev); 390 391 /* Switch on/off FM tuner source */ 392 if (src & SOUND_MASK_LINE1) 393 sb_setmixer(sb, 0x4a, 0x0c); 394 else 395 sb_setmixer(sb, 0x4a, 0x00); 396 397 /* 398 * since the same volume controls apply to the input and 399 * output sections, the best approach to have a consistent 400 * behaviour among cards would be to disable the output path 401 * on devices which are used to record. 402 * However, since users like to have feedback, we only disable 403 * the mic -- permanently. 404 */ 405 sb_setmixer(sb, SB16_OMASK, 0x1f & ~1); 406 407 return src; 408} 409 410static kobj_method_t sb16mix_mixer_methods[] = { 411 KOBJMETHOD(mixer_init, sb16mix_init), 412 KOBJMETHOD(mixer_set, sb16mix_set), 413 KOBJMETHOD(mixer_setrecsrc, sb16mix_setrecsrc), 414 { 0, 0 } 415}; 416MIXER_DECLARE(sb16mix_mixer); 417 418/************************************************************/ 419 420static void 421sb16_release_resources(struct sb_info *sb, device_t dev) 422{ 423 if (sb->irq) { 424 if (sb->ih) 425 bus_teardown_intr(dev, sb->irq, sb->ih); 426 bus_release_resource(dev, SYS_RES_IRQ, 0, sb->irq); 427 sb->irq = 0; 428 } 429 if (sb->drq2) { 430 if (sb->drq2 != sb->drq1) { 431 isa_dma_release(rman_get_start(sb->drq2)); 432 bus_release_resource(dev, SYS_RES_DRQ, 1, sb->drq2); 433 } 434 sb->drq2 = 0; 435 } 436 if (sb->drq1) { 437 isa_dma_release(rman_get_start(sb->drq1)); 438 bus_release_resource(dev, SYS_RES_DRQ, 0, sb->drq1); 439 sb->drq1 = 0; 440 } 441 if (sb->io_base) { 442 bus_release_resource(dev, SYS_RES_IOPORT, 0, sb->io_base); 443 sb->io_base = 0; 444 } 445 if (sb->parent_dmat) { 446 bus_dma_tag_destroy(sb->parent_dmat); 447 sb->parent_dmat = 0; 448 } 449 free(sb, M_DEVBUF); 450} 451 452static int 453sb16_alloc_resources(struct sb_info *sb, device_t dev) 454{ 455 int rid; 456 457 rid = 0; 458 if (!sb->io_base) 459 sb->io_base = bus_alloc_resource_any(dev, SYS_RES_IOPORT, 460 &rid, RF_ACTIVE); 461 462 rid = 0; 463 if (!sb->irq) 464 sb->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, 465 RF_ACTIVE); 466 467 rid = 0; 468 if (!sb->drq1) 469 sb->drq1 = bus_alloc_resource_any(dev, SYS_RES_DRQ, &rid, 470 RF_ACTIVE); 471 472 rid = 1; 473 if (!sb->drq2) 474 sb->drq2 = bus_alloc_resource_any(dev, SYS_RES_DRQ, &rid, 475 RF_ACTIVE); 476 477 if (sb->io_base && sb->drq1 && sb->irq) { 478 isa_dma_acquire(rman_get_start(sb->drq1)); 479 isa_dmainit(rman_get_start(sb->drq1), sb->bufsize); 480 481 if (sb->drq2) { 482 isa_dma_acquire(rman_get_start(sb->drq2)); 483 isa_dmainit(rman_get_start(sb->drq2), sb->bufsize); 484 } else { 485 sb->drq2 = sb->drq1; 486 pcm_setflags(dev, pcm_getflags(dev) | SD_F_SIMPLEX); 487 } 488 return 0; 489 } else return ENXIO; 490} 491 492/* sbc does locking for us */ 493static void 494sb_intr(void *arg) 495{ 496 struct sb_info *sb = (struct sb_info *)arg; 497 int reason, c; 498 499 /* 500 * The Vibra16X has separate flags for 8 and 16 bit transfers, but 501 * I have no idea how to tell capture from playback interrupts... 502 */ 503 504 reason = 0; 505 sb_lock(sb); 506 c = sb_getmixer(sb, IRQ_STAT); 507 if (c & 1) 508 sb_rd(sb, DSP_DATA_AVAIL); /* 8-bit int ack */ 509 510 if (c & 2) 511 sb_rd(sb, DSP_DATA_AVL16); /* 16-bit int ack */ 512 sb_unlock(sb); 513 514 /* 515 * this tells us if the source is 8-bit or 16-bit dma. We 516 * have to check the io channel to map it to read or write... 517 */ 518 519 if (sb->bd_flags & BD_F_SB16X) { 520 if (c & 1) { /* 8-bit format */ 521 if (sb->pch.fmt & AFMT_8BIT) 522 reason |= 1; 523 if (sb->rch.fmt & AFMT_8BIT) 524 reason |= 2; 525 } 526 if (c & 2) { /* 16-bit format */ 527 if (sb->pch.fmt & AFMT_16BIT) 528 reason |= 1; 529 if (sb->rch.fmt & AFMT_16BIT) 530 reason |= 2; 531 } 532 } else { 533 if (c & 1) { /* 8-bit dma */ 534 if (sb->pch.dch == 1) 535 reason |= 1; 536 if (sb->rch.dch == 1) 537 reason |= 2; 538 } 539 if (c & 2) { /* 16-bit dma */ 540 if (sb->pch.dch == 2) 541 reason |= 1; 542 if (sb->rch.dch == 2) 543 reason |= 2; 544 } 545 } 546#if 0 547 printf("sb_intr: reason=%d c=0x%x\n", reason, c); 548#endif 549 if ((reason & 1) && (sb->pch.run)) 550 chn_intr(sb->pch.channel); 551 552 if ((reason & 2) && (sb->rch.run)) 553 chn_intr(sb->rch.channel); 554} 555 556static int 557sb_setup(struct sb_info *sb) 558{ 559 struct sb_chinfo *ch; 560 u_int8_t v; 561 int l, pprio; 562 563 sb_lock(sb); 564 if (sb->bd_flags & BD_F_DMARUN) 565 sndbuf_dma(sb->pch.buffer, PCMTRIG_STOP); 566 if (sb->bd_flags & BD_F_DMARUN2) 567 sndbuf_dma(sb->rch.buffer, PCMTRIG_STOP); 568 sb->bd_flags &= ~(BD_F_DMARUN | BD_F_DMARUN2); 569 570 sb_reset_dsp(sb); 571 572 if (sb->bd_flags & BD_F_SB16X) { 573 /* full-duplex doesn't work! */ 574 pprio = sb->pch.run? 1 : 0; 575 sndbuf_dmasetup(sb->pch.buffer, pprio? sb->drq1 : sb->drq2); 576 sb->pch.dch = pprio? 1 : 0; 577 sndbuf_dmasetup(sb->rch.buffer, pprio? sb->drq2 : sb->drq1); 578 sb->rch.dch = pprio? 2 : 1; 579 } else { 580 if (sb->pch.run && sb->rch.run) { 581 pprio = (sb->rch.fmt & AFMT_16BIT)? 0 : 1; 582 sndbuf_dmasetup(sb->pch.buffer, pprio? sb->drq2 : sb->drq1); 583 sb->pch.dch = pprio? 2 : 1; 584 sndbuf_dmasetup(sb->rch.buffer, pprio? sb->drq1 : sb->drq2); 585 sb->rch.dch = pprio? 1 : 2; 586 } else { 587 if (sb->pch.run) { 588 sndbuf_dmasetup(sb->pch.buffer, (sb->pch.fmt & AFMT_16BIT)? sb->drq2 : sb->drq1); 589 sb->pch.dch = (sb->pch.fmt & AFMT_16BIT)? 2 : 1; 590 sndbuf_dmasetup(sb->rch.buffer, (sb->pch.fmt & AFMT_16BIT)? sb->drq1 : sb->drq2); 591 sb->rch.dch = (sb->pch.fmt & AFMT_16BIT)? 1 : 2; 592 } else if (sb->rch.run) { 593 sndbuf_dmasetup(sb->pch.buffer, (sb->rch.fmt & AFMT_16BIT)? sb->drq1 : sb->drq2); 594 sb->pch.dch = (sb->rch.fmt & AFMT_16BIT)? 1 : 2; 595 sndbuf_dmasetup(sb->rch.buffer, (sb->rch.fmt & AFMT_16BIT)? sb->drq2 : sb->drq1); 596 sb->rch.dch = (sb->rch.fmt & AFMT_16BIT)? 2 : 1; 597 } 598 } 599 } 600 601 sndbuf_dmasetdir(sb->pch.buffer, PCMDIR_PLAY); 602 sndbuf_dmasetdir(sb->rch.buffer, PCMDIR_REC); 603 604 /* 605 printf("setup: [pch = %d, pfmt = %d, pgo = %d] [rch = %d, rfmt = %d, rgo = %d]\n", 606 sb->pch.dch, sb->pch.fmt, sb->pch.run, sb->rch.dch, sb->rch.fmt, sb->rch.run); 607 */ 608 609 ch = &sb->pch; 610 if (ch->run) { 611 l = ch->blksz; 612 if (ch->fmt & AFMT_16BIT) 613 l >>= 1; 614 l--; 615 616 /* play speed */ 617 RANGE(ch->spd, 5000, 45000); 618 sb_cmd(sb, DSP_CMD_OUT16); 619 sb_cmd(sb, ch->spd >> 8); 620 sb_cmd(sb, ch->spd & 0xff); 621 622 /* play format, length */ 623 v = DSP_F16_AUTO | DSP_F16_FIFO_ON | DSP_F16_DAC; 624 v |= (ch->fmt & AFMT_16BIT)? DSP_DMA16 : DSP_DMA8; 625 sb_cmd(sb, v); 626 627 v = (ch->fmt & AFMT_STEREO)? DSP_F16_STEREO : 0; 628 v |= (ch->fmt & AFMT_SIGNED)? DSP_F16_SIGNED : 0; 629 sb_cmd2(sb, v, l); 630 sndbuf_dma(ch->buffer, PCMTRIG_START); 631 sb->bd_flags |= BD_F_DMARUN; 632 } 633 634 ch = &sb->rch; 635 if (ch->run) { 636 l = ch->blksz; 637 if (ch->fmt & AFMT_16BIT) 638 l >>= 1; 639 l--; 640 641 /* record speed */ 642 RANGE(ch->spd, 5000, 45000); 643 sb_cmd(sb, DSP_CMD_IN16); 644 sb_cmd(sb, ch->spd >> 8); 645 sb_cmd(sb, ch->spd & 0xff); 646 647 /* record format, length */ 648 v = DSP_F16_AUTO | DSP_F16_FIFO_ON | DSP_F16_ADC; 649 v |= (ch->fmt & AFMT_16BIT)? DSP_DMA16 : DSP_DMA8; 650 sb_cmd(sb, v); 651 652 v = (ch->fmt & AFMT_STEREO)? DSP_F16_STEREO : 0; 653 v |= (ch->fmt & AFMT_SIGNED)? DSP_F16_SIGNED : 0; 654 sb_cmd2(sb, v, l); 655 sndbuf_dma(ch->buffer, PCMTRIG_START); 656 sb->bd_flags |= BD_F_DMARUN2; 657 } 658 sb_unlock(sb); 659 660 return 0; 661} 662 663/* channel interface */ 664static void * 665sb16chan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir) 666{ 667 struct sb_info *sb = devinfo; 668 struct sb_chinfo *ch = (dir == PCMDIR_PLAY)? &sb->pch : &sb->rch; 669 670 ch->parent = sb; 671 ch->channel = c; 672 ch->buffer = b; 673 ch->dir = dir; 674 675 if (sndbuf_alloc(ch->buffer, sb->parent_dmat, sb->bufsize) != 0) 676 return NULL; 677 678 return ch; 679} 680 681static int 682sb16chan_setformat(kobj_t obj, void *data, u_int32_t format) 683{ 684 struct sb_chinfo *ch = data; 685 struct sb_info *sb = ch->parent; 686 687 ch->fmt = format; 688 sb->prio = ch->dir; 689 sb->prio16 = (ch->fmt & AFMT_16BIT)? 1 : 0; 690 691 return 0; 692} 693 694static int 695sb16chan_setspeed(kobj_t obj, void *data, u_int32_t speed) 696{ 697 struct sb_chinfo *ch = data; 698 699 ch->spd = speed; 700 return speed; 701} 702 703static int 704sb16chan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize) 705{ 706 struct sb_chinfo *ch = data; 707 708 ch->blksz = blocksize; 709 return ch->blksz; 710} 711 712static int 713sb16chan_trigger(kobj_t obj, void *data, int go) 714{ 715 struct sb_chinfo *ch = data; 716 struct sb_info *sb = ch->parent; 717 718 if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD) 719 return 0; 720 721 if (go == PCMTRIG_START) 722 ch->run = 1; 723 else 724 ch->run = 0; 725 726 sb_setup(sb); 727 728 return 0; 729} 730 731static int 732sb16chan_getptr(kobj_t obj, void *data) 733{ 734 struct sb_chinfo *ch = data; 735 736 return sndbuf_dmaptr(ch->buffer); 737} 738 739static struct pcmchan_caps * 740sb16chan_getcaps(kobj_t obj, void *data) 741{ 742 struct sb_chinfo *ch = data; 743 struct sb_info *sb = ch->parent; 744 745 if ((sb->prio == 0) || (sb->prio == ch->dir)) 746 return &sb16x_caps; 747 else 748 return sb->prio16? &sb16_caps8 : &sb16_caps16; 749} 750 751static int 752sb16chan_resetdone(kobj_t obj, void *data) 753{ 754 struct sb_chinfo *ch = data; 755 struct sb_info *sb = ch->parent; 756 757 sb->prio = 0; 758 759 return 0; 760} 761 762static kobj_method_t sb16chan_methods[] = { 763 KOBJMETHOD(channel_init, sb16chan_init), 764 KOBJMETHOD(channel_resetdone, sb16chan_resetdone), 765 KOBJMETHOD(channel_setformat, sb16chan_setformat), 766 KOBJMETHOD(channel_setspeed, sb16chan_setspeed), 767 KOBJMETHOD(channel_setblocksize, sb16chan_setblocksize), 768 KOBJMETHOD(channel_trigger, sb16chan_trigger), 769 KOBJMETHOD(channel_getptr, sb16chan_getptr), 770 KOBJMETHOD(channel_getcaps, sb16chan_getcaps), 771 { 0, 0 } 772}; 773CHANNEL_DECLARE(sb16chan); 774 775/************************************************************/ 776 777static int 778sb16_probe(device_t dev) 779{ 780 char buf[64]; 781 uintptr_t func, ver, r, f; 782 783 /* The parent device has already been probed. */ 784 r = BUS_READ_IVAR(device_get_parent(dev), dev, 0, &func); 785 if (func != SCF_PCM) 786 return (ENXIO); 787 788 r = BUS_READ_IVAR(device_get_parent(dev), dev, 1, &ver); 789 f = (ver & 0xffff0000) >> 16; 790 ver &= 0x0000ffff; 791 if (f & BD_F_SB16) { 792 snprintf(buf, sizeof buf, "SB16 DSP %d.%02d%s", (int) ver >> 8, (int) ver & 0xff, 793 (f & BD_F_SB16X)? " (ViBRA16X)" : ""); 794 device_set_desc_copy(dev, buf); 795 return 0; 796 } else 797 return (ENXIO); 798} 799 800static int 801sb16_attach(device_t dev) 802{ 803 struct sb_info *sb; 804 uintptr_t ver; 805 char status[SND_STATUSLEN], status2[SND_STATUSLEN]; 806 807 sb = (struct sb_info *)malloc(sizeof *sb, M_DEVBUF, M_NOWAIT | M_ZERO); 808 if (!sb) 809 return ENXIO; 810 811 sb->parent_dev = device_get_parent(dev); 812 BUS_READ_IVAR(sb->parent_dev, dev, 1, &ver); 813 sb->bd_id = ver & 0x0000ffff; 814 sb->bd_flags = (ver & 0xffff0000) >> 16; 815 sb->bufsize = pcm_getbuffersize(dev, 4096, SB16_BUFFSIZE, 65536); 816 817 if (sb16_alloc_resources(sb, dev)) 818 goto no; 819 sb_lock(sb); 820 if (sb_reset_dsp(sb)) { 821 sb_unlock(sb); 822 goto no; 823 } 824 sb_unlock(sb); 825 if (mixer_init(dev, &sb16mix_mixer_class, sb)) 826 goto no; 827 if (snd_setup_intr(dev, sb->irq, 0, sb_intr, sb, &sb->ih)) 828 goto no; 829 830 if (sb->bd_flags & BD_F_SB16X) 831 pcm_setflags(dev, pcm_getflags(dev) | SD_F_SIMPLEX); 832 833 sb->prio = 0; 834 835 if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0, 836 /*lowaddr*/BUS_SPACE_MAXADDR_24BIT, 837 /*highaddr*/BUS_SPACE_MAXADDR, 838 /*filter*/NULL, /*filterarg*/NULL, 839 /*maxsize*/sb->bufsize, /*nsegments*/1, 840 /*maxsegz*/0x3ffff, /*flags*/0, 841 /*lockfunc*/busdma_lock_mutex, /*lockarg*/&Giant, 842 &sb->parent_dmat) != 0) { 843 device_printf(dev, "unable to create dma tag\n"); 844 goto no; 845 } 846 847 if (!(pcm_getflags(dev) & SD_F_SIMPLEX)) 848 snprintf(status2, SND_STATUSLEN, ":%ld", rman_get_start(sb->drq2)); 849 else 850 status2[0] = '\0'; 851 852 snprintf(status, SND_STATUSLEN, "at io 0x%lx irq %ld drq %ld%s bufsz %ud %s", 853 rman_get_start(sb->io_base), rman_get_start(sb->irq), 854 rman_get_start(sb->drq1), status2, sb->bufsize, 855 PCM_KLDSTRING(snd_sb16)); 856 857 if (pcm_register(dev, sb, 1, 1)) 858 goto no; 859 pcm_addchan(dev, PCMDIR_REC, &sb16chan_class, sb); 860 pcm_addchan(dev, PCMDIR_PLAY, &sb16chan_class, sb); 861 862 pcm_setstatus(dev, status); 863 864 return 0; 865 866no: 867 sb16_release_resources(sb, dev); 868 return ENXIO; 869} 870 871static int 872sb16_detach(device_t dev) 873{ 874 int r; 875 struct sb_info *sb; 876 877 r = pcm_unregister(dev); 878 if (r) 879 return r; 880 881 sb = pcm_getdevinfo(dev); 882 sb16_release_resources(sb, dev); 883 return 0; 884} 885 886static device_method_t sb16_methods[] = { 887 /* Device interface */ 888 DEVMETHOD(device_probe, sb16_probe), 889 DEVMETHOD(device_attach, sb16_attach), 890 DEVMETHOD(device_detach, sb16_detach), 891 892 { 0, 0 } 893}; 894 895static driver_t sb16_driver = { 896 "pcm", 897 sb16_methods, 898 PCM_SOFTC_SIZE, 899}; 900 901DRIVER_MODULE(snd_sb16, sbc, sb16_driver, pcm_devclass, 0, 0); 902MODULE_DEPEND(snd_sb16, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER); 903MODULE_DEPEND(snd_sb16, snd_sbc, 1, 1, 1); 904MODULE_VERSION(snd_sb16, 1); 905