Changeset 679 for GPL/trunk/lib32

Timestamp:

Mar 18, 2021, 8:57:36 PM (5 years ago)

Author:

David Azarewicz

Message:

Merge changes from Paul's uniaud32next branch.

Location:

GPL/trunk

Files:

• . (modified) (1 prop)
• lib32/Makefile (modified) (2 diffs)
• lib32/base.h (copied) (copied from GPL/branches/uniaud32-next/lib32/base.h )
• lib32/bitmap.c (copied) (copied from GPL/branches/uniaud32-next/lib32/bitmap.c )
• lib32/devres.c (copied) (copied from GPL/branches/uniaud32-next/lib32/devres.c )
• lib32/driver.c (copied) (copied from GPL/branches/uniaud32-next/lib32/driver.c )
• lib32/drivers_base.c (copied) (copied from GPL/branches/uniaud32-next/lib32/drivers_base.c )
• lib32/drivers_bus.c (copied) (copied from GPL/branches/uniaud32-next/lib32/drivers_bus.c )
• lib32/driversbase.c (copied) (copied from GPL/branches/uniaud32-next/lib32/driversbase.c )
• lib32/find_next_bit.c (copied) (copied from GPL/branches/uniaud32-next/lib32/find_next_bit.c )
• lib32/fminstrload.c (modified) (1 diff)
• lib32/initcall.h (modified) (2 diffs)
• lib32/internal.h (copied) (copied from GPL/branches/uniaud32-next/lib32/internal.h )
• lib32/ioctl.c (modified) (32 diffs)
• lib32/kasprintf.c (copied) (copied from GPL/branches/uniaud32-next/lib32/kasprintf.c )
• lib32/klist.c (copied) (copied from GPL/branches/uniaud32-next/lib32/klist.c )
• lib32/kobject.c (copied) (copied from GPL/branches/uniaud32-next/lib32/kobject.c )
• lib32/malloc.c (modified) (1 diff)
• lib32/memory.c (modified) (22 diffs)
• lib32/misc.c (modified) (9 diffs)
• lib32/ossidc.c (modified) (7 diffs)
• lib32/pci.c (modified) (17 diffs)
• lib32/rbtree.c (copied) (copied from GPL/branches/uniaud32-next/lib32/rbtree.c )
• lib32/regcache-flat.c (copied) (copied from GPL/branches/uniaud32-next/lib32/regcache-flat.c )
• lib32/regcache-lzo.c (copied) (copied from GPL/branches/uniaud32-next/lib32/regcache-lzo.c )
• lib32/regcache-rbtree.c (copied) (copied from GPL/branches/uniaud32-next/lib32/regcache-rbtree.c )
• lib32/regcache.c (copied) (copied from GPL/branches/uniaud32-next/lib32/regcache.c )
• lib32/regmap.c (copied) (copied from GPL/branches/uniaud32-next/lib32/regmap.c )
• lib32/seq_file.c (copied) (copied from GPL/branches/uniaud32-next/lib32/seq_file.c )
• lib32/sound.c (modified) (33 diffs)
• lib32/soundmidi.c (modified) (8 diffs)
• lib32/soundmixer.c (modified) (15 diffs)
• lib32/soundoss.h (modified) (1 diff)
• lib32/stack.c (deleted)
• lib32/strscpy.c (copied) (copied from GPL/branches/uniaud32-next/lib32/strscpy.c )
• lib32/task.c (modified) (1 diff)
• lib32/timer.c (modified) (5 diffs)
• lib32/waitqueue.c (modified) (5 diffs)

GPL/trunk/lib32/Makefile

@@ -6 +6 @@
 !include $(ROOT)\tools\header.mif
 
+# note: Watcom headers must be before DDK headers to avoid conflicts
+# with C runtime headers
+%INCLUDE = $(%INCLUDE)$(DDK)\base\h;
 AINCLUDES = $(DDK)\base\H
 
@@ -21 +24 @@
 #
 #===================================================================
-FILES = spinlock.obj malloc.obj pci.obj irq.obj ioctl.obj &
+FILES = spinlock.obj malloc.obj pci.obj irq.obj ioctl.obj devres.obj &
   memory.obj debug.obj sound.obj soundmixer.obj soundmidi.obj &
-  ossidc.obj semaphore.obj waitqueue.obj misc.obj &
-  strncpy.obj task.obj &
-  strncmp.obj timer.obj &
-  instropl2.obj instropl3.obj vsprintf.obj
-# ossidc.obj semaphore.obj waitqueue.obj misc.obj fminstrload.obj
-!if $(KEE) == 0
-FILES += stack.obj
-!endif
+  ossidc.obj semaphore.obj waitqueue.obj misc.obj klist.obj kasprintf.obj &
+  seq_file.obj strncpy.obj strscpy.obj task.obj rbtree.obj &
+  strncmp.obj timer.obj kobject.obj driver.obj drivers_base.obj &
+  instropl2.obj instropl3.obj vsprintf.obj bitmap.obj find_next_bit.obj &
+  regmap.obj regcache.obj regcache-flat.obj regcache-rbtree.obj
 
 TARGET = linuxlib

GPL/trunk/lib32/fminstrload.c

@@ -215 +215 @@
     ev.data.ext.ptr = put;
 
-    err = pHandle->file.f_op->write(&pHandle->file, (char *)__Stack32ToFlat(&ev), sizeof(ev), &pHandle->file.f_pos);
+    err = pHandle->file.f_op->write(&pHandle->file, (char *)&ev, sizeof(ev), &pHandle->file.f_pos);
     if(err < 0) {
         dprintf(("Unable to write an instrument %.3i put event: %x",prg, err));

GPL/trunk/lib32/initcall.h

@@ -33 +33 @@
 extern_module_init(alsa_sound_init)
 extern_module_exit(alsa_sound_exit)
+extern_module_init(alsa_seq_device_init)
+extern_module_exit(alsa_seq_device_exit)
 extern_module_init(alsa_pcm_init)
 extern_module_exit(alsa_pcm_exit)
@@ -45 +47 @@
 extern_module_init(alsa_seq_init)
 extern_module_exit(alsa_seq_exit)
-extern_module_init(alsa_opl3_init)
-extern_module_exit(alsa_opl3_exit)
-extern_module_init(alsa_opl3_seq_init)
-extern_module_exit(alsa_opl3_seq_exit)
-extern_module_init(alsa_mpu401_uart_init)
-extern_module_exit(alsa_mpu401_uart_exit)
+//extern_module_init(alsa_opl3_init)
+//extern_module_exit(alsa_opl3_exit)
+extern_module_init(opl3_seq_driver_init)
+extern_module_exit(opl3_seq_driver_exit)
+extern_module_init(regmap_initcall)
+
+//extern_module_init(alsa_mpu401_uart_init)
+//extern_module_exit(alsa_mpu401_uart_exit)
 
 
 //pci cards
-extern_module_init(alsa_card_ali_init)
-extern_module_exit(alsa_card_ali_exit)
-extern_module_init(alsa_card_als4000_init)
-extern_module_exit(alsa_card_als4000_exit)
-extern_module_init(alsa_card_cs4281_init)
-extern_module_exit(alsa_card_cs4281_exit)
-extern_module_init(alsa_card_cs46xx_init)
-extern_module_exit(alsa_card_cs46xx_exit)
-extern_module_init(alsa_card_cs5535audio_init)
-extern_module_exit(alsa_card_cs5535audio_exit)
-extern_module_init(alsa_card_cmipci_init)
-extern_module_exit(alsa_card_cmipci_exit)
-extern_module_init(alsa_card_emu10k1_init)
-extern_module_exit(alsa_card_emu10k1_exit)
-extern_module_init(alsa_card_ens1370_init)
-extern_module_exit(alsa_card_ens1370_exit)
-extern_module_init(alsa_card_ens1371_init)
-extern_module_exit(alsa_card_ens1371_exit)
-extern_module_init(alsa_card_es1938_init)
-extern_module_exit(alsa_card_es1938_exit)
-extern_module_init(alsa_card_es1968_init)
-extern_module_exit(alsa_card_es1968_exit)
-extern_module_init(alsa_card_fm801_init)
-extern_module_exit(alsa_card_fm801_exit)
-extern_module_init(alsa_card_ice1712_init)
-extern_module_exit(alsa_card_ice1712_exit)
-extern_module_init(alsa_card_intel8x0_init)
-extern_module_exit(alsa_card_intel8x0_exit)
-extern_module_init(alsa_card_m3_init)
-extern_module_exit(alsa_card_m3_exit)
-extern_module_init(alsa_card_nm256_init)
-extern_module_exit(alsa_card_nm256_exit)
-extern_module_init(alsa_card_rme96_init)
-extern_module_exit(alsa_card_rme96_exit)
-extern_module_init(alsa_card_hammerfall_init)
-extern_module_exit(alsa_card_hammerfall_exit)
-extern_module_init(alsa_card_sonicvibes_init)
-extern_module_exit(alsa_card_sonicvibes_exit)
-extern_module_init(alsa_card_trident_init)
-extern_module_exit(alsa_card_trident_exit)
-extern_module_init(alsa_card_via82xx_init)
-extern_module_exit(alsa_card_via82xx_exit)
-extern_module_init(alsa_card_ymfpci_init)
-extern_module_exit(alsa_card_ymfpci_exit)
-extern_module_init(alsa_card_vortex_init)
-extern_module_exit(alsa_card_vortex_exit)
-extern_module_init(alsa_card_atiixp_init)
-extern_module_exit(alsa_card_atiixp_exit)
-extern_module_init(alsa_card_ca0106_init)
-extern_module_exit(alsa_card_ca0106_exit)
+extern_module_init(ali5451_driver_init)
+extern_module_exit(ali5451_driver_exit)
+extern_module_init(als4000_driver_init)
+extern_module_exit(als4000_driver_exit)
+extern_module_init(cs4281_driver_init)
+extern_module_exit(cs4281_driver_exit)
+extern_module_init(cs46xx_driver_init)
+extern_module_exit(cs46xx_driver_exit)
+extern_module_init(cs5535audio_driver_init)
+extern_module_exit(cs5535audio_driver_exit)
+extern_module_init(cmipci_driver_init)
+extern_module_exit(cmipci_driver_exit)
+extern_module_init(emu10k1_driver_init)
+extern_module_exit(emu10k1_driver_exit)
+extern_module_init(ens137x_driver_init)
+extern_module_exit(ens137x_driver_exit)
+extern_module_init(es1938_driver_init)
+extern_module_exit(es1938_driver_exit)
+extern_module_init(es1968_driver_init)
+extern_module_exit(es1968_driver_exit)
+extern_module_init(fm801_driver_init)
+extern_module_exit(fm801_driver_exit)
+extern_module_init(ice1712_driver_init)
+extern_module_exit(ice1712_driver_exit)
+extern_module_init(intel8x0_driver_init)
+extern_module_exit(intel8x0_driver_exit)
+extern_module_init(m3_driver_init)
+extern_module_exit(m3_driver_exit)
+extern_module_init(nm256_driver_init)
+extern_module_exit(nm256_driver_exit)
+extern_module_init(rme96_driver_init)
+extern_module_exit(rme96_driver_exit)
+extern_module_init(hammerfall_driver_init)
+extern_module_exit(hammerfall_driver_exit)
+extern_module_init(sonicvibes_driver_init)
+extern_module_exit(sonicvibes_driver_exit)
+extern_module_init(trident_driver_init)
+extern_module_exit(trident_driver_exit)
+extern_module_init(via82xx_driver_init)
+extern_module_exit(via82xx_driver_exit)
+extern_module_init(ymfpci_driver_init)
+extern_module_exit(ymfpci_driver_exit)
+extern_module_init(vortex_driver_init)
+extern_module_exit(vortex_driver_exit)
+extern_module_init(atiixp_driver_init)
+extern_module_exit(atiixp_driver_exit)
+extern_module_init(ca0106_driver_init)
+extern_module_exit(ca0106_driver_exit)
 extern_module_init(alsa_card_bt87x_init)
 extern_module_exit(alsa_card_bt87x_exit)
-extern_module_init(alsa_card_azx_init)
-extern_module_exit(alsa_card_azx_exit)
-extern_module_init(patch_analog_init)
-extern_module_exit(patch_analog_exit)
-extern_module_init(patch_cmedia_init)
-extern_module_exit(patch_cmedia_exit)
-extern_module_init(patch_conexant_init)
-extern_module_exit(patch_conexant_exit)
-extern_module_init(patch_realtek_init)
-extern_module_exit(patch_realtek_exit)
-extern_module_init(patch_sigmatel_init)
-extern_module_exit(patch_sigmatel_exit)
-extern_module_init(patch_via_init)
-extern_module_exit(patch_via_exit)
+extern_module_init(ac97_bus_init)
+
+
+
+//hda
+extern_module_init(hda_bus_init)
+extern_module_exit(hda_bus_exit)
+extern_module_init(generic_driver_init)
+extern_module_exit(generic_driver_exit)
+extern_module_init(azx_driver_init)
+extern_module_exit(azx_driver_exit)
+extern_module_init(analog_driver_init)
+extern_module_exit(analog_driver_exit)
+extern_module_init(cmedia_driver_init)
+extern_module_exit(cmedia_driver_exit)
+extern_module_init(ca0110_driver_init)
+extern_module_exit(ca0110_driver_exit)
+extern_module_init(cirrus_driver_init)
+extern_module_exit(cirrus_driver_exit)
+extern_module_init(conexant_driver_init)
+extern_module_exit(conexant_driver_exit)
+extern_module_init(hdmi_driver_init)
+extern_module_exit(hdmi_driver_exit)
+extern_module_init(realtek_driver_init)
+extern_module_exit(realtek_driver_exit)
+extern_module_init(sigmatel_driver_init)
+extern_module_exit(sigmatel_driver_exit)
+extern_module_init(via_driver_init)
+extern_module_exit(via_driver_exit)
 
 

GPL/trunk/lib32/ioctl.c

@@ -21 +21 @@
 #include "soundoss.h"
 
+#include <kee.h>
+#include <u32ioctl.h>
+
 POSS32_DEVCAPS pcmcaps[8] = {0,0,0,0,0,0,0,0};
 extern int pcm_device;
@@ -34 +37 @@
 int card_id_changed = 0;
 int unlock_all = 0;
-int GetUniaudPcmCaps(ULONG deviceid, void *caps);
-void FillCaps(ULONG deviceid);
 int pcm_instances(int card_id);
 
@@ -61 +62 @@
 {
         int ctl_id;
-        ULONG blkid = 0;
         int i = 0;
 
@@ -77 +77 @@
                         return -ETIME;
 
-                MyDevBlock(blkid, 1, 0);
+                KernBlock((ULONG)&WaitForControlChange, 1, 0, 0, 0);
                 if (unlock_all)
                 {
@@ -89 +89 @@
 int WaitForPCMInterrupt(void *handle, int timeout)
 {
-        ULONG blkid = 0;
         int i = 0;
         int j = 0;
@@ -143 +142 @@
                 }
 
-                MyDevBlock(blkid, 1, 0);
+                KernBlock((ULONG)&WaitForPCMInterrupt, 1, 0, 0, 0);
                 if (unlock_all)
                 {
@@ -180 +179 @@
 }
 
+/*
 int GetPcmForChannels(ULONG deviceid, int type, int channels)
 {
@@ -220 +220 @@
         return sel_pcm;
 }
+*/
 
 int GetMaxChannels(ULONG deviceid, int type)
@@ -262 +263 @@
  returns pcm caps
  */
-int GetUniaudPcmCaps1(ULONG deviceid, void *caps)
+static int GetUniaudPcmCaps1(ULONG deviceid, void *caps)
 {
         POSS32_DEVCAPS pcaps = (POSS32_DEVCAPS)caps;
@@ -302 +303 @@
                         if(ret != OSSERR_SUCCESS)
                         {
-                                dprintf(("GetUniaudPcmCaps: wave open error %i %s at pcm %i", ret, (j == 0) ?"PLAY":"REC", i));
+                                dprintf(("GetUniaudPcmCaps1: wave open error %i %s at pcm %i", ret, (j == 0) ?"PLAY":"REC", i));
                                 continue;
                                 //goto fail;
@@ -316 +317 @@
                         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);
+                        dprintf(("GetUniaudPcmCaps: cp1. pcm %i, phandle %x", i, pHandle));
+                        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_INFO, (ULONG)pcminfo);
                         if(ret != 0) {
                                 rprintf(("GetUniaudPcmCaps: SNDRV_PCM_IOCTL_INFO error %i", ret));
@@ -334 +335 @@
                         pWaveCaps->nrStreams = pcminfo->subdevices_count;
 
-                        dprintf(("GetUniaudPcmCaps: cp2. nr of streams: %i", pWaveCaps->nrStreams));
+                        dprintf(("GetUniaudPcmCaps: pcm %i, cp2. nr of streams: %i", 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);
+                        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
                         if(ret != 0) {
                                 dprintf(("GetUniaudPcmCaps: SNDRV_PCM_IOCTL_HW_REFINE error %i", ret));
@@ -362 +363 @@
                                 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;
@@ -469 +469 @@
         }
         //retrieve mixer information
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
                                                                         SNDRV_CTL_IOCTL_POWER_STATE,
                                                                         (ULONG)state);
@@ -523 +523 @@
         }
         //retrieve mixer information
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
                                                                         SNDRV_CTL_IOCTL_POWER,
                                                                         (ULONG)state);
@@ -579 +579 @@
         }
         //retrieve mixer information
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
                                                                         SNDRV_CTL_IOCTL_CARD_INFO,
                                                                         (ULONG)(struct snd_ctl_card_info *)info);
