source: GPL/branches/uniaud32-next/lib32/sound.c@ 621

Last change on this file since 621 was 621, checked in by Paul Smedley, 5 years ago

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