ossaudio.c revision 1.13
1 /* $NetBSD: ossaudio.c,v 1.13 1997/07/27 01:16:41 augustss Exp $ */ 2 #include <sys/param.h> 3 #include <sys/proc.h> 4 #include <sys/systm.h> 5 #include <sys/file.h> 6 #include <sys/vnode.h> 7 #include <sys/filedesc.h> 8 #include <sys/ioctl.h> 9 #include <sys/mount.h> 10 #include <sys/audioio.h> 11 12 #include <sys/syscallargs.h> 13 14 #include <compat/ossaudio/ossaudio.h> 15 #include <compat/ossaudio/ossaudiovar.h> 16 17 static struct audiodevinfo *getdevinfo __P((struct file *, struct proc *)); 18 19 int 20 oss_ioctl_audio(p, uap, retval) 21 register struct proc *p; 22 register struct oss_sys_ioctl_args /* { 23 syscallarg(int) fd; 24 syscallarg(u_long) com; 25 syscallarg(caddr_t) data; 26 } */ *uap; 27 register_t *retval; 28 { 29 register struct file *fp; 30 register struct filedesc *fdp; 31 u_long com; 32 struct audio_info tmpinfo; 33 struct audio_offset tmpoffs; 34 struct oss_audio_buf_info bufinfo; 35 struct oss_count_info cntinfo; 36 int idat, idata; 37 int error; 38 int (*ioctlf) __P((struct file *, u_long, caddr_t, struct proc *)); 39 40 fdp = p->p_fd; 41 if ((u_int)SCARG(uap, fd) >= fdp->fd_nfiles || 42 (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) 43 return (EBADF); 44 45 if ((fp->f_flag & (FREAD | FWRITE)) == 0) 46 return (EBADF); 47 48 ioctlf = fp->f_ops->fo_ioctl; 49 50 com = SCARG(uap, com); 51 retval[0] = 0; 52 53 switch (com) { 54 case OSS_SNDCTL_DSP_RESET: 55 error = ioctlf(fp, AUDIO_FLUSH, (caddr_t)0, p); 56 if (error) 57 return error; 58 break; 59 case OSS_SNDCTL_DSP_SYNC: 60 case OSS_SNDCTL_DSP_POST: 61 error = ioctlf(fp, AUDIO_DRAIN, (caddr_t)0, p); 62 if (error) 63 return error; 64 break; 65 case OSS_SNDCTL_DSP_SPEED: 66 AUDIO_INITINFO(&tmpinfo); 67 error = copyin(SCARG(uap, data), &idat, sizeof idat); 68 if (error) 69 return error; 70 tmpinfo.play.sample_rate = 71 tmpinfo.record.sample_rate = idat; 72 (void) ioctlf(fp, AUDIO_SETINFO, (caddr_t)&tmpinfo, p); 73 /* fall into ... */ 74 case OSS_SOUND_PCM_READ_RATE: 75 error = ioctlf(fp, AUDIO_GETINFO, (caddr_t)&tmpinfo, p); 76 if (error) 77 return error; 78 idat = tmpinfo.play.sample_rate; 79 error = copyout(&idat, SCARG(uap, data), sizeof idat); 80 if (error) 81 return error; 82 break; 83 case OSS_SNDCTL_DSP_STEREO: 84 AUDIO_INITINFO(&tmpinfo); 85 error = copyin(SCARG(uap, data), &idat, sizeof idat); 86 if (error) 87 return error; 88 tmpinfo.play.channels = 89 tmpinfo.record.channels = idat ? 2 : 1; 90 (void) ioctlf(fp, AUDIO_SETINFO, (caddr_t)&tmpinfo, p); 91 error = ioctlf(fp, AUDIO_GETINFO, (caddr_t)&tmpinfo, p); 92 if (error) 93 return error; 94 idat = tmpinfo.play.channels - 1; 95 error = copyout(&idat, SCARG(uap, data), sizeof idat); 96 if (error) 97 return error; 98 break; 99 case OSS_SNDCTL_DSP_GETBLKSIZE: 100 error = ioctlf(fp, AUDIO_GETINFO, (caddr_t)&tmpinfo, p); 101 if (error) 102 return error; 103 idat = tmpinfo.blocksize; 104 error = copyout(&idat, SCARG(uap, data), sizeof idat); 105 if (error) 106 return error; 107 break; 108 case OSS_SNDCTL_DSP_SETFMT: 109 AUDIO_INITINFO(&tmpinfo); 110 error = copyin(SCARG(uap, data), &idat, sizeof idat); 111 if (error) 112 return error; 113 switch (idat) { 114 case OSS_AFMT_MU_LAW: 115 tmpinfo.play.precision = 116 tmpinfo.record.precision = 8; 117 tmpinfo.play.encoding = 118 tmpinfo.record.encoding = AUDIO_ENCODING_ULAW; 119 break; 120 case OSS_AFMT_A_LAW: 121 tmpinfo.play.precision = 122 tmpinfo.record.precision = 8; 123 tmpinfo.play.encoding = 124 tmpinfo.record.encoding = AUDIO_ENCODING_ALAW; 125 break; 126 case OSS_AFMT_U8: 127 tmpinfo.play.precision = 128 tmpinfo.record.precision = 8; 129 tmpinfo.play.encoding = 130 tmpinfo.record.encoding = AUDIO_ENCODING_ULINEAR; 131 break; 132 case OSS_AFMT_S8: 133 tmpinfo.play.precision = 134 tmpinfo.record.precision = 8; 135 tmpinfo.play.encoding = 136 tmpinfo.record.encoding = AUDIO_ENCODING_SLINEAR; 137 break; 138 case OSS_AFMT_S16_LE: 139 tmpinfo.play.precision = 140 tmpinfo.record.precision = 16; 141 tmpinfo.play.encoding = 142 tmpinfo.record.encoding = AUDIO_ENCODING_SLINEAR_LE; 143 break; 144 case OSS_AFMT_S16_BE: 145 tmpinfo.play.precision = 146 tmpinfo.record.precision = 16; 147 tmpinfo.play.encoding = 148 tmpinfo.record.encoding = AUDIO_ENCODING_SLINEAR_BE; 149 break; 150 case OSS_AFMT_U16_LE: 151 tmpinfo.play.precision = 152 tmpinfo.record.precision = 16; 153 tmpinfo.play.encoding = 154 tmpinfo.record.encoding = AUDIO_ENCODING_ULINEAR_LE; 155 break; 156 case OSS_AFMT_U16_BE: 157 tmpinfo.play.precision = 158 tmpinfo.record.precision = 16; 159 tmpinfo.play.encoding = 160 tmpinfo.record.encoding = AUDIO_ENCODING_ULINEAR_BE; 161 break; 162 default: 163 return EINVAL; 164 } 165 (void) ioctlf(fp, AUDIO_SETINFO, (caddr_t)&tmpinfo, p); 166 /* fall into ... */ 167 case OSS_SOUND_PCM_READ_BITS: 168 error = ioctlf(fp, AUDIO_GETINFO, (caddr_t)&tmpinfo, p); 169 if (error) 170 return error; 171 switch (tmpinfo.play.encoding) { 172 case AUDIO_ENCODING_ULAW: 173 idat = OSS_AFMT_MU_LAW; 174 break; 175 case AUDIO_ENCODING_ALAW: 176 idat = OSS_AFMT_A_LAW; 177 break; 178 case AUDIO_ENCODING_SLINEAR_LE: 179 if (tmpinfo.play.precision == 16) 180 idat = OSS_AFMT_S16_LE; 181 else 182 idat = OSS_AFMT_S8; 183 break; 184 case AUDIO_ENCODING_SLINEAR_BE: 185 if (tmpinfo.play.precision == 16) 186 idat = OSS_AFMT_S16_BE; 187 else 188 idat = OSS_AFMT_S8; 189 break; 190 case AUDIO_ENCODING_ULINEAR_LE: 191 if (tmpinfo.play.precision == 16) 192 idat = OSS_AFMT_U16_LE; 193 else 194 idat = OSS_AFMT_U8; 195 break; 196 case AUDIO_ENCODING_ULINEAR_BE: 197 if (tmpinfo.play.precision == 16) 198 idat = OSS_AFMT_U16_BE; 199 else 200 idat = OSS_AFMT_U8; 201 break; 202 case AUDIO_ENCODING_ADPCM: 203 idat = OSS_AFMT_IMA_ADPCM; 204 break; 205 } 206 error = copyout(&idat, SCARG(uap, data), sizeof idat); 207 if (error) 208 return error; 209 break; 210 case OSS_SNDCTL_DSP_CHANNELS: 211 AUDIO_INITINFO(&tmpinfo); 212 error = copyin(SCARG(uap, data), &idat, sizeof idat); 213 if (error) 214 return error; 215 tmpinfo.play.channels = 216 tmpinfo.record.channels = idat; 217 (void) ioctlf(fp, AUDIO_SETINFO, (caddr_t)&tmpinfo, p); 218 /* fall into ... */ 219 case OSS_SOUND_PCM_READ_CHANNELS: 220 error = ioctlf(fp, AUDIO_GETINFO, (caddr_t)&tmpinfo, p); 221 if (error) 222 return error; 223 idat = tmpinfo.play.channels; 224 error = copyout(&idat, SCARG(uap, data), sizeof idat); 225 if (error) 226 return error; 227 break; 228 case OSS_SOUND_PCM_WRITE_FILTER: 229 case OSS_SOUND_PCM_READ_FILTER: 230 return EINVAL; /* XXX unimplemented */ 231 case OSS_SNDCTL_DSP_SUBDIVIDE: 232 error = copyin(SCARG(uap, data), &idat, sizeof idat); 233 if (error) 234 return error; 235 error = ioctlf(fp, AUDIO_GETINFO, (caddr_t)&tmpinfo, p); 236 if (error) 237 return error; 238 if (idat == 0) 239 idat = tmpinfo.buffersize / tmpinfo.blocksize; 240 idat = (tmpinfo.buffersize / idat) & -4; 241 AUDIO_INITINFO(&tmpinfo); 242 tmpinfo.blocksize = idat; 243 error = ioctlf(fp, AUDIO_SETINFO, (caddr_t)&tmpinfo, p); 244 if (error) 245 return error; 246 idat = tmpinfo.buffersize / tmpinfo.blocksize; 247 error = copyout(&idat, SCARG(uap, data), sizeof idat); 248 if (error) 249 return error; 250 break; 251 case OSS_SNDCTL_DSP_SETFRAGMENT: 252 AUDIO_INITINFO(&tmpinfo); 253 error = copyin(SCARG(uap, data), &idat, sizeof idat); 254 if (error) 255 return error; 256 if ((idat & 0xffff) < 4 || (idat & 0xffff) > 17) 257 return EINVAL; 258 tmpinfo.blocksize = 1 << (idat & 0xffff); 259 tmpinfo.hiwat = (idat >> 16) & 0xffff; 260 (void) ioctlf(fp, AUDIO_SETINFO, (caddr_t)&tmpinfo, p); 261 error = ioctlf(fp, AUDIO_GETINFO, (caddr_t)&tmpinfo, p); 262 if (error) 263 return error; 264 idat = tmpinfo.blocksize; 265 error = copyout(&idat, SCARG(uap, data), sizeof idat); 266 if (error) 267 return error; 268 break; 269 case OSS_SNDCTL_DSP_GETFMTS: 270 idat = OSS_AFMT_MU_LAW | OSS_AFMT_U8 | OSS_AFMT_S16_LE; 271 error = copyout(&idat, SCARG(uap, data), sizeof idat); 272 if (error) 273 return error; 274 break; 275 case OSS_SNDCTL_DSP_GETOSPACE: 276 error = ioctlf(fp, AUDIO_GETINFO, (caddr_t)&tmpinfo, p); 277 if (error) 278 return error; 279 bufinfo.fragsize = tmpinfo.blocksize; 280 bufinfo.fragments = /* XXX */ 281 bufinfo.fragstotal = tmpinfo.buffersize / bufinfo.fragsize; 282 bufinfo.bytes = bufinfo.fragments * bufinfo.fragsize; 283 error = copyout(&bufinfo, SCARG(uap, data), sizeof bufinfo); 284 if (error) 285 return error; 286 break; 287 case OSS_SNDCTL_DSP_GETISPACE: 288 case OSS_SNDCTL_DSP_NONBLOCK: 289 return EINVAL; /* XXX unimplemented */ 290 case OSS_SNDCTL_DSP_GETCAPS: 291 error = ioctlf(fp, AUDIO_GETPROPS, (caddr_t)&idata, p); 292 if (error) 293 return error; 294 idat = OSS_DSP_CAP_TRIGGER; /* pretend we have trigger */ 295 if (idata & AUDIO_PROP_FULLDUPLEX) 296 idat |= OSS_DSP_CAP_DUPLEX; 297 if (idata & AUDIO_PROP_MMAP) 298 idat |= OSS_DSP_CAP_MMAP; 299 error = copyout(&idat, SCARG(uap, data), sizeof idat); 300 if (error) 301 return error; 302 break; 303 #if 0 304 case OSS_SNDCTL_DSP_GETTRIGGER: 305 error = ioctlf(fp, AUDIO_GETINFO, (caddr_t)&tmpinfo, p); 306 if (error) 307 return error; 308 idat = (tmpinfo.play.pause ? 0 : OSS_PCM_ENABLE_OUTPUT) | 309 (tmpinfo.record.pause ? 0 : OSS_PCM_ENABLE_INPUT); 310 error = copyout(&idat, SCARG(uap, data), sizeof idat); 311 if (error) 312 return error; 313 break; 314 case OSS_SNDCTL_DSP_SETTRIGGER: 315 AUDIO_INITINFO(&tmpinfo); 316 error = copyin(SCARG(uap, data), &idat, sizeof idat); 317 if (error) 318 return error; 319 tmpinfo.play.pause = (idat & OSS_PCM_ENABLE_OUTPUT) == 0; 320 tmpinfo.record.pause = (idat & OSS_PCM_ENABLE_INPUT) == 0; 321 (void) ioctlf(fp, AUDIO_SETINFO, (caddr_t)&tmpinfo, p); 322 error = copyout(&idat, SCARG(uap, data), sizeof idat); 323 if (error) 324 return error; 325 break; 326 #else 327 case OSS_SNDCTL_DSP_GETTRIGGER: 328 case OSS_SNDCTL_DSP_SETTRIGGER: 329 /* XXX Do nothing for now. */ 330 idat = OSS_PCM_ENABLE_OUTPUT; 331 return copyout(&idat, SCARG(uap, data), sizeof idat); 332 #endif 333 case OSS_SNDCTL_DSP_GETIPTR: 334 error = ioctlf(fp, AUDIO_GETIOFFS, (caddr_t)&tmpoffs, p); 335 if (error) 336 return error; 337 cntinfo.bytes = tmpoffs.samples; 338 cntinfo.blocks = tmpoffs.deltablks; 339 cntinfo.ptr = tmpoffs.offset; 340 error = copyout(&cntinfo, SCARG(uap, data), sizeof cntinfo); 341 if (error) 342 return error; 343 break; 344 case OSS_SNDCTL_DSP_GETOPTR: 345 error = ioctlf(fp, AUDIO_GETOOFFS, (caddr_t)&tmpoffs, p); 346 if (error) 347 return error; 348 cntinfo.bytes = tmpoffs.samples; 349 cntinfo.blocks = tmpoffs.deltablks; 350 cntinfo.ptr = tmpoffs.offset; 351 error = copyout(&cntinfo, SCARG(uap, data), sizeof cntinfo); 352 if (error) 353 return error; 354 break; 355 case OSS_SNDCTL_DSP_MAPINBUF: 356 case OSS_SNDCTL_DSP_MAPOUTBUF: 357 case OSS_SNDCTL_DSP_SETSYNCRO: 358 case OSS_SNDCTL_DSP_SETDUPLEX: 359 case OSS_SNDCTL_DSP_PROFILE: 360 return EINVAL; /* XXX unimplemented */ 361 default: 362 return EINVAL; 363 } 364 365 return 0; 366 } 367 368 /* If the NetBSD mixer device should have more than 32 devices 369 * some will not be available to Linux */ 370 #define NETBSD_MAXDEVS 32 371 struct audiodevinfo { 372 int done; 373 dev_t dev; 374 int16_t devmap[OSS_SOUND_MIXER_NRDEVICES], 375 rdevmap[NETBSD_MAXDEVS]; 376 u_long devmask, recmask, stereomask; 377 u_long caps, source; 378 }; 379 380 /* 381 * Collect the audio device information to allow faster 382 * emulation of the Linux mixer ioctls. Cache the information 383 * to eliminate the overhead of repeating all the ioctls needed 384 * to collect the information. 385 */ 386 static struct audiodevinfo * 387 getdevinfo(fp, p) 388 struct file *fp; 389 struct proc *p; 390 { 391 mixer_devinfo_t mi; 392 int i; 393 static struct { 394 char *name; 395 int code; 396 } *dp, devs[] = { 397 { AudioNmicrophone, OSS_SOUND_MIXER_MIC }, 398 { AudioNline, OSS_SOUND_MIXER_LINE }, 399 { AudioNcd, OSS_SOUND_MIXER_CD }, 400 { AudioNdac, OSS_SOUND_MIXER_PCM }, 401 { AudioNrecord, OSS_SOUND_MIXER_IMIX }, 402 { AudioNvolume, OSS_SOUND_MIXER_VOLUME }, 403 { AudioNtreble, OSS_SOUND_MIXER_TREBLE }, 404 { AudioNbass, OSS_SOUND_MIXER_BASS }, 405 { AudioNspeaker, OSS_SOUND_MIXER_SPEAKER }, 406 /* { AudioNheadphone, ?? },*/ 407 { AudioNoutput, OSS_SOUND_MIXER_OGAIN }, 408 { AudioNinput, OSS_SOUND_MIXER_IGAIN }, 409 { AudioNmaster, OSS_SOUND_MIXER_SPEAKER }, 410 /* { AudioNstereo, ?? },*/ 411 /* { AudioNmono, ?? },*/ 412 { AudioNfmsynth, OSS_SOUND_MIXER_SYNTH }, 413 /* { AudioNwave, OSS_SOUND_MIXER_PCM },*/ 414 { AudioNmidi, OSS_SOUND_MIXER_SYNTH }, 415 /* { AudioNmixerout, ?? },*/ 416 { 0, -1 } 417 }; 418 int (*ioctlf) __P((struct file *, u_long, caddr_t, struct proc *)) = 419 fp->f_ops->fo_ioctl; 420 struct vnode *vp; 421 struct vattr va; 422 static struct audiodevinfo devcache = { 0 }; 423 struct audiodevinfo *di = &devcache; 424 425 /* Figure out what device it is so we can check if the 426 * cached data is valid. 427 */ 428 vp = (struct vnode *)fp->f_data; 429 if (vp->v_type != VCHR) 430 return 0; 431 if (VOP_GETATTR(vp, &va, p->p_ucred, p)) 432 return 0; 433 if (di->done && di->dev == va.va_rdev) 434 return di; 435 436 di->done = 1; 437 di->dev = va.va_rdev; 438 di->devmask = 0; 439 di->recmask = 0; 440 di->stereomask = 0; 441 di->source = -1; 442 di->caps = 0; 443 for(i = 0; i < OSS_SOUND_MIXER_NRDEVICES; i++) 444 di->devmap[i] = -1; 445 for(i = 0; i < NETBSD_MAXDEVS; i++) 446 di->rdevmap[i] = -1; 447 for(i = 0; i < NETBSD_MAXDEVS; i++) { 448 mi.index = i; 449 if (ioctlf(fp, AUDIO_MIXER_DEVINFO, (caddr_t)&mi, p) < 0) 450 break; 451 switch(mi.type) { 452 case AUDIO_MIXER_VALUE: 453 for(dp = devs; dp->name; dp++) 454 if (strcmp(dp->name, mi.label.name) == 0) 455 break; 456 if (dp->code >= 0) { 457 di->devmap[dp->code] = i; 458 di->rdevmap[i] = dp->code; 459 di->devmask |= 1 << dp->code; 460 if (mi.un.v.num_channels == 2) 461 di->stereomask |= 1 << dp->code; 462 } 463 break; 464 case AUDIO_MIXER_ENUM: 465 if (strcmp(mi.label.name, AudioNsource) == 0) { 466 int j; 467 di->source = i; 468 for(j = 0; j < mi.un.e.num_mem; j++) 469 di->recmask |= 1 << di->rdevmap[mi.un.e.member[j].ord]; 470 di->caps = OSS_SOUND_CAP_EXCL_INPUT; 471 } 472 break; 473 case AUDIO_MIXER_SET: 474 if (strcmp(mi.label.name, AudioNsource) == 0) { 475 int j; 476 di->source = i; 477 for(j = 0; j < mi.un.s.num_mem; j++) { 478 int k, mask = mi.un.s.member[j].mask; 479 if (mask) { 480 for(k = 0; !(mask & 1); mask >>= 1, k++) 481 ; 482 di->recmask |= 1 << di->rdevmap[k]; 483 } 484 } 485 } 486 break; 487 } 488 } 489 return di; 490 } 491 492 int 493 oss_ioctl_mixer(p, uap, retval) 494 register struct proc *p; 495 register struct oss_sys_ioctl_args /* { 496 syscallarg(int) fd; 497 syscallarg(u_long) com; 498 syscallarg(caddr_t) data; 499 } */ *uap; 500 register_t *retval; 501 { 502 struct file *fp; 503 struct filedesc *fdp; 504 u_long com; 505 struct audiodevinfo *di; 506 mixer_ctrl_t mc; 507 int idat; 508 int i; 509 int error; 510 int l, r, n; 511 int (*ioctlf) __P((struct file *, u_long, caddr_t, struct proc *)); 512 513 fdp = p->p_fd; 514 if ((u_int)SCARG(uap, fd) >= fdp->fd_nfiles || 515 (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) 516 return (EBADF); 517 518 if ((fp->f_flag & (FREAD | FWRITE)) == 0) 519 return (EBADF); 520 521 com = SCARG(uap, com); 522 retval[0] = 0; 523 524 di = getdevinfo(fp, p); 525 if (di == 0) 526 return EINVAL; 527 528 ioctlf = fp->f_ops->fo_ioctl; 529 switch (com) { 530 case OSS_SOUND_MIXER_READ_RECSRC: 531 if (di->source == -1) 532 return EINVAL; 533 mc.dev = di->source; 534 if (di->caps & OSS_SOUND_CAP_EXCL_INPUT) { 535 mc.type = AUDIO_MIXER_ENUM; 536 error = ioctlf(fp, AUDIO_MIXER_READ, (caddr_t)&mc, p); 537 if (error) 538 return error; 539 idat = 1 << di->rdevmap[mc.un.ord]; 540 } else { 541 int k; 542 unsigned int mask; 543 mc.type = AUDIO_MIXER_SET; 544 error = ioctlf(fp, AUDIO_MIXER_READ, (caddr_t)&mc, p); 545 if (error) 546 return error; 547 idat = 0; 548 for(mask = mc.un.mask, k = 0; mask; mask >>= 1, k++) 549 if (mask & 1) 550 idat |= 1 << di->rdevmap[k]; 551 } 552 break; 553 case OSS_SOUND_MIXER_READ_DEVMASK: 554 idat = di->devmask; 555 break; 556 case OSS_SOUND_MIXER_READ_RECMASK: 557 idat = di->recmask; 558 break; 559 case OSS_SOUND_MIXER_READ_STEREODEVS: 560 idat = di->stereomask; 561 break; 562 case OSS_SOUND_MIXER_READ_CAPS: 563 idat = di->caps; 564 break; 565 case OSS_SOUND_MIXER_WRITE_RECSRC: 566 if (di->source == -1) 567 return EINVAL; 568 mc.dev = di->source; 569 error = copyin(SCARG(uap, data), &idat, sizeof idat); 570 if (error) 571 return error; 572 if (di->caps & OSS_SOUND_CAP_EXCL_INPUT) { 573 mc.type = AUDIO_MIXER_ENUM; 574 for(i = 0; i < OSS_SOUND_MIXER_NRDEVICES; i++) 575 if (idat & (1 << i)) 576 break; 577 if (i >= OSS_SOUND_MIXER_NRDEVICES || 578 di->devmap[i] == -1) 579 return EINVAL; 580 mc.un.ord = di->devmap[i]; 581 } else { 582 mc.type = AUDIO_MIXER_SET; 583 mc.un.mask = 0; 584 for(i = 0; i < OSS_SOUND_MIXER_NRDEVICES; i++) { 585 if (idat & (1 << i)) { 586 if (di->devmap[i] == -1) 587 return EINVAL; 588 mc.un.mask |= 1 << di->devmap[i]; 589 } 590 } 591 } 592 return ioctlf(fp, AUDIO_MIXER_WRITE, (caddr_t)&mc, p); 593 default: 594 if (OSS_MIXER_READ(OSS_SOUND_MIXER_FIRST) <= com && 595 com < OSS_MIXER_READ(OSS_SOUND_MIXER_NRDEVICES)) { 596 n = OSS_GET_DEV(com); 597 if (di->devmap[n] == -1) 598 return EINVAL; 599 mc.dev = di->devmap[n]; 600 mc.type = AUDIO_MIXER_VALUE; 601 doread: 602 mc.un.value.num_channels = di->stereomask & (1<<n) ? 2 : 1; 603 error = ioctlf(fp, AUDIO_MIXER_READ, (caddr_t)&mc, p); 604 if (error) 605 return error; 606 if (mc.type != AUDIO_MIXER_VALUE) 607 return EINVAL; 608 if (mc.un.value.num_channels != 2) { 609 l = r = mc.un.value.level[AUDIO_MIXER_LEVEL_MONO]; 610 } else { 611 l = mc.un.value.level[AUDIO_MIXER_LEVEL_LEFT]; 612 r = mc.un.value.level[AUDIO_MIXER_LEVEL_RIGHT]; 613 } 614 l = l * 100 / 255; 615 r = r * 100 / 255; 616 idat = l | (r << 8); 617 break; 618 } else if (OSS_MIXER_WRITE(OSS_SOUND_MIXER_FIRST) <= com && 619 com < OSS_MIXER_WRITE(OSS_SOUND_MIXER_NRDEVICES)) { 620 n = OSS_GET_DEV(com); 621 if (di->devmap[n] == -1) 622 return EINVAL; 623 error = copyin(SCARG(uap, data), &idat, sizeof idat); 624 if (error) 625 return error; 626 l = (idat & 0xff) * 255 / 100; 627 r = (idat >> 8) * 255 / 100; 628 mc.dev = di->devmap[n]; 629 mc.type = AUDIO_MIXER_VALUE; 630 if (di->stereomask & (1<<n)) { 631 mc.un.value.num_channels = 2; 632 mc.un.value.level[AUDIO_MIXER_LEVEL_LEFT] = l; 633 mc.un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = r; 634 } else { 635 mc.un.value.num_channels = 1; 636 mc.un.value.level[AUDIO_MIXER_LEVEL_MONO] = (l+r)/2; 637 } 638 error = ioctlf(fp, AUDIO_MIXER_WRITE, (caddr_t)&mc, p); 639 if (error) 640 return error; 641 goto doread; 642 } else 643 return EINVAL; 644 } 645 return copyout(&idat, SCARG(uap, data), sizeof idat); 646 } 647 648 /* XXX hook for sequencer emulation */ 649 int 650 oss_ioctl_sequencer(p, uap, retval) 651 register struct proc *p; 652 register struct oss_sys_ioctl_args /* { 653 syscallarg(int) fd; 654 syscallarg(u_long) com; 655 syscallarg(caddr_t) data; 656 } */ *uap; 657 register_t *retval; 658 { 659 register struct file *fp; 660 register struct filedesc *fdp; 661 #if 0 662 u_long com; 663 int idat; 664 int error; 665 #endif 666 667 fdp = p->p_fd; 668 if ((u_int)SCARG(uap, fd) >= fdp->fd_nfiles || 669 (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) 670 return (EBADF); 671 672 if ((fp->f_flag & (FREAD | FWRITE)) == 0) 673 return (EBADF); 674 675 #if 0 676 com = SCARG(uap, com); 677 #endif 678 retval[0] = 0; 679 680 return EINVAL; 681 } 682
Indexes created Mon Sep 22 21:09:42 GMT 2025