@@ -636 +636 @@
         }
         //retrieve mixer information
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
                                                                         SNDRV_CTL_IOCTL_CARD_INFO,
                                                                         (ULONG)&pHandle->info);
@@ -646 +646 @@
         pHandle->list.offset = 0;
         pHandle->list.space  = 0;
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
                                                                         SNDRV_CTL_IOCTL_ELEM_LIST,
                                                                         (ULONG)&pHandle->list);
@@ -704 +704 @@
         }
         //retrieve mixer information
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
                                                                         SNDRV_CTL_IOCTL_CARD_INFO,
                                                                         (ULONG)&pHandle->info);
@@ -714 +714 @@
         pHandle->list.offset = 0;
         pHandle->list.space  = 0;
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
                                                                         SNDRV_CTL_IOCTL_ELEM_LIST,
                                                                         (ULONG)&pHandle->list);
@@ -733 +733 @@
         pHandle->list.space  = pHandle->list.count;
         pHandle->list.pids       = pHandle->pids;
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
                                                                         SNDRV_CTL_IOCTL_ELEM_LIST,
                                                                         (ULONG)&pHandle->list);
@@ -807 +807 @@
 
         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->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
         ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
         if(pHandle) kfree(pHandle);
@@ -865 +865 @@
         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->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_READ, (ULONG)pElem);
         ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
         if(pHandle) kfree(pHandle);
@@ -925 +925 @@
         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->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
         ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
         if(pHandle) kfree(pHandle);
@@ -953 +953 @@
 
         pHandle->file.f_flags = O_NONBLOCK;
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
         return ret;
 }
@@ -970 +970 @@
 
         pHandle->file.f_flags = O_NONBLOCK;
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_PARAMS, (ULONG)params);
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_PARAMS, (ULONG)params);
         return ret;
 }
@@ -989 +989 @@
         pHandle->file.f_flags = O_NONBLOCK;
 
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_SW_PARAMS, (ULONG)params);
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_SW_PARAMS, (ULONG)params);
         return ret;
 }
@@ -1006 +1006 @@
         pHandle->file.f_flags = O_NONBLOCK;
 
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)status);
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)status);
         return ret;
 }
@@ -1055 +1055 @@
         pHandle->file.f_flags = O_NONBLOCK;
 
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
         return ret;
 }
@@ -1070 +1070 @@
         pHandle->file.f_flags = O_NONBLOCK;
 
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PAUSE, pause);
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PAUSE, pause);
 
         return ret;
@@ -1086 +1086 @@
         pHandle->file.f_flags = O_NONBLOCK;
 
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_START, 0);
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_START, 0);
 
         return ret;
@@ -1102 +1102 @@
         pHandle->file.f_flags = O_NONBLOCK;
 
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_DROP, 0);
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_DROP, 0);
 
         return ret;

GPL/trunk/lib32/malloc.c

@@ -29 +29 @@
 
 #include <devhelp.h>
-#ifdef KEE
 #include <kee.h>
-#endif
 #include "malloc.h"
 

GPL/trunk/lib32/memory.c

@@ -32 +32 @@
 #include <stacktoflat.h>
 #include <limits.h>
-#ifdef KEE
 #include <kee.h>
-#endif
 #include "malloc.h"
+#define _I386_PAGE_H
+typedef struct { unsigned long pgprot; } pgprot_t;
+#define MAP_NR(addr)            (__pa(addr) >> PAGE_SHIFT)
+#define PAGE_SHIFT      12
+#define __PAGE_OFFSET           (0xC0000000)
+
+#define PAGE_OFFSET             ((unsigned long)__PAGE_OFFSET)
+#define __pa(x)                 ((unsigned long)(x)-PAGE_OFFSET)
+
+#include <linux/mm.h>
+#include <linux/slab.h>
+#include <linux/printk.h>
 
 #pragma off (unreferenced)
 
 #define PAGE_SIZE 4096
+#define min(a,b)  (((a) < (b)) ? (a) : (b))
 
 int free_pages(unsigned long addr, unsigned long order);
@@ -60 +71 @@
 
 typedef struct _BaseAddr {
-    ULONG                  base;
-    ULONG                  retaddr;
-    ULONG                  size;
+    ULONG                  base;        // VMAlloc addr
+    ULONG                  retaddr;     // aligned addr returned to caller
+    ULONG                  size;        // VMAlloc size
     struct _BaseAddr NEAR *next;
 } BaseAddr;
@@ -93 +104 @@
 //******************************************************************************
 //******************************************************************************
