Changeset 531

Timestamp:

Jul 27, 2010, 6:36:11 PM (15 years ago)

Author:

David Azarewicz

Message:

merge changes from trunk

Location:

GPL/branches/uniaud32-2.1.x

Files:

• alsa-kernel/core/control.c (modified) (1 diff)
• alsa-kernel/core/pcm_native.c (modified) (2 diffs)
• alsa-kernel/core/pcm_os2.c (modified) (1 diff)
• alsa-kernel/include/sound/adriver.h (modified) (1 diff)
• alsa-kernel/pci/hda/patch_sigmatel.c (modified) (1 diff)
• lib32/ioctl.c (modified) (7 diffs)
• lib32/sound.c (modified) (4 diffs)
• lib32/soundmixer.c (modified) (13 diffs)
• uniaud.inc (modified) (2 diffs)

GPL/branches/uniaud32-2.1.x/alsa-kernel/core/control.c

@@ -1222 +1222 @@
         }
         up_read(&snd_ioctl_rwsem);
-        snd_printdd("unknown ioctl = 0x%x\n", cmd);
+        snd_printdd("snd_ctl_ioctl: unknown ioctl = 0x%x", cmd);
         return -ENOTTY;
 }

GPL/branches/uniaud32-2.1.x/alsa-kernel/core/pcm_native.c

@@ -2600 +2600 @@
                 return snd_pcm_drop(substream);
         case SNDRV_PCM_IOCTL_PAUSE:
-        {
+                {
                 int res;
                 snd_pcm_stream_lock_irq(substream);
@@ -2606 +2606 @@
                 snd_pcm_stream_unlock_irq(substream);
                 return res;
-        }
-        }
-        snd_printd("unknown ioctl = 0x%x\n", cmd);
+                }
+        }
+        snd_printd("snd_pcm_common_ioctl1: unknown ioctl = 0x%x", cmd);
         return -ENOTTY;
 }

GPL/branches/uniaud32-2.1.x/alsa-kernel/core/pcm_os2.c

@@ +1 @@
+Apparently this file is not used in the driver
+
 #ifdef TARGET_OS2
 static int snd_pcm_setvolume(snd_pcm_substream_t * substream, snd_pcm_volume_t * _volume)

GPL/branches/uniaud32-2.1.x/alsa-kernel/include/sound/adriver.h

@@ -680 +680 @@
 #define schedule_work(w) snd_compat_schedule_work(w)
 struct workqueue_struct *snd_compat_create_workqueue(const char *name);
-#ifndef TARGET_OS2
-#define create_workqueue(name) snd_compat_create_workqueue((name))
-#endif
+
 void snd_compat_flush_workqueue(struct workqueue_struct *wq);
 #define flush_workqueue(wq) snd_compat_flush_workqueue((wq));
 void snd_compat_destroy_workqueue(struct workqueue_struct *wq);
-#ifndef TARGET_OS2
-#define destroy_workqueue(wq) snd_compat_destroy_workqueue((wq));
-#endif
 int snd_compat_queue_work(struct workqueue_struct *wq, struct work_struct *work);
-#ifndef TARGET_OS2
-#define queue_work(wq, work) snd_compat_queue_work((wq), (work))
-#endif
 int snd_compat_queue_delayed_work(struct workqueue_struct *wq, struct delayed_work *work, unsigned long delay);
-#ifndef TARGET_OS2
-#define queue_delayed_work(wq, work, delay) snd_compat_queue_delayed_work((wq), (work), (delay))
-#endif
 #define schedule_delayed_work(work, delay) snd_compat_queue_delayed_work(NULL, (work), (delay))
 int snd_compat_cancel_delayed_work(struct delayed_work *work);
 #define cancel_delayed_work(work) snd_compat_cancel_delayed_work(work)
 #define flush_scheduled_work()
+
+#ifndef TARGET_OS2
+#define create_workqueue(name) snd_compat_create_workqueue((name))
+#define destroy_workqueue(wq) snd_compat_destroy_workqueue((wq));
+#define queue_work(wq, work) snd_compat_queue_work((wq), (work))
+#define queue_delayed_work(wq, work, delay) snd_compat_queue_delayed_work((wq), (work), (delay))
+#endif
+
 #ifdef TARGET_OS2
 struct completion {

GPL/branches/uniaud32-2.1.x/alsa-kernel/pci/hda/patch_sigmatel.c

@@ -1998 +1998 @@
         SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000,
                       "ECS/PC chips", STAC_ECS_202),
+        SND_PCI_QUIRK(0x107b, 0x6051, "eMachines T5226", STAC_D945_REF),
         {0} /* terminator */
 };

GPL/branches/uniaud32-2.1.x/lib32/ioctl.c

@@ -40 +40 @@
 void uniaud_set_interrupted_substream(struct snd_pcm_substream *substream)
 {
-    int i;
-
-    for (i=0; i < 8*256; i++)
-    {
-        if (substream_int[i] == 0)
-        {
-            substream_int[i] = substream; // interrupted substream
-            //                printk("added %x to %i\n", substream, i);
-            break;
-        }
-        if (substream_int[i] == substream)
-        {
-            //                printk("already exist %x at %i\n", substream, i);
-            break;
-        }
-    }
+        int i;
+
+        for (i=0; i < 8*256; i++)
+        {
+                if (substream_int[i] == 0)
+                {
+                        substream_int[i] = substream; // interrupted substream
+                        //                                printk("added %x to %i\n", substream, i);
+                        break;
+                }
+                if (substream_int[i] == substream)
+                {
+                        //                                printk("already exist %x at %i\n", substream, i);
+                        break;
+                }
+        }
 }
 
 int WaitForControlChange(int card_id, int timeout)
 {
-    int ctl_id;
-    ULONG blkid = 0;
-    int i = 0;
-
-    while (1)
-    {
-        if (control_id_changed != 0 && card_id_changed == card_id)
-        {
-            ctl_id = control_id_changed;
-            control_id_changed = 0;
-            break;
-        }
-        i++;
-
-        if (i > timeout)
-            return -ETIME;
-
-        MyDevBlock(blkid, 1, 0);
-        if (unlock_all)
-        {
-            unlock_all = 0;
-            break;
-        }
-    }
-    return ctl_id;
+        int ctl_id;
+        ULONG blkid = 0;
+        int i = 0;
+
+        while (1)
+        {
+                if (control_id_changed != 0 && card_id_changed == card_id)
+                {
+                        ctl_id = control_id_changed;
+                        control_id_changed = 0;
+                        break;
+                }
+                i++;
+
+                if (i > timeout)
+                        return -ETIME;
+
+                MyDevBlock(blkid, 1, 0);
+                if (unlock_all)
+                {
+                        unlock_all = 0;
+                        break;
+                }
+        }
+        return ctl_id;
 }
 
 int WaitForPCMInterrupt(void *handle, int timeout)
 {
-    ULONG blkid = 0;
-    int i = 0;
-    int j = 0;
-    struct snd_pcm_file *pcm_file = NULL;
-    struct snd_pcm_substream *substream;
-    struct snd_pcm_runtime *runtime;
-    soundhandle        *pHandle = (soundhandle *)handle;
-    struct file *pfile;
-
-    if (handle == NULL)
-        return -ENXIO;
-
-    pfile = &pHandle->file;
-
-    if (pfile == NULL)
-        return -ENXIO;
-
-    pcm_file = (struct snd_pcm_file *)pfile->private_data;
-
-    if (pcm_file == NULL)
-        return -ENXIO;
-
-    substream = pcm_file->substream;
-
-    if (substream == NULL)
-        return -ENXIO;
-
-    runtime = substream->runtime;
-
-    if ((pfile->f_mode == FMODE_WRITE) &&
-        (runtime->status->state != SNDRV_PCM_STATE_RUNNING))
-        return -EBADFD;
-
-    //printk("wait for %x. tout %i\n",substream, timeout);
-
-    while (1)
-    {
-        for (i=0; i < 8*256; i++)
-        {
-            if (substream_int[i] == substream)
-            {
-//                printk("found %x at %i\n",substream_int[i], i);
-                substream_int[i] = 0;
-                //printk("j =%i\n",j);
-                return j; /* milliseconds */
-            }
-        }
-
-        if (j++ > timeout)
-        {
-            printk("j with tout =%i. handle: %x\n",j, pHandle);
-            return -ETIME;
-        }
-
-        MyDevBlock(blkid, 1, 0);
-        if (unlock_all)
-        {
-            unlock_all = 0;
-            break;
-        }
-    }
-    //printk("j at exit =%i\n",j);
-    return j;
+        ULONG blkid = 0;
+        int i = 0;
+        int j = 0;
+        struct snd_pcm_file *pcm_file = NULL;
+        struct snd_pcm_substream *substream;
+        struct snd_pcm_runtime *runtime;
+        soundhandle        *pHandle = (soundhandle *)handle;
+        struct file *pfile;
+
+        if (handle == NULL)
+                return -ENXIO;
+
+        pfile = &pHandle->file;
+
+        if (pfile == NULL)
+                return -ENXIO;
+
+        pcm_file = (struct snd_pcm_file *)pfile->private_data;
+
+        if (pcm_file == NULL)
+                return -ENXIO;
+
+        substream = pcm_file->substream;
+
+        if (substream == NULL)
+                return -ENXIO;
+
+        runtime = substream->runtime;
+
+        if ((pfile->f_mode == FMODE_WRITE) &&
+                (runtime->status->state != SNDRV_PCM_STATE_RUNNING))
+                return -EBADFD;
+
+        //printk("wait for %x. tout %i\n",substream, timeout);
+
+        while (1)
+        {
+                for (i=0; i < 8*256; i++)
+                {
+                        if (substream_int[i] == substream)
+                        {
+//                                printk("found %x at %i\n",substream_int[i], i);
+                                substream_int[i] = 0;
+                                //printk("j =%i\n",j);
+                                return j; /* milliseconds */
+                        }
+                }
+
+                if (j++ > timeout)
+                {
+                        printk("j with tout =%i. handle: %x\n",j, pHandle);
+                        return -ETIME;
+                }
+
+                MyDevBlock(blkid, 1, 0);
+                if (unlock_all)
+                {
+                        unlock_all = 0;
+                        break;
+                }
+        }
+        //printk("j at exit =%i\n",j);
+        return j;
 }
 
@@ -159 +159 @@
 int GetNumberOfCards(void)
 {
-    return nrCardsDetected;
+        return nrCardsDetected;
 }
 
@@ -167 +167 @@
 int GetNumberOfPcm(int card_id)
 {
-    return pcm_instances(card_id);
+        return pcm_instances(card_id);
 }
 
 int SetPCMInstance(int card_id, int pcm)
 {
-    if (pcm>=0 && pcm <= pcm_instances(card_id))
-    {
-        pcm_device = pcm;
-        return pcm;
-    } else
-        return pcm_device;
+        if (pcm>=0 && pcm <= pcm_instances(card_id))
+        {
+                pcm_device = pcm;
+                return pcm;
+        } else
+                return pcm_device;
 }
 
 int GetPcmForChannels(ULONG deviceid, int type, int channels)
 {
-    POSS32_DEVCAPS pcaps = NULL;
-    WAVE_CAPS *wc;
-    int i;
-    int sel_pcm = -1;
-
-    if (!pcmcaps[deviceid])
-    {
-        FillCaps(deviceid);
-        if (!pcmcaps[deviceid])
-        {
-            printk("Error querying caps for device: %i\n", deviceid);
-            return -1;
-        }
-    }
-
-    pcaps = pcmcaps[deviceid];
-
-    for (i=0; i<pcm_instances(deviceid);i++)
-    {
-        switch(type)
-        {
-        case OSS32_CAPS_WAVE_PLAYBACK: // play
-            wc = &pcaps->waveOutCaps;
-            break;
-        case OSS32_CAPS_WAVE_CAPTURE: // record
-            wc = &pcaps->waveInCaps;
-            break;
-        }
-        if (wc->ulMaxChannels == channels)
-        {
-            sel_pcm = i;
-            break;
-        }
-        pcaps++;
-    }
-
-    return sel_pcm;
+        POSS32_DEVCAPS pcaps = NULL;
+        WAVE_CAPS *wc;
+        int i;
+        int sel_pcm = -1;
+
+        if (!pcmcaps[deviceid])
+        {
+                FillCaps(deviceid);
+                if (!pcmcaps[deviceid])
+                {
+                        printk("Error querying caps for device: %i\n", deviceid);
+                        return -1;
+                }
+        }
+
+        pcaps = pcmcaps[deviceid];
+
+        for (i=0; i<pcm_instances(deviceid);i++)
+        {
+                switch(type)
+                {
+                case OSS32_CAPS_WAVE_PLAYBACK: // play
+                        wc = &pcaps->waveOutCaps;
+                        break;
+                case OSS32_CAPS_WAVE_CAPTURE: // record
+                        wc = &pcaps->waveInCaps;
+                        break;
+                }
+                if (wc->ulMaxChannels == channels)
+                {
+                        sel_pcm = i;
+                        break;
+                }
+                pcaps++;
+        }
+
+        return sel_pcm;
 }
 
 int GetMaxChannels(ULONG deviceid, int type)
 {
-    POSS32_DEVCAPS pcaps = NULL;
-    WAVE_CAPS *wc;
-    int i;
-    int sel_pcm = -1;
-    int max_ch = 0;
-
-    if (!pcmcaps[deviceid])
-    {
-        FillCaps(deviceid);
-        if (!pcmcaps[deviceid])
-        {
-            printk("Error querying caps for device: %i\n", deviceid);
-            return -1;
-        }
-    }
-
-    pcaps = pcmcaps[deviceid];
-
-    for (i=0; i<pcm_instances(deviceid);i++)
-    {
-        switch(type)
-        {
-        case OSS32_CAPS_WAVE_PLAYBACK: // play
-            wc = &pcaps->waveOutCaps;
-            break;
-        case OSS32_CAPS_WAVE_CAPTURE: // record
-            wc = &pcaps->waveInCaps;
-            break;
-        }
-        if (wc->ulMaxChannels > max_ch)
-            max_ch = wc->ulMaxChannels;
-        pcaps++;
-    }
-    return max_ch;
+        POSS32_DEVCAPS pcaps = NULL;
+        WAVE_CAPS *wc;
+        int i;
+        int sel_pcm = -1;
+        int max_ch = 0;
+
+        if (!pcmcaps[deviceid])
+        {
+                FillCaps(deviceid);
+                if (!pcmcaps[deviceid])
+                {
+                        printk("Error querying caps for device: %i\n", deviceid);
+                        return -1;
+                }
+        }
+
+        pcaps = pcmcaps[deviceid];
+
+        for (i=0; i<pcm_instances(deviceid);i++)
+        {
+                switch(type)
+                {
+                case OSS32_CAPS_WAVE_PLAYBACK: // play
+                        wc = &pcaps->waveOutCaps;
+                        break;
+                case OSS32_CAPS_WAVE_CAPTURE: // record
+                        wc = &pcaps->waveInCaps;
+                        break;
+                }
+                if (wc->ulMaxChannels > max_ch)
+                        max_ch = wc->ulMaxChannels;
+                pcaps++;
+        }
+        return max_ch;
 }
 
