source: GPL/trunk/lib32/sound.c@ 456

Last change on this file since 456 was 456, checked in by Paul Smedley, 16 years ago

Fixes to correctly initialise SPEAKER mixer control
File size: 51.6 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->nrDevices = nrCardsDetected;
339 pDevCaps->ulCaps = OSS32_CAPS_WAVE_PLAYBACK | OSS32_CAPS_WAVE_CAPTURE;
340
341 //query wave in & out caps
342 for(i=0;i<2;i++)
343 {
344 PWAVE_CAPS pWaveCaps = (i == 0) ? &pDevCaps->waveOutCaps : &pDevCaps->waveInCaps;
345
346 ret = OSS32_WaveOpen(deviceid, (i == 0) ? OSS32_STREAM_WAVEOUT : OSS32_STREAM_WAVEIN, &streamid, 0, 0);
347 if(ret != OSSERR_SUCCESS)
348 {
349 printk("OSS32_QueryDevCaps: wave open error %i\n", ret);
350 DebugInt3();
351 goto fail;
352 }
353 pHandle = (soundhandle *)streamid;
354 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
355 printk("OSS32_QueryDevCaps: invalid stream id \n");
356 ret = OSSERR_INVALID_STREAMID;
357 goto fail;
358 }
359 //set operation to non-blocking
360 pHandle->file.f_flags = O_NONBLOCK;
361
362 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_INFO, (ULONG)pcminfo);
363 if(ret != 0) {
364 printk("OSS32_QueryDevCaps: SNDRV_PCM_IOCTL_INFO error %i\n", ret);
365 ret = UNIXToOSSError(ret);
366 goto fail;
367 }
368 if(i == 0) {//only need to do this once
369 if(pcminfo->name[0]) {
370 strncpy(pDevCaps->szDeviceName, pcminfo->name, sizeof(pDevCaps->szDeviceName));
371 }
372 else strncpy(pDevCaps->szDeviceName, pcminfo->id, sizeof(pDevCaps->szDeviceName));
373 }
374 printk("Device name: %s", pDevCaps->szDeviceName);
375 pWaveCaps->nrStreams = pcminfo->subdevices_count;
376
377 //get all hardware parameters
378 _snd_pcm_hw_params_any(params);
379 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
380 if(ret != 0) {
381 printk("OSS32_QueryDevCaps: SNDRV_PCM_IOCTL_HW_REFINE error %i\n", ret);
382 ret = UNIXToOSSError(ret);
383 goto fail;
384 }
385
386 pWaveCaps->ulMinChannels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min;
387 pWaveCaps->ulMaxChannels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max;
388 pWaveCaps->ulChanFlags = 0;
389 if(pWaveCaps->ulMinChannels == 1) {
390 pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_MONO;
391 }
392 if(pWaveCaps->ulMaxChannels >= 2) {
393 pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_STEREO;
394 }
395 if(pWaveCaps->ulMaxChannels >= 4) {
396 pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_QUAD;
397 }
398 if(pWaveCaps->ulMaxChannels >= 6) {
399 pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_5_1;
400 }
401
402 pWaveCaps->ulMinRate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min;
403 pWaveCaps->ulMaxRate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max;
404
405 mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_RATE_MASK);
406
407 pWaveCaps->ulRateFlags = mask->bits[0];
408
409 pWaveCaps->ulRateFlags = ALSAToOSSRateFlags(pWaveCaps->ulRateFlags);
410
411 pWaveCaps->ulDataFormats = 0;
412
413 mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
414 format_mask = mask->bits[0];
415 for(fmt=0;fmt<32;fmt++)
416 {
417 if(format_mask & (1 << fmt))
418 {
419 int f = ALSAToOSSDataType(fmt);
420 if (f >= 0)
421 pWaveCaps->ulDataFormats |= f;
422 }
423 }
424
425 OSS32_WaveClose(streamid);
426 streamid = 0;
427
428 }
429
430 //Check support for MPU401, FM & Wavetable MIDI
431 if(OSS32_MidiOpen(deviceid, OSS32_STREAM_MPU401_MIDIOUT, &streamid) == OSSERR_SUCCESS)
432 {
433 pDevCaps->ulCaps |= OSS32_CAPS_MPU401_PLAYBACK;
434 OSS32_MidiClose(streamid);
435 streamid = 0;
436 }
437 if(OSS32_MidiOpen(deviceid, OSS32_STREAM_MPU401_MIDIIN, &streamid) == OSSERR_SUCCESS)
438 {
439 pDevCaps->ulCaps |= OSS32_CAPS_MPU401_CAPTURE;
440 OSS32_MidiClose(streamid);
441 streamid = 0;
442 }
443 if(OSS32_MidiOpen(deviceid, OSS32_STREAM_FM_MIDIOUT, &streamid) == OSSERR_SUCCESS)
444 {
445 pDevCaps->ulCaps |= OSS32_CAPS_FMSYNTH_PLAYBACK;
446 OSS32_MidiClose(streamid);
447 streamid = 0;
448 }
449 if(OSS32_MidiOpen(deviceid, OSS32_STREAM_WAVETABLE_MIDIOUT, &streamid) == OSSERR_SUCCESS)
450 {
451 pDevCaps->ulCaps |= OSS32_CAPS_WAVETABLE_PLAYBACK;
452 OSS32_MidiClose(streamid);
453 streamid = 0;
454 }
455
456 if(OSS32_MixQueryName(deviceid, &pDevCaps->szMixerName, sizeof(pDevCaps->szMixerName)) != OSSERR_SUCCESS) {
457 DebugInt3();
458 printk("OSS32_QueryDevCaps: OSS32_MixQueryName error\n");
459 goto fail;
460 }
461 printk("OSS32_QueryDevCaps: devname: [%s]\n", pDevCaps->szDeviceName);
462 kfree(pcminfo);
463 streamid = 0;
464
465
466 return OSSERR_SUCCESS;
467
468fail:
469 printk("OSS32_QueryDevCaps failed\n");
470 DebugInt3();
471 if(streamid) OSS32_WaveClose(streamid);
472 if(pcminfo) kfree(pcminfo);
473
474 return ret;
475}
476//******************************************************************************
477//******************************************************************************
478OSSRET OSS32_WaveOpen(ULONG deviceid, ULONG streamtype, OSSSTREAMID *pStreamId, int pcm, USHORT fileid)
479{
480 soundhandle *pHandle;
481 int ret,i;
482
483 if (pStreamId)
484 *pStreamId = 0;
485 else
486 {
487 printk("ERROR: invalid stream id pointer passed\n");
488 return OSSERR_OUT_OF_MEMORY;
489 }
490
491 if(alsa_fops == NULL) {
492 DebugInt3();
493#ifdef DEBUG
494 dprintf(("OSS32_WaveOpen: no devices"));
495#endif
496 printk("OSS32_WaveOpen: no devices\n");
497
498 return OSSERR_NO_DEVICE_AVAILABLE;
499 }
500
501// printk("dev id: %i\n",deviceid);
502
503 pHandle = kmalloc(sizeof(soundhandle), GFP_KERNEL);
504 if(pHandle == NULL) {
505 DebugInt3();
506 printk("OSS32_WaveOpen: out of memory\n");
507 return OSSERR_OUT_OF_MEMORY;
508 }
509 memset(pHandle, 0, sizeof(soundhandle));
510
511 //set operation to non-blocking
512 pHandle->file.f_flags = O_NONBLOCK;
513
514 //setup pointers in file structure (used internally by ALSA)
515 pHandle->file.f_dentry = &pHandle->d_entry;
516 pHandle->file.f_dentry->d_inode = &pHandle->inode;
517
518 switch(streamtype) {
519 case OSS32_STREAM_WAVEOUT:
520 pHandle->file.f_mode = FMODE_WRITE;
521 pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_PCM_PLAYBACK) + pcm;
522 break;
523 case OSS32_STREAM_WAVEIN:
524 pHandle->file.f_mode = FMODE_READ;
525 pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_PCM_CAPTURE) + pcm;
526 break;
527 default:
528 DebugInt3();
529 kfree(pHandle);
530 printk("OSS32_WaveOpen: invalid parameter\n");
531 return OSSERR_INVALID_PARAMETER;
532 }
533
534 ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
535 printk("OSS32_WaveOpen. ret: %i\n", ret);
536 /* check if PCM already opened (stupid uniaud16.sys doesnt closes it) */
537 if (ret == -16)
538 {
539 for (i=0; i < 8*256; i++)
540 {
541 if (opened_handles[i].handle != 0)
542 {
543 ret = 0;
544 if (pStreamId)
545 *pStreamId = (ULONG)opened_handles[i].handle;
546 opened_handles[i].reuse = 1; /* try to reuse */
547 if (OSS32_WaveClose((OSSSTREAMID)opened_handles[i].handle) == 0)
548 {
549 if (!opened_handles[i].reuse)
550 {
551 //opened_handles[i].handle = 0;
552 kfree(opened_handles[i].handle); //free handle data
553 ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
554 printk("OSS32_WaveOpen. Reopen ret: %i\n", ret);
555 }
556 else
557 {
558 kfree(pHandle);
559 pHandle = opened_handles[i].handle;
560 }
561 break;
562 }
563 }
564 }
565 }
566 else if (ret == 0)
567 {
568 for (i=0; i < 8*256; i++)
569 {
570 if (opened_handles[i].handle == 0)
571 {
572 opened_handles[i].handle = pHandle;
573 opened_handles[i].FileId = fileid;
574 break;
575 }
576 }
577 }
578
579 if(ret) {
580 kfree(pHandle);
581 DebugInt3();
582 printk("OSS32_WaveOpen: open error: %i\n",ret);
583 return UNIXToOSSError(ret);
584 }
585 pHandle->magic = MAGIC_WAVE_ALSA32;
586 if (pStreamId)
587 *pStreamId = (ULONG)pHandle;
588 // filling opened handles table
589 printk("OSS32_WaveOpen. streamid %X\n",(ULONG)pHandle);
590 return OSSERR_SUCCESS;
591}
592//******************************************************************************
593//******************************************************************************
594
595OSSRET OSS32_WaveClose(OSSSTREAMID streamid)
596{
597 soundhandle *pHandle = (soundhandle *)streamid;
598 int ret = 0, i;
599
600 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
601 DebugInt3();
602 printk("OSS32_WaveClose. invalid streamid %X\n",(ULONG)pHandle);
603 return OSSERR_INVALID_STREAMID;
604 }
605
606 //set operation to non-blocking
607 pHandle->file.f_flags = O_NONBLOCK;
608
609 for (i=0; i < 8*256; i++)
610 {
611 if (opened_handles[i].handle == pHandle)
612 {
613 printk("Found phandle for closing: %x reuse flag: %i\n", pHandle, opened_handles[i].reuse);
614 if (!opened_handles[i].reuse)
615 {
616 ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
617 opened_handles[i].handle = 0;
618 kfree(pHandle); //free handle data
619 OSS32_CloseUNI16(); /* say to UNIAUD16 that we closing now */
620 } else
621 {
622 /* prepare for reuse */
623 pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_RESET, 0);
624 pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
625 }
626 break;
627 }
628 }
629
630 if (i >= 8*256)
631 {
632 //all already closed
633 printk("phandle %x not found\n", pHandle);
634// return OSSERR_SUCCESS;
635 }
636
637
638 if(ret) {
639 printk("Error closing wave. rc = %i\n", ret);
640 DebugInt3();
641 return UNIXToOSSError(ret);
642 }
643 printk("OSS32_WaveClose. streamid %X\n",(ULONG)pHandle);
644 return OSSERR_SUCCESS;
645}
646//******************************************************************************
647//******************************************************************************
648OSSRET OSS32_WavePrepare(OSSSTREAMID streamid)
649{
650 soundhandle *pHandle = (soundhandle *)streamid;
651 int ret;
652
653#ifdef DEBUG
654 dprintf(("OSS32_WavePrepare"));
655#endif
656
657 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
658 DebugInt3();
659//#ifdef DEBUG
660 printk("vladest: OSS32_WavePrepare: invalid streamID\n");
661//#endif
662
663 return OSSERR_INVALID_STREAMID;
664 }
665 //set operation to non-blocking
666 pHandle->file.f_flags = O_NONBLOCK;
667
668 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
669 if (ret)
670 printk("Wave prepare ret = %i, streamid %X\n",ret,(ULONG)pHandle);
671
672 return UNIXToOSSError(ret);;
673}
674//******************************************************************************
675//******************************************************************************
676OSSRET OSS32_WaveStart(OSSSTREAMID streamid)
677{
678 soundhandle *pHandle = (soundhandle *)streamid;
679 int ret;
680
681 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
682 DebugInt3();
683 return OSSERR_INVALID_STREAMID;
684 }
685 //set operation to non-blocking
686 pHandle->file.f_flags = O_NONBLOCK;
687
688 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_START, 0);
689 if (ret)
690 printk("Wave start ret = %i, streamid %X\n",ret,(ULONG)pHandle);
691
692 return UNIXToOSSError(ret);;
693}
694//******************************************************************************
695//******************************************************************************
696OSSRET OSS32_WaveStop(OSSSTREAMID streamid)
697{
698 soundhandle *pHandle = (soundhandle *)streamid;
699 int ret;
700
701 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
702 DebugInt3();
703 return OSSERR_INVALID_STREAMID;
704 }
705 //set operation to non-blocking
706 pHandle->file.f_flags = O_NONBLOCK;
707
708 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_DROP, 0);
709 if (ret)
710 printk("Wave stop ret = %i. streamid %X\n",ret,(ULONG)pHandle);
711
712 return UNIXToOSSError(ret);;
713}
714//******************************************************************************
715//******************************************************************************
716OSSRET OSS32_WavePause(OSSSTREAMID streamid)
717{
718 soundhandle *pHandle = (soundhandle *)streamid;
719 int ret;
720
721 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
722 DebugInt3();
723 return OSSERR_INVALID_STREAMID;
724 }
725 //set operation to non-blocking
726 pHandle->file.f_flags = O_NONBLOCK;
727
728 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PAUSE, 0);
729 if (ret)
730 printk("Wave pause ret = %i, streamid %X\n",ret,(ULONG)pHandle);
731
732 return UNIXToOSSError(ret);;
733}
734//******************************************************************************
735//******************************************************************************
736OSSRET OSS32_WaveResume(OSSSTREAMID streamid)
737{
738 soundhandle *pHandle = (soundhandle *)streamid;
739 int ret;
740
741 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
742 DebugInt3();
743 return OSSERR_INVALID_STREAMID;
744 }
745 //set operation to non-blocking
746 pHandle->file.f_flags = O_NONBLOCK;
747
748 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PAUSE, 1);
749 if (ret)
750 printk("Wave resume ret = %i, streamid %X\n",ret,(ULONG)pHandle);
751
752 return UNIXToOSSError(ret);;
753}
754
755static unsigned rates[] = {
756 /* ATTENTION: these values depend on the definition in pcm.h! */
757 5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000,
758 64000, 88200, 96000, 176400, 192000
759};
760
761//******************************************************************************
762//******************************************************************************
763OSSRET OSS32_WaveSetHwParams(OSSSTREAMID streamid, OSS32_HWPARAMS *pHwParams)
764{
765 soundhandle *pHandle = (soundhandle *)streamid;
766 struct snd_pcm_hw_params params;
767 struct snd_pcm_sw_params swparams;
768 struct snd_pcm_status status;
769
770 int ret, nrperiods, minnrperiods, maxnrperiods, samplesize,i;
771 ULONG bufsize, periodsize, minperiodsize, maxperiodsize;
772 ULONG periodbytes, minperiodbytes, maxperiodbytes;
773 BOOL fTryAgain = FALSE;
774 ULONG ulMinRate, ulMaxRate;
775
776 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
777
778 DebugInt3();
779 return OSSERR_INVALID_STREAMID;
780 }
781 if(pHwParams == NULL) {
782
783 DebugInt3();
784 return OSSERR_INVALID_PARAMETER;
785 }
786 if(pHwParams->ulDataType >= OSS32_PCM_MAX_FORMATS) {
787
788 DebugInt3();
789 return OSSERR_INVALID_PARAMETER;
790 }
791 if ((int)pHwParams->ulNumChannels <= 0) {
792 printk("OSS32_WaveSetHwParams error. Invalid number of channels: %i\n", pHwParams->ulNumChannels);
793 DebugInt3();
794 return OSSERR_INVALID_PARAMETER;
795 }
796tryagain:
797 //set operation to non-blocking
798 pHandle->file.f_flags = O_NONBLOCK;
799
800 //size of two samples (adpcm sample can be as small as 4 bits (mono), so take two)
801 samplesize = snd_pcm_format_size(OSSToALSADataType[pHwParams->ulDataType], 1);
802 pHandle->doublesamplesize = samplesize * 2;
803 pHandle->doublesamplesize *= pHwParams->ulNumChannels;
804 periodbytes = pHwParams->ulPeriodSize;
805 periodsize = bytes_to_samples(periodbytes);
806 // checking number of channels
807
808 dprintf(("channels: %ld, period size: %lx",pHwParams->ulNumChannels, periodbytes));
809
810 _snd_pcm_hw_params_any(&params);
811 do {
812 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_ACCESS,
813 SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
814 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_CHANNELS,
815 pHwParams->ulNumChannels, 0);
816 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
817 if (ret == 0) break;
818 pHwParams->ulNumChannels--;
819 } while(ret < 0 && pHwParams->ulNumChannels > 1);
820
821 dprintf(("channels selected: %d",pHwParams->ulNumChannels));
822
823 //get all hardware parameters
824 _snd_pcm_hw_params_any(&params);
825 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_ACCESS,
826 SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
827 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FORMAT,
828 OSSToALSADataType[pHwParams->ulDataType], 0);
829 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
830 if(ret != 0) {
831 dprintf(("invalid format %lx\n", OSSToALSADataType[pHwParams->ulDataType]));
832 return UNIXToOSSError(ret);
833 }
834 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
835 pHwParams->ulBitsPerSample, 0);
836 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
837 if(ret != 0) {
838 dprintf(("invalid number of sample bits %d\n", pHwParams->ulBitsPerSample));
839 return UNIXToOSSError(ret);
840 }
841 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
842 pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
843 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
844 if(ret != 0) {
845 dprintf(("invalid number of frame bits %d\n", pHwParams->ulBitsPerSample*pHwParams->ulNumChannels));
846 return UNIXToOSSError(ret);
847 }
848
849 //_snd_pcm_hw_params_any(&params);
850 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
851 pHwParams->ulBitsPerSample, 0);
852 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
853 pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
854 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FORMAT,
855 OSSToALSADataType[pHwParams->ulDataType], 0);
856 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_CHANNELS,
857 pHwParams->ulNumChannels, 0);
858 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
859 pHwParams->ulSampleRate, 0);
860 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
861 if(ret != 0) {
862 dprintf(("32_WSetHwPms (first pass) error %d bps:%d fmt: %d ch: %d sr: %d\n",
863 ret,
864 pHwParams->ulBitsPerSample,
865 OSSToALSADataType[pHwParams->ulDataType],
866 pHwParams->ulNumChannels,
867 pHwParams->ulSampleRate));
868 //printk("OSS32_WaveSetHwParams invalid sample rate %i\n", pHwParams->ulSampleRate);
869 // printk("will set to nearest\n");
870 _snd_pcm_hw_params_any(&params);
871 for (i=0; i<(sizeof(rates)/sizeof(unsigned))-1;i++)
872 {
873 if (pHwParams->ulSampleRate >= rates[i] &&
874 pHwParams->ulSampleRate <= rates[i+1])
875 {
876 pHwParams->ulSampleRate = rates[i];
877 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
878 pHwParams->ulSampleRate, 0);
879 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
880 if(ret == 0)
881 {
882 _snd_pcm_hw_params_any(&params);
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 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
894 goto __next;
895 }
896 }
897 }
898 DebugInt3();
899 return UNIXToOSSError(ret);
900 }
901 __next:
902
903 //check period size against lower and upper boundaries
904 minperiodbytes = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_BYTES)->min;
905 maxperiodbytes = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_BYTES)->max;
906 if(periodbytes < minperiodbytes) {
907 periodbytes = minperiodbytes;
908 }
909 else
910 if(periodbytes > maxperiodbytes) {
911 periodbytes = maxperiodbytes;
912 }
913
914 minperiodsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min;
915 maxperiodsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->max;
916 if(periodsize < minperiodsize) {
917 periodsize = minperiodsize;
918 }
919 else
920 if(periodsize > maxperiodsize) {
921 periodsize = maxperiodsize;
922 }
923
924 if(samples_to_bytes(periodsize) < periodbytes) {
925 periodbytes = samples_to_bytes(periodsize);
926 }
927 else
928 if(bytes_to_samples(periodbytes) < periodsize) {
929 periodsize = bytes_to_samples(periodbytes);
930 }
931
932 //make sure period size is a whole fraction of the buffer size
933 bufsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_BUFFER_BYTES)->max;
934 if(periodsize) {
935 nrperiods = bufsize/periodbytes;
936 }
937 else {
938 dprintf(("32_WSHwPrms error. Invalid periodsize (=0). closing file\n"));
939 DebugInt3();
940 return OSSERR_INVALID_PARAMETER;
941 }
942 //check nr of periods against lower and upper boundaries
943 minnrperiods = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIODS)->min;
944 maxnrperiods = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIODS)->max;
945 if(nrperiods < minnrperiods) {
946 nrperiods = minnrperiods;
947 }
948 else
949 if(nrperiods > maxnrperiods) {
950 nrperiods = maxnrperiods;
951 }
952 //an odd nr of periods is not always a good thing (CMedia -> clicks during 8 bps playback),
953 //so we make sure it's an even number.
954 if(nrperiods == 1) {
955 dprintf(("32_WSHwPrms error. Invalid Num periods(=1). closing file\n"));
956 DebugInt3();
957 return OSSERR_INVALID_PARAMETER;
958 }
959 nrperiods &= ~1;
960
961 //initialize parameter block & set sample rate, nr of channels and sample format, nr of periods,
962 //period size and buffer size
963
964 _snd_pcm_hw_params_any(&params);
965 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_ACCESS,
966 SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
967 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
968 pHwParams->ulBitsPerSample, 0);
969 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
970 pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
971 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FORMAT,
972 OSSToALSADataType[pHwParams->ulDataType], 0);
973 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_CHANNELS,
974 pHwParams->ulNumChannels, 0);
975 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
976 pHwParams->ulSampleRate, 0);
977 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
978 periodsize, 0);
979 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
980 periodbytes, 0);
981 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_PERIODS,
982 nrperiods, 0);
983 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
984 periodsize*nrperiods, 0);
985 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
986 periodbytes*nrperiods, 0);
987
988
989 dprintf(("HWP: SR rate %ld, BPS %ld, CH %ld, PRSZ %lx, periods %lx",
990 pHwParams->ulSampleRate, pHwParams->ulBitsPerSample, pHwParams->ulNumChannels, periodsize, nrperiods));
991
992 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_PARAMS, (ULONG)__Stack32ToFlat(&params));
993 if (ret == -77 && fTryAgain == FALSE)
994 {
995 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
996 fTryAgain = TRUE;
997 dprintf((" Error -77 from first IOCTL HW Parms"));
998 goto tryagain;
999 }
1000
1001 if(ret) {
1002 if(fTryAgain == FALSE) {
1003 minperiodsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min;
1004 maxperiodsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->max;
1005 if(minperiodsize > maxperiodsize) {
1006 //ALSA doesn't like the period size; try suggested one
1007 periodsize = maxperiodsize;
1008 periodbytes = samples_to_bytes(periodsize);
1009 dprintf((" Peroid size error IOCTL HW Parms"));
1010 fTryAgain = TRUE;
1011 goto tryagain;
1012 }
1013 }
1014 dprintf(("Error second time.. Bailing"));
1015 return UNIXToOSSError(ret);
1016 }
1017
1018 //set silence threshold (all sizes in frames) (only needed for playback)
1019 if(pHandle->file.f_mode == FMODE_WRITE)
1020 {
1021 swparams.avail_min = periodsize;
1022 swparams.period_step = 1;
1023 if(nrperiods <= 2) {
1024 swparams.silence_size = (periodsize/2);
1025 }
1026 else {
1027 swparams.silence_size = periodsize;
1028 }
1029 swparams.silence_threshold = swparams.silence_size;
1030 swparams.sleep_min = 0;
1031 swparams.start_threshold = 1;
1032 swparams.stop_threshold = periodsize*nrperiods;
1033 swparams.tstamp_mode = SNDRV_PCM_TSTAMP_NONE;
1034 swparams.xfer_align = periodsize;
1035
1036 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_SW_PARAMS, (ULONG)__Stack32ToFlat(&swparams));
1037 }
1038
1039 total = 0;
1040 per_bytes = periodbytes;
1041 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
1042 if ( ((status.state != SNDRV_PCM_STATE_PREPARED) &&
1043 (status.state != SNDRV_PCM_STATE_SETUP) &&
1044 (status.state != SNDRV_PCM_STATE_RUNNING) &&
1045 (status.state != SNDRV_PCM_STATE_DRAINING))) {
1046 dprintf(("Device is not in proper state: %lx. Calling prepare\n", status.state));
1047 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
1048 }
1049 return UNIXToOSSError(ret);
1050}
1051
1052
1053//******************************************************************************
1054ULONG CountWv=0;
1055ULONG LockAdd=0;
1056extern ULONG xchg( ULONG *p, ULONG x);
1057#pragma aux xchg = "xchg [esi],eax" parm [ESI][EAX] value [EAX];
1058//******************************************************************************
1059OSSRET OSS32_WaveAddBuffer(OSSSTREAMID streamid, ULONG buffer, ULONG size, ULONG *pTransferred, int pcm)
1060{
1061 soundhandle *pHandle = (soundhandle *)streamid;
1062 struct snd_pcm_status status;
1063 int ret, align, size1, ret1;
1064 LONG transferred;
1065 ULONG position,i,j;
1066 char *buf;
1067
1068// return OSSERR_SUCCESS;
1069
1070 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1071 DebugInt3();
1072 return OSSERR_INVALID_STREAMID;
1073 }
1074 if(pTransferred == NULL || buffer == 0 || size == 0) {
1075 DebugInt3();
1076 return OSSERR_INVALID_PARAMETER;
1077 }
1078
1079 //set operation to non-blocking
1080 pHandle->file.f_flags = O_NONBLOCK;
1081
1082 //first check how much room is left in the circular dma buffer
1083 //this is done to make sure we don't block inside ALSA while trying to write
1084 //more data than fits in the internal dma buffer.
1085 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
1086
1087 if(ret) {
1088 DebugInt3();
1089 return UNIXToOSSError(ret);
1090 }
1091
1092 size1 = size;
1093
1094 size = min(size, samples_to_bytes(status.avail));
1095
1096#ifdef DEBUG_PK
1097 if (size1 != size)
1098 printk("requested size [%d] less then available [%d]\n", size1, size);
1099#endif
1100
1101 CountWv++;
1102
1103#ifdef DEBUG
1104 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);
1105#endif
1106
1107 if (size == 0)
1108 {
1109#ifdef DEBUG_PK
1110 printk("OSS32_WaveAddBuffer: no room left in hardware buffer!!\n");
1111 printk("state = %i\n",status.state);
1112 printk("avail = %i\n",status.avail);
1113 printk("size req = %i\n",size1);
1114#endif
1115 *pTransferred = 0;
1116 return OSSERR_BUFFER_FULL;
1117 }
1118
1119 transferred = 0;
1120 *pTransferred = 0;
1121 ret = -11;
1122 switch(SNDRV_MINOR_DEVICE(MINOR(pHandle->inode.i_rdev-pcm)))
1123 {
1124 case SNDRV_MINOR_PCM_PLAYBACK:
1125 // size should be aligned to channels number * samplesize //PS+++ what is it and why?!?!?!
1126 j = 10; // 10 try if error
1127 while (size && j && ret)
1128 {
1129 for (i=0; i < 1000; i++)
1130 {
1131 ret1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
1132 // If here any state and have free buffer to any byte
1133 if ((status.state != SNDRV_PCM_STATE_XRUN ) && samples_to_bytes(status.avail) )
1134 break;
1135 if (i > 998)
1136 {
1137// 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));
1138 ret1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
1139 }
1140 }
1141
1142 if (ret1 < 0)
1143 {
1144// printk("Status Error ret1:%i trans: %i need %d tot:%d\n",ret1,transferred, size,size1);
1145 break; // We have any global error, don't try more
1146 }
1147
1148 ret = pHandle->file.f_op->write(&pHandle->file, (char *)buffer, size, &pHandle->file.f_pos);
1149
1150 if (ret < 0 )
1151 { // We have any error, don't try more
1152 j--;
1153 if ( ret != -11 )
1154 ret1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
1155// printk("Error ret:%i ret1:%i trans: %d need %d tot:%d\n",ret,ret1,transferred, size,size1);
1156 continue;
1157 }
1158 if (ret == 0) continue;
1159 transferred += ret;
1160// printk("written: now: %d, trans: %d need %d tot:%d\n", ret, transferred, size,size1);
1161 buffer += ret;
1162 if (size > ret)
1163 size -= ret;
1164 else
1165 size = 0;
1166 }
1167 break;
1168 case SNDRV_MINOR_PCM_CAPTURE:
1169 transferred = pHandle->file.f_op->read(&pHandle->file, (char *)buffer, size, &pHandle->file.f_pos);
1170// printk("readed %i bytes\n", transferred);
1171 break;
1172 default:
1173 DebugInt3();
1174 return OSSERR_INVALID_PARAMETER;
1175 }
1176
1177 total += transferred;
1178 *pTransferred = transferred;
1179 prev_size = transferred;
1180 if (*pTransferred < size1)
1181 {
1182 printk("warning: transferred [%d] less than requested [%d]\n", *pTransferred, size1);
1183// ret1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
1184 }
1185
1186 return OSSERR_SUCCESS;
1187}
1188//******************************************************************************
1189//******************************************************************************
1190OSSRET OSS32_WaveGetPosition(ULONG streamid, ULONG *pPosition)
1191{
1192 soundhandle *pHandle = (soundhandle *)streamid;
1193 struct snd_pcm_status status;
1194 int ret;
1195 ULONG delta;
1196
1197 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1198 DebugInt3();
1199 return OSSERR_INVALID_STREAMID;
1200 }
1201 if(pPosition == NULL) {
1202 DebugInt3();
1203 return OSSERR_INVALID_PARAMETER;
1204 }
1205
1206 //set operation to non-blocking
1207 pHandle->file.f_flags = O_NONBLOCK;
1208
1209 //Get the status of the stream
1210 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
1211
1212 if(ret) {
1213 DebugInt3();
1214 return UNIXToOSSError(ret);
1215 }
1216
1217 dprintf2(("OSS32_WaveGetPosition: hardware %x application %x", samples_to_bytes(status.hw_ptr), samples_to_bytes(status.appl_ptr)));
1218 *pPosition = samples_to_bytes(status.hw_ptr); //return new hardware position
1219 return OSSERR_SUCCESS;
1220}
1221//******************************************************************************
1222//******************************************************************************
1223OSSRET OSS32_WaveGetSpace(ULONG streamid, ULONG *pBytesAvail)
1224{
1225 soundhandle *pHandle = (soundhandle *)streamid;
1226 struct snd_pcm_status status;
1227 int ret;
1228
1229 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1230 DebugInt3();
1231 return OSSERR_INVALID_STREAMID;
1232 }
1233 if(pBytesAvail == NULL) {
1234 DebugInt3();
1235 return OSSERR_INVALID_PARAMETER;
1236 }
1237
1238 //set operation to non-blocking
1239 pHandle->file.f_flags = O_NONBLOCK;
1240
1241 //Get the nr of bytes left in the audio buffer
1242 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
1243
1244 if(ret) {
1245 DebugInt3();
1246 return UNIXToOSSError(ret);
1247 }
1248 ret = samples_to_bytes(status.avail);
1249
1250 *pBytesAvail = ret > 752? ret - 752 : 0;
1251 return OSSERR_SUCCESS;
1252}
1253//******************************************************************************
1254//******************************************************************************
1255OSSRET OSS32_WaveGetHwPtr(ULONG streamid, ULONG *pPosition)
1256{
1257 soundhandle *pHandle = (soundhandle *)streamid;
1258 struct snd_pcm_status status;
1259 int ret;
1260 ULONG delta;
1261
1262 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1263 DebugInt3();
1264 return OSSERR_INVALID_STREAMID;
1265 }
1266 if(pPosition == NULL) {
1267 DebugInt3();
1268 return OSSERR_INVALID_PARAMETER;
1269 }
1270
1271 //set operation to non-blocking
1272 pHandle->file.f_flags = O_NONBLOCK;
1273
1274 //Get the status of the stream
1275 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
1276
1277 if(ret) {
1278 DebugInt3();
1279 return UNIXToOSSError(ret);
1280 }
1281
1282 dprintf(("OSS32_WaveGetHwPtr: %lx", samples_to_bytes(status.appl_ptr)));
1283 *pPosition = samples_to_bytes(status.appl_ptr); //return new hardware position
1284 return OSSERR_SUCCESS;
1285}
1286
1287//******************************************************************************
1288//******************************************************************************
1289OSSRET OSS32_WaveSetVolume(OSSSTREAMID streamid, ULONG volume)
1290{
1291 soundhandle *pHandle = (soundhandle *)streamid;
1292 int ret;
1293 int leftvol, rightvol;
1294 struct snd_pcm_volume pcm_volume;
1295
1296 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1297 DebugInt3();
1298 return OSSERR_INVALID_STREAMID;
1299 }
1300 //set operation to non-blocking
1301 pHandle->file.f_flags = O_NONBLOCK;
1302
1303 leftvol = GET_VOLUME_L(volume);
1304 rightvol = GET_VOLUME_R(volume);
1305
1306 pcm_volume.nrchannels = 4;
1307 pcm_volume.volume[SNDRV_PCM_VOL_FRONT_LEFT] = leftvol;
1308 pcm_volume.volume[SNDRV_PCM_VOL_FRONT_RIGHT] = rightvol;
1309 pcm_volume.volume[SNDRV_PCM_VOL_REAR_LEFT] = leftvol;
1310 pcm_volume.volume[SNDRV_PCM_VOL_REAR_RIGHT] = rightvol;
1311
1312 dprintf(("OSS32_WaveSetVolume %x to (%d,%d)", streamid, leftvol, rightvol));
1313 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_SETVOLUME, (ULONG)__Stack32ToFlat(&pcm_volume));
1314 return UNIXToOSSError(ret);
1315}
1316//******************************************************************************
1317//******************************************************************************
1318
Note: See TracBrowser for help on using the repository browser.