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

Last change on this file since 77 was 77, checked in by vladest, 19 years ago

Provide sources to latest exist binary. See changelog for changes
File size: 51.3 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/driver.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;
54int pcm_instances = 0;
55
56OpenedHandles opened_handles[8 * 256] = {0};
57
58//OSS32 to ALSA datatype conversion table
59static 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 snd_pcm_info_t *pcminfo = NULL;
317 snd_pcm_hw_params_t *params;
318 int ret, fmt, i;
319 ULONG format_mask;
320 snd_mask_t *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 = (snd_pcm_info_t *)kmalloc(sizeof(snd_pcm_info_t)+sizeof(snd_pcm_hw_params_t), 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 = (snd_pcm_hw_params_t *)(pcminfo+1);
336
337// printk("Number of cards: %i\n",nrCardsDetected);
338// printk("dev id: %i\n",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\n", 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_RATE_MASK);
407 pWaveCaps->ulRateFlags = mask->bits[0];
408
409 pWaveCaps->ulRateFlags = ALSAToOSSRateFlags(pWaveCaps->ulRateFlags);
410
411 printk("rate flags: %X\n", pWaveCaps->ulRateFlags);
412
413 pWaveCaps->ulDataFormats = 0;
414
415 mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
416 format_mask = mask->bits[0];
417 for(fmt=0;fmt<32;fmt++)
418 {
419 if(format_mask & (1 << fmt))
420 {
421 int f = ALSAToOSSDataType(fmt);
422 if (f >= 0)
423 pWaveCaps->ulDataFormats |= f;
424 }
425 }
426
427 OSS32_WaveClose(streamid);
428 streamid = 0;
429
430 }
431 //Check support for MPU401, FM & Wavetable MIDI
432 if(OSS32_MidiOpen(deviceid, OSS32_STREAM_MPU401_MIDIOUT, &streamid) == OSSERR_SUCCESS)
433 {
434 pDevCaps->ulCaps |= OSS32_CAPS_MPU401_PLAYBACK;
435 OSS32_MidiClose(streamid);
436 streamid = 0;
437 }
438 if(OSS32_MidiOpen(deviceid, OSS32_STREAM_MPU401_MIDIIN, &streamid) == OSSERR_SUCCESS)
439 {
440 pDevCaps->ulCaps |= OSS32_CAPS_MPU401_CAPTURE;
441 OSS32_MidiClose(streamid);
442 streamid = 0;
443 }
444 if(OSS32_MidiOpen(deviceid, OSS32_STREAM_FM_MIDIOUT, &streamid) == OSSERR_SUCCESS)
445 {
446 pDevCaps->ulCaps |= OSS32_CAPS_FMSYNTH_PLAYBACK;
447 OSS32_MidiClose(streamid);
448 streamid = 0;
449 }
450 if(OSS32_MidiOpen(deviceid, OSS32_STREAM_WAVETABLE_MIDIOUT, &streamid) == OSSERR_SUCCESS)
451 {
452 pDevCaps->ulCaps |= OSS32_CAPS_WAVETABLE_PLAYBACK;
453 OSS32_MidiClose(streamid);
454 streamid = 0;
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 printk("OSS32_WaveOpen: cp1\n");
535 ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
536 printk("OSS32_WaveOpen: cp2\n");
537 /* check if PCM already opened (stupid uniaud16.sys doesnt closes it) */
538 if (ret == -16)
539 {
540 kfree(pHandle);
541 for (i=0; i < 8*256; i++)
542 {
543 if (opened_handles[i].handle != 0)
544 {
545 if (pStreamId)
546 *pStreamId = (ULONG)opened_handles[i].handle;
547 opened_handles[i].reuse = 1;
548 printk("OSS32_WaveOpen. Reuse streamid %X\n",(ULONG)opened_handles[i].handle);
549 return OSSERR_SUCCESS;
550 }
551 }
552 }
553 printk("OSS32_WaveOpen: cp3\n");
554
555 if(ret) {
556 kfree(pHandle);
557 DebugInt3();
558 printk("OSS32_WaveOpen: open error: %i\n",ret);
559 return UNIXToOSSError(ret);
560 }
561 pHandle->magic = MAGIC_WAVE_ALSA32;
562 printk("OSS32_WaveOpen: cp4\n");
563
564 if (pStreamId)
565 *pStreamId = (ULONG)pHandle;
566 // filling opened handles table
567 for (i=0; i < 8*256; i++)
568 {
569 if (opened_handles[i].handle == 0)
570 {
571 opened_handles[i].handle = pHandle;
572 opened_handles[i].FileId = fileid;
573 break;
574 }
575 }
576 printk("OSS32_WaveOpen. streamid %X\n",(ULONG)pHandle);
577 return OSSERR_SUCCESS;
578}
579//******************************************************************************
580//******************************************************************************
581OSSRET OSS32_WaveClose(OSSSTREAMID streamid)
582{
583 soundhandle *pHandle = (soundhandle *)streamid;
584 int ret = 0, i;
585
586 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
587 DebugInt3();
588 printk("OSS32_WaveClose. invalid streamid %X\n",(ULONG)pHandle);
589 return OSSERR_INVALID_STREAMID;
590 }
591
592 //set operation to non-blocking
593 pHandle->file.f_flags = O_NONBLOCK;
594
595 for (i=0; i < 8*256; i++)
596 {
597 if (opened_handles[i].handle == pHandle)
598 {
599 printk("Found phandle for closing: %x reuse flag: %i\n", pHandle, opened_handles[i].reuse);
600 if (!opened_handles[i].reuse)
601 {
602 ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
603 opened_handles[i].handle = 0;
604 kfree(pHandle); //free handle data
605 } else
606 {
607 /* prepare for reuse */
608 pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
609 }
610 break;
611 }
612 }
613
614 if (i >= 8*256)
615 {
616 //all already closed
617 printk("phandle %x not found\n", pHandle);
618// return OSSERR_SUCCESS;
619 }
620
621
622 if(ret) {
623 printk("Error closing wave. rc = %i\n", ret);
624 DebugInt3();
625 return UNIXToOSSError(ret);
626 }
627 printk("OSS32_WaveClose. streamid %X\n",(ULONG)pHandle);
628 return OSSERR_SUCCESS;
629}
630//******************************************************************************
631//******************************************************************************
632OSSRET OSS32_WavePrepare(OSSSTREAMID streamid)
633{
634 soundhandle *pHandle = (soundhandle *)streamid;
635 int ret;
636
637#ifdef DEBUG
638 dprintf(("OSS32_WavePrepare"));
639#endif
640
641 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
642 DebugInt3();
643//#ifdef DEBUG
644 printk("vladest: OSS32_WavePrepare: invalid streamID\n");
645//#endif
646
647 return OSSERR_INVALID_STREAMID;
648 }
649 //set operation to non-blocking
650 pHandle->file.f_flags = O_NONBLOCK;
651
652 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
653 if (ret)
654 printk("Wave prepare ret = %i, streamid %X\n",ret,(ULONG)pHandle);
655
656 return UNIXToOSSError(ret);;
657}
658//******************************************************************************
659//******************************************************************************
660OSSRET OSS32_WaveStart(OSSSTREAMID streamid)
661{
662 soundhandle *pHandle = (soundhandle *)streamid;
663 int ret;
664
665 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
666 DebugInt3();
667 return OSSERR_INVALID_STREAMID;
668 }
669 //set operation to non-blocking
670 pHandle->file.f_flags = O_NONBLOCK;
671
672 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_START, 0);
673 if (ret)
674 printk("Wave start ret = %i, streamid %X\n",ret,(ULONG)pHandle);
675
676 return UNIXToOSSError(ret);;
677}
678//******************************************************************************
679//******************************************************************************
680OSSRET OSS32_WaveStop(OSSSTREAMID streamid)
681{
682 soundhandle *pHandle = (soundhandle *)streamid;
683 int ret;
684
685 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
686 DebugInt3();
687 return OSSERR_INVALID_STREAMID;
688 }
689 //set operation to non-blocking
690 pHandle->file.f_flags = O_NONBLOCK;
691
692 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_DROP, 0);
693 if (ret)
694 printk("Wave stop ret = %i. streamid %X\n",ret,(ULONG)pHandle);
695
696 return UNIXToOSSError(ret);;
697}
698//******************************************************************************
699//******************************************************************************
700OSSRET OSS32_WavePause(OSSSTREAMID streamid)
701{
702 soundhandle *pHandle = (soundhandle *)streamid;
703 int ret;
704
705 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
706 DebugInt3();
707 return OSSERR_INVALID_STREAMID;
708 }
709 //set operation to non-blocking
710 pHandle->file.f_flags = O_NONBLOCK;
711
712 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PAUSE, 0);
713 if (ret)
714 printk("Wave pause ret = %i, streamid %X\n",ret,(ULONG)pHandle);
715
716 return UNIXToOSSError(ret);;
717}
718//******************************************************************************
719//******************************************************************************
720OSSRET OSS32_WaveResume(OSSSTREAMID streamid)
721{
722 soundhandle *pHandle = (soundhandle *)streamid;
723 int ret;
724
725 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
726 DebugInt3();
727 return OSSERR_INVALID_STREAMID;
728 }
729 //set operation to non-blocking
730 pHandle->file.f_flags = O_NONBLOCK;
731
732 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PAUSE, 1);
733 if (ret)
734 printk("Wave resume ret = %i, streamid %X\n",ret,(ULONG)pHandle);
735
736 return UNIXToOSSError(ret);;
737}
738
739static unsigned rates[] = {
740 /* ATTENTION: these values depend on the definition in pcm.h! */
741 5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000,
742 64000, 88200, 96000, 176400, 192000
743};
744
745//******************************************************************************
746//******************************************************************************
747OSSRET OSS32_WaveSetHwParams(OSSSTREAMID streamid, OSS32_HWPARAMS *pHwParams)
748{
749 soundhandle *pHandle = (soundhandle *)streamid;
750 snd_pcm_hw_params_t params;
751 snd_pcm_sw_params_t swparams;
752 int ret, ret1, nrperiods, minnrperiods, maxnrperiods, samplesize, i;
753 ULONG bufsize, periodsize, minperiodsize, maxperiodsize;
754 ULONG periodbytes, minperiodbytes, maxperiodbytes;
755 BOOL fTryAgain = FALSE;
756 ULONG ulMinRate, ulMaxRate;
757
758#ifdef DEBUG
759 dprintf(("OSS32_WaveSetHwParams"));
760#endif
761 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
762 printk("OSS32_WaveSetHwParams error. Invalid handle\n");
763 DebugInt3();
764 return OSSERR_INVALID_STREAMID;
765 }
766 if(pHwParams == NULL) {
767 printk("OSS32_WaveSetHwParams error. params = NULL\n");
768 DebugInt3();
769 return OSSERR_INVALID_PARAMETER;
770 }
771 if(pHwParams->ulDataType >= OSS32_PCM_MAX_FORMATS) {
772 printk("OSS32_WaveSetHwParams error. Too high PCM format\n");
773 DebugInt3();
774 return OSSERR_INVALID_PARAMETER;
775 }
776 if ((int)pHwParams->ulNumChannels <= 0) {
777 printk("OSS32_WaveSetHwParams error. Invalid number of channels: %i\n", pHwParams->ulNumChannels);
778 DebugInt3();
779 return OSSERR_INVALID_PARAMETER;
780 }
781tryagain:
782 //set operation to non-blocking
783 pHandle->file.f_flags = O_NONBLOCK;
784 //size of two samples (adpcm sample can be as small as 4 bits (mono), so take two)
785 samplesize = snd_pcm_format_size(OSSToALSADataType[pHwParams->ulDataType], 1);
786 pHandle->doublesamplesize = samplesize * 2;
787 pHandle->doublesamplesize *= pHwParams->ulNumChannels;
788 periodbytes = pHwParams->ulPeriodSize;
789 periodsize = bytes_to_samples(periodbytes);
790 // checking number of channels
791
792 printk("channels: %i, period size: %i\n",pHwParams->ulNumChannels, periodbytes);
793 _snd_pcm_hw_params_any(&params);
794 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
795 ulMinRate = hw_param_interval(&params, SNDRV_PCM_HW_PARAM_RATE)->min;
796 ulMaxRate = hw_param_interval(&params, SNDRV_PCM_HW_PARAM_RATE)->max;
797
798 _snd_pcm_hw_params_any(&params);
799 do {
800 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_ACCESS,
801 SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
802 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_CHANNELS,
803 pHwParams->ulNumChannels, 0);
804 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
805 if (ret == 0) break;
806 pHwParams->ulNumChannels--;
807 } while(ret < 0 && pHwParams->ulNumChannels > 1);
808
809 printk("channels selected: %i\n",pHwParams->ulNumChannels);
810
811 //get all hardware parameters
812 _snd_pcm_hw_params_any(&params);
813 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_ACCESS,
814 SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
815 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FORMAT,
816 OSSToALSADataType[pHwParams->ulDataType], 0);
817 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
818 if(ret != 0) {
819 printk("invalid format %i\n", OSSToALSADataType[pHwParams->ulDataType]);
820 return UNIXToOSSError(ret);
821 }
822 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
823 pHwParams->ulBitsPerSample, 0);
824 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
825 if(ret != 0) {
826 printk("invalid number of sample bits %i\n", pHwParams->ulBitsPerSample);
827 return UNIXToOSSError(ret);
828 }
829 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
830 pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
831 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
832 if(ret != 0) {
833 printk("invalid number of frame bits %i\n", pHwParams->ulBitsPerSample*pHwParams->ulNumChannels);
834 return UNIXToOSSError(ret);
835 }
836
837 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
838 pHwParams->ulBitsPerSample, 0);
839 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
840 pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
841 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FORMAT,
842 OSSToALSADataType[pHwParams->ulDataType], 0);
843 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_CHANNELS,
844 pHwParams->ulNumChannels, 0);
845 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
846 pHwParams->ulSampleRate, 0);
847
848 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
849 if(ret != 0) {
850 printk("OSS32_WaveSetHwParams (first pass) error %i\n", ret);
851 printk("bps: %i\n",pHwParams->ulBitsPerSample);
852 printk("format: %i\n",OSSToALSADataType[pHwParams->ulDataType]);
853 printk("channels: %i\n",pHwParams->ulNumChannels);
854 printk("sample rate: %i\n",pHwParams->ulSampleRate);
855
856// printk("OSS32_WaveSetHwParams invalid sample rate %i\n", pHwParams->ulSampleRate);
857 // printk("will set to nearest\n");
858 _snd_pcm_hw_params_any(&params);
859 for (i=0; i<(sizeof(rates)/sizeof(unsigned))-1;i++)
860 {
861 if (pHwParams->ulSampleRate >= rates[i] &&
862 pHwParams->ulSampleRate <= rates[i+1])
863 {
864 pHwParams->ulSampleRate = rates[i];
865 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
866 pHwParams->ulSampleRate, 0);
867 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
868 if(ret == 0)
869 {
870 _snd_pcm_hw_params_any(&params);
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 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
882 goto __next;
883 }
884 }
885 }
886// ret1 = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
887 DebugInt3();
888 return UNIXToOSSError(ret);
889 }
890__next:
891
892 printk("sample rate: %i\n",pHwParams->ulSampleRate);
893
894 //check period size against lower and upper boundaries
895 minperiodbytes = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_BYTES)->min;
896 maxperiodbytes = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_BYTES)->max;
897 if(periodbytes < minperiodbytes) {
898 periodbytes = minperiodbytes;
899 }
900 else
901 if(periodbytes > maxperiodbytes) {
902 periodbytes = maxperiodbytes;
903 }
904
905 minperiodsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min;
906 maxperiodsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->max;
907 if(periodsize < minperiodsize) {
908 periodsize = minperiodsize;
909 }
910 else
911 if(periodsize > maxperiodsize) {
912 periodsize = maxperiodsize;
913 }
914
915 if(samples_to_bytes(periodsize) < periodbytes) {
916 periodbytes = samples_to_bytes(periodsize);
917 }
918 else
919 if(bytes_to_samples(periodbytes) < periodsize) {
920 periodsize = bytes_to_samples(periodbytes);
921 }
922
923 //make sure period size is a whole fraction of the buffer size
924 bufsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_BUFFER_BYTES)->max;
925 if(periodsize) {
926 nrperiods = bufsize/periodbytes;
927 }
928 else {
929 printk("OSS32_WaveSetHwParams error. Invalid periodsize (=0). closing file\n");
930// ret1 = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
931 DebugInt3();
932 return OSSERR_INVALID_PARAMETER;
933 }
934 //check nr of periods against lower and upper boundaries
935 minnrperiods = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIODS)->min;
936 maxnrperiods = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIODS)->max;
937 if(nrperiods < minnrperiods) {
938 nrperiods = minnrperiods;
939 }
940 else
941 if(nrperiods > maxnrperiods) {
942 nrperiods = maxnrperiods;
943 }
944 //an odd nr of periods is not always a good thing (CMedia -> clicks during 8 bps playback),
945 //so we make sure it's an even number.
946 if(nrperiods == 1) {
947 DebugInt3();
948 printk("OSS32_WaveSetHwParams error. Invalid number of periods(=1). closing file\n");
949// ret1 = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
950 return OSSERR_INVALID_PARAMETER;
951 }
952 nrperiods &= ~1;
953
954 //initialize parameter block & set sample rate, nr of channels and sample format, nr of periods,
955 //period size and buffer size
956//tryagain:
957 _snd_pcm_hw_params_any(&params);
958 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_ACCESS,
959 SNDRV_PCM_ACCESS_RW_INTERLEAVED, 0);
960 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
961 pHwParams->ulBitsPerSample, 0);
962 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
963 pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
964 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FORMAT,
965 OSSToALSADataType[pHwParams->ulDataType], 0);
966 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_CHANNELS,
967 pHwParams->ulNumChannels, 0);
968 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
969 pHwParams->ulSampleRate, 0);
970 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
971 periodsize, 0);
972 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
973 periodbytes, 0);
974 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_PERIODS,
975 nrperiods, 0);
976 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
977 periodsize*nrperiods, 0);
978 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
979 periodbytes*nrperiods, 0);
980//#ifdef DEBUG_PK
981 printk("Hardware parameters: sample rate %i, data type %i, channels %i, period size %i, periods %i\n",
982 pHwParams->ulSampleRate, pHwParams->ulDataType, pHwParams->ulNumChannels, periodsize, nrperiods);
983//#endif
984 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_PARAMS, (ULONG)__Stack32ToFlat(&params));
985 if (ret == -77 && fTryAgain == FALSE)
986 {
987 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
988 fTryAgain = TRUE;
989 goto tryagain;
990 }
991 if(ret) {
992 if(fTryAgain == FALSE) {
993 minperiodsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min;
994 maxperiodsize = hw_param_interval((&params), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->max;
995 if(minperiodsize > maxperiodsize) {
996 //ALSA doesn't like the period size; try suggested one
997 periodsize = maxperiodsize;
998 periodbytes = samples_to_bytes(periodsize);
999 fTryAgain = TRUE;
1000 goto tryagain;
1001 }
1002 }
1003 printk("OSS32_WaveSetHwParams (second pass) error %i\n", ret);
1004 printk("bps: %i\n",pHwParams->ulBitsPerSample);
1005 printk("format: %i\n",OSSToALSADataType[pHwParams->ulDataType]);
1006 printk("channels: %i\n",pHwParams->ulNumChannels);
1007 printk("sample rate: %i\n",pHwParams->ulSampleRate);
1008 printk("periodsize: %i\n",periodsize);
1009 printk("periodbytes: %i\n",periodbytes);
1010 printk("periods: %i\n",nrperiods);
1011// ret1 = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
1012 return UNIXToOSSError(ret);
1013 }
1014
1015 //set silence threshold (all sizes in frames) (only needed for playback)
1016 if(pHandle->file.f_mode == FMODE_WRITE)
1017 {
1018 swparams.avail_min = periodsize;
1019 swparams.period_step = 1;
1020 if(nrperiods <= 2) {
1021 swparams.silence_size = (periodsize/2);
1022 }
1023 else {
1024 swparams.silence_size = periodsize;
1025 }
1026 swparams.silence_threshold = swparams.silence_size;
1027 swparams.sleep_min = 0;
1028 swparams.start_threshold = 1;
1029 swparams.stop_threshold = periodsize*nrperiods;
1030 swparams.tstamp_mode = SNDRV_PCM_TSTAMP_NONE;
1031 swparams.xfer_align = periodsize;
1032
1033 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_SW_PARAMS, (ULONG)__Stack32ToFlat(&swparams));
1034 }
1035 total = 0;
1036 per_bytes = periodbytes;
1037 printk("OSS32_WaveSetHwParams return %d after SNDRV_PCM_IOCTL_SW_PARAMS ioctl, streamid %X", ret,(ULONG)pHandle);
1038 return UNIXToOSSError(ret);
1039}
1040
1041//******************************************************************************
1042//******************************************************************************
1043OSSRET OSS32_WaveAddBuffer(OSSSTREAMID streamid, ULONG buffer, ULONG size, ULONG *pTransferred, int pcm)
1044{
1045 soundhandle *pHandle = (soundhandle *)streamid;
1046 snd_pcm_status_t status;
1047 int ret, align, size1, ret1;
1048 LONG transferred;
1049 ULONG position;
1050 char *buf;
1051 int toret = 0;
1052
1053// return OSSERR_SUCCESS;
1054
1055 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1056 DebugInt3();
1057 return OSSERR_INVALID_STREAMID;
1058 }
1059 if(pTransferred == NULL || buffer == 0 || size == 0) {
1060 DebugInt3();
1061 return OSSERR_INVALID_PARAMETER;
1062 }
1063
1064 //set operation to non-blocking
1065 pHandle->file.f_flags = O_NONBLOCK;
1066
1067 //first check how much room is left in the circular dma buffer
1068 //this is done to make sure we don't block inside ALSA while trying to write
1069 //more data than fits in the internal dma buffer.
1070 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
1071
1072 if(ret) {
1073 DebugInt3();
1074 return UNIXToOSSError(ret);
1075 }
1076
1077 size1 = size;
1078
1079 size = min(size, samples_to_bytes(status.avail));
1080 if (size1 != size)
1081 printk("requested size [%i] less then available [%s]\n", size1, size);
1082#if 0
1083 if (size < per_bytes)
1084 { /*HACK!!!*/
1085 printk("HACK avoid buffer overrun: requested buffer [%i] less than period [%i]. prev size: %i\n", size, per_bytes, prev_size);
1086 *pTransferred = size;
1087 prev_size = size;
1088 ret1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
1089 return OSSERR_SUCCESS;
1090 }
1091#endif
1092// size = per_bytes * (size / per_bytes);
1093
1094#ifdef DEBUG_PK
1095 printk("OSS32_WaveAddBuffer hw %i app %i avail %i, orig size: %i, size %i align %i\n", samples_to_bytes(status.hw_ptr), samples_to_bytes(status.appl_ptr), samples_to_bytes(status.avail), size1, size, per_bytes);
1096#endif
1097
1098 if(size == 0) {
1099#ifdef DEBUG_PK
1100 printk("OSS32_WaveAddBuffer: no room left in hardware buffer!!\n");
1101 printk("state = %i\n",status.state);
1102 printk("avail = %i\n",status.avail);
1103 printk("size req = %i\n",size1);
1104#endif
1105 *pTransferred = 0;
1106 return OSSERR_BUFFER_FULL;
1107 }
1108
1109 transferred = 0;
1110 switch(SNDRV_MINOR_DEVICE(MINOR(pHandle->inode.i_rdev-pcm)))
1111 {
1112 case SNDRV_MINOR_PCM_PLAYBACK:
1113 // size should be aligned to channels number * samplesize
1114
1115 while(TRUE) {
1116 again:
1117 ret = pHandle->file.f_op->write(&pHandle->file, (char *)buffer, size, &pHandle->file.f_pos);
1118 if(ret < 0) {
1119 // check EAGAIN
1120 if (ret == -EPIPE)
1121 {
1122 ret1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
1123// if (ret1 == 0) continue;
1124// printk("prepare rc %i\n",ret);
1125 }
1126
1127 if(transferred > 0) {
1128 printk("OSS32_WaveAddBuffer failed on partial transfer %x %i; ret = %i\n", buffer, size, ret);
1129 *pTransferred = transferred;
1130 return OSSERR_SUCCESS;
1131 }
1132
1133 ret1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
1134
1135 if ( ((status.state != SNDRV_PCM_STATE_PREPARED) &&
1136 (status.state != SNDRV_PCM_STATE_RUNNING) &&
1137 (status.state != SNDRV_PCM_STATE_DRAINING)) || ret == -32 ) {
1138 ret1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
1139 printk("OSS32_WaveAddBuffer buffer overrun: size %i, ret %i, trans %i, prev sz %i per sz %i total %i\n", size, ret, transferred, prev_size, per_bytes, total);
1140 ret = size;
1141 transferred = size;
1142 break; /* UGLY hack*/
1143 //goto again;
1144 }
1145 else {
1146 printk("OSS32_WaveAddBuffer failed when SNDRV_MINOR_PCM_PLAYBACK. rc = %i\n",ret);
1147 printk("hw %i app %i avail %i, size %i\n", samples_to_bytes(status.hw_ptr), samples_to_bytes(status.appl_ptr), samples_to_bytes(status.avail), size);
1148 printk("total = %i\n",total);
1149 printk("state = %i\n",status.state);
1150 printk("avail = %i\n",status.avail);
1151 printk("size req = %i\n",size1);
1152 DebugInt3();
1153 return UNIXToOSSError(transferred);
1154 }
1155 }
1156 if(ret == 0) {
1157 break;
1158 }
1159 transferred += ret;
1160// printk("written: now: %i, buffer: %i, total: %i\n", ret, transferred, total);
1161 buffer += ret;
1162 size -= ret;
1163 if((int)size <= 0) {
1164 break;
1165 }
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 if(ret < 0) {
1177 dprintf(("OSS32_WaveAddBuffer failed"));
1178 DebugInt3();
1179 return UNIXToOSSError(transferred);
1180 }
1181
1182 total+=transferred;
1183 *pTransferred = transferred;
1184 prev_size = transferred;
1185 if (transferred < size)
1186 {
1187 printk("warning: transferred [%i] less than requested [%i]\n", transferred, size);
1188 ret1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
1189 }
1190
1191 return OSSERR_SUCCESS;
1192}
1193//******************************************************************************
1194//******************************************************************************
1195OSSRET OSS32_WaveGetPosition(ULONG streamid, ULONG *pPosition)
1196{
1197 soundhandle *pHandle = (soundhandle *)streamid;
1198 snd_pcm_status_t status;
1199 int ret;
1200 ULONG delta;
1201
1202 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1203 DebugInt3();
1204 return OSSERR_INVALID_STREAMID;
1205 }
1206 if(pPosition == NULL) {
1207 DebugInt3();
1208 return OSSERR_INVALID_PARAMETER;
1209 }
1210
1211 //set operation to non-blocking
1212 pHandle->file.f_flags = O_NONBLOCK;
1213
1214 //Get the status of the stream
1215 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
1216
1217 if(ret) {
1218 DebugInt3();
1219 return UNIXToOSSError(ret);
1220 }
1221
1222 dprintf2(("OSS32_WaveGetPosition: hardware %x application %x", samples_to_bytes(status.hw_ptr), samples_to_bytes(status.appl_ptr)));
1223 *pPosition = samples_to_bytes(status.hw_ptr); //return new hardware position
1224 return OSSERR_SUCCESS;
1225}
1226//******************************************************************************
1227//******************************************************************************
1228OSSRET OSS32_WaveGetSpace(ULONG streamid, ULONG *pBytesAvail)
1229{
1230 soundhandle *pHandle = (soundhandle *)streamid;
1231 snd_pcm_status_t status;
1232 int ret;
1233
1234 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1235 DebugInt3();
1236 return OSSERR_INVALID_STREAMID;
1237 }
1238 if(pBytesAvail == NULL) {
1239 DebugInt3();
1240 return OSSERR_INVALID_PARAMETER;
1241 }
1242
1243 //set operation to non-blocking
1244 pHandle->file.f_flags = O_NONBLOCK;
1245
1246 //Get the nr of bytes left in the audio buffer
1247 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
1248
1249 if(ret) {
1250 DebugInt3();
1251 return UNIXToOSSError(ret);
1252 }
1253 *pBytesAvail = samples_to_bytes(status.avail);
1254 return OSSERR_SUCCESS;
1255}
1256//******************************************************************************
1257//******************************************************************************
1258OSSRET OSS32_WaveSetVolume(OSSSTREAMID streamid, ULONG volume)
1259{
1260 soundhandle *pHandle = (soundhandle *)streamid;
1261 int ret;
1262 int leftvol, rightvol;
1263 struct snd_pcm_volume pcm_volume;
1264
1265 if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
1266 DebugInt3();
1267 return OSSERR_INVALID_STREAMID;
1268 }
1269 //set operation to non-blocking
1270 pHandle->file.f_flags = O_NONBLOCK;
1271
1272 leftvol = GET_VOLUME_L(volume);
1273 rightvol = GET_VOLUME_R(volume);
1274
1275 pcm_volume.nrchannels = 4;
1276 pcm_volume.volume[SNDRV_PCM_VOL_FRONT_LEFT] = leftvol;
1277 pcm_volume.volume[SNDRV_PCM_VOL_FRONT_RIGHT] = rightvol;
1278 pcm_volume.volume[SNDRV_PCM_VOL_REAR_LEFT] = leftvol;
1279 pcm_volume.volume[SNDRV_PCM_VOL_REAR_RIGHT] = rightvol;
1280
1281 dprintf(("OSS32_WaveSetVolume %x to (%d,%d)", streamid, leftvol, rightvol));
1282 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_SETVOLUME, (ULONG)__Stack32ToFlat(&pcm_volume));
1283 return UNIXToOSSError(ret);
1284}
1285//******************************************************************************
1286//******************************************************************************
1287
Note: See TracBrowser for help on using the repository browser.