@@ -264 +264 @@
 int GetUniaudPcmCaps1(ULONG deviceid, void *caps)
 {
-    POSS32_DEVCAPS pcaps = (POSS32_DEVCAPS)caps;
-    int i;
-    OSSSTREAMID          streamid = 0;
-    soundhandle         *pHandle;
-    struct snd_pcm_info      *pcminfo = NULL;
-    struct snd_pcm_hw_params *params;
-    int                  ret, fmt, j;
-    ULONG                format_mask;
-    struct snd_mask           *mask;
-    int pcms = 0;
-
-    pcms = pcm_instances(deviceid);
-
-    if (!pcaps || !pcms) return -1;
-
-
-    //these structures are too big to put on the stack
-    pcminfo = (struct snd_pcm_info *)kmalloc(sizeof(struct snd_pcm_info)+sizeof(struct snd_pcm_hw_params), GFP_KERNEL);
-    if(pcminfo == NULL) {
-        DebugInt3();
-        rprintf(("GetUniaudPcmCaps: out of memory"));
-        return OSSERR_OUT_OF_MEMORY;
-    }
-    params = (struct snd_pcm_hw_params *)(pcminfo+1);
-
-    for (i=0; i<pcms;i++)
-    {
-        pcaps->nrDevices  = nrCardsDetected;
-        pcaps->ulCaps     = OSS32_CAPS_WAVE_PLAYBACK | OSS32_CAPS_WAVE_CAPTURE;
-
-        //query wave in & out caps
-        for(j=0;j<2;j++)
-        {
-            PWAVE_CAPS pWaveCaps = (j == 0) ? &pcaps->waveOutCaps : &pcaps->waveInCaps;
-
-            ret = OSS32_WaveOpen(deviceid, (j == 0) ? OSS32_STREAM_WAVEOUT : OSS32_STREAM_WAVEIN, &streamid, i, 0);
-            if(ret != OSSERR_SUCCESS)
-            {
-                rprintf(("GetUniaudPcmCaps: wave open error %i %s at pcm %i", ret,
-                       (j == 0) ?"PLAY":"REC", i));
-                continue;
-//                goto fail;
-            }
-            pHandle = (soundhandle *)streamid;
-            if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
-                rprintf(("GetUniaudPcmCaps: invalid stream id"));
-                ret = OSSERR_INVALID_STREAMID;
-//                goto fail;
-            }
-
-            //set operation to non-blocking
-            pHandle->file.f_flags = O_NONBLOCK;
-
-            dprintf(("GetUniaudPcmCaps: cp1. phandle %x", pHandle));
-            ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_INFO, (ULONG)pcminfo);
-            if(ret != 0) {
-                rprintf(("GetUniaudPcmCaps: SNDRV_PCM_IOCTL_INFO error %i", ret));
-                ret = UNIXToOSSError(ret);
-                continue;
-            }
-            if(pcminfo->name[0]) {
-                strncpy(pcaps->szDeviceName, pcminfo->name, sizeof(pcaps->szDeviceName));
-            }
-            else strncpy(pcaps->szDeviceName, pcminfo->id, sizeof(pcaps->szDeviceName));
-
-            if(pcminfo->subname[0]) {
-                strncpy(pcaps->szMixerName, pcminfo->subname, sizeof(pcaps->szMixerName));
-            }
-
-            pWaveCaps->nrStreams = pcminfo->subdevices_count;
-
-            dprintf(("GetUniaudPcmCaps: cp2. nr of streams: %i", pWaveCaps->nrStreams));
-            //get all hardware parameters
-            _snd_pcm_hw_params_any(params);
-            ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
-            if(ret != 0) {
-                rprintf(("GetUniaudPcmCaps: SNDRV_PCM_IOCTL_HW_REFINE error %i", ret));
-                ret = UNIXToOSSError(ret);
-                //goto fail;
-                continue;
-            }
-            //dprintf("GetUniaudPcmCaps: cp3"));
-
-            pWaveCaps->ulMinChannels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min;
-            pWaveCaps->ulMaxChannels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max;
-            dprintf(("chan: from %i to %i\n", pWaveCaps->ulMinChannels,pWaveCaps->ulMaxChannels));
-            pWaveCaps->ulChanFlags   = 0;
-            if(pWaveCaps->ulMinChannels == 1) {
-                pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_MONO;
-            }
-            if(pWaveCaps->ulMaxChannels >= 2) {
-                pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_STEREO;
-            }
-            if(pWaveCaps->ulMaxChannels >= 4) {
-                pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_QUAD;
-            }
-            if(pWaveCaps->ulMaxChannels >= 6) {
-                pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_5_1;
-            }
-
-            pWaveCaps->ulMinRate     = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min;
-            pWaveCaps->ulMaxRate     = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max;
-
-            mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_RATE_MASK);
+        POSS32_DEVCAPS pcaps = (POSS32_DEVCAPS)caps;
+        int i;
+        OSSSTREAMID              streamid = 0;
+        soundhandle             *pHandle;
+        struct snd_pcm_info      *pcminfo = NULL;
+        struct snd_pcm_hw_params *params;
+        int                              ret, fmt, j;
+        ULONG                            format_mask;
+        struct snd_mask                   *mask;
+        int pcms = 0;
+
+        pcms = pcm_instances(deviceid);
+
+        if (!pcaps || !pcms) return -1;
+
+
+        //these structures are too big to put on the stack
+        pcminfo = (struct snd_pcm_info *)kmalloc(sizeof(struct snd_pcm_info)+sizeof(struct snd_pcm_hw_params), GFP_KERNEL);
+        if(pcminfo == NULL) {
+                DebugInt3();
+                rprintf(("GetUniaudPcmCaps: out of memory"));
+                return OSSERR_OUT_OF_MEMORY;
+        }
+        params = (struct snd_pcm_hw_params *)(pcminfo+1);
+
+        for (i=0; i<pcms;i++)
+        {
+                pcaps->nrDevices  = nrCardsDetected;
+                pcaps->ulCaps     = OSS32_CAPS_WAVE_PLAYBACK | OSS32_CAPS_WAVE_CAPTURE;
+
+                //query wave in & out caps
+                for(j=0;j<2;j++)
+                {
+                        PWAVE_CAPS pWaveCaps = (j == 0) ? &pcaps->waveOutCaps : &pcaps->waveInCaps;
+
+                        ret = OSS32_WaveOpen(deviceid, (j == 0) ? OSS32_STREAM_WAVEOUT : OSS32_STREAM_WAVEIN, &streamid, i, 0);
+                        if(ret != OSSERR_SUCCESS)
+                        {
+                                dprintf(("GetUniaudPcmCaps: wave open error %i %s at pcm %i", ret, (j == 0) ?"PLAY":"REC", i));
+                                continue;
+                                //goto fail;
+                        }
+                        pHandle = (soundhandle *)streamid;
+                        if(pHandle == NULL || pHandle->magic != MAGIC_WAVE_ALSA32) {
+                                rprintf(("GetUniaudPcmCaps: invalid stream id"));
+                                ret = OSSERR_INVALID_STREAMID;
+                                //goto fail;
+                        }
+
+                        //set operation to non-blocking
+                        pHandle->file.f_flags = O_NONBLOCK;
+
+                        dprintf(("GetUniaudPcmCaps: cp1. phandle %x", pHandle));
+                        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_INFO, (ULONG)pcminfo);
+                        if(ret != 0) {
+                                rprintf(("GetUniaudPcmCaps: SNDRV_PCM_IOCTL_INFO error %i", ret));
+                                ret = UNIXToOSSError(ret);
+                                continue;
+                        }
+                        if(pcminfo->name[0]) {
+                                strncpy(pcaps->szDeviceName, pcminfo->name, sizeof(pcaps->szDeviceName));
+                        }
+                        else strncpy(pcaps->szDeviceName, pcminfo->id, sizeof(pcaps->szDeviceName));
+
+                        if(pcminfo->subname[0]) {
+                                strncpy(pcaps->szMixerName, pcminfo->subname, sizeof(pcaps->szMixerName));
+                        }
+
+                        pWaveCaps->nrStreams = pcminfo->subdevices_count;
+
+                        dprintf(("GetUniaudPcmCaps: cp2. nr of streams: %i", pWaveCaps->nrStreams));
+                        //get all hardware parameters
+                        _snd_pcm_hw_params_any(params);
+                        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
+                        if(ret != 0) {
+                                dprintf(("GetUniaudPcmCaps: SNDRV_PCM_IOCTL_HW_REFINE error %i", ret));
+                                ret = UNIXToOSSError(ret);
+                                //goto fail;
+                                continue;
+                        }
+                        //dprintf("GetUniaudPcmCaps: cp3"));
+
+                        pWaveCaps->ulMinChannels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min;
+                        pWaveCaps->ulMaxChannels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max;
+                        dprintf(("chan: from %i to %i\n", pWaveCaps->ulMinChannels,pWaveCaps->ulMaxChannels));
+                        pWaveCaps->ulChanFlags   = 0;
+                        if(pWaveCaps->ulMinChannels == 1) {
+                                pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_MONO;
+                        }
+                        if(pWaveCaps->ulMaxChannels >= 2) {
+                                pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_STEREO;
+                        }
+                        if(pWaveCaps->ulMaxChannels >= 4) {
+                                pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_QUAD;
+                        }
+                        if(pWaveCaps->ulMaxChannels >= 6) {
+                                pWaveCaps->ulChanFlags |= OSS32_CAPS_PCM_CHAN_5_1;
+                        }
+
+                        pWaveCaps->ulMinRate     = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min;
+                        pWaveCaps->ulMaxRate     = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max;
+
+                        mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_RATE_MASK);
                         //mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
-            pWaveCaps->ulRateFlags   = mask->bits[0];
-
-            pWaveCaps->ulRateFlags   = ALSAToOSSRateFlags(pWaveCaps->ulRateFlags);
-
-            pWaveCaps->ulDataFormats = 0;
-
-            mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
-            format_mask = mask->bits[0];
-            for(fmt=0;fmt<32;fmt++)
-            {
-                if(format_mask & (1 << fmt))
-                {
-                    int f = ALSAToOSSDataType(fmt);
-                    if (f >= 0)
-                        pWaveCaps->ulDataFormats |= f;
-                }
-            }
-
-            OSS32_WaveClose(streamid);
-            streamid = 0;
-        } // for j
-        pcaps++; // next pcm
-    } // for i
-
-    if (pcminfo) kfree(pcminfo);
-    return OSSERR_SUCCESS;
+                        pWaveCaps->ulRateFlags   = mask->bits[0];
+
+                        pWaveCaps->ulRateFlags   = ALSAToOSSRateFlags(pWaveCaps->ulRateFlags);
+
+                        pWaveCaps->ulDataFormats = 0;
+
+                        mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
+                        format_mask = mask->bits[0];
+                        for(fmt=0;fmt<32;fmt++)
+                        {
+                                if(format_mask & (1 << fmt))
+                                {
+                                        int f = ALSAToOSSDataType(fmt);
+                                        if (f >= 0)
+                                                pWaveCaps->ulDataFormats |= f;
+                                }
+                        }
+
+                        OSS32_WaveClose(streamid);
+                        streamid = 0;
+                } // for j
+                pcaps++; // next pcm
+        } // for i
+
+        if (pcminfo) kfree(pcminfo);
+        return OSSERR_SUCCESS;
 }
 
 void FillCaps(ULONG deviceid)
 {
-    int pcms = 0;
-
-    pcms = pcm_instances(deviceid);
-
-    dprintf(("FillCaps: pcms=%i\n", pcms));
-    if (!pcmcaps[deviceid])
-    {
-        pcmcaps[deviceid] = (POSS32_DEVCAPS)kmalloc(sizeof(OSS32_DEVCAPS)*pcms, GFP_KERNEL);
-        if (pcmcaps[deviceid])
-        {
-            memset(pcmcaps[deviceid], 0, sizeof(OSS32_DEVCAPS)*pcms);
-            GetUniaudPcmCaps1(deviceid, (void *)pcmcaps[deviceid]);
-        }
-    }
-    return;
+        int pcms = 0;
+
+        pcms = pcm_instances(deviceid);
+
+        dprintf(("FillCaps: pcms=%i\n", pcms));
+        if (!pcmcaps[deviceid])
+        {
+                pcmcaps[deviceid] = (POSS32_DEVCAPS)kmalloc(sizeof(OSS32_DEVCAPS)*pcms, GFP_KERNEL);
+                if (pcmcaps[deviceid])
+                {
+                        memset(pcmcaps[deviceid], 0, sizeof(OSS32_DEVCAPS)*pcms);
+                        GetUniaudPcmCaps1(deviceid, (void *)pcmcaps[deviceid]);
+                }
+        }
+        return;
 }
 
 int GetUniaudPcmCaps(ULONG deviceid, void *caps)
 {
-    int pcms = 0;
-
-    pcms = pcm_instances(deviceid);
-
-//    printk("pcms = %i\n", pcms);
-    if (pcmcaps[deviceid])
-    {
-        memcpy((unsigned char*)caps,(unsigned char*)pcmcaps[deviceid],sizeof(OSS32_DEVCAPS)*pcms);
-        return 0;
-    }
-    else
-    {
-        return -1;
-    }
+        int pcms = 0;
+
+        pcms = pcm_instances(deviceid);
+
+//        printk("pcms = %i\n", pcms);
+        if (pcmcaps[deviceid])
+        {
+                memcpy((unsigned char*)caps,(unsigned char*)pcmcaps[deviceid],sizeof(OSS32_DEVCAPS)*pcms);
+                return 0;
+        }
+        else
+        {
+                return -1;
+        }
 }
 
@@ -439 +438 @@
 int UniaudCtlGetPowerState(ULONG deviceid, void *state)
 {
-    mixerhandle *pHandle = NULL;
-    int          ret, i, j;
-
-    if(alsa_fops == NULL) {
-        ret = OSSERR_NO_DEVICE_AVAILABLE;
-        goto failure;
-    }
-
-    pHandle = kmalloc(sizeof(mixerhandle), GFP_KERNEL);
-    if(pHandle == NULL) {
-        ret = OSSERR_OUT_OF_MEMORY;
-        goto failure;
-    }
-    memset(pHandle, 0, sizeof(mixerhandle));
-
-    //set operation to non-blocking
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    //setup pointers in file structure (used internally by ALSA)
-    pHandle->file.f_dentry          = &pHandle->d_entry;
-    pHandle->file.f_dentry->d_inode = &pHandle->inode;
-
-    pHandle->file.f_mode  = FMODE_WRITE;
-    pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
-
-    ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
-    if(ret) {
-        goto failure;
-    }
-    //retrieve mixer information
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
-                                    SNDRV_CTL_IOCTL_POWER_STATE,
-                                    (ULONG)state);
-
-    pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-
-    kfree(pHandle);
-
-    if(ret) {
-        goto failure;
-    }
-
-    return OSSERR_SUCCESS;
+        mixerhandle *pHandle = NULL;
+        int              ret, i, j;
+
+        if(alsa_fops == NULL) {
+                ret = OSSERR_NO_DEVICE_AVAILABLE;
+                goto failure;
+        }
+
+        pHandle = kmalloc(sizeof(mixerhandle), GFP_KERNEL);
+        if(pHandle == NULL) {
+                ret = OSSERR_OUT_OF_MEMORY;
+                goto failure;
+        }
+        memset(pHandle, 0, sizeof(mixerhandle));
+
+        //set operation to non-blocking
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        //setup pointers in file structure (used internally by ALSA)
+        pHandle->file.f_dentry                  = &pHandle->d_entry;
+        pHandle->file.f_dentry->d_inode = &pHandle->inode;
+
+        pHandle->file.f_mode  = FMODE_WRITE;
+        pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
+
+        ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
+        if(ret) {
+                goto failure;
+        }
+        //retrieve mixer information
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+                                                                        SNDRV_CTL_IOCTL_POWER_STATE,
+                                                                        (ULONG)state);
+
+        pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+
+        kfree(pHandle);
+
+        if(ret) {
+                goto failure;
+        }
+
+        return OSSERR_SUCCESS;
 failure:
-    DebugInt3();
-    return ret;
+        DebugInt3();
+        return ret;
 }
 
@@ -492 +491 @@
 int UniaudCtlSetPowerState(ULONG deviceid, void *state)
 {
-    mixerhandle *pHandle = NULL;
-    int          ret, i, j;
-
-    if(alsa_fops == NULL) {
-        ret = OSSERR_NO_DEVICE_AVAILABLE;
-        goto failure;
-    }
-
-    pHandle = kmalloc(sizeof(mixerhandle), GFP_KERNEL);
-    if(pHandle == NULL) {
-        ret = OSSERR_OUT_OF_MEMORY;
-        goto failure;
-    }
-    memset(pHandle, 0, sizeof(mixerhandle));
-
-    //set operation to non-blocking
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    //setup pointers in file structure (used internally by ALSA)
-    pHandle->file.f_dentry          = &pHandle->d_entry;
-    pHandle->file.f_dentry->d_inode = &pHandle->inode;
-
-    pHandle->file.f_mode  = FMODE_WRITE;
-    pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
-
-    ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
-    if(ret) {
-        goto failure;
-    }
-    //retrieve mixer information
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
-                                    SNDRV_CTL_IOCTL_POWER,
-                                    (ULONG)state);
-
-    pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-
-    kfree(pHandle);
-
-    if(ret) {
-        goto failure;
-    }
-
-    return OSSERR_SUCCESS;
+        mixerhandle *pHandle = NULL;
+        int              ret, i, j;
+
+        if(alsa_fops == NULL) {
+                ret = OSSERR_NO_DEVICE_AVAILABLE;
+                goto failure;
+        }
+
+        pHandle = kmalloc(sizeof(mixerhandle), GFP_KERNEL);
+        if(pHandle == NULL) {
+                ret = OSSERR_OUT_OF_MEMORY;
+                goto failure;
+        }
+        memset(pHandle, 0, sizeof(mixerhandle));
+
+        //set operation to non-blocking
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        //setup pointers in file structure (used internally by ALSA)
+        pHandle->file.f_dentry                  = &pHandle->d_entry;
+        pHandle->file.f_dentry->d_inode = &pHandle->inode;
+
+        pHandle->file.f_mode  = FMODE_WRITE;
+        pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
+
+        ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
+        if(ret) {
+                goto failure;
+        }
+        //retrieve mixer information
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+                                                                        SNDRV_CTL_IOCTL_POWER,
+                                                                        (ULONG)state);
+
+        pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+
+        kfree(pHandle);
+
+        if(ret) {
+                goto failure;
+        }
+
+        return OSSERR_SUCCESS;
 failure:
-    DebugInt3();
-    return ret;
+        DebugInt3();
+        return ret;
 }
 
