source: GPL/trunk/lib32/sound.c

Last change on this file was 777, checked in by David Azarewicz, 5 months ago

Merge from uniaud32-exp branch
File size: 49.0 KB
RevLine 
[32]1/*
2 * MMPM/2 to OSS interface translation layer
3 *
4 * (C) 2000-2002 InnoTek Systemberatung GmbH
5 * (C) 2000-2001 Sander van Leeuwen (sandervl@xs4all.nl)
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License as
9 * published by the Free Software Foundation; either version 2 of
10 * the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public
18 * License along with this program; if not, write to the Free
19 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
20 * USA.
21 *
22 */
23
[305]24#include <sound/core.h>
[32]25#include <sound/control.h>
26#include <sound/info.h>
27#include <sound/pcm.h>
28#include <sound/pcm_params.h>
29#include <sound/minors.h>
30#include <linux/file.h>
31#include <linux/soundcard.h>
32
33#define LINUX
34#include <ossidc32.h>
35#include <osspci.h>
36#include <stacktoflat.h>
37#include <stdlib.h>
[479]38#include <proto.h>
[679]39#include <u32ioctl.h>
[32]40#include "soundoss.h"
41
42#undef samples_to_bytes
43#undef bytes_to_samples
[518]44#define samples_to_bytes(a) ((a*pHandle->doublesamplesize)/2)
[32]45#define bytes_to_samples(a) (pHandle->doublesamplesize ? ((a*2)/pHandle->doublesamplesize) : a)
46
47struct file_operations oss_devices[OSS32_MAX_DEVICES] = {0};
[679]48const struct file_operations *alsa_fops = NULL;
[32]49int per_bytes = 0;
50int prev_size = 0;
51int pcm_device = 0;
52int total = 0;
[269]53// int pcm_instances = 0; //PS+++ !!!!!!! what is it!!!! see pcm.lib
[32]54
55OpenedHandles opened_handles[8 * 256] = {0};
56
57//OSS32 to ALSA datatype conversion table
[130]58static int OSSToALSADataType[OSS32_PCM_MAX_FORMATS] = {
[518]59/* OSS32_PCM_FORMAT_S8 */ SNDRV_PCM_FORMAT_S8, //signed 8 bits sample
60/* OSS32_PCM_FORMAT_U8 */ SNDRV_PCM_FORMAT_U8, //unsigned 8 bits sample
61/* OSS32_PCM_FORMAT_S16_LE */ SNDRV_PCM_FORMAT_S16_LE, //signed 16 bits sample (little endian/Intel)
62/* OSS32_PCM_FORMAT_S16_BE */ SNDRV_PCM_FORMAT_S16_BE, //signed 16 bits sample (big endian/Motorola)
63/* OSS32_PCM_FORMAT_U16_LE */ SNDRV_PCM_FORMAT_U16_LE, //unsigned 16 bits sample (little endian/Intel)
64/* OSS32_PCM_FORMAT_U16_BE */ SNDRV_PCM_FORMAT_U16_BE, //unsigned 16 bits sample (big endian/Motorola)
65/* OSS32_PCM_FORMAT_S24_LE */ SNDRV_PCM_FORMAT_S24_LE, //signed 24 bits sample (little endian/Intel)
66/* OSS32_PCM_FORMAT_S24_BE */ SNDRV_PCM_FORMAT_S24_BE, //signed 24 bits sample (big endian/Motorola)
67/* OSS32_PCM_FORMAT_U24_LE */ SNDRV_PCM_FORMAT_U24_LE, //unsigned 24 bits sample (little endian/Intel)
68/* OSS32_PCM_FORMAT_U24_BE */ SNDRV_PCM_FORMAT_U24_BE, //unsigned 24 bits sample (big endian/Motorola)
69/* OSS32_PCM_FORMAT_S32_LE */ SNDRV_PCM_FORMAT_S32_LE, //signed 32 bits sample (little endian/Intel)
70/* OSS32_PCM_FORMAT_S32_BE */ SNDRV_PCM_FORMAT_S32_BE, //signed 32 bits sample (big endian/Motorola)
71/* OSS32_PCM_FORMAT_U32_LE */ SNDRV_PCM_FORMAT_U32_LE, //unsigned 32 bits sample (little endian/Intel)
72/* OSS32_PCM_FORMAT_U32_BE */ SNDRV_PCM_FORMAT_U32_BE, //unsigned 32 bits sample (big endian/Motorola)
73/* OSS32_PCM_FORMAT_MULAW */ SNDRV_PCM_FORMAT_MU_LAW, //8 bps (compressed 16 bits sample)
74/* OSS32_PCM_FORMAT_ALAW */ SNDRV_PCM_FORMAT_A_LAW, //8 bps (compressed 16 bits sample)
75/* OSS32_PCM_FORMAT_ADPCM */ SNDRV_PCM_FORMAT_IMA_ADPCM, //4 bps (compressed 16 bits sample)
76/* OSS32_PCM_FORMAT_MPEG */ SNDRV_PCM_FORMAT_MPEG, //AC3?
[32]77};
78
79//******************************************************************************
80//******************************************************************************
[679]81int register_chrdev(unsigned int version, const char *name, const struct file_operations *fsop)
[32]82{
83 if(!strcmp(name, "alsa")) {
[518]84 alsa_fops = fsop;
[32]85 }
86 return 0;
87}
88//******************************************************************************
89//******************************************************************************
90int unregister_chrdev(unsigned int version, const char *name)
91{
92 if(!strcmp(name, "alsa")) {
[518]93 alsa_fops = NULL;
[32]94 }
95 return 0;
96}
97//******************************************************************************
98//******************************************************************************
99int register_sound_special(struct file_operations *fops, int unit)
100{
[518]101 if(fops == NULL) return -1;
[32]102
[518]103 memcpy(&oss_devices[OSS32_SPECIALID], fops, sizeof(struct file_operations));
104 return OSS32_SPECIALID;
[32]105}
106//******************************************************************************
107//******************************************************************************
108int register_sound_mixer(struct file_operations *fops, int dev)
109{
[518]110 if(fops == NULL) return -1;
[32]111
[518]112 memcpy(&oss_devices[OSS32_MIXERID], fops, sizeof(struct file_operations));
113 return OSS32_MIXERID;
[32]114}
115//******************************************************************************
116//******************************************************************************
117int register_sound_midi(struct file_operations *fops, int dev)
118{
[518]119 if(fops == NULL) return -1;
[32]120
[518]121 memcpy(&oss_devices[OSS32_MIDIID], fops, sizeof(struct file_operations));
122 return OSS32_MIDIID;
[32]123}
124//******************************************************************************
125//******************************************************************************
126int register_sound_dsp(struct file_operations *fops, int dev)
127{
[518]128 if(fops == NULL) return -1;
[32]129
[518]130 memcpy(&oss_devices[OSS32_DSPID], fops, sizeof(struct file_operations));
131 return OSS32_DSPID;
[32]132}
133//******************************************************************************
134//******************************************************************************
135int register_sound_synth(struct file_operations *fops, int dev)
136{
[518]137 if(fops == NULL) return -1;
[32]138
[518]139 memcpy(&oss_devices[OSS32_SYNTHID], fops, sizeof(struct file_operations));
140 return OSS32_SYNTHID;
[32]141}
142//******************************************************************************
143//******************************************************************************
144void unregister_sound_special(int unit)
145{
[518]146 memset(&oss_devices[OSS32_SPECIALID], 0, sizeof(struct file_operations));
[32]147}
148//******************************************************************************
149//******************************************************************************
150void unregister_sound_mixer(int unit)
151{
[518]152 memset(&oss_devices[OSS32_MIXERID], 0, sizeof(struct file_operations));
[32]153}
154//******************************************************************************
155//******************************************************************************
156void unregister_sound_midi(int unit)
157{
[518]158 memset(&oss_devices[OSS32_MIDIID], 0, sizeof(struct file_operations));
[32]159}
160//******************************************************************************
161//******************************************************************************
162void unregister_sound_dsp(int unit)
163{
[518]164 memset(&oss_devices[OSS32_DSPID], 0, sizeof(struct file_operations));
[32]165}
166//******************************************************************************
167//******************************************************************************
168void unregister_sound_synth(int unit)
169{
[518]170 memset(&oss_devices[OSS32_SYNTHID], 0, sizeof(struct file_operations));
[32]171}
172//******************************************************************************
173//******************************************************************************
174OSSRET UNIXToOSSError(int unixerror)
175{
[518]176 switch(unixerror) {
177 case 0:
178 return OSSERR_SUCCESS;
179 case -ENOMEM:
180 return OSSERR_OUT_OF_MEMORY;
181 case -ENODEV:
182 return OSSERR_NO_DEVICE_AVAILABLE;
183 case -ENOTTY:
184 case -EINVAL:
185 return OSSERR_INVALID_PARAMETER;
186 case -EAGAIN:
187 return OSSERR_AGAIN; //????
188 case -ENXIO:
189 return OSSERR_IO_ERROR;
190 case -EBUSY:
191 return OSSERR_BUSY;
192 case -EPERM:
193 return OSSERR_ACCESS_DENIED; //??
194 case -EPIPE:
195 case -EBADFD:
196 return OSSERR_ACCESS_DENIED; //??
197 default:
198 dprintf(("Unknown error %d", (unixerror > 0) ? unixerror : -unixerror));
199 return OSSERR_UNKNOWN;
200 }
[32]201}
202//******************************************************************************
203//ALSA to OSS32 datatype conversion
204//******************************************************************************
205int ALSAToOSSDataType(ULONG ALSADataType)
206{
[518]207 switch(ALSADataType)
208 {
209 case SNDRV_PCM_FORMAT_S8:
210 return OSS32_CAPS_PCM_FORMAT_S8; //signed 8 bits sample
211 case SNDRV_PCM_FORMAT_U8:
212 return OSS32_CAPS_PCM_FORMAT_U8; //unsigned 8 bits sample
213 case SNDRV_PCM_FORMAT_S16_LE:
214 return OSS32_CAPS_PCM_FORMAT_S16_LE; //signed 16 bits sample (little endian/Intel)
215 case SNDRV_PCM_FORMAT_S16_BE:
216 return OSS32_CAPS_PCM_FORMAT_S16_BE; //signed 16 bits sample (big endian/Motorola)
217 case SNDRV_PCM_FORMAT_U16_LE:
218 return OSS32_CAPS_PCM_FORMAT_U16_LE; //unsigned 16 bits sample (little endian/Intel)
219 case SNDRV_PCM_FORMAT_U16_BE:
220 return OSS32_CAPS_PCM_FORMAT_U16_BE; //unsigned 16 bits sample (big endian/Motorola)
221 case SNDRV_PCM_FORMAT_S24_LE:
222 return OSS32_CAPS_PCM_FORMAT_S24_LE; //signed 24 bits sample (little endian/Intel)
223 case SNDRV_PCM_FORMAT_S24_BE:
224 return OSS32_CAPS_PCM_FORMAT_S24_BE; //signed 24 bits sample (big endian/Motorola)
225 case SNDRV_PCM_FORMAT_U24_LE:
226 return OSS32_CAPS_PCM_FORMAT_U24_LE; //unsigned 24 bits sample (little endian/Intel)
227 case SNDRV_PCM_FORMAT_U24_BE:
228 return OSS32_CAPS_PCM_FORMAT_U24_BE; //unsigned 16 bits sample (big endian/Motorola)
229 case SNDRV_PCM_FORMAT_S32_LE:
230 return OSS32_CAPS_PCM_FORMAT_S32_LE; //signed 32 bits sample (little endian/Intel)
231 case SNDRV_PCM_FORMAT_S32_BE:
232 return OSS32_CAPS_PCM_FORMAT_S32_BE; //signed 32 bits sample (big endian/Motorola)
233 case SNDRV_PCM_FORMAT_U32_LE:
234 return OSS32_CAPS_PCM_FORMAT_U32_LE; //unsigned 32 bits sample (little endian/Intel)
235 case SNDRV_PCM_FORMAT_U32_BE:
236 return OSS32_CAPS_PCM_FORMAT_U32_BE; //unsigned 32 bits sample (big endian/Motorola)
237 case SNDRV_PCM_FORMAT_MU_LAW:
238 return OSS32_CAPS_PCM_FORMAT_MULAW; //8 bps (compressed 16 bits sample)
239 case SNDRV_PCM_FORMAT_A_LAW:
240 return OSS32_CAPS_PCM_FORMAT_ALAW; //8 bps (compressed 16 bits sample)
241 case SNDRV_PCM_FORMAT_IMA_ADPCM:
242 return OSS32_CAPS_PCM_FORMAT_ADPCM; //4 bps (compressed 16 bits sample)
243 case SNDRV_PCM_FORMAT_MPEG:
244 return OSS32_CAPS_PCM_FORMAT_MPEG; //AC3?
245 default:
246 DebugInt3();
247 return -1;
248 }
[32]249}
250//******************************************************************************
251//******************************************************************************
252ULONG ALSAToOSSRateFlags(ULONG fuRates)
253{
[518]254 ULONG fuOSSRates = 0;
[32]255
[518]256 char szMixerName[64];
257 char szDeviceName[128];
258 OSS32_QueryNames(OSS32_DEFAULT_DEVICE, szDeviceName,
259 sizeof(szDeviceName),szMixerName,
260 sizeof(szMixerName), TRUE);
261 if (strncmp(szDeviceName,"HDA",3) != 0){
262 /* non-HDA audio - support 5512 - 32000 Hz sample rates */
263 if(fuRates & SNDRV_PCM_RATE_5512) {
264 fuOSSRates |= OSS32_CAPS_PCM_RATE_5512;
265 }
266 if(fuRates & SNDRV_PCM_RATE_8000) {
267 fuOSSRates |= OSS32_CAPS_PCM_RATE_8000;
268 }
269 if(fuRates & SNDRV_PCM_RATE_11025) {
270 fuOSSRates |= OSS32_CAPS_PCM_RATE_11025;
271 }
272 if(fuRates & SNDRV_PCM_RATE_16000) {
273 fuOSSRates |= OSS32_CAPS_PCM_RATE_16000;
274 }
275 if(fuRates & SNDRV_PCM_RATE_22050) {
276 fuOSSRates |= OSS32_CAPS_PCM_RATE_22050;
277 }
278 if(fuRates & SNDRV_PCM_RATE_32000) {
279 fuOSSRates |= OSS32_CAPS_PCM_RATE_32000;
280 }
281 } else {
282 dprintf(("HDA audio detected - don't support 5512 - 32000 Hz audio sample rates\n"));
283 }
284 if(fuRates & SNDRV_PCM_RATE_44100) {
285 fuOSSRates |= OSS32_CAPS_PCM_RATE_44100;
286 }
287 if(fuRates & SNDRV_PCM_RATE_48000) {
288 fuOSSRates |= OSS32_CAPS_PCM_RATE_48000;
289 }
[320]290#if 0
[518]291 if(fuRates & SNDRV_PCM_RATE_64000) {
292 fuOSSRates |= OSS32_CAPS_PCM_RATE_64000;
293 }
294 if(fuRates & SNDRV_PCM_RATE_88200) {
295 fuOSSRates |= OSS32_CAPS_PCM_RATE_88200;
296 }
297 if(fuRates & SNDRV_PCM_RATE_96000) {
298 fuOSSRates |= OSS32_CAPS_PCM_RATE_96000;
299 }
300 if(fuRates & SNDRV_PCM_RATE_176400) {
301 fuOSSRates |= OSS32_CAPS_PCM_RATE_176400;
302 }
303 if(fuRates & SNDRV_PCM_RATE_192000) {
304 fuOSSRates |= OSS32_CAPS_PCM_RATE_192000;
305 }
[320]306#endif
[518]307 if(fuRates & SNDRV_PCM_RATE_CONTINUOUS) {
308 fuOSSRates |= OSS32_CAPS_PCM_RATE_CONTINUOUS;
309 }
[32]310
[518]311 //TODO:
312 if(fuRates & SNDRV_PCM_RATE_KNOT) {
313 DebugInt3();
314 }
[32]315//#define OSS32_CAPS_PCM_RATE_KNOT (1<<31) /* supports more non-continuos rates */
316
[518]317 return fuOSSRates;
[32]318}
319//******************************************************************************
320//******************************************************************************
321OSSRET OSS32_QueryDevCaps(ULONG deviceid, POSS32_DEVCAPS pDevCaps)
322{
[518]323 OSSSTREAMID streamid = 0;
324 soundhandle *pHandle;
325 struct snd_pcm_info *pcminfo = NULL;
326 struct snd_pcm_hw_params *params;
327 int ret, fmt, i;
328 ULONG format_mask;
329 struct snd_mask *mask;
[598]330 //int max_ch;
[32]331
[518]332 dprintf(("OSS32_QueryDevCaps"));
333// max_ch = GetMaxChannels(deviceid, OSS32_CAPS_WAVE_PLAYBACK);
[32]334
[518]335 //these structures are too big to put on the stack
336 pcminfo = (struct snd_pcm_info *)kmalloc(sizeof(struct snd_pcm_info)+sizeof(struct snd_pcm_hw_params), GFP_KERNEL);
337 if(pcminfo == NULL) {
338 DebugInt3();
339 rprintf(("OSS32_QueryDevCaps: out of memory\n"));
340 return OSSERR_OUT_OF_MEMORY;
341 }
342 params = (struct snd_pcm_hw_params *)(pcminfo+1);
[32]343
[518]344 dprintf(("Number of cards=%i dev id=%i", nrCardsDetected, deviceid));
345 pDevCaps->nrDevices = 1;//nrCardsDetected;
346// pDevCaps->nrDevices = nrCardsDetected;
347 pDevCaps->ulCaps = OSS32_CAPS_WAVE_PLAYBACK | OSS32_CAPS_WAVE_CAPTURE;
[32]348
[518]349 //query wave in & out caps
350 for(i=0;i<2;i++)
351 {
352 PWAVE_CAPS pWaveCaps = (i == 0) ? &pDevCaps->waveOutCaps : &pDevCaps->waveInCaps;
[32]353
[518]354 ret = OSS32_WaveOpen(deviceid, (i == 0) ? OSS32_STREAM_WAVEOUT : OSS32_STREAM_WAVEIN, &streamid, 0, 0);
355 if(ret != OSSERR_SUCCESS)
356 {
357 rprintf(("OSS32_QueryDevCaps: wave open error %i\n", ret));
358 DebugInt3();
359 goto fail;
360 }
361 pHandle = (soundhandle *)streamid;
362 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
363 rprintf(("OSS32_QueryDevCaps: invalid stream id \n"));
364 ret = OSSERR_INVALID_STREAMID;
365 goto fail;
366 }
367 //set operation to non-blocking
368 pHandle->file.f_flags = O_NONBLOCK;
[386]369
[679]370 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_INFO, (ULONG)pcminfo);
[518]371 if(ret != 0) {
372 rprintf(("OSS32_QueryDevCaps: SNDRV_PCM_IOCTL_INFO error %i\n", ret));
373 ret = UNIXToOSSError(ret);
374 goto fail;
375 }
376 if(i == 0) {//only need to do this once
377 if(pcminfo->name[0]) {
378 strncpy(pDevCaps->szDeviceName, pcminfo->name, sizeof(pDevCaps->szDeviceName));
379 }
380 else strncpy(pDevCaps->szDeviceName, pcminfo->id, sizeof(pDevCaps->szDeviceName));
381 }
382 dprintf(("Device name: %s", pDevCaps->szDeviceName));
383 pWaveCaps->nrStreams = pcminfo->subdevices_count;
[386]384
[518]385 //get all hardware parameters
386 _snd_pcm_hw_params_any(params);
[679]387 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
[518]388 if(ret != 0) {
389 rprintf(("OSS32_QueryDevCaps: SNDRV_PCM_IOCTL_HW_REFINE error %i\n", ret));
390 ret = UNIXToOSSError(ret);
391 goto fail;
392 }
[32]393
[518]394 pWaveCaps->ulMinChannels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min;
395 pWaveCaps->ulMaxChannels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max;
396 pWaveCaps->ulChanFlags = 0;
397 if(pWaveCaps->ulMinChannels == 1) {
398 pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_MONO;
399 }
400 if(pWaveCaps->ulMaxChannels >= 2) {
401 pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_STEREO;
402 }
403 if(pWaveCaps->ulMaxChannels >= 4) {
404 pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_QUAD;
405 }
406 if(pWaveCaps->ulMaxChannels >= 6) {
407 pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_5_1;
408 }
[32]409
[518]410 pWaveCaps->ulMinRate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min;
411 pWaveCaps->ulMaxRate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max;
[32]412
[518]413 mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_RATE_MASK);
[307]414
[518]415 pWaveCaps->ulRateFlags = mask->bits[0];
[386]416
[518]417 pWaveCaps->ulRateFlags = ALSAToOSSRateFlags(pWaveCaps->ulRateFlags);
[32]418
[518]419 pWaveCaps->ulDataFormats = 0;
[32]420
[518]421 mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
422 format_mask = mask->bits[0];
423 for(fmt=0;fmt<32;fmt++)
424 {
425 if(format_mask & (1 << fmt))
426 {
427 int f = ALSAToOSSDataType(fmt);
428 if (f >= 0)
429 pWaveCaps->ulDataFormats |= f;
430 }
431 }
[32]432
[518]433 OSS32_WaveClose(streamid);
434 streamid = 0;
[32]435
[518]436 }
[363]437
[518]438 //Check support for MPU401, FM & Wavetable MIDI
439 if(OSS32_MidiOpen(deviceid, OSS32_STREAM_MPU401_MIDIOUT, &streamid) == OSSERR_SUCCESS)
440 {
441 pDevCaps->ulCaps |= OSS32_CAPS_MPU401_PLAYBACK;
442 OSS32_MidiClose(streamid);
443 streamid = 0;
444 }
445 if(OSS32_MidiOpen(deviceid, OSS32_STREAM_MPU401_MIDIIN, &streamid) == OSSERR_SUCCESS)
446 {
447 pDevCaps->ulCaps |= OSS32_CAPS_MPU401_CAPTURE;
448 OSS32_MidiClose(streamid);
449 streamid = 0;
450 }
451 if(OSS32_MidiOpen(deviceid, OSS32_STREAM_FM_MIDIOUT, &streamid) == OSSERR_SUCCESS)
452 {
453 pDevCaps->ulCaps |= OSS32_CAPS_FMSYNTH_PLAYBACK;
454 OSS32_MidiClose(streamid);
455 streamid = 0;
456 }
457 if(OSS32_MidiOpen(deviceid, OSS32_STREAM_WAVETABLE_MIDIOUT, &streamid) == OSSERR_SUCCESS)
458 {
459 pDevCaps->ulCaps |= OSS32_CAPS_WAVETABLE_PLAYBACK;
460 OSS32_MidiClose(streamid);
461 streamid = 0;
462 }
[363]463
[518]464 if(OSS32_MixQueryName(deviceid, &pDevCaps->szMixerName, sizeof(pDevCaps->szMixerName)) != OSSERR_SUCCESS) {
465 DebugInt3();
466 rprintf(("OSS32_QueryDevCaps: OSS32_MixQueryName error\n"));
467 goto fail;
468 }
469 dprintf(("OSS32_QueryDevCaps: devname: [%s]\n", pDevCaps->szDeviceName));
470 kfree(pcminfo);
471 streamid = 0;
[32]472
473
[518]474 return OSSERR_SUCCESS;
[32]475
476fail:
[518]477 rprintf(("OSS32_QueryDevCaps failed\n"));
478 DebugInt3();
479 if(streamid) OSS32_WaveClose(streamid);
480 if(pcminfo) kfree(pcminfo);
[32]481
[518]482 return ret;
[32]483}
484//******************************************************************************
485//******************************************************************************
486OSSRET OSS32_WaveOpen(ULONG deviceid, ULONG streamtype, OSSSTREAMID *pStreamId, int pcm, USHORT fileid)
487{
[518]488 soundhandle *pHandle;
489 int ret,i;
[32]490
[518]491 if (pStreamId)
492 *pStreamId = 0;
493 else
494 {
495 rprintf(("ERROR: invalid stream id pointer\n"));
496 return OSSERR_OUT_OF_MEMORY;
497 }
[32]498
[518]499 if(alsa_fops == NULL) {
500 DebugInt3();
501 rprintf(("OSS32_WaveOpen: no devices"));
[32]502
[518]503 return OSSERR_NO_DEVICE_AVAILABLE;
504 }
[32]505
[518]506 //dprintf(("dev id: %i\n",deviceid));
[32]507
[518]508 pHandle = kmalloc(sizeof(soundhandle), GFP_KERNEL);
509 if(pHandle == NULL) {
510 DebugInt3();
511 rprintf(("OSS32_WaveOpen: out of memory\n"));
512 return OSSERR_OUT_OF_MEMORY;
513 }
514 memset(pHandle, 0, sizeof(soundhandle));
[32]515
[518]516 //set operation to non-blocking
517 pHandle->file.f_flags = O_NONBLOCK;
[32]518
[518]519 //setup pointers in file structure (used internally by ALSA)
520 pHandle->file.f_dentry = &pHandle->d_entry;
521 pHandle->file.f_dentry->d_inode = &pHandle->inode;
[32]522
[518]523 switch(streamtype) {
524 case OSS32_STREAM_WAVEOUT:
525 pHandle->file.f_mode = FMODE_WRITE;
526 pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_PCM_PLAYBACK) + pcm;
527 break;
528 case OSS32_STREAM_WAVEIN:
529 pHandle->file.f_mode = FMODE_READ;
530 pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_PCM_CAPTURE) + pcm;
531 break;
532 default:
533 DebugInt3();
534 kfree(pHandle);
535 rprintf(("OSS32_WaveOpen: invalid parameter\n"));
536 return OSSERR_INVALID_PARAMETER;
537 }
[32]538
[518]539 ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
[679]540
[518]541 //dprintf(("OSS32_WaveOpen. ret: %i\n", ret));
542 /* check if PCM already opened (stupid uniaud16.sys doesnt closes it) */
543 if (ret == -16)
544 {
545 for (i=0; i < 8*256; i++)
546 {
547 if (opened_handles[i].handle != 0)
548 {
549 ret = 0;
550 if (pStreamId)
551 *pStreamId = (ULONG)opened_handles[i].handle;
552 opened_handles[i].reuse = 1; /* try to reuse */
553 if (OSS32_WaveClose((OSSSTREAMID)opened_handles[i].handle) == 0)
554 {
555 if (!opened_handles[i].reuse)
556 {
557 //opened_handles[i].handle = 0;
558 kfree(opened_handles[i].handle); //free handle data
559 ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
560 dprintf(("OSS32_WaveOpen. Reopen ret: %i\n", ret));
561 }
562 else
563 {
564 kfree(pHandle);
565 pHandle = opened_handles[i].handle;
566 }
567 break;
568 }
569 }
570 }
571 }
572 else if (ret == 0)
573 {
574 for (i=0; i < 8*256; i++)
575 {
576 if (opened_handles[i].handle == 0)
577 {
578 opened_handles[i].handle = pHandle;
579 opened_handles[i].FileId = fileid;
580 break;
581 }
582 }
583 }
[32]584
[518]585 if(ret) {
586 kfree(pHandle);
587 DebugInt3();
588 rprintf(("OSS32_WaveOpen: open error: %i\n",ret));
589 return UNIXToOSSError(ret);
590 }
591 pHandle->magic = MAGIC_WAVE_ALSA32;
592 if (pStreamId)
593 *pStreamId = (ULONG)pHandle;
594 // filling opened handles table
595 dprintf(("OSS32_WaveOpen. streamid %X\n",(ULONG)pHandle));
596 return OSSERR_SUCCESS;
[32]597}
598//******************************************************************************
599//******************************************************************************
[130]600
[32]601OSSRET OSS32_WaveClose(OSSSTREAMID streamid)
602{
[518]603 soundhandle *pHandle = (soundhandle *)streamid;
604 int ret = 0, i;
[32]605
[518]606 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
607 DebugInt3();
608 rprintf(("OSS32_WaveClose. invalid streamid %X\n",(ULONG)pHandle));
609 return OSSERR_INVALID_STREAMID;
610 }
[32]611
[518]612 //set operation to non-blocking
613 pHandle->file.f_flags = O_NONBLOCK;
[32]614
[518]615 for (i=0; i < 8*256; i++)
616 {
617 if (opened_handles[i].handle == pHandle)
618 {
619 dprintf(("Found phandle for closing: %x reuse flag: %i\n", pHandle, opened_handles[i].reuse));
620 if (!opened_handles[i].reuse)
621 {
622 ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
623 opened_handles[i].handle = 0;
624 kfree(pHandle); //free handle data
625 OSS32_CloseUNI16(); /* say to UNIAUD16 that we closing now */
626 } else
627 {
628 /* prepare for reuse */
[679]629 pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_RESET, 0);
630 pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
[518]631 }
632 break;
633 }
634 }
[32]635
[518]636 if (i >= 8*256)
637 {
638 //all already closed
639 dprintf(("phandle %x not found\n", pHandle));
640// return OSSERR_SUCCESS;
641 }
[32]642
643
[518]644 if(ret) {
645 dprintf(("Error closing wave. rc = %i\n", ret));
646 DebugInt3();
647 return UNIXToOSSError(ret);
648 }
649 dprintf(("OSS32_WaveClose. streamid %X\n", (ULONG)pHandle));
650 return OSSERR_SUCCESS;
[32]651}
652//******************************************************************************
653//******************************************************************************
654OSSRET OSS32_WavePrepare(OSSSTREAMID streamid)
655{
[518]656 soundhandle *pHandle = (soundhandle *)streamid;
657 int ret;
[32]658
[518]659 dprintf(("OSS32_WavePrepare"));
[32]660
[518]661 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
662 DebugInt3();
663 rprintf(("vladest: OSS32_WavePrepare: invalid streamID\n"));
[32]664
[518]665 return OSSERR_INVALID_STREAMID;
666 }
667 //set operation to non-blocking
668 pHandle->file.f_flags = O_NONBLOCK;
[32]669
[679]670 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
[518]671 if (ret)
672 rprintf(("Wave prepare ret = %i, streamid %X\n",ret,(ULONG)pHandle));
[32]673
[518]674 return UNIXToOSSError(ret);;
[32]675}
676//******************************************************************************
677//******************************************************************************
678OSSRET OSS32_WaveStart(OSSSTREAMID streamid)
679{
[518]680 soundhandle *pHandle = (soundhandle *)streamid;
681 int ret;
[32]682
[518]683 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
684 DebugInt3();
685 return OSSERR_INVALID_STREAMID;
686 }
687 //set operation to non-blocking
688 pHandle->file.f_flags = O_NONBLOCK;
[679]689 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_START, 0);
[518]690 if (ret)
691 rprintf(("Wave start ret = %i, streamid %X\n",ret,(ULONG)pHandle));
[32]692
[518]693 return UNIXToOSSError(ret);;
[32]694}
695//******************************************************************************
696//******************************************************************************
697OSSRET OSS32_WaveStop(OSSSTREAMID streamid)
698{
[518]699 soundhandle *pHandle = (soundhandle *)streamid;
700 int ret;
[32]701
[518]702 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
703 DebugInt3();
704 return OSSERR_INVALID_STREAMID;
705 }
706 //set operation to non-blocking
707 pHandle->file.f_flags = O_NONBLOCK;
[32]708
[679]709 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_DROP, 0);
[518]710 if (ret)
711 rprintf(("Wave stop ret = %i. streamid %X\n",ret,(ULONG)pHandle));
[32]712
[518]713 return UNIXToOSSError(ret);;
[32]714}
715//******************************************************************************
716//******************************************************************************
717OSSRET OSS32_WavePause(OSSSTREAMID streamid)
718{
[518]719 soundhandle *pHandle = (soundhandle *)streamid;
720 int ret;
[32]721
[518]722 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
723 DebugInt3();
724 return OSSERR_INVALID_STREAMID;
725 }
726 //set operation to non-blocking
727 pHandle->file.f_flags = O_NONBLOCK;
[32]728
[679]729 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PAUSE, 0);
[518]730 if (ret)
731 rprintf(("Wave pause ret = %i, streamid %X\n",ret,(ULONG)pHandle));
[32]732
[518]733 return UNIXToOSSError(ret);;
[32]734}
735//******************************************************************************
736//******************************************************************************
737OSSRET OSS32_WaveResume(OSSSTREAMID streamid)
738{
[518]739 soundhandle *pHandle = (soundhandle *)streamid;
740 int ret;
[32]741
[518]742 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
743 DebugInt3();
744 return OSSERR_INVALID_STREAMID;
745 }
746 //set operation to non-blocking
747 pHandle->file.f_flags = O_NONBLOCK;
[32]748
[679]749 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PAUSE, 1);
[518]750 if (ret)
751 rprintf(("Wave resume ret = %i, streamid %X\n",ret,(ULONG)pHandle));
[32]752
[518]753 return UNIXToOSSError(ret);;
[32]754}
755
756static unsigned rates[] = {
[518]757 /* ATTENTION: these values depend on the definition in pcm.h! */
758 5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000,
759 64000, 88200, 96000, 176400, 192000
[32]760};
761
762//******************************************************************************
763//******************************************************************************
764OSSRET OSS32_WaveSetHwParams(OSSSTREAMID streamid, OSS32_HWPARAMS *pHwParams)
765{
[518]766 soundhandle *pHandle = (soundhandle *)streamid;
767 struct snd_pcm_hw_params params;
768 struct snd_pcm_sw_params swparams;
769 struct snd_pcm_status status;
[386]770
[518]771 int ret, nrperiods, minnrperiods, maxnrperiods, samplesize,i;
772 ULONG bufsize, periodsize, minperiodsize, maxperiodsize;
773 ULONG periodbytes, minperiodbytes, maxperiodbytes;
774 BOOL fTryAgain = FALSE;
[598]775 //ULONG ulMinRate, ulMaxRate;
[386]776
[518]777 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
[386]778
[518]779 DebugInt3();
780 return OSSERR_INVALID_STREAMID;
781 }
782 if(pHwParams == NULL) {
[386]783
[518]784 DebugInt3();
785 return OSSERR_INVALID_PARAMETER;
786 }
787 if(pHwParams->ulDataType >= OSS32_PCM_MAX_FORMATS) {
[386]788
[518]789 DebugInt3();
790 return OSSERR_INVALID_PARAMETER;
791 }
792 if ((int)pHwParams->ulNumChannels <= 0) {
793 rprintf(("OSS32_WaveSetHwParams error. Invalid number of channels: %i\n", pHwParams->ulNumChannels));
794 DebugInt3();
795 return OSSERR_INVALID_PARAMETER;
796 }
[377]797tryagain:
[518]798 //set operation to non-blocking
799 pHandle->file.f_flags = O_NONBLOCK;
[356]800
[518]801 //size of two samples (adpcm sample can be as small as 4 bits (mono), so take two)
802 samplesize = snd_pcm_format_size(OSSToALSADataType[pHwParams->ulDataType], 1);
803 pHandle->doublesamplesize = samplesize * 2;
804 pHandle->doublesamplesize *= pHwParams->ulNumChannels;
805 periodbytes = pHwParams->ulPeriodSize;
806 periodsize = bytes_to_samples(periodbytes);
807 // checking number of channels
[386]808
[518]809 dprintf(("channels: %ld, period size: %lx",pHwParams->ulNumChannels, periodbytes));
[386]810
[518]811 _snd_pcm_hw_params_any(&params);
812 do {
813 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_ACCESS,
814 SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
815 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_CHANNELS,
816 pHwParams->ulNumChannels, 0);
[679]817 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)&params);
[518]818 if (ret == 0) break;
819 pHwParams->ulNumChannels--;
820 } while(ret < 0 && pHwParams->ulNumChannels > 1);
[386]821
[518]822 dprintf(("channels selected: %d",pHwParams->ulNumChannels));
[32]823
[518]824 //get all hardware parameters
825 _snd_pcm_hw_params_any(&params);
826 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_ACCESS,
827 SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
828 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FORMAT,
829 OSSToALSADataType[pHwParams->ulDataType], 0);
[679]830 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)&params);
[518]831 if(ret != 0) {
832 rprintf(("invalid format %lx\n", OSSToALSADataType[pHwParams->ulDataType]));
833 return UNIXToOSSError(ret);
834 }
835 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
836 pHwParams->ulBitsPerSample, 0);
[679]837 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)&params);
[518]838 if(ret != 0) {
839 rprintf(("invalid number of sample bits %d\n", pHwParams->ulBitsPerSample));
840 return UNIXToOSSError(ret);
841 }
842 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
843 pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
[679]844 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)&params);
[518]845 if(ret != 0) {
846 rprintf(("invalid number of frame bits %d\n", pHwParams->ulBitsPerSample*pHwParams->ulNumChannels));
847 return UNIXToOSSError(ret);
848 }
[377]849
[518]850 //_snd_pcm_hw_params_any(&params);
851 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
852 pHwParams->ulBitsPerSample, 0);
853 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
854 pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
855 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FORMAT,
856 OSSToALSADataType[pHwParams->ulDataType], 0);
857 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_CHANNELS,
858 pHwParams->ulNumChannels, 0);
859 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
860 pHwParams->ulSampleRate, 0);
[679]861 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)&params);
[518]862 if(ret != 0) {
863 rprintf(("32_WSetHwPms (first pass) error %d bps:%d fmt: %d ch: %d sr: %d\n",
864 ret,
865 pHwParams->ulBitsPerSample,
866 OSSToALSADataType[pHwParams->ulDataType],
867 pHwParams->ulNumChannels,
868 pHwParams->ulSampleRate));
869 //printk("OSS32_WaveSetHwParams invalid sample rate %i\n", pHwParams->ulSampleRate);
870 // printk("will set to nearest\n");
871 _snd_pcm_hw_params_any(&params);
872 for (i=0; i<(sizeof(rates)/sizeof(unsigned))-1;i++)
873 {
874 if (pHwParams->ulSampleRate >= rates[i] &&
875 pHwParams->ulSampleRate <= rates[i+1])
876 {
877 pHwParams->ulSampleRate = rates[i];
878 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
879 pHwParams->ulSampleRate, 0);
[679]880 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)&params);
[518]881 if(ret == 0)
882 {
883 _snd_pcm_hw_params_any(&params);
884 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
885 pHwParams->ulBitsPerSample, 0);
886 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
887 pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
888 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FORMAT,
889 OSSToALSADataType[pHwParams->ulDataType], 0);
890 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_CHANNELS,
891 pHwParams->ulNumChannels, 0);
892 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
893 pHwParams->ulSampleRate, 0);
[679]894 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)&params);
[518]895 goto __next;
896 }
897 }
898 }
899 DebugInt3();
900 return UNIXToOSSError(ret);
901 }
[386]902 __next:
[32]903
[518]904 //check period size against lower and upper boundaries
905 minperiodbytes = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_BYTES)->min;
906 maxperiodbytes = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_BYTES)->max;
907 if(periodbytes < minperiodbytes) {
908 periodbytes = minperiodbytes;
909 }
910 else
911 if(periodbytes > maxperiodbytes) {
912 periodbytes = maxperiodbytes;
913 }
[356]914
[518]915 minperiodsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min;
916 maxperiodsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->max;
917 if(periodsize < minperiodsize) {
918 periodsize = minperiodsize;
919 }
920 else
921 if(periodsize > maxperiodsize) {
922 periodsize = maxperiodsize;
923 }
[356]924
[518]925 if(samples_to_bytes(periodsize) < periodbytes) {
926 periodbytes = samples_to_bytes(periodsize);
927 }
928 else
929 if(bytes_to_samples(periodbytes) < periodsize) {
930 periodsize = bytes_to_samples(periodbytes);
931 }
[356]932
[518]933 //make sure period size is a whole fraction of the buffer size
934 bufsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_BUFFER_BYTES)->max;
935 if(periodsize) {
936 nrperiods = bufsize/periodbytes;
937 }
938 else {
939 rprintf(("32_WSHwPrms error. Invalid periodsize (=0). closing file\n"));
940 DebugInt3();
941 return OSSERR_INVALID_PARAMETER;
942 }
943 //check nr of periods against lower and upper boundaries
944 minnrperiods = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIODS)->min;
945 maxnrperiods = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIODS)->max;
946 if(nrperiods < minnrperiods) {
947 nrperiods = minnrperiods;
948 }
949 else
950 if(nrperiods > maxnrperiods) {
951 nrperiods = maxnrperiods;
952 }
953 //an odd nr of periods is not always a good thing (CMedia -> clicks during 8 bps playback),
954 //so we make sure it's an even number.
955 if(nrperiods == 1) {
956 rprintf(("32_WSHwPrms error. Invalid Num periods(=1). closing file\n"));
957 DebugInt3();
958 return OSSERR_INVALID_PARAMETER;
959 }
960 nrperiods &= ~1;
[32]961
[518]962 //initialize parameter block & set sample rate, nr of channels and sample format, nr of periods,
963 //period size and buffer size
[386]964
[518]965 _snd_pcm_hw_params_any(&params);
966 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_ACCESS,
967 SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
968 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
969 pHwParams->ulBitsPerSample, 0);
970 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
971 pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
972 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FORMAT,
973 OSSToALSADataType[pHwParams->ulDataType], 0);
974 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_CHANNELS,
975 pHwParams->ulNumChannels, 0);
976 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
977 pHwParams->ulSampleRate, 0);
[604]978
979 /* Change from Andy. If statement added around 5 statements.
980 * Andy says: TODO: determine why small buffers are a problem for this code
[605]981 * 20100107: DAZ: This change is questionable.
982 * 20180109: DAZ: This changes causes problems for many systems including intermittent
983 * sound and unexpected hangs. Reverted by commenting out the if statement.
[604]984 */
[605]985// if (periodsize > 6 * minperiodsize)
986// {
[518]987 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
988 periodsize, 0);
989 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
990 periodbytes, 0);
991 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_PERIODS,
992 nrperiods, 0);
993 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
994 periodsize*nrperiods, 0);
995 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
996 periodbytes*nrperiods, 0);
[605]997// }
[386]998
[518]999 dprintf(("HWP: SR rate %ld, BPS %ld, CH %ld, PRSZ %lx, periods %lx",
1000 pHwParams->ulSampleRate, pHwParams->ulBitsPerSample, pHwParams->ulNumChannels, periodsize, nrperiods));
[356]1001
[679]1002 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_PARAMS, (ULONG)&params);
[518]1003 if (ret == -77 && fTryAgain == FALSE)
1004 {
[679]1005 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
[518]1006 fTryAgain = TRUE;
1007 rprintf((" Error -77 from first IOCTL HW Parms"));
1008 goto tryagain;
1009 }
[386]1010
[518]1011 if(ret) {
1012 if(fTryAgain == FALSE) {
1013 minperiodsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min;
1014 maxperiodsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->max;
1015 dprintf(("Period size min=%lx max=%lx", minperiodsize, maxperiodsize));
1016 if(minperiodsize > maxperiodsize) {
1017 //ALSA doesn't like the period size; try suggested one
1018 periodsize = maxperiodsize;
1019 periodbytes = samples_to_bytes(periodsize);
[777]1020 dprintf((" Period size error IOCTL HW Parms"));
[518]1021 fTryAgain = TRUE;
1022 goto tryagain;
1023 }
1024 }
1025 rprintf(("Error %ld second time.. Bailing", ret));
1026 return UNIXToOSSError(ret);
1027 }
[32]1028
[518]1029 //set silence threshold (all sizes in frames) (only needed for playback)
1030 if(pHandle->file.f_mode == FMODE_WRITE)
1031 {
1032 swparams.avail_min = periodsize;
1033 swparams.period_step = 1;
1034 if(nrperiods <= 2) {
1035 swparams.silence_size = (periodsize/2);
1036 }
1037 else {
1038 swparams.silence_size = periodsize;
1039 }
1040 swparams.silence_threshold = swparams.silence_size;
1041 swparams.sleep_min = 0;
1042 swparams.start_threshold = 1;
1043 swparams.stop_threshold = periodsize*nrperiods;
1044 swparams.tstamp_mode = SNDRV_PCM_TSTAMP_NONE;
1045 swparams.xfer_align = periodsize;
[32]1046
[679]1047 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_SW_PARAMS, (ULONG)&swparams);
[518]1048 }
[386]1049
[518]1050 total = 0;
1051 per_bytes = periodbytes;
[679]1052 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)&status);
[518]1053 if ( ((status.state != SNDRV_PCM_STATE_PREPARED) &&
1054 (status.state != SNDRV_PCM_STATE_SETUP) &&
1055 (status.state != SNDRV_PCM_STATE_RUNNING) &&
1056 (status.state != SNDRV_PCM_STATE_DRAINING))) {
1057 rprintf(("Device is not in proper state: %lx. Calling prepare\n", status.state));
[679]1058 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
[518]1059 }
1060 return UNIXToOSSError(ret);
[32]1061}
1062
[386]1063
[32]1064//******************************************************************************
[269]1065ULONG CountWv=0;
1066ULONG LockAdd=0;
[518]1067extern ULONG xchg( ULONG *p, ULONG x);
[269]1068#pragma aux xchg = "xchg [esi],eax" parm [ESI][EAX] value [EAX];
[32]1069//******************************************************************************
[518]1070OSSRET OSS32_WaveAddBuffer(OSSSTREAMID streamid, ULONG ulBuffer, ULONG ulReqSize, ULONG *pulTransferred, int pcm)
[32]1071{
[518]1072 soundhandle *pHandle = (soundhandle *)streamid;
1073 struct snd_pcm_status status;
[598]1074 int iRet;
1075 //int align, iRet1;
[518]1076 LONG ulTransferred;
[598]1077 //ULONG ulPosition, ulI, ulJ;
1078 ULONG ulSize;
1079 //char *buf;
[32]1080
[518]1081// return OSSERR_SUCCESS;
[32]1082
[518]1083 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1084 DebugInt3();
1085 return OSSERR_INVALID_STREAMID;
1086 }
1087 if(pulTransferred == NULL || ulBuffer == 0 || ulReqSize == 0) {
1088 DebugInt3();
1089 return OSSERR_INVALID_PARAMETER;
1090 }
[32]1091
[518]1092 //set operation to non-blocking
1093 pHandle->file.f_flags = O_NONBLOCK;
[32]1094
[484]1095 /* get the status of the circular dma buffer */
[679]1096 iRet = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)&status);
[32]1097
[518]1098 if(iRet) {
[484]1099 DebugInt3();
[518]1100 return UNIXToOSSError(iRet);
[484]1101 }
[32]1102
[484]1103 CountWv++;
[518]1104 ulTransferred = 0;
1105 *pulTransferred = 0;
1106 switch(SNDRV_MINOR_DEVICE(MINOR(pHandle->inode.i_rdev-pcm)))
1107 {
1108 case SNDRV_MINOR_PCM_PLAYBACK:
[32]1109
[518]1110#if 1
[484]1111 //first check how much room is left in the circular dma buffer
1112 //this is done to make sure we don't block inside ALSA while trying to write
1113 //more data than fits in the internal dma buffer.
[518]1114 ulSize = min(ulReqSize, samples_to_bytes(status.avail));
[269]1115
[518]1116 if (ulSize == 0) {
[530]1117 rprintf(("OSS32_WaveAddBuffer: no room left in hardware buffer!!"));
1118 rprintf(("state=%x avail=%x ReqSize=%x", status.state, status.avail, ulReqSize));
[518]1119 *pulTransferred = 0;
1120 return OSSERR_BUFFER_FULL;
1121 }
[598]1122
1123 //dprintf(("WaveAddBuffer: ReqSize=%x Size=%x", ulReqSize, ulSize));
[518]1124
[530]1125 //rprintf(("AddBuffer: state=%x avail=%x ReqSize=%x", status.state, status.avail, ulReqSize));
[518]1126 if (status.state == SNDRV_PCM_STATE_XRUN) {
[530]1127 rprintf(("Internal Error: Xrun"));
[679]1128 iRet = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
[530]1129 if (iRet < 0) {
1130 rprintf(("Prepare failed: state=%x avail=%x ReqSize=%x", status.state, status.avail, ulReqSize));
1131 return UNIXToOSSError(iRet);
1132 }
[679]1133 iRet = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)&status);
[530]1134 rprintf(("Xrun restarted: state=%x avail=%x ReqSize=%x", status.state, status.avail, ulReqSize));
1135 if (iRet < 0) return UNIXToOSSError(iRet);
[518]1136 }
1137
1138 iRet = pHandle->file.f_op->write(&pHandle->file, (char *)ulBuffer, ulSize, &pHandle->file.f_pos);
1139
[530]1140 if (iRet != ulSize) rprintf(("WaveAddBuffer: ReqSize=%x Size=%x iRet=%x", ulReqSize, ulSize, iRet));
[528]1141
[530]1142 if (iRet < 0) return UNIXToOSSError(iRet);
[518]1143 ulTransferred = iRet;
1144#else
1145 //first check how much room is left in the circular dma buffer
1146 //this is done to make sure we don't block inside ALSA while trying to write
1147 //more data than fits in the internal dma buffer.
1148 ulSize = min(ulReqSize, samples_to_bytes(status.avail));
1149
[530]1150 //printk("OSS32_WaveAddBuffer N:%d hw=%x app=%x avail=%x req size=%x size=%x",
[518]1151 // CountWv, samples_to_bytes(status.hw_ptr), samples_to_bytes(status.appl_ptr), samples_to_bytes(status.avail), ulSize, ulReqSize);
[32]1152
[518]1153 if (ulSize == 0) {
[530]1154 rprintf(("OSS32_WaveAddBuffer: no room left in hardware buffer!!"));
1155 rprintf(("state=%x avail=%x SizeReq=%x", status.state, status.avail, ulReqSize));
[518]1156 *pulTransferred = 0;
1157 return OSSERR_BUFFER_FULL;
1158 }
[32]1159
[530]1160 rprintf(("WaveAddBuffer: ReqSize=%x Size=%x", ulReqSize, ulSize));
[528]1161
[484]1162 // size should be aligned to channels number * samplesize //PS+++ what is it and why?!?!?!
[518]1163 ulJ = 10; // 10 try if error
1164 iRet = -11;
[528]1165 while (ulSize && ulJ && iRet) {
1166 for (ulI=0; ulI < 1000; ulI++) {
[679]1167 iRet1 = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)&status);
[484]1168 // If here any state and have free buffer to any byte
1169 if ((status.state != SNDRV_PCM_STATE_XRUN ) && samples_to_bytes(status.avail) ) break;
[518]1170 if (status.state == SNDRV_PCM_STATE_XRUN) {
[530]1171 rprintf(("Internal Error: Xrun"));
[518]1172 }
1173 if (ulI > 998) {
[528]1174 rprintf(("timeout state=%x avail=%d hw=%d app=%d",status.state,samples_to_bytes(status.avail),samples_to_bytes(status.hw_ptr), samples_to_bytes(status.appl_ptr)));
[679]1175 iRet1 = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
[484]1176 }
1177 }
[32]1178
[518]1179 if (iRet1 < 0) {
[530]1180 rprintf(("iRet1=%i trans=%x ReqSize=%x Size=%x", iRet1, ulTransferred, ulReqSize, ulSize));
[518]1181 break; // We have any global error, don't try more
[484]1182 }
[32]1183
[518]1184 iRet = pHandle->file.f_op->write(&pHandle->file, (char *)ulBuffer, ulSize, &pHandle->file.f_pos);
[528]1185 rprintf(("J=%x iRet=%x", ulJ, iRet));
[32]1186
[518]1187 if (iRet < 0 ) { // We have any error, don't try more
1188 ulJ--;
[528]1189 rprintf(("Error ret=%i ret1=%i trans=%x ReqSize=%x Size=%x", iRet, iRet1, ulTransferred, ulReqSize, ulSize));
1190 if ( iRet != -11 ) {
1191 rprintf(("Doing prepare"));
[679]1192 iRet1 = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
[528]1193 }
[484]1194 continue;
1195 }
[528]1196 if (iRet == 0) {
1197 continue;
1198 }
[518]1199 ulTransferred += iRet;
[530]1200 // printk("written: now: %d, trans: %d need %d tot:%d", iRet, ulTransferred, ulReqSize,ulSize);
[518]1201 ulBuffer += iRet;
1202 if (ulSize > iRet) ulSize -= iRet;
1203 else ulSize = 0;
[484]1204 }
[518]1205#endif
1206 break;
1207 case SNDRV_MINOR_PCM_CAPTURE:
[530]1208 //printk("OSS32_WaveAddBuffer N:%d state=%x hw=%x app=%x avail=%x size=%x",
[518]1209 // CountWv, status.state, samples_to_bytes(status.hw_ptr), samples_to_bytes(status.appl_ptr), samples_to_bytes(status.avail), ulReqSize);
[484]1210// Need to handle overrun condition when reading
1211// if (status.state == SNDRV_PCM_STATE_XRUN) {
[518]1212// *pulTransferred = 0;
[484]1213// return OSSERR_BUFFER_FULL;
1214// }
[518]1215 iRet = pHandle->file.f_op->read(&pHandle->file, (char *)ulBuffer, ulReqSize, &pHandle->file.f_pos);
1216 if (iRet < 0) {
1217 *pulTransferred = 0;
[484]1218 return OSSERR_BUFFER_FULL;
1219 }
[518]1220 ulTransferred = iRet;
1221 break;
1222 default:
1223 DebugInt3();
1224 return OSSERR_INVALID_PARAMETER;
1225 }
[32]1226
[518]1227 total += ulTransferred;
1228 *pulTransferred = ulTransferred;
1229 prev_size = ulTransferred;
1230// if (*pulTransferred < ulSize)
1231// {
[530]1232// printk("warning: ulTransferred [%d] less than requested [%d]", *pulTransferred, ulSize);
[679]1233// iRet1 = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
[518]1234// }
[32]1235
[518]1236 return OSSERR_SUCCESS;
[32]1237}
1238//******************************************************************************
1239//******************************************************************************
1240OSSRET OSS32_WaveGetPosition(ULONG streamid, ULONG *pPosition)
1241{
[518]1242 soundhandle *pHandle = (soundhandle *)streamid;
1243 struct snd_pcm_status status;
1244 int ret;
[32]1245
[518]1246 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1247 DebugInt3();
1248 return OSSERR_INVALID_STREAMID;
1249 }
1250 if(pPosition == NULL) {
1251 DebugInt3();
1252 return OSSERR_INVALID_PARAMETER;
1253 }
[32]1254
[518]1255 //set operation to non-blocking
1256 pHandle->file.f_flags = O_NONBLOCK;
[32]1257
[518]1258 //Get the status of the stream
[679]1259 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)&status);
[32]1260
[518]1261 if(ret) {
1262 DebugInt3();
1263 return UNIXToOSSError(ret);
1264 }
[32]1265
[518]1266 dprintf2(("OSS32_WaveGetPosition: hardware %x application %x", samples_to_bytes(status.hw_ptr), samples_to_bytes(status.appl_ptr)));
1267 *pPosition = samples_to_bytes(status.hw_ptr); //return new hardware position
1268 return OSSERR_SUCCESS;
[32]1269}
1270//******************************************************************************
1271//******************************************************************************
1272OSSRET OSS32_WaveGetSpace(ULONG streamid, ULONG *pBytesAvail)
1273{
[518]1274 soundhandle *pHandle = (soundhandle *)streamid;
1275 struct snd_pcm_status status;
1276 int ret;
[32]1277
[518]1278 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1279 DebugInt3();
1280 return OSSERR_INVALID_STREAMID;
1281 }
1282 if(pBytesAvail == NULL) {
1283 DebugInt3();
1284 return OSSERR_INVALID_PARAMETER;
1285 }
[32]1286
[518]1287 //set operation to non-blocking
1288 pHandle->file.f_flags = O_NONBLOCK;
[32]1289
[518]1290 //Get the nr of bytes left in the audio buffer
[679]1291 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)&status);
[32]1292
[518]1293 if(ret) {
1294 DebugInt3();
1295 return UNIXToOSSError(ret);
1296 }
1297 ret = samples_to_bytes(status.avail);
[305]1298
[518]1299 *pBytesAvail = ret;
1300 return OSSERR_SUCCESS;
[32]1301}
1302//******************************************************************************
1303//******************************************************************************
[386]1304OSSRET OSS32_WaveGetHwPtr(ULONG streamid, ULONG *pPosition)
1305{
[518]1306 soundhandle *pHandle = (soundhandle *)streamid;
1307 struct snd_pcm_status status;
1308 int ret;
[386]1309
[518]1310 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1311 DebugInt3();
1312 return OSSERR_INVALID_STREAMID;
1313 }
1314 if(pPosition == NULL) {
1315 DebugInt3();
1316 return OSSERR_INVALID_PARAMETER;
1317 }
[386]1318
[518]1319 //set operation to non-blocking
1320 pHandle->file.f_flags = O_NONBLOCK;
[386]1321
[518]1322 //Get the status of the stream
[679]1323 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)&status);
[386]1324
[518]1325 if(ret) {
1326 DebugInt3();
1327 return UNIXToOSSError(ret);
1328 }
[386]1329
[518]1330 *pPosition = samples_to_bytes(status.appl_ptr); //return new hardware position
1331 return OSSERR_SUCCESS;
[386]1332}
[493]1333//******************************************************************************
1334//******************************************************************************
1335OSSRET OSS32_WaveGetStatus(ULONG streamid, ULONG *pStatus)
1336{
[535]1337 struct snd_pcm_status status;
[518]1338 soundhandle *pHandle = (soundhandle *)streamid;
1339 int ret;
[386]1340
[518]1341 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1342 DebugInt3();
1343 return OSSERR_INVALID_STREAMID;
1344 }
1345 if(pStatus == NULL) {
1346 DebugInt3();
1347 return OSSERR_INVALID_PARAMETER;
1348 }
[493]1349
[518]1350 //set operation to non-blocking
1351 pHandle->file.f_flags = O_NONBLOCK;
[493]1352
[518]1353 //Get the status of the stream
[679]1354 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)&status);
[535]1355 if(ret) return UNIXToOSSError(ret);
1356 *pStatus = status.state;
[493]1357
[518]1358 return OSSERR_SUCCESS;
[493]1359}
[386]1360//******************************************************************************
1361//******************************************************************************
[32]1362OSSRET OSS32_WaveSetVolume(OSSSTREAMID streamid, ULONG volume)
1363{
[518]1364 soundhandle *pHandle = (soundhandle *)streamid;
1365 int ret;
1366 int leftvol, rightvol;
1367 struct snd_pcm_volume pcm_volume;
[32]1368
[518]1369 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1370 DebugInt3();
1371 return OSSERR_INVALID_STREAMID;
1372 }
1373 //set operation to non-blocking
1374 pHandle->file.f_flags = O_NONBLOCK;
[32]1375
[518]1376 leftvol = GET_VOLUME_L(volume);
1377 rightvol = GET_VOLUME_R(volume);
[32]1378
[518]1379 pcm_volume.nrchannels = 4;
1380 pcm_volume.volume[SNDRV_PCM_VOL_FRONT_LEFT] = leftvol;
1381 pcm_volume.volume[SNDRV_PCM_VOL_FRONT_RIGHT] = rightvol;
1382 pcm_volume.volume[SNDRV_PCM_VOL_REAR_LEFT] = leftvol;
1383 pcm_volume.volume[SNDRV_PCM_VOL_REAR_RIGHT] = rightvol;
[32]1384
[518]1385 dprintf(("OSS32_WaveSetVolume %x to (%d,%d)", streamid, leftvol, rightvol));
[679]1386 ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_SETVOLUME, (ULONG)&pcm_volume);
[518]1387 return UNIXToOSSError(ret);
[32]1388}
1389//******************************************************************************
1390
Note: See TracBrowser for help on using the repository browser.