-ULONG GetBaseAddress(ULONG addr, ULONG *pSize)
+ULONG GetBaseAddressAndFree(ULONG addr, ULONG *pSize)
 {
     BaseAddr NEAR *pCur, NEAR *pTemp;
@@ -102 +113 @@
     pCur = pBaseAddrHead;
 
+    // If address is in list, remove list item and free entry
+    // Caller must VMFree returned address or else
     if(pCur->retaddr == addr)
     {
@@ -126 +139 @@
 }
 //******************************************************************************
+//******************************************************************************
+ULONG GetBaseAddressNoFree(ULONG addr, ULONG *pSize)
+{
+    BaseAddr NEAR *pCur, NEAR *pTemp;
+
+    if(pBaseAddrHead == NULL) return addr;
+
+    DevCli();
+    pCur = pBaseAddrHead;
+
+    if(pCur->retaddr == addr)
+    {
+        addr = pCur->base;
+        if(pSize) *pSize = pCur->size;
+        pBaseAddrHead = pCur->next;
+//        _kfree(pCur);
+    }
+    else
+    while(pCur->next) {
+        if(pCur->next->retaddr == addr) {
+            pTemp = pCur->next;
+            addr = pTemp->base;
+            if(pSize) *pSize = pTemp->size;
+            pCur->next = pTemp->next;
+//            _kfree(pTemp);
+            break;
+        }
+        pCur = pCur->next;
+    }
+    DevSti();
+    return addr;
+}
+//******************************************************************************
 //NOTE: Assumes memory is continuous!!
 //******************************************************************************
 unsigned long virt_to_phys(void * address)
 {
-#ifdef KEE
     KEEVMPageList pagelist;
     ULONG         nrpages;
@@ -139 +184 @@
         }
         return pagelist.addr;
-#else
-    LINEAR addr = (LINEAR)address;
-    PAGELIST pagelist;
-
-        if(DevLinToPageList(addr, PAGE_SIZE, (PAGELIST NEAR *)__Stack32ToFlat((ULONG)&pagelist))) {
-                DebugInt3();
-                return 0;
-        }
-        return pagelist.physaddr;
-#endif
 }
 //******************************************************************************
@@ -157 +192 @@
     ULONG addr = 0;
 
-#ifdef KEE
     SHORT sel;
     rc = KernVMAlloc(PAGE_SIZE, VMDHA_PHYS, (PVOID*)&addr, (PVOID*)&address, &sel);
