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

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

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