sys/dev/sound/pcm/mixer.c

   1 /*
   2  * Copyright (c) 1999 Cameron Grant <gandalf@vilnya.demon.co.uk>
   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  * $FreeBSD: src/sys/dev/sound/pcm/mixer.c,v 1.4.2.8 2002/04/22 15:49:36 cg Exp $
  27  * $DragonFly: src/sys/dev/sound/pcm/mixer.c,v 1.7 2004/05/21 01:14:27 dillon Exp $
  28  */
  29
  30 #include <dev/sound/pcm/sound.h>
  31
  32 #include "mixer_if.h"
  33
  34 SND_DECLARE_FILE("$DragonFly: src/sys/dev/sound/pcm/mixer.c,v 1.7 2004/05/21 01:14:27 dillon Exp $");
  35
  36 MALLOC_DEFINE(M_MIXER, "mixer", "mixer");
  37
  38 #define MIXER_NAMELEN   16
  39 struct snd_mixer {
  40         KOBJ_FIELDS;
  41         const char *type;
  42         void *devinfo;
  43         int busy;
  44         int hwvol_muted;
  45         int hwvol_mixer;
  46         int hwvol_step;
  47         u_int32_t hwvol_mute_level;
  48         u_int32_t devs;
  49         u_int32_t recdevs;
  50         u_int32_t recsrc;
  51         u_int16_t level[32];
  52         char name[MIXER_NAMELEN];
  53         void *lock;
  54 };
  55
  56 static u_int16_t snd_mixerdefaults[SOUND_MIXER_NRDEVICES] = {
  57         [SOUND_MIXER_VOLUME]    = 75,
  58         [SOUND_MIXER_BASS]      = 50,
  59         [SOUND_MIXER_TREBLE]    = 50,
  60         [SOUND_MIXER_SYNTH]     = 75,
  61         [SOUND_MIXER_PCM]       = 75,
  62         [SOUND_MIXER_SPEAKER]   = 75,
  63         [SOUND_MIXER_LINE]      = 75,
  64         [SOUND_MIXER_MIC]       = 0,
  65         [SOUND_MIXER_CD]        = 75,
  66         [SOUND_MIXER_LINE1]     = 75,
  67         [SOUND_MIXER_VIDEO]     = 75,
  68         [SOUND_MIXER_RECLEV]    = 0,
  69         [SOUND_MIXER_OGAIN]     = 50,
  70         [SOUND_MIXER_MONITOR]   = 75,
  71 };
  72
  73 static char* snd_mixernames[SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_NAMES;
  74
  75 static d_open_t mixer_open;
  76 static d_close_t mixer_close;
  77
  78 static struct cdevsw mixer_cdevsw = {
  79         /* name */      "mixer",
  80         /* maj */       SND_CDEV_MAJOR,
  81         /* flags */     0,
  82         /* port */      NULL,
  83         /* clone */     NULL,
  84
  85         /* open */      mixer_open,
  86         /* close */     mixer_close,
  87         /* read */      noread,
  88         /* write */     nowrite,
  89         /* ioctl */     mixer_ioctl,
  90         /* poll */      nopoll,
  91         /* mmap */      nommap,
  92         /* strategy */  nostrategy,
  93         /* dump */      nodump,
  94         /* psize */     nopsize
  95 };
  96
  97 #ifdef USING_DEVFS
  98 static eventhandler_tag mixer_ehtag;
  99 #endif
 100
 101 static dev_t
 102 mixer_get_devt(device_t dev)
 103 {
 104         dev_t pdev;
 105         int unit;
 106
 107         unit = device_get_unit(dev);
 108         pdev = make_adhoc_dev(&mixer_cdevsw, PCMMKMINOR(unit, SND_DEV_CTL, 0));
 109
 110         return pdev;
 111 }
 112
 113 #ifdef SND_DYNSYSCTL
 114 static int
 115 mixer_lookup(char *devname)
 116 {
 117         int i;
 118
 119         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
 120                 if (strncmp(devname, snd_mixernames[i],
 121                     strlen(snd_mixernames[i])) == 0)
 122                         return i;
 123         return -1;
 124 }
 125 #endif
 126
 127 static int
 128 mixer_set(struct snd_mixer *mixer, unsigned dev, unsigned lev)
 129 {
 130         unsigned l, r;
 131         int v;
 132
 133         if ((dev >= SOUND_MIXER_NRDEVICES) || (0 == (mixer->devs & (1 << dev))))
 134                 return -1;
 135
 136         l = min((lev & 0x00ff), 100);
 137         r = min(((lev & 0xff00) >> 8), 100);
 138
 139         v = MIXER_SET(mixer, dev, l, r);
 140         if (v < 0)
 141                 return -1;
 142
 143         mixer->level[dev] = l | (r << 8);
 144         return 0;
 145 }
 146
 147 static int
 148 mixer_get(struct snd_mixer *mixer, int dev)
 149 {
 150         if ((dev < SOUND_MIXER_NRDEVICES) && (mixer->devs & (1 << dev)))
 151                 return mixer->level[dev];
 152         else return -1;
 153 }
 154
 155 static int
 156 mixer_setrecsrc(struct snd_mixer *mixer, u_int32_t src)
 157 {
 158         src &= mixer->recdevs;
 159         if (src == 0)
 160                 src = SOUND_MASK_MIC;
 161         mixer->recsrc = MIXER_SETRECSRC(mixer, src);
 162         return 0;
 163 }
 164
 165 static int
 166 mixer_getrecsrc(struct snd_mixer *mixer)
 167 {
 168         return mixer->recsrc;
 169 }
 170
 171 void
 172 mix_setdevs(struct snd_mixer *m, u_int32_t v)
 173 {
 174         m->devs = v;
 175 }
 176
 177 void
 178 mix_setrecdevs(struct snd_mixer *m, u_int32_t v)
 179 {
 180         m->recdevs = v;
 181 }
 182
 183 u_int32_t
 184 mix_getdevs(struct snd_mixer *m)
 185 {
 186         return m->devs;
 187 }
 188
 189 u_int32_t
 190 mix_getrecdevs(struct snd_mixer *m)
 191 {
 192         return m->recdevs;
 193 }
 194
 195 void *
 196 mix_getdevinfo(struct snd_mixer *m)
 197 {
 198         return m->devinfo;
 199 }
 200
 201 int
 202 mixer_init(device_t dev, kobj_class_t cls, void *devinfo)
 203 {
 204         struct snd_mixer *m;
 205         u_int16_t v;
 206         dev_t pdev;
 207         int i, unit;
 208
 209         m = (struct snd_mixer *)kobj_create(cls, M_MIXER, M_WAITOK | M_ZERO);
 210         snprintf(m->name, MIXER_NAMELEN, "%s:mixer", device_get_nameunit(dev));
 211         m->lock = snd_mtxcreate(m->name, "pcm mixer");
 212         m->type = cls->name;
 213         m->devinfo = devinfo;
 214         m->busy = 0;
 215
 216         if (MIXER_INIT(m))
 217                 goto bad;
 218
 219         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
 220                 v = snd_mixerdefaults[i];
 221                 mixer_set(m, i, v | (v << 8));
 222         }
 223
 224         mixer_setrecsrc(m, SOUND_MASK_MIC);
 225
 226         unit = device_get_unit(dev);
 227         cdevsw_add(&mixer_cdevsw,
 228                     PCMMKMINOR(-1, -1, 0), PCMMKMINOR(unit, SND_DEV_CTL, 0));
 229         pdev = make_dev(&mixer_cdevsw, PCMMKMINOR(unit, SND_DEV_CTL, 0),
 230                  UID_ROOT, GID_WHEEL, 0666, "mixer%d", unit);
 231         pdev->si_drv1 = m;
 232
 233         return 0;
 234
 235 bad:
 236         snd_mtxlock(m->lock);
 237         snd_mtxfree(m->lock);
 238         kobj_delete((kobj_t)m, M_MIXER);
 239         return -1;
 240 }
 241
 242 int
 243 mixer_uninit(device_t dev)
 244 {
 245         int i;
 246         int unit;
 247         struct snd_mixer *m;
 248         dev_t pdev;
 249
 250         pdev = mixer_get_devt(dev);
 251         m = pdev->si_drv1;
 252         snd_mtxlock(m->lock);
 253
 254         if (m->busy) {
 255                 snd_mtxunlock(m->lock);
 256                 return EBUSY;
 257         }
 258
 259         pdev->si_drv1 = NULL;
 260
 261         unit = device_get_unit(dev);
 262         cdevsw_remove(&mixer_cdevsw,
 263                     PCMMKMINOR(-1, -1, 0), PCMMKMINOR(unit, SND_DEV_CTL, 0));
 264
 265         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
 266                 mixer_set(m, i, 0);
 267
 268         mixer_setrecsrc(m, SOUND_MASK_MIC);
 269
 270         MIXER_UNINIT(m);
 271
 272         snd_mtxfree(m->lock);
 273         kobj_delete((kobj_t)m, M_MIXER);
 274
 275         return 0;
 276 }
 277
 278 int
 279 mixer_reinit(device_t dev)
 280 {
 281         struct snd_mixer *m;
 282         dev_t pdev;
 283         int i;
 284
 285         pdev = mixer_get_devt(dev);
 286         m = pdev->si_drv1;
 287         snd_mtxlock(m->lock);
 288
 289         i = MIXER_REINIT(m);
 290         if (i) {
 291                 snd_mtxunlock(m->lock);
 292                 return i;
 293         }
 294
 295         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
 296                 mixer_set(m, i, m->level[i]);
 297
 298         mixer_setrecsrc(m, m->recsrc);
 299         snd_mtxunlock(m->lock);
 300
 301         return 0;
 302 }
 303
 304 #ifdef SND_DYNSYSCTL
 305 static int
 306 sysctl_hw_snd_hwvol_mixer(SYSCTL_HANDLER_ARGS)
 307 {
 308         char devname[32];
 309         int error, dev;
 310         struct snd_mixer *m;
 311
 312         m = oidp->oid_arg1;
 313         snd_mtxlock(m->lock);
 314         strncpy(devname, snd_mixernames[m->hwvol_mixer], sizeof(devname));
 315         error = sysctl_handle_string(oidp, &devname[0], sizeof(devname), req);
 316         if (error == 0 && req->newptr != NULL) {
 317                 dev = mixer_lookup(devname);
 318                 if (dev == -1) {
 319                         snd_mtxunlock(m->lock);
 320                         return EINVAL;
 321                 }
 322                 else if (dev != m->hwvol_mixer) {
 323                         m->hwvol_mixer = dev;
 324                         m->hwvol_muted = 0;
 325                 }
 326         }
 327         snd_mtxunlock(m->lock);
 328         return error;
 329 }
 330 #endif
 331
 332 int
 333 mixer_hwvol_init(device_t dev)
 334 {
 335         struct snd_mixer *m;
 336         dev_t pdev;
 337
 338         pdev = mixer_get_devt(dev);
 339         m = pdev->si_drv1;
 340         snd_mtxlock(m->lock);
 341
 342         m->hwvol_mixer = SOUND_MIXER_VOLUME;
 343         m->hwvol_step = 5;
 344 #ifdef SND_DYNSYSCTL
 345         SYSCTL_ADD_INT(snd_sysctl_tree(dev), SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)),
 346             OID_AUTO, "hwvol_step", CTLFLAG_RW, &m->hwvol_step, 0, "");
 347         SYSCTL_ADD_PROC(snd_sysctl_tree(dev), SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)),
 348             OID_AUTO, "hwvol_mixer", CTLTYPE_STRING | CTLFLAG_RW, m, 0,
 349             sysctl_hw_snd_hwvol_mixer, "A", "")
 350 #endif
 351         snd_mtxunlock(m->lock);
 352         return 0;
 353 }
 354
 355 void
 356 mixer_hwvol_mute(device_t dev)
 357 {
 358         struct snd_mixer *m;
 359         dev_t pdev;
 360
 361         pdev = mixer_get_devt(dev);
 362         m = pdev->si_drv1;
 363         snd_mtxlock(m->lock);
 364         if (m->hwvol_muted) {
 365                 m->hwvol_muted = 0;
 366                 mixer_set(m, m->hwvol_mixer, m->hwvol_mute_level);
 367         } else {
 368                 m->hwvol_muted++;
 369                 m->hwvol_mute_level = mixer_get(m, m->hwvol_mixer);
 370                 mixer_set(m, m->hwvol_mixer, 0);
 371         }
 372         snd_mtxunlock(m->lock);
 373 }
 374
 375 void
 376 mixer_hwvol_step(device_t dev, int left_step, int right_step)
 377 {
 378         struct snd_mixer *m;
 379         int level, left, right;
 380         dev_t pdev;
 381
 382         pdev = mixer_get_devt(dev);
 383         m = pdev->si_drv1;
 384         snd_mtxlock(m->lock);
 385         if (m->hwvol_muted) {
 386                 m->hwvol_muted = 0;
 387                 level = m->hwvol_mute_level;
 388         } else
 389                 level = mixer_get(m, m->hwvol_mixer);
 390         if (level != -1) {
 391                 left = level & 0xff;
 392                 right = level >> 8;
 393                 left += left_step * m->hwvol_step;
 394                 if (left < 0)
 395                         left = 0;
 396                 right += right_step * m->hwvol_step;
 397                 if (right < 0)
 398                         right = 0;
 399                 mixer_set(m, m->hwvol_mixer, left | right << 8);
 400         }
 401         snd_mtxunlock(m->lock);
 402 }
 403
 404 /* ----------------------------------------------------------------------- */
 405
 406 static int
 407 mixer_open(dev_t i_dev, int flags, int mode, struct thread *td)
 408 {
 409         struct snd_mixer *m;
 410         intrmask_t s;
 411
 412         m = i_dev->si_drv1;
 413         s = spltty();
 414         snd_mtxlock(m->lock);
 415
 416         m->busy++;
 417
 418         snd_mtxunlock(m->lock);
 419         splx(s);
 420         return 0;
 421 }
 422
 423 static int
 424 mixer_close(dev_t i_dev, int flags, int mode, struct thread *td)
 425 {
 426         struct snd_mixer *m;
 427         intrmask_t s;
 428
 429         m = i_dev->si_drv1;
 430         s = spltty();
 431         snd_mtxlock(m->lock);
 432
 433         if (!m->busy) {
 434                 snd_mtxunlock(m->lock);
 435                 splx(s);
 436                 return EBADF;
 437         }
 438         m->busy--;
 439
 440         snd_mtxunlock(m->lock);
 441         splx(s);
 442         return 0;
 443 }
 444
 445 int
 446 mixer_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td)
 447 {
 448         struct snd_mixer *m;
 449         intrmask_t s;
 450         int ret, *arg_i = (int *)arg;
 451         int v = -1, j = cmd & 0xff;
 452
 453         m = i_dev->si_drv1;
 454         if (!m->busy)
 455                 return EBADF;
 456
 457         s = spltty();
 458         snd_mtxlock(m->lock);
 459         if ((cmd & MIXER_WRITE(0)) == MIXER_WRITE(0)) {
 460                 if (j == SOUND_MIXER_RECSRC)
 461                         ret = mixer_setrecsrc(m, *arg_i);
 462                 else
 463                         ret = mixer_set(m, j, *arg_i);
 464                 snd_mtxunlock(m->lock);
 465                 splx(s);
 466                 return (ret == 0)? 0 : ENXIO;
 467         }
 468
 469         if ((cmd & MIXER_READ(0)) == MIXER_READ(0)) {
 470                 switch (j) {
 471                 case SOUND_MIXER_DEVMASK:
 472                 case SOUND_MIXER_CAPS:
 473                 case SOUND_MIXER_STEREODEVS:
 474                         v = mix_getdevs(m);
 475                         break;
 476
 477                 case SOUND_MIXER_RECMASK:
 478                         v = mix_getrecdevs(m);
 479                         break;
 480
 481                 case SOUND_MIXER_RECSRC:
 482                         v = mixer_getrecsrc(m);
 483                         break;
 484
 485                 default:
 486                         v = mixer_get(m, j);
 487                 }
 488                 *arg_i = v;
 489                 snd_mtxunlock(m->lock);
 490                 return (v != -1)? 0 : ENXIO;
 491         }
 492         snd_mtxunlock(m->lock);
 493         splx(s);
 494         return ENXIO;
 495 }
 496
 497 #ifdef USING_DEVFS
 498 static void
 499 mixer_clone(void *arg, char *name, int namelen, dev_t *dev)
 500 {
 501         dev_t pdev;
 502
 503         if (*dev != NODEV)
 504                 return;
 505         if (strcmp(name, "mixer") == 0) {
 506                 pdev = make_adhoc_dev(&mixer_cdevsw,
 507                                         PCMMKMINOR(snd_unit, SND_DEV_CTL, 0));
 508                 if (pdev->si_flags & SI_NAMED)
 509                         *dev = pdev;
 510         }
 511 }
 512
 513 static void
 514 mixer_sysinit(void *p)
 515 {
 516         mixer_ehtag = EVENTHANDLER_REGISTER(dev_clone, mixer_clone, 0, 1000);
 517 }
 518
 519 static void
 520 mixer_sysuninit(void *p)
 521 {
 522         if (mixer_ehtag != NULL)
 523                 EVENTHANDLER_DEREGISTER(dev_clone, mixer_ehtag);
 524 }
 525
 526 SYSINIT(mixer_sysinit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysinit, NULL);
 527 SYSUNINIT(mixer_sysuninit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysuninit, NULL);
 528 #endif
 529
 530