-#else
-    rc = DevVMAlloc(VMDHA_PHYS, PAGE_SIZE, (LINEAR)&address, __Stack32ToFlat((ULONG)&addr));
-#endif
     if (rc != 0) {
         DebugInt3();
@@ -184 +215 @@
 __again:
 
-#ifdef KEE
-
     rc = KernVMAlloc(size, flags, (PVOID*)&addr, (PVOID*)-1, &sel);
-#else
-    rc = DevVMAlloc(flags, size, (LINEAR)-1, __Stack32ToFlat((ULONG)&addr));
-#endif
     if (rc == 0) {
         *pAddr = (LINEAR)addr;
@@ -209 +235 @@
 {
     APIRET rc;
-
-#ifdef KEE
-        rc = KernVMFree((PVOID)addr);
-#else
-        rc = DevVMFree((LINEAR)addr);
-#endif
+    rc = KernVMFree((PVOID)addr);
     if(rc) {
         DebugInt3();
@@ -224 +245 @@
 ULONG ulget_free_pagesMemUsed = 0;
 
-#define GFP_DMA         0x80
-#define GFP_DMAHIGHMEM  0x100
 //******************************************************************************
 //******************************************************************************
@@ -243 +262 @@
 
         if(startpage != endpage) {
-            //try once more
+            // not in same 32K page, try once more
             rc = VMAlloc(size, flags, (LINEAR *)&tempaddr);
             VMFree((LINEAR)addr);
@@ -333 +352 @@
 
             if (startpage != endpage) {
+                // Not in same 32K page
                 physaddr2 = (startpage+1) << 16;
 
@@ -363 +383 @@
 
     //check if it really is the base of the allocation (see above)
-    addr = GetBaseAddress(addr, (ULONG NEAR *)__Stack32ToFlat(&size));
+    addr = GetBaseAddressAndFree(addr, (ULONG NEAR *)&size);
 
     if(VMFree((LINEAR)addr)) {
@@ -402 +422 @@
 //******************************************************************************
 //******************************************************************************
+void *__vmalloc(unsigned long size, gfp_t gfp_mask)
+{
+        return vmalloc(size);
+}
+//******************************************************************************
+//******************************************************************************
+/**
+ * __vmalloc_node - allocate virtually contiguous memory
+ * @size:           allocation size
+ * @align:          desired alignment
+ * @gfp_mask:       flags for the page level allocator
+ * @node:           node to use for allocation or NUMA_NO_NODE
+ * @caller:         caller's return address
+ *
+ * Allocate enough pages to cover @size from the page level allocator with
+ * @gfp_mask flags.  Map them into contiguous kernel virtual space.
+ *
+ * Reclaim modifiers in @gfp_mask - __GFP_NORETRY, __GFP_RETRY_MAYFAIL
+ * and __GFP_NOFAIL are not supported
+ *
+ * Any use of gfp flags outside of GFP_KERNEL should be consulted
+ * with mm people.
+ *
+ * Return: pointer to the allocated memory or %NULL on error
+ */
+void *__vmalloc_node(unsigned long size, unsigned long align,
+                            gfp_t gfp_mask, int node, const void *caller)
+{
+        return vmalloc(size);
+}
+//******************************************************************************
+//******************************************************************************
 void vfree(void *ptr)
 {
@@ -407 +459 @@
     ULONG  size = 0;
 
-    GetBaseAddress((ULONG)ptr, (ULONG NEAR *)__Stack32ToFlat(&size));
+    GetBaseAddressAndFree((ULONG)ptr, (ULONG NEAR *)&size);
 
     if(VMFree((LINEAR)ptr)) {
@@ -427 +479 @@
 //******************************************************************************
 //******************************************************************************
-int remap_page_range(unsigned long from, unsigned long to, unsigned long size, unsigned long prot)
+int remap_page_range(unsigned long from, unsigned long to, unsigned long size, pgprot_t prot)
 {
         DebugInt3();
@@ -452 +504 @@
         //size &= 0xFFFFF000;
 
-#ifdef KEE
     SHORT sel;
-
-        //rc = KernVMAlloc(size, VMDHA_PHYS, (PVOID*)&addr, (PVOID*)&physaddr, &sel);
+    //rc = KernVMAlloc(size, VMDHA_PHYS, (PVOID*)&addr, (PVOID*)&physaddr, &sel);
     rc = KernVMAlloc(Length, VMDHA_PHYS, (PVOID*)&addr, (PVOID*)&PhysicalAddress, &sel);
-#else
-    //rc = DevVMAlloc(VMDHA_PHYS, size, (LINEAR)&physaddr, __Stack32ToFlat((ULONG)&addr));
-    rc = DevVMAlloc(VMDHA_PHYS, Length, (LINEAR)&PhysicalAddress, __Stack32ToFlat((ULONG)&addr));
-#endif
     if (rc != 0) {
         dprintf(("ioremap error: %x", rc));
@@ -497 +543 @@
     if(n == 0) return;
 
-        kmemcpy(to, from, n);
+        memcpy(to, from, n);
 }
 //******************************************************************************
@@ -509 +555 @@
     if(n == 0) return 0;
 
-        kmemcpy(to, from, n);
+        memcpy(to, from, n);
         return 0;
 }
@@ -534 +580 @@
     if(n == 0) return 0;
 
-        kmemcpy(to, from, n);
+        memcpy(to, from, n);
         return 0;
 }
@@ -547 +593 @@
                 return 0;
         }
-        kmemcpy(dest, src, size);
+        memcpy(dest, src, size);
         return 0;
 }
@@ -638 +684 @@
         return kzalloc(n * size, flags);
 }
-
+//******************************************************************************
+//******************************************************************************
+
+size_t ksize(const void *block)
+{
+        size_t size;
+
+        if (!block)
+            size = 0;                   // Bad coder
+
+        else if (block == ZERO_SIZE_PTR)
+            size = 0;                   // Bad coder
+
+        else if(IsHeapAddr((ULONG)block))
+            size = _msize((void _near *)block);
+
+        else if (!GetBaseAddressNoFree((ULONG)block, (ULONG NEAR *)&size))
+            size = 0;                   // Something wrong
+
+        return size;
+}
+//******************************************************************************
+//******************************************************************************
+static inline void *__do_krealloc(const void *p, size_t new_size,
+                                           gfp_t flags)
+{
+        void *ret;
+        size_t ks = 0;
+
+        if (p)
+                ks = ksize(p);
+
+        if (ks >= new_size)
+                return (void *)p;
+
+        ret = __kmalloc(new_size, flags);
+        if (ret && p)
+                memcpy(ret, p, ks);
+
+        return ret;
+}
+//******************************************************************************
+//******************************************************************************
+/**
+ * krealloc - reallocate memory. The contents will remain unchanged.
+ * @p: object to reallocate memory for.
+ * @new_size: how many bytes of memory are required.
+ * @flags: the type of memory to allocate.
+ *
+ * The contents of the object pointed to are preserved up to the
+ * lesser of the new and old sizes.  If @p is %NULL, krealloc()
+ * behaves exactly like kmalloc().  If @new_size is 0 and @p is not a
+ * %NULL pointer, the object pointed to is freed.
+ */
+void *krealloc(const void *p, size_t new_size, gfp_t flags)
+{
+        void *ret;
+
+        if (!new_size) {
+                kfree(p);
+                return ZERO_SIZE_PTR;
+        }
+
+        ret = __do_krealloc(p, new_size, flags);
+        if (ret && p != ret)
+                kfree(p);
+
+        return ret;
+}
+//******************************************************************************
+//******************************************************************************
+/**
+ *      vzalloc - allocate virtually contiguous memory with zero fill
+ *      @size:  allocation size
+ *      Allocate enough pages to cover @size from the page level
+ *      allocator and map them into contiguous kernel virtual space.
+ *      The memory allocated is set to zero.
+ *
+ *      For tight control over page level allocator and protection flags
+ *      use __vmalloc() instead.
+ */
+void *vzalloc(unsigned long size)
+{
+        void *buf;
+        buf = vmalloc(size);
+        if (buf)
+                memset(buf, 0, size);
+        return buf;
+}
+//******************************************************************************
+//******************************************************************************
+/**
+ * kvmalloc_node - attempt to allocate physically contiguous memory, but upon
+ * failure, fall back to non-contiguous (vmalloc) allocation.
+ * @size: size of the request.
+ * @flags: gfp mask for the allocation - must be compatible (superset) with GFP_KERNEL.
+ * @node: numa node to allocate from
+ *
+ * Uses kmalloc to get the memory but if the allocation fails then falls back
+ * to the vmalloc allocator. Use kvfree for freeing the memory.
+ *
+ * Reclaim modifiers - __GFP_NORETRY and __GFP_NOFAIL are not supported.
+ * __GFP_RETRY_MAYFAIL is supported, and it should be used only if kmalloc is
+ * preferable to the vmalloc fallback, due to visible performance drawbacks.
+ *
+ * Please note that any use of gfp flags outside of GFP_KERNEL is careful to not
+ * fall back to vmalloc.
+ *
+ * Return: pointer to the allocated memory of %NULL in case of failure
+ */
+void *kvmalloc_node(size_t size, gfp_t flags, int node)
+{
+        gfp_t kmalloc_flags = flags;
+        void *ret;
+
+        /*
+         * vmalloc uses GFP_KERNEL for some internal allocations (e.g page tables)
+         * so the given set of flags has to be compatible.
+         */
+        if ((flags & GFP_KERNEL) != GFP_KERNEL)
+                return kmalloc_node(size, flags, node);
+
+        /*
+         * We want to attempt a large physically contiguous block first because
+         * it is less likely to fragment multiple larger blocks and therefore
+         * contribute to a long term fragmentation less than vmalloc fallback.
+         * However make sure that larger requests are not too disruptive - no
+         * OOM killer and no allocation failure warnings as we have a fallback.
+         */
+        if (size > PAGE_SIZE) {
+                kmalloc_flags |= __GFP_NOWARN;
+
+                if (!(kmalloc_flags & __GFP_RETRY_MAYFAIL))
+                        kmalloc_flags |= __GFP_NORETRY;
+        }
+
+        ret = kmalloc_node(size, kmalloc_flags, node);
+
+        /*
+         * It doesn't really make sense to fallback to vmalloc for sub page
+         * requests
+         */
+        if (ret || size <= PAGE_SIZE)
+                return ret;
+
+        return __vmalloc_node(size, 1, flags, node,
+                        __builtin_return_address(0));
+}
+//******************************************************************************
+//******************************************************************************

GPL/trunk/lib32/misc.c

@@ -29 +29 @@
 #include <linux/fs.h>
 #include <linux/poll.h>
-#define CONFIG_PROC_FS
+#define CONFIG_PROC_FS 1
 #include <linux/proc_fs.h>
 #include <asm/uaccess.h>
@@ -38 +38 @@
 #include <linux/workqueue.h>
 #include <linux/firmware.h>
+#include <linux/ctype.h>
 #include <dbgos2.h>
 
@@ -84 +85 @@
     return 0;
 }
+
+//******************************************************************************
+//Save error message in szLastALSAError; if card init failed, then we will
+//print it in drv32\init.cpp
+//******************************************************************************
+int dev_dbg(const struct device *dev, const char * fmt, ...)
+{
+    va_list argptr;                /* -> variable argument list */
+
+    char *pszLastALSAError;
+
+    pszLastALSAError= iLastError ? szLastALSAError2 : szLastALSAError1;
+
+    va_start(argptr, fmt);           /* get pointer to argument list */
+    vsprintf(pszLastALSAError, fmt, argptr);
+//    strcat(pszLastALSAError, "\r");
+    va_end(argptr);                /* done with variable arguments */
+
+    if(szOverrunTest1 != 0xCC || szOverrunTest2 != 0xCC) {
+        DebugInt3();
+    }
+
+        StringOut(pszLastALSAError);
+//    rprintf( (pszLastALSAError) );
+    if(++iLastError > 1) {
+        iLastError = 0;
+    }
+    return 0;
+}
+//******************************************************************************
+int pcm_dbg(struct snd_pcm *dev, const char * fmt, ...)
+{
+    va_list argptr;                /* -> variable argument list */
+
+    char *pszLastALSAError;
+
+    pszLastALSAError= iLastError ? szLastALSAError2 : szLastALSAError1;
+
+    va_start(argptr, fmt);           /* get pointer to argument list */
+    vsprintf(pszLastALSAError, fmt, argptr);
+//    strcat(pszLastALSAError, "\r");
+    va_end(argptr);                /* done with variable arguments */
+
+    if(szOverrunTest1 != 0xCC || szOverrunTest2 != 0xCC) {
+        DebugInt3();
+    }
+
+        StringOut(pszLastALSAError);
+//    rprintf( (pszLastALSAError) );
+    if(++iLastError > 1) {
+        iLastError = 0;
+    }
+    return 0;
+}
+//******************************************************************************
+int codec_dbg(struct hda_codec *dev, const char * fmt, ...)
+{
+    va_list argptr;                /* -> variable argument list */
+
+    char *pszLastALSAError;
+
+    pszLastALSAError= iLastError ? szLastALSAError2 : szLastALSAError1;
+
+    va_start(argptr, fmt);           /* get pointer to argument list */
+    vsprintf(pszLastALSAError, fmt, argptr);
+//    strcat(pszLastALSAError, "\r");
+    va_end(argptr);                /* done with variable arguments */
+
+    if(szOverrunTest1 != 0xCC || szOverrunTest2 != 0xCC) {
+        DebugInt3();
+    }
+
+        StringOut(pszLastALSAError);
+//    rprintf( (pszLastALSAError) );
+    if(++iLastError > 1) {
+        iLastError = 0;
+    }
+    return 0;
+}
 //******************************************************************************
 //******************************************************************************
@@ -169 +249 @@
 //******************************************************************************
 //******************************************************************************
+struct proc_dir_entry *proc_mkdir_mode(const char *name, umode_t mode,
+        struct proc_dir_entry *parent){
+    struct proc_dir_entry *proc;
+    proc = (struct proc_dir_entry *)kmalloc(sizeof(struct proc_dir_entry), 0);
+    memset(proc, 0, sizeof(struct proc_dir_entry));
+
+    proc->name   = name;
+    proc->parent = parent;
+
+    return proc;
+}
+//******************************************************************************
+//******************************************************************************
+struct proc_dir_entry *proc_mkdir(const char *name, struct proc_dir_entry *parent)
+{
+    return proc_mkdir_mode(name, S_IRUGO | S_IXUGO, parent);
+}
+//******************************************************************************
+//******************************************************************************
+struct proc_dir_entry *proc_symlink(const char *name, struct proc_dir_entry *parent, const char *dest)
+{
+    struct proc_dir_entry *proc;
+    proc = (struct proc_dir_entry *)kmalloc(sizeof(struct proc_dir_entry), 0);
+    memset(proc, 0, sizeof(struct proc_dir_entry));
+
+    proc->name   = name;
+    proc->parent = parent;
+    proc->data = (void*)dest;
+
+    return proc;
+}
+//******************************************************************************
+//******************************************************************************
 int fasync_helper(int a, struct file *b, int c, struct fasync_struct **d)
 {
@@ -175 +288 @@
 //******************************************************************************
 //******************************************************************************
-void kill_fasync(struct fasync_struct *a, int b, int c)
+void kill_fasync(struct fasync_struct **a, int b, int c)
 {
 }
@@ -273 +386 @@
                 run_workqueue(wq);
         } else {
-                wait_queue_t wait;
+                struct wait_queue_entry wait;
 
                 init_waitqueue_entry(&wait, current);
@@ -399 +512 @@
 //******************************************************************************
 //******************************************************************************
-void *memdup_user(void __user *src, size_t len)
+void *memdup_user(const void __user *src, size_t len)
 {
         void *p = kmalloc(len, GFP_KERNEL);
@@ -425 +538 @@
 //******************************************************************************
 //******************************************************************************
-int schedule_work(struct work_struct *works)
-{
-#ifndef TARGET_OS2
-        return kernel_thread(work_caller, works, 0) >= 0;
-#else
-        return 1;
+struct workqueue_struct *system_wq;
+
+int schedule_work(struct work_struct *work)
+{
+#ifndef TARGET_OS2 // crashes
+        return queue_work(system_wq, work);
 #endif
-}
+        return 0;
+}
+
 //******************************************************************************
 //******************************************************************************
@@ -517 +632 @@
         return -EINVAL;
 }
+//******************************************************************************
+//******************************************************************************
+
+static void u32_swap(void *a, void *b, int size)
+{
+        u32 t = *(u32 *)a;
+        *(u32 *)a = *(u32 *)b;
+        *(u32 *)b = t;
+}
+
+static void generic_swap(void *a, void *b, int size)
+{
+        char t;
+
+        do {
+                t = *(char *)a;
+                *(char *)a++ = *(char *)b;
+                *(char *)b++ = t;
+        } while (--size > 0);
+}
+
+/**
+ * sort - sort an array of elements
+ * @base: pointer to data to sort
+ * @num: number of elements
+ * @size: size of each element
+ * @cmp_func: pointer to comparison function
+ * @swap_func: pointer to swap function or NULL
+ *
+ * This function does a heapsort on the given array. You may provide a
+ * swap_func function optimized to your element type.
+ *
+ * Sorting time is O(n log n) both on average and worst-case. While
+ * qsort is about 20% faster on average, it suffers from exploitable
+ * O(n*n) worst-case behavior and extra memory requirements that make
+ * it less suitable for kernel use.
+ */
+
+void sort(void *base, size_t num, size_t size,
+          int (*cmp_func)(const void *, const void *),
+          void (*swap_func)(void *, void *, int size))
+{
+        /* pre-scale counters for performance */
+        int i = (num/2 - 1) * size, n = num * size, c, r;
+
+        if (!swap_func)
+                swap_func = (size == 4 ? u32_swap : generic_swap);
+
+        /* heapify */
+        for ( ; i >= 0; i -= size) {
+                for (r = i; r * 2 + size < n; r  = c) {
+                        c = r * 2 + size;
+                        if (c < n - size &&
+                                        cmp_func(base + c, base + c + size) < 0)
+                                c += size;
+                        if (cmp_func(base + r, base + c) >= 0)
+                                break;
+                        swap_func(base + r, base + c, size);
+                }
+        }
+
+        /* sort */
+        for (i = n - size; i > 0; i -= size) {
+                swap_func(base, base + i, size);
+                for (r = 0; r * 2 + size < i; r = c) {
+                        c = r * 2 + size;
+                        if (c < i - size &&
+                                        cmp_func(base + c, base + c + size) < 0)
+                                c += size;
+                        if (cmp_func(base + r, base + c) >= 0)
+                                break;
+                        swap_func(base + r, base + c, size);
+                }
+        }
+}
+//******************************************************************************
+//******************************************************************************
+
+/**
+ * hex_to_bin - convert a hex digit to its real value
+ * @ch: ascii character represents hex digit
+ *
+ * hex_to_bin() converts one hex digit to its actual value or -1 in case of bad
+ * input.
+ */
+int hex_to_bin(char ch)
+{
+        if ((ch >= '0') && (ch <= '9'))
+                return ch - '0';
+        ch = tolower(ch);
+        if ((ch >= 'a') && (ch <= 'f'))
+                return ch - 'a' + 10;
+        return -1;
+}
+//******************************************************************************
+
+
+/*
+ * stream_open is used by subsystems that want stream-like file descriptors.
+ * Such file descriptors are not seekable and don't have notion of position
+ * (file.f_pos is always 0). Contrary to file descriptors of other regular
+ * files, .read() and .write() can run simultaneously.
+ *
+ * stream_open never fails and is marked to return int so that it could be
+ * directly used as file_operations.open .
+ */
+int stream_open(struct inode *inode, struct file *filp)
+{
+        filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE | FMODE_ATOMIC_POS);
+        //DAZ f_mode is 16 bit so FMODE_STREAM doesn't fit, but we don't use this on OS/2.
+        //filp->f_mode |= FMODE_STREAM;
+        return 0;
+}
+
+/**
+ * alloc_pages_exact - allocate pages with the given size
+ * @size: the size to allocate in bytes
+ * @gfp_flags: the allocation conditions, GFP_XXX
+ *
+ * Allocates the physically contiguous pages with the given size.
+ *
+ * Return: The pointer of the buffer, or %NULL if no enough memory.
+ */
+void *alloc_pages_exact(size_t size, gfp_t gfp_flags)
+{
+        int pg;
+
+        if (WARN_ON(!size))
+                return NULL;
+        if (WARN_ON(!gfp_flags))
+                return NULL;
+        gfp_flags |= __GFP_COMP;        /* compound page lets parts be mapped */
+        pg = get_order(size);
+        return (void *) __get_free_pages(gfp_flags, pg);
+}
+
+/**
+ * free_pages_exact - release the pages
+ * @ptr: the buffer pointer to release
+ * @size: the allocated buffer size
+ *
+ * Releases the buffer allocated via snd_malloc_pages().
+ */
+void free_pages_exact(void *ptr, size_t size)
+{
+        int pg;
+
+        if (ptr == NULL)
+                return;
+        pg = get_order(size);
+        free_pages((unsigned long) ptr, pg);
+}

GPL/trunk/lib32/ossidc.c

@@ -32 +32 @@
 #include <unicard.h>
 #include <version.h>
-#ifdef KEE
-#include <kee.h>
-#endif
 #include "initcall.h"
+#include <u32ioctl.h>
 
 extern DWORD TimerHandler16;    //drv32\strategy.asm
@@ -66 +64 @@
 
 cardcalls_t cardcalls[CARDS_NUM] = {
-        { CARD_ICH,              &name_module_init(alsa_card_intel8x0_init),    &name_module_exit(alsa_card_intel8x0_exit)        },
-        { CARD_VIA82XX,  &name_module_init(alsa_card_via82xx_init),             &name_module_exit(alsa_card_via82xx_exit)         },
-        { CARD_SBLIVE,   &name_module_init(alsa_card_emu10k1_init),             &name_module_exit(alsa_card_emu10k1_exit)         },
-        { CARD_CMEDIA,   &name_module_init(alsa_card_cmipci_init),              &name_module_exit(alsa_card_cmipci_exit)          },
-        { CARD_ALS4000,  &name_module_init(alsa_card_als4000_init),             &name_module_exit(alsa_card_als4000_exit)         },
-        { CARD_CS4281,   &name_module_init(alsa_card_cs4281_init),              &name_module_exit(alsa_card_cs4281_exit)          },
-        { CARD_CS46XX,   &name_module_init(alsa_card_cs46xx_init),              &name_module_exit(alsa_card_cs46xx_exit)          },
-        { CARD_CS5535,   &name_module_init(alsa_card_cs5535audio_init), &name_module_exit(alsa_card_cs5535audio_exit) },
-        { CARD_ESS1938,  &name_module_init(alsa_card_es1938_init),              &name_module_exit(alsa_card_es1938_exit)          },
-        { CARD_ENSONIQ0, &name_module_init(alsa_card_ens1370_init),             &name_module_exit(alsa_card_ens1370_exit)         },
-        { CARD_ENSONIQ1, &name_module_init(alsa_card_ens1371_init),             &name_module_exit(alsa_card_ens1371_exit)         },
-        { CARD_YAMAHA,   &name_module_init(alsa_card_ymfpci_init),              &name_module_exit(alsa_card_ymfpci_exit)          },
-        { CARD_MAESTRO,  &name_module_init(alsa_card_es1968_init),              &name_module_exit(alsa_card_es1968_exit)          },
-        { CARD_MAESTRO3, &name_module_init(alsa_card_m3_init),                  &name_module_exit(alsa_card_m3_exit)              },
-        { CARD_ALI5451,  &name_module_init(alsa_card_ali_init),                 &name_module_exit(alsa_card_ali_exit)             },
-        { CARD_TRIDENT,  &name_module_init(alsa_card_trident_init),             &name_module_exit(alsa_card_trident_exit)         },
+        { CARD_ICH,      &name_module_init(intel8x0_driver_init),       &name_module_exit(intel8x0_driver_exit)   },
+        { CARD_VIA82XX,  &name_module_init(via82xx_driver_init),        &name_module_exit(via82xx_driver_exit)    },
+        { CARD_SBLIVE,   &name_module_init(emu10k1_driver_init),        &name_module_exit(emu10k1_driver_exit)    },
+        { CARD_CMEDIA,   &name_module_init(cmipci_driver_init),         &name_module_exit(cmipci_driver_exit)     },
+        { CARD_ALS4000,  &name_module_init(als4000_driver_init),        &name_module_exit(als4000_driver_exit)    },
+        { CARD_CS4281,   &name_module_init(cs4281_driver_init),         &name_module_exit(cs4281_driver_exit)     },
+        { CARD_CS46XX,   &name_module_init(cs46xx_driver_init),         &name_module_exit(cs46xx_driver_exit)     },
+        { CARD_CS5535,   &name_module_init(cs5535audio_driver_init),    &name_module_exit(cs5535audio_driver_exit) },
+        { CARD_ESS1938,  &name_module_init(es1938_driver_init),         &name_module_exit(es1938_driver_exit)     },
+        { CARD_ENSONIQ0, &name_module_init(ens137x_driver_init),        &name_module_exit(ens137x_driver_exit)    },
+        { CARD_ENSONIQ1, NULL,                                          NULL                                      },
+        { CARD_YAMAHA,   &name_module_init(ymfpci_driver_init),         &name_module_exit(ymfpci_driver_exit)     },
+        { CARD_MAESTRO,  &name_module_init(es1968_driver_init),         &name_module_exit(es1968_driver_exit)     },
+        { CARD_MAESTRO3, &name_module_init(m3_driver_init),             &name_module_exit(m3_driver_exit)         },
+        { CARD_ALI5451,  &name_module_init(ali5451_driver_init),        &name_module_exit(ali5451_driver_exit)    },
+        { CARD_TRIDENT,  &name_module_init(trident_driver_init),        &name_module_exit(trident_driver_exit)    },
 #ifdef VORTEX
-        { CARD_VORTEX,   &name_module_init(alsa_card_vortex_init),              &name_module_exit(alsa_card_vortex_exit)          },
+        { CARD_VORTEX,   &name_module_init(vortex_driver_init),         &name_module_exit(vortex_driver_exit)     },
 #else
-        { CARD_VORTEX,   NULL,          NULL },
+        { CARD_VORTEX,   NULL,                                          NULL                                      },
 #endif
-        { CARD_NEOMAGIC, &name_module_init(alsa_card_nm256_init),               &name_module_exit(alsa_card_nm256_exit)           },
-        { CARD_FM801,    &name_module_init(alsa_card_fm801_init),               &name_module_exit(alsa_card_fm801_exit)           },
-        { CARD_ATIIXP,   &name_module_init(alsa_card_atiixp_init),              &name_module_exit(alsa_card_atiixp_exit)          },
-        { CARD_AUDIGYLS, &name_module_init(alsa_card_ca0106_init),              &name_module_exit(alsa_card_ca0106_exit)          },
-        { CARD_AZX,              &name_module_init(alsa_card_azx_init),                 &name_module_exit(alsa_card_azx_exit)             },
-        { CARD_BT87X,    &name_module_init(alsa_card_bt87x_init),               &name_module_exit(alsa_card_bt87x_exit)           },
+        { CARD_NEOMAGIC, &name_module_init(nm256_driver_init),          &name_module_exit(nm256_driver_exit)      },
+        { CARD_FM801,    &name_module_init(fm801_driver_init),          &name_module_exit(fm801_driver_exit)      },
+        { CARD_ATIIXP,   &name_module_init(atiixp_driver_init),         &name_module_exit(atiixp_driver_exit)     },
+        { CARD_AUDIGYLS, &name_module_init(ca0106_driver_init),         &name_module_exit(ca0106_driver_exit)     },
+        { CARD_AZX,      &name_module_init(azx_driver_init),            &name_module_exit(azx_driver_exit)        },
+        { CARD_BT87X,    &name_module_init(alsa_card_bt87x_init),       &name_module_exit(alsa_card_bt87x_exit)   },
 };
 
@@ -98 +96 @@
 int        fStrategyInit = FALSE;
 void pcm_info(void);
-void FillCaps(ULONG deviceid);
 
 //******************************************************************************
@@ -115 +112 @@
         dprintf(("OSS32_Initialize: Start address: %X", OffsetBeginCS32));
 
-        if(call_module_init(alsa_sound_init) != 0)               return OSSERR_INIT_FAILED;
+        if(call_module_init(alsa_sound_init) != 0)              return OSSERR_INIT_FAILED;
+        if(call_module_init(alsa_seq_device_init) != 0)         return OSSERR_INIT_FAILED;
         dprintf(("OSS32_Initialize1: Start address: %X", OffsetBeginCS32));
-        if(call_module_init(alsa_pcm_init) != 0)                 return OSSERR_INIT_FAILED;
-        if(call_module_init(alsa_hwdep_init) != 0)               return OSSERR_INIT_FAILED;
-        if(call_module_init(alsa_timer_init) != 0)               return OSSERR_INIT_FAILED;
-
-        if(call_module_init(alsa_rawmidi_init) != 0)     return OSSERR_INIT_FAILED;
-        if(call_module_init(alsa_seq_init) != 0)                 return OSSERR_INIT_FAILED;
-        if(call_module_init(alsa_opl3_init) != 0)                return OSSERR_INIT_FAILED;
-        if(call_module_init(alsa_opl3_seq_init) != 0)    return OSSERR_INIT_FAILED;
-
-        if(call_module_init(alsa_mpu401_uart_init) != 0) return OSSERR_INIT_FAILED;
+        if(call_module_init(alsa_pcm_init) != 0)                return OSSERR_INIT_FAILED;
+        if(call_module_init(alsa_hwdep_init) != 0)              return OSSERR_INIT_FAILED;
+        if(call_module_init(alsa_timer_init) != 0)              return OSSERR_INIT_FAILED;
+
+        if(call_module_init(alsa_rawmidi_init) != 0)            return OSSERR_INIT_FAILED;
+        if(call_module_init(alsa_seq_init) != 0)                return OSSERR_INIT_FAILED;
+        call_module_init(opl3_seq_driver_init);  
+        call_module_init(regmap_initcall);
 
         /* Init functions for HDA audio */
-        call_module_init(patch_analog_init);
-        //call_module_init(patch_atihdmi_init);
-        call_module_init(patch_cmedia_init);
-        call_module_init(patch_conexant_init);
-        call_module_init(patch_realtek_init);
-        call_module_init(patch_sigmatel_init);
-        call_module_init(patch_via_init);
+        call_module_init(hda_bus_init);
+        call_module_init(generic_driver_init);
+        call_module_init(analog_driver_init);
+        call_module_init(ca0110_driver_init);
+        call_module_init(cirrus_driver_init);
+        call_module_init(cmedia_driver_init);
+        call_module_init(conexant_driver_init);
+//      call_module_init(hdmi_driver_init);
+        call_module_init(realtek_driver_init);
+        call_module_init(sigmatel_driver_init);
+        call_module_init(via_driver_init);
 
         //dprintf(("OSS32_Initialize: ForceCard=%d", ForceCard));
@@ -178 +178 @@
         }
 
-        call_module_exit(alsa_mpu401_uart_exit);
-        call_module_exit(alsa_opl3_seq_exit);
-        call_module_exit(alsa_opl3_exit);
+        call_module_exit(opl3_seq_driver_exit);
         call_module_exit(alsa_seq_exit);
         call_module_exit(alsa_rawmidi_exit);
@@ -186 +184 @@
         call_module_exit(alsa_hwdep_exit);
         call_module_exit(alsa_pcm_exit);
+        call_module_exit(alsa_seq_device_exit);
         call_module_exit(alsa_sound_exit);
 
@@ -208 +207 @@
 
 //******************************************************************************
-int MyDevBlock(ULONG id, ULONG tout, char flag)
-{
-        return DevBlock(id,tout, flag);
-}
 
 int OSS32_DebugString(char *buffer, ULONG size)

GPL/trunk/lib32/pci.c

@@ -25 +25 @@
  *
  */
-
+#define CONFIG_PM
 #include "linux.h"
 #include <linux/init.h>
 #include <linux/poll.h>
+#include <linux/dma-mapping.h>
 #include <asm/uaccess.h>
 #include <asm/hardirq.h>
@@ -183 +184 @@
         memset((void near *)pcidev, 0, sizeof(struct pci_dev));
 
-        pcidev->_class = ulTmp2;
+        pcidev->class = ulTmp2;
         pcidev->vendor = detectedId & 0xffff;
         pcidev->device = detectedId >> 16;
@@ -201 +202 @@
         pcidev->sibling = NULL;
         pcidev->next = NULL;
-        pcidev->dma_mask = 0xFFFFFFFF;
+        pcidev->dma_mask = 0xffffffff;
+        pcidev->dev.dma_mask = &pcidev->dma_mask;
+        pcidev->dev.coherent_dma_mask = 0xffffffffull;
 
         // Subsystem ID
         pci_read_config_word(pcidev, PCI_SUBSYSTEM_VENDOR_ID, &pcidev->subsystem_vendor);
         pci_read_config_word(pcidev, PCI_SUBSYSTEM_ID, &pcidev->subsystem_device);
+
+        // revision
+        pci_read_config_byte(pcidev, PCI_REVISION_ID, &pcidev->revision);
 
         // I/O  and MEM
@@ -296 +302 @@
   if(a->flags & IORESOURCE_MEM) {
     if(RMRequestMem(/*hResMgr,*/ start, n) == FALSE) {
-      printk("RMRequestIO failed for io %x, length %x\n", start, n);
+      printk("RMRequestIO failed for mem %x length %x\n", start, n);
       return NULL;
     }
@@ -302 +308 @@
   else if(a->flags & IORESOURCE_IO) {
     if(RMRequestIO(/*hResMgr,*/ start, n) == FALSE) {
-      printk("RMRequestIO failed for io %x, length %x\n", start, n);
+      printk("RMRequestIO failed for io %x length %x\n", start, n);
       return NULL;
     }
@@ -477 +483 @@
   struct pci_dev *pcidev;
   struct pci_device_id IdTable;
+  USHORT usVendor, usDevice;
   int iAdapter = 0;
 
@@ -499 +506 @@
     int iTableIx;
 
-    rprintf(("pci_register_driver: query_device found %x %x:%x class=%x checking %s",
-      ulLast, pcidev->vendor, pcidev->device, pcidev->_class, driver->name));
+    rprintf((__func__": query_device found %x %04x:%04x class=%x checking %s",
+      ulLast, pcidev->vendor, pcidev->device, pcidev->class, driver->name));
+
+    usVendor = 0;
+    usDevice = 0;
 
     for( iTableIx = 0; driver->id_table[iTableIx].vendor; iTableIx++)
@@ -506 +516 @@
       struct pci_device_id const *pDriverId = &driver->id_table[iTableIx];
 
-      if ( (pDriverId->class) && ((pcidev->_class & pDriverId->class_mask) != pDriverId->class) ) continue;
+      if ( (pDriverId->class) && ((pcidev->class & pDriverId->class_mask) != pDriverId->class) ) continue;
       if (pDriverId->vendor != pcidev->vendor) continue;
       if ( (pDriverId->device != PCI_ANY_ID) && (pDriverId->device != pcidev->device) ) continue;
 
-      rprintf(("pci_register_driver: matched %d %x:%x/%x with %x:%x/%x %x (%s)", iTableIx,
-        pcidev->vendor, pcidev->device, pcidev->_class,
+      /* skip a duplicate device that could be matched by both and exact match and a class match */
+      if (usVendor == pcidev->vendor && usDevice == pcidev->device) continue;
+      usVendor = pcidev->vendor;
+      usDevice = pcidev->device;
+
+      rprintf((__func__": matched %d %x:%x/%x with %x:%x/%x %x (%s)", iTableIx,
+        pcidev->vendor, pcidev->device, pcidev->class,
         pDriverId->vendor, pDriverId->device, pDriverId->class, pDriverId->class_mask, driver->name));
 
       if ((iAdapterNumber >= 0) && (iAdapter < iAdapterNumber))
       {
+        rprintf((__func__": AdapterNumber=%x skipping Adapter=%x", iAdapterNumber, iAdapter));
         iAdapter++;
         continue;
       }
 
-      RMInit();
       if (driver->probe(pcidev, pDriverId) == 0)
       {
@@ -527 +542 @@
 
         // create adapter
-        RMDone((pcidev->device << 16) | pcidev->vendor, &pcidev->hAdapter, &pcidev->hDevice);
+        RMCreateAdapterU32((pcidev->device << 16) | pcidev->vendor, &pcidev->hAdapter, ulLast, iNumCards);
+
         iNumCards++;
         pcidev = NULL; /* we need a new slot */
         break;
       }
-      RMDone(0, 0, 0);
+      // release resources which were possibly allocated during probe() 
+      RMDeallocRes();
     } /* for id_table loop */
 
@@ -647 +664 @@
     //try not to exhaust low memory (< 16mb) so allocate from the high region first
     //if that doesn't satisfy the dma mask requirement, then get it from the low
-    //regino anyway
+    //region anyway
     if(hwdev->dma_mask > 0x00ffffff) {
       order = __compat_get_order(size);
@@ -666 +683 @@
     ret = (void *)__get_free_pages(gfp, __compat_get_order(size));
   }
-
   if (ret != NULL) {
     memset(ret, 0, size);
@@ -672 +688 @@
   }
   return ret;
+}
+
+#if 0
+void *pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
+                      dma_addr_t *dma_handle)
+ {
+         return dma_alloc_coherent(hwdev == NULL ? NULL : &hwdev->dev, size, dma_handle, GFP_ATOMIC);
+ }
+#endif
+#if 0
+void *dma_alloc_coherent(struct device *dev, size_t size,
+                                dma_addr_t *dma_handle, gfp_t gfp)
+{
+  void *ret = NULL;
+  int order;
+
+  dprintf(("dma_alloc_coherent %d mask %x", size, (dev) ? dev->dma_mask : 0));
+  if (dev == NULL || *dev->dma_mask != 0xffffffff) {
+  dprintf(("dma_alloc_coherent"));
+    //try not to exhaust low memory (< 16mb) so allocate from the high region first
+    //if that doesn't satisfy the dma mask requirement, then get it from the low
+    //region anyway
+    if(*dev->dma_mask > 0x00ffffff) {
+  dprintf(("dma_alloc_coherent2"));
+      order = __compat_get_order(size);
+      ret = (void *)__get_free_pages(gfp|GFP_DMAHIGHMEM, order);
+      *dma_handle = virt_to_bus(ret);
+      if(*dma_handle > *dev->dma_mask) {
+  dprintf(("dma_alloc_coherent3"));
+        free_pages((unsigned long)ret, __compat_get_order(size));
+        //be sure and allocate below 16 mb
+        gfp |= GFP_DMA;
+        ret = NULL;
+      }
+  dprintf(("dma_alloc_coherent3a"));
+    }
+    else { //must always allocate below 16 mb
+  dprintf(("dma_alloc_coherent4"));
+      gfp |= GFP_DMA;
+    }
+  }
+  if(ret == NULL) {
+  dprintf(("dma_alloc_coherent5"));
+    ret = (void *)__get_free_pages(gfp, __compat_get_order(size));
+  }
+
+  if (ret != NULL) {
+    memset(ret, 0, size);
+    *dma_handle = virt_to_bus(ret);
+  }
+  return ret;
+
+}
+#endif
+
+int dma_supported(struct device *dev, u64 mask)
+{
+  return 1;
+}
+
+int dma_set_coherent_mask(struct device *dev, u64 mask)
+{
+        /*
+         * Truncate the mask to the actually supported dma_addr_t width to
+         * avoid generating unsupportable addresses.
+         */
+        mask = (dma_addr_t)mask;
+
+        if (!dma_supported(dev, mask))
+                return -EIO;
+
+        dev->coherent_dma_mask = mask;
+        return 0;
+}
+
+int dma_set_mask(struct device *dev, u64 mask)
+{
+        /*
+         * Truncate the mask to the actually supported dma_addr_t width to
+         * avoid generating unsupportable addresses.
+         */
+        mask = (dma_addr_t)mask;
+
+        if (!dev->dma_mask || !dma_supported(dev, mask))
+                return -EIO;
+
+        *dev->dma_mask = mask;
+        return 0;
 }
 
@@ -888 +992 @@
 }
 
-const struct pci_device_id * pci_match_device(const struct pci_device_id *ids, struct pci_dev *dev)
+const struct pci_device_id * pci_match_id(const struct pci_device_id *ids, struct pci_dev *dev)
 {
   u16 subsystem_vendor, subsystem_device;
@@ -900 +1004 @@
       (ids->subvendor == PCI_ANY_ID || ids->subvendor == subsystem_vendor) &&
       (ids->subdevice == PCI_ANY_ID || ids->subdevice == subsystem_device) &&
-      !((ids->class ^ dev->_class) & ids->class_mask))
+      !((ids->class ^ dev->class) & ids->class_mask))
       return ids;
     ids++;
@@ -981 +1085 @@
     if(pci_devices[i].devfn)
     {
-      RMSetHandles(pci_devices[i].hAdapter, pci_devices[i].hDevice); /* DAZ - dirty hack */
+      RMSetHandles(pci_devices[i].hAdapter); /* DAZ - dirty hack */
       driver = pci_devices[i].pcidriver;
       if(driver && driver->resume) {
@@ -1004 +1108 @@
     if(pci_devices[i].devfn)
     {
-      RMSetHandles(pci_devices[i].hAdapter, pci_devices[i].hDevice); /* DAZ - dirty hack */
+      RMSetHandles(pci_devices[i].hAdapter); /* DAZ - dirty hack */
       driver = pci_devices[i].pcidriver;
       if(driver && driver->suspend) {
@@ -1040 +1144 @@
 #endif
 
+/**
+ * pci_status_get_and_clear_errors - return and clear error bits in PCI_STATUS
+ * @pdev: the PCI device
+ *
+ * Returns error bits set in PCI_STATUS and clears them.
+ */
+int pci_status_get_and_clear_errors(struct pci_dev *pdev)
+{
+        u16 status;
+        int ret;
+
+        ret = pci_read_config_word(pdev, PCI_STATUS, &status);
+        if (ret != PCIBIOS_SUCCESSFUL)
+                return -EIO;
+
+        status &= PCI_STATUS_ERROR_BITS;
+        if (status)
+                pci_write_config_word(pdev, PCI_STATUS, status);
+
+        return status;
+}
+

GPL/trunk/lib32/sound.c

@@ -37 +37 @@
 #include <stdlib.h>
 #include <proto.h>
-//#include <dbgos2.h>
+#include <u32ioctl.h>
 #include "soundoss.h"
 
@@ -44 +44 @@
 #define samples_to_bytes(a)     ((a*pHandle->doublesamplesize)/2)
 #define bytes_to_samples(a)    (pHandle->doublesamplesize ? ((a*2)/pHandle->doublesamplesize) : a)
-int GetMaxChannels(ULONG deviceid, int type);
 
 struct file_operations oss_devices[OSS32_MAX_DEVICES] = {0};
-struct file_operations *alsa_fops = NULL;
+const struct file_operations *alsa_fops = NULL;
 int per_bytes = 0;
 int prev_size = 0;
@@ -80 +79 @@
 //******************************************************************************
 //******************************************************************************
-int register_chrdev(unsigned int version, const char *name, struct file_operations *fsop)
+int register_chrdev(unsigned int version, const char *name, const struct file_operations *fsop)
 {
    if(!strcmp(name, "alsa")) {
@@ -369 +368 @@
                 pHandle->file.f_flags = O_NONBLOCK;
 
-                ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_INFO, (ULONG)pcminfo);
+                ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_INFO, (ULONG)pcminfo);
                 if(ret != 0) {
                         rprintf(("OSS32_QueryDevCaps: SNDRV_PCM_IOCTL_INFO error %i\n", ret));
@@ -386 +385 @@
                 //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);
+                ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
                 if(ret != 0) {
                         rprintf(("OSS32_QueryDevCaps: SNDRV_PCM_IOCTL_HW_REFINE error %i\n", ret));
@@ -539 +538 @@
 
         ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
+
         //dprintf(("OSS32_WaveOpen. ret: %i\n", ret));
         /* check if PCM already opened (stupid uniaud16.sys doesnt closes it) */
@@ -627 +627 @@
                         {
                                 /* prepare for reuse */
-                                pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_RESET, 0);
-                                pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
+                                pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_RESET, 0);
+                                pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
                         }
                         break;
@@ -668 +668 @@
         pHandle->file.f_flags = O_NONBLOCK;
 
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
         if (ret)
                 rprintf(("Wave prepare ret = %i, streamid %X\n",ret,(ULONG)pHandle));
@@ -687 +687 @@
         //set operation to non-blocking
         pHandle->file.f_flags = O_NONBLOCK;
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_START, 0);
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_START, 0);
         if (ret)
                 rprintf(("Wave start ret = %i, streamid %X\n",ret,(ULONG)pHandle));
@@ -707 +707 @@
         pHandle->file.f_flags = O_NONBLOCK;
 
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_DROP, 0);
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_DROP, 0);
         if (ret)
                 rprintf(("Wave stop ret = %i. streamid %X\n",ret,(ULONG)pHandle));
@@ -727 +727 @@
         pHandle->file.f_flags = O_NONBLOCK;
 
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PAUSE, 0);
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PAUSE, 0);
         if (ret)
                 rprintf(("Wave pause ret = %i, streamid %X\n",ret,(ULONG)pHandle));