@@ -545 +544 @@
 int GetUniaudCardInfo(ULONG deviceid, void *info)
 {
-    mixerhandle *pHandle = NULL;
-    int          ret, i, j;
-//    struct snd_ctl_card_info *pinfo;
-
-    if(alsa_fops == NULL) {
-        ret = OSSERR_NO_DEVICE_AVAILABLE;
-        goto failure;
-    }
-
-    pHandle = kmalloc(sizeof(mixerhandle), GFP_KERNEL);
-    if(pHandle == NULL) {
-        ret = OSSERR_OUT_OF_MEMORY;
-        goto failure;
-    }
-    memset(pHandle, 0, sizeof(mixerhandle));
-
-    //set operation to non-blocking
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    //setup pointers in file structure (used internally by ALSA)
-    pHandle->file.f_dentry          = &pHandle->d_entry;
-    pHandle->file.f_dentry->d_inode = &pHandle->inode;
-
-    pHandle->file.f_mode  = FMODE_WRITE;
-    pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
-
-    ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
-    if(ret) {
-        goto failure;
-    }
-    //retrieve mixer information
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
-                                    SNDRV_CTL_IOCTL_CARD_INFO,
-                                    (ULONG)(struct snd_ctl_card_info *)info);
-    if(ret) {
-        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-        goto failure;
-    }
-    ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-
-    if(pHandle) {
-        kfree(pHandle);
-    }
-    return OSSERR_SUCCESS;
+        mixerhandle *pHandle = NULL;
+        int              ret, i, j;
+//        struct snd_ctl_card_info *pinfo;
+
+        if(alsa_fops == NULL) {
+                ret = OSSERR_NO_DEVICE_AVAILABLE;
+                goto failure;
+        }
+
+        pHandle = kmalloc(sizeof(mixerhandle), GFP_KERNEL);
+        if(pHandle == NULL) {
+                ret = OSSERR_OUT_OF_MEMORY;
+                goto failure;
+        }
+        memset(pHandle, 0, sizeof(mixerhandle));
+
+        //set operation to non-blocking
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        //setup pointers in file structure (used internally by ALSA)
+        pHandle->file.f_dentry                  = &pHandle->d_entry;
+        pHandle->file.f_dentry->d_inode = &pHandle->inode;
+
+        pHandle->file.f_mode  = FMODE_WRITE;
+        pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
+
+        ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
+        if(ret) {
+                goto failure;
+        }
+        //retrieve mixer information
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+                                                                        SNDRV_CTL_IOCTL_CARD_INFO,
+                                                                        (ULONG)(struct snd_ctl_card_info *)info);
+        if(ret) {
+                ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+                goto failure;
+        }
+        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+
+        if(pHandle) {
+                kfree(pHandle);
+        }
+        return OSSERR_SUCCESS;
 failure:
-    if(pHandle) {
-        kfree(pHandle);
-    }
-    DebugInt3();
-    return OSSERR_OUT_OF_MEMORY;
+        if(pHandle) {
+                kfree(pHandle);
+        }
+        DebugInt3();
+        return OSSERR_OUT_OF_MEMORY;
 }
 
 int GetUniaudControlNum(ULONG deviceid)
 {
-    mixerhandle *pHandle = NULL;
-    int          ret, i, j, sz;
-
-    if(alsa_fops == NULL) {
-        ret = OSSERR_NO_DEVICE_AVAILABLE;
-        goto failure;
-    }
-
-    sz = sizeof(mixerhandle);
-    pHandle = kmalloc(sz, GFP_KERNEL);
-    if(pHandle == NULL) {
-        ret = OSSERR_OUT_OF_MEMORY;
-        goto failure;
-    }
-    memset(pHandle, 0, sizeof(mixerhandle));
-
-    //set operation to non-blocking
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    //setup pointers in file structure (used internally by ALSA)
-    pHandle->file.f_dentry          = &pHandle->d_entry;
-    pHandle->file.f_dentry->d_inode = &pHandle->inode;
-
-    pHandle->file.f_mode  = FMODE_WRITE;
-    pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
-
-    ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
-    if(ret) {
-        goto failure;
-    }
-    //retrieve mixer information
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
-                                    SNDRV_CTL_IOCTL_CARD_INFO,
-                                    (ULONG)&pHandle->info);
-    if(ret) {
-        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-        goto failure;
-    }
-    //get the number of mixer elements
-    pHandle->list.offset = 0;
-    pHandle->list.space  = 0;
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
-                                    SNDRV_CTL_IOCTL_ELEM_LIST,
-                                    (ULONG)&pHandle->list);
-    if(ret) {
-        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-        goto failure;
-    }
-    ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-    if(pHandle) {
-        if(pHandle->pids) kfree(pHandle->pids);
-        kfree(pHandle);
-    }
-    return pHandle->list.count;
+        mixerhandle *pHandle = NULL;
+        int              ret, i, j, sz;
+
+        if(alsa_fops == NULL) {
+                ret = OSSERR_NO_DEVICE_AVAILABLE;
+                goto failure;
+        }
+
+        sz = sizeof(mixerhandle);
+        pHandle = kmalloc(sz, GFP_KERNEL);
+        if(pHandle == NULL) {
+                ret = OSSERR_OUT_OF_MEMORY;
+                goto failure;
+        }
+        memset(pHandle, 0, sizeof(mixerhandle));
+
+        //set operation to non-blocking
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        //setup pointers in file structure (used internally by ALSA)
+        pHandle->file.f_dentry                  = &pHandle->d_entry;
+        pHandle->file.f_dentry->d_inode = &pHandle->inode;
+
+        pHandle->file.f_mode  = FMODE_WRITE;
+        pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
+
+        ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
+        if(ret) {
+                goto failure;
+        }
+        //retrieve mixer information
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+                                                                        SNDRV_CTL_IOCTL_CARD_INFO,
+                                                                        (ULONG)&pHandle->info);
+        if(ret) {
+                ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+                goto failure;
+        }
+        //get the number of mixer elements
+        pHandle->list.offset = 0;
+        pHandle->list.space  = 0;
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+                                                                        SNDRV_CTL_IOCTL_ELEM_LIST,
+                                                                        (ULONG)&pHandle->list);
+        if(ret) {
+                ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+                goto failure;
+        }
+        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+        if(pHandle) {
+                if(pHandle->pids) kfree(pHandle->pids);
+                kfree(pHandle);
+        }
+        return pHandle->list.count;
 failure:
-    if(pHandle) {
-        if(pHandle->pids) kfree(pHandle->pids);
-        kfree(pHandle);
-    }
-    DebugInt3();
-    return OSSERR_OUT_OF_MEMORY;
+        if(pHandle) {
+                if(pHandle->pids) kfree(pHandle->pids);
+                kfree(pHandle);
+        }
+        DebugInt3();
+        return OSSERR_OUT_OF_MEMORY;
 }
 
 int GetUniaudControls(ULONG deviceid, void *pids)
 {
-    mixerhandle *pHandle = NULL;
-    int          ret, i, j, sz;
-
-    if(alsa_fops == NULL) {
-        ret = OSSERR_NO_DEVICE_AVAILABLE;
-        goto failure;
-    }
-
-    sz = sizeof(mixerhandle);
-    pHandle = kmalloc(sz, GFP_KERNEL);
-    if(pHandle == NULL) {
-        ret = OSSERR_OUT_OF_MEMORY;
-        goto failure;
-    }
-    memset(pHandle, 0, sizeof(mixerhandle));
-
-    //set operation to non-blocking
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    //setup pointers in file structure (used internally by ALSA)
-    pHandle->file.f_dentry          = &pHandle->d_entry;
-    pHandle->file.f_dentry->d_inode = &pHandle->inode;
-
-    pHandle->file.f_mode  = FMODE_WRITE;
-    pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
-
-    ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
-    if(ret) {
-        goto failure;
-    }
-    //retrieve mixer information
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
-                                    SNDRV_CTL_IOCTL_CARD_INFO,
-                                    (ULONG)&pHandle->info);
-    if(ret) {
-        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-        goto failure;
-    }
-    //get the number of mixer elements
-    pHandle->list.offset = 0;
-    pHandle->list.space  = 0;
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
-                                    SNDRV_CTL_IOCTL_ELEM_LIST,
-                                    (ULONG)&pHandle->list);
-    if(ret) {
-        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-        goto failure;
-    }
-
-    //allocate memory for all mixer elements
-    pHandle->pids = (struct snd_ctl_elem_id *)pids;
-        //kmalloc(sizeof(struct snd_ctl_elem_id)*pHandle->list.count, GFP_KERNEL);
-    if(pHandle->pids == NULL) {
-        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-        goto failure;
-    }
-    //and retrieve all mixer elements
-    pHandle->list.offset = 0;
-    pHandle->list.space  = pHandle->list.count;
-    pHandle->list.pids   = pHandle->pids;
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
-                                    SNDRV_CTL_IOCTL_ELEM_LIST,
-                                    (ULONG)&pHandle->list);
-    if(ret) {
-        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-        goto failure;
-    }
-//    if (pids)
-//        memcpy(pids, pHandle->pids,
-//               sizeof(struct snd_ctl_elem_id)*pHandle->list.count);
-
-    ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-    if(pHandle) {
-//        if(pHandle->pids) kfree(pHandle->pids);
-        kfree(pHandle);
-    }
-    return pHandle->list.count;
+        mixerhandle *pHandle = NULL;
+        int              ret, i, j, sz;
+
+        if(alsa_fops == NULL) {
+                ret = OSSERR_NO_DEVICE_AVAILABLE;
+                goto failure;
+        }
+
+        sz = sizeof(mixerhandle);
+        pHandle = kmalloc(sz, GFP_KERNEL);
+        if(pHandle == NULL) {
+                ret = OSSERR_OUT_OF_MEMORY;
+                goto failure;
+        }
+        memset(pHandle, 0, sizeof(mixerhandle));
+
+        //set operation to non-blocking
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        //setup pointers in file structure (used internally by ALSA)
+        pHandle->file.f_dentry                  = &pHandle->d_entry;
+        pHandle->file.f_dentry->d_inode = &pHandle->inode;
+
+        pHandle->file.f_mode  = FMODE_WRITE;
+        pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
+
+        ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
+        if(ret) {
+                goto failure;
+        }
+        //retrieve mixer information
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+                                                                        SNDRV_CTL_IOCTL_CARD_INFO,
+                                                                        (ULONG)&pHandle->info);
+        if(ret) {
+                ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+                goto failure;
+        }
+        //get the number of mixer elements
+        pHandle->list.offset = 0;
+        pHandle->list.space  = 0;
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+                                                                        SNDRV_CTL_IOCTL_ELEM_LIST,
+                                                                        (ULONG)&pHandle->list);
+        if(ret) {
+                ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+                goto failure;
+        }
+
+        //allocate memory for all mixer elements
+        pHandle->pids = (struct snd_ctl_elem_id *)pids;
+                //kmalloc(sizeof(struct snd_ctl_elem_id)*pHandle->list.count, GFP_KERNEL);
+        if(pHandle->pids == NULL) {
+                ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+                goto failure;
+        }
+        //and retrieve all mixer elements
+        pHandle->list.offset = 0;
+        pHandle->list.space  = pHandle->list.count;
+        pHandle->list.pids       = pHandle->pids;
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+                                                                        SNDRV_CTL_IOCTL_ELEM_LIST,
+                                                                        (ULONG)&pHandle->list);
+        if(ret) {
+                ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+                goto failure;
+        }
+//        if (pids)
+//                memcpy(pids, pHandle->pids,
+//                               sizeof(struct snd_ctl_elem_id)*pHandle->list.count);
+
+        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+        if(pHandle) {
+//                if(pHandle->pids) kfree(pHandle->pids);
+                kfree(pHandle);
+        }
+        return pHandle->list.count;
 failure:
-    if(pHandle) {
-//        if(pHandle->pids) kfree(pHandle->pids);
-        kfree(pHandle);
-    }
-    DebugInt3();
-    return OSSERR_OUT_OF_MEMORY;
+        if(pHandle) {
+//                if(pHandle->pids) kfree(pHandle->pids);
+                kfree(pHandle);
+        }
+        DebugInt3();
+        return OSSERR_OUT_OF_MEMORY;
 }
 
 int GetUniaudControlInfo(ULONG deviceid, ULONG id, void *info)
 {
-    struct snd_ctl_elem_value *pElem = NULL;
-    struct snd_ctl_elem_info  *pElemInfo = NULL;
-    mixerhandle *pHandle = NULL;
-    int          ret, i, j, sz;
-
-    if(alsa_fops == NULL) {
-        ret = OSSERR_NO_DEVICE_AVAILABLE;
-        goto failure;
-    }
-
-    sz = sizeof(mixerhandle);
-    pHandle = kmalloc(sz, GFP_KERNEL);
-    if(pHandle == NULL) {
-        ret = OSSERR_OUT_OF_MEMORY;
-        goto failure;
-    }
-    memset(pHandle, 0, sizeof(mixerhandle));
-
-    //set operation to non-blocking
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    //setup pointers in file structure (used internally by ALSA)
-    pHandle->file.f_dentry          = &pHandle->d_entry;
-    pHandle->file.f_dentry->d_inode = &pHandle->inode;
-
-    pHandle->file.f_mode  = FMODE_WRITE;
-    pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
-
-    ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
-    if(ret) {
-        goto failure;
-    }
-
-    //allocate memory for info element
-    pElemInfo = (struct snd_ctl_elem_info *)info;
-    if(pElemInfo == NULL) {
-        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-        goto failure;
-    }
-
-//    printk("sizeof elem_info %i\n",sizeof(struct snd_ctl_elem_info));
-
-    pElemInfo->id.numid = id;
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
-    ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-    if(pHandle) kfree(pHandle);
-//    printk("elem type: %i, id: %i, card: %i\n", pElemInfo->type, pElemInfo->id.numid, deviceid);
-    return OSSERR_SUCCESS;
+        struct snd_ctl_elem_value *pElem = NULL;
+        struct snd_ctl_elem_info  *pElemInfo = NULL;
+        mixerhandle *pHandle = NULL;
+        int              ret, i, j, sz;
+
+        if(alsa_fops == NULL) {
+                ret = OSSERR_NO_DEVICE_AVAILABLE;
+                goto failure;
+        }
+
+        sz = sizeof(mixerhandle);
+        pHandle = kmalloc(sz, GFP_KERNEL);
+        if(pHandle == NULL) {
+                ret = OSSERR_OUT_OF_MEMORY;
+                goto failure;
+        }
+        memset(pHandle, 0, sizeof(mixerhandle));
+
+        //set operation to non-blocking
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        //setup pointers in file structure (used internally by ALSA)
+        pHandle->file.f_dentry                  = &pHandle->d_entry;
+        pHandle->file.f_dentry->d_inode = &pHandle->inode;
+
+        pHandle->file.f_mode  = FMODE_WRITE;
+        pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
+
+        ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
+        if(ret) {
+                goto failure;
+        }
+
+        //allocate memory for info element
+        pElemInfo = (struct snd_ctl_elem_info *)info;
+        if(pElemInfo == NULL) {
+                ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+                goto failure;
+        }
+
+//        printk("sizeof elem_info %i\n",sizeof(struct snd_ctl_elem_info));
+
+        pElemInfo->id.numid = id;
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
+        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+        if(pHandle) kfree(pHandle);
+//        printk("elem type: %i, id: %i, card: %i\n", pElemInfo->type, pElemInfo->id.numid, deviceid);
+        return OSSERR_SUCCESS;
 
 failure:
-    if(pHandle) {
-        kfree(pHandle);
-    }
-    DebugInt3();
-    return OSSERR_OUT_OF_MEMORY;
+        if(pHandle) {
+                kfree(pHandle);
+        }
+        DebugInt3();
+        return OSSERR_OUT_OF_MEMORY;
 }
 
 int GetUniaudControlValueGet(ULONG deviceid, ULONG id, void *value)
 {
-    struct snd_ctl_elem_value *pElem = NULL;
-    struct snd_ctl_elem_info  *pElemInfo = NULL;
-    mixerhandle *pHandle = NULL;
-    int          ret, i, j, sz;
-
-    if(alsa_fops == NULL) {
-        ret = OSSERR_NO_DEVICE_AVAILABLE;
-        goto failure;
-    }
-
-    sz = sizeof(mixerhandle);
-    pHandle = kmalloc(sz, GFP_KERNEL);
-    if(pHandle == NULL) {
-        ret = OSSERR_OUT_OF_MEMORY;
-        goto failure;
-    }
-    memset(pHandle, 0, sizeof(mixerhandle));
-
-    //set operation to non-blocking
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    //setup pointers in file structure (used internally by ALSA)
-    pHandle->file.f_dentry          = &pHandle->d_entry;
-    pHandle->file.f_dentry->d_inode = &pHandle->inode;
-
-    pHandle->file.f_mode  = FMODE_WRITE;
-    pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
-
-    ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
-    if(ret) {
-        goto failure;
-    }
-
-    pElem = (struct snd_ctl_elem_value *)value;
-    if(pElem == NULL) {
-        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-        goto failure;
-    }
-
-//    printk("sizeof elem_info %i\n",sizeof(struct snd_ctl_elem_info));
-
-    pElem->id.numid = id;
-    pElem->indirect = 0;
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_READ, (ULONG)pElem);
-    ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-    if(pHandle) kfree(pHandle);
-
-    return OSSERR_SUCCESS;
+        struct snd_ctl_elem_value *pElem = NULL;
+        struct snd_ctl_elem_info  *pElemInfo = NULL;
+        mixerhandle *pHandle = NULL;
+        int              ret, i, j, sz;
+
+        if(alsa_fops == NULL) {
+                ret = OSSERR_NO_DEVICE_AVAILABLE;
+                goto failure;
+        }
+
+        sz = sizeof(mixerhandle);
+        pHandle = kmalloc(sz, GFP_KERNEL);
+        if(pHandle == NULL) {
+                ret = OSSERR_OUT_OF_MEMORY;
+                goto failure;
+        }
+        memset(pHandle, 0, sizeof(mixerhandle));
+
+        //set operation to non-blocking
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        //setup pointers in file structure (used internally by ALSA)
+        pHandle->file.f_dentry                  = &pHandle->d_entry;
+        pHandle->file.f_dentry->d_inode = &pHandle->inode;
+
+        pHandle->file.f_mode  = FMODE_WRITE;
+        pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
+
+        ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
+        if(ret) {
+                goto failure;
+        }
+
+        pElem = (struct snd_ctl_elem_value *)value;
+        if(pElem == NULL) {
+                ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+                goto failure;
+        }
+
+//        printk("sizeof elem_info %i\n",sizeof(struct snd_ctl_elem_info));
+
+        pElem->id.numid = id;
+        pElem->indirect = 0;
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_READ, (ULONG)pElem);
+        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+        if(pHandle) kfree(pHandle);
+
+        return OSSERR_SUCCESS;
 failure:
