ossaudio.c revision 1.20
1 /* $NetBSD: ossaudio.c,v 1.20 1997/08/24 23:31: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 #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 if (error) 366 return error; 367 break; 368 case OSS_SNDCTL_DSP_GETCAPS: 369 error = ioctlf(fp, AUDIO_GETPROPS, (caddr_t)&idata, p); 370 if (error) 371 return error; 372 idat = OSS_DSP_CAP_TRIGGER; /* pretend we have trigger */ 373 if (idata & AUDIO_PROP_FULLDUPLEX) 374 idat |= OSS_DSP_CAP_DUPLEX; 375 if (idata & AUDIO_PROP_MMAP) 376 idat |= OSS_DSP_CAP_MMAP; 377 DPRINTF(("oss_sys_ioctl: SNDCTL_DSP_GETCAPS = %x\n", idat)); 378 error = copyout(&idat, SCARG(uap, data), sizeof idat); 379 if (error) 380 return error; 381 break; 382 #if 0 383 case OSS_SNDCTL_DSP_GETTRIGGER: 384 error = ioctlf(fp, AUDIO_GETINFO, (caddr_t)&tmpinfo, p); 385 if (error) 386 return error; 387 idat = (tmpinfo.play.pause ? 0 : OSS_PCM_ENABLE_OUTPUT) | 388 (tmpinfo.record.pause ? 0 : OSS_PCM_ENABLE_INPUT); 389 error = copyout(&idat, SCARG(uap, data), sizeof idat); 390 if (error) 391 return error; 392 break; 393 case OSS_SNDCTL_DSP_SETTRIGGER: 394 AUDIO_INITINFO(&tmpinfo); 395 error = copyin(SCARG(uap, data), &idat, sizeof idat); 396 if (error) 397 return error; 398 tmpinfo.play.pause = (idat & OSS_PCM_ENABLE_OUTPUT) == 0; 399 tmpinfo.record.pause = (idat & OSS_PCM_ENABLE_INPUT) == 0; 400 (void) ioctlf(fp, AUDIO_SETINFO, (caddr_t)&tmpinfo, p); 401 error = copyout(&idat, SCARG(uap, data), sizeof idat); 402 if (error) 403 return error; 404 break; 405 #else 406 case OSS_SNDCTL_DSP_GETTRIGGER: 407 case OSS_SNDCTL_DSP_SETTRIGGER: 408 /* XXX Do nothing for now. */ 409 idat = OSS_PCM_ENABLE_OUTPUT; 410 return copyout(&idat, SCARG(uap, data), sizeof idat); 411 #endif 412 case OSS_SNDCTL_DSP_GETIPTR: 413 error = ioctlf(fp, AUDIO_GETIOFFS, (caddr_t)&tmpoffs, p); 414 if (error) 415 return error; 416 cntinfo.bytes = tmpoffs.samples; 417 cntinfo.blocks = tmpoffs.deltablks; 418 cntinfo.ptr = tmpoffs.offset; 419 error = copyout(&cntinfo, SCARG(uap, data), sizeof cntinfo); 420 if (error) 421 return error; 422 break; 423 case OSS_SNDCTL_DSP_GETOPTR: 424 error = ioctlf(fp, AUDIO_GETOOFFS, (caddr_t)&tmpoffs, p); 425 if (error) 426 return error; 427 cntinfo.bytes = tmpoffs.samples; 428 cntinfo.blocks = tmpoffs.deltablks; 429 cntinfo.ptr = tmpoffs.offset; 430 error = copyout(&cntinfo, SCARG(uap, data), sizeof cntinfo); 431 if (error) 432 return error; 433 break; 434 case OSS_SNDCTL_DSP_MAPINBUF: 435 case OSS_SNDCTL_DSP_MAPOUTBUF: 436 case OSS_SNDCTL_DSP_SETSYNCRO: 437 case OSS_SNDCTL_DSP_SETDUPLEX: 438 case OSS_SNDCTL_DSP_PROFILE: 439 return EINVAL; /* XXX unimplemented */ 440 default: 441 return EINVAL; 442 } 443 444 return 0; 445 } 446 447 /* If the NetBSD mixer device should have more than 32 devices 448 * some will not be available to Linux */ 449 #define NETBSD_MAXDEVS 64 450 struct audiodevinfo { 451 int done; 452 dev_t dev; 453 int16_t devmap[OSS_SOUND_MIXER_NRDEVICES], 454 rdevmap[NETBSD_MAXDEVS]; 455 u_long devmask, recmask, stereomask; 456 u_long caps, source; 457 }; 458 459 /* 460 * Collect the audio device information to allow faster 461 * emulation of the Linux mixer ioctls. Cache the information 462 * to eliminate the overhead of repeating all the ioctls needed 463 * to collect the information. 464 */ 465 static struct audiodevinfo * 466 getdevinfo(fp, p) 467 struct file *fp; 468 struct proc *p; 469 { 470 mixer_devinfo_t mi; 471 int i; 472 static struct { 473 char *name; 474 int code; 475 } *dp, devs[] = { 476 { AudioNmicrophone, OSS_SOUND_MIXER_MIC }, 477 { AudioNline, OSS_SOUND_MIXER_LINE }, 478 { AudioNcd, OSS_SOUND_MIXER_CD }, 479 { AudioNdac, OSS_SOUND_MIXER_PCM }, 480 { AudioNrecord, OSS_SOUND_MIXER_IMIX }, 481 { AudioNmaster, OSS_SOUND_MIXER_VOLUME }, 482 { AudioNtreble, OSS_SOUND_MIXER_TREBLE }, 483 { AudioNbass, OSS_SOUND_MIXER_BASS }, 484 { AudioNspeaker, OSS_SOUND_MIXER_SPEAKER }, 485 /* { AudioNheadphone, ?? },*/ 486 { AudioNoutput, OSS_SOUND_MIXER_OGAIN }, 487 { AudioNinput, OSS_SOUND_MIXER_IGAIN }, 488 /* { AudioNmaster, OSS_SOUND_MIXER_SPEAKER },*/ 489 /* { AudioNstereo, ?? },*/ 490 /* { AudioNmono, ?? },*/ 491 { AudioNfmsynth, OSS_SOUND_MIXER_SYNTH }, 492 /* { AudioNwave, OSS_SOUND_MIXER_PCM },*/ 493 { AudioNmidi, OSS_SOUND_MIXER_SYNTH }, 494 /* { AudioNmixerout, ?? },*/ 495 { 0, -1 } 496 }; 497 int (*ioctlf) __P((struct file *, u_long, caddr_t, struct proc *)) = 498 fp->f_ops->fo_ioctl; 499 struct vnode *vp; 500 struct vattr va; 501 static struct audiodevinfo devcache = { 0 }; 502 struct audiodevinfo *di = &devcache; 503 504 /* Figure out what device it is so we can check if the 505 * cached data is valid. 506 */ 507 vp = (struct vnode *)fp->f_data; 508 if (vp->v_type != VCHR) 509 return 0; 510 if (VOP_GETATTR(vp, &va, p->p_ucred, p)) 511 return 0; 512 if (di->done && di->dev == va.va_rdev) 513 return di; 514 515 di->done = 1; 516 di->dev = va.va_rdev; 517 di->devmask = 0; 518 di->recmask = 0; 519 di->stereomask = 0; 520 di->source = -1; 521 di->caps = 0; 522 for(i = 0; i < OSS_SOUND_MIXER_NRDEVICES; i++) 523 di->devmap[i] = -1; 524 for(i = 0; i < NETBSD_MAXDEVS; i++) 525 di->rdevmap[i] = -1; 526 for(i = 0; i < NETBSD_MAXDEVS; i++) { 527 mi.index = i; 528 if (ioctlf(fp, AUDIO_MIXER_DEVINFO, (caddr_t)&mi, p) < 0) 529 break; 530 switch(mi.type) { 531 case AUDIO_MIXER_VALUE: 532 for(dp = devs; dp->name; dp++) 533 if (strcmp(dp->name, mi.label.name) == 0) 534 break; 535 if (dp->code >= 0) { 536 di->devmap[dp->code] = i; 537 di->rdevmap[i] = dp->code; 538 di->devmask |= 1 << dp->code; 539 if (mi.un.v.num_channels == 2) 540 di->stereomask |= 1 << dp->code; 541 } 542 break; 543 case AUDIO_MIXER_ENUM: 544 if (strcmp(mi.label.name, AudioNsource) == 0) { 545 int j; 546 di->source = i; 547 for(j = 0; j < mi.un.e.num_mem; j++) 548 di->recmask |= 1 << di->rdevmap[mi.un.e.member[j].ord]; 549 di->caps = OSS_SOUND_CAP_EXCL_INPUT; 550 } 551 break; 552 case AUDIO_MIXER_SET: 553 if (strcmp(mi.label.name, AudioNsource) == 0) { 554 int j; 555 di->source = i; 556 for(j = 0; j < mi.un.s.num_mem; j++) { 557 int k, mask = mi.un.s.member[j].mask; 558 if (mask) { 559 for(k = 0; !(mask & 1); mask >>= 1, k++) 560 ; 561 di->recmask |= 1 << di->rdevmap[k]; 562 } 563 } 564 } 565 break; 566 } 567 } 568 return di; 569 } 570 571 int 572 oss_ioctl_mixer(p, uap, retval) 573 register struct proc *p; 574 register struct oss_sys_ioctl_args /* { 575 syscallarg(int) fd; 576 syscallarg(u_long) com; 577 syscallarg(caddr_t) data; 578 } */ *uap; 579 register_t *retval; 580 { 581 struct file *fp; 582 struct filedesc *fdp; 583 u_long com; 584 struct audiodevinfo *di; 585 mixer_ctrl_t mc; 586 int idat; 587 int i; 588 int error; 589 int l, r, n; 590 int (*ioctlf) __P((struct file *, u_long, caddr_t, struct proc *)); 591 592 fdp = p->p_fd; 593 if ((u_int)SCARG(uap, fd) >= fdp->fd_nfiles || 594 (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) 595 return (EBADF); 596 597 if ((fp->f_flag & (FREAD | FWRITE)) == 0) 598 return (EBADF); 599 600 com = SCARG(uap, com); 601 retval[0] = 0; 602 603 di = getdevinfo(fp, p); 604 if (di == 0) 605 return EINVAL; 606 607 ioctlf = fp->f_ops->fo_ioctl; 608 switch (com) { 609 case OSS_SOUND_MIXER_READ_RECSRC: 610 if (di->source == -1) 611 return EINVAL; 612 mc.dev = di->source; 613 if (di->caps & OSS_SOUND_CAP_EXCL_INPUT) { 614 mc.type = AUDIO_MIXER_ENUM; 615 error = ioctlf(fp, AUDIO_MIXER_READ, (caddr_t)&mc, p); 616 if (error) 617 return error; 618 idat = 1 << di->rdevmap[mc.un.ord]; 619 } else { 620 int k; 621 unsigned int mask; 622 mc.type = AUDIO_MIXER_SET; 623 error = ioctlf(fp, AUDIO_MIXER_READ, (caddr_t)&mc, p); 624 if (error) 625 return error; 626 idat = 0; 627 for(mask = mc.un.mask, k = 0; mask; mask >>= 1, k++) 628 if (mask & 1) 629 idat |= 1 << di->rdevmap[k]; 630 } 631 break; 632 case OSS_SOUND_MIXER_READ_DEVMASK: 633 idat = di->devmask; 634 break; 635 case OSS_SOUND_MIXER_READ_RECMASK: 636 idat = di->recmask; 637 break; 638 case OSS_SOUND_MIXER_READ_STEREODEVS: 639 idat = di->stereomask; 640 break; 641 case OSS_SOUND_MIXER_READ_CAPS: 642 idat = di->caps; 643 break; 644 case OSS_SOUND_MIXER_WRITE_RECSRC: 645 case OSS_SOUND_MIXER_WRITE_R_RECSRC: 646 if (di->source == -1) 647 return EINVAL; 648 mc.dev = di->source; 649 error = copyin(SCARG(uap, data), &idat, sizeof idat); 650 if (error) 651 return error; 652 if (di->caps & OSS_SOUND_CAP_EXCL_INPUT) { 653 mc.type = AUDIO_MIXER_ENUM; 654 for(i = 0; i < OSS_SOUND_MIXER_NRDEVICES; i++) 655 if (idat & (1 << i)) 656 break; 657 if (i >= OSS_SOUND_MIXER_NRDEVICES || 658 di->devmap[i] == -1) 659 return EINVAL; 660 mc.un.ord = di->devmap[i]; 661 } else { 662 mc.type = AUDIO_MIXER_SET; 663 mc.un.mask = 0; 664 for(i = 0; i < OSS_SOUND_MIXER_NRDEVICES; i++) { 665 if (idat & (1 << i)) { 666 if (di->devmap[i] == -1) 667 return EINVAL; 668 mc.un.mask |= 1 << di->devmap[i]; 669 } 670 } 671 } 672 return ioctlf(fp, AUDIO_MIXER_WRITE, (caddr_t)&mc, p); 673 default: 674 if (OSS_MIXER_READ(OSS_SOUND_MIXER_FIRST) <= com && 675 com < OSS_MIXER_READ(OSS_SOUND_MIXER_NRDEVICES)) { 676 n = OSS_GET_DEV(com); 677 if (di->devmap[n] == -1) 678 return EINVAL; 679 doread: 680 mc.dev = di->devmap[n]; 681 mc.type = AUDIO_MIXER_VALUE; 682 mc.un.value.num_channels = di->stereomask & (1<<n) ? 2 : 1; 683 error = ioctlf(fp, AUDIO_MIXER_READ, (caddr_t)&mc, p); 684 if (error) 685 return error; 686 if (mc.un.value.num_channels != 2) { 687 l = r = mc.un.value.level[AUDIO_MIXER_LEVEL_MONO]; 688 } else { 689 l = mc.un.value.level[AUDIO_MIXER_LEVEL_LEFT]; 690 r = mc.un.value.level[AUDIO_MIXER_LEVEL_RIGHT]; 691 } 692 idat = TO_OSSVOL(l) | (TO_OSSVOL(r) << 8); 693 DPRINTF(("OSS_MIXER_READ n=%d (dev=%d) l=%d, r=%d, idat=%04x\n", 694 n, di->devmap[n], l, r, idat)); 695 break; 696 } else if ((OSS_MIXER_WRITE_R(OSS_SOUND_MIXER_FIRST) <= com && 697 com < OSS_MIXER_WRITE_R(OSS_SOUND_MIXER_NRDEVICES)) || 698 (OSS_MIXER_WRITE(OSS_SOUND_MIXER_FIRST) <= com && 699 com < OSS_MIXER_WRITE(OSS_SOUND_MIXER_NRDEVICES))) { 700 n = OSS_GET_DEV(com); 701 if (di->devmap[n] == -1) 702 return EINVAL; 703 error = copyin(SCARG(uap, data), &idat, sizeof idat); 704 if (error) 705 return error; 706 l = FROM_OSSVOL( idat & 0xff); 707 r = FROM_OSSVOL((idat >> 8) & 0xff); 708 mc.dev = di->devmap[n]; 709 mc.type = AUDIO_MIXER_VALUE; 710 if (di->stereomask & (1<<n)) { 711 mc.un.value.num_channels = 2; 712 mc.un.value.level[AUDIO_MIXER_LEVEL_LEFT] = l; 713 mc.un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = r; 714 } else { 715 mc.un.value.num_channels = 1; 716 mc.un.value.level[AUDIO_MIXER_LEVEL_MONO] = (l+r)/2; 717 } 718 DPRINTF(("OSS_MIXER_WRITE n=%d (dev=%d) l=%d, r=%d, idat=%04x\n", 719 n, di->devmap[n], l, r, idat)); 720 error = ioctlf(fp, AUDIO_MIXER_WRITE, (caddr_t)&mc, p); 721 if (error) 722 return error; 723 if (OSS_MIXER_WRITE(OSS_SOUND_MIXER_FIRST) <= com && 724 com < OSS_MIXER_WRITE(OSS_SOUND_MIXER_NRDEVICES)) 725 return 0; 726 goto doread; 727 } else { 728 #ifdef AUDIO_DEBUG 729 printf("oss_audio: unknown mixer ioctl %04lx\n", com); 730 #endif 731 return EINVAL; 732 } 733 } 734 return copyout(&idat, SCARG(uap, data), sizeof idat); 735 } 736 737 /* XXX hook for sequencer emulation */ 738 int 739 oss_ioctl_sequencer(p, uap, retval) 740 register struct proc *p; 741 register struct oss_sys_ioctl_args /* { 742 syscallarg(int) fd; 743 syscallarg(u_long) com; 744 syscallarg(caddr_t) data; 745 } */ *uap; 746 register_t *retval; 747 { 748 register struct file *fp; 749 register struct filedesc *fdp; 750 #if 0 751 u_long com; 752 int idat; 753 int error; 754 #endif 755 756 fdp = p->p_fd; 757 if ((u_int)SCARG(uap, fd) >= fdp->fd_nfiles || 758 (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) 759 return (EBADF); 760 761 if ((fp->f_flag & (FREAD | FWRITE)) == 0) 762 return (EBADF); 763 764 #if 0 765 com = SCARG(uap, com); 766 #endif 767 retval[0] = 0; 768 769 return EINVAL; 770 } 771 772 /* 773 * Check that the blocksize is a power of 2 as OSS wants. 774 * If not, set it to be. 775 */ 776 static void setblocksize(fp, info, p) 777 struct file *fp; 778 struct audio_info *info; 779 struct proc *p; 780 { 781 struct audio_info set; 782 int s; 783 784 if (info->blocksize & (info->blocksize-1)) { 785 for(s = 32; s < info->blocksize; s <<= 1) 786 ; 787 AUDIO_INITINFO(&set); 788 set.blocksize = s; 789 fp->f_ops->fo_ioctl(fp, AUDIO_SETINFO, (caddr_t)&set, p); 790 fp->f_ops->fo_ioctl(fp, AUDIO_GETINFO, (caddr_t)info, p); 791 } 792 } 793
Indexes created Tue Sep 23 07:09:52 GMT 2025