@@ -747 +747 @@
         pHandle->file.f_flags = O_NONBLOCK;
 
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PAUSE, 1);
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PAUSE, 1);
         if (ret)
                 rprintf(("Wave resume ret = %i, streamid %X\n",ret,(ULONG)pHandle));
@@ -815 +815 @@
                 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_CHANNELS,
                                                           pHwParams->ulNumChannels, 0);
-                ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
+                ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)&params);
                 if (ret == 0) break;
                 pHwParams->ulNumChannels--;
@@ -828 +828 @@
         _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FORMAT,
                                                    OSSToALSADataType[pHwParams->ulDataType], 0);
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)&params);
         if(ret != 0) {
                 rprintf(("invalid format %lx\n", OSSToALSADataType[pHwParams->ulDataType]));
@@ -835 +835 @@
         _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
                                                   pHwParams->ulBitsPerSample, 0);
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)&params);
         if(ret != 0) {
                 rprintf(("invalid number of sample bits %d\n", pHwParams->ulBitsPerSample));
@@ -842 +842 @@
         _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
                                                   pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)&params);
         if(ret != 0) {
                 rprintf(("invalid number of frame bits %d\n", pHwParams->ulBitsPerSample*pHwParams->ulNumChannels));
@@ -859 +859 @@
         _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
                                                   pHwParams->ulSampleRate, 0);
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)&params);
         if(ret != 0) {
                 rprintf(("32_WSetHwPms (first pass) error %d bps:%d fmt: %d ch: %d sr: %d\n",
@@ -878 +878 @@
                                 _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
                                                                           pHwParams->ulSampleRate, 0);
-                                ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
+                                ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)&params);
                                 if(ret == 0)
                                 {
@@ -892 +892 @@
                                         _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
                                                                                   pHwParams->ulSampleRate, 0);