-    if(pHandle) {
-        kfree(pHandle);
-    }
-    DebugInt3();
-    return OSSERR_OUT_OF_MEMORY;
+        if(pHandle) {
+                kfree(pHandle);
+        }
+        DebugInt3();
+        return OSSERR_OUT_OF_MEMORY;
 }
 
 int GetUniaudControlValuePut(ULONG deviceid, ULONG id, void *value)
 {
-    struct snd_ctl_elem_value *pElem = NULL;
-    struct snd_ctl_elem_info  *pElemInfo = NULL;
-    mixerhandle *pHandle = NULL;
-    int          ret, i, j, sz;
-
-    if(alsa_fops == NULL) {
-        ret = OSSERR_NO_DEVICE_AVAILABLE;
-        goto failure;
-    }
-
-    sz = sizeof(mixerhandle);
-    pHandle = kmalloc(sz, GFP_KERNEL);
-    if(pHandle == NULL) {
-        ret = OSSERR_OUT_OF_MEMORY;
-        goto failure;
-    }
-    memset(pHandle, 0, sizeof(mixerhandle));
-
-    //set operation to non-blocking
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    //setup pointers in file structure (used internally by ALSA)
-    pHandle->file.f_dentry          = &pHandle->d_entry;
-    pHandle->file.f_dentry->d_inode = &pHandle->inode;
-
-    pHandle->file.f_mode  = FMODE_WRITE;
-    pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
-
-    ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
-    if(ret) {
-        goto failure;
-    }
-
-    pElem = (struct snd_ctl_elem_value *)value;
-    if(pElem == NULL) {
-        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-        goto failure;
-    }
-
-//    printk("sizeof elem_info %i\n",sizeof(struct snd_ctl_elem_info));
-
-    pElem->id.numid = id;
-    pElem->indirect = 0;
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
-    ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-    if(pHandle) kfree(pHandle);
-
-    return OSSERR_SUCCESS;
+        struct snd_ctl_elem_value *pElem = NULL;
+        struct snd_ctl_elem_info  *pElemInfo = NULL;
+        mixerhandle *pHandle = NULL;
+        int              ret, i, j, sz;
+
+        if(alsa_fops == NULL) {
+                ret = OSSERR_NO_DEVICE_AVAILABLE;
+                goto failure;
+        }
+
+        sz = sizeof(mixerhandle);
+        pHandle = kmalloc(sz, GFP_KERNEL);
+        if(pHandle == NULL) {
+                ret = OSSERR_OUT_OF_MEMORY;
+                goto failure;
+        }
+        memset(pHandle, 0, sizeof(mixerhandle));
+
+        //set operation to non-blocking
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        //setup pointers in file structure (used internally by ALSA)
+        pHandle->file.f_dentry                  = &pHandle->d_entry;
+        pHandle->file.f_dentry->d_inode = &pHandle->inode;
+
+        pHandle->file.f_mode  = FMODE_WRITE;
+        pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
+
+        ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
+        if(ret) {
+                goto failure;
+        }
+
+        pElem = (struct snd_ctl_elem_value *)value;
+        if(pElem == NULL) {
+                ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+                goto failure;
+        }
+
+//        printk("sizeof elem_info %i\n",sizeof(struct snd_ctl_elem_info));
+
+        pElem->id.numid = id;
+        pElem->indirect = 0;
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
+        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+        if(pHandle) kfree(pHandle);
+
+        return OSSERR_SUCCESS;
 
 failure:
-    if(pHandle) {
-        kfree(pHandle);
-    }
-    DebugInt3();
-    return OSSERR_OUT_OF_MEMORY;
+        if(pHandle) {
+                kfree(pHandle);
+        }
+        DebugInt3();
+        return OSSERR_OUT_OF_MEMORY;
 }
 
 int UniaudIoctlHWRefine(OSSSTREAMID streamid, void *pHwParams)
 {
-    int ret;
-    soundhandle        *pHandle = (soundhandle *)streamid;
-    struct snd_pcm_hw_params *params = NULL;
-    printk("PS UniaudIoctlHWRefine\n");
-    params = (struct snd_pcm_hw_params *)pHwParams;
-
-    if (!params) return -1001;
-
-    if (!pHandle) return -1002;
-
-    pHandle->file.f_flags = O_NONBLOCK;
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
-    return ret;
+        int ret;
+        soundhandle        *pHandle = (soundhandle *)streamid;
+        struct snd_pcm_hw_params *params = NULL;
+        printk("PS UniaudIoctlHWRefine\n");
+        params = (struct snd_pcm_hw_params *)pHwParams;
+
+        if (!params) return -1001;
+
+        if (!pHandle) return -1002;
+
+        pHandle->file.f_flags = O_NONBLOCK;
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
+        return ret;
 }
 
 int UniaudIoctlHWParamSet(OSSSTREAMID streamid, void *pHwParams)
 {
-    int ret;
-    soundhandle        *pHandle = (soundhandle *)streamid;
-    struct snd_pcm_hw_params *params = NULL;
-    printk("PS UniaudIoctlHWParamSet\n");
-    params = (struct snd_pcm_hw_params *)pHwParams;
-
-    if (!params) return -1001;
-    if (!pHandle) return -1002;
-
-    pHandle->file.f_flags = O_NONBLOCK;
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_PARAMS, (ULONG)params);
-    return ret;
+        int ret;
+        soundhandle        *pHandle = (soundhandle *)streamid;
+        struct snd_pcm_hw_params *params = NULL;
+        printk("PS UniaudIoctlHWParamSet\n");
+        params = (struct snd_pcm_hw_params *)pHwParams;
+
+        if (!params) return -1001;
+        if (!pHandle) return -1002;
+
+        pHandle->file.f_flags = O_NONBLOCK;
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_PARAMS, (ULONG)params);
+        return ret;
 }
 
 int UniaudIoctlSWParamSet(OSSSTREAMID streamid, void *pSwParams)
 {
-    int ret;
-    soundhandle        *pHandle = (soundhandle *)streamid;
-    struct snd_pcm_sw_params *params = NULL;
-    printk("PS UniaudIoctlSWParamSet\n");
-    params = (struct snd_pcm_sw_params *)pSwParams;
-
-    if (!params) return -1001;
-    if (!pHandle) return -1002;
-
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_SW_PARAMS, (ULONG)params);
-    return ret;
+        int ret;
+        soundhandle        *pHandle = (soundhandle *)streamid;
+        struct snd_pcm_sw_params *params = NULL;
+        printk("PS UniaudIoctlSWParamSet\n");
+        params = (struct snd_pcm_sw_params *)pSwParams;
+
+        if (!params) return -1001;
+        if (!pHandle) return -1002;
+
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_SW_PARAMS, (ULONG)params);
+        return ret;
 }
 
 int UniaudIoctlPCMStatus(OSSSTREAMID streamid, void *pstatus)
 {
-    int ret;
-    soundhandle        *pHandle = (soundhandle *)streamid;
-    struct snd_pcm_status   *status = (struct snd_pcm_status *)pstatus;
-
-    if (!status) return -1001;
-    if (!pHandle) return -1002;
-
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)status);
-    return ret;
+        int ret;
+        soundhandle        *pHandle = (soundhandle *)streamid;
+        struct snd_pcm_status   *status = (struct snd_pcm_status *)pstatus;
+
+        if (!status) return -1001;
+        if (!pHandle) return -1002;
+
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)status);
+        return ret;
 }
 
 int UniaudIoctlPCMWrite(OSSSTREAMID streamid, char *buf, int size)
 {
-    int ret;
-    soundhandle        *pHandle = (soundhandle *)streamid;
-
-    if (!buf) return -1001;
-    if (!pHandle) return -1002;
-
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    ret = pHandle->file.f_op->write(&pHandle->file, buf, size, &pHandle->file.f_pos);
-
-    return ret;
+        int ret;
+        soundhandle        *pHandle = (soundhandle *)streamid;
+
+        if (!buf) return -1001;
+        if (!pHandle) return -1002;
+
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        ret = pHandle->file.f_op->write(&pHandle->file, buf, size, &pHandle->file.f_pos);
+
+        return ret;
 }
 
 int UniaudIoctlPCMRead(OSSSTREAMID streamid, char *buf, int size)
 {
-    int ret;
-    soundhandle        *pHandle = (soundhandle *)streamid;
-
-    if (!buf) return -1001;
-    if (!pHandle) return -1002;
-
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    ret = pHandle->file.f_op->read(&pHandle->file, buf, size, &pHandle->file.f_pos);
-
-    return ret;
+        int ret;
+        soundhandle        *pHandle = (soundhandle *)streamid;
+
+        if (!buf) return -1001;
+        if (!pHandle) return -1002;
+
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        ret = pHandle->file.f_op->read(&pHandle->file, buf, size, &pHandle->file.f_pos);
+
+        return ret;
 }
 
 int UniaudIoctlPCMPrepare(OSSSTREAMID streamid)
 {
-    int ret;
-    soundhandle        *pHandle = (soundhandle *)streamid;
-
-    if (!pHandle) return -1002;
-
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
-    return ret;
+        int ret;
+        soundhandle        *pHandle = (soundhandle *)streamid;
+
+        if (!pHandle) return -1002;
+
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
+        return ret;
 }
 
 int UniaudIoctlPCMResume(OSSSTREAMID streamid, int pause)
 {
-    int ret;
-    soundhandle        *pHandle = (soundhandle *)streamid;
-
-    if (!pHandle) return -1002;
-
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PAUSE, pause);
-
-    return ret;
+        int ret;
+        soundhandle        *pHandle = (soundhandle *)streamid;
+
+        if (!pHandle) return -1002;
+
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PAUSE, pause);
+
+        return ret;
 }
 
 int UniaudIoctlPCMStart(OSSSTREAMID streamid)
 {
-    int ret;
-    soundhandle        *pHandle = (soundhandle *)streamid;
-
-    if (!pHandle) return -1002;
-
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_START, 0);
-
-    return ret;
+        int ret;
+        soundhandle        *pHandle = (soundhandle *)streamid;
+
+        if (!pHandle) return -1002;
+
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_START, 0);
+
+        return ret;
 }
 
 int UniaudIoctlPCMDrop(OSSSTREAMID streamid)
 {
-    int ret;
-    soundhandle        *pHandle = (soundhandle *)streamid;
-
-    if (!pHandle) return -1002;
-
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_DROP, 0);
-
-    return ret;
+        int ret;
+        soundhandle        *pHandle = (soundhandle *)streamid;
+
+        if (!pHandle) return -1002;
+
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_DROP, 0);
+
+        return ret;
 }
 
 void UniaudCloseAll(USHORT fileid)
 {
-    int i;
-
-    for (i=0; i < 8*256; i++)
-    {
-        if (opened_handles[i].handle != 0)
-        {
-            if (fileid)
-            {
-                if (fileid == opened_handles[i].FileId)
-                {
-                    opened_handles[i].reuse = 0;
-                    if (OSS32_WaveClose((OSSSTREAMID)opened_handles[i].handle) == 0)
-                        opened_handles[i].handle = 0;
-                }
-            }
-            else
-            {
-                opened_handles[i].reuse = 0;
-                if (OSS32_WaveClose((OSSSTREAMID)opened_handles[i].handle) == 0)
-                    opened_handles[i].handle = 0;
-            }
-        }
-    }
-    return;
-}
+        int i;
+
+        for (i=0; i < 8*256; i++)
+        {
+                if (opened_handles[i].handle != 0)
+                {
+                        if (fileid)
+                        {
+                                if (fileid == opened_handles[i].FileId)
+                                {
+                                        opened_handles[i].reuse = 0;
+                                        if (OSS32_WaveClose((OSSSTREAMID)opened_handles[i].handle) == 0)
+                                                opened_handles[i].handle = 0;
+                                }
+                        }
+                        else
+                        {
+                                opened_handles[i].reuse = 0;
+                                if (OSS32_WaveClose((OSSSTREAMID)opened_handles[i].handle) == 0)
+                                        opened_handles[i].handle = 0;
+                        }
+                }
+        }
+        return;
+}

GPL/branches/uniaud32-2.1.x/lib32/sound.c

@@ -1116 +1116 @@
                 iRet = pHandle->file.f_op->write(&pHandle->file, (char *)ulBuffer, ulSize, &pHandle->file.f_pos);
 
+                if (iRet != ulSize) rprintf(("WaveAddBuffer: ReqSize=%x Size=%x iRet=%x\n", ulReqSize, ulSize, iRet));
+
                 if (iRet < 0 ) break;
                 ulTransferred = iRet;
@@ -1134 +1136 @@
                 }
 
+                rprintf(("WaveAddBuffer: ReqSize=%x Size=%x\n", ulReqSize, ulSize));
+
                 // size should be aligned to channels number * samplesize  //PS+++ what is it and why?!?!?!
                 ulJ = 10;                        // 10 try if error
                 iRet = -11;
