sys/dev/sound/pci/hdspe-pcm.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2012-2016 Ruslan Bukin <br@bsdpad.com>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 /*
  30  * RME HDSPe driver for FreeBSD (pcm-part).
  31  * Supported cards: AIO, RayDAT.
  32  */
  33
  34 #include <dev/sound/pcm/sound.h>
  35 #include <dev/sound/pci/hdspe.h>
  36 #include <dev/sound/chip.h>
  37
  38 #include <dev/pci/pcireg.h>
  39 #include <dev/pci/pcivar.h>
  40
  41 #include <mixer_if.h>
  42
  43 SND_DECLARE_FILE("$FreeBSD$");
  44
  45 struct hdspe_latency {
  46         uint32_t n;
  47         uint32_t period;
  48         float ms;
  49 };
  50
  51 static struct hdspe_latency latency_map[] = {
  52         { 7,   32, 0.7 },
  53         { 0,   64, 1.5 },
  54         { 1,  128,   3 },
  55         { 2,  256,   6 },
  56         { 3,  512,  12 },
  57         { 4, 1024,  23 },
  58         { 5, 2048,  46 },
  59         { 6, 4096,  93 },
  60
  61         { 0,    0,   0 },
  62 };
  63
  64 struct hdspe_rate {
  65         uint32_t speed;
  66         uint32_t reg;
  67 };
  68
  69 static struct hdspe_rate rate_map[] = {
  70         {  32000, (HDSPE_FREQ_32000) },
  71         {  44100, (HDSPE_FREQ_44100) },
  72         {  48000, (HDSPE_FREQ_48000) },
  73         {  64000, (HDSPE_FREQ_32000 | HDSPE_FREQ_DOUBLE) },
  74         {  88200, (HDSPE_FREQ_44100 | HDSPE_FREQ_DOUBLE) },
  75         {  96000, (HDSPE_FREQ_48000 | HDSPE_FREQ_DOUBLE) },
  76         { 128000, (HDSPE_FREQ_32000 | HDSPE_FREQ_QUAD)   },
  77         { 176400, (HDSPE_FREQ_44100 | HDSPE_FREQ_QUAD)   },
  78         { 192000, (HDSPE_FREQ_48000 | HDSPE_FREQ_QUAD)   },
  79
  80         { 0, 0 },
  81 };
  82
  83
  84 static int
  85 hdspe_hw_mixer(struct sc_chinfo *ch, unsigned int dst,
  86     unsigned int src, unsigned short data)
  87 {
  88         struct sc_pcminfo *scp;
  89         struct sc_info *sc;
  90         int offs;
  91
  92         scp = ch->parent;
  93         sc = scp->sc;
  94
  95         offs = 0;
  96         if (ch->dir == PCMDIR_PLAY)
  97                 offs = 64;
  98
  99         hdspe_write_4(sc, HDSPE_MIXER_BASE +
 100             ((offs + src + 128 * dst) * sizeof(uint32_t)),
 101             data & 0xFFFF);
 102
 103         return (0);
 104 };
 105
 106 static int
 107 hdspechan_setgain(struct sc_chinfo *ch)
 108 {
 109
 110         hdspe_hw_mixer(ch, ch->lslot, ch->lslot,
 111             ch->lvol * HDSPE_MAX_GAIN / 100);
 112         hdspe_hw_mixer(ch, ch->rslot, ch->rslot,
 113             ch->rvol * HDSPE_MAX_GAIN / 100);
 114
 115         return (0);
 116 }
 117
 118 static int
 119 hdspemixer_init(struct snd_mixer *m)
 120 {
 121         struct sc_pcminfo *scp;
 122         struct sc_info *sc;
 123         int mask;
 124
 125         scp = mix_getdevinfo(m);
 126         sc = scp->sc;
 127         if (sc == NULL)
 128                 return (-1);
 129
 130         mask = SOUND_MASK_PCM;
 131
 132         if (scp->hc->play)
 133                 mask |= SOUND_MASK_VOLUME;
 134
 135         if (scp->hc->rec)
 136                 mask |= SOUND_MASK_RECLEV;
 137
 138         snd_mtxlock(sc->lock);
 139         pcm_setflags(scp->dev, pcm_getflags(scp->dev) | SD_F_SOFTPCMVOL);
 140         mix_setdevs(m, mask);
 141         snd_mtxunlock(sc->lock);
 142
 143         return (0);
 144 }
 145
 146 static int
 147 hdspemixer_set(struct snd_mixer *m, unsigned dev,
 148     unsigned left, unsigned right)
 149 {
 150         struct sc_pcminfo *scp;
 151         struct sc_chinfo *ch;
 152         int i;
 153
 154         scp = mix_getdevinfo(m);
 155
 156 #if 0
 157         device_printf(scp->dev, "hdspemixer_set() %d %d\n",
 158             left, right);
 159 #endif
 160
 161         for (i = 0; i < scp->chnum; i++) {
 162                 ch = &scp->chan[i];
 163                 if ((dev == SOUND_MIXER_VOLUME && ch->dir == PCMDIR_PLAY) ||
 164                     (dev == SOUND_MIXER_RECLEV && ch->dir == PCMDIR_REC)) {
 165                         ch->lvol = left;
 166                         ch->rvol = right;
 167                         if (ch->run)
 168                                 hdspechan_setgain(ch);
 169                 }
 170         }
 171
 172         return (0);
 173 }
 174
 175 static kobj_method_t hdspemixer_methods[] = {
 176         KOBJMETHOD(mixer_init,      hdspemixer_init),
 177         KOBJMETHOD(mixer_set,       hdspemixer_set),
 178         KOBJMETHOD_END
 179 };
 180 MIXER_DECLARE(hdspemixer);
 181
 182 static void
 183 hdspechan_enable(struct sc_chinfo *ch, int value)
 184 {
 185         struct sc_pcminfo *scp;
 186         struct sc_info *sc;
 187         int reg;
 188
 189         scp = ch->parent;
 190         sc = scp->sc;
 191
 192         if (ch->dir == PCMDIR_PLAY)
 193                 reg = HDSPE_OUT_ENABLE_BASE;
 194         else
 195                 reg = HDSPE_IN_ENABLE_BASE;
 196
 197         ch->run = value;
 198
 199         hdspe_write_1(sc, reg + (4 * ch->lslot), value);
 200         hdspe_write_1(sc, reg + (4 * ch->rslot), value);
 201 }
 202
 203 static int
 204 hdspe_running(struct sc_info *sc)
 205 {
 206         struct sc_pcminfo *scp;
 207         struct sc_chinfo *ch;
 208         device_t *devlist;
 209         int devcount;
 210         int i, j;
 211         int err;
 212
 213         if ((err = device_get_children(sc->dev, &devlist, &devcount)) != 0)
 214                 goto bad;
 215
 216         for (i = 0; i < devcount; i++) {
 217                 scp = device_get_ivars(devlist[i]);
 218                 for (j = 0; j < scp->chnum; j++) {
 219                         ch = &scp->chan[j];
 220                         if (ch->run)
 221                                 goto bad;
 222                 }
 223         }
 224
 225         free(devlist, M_TEMP);
 226
 227         return (0);
 228 bad:
 229
 230 #if 0
 231         device_printf(sc->dev, "hdspe is running\n");
 232 #endif
 233
 234         free(devlist, M_TEMP);
 235
 236         return (1);
 237 }
 238
 239 static void
 240 hdspe_start_audio(struct sc_info *sc)
 241 {
 242
 243         sc->ctrl_register |= (HDSPE_AUDIO_INT_ENABLE | HDSPE_ENABLE);
 244         hdspe_write_4(sc, HDSPE_CONTROL_REG, sc->ctrl_register);
 245 }
 246
 247 static void
 248 hdspe_stop_audio(struct sc_info *sc)
 249 {
 250
 251         if (hdspe_running(sc) == 1)
 252                 return;
 253
 254         sc->ctrl_register &= ~(HDSPE_AUDIO_INT_ENABLE | HDSPE_ENABLE);
 255         hdspe_write_4(sc, HDSPE_CONTROL_REG, sc->ctrl_register);
 256 }
 257
 258 /* Multiplex / demultiplex: 2.0 <-> 2 x 1.0. */
 259 static void
 260 buffer_copy(struct sc_chinfo *ch)
 261 {
 262         struct sc_pcminfo *scp;
 263         struct sc_info *sc;
 264         int ssize, dsize;
 265         int src, dst;
 266         int length;
 267         int i;
 268
 269         scp = ch->parent;
 270         sc = scp->sc;
 271
 272         length = sndbuf_getready(ch->buffer) /
 273             (4 /* Bytes per sample. */ * 2 /* channels */);
 274
 275         if (ch->dir == PCMDIR_PLAY) {
 276                 src = sndbuf_getreadyptr(ch->buffer);
 277         } else {
 278                 src = sndbuf_getfreeptr(ch->buffer);
 279         }
 280
 281         src /= 4; /* Bytes per sample. */
 282         dst = src / 2; /* Destination buffer twice smaller. */
 283
 284         ssize = ch->size / 4;
 285         dsize = ch->size / 8;
 286
 287         /*
 288          * Use two fragment buffer to avoid sound clipping.
 289          */
 290
 291         for (i = 0; i < sc->period * 2 /* fragments */; i++) {
 292                 if (ch->dir == PCMDIR_PLAY) {
 293                         sc->pbuf[dst + HDSPE_CHANBUF_SAMPLES * ch->lslot] =
 294                             ch->data[src];
 295                         sc->pbuf[dst + HDSPE_CHANBUF_SAMPLES * ch->rslot] =
 296                             ch->data[src + 1];
 297
 298                 } else {
 299                         ch->data[src] =
 300                             sc->rbuf[dst + HDSPE_CHANBUF_SAMPLES * ch->lslot];
 301                         ch->data[src+1] =
 302                             sc->rbuf[dst + HDSPE_CHANBUF_SAMPLES * ch->rslot];
 303                 }
 304
 305                 dst+=1;
 306                 dst %= dsize;
 307                 src+=2;
 308                 src %= ssize;
 309         }
 310 }
 311
 312 static int
 313 clean(struct sc_chinfo *ch)
 314 {
 315         struct sc_pcminfo *scp;
 316         struct sc_info *sc;
 317         uint32_t *buf;
 318
 319         scp = ch->parent;
 320         sc = scp->sc;
 321         buf = sc->rbuf;
 322
 323         if (ch->dir == PCMDIR_PLAY) {
 324                 buf = sc->pbuf;
 325         }
 326
 327         bzero(buf + HDSPE_CHANBUF_SAMPLES * ch->lslot, HDSPE_CHANBUF_SIZE);
 328         bzero(buf + HDSPE_CHANBUF_SAMPLES * ch->rslot, HDSPE_CHANBUF_SIZE);
 329
 330         return (0);
 331 }
 332
 333
 334 /* Channel interface. */
 335 static void *
 336 hdspechan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 337     struct pcm_channel *c, int dir)
 338 {
 339         struct sc_pcminfo *scp;
 340         struct sc_chinfo *ch;
 341         struct sc_info *sc;
 342         int num;
 343
 344         scp = devinfo;
 345         sc = scp->sc;
 346
 347         snd_mtxlock(sc->lock);
 348         num = scp->chnum;
 349
 350         ch = &scp->chan[num];
 351         ch->lslot = scp->hc->left;
 352         ch->rslot = scp->hc->right;
 353         ch->run = 0;
 354         ch->lvol = 0;
 355         ch->rvol = 0;
 356
 357         ch->size = HDSPE_CHANBUF_SIZE * 2 /* slots */;
 358         ch->data = malloc(ch->size, M_HDSPE, M_NOWAIT);
 359
 360         ch->buffer = b;
 361         ch->channel = c;
 362         ch->parent = scp;
 363
 364         ch->dir = dir;
 365
 366         snd_mtxunlock(sc->lock);
 367
 368         if (sndbuf_setup(ch->buffer, ch->data, ch->size) != 0) {
 369                 device_printf(scp->dev, "Can't setup sndbuf.\n");
 370                 return (NULL);
 371         }
 372
 373         return (ch);
 374 }
 375
 376 static int
 377 hdspechan_trigger(kobj_t obj, void *data, int go)
 378 {
 379         struct sc_pcminfo *scp;
 380         struct sc_chinfo *ch;
 381         struct sc_info *sc;
 382
 383         ch = data;
 384         scp = ch->parent;
 385         sc = scp->sc;
 386
 387         snd_mtxlock(sc->lock);
 388         switch (go) {
 389         case PCMTRIG_START:
 390 #if 0
 391                 device_printf(scp->dev, "hdspechan_trigger(): start\n");
 392 #endif
 393                 hdspechan_enable(ch, 1);
 394                 hdspechan_setgain(ch);
 395                 hdspe_start_audio(sc);
 396                 break;
 397
 398         case PCMTRIG_STOP:
 399         case PCMTRIG_ABORT:
 400 #if 0
 401                 device_printf(scp->dev, "hdspechan_trigger(): stop or abort\n");
 402 #endif
 403                 clean(ch);
 404                 hdspechan_enable(ch, 0);
 405                 hdspe_stop_audio(sc);
 406                 break;
 407
 408         case PCMTRIG_EMLDMAWR:
 409         case PCMTRIG_EMLDMARD:
 410                 if(ch->run)
 411                         buffer_copy(ch);
 412                 break;
 413         }
 414
 415         snd_mtxunlock(sc->lock);
 416
 417         return (0);
 418 }
 419
 420 static uint32_t
 421 hdspechan_getptr(kobj_t obj, void *data)
 422 {
 423         struct sc_pcminfo *scp;
 424         struct sc_chinfo *ch;
 425         struct sc_info *sc;
 426         uint32_t ret, pos;
 427
 428         ch = data;
 429         scp = ch->parent;
 430         sc = scp->sc;
 431
 432         snd_mtxlock(sc->lock);
 433         ret = hdspe_read_2(sc, HDSPE_STATUS_REG);
 434         snd_mtxunlock(sc->lock);
 435
 436         pos = ret & HDSPE_BUF_POSITION_MASK;
 437         pos *= 2; /* Hardbuf twice bigger. */
 438
 439         return (pos);
 440 }
 441
 442 static int
 443 hdspechan_free(kobj_t obj, void *data)
 444 {
 445         struct sc_pcminfo *scp;
 446         struct sc_chinfo *ch;
 447         struct sc_info *sc;
 448
 449         ch = data;
 450         scp = ch->parent;
 451         sc = scp->sc;
 452
 453 #if 0
 454         device_printf(scp->dev, "hdspechan_free()\n");
 455 #endif
 456
 457         snd_mtxlock(sc->lock);
 458         if (ch->data != NULL) {
 459                 free(ch->data, M_HDSPE);
 460                 ch->data = NULL;
 461         }
 462         snd_mtxunlock(sc->lock);
 463
 464         return (0);
 465 }
 466
 467 static int
 468 hdspechan_setformat(kobj_t obj, void *data, uint32_t format)
 469 {
 470         struct sc_chinfo *ch;
 471
 472         ch = data;
 473
 474 #if 0
 475         struct sc_pcminfo *scp = ch->parent;
 476         device_printf(scp->dev, "hdspechan_setformat(%d)\n", format);
 477 #endif
 478
 479         ch->format = format;
 480
 481         return (0);
 482 }
 483
 484 static uint32_t
 485 hdspechan_setspeed(kobj_t obj, void *data, uint32_t speed)
 486 {
 487         struct sc_pcminfo *scp;
 488         struct hdspe_rate *hr;
 489         struct sc_chinfo *ch;
 490         struct sc_info *sc;
 491         long long period;
 492         int threshold;
 493         int i;
 494
 495         ch = data;
 496         scp = ch->parent;
 497         sc = scp->sc;
 498         hr = NULL;
 499
 500 #if 0
 501         device_printf(scp->dev, "hdspechan_setspeed(%d)\n", speed);
 502 #endif
 503
 504         if (hdspe_running(sc) == 1)
 505                 goto end;
 506
 507         /* First look for equal frequency. */
 508         for (i = 0; rate_map[i].speed != 0; i++) {
 509                 if (rate_map[i].speed == speed)
 510                         hr = &rate_map[i];
 511         }
 512
 513         /* If no match, just find nearest. */
 514         if (hr == NULL) {
 515                 for (i = 0; rate_map[i].speed != 0; i++) {
 516                         hr = &rate_map[i];
 517                         threshold = hr->speed + ((rate_map[i + 1].speed != 0) ?
 518                             ((rate_map[i + 1].speed - hr->speed) >> 1) : 0);
 519                         if (speed < threshold)
 520                                 break;
 521                 }
 522         }
 523
 524         switch (sc->type) {
 525         case RAYDAT:
 526         case AIO:
 527                 period = HDSPE_FREQ_AIO;
 528                 break;
 529         default:
 530                 /* Unsupported card. */
 531                 goto end;
 532         }
 533
 534         /* Write frequency on the device. */
 535         sc->ctrl_register &= ~HDSPE_FREQ_MASK;
 536         sc->ctrl_register |= hr->reg;
 537         hdspe_write_4(sc, HDSPE_CONTROL_REG, sc->ctrl_register);
 538
 539         speed = hr->speed;
 540         if (speed > 96000)
 541                 speed /= 4;
 542         else if (speed > 48000)
 543                 speed /= 2;
 544
 545         /* Set DDS value. */
 546         period /= speed;
 547         hdspe_write_4(sc, HDSPE_FREQ_REG, period);
 548
 549         sc->speed = hr->speed;
 550 end:
 551
 552         return (sc->speed);
 553 }
 554
 555 static uint32_t
 556 hdspechan_setblocksize(kobj_t obj, void *data, uint32_t blocksize)
 557 {
 558         struct hdspe_latency *hl;
 559         struct sc_pcminfo *scp;
 560         struct sc_chinfo *ch;
 561         struct sc_info *sc;
 562         int threshold;
 563         int i;
 564
 565         ch = data;
 566         scp = ch->parent;
 567         sc = scp->sc;
 568         hl = NULL;
 569
 570 #if 0
 571         device_printf(scp->dev, "hdspechan_setblocksize(%d)\n", blocksize);
 572 #endif
 573
 574         if (hdspe_running(sc) == 1)
 575                 goto end;
 576
 577         if (blocksize > HDSPE_LAT_BYTES_MAX)
 578                 blocksize = HDSPE_LAT_BYTES_MAX;
 579         else if (blocksize < HDSPE_LAT_BYTES_MIN)
 580                 blocksize = HDSPE_LAT_BYTES_MIN;
 581
 582         blocksize /= 4 /* samples */;
 583
 584         /* First look for equal latency. */
 585         for (i = 0; latency_map[i].period != 0; i++) {
 586                 if (latency_map[i].period == blocksize) {
 587                         hl = &latency_map[i];
 588                 }
 589         }
 590
 591         /* If no match, just find nearest. */
 592         if (hl == NULL) {
 593                 for (i = 0; latency_map[i].period != 0; i++) {
 594                         hl = &latency_map[i];
 595                         threshold = hl->period + ((latency_map[i + 1].period != 0) ?
 596                             ((latency_map[i + 1].period - hl->period) >> 1) : 0);
 597                         if (blocksize < threshold)
 598                                 break;
 599                 }
 600         }
 601
 602         snd_mtxlock(sc->lock);
 603         sc->ctrl_register &= ~HDSPE_LAT_MASK;
 604         sc->ctrl_register |= hdspe_encode_latency(hl->n);
 605         hdspe_write_4(sc, HDSPE_CONTROL_REG, sc->ctrl_register);
 606         sc->period = hl->period;
 607         snd_mtxunlock(sc->lock);
 608
 609 #if 0
 610         device_printf(scp->dev, "New period=%d\n", sc->period);
 611 #endif
 612
 613         sndbuf_resize(ch->buffer, (HDSPE_CHANBUF_SIZE * 2) / (sc->period * 4),
 614             (sc->period * 4));
 615 end:
 616
 617         return (sndbuf_getblksz(ch->buffer));
 618 }
 619
 620 static uint32_t hdspe_rfmt[] = {
 621         SND_FORMAT(AFMT_S32_LE, 2, 0),
 622         0
 623 };
 624
 625 static struct pcmchan_caps hdspe_rcaps = {32000, 192000, hdspe_rfmt, 0};
 626
 627 static uint32_t hdspe_pfmt[] = {
 628         SND_FORMAT(AFMT_S32_LE, 2, 0),
 629         0
 630 };
 631
 632 static struct pcmchan_caps hdspe_pcaps = {32000, 192000, hdspe_pfmt, 0};
 633
 634 static struct pcmchan_caps *
 635 hdspechan_getcaps(kobj_t obj, void *data)
 636 {
 637         struct sc_chinfo *ch;
 638
 639         ch = data;
 640
 641 #if 0
 642         struct sc_pcminfo *scl = ch->parent;
 643         device_printf(scp->dev, "hdspechan_getcaps()\n");
 644 #endif
 645
 646         return ((ch->dir == PCMDIR_PLAY) ?
 647             &hdspe_pcaps : &hdspe_rcaps);
 648 }
 649
 650 static kobj_method_t hdspechan_methods[] = {
 651         KOBJMETHOD(channel_init,         hdspechan_init),
 652         KOBJMETHOD(channel_free,         hdspechan_free),
 653         KOBJMETHOD(channel_setformat,    hdspechan_setformat),
 654         KOBJMETHOD(channel_setspeed,     hdspechan_setspeed),
 655         KOBJMETHOD(channel_setblocksize, hdspechan_setblocksize),
 656         KOBJMETHOD(channel_trigger,      hdspechan_trigger),
 657         KOBJMETHOD(channel_getptr,       hdspechan_getptr),
 658         KOBJMETHOD(channel_getcaps,      hdspechan_getcaps),
 659         KOBJMETHOD_END
 660 };
 661 CHANNEL_DECLARE(hdspechan);
 662
 663
 664 static int
 665 hdspe_pcm_probe(device_t dev)
 666 {
 667
 668 #if 0
 669         device_printf(dev,"hdspe_pcm_probe()\n");
 670 #endif
 671
 672         return (0);
 673 }
 674
 675 static uint32_t
 676 hdspe_pcm_intr(struct sc_pcminfo *scp)
 677 {
 678         struct sc_chinfo *ch;
 679         struct sc_info *sc;
 680         int i;
 681
 682         sc = scp->sc;
 683
 684         for (i = 0; i < scp->chnum; i++) {
 685                 ch = &scp->chan[i];
 686                 snd_mtxunlock(sc->lock);
 687                 chn_intr(ch->channel);
 688                 snd_mtxlock(sc->lock);
 689         }
 690
 691         return (0);
 692 }
 693
 694 static int
 695 hdspe_pcm_attach(device_t dev)
 696 {
 697         char status[SND_STATUSLEN];
 698         struct sc_pcminfo *scp;
 699         char desc[64];
 700         int i, err;
 701
 702         scp = device_get_ivars(dev);
 703         scp->ih = &hdspe_pcm_intr;
 704
 705         bzero(desc, sizeof(desc));
 706         snprintf(desc, sizeof(desc), "HDSPe AIO [%s]", scp->hc->descr);
 707         device_set_desc_copy(dev, desc);
 708
 709         /*
 710          * We don't register interrupt handler with snd_setup_intr
 711          * in pcm device. Mark pcm device as MPSAFE manually.
 712          */
 713         pcm_setflags(dev, pcm_getflags(dev) | SD_F_MPSAFE);
 714
 715         err = pcm_register(dev, scp, scp->hc->play, scp->hc->rec);
 716         if (err) {
 717                 device_printf(dev, "Can't register pcm.\n");
 718                 return (ENXIO);
 719         }
 720
 721         scp->chnum = 0;
 722         for (i = 0; i < scp->hc->play; i++) {
 723                 pcm_addchan(dev, PCMDIR_PLAY, &hdspechan_class, scp);
 724                 scp->chnum++;
 725         }
 726
 727         for (i = 0; i < scp->hc->rec; i++) {
 728                 pcm_addchan(dev, PCMDIR_REC, &hdspechan_class, scp);
 729                 scp->chnum++;
 730         }
 731
 732         snprintf(status, SND_STATUSLEN, "at io 0x%jx irq %jd %s",
 733             rman_get_start(scp->sc->cs),
 734             rman_get_start(scp->sc->irq),
 735             PCM_KLDSTRING(snd_hdspe));
 736         pcm_setstatus(dev, status);
 737
 738         mixer_init(dev, &hdspemixer_class, scp);
 739
 740         return (0);
 741 }
 742
 743 static int
 744 hdspe_pcm_detach(device_t dev)
 745 {
 746         int err;
 747
 748         err = pcm_unregister(dev);
 749         if (err) {
 750                 device_printf(dev, "Can't unregister device.\n");
 751                 return (err);
 752         }
 753
 754         return (0);
 755 }
 756
 757 static device_method_t hdspe_pcm_methods[] = {
 758         DEVMETHOD(device_probe,     hdspe_pcm_probe),
 759         DEVMETHOD(device_attach,    hdspe_pcm_attach),
 760         DEVMETHOD(device_detach,    hdspe_pcm_detach),
 761         { 0, 0 }
 762 };
 763
 764 static driver_t hdspe_pcm_driver = {
 765         "pcm",
 766         hdspe_pcm_methods,
 767         PCM_SOFTC_SIZE,
 768 };
 769
 770 DRIVER_MODULE(snd_hdspe_pcm, hdspe, hdspe_pcm_driver, pcm_devclass, 0, 0);
 771 MODULE_DEPEND(snd_hdspe, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
 772 MODULE_VERSION(snd_hdspe, 1);