-                                        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
+                                        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)&params);
                                         goto __next;
                                 }
@@ -1000 +1000 @@
                          pHwParams->ulSampleRate, pHwParams->ulBitsPerSample, pHwParams->ulNumChannels, periodsize, nrperiods));
 
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_PARAMS, (ULONG)__Stack32ToFlat(&params));
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_PARAMS, (ULONG)&params);
         if (ret == -77 && fTryAgain == FALSE)
         {
-                ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
+                ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
                 fTryAgain = TRUE;
                 rprintf((" Error -77 from first IOCTL HW Parms"));
@@ -1045 +1045 @@
                 swparams.xfer_align        = periodsize;
 
-                ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_SW_PARAMS, (ULONG)__Stack32ToFlat(&swparams));
+                ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_SW_PARAMS, (ULONG)&swparams);
         }
 
         total = 0;
         per_bytes = periodbytes;
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)&status);
         if ( ((status.state != SNDRV_PCM_STATE_PREPARED) &&
                    (status.state != SNDRV_PCM_STATE_SETUP) &&
@@ -1056 +1056 @@
                    (status.state != SNDRV_PCM_STATE_DRAINING))) {
                 rprintf(("Device is not in proper state: %lx. Calling prepare\n", status.state));
-                ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
+                ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
         }
         return UNIXToOSSError(ret);
