sys/dev/sound/pci/ds1.c

   1 /*-
   2  * Copyright (c) 2000 Cameron Grant <cg@freebsd.org>
   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, WHETHERIN 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 THEPOSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/sys/dev/sound/pci/ds1.c,v 1.43.2.1 2006/01/18 01:05:34 ariff Exp $
  27  */
  28
  29 #include <dev/sound/pcm/sound.h>
  30 #include <dev/sound/pcm/ac97.h>
  31
  32 #include <bus/pci/pcireg.h>
  33 #include <bus/pci/pcivar.h>
  34
  35 #include <dev/sound/pci/ds1.h>
  36 #include <dev/sound/pci/ds1-fw.h>
  37
  38 SND_DECLARE_FILE("$DragonFly: src/sys/dev/sound/pci/ds1.c,v 1.11 2008/01/07 09:42:07 swildner Exp $");
  39
  40 /* -------------------------------------------------------------------- */
  41
  42 #define DS1_CHANS 4
  43 #define DS1_RECPRIMARY 0
  44 #define DS1_IRQHZ ((48000 << 8) / 256)
  45 #define DS1_BUFFSIZE 4096
  46
  47 struct pbank {
  48         volatile u_int32_t      Format;
  49         volatile u_int32_t      LoopDefault;
  50         volatile u_int32_t      PgBase;
  51         volatile u_int32_t      PgLoop;
  52         volatile u_int32_t      PgLoopEnd;
  53         volatile u_int32_t      PgLoopFrac;
  54         volatile u_int32_t      PgDeltaEnd;
  55         volatile u_int32_t      LpfKEnd;
  56         volatile u_int32_t      EgGainEnd;
  57         volatile u_int32_t      LchGainEnd;
  58         volatile u_int32_t      RchGainEnd;
  59         volatile u_int32_t      Effect1GainEnd;
  60         volatile u_int32_t      Effect2GainEnd;
  61         volatile u_int32_t      Effect3GainEnd;
  62         volatile u_int32_t      LpfQ;
  63         volatile u_int32_t      Status;
  64         volatile u_int32_t      NumOfFrames;
  65         volatile u_int32_t      LoopCount;
  66         volatile u_int32_t      PgStart;
  67         volatile u_int32_t      PgStartFrac;
  68         volatile u_int32_t      PgDelta;
  69         volatile u_int32_t      LpfK;
  70         volatile u_int32_t      EgGain;
  71         volatile u_int32_t      LchGain;
  72         volatile u_int32_t      RchGain;
  73         volatile u_int32_t      Effect1Gain;
  74         volatile u_int32_t      Effect2Gain;
  75         volatile u_int32_t      Effect3Gain;
  76         volatile u_int32_t      LpfD1;
  77         volatile u_int32_t      LpfD2;
  78 };
  79
  80 struct rbank {
  81         volatile u_int32_t      PgBase;
  82         volatile u_int32_t      PgLoopEnd;
  83         volatile u_int32_t      PgStart;
  84         volatile u_int32_t      NumOfLoops;
  85 };
  86
  87 struct sc_info;
  88
  89 /* channel registers */
  90 struct sc_pchinfo {
  91         int run, spd, dir, fmt;
  92         struct snd_dbuf *buffer;
  93         struct pcm_channel *channel;
  94         volatile struct pbank *lslot, *rslot;
  95         int lsnum, rsnum;
  96         struct sc_info *parent;
  97 };
  98
  99 struct sc_rchinfo {
 100         int run, spd, dir, fmt, num;
 101         struct snd_dbuf *buffer;
 102         struct pcm_channel *channel;
 103         volatile struct rbank *slot;
 104         struct sc_info *parent;
 105 };
 106
 107 /* device private data */
 108 struct sc_info {
 109         device_t        dev;
 110         u_int32_t       type, rev;
 111         u_int32_t       cd2id, ctrlbase;
 112
 113         bus_space_tag_t st;
 114         bus_space_handle_t sh;
 115         bus_dma_tag_t buffer_dmat, control_dmat;
 116         bus_dmamap_t map;
 117
 118         struct resource *reg, *irq;
 119         int             regid, irqid;
 120         void            *ih;
 121         sndlock_t       lock;
 122
 123         void *regbase;
 124         u_int32_t *pbase, pbankbase, pbanksize;
 125         volatile struct pbank *pbank[2 * 64];
 126         volatile struct rbank *rbank;
 127         int pslotfree, currbank, pchn, rchn;
 128         unsigned int bufsz;
 129
 130         struct sc_pchinfo pch[DS1_CHANS];
 131         struct sc_rchinfo rch[2];
 132 };
 133
 134 struct {
 135         u_int32_t dev, subdev;
 136         char *name;
 137         u_int32_t *mcode;
 138 } ds_devs[] = {
 139         {0x00041073, 0,                 "Yamaha DS-1 (YMF724)", CntrlInst},
 140         {0x000d1073, 0,                 "Yamaha DS-1E (YMF724F)", CntrlInst1E},
 141         {0x00051073, 0,                 "Yamaha DS-1? (YMF734)", CntrlInst},
 142         {0x00081073, 0,                 "Yamaha DS-1? (YMF737)", CntrlInst},
 143         {0x00201073, 0,                 "Yamaha DS-1? (YMF738)", CntrlInst},
 144         {0x00061073, 0,                 "Yamaha DS-1? (YMF738_TEG)", CntrlInst},
 145         {0x000a1073, 0x00041073,        "Yamaha DS-1 (YMF740)", CntrlInst},
 146         {0x000a1073, 0x000a1073,        "Yamaha DS-1 (YMF740B)", CntrlInst},
 147         {0x000a1073, 0x53328086,        "Yamaha DS-1 (YMF740I)", CntrlInst},
 148         {0x000a1073, 0,                 "Yamaha DS-1 (YMF740?)", CntrlInst},
 149         {0x000c1073, 0,                 "Yamaha DS-1E (YMF740C)", CntrlInst1E},
 150         {0x00101073, 0,                 "Yamaha DS-1E (YMF744)", CntrlInst1E},
 151         {0x00121073, 0,                 "Yamaha DS-1E (YMF754)", CntrlInst1E},
 152         {0, 0, NULL, NULL}
 153 };
 154
 155 /* -------------------------------------------------------------------- */
 156
 157 /*
 158  * prototypes
 159  */
 160
 161 /* stuff */
 162 static int       ds_init(struct sc_info *);
 163 static void      ds_intr(void *);
 164
 165 /* talk to the card */
 166 static u_int32_t ds_rd(struct sc_info *, int, int);
 167 static void      ds_wr(struct sc_info *, int, u_int32_t, int);
 168
 169 /* -------------------------------------------------------------------- */
 170
 171 static u_int32_t ds_recfmt[] = {
 172         AFMT_U8,
 173         AFMT_STEREO | AFMT_U8,
 174         AFMT_S8,
 175         AFMT_STEREO | AFMT_S8,
 176         AFMT_S16_LE,
 177         AFMT_STEREO | AFMT_S16_LE,
 178         AFMT_U16_LE,
 179         AFMT_STEREO | AFMT_U16_LE,
 180         0
 181 };
 182 static struct pcmchan_caps ds_reccaps = {4000, 48000, ds_recfmt, 0};
 183
 184 static u_int32_t ds_playfmt[] = {
 185         AFMT_U8,
 186         AFMT_STEREO | AFMT_U8,
 187         /* AFMT_S16_LE, */
 188         AFMT_STEREO | AFMT_S16_LE,
 189         0
 190 };
 191 static struct pcmchan_caps ds_playcaps = {4000, 96000, ds_playfmt, 0};
 192
 193 /* -------------------------------------------------------------------- */
 194 /* Hardware */
 195 static u_int32_t
 196 ds_rd(struct sc_info *sc, int regno, int size)
 197 {
 198         switch (size) {
 199         case 1:
 200                 return bus_space_read_1(sc->st, sc->sh, regno);
 201         case 2:
 202                 return bus_space_read_2(sc->st, sc->sh, regno);
 203         case 4:
 204                 return bus_space_read_4(sc->st, sc->sh, regno);
 205         default:
 206                 return 0xffffffff;
 207         }
 208 }
 209
 210 static void
 211 ds_wr(struct sc_info *sc, int regno, u_int32_t data, int size)
 212 {
 213         switch (size) {
 214         case 1:
 215                 bus_space_write_1(sc->st, sc->sh, regno, data);
 216                 break;
 217         case 2:
 218                 bus_space_write_2(sc->st, sc->sh, regno, data);
 219                 break;
 220         case 4:
 221                 bus_space_write_4(sc->st, sc->sh, regno, data);
 222                 break;
 223         }
 224 }
 225
 226 static void
 227 wrl(struct sc_info *sc, u_int32_t *ptr, u_int32_t val)
 228 {
 229         *(volatile u_int32_t *)ptr = val;
 230         bus_space_barrier(sc->st, sc->sh, 0, 0, BUS_SPACE_BARRIER_WRITE);
 231 }
 232
 233 /* -------------------------------------------------------------------- */
 234 /* ac97 codec */
 235 static int
 236 ds_cdbusy(struct sc_info *sc, int sec)
 237 {
 238         int i, reg;
 239
 240         reg = sec? YDSXGR_SECSTATUSADR : YDSXGR_PRISTATUSADR;
 241         i = YDSXG_AC97TIMEOUT;
 242         while (i > 0) {
 243                 if (!(ds_rd(sc, reg, 2) & 0x8000))
 244                         return 0;
 245                 i--;
 246         }
 247         return ETIMEDOUT;
 248 }
 249
 250 static u_int32_t
 251 ds_initcd(kobj_t obj, void *devinfo)
 252 {
 253         struct sc_info *sc = (struct sc_info *)devinfo;
 254         u_int32_t x;
 255
 256         x = pci_read_config(sc->dev, PCIR_DSXGCTRL, 1);
 257         if (x & 0x03) {
 258                 pci_write_config(sc->dev, PCIR_DSXGCTRL, x & ~0x03, 1);
 259                 pci_write_config(sc->dev, PCIR_DSXGCTRL, x | 0x03, 1);
 260                 pci_write_config(sc->dev, PCIR_DSXGCTRL, x & ~0x03, 1);
 261                 /*
 262                  * The YMF740 on some Intel motherboards requires a pretty
 263                  * hefty delay after this reset for some reason...  Otherwise:
 264                  * "pcm0: ac97 codec init failed"
 265                  * Maybe this is needed for all YMF740's?
 266                  * 400ms and 500ms here seem to work, 300ms does not.
 267                  *
 268                  * do it for all chips -cg
 269                  */
 270                 DELAY(500000);
 271         }
 272
 273         return ds_cdbusy(sc, 0)? 0 : 1;
 274 }
 275
 276 static int
 277 ds_rdcd(kobj_t obj, void *devinfo, int regno)
 278 {
 279         struct sc_info *sc = (struct sc_info *)devinfo;
 280         int sec, cid, i;
 281         u_int32_t cmd, reg;
 282
 283         sec = regno & 0x100;
 284         regno &= 0xff;
 285         cid = sec? (sc->cd2id << 8) : 0;
 286         reg = sec? YDSXGR_SECSTATUSDATA : YDSXGR_PRISTATUSDATA;
 287         if (sec && cid == 0)
 288                 return 0xffffffff;
 289
 290         cmd = YDSXG_AC97READCMD | cid | regno;
 291         ds_wr(sc, YDSXGR_AC97CMDADR, cmd, 2);
 292
 293         if (ds_cdbusy(sc, sec))
 294                 return 0xffffffff;
 295
 296         if (sc->type == 11 && sc->rev < 2)
 297                 for (i = 0; i < 600; i++)
 298                         ds_rd(sc, reg, 2);
 299
 300         return ds_rd(sc, reg, 2);
 301 }
 302
 303 static int
 304 ds_wrcd(kobj_t obj, void *devinfo, int regno, u_int32_t data)
 305 {
 306         struct sc_info *sc = (struct sc_info *)devinfo;
 307         int sec, cid;
 308         u_int32_t cmd;
 309
 310         sec = regno & 0x100;
 311         regno &= 0xff;
 312         cid = sec? (sc->cd2id << 8) : 0;
 313         if (sec && cid == 0)
 314                 return ENXIO;
 315
 316         cmd = YDSXG_AC97WRITECMD | cid | regno;
 317         cmd <<= 16;
 318         cmd |= data;
 319         ds_wr(sc, YDSXGR_AC97CMDDATA, cmd, 4);
 320
 321         return ds_cdbusy(sc, sec);
 322 }
 323
 324 static kobj_method_t ds_ac97_methods[] = {
 325         KOBJMETHOD(ac97_init,           ds_initcd),
 326         KOBJMETHOD(ac97_read,           ds_rdcd),
 327         KOBJMETHOD(ac97_write,          ds_wrcd),
 328         { 0, 0 }
 329 };
 330 AC97_DECLARE(ds_ac97);
 331
 332 /* -------------------------------------------------------------------- */
 333
 334 static void
 335 ds_enadsp(struct sc_info *sc, int on)
 336 {
 337         u_int32_t v, i;
 338
 339         v = on? 1 : 0;
 340         if (on) {
 341                 ds_wr(sc, YDSXGR_CONFIG, 0x00000001, 4);
 342         } else {
 343                 if (ds_rd(sc, YDSXGR_CONFIG, 4))
 344                         ds_wr(sc, YDSXGR_CONFIG, 0x00000000, 4);
 345                 i = YDSXG_WORKBITTIMEOUT;
 346                 while (i > 0) {
 347                         if (!(ds_rd(sc, YDSXGR_CONFIG, 4) & 0x00000002))
 348                                 break;
 349                         i--;
 350                 }
 351         }
 352 }
 353
 354 static volatile struct pbank *
 355 ds_allocpslot(struct sc_info *sc)
 356 {
 357         int slot;
 358
 359         if (sc->pslotfree > 63)
 360                 return NULL;
 361         slot = sc->pslotfree++;
 362         return sc->pbank[slot * 2];
 363 }
 364
 365 static int
 366 ds_initpbank(volatile struct pbank *pb, int ch, int b16, int stereo, u_int32_t rate, bus_addr_t base, u_int32_t len)
 367 {
 368         u_int32_t lv[] = {1, 1, 0, 0, 0};
 369         u_int32_t rv[] = {1, 0, 1, 0, 0};
 370         u_int32_t e1[] = {0, 0, 0, 0, 0};
 371         u_int32_t e2[] = {1, 0, 0, 1, 0};
 372         u_int32_t e3[] = {1, 0, 0, 0, 1};
 373         int ss, i;
 374         u_int32_t delta;
 375
 376         struct {
 377                 int rate, fK, fQ;
 378         } speedinfo[] = {
 379                 {  100, 0x00570000, 0x35280000},
 380                 { 2000, 0x06aa0000, 0x34a70000},
 381                 { 8000, 0x18b20000, 0x32020000},
 382                 {11025, 0x20930000, 0x31770000},
 383                 {16000, 0x2b9a0000, 0x31390000},
 384                 {22050, 0x35a10000, 0x31c90000},
 385                 {32000, 0x3eaa0000, 0x33d00000},
 386 /*              {44100, 0x04646000, 0x370a0000},
 387 */              {48000, 0x40000000, 0x40000000},
 388         };
 389
 390         ss = b16? 1 : 0;
 391         ss += stereo? 1 : 0;
 392         delta = (65536 * rate) / 48000;
 393         i = 0;
 394         while (i < 7 && speedinfo[i].rate < rate)
 395                 i++;
 396
 397         pb->Format = stereo? 0x00010000 : 0;
 398         pb->Format |= b16? 0 : 0x80000000;
 399         pb->Format |= (stereo && (ch == 2 || ch == 4))? 0x00000001 : 0;
 400         pb->LoopDefault = 0;
 401         pb->PgBase = base? base : 0;
 402         pb->PgLoop = 0;
 403         pb->PgLoopEnd = len >> ss;
 404         pb->PgLoopFrac = 0;
 405         pb->Status = 0;
 406         pb->NumOfFrames = 0;
 407         pb->LoopCount = 0;
 408         pb->PgStart = 0;
 409         pb->PgStartFrac = 0;
 410         pb->PgDelta = pb->PgDeltaEnd = delta << 12;
 411         pb->LpfQ = speedinfo[i].fQ;
 412         pb->LpfK = pb->LpfKEnd = speedinfo[i].fK;
 413         pb->LpfD1 = pb->LpfD2 = 0;
 414         pb->EgGain = pb->EgGainEnd = 0x40000000;
 415         pb->LchGain = pb->LchGainEnd = lv[ch] * 0x40000000;
 416         pb->RchGain = pb->RchGainEnd = rv[ch] * 0x40000000;
 417         pb->Effect1Gain = pb->Effect1GainEnd = e1[ch] * 0x40000000;
 418         pb->Effect2Gain = pb->Effect2GainEnd = e2[ch] * 0x40000000;
 419         pb->Effect3Gain = pb->Effect3GainEnd = e3[ch] * 0x40000000;
 420
 421         return 0;
 422 }
 423
 424 static void
 425 ds_enapslot(struct sc_info *sc, int slot, int go)
 426 {
 427         wrl(sc, &sc->pbase[slot + 1], go? (sc->pbankbase + 2 * slot * sc->pbanksize) : 0);
 428         /* kprintf("pbase[%d] = 0x%x\n", slot + 1, go? (sc->pbankbase + 2 * slot * sc->pbanksize) : 0); */
 429 }
 430
 431 static void
 432 ds_setuppch(struct sc_pchinfo *ch)
 433 {
 434         int stereo, b16, c, sz;
 435         bus_addr_t addr;
 436
 437         stereo = (ch->fmt & AFMT_STEREO)? 1 : 0;
 438         b16 = (ch->fmt & AFMT_16BIT)? 1 : 0;
 439         c = stereo? 1 : 0;
 440         addr = sndbuf_getbufaddr(ch->buffer);
 441         sz = sndbuf_getsize(ch->buffer);
 442
 443         ds_initpbank(ch->lslot, c, stereo, b16, ch->spd, addr, sz);
 444         ds_initpbank(ch->lslot + 1, c, stereo, b16, ch->spd, addr, sz);
 445         ds_initpbank(ch->rslot, 2, stereo, b16, ch->spd, addr, sz);
 446         ds_initpbank(ch->rslot + 1, 2, stereo, b16, ch->spd, addr, sz);
 447 }
 448
 449 static void
 450 ds_setuprch(struct sc_rchinfo *ch)
 451 {
 452         struct sc_info *sc = ch->parent;
 453         int stereo, b16, i, sz, pri;
 454         u_int32_t x, y;
 455         bus_addr_t addr;
 456
 457         stereo = (ch->fmt & AFMT_STEREO)? 1 : 0;
 458         b16 = (ch->fmt & AFMT_16BIT)? 1 : 0;
 459         addr = sndbuf_getbufaddr(ch->buffer);
 460         sz = sndbuf_getsize(ch->buffer);
 461         pri = (ch->num == DS1_RECPRIMARY)? 1 : 0;
 462
 463         for (i = 0; i < 2; i++) {
 464                 ch->slot[i].PgBase = addr;
 465                 ch->slot[i].PgLoopEnd = sz;
 466                 ch->slot[i].PgStart = 0;
 467                 ch->slot[i].NumOfLoops = 0;
 468         }
 469         x = (b16? 0x00 : 0x01) | (stereo? 0x02 : 0x00);
 470         y = (48000 * 4096) / ch->spd;
 471         y--;
 472         /* kprintf("pri = %d, x = %d, y = %d\n", pri, x, y); */
 473         ds_wr(sc, pri? YDSXGR_ADCFORMAT : YDSXGR_RECFORMAT, x, 4);
 474         ds_wr(sc, pri? YDSXGR_ADCSLOTSR : YDSXGR_RECSLOTSR, y, 4);
 475 }
 476
 477 /* -------------------------------------------------------------------- */
 478 /* play channel interface */
 479 static void *
 480 ds1pchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir)
 481 {
 482         struct sc_info *sc = devinfo;
 483         struct sc_pchinfo *ch;
 484
 485         KASSERT(dir == PCMDIR_PLAY, ("ds1pchan_init: bad direction"));
 486
 487         ch = &sc->pch[sc->pchn++];
 488         ch->buffer = b;
 489         ch->parent = sc;
 490         ch->channel = c;
 491         ch->dir = dir;
 492         ch->fmt = AFMT_U8;
 493         ch->spd = 8000;
 494         ch->run = 0;
 495         if (sndbuf_alloc(ch->buffer, sc->buffer_dmat, sc->bufsz) != 0)
 496                 return NULL;
 497         else {
 498                 ch->lsnum = sc->pslotfree;
 499                 ch->lslot = ds_allocpslot(sc);
 500                 ch->rsnum = sc->pslotfree;
 501                 ch->rslot = ds_allocpslot(sc);
 502                 ds_setuppch(ch);
 503                 return ch;
 504         }
 505 }
 506
 507 static int
 508 ds1pchan_setformat(kobj_t obj, void *data, u_int32_t format)
 509 {
 510         struct sc_pchinfo *ch = data;
 511
 512         ch->fmt = format;
 513
 514         return 0;
 515 }
 516
 517 static int
 518 ds1pchan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 519 {
 520         struct sc_pchinfo *ch = data;
 521
 522         ch->spd = speed;
 523
 524         return speed;
 525 }
 526
 527 static int
 528 ds1pchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 529 {
 530         struct sc_pchinfo *ch = data;
 531         struct sc_info *sc = ch->parent;
 532         int drate;
 533
 534         /* irq rate is fixed at 187.5hz */
 535         drate = ch->spd * sndbuf_getbps(ch->buffer);
 536         blocksize = roundup2((drate << 8) / DS1_IRQHZ, 4);
 537         sndbuf_resize(ch->buffer, sc->bufsz / blocksize, blocksize);
 538
 539         return blocksize;
 540 }
 541
 542 /* semantic note: must start at beginning of buffer */
 543 static int
 544 ds1pchan_trigger(kobj_t obj, void *data, int go)
 545 {
 546         struct sc_pchinfo *ch = data;
 547         struct sc_info *sc = ch->parent;
 548         int stereo;
 549
 550         if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD)
 551                 return 0;
 552         stereo = (ch->fmt & AFMT_STEREO)? 1 : 0;
 553         if (go == PCMTRIG_START) {
 554                 ch->run = 1;
 555                 ds_setuppch(ch);
 556                 ds_enapslot(sc, ch->lsnum, 1);
 557                 ds_enapslot(sc, ch->rsnum, stereo);
 558                 snd_mtxlock(sc->lock);
 559                 ds_wr(sc, YDSXGR_MODE, 0x00000003, 4);
 560                 snd_mtxunlock(sc->lock);
 561         } else {
 562                 ch->run = 0;
 563                 /* ds_setuppch(ch); */
 564                 ds_enapslot(sc, ch->lsnum, 0);
 565                 ds_enapslot(sc, ch->rsnum, 0);
 566         }
 567
 568         return 0;
 569 }
 570
 571 static int
 572 ds1pchan_getptr(kobj_t obj, void *data)
 573 {
 574         struct sc_pchinfo *ch = data;
 575         struct sc_info *sc = ch->parent;
 576         volatile struct pbank *bank;
 577         int ss;
 578         u_int32_t ptr;
 579
 580         ss = (ch->fmt & AFMT_STEREO)? 1 : 0;
 581         ss += (ch->fmt & AFMT_16BIT)? 1 : 0;
 582
 583         bank = ch->lslot + sc->currbank;
 584         /* kprintf("getptr: %d\n", bank->PgStart << ss); */
 585         ptr = bank->PgStart;
 586         ptr <<= ss;
 587         return ptr;
 588 }
 589
 590 static struct pcmchan_caps *
 591 ds1pchan_getcaps(kobj_t obj, void *data)
 592 {
 593         return &ds_playcaps;
 594 }
 595
 596 static kobj_method_t ds1pchan_methods[] = {
 597         KOBJMETHOD(channel_init,                ds1pchan_init),
 598         KOBJMETHOD(channel_setformat,           ds1pchan_setformat),
 599         KOBJMETHOD(channel_setspeed,            ds1pchan_setspeed),
 600         KOBJMETHOD(channel_setblocksize,        ds1pchan_setblocksize),
 601         KOBJMETHOD(channel_trigger,             ds1pchan_trigger),
 602         KOBJMETHOD(channel_getptr,              ds1pchan_getptr),
 603         KOBJMETHOD(channel_getcaps,             ds1pchan_getcaps),
 604         { 0, 0 }
 605 };
 606 CHANNEL_DECLARE(ds1pchan);
 607
 608 /* -------------------------------------------------------------------- */
 609 /* record channel interface */
 610 static void *
 611 ds1rchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir)
 612 {
 613         struct sc_info *sc = devinfo;
 614         struct sc_rchinfo *ch;
 615
 616         KASSERT(dir == PCMDIR_REC, ("ds1rchan_init: bad direction"));
 617
 618         ch = &sc->rch[sc->rchn];
 619         ch->num = sc->rchn++;
 620         ch->buffer = b;
 621         ch->parent = sc;
 622         ch->channel = c;
 623         ch->dir = dir;
 624         ch->fmt = AFMT_U8;
 625         ch->spd = 8000;
 626         if (sndbuf_alloc(ch->buffer, sc->buffer_dmat, sc->bufsz) != 0)
 627                 return NULL;
 628         else {
 629                 ch->slot = (ch->num == DS1_RECPRIMARY)? sc->rbank + 2: sc->rbank;
 630                 ds_setuprch(ch);
 631                 return ch;
 632         }
 633 }
 634
 635 static int
 636 ds1rchan_setformat(kobj_t obj, void *data, u_int32_t format)
 637 {
 638         struct sc_rchinfo *ch = data;
 639
 640         ch->fmt = format;
 641
 642         return 0;
 643 }
 644
 645 static int
 646 ds1rchan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 647 {
 648         struct sc_rchinfo *ch = data;
 649
 650         ch->spd = speed;
 651
 652         return speed;
 653 }
 654
 655 static int
 656 ds1rchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 657 {
 658         struct sc_rchinfo *ch = data;
 659         struct sc_info *sc = ch->parent;
 660         int drate;
 661
 662         /* irq rate is fixed at 187.5hz */
 663         drate = ch->spd * sndbuf_getbps(ch->buffer);
 664         blocksize = roundup2((drate << 8) / DS1_IRQHZ, 4);
 665         sndbuf_resize(ch->buffer, sc->bufsz / blocksize, blocksize);
 666
 667         return blocksize;
 668 }
 669
 670 /* semantic note: must start at beginning of buffer */
 671 static int
 672 ds1rchan_trigger(kobj_t obj, void *data, int go)
 673 {
 674         struct sc_rchinfo *ch = data;
 675         struct sc_info *sc = ch->parent;
 676         u_int32_t x;
 677
 678         if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD)
 679                 return 0;
 680         if (go == PCMTRIG_START) {
 681                 ch->run = 1;
 682                 ds_setuprch(ch);
 683                 snd_mtxlock(sc->lock);
 684                 x = ds_rd(sc, YDSXGR_MAPOFREC, 4);
 685                 x |= (ch->num == DS1_RECPRIMARY)? 0x02 : 0x01;
 686                 ds_wr(sc, YDSXGR_MAPOFREC, x, 4);
 687                 ds_wr(sc, YDSXGR_MODE, 0x00000003, 4);
 688                 snd_mtxunlock(sc->lock);
 689         } else {
 690                 ch->run = 0;
 691                 snd_mtxlock(sc->lock);
 692                 x = ds_rd(sc, YDSXGR_MAPOFREC, 4);
 693                 x &= ~((ch->num == DS1_RECPRIMARY)? 0x02 : 0x01);
 694                 ds_wr(sc, YDSXGR_MAPOFREC, x, 4);
 695                 snd_mtxunlock(sc->lock);
 696         }
 697
 698         return 0;
 699 }
 700
 701 static int
 702 ds1rchan_getptr(kobj_t obj, void *data)
 703 {
 704         struct sc_rchinfo *ch = data;
 705         struct sc_info *sc = ch->parent;
 706
 707         return ch->slot[sc->currbank].PgStart;
 708 }
 709
 710 static struct pcmchan_caps *
 711 ds1rchan_getcaps(kobj_t obj, void *data)
 712 {
 713         return &ds_reccaps;
 714 }
 715
 716 static kobj_method_t ds1rchan_methods[] = {
 717         KOBJMETHOD(channel_init,                ds1rchan_init),
 718         KOBJMETHOD(channel_setformat,           ds1rchan_setformat),
 719         KOBJMETHOD(channel_setspeed,            ds1rchan_setspeed),
 720         KOBJMETHOD(channel_setblocksize,        ds1rchan_setblocksize),
 721         KOBJMETHOD(channel_trigger,             ds1rchan_trigger),
 722         KOBJMETHOD(channel_getptr,              ds1rchan_getptr),
 723         KOBJMETHOD(channel_getcaps,             ds1rchan_getcaps),
 724         { 0, 0 }
 725 };
 726 CHANNEL_DECLARE(ds1rchan);
 727
 728 /* -------------------------------------------------------------------- */
 729 /* The interrupt handler */
 730 static void
 731 ds_intr(void *p)
 732 {
 733         struct sc_info *sc = (struct sc_info *)p;
 734         u_int32_t i, x;
 735
 736         snd_mtxlock(sc->lock);
 737         i = ds_rd(sc, YDSXGR_STATUS, 4);
 738         if (i & 0x00008000)
 739                 device_printf(sc->dev, "timeout irq\n");
 740         if (i & 0x80008000) {
 741                 ds_wr(sc, YDSXGR_STATUS, i & 0x80008000, 4);
 742                 sc->currbank = ds_rd(sc, YDSXGR_CTRLSELECT, 4) & 0x00000001;
 743
 744                 x = 0;
 745                 for (i = 0; i < DS1_CHANS; i++) {
 746                         if (sc->pch[i].run) {
 747                                 x = 1;
 748                                 snd_mtxunlock(sc->lock);
 749                                 chn_intr(sc->pch[i].channel);
 750                                 snd_mtxlock(sc->lock);
 751                         }
 752                 }
 753                 for (i = 0; i < 2; i++) {
 754                         if (sc->rch[i].run) {
 755                                 x = 1;
 756                                 snd_mtxunlock(sc->lock);
 757                                 chn_intr(sc->rch[i].channel);
 758                                 snd_mtxlock(sc->lock);
 759                         }
 760                 }
 761                 i = ds_rd(sc, YDSXGR_MODE, 4);
 762                 if (x)
 763                         ds_wr(sc, YDSXGR_MODE, i | 0x00000002, 4);
 764
 765         }
 766         snd_mtxunlock(sc->lock);
 767 }
 768
 769 /* -------------------------------------------------------------------- */
 770
 771 /*
 772  * Probe and attach the card
 773  */
 774
 775 static void
 776 ds_setmap(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 777 {
 778         struct sc_info *sc = arg;
 779
 780         sc->ctrlbase = error? 0 : (u_int32_t)segs->ds_addr;
 781
 782         if (bootverbose) {
 783                 kprintf("ds1: setmap (%lx, %lx), nseg=%d, error=%d\n",
 784                        (unsigned long)segs->ds_addr, (unsigned long)segs->ds_len,
 785                        nseg, error);
 786         }
 787 }
 788
 789 static int
 790 ds_init(struct sc_info *sc)
 791 {
 792         int i;
 793         u_int32_t *ci, r, pcs, rcs, ecs, ws, memsz, cb;
 794         u_int8_t *t;
 795         void *buf;
 796
 797         ci = ds_devs[sc->type].mcode;
 798
 799         ds_wr(sc, YDSXGR_NATIVEDACOUTVOL, 0x00000000, 4);
 800         ds_enadsp(sc, 0);
 801         ds_wr(sc, YDSXGR_MODE, 0x00010000, 4);
 802         ds_wr(sc, YDSXGR_MODE, 0x00000000, 4);
 803         ds_wr(sc, YDSXGR_MAPOFREC, 0x00000000, 4);
 804         ds_wr(sc, YDSXGR_MAPOFEFFECT, 0x00000000, 4);
 805         ds_wr(sc, YDSXGR_PLAYCTRLBASE, 0x00000000, 4);
 806         ds_wr(sc, YDSXGR_RECCTRLBASE, 0x00000000, 4);
 807         ds_wr(sc, YDSXGR_EFFCTRLBASE, 0x00000000, 4);
 808         r = ds_rd(sc, YDSXGR_GLOBALCTRL, 2);
 809         ds_wr(sc, YDSXGR_GLOBALCTRL, r & ~0x0007, 2);
 810
 811         for (i = 0; i < YDSXG_DSPLENGTH; i += 4)
 812                 ds_wr(sc, YDSXGR_DSPINSTRAM + i, DspInst[i >> 2], 4);
 813
 814         for (i = 0; i < YDSXG_CTRLLENGTH; i += 4)
 815                 ds_wr(sc, YDSXGR_CTRLINSTRAM + i, ci[i >> 2], 4);
 816
 817         ds_enadsp(sc, 1);
 818
 819         pcs = 0;
 820         for (i = 100; i > 0; i--) {
 821                 pcs = ds_rd(sc, YDSXGR_PLAYCTRLSIZE, 4) << 2;
 822                 if (pcs == sizeof(struct pbank))
 823                         break;
 824                 DELAY(1000);
 825         }
 826         if (pcs != sizeof(struct pbank)) {
 827                 device_printf(sc->dev, "preposterous playctrlsize (%d)\n", pcs);
 828                 return -1;
 829         }
 830         rcs = ds_rd(sc, YDSXGR_RECCTRLSIZE, 4) << 2;
 831         ecs = ds_rd(sc, YDSXGR_EFFCTRLSIZE, 4) << 2;
 832         ws = ds_rd(sc, YDSXGR_WORKSIZE, 4) << 2;
 833
 834         memsz = 64 * 2 * pcs + 2 * 2 * rcs + 5 * 2 * ecs + ws;
 835         memsz += (64 + 1) * 4;
 836
 837         if (sc->regbase == NULL) {
 838                 if (bus_dma_tag_create(NULL, 2, 0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR,
 839                                        NULL, NULL, memsz, 1, memsz, 0,
 840                                        &sc->control_dmat))
 841                         return -1;
 842                 if (bus_dmamem_alloc(sc->control_dmat, &buf, BUS_DMA_NOWAIT, &sc->map))
 843                         return -1;
 844                 if (bus_dmamap_load(sc->control_dmat, sc->map, buf, memsz, ds_setmap, sc, 0) || !sc->ctrlbase) {
 845                         device_printf(sc->dev, "pcs=%d, rcs=%d, ecs=%d, ws=%d, memsz=%d\n",
 846                                       pcs, rcs, ecs, ws, memsz);
 847                         return -1;
 848                 }
 849                 sc->regbase = buf;
 850         } else
 851                 buf = sc->regbase;
 852
 853         cb = 0;
 854         t = buf;
 855         ds_wr(sc, YDSXGR_WORKBASE, sc->ctrlbase + cb, 4);
 856         cb += ws;
 857         sc->pbase = (u_int32_t *)(t + cb);
 858         /* kprintf("pbase = %p -> 0x%x\n", sc->pbase, sc->ctrlbase + cb); */
 859         ds_wr(sc, YDSXGR_PLAYCTRLBASE, sc->ctrlbase + cb, 4);
 860         cb += (64 + 1) * 4;
 861         sc->rbank = (struct rbank *)(t + cb);
 862         ds_wr(sc, YDSXGR_RECCTRLBASE, sc->ctrlbase + cb, 4);
 863         cb += 2 * 2 * rcs;
 864         ds_wr(sc, YDSXGR_EFFCTRLBASE, sc->ctrlbase + cb, 4);
 865         cb += 5 * 2 * ecs;
 866
 867         sc->pbankbase = sc->ctrlbase + cb;
 868         sc->pbanksize = pcs;
 869         for (i = 0; i < 64; i++) {
 870                 wrl(sc, &sc->pbase[i + 1], 0);
 871                 sc->pbank[i * 2] = (struct pbank *)(t + cb);
 872                 /* kprintf("pbank[%d] = %p -> 0x%x; ", i * 2, (struct pbank *)(t + cb), sc->ctrlbase + cb - vtophys(t + cb)); */
 873                 cb += pcs;
 874                 sc->pbank[i * 2 + 1] = (struct pbank *)(t + cb);
 875                 /* kprintf("pbank[%d] = %p -> 0x%x\n", i * 2 + 1, (struct pbank *)(t + cb), sc->ctrlbase + cb - vtophys(t + cb)); */
 876                 cb += pcs;
 877         }
 878         wrl(sc, &sc->pbase[0], DS1_CHANS * 2);
 879
 880         sc->pchn = sc->rchn = 0;
 881         ds_wr(sc, YDSXGR_NATIVEDACOUTVOL, 0x3fff3fff, 4);
 882         ds_wr(sc, YDSXGR_NATIVEADCINVOL, 0x3fff3fff, 4);
 883         ds_wr(sc, YDSXGR_NATIVEDACINVOL, 0x3fff3fff, 4);
 884
 885         return 0;
 886 }
 887
 888 static int
 889 ds_uninit(struct sc_info *sc)
 890 {
 891         ds_wr(sc, YDSXGR_NATIVEDACOUTVOL, 0x00000000, 4);
 892         ds_wr(sc, YDSXGR_NATIVEADCINVOL, 0, 4);
 893         ds_wr(sc, YDSXGR_NATIVEDACINVOL, 0, 4);
 894         ds_enadsp(sc, 0);
 895         ds_wr(sc, YDSXGR_MODE, 0x00010000, 4);
 896         ds_wr(sc, YDSXGR_MAPOFREC, 0x00000000, 4);
 897         ds_wr(sc, YDSXGR_MAPOFEFFECT, 0x00000000, 4);
 898         ds_wr(sc, YDSXGR_PLAYCTRLBASE, 0x00000000, 4);
 899         ds_wr(sc, YDSXGR_RECCTRLBASE, 0x00000000, 4);
 900         ds_wr(sc, YDSXGR_EFFCTRLBASE, 0x00000000, 4);
 901         ds_wr(sc, YDSXGR_GLOBALCTRL, 0, 2);
 902
 903         bus_dmamap_unload(sc->control_dmat, sc->map);
 904         bus_dmamem_free(sc->control_dmat, sc->regbase, sc->map);
 905
 906         return 0;
 907 }
 908
 909 static int
 910 ds_finddev(u_int32_t dev, u_int32_t subdev)
 911 {
 912         int i;
 913
 914         for (i = 0; ds_devs[i].dev; i++) {
 915                 if (ds_devs[i].dev == dev &&
 916                     (ds_devs[i].subdev == subdev || ds_devs[i].subdev == 0))
 917                         return i;
 918         }
 919         return -1;
 920 }
 921
 922 static int
 923 ds_pci_probe(device_t dev)
 924 {
 925         int i;
 926         u_int32_t subdev;
 927
 928         subdev = (pci_get_subdevice(dev) << 16) | pci_get_subvendor(dev);
 929         i = ds_finddev(pci_get_devid(dev), subdev);
 930         if (i >= 0) {
 931                 device_set_desc(dev, ds_devs[i].name);
 932                 return BUS_PROBE_DEFAULT;
 933         } else
 934                 return ENXIO;
 935 }
 936
 937 static int
 938 ds_pci_attach(device_t dev)
 939 {
 940         u_int32_t       data;
 941         u_int32_t subdev, i;
 942         struct sc_info *sc;
 943         struct ac97_info *codec = NULL;
 944         char            status[SND_STATUSLEN];
 945
 946         sc = kmalloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
 947
 948         sc->lock = snd_mtxcreate(device_get_nameunit(dev), "sound softc");
 949         sc->dev = dev;
 950         subdev = (pci_get_subdevice(dev) << 16) | pci_get_subvendor(dev);
 951         sc->type = ds_finddev(pci_get_devid(dev), subdev);
 952         sc->rev = pci_get_revid(dev);
 953
 954         data = pci_read_config(dev, PCIR_COMMAND, 2);
 955         data |= (PCIM_CMD_PORTEN|PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN);
 956         pci_write_config(dev, PCIR_COMMAND, data, 2);
 957         data = pci_read_config(dev, PCIR_COMMAND, 2);
 958
 959         sc->regid = PCIR_BAR(0);
 960         sc->reg = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &sc->regid,
 961                                          RF_ACTIVE);
 962         if (!sc->reg) {
 963                 device_printf(dev, "unable to map register space\n");
 964                 goto bad;
 965         }
 966
 967         sc->st = rman_get_bustag(sc->reg);
 968         sc->sh = rman_get_bushandle(sc->reg);
 969
 970         sc->bufsz = pcm_getbuffersize(dev, 4096, DS1_BUFFSIZE, 65536);
 971
 972         if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0,
 973                 /*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
 974                 /*highaddr*/BUS_SPACE_MAXADDR,
 975                 /*filter*/NULL, /*filterarg*/NULL,
 976                 /*maxsize*/sc->bufsz, /*nsegments*/1, /*maxsegz*/0x3ffff,
 977                 /*flags*/0,
 978                 &sc->buffer_dmat) != 0) {
 979                 device_printf(dev, "unable to create dma tag\n");
 980                 goto bad;
 981         }
 982
 983         sc->regbase = NULL;
 984         if (ds_init(sc) == -1) {
 985                 device_printf(dev, "unable to initialize the card\n");
 986                 goto bad;
 987         }
 988
 989         codec = AC97_CREATE(dev, sc, ds_ac97);
 990         if (codec == NULL)
 991                 goto bad;
 992         /*
 993          * Turn on inverted external amplifier sense flags for few
 994          * 'special' boards.
 995          */
 996         switch (subdev) {
 997         case 0x81171033:        /* NEC ValueStar (VT550/0) */
 998                 ac97_setflags(codec, ac97_getflags(codec) | AC97_F_EAPD_INV);
 999                 break;
1000         default:
1001                 break;
1002         }
1003         mixer_init(dev, ac97_getmixerclass(), codec);
1004
1005         sc->irqid = 0;
1006         sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->irqid,
1007                                          RF_ACTIVE | RF_SHAREABLE);
1008         if (!sc->irq || snd_setup_intr(dev, sc->irq, INTR_MPSAFE, ds_intr, sc, &sc->ih)) {
1009                 device_printf(dev, "unable to map interrupt\n");
1010                 goto bad;
1011         }
1012
1013         ksnprintf(status, SND_STATUSLEN, "at memory 0x%lx irq %ld %s",
1014                  rman_get_start(sc->reg), rman_get_start(sc->irq),PCM_KLDSTRING(snd_ds1));
1015
1016         if (pcm_register(dev, sc, DS1_CHANS, 2))
1017                 goto bad;
1018         for (i = 0; i < DS1_CHANS; i++)
1019                 pcm_addchan(dev, PCMDIR_PLAY, &ds1pchan_class, sc);
1020         for (i = 0; i < 2; i++)
1021                 pcm_addchan(dev, PCMDIR_REC, &ds1rchan_class, sc);
1022         pcm_setstatus(dev, status);
1023
1024         return 0;
1025
1026 bad:
1027         if (codec)
1028                 ac97_destroy(codec);
1029         if (sc->reg)
1030                 bus_release_resource(dev, SYS_RES_MEMORY, sc->regid, sc->reg);
1031         if (sc->ih)
1032                 bus_teardown_intr(dev, sc->irq, sc->ih);
1033         if (sc->irq)
1034                 bus_release_resource(dev, SYS_RES_IRQ, sc->irqid, sc->irq);
1035         if (sc->buffer_dmat)
1036                 bus_dma_tag_destroy(sc->buffer_dmat);
1037         if (sc->control_dmat)
1038                 bus_dma_tag_destroy(sc->control_dmat);
1039         if (sc->lock)
1040                 snd_mtxfree(sc->lock);
1041         kfree(sc, M_DEVBUF);
1042         return ENXIO;
1043 }
1044
1045 static int
1046 ds_pci_resume(device_t dev)
1047 {
1048        struct sc_info *sc;
1049
1050        sc = pcm_getdevinfo(dev);
1051
1052        if (ds_init(sc) == -1) {
1053            device_printf(dev, "unable to reinitialize the card\n");
1054            return ENXIO;
1055        }
1056        if (mixer_reinit(dev) == -1) {
1057                device_printf(dev, "unable to reinitialize the mixer\n");
1058                return ENXIO;
1059        }
1060        return 0;
1061 }
1062
1063 static int
1064 ds_pci_detach(device_t dev)
1065 {
1066         int r;
1067         struct sc_info *sc;
1068
1069         r = pcm_unregister(dev);
1070         if (r)
1071                 return r;
1072
1073         sc = pcm_getdevinfo(dev);
1074         ds_uninit(sc);
1075         bus_release_resource(dev, SYS_RES_MEMORY, sc->regid, sc->reg);
1076         bus_teardown_intr(dev, sc->irq, sc->ih);
1077         bus_release_resource(dev, SYS_RES_IRQ, sc->irqid, sc->irq);
1078         bus_dma_tag_destroy(sc->buffer_dmat);
1079         bus_dma_tag_destroy(sc->control_dmat);
1080         snd_mtxfree(sc->lock);
1081         kfree(sc, M_DEVBUF);
1082         return 0;
1083 }
1084
1085 static device_method_t ds1_methods[] = {
1086         /* Device interface */
1087         DEVMETHOD(device_probe,         ds_pci_probe),
1088         DEVMETHOD(device_attach,        ds_pci_attach),
1089         DEVMETHOD(device_detach,        ds_pci_detach),
1090         DEVMETHOD(device_resume,        ds_pci_resume),
1091         { 0, 0 }
1092 };
1093
1094 static driver_t ds1_driver = {
1095         "pcm",
1096         ds1_methods,
1097         PCM_SOFTC_SIZE,
1098 };
1099
1100 DRIVER_MODULE(snd_ds1, pci, ds1_driver, pcm_devclass, NULL, NULL);
1101 MODULE_DEPEND(snd_ds1, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
1102 MODULE_VERSION(snd_ds1, 1);