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