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