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