@@ -1094 +1094 @@
 
         /* get the status of the circular dma buffer */
-        iRet = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
+        iRet = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)&status);
 
         if(iRet) {
@@ -1126 +1126 @@
                 if (status.state == SNDRV_PCM_STATE_XRUN) {
                         rprintf(("Internal Error: Xrun"));
-                        iRet = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
+                        iRet = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
                         if (iRet < 0) {
                                 rprintf(("Prepare failed: state=%x avail=%x ReqSize=%x", status.state, status.avail, ulReqSize));
                                 return UNIXToOSSError(iRet);
                         }
-                        iRet = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
+                        iRet = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)&status);
                         rprintf(("Xrun restarted: state=%x avail=%x ReqSize=%x", status.state, status.avail, ulReqSize));
                         if (iRet < 0) return UNIXToOSSError(iRet);
@@ -1165 +1165 @@
                 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));
+                                iRet1 = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)&status);
                                 // If here any state and have free buffer to any byte
                                 if ((status.state != SNDRV_PCM_STATE_XRUN ) && samples_to_bytes(status.avail) ) break;
@@ -1173 +1173 @@
                                 if (ulI > 998) {
                                         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);
+                                        iRet1 = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
                                 }
                         }
@@ -1190 +1190 @@
                                 if ( iRet != -11 ) {
                                         rprintf(("Doing prepare"));
-                                        iRet1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
+                                        iRet1 = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
                                 }
                                 continue;
@@ -1231 +1231 @@
 //        {
 //                printk("warning: ulTransferred [%d] less than requested [%d]", *pulTransferred, ulSize);
-//                iRet1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
+//                iRet1 = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
 //        }
 
@@ -1257 +1257 @@
 
         //Get the status of the stream
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)&status);
 
         if(ret) {
@@ -1289 +1289 @@
 
         //Get the nr of bytes left in the audio buffer
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)&status);
 
         if(ret) {
@@ -1321 +1321 @@
 
         //Get the status of the stream
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)&status);
 
         if(ret) {
@@ -1352 +1352 @@
 
         //Get the status of the stream
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)&status);
         if(ret) return UNIXToOSSError(ret);
         *pStatus = status.state;
@@ -1384 +1384 @@
 
         dprintf(("OSS32_WaveSetVolume %x to (%d,%d)", streamid, leftvol, rightvol));
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_SETVOLUME, (ULONG)__Stack32ToFlat(&pcm_volume));
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_SETVOLUME, (ULONG)&pcm_volume);
         return UNIXToOSSError(ret);
 }

GPL/trunk/lib32/soundmidi.c

@@ -120 +120 @@
     {
         //get the client id
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_SEQ_IOCTL_CLIENT_ID, (ULONG)&pHandle->clientid);
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_SEQ_IOCTL_CLIENT_ID, (ULONG)&pHandle->clientid);
         if(ret) {
             rprintf(("Get client id failed with error %d", ret));
@@ -130 +130 @@
         for(i=64;i<64+((deviceid+1)<<3);i++)
         {
-            memset((PVOID)__Stack32ToFlat(&clientinfo), 0, sizeof(clientinfo));
+            memset(&clientinfo, 0, sizeof(clientinfo));
             clientinfo.client = i;
             clientinfo.type   = KERNEL_CLIENT;
-            ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_SEQ_IOCTL_GET_CLIENT_INFO, (ULONG)__Stack32ToFlat(&clientinfo));
+            ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_SEQ_IOCTL_GET_CLIENT_INFO, (ULONG)&clientinfo);
             if(ret) {
                 continue;
@@ -157 +157 @@
         portinfo.addr.client = pHandle->clientid;
         portinfo.flags       = SNDRV_SEQ_PORT_TYPE_APPLICATION;
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_SEQ_IOCTL_CREATE_PORT, (ULONG)__Stack32ToFlat(&portinfo));
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_SEQ_IOCTL_CREATE_PORT, (ULONG)&portinfo);
         if(ret) {
             rprintf(("subscribe error %d", ret));
@@ -172 +172 @@
         subs.sender.client = pHandle->clientid;
         subs.sender.port   = pHandle->clientport;
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, (ULONG)__Stack32ToFlat(&subs));
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, (ULONG)&subs);
         if(ret) {
             rprintf(("subscribe error %d", ret));
@@ -212 +212 @@
         subs.sender.client = pHandle->clientid;
         subs.sender.port   = pHandle->clientport;
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT, (ULONG)__Stack32ToFlat(&subs));
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT, (ULONG)&subs);
         if(ret) {
             rprintf(("unsubscribe error %d", ret));
@@ -227 +227 @@
         portinfo.addr.client = pHandle->clientid;
         portinfo.addr.port   = pHandle->clientport;
-        ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_SEQ_IOCTL_DELETE_PORT, (ULONG)__Stack32ToFlat(&portinfo));
+        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_SEQ_IOCTL_DELETE_PORT, (ULONG)&portinfo);
         if(ret) {
             dprintf(("delete port error %d", ret));
@@ -300 +300 @@
     pHandle->file.f_flags = O_NONBLOCK;
 
-    memset((PVOID)__Stack32ToFlat(&fmevent), 0, sizeof(fmevent));
+    memset(&fmevent, 0, sizeof(fmevent));
     switch(Cmd) {
     case IDC32_MIDI_NOTEON:
@@ -331 +331 @@
     fmevent.dest.port     = pHandle->destport;
 
-    transferred = pHandle->file.f_op->write(&pHandle->file, (char *)__Stack32ToFlat(&fmevent), sizeof(fmevent), &pHandle->file.f_pos);
+    transferred = pHandle->file.f_op->write(&pHandle->file, (char *)&fmevent, sizeof(fmevent), &pHandle->file.f_pos);
 
     if(transferred < 0) {

GPL/trunk/lib32/soundmixer.c

@@ -148 +148 @@
   }
   //retrieve mixer information
-  ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+  ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
                   SNDRV_CTL_IOCTL_CARD_INFO,
                   (ULONG)&pHandle->info);
@@ -157 +157 @@
   pHandle->list.offset = 0;
   pHandle->list.space  = 0;
-  ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+  ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
                   SNDRV_CTL_IOCTL_ELEM_LIST,
                   (ULONG)&pHandle->list);
@@ -172 +172 @@
   pHandle->list.space  = pHandle->list.count;
   pHandle->list.pids   = pHandle->pids;
-  ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+  ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
                   SNDRV_CTL_IOCTL_ELEM_LIST,
                   (ULONG)&pHandle->list);
@@ -271 +271 @@
       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);
+      ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
       if(ret) {
         DebugInt3();
@@ -484 +484 @@
     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);
