sys/dev/sound/pci/solo.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 1999 Cameron Grant <cg@freebsd.org>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #ifdef HAVE_KERNEL_OPTION_HEADERS
  29 #include "opt_snd.h"
  30 #endif
  31
  32 #include <dev/sound/pcm/sound.h>
  33
  34 #include <dev/pci/pcireg.h>
  35 #include <dev/pci/pcivar.h>
  36
  37 #include  <dev/sound/isa/sb.h>
  38 #include  <dev/sound/chip.h>
  39
  40 #include "mixer_if.h"
  41
  42 SND_DECLARE_FILE("$FreeBSD$");
  43
  44 #define SOLO_DEFAULT_BUFSZ 16384
  45 #define ABS(x) (((x) < 0)? -(x) : (x))
  46
  47 /* if defined, playback always uses the 2nd channel and full duplex works */
  48 #define ESS18XX_DUPLEX  1
  49
  50 /* more accurate clocks and split audio1/audio2 rates */
  51 #define ESS18XX_NEWSPEED
  52
  53 static u_int32_t ess_playfmt[] = {
  54         SND_FORMAT(AFMT_U8, 1, 0),
  55         SND_FORMAT(AFMT_U8, 2, 0),
  56         SND_FORMAT(AFMT_S8, 1, 0),
  57         SND_FORMAT(AFMT_S8, 2, 0),
  58         SND_FORMAT(AFMT_S16_LE, 1, 0),
  59         SND_FORMAT(AFMT_S16_LE, 2, 0),
  60         SND_FORMAT(AFMT_U16_LE, 1, 0),
  61         SND_FORMAT(AFMT_U16_LE, 2, 0),
  62         0
  63 };
  64 static struct pcmchan_caps ess_playcaps = {6000, 48000, ess_playfmt, 0};
  65
  66 /*
  67  * Recording output is byte-swapped
  68  */
  69 static u_int32_t ess_recfmt[] = {
  70         SND_FORMAT(AFMT_U8, 1, 0),
  71         SND_FORMAT(AFMT_U8, 2, 0),
  72         SND_FORMAT(AFMT_S8, 1, 0),
  73         SND_FORMAT(AFMT_S8, 2, 0),
  74         SND_FORMAT(AFMT_S16_BE, 1, 0),
  75         SND_FORMAT(AFMT_S16_BE, 2, 0),
  76         SND_FORMAT(AFMT_U16_BE, 1, 0),
  77         SND_FORMAT(AFMT_U16_BE, 2, 0),
  78         0
  79 };
  80 static struct pcmchan_caps ess_reccaps = {6000, 48000, ess_recfmt, 0};
  81
  82 struct ess_info;
  83
  84 struct ess_chinfo {
  85         struct ess_info *parent;
  86         struct pcm_channel *channel;
  87         struct snd_dbuf *buffer;
  88         int dir, hwch, stopping;
  89         u_int32_t fmt, spd, blksz;
  90 };
  91
  92 struct ess_info {
  93         struct resource *io, *sb, *vc, *mpu, *gp;       /* I/O address for the board */
  94         struct resource *irq;
  95         void            *ih;
  96         bus_dma_tag_t parent_dmat;
  97
  98         int simplex_dir, type, dmasz[2];
  99         unsigned int duplex:1, newspeed:1;
 100         unsigned int bufsz;
 101
 102         struct ess_chinfo pch, rch;
 103         struct mtx *lock;
 104 };
 105
 106 #define ess_lock(_ess) snd_mtxlock((_ess)->lock)
 107 #define ess_unlock(_ess) snd_mtxunlock((_ess)->lock)
 108 #define ess_lock_assert(_ess) snd_mtxassert((_ess)->lock)
 109
 110 static int ess_rd(struct ess_info *sc, int reg);
 111 static void ess_wr(struct ess_info *sc, int reg, u_int8_t val);
 112 static int ess_dspready(struct ess_info *sc);
 113 static int ess_cmd(struct ess_info *sc, u_char val);
 114 static int ess_cmd1(struct ess_info *sc, u_char cmd, int val);
 115 static int ess_get_byte(struct ess_info *sc);
 116 static void ess_setmixer(struct ess_info *sc, u_int port, u_int value);
 117 static int ess_getmixer(struct ess_info *sc, u_int port);
 118 static int ess_reset_dsp(struct ess_info *sc);
 119
 120 static int ess_write(struct ess_info *sc, u_char reg, int val);
 121 static int ess_read(struct ess_info *sc, u_char reg);
 122
 123 static void ess_intr(void *arg);
 124 static int ess_setupch(struct ess_info *sc, int ch, int dir, int spd, u_int32_t fmt, int len);
 125 static int ess_start(struct ess_chinfo *ch);
 126 static int ess_stop(struct ess_chinfo *ch);
 127
 128 static int ess_dmasetup(struct ess_info *sc, int ch, u_int32_t base, u_int16_t cnt, int dir);
 129 static int ess_dmapos(struct ess_info *sc, int ch);
 130 static int ess_dmatrigger(struct ess_info *sc, int ch, int go);
 131
 132 /*
 133  * Common code for the midi and pcm functions
 134  *
 135  * ess_cmd write a single byte to the CMD port.
 136  * ess_cmd1 write a CMD + 1 byte arg
 137  * ess_cmd2 write a CMD + 2 byte arg
 138  * ess_get_byte returns a single byte from the DSP data port
 139  *
 140  * ess_write is actually ess_cmd1
 141  * ess_read access ext. regs via ess_cmd(0xc0, reg) followed by ess_get_byte
 142  */
 143
 144 static int
 145 port_rd(struct resource *port, int regno, int size)
 146 {
 147         bus_space_tag_t st = rman_get_bustag(port);
 148         bus_space_handle_t sh = rman_get_bushandle(port);
 149
 150         switch (size) {
 151         case 1:
 152                 return bus_space_read_1(st, sh, regno);
 153         case 2:
 154                 return bus_space_read_2(st, sh, regno);
 155         case 4:
 156                 return bus_space_read_4(st, sh, regno);
 157         default:
 158                 return 0xffffffff;
 159         }
 160 }
 161
 162 static void
 163 port_wr(struct resource *port, int regno, u_int32_t data, int size)
 164 {
 165         bus_space_tag_t st = rman_get_bustag(port);
 166         bus_space_handle_t sh = rman_get_bushandle(port);
 167
 168         switch (size) {
 169         case 1:
 170                 bus_space_write_1(st, sh, regno, data);
 171                 break;
 172         case 2:
 173                 bus_space_write_2(st, sh, regno, data);
 174                 break;
 175         case 4:
 176                 bus_space_write_4(st, sh, regno, data);
 177                 break;
 178         }
 179 }
 180
 181 static int
 182 ess_rd(struct ess_info *sc, int reg)
 183 {
 184         return port_rd(sc->sb, reg, 1);
 185 }
 186
 187 static void
 188 ess_wr(struct ess_info *sc, int reg, u_int8_t val)
 189 {
 190         port_wr(sc->sb, reg, val, 1);
 191 }
 192
 193 static int
 194 ess_dspready(struct ess_info *sc)
 195 {
 196         return ((ess_rd(sc, SBDSP_STATUS) & 0x80) == 0);
 197 }
 198
 199 static int
 200 ess_dspwr(struct ess_info *sc, u_char val)
 201 {
 202         int  i;
 203
 204         for (i = 0; i < 1000; i++) {
 205                 if (ess_dspready(sc)) {
 206                         ess_wr(sc, SBDSP_CMD, val);
 207                         return 1;
 208                 }
 209                 if (i > 10) DELAY((i > 100)? 1000 : 10);
 210         }
 211         printf("ess_dspwr(0x%02x) timed out.\n", val);
 212         return 0;
 213 }
 214
 215 static int
 216 ess_cmd(struct ess_info *sc, u_char val)
 217 {
 218         DEB(printf("ess_cmd: %x\n", val));
 219         return ess_dspwr(sc, val);
 220 }
 221
 222 static int
 223 ess_cmd1(struct ess_info *sc, u_char cmd, int val)
 224 {
 225         DEB(printf("ess_cmd1: %x, %x\n", cmd, val));
 226         if (ess_dspwr(sc, cmd)) {
 227                 return ess_dspwr(sc, val & 0xff);
 228         } else return 0;
 229 }
 230
 231 static void
 232 ess_setmixer(struct ess_info *sc, u_int port, u_int value)
 233 {
 234         DEB(printf("ess_setmixer: reg=%x, val=%x\n", port, value);)
 235         ess_wr(sc, SB_MIX_ADDR, (u_char) (port & 0xff)); /* Select register */
 236         DELAY(10);
 237         ess_wr(sc, SB_MIX_DATA, (u_char) (value & 0xff));
 238         DELAY(10);
 239 }
 240
 241 static int
 242 ess_getmixer(struct ess_info *sc, u_int port)
 243 {
 244         int val;
 245
 246         ess_wr(sc, SB_MIX_ADDR, (u_char) (port & 0xff)); /* Select register */
 247         DELAY(10);
 248         val = ess_rd(sc, SB_MIX_DATA);
 249         DELAY(10);
 250
 251         return val;
 252 }
 253
 254 static int
 255 ess_get_byte(struct ess_info *sc)
 256 {
 257         int i;
 258
 259         for (i = 1000; i > 0; i--) {
 260                 if (ess_rd(sc, 0xc) & 0x40)
 261                         return ess_rd(sc, DSP_READ);
 262                 else
 263                         DELAY(20);
 264         }
 265         return -1;
 266 }
 267
 268 static int
 269 ess_write(struct ess_info *sc, u_char reg, int val)
 270 {
 271         return ess_cmd1(sc, reg, val);
 272 }
 273
 274 static int
 275 ess_read(struct ess_info *sc, u_char reg)
 276 {
 277         return (ess_cmd(sc, 0xc0) && ess_cmd(sc, reg))? ess_get_byte(sc) : -1;
 278 }
 279
 280 static int
 281 ess_reset_dsp(struct ess_info *sc)
 282 {
 283         DEB(printf("ess_reset_dsp\n"));
 284         ess_wr(sc, SBDSP_RST, 3);
 285         DELAY(100);
 286         ess_wr(sc, SBDSP_RST, 0);
 287         if (ess_get_byte(sc) != 0xAA) {
 288                 DEB(printf("ess_reset_dsp failed\n"));
 289 /*
 290                            rman_get_start(d->io_base)));
 291 */
 292                 return ENXIO;   /* Sorry */
 293         }
 294         ess_cmd(sc, 0xc6);
 295         return 0;
 296 }
 297
 298 static void
 299 ess_intr(void *arg)
 300 {
 301         struct ess_info *sc = (struct ess_info *)arg;
 302         int src, pirq = 0, rirq = 0;
 303
 304         ess_lock(sc);
 305         src = 0;
 306         if (ess_getmixer(sc, 0x7a) & 0x80)
 307                 src |= 2;
 308         if (ess_rd(sc, 0x0c) & 0x01)
 309                 src |= 1;
 310
 311         if (src == 0) {
 312                 ess_unlock(sc);
 313                 return;
 314         }
 315
 316         if (sc->duplex) {
 317                 pirq = (src & sc->pch.hwch)? 1 : 0;
 318                 rirq = (src & sc->rch.hwch)? 1 : 0;
 319         } else {
 320                 if (sc->simplex_dir == PCMDIR_PLAY)
 321                         pirq = 1;
 322                 if (sc->simplex_dir == PCMDIR_REC)
 323                         rirq = 1;
 324                 if (!pirq && !rirq)
 325                         printf("solo: IRQ neither playback nor rec!\n");
 326         }
 327
 328         DEB(printf("ess_intr: pirq:%d rirq:%d\n",pirq,rirq));
 329
 330         if (pirq) {
 331                 if (sc->pch.stopping) {
 332                         ess_dmatrigger(sc, sc->pch.hwch, 0);
 333                         sc->pch.stopping = 0;
 334                         if (sc->pch.hwch == 1)
 335                                 ess_write(sc, 0xb8, ess_read(sc, 0xb8) & ~0x01);
 336                         else
 337                                 ess_setmixer(sc, 0x78, ess_getmixer(sc, 0x78) & ~0x03);
 338                 }
 339                 ess_unlock(sc);
 340                 chn_intr(sc->pch.channel);
 341                 ess_lock(sc);
 342         }
 343
 344         if (rirq) {
 345                 if (sc->rch.stopping) {
 346                         ess_dmatrigger(sc, sc->rch.hwch, 0);
 347                         sc->rch.stopping = 0;
 348                         /* XXX: will this stop audio2? */
 349                         ess_write(sc, 0xb8, ess_read(sc, 0xb8) & ~0x01);
 350                 }
 351                 ess_unlock(sc);
 352                 chn_intr(sc->rch.channel);
 353                 ess_lock(sc);
 354         }
 355
 356         if (src & 2)
 357                 ess_setmixer(sc, 0x7a, ess_getmixer(sc, 0x7a) & ~0x80);
 358         if (src & 1)
 359                 ess_rd(sc, DSP_DATA_AVAIL);
 360
 361         ess_unlock(sc);
 362 }
 363
 364 /* utility functions for ESS */
 365 static u_int8_t
 366 ess_calcspeed8(int *spd)
 367 {
 368         int speed = *spd;
 369         u_int32_t t;
 370
 371         if (speed > 22000) {
 372                 t = (795500 + speed / 2) / speed;
 373                 speed = (795500 + t / 2) / t;
 374                 t = (256 - t) | 0x80;
 375         } else {
 376                 t = (397700 + speed / 2) / speed;
 377                 speed = (397700 + t / 2) / t;
 378                 t = 128 - t;
 379         }
 380         *spd = speed;
 381         return t & 0x000000ff;
 382 }
 383
 384 static u_int8_t
 385 ess_calcspeed9(int *spd)
 386 {
 387         int speed, s0, s1, use0;
 388         u_int8_t t0, t1;
 389
 390         /* rate = source / (256 - divisor) */
 391         /* divisor = 256 - (source / rate) */
 392         speed = *spd;
 393         t0 = 128 - (793800 / speed);
 394         s0 = 793800 / (128 - t0);
 395
 396         t1 = 128 - (768000 / speed);
 397         s1 = 768000 / (128 - t1);
 398         t1 |= 0x80;
 399
 400         use0 = (ABS(speed - s0) < ABS(speed - s1))? 1 : 0;
 401
 402         *spd = use0? s0 : s1;
 403         return use0? t0 : t1;
 404 }
 405
 406 static u_int8_t
 407 ess_calcfilter(int spd)
 408 {
 409         int cutoff;
 410
 411         /* cutoff = 7160000 / (256 - divisor) */
 412         /* divisor = 256 - (7160000 / cutoff) */
 413         cutoff = (spd * 9 * 82) / 20;
 414         return (256 - (7160000 / cutoff));
 415 }
 416
 417 static int
 418 ess_setupch(struct ess_info *sc, int ch, int dir, int spd, u_int32_t fmt, int len)
 419 {
 420         int play = (dir == PCMDIR_PLAY)? 1 : 0;
 421         int b16 = (fmt & AFMT_16BIT)? 1 : 0;
 422         int stereo = (AFMT_CHANNEL(fmt) > 1)? 1 : 0;
 423         int unsign = (!(fmt & AFMT_SIGNED))? 1 : 0;
 424         u_int8_t spdval, fmtval;
 425
 426         DEB(printf("ess_setupch\n"));
 427         spdval = (sc->newspeed)? ess_calcspeed9(&spd) : ess_calcspeed8(&spd);
 428
 429         sc->simplex_dir = play ? PCMDIR_PLAY : PCMDIR_REC ;
 430
 431         if (ch == 1) {
 432                 KASSERT((dir == PCMDIR_PLAY) || (dir == PCMDIR_REC), ("ess_setupch: dir1 bad"));
 433                 len = -len;
 434                 /* transfer length low */
 435                 ess_write(sc, 0xa4, len & 0x00ff);
 436                 /* transfer length high */
 437                 ess_write(sc, 0xa5, (len & 0xff00) >> 8);
 438                 /* autoinit, dma dir */
 439                 ess_write(sc, 0xb8, 0x04 | (play? 0x00 : 0x0a));
 440                 /* mono/stereo */
 441                 ess_write(sc, 0xa8, (ess_read(sc, 0xa8) & ~0x03) | (stereo? 0x01 : 0x02));
 442                 /* demand mode, 4 bytes/xfer */
 443                 ess_write(sc, 0xb9, 0x02);
 444                 /* sample rate */
 445                 ess_write(sc, 0xa1, spdval);
 446                 /* filter cutoff */
 447                 ess_write(sc, 0xa2, ess_calcfilter(spd));
 448                 /* setup dac/adc */
 449                 /*
 450                 if (play)
 451                         ess_write(sc, 0xb6, unsign? 0x80 : 0x00);
 452                 */
 453                 /* mono, b16: signed, load signal */
 454                 /*
 455                 ess_write(sc, 0xb7, 0x51 | (unsign? 0x00 : 0x20));
 456                 */
 457                 /* setup fifo */
 458                 ess_write(sc, 0xb7, 0x91 | (unsign? 0x00 : 0x20) |
 459                                            (b16? 0x04 : 0x00) |
 460                                            (stereo? 0x08 : 0x40));
 461                 /* irq control */
 462                 ess_write(sc, 0xb1, (ess_read(sc, 0xb1) & 0x0f) | 0x50);
 463                 /* drq control */
 464                 ess_write(sc, 0xb2, (ess_read(sc, 0xb2) & 0x0f) | 0x50);
 465         } else if (ch == 2) {
 466                 KASSERT(dir == PCMDIR_PLAY, ("ess_setupch: dir2 bad"));
 467                 len >>= 1;
 468                 len = -len;
 469                 /* transfer length low */
 470                 ess_setmixer(sc, 0x74, len & 0x00ff);
 471                 /* transfer length high */
 472                 ess_setmixer(sc, 0x76, (len & 0xff00) >> 8);
 473                 /* autoinit, 4 bytes/req */
 474                 ess_setmixer(sc, 0x78, 0x10);
 475                 fmtval = b16 | (stereo << 1) | ((!unsign) << 2);
 476                 /* enable irq, set format */
 477                 ess_setmixer(sc, 0x7a, 0x40 | fmtval);
 478                 if (sc->newspeed) {
 479                         /* sample rate */
 480                         ess_setmixer(sc, 0x70, spdval);
 481                         /* filter cutoff */
 482                         ess_setmixer(sc, 0x72, ess_calcfilter(spd));
 483                 }
 484         }
 485         return 0;
 486 }
 487 static int
 488 ess_start(struct ess_chinfo *ch)
 489 {
 490         struct ess_info *sc = ch->parent;
 491
 492         DEB(printf("ess_start\n"););
 493         ess_setupch(sc, ch->hwch, ch->dir, ch->spd, ch->fmt, ch->blksz);
 494         ch->stopping = 0;
 495         if (ch->hwch == 1) {
 496                 ess_write(sc, 0xb8, ess_read(sc, 0xb8) | 0x01);
 497                 if (ch->dir == PCMDIR_PLAY) {
 498 #if 0
 499                         DELAY(100000); /* 100 ms */
 500 #endif
 501                         ess_cmd(sc, 0xd1);
 502                 }
 503         } else
 504                 ess_setmixer(sc, 0x78, ess_getmixer(sc, 0x78) | 0x03);
 505         return 0;
 506 }
 507
 508 static int
 509 ess_stop(struct ess_chinfo *ch)
 510 {
 511         struct ess_info *sc = ch->parent;
 512
 513         DEB(printf("ess_stop\n"));
 514         ch->stopping = 1;
 515         if (ch->hwch == 1)
 516                 ess_write(sc, 0xb8, ess_read(sc, 0xb8) & ~0x04);
 517         else
 518                 ess_setmixer(sc, 0x78, ess_getmixer(sc, 0x78) & ~0x10);
 519         DEB(printf("done with stop\n"));
 520         return 0;
 521 }
 522
 523 /* -------------------------------------------------------------------- */
 524 /* channel interface for ESS18xx */
 525 static void *
 526 esschan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir)
 527 {
 528         struct ess_info *sc = devinfo;
 529         struct ess_chinfo *ch = (dir == PCMDIR_PLAY)? &sc->pch : &sc->rch;
 530
 531         DEB(printf("esschan_init\n"));
 532         ch->parent = sc;
 533         ch->channel = c;
 534         ch->buffer = b;
 535         ch->dir = dir;
 536         if (sndbuf_alloc(ch->buffer, sc->parent_dmat, 0, sc->bufsz) != 0)
 537                 return NULL;
 538         ch->hwch = 1;
 539         if ((dir == PCMDIR_PLAY) && (sc->duplex))
 540                 ch->hwch = 2;
 541         return ch;
 542 }
 543
 544 static int
 545 esschan_setformat(kobj_t obj, void *data, u_int32_t format)
 546 {
 547         struct ess_chinfo *ch = data;
 548
 549         ch->fmt = format;
 550         return 0;
 551 }
 552
 553 static u_int32_t
 554 esschan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 555 {
 556         struct ess_chinfo *ch = data;
 557         struct ess_info *sc = ch->parent;
 558
 559         ch->spd = speed;
 560         if (sc->newspeed)
 561                 ess_calcspeed9(&ch->spd);
 562         else
 563                 ess_calcspeed8(&ch->spd);
 564         return ch->spd;
 565 }
 566
 567 static u_int32_t
 568 esschan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 569 {
 570         struct ess_chinfo *ch = data;
 571
 572         ch->blksz = blocksize;
 573         return ch->blksz;
 574 }
 575
 576 static int
 577 esschan_trigger(kobj_t obj, void *data, int go)
 578 {
 579         struct ess_chinfo *ch = data;
 580         struct ess_info *sc = ch->parent;
 581
 582         if (!PCMTRIG_COMMON(go))
 583                 return 0;
 584
 585         DEB(printf("esschan_trigger: %d\n",go));
 586
 587         ess_lock(sc);
 588         switch (go) {
 589         case PCMTRIG_START:
 590                 ess_dmasetup(sc, ch->hwch, sndbuf_getbufaddr(ch->buffer), sndbuf_getsize(ch->buffer), ch->dir);
 591                 ess_dmatrigger(sc, ch->hwch, 1);
 592                 ess_start(ch);
 593                 break;
 594
 595         case PCMTRIG_STOP:
 596         case PCMTRIG_ABORT:
 597         default:
 598                 ess_stop(ch);
 599                 break;
 600         }
 601         ess_unlock(sc);
 602         return 0;
 603 }
 604
 605 static u_int32_t
 606 esschan_getptr(kobj_t obj, void *data)
 607 {
 608         struct ess_chinfo *ch = data;
 609         struct ess_info *sc = ch->parent;
 610         u_int32_t ret;
 611
 612         ess_lock(sc);
 613         ret = ess_dmapos(sc, ch->hwch);
 614         ess_unlock(sc);
 615         return ret;
 616 }
 617
 618 static struct pcmchan_caps *
 619 esschan_getcaps(kobj_t obj, void *data)
 620 {
 621         struct ess_chinfo *ch = data;
 622
 623         return (ch->dir == PCMDIR_PLAY)? &ess_playcaps : &ess_reccaps;
 624 }
 625
 626 static kobj_method_t esschan_methods[] = {
 627         KOBJMETHOD(channel_init,                esschan_init),
 628         KOBJMETHOD(channel_setformat,           esschan_setformat),
 629         KOBJMETHOD(channel_setspeed,            esschan_setspeed),
 630         KOBJMETHOD(channel_setblocksize,        esschan_setblocksize),
 631         KOBJMETHOD(channel_trigger,             esschan_trigger),
 632         KOBJMETHOD(channel_getptr,              esschan_getptr),
 633         KOBJMETHOD(channel_getcaps,             esschan_getcaps),
 634         KOBJMETHOD_END
 635 };
 636 CHANNEL_DECLARE(esschan);
 637
 638 /************************************************************/
 639
 640 static int
 641 essmix_init(struct snd_mixer *m)
 642 {
 643         struct ess_info *sc = mix_getdevinfo(m);
 644
 645         mix_setrecdevs(m, SOUND_MASK_CD | SOUND_MASK_MIC | SOUND_MASK_LINE |
 646                           SOUND_MASK_IMIX);
 647
 648         mix_setdevs(m, SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_LINE |
 649                        SOUND_MASK_MIC | SOUND_MASK_CD | SOUND_MASK_VOLUME |
 650                        SOUND_MASK_LINE1);
 651
 652         ess_setmixer(sc, 0, 0); /* reset */
 653
 654         return 0;
 655 }
 656
 657 static int
 658 essmix_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
 659 {
 660         struct ess_info *sc = mix_getdevinfo(m);
 661         int preg = 0, rreg = 0, l, r;
 662
 663         l = (left * 15) / 100;
 664         r = (right * 15) / 100;
 665         switch (dev) {
 666         case SOUND_MIXER_SYNTH:
 667                 preg = 0x36;
 668                 rreg = 0x6b;
 669                 break;
 670
 671         case SOUND_MIXER_PCM:
 672                 preg = 0x14;
 673                 rreg = 0x7c;
 674                 break;
 675
 676         case SOUND_MIXER_LINE:
 677                 preg = 0x3e;
 678                 rreg = 0x6e;
 679                 break;
 680
 681         case SOUND_MIXER_MIC:
 682                 preg = 0x1a;
 683                 rreg = 0x68;
 684                 break;
 685
 686         case SOUND_MIXER_LINE1:
 687                 preg = 0x3a;
 688                 rreg = 0x6c;
 689                 break;
 690
 691         case SOUND_MIXER_CD:
 692                 preg = 0x38;
 693                 rreg = 0x6a;
 694                 break;
 695
 696         case SOUND_MIXER_VOLUME:
 697                 l = left? (left * 63) / 100 : 64;
 698                 r = right? (right * 63) / 100 : 64;
 699                 ess_setmixer(sc, 0x60, l);
 700                 ess_setmixer(sc, 0x62, r);
 701                 left = (l == 64)? 0 : (l * 100) / 63;
 702                 right = (r == 64)? 0 : (r * 100) / 63;
 703                 return left | (right << 8);
 704         }
 705
 706         if (preg)
 707                 ess_setmixer(sc, preg, (l << 4) | r);
 708         if (rreg)
 709                 ess_setmixer(sc, rreg, (l << 4) | r);
 710
 711         left = (l * 100) / 15;
 712         right = (r * 100) / 15;
 713
 714         return left | (right << 8);
 715 }
 716
 717 static u_int32_t
 718 essmix_setrecsrc(struct snd_mixer *m, u_int32_t src)
 719 {
 720         struct ess_info *sc = mix_getdevinfo(m);
 721         u_char recdev;
 722
 723         switch (src) {
 724         case SOUND_MASK_CD:
 725                 recdev = 0x02;
 726                 break;
 727
 728         case SOUND_MASK_LINE:
 729                 recdev = 0x06;
 730                 break;
 731
 732         case SOUND_MASK_IMIX:
 733                 recdev = 0x05;
 734                 break;
 735
 736         case SOUND_MASK_MIC:
 737         default:
 738                 recdev = 0x00;
 739                 src = SOUND_MASK_MIC;
 740                 break;
 741         }
 742
 743         ess_setmixer(sc, 0x1c, recdev);
 744
 745         return src;
 746 }
 747
 748 static kobj_method_t solomixer_methods[] = {
 749         KOBJMETHOD(mixer_init,          essmix_init),
 750         KOBJMETHOD(mixer_set,           essmix_set),
 751         KOBJMETHOD(mixer_setrecsrc,     essmix_setrecsrc),
 752         KOBJMETHOD_END
 753 };
 754 MIXER_DECLARE(solomixer);
 755
 756 /************************************************************/
 757
 758 static int
 759 ess_dmasetup(struct ess_info *sc, int ch, u_int32_t base, u_int16_t cnt, int dir)
 760 {
 761         KASSERT(ch == 1 || ch == 2, ("bad ch"));
 762         sc->dmasz[ch - 1] = cnt;
 763         if (ch == 1) {
 764                 port_wr(sc->vc, 0x8, 0xc4, 1); /* command */
 765                 port_wr(sc->vc, 0xd, 0xff, 1); /* reset */
 766                 port_wr(sc->vc, 0xf, 0x01, 1); /* mask */
 767                 port_wr(sc->vc, 0xb, dir == PCMDIR_PLAY? 0x58 : 0x54, 1); /* mode */
 768                 port_wr(sc->vc, 0x0, base, 4);
 769                 port_wr(sc->vc, 0x4, cnt - 1, 2);
 770
 771         } else if (ch == 2) {
 772                 port_wr(sc->io, 0x6, 0x08, 1); /* autoinit */
 773                 port_wr(sc->io, 0x0, base, 4);
 774                 port_wr(sc->io, 0x4, cnt, 2);
 775         }
 776         return 0;
 777 }
 778
 779 static int
 780 ess_dmapos(struct ess_info *sc, int ch)
 781 {
 782         int p = 0, i = 0, j = 0;
 783
 784         KASSERT(ch == 1 || ch == 2, ("bad ch"));
 785         if (ch == 1) {
 786 /*
 787  * During recording, this register is known to give back
 788  * garbage if it's not quiescent while being read. That's
 789  * why we spl, stop the DMA, and try over and over until
 790  * adjacent reads are "close", in the right order and not
 791  * bigger than is otherwise possible.
 792  */
 793                 ess_dmatrigger(sc, ch, 0);
 794                 DELAY(20);
 795                 do {
 796                         DELAY(10);
 797                         if (j > 1)
 798                                 printf("DMA count reg bogus: %04x & %04x\n",
 799                                         i, p);
 800                         i = port_rd(sc->vc, 0x4, 2) + 1;
 801                         p = port_rd(sc->vc, 0x4, 2) + 1;
 802                 } while ((p > sc->dmasz[ch - 1] || i < p || (p - i) > 0x8) && j++ < 1000);
 803                 ess_dmatrigger(sc, ch, 1);
 804         }
 805         else if (ch == 2)
 806                 p = port_rd(sc->io, 0x4, 2);
 807         return sc->dmasz[ch - 1] - p;
 808 }
 809
 810 static int
 811 ess_dmatrigger(struct ess_info *sc, int ch, int go)
 812 {
 813         KASSERT(ch == 1 || ch == 2, ("bad ch"));
 814         if (ch == 1)
 815                 port_wr(sc->vc, 0xf, go? 0x00 : 0x01, 1); /* mask */
 816         else if (ch == 2)
 817                 port_wr(sc->io, 0x6, 0x08 | (go? 0x02 : 0x00), 1); /* autoinit */
 818         return 0;
 819 }
 820
 821 static void
 822 ess_release_resources(struct ess_info *sc, device_t dev)
 823 {
 824         if (sc->irq) {
 825                 if (sc->ih)
 826                         bus_teardown_intr(dev, sc->irq, sc->ih);
 827                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
 828                 sc->irq = NULL;
 829         }
 830         if (sc->io) {
 831                 bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(0), sc->io);
 832                 sc->io = NULL;
 833         }
 834
 835         if (sc->sb) {
 836                 bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(1), sc->sb);
 837                 sc->sb = NULL;
 838         }
 839
 840         if (sc->vc) {
 841                 bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(2), sc->vc);
 842                 sc->vc = NULL;
 843         }
 844
 845         if (sc->mpu) {
 846                 bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(3), sc->mpu);
 847                 sc->mpu = NULL;
 848         }
 849
 850         if (sc->gp) {
 851                 bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(4), sc->gp);
 852                 sc->gp = NULL;
 853         }
 854
 855         if (sc->parent_dmat) {
 856                 bus_dma_tag_destroy(sc->parent_dmat);
 857                 sc->parent_dmat = 0;
 858         }
 859
 860         if (sc->lock) {
 861                 snd_mtxfree(sc->lock);
 862                 sc->lock = NULL;
 863         }
 864
 865         free(sc, M_DEVBUF);
 866 }
 867
 868 static int
 869 ess_alloc_resources(struct ess_info *sc, device_t dev)
 870 {
 871         int rid;
 872
 873         rid = PCIR_BAR(0);
 874         sc->io = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid, RF_ACTIVE);
 875
 876         rid = PCIR_BAR(1);
 877         sc->sb = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid, RF_ACTIVE);
 878
 879         rid = PCIR_BAR(2);
 880         sc->vc = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid, RF_ACTIVE);
 881
 882         rid = PCIR_BAR(3);
 883         sc->mpu = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid, RF_ACTIVE);
 884
 885         rid = PCIR_BAR(4);
 886         sc->gp = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid, RF_ACTIVE);
 887
 888         rid = 0;
 889         sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
 890                 RF_ACTIVE | RF_SHAREABLE);
 891
 892         sc->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_solo softc");
 893
 894         return (sc->irq && sc->io && sc->sb && sc->vc &&
 895                                 sc->mpu && sc->gp && sc->lock)? 0 : ENXIO;
 896 }
 897
 898 static int
 899 ess_probe(device_t dev)
 900 {
 901         char *s = NULL;
 902         u_int32_t subdev;
 903
 904         subdev = (pci_get_subdevice(dev) << 16) | pci_get_subvendor(dev);
 905         switch (pci_get_devid(dev)) {
 906         case 0x1969125d:
 907                 if (subdev == 0x8888125d)
 908                         s = "ESS Solo-1E";
 909                 else if (subdev == 0x1818125d)
 910                         s = "ESS Solo-1";
 911                 else
 912                         s = "ESS Solo-1 (unknown vendor)";
 913                 break;
 914         }
 915
 916         if (s)
 917                 device_set_desc(dev, s);
 918         return s ? BUS_PROBE_DEFAULT : ENXIO;
 919 }
 920
 921 #define ESS_PCI_LEGACYCONTROL       0x40
 922 #define ESS_PCI_CONFIG              0x50
 923 #define ESS_PCI_DDMACONTROL             0x60
 924
 925 static int
 926 ess_suspend(device_t dev)
 927 {
 928   return 0;
 929 }
 930
 931 static int
 932 ess_resume(device_t dev)
 933 {
 934         uint16_t ddma;
 935         struct ess_info *sc = pcm_getdevinfo(dev);
 936
 937         ess_lock(sc);
 938         ddma = rman_get_start(sc->vc) | 1;
 939         pci_write_config(dev, ESS_PCI_LEGACYCONTROL, 0x805f, 2);
 940         pci_write_config(dev, ESS_PCI_DDMACONTROL, ddma, 2);
 941         pci_write_config(dev, ESS_PCI_CONFIG, 0, 2);
 942
 943         if (ess_reset_dsp(sc)) {
 944                 ess_unlock(sc);
 945                 goto no;
 946         }
 947         ess_unlock(sc);
 948         if (mixer_reinit(dev))
 949                 goto no;
 950         ess_lock(sc);
 951         if (sc->newspeed)
 952                 ess_setmixer(sc, 0x71, 0x2a);
 953
 954         port_wr(sc->io, 0x7, 0xb0, 1); /* enable irqs */
 955         ess_unlock(sc);
 956
 957         return 0;
 958  no:
 959         return EIO;
 960 }
 961
 962 static int
 963 ess_attach(device_t dev)
 964 {
 965         struct ess_info *sc;
 966         char status[SND_STATUSLEN];
 967         u_int16_t ddma;
 968
 969         sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
 970         pci_enable_busmaster(dev);
 971
 972         if (ess_alloc_resources(sc, dev))
 973                 goto no;
 974
 975         sc->bufsz = pcm_getbuffersize(dev, 4096, SOLO_DEFAULT_BUFSZ, 65536);
 976
 977         ddma = rman_get_start(sc->vc) | 1;
 978         pci_write_config(dev, ESS_PCI_LEGACYCONTROL, 0x805f, 2);
 979         pci_write_config(dev, ESS_PCI_DDMACONTROL, ddma, 2);
 980         pci_write_config(dev, ESS_PCI_CONFIG, 0, 2);
 981
 982         port_wr(sc->io, 0x7, 0xb0, 1); /* enable irqs */
 983 #ifdef ESS18XX_DUPLEX
 984         sc->duplex = 1;
 985 #else
 986         sc->duplex = 0;
 987 #endif
 988
 989 #ifdef ESS18XX_NEWSPEED
 990         sc->newspeed = 1;
 991 #else
 992         sc->newspeed = 0;
 993 #endif
 994         if (snd_setup_intr(dev, sc->irq, INTR_MPSAFE, ess_intr, sc, &sc->ih)) {
 995                 device_printf(dev, "unable to map interrupt\n");
 996                 goto no;
 997         }
 998
 999         if (!sc->duplex)
1000                 pcm_setflags(dev, pcm_getflags(dev) | SD_F_SIMPLEX);
1001
1002 #if 0
1003         if (bus_dma_tag_create(/*parent*/bus_get_dma_tag(dev), /*alignment*/65536, /*boundary*/0,
1004 #endif
1005         if (bus_dma_tag_create(/*parent*/bus_get_dma_tag(dev), /*alignment*/2, /*boundary*/0,
1006                         /*lowaddr*/BUS_SPACE_MAXADDR_24BIT,
1007                         /*highaddr*/BUS_SPACE_MAXADDR,
1008                         /*filter*/NULL, /*filterarg*/NULL,
1009                         /*maxsize*/sc->bufsz, /*nsegments*/1,
1010                         /*maxsegz*/0x3ffff,
1011                         /*flags*/0,
1012                         /*lockfunc*/NULL, /*lockarg*/NULL,
1013                         &sc->parent_dmat) != 0) {
1014                 device_printf(dev, "unable to create dma tag\n");
1015                 goto no;
1016         }
1017
1018         if (ess_reset_dsp(sc))
1019                 goto no;
1020
1021         if (sc->newspeed)
1022                 ess_setmixer(sc, 0x71, 0x2a);
1023
1024         if (mixer_init(dev, &solomixer_class, sc))
1025                 goto no;
1026
1027         snprintf(status, SND_STATUSLEN, "at io 0x%jx,0x%jx,0x%jx irq %jd %s",
1028                 rman_get_start(sc->io), rman_get_start(sc->sb), rman_get_start(sc->vc),
1029                 rman_get_start(sc->irq),PCM_KLDSTRING(snd_solo));
1030
1031         if (pcm_register(dev, sc, 1, 1))
1032                 goto no;
1033         pcm_addchan(dev, PCMDIR_REC, &esschan_class, sc);
1034         pcm_addchan(dev, PCMDIR_PLAY, &esschan_class, sc);
1035         pcm_setstatus(dev, status);
1036
1037         return 0;
1038
1039 no:
1040         ess_release_resources(sc, dev);
1041         return ENXIO;
1042 }
1043
1044 static int
1045 ess_detach(device_t dev)
1046 {
1047         int r;
1048         struct ess_info *sc;
1049
1050         r = pcm_unregister(dev);
1051         if (r)
1052                 return r;
1053
1054         sc = pcm_getdevinfo(dev);
1055         ess_release_resources(sc, dev);
1056         return 0;
1057 }
1058
1059 static device_method_t ess_methods[] = {
1060         /* Device interface */
1061         DEVMETHOD(device_probe,         ess_probe),
1062         DEVMETHOD(device_attach,        ess_attach),
1063         DEVMETHOD(device_detach,        ess_detach),
1064         DEVMETHOD(device_resume,        ess_resume),
1065         DEVMETHOD(device_suspend,       ess_suspend),
1066         { 0, 0 }
1067 };
1068
1069 static driver_t ess_driver = {
1070         "pcm",
1071         ess_methods,
1072         PCM_SOFTC_SIZE,
1073 };
1074
1075 DRIVER_MODULE(snd_solo, pci, ess_driver, pcm_devclass, 0, 0);
1076 MODULE_DEPEND(snd_solo, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
1077 MODULE_VERSION(snd_solo, 1);