1 /*- 2 * Copyright (c) 1999 Cameron Grant <cg@freebsd.org> 3 * All rights reserved. 4 * 5 * Derived from the public domain Linux driver 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHERIN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THEPOSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #ifdef HAVE_KERNEL_OPTION_HEADERS 30 #include "opt_snd.h" 31 #endif 32 33 #include <dev/sound/pcm/sound.h> 34 #include <dev/sound/pcm/ac97.h> 35 #include <dev/sound/pci/neomagic.h> 36 #include <dev/sound/pci/neomagic-coeff.h> 37 38 #include <dev/pci/pcireg.h> 39 #include <dev/pci/pcivar.h> 40 41 SND_DECLARE_FILE("$FreeBSD$"); 42 43 /* -------------------------------------------------------------------- */ 44 45 #define NM_BUFFSIZE 16384 46 47 #define NM256AV_PCI_ID 0x800510c8 48 #define NM256ZX_PCI_ID 0x800610c8 49 50 struct sc_info; 51 52 /* channel registers */ 53 struct sc_chinfo { 54 int active, spd, dir, fmt; 55 u_int32_t blksize, wmark; 56 struct snd_dbuf *buffer; 57 struct pcm_channel *channel; 58 struct sc_info *parent; 59 }; 60 61 /* device private data */ 62 struct sc_info { 63 device_t dev; 64 u_int32_t type; 65 66 struct resource *reg, *irq, *buf; 67 int regid, irqid, bufid; 68 void *ih; 69 70 u_int32_t ac97_base, ac97_status, ac97_busy; 71 u_int32_t buftop, pbuf, rbuf, cbuf, acbuf; 72 u_int32_t playint, recint, misc1int, misc2int; 73 u_int32_t irsz, badintr; 74 75 struct sc_chinfo pch, rch; 76 }; 77 78 /* -------------------------------------------------------------------- */ 79 80 /* 81 * prototypes 82 */ 83 84 /* stuff */ 85 static int nm_loadcoeff(struct sc_info *sc, int dir, int num); 86 static int nm_setch(struct sc_chinfo *ch); 87 static int nm_init(struct sc_info *); 88 static void nm_intr(void *); 89 90 /* talk to the card */ 91 static u_int32_t nm_rd(struct sc_info *, int, int); 92 static void nm_wr(struct sc_info *, int, u_int32_t, int); 93 static u_int32_t nm_rdbuf(struct sc_info *, int, int); 94 static void nm_wrbuf(struct sc_info *, int, u_int32_t, int); 95 96 static u_int32_t badcards[] = { 97 0x0007103c, 98 0x008f1028, 99 0x00dd1014, 100 0x8005110a, 101 }; 102 #define NUM_BADCARDS (sizeof(badcards) / sizeof(u_int32_t)) 103 104 /* The actual rates supported by the card. */ 105 static int samplerates[9] = { 106 8000, 107 11025, 108 16000, 109 22050, 110 24000, 111 32000, 112 44100, 113 48000, 114 99999999 115 }; 116 117 /* -------------------------------------------------------------------- */ 118 119 static u_int32_t nm_fmt[] = { 120 SND_FORMAT(AFMT_U8, 1, 0), 121 SND_FORMAT(AFMT_U8, 2, 0), 122 SND_FORMAT(AFMT_S16_LE, 1, 0), 123 SND_FORMAT(AFMT_S16_LE, 2, 0), 124 0 125 }; 126 static struct pcmchan_caps nm_caps = {4000, 48000, nm_fmt, 0}; 127 128 /* -------------------------------------------------------------------- */ 129 130 /* Hardware */ 131 static u_int32_t 132 nm_rd(struct sc_info *sc, int regno, int size) 133 { 134 bus_space_tag_t st = rman_get_bustag(sc->reg); 135 bus_space_handle_t sh = rman_get_bushandle(sc->reg); 136 137 switch (size) { 138 case 1: 139 return bus_space_read_1(st, sh, regno); 140 case 2: 141 return bus_space_read_2(st, sh, regno); 142 case 4: 143 return bus_space_read_4(st, sh, regno); 144 default: 145 return 0xffffffff; 146 } 147 } 148 149 static void 150 nm_wr(struct sc_info *sc, int regno, u_int32_t data, int size) 151 { 152 bus_space_tag_t st = rman_get_bustag(sc->reg); 153 bus_space_handle_t sh = rman_get_bushandle(sc->reg); 154 155 switch (size) { 156 case 1: 157 bus_space_write_1(st, sh, regno, data); 158 break; 159 case 2: 160 bus_space_write_2(st, sh, regno, data); 161 break; 162 case 4: 163 bus_space_write_4(st, sh, regno, data); 164 break; 165 } 166 } 167 168 static u_int32_t 169 nm_rdbuf(struct sc_info *sc, int regno, int size) 170 { 171 bus_space_tag_t st = rman_get_bustag(sc->buf); 172 bus_space_handle_t sh = rman_get_bushandle(sc->buf); 173 174 switch (size) { 175 case 1: 176 return bus_space_read_1(st, sh, regno); 177 case 2: 178 return bus_space_read_2(st, sh, regno); 179 case 4: 180 return bus_space_read_4(st, sh, regno); 181 default: 182 return 0xffffffff; 183 } 184 } 185 186 static void 187 nm_wrbuf(struct sc_info *sc, int regno, u_int32_t data, int size) 188 { 189 bus_space_tag_t st = rman_get_bustag(sc->buf); 190 bus_space_handle_t sh = rman_get_bushandle(sc->buf); 191 192 switch (size) { 193 case 1: 194 bus_space_write_1(st, sh, regno, data); 195 break; 196 case 2: 197 bus_space_write_2(st, sh, regno, data); 198 break; 199 case 4: 200 bus_space_write_4(st, sh, regno, data); 201 break; 202 } 203 } 204 205 /* -------------------------------------------------------------------- */ 206 /* ac97 codec */ 207 static int 208 nm_waitcd(struct sc_info *sc) 209 { 210 int cnt = 10; 211 int fail = 1; 212 213 while (cnt-- > 0) { 214 if (nm_rd(sc, sc->ac97_status, 2) & sc->ac97_busy) { 215 DELAY(100); 216 } else { 217 fail = 0; 218 break; 219 } 220 } 221 return (fail); 222 } 223 224 static u_int32_t 225 nm_initcd(kobj_t obj, void *devinfo) 226 { 227 struct sc_info *sc = (struct sc_info *)devinfo; 228 229 nm_wr(sc, 0x6c0, 0x01, 1); 230 #if 0 231 /* 232 * The following code-line may cause a hang for some chipsets, see 233 * PR 56617. 234 * In case of a bugreport without this line have a look at the PR and 235 * conditionize the code-line based upon the specific version of 236 * the chip. 237 */ 238 nm_wr(sc, 0x6cc, 0x87, 1); 239 #endif 240 nm_wr(sc, 0x6cc, 0x80, 1); 241 nm_wr(sc, 0x6cc, 0x00, 1); 242 return 1; 243 } 244 245 static int 246 nm_rdcd(kobj_t obj, void *devinfo, int regno) 247 { 248 struct sc_info *sc = (struct sc_info *)devinfo; 249 u_int32_t x; 250 251 if (!nm_waitcd(sc)) { 252 x = nm_rd(sc, sc->ac97_base + regno, 2); 253 DELAY(1000); 254 return x; 255 } else { 256 device_printf(sc->dev, "ac97 codec not ready\n"); 257 return -1; 258 } 259 } 260 261 static int 262 nm_wrcd(kobj_t obj, void *devinfo, int regno, u_int32_t data) 263 { 264 struct sc_info *sc = (struct sc_info *)devinfo; 265 int cnt = 3; 266 267 if (!nm_waitcd(sc)) { 268 while (cnt-- > 0) { 269 nm_wr(sc, sc->ac97_base + regno, data, 2); 270 if (!nm_waitcd(sc)) { 271 DELAY(1000); 272 return 0; 273 } 274 } 275 } 276 device_printf(sc->dev, "ac97 codec not ready\n"); 277 return -1; 278 } 279 280 static kobj_method_t nm_ac97_methods[] = { 281 KOBJMETHOD(ac97_init, nm_initcd), 282 KOBJMETHOD(ac97_read, nm_rdcd), 283 KOBJMETHOD(ac97_write, nm_wrcd), 284 KOBJMETHOD_END 285 }; 286 AC97_DECLARE(nm_ac97); 287 288 /* -------------------------------------------------------------------- */ 289 290 static void 291 nm_ackint(struct sc_info *sc, u_int32_t num) 292 { 293 if (sc->type == NM256AV_PCI_ID) { 294 nm_wr(sc, NM_INT_REG, num << 1, 2); 295 } else if (sc->type == NM256ZX_PCI_ID) { 296 nm_wr(sc, NM_INT_REG, num, 4); 297 } 298 } 299 300 static int 301 nm_loadcoeff(struct sc_info *sc, int dir, int num) 302 { 303 int ofs, sz, i; 304 u_int32_t addr; 305 306 addr = (dir == PCMDIR_PLAY)? 0x01c : 0x21c; 307 if (dir == PCMDIR_REC) 308 num += 8; 309 sz = coefficientSizes[num]; 310 ofs = 0; 311 while (num-- > 0) 312 ofs+= coefficientSizes[num]; 313 for (i = 0; i < sz; i++) 314 nm_wrbuf(sc, sc->cbuf + i, coefficients[ofs + i], 1); 315 nm_wr(sc, addr, sc->cbuf, 4); 316 if (dir == PCMDIR_PLAY) 317 sz--; 318 nm_wr(sc, addr + 4, sc->cbuf + sz, 4); 319 return 0; 320 } 321 322 static int 323 nm_setch(struct sc_chinfo *ch) 324 { 325 struct sc_info *sc = ch->parent; 326 u_int32_t base; 327 u_int8_t x; 328 329 for (x = 0; x < 8; x++) 330 if (ch->spd < (samplerates[x] + samplerates[x + 1]) / 2) 331 break; 332 333 if (x == 8) return 1; 334 335 ch->spd = samplerates[x]; 336 nm_loadcoeff(sc, ch->dir, x); 337 338 x <<= 4; 339 x &= NM_RATE_MASK; 340 if (ch->fmt & AFMT_16BIT) x |= NM_RATE_BITS_16; 341 if (AFMT_CHANNEL(ch->fmt) > 1) x |= NM_RATE_STEREO; 342 343 base = (ch->dir == PCMDIR_PLAY)? NM_PLAYBACK_REG_OFFSET : NM_RECORD_REG_OFFSET; 344 nm_wr(sc, base + NM_RATE_REG_OFFSET, x, 1); 345 return 0; 346 } 347 348 /* channel interface */ 349 static void * 350 nmchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir) 351 { 352 struct sc_info *sc = devinfo; 353 struct sc_chinfo *ch; 354 u_int32_t chnbuf; 355 356 chnbuf = (dir == PCMDIR_PLAY)? sc->pbuf : sc->rbuf; 357 ch = (dir == PCMDIR_PLAY)? &sc->pch : &sc->rch; 358 ch->active = 0; 359 ch->blksize = 0; 360 ch->wmark = 0; 361 ch->buffer = b; 362 sndbuf_setup(ch->buffer, (u_int8_t *)rman_get_virtual(sc->buf) + chnbuf, NM_BUFFSIZE); 363 if (bootverbose) 364 device_printf(sc->dev, "%s buf %p\n", (dir == PCMDIR_PLAY)? 365 "play" : "rec", sndbuf_getbuf(ch->buffer)); 366 ch->parent = sc; 367 ch->channel = c; 368 ch->dir = dir; 369 return ch; 370 } 371 372 static int 373 nmchan_free(kobj_t obj, void *data) 374 { 375 return 0; 376 } 377 378 static int 379 nmchan_setformat(kobj_t obj, void *data, u_int32_t format) 380 { 381 struct sc_chinfo *ch = data; 382 383 ch->fmt = format; 384 return nm_setch(ch); 385 } 386 387 static u_int32_t 388 nmchan_setspeed(kobj_t obj, void *data, u_int32_t speed) 389 { 390 struct sc_chinfo *ch = data; 391 392 ch->spd = speed; 393 return nm_setch(ch)? 0 : ch->spd; 394 } 395 396 static u_int32_t 397 nmchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize) 398 { 399 struct sc_chinfo *ch = data; 400 401 ch->blksize = blocksize; 402 403 return blocksize; 404 } 405 406 static int 407 nmchan_trigger(kobj_t obj, void *data, int go) 408 { 409 struct sc_chinfo *ch = data; 410 struct sc_info *sc = ch->parent; 411 int ssz; 412 413 if (!PCMTRIG_COMMON(go)) 414 return 0; 415 416 ssz = (ch->fmt & AFMT_16BIT)? 2 : 1; 417 if (AFMT_CHANNEL(ch->fmt) > 1) 418 ssz <<= 1; 419 420 if (ch->dir == PCMDIR_PLAY) { 421 if (go == PCMTRIG_START) { 422 ch->active = 1; 423 ch->wmark = ch->blksize; 424 nm_wr(sc, NM_PBUFFER_START, sc->pbuf, 4); 425 nm_wr(sc, NM_PBUFFER_END, sc->pbuf + NM_BUFFSIZE - ssz, 4); 426 nm_wr(sc, NM_PBUFFER_CURRP, sc->pbuf, 4); 427 nm_wr(sc, NM_PBUFFER_WMARK, sc->pbuf + ch->wmark, 4); 428 nm_wr(sc, NM_PLAYBACK_ENABLE_REG, NM_PLAYBACK_FREERUN | 429 NM_PLAYBACK_ENABLE_FLAG, 1); 430 nm_wr(sc, NM_AUDIO_MUTE_REG, 0, 2); 431 } else { 432 ch->active = 0; 433 nm_wr(sc, NM_PLAYBACK_ENABLE_REG, 0, 1); 434 nm_wr(sc, NM_AUDIO_MUTE_REG, NM_AUDIO_MUTE_BOTH, 2); 435 } 436 } else { 437 if (go == PCMTRIG_START) { 438 ch->active = 1; 439 ch->wmark = ch->blksize; 440 nm_wr(sc, NM_RECORD_ENABLE_REG, NM_RECORD_FREERUN | 441 NM_RECORD_ENABLE_FLAG, 1); 442 nm_wr(sc, NM_RBUFFER_START, sc->rbuf, 4); 443 nm_wr(sc, NM_RBUFFER_END, sc->rbuf + NM_BUFFSIZE, 4); 444 nm_wr(sc, NM_RBUFFER_CURRP, sc->rbuf, 4); 445 nm_wr(sc, NM_RBUFFER_WMARK, sc->rbuf + ch->wmark, 4); 446 } else { 447 ch->active = 0; 448 nm_wr(sc, NM_RECORD_ENABLE_REG, 0, 1); 449 } 450 } 451 return 0; 452 } 453 454 static u_int32_t 455 nmchan_getptr(kobj_t obj, void *data) 456 { 457 struct sc_chinfo *ch = data; 458 struct sc_info *sc = ch->parent; 459 460 if (ch->dir == PCMDIR_PLAY) 461 return nm_rd(sc, NM_PBUFFER_CURRP, 4) - sc->pbuf; 462 else 463 return nm_rd(sc, NM_RBUFFER_CURRP, 4) - sc->rbuf; 464 } 465 466 static struct pcmchan_caps * 467 nmchan_getcaps(kobj_t obj, void *data) 468 { 469 return &nm_caps; 470 } 471 472 static kobj_method_t nmchan_methods[] = { 473 KOBJMETHOD(channel_init, nmchan_init), 474 KOBJMETHOD(channel_free, nmchan_free), 475 KOBJMETHOD(channel_setformat, nmchan_setformat), 476 KOBJMETHOD(channel_setspeed, nmchan_setspeed), 477 KOBJMETHOD(channel_setblocksize, nmchan_setblocksize), 478 KOBJMETHOD(channel_trigger, nmchan_trigger), 479 KOBJMETHOD(channel_getptr, nmchan_getptr), 480 KOBJMETHOD(channel_getcaps, nmchan_getcaps), 481 KOBJMETHOD_END 482 }; 483 CHANNEL_DECLARE(nmchan); 484 485 /* The interrupt handler */ 486 static void 487 nm_intr(void *p) 488 { 489 struct sc_info *sc = (struct sc_info *)p; 490 int status, x; 491 492 status = nm_rd(sc, NM_INT_REG, sc->irsz); 493 if (status == 0) 494 return; 495 496 if (status & sc->playint) { 497 status &= ~sc->playint; 498 sc->pch.wmark += sc->pch.blksize; 499 sc->pch.wmark %= NM_BUFFSIZE; 500 nm_wr(sc, NM_PBUFFER_WMARK, sc->pbuf + sc->pch.wmark, 4); 501 502 nm_ackint(sc, sc->playint); 503 chn_intr(sc->pch.channel); 504 } 505 if (status & sc->recint) { 506 status &= ~sc->recint; 507 sc->rch.wmark += sc->rch.blksize; 508 sc->rch.wmark %= NM_BUFFSIZE; 509 nm_wr(sc, NM_RBUFFER_WMARK, sc->rbuf + sc->rch.wmark, 4); 510 511 nm_ackint(sc, sc->recint); 512 chn_intr(sc->rch.channel); 513 } 514 if (status & sc->misc1int) { 515 status &= ~sc->misc1int; 516 nm_ackint(sc, sc->misc1int); 517 x = nm_rd(sc, 0x400, 1); 518 nm_wr(sc, 0x400, x | 2, 1); 519 device_printf(sc->dev, "misc int 1\n"); 520 } 521 if (status & sc->misc2int) { 522 status &= ~sc->misc2int; 523 nm_ackint(sc, sc->misc2int); 524 x = nm_rd(sc, 0x400, 1); 525 nm_wr(sc, 0x400, x & ~2, 1); 526 device_printf(sc->dev, "misc int 2\n"); 527 } 528 if (status) { 529 nm_ackint(sc, status); 530 device_printf(sc->dev, "unknown int\n"); 531 } 532 } 533 534 /* -------------------------------------------------------------------- */ 535 536 /* 537 * Probe and attach the card 538 */ 539 540 static int 541 nm_init(struct sc_info *sc) 542 { 543 u_int32_t ofs, i; 544 545 if (sc->type == NM256AV_PCI_ID) { 546 sc->ac97_base = NM_MIXER_OFFSET; 547 sc->ac97_status = NM_MIXER_STATUS_OFFSET; 548 sc->ac97_busy = NM_MIXER_READY_MASK; 549 550 sc->buftop = 2560 * 1024; 551 552 sc->irsz = 2; 553 sc->playint = NM_PLAYBACK_INT; 554 sc->recint = NM_RECORD_INT; 555 sc->misc1int = NM_MISC_INT_1; 556 sc->misc2int = NM_MISC_INT_2; 557 } else if (sc->type == NM256ZX_PCI_ID) { 558 sc->ac97_base = NM_MIXER_OFFSET; 559 sc->ac97_status = NM2_MIXER_STATUS_OFFSET; 560 sc->ac97_busy = NM2_MIXER_READY_MASK; 561 562 sc->buftop = (nm_rd(sc, 0xa0b, 2)? 6144 : 4096) * 1024; 563 564 sc->irsz = 4; 565 sc->playint = NM2_PLAYBACK_INT; 566 sc->recint = NM2_RECORD_INT; 567 sc->misc1int = NM2_MISC_INT_1; 568 sc->misc2int = NM2_MISC_INT_2; 569 } else return -1; 570 sc->badintr = 0; 571 ofs = sc->buftop - 0x0400; 572 sc->buftop -= 0x1400; 573 574 if (bootverbose) 575 device_printf(sc->dev, "buftop is 0x%08x\n", sc->buftop); 576 if ((nm_rdbuf(sc, ofs, 4) & NM_SIG_MASK) == NM_SIGNATURE) { 577 i = nm_rdbuf(sc, ofs + 4, 4); 578 if (i != 0 && i != 0xffffffff) { 579 if (bootverbose) 580 device_printf(sc->dev, "buftop is changed to 0x%08x\n", i); 581 sc->buftop = i; 582 } 583 } 584 585 sc->cbuf = sc->buftop - NM_MAX_COEFFICIENT; 586 sc->rbuf = sc->cbuf - NM_BUFFSIZE; 587 sc->pbuf = sc->rbuf - NM_BUFFSIZE; 588 sc->acbuf = sc->pbuf - (NM_TOTAL_COEFF_COUNT * 4); 589 590 nm_wr(sc, 0, 0x11, 1); 591 nm_wr(sc, NM_RECORD_ENABLE_REG, 0, 1); 592 nm_wr(sc, 0x214, 0, 2); 593 594 return 0; 595 } 596 597 static int 598 nm_pci_probe(device_t dev) 599 { 600 struct sc_info *sc = NULL; 601 char *s = NULL; 602 u_int32_t subdev, i, data; 603 604 subdev = (pci_get_subdevice(dev) << 16) | pci_get_subvendor(dev); 605 switch (pci_get_devid(dev)) { 606 case NM256AV_PCI_ID: 607 i = 0; 608 while ((i < NUM_BADCARDS) && (badcards[i] != subdev)) 609 i++; 610 611 /* Try to catch other non-ac97 cards */ 612 613 if (i == NUM_BADCARDS) { 614 if (!(sc = malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT | M_ZERO))) { 615 device_printf(dev, "cannot allocate softc\n"); 616 return ENXIO; 617 } 618 619 data = pci_read_config(dev, PCIR_COMMAND, 2); 620 pci_write_config(dev, PCIR_COMMAND, data | 621 PCIM_CMD_PORTEN | PCIM_CMD_MEMEN | 622 PCIM_CMD_BUSMASTEREN, 2); 623 624 sc->regid = PCIR_BAR(1); 625 sc->reg = bus_alloc_resource_any(dev, SYS_RES_MEMORY, 626 &sc->regid, 627 RF_ACTIVE); 628 629 if (!sc->reg) { 630 device_printf(dev, "unable to map register space\n"); 631 pci_write_config(dev, PCIR_COMMAND, data, 2); 632 free(sc, M_DEVBUF); 633 return ENXIO; 634 } 635 636 /* 637 * My Panasonic CF-M2EV needs resetting device 638 * before checking mixer is present or not. 639 * t.ichinoseki@nifty.com. 640 */ 641 nm_wr(sc, 0, 0x11, 1); /* reset device */ 642 if ((nm_rd(sc, NM_MIXER_PRESENCE, 2) & 643 NM_PRESENCE_MASK) != NM_PRESENCE_VALUE) { 644 i = 0; /* non-ac97 card, but not listed */ 645 DEB(device_printf(dev, "subdev = 0x%x - badcard?\n", 646 subdev)); 647 } 648 pci_write_config(dev, PCIR_COMMAND, data, 2); 649 bus_release_resource(dev, SYS_RES_MEMORY, sc->regid, 650 sc->reg); 651 free(sc, M_DEVBUF); 652 } 653 654 if (i == NUM_BADCARDS) 655 s = "NeoMagic 256AV"; 656 DEB(else) 657 DEB(device_printf(dev, "this is a non-ac97 NM256AV, not attaching\n")); 658 659 break; 660 661 case NM256ZX_PCI_ID: 662 s = "NeoMagic 256ZX"; 663 break; 664 } 665 666 if (s) device_set_desc(dev, s); 667 return s? 0 : ENXIO; 668 } 669 670 static int 671 nm_pci_attach(device_t dev) 672 { 673 u_int32_t data; 674 struct sc_info *sc; 675 struct ac97_info *codec = 0; 676 char status[SND_STATUSLEN]; 677 678 sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO); 679 sc->dev = dev; 680 sc->type = pci_get_devid(dev); 681 682 data = pci_read_config(dev, PCIR_COMMAND, 2); 683 data |= (PCIM_CMD_PORTEN|PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN); 684 pci_write_config(dev, PCIR_COMMAND, data, 2); 685 data = pci_read_config(dev, PCIR_COMMAND, 2); 686 687 sc->bufid = PCIR_BAR(0); 688 sc->buf = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &sc->bufid, 689 RF_ACTIVE); 690 sc->regid = PCIR_BAR(1); 691 sc->reg = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &sc->regid, 692 RF_ACTIVE); 693 694 if (!sc->buf || !sc->reg) { 695 device_printf(dev, "unable to map register space\n"); 696 goto bad; 697 } 698 699 if (nm_init(sc) == -1) { 700 device_printf(dev, "unable to initialize the card\n"); 701 goto bad; 702 } 703 704 codec = AC97_CREATE(dev, sc, nm_ac97); 705 if (codec == NULL) goto bad; 706 if (mixer_init(dev, ac97_getmixerclass(), codec) == -1) goto bad; 707 708 sc->irqid = 0; 709 sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->irqid, 710 RF_ACTIVE | RF_SHAREABLE); 711 if (!sc->irq || snd_setup_intr(dev, sc->irq, 0, nm_intr, sc, &sc->ih)) { 712 device_printf(dev, "unable to map interrupt\n"); 713 goto bad; 714 } 715 716 snprintf(status, SND_STATUSLEN, "at memory 0x%lx, 0x%lx irq %ld %s", 717 rman_get_start(sc->buf), rman_get_start(sc->reg), 718 rman_get_start(sc->irq),PCM_KLDSTRING(snd_neomagic)); 719 720 if (pcm_register(dev, sc, 1, 1)) goto bad; 721 pcm_addchan(dev, PCMDIR_REC, &nmchan_class, sc); 722 pcm_addchan(dev, PCMDIR_PLAY, &nmchan_class, sc); 723 pcm_setstatus(dev, status); 724 725 return 0; 726 727 bad: 728 if (codec) ac97_destroy(codec); 729 if (sc->buf) bus_release_resource(dev, SYS_RES_MEMORY, sc->bufid, sc->buf); 730 if (sc->reg) bus_release_resource(dev, SYS_RES_MEMORY, sc->regid, sc->reg); 731 if (sc->ih) bus_teardown_intr(dev, sc->irq, sc->ih); 732 if (sc->irq) bus_release_resource(dev, SYS_RES_IRQ, sc->irqid, sc->irq); 733 free(sc, M_DEVBUF); 734 return ENXIO; 735 } 736 737 static int 738 nm_pci_detach(device_t dev) 739 { 740 int r; 741 struct sc_info *sc; 742 743 r = pcm_unregister(dev); 744 if (r) 745 return r; 746 747 sc = pcm_getdevinfo(dev); 748 bus_release_resource(dev, SYS_RES_MEMORY, sc->bufid, sc->buf); 749 bus_release_resource(dev, SYS_RES_MEMORY, sc->regid, sc->reg); 750 bus_teardown_intr(dev, sc->irq, sc->ih); 751 bus_release_resource(dev, SYS_RES_IRQ, sc->irqid, sc->irq); 752 free(sc, M_DEVBUF); 753 754 return 0; 755 } 756 757 static int 758 nm_pci_suspend(device_t dev) 759 { 760 struct sc_info *sc; 761 762 sc = pcm_getdevinfo(dev); 763 764 /* stop playing */ 765 if (sc->pch.active) { 766 nm_wr(sc, NM_PLAYBACK_ENABLE_REG, 0, 1); 767 nm_wr(sc, NM_AUDIO_MUTE_REG, NM_AUDIO_MUTE_BOTH, 2); 768 } 769 /* stop recording */ 770 if (sc->rch.active) { 771 nm_wr(sc, NM_RECORD_ENABLE_REG, 0, 1); 772 } 773 return 0; 774 } 775 776 static int 777 nm_pci_resume(device_t dev) 778 { 779 struct sc_info *sc; 780 781 sc = pcm_getdevinfo(dev); 782 783 /* 784 * Reinit audio device. 785 * Don't call nm_init(). It would change buftop if X ran or 786 * is running. This makes playing and recording buffer address 787 * shift but these buffers of channel layer are not changed. 788 * As a result of this inconsistency, periodic noise will be 789 * generated while playing. 790 */ 791 nm_wr(sc, 0, 0x11, 1); 792 nm_wr(sc, 0x214, 0, 2); 793 794 /* Reinit mixer */ 795 if (mixer_reinit(dev) == -1) { 796 device_printf(dev, "unable to reinitialize the mixer\n"); 797 return ENXIO; 798 } 799 /* restart playing */ 800 if (sc->pch.active) { 801 nm_wr(sc, NM_PLAYBACK_ENABLE_REG, NM_PLAYBACK_FREERUN | 802 NM_PLAYBACK_ENABLE_FLAG, 1); 803 nm_wr(sc, NM_AUDIO_MUTE_REG, 0, 2); 804 } 805 /* restart recording */ 806 if (sc->rch.active) { 807 nm_wr(sc, NM_RECORD_ENABLE_REG, NM_RECORD_FREERUN | 808 NM_RECORD_ENABLE_FLAG, 1); 809 } 810 return 0; 811 } 812 813 static device_method_t nm_methods[] = { 814 /* Device interface */ 815 DEVMETHOD(device_probe, nm_pci_probe), 816 DEVMETHOD(device_attach, nm_pci_attach), 817 DEVMETHOD(device_detach, nm_pci_detach), 818 DEVMETHOD(device_suspend, nm_pci_suspend), 819 DEVMETHOD(device_resume, nm_pci_resume), 820 { 0, 0 } 821 }; 822 823 static driver_t nm_driver = { 824 "pcm", 825 nm_methods, 826 PCM_SOFTC_SIZE, 827 }; 828 829 DRIVER_MODULE(snd_neomagic, pci, nm_driver, pcm_devclass, 0, 0); 830 MODULE_DEPEND(snd_neomagic, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER); 831 MODULE_VERSION(snd_neomagic, 1); 832