-                while (ulSize && ulJ && iRet)
-                {
-                        for (ulI=0; ulI < 1000; ulI++)
-                        {
+                while (ulSize && ulJ && iRet) {
+                        for (ulI=0; ulI < 1000; ulI++) {
                                 iRet1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
                                 // If here any state and have free buffer to any byte
@@ -1148 +1150 @@
                                 }
                                 if (ulI > 998) {
-                                        // 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));
+                                        rprintf(("timeout state=%x avail=%d hw=%d app=%d",status.state,samples_to_bytes(status.avail),samples_to_bytes(status.hw_ptr), samples_to_bytes(status.appl_ptr)));
                                         iRet1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
                                 }
@@ -1154 +1156 @@
 
                         if (iRet1 < 0) {
-                                // printk("Status Error iRet1:%i trans: %i need %d tot:%d\n",iRet1,ulTransferred, ulReqSize,ulSize);
+                                rprintf(("iRet1=%i trans=%x ReqSize=%x Size=%x\n", iRet1, ulTransferred, ulReqSize, ulSize));
                                 break;     // We have any global error, don't try more
                         }
 
                         iRet = pHandle->file.f_op->write(&pHandle->file, (char *)ulBuffer, ulSize, &pHandle->file.f_pos);
+                        rprintf(("J=%x iRet=%x", ulJ, iRet));
 
                         if (iRet < 0 ) {  // We have any error, don't try more
                                 ulJ--;
-                                if ( iRet != -11 )
-                                iRet1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
-                                // printk("Error ret:%i ret1:%i trans: %d need %d tot:%d\n",iRet,iRet1,ulTransferred, ulReqSize,ulSize);
+                                rprintf(("Error ret=%i ret1=%i trans=%x ReqSize=%x Size=%x", iRet, iRet1, ulTransferred, ulReqSize, ulSize));
+                                if ( iRet != -11 ) {
+                                        rprintf(("Doing prepare"));
+                                        iRet1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
+                                }
                                 continue;
                         }
-                        if (iRet == 0)  continue;
+                        if (iRet == 0) {
+                                continue;
+                        }
                         ulTransferred += iRet;
                         // printk("written: now: %d, trans: %d need %d tot:%d\n", iRet, ulTransferred, ulReqSize,ulSize);

GPL/branches/uniaud32-2.1.x/lib32/soundmixer.c

@@ -41 +41 @@
 
 static struct {
-    char *name;
-    unsigned int index;
-    unsigned int recsrc;
+        char *name;
+        unsigned int index;
+        unsigned int recsrc;
 } ossid[OSS_MIXER_NRDEVICES] = {
         /* OSS_MIXER_VOLUME   */ { "Master", 0 , -1},
-        /* OSS_MIXER_BASS     */ { "Tone Control - Bass", 0, -1},
+        /* OSS_MIXER_BASS         */ { "Tone Control - Bass", 0, -1},
         /* OSS_MIXER_TREBLE   */ { "Tone Control - Treble", 0, -1},
-        /* OSS_MIXER_SYNTH    */ { "Synth", 0 , OSS32_MIX_RECSRC_SYNTH},
-        /* OSS_MIXER_PCM      */ { "PCM", 0 , -1},
-        /* OSS_MIXER_PCSPEAKER  */ { "PC Speaker", 0 , -1},
-        /* OSS_MIXER_LINE     */ { "Line", 0 , OSS32_MIX_RECSRC_LINE},
-        /* OSS_MIXER_MIC      */ { "Mic", 0, OSS32_MIX_RECSRC_MIC},
-        /* OSS_MIXER_CD       */ { "CD", 0 , OSS32_MIX_RECSRC_CD},
-        /* OSS_MIXER_IMIX     */ { "Monitor Mix", 0 , OSS32_MIX_RECSRC_MIXER},
+        /* OSS_MIXER_SYNTH        */ { "Synth", 0 , OSS32_MIX_RECSRC_SYNTH},
+        /* OSS_MIXER_PCM          */ { "PCM", 0 , -1},
+        /* OSS_MIXER_PCSPEAKER  */ { "PC Speaker", 0 , -1},
+        /* OSS_MIXER_LINE         */ { "Line", 0 , OSS32_MIX_RECSRC_LINE},
+        /* OSS_MIXER_MIC          */ { "Mic", 0, OSS32_MIX_RECSRC_MIC},
+        /* OSS_MIXER_CD           */ { "CD", 0 , OSS32_MIX_RECSRC_CD},
+        /* OSS_MIXER_IMIX         */ { "Monitor Mix", 0 , OSS32_MIX_RECSRC_MIXER},
         /* OSS_MIXER_ALTPCM   */ { "PCM",       1 , -1},
         /* OSS_MIXER_RECLEV   */ { "-- nothing --", 0 , -1},
-        /* OSS_MIXER_IGAIN    */ { "Capture", 0 , -1},
-        /* OSS_MIXER_OGAIN    */ { "Playback", 0 , -1},
-        /* OSS_MIXER_LINE1    */ { "Aux", 0 , OSS32_MIX_RECSRC_AUX},
-        /* OSS_MIXER_LINE2    */ { "Aux", 1 , -1},
-        /* OSS_MIXER_LINE3    */ { "Aux", 2 , -1},
+        /* OSS_MIXER_IGAIN        */ { "Capture", 0 , -1},
+        /* OSS_MIXER_OGAIN        */ { "Playback", 0 , -1},
+        /* OSS_MIXER_LINE1        */ { "Aux", 0 , OSS32_MIX_RECSRC_AUX},
+        /* OSS_MIXER_LINE2        */ { "Aux", 1 , -1},
+        /* OSS_MIXER_LINE3        */ { "Aux", 2 , -1},
         /* OSS_MIXER_DIGITAL1 */ { "Digital", 0 , -1},
         /* OSS_MIXER_DIGITAL2 */ { "Digital", 1 , -1},
@@ -67 +67 @@
         /* OSS_MIXER_PHONEIN  */ { "Phone", 0 , OSS32_MIX_RECSRC_PHONE},
         /* OSS_MIXER_PHONEOUT */ { "Phone", 1 , -1},
-        /* OSS_MIXER_VIDEO    */ { "Video", 0 , OSS32_MIX_RECSRC_VIDEO},
-        /* OSS_MIXER_RADIO    */ { "Radio", 0 , -1},
+        /* OSS_MIXER_VIDEO        */ { "Video", 0 , OSS32_MIX_RECSRC_VIDEO},
+        /* OSS_MIXER_RADIO        */ { "Radio", 0 , -1},
         /* OSS_MIXER_MONITOR  */ { "Monitor", 0 , -1},
         /* OSS_MIXER_3DDEPTH  */ { "3D Control - Depth", 0 , -1},
-    /* OSS_MIXER_3DCENTER */ { "3D Control - Center", 0 , -1},
-        /* OSS_MIXER_FRONT    */ { "Front", 0 , -1},
+        /* OSS_MIXER_3DCENTER */ { "3D Control - Center", 0 , -1},
+        /* OSS_MIXER_FRONT        */ { "Front", 0 , -1},
         /* OSS_MIXER_SPEAKER  */ { "Speaker", 0 , -1},
         /* OSS_MIXER_HEADPHONE */ { "Headphone", 0 , -1},
 };
 char *szRecSources[OSS32_MIX_RECSRC_MAX] = {
-    "Mic", "CD", "Line", "Video", "Aux", "Mix", "Mix Mono", "Phone", "Synth"
+        "Mic", "CD", "Line", "Video", "Aux", "Mix", "Mix Mono", "Phone", "Synth"
 };
 
 static unsigned char LinToLog[OSS32_MAX_VOLUME+1] = {
-  0,   0,   0,   0,   1,   2,   2,   5,   5,  10,
- 10,  10,  16,  19,  20,  22,  24,  25,  27,  27,
- 28,  28,  29,  30,  30,  35,  35,  35,  39,  39,
- 43,  44,  45,  47,  48,  49,  50,  51,  52,  53,
- 55,  56,  57,  59,  60,  62,  63,  64,  65,  66,
- 67,  68,  69,  70,  71,  72,  73,  74,  74,  75,
- 76,  77,  78,  79,  79,  80,  81,  82,  83,  84,
- 85,  86,  87,  88,  89,  90,  91,  92,  92,  93,
- 93,  94,  94,  95,  95,  96,  96,  97,  97,  98,
- 98,  99,  99,  99,  99, 100, 100, 100, 100, 100,
+  0,   0,       0,       0,   1,   2,   2,       5,   5,  10,
+ 10,  10,  16,  19,  20,  22,  24,      25,  27,  27,
+ 28,  28,  29,  30,  30,  35,  35,      35,  39,  39,
+ 43,  44,  45,  47,  48,  49,  50,      51,  52,  53,
+ 55,  56,  57,  59,  60,  62,  63,      64,  65,  66,
+ 67,  68,  69,  70,  71,  72,  73,      74,  74,  75,
+ 76,  77,  78,  79,  79,  80,  81,      82,  83,  84,
+ 85,  86,  87,  88,  89,  90,  91,      92,  92,  93,
+ 93,  94,  94,  95,  95,  96,  96,      97,  97,  98,
+ 98,  99,  99,  99,  99, 100, 100, 100, 100, 100,
  100
 };
@@ -99 +99 @@
 ULONG ConvertVolume(ULONG ulLinVolume, ULONG ulLogVolMax)
 {
-    if(ulLinVolume > OSS32_MAX_VOLUME) {
-        ulLinVolume = OSS32_MAX_VOLUME;
-    }
-    ulLinVolume = LinToLog[ulLinVolume];
-
-    return (ulLinVolume * ulLogVolMax) / OSS32_MAX_VOLUME;
+        if(ulLinVolume > OSS32_MAX_VOLUME) {
+                ulLinVolume = OSS32_MAX_VOLUME;
+        }
+        ulLinVolume = LinToLog[ulLinVolume];
+
+        return (ulLinVolume * ulLogVolMax) / OSS32_MAX_VOLUME;
 }
 
@@ -111 +111 @@
 OSSRET OSS32_MixOpen(ULONG deviceid, OSSSTREAMID *pStreamId)
 {
-    mixerhandle *pHandle = NULL;
-    int          ret, i, j, sz;
-
-    if(pStreamId == NULL) {
-        DebugInt3();
-        return OSSERR_INVALID_PARAMETER;
-    }
-    *pStreamId = 0;
-
-    if(alsa_fops == NULL) {
-        ret = OSSERR_NO_DEVICE_AVAILABLE;
-        goto failure;
-    }
-
-    sz = sizeof(mixerhandle);
-    pHandle = kmalloc(sz, GFP_KERNEL);
-    if(pHandle == NULL) {
-        ret = OSSERR_OUT_OF_MEMORY;
-        goto failure;
-    }
-    memset(pHandle, 0, sizeof(mixerhandle));
-
-    //set operation to non-blocking
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    //setup pointers in file structure (used internally by ALSA)
-    pHandle->file.f_dentry          = &pHandle->d_entry;
-    pHandle->file.f_dentry->d_inode = &pHandle->inode;
-
-    pHandle->file.f_mode  = FMODE_WRITE;
-    pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
-
-    ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
-    if(ret) {
-        goto failure;
-    }
-    //retrieve mixer information
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
-                                    SNDRV_CTL_IOCTL_CARD_INFO,
-                                    (ULONG)&pHandle->info);
-    if(ret) {
-        goto failure;
-    }
-    //get the number of mixer elements
-    pHandle->list.offset = 0;
-    pHandle->list.space  = 0;
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
-                                    SNDRV_CTL_IOCTL_ELEM_LIST,
-                                    (ULONG)&pHandle->list);
-    if(ret) {
-        goto failure;
-    }
-    //allocate memory for all mixer elements
-    pHandle->pids = (struct snd_ctl_elem_id *)kmalloc(sizeof(struct snd_ctl_elem_id)*pHandle->list.count, GFP_KERNEL);
-    if(pHandle->pids == NULL) {
-        goto failure;
-    }
-    //and retrieve all mixer elements
-    pHandle->list.offset = 0;
-    pHandle->list.space  = pHandle->list.count;
-    pHandle->list.pids   = pHandle->pids;
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
-                                    SNDRV_CTL_IOCTL_ELEM_LIST,
-                                    (ULONG)&pHandle->list);
-    if(ret) {
-        goto failure;
-    }
+        mixerhandle *pHandle = NULL;
+        int              ret, i, j, sz;
+
+        if(pStreamId == NULL) {
+                DebugInt3();
+                return OSSERR_INVALID_PARAMETER;
+        }
+        *pStreamId = 0;
+
+        if(alsa_fops == NULL) {
+                ret = OSSERR_NO_DEVICE_AVAILABLE;
+                goto failure;
+        }
+
+        sz = sizeof(mixerhandle);
+        pHandle = kmalloc(sz, GFP_KERNEL);
+        if(pHandle == NULL) {
+                ret = OSSERR_OUT_OF_MEMORY;
+                goto failure;
+        }
+        memset(pHandle, 0, sizeof(mixerhandle));
+
+        //set operation to non-blocking
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        //setup pointers in file structure (used internally by ALSA)
+        pHandle->file.f_dentry                  = &pHandle->d_entry;
+        pHandle->file.f_dentry->d_inode = &pHandle->inode;
+
+        pHandle->file.f_mode  = FMODE_WRITE;
+        pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
+
+        ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
+        if(ret) {
+                goto failure;
+        }
+        //retrieve mixer information
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+                                                                        SNDRV_CTL_IOCTL_CARD_INFO,
+                                                                        (ULONG)&pHandle->info);
+        if(ret) {
+                goto failure;
+        }
+        //get the number of mixer elements
+        pHandle->list.offset = 0;
+        pHandle->list.space  = 0;
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+                                                                        SNDRV_CTL_IOCTL_ELEM_LIST,
+                                                                        (ULONG)&pHandle->list);
+        if(ret) {
+                goto failure;
+        }
+        //allocate memory for all mixer elements
+        pHandle->pids = (struct snd_ctl_elem_id *)kmalloc(sizeof(struct snd_ctl_elem_id)*pHandle->list.count, GFP_KERNEL);
+        if(pHandle->pids == NULL) {
+                goto failure;
+        }
+        //and retrieve all mixer elements
+        pHandle->list.offset = 0;
+        pHandle->list.space  = pHandle->list.count;
+        pHandle->list.pids       = pHandle->pids;
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+                                                                        SNDRV_CTL_IOCTL_ELEM_LIST,
+                                                                        (ULONG)&pHandle->list);
+        if(ret) {
+                goto failure;
+        }
 
 #if 0
-    dprintf(("Mixer name: %s", pHandle->info.mixername));
-    dprintf(("List of mixer elements:"));
-    for(i=0;i<pHandle->list.count;i++) {
-        dprintf(("index %d name %s id %d device %d subdevice %d", pHandle->pids[i].index, pHandle->pids[i].name, pHandle->pids[i].numid, pHandle->pids[i].device, pHandle->pids[i].subdevice));
-    }
+        dprintf(("Mixer name: %s", pHandle->info.mixername));
+        dprintf(("List of mixer elements:"));
+        for(i=0;i<pHandle->list.count;i++) {
+                dprintf(("index %d name %s id %d device %d subdevice %d", pHandle->pids[i].index, pHandle->pids[i].name, pHandle->pids[i].numid, pHandle->pids[i].device, pHandle->pids[i].subdevice));
+        }
 #endif
 
