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

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