sb16.c revision 135115
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 135115 2004-09-12 18:19:42Z truckman $"); 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 = 3, 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 pprio = sb->pch.run? 1 : 0; 574 sndbuf_dmasetup(sb->pch.buffer, pprio? sb->drq1 : NULL); 575 sb->pch.dch = pprio? 1 : 0; 576 sndbuf_dmasetup(sb->rch.buffer, pprio? sb->drq2 : sb->drq1); 577 sb->rch.dch = pprio? 2 : 1; 578 } else { 579 if (sb->pch.run && sb->rch.run) { 580 pprio = (sb->rch.fmt & AFMT_16BIT)? 0 : 1; 581 sndbuf_dmasetup(sb->pch.buffer, pprio? sb->drq2 : sb->drq1); 582 sb->pch.dch = pprio? 2 : 1; 583 sndbuf_dmasetup(sb->rch.buffer, pprio? sb->drq1 : sb->drq2); 584 sb->rch.dch = pprio? 1 : 2; 585 } else { 586 if (sb->pch.run) { 587 sndbuf_dmasetup(sb->pch.buffer, (sb->pch.fmt & AFMT_16BIT)? sb->drq2 : sb->drq1); 588 sb->pch.dch = (sb->pch.fmt & AFMT_16BIT)? 2 : 1; 589 sndbuf_dmasetup(sb->rch.buffer, (sb->pch.fmt & AFMT_16BIT)? sb->drq1 : sb->drq2); 590 sb->rch.dch = (sb->pch.fmt & AFMT_16BIT)? 1 : 2; 591 } else if (sb->rch.run) { 592 sndbuf_dmasetup(sb->pch.buffer, (sb->rch.fmt & AFMT_16BIT)? sb->drq1 : sb->drq2); 593 sb->pch.dch = (sb->rch.fmt & AFMT_16BIT)? 1 : 2; 594 sndbuf_dmasetup(sb->rch.buffer, (sb->rch.fmt & AFMT_16BIT)? sb->drq2 : sb->drq1); 595 sb->rch.dch = (sb->rch.fmt & AFMT_16BIT)? 2 : 1; 596 } 597 } 598 } 599 600 sndbuf_dmasetdir(sb->pch.buffer, PCMDIR_PLAY); 601 sndbuf_dmasetdir(sb->rch.buffer, PCMDIR_REC); 602 603 /* 604 printf("setup: [pch = %d, pfmt = %d, pgo = %d] [rch = %d, rfmt = %d, rgo = %d]\n", 605 sb->pch.dch, sb->pch.fmt, sb->pch.run, sb->rch.dch, sb->rch.fmt, sb->rch.run); 606 */ 607 608 ch = &sb->pch; 609 if (ch->run) { 610 l = ch->blksz; 611 if (ch->fmt & AFMT_16BIT) 612 l >>= 1; 613 l--; 614 615 /* play speed */ 616 RANGE(ch->spd, 5000, 45000); 617 sb_cmd(sb, DSP_CMD_OUT16); 618 sb_cmd(sb, ch->spd >> 8); 619 sb_cmd(sb, ch->spd & 0xff); 620 621 /* play format, length */ 622 v = DSP_F16_AUTO | DSP_F16_FIFO_ON | DSP_F16_DAC; 623 v |= (ch->fmt & AFMT_16BIT)? DSP_DMA16 : DSP_DMA8; 624 sb_cmd(sb, v); 625 626 v = (ch->fmt & AFMT_STEREO)? DSP_F16_STEREO : 0; 627 v |= (ch->fmt & AFMT_SIGNED)? DSP_F16_SIGNED : 0; 628 sb_cmd2(sb, v, l); 629 sndbuf_dma(ch->buffer, PCMTRIG_START); 630 sb->bd_flags |= BD_F_DMARUN; 631 } 632 633 ch = &sb->rch; 634 if (ch->run) { 635 l = ch->blksz; 636 if (ch->fmt & AFMT_16BIT) 637 l >>= 1; 638 l--; 639 640 /* record speed */ 641 RANGE(ch->spd, 5000, 45000); 642 sb_cmd(sb, DSP_CMD_IN16); 643 sb_cmd(sb, ch->spd >> 8); 644 sb_cmd(sb, ch->spd & 0xff); 645 646 /* record format, length */ 647 v = DSP_F16_AUTO | DSP_F16_FIFO_ON | DSP_F16_ADC; 648 v |= (ch->fmt & AFMT_16BIT)? DSP_DMA16 : DSP_DMA8; 649 sb_cmd(sb, v); 650 651 v = (ch->fmt & AFMT_STEREO)? DSP_F16_STEREO : 0; 652 v |= (ch->fmt & AFMT_SIGNED)? DSP_F16_SIGNED : 0; 653 sb_cmd2(sb, v, l); 654 sndbuf_dma(ch->buffer, PCMTRIG_START); 655 sb->bd_flags |= BD_F_DMARUN2; 656 } 657 sb_unlock(sb); 658 659 return 0; 660} 661 662/* channel interface */ 663static void * 664sb16chan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir) 665{ 666 struct sb_info *sb = devinfo; 667 struct sb_chinfo *ch = (dir == PCMDIR_PLAY)? &sb->pch : &sb->rch; 668 669 ch->parent = sb; 670 ch->channel = c; 671 ch->buffer = b; 672 ch->dir = dir; 673 674 if (sndbuf_alloc(ch->buffer, sb->parent_dmat, sb->bufsize) == -1) 675 return NULL; 676 677 return ch; 678} 679 680static int 681sb16chan_setformat(kobj_t obj, void *data, u_int32_t format) 682{ 683 struct sb_chinfo *ch = data; 684 struct sb_info *sb = ch->parent; 685 686 ch->fmt = format; 687 sb->prio = ch->dir; 688 sb->prio16 = (ch->fmt & AFMT_16BIT)? 1 : 0; 689 690 return 0; 691} 692 693static int 694sb16chan_setspeed(kobj_t obj, void *data, u_int32_t speed) 695{ 696 struct sb_chinfo *ch = data; 697 698 ch->spd = speed; 699 return speed; 700} 701 702static int 703sb16chan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize) 704{ 705 struct sb_chinfo *ch = data; 706 707 ch->blksz = blocksize; 708 return ch->blksz; 709} 710 711static int 712sb16chan_trigger(kobj_t obj, void *data, int go) 713{ 714 struct sb_chinfo *ch = data; 715 struct sb_info *sb = ch->parent; 716 717 if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD) 718 return 0; 719 720 if (go == PCMTRIG_START) 721 ch->run = 1; 722 else 723 ch->run = 0; 724 725 sb_setup(sb); 726 727 return 0; 728} 729 730static int 731sb16chan_getptr(kobj_t obj, void *data) 732{ 733 struct sb_chinfo *ch = data; 734 735 return sndbuf_dmaptr(ch->buffer); 736} 737 738static struct pcmchan_caps * 739sb16chan_getcaps(kobj_t obj, void *data) 740{ 741 struct sb_chinfo *ch = data; 742 struct sb_info *sb = ch->parent; 743 744 if ((sb->prio == 0) || (sb->prio == ch->dir)) 745 return &sb16x_caps; 746 else 747 return sb->prio16? &sb16_caps8 : &sb16_caps16; 748} 749 750static int 751sb16chan_resetdone(kobj_t obj, void *data) 752{ 753 struct sb_chinfo *ch = data; 754 struct sb_info *sb = ch->parent; 755 756 sb->prio = 0; 757 758 return 0; 759} 760 761static kobj_method_t sb16chan_methods[] = { 762 KOBJMETHOD(channel_init, sb16chan_init), 763 KOBJMETHOD(channel_resetdone, sb16chan_resetdone), 764 KOBJMETHOD(channel_setformat, sb16chan_setformat), 765 KOBJMETHOD(channel_setspeed, sb16chan_setspeed), 766 KOBJMETHOD(channel_setblocksize, sb16chan_setblocksize), 767 KOBJMETHOD(channel_trigger, sb16chan_trigger), 768 KOBJMETHOD(channel_getptr, sb16chan_getptr), 769 KOBJMETHOD(channel_getcaps, sb16chan_getcaps), 770 { 0, 0 } 771}; 772CHANNEL_DECLARE(sb16chan); 773 774/************************************************************/ 775 776static int 777sb16_probe(device_t dev) 778{ 779 char buf[64]; 780 uintptr_t func, ver, r, f; 781 782 /* The parent device has already been probed. */ 783 r = BUS_READ_IVAR(device_get_parent(dev), dev, 0, &func); 784 if (func != SCF_PCM) 785 return (ENXIO); 786 787 r = BUS_READ_IVAR(device_get_parent(dev), dev, 1, &ver); 788 f = (ver & 0xffff0000) >> 16; 789 ver &= 0x0000ffff; 790 if (f & BD_F_SB16) { 791 snprintf(buf, sizeof buf, "SB16 DSP %d.%02d%s", (int) ver >> 8, (int) ver & 0xff, 792 (f & BD_F_SB16X)? " (ViBRA16X)" : ""); 793 device_set_desc_copy(dev, buf); 794 return 0; 795 } else 796 return (ENXIO); 797} 798 799static int 800sb16_attach(device_t dev) 801{ 802 struct sb_info *sb; 803 uintptr_t ver; 804 char status[SND_STATUSLEN], status2[SND_STATUSLEN]; 805 806 sb = (struct sb_info *)malloc(sizeof *sb, M_DEVBUF, M_NOWAIT | M_ZERO); 807 if (!sb) 808 return ENXIO; 809 810 sb->parent_dev = device_get_parent(dev); 811 BUS_READ_IVAR(sb->parent_dev, dev, 1, &ver); 812 sb->bd_id = ver & 0x0000ffff; 813 sb->bd_flags = (ver & 0xffff0000) >> 16; 814 sb->bufsize = pcm_getbuffersize(dev, 4096, SB16_BUFFSIZE, 65536); 815 816 if (sb16_alloc_resources(sb, dev)) 817 goto no; 818 sb_lock(sb); 819 if (sb_reset_dsp(sb)) { 820 sb_unlock(sb); 821 goto no; 822 } 823 sb_unlock(sb); 824 if (mixer_init(dev, &sb16mix_mixer_class, sb)) 825 goto no; 826 if (snd_setup_intr(dev, sb->irq, 0, sb_intr, sb, &sb->ih)) 827 goto no; 828 829 if (sb->bd_flags & BD_F_SB16X) 830 pcm_setflags(dev, pcm_getflags(dev) | SD_F_SIMPLEX); 831 832 sb->prio = 0; 833 834 if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0, 835 /*lowaddr*/BUS_SPACE_MAXADDR_24BIT, 836 /*highaddr*/BUS_SPACE_MAXADDR, 837 /*filter*/NULL, /*filterarg*/NULL, 838 /*maxsize*/sb->bufsize, /*nsegments*/1, 839 /*maxsegz*/0x3ffff, /*flags*/0, 840 /*lockfunc*/busdma_lock_mutex, /*lockarg*/&Giant, 841 &sb->parent_dmat) != 0) { 842 device_printf(dev, "unable to create dma tag\n"); 843 goto no; 844 } 845 846 if (!(pcm_getflags(dev) & SD_F_SIMPLEX)) 847 snprintf(status2, SND_STATUSLEN, ":%ld", rman_get_start(sb->drq2)); 848 else 849 status2[0] = '\0'; 850 851 snprintf(status, SND_STATUSLEN, "at io 0x%lx irq %ld drq %ld%s bufsz %ud %s", 852 rman_get_start(sb->io_base), rman_get_start(sb->irq), 853 rman_get_start(sb->drq1), status2, sb->bufsize, 854 PCM_KLDSTRING(snd_sb16)); 855 856 if (pcm_register(dev, sb, 1, 1)) 857 goto no; 858 pcm_addchan(dev, PCMDIR_REC, &sb16chan_class, sb); 859 pcm_addchan(dev, PCMDIR_PLAY, &sb16chan_class, sb); 860 861 pcm_setstatus(dev, status); 862 863 return 0; 864 865no: 866 sb16_release_resources(sb, dev); 867 return ENXIO; 868} 869 870static int 871sb16_detach(device_t dev) 872{ 873 int r; 874 struct sb_info *sb; 875 876 r = pcm_unregister(dev); 877 if (r) 878 return r; 879 880 sb = pcm_getdevinfo(dev); 881 sb16_release_resources(sb, dev); 882 return 0; 883} 884 885static device_method_t sb16_methods[] = { 886 /* Device interface */ 887 DEVMETHOD(device_probe, sb16_probe), 888 DEVMETHOD(device_attach, sb16_attach), 889 DEVMETHOD(device_detach, sb16_detach), 890 891 { 0, 0 } 892}; 893 894static driver_t sb16_driver = { 895 "pcm", 896 sb16_methods, 897 PCM_SOFTC_SIZE, 898}; 899 900DRIVER_MODULE(snd_sb16, sbc, sb16_driver, pcm_devclass, 0, 0); 901MODULE_DEPEND(snd_sb16, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER); 902MODULE_DEPEND(snd_sb16, snd_sbc, 1, 1, 1); 903MODULE_VERSION(snd_sb16, 1); 904