source: GPL/branches/uniaud32-2.0/lib32/sound.c@ 356

Last change on this file since 356 was 356, checked in by Paul Smedley, 17 years ago

test fix to see if reverting OSS32_SetHwParams to original Innotek version fixes HDA for all users
File size: 45.1 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 "soundoss.h"
39
40#undef samples_to_bytes
41#undef bytes_to_samples
42#define samples_to_bytes(a) ((a*pHandle->doublesamplesize)/2)
43#define bytes_to_samples(a) (pHandle->doublesamplesize ? ((a*2)/pHandle->doublesamplesize) : a)
44int GetMaxChannels(ULONG deviceid, int type);
45
46struct file_operations oss_devices[OSS32_MAX_DEVICES] = {0};
47struct file_operations *alsa_fops = NULL;
48int per_bytes = 0;
49int prev_size = 0;
50int pcm_device = 0;
51int total = 0;
52// int pcm_instances = 0; //PS+++ !!!!!!! what is it!!!! see pcm.lib
53
54OpenedHandles opened_handles[8 * 256] = {0};
55
56//OSS32 to ALSA datatype conversion table
57static int OSSToALSADataType[OSS32_PCM_MAX_FORMATS] = {
58/* OSS32_PCM_FORMAT_S8 */ SNDRV_PCM_FORMAT_S8, //signed 8 bits sample
59/* OSS32_PCM_FORMAT_U8 */ SNDRV_PCM_FORMAT_U8, //unsigned 8 bits sample
60/* OSS32_PCM_FORMAT_S16_LE */ SNDRV_PCM_FORMAT_S16_LE, //signed 16 bits sample (little endian/Intel)
61/* OSS32_PCM_FORMAT_S16_BE */ SNDRV_PCM_FORMAT_S16_BE, //signed 16 bits sample (big endian/Motorola)
62/* OSS32_PCM_FORMAT_U16_LE */ SNDRV_PCM_FORMAT_U16_LE, //unsigned 16 bits sample (little endian/Intel)
63/* OSS32_PCM_FORMAT_U16_BE */ SNDRV_PCM_FORMAT_U16_BE, //unsigned 16 bits sample (big endian/Motorola)
64/* OSS32_PCM_FORMAT_S24_LE */ SNDRV_PCM_FORMAT_S24_LE, //signed 24 bits sample (little endian/Intel)
65/* OSS32_PCM_FORMAT_S24_BE */ SNDRV_PCM_FORMAT_S24_BE, //signed 24 bits sample (big endian/Motorola)
66/* OSS32_PCM_FORMAT_U24_LE */ SNDRV_PCM_FORMAT_U24_LE, //unsigned 24 bits sample (little endian/Intel)
67/* OSS32_PCM_FORMAT_U24_BE */ SNDRV_PCM_FORMAT_U24_BE, //unsigned 24 bits sample (big endian/Motorola)
68/* OSS32_PCM_FORMAT_S32_LE */ SNDRV_PCM_FORMAT_S32_LE, //signed 32 bits sample (little endian/Intel)
69/* OSS32_PCM_FORMAT_S32_BE */ SNDRV_PCM_FORMAT_S32_BE, //signed 32 bits sample (big endian/Motorola)
70/* OSS32_PCM_FORMAT_U32_LE */ SNDRV_PCM_FORMAT_U32_LE, //unsigned 32 bits sample (little endian/Intel)
71/* OSS32_PCM_FORMAT_U32_BE */ SNDRV_PCM_FORMAT_U32_BE, //unsigned 32 bits sample (big endian/Motorola)
72/* OSS32_PCM_FORMAT_MULAW */ SNDRV_PCM_FORMAT_MU_LAW, //8 bps (compressed 16 bits sample)
73/* OSS32_PCM_FORMAT_ALAW */ SNDRV_PCM_FORMAT_A_LAW, //8 bps (compressed 16 bits sample)
74/* OSS32_PCM_FORMAT_ADPCM */ SNDRV_PCM_FORMAT_IMA_ADPCM, //4 bps (compressed 16 bits sample)
75/* OSS32_PCM_FORMAT_MPEG */ SNDRV_PCM_FORMAT_MPEG, //AC3?
76};
77
78//******************************************************************************
79//******************************************************************************
80int register_chrdev(unsigned int version, const char *name, struct file_operations *fsop)
81{
82 if(!strcmp(name, "alsa")) {
83 alsa_fops = fsop;
84 }
85 return 0;
86}
87//******************************************************************************
88//******************************************************************************
89int unregister_chrdev(unsigned int version, const char *name)
90{
91 if(!strcmp(name, "alsa")) {
92 alsa_fops = NULL;
93 }
94 return 0;
95}
96//******************************************************************************
97//******************************************************************************
98int register_sound_special(struct file_operations *fops, int unit)
99{
100 if(fops == NULL) return -1;
101
102 memcpy(&oss_devices[OSS32_SPECIALID], fops, sizeof(struct file_operations));
103 return OSS32_SPECIALID;
104}
105//******************************************************************************
106//******************************************************************************
107int register_sound_mixer(struct file_operations *fops, int dev)
108{
109 if(fops == NULL) return -1;
110
111 memcpy(&oss_devices[OSS32_MIXERID], fops, sizeof(struct file_operations));
112 return OSS32_MIXERID;
113}
114//******************************************************************************
115//******************************************************************************
116int register_sound_midi(struct file_operations *fops, int dev)
117{
118 if(fops == NULL) return -1;
119
120 memcpy(&oss_devices[OSS32_MIDIID], fops, sizeof(struct file_operations));
121 return OSS32_MIDIID;
122}
123//******************************************************************************
124//******************************************************************************
125int register_sound_dsp(struct file_operations *fops, int dev)
126{
127 if(fops == NULL) return -1;
128
129 memcpy(&oss_devices[OSS32_DSPID], fops, sizeof(struct file_operations));
130 return OSS32_DSPID;
131}
132//******************************************************************************
133//******************************************************************************
134int register_sound_synth(struct file_operations *fops, int dev)
135{
136 if(fops == NULL) return -1;
137
138 memcpy(&oss_devices[OSS32_SYNTHID], fops, sizeof(struct file_operations));
139 return OSS32_SYNTHID;
140}
141//******************************************************************************
142//******************************************************************************
143void unregister_sound_special(int unit)
144{
145 memset(&oss_devices[OSS32_SPECIALID], 0, sizeof(struct file_operations));
146}
147//******************************************************************************
148//******************************************************************************
149void unregister_sound_mixer(int unit)
150{
151 memset(&oss_devices[OSS32_MIXERID], 0, sizeof(struct file_operations));
152}
153//******************************************************************************
154//******************************************************************************
155void unregister_sound_midi(int unit)
156{
157 memset(&oss_devices[OSS32_MIDIID], 0, sizeof(struct file_operations));
158}
159//******************************************************************************
160//******************************************************************************
161void unregister_sound_dsp(int unit)
162{
163 memset(&oss_devices[OSS32_DSPID], 0, sizeof(struct file_operations));
164}
165//******************************************************************************
166//******************************************************************************
167void unregister_sound_synth(int unit)
168{
169 memset(&oss_devices[OSS32_SYNTHID], 0, sizeof(struct file_operations));
170}
171//******************************************************************************
172//******************************************************************************
173OSSRET UNIXToOSSError(int unixerror)
174{
175 switch(unixerror) {
176 case 0:
177 return OSSERR_SUCCESS;
178 case -ENOMEM:
179 return OSSERR_OUT_OF_MEMORY;
180 case -ENODEV:
181 return OSSERR_NO_DEVICE_AVAILABLE;
182 case -ENOTTY:
183 case -EINVAL:
184 return OSSERR_INVALID_PARAMETER;
185 case -EAGAIN:
186 return OSSERR_AGAIN; //????
187 case -ENXIO:
188 return OSSERR_IO_ERROR;
189 case -EBUSY:
190 return OSSERR_BUSY;
191 case -EPERM:
192 return OSSERR_ACCESS_DENIED; //??
193 case -EPIPE:
194 case -EBADFD:
195 return OSSERR_ACCESS_DENIED; //??
196 default:
197 dprintf(("Unknown error %d", (unixerror > 0) ? unixerror : -unixerror));
198 return OSSERR_UNKNOWN;
199 }
200}
201//******************************************************************************
202//ALSA to OSS32 datatype conversion
203//******************************************************************************
204int ALSAToOSSDataType(ULONG ALSADataType)
205{
206 switch(ALSADataType)
207 {
208 case SNDRV_PCM_FORMAT_S8:
209 return OSS32_CAPS_PCM_FORMAT_S8; //signed 8 bits sample
210 case SNDRV_PCM_FORMAT_U8:
211 return OSS32_CAPS_PCM_FORMAT_U8; //unsigned 8 bits sample
212 case SNDRV_PCM_FORMAT_S16_LE:
213 return OSS32_CAPS_PCM_FORMAT_S16_LE; //signed 16 bits sample (little endian/Intel)
214 case SNDRV_PCM_FORMAT_S16_BE:
215 return OSS32_CAPS_PCM_FORMAT_S16_BE; //signed 16 bits sample (big endian/Motorola)
216 case SNDRV_PCM_FORMAT_U16_LE:
217 return OSS32_CAPS_PCM_FORMAT_U16_LE; //unsigned 16 bits sample (little endian/Intel)
218 case SNDRV_PCM_FORMAT_U16_BE:
219 return OSS32_CAPS_PCM_FORMAT_U16_BE; //unsigned 16 bits sample (big endian/Motorola)
220 case SNDRV_PCM_FORMAT_S24_LE:
221 return OSS32_CAPS_PCM_FORMAT_S24_LE; //signed 24 bits sample (little endian/Intel)
222 case SNDRV_PCM_FORMAT_S24_BE:
223 return OSS32_CAPS_PCM_FORMAT_S24_BE; //signed 24 bits sample (big endian/Motorola)
224 case SNDRV_PCM_FORMAT_U24_LE:
225 return OSS32_CAPS_PCM_FORMAT_U24_LE; //unsigned 24 bits sample (little endian/Intel)
226 case SNDRV_PCM_FORMAT_U24_BE:
227 return OSS32_CAPS_PCM_FORMAT_U24_BE; //unsigned 16 bits sample (big endian/Motorola)
228 case SNDRV_PCM_FORMAT_S32_LE:
229 return OSS32_CAPS_PCM_FORMAT_S32_LE; //signed 32 bits sample (little endian/Intel)
230 case SNDRV_PCM_FORMAT_S32_BE:
231 return OSS32_CAPS_PCM_FORMAT_S32_BE; //signed 32 bits sample (big endian/Motorola)
232 case SNDRV_PCM_FORMAT_U32_LE:
233 return OSS32_CAPS_PCM_FORMAT_U32_LE; //unsigned 32 bits sample (little endian/Intel)
234 case SNDRV_PCM_FORMAT_U32_BE:
235 return OSS32_CAPS_PCM_FORMAT_U32_BE; //unsigned 32 bits sample (big endian/Motorola)
236 case SNDRV_PCM_FORMAT_MU_LAW:
237 return OSS32_CAPS_PCM_FORMAT_MULAW; //8 bps (compressed 16 bits sample)
238 case SNDRV_PCM_FORMAT_A_LAW:
239 return OSS32_CAPS_PCM_FORMAT_ALAW; //8 bps (compressed 16 bits sample)
240 case SNDRV_PCM_FORMAT_IMA_ADPCM:
241 return OSS32_CAPS_PCM_FORMAT_ADPCM; //4 bps (compressed 16 bits sample)
242 case SNDRV_PCM_FORMAT_MPEG:
243 return OSS32_CAPS_PCM_FORMAT_MPEG; //AC3?
244 default:
245 DebugInt3();
246 return -1;
247 }
248}
249//******************************************************************************
250//******************************************************************************
251ULONG ALSAToOSSRateFlags(ULONG fuRates)
252{
253 ULONG fuOSSRates = 0;
254
255 if(fuRates & SNDRV_PCM_RATE_5512) {
256 fuOSSRates |= OSS32_CAPS_PCM_RATE_5512;
257 }
258 if(fuRates & SNDRV_PCM_RATE_8000) {
259 fuOSSRates |= OSS32_CAPS_PCM_RATE_8000;
260 }
261 if(fuRates & SNDRV_PCM_RATE_11025) {
262 fuOSSRates |= OSS32_CAPS_PCM_RATE_11025;
263 }
264 if(fuRates & SNDRV_PCM_RATE_16000) {
265 fuOSSRates |= OSS32_CAPS_PCM_RATE_16000;
266 }
267 if(fuRates & SNDRV_PCM_RATE_22050) {
268 fuOSSRates |= OSS32_CAPS_PCM_RATE_22050;
269 }
270 if(fuRates & SNDRV_PCM_RATE_32000) {
271 fuOSSRates |= OSS32_CAPS_PCM_RATE_32000;
272 }
273 if(fuRates & SNDRV_PCM_RATE_44100) {
274 fuOSSRates |= OSS32_CAPS_PCM_RATE_44100;
275 }
276 if(fuRates & SNDRV_PCM_RATE_48000) {
277 fuOSSRates |= OSS32_CAPS_PCM_RATE_48000;
278 }
279#if 0
280 if(fuRates & SNDRV_PCM_RATE_64000) {
281 fuOSSRates |= OSS32_CAPS_PCM_RATE_64000;
282 }
283 if(fuRates & SNDRV_PCM_RATE_88200) {
284 fuOSSRates |= OSS32_CAPS_PCM_RATE_88200;
285 }
286 if(fuRates & SNDRV_PCM_RATE_96000) {
287 fuOSSRates |= OSS32_CAPS_PCM_RATE_96000;
288 }
289 if(fuRates & SNDRV_PCM_RATE_176400) {
290 fuOSSRates |= OSS32_CAPS_PCM_RATE_176400;
291 }
292 if(fuRates & SNDRV_PCM_RATE_192000) {
293 fuOSSRates |= OSS32_CAPS_PCM_RATE_192000;
294 }
295#endif
296 if(fuRates & SNDRV_PCM_RATE_CONTINUOUS) {
297 fuOSSRates |= OSS32_CAPS_PCM_RATE_CONTINUOUS;
298 }
299
300 //TODO:
301 if(fuRates & SNDRV_PCM_RATE_KNOT) {
302 DebugInt3();
303 }
304//#define OSS32_CAPS_PCM_RATE_KNOT (1<<31) /* supports more non-continuos rates */
305
306 return fuOSSRates;
307}
308//******************************************************************************
309//******************************************************************************
310OSSRET OSS32_QueryDevCaps(ULONG deviceid, POSS32_DEVCAPS pDevCaps)
311{
312 OSSSTREAMID streamid = 0;
313 soundhandle *pHandle;
314 struct snd_pcm_info *pcminfo = NULL;
315 struct snd_pcm_hw_params *params;
316 int ret, fmt, i;
317 ULONG format_mask;
318 struct snd_mask *mask;
319 int max_ch;
320
321#ifdef DEBUG
322 dprintf(("OSS32_QueryDevCaps"));
323#endif
324// max_ch = GetMaxChannels(deviceid, OSS32_CAPS_WAVE_PLAYBACK);
325
326 //these structures are too big to put on the stack
327 pcminfo = (struct snd_pcm_info *)kmalloc(sizeof(struct snd_pcm_info)+sizeof(struct snd_pcm_hw_params), GFP_KERNEL);
328 if(pcminfo == NULL) {
329 DebugInt3();
330 printk("OSS32_QueryDevCaps: out of memory\n");
331 return OSSERR_OUT_OF_MEMORY;
332 }
333 params = (struct snd_pcm_hw_params *)(pcminfo+1);
334
335 printk("Number of cards: %i",nrCardsDetected);
336 printk("dev id: %i",deviceid);
337 pDevCaps->nrDevices = 1;//nrCardsDetected;
338 pDevCaps->ulCaps = OSS32_CAPS_WAVE_PLAYBACK | OSS32_CAPS_WAVE_CAPTURE;
339
340 //query wave in & out caps
341 for(i=0;i<2;i++)
342 {
343 PWAVE_CAPS pWaveCaps = (i == 0) ? &pDevCaps->waveOutCaps : &pDevCaps->waveInCaps;
344
345 ret = OSS32_WaveOpen(deviceid, (i == 0) ? OSS32_STREAM_WAVEOUT : OSS32_STREAM_WAVEIN, &streamid, 0, 0);
346 if(ret != OSSERR_SUCCESS)
347 {
348 printk("OSS32_QueryDevCaps: wave open error %i\n", ret);
349 DebugInt3();
350 goto fail;
351 }
352 pHandle = (soundhandle *)streamid;
353 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
354 printk("OSS32_QueryDevCaps: invalid stream id \n");
355 ret = OSSERR_INVALID_STREAMID;
356 goto fail;
357 }
358 //set operation to non-blocking
359 pHandle->file.f_flags = O_NONBLOCK;
360
361 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_INFO, (ULONG)pcminfo);
362 if(ret != 0) {
363 printk("OSS32_QueryDevCaps: SNDRV_PCM_IOCTL_INFO error %i\n", ret);
364 ret = UNIXToOSSError(ret);
365 goto fail;
366 }
367 if(i == 0) {//only need to do this once
368 if(pcminfo->name[0]) {
369 strncpy(pDevCaps->szDeviceName, pcminfo->name, sizeof(pDevCaps->szDeviceName));
370 }
371 else strncpy(pDevCaps->szDeviceName, pcminfo->id, sizeof(pDevCaps->szDeviceName));
372 }
373 printk("Device name: %s", pDevCaps->szDeviceName);
374 pWaveCaps->nrStreams = pcminfo->subdevices_count;
375
376 //get all hardware parameters
377 _snd_pcm_hw_params_any(params);
378 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
379 if(ret != 0) {
380 printk("OSS32_QueryDevCaps: SNDRV_PCM_IOCTL_HW_REFINE error %i\n", ret);
381 ret = UNIXToOSSError(ret);
382 goto fail;
383 }
384
385 pWaveCaps->ulMinChannels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min;
386 pWaveCaps->ulMaxChannels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max;
387 pWaveCaps->ulChanFlags = 0;
388 if(pWaveCaps->ulMinChannels == 1) {
389 pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_MONO;
390 }
391 if(pWaveCaps->ulMaxChannels >= 2) {
392 pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_STEREO;
393 }
394 if(pWaveCaps->ulMaxChannels >= 4) {
395 pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_QUAD;
396 }
397 if(pWaveCaps->ulMaxChannels >= 6) {
398 pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_5_1;
399 }
400
401 pWaveCaps->ulMinRate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min;
402 pWaveCaps->ulMaxRate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max;
403
404 mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
405 printk("rate flags1: %X", mask);
406
407 mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_RATE_MASK);
408 printk("rate flags2: %X", mask);
409
410 pWaveCaps->ulRateFlags = mask->bits[0];
411
412 printk("rate flags3: %X", pWaveCaps->ulRateFlags);
413 pWaveCaps->ulRateFlags = ALSAToOSSRateFlags(pWaveCaps->ulRateFlags);
414
415 printk("rate flags4: %X", pWaveCaps->ulRateFlags);
416
417 pWaveCaps->ulDataFormats = 0;
418
419 mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
420 format_mask = mask->bits[0];
421 for(fmt=0;fmt<32;fmt++)
422 {
423 if(format_mask & (1 << fmt))
424 {
425 int f = ALSAToOSSDataType(fmt);
426 if (f >= 0)
427 pWaveCaps->ulDataFormats |= f;
428 }
429 }
430
431 OSS32_WaveClose(streamid);
432 streamid = 0;
433
434 }
435 //Check support for MPU401, FM & Wavetable MIDI
436 if(OSS32_MidiOpen(deviceid, OSS32_STREAM_MPU401_MIDIOUT, &streamid) == OSSERR_SUCCESS)
437 {
438 pDevCaps->ulCaps |= OSS32_CAPS_MPU401_PLAYBACK;
439 OSS32_MidiClose(streamid);
440 streamid = 0;
441 }
442 if(OSS32_MidiOpen(deviceid, OSS32_STREAM_MPU401_MIDIIN, &streamid) == OSSERR_SUCCESS)
443 {
444 pDevCaps->ulCaps |= OSS32_CAPS_MPU401_CAPTURE;
445 OSS32_MidiClose(streamid);
446 streamid = 0;
447 }
448 if(OSS32_MidiOpen(deviceid, OSS32_STREAM_FM_MIDIOUT, &streamid) == OSSERR_SUCCESS)
449 {
450 pDevCaps->ulCaps |= OSS32_CAPS_FMSYNTH_PLAYBACK;
451 OSS32_MidiClose(streamid);
452 streamid = 0;
453 }
454 if(OSS32_MidiOpen(deviceid, OSS32_STREAM_WAVETABLE_MIDIOUT, &streamid) == OSSERR_SUCCESS)
455 {
456 pDevCaps->ulCaps |= OSS32_CAPS_WAVETABLE_PLAYBACK;
457 OSS32_MidiClose(streamid);
458 streamid = 0;
459 }
460 if(OSS32_MixQueryName(deviceid, &pDevCaps->szMixerName, sizeof(pDevCaps->szMixerName)) != OSSERR_SUCCESS) {
461 DebugInt3();
462 printk("OSS32_QueryDevCaps: OSS32_MixQueryName error\n");
463 goto fail;
464 }
465 printk("OSS32_QueryDevCaps: devname: [%s]\n", pDevCaps->szDeviceName);
466 kfree(pcminfo);
467 streamid = 0;
468
469
470 return OSSERR_SUCCESS;
471
472fail:
473 printk("OSS32_QueryDevCaps failed\n");
474 DebugInt3();
475 if(streamid) OSS32_WaveClose(streamid);
476 if(pcminfo) kfree(pcminfo);
477
478 return ret;
479}
480//******************************************************************************
481//******************************************************************************
482OSSRET OSS32_WaveOpen(ULONG deviceid, ULONG streamtype, OSSSTREAMID *pStreamId, int pcm, USHORT fileid)
483{
484 soundhandle *pHandle;
485 int ret,i;
486
487 if (pStreamId)
488 *pStreamId = 0;
489 else
490 {
491 printk("ERROR: invalid stream id pointer passed\n");
492 return OSSERR_OUT_OF_MEMORY;
493 }
494
495 if(alsa_fops == NULL) {
496 DebugInt3();
497#ifdef DEBUG
498 dprintf(("OSS32_WaveOpen: no devices"));
499#endif
500 printk("OSS32_WaveOpen: no devices\n");
501
502 return OSSERR_NO_DEVICE_AVAILABLE;
503 }
504
505// printk("dev id: %i\n",deviceid);
506
507 pHandle = kmalloc(sizeof(soundhandle), GFP_KERNEL);
508 if(pHandle == NULL) {
509 DebugInt3();
510 printk("OSS32_WaveOpen: out of memory\n");
511 return OSSERR_OUT_OF_MEMORY;
512 }
513 memset(pHandle, 0, sizeof(soundhandle));
514
515 //set operation to non-blocking
516 pHandle->file.f_flags = O_NONBLOCK;
517
518 //setup pointers in file structure (used internally by ALSA)
519 pHandle->file.f_dentry = &pHandle->d_entry;
520 pHandle->file.f_dentry->d_inode = &pHandle->inode;
521
522 switch(streamtype) {
523 case OSS32_STREAM_WAVEOUT:
524 pHandle->file.f_mode = FMODE_WRITE;
525 pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_PCM_PLAYBACK) + pcm;
526 break;
527 case OSS32_STREAM_WAVEIN:
528 pHandle->file.f_mode = FMODE_READ;
529 pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_PCM_CAPTURE) + pcm;
530 break;
531 default:
532 DebugInt3();
533 kfree(pHandle);
534 printk("OSS32_WaveOpen: invalid parameter\n");
535 return OSSERR_INVALID_PARAMETER;
536 }
537
538 ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
539 printk("OSS32_WaveOpen. ret: %i\n", ret);
540 /* check if PCM already opened (stupid uniaud16.sys doesnt closes it) */
541 if (ret == -16)
542 {
543 for (i=0; i < 8*256; i++)
544 {
545 if (opened_handles[i].handle != 0)
546 {
547 ret = 0;
548 if (pStreamId)
549 *pStreamId = (ULONG)opened_handles[i].handle;
550 opened_handles[i].reuse = 1; /* try to reuse */
551 if (OSS32_WaveClose((OSSSTREAMID)opened_handles[i].handle) == 0)
552 {
553 if (!opened_handles[i].reuse)
554 {
555 //opened_handles[i].handle = 0;
556 kfree(opened_handles[i].handle); //free handle data
557 ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
558 printk("OSS32_WaveOpen. Reopen ret: %i\n", ret);
559 }
560 else
561 {
562 kfree(pHandle);
563 pHandle = opened_handles[i].handle;
564 }
565 break;
566 }
567 }
568 }
569 }
570 else if (ret == 0)
571 {
572 for (i=0; i < 8*256; i++)
573 {
574 if (opened_handles[i].handle == 0)
575 {
576 opened_handles[i].handle = pHandle;
577 opened_handles[i].FileId = fileid;
578 break;
579 }
580 }
581 }
582
583 if(ret) {
584 kfree(pHandle);
585 DebugInt3();
586 printk("OSS32_WaveOpen: open error: %i\n",ret);
587 return UNIXToOSSError(ret);
588 }
589 pHandle->magic = MAGIC_WAVE_ALSA32;
590 if (pStreamId)
591 *pStreamId = (ULONG)pHandle;
592 // filling opened handles table
593 printk("OSS32_WaveOpen. streamid %X\n",(ULONG)pHandle);
594 return OSSERR_SUCCESS;
595}
596//******************************************************************************
597//******************************************************************************
598
599OSSRET OSS32_WaveClose(OSSSTREAMID streamid)
600{
601 soundhandle *pHandle = (soundhandle *)streamid;
602 int ret = 0, i;
603
604 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
605 DebugInt3();
606 printk("OSS32_WaveClose. invalid streamid %X\n",(ULONG)pHandle);
607 return OSSERR_INVALID_STREAMID;
608 }
609
610 //set operation to non-blocking
611 pHandle->file.f_flags = O_NONBLOCK;
612
613 for (i=0; i < 8*256; i++)
614 {
615 if (opened_handles[i].handle == pHandle)
616 {
617 printk("Found phandle for closing: %x reuse flag: %i\n", pHandle, opened_handles[i].reuse);
618 if (!opened_handles[i].reuse)
619 {
620 ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
621 opened_handles[i].handle = 0;
622 kfree(pHandle); //free handle data
623 OSS32_CloseUNI16(); /* say to UNIAUD16 that we closing now */
624 } else
625 {
626 /* prepare for reuse */
627 pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_RESET, 0);
628 pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
629 }
630 break;
631 }
632 }
633
634 if (i >= 8*256)
635 {
636 //all already closed
637 printk("phandle %x not found\n", pHandle);
638// return OSSERR_SUCCESS;
639 }
640
641
642 if(ret) {
643 printk("Error closing wave. rc = %i\n", ret);
644 DebugInt3();
645 return UNIXToOSSError(ret);
646 }
647 printk("OSS32_WaveClose. streamid %X\n",(ULONG)pHandle);
648 return OSSERR_SUCCESS;
649}
650//******************************************************************************
651//******************************************************************************
652OSSRET OSS32_WavePrepare(OSSSTREAMID streamid)
653{
654 soundhandle *pHandle = (soundhandle *)streamid;
655 int ret;
656
657#ifdef DEBUG
658 dprintf(("OSS32_WavePrepare"));
659#endif
660
661 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
662 DebugInt3();
663//#ifdef DEBUG
664 printk("vladest: OSS32_WavePrepare: invalid streamID\n");
665//#endif
666
667 return OSSERR_INVALID_STREAMID;
668 }
669 //set operation to non-blocking
670 pHandle->file.f_flags = O_NONBLOCK;
671
672 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
673 if (ret)
674 printk("Wave prepare ret = %i, streamid %X\n",ret,(ULONG)pHandle);
675
676 return UNIXToOSSError(ret);;
677}
678//******************************************************************************
679//******************************************************************************
680OSSRET OSS32_WaveStart(OSSSTREAMID streamid)
681{
682 soundhandle *pHandle = (soundhandle *)streamid;
683 int ret;
684
685 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
686 DebugInt3();
687 return OSSERR_INVALID_STREAMID;
688 }
689 //set operation to non-blocking
690 pHandle->file.f_flags = O_NONBLOCK;
691
692 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_START, 0);
693 if (ret)
694 printk("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 printk("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 printk("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 printk("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
773 int ret, nrperiods, minnrperiods, maxnrperiods, samplesize;
774 ULONG bufsize, periodsize, minperiodsize, maxperiodsize;
775 ULONG periodbytes, minperiodbytes, maxperiodbytes;
776 BOOL fTryAgain = FALSE;
777
778 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
779 DebugInt3();
780 return OSSERR_INVALID_STREAMID;
781 }
782 if(pHwParams == NULL) {
783 DebugInt3();
784 return OSSERR_INVALID_PARAMETER;
785 }
786 if(pHwParams->ulDataType >= OSS32_PCM_MAX_FORMATS) {
787 DebugInt3();
788 return OSSERR_INVALID_PARAMETER;
789 }
790
791 //set operation to non-blocking
792 pHandle->file.f_flags = O_NONBLOCK;
793
794 //size of two samples (adpcm sample can be as small as 4 bits (mono), so take two)
795 samplesize = snd_pcm_format_size(OSSToALSADataType[pHwParams->ulDataType], 1);
796 pHandle->doublesamplesize = samplesize * 2;
797 pHandle->doublesamplesize *= pHwParams->ulNumChannels;
798 periodbytes = pHwParams->ulPeriodSize;
799 periodsize = bytes_to_samples(periodbytes);
800
801 //get all hardware parameters
802 _snd_pcm_hw_params_any(&params);
803 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_ACCESS,
804 SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
805 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
806 pHwParams->ulBitsPerSample, 0);
807 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
808 pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
809 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FORMAT,
810 OSSToALSADataType[pHwParams->ulDataType], 0);
811 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_CHANNELS,
812 pHwParams->ulNumChannels, 0);
813 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
814 pHwParams->ulSampleRate, 0);
815 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
816 if(ret != 0) {
817 DebugInt3();
818 return UNIXToOSSError(ret);
819 }
820
821 //check period size against lower and upper boundaries
822 minperiodbytes = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_BYTES)->min;
823 maxperiodbytes = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_BYTES)->max;
824 if(periodbytes < minperiodbytes) {
825 periodbytes = minperiodbytes;
826 }
827 else
828 if(periodbytes > maxperiodbytes) {
829 periodbytes = maxperiodbytes;
830 }
831
832 minperiodsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min;
833 maxperiodsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->max;
834 if(periodsize < minperiodsize) {
835 periodsize = minperiodsize;
836 }
837 else
838 if(periodsize > maxperiodsize) {
839 periodsize = maxperiodsize;
840 }
841
842 if(samples_to_bytes(periodsize) < periodbytes) {
843 periodbytes = samples_to_bytes(periodsize);
844 }
845 else
846 if(bytes_to_samples(periodbytes) < periodsize) {
847 periodsize = bytes_to_samples(periodbytes);
848 }
849
850 //make sure period size is a whole fraction of the buffer size
851 bufsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_BUFFER_BYTES)->max;
852 if(periodsize) {
853 nrperiods = bufsize/periodbytes;
854 }
855 else {
856 DebugInt3();
857 return OSSERR_INVALID_PARAMETER;
858 }
859 //check nr of periods against lower and upper boundaries
860 minnrperiods = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIODS)->min;
861 maxnrperiods = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIODS)->max;
862 if(nrperiods < minnrperiods) {
863 nrperiods = minnrperiods;
864 }
865 else
866 if(nrperiods > maxnrperiods) {
867 nrperiods = maxnrperiods;
868 }
869 //an odd nr of periods is not always a good thing (CMedia -> clicks during 8 bps playback),
870 //so we make sure it's an even number.
871 if(nrperiods == 1) {
872 DebugInt3();
873 return OSSERR_INVALID_PARAMETER;
874 }
875 nrperiods &= ~1;
876
877 //initialize parameter block & set sample rate, nr of channels and sample format, nr of periods,
878 //period size and buffer size
879tryagain:
880 _snd_pcm_hw_params_any(&params);
881 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_ACCESS,
882 SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
883 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
884 pHwParams->ulBitsPerSample, 0);
885 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
886 pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
887 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FORMAT,
888 OSSToALSADataType[pHwParams->ulDataType], 0);
889 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_CHANNELS,
890 pHwParams->ulNumChannels, 0);
891 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
892 pHwParams->ulSampleRate, 0);
893 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
894 periodsize, 0);
895 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
896 periodbytes, 0);
897 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_PERIODS,
898 nrperiods, 0);
899 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
900 periodsize*nrperiods, 0);
901 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
902 periodbytes*nrperiods, 0);
903
904 dprintf(("Hardware parameters: sample rate %d, data type %d, channels %d, period size %d, periods %d",
905 pHwParams->ulSampleRate, pHwParams->ulDataType, pHwParams->ulNumChannels, periodsize, nrperiods));
906
907 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_PARAMS, (ULONG)__Stack32ToFlat(&params));
908 if(ret) {
909 if(fTryAgain == FALSE) {
910 minperiodsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min;
911 maxperiodsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->max;
912 if(minperiodsize > maxperiodsize) {
913 //ALSA doesn't like the period size; try suggested one
914 periodsize = maxperiodsize;
915 periodbytes = samples_to_bytes(periodsize);
916 fTryAgain = TRUE;
917 goto tryagain;
918 }
919 }
920 return UNIXToOSSError(ret);
921 }
922
923 //set silence threshold (all sizes in frames) (only needed for playback)
924 if(pHandle->file.f_mode == FMODE_WRITE)
925 {
926 swparams.avail_min = periodsize;
927 swparams.period_step = 1;
928 if(nrperiods <= 2) {
929 swparams.silence_size = (periodsize/2);
930 }
931 else {
932 swparams.silence_size = periodsize;
933 }
934 swparams.silence_threshold = swparams.silence_size;
935 swparams.sleep_min = 0;
936 swparams.start_threshold = 1;
937 swparams.stop_threshold = periodsize*nrperiods;
938 swparams.tstamp_mode = SNDRV_PCM_TSTAMP_NONE;
939 swparams.xfer_align = periodsize;
940
941 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_SW_PARAMS, (ULONG)__Stack32ToFlat(&swparams));
942 }
943 return UNIXToOSSError(ret);
944}
945
946//******************************************************************************
947ULONG CountWv=0;
948ULONG LockAdd=0;
949extern ULONG xchg( ULONG *p, ULONG x);
950#pragma aux xchg = "xchg [esi],eax" parm [ESI][EAX] value [EAX];
951//******************************************************************************
952OSSRET OSS32_WaveAddBuffer(OSSSTREAMID streamid, ULONG buffer, ULONG size, ULONG *pTransferred, int pcm)
953{
954 soundhandle *pHandle = (soundhandle *)streamid;
955 struct snd_pcm_status status;
956 int ret, align, size1, ret1;
957 LONG transferred;
958 ULONG position,i,j;
959 char *buf;
960
961// return OSSERR_SUCCESS;
962
963 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
964 DebugInt3();
965 return OSSERR_INVALID_STREAMID;
966 }
967 if(pTransferred == NULL || buffer == 0 || size == 0) {
968 DebugInt3();
969 return OSSERR_INVALID_PARAMETER;
970 }
971
972 //set operation to non-blocking
973 pHandle->file.f_flags = O_NONBLOCK;
974
975 //first check how much room is left in the circular dma buffer
976 //this is done to make sure we don't block inside ALSA while trying to write
977 //more data than fits in the internal dma buffer.
978 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
979
980 if(ret) {
981 DebugInt3();
982 return UNIXToOSSError(ret);
983 }
984
985 size1 = size;
986
987 size = min(size, samples_to_bytes(status.avail));
988
989#ifdef DEBUG_PK
990 if (size1 != size)
991 printk("requested size [%d] less then available [%d]\n", size1, size);
992#endif
993
994 CountWv++;
995
996#ifdef DEBUG
997 printk("OSS32_WaveAddBuffer N:%d hw %d app %d avail %d, orig size: %d, size %d\n",CountWv, samples_to_bytes(status.hw_ptr), samples_to_bytes(status.appl_ptr), samples_to_bytes(status.avail), size1, size);
998#endif
999
1000 if (size == 0)
1001 {
1002#ifdef DEBUG_PK
1003 printk("OSS32_WaveAddBuffer: no room left in hardware buffer!!\n");
1004 printk("state = %i\n",status.state);
1005 printk("avail = %i\n",status.avail);
1006 printk("size req = %i\n",size1);
1007#endif
1008 *pTransferred = 0;
1009 return OSSERR_BUFFER_FULL;
1010 }
1011
1012 transferred = 0;
1013 *pTransferred = 0;
1014 ret = -11;
1015 switch(SNDRV_MINOR_DEVICE(MINOR(pHandle->inode.i_rdev-pcm)))
1016 {
1017 case SNDRV_MINOR_PCM_PLAYBACK:
1018 // size should be aligned to channels number * samplesize //PS+++ what is it and why?!?!?!
1019 j = 10; // 10 try if error
1020 while (size && j && ret)
1021 {
1022 for (i=0; i < 1000; i++)
1023 {
1024 ret1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
1025 // If here any state and have free buffer to any byte
1026 if ((status.state != SNDRV_PCM_STATE_XRUN ) && samples_to_bytes(status.avail) )
1027 break;
1028 if (i > 998)
1029 {
1030// printk("timeout stat %x avail:%d hw:%d app:%d\n",status.state,samples_to_bytes(status.avail),samples_to_bytes(status.hw_ptr), samples_to_bytes(status.appl_ptr));
1031 ret1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
1032 }
1033 }
1034
1035 if (ret1 < 0)
1036 {
1037// printk("Status Error ret1:%i trans: %i need %d tot:%d\n",ret1,transferred, size,size1);
1038 break; // We have any global error, don't try more
1039 }
1040
1041 ret = pHandle->file.f_op->write(&pHandle->file, (char *)buffer, size, &pHandle->file.f_pos);
1042
1043 if (ret < 0 )
1044 { // We have any error, don't try more
1045 j--;
1046 if ( ret != -11 )
1047 ret1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
1048// printk("Error ret:%i ret1:%i trans: %d need %d tot:%d\n",ret,ret1,transferred, size,size1);
1049 continue;
1050 }
1051 if (ret == 0) continue;
1052 transferred += ret;
1053// printk("written: now: %d, trans: %d need %d tot:%d\n", ret, transferred, size,size1);
1054 buffer += ret;
1055 if (size > ret)
1056 size -= ret;
1057 else
1058 size = 0;
1059 }
1060 break;
1061 case SNDRV_MINOR_PCM_CAPTURE:
1062 transferred = pHandle->file.f_op->read(&pHandle->file, (char *)buffer, size, &pHandle->file.f_pos);
1063// printk("readed %i bytes\n", transferred);
1064 break;
1065 default:
1066 DebugInt3();
1067 return OSSERR_INVALID_PARAMETER;
1068 }
1069
1070 total += transferred;
1071 *pTransferred = transferred;
1072 prev_size = transferred;
1073 if (*pTransferred < size1)
1074 {
1075 printk("warning: transferred [%d] less than requested [%d]\n", *pTransferred, size1);
1076// ret1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
1077 }
1078
1079 return OSSERR_SUCCESS;
1080}
1081//******************************************************************************
1082//******************************************************************************
1083OSSRET OSS32_WaveGetPosition(ULONG streamid, ULONG *pPosition)
1084{
1085 soundhandle *pHandle = (soundhandle *)streamid;
1086 struct snd_pcm_status status;
1087 int ret;
1088 ULONG delta;
1089
1090 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1091 DebugInt3();
1092 return OSSERR_INVALID_STREAMID;
1093 }
1094 if(pPosition == NULL) {
1095 DebugInt3();
1096 return OSSERR_INVALID_PARAMETER;
1097 }
1098
1099 //set operation to non-blocking
1100 pHandle->file.f_flags = O_NONBLOCK;
1101
1102 //Get the status of the stream
1103 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
1104
1105 if(ret) {
1106 DebugInt3();
1107 return UNIXToOSSError(ret);
1108 }
1109
1110 dprintf2(("OSS32_WaveGetPosition: hardware %x application %x", samples_to_bytes(status.hw_ptr), samples_to_bytes(status.appl_ptr)));
1111 *pPosition = samples_to_bytes(status.hw_ptr); //return new hardware position
1112 return OSSERR_SUCCESS;
1113}
1114//******************************************************************************
1115//******************************************************************************
1116OSSRET OSS32_WaveGetSpace(ULONG streamid, ULONG *pBytesAvail)
1117{
1118 soundhandle *pHandle = (soundhandle *)streamid;
1119 struct snd_pcm_status status;
1120 int ret;
1121
1122 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1123 DebugInt3();
1124 return OSSERR_INVALID_STREAMID;
1125 }
1126 if(pBytesAvail == NULL) {
1127 DebugInt3();
1128 return OSSERR_INVALID_PARAMETER;
1129 }
1130
1131 //set operation to non-blocking
1132 pHandle->file.f_flags = O_NONBLOCK;
1133
1134 //Get the nr of bytes left in the audio buffer
1135 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
1136
1137 if(ret) {
1138 DebugInt3();
1139 return UNIXToOSSError(ret);
1140 }
1141 ret = samples_to_bytes(status.avail);
1142
1143 *pBytesAvail = ret > 752? ret - 752 : 0;
1144 return OSSERR_SUCCESS;
1145}
1146//******************************************************************************
1147//******************************************************************************
1148OSSRET OSS32_WaveSetVolume(OSSSTREAMID streamid, ULONG volume)
1149{
1150 soundhandle *pHandle = (soundhandle *)streamid;
1151 int ret;
1152 int leftvol, rightvol;
1153 struct snd_pcm_volume pcm_volume;
1154
1155 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1156 DebugInt3();
1157 return OSSERR_INVALID_STREAMID;
1158 }
1159 //set operation to non-blocking
1160 pHandle->file.f_flags = O_NONBLOCK;
1161
1162 leftvol = GET_VOLUME_L(volume);
1163 rightvol = GET_VOLUME_R(volume);
1164
1165 pcm_volume.nrchannels = 4;
1166 pcm_volume.volume[SNDRV_PCM_VOL_FRONT_LEFT] = leftvol;
1167 pcm_volume.volume[SNDRV_PCM_VOL_FRONT_RIGHT] = rightvol;
1168 pcm_volume.volume[SNDRV_PCM_VOL_REAR_LEFT] = leftvol;
1169 pcm_volume.volume[SNDRV_PCM_VOL_REAR_RIGHT] = rightvol;
1170
1171 dprintf(("OSS32_WaveSetVolume %x to (%d,%d)", streamid, leftvol, rightvol));
1172 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_SETVOLUME, (ULONG)__Stack32ToFlat(&pcm_volume));
1173 return UNIXToOSSError(ret);
1174}
1175//******************************************************************************
1176//******************************************************************************
1177
Note: See TracBrowser for help on using the repository browser.