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