1 /* 2 * Copyright (c) 2000 Dmitry Dicky diwil@dataart.com 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS `AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD$ 27 */ 28 29 #include <dev/sound/pcm/sound.h> 30 #include <dev/sound/pcm/ac97.h> 31 #include <pci/pcireg.h> 32 #include <pci/pcivar.h> 33 34 #define PCI_VENDOR_FORTEMEDIA 0x1319 35 #define PCI_DEVICE_FORTEMEDIA1 0x08011319 36 #define PCI_DEVICE_FORTEMEDIA2 0x08021319 /* ??? have no idea what's this... */ 37 38 #define FM_PCM_VOLUME 0x00 39 #define FM_FM_VOLUME 0x02 40 #define FM_I2S_VOLUME 0x04 41 #define FM_RECORD_SOURCE 0x06 42 43 #define FM_PLAY_CTL 0x08 44 #define FM_PLAY_RATE_MASK 0x0f00 45 #define FM_PLAY_BUF1_LAST 0x0001 46 #define FM_PLAY_BUF2_LAST 0x0002 47 #define FM_PLAY_START 0x0020 48 #define FM_PLAY_PAUSE 0x0040 49 #define FM_PLAY_STOPNOW 0x0080 50 #define FM_PLAY_16BIT 0x4000 51 #define FM_PLAY_STEREO 0x8000 52 53 #define FM_PLAY_DMALEN 0x0a 54 #define FM_PLAY_DMABUF1 0x0c 55 #define FM_PLAY_DMABUF2 0x10 56 57 58 #define FM_REC_CTL 0x14 59 #define FM_REC_RATE_MASK 0x0f00 60 #define FM_REC_BUF1_LAST 0x0001 61 #define FM_REC_BUF2_LAST 0x0002 62 #define FM_REC_START 0x0020 63 #define FM_REC_PAUSE 0x0040 64 #define FM_REC_STOPNOW 0x0080 65 #define FM_REC_16BIT 0x4000 66 #define FM_REC_STEREO 0x8000 67 68 69 #define FM_REC_DMALEN 0x16 70 #define FM_REC_DMABUF1 0x18 71 #define FM_REC_DMABUF2 0x1c 72 73 #define FM_CODEC_CTL 0x22 74 #define FM_VOLUME 0x26 75 #define FM_VOLUME_MUTE 0x8000 76 77 #define FM_CODEC_CMD 0x2a 78 #define FM_CODEC_CMD_READ 0x0080 79 #define FM_CODEC_CMD_VALID 0x0100 80 #define FM_CODEC_CMD_BUSY 0x0200 81 82 #define FM_CODEC_DATA 0x2c 83 84 #define FM_IO_CTL 0x52 85 #define FM_CARD_CTL 0x54 86 87 #define FM_INTMASK 0x56 88 #define FM_INTMASK_PLAY 0x0001 89 #define FM_INTMASK_REC 0x0002 90 #define FM_INTMASK_VOL 0x0040 91 #define FM_INTMASK_MPU 0x0080 92 93 #define FM_INTSTATUS 0x5a 94 #define FM_INTSTATUS_PLAY 0x0100 95 #define FM_INTSTATUS_REC 0x0200 96 #define FM_INTSTATUS_VOL 0x4000 97 #define FM_INTSTATUS_MPU 0x8000 98 99 #define FM801_BUFFSIZE 1024*4 /* Other values do not work!!! */ 100 101 /* debug purposes */ 102 #define DPRINT if(0) printf 103 104 /* 105 static int fm801ch_setup(struct pcm_channel *c); 106 */ 107 108 static u_int32_t fmts[] = { 109 AFMT_U8, 110 AFMT_STEREO | AFMT_U8, 111 AFMT_S16_LE, 112 AFMT_STEREO | AFMT_S16_LE, 113 0 114 }; 115 116 static struct pcmchan_caps fm801ch_caps = { 117 4000, 48000, 118 fmts, 0 119 }; 120 121 struct fm801_info; 122 123 struct fm801_chinfo { 124 struct fm801_info *parent; 125 struct pcm_channel *channel; 126 struct snd_dbuf *buffer; 127 u_int32_t spd, dir, fmt; /* speed, direction, format */ 128 u_int32_t shift; 129 }; 130 131 struct fm801_info { 132 int type; 133 bus_space_tag_t st; 134 bus_space_handle_t sh; 135 bus_dma_tag_t parent_dmat; 136 137 device_t dev; 138 int num; 139 u_int32_t unit; 140 141 struct resource *reg, *irq; 142 int regtype, regid, irqid; 143 void *ih; 144 145 u_int32_t play_flip, 146 play_nextblk, 147 play_start, 148 play_blksize, 149 play_fmt, 150 play_shift, 151 play_size; 152 153 u_int32_t rec_flip, 154 rec_nextblk, 155 rec_start, 156 rec_blksize, 157 rec_fmt, 158 rec_shift, 159 rec_size; 160 161 struct fm801_chinfo pch, rch; 162 }; 163 164 /* Bus Read / Write routines */ 165 static u_int32_t 166 fm801_rd(struct fm801_info *fm801, int regno, int size) 167 { 168 switch(size) { 169 case 1: 170 return (bus_space_read_1(fm801->st, fm801->sh, regno)); 171 case 2: 172 return (bus_space_read_2(fm801->st, fm801->sh, regno)); 173 case 4: 174 return (bus_space_read_4(fm801->st, fm801->sh, regno)); 175 default: 176 return 0xffffffff; 177 } 178 } 179 180 static void 181 fm801_wr(struct fm801_info *fm801, int regno, u_int32_t data, int size) 182 { 183 switch(size) { 184 case 1: 185 return bus_space_write_1(fm801->st, fm801->sh, regno, data); 186 case 2: 187 return bus_space_write_2(fm801->st, fm801->sh, regno, data); 188 case 4: 189 return bus_space_write_4(fm801->st, fm801->sh, regno, data); 190 default: 191 return; 192 } 193 } 194 195 /* -------------------------------------------------------------------- */ 196 /* 197 * ac97 codec routines 198 */ 199 #define TIMO 50 200 static int 201 fm801_rdcd(kobj_t obj, void *devinfo, int regno) 202 { 203 struct fm801_info *fm801 = (struct fm801_info *)devinfo; 204 int i; 205 206 for (i = 0; i < TIMO && fm801_rd(fm801,FM_CODEC_CMD,2) & FM_CODEC_CMD_BUSY; i++) { 207 DELAY(10000); 208 DPRINT("fm801 rdcd: 1 - DELAY\n"); 209 } 210 if (i >= TIMO) { 211 printf("fm801 rdcd: codec busy\n"); 212 return 0; 213 } 214 215 fm801_wr(fm801,FM_CODEC_CMD, regno|FM_CODEC_CMD_READ,2); 216 217 for (i = 0; i < TIMO && !(fm801_rd(fm801,FM_CODEC_CMD,2) & FM_CODEC_CMD_VALID); i++) 218 { 219 DELAY(10000); 220 DPRINT("fm801 rdcd: 2 - DELAY\n"); 221 } 222 if (i >= TIMO) { 223 printf("fm801 rdcd: write codec invalid\n"); 224 return 0; 225 } 226 227 return fm801_rd(fm801,FM_CODEC_DATA,2); 228 } 229 230 static int 231 fm801_wrcd(kobj_t obj, void *devinfo, int regno, u_int32_t data) 232 { 233 struct fm801_info *fm801 = (struct fm801_info *)devinfo; 234 int i; 235 236 DPRINT("fm801_wrcd reg 0x%x val 0x%x\n",regno, data); 237 /* 238 if(regno == AC97_REG_RECSEL) return; 239 */ 240 /* Poll until codec is ready */ 241 for (i = 0; i < TIMO && fm801_rd(fm801,FM_CODEC_CMD,2) & FM_CODEC_CMD_BUSY; i++) { 242 DELAY(10000); 243 DPRINT("fm801 rdcd: 1 - DELAY\n"); 244 } 245 if (i >= TIMO) { 246 printf("fm801 wrcd: read codec busy\n"); 247 return -1; 248 } 249 250 fm801_wr(fm801,FM_CODEC_DATA,data, 2); 251 fm801_wr(fm801,FM_CODEC_CMD, regno,2); 252 253 /* wait until codec is ready */ 254 for (i = 0; i < TIMO && fm801_rd(fm801,FM_CODEC_CMD,2) & FM_CODEC_CMD_BUSY; i++) { 255 DELAY(10000); 256 DPRINT("fm801 wrcd: 2 - DELAY\n"); 257 } 258 if (i >= TIMO) { 259 printf("fm801 wrcd: read codec busy\n"); 260 return -1; 261 } 262 DPRINT("fm801 wrcd release reg 0x%x val 0x%x\n",regno, data); 263 return 0; 264 } 265 266 static kobj_method_t fm801_ac97_methods[] = { 267 KOBJMETHOD(ac97_read, fm801_rdcd), 268 KOBJMETHOD(ac97_write, fm801_wrcd), 269 { 0, 0 } 270 }; 271 AC97_DECLARE(fm801_ac97); 272 273 /* -------------------------------------------------------------------- */ 274 275 /* 276 * The interrupt handler 277 */ 278 static void 279 fm801_intr(void *p) 280 { 281 struct fm801_info *fm801 = (struct fm801_info *)p; 282 u_int32_t intsrc = fm801_rd(fm801, FM_INTSTATUS, 2); 283 284 DPRINT("\nfm801_intr intsrc 0x%x ", intsrc); 285 286 if(intsrc & FM_INTSTATUS_PLAY) { 287 fm801->play_flip++; 288 if(fm801->play_flip & 1) { 289 fm801_wr(fm801, FM_PLAY_DMABUF1, fm801->play_start,4); 290 } else 291 fm801_wr(fm801, FM_PLAY_DMABUF2, fm801->play_nextblk,4); 292 chn_intr(fm801->pch.channel); 293 } 294 295 if(intsrc & FM_INTSTATUS_REC) { 296 fm801->rec_flip++; 297 if(fm801->rec_flip & 1) { 298 fm801_wr(fm801, FM_REC_DMABUF1, fm801->rec_start,4); 299 } else 300 fm801_wr(fm801, FM_REC_DMABUF2, fm801->rec_nextblk,4); 301 chn_intr(fm801->rch.channel); 302 } 303 304 if ( intsrc & FM_INTSTATUS_MPU ) { 305 /* This is a TODOish thing... */ 306 fm801_wr(fm801, FM_INTSTATUS, intsrc & FM_INTSTATUS_MPU,2); 307 } 308 309 if ( intsrc & FM_INTSTATUS_VOL ) { 310 /* This is a TODOish thing... */ 311 fm801_wr(fm801, FM_INTSTATUS, intsrc & FM_INTSTATUS_VOL,2); 312 } 313 314 DPRINT("fm801_intr clear\n\n"); 315 fm801_wr(fm801, FM_INTSTATUS, intsrc & (FM_INTSTATUS_PLAY | FM_INTSTATUS_REC), 2); 316 } 317 318 /* -------------------------------------------------------------------- */ 319 /* channel interface */ 320 static void * 321 fm801ch_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir) 322 { 323 struct fm801_info *fm801 = (struct fm801_info *)devinfo; 324 struct fm801_chinfo *ch = (dir == PCMDIR_PLAY)? &fm801->pch : &fm801->rch; 325 326 DPRINT("fm801ch_init, direction = %d\n", dir); 327 ch->parent = fm801; 328 ch->channel = c; 329 ch->buffer = b; 330 ch->dir = dir; 331 if (sndbuf_alloc(ch->buffer, fm801->parent_dmat, FM801_BUFFSIZE) == -1) return NULL; 332 return (void *)ch; 333 } 334 335 static int 336 fm801ch_setformat(kobj_t obj, void *data, u_int32_t format) 337 { 338 struct fm801_chinfo *ch = data; 339 struct fm801_info *fm801 = ch->parent; 340 341 DPRINT("fm801ch_setformat 0x%x : %s, %s, %s, %s\n", format, 342 (format & AFMT_STEREO)?"stereo":"mono", 343 (format & (AFMT_S16_LE | AFMT_S16_BE | AFMT_U16_LE | AFMT_U16_BE)) ? "16bit":"8bit", 344 (format & AFMT_SIGNED)? "signed":"unsigned", 345 (format & AFMT_BIGENDIAN)?"bigendiah":"littleendian" ); 346 347 if(ch->dir == PCMDIR_PLAY) { 348 fm801->play_fmt = (format & AFMT_STEREO)? FM_PLAY_STEREO : 0; 349 fm801->play_fmt |= (format & AFMT_16BIT) ? FM_PLAY_16BIT : 0; 350 return 0; 351 } 352 353 if(ch->dir == PCMDIR_REC ) { 354 fm801->rec_fmt = (format & AFMT_STEREO)? FM_REC_STEREO:0; 355 fm801->rec_fmt |= (format & AFMT_16BIT) ? FM_PLAY_16BIT : 0; 356 return 0; 357 } 358 359 return 0; 360 } 361 362 struct { 363 int limit; 364 int rate; 365 } fm801_rates[11] = { 366 { 6600, 5500 }, 367 { 8750, 8000 }, 368 { 10250, 9600 }, 369 { 13200, 11025 }, 370 { 17500, 16000 }, 371 { 20500, 19200 }, 372 { 26500, 22050 }, 373 { 35000, 32000 }, 374 { 41000, 38400 }, 375 { 46000, 44100 }, 376 { 48000, 48000 }, 377 /* anything above -> 48000 */ 378 }; 379 380 static int 381 fm801ch_setspeed(kobj_t obj, void *data, u_int32_t speed) 382 { 383 struct fm801_chinfo *ch = data; 384 struct fm801_info *fm801 = ch->parent; 385 register int i; 386 387 388 for (i = 0; i < 10 && fm801_rates[i].limit <= speed; i++) ; 389 390 if(ch->dir == PCMDIR_PLAY) { 391 fm801->pch.spd = fm801_rates[i].rate; 392 fm801->play_shift = (i<<8); 393 fm801->play_shift &= FM_PLAY_RATE_MASK; 394 } 395 396 if(ch->dir == PCMDIR_REC ) { 397 fm801->rch.spd = fm801_rates[i].rate; 398 fm801->rec_shift = (i<<8); 399 fm801->rec_shift &= FM_REC_RATE_MASK; 400 } 401 402 ch->spd = fm801_rates[i].rate; 403 404 return fm801_rates[i].rate; 405 } 406 407 static int 408 fm801ch_setblocksize(kobj_t obj, void *data, u_int32_t blocksize) 409 { 410 struct fm801_chinfo *ch = data; 411 struct fm801_info *fm801 = ch->parent; 412 413 if(ch->dir == PCMDIR_PLAY) { 414 if(fm801->play_flip) return fm801->play_blksize; 415 fm801->play_blksize = blocksize; 416 } 417 418 if(ch->dir == PCMDIR_REC) { 419 if(fm801->rec_flip) return fm801->rec_blksize; 420 fm801->rec_blksize = blocksize; 421 } 422 423 DPRINT("fm801ch_setblocksize %d (dir %d)\n",blocksize, ch->dir); 424 425 return blocksize; 426 } 427 428 static int 429 fm801ch_trigger(kobj_t obj, void *data, int go) 430 { 431 struct fm801_chinfo *ch = data; 432 struct fm801_info *fm801 = ch->parent; 433 u_int32_t baseaddr = vtophys(sndbuf_getbuf(ch->buffer)); 434 u_int32_t k1; 435 436 DPRINT("fm801ch_trigger go %d , ", go); 437 438 if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD) { 439 return 0; 440 } 441 442 if (ch->dir == PCMDIR_PLAY) { 443 if (go == PCMTRIG_START) { 444 445 fm801->play_start = baseaddr; 446 fm801->play_nextblk = fm801->play_start + fm801->play_blksize; 447 fm801->play_flip = 0; 448 fm801_wr(fm801, FM_PLAY_DMALEN, fm801->play_blksize - 1, 2); 449 fm801_wr(fm801, FM_PLAY_DMABUF1,fm801->play_start,4); 450 fm801_wr(fm801, FM_PLAY_DMABUF2,fm801->play_nextblk,4); 451 fm801_wr(fm801, FM_PLAY_CTL, 452 FM_PLAY_START | FM_PLAY_STOPNOW | fm801->play_fmt | fm801->play_shift, 453 2 ); 454 } else { 455 fm801->play_flip = 0; 456 k1 = fm801_rd(fm801, FM_PLAY_CTL,2); 457 fm801_wr(fm801, FM_PLAY_CTL, 458 (k1 & ~(FM_PLAY_STOPNOW | FM_PLAY_START)) | 459 FM_PLAY_BUF1_LAST | FM_PLAY_BUF2_LAST, 2 ); 460 } 461 } else if(ch->dir == PCMDIR_REC) { 462 if (go == PCMTRIG_START) { 463 fm801->rec_start = baseaddr; 464 fm801->rec_nextblk = fm801->rec_start + fm801->rec_blksize; 465 fm801->rec_flip = 0; 466 fm801_wr(fm801, FM_REC_DMALEN, fm801->rec_blksize - 1, 2); 467 fm801_wr(fm801, FM_REC_DMABUF1,fm801->rec_start,4); 468 fm801_wr(fm801, FM_REC_DMABUF2,fm801->rec_nextblk,4); 469 fm801_wr(fm801, FM_REC_CTL, 470 FM_REC_START | FM_REC_STOPNOW | fm801->rec_fmt | fm801->rec_shift, 471 2 ); 472 } else { 473 fm801->rec_flip = 0; 474 k1 = fm801_rd(fm801, FM_REC_CTL,2); 475 fm801_wr(fm801, FM_REC_CTL, 476 (k1 & ~(FM_REC_STOPNOW | FM_REC_START)) | 477 FM_REC_BUF1_LAST | FM_REC_BUF2_LAST, 2); 478 } 479 } 480 481 return 0; 482 } 483 484 /* Almost ALSA copy */ 485 static int 486 fm801ch_getptr(kobj_t obj, void *data) 487 { 488 struct fm801_chinfo *ch = data; 489 struct fm801_info *fm801 = ch->parent; 490 int result = 0; 491 492 if (ch->dir == PCMDIR_PLAY) { 493 result = fm801_rd(fm801, 494 (fm801->play_flip&1) ? 495 FM_PLAY_DMABUF2:FM_PLAY_DMABUF1, 4) - fm801->play_start; 496 } 497 498 if (ch->dir == PCMDIR_REC) { 499 result = fm801_rd(fm801, 500 (fm801->rec_flip&1) ? 501 FM_REC_DMABUF2:FM_REC_DMABUF1, 4) - fm801->rec_start; 502 } 503 504 return result; 505 } 506 507 static struct pcmchan_caps * 508 fm801ch_getcaps(kobj_t obj, void *data) 509 { 510 return &fm801ch_caps; 511 } 512 513 static kobj_method_t fm801ch_methods[] = { 514 KOBJMETHOD(channel_init, fm801ch_init), 515 KOBJMETHOD(channel_setformat, fm801ch_setformat), 516 KOBJMETHOD(channel_setspeed, fm801ch_setspeed), 517 KOBJMETHOD(channel_setblocksize, fm801ch_setblocksize), 518 KOBJMETHOD(channel_trigger, fm801ch_trigger), 519 KOBJMETHOD(channel_getptr, fm801ch_getptr), 520 KOBJMETHOD(channel_getcaps, fm801ch_getcaps), 521 { 0, 0 } 522 }; 523 CHANNEL_DECLARE(fm801ch); 524 525 /* -------------------------------------------------------------------- */ 526 527 /* 528 * Init routine is taken from an original NetBSD driver 529 */ 530 static int 531 fm801_init(struct fm801_info *fm801) 532 { 533 u_int32_t k1; 534 535 /* reset codec */ 536 fm801_wr(fm801, FM_CODEC_CTL, 0x0020,2); 537 DELAY(100000); 538 fm801_wr(fm801, FM_CODEC_CTL, 0x0000,2); 539 DELAY(100000); 540 541 fm801_wr(fm801, FM_PCM_VOLUME, 0x0808,2); 542 fm801_wr(fm801, FM_FM_VOLUME, 0x0808,2); 543 fm801_wr(fm801, FM_I2S_VOLUME, 0x0808,2); 544 fm801_wr(fm801, 0x40,0x107f,2); /* enable legacy audio */ 545 546 fm801_wr((void *)fm801, FM_RECORD_SOURCE, 0x0000,2); 547 548 /* Unmask playback, record and mpu interrupts, mask the rest */ 549 k1 = fm801_rd((void *)fm801, FM_INTMASK,2); 550 fm801_wr(fm801, FM_INTMASK, 551 (k1 & ~(FM_INTMASK_PLAY | FM_INTMASK_REC | FM_INTMASK_MPU)) | 552 FM_INTMASK_VOL,2); 553 fm801_wr(fm801, FM_INTSTATUS, 554 FM_INTSTATUS_PLAY | FM_INTSTATUS_REC | FM_INTSTATUS_MPU | 555 FM_INTSTATUS_VOL,2); 556 557 DPRINT("FM801 init Ok\n"); 558 return 0; 559 } 560 561 static int 562 fm801_pci_attach(device_t dev) 563 { 564 u_int32_t data; 565 struct ac97_info *codec = 0; 566 struct fm801_info *fm801; 567 int i; 568 int mapped = 0; 569 char status[SND_STATUSLEN]; 570 571 if ((fm801 = (struct fm801_info *)malloc(sizeof(*fm801), M_DEVBUF, M_NOWAIT | M_ZERO)) == NULL) { 572 device_printf(dev, "cannot allocate softc\n"); 573 return ENXIO; 574 } 575 576 fm801->type = pci_get_devid(dev); 577 578 data = pci_read_config(dev, PCIR_COMMAND, 2); 579 data |= (PCIM_CMD_PORTEN|PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN); 580 pci_write_config(dev, PCIR_COMMAND, data, 2); 581 data = pci_read_config(dev, PCIR_COMMAND, 2); 582 583 for (i = 0; (mapped == 0) && (i < PCI_MAXMAPS_0); i++) { 584 fm801->regid = PCIR_MAPS + i*4; 585 fm801->regtype = SYS_RES_MEMORY; 586 fm801->reg = bus_alloc_resource(dev, fm801->regtype, &fm801->regid, 587 0, ~0, 1, RF_ACTIVE); 588 if(!fm801->reg) 589 { 590 fm801->regtype = SYS_RES_IOPORT; 591 fm801->reg = bus_alloc_resource(dev, fm801->regtype, &fm801->regid, 592 0, ~0, 1, RF_ACTIVE); 593 } 594 595 if(fm801->reg) { 596 fm801->st = rman_get_bustag(fm801->reg); 597 fm801->sh = rman_get_bushandle(fm801->reg); 598 mapped++; 599 } 600 } 601 602 if (mapped == 0) { 603 device_printf(dev, "unable to map register space\n"); 604 goto oops; 605 } 606 607 fm801_init(fm801); 608 609 codec = AC97_CREATE(dev, fm801, fm801_ac97); 610 if (codec == NULL) goto oops; 611 612 if (mixer_init(dev, ac97_getmixerclass(), codec) == -1) goto oops; 613 614 fm801->irqid = 0; 615 fm801->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &fm801->irqid, 616 0, ~0, 1, RF_ACTIVE | RF_SHAREABLE); 617 if (!fm801->irq || snd_setup_intr(dev, fm801->irq, 0, fm801_intr, fm801, &fm801->ih)) { 618 device_printf(dev, "unable to map interrupt\n"); 619 goto oops; 620 } 621 622 if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0, 623 /*lowaddr*/BUS_SPACE_MAXADDR_32BIT, 624 /*highaddr*/BUS_SPACE_MAXADDR, 625 /*filter*/NULL, /*filterarg*/NULL, 626 /*maxsize*/FM801_BUFFSIZE, /*nsegments*/1, /*maxsegz*/0x3ffff, 627 /*flags*/0, &fm801->parent_dmat) != 0) { 628 device_printf(dev, "unable to create dma tag\n"); 629 goto oops; 630 } 631 632 snprintf(status, 64, "at %s 0x%lx irq %ld", 633 (fm801->regtype == SYS_RES_IOPORT)? "io" : "memory", 634 rman_get_start(fm801->reg), rman_get_start(fm801->irq)); 635 636 #define FM801_MAXPLAYCH 1 637 if (pcm_register(dev, fm801, FM801_MAXPLAYCH, 1)) goto oops; 638 pcm_addchan(dev, PCMDIR_PLAY, &fm801ch_class, fm801); 639 pcm_addchan(dev, PCMDIR_REC, &fm801ch_class, fm801); 640 pcm_setstatus(dev, status); 641 642 return 0; 643 644 oops: 645 if (codec) ac97_destroy(codec); 646 if (fm801->reg) bus_release_resource(dev, fm801->regtype, fm801->regid, fm801->reg); 647 if (fm801->ih) bus_teardown_intr(dev, fm801->irq, fm801->ih); 648 if (fm801->irq) bus_release_resource(dev, SYS_RES_IRQ, fm801->irqid, fm801->irq); 649 if (fm801->parent_dmat) bus_dma_tag_destroy(fm801->parent_dmat); 650 free(fm801, M_DEVBUF); 651 return ENXIO; 652 } 653 654 static int 655 fm801_pci_detach(device_t dev) 656 { 657 int r; 658 struct fm801_info *fm801; 659 660 DPRINT("Forte Media FM801 detach\n"); 661 662 r = pcm_unregister(dev); 663 if (r) 664 return r; 665 666 fm801 = pcm_getdevinfo(dev); 667 bus_release_resource(dev, fm801->regtype, fm801->regid, fm801->reg); 668 bus_teardown_intr(dev, fm801->irq, fm801->ih); 669 bus_release_resource(dev, SYS_RES_IRQ, fm801->irqid, fm801->irq); 670 bus_dma_tag_destroy(fm801->parent_dmat); 671 free(fm801, M_DEVBUF); 672 return 0; 673 } 674 675 static int 676 fm801_pci_probe( device_t dev ) 677 { 678 int id; 679 if ((id = pci_get_devid(dev)) == PCI_DEVICE_FORTEMEDIA1 ) { 680 device_set_desc(dev, "Forte Media FM801 Audio Controller"); 681 return 0; 682 } 683 /* 684 if ((id = pci_get_devid(dev)) == PCI_DEVICE_FORTEMEDIA2 ) { 685 device_set_desc(dev, "Forte Media FM801 Joystick (Not Supported)"); 686 return ENXIO; 687 } 688 */ 689 return ENXIO; 690 } 691 692 static device_method_t fm801_methods[] = { 693 /* Device interface */ 694 DEVMETHOD(device_probe, fm801_pci_probe), 695 DEVMETHOD(device_attach, fm801_pci_attach), 696 DEVMETHOD(device_detach, fm801_pci_detach), 697 { 0, 0} 698 }; 699 700 static driver_t fm801_driver = { 701 "pcm", 702 fm801_methods, 703 sizeof(struct snddev_info), 704 }; 705 706 DRIVER_MODULE(snd_fm801, pci, fm801_driver, pcm_devclass, 0, 0); 707 MODULE_DEPEND(snd_fm801, snd_pcm, PCM_MINVER, PCM_PREFVER, PCM_MAXVER); 708 MODULE_VERSION(snd_fm801, 1); 709 710