sys/dev/sound/pci/fm801.c

   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
  27 #include <dev/sound/pcm/sound.h>
  28 #include <dev/sound/pcm/ac97.h>
  29 #include <pci/pcireg.h>
  30 #include <pci/pcivar.h>
  31
  32 SND_DECLARE_FILE("$FreeBSD: src/sys/dev/sound/pci/fm801.c,v 1.3.2.8 2002/12/24 21:17:42 semenu Exp $");
  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_DEFAULT_BUFSZ     4096    /* 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         unsigned int            bufsz;
 162
 163         struct fm801_chinfo     pch, rch;
 164
 165         device_t                radio;
 166 };
 167
 168 /* Bus Read / Write routines */
 169 static u_int32_t
 170 fm801_rd(struct fm801_info *fm801, int regno, int size)
 171 {
 172         switch(size) {
 173         case 1:
 174                 return (bus_space_read_1(fm801->st, fm801->sh, regno));
 175         case 2:
 176                 return (bus_space_read_2(fm801->st, fm801->sh, regno));
 177         case 4:
 178                 return (bus_space_read_4(fm801->st, fm801->sh, regno));
 179         default:
 180                 return 0xffffffff;
 181         }
 182 }
 183
 184 static void
 185 fm801_wr(struct fm801_info *fm801, int regno, u_int32_t data, int size)
 186 {
 187
 188         switch(size) {
 189         case 1:
 190                 bus_space_write_1(fm801->st, fm801->sh, regno, data);
 191                 break;
 192         case 2:
 193                 bus_space_write_2(fm801->st, fm801->sh, regno, data);
 194                 break;
 195         case 4:
 196                 bus_space_write_4(fm801->st, fm801->sh, regno, data);
 197                 break;
 198         }
 199 }
 200
 201 /* -------------------------------------------------------------------- */
 202 /*
 203  *  ac97 codec routines
 204  */
 205 #define TIMO 50
 206 static int
 207 fm801_rdcd(kobj_t obj, void *devinfo, int regno)
 208 {
 209         struct fm801_info *fm801 = (struct fm801_info *)devinfo;
 210         int i;
 211
 212         for (i = 0; i < TIMO && fm801_rd(fm801,FM_CODEC_CMD,2) & FM_CODEC_CMD_BUSY; i++) {
 213                 DELAY(10000);
 214                 DPRINT("fm801 rdcd: 1 - DELAY\n");
 215         }
 216         if (i >= TIMO) {
 217                 printf("fm801 rdcd: codec busy\n");
 218                 return 0;
 219         }
 220
 221         fm801_wr(fm801,FM_CODEC_CMD, regno|FM_CODEC_CMD_READ,2);
 222
 223         for (i = 0; i < TIMO && !(fm801_rd(fm801,FM_CODEC_CMD,2) & FM_CODEC_CMD_VALID); i++)
 224         {
 225                 DELAY(10000);
 226                 DPRINT("fm801 rdcd: 2 - DELAY\n");
 227         }
 228         if (i >= TIMO) {
 229                 printf("fm801 rdcd: write codec invalid\n");
 230                 return 0;
 231         }
 232
 233         return fm801_rd(fm801,FM_CODEC_DATA,2);
 234 }
 235
 236 static int
 237 fm801_wrcd(kobj_t obj, void *devinfo, int regno, u_int32_t data)
 238 {
 239         struct fm801_info *fm801 = (struct fm801_info *)devinfo;
 240         int i;
 241
 242         DPRINT("fm801_wrcd reg 0x%x val 0x%x\n",regno, data);
 243 /*
 244         if(regno == AC97_REG_RECSEL)    return;
 245 */
 246         /* Poll until codec is ready */
 247         for (i = 0; i < TIMO && fm801_rd(fm801,FM_CODEC_CMD,2) & FM_CODEC_CMD_BUSY; i++) {
 248                 DELAY(10000);
 249                 DPRINT("fm801 rdcd: 1 - DELAY\n");
 250         }
 251         if (i >= TIMO) {
 252                 printf("fm801 wrcd: read codec busy\n");
 253                 return -1;
 254         }
 255
 256         fm801_wr(fm801,FM_CODEC_DATA,data, 2);
 257         fm801_wr(fm801,FM_CODEC_CMD, regno,2);
 258
 259         /* wait until codec is ready */
 260         for (i = 0; i < TIMO && fm801_rd(fm801,FM_CODEC_CMD,2) & FM_CODEC_CMD_BUSY; i++) {
 261                 DELAY(10000);
 262                 DPRINT("fm801 wrcd: 2 - DELAY\n");
 263         }
 264         if (i >= TIMO) {
 265                 printf("fm801 wrcd: read codec busy\n");
 266                 return -1;
 267         }
 268         DPRINT("fm801 wrcd release reg 0x%x val 0x%x\n",regno, data);
 269         return 0;
 270 }
 271
 272 static kobj_method_t fm801_ac97_methods[] = {
 273         KOBJMETHOD(ac97_read,           fm801_rdcd),
 274         KOBJMETHOD(ac97_write,          fm801_wrcd),
 275         { 0, 0 }
 276 };
 277 AC97_DECLARE(fm801_ac97);
 278
 279 /* -------------------------------------------------------------------- */
 280
 281 /*
 282  * The interrupt handler
 283  */
 284 static void
 285 fm801_intr(void *p)
 286 {
 287         struct fm801_info       *fm801 = (struct fm801_info *)p;
 288         u_int32_t               intsrc = fm801_rd(fm801, FM_INTSTATUS, 2);
 289
 290         DPRINT("\nfm801_intr intsrc 0x%x ", intsrc);
 291
 292         if(intsrc & FM_INTSTATUS_PLAY) {
 293                 fm801->play_flip++;
 294                 if(fm801->play_flip & 1) {
 295                         fm801_wr(fm801, FM_PLAY_DMABUF1, fm801->play_start,4);
 296                 } else
 297                         fm801_wr(fm801, FM_PLAY_DMABUF2, fm801->play_nextblk,4);
 298                 chn_intr(fm801->pch.channel);
 299         }
 300
 301         if(intsrc & FM_INTSTATUS_REC) {
 302                 fm801->rec_flip++;
 303                 if(fm801->rec_flip & 1) {
 304                         fm801_wr(fm801, FM_REC_DMABUF1, fm801->rec_start,4);
 305                 } else
 306                         fm801_wr(fm801, FM_REC_DMABUF2, fm801->rec_nextblk,4);
 307                 chn_intr(fm801->rch.channel);
 308         }
 309
 310         if ( intsrc & FM_INTSTATUS_MPU ) {
 311                 /* This is a TODOish thing... */
 312                 fm801_wr(fm801, FM_INTSTATUS, intsrc & FM_INTSTATUS_MPU,2);
 313         }
 314
 315         if ( intsrc & FM_INTSTATUS_VOL ) {
 316                 /* This is a TODOish thing... */
 317                 fm801_wr(fm801, FM_INTSTATUS, intsrc & FM_INTSTATUS_VOL,2);
 318         }
 319
 320         DPRINT("fm801_intr clear\n\n");
 321         fm801_wr(fm801, FM_INTSTATUS, intsrc & (FM_INTSTATUS_PLAY | FM_INTSTATUS_REC), 2);
 322 }
 323
 324 /* -------------------------------------------------------------------- */
 325 /* channel interface */
 326 static void *
 327 fm801ch_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir)
 328 {
 329         struct fm801_info *fm801 = (struct fm801_info *)devinfo;
 330         struct fm801_chinfo *ch = (dir == PCMDIR_PLAY)? &fm801->pch : &fm801->rch;
 331
 332         DPRINT("fm801ch_init, direction = %d\n", dir);
 333         ch->parent = fm801;
 334         ch->channel = c;
 335         ch->buffer = b;
 336         ch->dir = dir;
 337         if (sndbuf_alloc(ch->buffer, fm801->parent_dmat, fm801->bufsz) == -1) return NULL;
 338         return (void *)ch;
 339 }
 340
 341 static int
 342 fm801ch_setformat(kobj_t obj, void *data, u_int32_t format)
 343 {
 344         struct fm801_chinfo *ch = data;
 345         struct fm801_info *fm801 = ch->parent;
 346
 347         DPRINT("fm801ch_setformat 0x%x : %s, %s, %s, %s\n", format,
 348                 (format & AFMT_STEREO)?"stereo":"mono",
 349                 (format & (AFMT_S16_LE | AFMT_S16_BE | AFMT_U16_LE | AFMT_U16_BE)) ? "16bit":"8bit",
 350                 (format & AFMT_SIGNED)? "signed":"unsigned",
 351                 (format & AFMT_BIGENDIAN)?"bigendiah":"littleendian" );
 352
 353         if(ch->dir == PCMDIR_PLAY) {
 354                 fm801->play_fmt =  (format & AFMT_STEREO)? FM_PLAY_STEREO : 0;
 355                 fm801->play_fmt |= (format & AFMT_16BIT) ? FM_PLAY_16BIT : 0;
 356                 return 0;
 357         }
 358
 359         if(ch->dir == PCMDIR_REC ) {
 360                 fm801->rec_fmt = (format & AFMT_STEREO)? FM_REC_STEREO:0;
 361                 fm801->rec_fmt |= (format & AFMT_16BIT) ? FM_PLAY_16BIT : 0;
 362                 return 0;
 363         }
 364
 365         return 0;
 366 }
 367
 368 struct {
 369         int limit;
 370         int rate;
 371 } fm801_rates[11] = {
 372         {  6600,  5500 },
 373         {  8750,  8000 },
 374         { 10250,  9600 },
 375         { 13200, 11025 },
 376         { 17500, 16000 },
 377         { 20500, 19200 },
 378         { 26500, 22050 },
 379         { 35000, 32000 },
 380         { 41000, 38400 },
 381         { 46000, 44100 },
 382         { 48000, 48000 },
 383 /* anything above -> 48000 */
 384 };
 385
 386 static int
 387 fm801ch_setspeed(kobj_t obj, void *data, u_int32_t speed)
 388 {
 389         struct fm801_chinfo *ch = data;
 390         struct fm801_info *fm801 = ch->parent;
 391         register int i;
 392
 393
 394         for (i = 0; i < 10 && fm801_rates[i].limit <= speed; i++) ;
 395
 396         if(ch->dir == PCMDIR_PLAY) {
 397                 fm801->pch.spd = fm801_rates[i].rate;
 398                 fm801->play_shift = (i<<8);
 399                 fm801->play_shift &= FM_PLAY_RATE_MASK;
 400         }
 401
 402         if(ch->dir == PCMDIR_REC ) {
 403                 fm801->rch.spd = fm801_rates[i].rate;
 404                 fm801->rec_shift = (i<<8);
 405                 fm801->rec_shift &= FM_REC_RATE_MASK;
 406         }
 407
 408         ch->spd = fm801_rates[i].rate;
 409
 410         return fm801_rates[i].rate;
 411 }
 412
 413 static int
 414 fm801ch_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 415 {
 416         struct fm801_chinfo *ch = data;
 417         struct fm801_info *fm801 = ch->parent;
 418
 419         if(ch->dir == PCMDIR_PLAY) {
 420                 if(fm801->play_flip) return fm801->play_blksize;
 421                 fm801->play_blksize = blocksize;
 422         }
 423
 424         if(ch->dir == PCMDIR_REC) {
 425                 if(fm801->rec_flip) return fm801->rec_blksize;
 426                 fm801->rec_blksize = blocksize;
 427         }
 428
 429         DPRINT("fm801ch_setblocksize %d (dir %d)\n",blocksize, ch->dir);
 430
 431         return blocksize;
 432 }
 433
 434 static int
 435 fm801ch_trigger(kobj_t obj, void *data, int go)
 436 {
 437         struct fm801_chinfo *ch = data;
 438         struct fm801_info *fm801 = ch->parent;
 439         u_int32_t baseaddr = vtophys(sndbuf_getbuf(ch->buffer));
 440         u_int32_t k1;
 441
 442         DPRINT("fm801ch_trigger go %d , ", go);
 443
 444         if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD) {
 445                 return 0;
 446         }
 447
 448         if (ch->dir == PCMDIR_PLAY) {
 449                 if (go == PCMTRIG_START) {
 450
 451                         fm801->play_start = baseaddr;
 452                         fm801->play_nextblk = fm801->play_start + fm801->play_blksize;
 453                         fm801->play_flip = 0;
 454                         fm801_wr(fm801, FM_PLAY_DMALEN, fm801->play_blksize - 1, 2);
 455                         fm801_wr(fm801, FM_PLAY_DMABUF1,fm801->play_start,4);
 456                         fm801_wr(fm801, FM_PLAY_DMABUF2,fm801->play_nextblk,4);
 457                         fm801_wr(fm801, FM_PLAY_CTL,
 458                                         FM_PLAY_START | FM_PLAY_STOPNOW | fm801->play_fmt | fm801->play_shift,
 459                                         2 );
 460                         } else {
 461                         fm801->play_flip = 0;
 462                         k1 = fm801_rd(fm801, FM_PLAY_CTL,2);
 463                         fm801_wr(fm801, FM_PLAY_CTL,
 464                                 (k1 & ~(FM_PLAY_STOPNOW | FM_PLAY_START)) |
 465                                 FM_PLAY_BUF1_LAST | FM_PLAY_BUF2_LAST, 2 );
 466                 }
 467         } else if(ch->dir == PCMDIR_REC) {
 468                 if (go == PCMTRIG_START) {
 469                         fm801->rec_start = baseaddr;
 470                         fm801->rec_nextblk = fm801->rec_start + fm801->rec_blksize;
 471                         fm801->rec_flip = 0;
 472                         fm801_wr(fm801, FM_REC_DMALEN, fm801->rec_blksize - 1, 2);
 473                         fm801_wr(fm801, FM_REC_DMABUF1,fm801->rec_start,4);
 474                         fm801_wr(fm801, FM_REC_DMABUF2,fm801->rec_nextblk,4);
 475                         fm801_wr(fm801, FM_REC_CTL,
 476                                         FM_REC_START | FM_REC_STOPNOW | fm801->rec_fmt | fm801->rec_shift,
 477                                         2 );
 478                         } else {
 479                         fm801->rec_flip = 0;
 480                         k1 = fm801_rd(fm801, FM_REC_CTL,2);
 481                         fm801_wr(fm801, FM_REC_CTL,
 482                                 (k1 & ~(FM_REC_STOPNOW | FM_REC_START)) |
 483                                 FM_REC_BUF1_LAST | FM_REC_BUF2_LAST, 2);
 484                 }
 485         }
 486
 487         return 0;
 488 }
 489
 490 /* Almost ALSA copy */
 491 static int
 492 fm801ch_getptr(kobj_t obj, void *data)
 493 {
 494         struct fm801_chinfo *ch = data;
 495         struct fm801_info *fm801 = ch->parent;
 496         int result = 0;
 497
 498         if (ch->dir == PCMDIR_PLAY) {
 499                 result = fm801_rd(fm801,
 500                         (fm801->play_flip&1) ?
 501                         FM_PLAY_DMABUF2:FM_PLAY_DMABUF1, 4) - fm801->play_start;
 502         }
 503
 504         if (ch->dir == PCMDIR_REC) {
 505                 result = fm801_rd(fm801,
 506                         (fm801->rec_flip&1) ?
 507                         FM_REC_DMABUF2:FM_REC_DMABUF1, 4) - fm801->rec_start;
 508         }
 509
 510         return result;
 511 }
 512
 513 static struct pcmchan_caps *
 514 fm801ch_getcaps(kobj_t obj, void *data)
 515 {
 516         return &fm801ch_caps;
 517 }
 518
 519 static kobj_method_t fm801ch_methods[] = {
 520         KOBJMETHOD(channel_init,                fm801ch_init),
 521         KOBJMETHOD(channel_setformat,           fm801ch_setformat),
 522         KOBJMETHOD(channel_setspeed,            fm801ch_setspeed),
 523         KOBJMETHOD(channel_setblocksize,        fm801ch_setblocksize),
 524         KOBJMETHOD(channel_trigger,             fm801ch_trigger),
 525         KOBJMETHOD(channel_getptr,              fm801ch_getptr),
 526         KOBJMETHOD(channel_getcaps,             fm801ch_getcaps),
 527         { 0, 0 }
 528 };
 529 CHANNEL_DECLARE(fm801ch);
 530
 531 /* -------------------------------------------------------------------- */
 532
 533 /*
 534  *  Init routine is taken from an original NetBSD driver
 535  */
 536 static int
 537 fm801_init(struct fm801_info *fm801)
 538 {
 539         u_int32_t k1;
 540
 541         /* reset codec */
 542         fm801_wr(fm801, FM_CODEC_CTL, 0x0020,2);
 543         DELAY(100000);
 544         fm801_wr(fm801, FM_CODEC_CTL, 0x0000,2);
 545         DELAY(100000);
 546
 547         fm801_wr(fm801, FM_PCM_VOLUME, 0x0808,2);
 548         fm801_wr(fm801, FM_FM_VOLUME, 0x0808,2);
 549         fm801_wr(fm801, FM_I2S_VOLUME, 0x0808,2);
 550         fm801_wr(fm801, 0x40,0x107f,2); /* enable legacy audio */
 551
 552         fm801_wr((void *)fm801, FM_RECORD_SOURCE, 0x0000,2);
 553
 554         /* Unmask playback, record and mpu interrupts, mask the rest */
 555         k1 = fm801_rd((void *)fm801, FM_INTMASK,2);
 556         fm801_wr(fm801, FM_INTMASK,
 557                 (k1 & ~(FM_INTMASK_PLAY | FM_INTMASK_REC | FM_INTMASK_MPU)) |
 558                 FM_INTMASK_VOL,2);
 559         fm801_wr(fm801, FM_INTSTATUS,
 560                 FM_INTSTATUS_PLAY | FM_INTSTATUS_REC | FM_INTSTATUS_MPU |
 561                 FM_INTSTATUS_VOL,2);
 562
 563         DPRINT("FM801 init Ok\n");
 564         return 0;
 565 }
 566
 567 static int
 568 fm801_pci_attach(device_t dev)
 569 {
 570         u_int32_t               data;
 571         struct ac97_info        *codec = 0;
 572         struct fm801_info       *fm801;
 573         int                     i;
 574         int                     mapped = 0;
 575         char                    status[SND_STATUSLEN];
 576
 577         if ((fm801 = (struct fm801_info *)malloc(sizeof(*fm801), M_DEVBUF, M_NOWAIT | M_ZERO)) == NULL) {
 578                 device_printf(dev, "cannot allocate softc\n");
 579                 return ENXIO;
 580         }
 581
 582         fm801->type = pci_get_devid(dev);
 583
 584         data = pci_read_config(dev, PCIR_COMMAND, 2);
 585         data |= (PCIM_CMD_PORTEN|PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN);
 586         pci_write_config(dev, PCIR_COMMAND, data, 2);
 587         data = pci_read_config(dev, PCIR_COMMAND, 2);
 588
 589         for (i = 0; (mapped == 0) && (i < PCI_MAXMAPS_0); i++) {
 590                 fm801->regid = PCIR_MAPS + i*4;
 591                 fm801->regtype = SYS_RES_MEMORY;
 592                 fm801->reg = bus_alloc_resource(dev, fm801->regtype, &fm801->regid,
 593                                                 0, ~0, 1, RF_ACTIVE);
 594                 if(!fm801->reg)
 595                 {
 596                         fm801->regtype = SYS_RES_IOPORT;
 597                         fm801->reg = bus_alloc_resource(dev, fm801->regtype, &fm801->regid,
 598                                                 0, ~0, 1, RF_ACTIVE);
 599                 }
 600
 601                 if(fm801->reg) {
 602                         fm801->st = rman_get_bustag(fm801->reg);
 603                         fm801->sh = rman_get_bushandle(fm801->reg);
 604                         mapped++;
 605                 }
 606         }
 607
 608         if (mapped == 0) {
 609                 device_printf(dev, "unable to map register space\n");
 610                 goto oops;
 611         }
 612
 613         fm801->bufsz = pcm_getbuffersize(dev, 4096, FM801_DEFAULT_BUFSZ, 65536);
 614
 615         fm801_init(fm801);
 616
 617         codec = AC97_CREATE(dev, fm801, fm801_ac97);
 618         if (codec == NULL) goto oops;
 619
 620         if (mixer_init(dev, ac97_getmixerclass(), codec) == -1) goto oops;
 621
 622         fm801->irqid = 0;
 623         fm801->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &fm801->irqid,
 624                                 0, ~0, 1, RF_ACTIVE | RF_SHAREABLE);
 625         if (!fm801->irq || snd_setup_intr(dev, fm801->irq, 0, fm801_intr, fm801, &fm801->ih)) {
 626                 device_printf(dev, "unable to map interrupt\n");
 627                 goto oops;
 628         }
 629
 630         if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0,
 631                 /*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
 632                 /*highaddr*/BUS_SPACE_MAXADDR,
 633                 /*filter*/NULL, /*filterarg*/NULL,
 634                 /*maxsize*/fm801->bufsz, /*nsegments*/1, /*maxsegz*/0x3ffff,
 635                 /*flags*/0, &fm801->parent_dmat) != 0) {
 636                 device_printf(dev, "unable to create dma tag\n");
 637                 goto oops;
 638         }
 639
 640         snprintf(status, 64, "at %s 0x%lx irq %ld",
 641                 (fm801->regtype == SYS_RES_IOPORT)? "io" : "memory",
 642                 rman_get_start(fm801->reg), rman_get_start(fm801->irq));
 643
 644 #define FM801_MAXPLAYCH 1
 645         if (pcm_register(dev, fm801, FM801_MAXPLAYCH, 1)) goto oops;
 646         pcm_addchan(dev, PCMDIR_PLAY, &fm801ch_class, fm801);
 647         pcm_addchan(dev, PCMDIR_REC, &fm801ch_class, fm801);
 648         pcm_setstatus(dev, status);
 649
 650         fm801->radio = device_add_child(dev, "radio", -1);
 651         bus_generic_attach(dev);
 652
 653         return 0;
 654
 655 oops:
 656         if (codec) ac97_destroy(codec);
 657         if (fm801->reg) bus_release_resource(dev, fm801->regtype, fm801->regid, fm801->reg);
 658         if (fm801->ih) bus_teardown_intr(dev, fm801->irq, fm801->ih);
 659         if (fm801->irq) bus_release_resource(dev, SYS_RES_IRQ, fm801->irqid, fm801->irq);
 660         if (fm801->parent_dmat) bus_dma_tag_destroy(fm801->parent_dmat);
 661         free(fm801, M_DEVBUF);
 662         return ENXIO;
 663 }
 664
 665 static int
 666 fm801_pci_detach(device_t dev)
 667 {
 668         int r;
 669         struct fm801_info *fm801;
 670
 671         DPRINT("Forte Media FM801 detach\n");
 672
 673         fm801 = pcm_getdevinfo(dev);
 674
 675         r = bus_generic_detach(dev);
 676         if (r)
 677                 return r;
 678         if (fm801->radio != NULL) {
 679                 r = device_delete_child(dev, fm801->radio);
 680                 if (r)
 681                         return r;
 682                 fm801->radio = NULL;
 683         }
 684
 685         r = pcm_unregister(dev);
 686         if (r)
 687                 return r;
 688
 689         bus_release_resource(dev, fm801->regtype, fm801->regid, fm801->reg);
 690         bus_teardown_intr(dev, fm801->irq, fm801->ih);
 691         bus_release_resource(dev, SYS_RES_IRQ, fm801->irqid, fm801->irq);
 692         bus_dma_tag_destroy(fm801->parent_dmat);
 693         free(fm801, M_DEVBUF);
 694         return 0;
 695 }
 696
 697 static int
 698 fm801_pci_probe( device_t dev )
 699 {
 700         u_int32_t data;
 701         int id, regtype, regid, result;
 702         struct resource *reg;
 703         bus_space_tag_t st;
 704         bus_space_handle_t sh;
 705
 706         result = ENXIO;
 707
 708         if ((id = pci_get_devid(dev)) == PCI_DEVICE_FORTEMEDIA1 ) {
 709                 data = pci_read_config(dev, PCIR_COMMAND, 2);
 710                 data |= (PCIM_CMD_PORTEN|PCIM_CMD_BUSMASTEREN);
 711                 pci_write_config(dev, PCIR_COMMAND, data, 2);
 712                 data = pci_read_config(dev, PCIR_COMMAND, 2);
 713
 714                 regid = PCIR_MAPS;
 715                 regtype = SYS_RES_IOPORT;
 716                 reg = bus_alloc_resource(dev, regtype, &regid, 0, ~0, 1,
 717                     RF_ACTIVE);
 718
 719                 if (reg == NULL)
 720                         return ENXIO;
 721
 722                 st = rman_get_bustag(reg);
 723                 sh = rman_get_bushandle(reg);
 724                 /*
 725                  * XXX: quick check that device actually has sound capabilities.
 726                  * The problem is that some cards built around FM801 chip only
 727                  * have radio tuner onboard, but no sound capabilities. There
 728                  * is no "official" way to quickly check this, because all
 729                  * IDs are exactly the same. The only difference is 0x28
 730                  * device control register, described in FM801 specification
 731                  * as "SRC/Mixer Test Control/DFC Status", but without
 732                  * any more detailed explanation. According to specs, and
 733                  * available sample cards (SF256-PCP-R and SF256-PCS-R) its
 734                  * power-on value should be `0', while on AC97-less tuner
 735                  * card (SF64-PCR) it was 0x80.
 736                  */
 737                 if (bus_space_read_1(st, sh, 0x28) == 0) {
 738                         device_set_desc(dev,
 739                             "Forte Media FM801 Audio Controller");
 740                         result = 0;
 741                 }
 742
 743                 bus_release_resource(dev, regtype, regid, reg);
 744         }
 745 /*
 746         if ((id = pci_get_devid(dev)) == PCI_DEVICE_FORTEMEDIA2 ) {
 747                 device_set_desc(dev, "Forte Media FM801 Joystick (Not Supported)");
 748                 return ENXIO;
 749         }
 750 */
 751         return (result);
 752 }
 753
 754 static struct resource *
 755 fm801_alloc_resource(device_t bus, device_t child, int type, int *rid,
 756                      u_long start, u_long end, u_long count, u_int flags)
 757 {
 758         struct fm801_info *fm801;
 759
 760         fm801 = pcm_getdevinfo(bus);
 761
 762         if (type == SYS_RES_IOPORT && *rid == PCIR_MAPS)
 763                 return (fm801->reg);
 764
 765         return (NULL);
 766 }
 767
 768 static int
 769 fm801_release_resource(device_t bus, device_t child, int type, int rid,
 770                        struct resource *r)
 771 {
 772         return (0);
 773 }
 774
 775 static device_method_t fm801_methods[] = {
 776         /* Device interface */
 777         DEVMETHOD(device_probe,         fm801_pci_probe),
 778         DEVMETHOD(device_attach,        fm801_pci_attach),
 779         DEVMETHOD(device_detach,        fm801_pci_detach),
 780         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
 781         DEVMETHOD(device_suspend,       bus_generic_suspend),
 782         DEVMETHOD(device_resume,        bus_generic_resume),
 783
 784         /* Bus interface */
 785         DEVMETHOD(bus_print_child,      bus_generic_print_child),
 786         DEVMETHOD(bus_alloc_resource,   fm801_alloc_resource),
 787         DEVMETHOD(bus_release_resource, fm801_release_resource),
 788         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
 789         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
 790         { 0, 0}
 791 };
 792
 793 static driver_t fm801_driver = {
 794         "pcm",
 795         fm801_methods,
 796         PCM_SOFTC_SIZE,
 797 };
 798
 799 DRIVER_MODULE(snd_fm801, pci, fm801_driver, pcm_devclass, 0, 0);
 800 MODULE_DEPEND(snd_fm801, snd_pcm, PCM_MINVER, PCM_PREFVER, PCM_MAXVER);
 801 MODULE_VERSION(snd_fm801, 1);