source: sbliveos2/trunk/drv16/ioctl.cpp@ 176

Last change on this file since 176 was 172, checked in by sandervl, 24 years ago

setvolume change
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 26.1 KB
Line 
1/* $Id: ioctl.cpp 172 2001-03-25 22:07:21Z sandervl $ */
2
3/* SCCSID = %W% %E% */
4/****************************************************************************
5 * *
6 * Copyright (c) IBM Corporation 1994 - 1997. *
7 * *
8 * The following IBM OS/2 source code is provided to you solely for the *
9 * the purpose of assisting you in your development of OS/2 device drivers. *
10 * You may use this code in accordance with the IBM License Agreement *
11 * provided in the IBM Device Driver Source Kit for OS/2. *
12 * *
13 ****************************************************************************/
14/**@internal %W%
15 * @notes
16 * the functions that implement all the IOCTLs (command 10x) received by
17 * the device driver via the strategy entry.
18 * @version %I%
19 * @context Unless otherwise noted, all interfaces are Ring-0, 16-bit,
20 * <stack context>.
21 * @history
22 *
23 */
24#define INCL_NOPMAPI
25#include <os2.h>
26#include <os2me.h>
27#include <audio.h>
28
29#include "strategy.h"
30#include "audiohw.hpp"
31#include "mpu401.hpp"
32#include "wavehw.hpp"
33#include "dwavestrm.hpp"
34#include "midistrm.hpp"
35
36#include <include.h>
37#include <sbvsd.h>
38#include <dbgos2.h>
39#include <devhelp.h>
40#include <ossidc.h>
41#include <ioctl90.h>
42#include <parse.h>
43#include "ioctl.h"
44
45#include <daudio.h>
46
47//Map of possible 256 supported ioctls (IOCTl 90 mixer api)
48char SBLiveIOCTLMap[256] = {0};
49MIXSTRUCT MixerSettings[16] = {0};
50
51//override flags for rec src & gain mixer commands
52BOOL fRecSrcIOCTL90 = FALSE;
53BOOL fRecGainIOCTL90 = FALSE;
54
55/**@internal
56 * @param PREQPACKET pointer to the strategy request packet
57 * @return None But the Status in the request packet is updated on error
58 * @notes
59 * The Audio Init Ioctl only 2 things happen in here :
60 * 1. We call CheckForStream to make sure there is not already a stream
61 * registered with the same sysfilenumber. If we get a good rc from that
62 * 2: we look at sMode in the MCI_AUDIO_INIT to determine the type of stream
63 * to init and call the approprate stream constructor.
64 *
65 */
66void IoctlAudioInit(PREQPACKET prp, USHORT LDev)
67{
68 LPMCI_AUDIO_INIT p = (LPMCI_AUDIO_INIT)prp->s.ioctl.pvData;
69 PAUDIOHW pHWobj;
70 PSTREAM pstream;
71 ULONG HardwareType;
72
73 // if this is an IDLE or De-Init request
74 // fetch the stream object based on the sysfilenum and turn on the
75 // stream idle bit in the stream state then write the sysfilenum
76 // into the request packet, set rc = 0 and return
77 if (p->sMode == IDLE) {
78 pstream = FindStream_fromFile((ULONG) prp->s.ioctl.usSysFileNum);
79 if (pstream)
80 pstream->ulStreamState |= STREAM_IDLE;
81 p->pvReserved = (VOID FAR *) (ULONG)prp->s.ioctl.usSysFileNum;
82 p->sReturnCode = 0;
83 return;
84 }
85 // call FindStream_fromFile to see if there is already a stream
86 // for this sysfilenum. if there is then see if the idle bit is on,
87 // if the idle bit is on, reset it, then write the sysfilenum
88 // into the request packet, set rc = 0 and return
89 // MMPM sends idle down to a stream that is "losing" the hardware but
90 // should not go away. It usually is associated with an app losing
91 // focus. If the idle bit is not the stream is either not registered or
92 // is being "re-initted" in another mode or with different file
93 // attributes. "Re-initting" a stream is a total hack on the part
94 // of MMPM they should de-register the stream and then init a new
95 // stream but they don't . If anyone ever writes a VSD that behaves
96 // "correctly" then this code can be deleted.
97 // Either way delete the stream and build a new one with
98 // this request packet.
99 pstream = FindStream_fromFile((ULONG) prp->s.ioctl.usSysFileNum);
100 if (pstream) {
101 if (pstream->ulStreamState & STREAM_IDLE) {
102 pstream->ulStreamState &= STREAM_NOT_IDLE;
103 p->pvReserved = (VOID FAR *) (ULONG)prp->s.ioctl.usSysFileNum;
104 p->sReturnCode = 0;
105 return;
106 }
107 else {
108 delete pstream;
109 }
110 }
111
112 // get the hardware type
113 // return with bad status if the harware type is invalid/unsupported
114 HardwareType = GetHardwareType(p->sMode, (USHORT)p->ulOperation, LDev);
115 if (HardwareType == AUDIOHW_INVALID_DEVICE) {
116 p->sReturnCode = INVALID_REQUEST;
117 prp->usStatus |= RPERR;
118 return;
119 }
120 // make sure we have a Hardware object that can handle this
121 // data type and operation..
122 pHWobj = GetHardwareDevice(HardwareType);
123 if (pHWobj == NULL) {
124 p->sReturnCode = INVALID_REQUEST;
125 prp->usStatus |= RPERR;
126 return;
127 }
128
129 p->ulFlags = 0; /* Zero the Flags */
130 switch (HardwareType) {
131 case AUDIOHW_WAVE_PLAY:
132 case AUDIOHW_WAVE_CAPTURE:
133 pstream = new WAVESTREAM(HardwareType,p,prp->s.ioctl.usSysFileNum);
134 break;
135#if 0
136 case AUDIOHW_MPU401_PLAY:
137 pstream = new MIDISTREAM(HardwareType, prp->s.ioctl.usSysFileNum);
138 break;
139#endif
140 default:
141 p->sReturnCode = INVALID_REQUEST;
142 prp->usStatus |= RPERR;
143 return;
144 } /* endswitch */
145
146 p->ulFlags |= VOLUME; /* volume control is supported */
147 p->ulFlags |= INPUT; /* Input select is supported */
148 p->ulFlags |= OUTPUT; /* Output select is supported */
149 p->ulFlags |= MONITOR; /* Record Monitor is supported */
150 p->sDeviceID = SB_LIVE; /* Reported in VSD dll */
151 pstream->ulSysFileNum = prp->s.ioctl.usSysFileNum;
152 p->pvReserved = (VOID FAR *) (ULONG) prp->s.ioctl.usSysFileNum;
153 p->sReturnCode = 0;
154 dprintf(("IoctlAudioInit: file nr: %lx", pstream->ulSysFileNum));
155}
156
157
158/**@internal
159 * @param PREQPACKET pointer to the strategy request packet
160 * @return None But the Status in the request packet is updated on error
161 * @notes
162 */
163void IoctlAudioCapability(PREQPACKET prp, USHORT LDev)
164{
165 PAUDIOHW pHWobj;
166 PAUDIO_CAPS p = (PAUDIO_CAPS)prp->s.ioctl.pvData;
167 ULONG ulDevicetype;
168
169 // get the hardware device type based on the datatype and operation
170 ulDevicetype = GetHardwareType((USHORT)p->ulDataType,(USHORT)p->ulOperation,LDev);
171
172 // Tell the caller we support this IOCTL
173 p->ulCapability = SUPPORT_CAP;
174
175 // get the pointer to the hardware object
176 // call DevCaps
177 // bailout if no hardware object is returned..
178 pHWobj = GetHardwareDevice(ulDevicetype);
179 if (pHWobj) {
180 pHWobj->DevCaps(p);
181 if (p->ulSupport != SUPPORT_SUCCESS) {
182 prp->usStatus |= RPERR;
183 }
184 }
185 else {
186 p->ulSupport = UNSUPPORTED_DATATYPE;
187 prp->usStatus |= RPERR;
188 }
189}
190
191/**@internal IoctlAudioControl
192 * @param PREQPACKET pointer to the strategy request packet
193 * @return None But the Status in the request packet is updated on error
194 * @notes
195 * if it's AUDIO_CHANGE, just report success, otherwise report failure
196 * this is because we don't support volume, balance, multiple in/out devices,
197 * etc. Also, START, STOP, RESUME, and PAUSE are redundant, so we don't
198 * support those either.
199 */
200void IoctlAudioControl(PREQPACKET prp)
201{
202 LPMCI_AUDIO_CONTROL p = (LPMCI_AUDIO_CONTROL) prp->s.ioctl.pvData;
203 LPMCI_AUDIO_CHANGE pAudChange;
204 LPMCI_TRACK_INFO pMasterVol;
205 PSTREAM pStream;
206 ULONG volume;
207 ULONG addr;
208
209 if (p->usIOCtlRequest != AUDIO_CHANGE) {
210 p->sReturnCode = INVALID_REQUEST;
211 prp->usStatus |= RPERR | RPBADCMD;
212 return;
213 }
214 p->sReturnCode=0;
215
216 pAudChange = (LPMCI_AUDIO_CHANGE)p->pbRequestInfo;
217
218 //Test for MMPM/2 bug (structure crosses selector boundary)
219 addr = OFFSETOF(pAudChange);
220 addr += sizeof(MCI_AUDIO_CHANGE);
221 if(addr >= 0x10000UL) {
222 dprintf(("Invalid MCI_AUDIO_CHANGE pointer %lx!!", (ULONG)pAudChange));
223 p->sReturnCode = INVALID_REQUEST;
224 prp->usStatus |= RPERR | RPBADCMD;
225 return;
226 }
227 pMasterVol = (LPMCI_TRACK_INFO)pAudChange->pvDevInfo;
228
229 //Test for MMPM/2 bug (structure crosses selector boundary)
230 addr = OFFSETOF(pMasterVol);
231 addr += sizeof(MCI_TRACK_INFO);
232 if(addr >= 0x10000UL) {
233 dprintf(("Invalid MCI_TRACK_INFO pointer %lx!!", (ULONG)pMasterVol));
234 p->sReturnCode = INVALID_REQUEST;
235 prp->usStatus |= RPERR | RPBADCMD;
236 return;
237 }
238
239 pStream = FindStream_fromFile((ULONG) prp->s.ioctl.usSysFileNum);
240 if(pStream == NULL) {
241 dprintf(("IoctlAudioControl stream %lx not found!", (ULONG) prp->s.ioctl.usSysFileNum));
242 DebugInt3();
243 return;
244 }
245 if(pAudChange->lBalance != AUDIO_IGNORE)
246 pStream->SetBalance(pAudChange->lBalance);
247
248 if(pAudChange->lVolume != AUDIO_IGNORE) {
249 // stream volume ranges from 0 to 0x7FFFFFFF (linear)
250 volume = pAudChange->lVolume >> 16UL;
251 volume = (volume*100UL)/0x7FFFUL;
252 dprintf(("Set stream volume of %x to %d", prp->s.ioctl.usSysFileNum, volume));
253 pStream->SetVolume(MAKE_VOLUME_LR(volume, volume));
254 }
255
256 if(pMasterVol && pMasterVol->usMasterVolume != AUDIO_IGNORE) {
257 // master volume ranges from 0 to 0x7FFF (linear)
258 volume = pMasterVol->usMasterVolume;
259 volume = (volume*100UL)/0x7FFFUL;
260 if(volume > 100) {
261 volume = 100;
262 }
263 dprintf(("Set mastervolume to %d", volume));
264 pStream->SetMasterVol(MAKE_VOLUME_LR(volume, volume));
265 }
266 if(!fRecSrcIOCTL90) {
267 for(int i=0;i<8;i++)
268 {
269 switch(pAudChange->rInputList[0].ulDevType) {
270 case NULL_INPUT:
271 break; //continue;
272 case STEREO_LINE_INPUT:
273 case LEFT_LINE_INPUT:
274 case RIGHT_LINE_INPUT:
275 pStream->SetInputSrc(MIX_RECSRC_LINE);
276 break;
277
278 case MIC_INPUT:
279 case BOOSTED_MIC_INPUT:
280 pStream->SetInputSrc(MIX_RECSRC_MIC);
281 break;
282
283 case PHONE_LINE_INPUT:
284 case HANDSET_INPUT:
285 case SYNTH_INPUT:
286 case DIGITAL_PHONE_LINE_INPUT:
287 case DIGITAL_HANDSET_INPUT:
288 case MIDI_IN_PORT:
289// case LOOPBACK:
290 pStream->SetInputSrc(MIX_RECSRC_MIXER);
291 break;
292 }
293 }
294 }
295 if(!fRecGainIOCTL90 && pAudChange->lGain != AUDIO_IGNORE) {
296 // input ranges from 0 to 0x7FFFFFFF (linear)
297 volume = pAudChange->lGain >> 16UL;
298 volume = (volume*100UL)/0x7FFFUL;
299 if(volume > 100) {
300 volume = 100;
301 }
302 dprintf(("Set input gain of %x to %d", prp->s.ioctl.usSysFileNum, volume));
303 pStream->SetInputGain(MAKE_VOLUME_LR(volume, volume));
304 }
305}
306//******************************************************************************
307//******************************************************************************
308void IoctlDirectAudio(PREQPACKET prp)
309{
310 if(prp->s.ioctl.bCode == DAUDIO_OPEN)
311 {
312 LPMCI_AUDIO_INIT pInit = (LPMCI_AUDIO_INIT) prp->s.ioctl.pvData;
313 PAUDIOHW pHWobj;
314 MCI_AUDIO_CAPS audioCaps;
315 PDWAVESTREAM pStream;
316
317 if(DevHelp_VerifyAccess(SELECTOROF(pInit), sizeof(MCI_AUDIO_INIT), OFFSETOF(pInit), VERIFY_READWRITE))
318 {
319 dprintf(("Invalid MCI_AUDIO_INIT pointer %lx!!", (ULONG)pInit));
320 prp->usStatus |= RPERR | RPBADCMD;
321 return;
322 }
323
324 audioCaps.ulLength = sizeof(MCI_AUDIO_CAPS);
325 audioCaps.ulSamplingRate = pInit->lSRate;
326 audioCaps.ulChannels = pInit->sChannels;
327 audioCaps.ulBitsPerSample = pInit->lBitsPerSRate;
328 audioCaps.ulDataType = pInit->sMode;
329 audioCaps.ulOperation = OPERATION_PLAY;
330
331 // get the pointer to the hardware object
332 // call DevCaps
333 // bailout if no hardware object is returned..
334 pHWobj = GetHardwareDevice(AUDIOHW_WAVE_PLAY);
335 if (pHWobj)
336 {
337 pHWobj->DevCaps(&audioCaps);
338 if (audioCaps.ulSupport != SUPPORT_SUCCESS) {
339 dprintf(("IoctlDirectAudio: DevCaps failed"));
340 pInit->sReturnCode = INVALID_REQUEST;
341 prp->usStatus |= RPERR;
342 return;
343 }
344 }
345 else {
346 pInit->sReturnCode = INVALID_REQUEST;
347 prp->usStatus |= RPERR;
348 return;
349 }
350
351 pStream = new DWAVESTREAM(AUDIOHW_WAVE_PLAY, pInit, prp->s.ioctl.usSysFileNum);
352 if(pStream == NULL) {
353 DebugInt3();
354 pInit->sReturnCode = INVALID_REQUEST;
355 prp->usStatus |= RPERR;
356 return;
357 }
358
359 if(!pStream->IsEverythingOk()) {
360 delete pStream;
361 DebugInt3();
362 pInit->sReturnCode = INVALID_REQUEST;
363 prp->usStatus |= RPERR;
364 return;
365 }
366 pInit->ulFlags |= VOLUME; /* volume control is supported */
367 pInit->ulFlags |= INPUT; /* Input select is supported */
368 pInit->ulFlags |= OUTPUT; /* Output select is supported */
369 pInit->ulFlags |= MONITOR; /* Record Monitor is supported */
370 pInit->sDeviceID = SB_LIVE; /* Reported in VSD dll */
371 pStream->ulSysFileNum = prp->s.ioctl.usSysFileNum;
372 pInit->pvReserved = (VOID FAR *) (ULONG) prp->s.ioctl.usSysFileNum;
373 pInit->sReturnCode = 0;
374
375 return;
376 }
377 else
378 if(prp->s.ioctl.bCode == DAUDIO_QUERYFORMAT)
379 {
380 LPMCI_AUDIO_INIT pInit = (LPMCI_AUDIO_INIT) prp->s.ioctl.pvData;
381 PAUDIOHW pHWobj;
382 MCI_AUDIO_CAPS audioCaps;
383
384 if(DevHelp_VerifyAccess(SELECTOROF(pInit), sizeof(MCI_AUDIO_INIT), OFFSETOF(pInit), VERIFY_READWRITE))
385 {
386 dprintf(("Invalid MCI_AUDIO_INIT pointer %lx!!", (ULONG)pInit));
387 prp->usStatus |= RPERR | RPBADCMD;
388 return;
389 }
390
391 audioCaps.ulLength = sizeof(MCI_AUDIO_CAPS);
392 audioCaps.ulSamplingRate = pInit->lSRate;
393 audioCaps.ulChannels = pInit->sChannels;
394 audioCaps.ulBitsPerSample = pInit->lBitsPerSRate;
395 audioCaps.ulDataType = pInit->sMode;
396 audioCaps.ulOperation = OPERATION_PLAY;
397
398 // get the pointer to the hardware object
399 // call DevCaps
400 // bailout if no hardware object is returned..
401 pHWobj = GetHardwareDevice(AUDIOHW_WAVE_PLAY);
402 if (pHWobj)
403 {
404 pHWobj->DevCaps(&audioCaps);
405 if (audioCaps.ulSupport != SUPPORT_SUCCESS) {
406 dprintf(("IoctlDirectAudio: DevCaps failed"));
407 prp->usStatus |= RPERR;
408 pInit->sReturnCode = INVALID_REQUEST;
409 return;
410 }
411 pInit->sReturnCode = 0;
412 return;
413 }
414 else {
415 pInit->sReturnCode = INVALID_REQUEST;
416 prp->usStatus |= RPERR;
417 return;
418 }
419 }
420
421 PSTREAM pStream;
422
423 pStream = FindStream_fromFile((ULONG) prp->s.ioctl.usSysFileNum);
424 if(pStream == NULL) {
425 dprintf(("IoctlDirectAudio stream %lx not found!", (ULONG) prp->s.ioctl.usSysFileNum));
426 DebugInt3();
427 prp->usStatus |= RPERR | RPBADCMD;
428 return;
429 }
430
431 LPDAUDIO_CMD pDAudioCmd = (LPDAUDIO_CMD) prp->s.ioctl.pvData;
432 ULONG rc = 0;
433
434 if(DevHelp_VerifyAccess(SELECTOROF(pDAudioCmd), sizeof(DAUDIO_CMD), OFFSETOF(pDAudioCmd), VERIFY_READWRITE))
435 {
436 dprintf(("Invalid DAUDIO_CMD pointer %lx!!", (ULONG)pDAudioCmd));
437 prp->usStatus |= RPERR | RPBADCMD;
438 return;
439 }
440
441 switch(prp->s.ioctl.bCode)
442 {
443 case DAUDIO_CLOSE:
444 delete pStream;
445 break;
446
447 case DAUDIO_SETVOLUME:
448 {
449 pStream->SetVolume(MAKE_VOLUME_LR(pDAudioCmd->Vol.VolumeL, pDAudioCmd->Vol.VolumeR));
450 break;
451 }
452
453 case DAUDIO_GETVOLUME:
454 pDAudioCmd->Vol.VolumeL = GET_VOLUME_L(pStream->GetVolume());
455 pDAudioCmd->Vol.VolumeR = GET_VOLUME_R(pStream->GetVolume());
456 break;
457
458 case DAUDIO_START:
459 rc = pStream->StartStream();
460 break;
461
462 case DAUDIO_STOP:
463 {
464 CONTROL_PARM cParm;
465 rc = pStream->StopStream(&cParm);
466 break;
467 }
468
469 case DAUDIO_PAUSE:
470 {
471 CONTROL_PARM cParm;
472 rc = pStream->PauseStream(&cParm);
473 break;
474 }
475
476 case DAUDIO_RESUME:
477 rc = pStream->ResumeStream();
478 break;
479
480 case DAUDIO_GETPOS:
481 pDAudioCmd->Pos.ulCurrentPos = pStream->GetCurrentPos();
482 break;
483
484 case DAUDIO_ADDBUFFER:
485 {
486 rc = pStream->Write((PSTREAMBUF)pDAudioCmd->Buffer.lpBuffer, pDAudioCmd->Buffer.ulBufferLength);
487 break;
488 }
489
490 case DAUDIO_REGISTER_THREAD:
491 {
492 DDCMDREGISTER reg;
493
494 reg.ulFunction = DDCMD_REG_STREAM;
495 reg.hStream = pDAudioCmd->Thread.hSemaphore;
496 reg.ulSysFileNum = prp->s.ioctl.usSysFileNum;
497 reg.pSHDEntryPoint = NULL;
498 rc = pStream->Register(&reg);
499 break;
500 }
501
502 case DAUDIO_DEREGISTER_THREAD:
503 {
504 pStream->DeRegister();
505 break;
506 }
507
508 }
509
510 if(rc) {
511 prp->usStatus |= RPERR | RPBADCMD;
512 return;
513 }
514 return;
515}
516//******************************************************************************
517//******************************************************************************
518void IoctlMixer(PREQPACKET prp)
519{
520 MIXSTRUCT FAR *pMixStruct = (MIXSTRUCT FAR *)prp->s.ioctl.pvData;
521 ULONG FAR *pIoctlData = (ULONG FAR *)prp->s.ioctl.pvData;
522 CHAR FAR *pIoctlMap = (CHAR FAR *)prp->s.ioctl.pvData; //getapimap
523 USHORT VolumeL, VolumeR;
524
525 if((prp->s.ioctl.bCode & 0xF0) == 0x40)
526 {
527 if(DevHelp_VerifyAccess(SELECTOROF(pMixStruct), sizeof(MIXSTRUCT), OFFSETOF(pMixStruct), VERIFY_READWRITE))
528 {
529 dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pMixStruct));
530 prp->usStatus |= RPERR | RPBADCMD;
531 return;
532 }
533 MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeL = pMixStruct->VolumeL;
534 MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeR = pMixStruct->VolumeR;
535 MixerSettings[prp->s.ioctl.bCode & 0xF].Mute = pMixStruct->Mute;
536 VolumeL = (USHORT)pMixStruct->VolumeL;
537 VolumeR = (USHORT)pMixStruct->VolumeR;
538 if(prp->s.ioctl.bCode != BASSTREBLESET) {
539 if(pMixStruct->Mute == 1)
540 VolumeL = VolumeR = 0;
541 }
542 }
543 else
544 if((prp->s.ioctl.bCode & 0xF0) == 0x60)
545 {
546 if(DevHelp_VerifyAccess(SELECTOROF(pMixStruct), sizeof(MIXSTRUCT), OFFSETOF(pMixStruct), VERIFY_READONLY))
547 {
548 dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pMixStruct));
549 prp->usStatus |= RPERR | RPBADCMD;
550 return;
551 }
552 }
553
554 switch(prp->s.ioctl.bCode) {
555 case MICSET:
556 OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETMICVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
557 break;
558 case LINESET:
559 OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETLINEINVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
560 break;
561 case CDSET:
562 OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETCDVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
563 break;
564 case VIDEOSET:
565 OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETVIDEOVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
566 break;
567 case AUXSET:
568 OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETAUXVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
569 break;
570
571 case BASSTREBLESET:
572 OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETBASS, MAKE_VOLUME_LR(VolumeL, VolumeL));
573 OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETTREBLE, MAKE_VOLUME_LR(VolumeR, VolumeR));
574 break;
575#if 0
576 case STREAMVOLSET:
577 //release stream volume override?
578 if(pMixStruct->Mute == 2) {
579 fStreamVolIOCTL90 = FALSE;
580 break;
581 }
582 fStreamVolIOCTL90 = TRUE;
583 OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETMASTERVOL, MAKE_VOLUME_LR(VolumeL, VolumeR));
584 break;
585#endif
586
587 case RECORDSRCSET:
588 {
589 int recsrc = MIX_RECSRC_LINE;
590
591 //release recording source override?
592 if(pMixStruct->Mute == 2) {
593 fRecSrcIOCTL90 = FALSE;
594 break;
595 }
596 fRecSrcIOCTL90 = TRUE;
597 switch(pMixStruct->VolumeL) {
598 case I90SRC_MIC:
599 recsrc = MIX_RECSRC_MIC;
600 break;
601 case I90SRC_CD:
602 recsrc = MIX_RECSRC_CD;
603 break;
604 case I90SRC_VIDEO:
605 recsrc = MIX_RECSRC_VIDEO;
606 break;
607 case I90SRC_LINE:
608 recsrc = MIX_RECSRC_LINE;
609 break;
610 case I90SRC_AUX:
611 recsrc = MIX_RECSRC_AUX;
612 break;
613 // case I90SRC_RES5:
614 // case I90SRC_RES6:
615 // case I90SRC_PHONE:
616 default:
617 break;
618 }
619 OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETINPUTSRC, recsrc);
620 break;
621 }
622 case RECORDGAINSET:
623 //release recording gain override?
624 if(pMixStruct->Mute == 2) {
625 fRecGainIOCTL90 = FALSE;
626 break;
627 }
628 fRecGainIOCTL90 = TRUE;
629 OSS16_SetGlobalVol(prp->s.ioctl.usSysFileNum, MIX_SETINPUTGAIN, MAKE_VOLUME_LR(VolumeL, VolumeL));
630 break;
631
632 case MICQUERY:
633 case LINEQUERY:
634 case AUXQUERY:
635 case CDQUERY:
636 case VIDEOQUERY:
637 case RECORDSRCQUERY:
638 case RECORDGAINQUERY:
639 pMixStruct->VolumeL = MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeL;
640 pMixStruct->VolumeR = MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeR;
641 pMixStruct->Mute = MixerSettings[prp->s.ioctl.bCode & 0xF].Mute;
642 break;
643
644 case BASSTREBLEQUERY:
645 pMixStruct->VolumeL = MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeL;
646 pMixStruct->VolumeR = MixerSettings[prp->s.ioctl.bCode & 0xF].VolumeR;
647 pMixStruct->Mute = 3; //bass & treble
648 break;
649
650 case APILEVELQUERY:
651 if(DevHelp_VerifyAccess(SELECTOROF(pIoctlData), sizeof(ULONG), OFFSETOF(pIoctlData), VERIFY_READWRITE))
652 {
653 dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pIoctlData));
654 prp->usStatus |= RPERR | RPBADCMD;
655 return;
656 }
657 *pIoctlData = 2;
658 break;
659
660 case GETAPIMAP:
661 if(DevHelp_VerifyAccess(SELECTOROF(pIoctlMap), sizeof(SBLiveIOCTLMap), OFFSETOF(pIoctlMap), VERIFY_READWRITE))
662 {
663 dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pMixStruct));
664 prp->usStatus |= RPERR | RPBADCMD;
665 return;
666 }
667 _fmemcpy(pIoctlMap, SBLiveIOCTLMap, sizeof(SBLiveIOCTLMap));
668 break;
669// case STREAMVOLQUERY:
670// case MONOINSET:
671// case PHONESET:
672// case THREEDSET:
673// case MONOINQUERY:
674// case PHONEQUERY:
675// case THREEDQUERY:
676// case CALLBACKREG:
677// case MSGBUF:
678 default:
679 prp->usStatus |= RPERR | RPBADCMD;
680 return;
681 }
682}
683//******************************************************************************
684//******************************************************************************
685void MixerInit()
686{
687 REQPACKET rp;
688 MIXSTRUCT mixinfo;
689
690 SBLiveIOCTLMap[MICSET] = 1;
691 SBLiveIOCTLMap[MICQUERY] = 1;
692 SBLiveIOCTLMap[LINESET] = 1;
693 SBLiveIOCTLMap[LINEQUERY] = 1;
694 SBLiveIOCTLMap[CDSET] = 1;
695 SBLiveIOCTLMap[CDQUERY] = 1;
696 SBLiveIOCTLMap[VIDEOSET] = 1;
697 SBLiveIOCTLMap[VIDEOQUERY] = 1;
698 SBLiveIOCTLMap[AUXSET] = 1;
699 SBLiveIOCTLMap[AUXQUERY] = 1;
700 SBLiveIOCTLMap[BASSTREBLESET] = 1;
701 SBLiveIOCTLMap[BASSTREBLEQUERY] = 1;
702//// SBLiveIOCTLMap[STREAMVOLSET] = 1;
703//// SBLiveIOCTLMap[STREAMVOLQUERY] = 1;
704 SBLiveIOCTLMap[RECORDSRCSET] = 1;
705 SBLiveIOCTLMap[RECORDSRCQUERY] = 1;
706 SBLiveIOCTLMap[RECORDGAINSET] = 1;
707 SBLiveIOCTLMap[RECORDGAINQUERY] = 1;
708 SBLiveIOCTLMap[APILEVELQUERY] = 1;
709 SBLiveIOCTLMap[GETAPIMAP] = 1;
710// SBLiveIOCTLMap[CALLBACKREG] = 1;
711
712 //Set mic
713 rp.s.ioctl.bCode = MICSET;
714 rp.s.ioctl.pvData = (void FAR *)&mixinfo;
715 mixinfo.Mute = fMicMute;
716 mixinfo.VolumeR = mixinfo.VolumeL = 60;
717 IoctlMixer(&rp);
718
719 //Set line
720 rp.s.ioctl.bCode = LINESET;
721 rp.s.ioctl.pvData = (void FAR *)&mixinfo;
722 mixinfo.Mute = fLineMute;
723 mixinfo.VolumeR = mixinfo.VolumeL = 80;
724 IoctlMixer(&rp);
725
726 //Set CD
727 rp.s.ioctl.bCode = CDSET;
728 rp.s.ioctl.pvData = (void FAR *)&mixinfo;
729 mixinfo.Mute = fCDMute;
730 mixinfo.VolumeR = mixinfo.VolumeL = 80;
731 IoctlMixer(&rp);
732
733 //Set bass/treble
734 rp.s.ioctl.bCode = BASSTREBLESET;
735 rp.s.ioctl.pvData = (void FAR *)&mixinfo;
736 mixinfo.Mute = 3;
737 mixinfo.VolumeR = mixinfo.VolumeL = 50;
738 IoctlMixer(&rp);
739
740 //Set recording source to line in
741 rp.s.ioctl.bCode = RECORDSRCSET;
742 rp.s.ioctl.pvData = (void FAR *)&mixinfo;
743 mixinfo.Mute = 0;
744 mixinfo.VolumeL = I90SRC_LINE;
745 IoctlMixer(&rp);
746
747 //Release recording source override
748 rp.s.ioctl.bCode = RECORDSRCSET;
749 rp.s.ioctl.pvData = (void FAR *)&mixinfo;
750 mixinfo.Mute = 2;
751 mixinfo.VolumeL = I90SRC_LINE;
752 IoctlMixer(&rp);
753
754 //Set master volume
755 rp.s.ioctl.bCode = STREAMVOLSET;
756 rp.s.ioctl.pvData = (void FAR *)&mixinfo;
757 mixinfo.Mute = 0;
758 mixinfo.VolumeR = mixinfo.VolumeL = 90;
759 IoctlMixer(&rp);
760
761 //Release master volume override
762 rp.s.ioctl.bCode = STREAMVOLSET;
763 rp.s.ioctl.pvData = (void FAR *)&mixinfo;
764 mixinfo.Mute = 2;
765 mixinfo.VolumeR = mixinfo.VolumeL = 90;
766 IoctlMixer(&rp);
767}
768//******************************************************************************
769//******************************************************************************
770/**@internal
771 * @param PREQPACKET pointer to the strategy request packet
772 * @return None But the Status in the request packet is updated on error
773 * @notes
774 * StrategyIoctl is called from the strategy entry point to process IOCTL
775 * requests. only catagory 80x requests will be processed.
776 */
777/* extern "C" void StrategyIoctl(PREQPACKET prp, USHORT LDev)
778*
779*
780*
781*/
782extern "C" void StrategyIoctl(PREQPACKET prp, USHORT LDev)
783{
784 if(prp->s.ioctl.bCategory == DAUDIO_IOCTL_CAT) {
785 IoctlDirectAudio(prp);
786 return;
787 }
788
789 if(prp->s.ioctl.bCategory == 0x90) {
790 IoctlMixer(prp);
791 return;
792 }
793 if(prp->s.ioctl.bCategory != AUDIO_IOCTL_CAT) {
794 prp->usStatus |= RPERR | RPBADCMD;
795 return;
796 }
797
798 switch (prp->s.ioctl.bCode)
799 {
800 case AUDIO_INIT:
801 IoctlAudioInit(prp, LDev);
802 break;
803 case AUDIO_CONTROL:
804 IoctlAudioControl(prp);
805 break;
806 case AUDIO_CAPABILITY:
807 IoctlAudioCapability(prp, LDev);
808 break;
809 default:
810 prp->usStatus |= RPERR | RPBADCMD;
811 break;
812 }
813 return;
814}
Note: See TracBrowser for help on using the repository browser.