+    ret = pHandle->file.f_op->unlocked_ioctl(&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);
+  ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
   if(ret) {
     ret = UNIXToOSSError(ret);
@@ -515 +515 @@
 
 #if 1
-  ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
+  ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
 #else
   // looking for more, then one opened streams to prevent of muting active stream
@@ -528 +528 @@
   {
     dprintf(("OSS32_MixSetVolume Ioctl"));
-    ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
+    ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
 
     if(idxMute != -1 && volume == 0) {
@@ -538 +538 @@
       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->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
     }
   }
@@ -603 +603 @@
           //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);
+          ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
           if(ret) {
             ret = UNIXToOSSError(ret);
@@ -621 +621 @@
           }
 
-          ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
+          ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
           if(ret) {
             ret = UNIXToOSSError(ret);
@@ -631 +631 @@
       //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);
+      ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
       if(ret) {
         ret = UNIXToOSSError(ret);
@@ -678 +678 @@
     //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);
+    ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
     if(ret) {
       ret = UNIXToOSSError(ret);
@@ -707 +707 @@
 
   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);
+  ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
 
   kfree(pElem);
@@ -849 +849 @@
   }
   //retrieve mixer information
-  ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+  ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
                   SNDRV_CTL_IOCTL_CARD_INFO,
                   (ULONG)&pHandle->info);
@@ -911 +911 @@
   }
   //retrieve mixer information
-  ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
+  ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
                   SNDRV_CTL_IOCTL_CARD_INFO,
                   (ULONG)&pHandle->info);

GPL/trunk/lib32/soundoss.h

@@ -69 +69 @@
 } mixerhandle;
 
-extern struct file_operations *alsa_fops;
+extern const struct file_operations *alsa_fops;
 extern int                     nrCardsDetected;
 

GPL/trunk/lib32/task.c

@@ -26 +26 @@
 #include <linux/kernel.h>
 #include <linux/fs.h>
-#include <linux/tqueue.h>
 #include <linux/interrupt.h>
 #define LINUX

GPL/trunk/lib32/timer.c

@@ -30 +30 @@
 #include <asm/io.h>
 #include <linux/time.h>
+#include <linux/math64.h>
+#include <linux/clocksource.h>
 
 #define LINUX
@@ -36 +38 @@
 #include <dbgos2.h>
 
+#pragma pack(1)
+#include     "infoseg.h"
+#pragma pack()
+extern PVOID  KernSISData;
+#define KernSISData             ((struct InfoSegGDT *)&KernSISData)
+
 static   long          jiffiems    = 1000/HZ;
 static   long          lasttime    = 0;
@@ -47 +55 @@
     long delta, newtime, remainder;
 
-    newtime    = os2gettimemsec();
+    newtime    = KernSISData->SIS_MsCount;
     delta      = newtime - lasttime;
 
@@ -95 +103 @@
 {
 #if 0
-    tv->tv_sec  = 0; //os2gettimesec();
-    tv->tv_usec = os2gettimemsec() * 1000;
+    tv->tv_sec  = 0; //KernSISData->SIS_BigTime;
+    tv->tv_usec = KernSISData->SIS_MsCount * 1000;
 #else /* r.ihle patch */
-    unsigned u = os2gettimemsec();
+    unsigned u = KernSISData->SIS_MsCount;
     tv->tv_sec  = u / 1000;
     tv->tv_usec = (u % 1000) * 1000;
@@ -140 +148 @@
 //******************************************************************************
 //******************************************************************************
+
+/**
+ * ns_to_timespec - Convert nanoseconds to timespec
+ * @nsec:       the nanoseconds value to be converted
+ *
+ * Returns the timespec representation of the nsec parameter.
+ */
+struct timespec ns_to_timespec(const s64 nsec)
+{
+        struct timespec ts;
+        s32 rem;
+
+        if (!nsec) {
+                ts.tv_sec = 0;
+                ts.tv_nsec = 0;
+                return ts;
+        }
+
+        ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
+        if (unlikely(rem < 0)) {
+                ts.tv_sec--;
+                rem += NSEC_PER_SEC;
+        }
+        ts.tv_nsec = rem;
+
+        return ts;
+}
+
+
+//******************************************************************************
+//******************************************************************************
+
+/**
+ * ns_to_timespec - Convert nanoseconds to timespec
+ * @nsec:       the nanoseconds value to be converted
+ *
+ * Returns the timespec representation of the nsec parameter.
+ */
+struct timespec64 ns_to_timespec64(const s64 nsec)
+{
+        struct timespec64 ts;
+        s32 rem;
+
+        if (!nsec) {
+                ts.tv_sec = 0;
+                ts.tv_nsec = 0;
+                return ts;
+        }
+
+        ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
+        if (unlikely(rem < 0)) {
+                ts.tv_sec--;
+                rem += NSEC_PER_SEC;
+        }
+        ts.tv_nsec = rem;
+
+        return ts;
+}
+//******************************************************************************
+//******************************************************************************
+
+void timecounter_init(struct timecounter *tc,
+                      const struct cyclecounter *cc,
+                      u64 start_tstamp)
+{
+        tc->cc = cc;
+        tc->cycle_last = cc->read(cc);
+        tc->nsec = start_tstamp;
+}
+
+/**
+ * timecounter_read_delta - get nanoseconds since last call of this function
+ * @tc:         Pointer to time counter
+ *
+ * When the underlying cycle counter runs over, this will be handled
+ * correctly as long as it does not run over more than once between
+ * calls.
+ *
+ * The first call to this function for a new time counter initializes
+ * the time tracking and returns an undefined result.
+ */
+static u64 timecounter_read_delta(struct timecounter *tc)
+{
+        cycle_t cycle_now, cycle_delta;
+        u64 ns_offset;
+
+        /* read cycle counter: */
+        cycle_now = tc->cc->read(tc->cc);
+
+        /* calculate the delta since the last timecounter_read_delta(): */
+        cycle_delta = (cycle_now - tc->cycle_last) & tc->cc->mask;
+
+        /* convert to nanoseconds: */
+        ns_offset = cyclecounter_cyc2ns(tc->cc, cycle_delta);
+
+        /* update time stamp of timecounter_read_delta() call: */
+        tc->cycle_last = cycle_now;
+
+        return ns_offset;
+}
+
+u64 timecounter_read(struct timecounter *tc)
+{
+        u64 nsec;
+
+        /* increment time by nanoseconds since last call */
+        nsec = timecounter_read_delta(tc);
+        nsec += tc->nsec;
+        tc->nsec = nsec;
+
+        return nsec;
+}
+
+/**
+ * set_normalized_timespec - set timespec sec and nsec parts and normalize
+ *
+ * @ts:         pointer to timespec variable to be set
+ * @sec:        seconds to set
+ * @nsec:       nanoseconds to set
+ *
+ * Set seconds and nanoseconds field of a timespec variable and
+ * normalize to the timespec storage format
+ *
+ * Note: The tv_nsec part is always in the range of
+ *      0 <= tv_nsec < NSEC_PER_SEC
+ * For negative values only the tv_sec field is negative !
+ */
+void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec)
+{
+        while (nsec >= NSEC_PER_SEC) {
+                /*
+                 * The following asm() prevents the compiler from
+                 * optimising this loop into a modulo operation. See
+                 * also __iter_div_u64_rem() in include/linux/time.h
+                 */
+//              asm("" : "+rm"(nsec));
+                nsec -= NSEC_PER_SEC;
+                ++sec;
+        }
+        while (nsec < 0) {
+//              asm("" : "+rm"(nsec));
+                nsec += NSEC_PER_SEC;
+                --sec;
+        }
+        ts->tv_sec = sec;
+        ts->tv_nsec = nsec;
+}

GPL/trunk/lib32/waitqueue.c

@@ -38 +38 @@
 //******************************************************************************
 //******************************************************************************
-void add_wait_queue(wait_queue_head_t *q, wait_queue_t * wait)
+void add_wait_queue(struct wait_queue_head *q, struct wait_queue_entry * wait)
 {
 //    dprintf3(("WARNING: add_wait_queue STUB"));
@@ -44 +44 @@
 //******************************************************************************
 //******************************************************************************
-void add_wait_queue_exclusive(wait_queue_head_t *q)
+void add_wait_queue_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
 {
 //    dprintf3(("WARNING: add_wait_queue_exclusive STUB"));
@@ -50 +50 @@
 //******************************************************************************
 //******************************************************************************
-void remove_wait_queue(wait_queue_head_t *q, wait_queue_t * wait)
+void remove_wait_queue(struct wait_queue_head *q, struct wait_queue_entry * wait)
 {
 //    dprintf(("WARNING: remove_wait_queue STUB"));
@@ -75 +75 @@
 //******************************************************************************
 //******************************************************************************
-void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p)
+void init_waitqueue_entry(struct wait_queue_entry *wq_entry, struct task_struct *p)
 {
 //    dprintf(("WARNING: init_waitqueue_entry STUB"));
@@ -88 +88 @@
 //******************************************************************************
 //******************************************************************************
+/**
+ * complete: - signals a single thread waiting on this completion
+ * @x:  holds the state of this particular completion
+ *
+ * This will wake up a single thread waiting on this completion. Threads will be
+ * awakened in the same order in which they were queued.
+ *
+ * See also complete_all(), wait_for_completion() and related routines.
+ *
+ * It may be assumed that this function implies a write memory barrier before
+ * changing the task state if and only if any tasks are woken up.
+ */
+void complete(struct completion *x)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&x->wait.lock, flags);
+        x->done++;
+        __wake_up_locked(&x->wait, TASK_NORMAL, 1);
+        spin_unlock_irqrestore(&x->wait.lock, flags);
+}
+/**
+ * complete_all: - signals all threads waiting on this completion
+ * @x:  holds the state of this particular completion
+ *
+ * This will wake up all threads waiting on this particular completion event.
+ *
+ * If this function wakes up a task, it executes a full memory barrier before
+ * accessing the task state.
+ *
+ * Since complete_all() sets the completion of @x permanently to done
+ * to allow multiple waiters to finish, a call to reinit_completion()
+ * must be used on @x if @x is to be used again. The code must make
+ * sure that all waiters have woken and finished before reinitializing
+ * @x. Also note that the function completion_done() can not be used
+ * to know if there are still waiters after complete_all() has been called.
+ */
+void complete_all(struct completion *x)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&x->wait.lock, flags);
+        __wake_up_locked(&x->wait, TASK_NORMAL, 1);
+        spin_unlock_irqrestore(&x->wait.lock, flags);
+}
+//******************************************************************************
+//******************************************************************************
+void __wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr)
+{
+    dprintf3(("WARNING: __wake_up_locked STUB"));
+}
+//******************************************************************************
+//******************************************************************************
+/**
+ * wait_for_completion: - waits for completion of a task
+ * @x:  holds the state of this particular completion
+ *
+ * This waits to be signaled for completion of a specific task. It is NOT
+ * interruptible and there is no timeout.
+ *
+ * See also similar routines (i.e. wait_for_completion_timeout()) with timeout
+ * and interrupt capability. Also see complete().
+ */
+void wait_for_completion(struct completion *x)
+{
+    dprintf3(("WARNING: wait_for_completion STUB"));
+}
+
+
+/**
+ * wait_for_completion_timeout: - waits for completion of a task (w/timeout)
+ * @x:  holds the state of this particular completion
+ * @timeout:  timeout value in jiffies
+ *
+ * This waits for either a completion of a specific task to be signaled or for a
+ * specified timeout to expire. The timeout is in jiffies. It is not
+ * interruptible.
+ *
+ * Return: 0 if timed out, and positive (at least 1, or number of jiffies left
+ * till timeout) if completed.
+ */
+unsigned long wait_for_completion_timeout(struct completion *x, unsigned long timeout)
+{
+    dprintf3(("WARNING: wait_for_completion_timeout STUB"));
+    return 1;
+}