-    //Extract standard mixer controls from array with control names
-    for(j=0;j<OSS_MIXER_NRDEVICES;j++)
-    {
-        int namelen = strlen(ossid[j].name);
-
-        pHandle->controls[j].idxVolume        = -1;
-        pHandle->controls[j].idxMute          = -1;
-        pHandle->controls[j].idxCustom        = -1;
-        pHandle->controls[j].idxCaptureSwitch = -1;
-
-        for(i=0;i<pHandle->list.count;i++)
-        {
-            if (pHandle->pids[i].index == ossid[j].index &&
-                strncmp(pHandle->pids[i].name, ossid[j].name, namelen) == 0)
-            {
-                int controlnamelen = strlen(pHandle->pids[i].name);
-
-                if(namelen == controlnamelen)
-                {//control names are identical; found exact match
-                    pHandle->controls[j].idxVolume = i;
-                    break;
-                }
-                else
-                {//first part of the control name is correct; now find out what
-                 //is it exactly
-                    char *nextword = &pHandle->pids[i].name[namelen];
-                    while(*nextword && *nextword == ' ') nextword++;
-
-                    if(strncmp(nextword, MIXER_PLAYBACKVOLUME, sizeof(MIXER_PLAYBACKVOLUME)-1) == 0 ||
-                       strncmp(nextword, MIXER_VOLUME, sizeof(MIXER_VOLUME)-1) == 0)
-                    {//volume control
-                        pHandle->controls[j].idxVolume = i;
-                    }
-                    else
-                    if(strncmp(nextword, MIXER_PLAYBACKSWITCH, sizeof(MIXER_PLAYBACKSWITCH)-1) == 0 ||
-                       strncmp(nextword, MIXER_SWITCH, sizeof(MIXER_SWITCH)-1) == 0)
-                    {//mute control
-                        pHandle->controls[j].idxMute = i;
-                        if (pHandle->controls[j].idxVolume == -1)
-                                pHandle->controls[j].idxVolume = i;
-                    }
-                    else
-                    if(strncmp(nextword, MIXER_SOURCE, sizeof(MIXER_SOURCE)-1) == 0)
-                    {//source control (e.g. recording source)
-                        pHandle->controls[j].idxCustom = i;
-                    }
-                    else
-                    if(strncmp(nextword, MIXER_CAPTUREROUTE, sizeof(MIXER_CAPTUREROUTE)-1) == 0 ||
-                       strncmp(nextword, MIXER_CAPTURESWITCH, sizeof(MIXER_CAPTURESWITCH)-1) == 0)
-                    {//source control for recording (per input)
-                        pHandle->controls[j].idxCaptureSwitch = i;
-                    }
-                    else
-                    if(i == OSS_MIXER_MIC) {
-                        if(strncmp(nextword, MIXER_BOOST, sizeof(MIXER_BOOST)-1) == 0)
-                        {//mic boost switch
-                            pHandle->controls[j].idxCustom = i;
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    pHandle->reccaps = 0;
-    for(j=0;j<OSS32_MIX_RECSRC_MAX;j++) {
-        pHandle->idxRecCaps[j] = -1;
-    }
-
-    //request information about available capture sources
-    if(pHandle->controls[OSS_MIXER_IGAIN].idxCustom != -1)
-    {
-        struct snd_ctl_elem_info  *pElemInfo = NULL;
-        int                   idx, j;
-
-        idx = pHandle->controls[OSS_MIXER_IGAIN].idxCustom;
-
-        //set operation to non-blocking
-        pHandle->file.f_flags = O_NONBLOCK;
-
-        pHandle->rectype = RECTYPE_SELECTOR;
-
-        //too big to put on the stack
-        pElemInfo = (struct snd_ctl_elem_info *)kmalloc(sizeof(struct snd_ctl_elem_info), GFP_KERNEL);
-        if(pElemInfo == NULL) {
-            DebugInt3();
-            goto failure;
-        }
-
-        pElemInfo->value.enumerated.items = 1;
-        for(i=0;i<pElemInfo->value.enumerated.items;i++)
-        {
-            pElemInfo->value.enumerated.item = i;
-            pElemInfo->id.numid = pHandle->pids[idx].numid;
-            ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
-            if(ret) {
-                DebugInt3();
-                break;
-            }
-            if(pElemInfo->type != SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
-                DebugInt3();
-                break;
-            }
-            for(j=0;j<OSS32_MIX_RECSRC_MAX;j++) {
-                if(!strcmp(pElemInfo->value.enumerated.name, szRecSources[j])) {
-                    pHandle->reccaps      |= OSS32_MIX_FLAG(j);
-                    pHandle->idxRecCaps[j] = i; //save alsa index
-                    break;
-                }
-            }
-        }
-        kfree(pElemInfo);
-    }
-    else
-    {//This card has no record source selection, but probably route switches for
-     //each input source (SB mixers (also ALS4000), CMedia)
-        pHandle->rectype = RECTYPE_SWITCH;
-        for(j=0;j<OSS32_MIX_RECSRC_MAX;j++) {
-            pHandle->idxRecCaps[j] = -1;
-        }
-        for(j=0;j<OSS_MIXER_NRDEVICES;j++)
-        {
-            if(pHandle->controls[j].idxCaptureSwitch != -1) {
-                pHandle->reccaps                    |= OSS32_MIX_FLAG(ossid[j].recsrc);
-                pHandle->idxRecCaps[ossid[j].recsrc] = pHandle->controls[j].idxCaptureSwitch; //save alsa index
-            }
-        }
-    }
-
-    pHandle->magic = MAGIC_MIXER_ALSA32;
-    *pStreamId = (ULONG)pHandle;
-    return OSSERR_SUCCESS;
+        //Extract standard mixer controls from array with control names
+        for(j=0;j<OSS_MIXER_NRDEVICES;j++)
+        {
+                int namelen = strlen(ossid[j].name);
+
+                pHandle->controls[j].idxVolume            = -1;
+                pHandle->controls[j].idxMute              = -1;
+                pHandle->controls[j].idxCustom            = -1;
+                pHandle->controls[j].idxCaptureSwitch = -1;
+
+                for(i=0;i<pHandle->list.count;i++) {
+                        if (pHandle->pids[i].index == ossid[j].index && strncmp(pHandle->pids[i].name, ossid[j].name, namelen) == 0) {
+                                int controlnamelen = strlen(pHandle->pids[i].name);
+
+                                if(namelen == controlnamelen) { //control names are identical; found exact match
+                                        pHandle->controls[j].idxVolume = i;
+                                        break;
+                                } else { //first part of the control name is correct; now find out what is it exactly
+                                        char *nextword = &pHandle->pids[i].name[namelen];
+                                        while(*nextword && *nextword == ' ') nextword++;
+
+                                        if(strncmp(nextword, MIXER_PLAYBACKVOLUME, sizeof(MIXER_PLAYBACKVOLUME)-1) == 0 ||
+                                           strncmp(nextword, MIXER_VOLUME, sizeof(MIXER_VOLUME)-1) == 0)
+                                        { //volume control
+                                                pHandle->controls[j].idxVolume = i;
+                                        }
+                                        else
+                                        if(strncmp(nextword, MIXER_PLAYBACKSWITCH, sizeof(MIXER_PLAYBACKSWITCH)-1) == 0 ||
+                                           strncmp(nextword, MIXER_SWITCH, sizeof(MIXER_SWITCH)-1) == 0)
+                                        { //mute control
+                                                pHandle->controls[j].idxMute = i;
+                                                if (pHandle->controls[j].idxVolume == -1) pHandle->controls[j].idxVolume = i;
+                                        }
+                                        else
+                                        if(strncmp(nextword, MIXER_SOURCE, sizeof(MIXER_SOURCE)-1) == 0)
+                                        { //source control (e.g. recording source)
+                                                pHandle->controls[j].idxCustom = i;
+                                        }
+                                        else
+                                        if(strncmp(nextword, MIXER_CAPTUREROUTE, sizeof(MIXER_CAPTUREROUTE)-1) == 0 ||
+                                           strncmp(nextword, MIXER_CAPTURESWITCH, sizeof(MIXER_CAPTURESWITCH)-1) == 0)
+                                        { //source control for recording (per input)
+                                                pHandle->controls[j].idxCaptureSwitch = i;
+                                        }
+                                        else
+                                        if(i == OSS_MIXER_MIC) {
+                                                if(strncmp(nextword, MIXER_BOOST, sizeof(MIXER_BOOST)-1) == 0) { //mic boost switch
+                                                        pHandle->controls[j].idxCustom = i;
+                                                }
+                                        }
+                                }
+                        }
+                }
+        }
+
+        pHandle->reccaps = 0;
+        for (j=0;j<OSS32_MIX_RECSRC_MAX;j++) {
+                pHandle->idxRecCaps[j] = -1;
+        }
+
+        //request information about available capture sources
+        if (pHandle->controls[OSS_MIXER_IGAIN].idxCustom != -1) {
+                struct snd_ctl_elem_info  *pElemInfo = NULL;
+                int idx, j;
+
+                idx = pHandle->controls[OSS_MIXER_IGAIN].idxCustom;
+
+                //set operation to non-blocking
+                pHandle->file.f_flags = O_NONBLOCK;
+
+                pHandle->rectype = RECTYPE_SELECTOR;
+
+                //too big to put on the stack
+                pElemInfo = (struct snd_ctl_elem_info *)kmalloc(sizeof(struct snd_ctl_elem_info), GFP_KERNEL);
+                if(pElemInfo == NULL) {
+                        DebugInt3();
+                        goto failure;
+                }
+
+                pElemInfo->value.enumerated.items = 1;
+                for(i=0;i<pElemInfo->value.enumerated.items;i++)
+                {
+                        pElemInfo->value.enumerated.item = i;
+                        pElemInfo->id.numid = pHandle->pids[idx].numid;
+                        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
+                        if(ret) {
+                                DebugInt3();
+                                break;
+                        }
+                        if(pElemInfo->type != SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
+                                DebugInt3();
+                                break;
+                        }
+                        for(j=0;j<OSS32_MIX_RECSRC_MAX;j++) {
+                                if(!strcmp(pElemInfo->value.enumerated.name, szRecSources[j])) {
+                                        pHandle->reccaps          |= OSS32_MIX_FLAG(j);
+                                        pHandle->idxRecCaps[j] = i; //save alsa index
+                                        break;
+                                }
+                        }
+                }
+                kfree(pElemInfo);
+        }
+        else
+        {//This card has no record source selection, but probably route switches for
+         //each input source (SB mixers (also ALS4000), CMedia)
+                pHandle->rectype = RECTYPE_SWITCH;
+                for(j=0;j<OSS32_MIX_RECSRC_MAX;j++) {
+                        pHandle->idxRecCaps[j] = -1;
+                }
+                for(j=0;j<OSS_MIXER_NRDEVICES;j++)
+                {
+                        if(pHandle->controls[j].idxCaptureSwitch != -1) {
+                                pHandle->reccaps                                        |= OSS32_MIX_FLAG(ossid[j].recsrc);
+                                pHandle->idxRecCaps[ossid[j].recsrc] = pHandle->controls[j].idxCaptureSwitch; //save alsa index
+                        }
+                }
+        }
+
+        pHandle->magic = MAGIC_MIXER_ALSA32;
+        *pStreamId = (ULONG)pHandle;
+        return OSSERR_SUCCESS;
 
 failure:
-    if(pHandle) {
-        if(pHandle->pids) kfree(pHandle->pids);
-        kfree(pHandle);
-    }
-    DebugInt3();
-    return OSSERR_OUT_OF_MEMORY;
+        if(pHandle) {
+                if(pHandle->pids) kfree(pHandle->pids);
+                kfree(pHandle);
+        }
+        DebugInt3();
+        return OSSERR_OUT_OF_MEMORY;
 }
 //******************************************************************************
@@ -332 +322 @@
 OSSRET OSS32_MixClose(OSSSTREAMID streamid)
 {
-    mixerhandle *pHandle = (mixerhandle *)streamid;
-    int          ret;
-
-    if(pHandle == NULL || pHandle->magic != MAGIC_MIXER_ALSA32) {
-        DebugInt3();
-        return OSSERR_INVALID_STREAMID;
-    }
-    //set operation to non-blocking
-    pHandle->file.f_flags = O_NONBLOCK;
-    ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-    kfree(pHandle->pids);  //free mixer element array
-    kfree(pHandle);        //free handle data
-
-    if(ret) {
-        DebugInt3();
-        return UNIXToOSSError(ret);
-    }
-    return OSSERR_SUCCESS;
+        mixerhandle *pHandle = (mixerhandle *)streamid;
+        int              ret;
+
+        if(pHandle == NULL || pHandle->magic != MAGIC_MIXER_ALSA32) {
+                DebugInt3();
+                return OSSERR_INVALID_STREAMID;
+        }
+        //set operation to non-blocking
+        pHandle->file.f_flags = O_NONBLOCK;
+        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+        kfree(pHandle->pids);  //free mixer element array
+        kfree(pHandle);            //free handle data
+
+        if(ret) {
+                DebugInt3();
+                return UNIXToOSSError(ret);
+        }
+        return OSSERR_SUCCESS;
 }
 //******************************************************************************
@@ -355 +345 @@
 OSSRET OSS32_MixGetVolume(OSSSTREAMID streamid, ULONG line, ULONG *pVolume)
 {
-    mixerhandle *pHandle = (mixerhandle *)streamid;
-    int          ret;
-
-    if(pHandle == NULL || pHandle->magic != MAGIC_MIXER_ALSA32) {
-        DebugInt3();
-        return OSSERR_INVALID_STREAMID;
-    }
-    //set operation to non-blocking
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    return OSSERR_NOT_SUPPORTED;
+        mixerhandle *pHandle = (mixerhandle *)streamid;
+        int              ret;
+
+        if(pHandle == NULL || pHandle->magic != MAGIC_MIXER_ALSA32) {
+                DebugInt3();
+                return OSSERR_INVALID_STREAMID;
+        }
+        //set operation to non-blocking
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        return OSSERR_NOT_SUPPORTED;
 }
 //******************************************************************************
@@ -371 +361 @@
 OSSRET OSS32_MixSetVolume(OSSSTREAMID streamid, ULONG line, ULONG volume)
 {
-    mixerhandle          *pHandle = (mixerhandle *)streamid;
-    struct snd_ctl_elem_value *pElem = NULL;
-    struct snd_ctl_elem_info  *pElemInfo;
-    int                   ret, idx, lVol, rVol = 0, idxMute, cnt;
-
-    //dprintf(("OSS32_MixSetVolume line=%d\n", line));
-    if(pHandle == NULL || pHandle->magic != MAGIC_MIXER_ALSA32) {
-        printk("Invalid handle in OSS32_MixSetVolume\n");
-        DebugInt3();
-        return OSSERR_INVALID_STREAMID;
-    }
-    //set operation to non-blocking
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    //too big to put on the stack
-    pElem = (struct snd_ctl_elem_value *)kmalloc(sizeof(struct snd_ctl_elem_value) + sizeof(struct snd_ctl_elem_info), GFP_KERNEL);
-    if(pElem == NULL) {
-        printk("Out of memory in OSS32_MixSetVolume\n");
-        DebugInt3();
-        return OSSERR_OUT_OF_MEMORY;
-    }
-    pElemInfo = (struct snd_ctl_elem_info *)(pElem+1);
-
-    switch(line) {
-    case OSS32_MIX_VOLUME_MASTER_FRONT:
-        idx = pHandle->controls[OSS_MIXER_VOLUME].idxVolume;
-        idxMute = pHandle->controls[OSS_MIXER_VOLUME].idxMute;
-        if (idx == -1)
-        {
-            /* HDA codecs workaround */
-            idx = pHandle->controls[OSS_MIXER_FRONT].idxVolume;
-            idxMute = pHandle->controls[OSS_MIXER_FRONT].idxMute;
-        }
-        break;
-    case OSS32_MIX_VOLUME_MASTER_REAR: //TODO:
-        idx = pHandle->controls[OSS_MIXER_VOLUME].idxVolume;
-        idxMute = pHandle->controls[OSS_MIXER_VOLUME].idxMute;
-        break;
-    case OSS32_MIX_VOLUME_PCM:
-        idx = pHandle->controls[OSS_MIXER_PCM].idxVolume;
-        idxMute = pHandle->controls[OSS_MIXER_PCM].idxMute;
-        if (idx == -1)
-        {
-            /* HDA codecs workaround */
-            idx = pHandle->controls[OSS_MIXER_FRONT].idxVolume;
-            idxMute = pHandle->controls[OSS_MIXER_FRONT].idxMute;
-        }
-        break;
-    case OSS32_MIX_VOLUME_MIDI:
-        idx = pHandle->controls[OSS_MIXER_SYNTH].idxVolume;
-        idxMute = pHandle->controls[OSS_MIXER_SYNTH].idxMute;
-        break;
-    case OSS32_MIX_VOLUME_LINEIN:
-        idx = pHandle->controls[OSS_MIXER_LINE].idxVolume;
-        idxMute = pHandle->controls[OSS_MIXER_LINE].idxMute;
-        break;
-    case OSS32_MIX_VOLUME_MIC:
-        idx = pHandle->controls[OSS_MIXER_MIC].idxVolume;
-        idxMute = pHandle->controls[OSS_MIXER_MIC].idxMute;
-        break;
-    case OSS32_MIX_VOLUME_CD:
-        idx = pHandle->controls[OSS_MIXER_CD].idxVolume;
-        idxMute = pHandle->controls[OSS_MIXER_CD].idxMute;
-        break;
-    case OSS32_MIX_VOLUME_SPDIF:
-        idx = pHandle->controls[OSS_MIXER_DIGITAL1].idxVolume;
-        idxMute = pHandle->controls[OSS_MIXER_DIGITAL1].idxMute;
-        break;
-    case OSS32_MIX_VOLUME_VIDEO:
-        idx = pHandle->controls[OSS_MIXER_VIDEO].idxVolume;
-        idxMute = pHandle->controls[OSS_MIXER_VIDEO].idxMute;
-        break;
-    case OSS32_MIX_VOLUME_PCSPEAKER:
-        idx = pHandle->controls[OSS_MIXER_PCSPEAKER].idxVolume;
-        idxMute = pHandle->controls[OSS_MIXER_PCSPEAKER].idxMute;
-        break;
-    case OSS32_MIX_VOLUME_PHONE:
-        idx = pHandle->controls[OSS_MIXER_PHONEOUT].idxVolume;
-        idxMute = pHandle->controls[OSS_MIXER_PHONEOUT].idxMute;
-        break;
-    case OSS32_MIX_VOLUME_HEADPHONE:
-        idx = pHandle->controls[OSS_MIXER_HEADPHONE].idxVolume;
-        idxMute = pHandle->controls[OSS_MIXER_HEADPHONE].idxMute;
-        break;
-    case OSS32_MIX_VOLUME_SPEAKER:
-        idx = pHandle->controls[OSS_MIXER_SPEAKER].idxVolume;
-        idxMute = pHandle->controls[OSS_MIXER_SPEAKER].idxMute;
-        break;
-    case OSS32_MIX_VOLUME_AUX:
-        idx = pHandle->controls[OSS_MIXER_LINE1].idxVolume;
-        idxMute = pHandle->controls[OSS_MIXER_LINE1].idxMute;
-        break;
-    case OSS32_MIX_VOLUME_CAPTURE:
-        idx = pHandle->controls[OSS_MIXER_IGAIN].idxVolume;
-        idxMute = pHandle->controls[OSS_MIXER_IGAIN].idxMute;
-        break;
-
-    default:
-        DebugInt3();
-        ret = OSSERR_INVALID_PARAMETER;
-        goto fail;
-    }
-    if(idx == -1) {
-        rprintf(("Unknown control %d", line));
-        ret = OSSERR_INVALID_PARAMETER;
-        goto fail;
-    }
-
-    if(idxMute != -1 && volume != 0) {
-        //disable mute
-        pElem->id.numid = pHandle->pids[idxMute].numid;
-        pElem->indirect = 0;
-
-        pElem->value.integer.value[0] = TRUE;  //switch, not mute control (inversed)
-        pElem->value.integer.value[1] = TRUE;
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
-    }
-    //request information about mixer control
-    pElemInfo->id.numid = pHandle->pids[idx].numid;
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
-    if(ret) {
-        ret = UNIXToOSSError(ret);
-        DebugInt3();
-        goto fail;
-    }
-    if(pElemInfo->type != SNDRV_CTL_ELEM_TYPE_INTEGER) {
-        ret = OSSERR_INVALID_PARAMETER;
-        DebugInt3();
-        goto fail;
-    }
-    pElem->id.numid = pHandle->pids[idx].numid;
-    pElem->indirect = 0;
-
-    lVol = ConvertVolume(GET_VOLUME_L(volume), pElemInfo->value.integer.max);
-    pElem->value.integer.value[0] = lVol;
-
-    if(pElemInfo->count > 1) { //stereo
-        rVol = ConvertVolume(GET_VOLUME_R(volume), pElemInfo->value.integer.max);
-        pElem->value.integer.value[1] = rVol;
-    }
+        mixerhandle              *pHandle = (mixerhandle *)streamid;
+        struct snd_ctl_elem_value *pElem = NULL;
+        struct snd_ctl_elem_info  *pElemInfo;
+        int                               ret, idx, lVol, rVol = 0, idxMute, cnt;
+
+        //dprintf(("OSS32_MixSetVolume line=%d\n", line));
+        if(pHandle == NULL || pHandle->magic != MAGIC_MIXER_ALSA32) {
+                printk("Invalid handle in OSS32_MixSetVolume\n");
+                DebugInt3();
+                return OSSERR_INVALID_STREAMID;
+        }
+        //set operation to non-blocking
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        //too big to put on the stack
+        pElem = (struct snd_ctl_elem_value *)kmalloc(sizeof(struct snd_ctl_elem_value) + sizeof(struct snd_ctl_elem_info), GFP_KERNEL);
+        if(pElem == NULL) {
+                printk("Out of memory in OSS32_MixSetVolume\n");
+                DebugInt3();
+                return OSSERR_OUT_OF_MEMORY;
+        }
+        pElemInfo = (struct snd_ctl_elem_info *)(pElem+1);
+
+        switch(line) {
+        case OSS32_MIX_VOLUME_MASTER_FRONT:
+                idx = pHandle->controls[OSS_MIXER_VOLUME].idxVolume;
+                idxMute = pHandle->controls[OSS_MIXER_VOLUME].idxMute;
+                if (idx == -1)
+                {
+                        /* HDA codecs workaround */
+                        idx = pHandle->controls[OSS_MIXER_FRONT].idxVolume;
+                        idxMute = pHandle->controls[OSS_MIXER_FRONT].idxMute;
+                }
+                break;
+        case OSS32_MIX_VOLUME_MASTER_REAR: //TODO:
+                idx = pHandle->controls[OSS_MIXER_VOLUME].idxVolume;
+                idxMute = pHandle->controls[OSS_MIXER_VOLUME].idxMute;
+                break;
+        case OSS32_MIX_VOLUME_PCM:
+                idx = pHandle->controls[OSS_MIXER_PCM].idxVolume;
+                idxMute = pHandle->controls[OSS_MIXER_PCM].idxMute;
+                if (idx == -1)
+                {
+                        /* HDA codecs workaround */
+                        idx = pHandle->controls[OSS_MIXER_FRONT].idxVolume;
+                        idxMute = pHandle->controls[OSS_MIXER_FRONT].idxMute;
+                }
+                break;
+        case OSS32_MIX_VOLUME_MIDI:
+                idx = pHandle->controls[OSS_MIXER_SYNTH].idxVolume;
+                idxMute = pHandle->controls[OSS_MIXER_SYNTH].idxMute;
+                break;
+        case OSS32_MIX_VOLUME_LINEIN:
+                idx = pHandle->controls[OSS_MIXER_LINE].idxVolume;
+                idxMute = pHandle->controls[OSS_MIXER_LINE].idxMute;
+                break;
+        case OSS32_MIX_VOLUME_MIC:
+                idx = pHandle->controls[OSS_MIXER_MIC].idxVolume;
+                idxMute = pHandle->controls[OSS_MIXER_MIC].idxMute;
+                break;
+        case OSS32_MIX_VOLUME_CD:
+                idx = pHandle->controls[OSS_MIXER_CD].idxVolume;
+                idxMute = pHandle->controls[OSS_MIXER_CD].idxMute;
+                break;
+        case OSS32_MIX_VOLUME_SPDIF:
+                idx = pHandle->controls[OSS_MIXER_DIGITAL1].idxVolume;
+                idxMute = pHandle->controls[OSS_MIXER_DIGITAL1].idxMute;
+                break;
+        case OSS32_MIX_VOLUME_VIDEO:
+                idx = pHandle->controls[OSS_MIXER_VIDEO].idxVolume;
+                idxMute = pHandle->controls[OSS_MIXER_VIDEO].idxMute;
+                break;
+        case OSS32_MIX_VOLUME_PCSPEAKER:
+                idx = pHandle->controls[OSS_MIXER_PCSPEAKER].idxVolume;
+                idxMute = pHandle->controls[OSS_MIXER_PCSPEAKER].idxMute;
+                break;
+        case OSS32_MIX_VOLUME_PHONE:
+                idx = pHandle->controls[OSS_MIXER_PHONEOUT].idxVolume;
+                idxMute = pHandle->controls[OSS_MIXER_PHONEOUT].idxMute;
+                break;
+        case OSS32_MIX_VOLUME_HEADPHONE:
+                idx = pHandle->controls[OSS_MIXER_HEADPHONE].idxVolume;
+                idxMute = pHandle->controls[OSS_MIXER_HEADPHONE].idxMute;
+                break;
+        case OSS32_MIX_VOLUME_SPEAKER:
+                idx = pHandle->controls[OSS_MIXER_SPEAKER].idxVolume;
+                idxMute = pHandle->controls[OSS_MIXER_SPEAKER].idxMute;
+                break;
+        case OSS32_MIX_VOLUME_AUX:
+                idx = pHandle->controls[OSS_MIXER_LINE1].idxVolume;
+                idxMute = pHandle->controls[OSS_MIXER_LINE1].idxMute;
+                break;
+        case OSS32_MIX_VOLUME_CAPTURE:
+                idx = pHandle->controls[OSS_MIXER_IGAIN].idxVolume;
+                idxMute = pHandle->controls[OSS_MIXER_IGAIN].idxMute;
+                break;
+
+        default:
+                DebugInt3();
+                ret = OSSERR_INVALID_PARAMETER;
+                goto fail;
+        }
+        if(idx == -1) {
+                rprintf(("Unknown control %d", line));
+                ret = OSSERR_INVALID_PARAMETER;
+                goto fail;
+        }
+
+        if(idxMute != -1 && volume != 0) {
+                //disable mute
+                pElem->id.numid = pHandle->pids[idxMute].numid;
+                pElem->indirect = 0;
+
+                pElem->value.integer.value[0] = TRUE;  //switch, not mute control (inversed)
+                pElem->value.integer.value[1] = TRUE;
+                ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
+        }
+        //request information about mixer control
+        pElemInfo->id.numid = pHandle->pids[idx].numid;
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
+        if(ret) {
+                ret = UNIXToOSSError(ret);
+                DebugInt3();
+                goto fail;
+        }
+        if(pElemInfo->type != SNDRV_CTL_ELEM_TYPE_INTEGER) {
+                ret = OSSERR_INVALID_PARAMETER;
+                DebugInt3();
+                goto fail;
+        }
+        pElem->id.numid = pHandle->pids[idx].numid;
+        pElem->indirect = 0;
+
+        lVol = ConvertVolume(GET_VOLUME_L(volume), pElemInfo->value.integer.max);
+        pElem->value.integer.value[0] = lVol;
+
+        if(pElemInfo->count > 1) { //stereo
+                rVol = ConvertVolume(GET_VOLUME_R(volume), pElemInfo->value.integer.max);
+                pElem->value.integer.value[1] = rVol;
+        }
 
         dprintf(("OSS32_MixSetVolume of %s streamid %X to (%d,%d)(%d,%d) caps %d",
@@ -519 +509 @@
         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
 #else
-    // looking for more, then one opened streams to prevent of muting active stream
-    cnt = 0;
-    for (idx=0; idx < 8*256; idx++)
-        if (opened_handles[idx].handle != 0)
-            cnt++;
+        // looking for more, then one opened streams to prevent of muting active stream
+        cnt = 0;
+        for (idx=0; idx < 8*256; idx++)
+                if (opened_handles[idx].handle != 0)
+                        cnt++;
 
         dprintf(("OSS32_MixSetVolume old cnt=%X line=%x lVol=%x rVol=%x", cnt, line, lVol, rVol));
-    //    if (((cnt == 1 && (lVol==0 && rVol==0)) || (lVol>0 && rVol>0)) ||
-    if (cnt == 1 || line != OSS32_MIX_VOLUME_PCM)
-    {
+        //        if (((cnt == 1 && (lVol==0 && rVol==0)) || (lVol>0 && rVol>0)) ||
+        if (cnt == 1 || line != OSS32_MIX_VOLUME_PCM)
+        {
                 dprintf(("OSS32_MixSetVolume Ioctl"));
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
-
-        if(idxMute != -1 && volume == 0) {
-            //enable mute
-            pElem->id.numid = pHandle->pids[idxMute].numid;
-            pElem->indirect = 0;
-
-            pElem->value.integer.value[0] = FALSE;  //switch, not mute control (inversed)
-            pElem->value.integer.value[1] = FALSE;
+                ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
+
+                if(idxMute != -1 && volume == 0) {
+                        //enable mute
+                        pElem->id.numid = pHandle->pids[idxMute].numid;
+                        pElem->indirect = 0;
+
+                        pElem->value.integer.value[0] = FALSE;  //switch, not mute control (inversed)
+                        pElem->value.integer.value[1] = FALSE;
                         dprintf(("OSS32_MixSetVolume Ioctl mute"));
-            ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
-        }
-    }
+                        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
+                }
+        }
 #endif
 
-    kfree(pElem);
-    pElem = NULL;
-    if(ret) {
-        rprintf(("OSS32_MixSetVolume ret=%x", ret));
-        DebugInt3();
-        return UNIXToOSSError(ret);
-    }
-    return OSSERR_SUCCESS;
+        kfree(pElem);
+        pElem = NULL;
+        if(ret) {
+                rprintf(("OSS32_MixSetVolume ret=%x", ret));
+                DebugInt3();
+                return UNIXToOSSError(ret);
+        }
+        return OSSERR_SUCCESS;
 
 fail:
-    if(pElem) kfree(pElem);
-    return ret;
+        if(pElem) kfree(pElem);
+        return ret;
 }
 //******************************************************************************
@@ -562 +552 @@
 OSSRET OSS32_MixSetProperty(OSSSTREAMID streamid, ULONG ulLine, ULONG ulValue)
 {
-    mixerhandle          *pHandle = (mixerhandle *)streamid;
-    struct snd_ctl_elem_value *pElem = NULL;
-    struct snd_ctl_elem_info  *pElemInfo;
-    int                   ret, idx = -1, lVol, rVol = 0, j, i;
-
-    if(pHandle == NULL || pHandle->magic != MAGIC_MIXER_ALSA32) {
-        DebugInt3();
-        return OSSERR_INVALID_STREAMID;
-    }
-    //set operation to non-blocking
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    //too big to put on the stack
-    pElem = (struct snd_ctl_elem_value *)kmalloc(sizeof(struct snd_ctl_elem_value) + sizeof(struct snd_ctl_elem_info), GFP_KERNEL);
-    if(pElem == NULL) {
-        DebugInt3();
-        return OSSERR_OUT_OF_MEMORY;
-    }
-    pElemInfo = (struct snd_ctl_elem_info *)(pElem+1);
-
-    switch(ulLine) {
-    case OSS32_MIX_INPUTSRC:
-        idx = pHandle->controls[OSS_MIXER_IGAIN].idxCustom;
-        //is this capture source supported by the hardware??
-        if(!(pHandle->reccaps & OSS32_MIX_FLAG(ulValue))) {
-            DebugInt3();
-            ret = OSSERR_INVALID_PARAMETER;
-            goto fail;
-        }
-        if(pHandle->rectype == RECTYPE_SELECTOR) {//input source selector
-            //set left and right capture source
-            pElem->value.enumerated.item[0] = pHandle->idxRecCaps[ulValue];
-            pElem->value.enumerated.item[1] = pHandle->idxRecCaps[ulValue];
-        }
-        else {//capture switch for each input source
-            //first turn off all capture switches...
-            for(j=0;j<OSS32_MIX_RECSRC_MAX;j++)
-            {
-                if(pHandle->idxRecCaps[j] != -1) {
-                    idx                           = pHandle->idxRecCaps[j];
-
-                    //request information about mixer control
-                    pElemInfo->id.numid           = pHandle->pids[idx].numid;
-                    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
-                    if(ret) {
-                        ret = UNIXToOSSError(ret);
-                        DebugInt3();
-                        goto fail;
-                    }
-                    if(pElemInfo->type != SNDRV_CTL_ELEM_TYPE_BOOLEAN) {
-                        ret = OSSERR_INVALID_PARAMETER;
-                        DebugInt3();
-                        goto fail;
-                    }
-
-                    pElem->id.numid               = pHandle->pids[idx].numid;
-                    pElem->indirect               = 0;
-                    for(i=0;i<pElemInfo->count;i++) {
-                        pElem->value.integer.value[i] = 0;
-                    }
-
-                    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
-                    if(ret) {
-                        ret = UNIXToOSSError(ret);
-                        DebugInt3();
-                        goto fail;
-                    }
-                }
-            }
-            //request information about mixer control
-            pElemInfo->id.numid = pHandle->pids[idx].numid;
-            ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
-            if(ret) {
-                ret = UNIXToOSSError(ret);
-                DebugInt3();
-                goto fail;
-            }
-
-            //and enable the capture switch for the selected input source
-            idx = pHandle->idxRecCaps[ulValue];
-            for(i=0;i<pElemInfo->count;i++) {
-                pElem->value.integer.value[i] = 1;
-            }
-        }
-
-        break;
-
-    case OSS32_MIX_SWITCH_MICBOOST:
-        idx = pHandle->controls[OSS_MIXER_MIC].idxCustom;
-        if(idx == -1) {
-            DebugInt3();
-            ret = OSSERR_INVALID_PARAMETER;
-            goto fail;
-        }
-        //set mic switch value (on/off)
-        pElem->value.integer.value[0] = ulValue;
-        break;
-
-    case OSS32_MIX_LEVEL_BASS:
-        idx = pHandle->controls[OSS_MIXER_BASS].idxVolume;
-        goto levelcontinue;
-    case OSS32_MIX_LEVEL_TREBLE:
-        idx = pHandle->controls[OSS_MIXER_TREBLE].idxVolume;
-        goto levelcontinue;
-    case OSS32_MIX_LEVEL_3DCENTER:
-        idx = pHandle->controls[OSS_MIXER_3DCENTER].idxVolume;
-        goto levelcontinue;
-    case OSS32_MIX_LEVEL_3DDEPTH:
-        idx = pHandle->controls[OSS_MIXER_3DDEPTH].idxVolume;
+        mixerhandle              *pHandle = (mixerhandle *)streamid;
+        struct snd_ctl_elem_value *pElem = NULL;
+        struct snd_ctl_elem_info  *pElemInfo;
+        int                               ret, idx = -1, lVol, rVol = 0, j, i;
+
+        if(pHandle == NULL || pHandle->magic != MAGIC_MIXER_ALSA32) {
+                DebugInt3();
+                return OSSERR_INVALID_STREAMID;
+        }
+        //set operation to non-blocking
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        //too big to put on the stack
+        pElem = (struct snd_ctl_elem_value *)kmalloc(sizeof(struct snd_ctl_elem_value) + sizeof(struct snd_ctl_elem_info), GFP_KERNEL);
+        if(pElem == NULL) {
+                DebugInt3();
+                return OSSERR_OUT_OF_MEMORY;
+        }
+        pElemInfo = (struct snd_ctl_elem_info *)(pElem+1);
+
+        switch(ulLine) {
+        case OSS32_MIX_INPUTSRC:
+                idx = pHandle->controls[OSS_MIXER_IGAIN].idxCustom;
+                //is this capture source supported by the hardware??
+                if(!(pHandle->reccaps & OSS32_MIX_FLAG(ulValue))) {
+                        DebugInt3();
+                        ret = OSSERR_INVALID_PARAMETER;
+                        goto fail;
+                }
+                if(pHandle->rectype == RECTYPE_SELECTOR) {//input source selector
+                        //set left and right capture source
+                        pElem->value.enumerated.item[0] = pHandle->idxRecCaps[ulValue];
+                        pElem->value.enumerated.item[1] = pHandle->idxRecCaps[ulValue];
+                }
+                else {//capture switch for each input source
+                        //first turn off all capture switches...
+                        for(j=0;j<OSS32_MIX_RECSRC_MAX;j++)
+                        {
+                                if(pHandle->idxRecCaps[j] != -1) {
+                                        idx                                               = pHandle->idxRecCaps[j];
+
+                                        //request information about mixer control
+                                        pElemInfo->id.numid               = pHandle->pids[idx].numid;
+                                        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
+                                        if(ret) {
+                                                ret = UNIXToOSSError(ret);
+                                                DebugInt3();
+                                                goto fail;
+                                        }
+                                        if(pElemInfo->type != SNDRV_CTL_ELEM_TYPE_BOOLEAN) {
+                                                ret = OSSERR_INVALID_PARAMETER;
+                                                DebugInt3();
+                                                goto fail;
+                                        }
+
+                                        pElem->id.numid                           = pHandle->pids[idx].numid;
+                                        pElem->indirect                           = 0;
+                                        for(i=0;i<pElemInfo->count;i++) {
+                                                pElem->value.integer.value[i] = 0;
+                                        }
+
+                                        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
+                                        if(ret) {
+                                                ret = UNIXToOSSError(ret);
+                                                DebugInt3();
+                                                goto fail;
+                                        }
+                                }
+                        }
+                        //request information about mixer control
+                        pElemInfo->id.numid = pHandle->pids[idx].numid;
+                        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
+                        if(ret) {
+                                ret = UNIXToOSSError(ret);
+                                DebugInt3();
+                                goto fail;
+                        }
+
+                        //and enable the capture switch for the selected input source
+                        idx = pHandle->idxRecCaps[ulValue];
+                        for(i=0;i<pElemInfo->count;i++) {
+                                pElem->value.integer.value[i] = 1;
+                        }
+                }
+
+                break;
+
+        case OSS32_MIX_SWITCH_MICBOOST:
+                idx = pHandle->controls[OSS_MIXER_MIC].idxCustom;
+                if(idx == -1) {
+                        DebugInt3();
+                        ret = OSSERR_INVALID_PARAMETER;
+                        goto fail;
+                }
+                //set mic switch value (on/off)
+                pElem->value.integer.value[0] = ulValue;
+                break;
+
+        case OSS32_MIX_LEVEL_BASS:
+                idx = pHandle->controls[OSS_MIXER_BASS].idxVolume;
+                goto levelcontinue;
+        case OSS32_MIX_LEVEL_TREBLE:
+                idx = pHandle->controls[OSS_MIXER_TREBLE].idxVolume;
+                goto levelcontinue;
+        case OSS32_MIX_LEVEL_3DCENTER:
+                idx = pHandle->controls[OSS_MIXER_3DCENTER].idxVolume;
+                goto levelcontinue;
+        case OSS32_MIX_LEVEL_3DDEPTH:
+                idx = pHandle->controls[OSS_MIXER_3DDEPTH].idxVolume;
 levelcontinue:
 
-        if(idx == -1) {//supported?
-            DebugInt3();
-            ret = OSSERR_INVALID_PARAMETER;
-            goto fail;
-        }
-        //request information about mixer control
-        pElemInfo->id.numid = pHandle->pids[idx].numid;
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
-        if(ret) {
-            ret = UNIXToOSSError(ret);
-            DebugInt3();
-            goto fail;
-        }
-        if(pElemInfo->type != SNDRV_CTL_ELEM_TYPE_INTEGER) {
-            ret = OSSERR_INVALID_PARAMETER;
-            DebugInt3();
-            goto fail;
-        }
-        lVol = ConvertVolume(GET_VOLUME_L(ulValue), pElemInfo->value.integer.max);
-        pElem->value.integer.value[0] = lVol;
-
-        if(pElemInfo->count > 1) { //stereo
-            rVol = ConvertVolume(GET_VOLUME_R(ulValue), pElemInfo->value.integer.max);
-            pElem->value.integer.value[1] = rVol;
-        }
-        break;
-
-    default:
-        DebugInt3();
-        ret = OSSERR_INVALID_PARAMETER;
-        goto fail;
-    }
-    pElem->id.numid = pHandle->pids[idx].numid;
-    pElem->indirect = 0;
-
-    dprintf(("OSS32_MixSetProperty of %s to %x", pHandle->pids[idx].name, ulValue));
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
-
-    kfree(pElem);
-    pElem = NULL;
-    if(ret) {
-        DebugInt3();
-        return UNIXToOSSError(ret);
-    }
-    return OSSERR_SUCCESS;
+                if(idx == -1) {//supported?
+                        DebugInt3();
+                        ret = OSSERR_INVALID_PARAMETER;
+                        goto fail;
+                }
+                //request information about mixer control
+                pElemInfo->id.numid = pHandle->pids[idx].numid;
+                ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
+                if(ret) {
+                        ret = UNIXToOSSError(ret);
+                        DebugInt3();
+                        goto fail;
+                }
+                if(pElemInfo->type != SNDRV_CTL_ELEM_TYPE_INTEGER) {
+                        ret = OSSERR_INVALID_PARAMETER;
+                        DebugInt3();
+                        goto fail;
+                }
+                lVol = ConvertVolume(GET_VOLUME_L(ulValue), pElemInfo->value.integer.max);
+                pElem->value.integer.value[0] = lVol;
+
+                if(pElemInfo->count > 1) { //stereo
+                        rVol = ConvertVolume(GET_VOLUME_R(ulValue), pElemInfo->value.integer.max);
+                        pElem->value.integer.value[1] = rVol;
+                }
+                break;
+
+        default:
+                DebugInt3();
+                ret = OSSERR_INVALID_PARAMETER;
+                goto fail;
+        }
+        pElem->id.numid = pHandle->pids[idx].numid;
+        pElem->indirect = 0;
+
+        dprintf(("OSS32_MixSetProperty of %s to %x", pHandle->pids[idx].name, ulValue));
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
+
+        kfree(pElem);
+        pElem = NULL;
+        if(ret) {
+                DebugInt3();
+                return UNIXToOSSError(ret);
+        }
+        return OSSERR_SUCCESS;
 
 fail:
-    if(pElem) kfree(pElem);
-    return ret;
+        if(pElem) kfree(pElem);
+        return ret;
 }
 //******************************************************************************
@@ -727 +717 @@
 OSSRET OSS32_MixGetProperty(OSSSTREAMID streamid, ULONG line, ULONG *pValue)
 {
-    mixerhandle *pHandle = (mixerhandle *)streamid;
-    int          ret;
-
-    if(pHandle == NULL || pHandle->magic != MAGIC_MIXER_ALSA32) {
-        DebugInt3();
-        return OSSERR_INVALID_STREAMID;
-    }
-    //set operation to non-blocking
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    return OSSERR_NOT_SUPPORTED;
+        mixerhandle *pHandle = (mixerhandle *)streamid;
+        int              ret;
+
+        if(pHandle == NULL || pHandle->magic != MAGIC_MIXER_ALSA32) {
+                DebugInt3();
+                return OSSERR_INVALID_STREAMID;
+        }
+        //set operation to non-blocking
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        return OSSERR_NOT_SUPPORTED;
 }
 //******************************************************************************
@@ -743 +733 @@
 ULONG OSSToALSAVolume(ULONG OSSVolIdx)
 {
-    switch(OSSVolIdx) {
-    case OSS_MIXER_VOLUME:
-        return OSS32_MIX_VOLUME_MASTER_FRONT;
+        switch(OSSVolIdx) {
+        case OSS_MIXER_VOLUME:
+                return OSS32_MIX_VOLUME_MASTER_FRONT;
 #if 0
-    case OSS_MIXER_VOLUME: //TODO:
-        return OSS32_MIX_VOLUME_MASTER_REAR;
+        case OSS_MIXER_VOLUME: //TODO:
+                return OSS32_MIX_VOLUME_MASTER_REAR;
 #endif
-    case OSS_MIXER_PCM:
-        return OSS32_MIX_VOLUME_PCM;
-    case OSS_MIXER_SYNTH:
-        return OSS32_MIX_VOLUME_MIDI;
-    case OSS_MIXER_LINE:
-        return OSS32_MIX_VOLUME_LINEIN;
-    case OSS_MIXER_MIC:
-        return OSS32_MIX_VOLUME_MIC;
-    case OSS_MIXER_CD:
-        return OSS32_MIX_VOLUME_CD;
-    case OSS_MIXER_DIGITAL1:
-        return OSS32_MIX_VOLUME_SPDIF;
-    case OSS_MIXER_VIDEO:
-        return OSS32_MIX_VOLUME_VIDEO;
-    case OSS_MIXER_PCSPEAKER:
-        return OSS32_MIX_VOLUME_PCSPEAKER;
-    case OSS_MIXER_PHONEOUT:
-        return OSS32_MIX_VOLUME_PHONE;
-    case OSS_MIXER_IGAIN:
-        return OSS32_MIX_VOLUME_CAPTURE;
-    case OSS_MIXER_TREBLE:
-        return OSS32_MIX_LEVEL_TREBLE;
-    case OSS_MIXER_BASS:
-        return OSS32_MIX_LEVEL_BASS;
-    case OSS_MIXER_HEADPHONE:
-        return OSS32_MIX_VOLUME_HEADPHONE;
-    case OSS_MIXER_SPEAKER:
-        return OSS32_MIX_VOLUME_SPEAKER;
-    case OSS_MIXER_LINE1:
-        return OSS32_MIX_VOLUME_AUX;
-    }
-    return -1;
+        case OSS_MIXER_PCM:
+                return OSS32_MIX_VOLUME_PCM;
+        case OSS_MIXER_SYNTH:
+                return OSS32_MIX_VOLUME_MIDI;
+        case OSS_MIXER_LINE:
+                return OSS32_MIX_VOLUME_LINEIN;
+        case OSS_MIXER_MIC:
+                return OSS32_MIX_VOLUME_MIC;
+        case OSS_MIXER_CD:
+                return OSS32_MIX_VOLUME_CD;
+        case OSS_MIXER_DIGITAL1:
+                return OSS32_MIX_VOLUME_SPDIF;
+        case OSS_MIXER_VIDEO:
+                return OSS32_MIX_VOLUME_VIDEO;
+        case OSS_MIXER_PCSPEAKER:
+                return OSS32_MIX_VOLUME_PCSPEAKER;
+        case OSS_MIXER_PHONEOUT:
+                return OSS32_MIX_VOLUME_PHONE;
+        case OSS_MIXER_IGAIN:
+                return OSS32_MIX_VOLUME_CAPTURE;
+        case OSS_MIXER_TREBLE:
+                return OSS32_MIX_LEVEL_TREBLE;
+        case OSS_MIXER_BASS:
+                return OSS32_MIX_LEVEL_BASS;
+        case OSS_MIXER_HEADPHONE:
+                return OSS32_MIX_VOLUME_HEADPHONE;
+        case OSS_MIXER_SPEAKER:
+                return OSS32_MIX_VOLUME_SPEAKER;
+        case OSS_MIXER_LINE1:
+                return OSS32_MIX_VOLUME_AUX;
+        }
+        return -1;
 }
 //******************************************************************************
@@ -787 +777 @@
 OSSRET OSS32_MixQueryCaps(OSSSTREAMID streamid, POSS32_MIXCAPS pCaps)
 {
-    mixerhandle *pHandle = (mixerhandle *)streamid;
-    int i;
-
-    if(pHandle == NULL || pHandle->magic != MAGIC_MIXER_ALSA32) {
-        DebugInt3();
-        return OSSERR_INVALID_STREAMID;
-    }
-
-    strncpy(pCaps->name, pHandle->info.mixername, sizeof(pCaps->name));
-    pCaps->fuCtrlCaps = 0;
-    pCaps->fuRecCaps  = 0;
-
-    for(i=0;i<OSS_MIXER_NRDEVICES;i++)
-    {
-        if(pHandle->controls[i].idxVolume != -1) {
-            ULONG volidx = OSSToALSAVolume(i);
-            if(volidx != -1)
-                pCaps->fuCtrlCaps |= OSS32_MIX_FLAG(volidx);
-        }
-    }
-
-    //if it has a capture source control or the card has capture route switches,
-    //then we support intput source selection
-    if(pHandle->controls[OSS_MIXER_IGAIN].idxCustom != -1 ||
-       pHandle->rectype == RECTYPE_SWITCH)
-    {
-        pCaps->fuCtrlCaps |= OSS32_MIX_FLAG(OSS32_MIX_INPUTSRC);
-        pCaps->fuRecCaps   = pHandle->reccaps;
-    }
-    return OSSERR_SUCCESS;
+        mixerhandle *pHandle = (mixerhandle *)streamid;
+        int i;
+
+        if(pHandle == NULL || pHandle->magic != MAGIC_MIXER_ALSA32) {
+                DebugInt3();
+                return OSSERR_INVALID_STREAMID;
+        }
+
+        strncpy(pCaps->name, pHandle->info.mixername, sizeof(pCaps->name));
+        pCaps->fuCtrlCaps = 0;
+        pCaps->fuRecCaps  = 0;
+
+        for(i=0;i<OSS_MIXER_NRDEVICES;i++)
+        {
+                if(pHandle->controls[i].idxVolume != -1) {
+                        ULONG volidx = OSSToALSAVolume(i);
+                        if(volidx != -1)
+                                pCaps->fuCtrlCaps |= OSS32_MIX_FLAG(volidx);
+                }
+        }
+
+        //if it has a capture source control or the card has capture route switches,
+        //then we support intput source selection
+        if(pHandle->controls[OSS_MIXER_IGAIN].idxCustom != -1 ||
+           pHandle->rectype == RECTYPE_SWITCH)
+        {
+                pCaps->fuCtrlCaps |= OSS32_MIX_FLAG(OSS32_MIX_INPUTSRC);
+                pCaps->fuRecCaps   = pHandle->reccaps;
+        }
+        return OSSERR_SUCCESS;
 }
 //******************************************************************************
@@ -822 +812 @@
 OSSRET OSS32_MixQueryName(ULONG deviceid, char *pszMixerName, ULONG cbMixerName)
 {
-    mixerhandle *pHandle = NULL;
-    int          ret, i, j;
-
-    if(alsa_fops == NULL)
-        return OSSERR_NO_DEVICE_AVAILABLE;
-
-    pHandle = kmalloc(sizeof(mixerhandle), GFP_KERNEL);
-    if(pHandle == NULL) {
-        ret = OSSERR_OUT_OF_MEMORY;
-        goto failure;
-    }
-    memset(pHandle, 0, sizeof(mixerhandle));
-
-    //set operation to non-blocking
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    //setup pointers in file structure (used internally by ALSA)
-    pHandle->file.f_dentry          = &pHandle->d_entry;
-    pHandle->file.f_dentry->d_inode = &pHandle->inode;
-
-    pHandle->file.f_mode  = FMODE_WRITE;
-    pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
-
-    ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
-    if(ret) {
-        goto failure;
-    }
-    //retrieve mixer information
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
-                                    SNDRV_CTL_IOCTL_CARD_INFO,
-                                    (ULONG)&pHandle->info);
-    if(ret) {
-        goto failure;
-    }
-
-    strncpy(pszMixerName, pHandle->info.mixername, cbMixerName);
-
-    pHandle->file.f_flags = O_NONBLOCK;
-    ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-    if(ret) {
-        goto failure;
-    }
-    kfree(pHandle);
-    return OSSERR_SUCCESS;
+        mixerhandle *pHandle = NULL;
+        int              ret, i, j;
+
+        if(alsa_fops == NULL)
+                return OSSERR_NO_DEVICE_AVAILABLE;
+
+        pHandle = kmalloc(sizeof(mixerhandle), GFP_KERNEL);
+        if(pHandle == NULL) {
+                ret = OSSERR_OUT_OF_MEMORY;
+                goto failure;
+        }
+        memset(pHandle, 0, sizeof(mixerhandle));
+
+        //set operation to non-blocking
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        //setup pointers in file structure (used internally by ALSA)
+        pHandle->file.f_dentry                  = &pHandle->d_entry;
+        pHandle->file.f_dentry->d_inode = &pHandle->inode;
+
+        pHandle->file.f_mode  = FMODE_WRITE;
+        pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
+
+        ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
+        if(ret) {
+                goto failure;
+        }
+        //retrieve mixer information
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+                                                                        SNDRV_CTL_IOCTL_CARD_INFO,
+                                                                        (ULONG)&pHandle->info);
+        if(ret) {
+                goto failure;
+        }
+
+        strncpy(pszMixerName, pHandle->info.mixername, cbMixerName);
+
+        pHandle->file.f_flags = O_NONBLOCK;
+        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+        if(ret) {
+                goto failure;
+        }
+        kfree(pHandle);
+        return OSSERR_SUCCESS;
 
 failure:
-    if(pHandle) {
-        kfree(pHandle);
-    }
-    DebugInt3();
-    return OSSERR_OUT_OF_MEMORY;
+        if(pHandle) {
+                kfree(pHandle);
+        }
+        DebugInt3();
+        return OSSERR_OUT_OF_MEMORY;
 }
 //******************************************************************************
 //******************************************************************************
 OSSRET OSS32_QueryNames(ULONG deviceid, char *pszDeviceName, ULONG cbDeviceName,
-                        char *pszMixerName, ULONG cbMixerName, BOOL fLongName)
-{
-    mixerhandle *pHandle = NULL;
-    int          ret, i, j;
-
-    if(alsa_fops == NULL) {
-        ret = OSSERR_NO_DEVICE_AVAILABLE;
-        printk("ret = OSSERR_NO_DEVICE_AVAILABLE\n");
-        goto failure;
-    }
-
-    pHandle = kmalloc(sizeof(mixerhandle), GFP_KERNEL);
-    if(pHandle == NULL) {
-        ret = OSSERR_OUT_OF_MEMORY;
-        goto failure;
-    }
-    memset(pHandle, 0, sizeof(mixerhandle));
-
-    //set operation to non-blocking
-    pHandle->file.f_flags = O_NONBLOCK;
-
-    //setup pointers in file structure (used internally by ALSA)
-    pHandle->file.f_dentry          = &pHandle->d_entry;
-    pHandle->file.f_dentry->d_inode = &pHandle->inode;
-
-    pHandle->file.f_mode  = FMODE_WRITE;
-    pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
-
-    ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
-    if(ret) {
-        printk("open ret = %i\n", ret);
-        goto failure;
-    }
-    //retrieve mixer information
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
-                                    SNDRV_CTL_IOCTL_CARD_INFO,
-                                    (ULONG)&pHandle->info);
-    if(ret) {
-        printk("ioctl ret = %i\n", ret);
-        goto failure;
-    }
-
-    if(pszDeviceName) {
-        if(fLongName == TRUE) {
-             strncpy(pszDeviceName, pHandle->info.longname, cbDeviceName);
-        }
-        else strncpy(pszDeviceName, pHandle->info.name, cbDeviceName);
-    }
-    if(pszMixerName) {
-        strncpy(pszMixerName, pHandle->info.mixername, cbMixerName);
-    }
-
-//    printk("Card: %s with mixer %s\n",pszDeviceName, pszMixerName);
-
-    pHandle->file.f_flags = O_NONBLOCK;
-    ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
-    if(ret) {
-        printk("release ret = %i\n", ret);
-        goto failure;
-    }
-    kfree(pHandle);
-    return OSSERR_SUCCESS;
+                                                char *pszMixerName, ULONG cbMixerName, BOOL fLongName)
+{
+        mixerhandle *pHandle = NULL;
+        int              ret, i, j;
+
+        if(alsa_fops == NULL) {
+                ret = OSSERR_NO_DEVICE_AVAILABLE;
+                printk("ret = OSSERR_NO_DEVICE_AVAILABLE\n");
+                goto failure;
+        }
+
+        pHandle = kmalloc(sizeof(mixerhandle), GFP_KERNEL);
+        if(pHandle == NULL) {
+                ret = OSSERR_OUT_OF_MEMORY;
+                goto failure;
+        }
+        memset(pHandle, 0, sizeof(mixerhandle));
+
+        //set operation to non-blocking
+        pHandle->file.f_flags = O_NONBLOCK;
+
+        //setup pointers in file structure (used internally by ALSA)
+        pHandle->file.f_dentry                  = &pHandle->d_entry;
+        pHandle->file.f_dentry->d_inode = &pHandle->inode;
+
+        pHandle->file.f_mode  = FMODE_WRITE;
+        pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
+
+        ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
+        if(ret) {
+                printk("open ret = %i\n", ret);
+                goto failure;
+        }
+        //retrieve mixer information
+        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+                                                                        SNDRV_CTL_IOCTL_CARD_INFO,
+                                                                        (ULONG)&pHandle->info);
+        if(ret) {
+                printk("ioctl ret = %i\n", ret);
+                goto failure;
+        }
+
+        if(pszDeviceName) {
+                if(fLongName == TRUE) {
+                         strncpy(pszDeviceName, pHandle->info.longname, cbDeviceName);
+                }
+                else strncpy(pszDeviceName, pHandle->info.name, cbDeviceName);
+        }
+        if(pszMixerName) {
+                strncpy(pszMixerName, pHandle->info.mixername, cbMixerName);
+        }
+
+//        printk("Card: %s with mixer %s\n",pszDeviceName, pszMixerName);
+
+        pHandle->file.f_flags = O_NONBLOCK;
+        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
+        if(ret) {
+                printk("release ret = %i\n", ret);
+                goto failure;
+        }
+        kfree(pHandle);
+        return OSSERR_SUCCESS;
 
 failure:
-    if(pHandle) {
-        kfree(pHandle);
-    }
-    DebugInt3();
-    printk("OSS32_QueryNames() ret = %i\n", ret);
-    return OSSERR_OUT_OF_MEMORY;
-}
-//******************************************************************************
-//******************************************************************************
-
+        if(pHandle) {
+                kfree(pHandle);
+        }
+        DebugInt3();
+        printk("OSS32_QueryNames() ret = %i\n", ret);
+        return OSSERR_OUT_OF_MEMORY;
+}
+//******************************************************************************
+//******************************************************************************
+

GPL/branches/uniaud32-2.1.x/uniaud.inc

@@ -7 +7 @@
 # BUILDVERSION must be 3 parts, and only numbers like 5.44.108
 # It is best that 2'nd number is always 2 digits, eg at least 10
-BUILDVERSION = 2.1.0
+BUILDVERSION = 2.1.1
 
 # Fixpack version
@@ -13 +13 @@
 # ex RC3  GA  FIXPACK2 beta_47
 # Comment out to avoid a fixpack line in bldlevel
-FIXPACK = BETA SVNr523
+FIXPACK = BETA SVNr528
 
 # ALSA BUILD VERSION