Changeset 504 for GPL/branches

Timestamp:

Jul 11, 2010, 7:42:10 AM (15 years ago)

Author:

David Azarewicz

Message:

Bring branch up-to-date with trunk

Location:

GPL/branches/uniaud32-2.1.x

Files:

• alsa-kernel/core/memalloc.c (modified) (5 diffs)
• drv32/init.c (modified) (8 diffs)
• drv32/parse.c (modified) (1 diff)
• drv32/read.cpp (modified) (5 diffs)
• drv32/strategy.c (modified) (4 diffs)
• include/dbgos2.h (modified) (1 diff)
• include/malloc.h (modified) (3 diffs)
• lib32/debug.c (modified) (6 diffs)
• lib32/irq.c (modified) (4 diffs)
• lib32/malloc.cpp (modified) (22 diffs)
• lib32/memory.cpp (modified) (10 diffs)
• lib32/ossidc.cpp (modified) (3 diffs)
• lib32/sound.c (modified) (1 diff)
• uniaud.inc (modified) (1 diff)

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

@@ -2 +2 @@
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
  *                   Takashi Iwai <tiwai@suse.de>
- * 
+ *
  *  Generic memory allocators
  *
@@ -209 +209 @@
  * Calls the memory-allocator function for the corresponding
  * buffer type.
- * 
+ *
  * Returns zero if the buffer with the given size is allocated successfuly,
  * other a negative value at error.
@@ -216 +216 @@
                         struct snd_dma_buffer *dmab)
 {
-#ifdef DEBUG
     dprintf(("snd_dma_alloc_pages with size = %d",size));
-#endif
         if (WARN_ON(!size))
                 return -ENXIO;
@@ -265 +263 @@
  * tries to allocate again.  The size actually allocated is stored in
  * res_size argument.
- * 
+ *
  * Returns zero if the buffer with the given size is allocated successfuly,
  * other a negative value at error.
@@ -362 +360 @@
  *
  * Reserves the given buffer as a reserved buffer.
- * 
+ *
  * Returns zero if successful, or a negative code at error.
  */

GPL/branches/uniaud32-2.1.x/drv32/init.c

@@ -36 +36 @@
 #include <ossidc32.h>
 #include <dbgos2.h>
-#include <printfos2.h>
 #include <irqos2.h>
 //#include <bsedos16.h>
@@ -43 +42 @@
 #endif
 #include "parse.h"
+#include "malloc.h"
 
 const char ERR_ERROR[]   = "ERROR: ";
@@ -68 +68 @@
 extern "C" int sprintf (char *buffer, const char *format, ...);
 
-extern "C" int wrOffset;
-extern "C" char *szprintBuf;
 extern "C" APIRET APIENTRY DOS16OPEN(PSZ pszFileName, PHFILE phf, PULONG pulAction, ULONG cbFile, ULONG ulAttribute, ULONG fsOpenFlags, ULONG fsOpenMode, PEAOP2 peaop2 );
 extern "C" APIRET APIENTRY DOS16CLOSE(HFILE hFile);
 extern "C" APIRET APIENTRY DOS16WRITE(HFILE hFile, PVOID pBuffer, ULONG cbWrite, PULONG pcbActual);
 extern "C" void SaveBuffer(void);
+
+#define VMDHA_FIXED             0x0002
+
+extern "C" APIRET VMAlloc(ULONG size, ULONG flags, char NEAR* *pAddr);
 
 //Print messages with DosWrite when init is done or has failed (see startup.asm)
@@ -91 +93 @@
 }
 
-void _cdecl printfos2(char *string)
-{
-   DevSaveMessage(string, strlen(string));
-}
-
 //SvL: Lock our 32 bits data & code segments
-int LockSegments(void) 
+int LockSegments(void)
 {
 #ifdef KEE
@@ -194 +191 @@
 #endif
 // Initialize device driver
-WORD32 DiscardableInit(RPInit __far* rp)  
+WORD32 DiscardableInit(RPInit __far* rp)
 {
     char        debugmsg[64];
@@ -209 +206 @@
     }
 
+        DebugLevel = 1;
     rp->Out.FinalCS = 0;
     rp->Out.FinalDS = 0;
+
+        if ( szprintBuf == 0 ) {
+                VMAlloc( DBG_MAX_BUF_SIZE, VMDHA_FIXED, &szprintBuf );
+                if (szprintBuf) {
+                        memset( szprintBuf, 0, DBG_MAX_BUF_SIZE );
+                        wrOffset= 0;
+                }
+        }
+        if (!HeapInit(HEAP_SIZE)) {
+                dprintf(("HeapInit failed!"));
+        }
 
     args = MAKE_FARPTR32(rp->In.Args);
@@ -268 +277 @@
 #if 0
         for(int i=1;i<OSS32_MAX_AUDIOCARDS;i++) {
-            if(OSS32_QueryNames(i, szDeviceName, sizeof(szDeviceName), szMixerName, sizeof(szMixerName)) == OSSERR_SUCCESS) 
+            if(OSS32_QueryNames(i, szDeviceName, sizeof(szDeviceName), szMixerName, sizeof(szMixerName)) == OSSERR_SUCCESS)
             {
                 WriteString(szDeviceName, strlen(szDeviceName));
@@ -281 +290 @@
         WriteString(szEOL, sizeof(szEOL)-1);
     }
-#ifdef DEBUG
-    dprintf(("DiscardableInit. cp1"));
-#endif
     // Complete the installation
     rp->Out.FinalCS = _OffsetFinalCS16;
     rp->Out.FinalDS = _OffsetFinalDS16;
-#ifdef DEBUG
-    dprintf(("DiscardableInit. cp2"));
-#endif
-
-//    SaveBuffer();
+
+        //SaveBuffer();
 
     // Confirm a successful installation

GPL/branches/uniaud32-2.1.x/drv32/parse.c

@@ -39 +39 @@
 #include <string.h>
 
-#ifdef DEBUG
 #define COMM_DEBUG
-#endif
 
 // True if the /V parameter was specified

GPL/branches/uniaud32-2.1.x/drv32/read.cpp

@@ -11 +11 @@
 int   wrOffset= 0;
 char  *szprintBuf= 0;
-#ifdef DEBUG
-int   max_buf_size= 0x100000;
-#else
-int   max_buf_size= 0x10000;
-#endif
 
 void * __ioremap(unsigned long physaddr, unsigned long size, unsigned long flags);
@@ -25 +20 @@
 {
   RPRWV __far* rp = (RPRWV __far*)_rp;
-  
+
   char *lin;
   int   transferCount= rp->Count;
-  
+
   if( szprintBuf )
   {
@@ -35 +30 @@
     {
       int diffCount;
-      
+
       if( rdOffset > wrOffset )
       {
-        diffCount= max_buf_size - rdOffset + wrOffset;
+        diffCount= DBG_MAX_BUF_SIZE - rdOffset + wrOffset;
       } else
       {
@@ -45 +40 @@
       if( transferCount > diffCount )
         transferCount= diffCount;
-      
+
       rp->Count= transferCount;
-      if( (rdOffset + transferCount) > max_buf_size )
+      if( (rdOffset + transferCount) > DBG_MAX_BUF_SIZE )
       {
-        diffCount= max_buf_size - rdOffset;
+        diffCount= DBG_MAX_BUF_SIZE - rdOffset;
         memcpy( lin, szprintBuf + rdOffset, diffCount );
         transferCount= transferCount - diffCount;
@@ -55 +50 @@
       } else
         diffCount= 0;
-        
-      if( transferCount ) 
+
+      if( transferCount )
       {
         memcpy( lin + diffCount, szprintBuf + rdOffset, transferCount );

GPL/branches/uniaud32-2.1.x/drv32/strategy.c

@@ -38 +38 @@
 ULONG StratClose(RP __far *_rp);
 
-ULONG DiscardableInit(RPInit __far*);  
+ULONG DiscardableInit(RPInit __far*);
 
 ULONG deviceOwner = DEV_NO_OWNER;
@@ -70 +70 @@
     RPInit __far* rp = (RPInit __far*)_rp;
     rc = DiscardableInit(rp);
-#ifdef DEBUG
-    dprintf(("StratInit. cp1.rc %d", rc));
-#endif
+    dprintf(("StratInit End rc=%d", rc));
     return rc;
 }
@@ -89 +87 @@
     BYTE   LowIRQ;
     BYTE   HighIRQ;
-    BYTE   Pin;   
+    BYTE   Pin;
 };
 extern struct SaveIRQForSlot sISRHigh[];
@@ -138 +136 @@
 #endif
   if(rp->Function == 1) {//end of shutdown
-        OSS32_Shutdown(); 
+        OSS32_Shutdown();
   }
   return(RPDONE);

GPL/branches/uniaud32-2.1.x/include/dbgos2.h

@@ -26 +26 @@
 #define __COMMDBG_H__
 
-//#ifdef DEBUG
-#if 1
 #ifdef __cplusplus
 extern "C" {
 #endif
 extern int DebugLevel;
-
+extern int wrOffset;
+extern char *szprintBuf;
+//void _cdecl DPD(int level, char *x, ...) ; /* not debugging: nothing */
 void _cdecl DPE(char *x, ...) ; /* not debugging: nothing */
-void _cdecl DPD(int level, char *x, ...) ; /* not debugging: nothing */
 #ifdef __cplusplus
 }
 #endif
-#define dprintf(a)      if(DebugLevel > 0) DPE a
+
+/* rprintf always prints to the log buffer, and to SIO if enabled */
+#define rprintf(a) DPE a
+
+/* the dprintf functions only print if DEBUG is defined */
+#ifdef DEBUG
+#define DBG_MAX_BUF_SIZE 0x100000
+#define dprintf(a)      DPE a
+#define dprintf1(a)     if(DebugLevel > 0) DPE a
 #define dprintf2(a)     if(DebugLevel > 1) DPE a
 #define dprintf3(a)     if(DebugLevel > 2) DPE a
-#define DebugInt3()     ; //_asm int 3;
-#define DebInt3()       _asm int 3;
-#else // #ifdef DEBUG
+#define DebugInt3()     ; //_asm int 3
+//#define DebInt3()     _asm int 3;
+#else
+// not DEBUG
+#define DBG_MAX_BUF_SIZE 0x10000
 #define dprintf(a)
+#define dprintf1(a)
 #define dprintf2(a)
 #define dprintf3(a)
-#define DebugInt3()     ;
-#endif // #ifdef DEBUG
+#define DebugInt3()
+#endif
 
 #endif //__COMMDBG_H__
+

GPL/branches/uniaud32-2.1.x/include/malloc.h

@@ -25 +25 @@
 #define MALLOC_INCLUDED
 
+#define  DEFAULT_HEAP   256*1024
+#define  HEAP_SIZE      256*1024
+
 // Standard malloc.h functions
 
@@ -30 +33 @@
 //      put in seperate private segments)
 #ifdef DEBUGHEAP
-void NEAR *malloc(unsigned size, const char *filename, int lineno);
+void NEAR *malloc(ULONG size, const char *filename, int lineno);
 void       free(void *NEAR ptr, const char *filename, int lineno);
 void NEAR *realloc(void *NEAR ptr, unsigned newsize, const char *filename, int lineno);
 #else
-void NEAR *malloc(unsigned);
+void NEAR *malloc(ULONG size);
 void       free(void NEAR *);
 void NEAR *realloc(void NEAR *, unsigned);
@@ -49 +52 @@
 
 // Specialized routines
-unsigned HeapInit(unsigned);        // initializes the heap manager
+ULONG HeapInit(ULONG size);        // initializes the heap manager
 void dumpheap(void);
 

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

@@ -27 +27 @@
 
 #include <string.h>
+#include <dbgos2.h>
+
+#define COMM_DEBUG
 
 #define CR 0x0d
@@ -34 +37 @@
 #define SIGNIFICANT_FIELD       0x0007
 
-BOOL  fLineTerminate=TRUE;
-int   DebugLevel = 1;
-
-extern int wrOffset;
-extern char *szprintBuf;
-extern int max_buf_size;
+int DebugLevel;
 
 char hextab[]="0123456789ABCDEF";
@@ -144 +142 @@
 }
 
-#ifdef DEBUG
-#define COMM_DEBUG
-//------------------------- StringOut --------------------------//
-
-#define VMDHA_FIXED             0x0002
-
-extern APIRET VMAlloc(ULONG size, ULONG flags, char NEAR* *pAddr);
-
 /**
  * Finds the length of a string up to cchMax.
@@ -218 +208 @@
 #endif
 
+//------------------------- StringOut --------------------------//
 void StringOut(char *DbgStr)
 {
-   int len;
+        int len;
+
+        len= _strnlen( DbgStr, 1024 );
+
 #ifdef COMM_DEBUG
-   int i;
-#endif /* DEBUG */
-
-   len= _strnlen( DbgStr, 1024 );
-/*
-   while (*DbgStr)
-      CharOut(*DbgStr++);
-      */
-#ifdef COMM_DEBUG
-   if (MAGIC_COMM_PORT)   //PS+++ If have comport - out to it
-   {
-       for( i= 0; i < len; i++ )
-           CharOut( DbgStr[i] );
-
-       if (fLineTerminate)
-       {
-           CharOut(CR);                              // append carriage return,
-           CharOut(LF);                              // linefeed
-       }
-   }
+        if (MAGIC_COMM_PORT) {
+                int i;
+
+                for( i= 0; i < len; i++ ) CharOut( DbgStr[i] );
+
+                CharOut(CR);                              // append carriage return,
+                CharOut(LF);                              // linefeed
+        }
 #endif
-   if( szprintBuf == 0 )
-   {
-      VMAlloc( max_buf_size, VMDHA_FIXED, &szprintBuf );
-      if( szprintBuf )
-         memset( szprintBuf, 0, max_buf_size );
-      wrOffset= 0;
-   }
-   if( szprintBuf )
-   {
-       if( (len + wrOffset) > max_buf_size )
-       {
-          int cntr;
-          cntr= max_buf_size - wrOffset;
-          memcpy( szprintBuf +  wrOffset, DbgStr, cntr );
-          DbgStr+= cntr;
-          len= len - cntr;
-          wrOffset= 0;
-       }
-       if( len )
-       {
-          memcpy( szprintBuf + wrOffset, DbgStr, len );
-          wrOffset= wrOffset + len;
-          if( wrOffset >= max_buf_size )
-              wrOffset= 0;
-       }
-       if (fLineTerminate)
-       {
-//           if( (wrOffset+1) >= max_buf_size )
-//               wrOffset= 0;
-           szprintBuf[wrOffset]= CR;
-           if( ++wrOffset >= max_buf_size )
-               wrOffset= 0;
-           szprintBuf[wrOffset]= LF;
-           if( ++wrOffset >= max_buf_size )
-               wrOffset= 0;
-       }
-   }
-}
-#endif
-
-#ifdef  DEBUG
+
+        if (szprintBuf == 0) return;
+
+        if( (len + wrOffset) > DBG_MAX_BUF_SIZE ) {
+                int cntr;
+                cntr = DBG_MAX_BUF_SIZE - wrOffset;
+                memcpy( szprintBuf +  wrOffset, DbgStr, cntr );
+                DbgStr += cntr;
+                len = len - cntr;
+                wrOffset= 0;
+        }
+
+        if ( len ) {
+                memcpy( szprintBuf + wrOffset, DbgStr, len );
+                wrOffset= wrOffset + len;
+                if( wrOffset >= DBG_MAX_BUF_SIZE ) wrOffset= 0;
+        }
+
+        if ( (wrOffset+1) >= DBG_MAX_BUF_SIZE ) wrOffset= 0;
+        szprintBuf[wrOffset]= CR;
+        if ( ++wrOffset >= DBG_MAX_BUF_SIZE ) wrOffset= 0;
+        szprintBuf[wrOffset]= LF;
+        if ( ++wrOffset >= DBG_MAX_BUF_SIZE ) wrOffset= 0;
+}
+
 char BuildString[1024];
-#endif          // DEBUG
-
+
+#if 0
 //------------------------- PrintfOut -
 void _cdecl DPD(int level, char *DbgStr, ...)
 {
-#ifdef DEBUG
    char *BuildPtr=BuildString;
    char *pStr=(char *) DbgStr;
@@ -398 +363 @@
    *BuildPtr=0;                                 // cauterize the string
    StringOut((char *) BuildString);
-#endif                            //DEBUG
-}
-
+}
+#endif
 
 void _cdecl DPE(char *DbgStr, ...)
 {
-#ifdef DEBUG
    char *BuildPtr=BuildString;
    char *pStr = (char *) DbgStr;
@@ -517 +480 @@
    *BuildPtr=0;                                 // cauterize the string
    StringOut((char *) BuildString);
-#endif                            //DEBUG
 }
 

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

@@ -174 +174 @@
     IRQ_SLOT    *pSlot;
 
-#ifdef DEBUG
-//    dprintf(("enter int proc %d %d",ulSlotNo, *pulIrq));
-#endif
+        //dprintf(("enter int proc %d %d",ulSlotNo, *pulIrq));
 
     if(fSuspended)
@@ -183 +181 @@
         //Don't pass it to the linux handler as the device doesn't respond as expected
         //when suspended
-#ifdef DEBUG
         dprintf(("Slot %d IRQ %d suspended",ulSlotNo, *pulIrq));
-#endif
         return FALSE;
     }
@@ -229 +225 @@
                     //ok, this interrupt was intended for us; notify the 16 bits MMPM/2 driver
                     OSS32_ProcessIRQ();
-#ifdef DEBUG
-//                    dprintf(("exit(1) int proc %d %d",ulSlotNo, *pulIrq));
-#endif
+                                        //dprintf(("exit(1) int proc %d %d",ulSlotNo, *pulIrq));
                     eoiIrq[pSlot->irqNo] = 0;
                     return TRUE;
@@ -238 +232 @@
         }
     }
-#ifdef DEBUG
-//                    dprintf(("exit(0) int proc %d %d",ulSlotNo, *pulIrq));
-#endif
+        //dprintf(("exit(0) int proc %d %d",ulSlotNo, *pulIrq));
 
     return FALSE;

GPL/branches/uniaud32-2.1.x/lib32/malloc.cpp

@@ -38 +38 @@
 #endif
 
-#define  DEFAULT_HEAP   256*1024
-#define  HEAP_SIZE      256*1024
-
 #define  SIGNATURE      0xBEEFDEAD      // "DeadBeef" when view in hex in word order.
 
@@ -46 +43 @@
 typedef struct _MEMBLOCK {
     ULONG                  ulSignature;
-    ULONG                  uSize;
+    ULONG                  ulSize;
     struct _MEMBLOCK NEAR *pmbNext;
 #ifdef DEBUGHEAP
@@ -69 +66 @@
 LINEAR     acHeap   = NULL;
 
+ULONG ulnAlloc = 0;           // Current number of allocated blocks.
+ULONG ulcAlloc = 0;           // Total memory in allocated blocks incl. headers.
+ULONG ulnAllocCalls = 0;      // Cumulative total, number of malloc() calls.
+ULONG ulnFree  = 0;           // Current number of free blocks.
+ULONG ulcFree  = 0;           // Total memory in free blocks incl. headers.
+ULONG ulnFreeCalls  = 0;      // Cumulative total, number of free() calls.
+ULONG ulnCompact = 0;         // Num of times we've joined two adjacent free
+                             // blocks into a single larger block.
+ULONG ulcTotalHeap = HEAP_SIZE;
+
+
 #pragma off (unreferenced)
 
@@ -77 +85 @@
 void dumpheap(void)
 {
-    int i;
+    SHORT sI;
     PMEMBLOCK pmb;
-    unsigned u=0;
-
+    ULONG ulSize;
+
+        ulSize = 0;
     pmb=pmbUsed;
-    dprintf(("HEAP: Heap Dump - Used blocks\n"));
-    for (i=0; i<10; i++) {
-        dprintf(("  pmb=%p, length=%ui\n",(void __far *) pmb, pmb->uSize));
-        u+=pmb->uSize;
+        dprintf(("HEAP:Heap Dump acHeap=%lx Used=%p Free=%p\n", (void __far *)acHeap, pmbUsed, pmbFree));
+    dprintf(("  Used blocks\n"));
+    for (sI=0; sI<10; sI++) {
+        dprintf(("  pmb=%p, length=%lx\n",(void __far *) pmb, pmb->ulSize));
+        ulSize+=pmb->ulSize;
         pmb=pmb->pmbNext;
         if (!pmb) break;
     }
-    dprintf(("  Total used = %ui\n",u));
-
-    u=0;
+    dprintf(("  Total used = %lx\n", ulSize));
+
+    ulSize=0;
     pmb=pmbFree;
-    dprintf(("HEAP: Heap Dump - Free blocks\n"));
-    for (i=0; i<50; i++) {
-        dprintf(("  pmb=%p, length=%ui\n",(void __far *) pmb, pmb->uSize));
-        u+=pmb->uSize;
+    dprintf(("  Free blocks\n"));
+    for (sI=0; sI<50; sI++) {
+        dprintf(("  pmb=%p, length=%lx\n",(void __far *) pmb, pmb->ulSize));
+        ulSize+=pmb->ulSize;
         pmb=pmb->pmbNext;
         if (!pmb) break;
     }
-    dprintf(("  Total free = %ui\n",u));
-}
-//*****************************************************************************
-//*****************************************************************************
-
-ULONG fMemoryDoc = 0;
-ULONG nAlloc = 0;           // Current number of allocated blocks.
-ULONG cAlloc = 0;           // Total memory in allocated blocks incl. headers.
-ULONG nAllocCalls = 0;      // Cumulative total, number of malloc() calls.
-ULONG nFree  = 0;           // Current number of free blocks.
-ULONG cFree  = 0;           // Total memory in free blocks incl. headers.
-ULONG nFreeCalls  = 0;      // Cumulative total, number of free() calls.
-ULONG nCompact = 0;         // Num of times we've joined two adjacent free
-                             // blocks into a single larger block.
-ULONG cTotalHeap = HEAP_SIZE;
-
-//*****************************************************************************
-//*****************************************************************************
-BOOL SignatureCheck ( PMEMBLOCK p, PSZ idText )
-{
-    int bGoodPointer;
+    dprintf(("  Total free = %lx\n", ulSize));
+}
+//*****************************************************************************
+//*****************************************************************************
+
+//*****************************************************************************
+//*****************************************************************************
+SHORT SignatureCheck ( PMEMBLOCK p, PSZ idText )
+{
+    short sGoodPointer;
 
     // Set bGoodPointer to indicate whether or not 'p' points within heap.
-    bGoodPointer = ((LINEAR)p >= (acHeap))
-                    && ((LINEAR)p <= (( acHeap) + HEAP_SIZE)) ;
-                              //### heap might have less than HEAP_SIZE bytes
+    sGoodPointer = ((LINEAR)p >= (acHeap))
+                                        && ((LINEAR)p <= (( acHeap) + HEAP_SIZE)) ;
+                                        //### heap might have less than HEAP_SIZE bytes
 
     // Check for correct signature.
-    if (bGoodPointer)
-        bGoodPointer = (p->ulSignature == SIGNATURE) && p->uSize < HEAP_SIZE;
-
-    if (! bGoodPointer)
-    {
-//      ddprintf( "Heap pointer out of range, or signature exception: %p %s\n", p, idText );
+    if (sGoodPointer) sGoodPointer = (p->ulSignature == SIGNATURE) && p->ulSize < HEAP_SIZE;
+
+    if (!sGoodPointer) {
+                dprintf(("SignatureCheck: Bad pointer %p %s\n", p, idText));
         DebugInt3();
     }
-    return bGoodPointer;
-}
-//*****************************************************************************
-//*****************************************************************************
-#ifdef DEBUG
+    return sGoodPointer;
+}
+//*****************************************************************************
+//*****************************************************************************
 void HeapCheck ( PSZ idText )
 {
     PMEMBLOCK p;
-    for ( nAlloc = 0, cAlloc = 0, p = pmbUsed; p; p = p->pmbNext ) {
-        ++nAlloc;
+    for ( ulnAlloc = 0, ulcAlloc = 0, p = pmbUsed; p; p = p->pmbNext ) {
+        ++ulnAlloc;
+        ulcAlloc += p->ulSize + HDR_SIZE;
         SignatureCheck( p,(PSZ) "HeapCheck() Used list" );
-        cAlloc += p->uSize + HDR_SIZE;
-    }
-    for ( nFree = 0, cFree = 0, p = pmbFree; p; p = p->pmbNext ) {
-        ++nFree;
+                if (p == p->pmbNext) {
+                        dprintf(("HeapCheck: used %p points to itself\n", p));
+                        DebugInt3();
+                }
+    }
+    for ( ulnFree = 0, ulcFree = 0, p = pmbFree; p; p = p->pmbNext ) {
+        ++ulnFree;
+        ulcFree += p->ulSize + HDR_SIZE;
         SignatureCheck( p,(PSZ) "HeapCheck() Free list" );
-        cFree += p->uSize + HDR_SIZE;
-    }
-    if (fMemoryDoc & 1) {
-        if (cAlloc + cFree != cTotalHeap) {
-//         ddprintf( "Heap Alloc + Free != Total\n" );
-//       dumpheap();
-            DebugInt3();
-        }
-    }
-}
-#else
-#define HeapCheck(a)
-#endif
-
-//*****************************************************************************
-//*****************************************************************************
-
-
+                if (p == p->pmbNext) {
+                        dprintf(("HeapCheck: free %p points to itself\n", p));
+                        DebugInt3();
+                }
+    }
+        if (ulcAlloc + ulcFree != ulcTotalHeap) {
+                dprintf(("HeapCheck: Alloc+Free != Total\n"));
+                //dumpheap();
+                DebugInt3();
+        }
+}
+
+//*****************************************************************************
+//*****************************************************************************
 
 // Threshold for creating a new free block.
 #define  MIN_Leftover  (HDR_SIZE + MIN_FragSize)
 
-/* make_new_free()
+/*
    Formats the back part of an existing free MEMBLOCK as a new, smaller
    "Free" MEMBLOCK.  Doesn't update Global vbls (caller responsibility).
@@ -227 +224 @@
   We split the block into an allocated part to satisfy the allocation request,
   and a free block which can be allocated in a subsequent request.
-*/
-
-PMEMBLOCK make_new_free(PMEMBLOCK pmbOldFree, unsigned uRequest)
-{
-    PMEMBLOCK pmbNewFree;     // If we create a new free block, it goes here.
-
-    // Which of the two cases (as described in function header) have we got?
-    // We know we're big enough to satisfy request, is there enough leftover
-    // for a new free block?
-
-    if ((uRequest + MIN_Leftover) > pmbOldFree->uSize) {
-        // Not enough leftover, allocate the entire free block.  Don't
-        // change pmbOldFree->uSize.
-        pmbNewFree = 0;
-    }
-    else {
-        // We've got enough leftover to make a new free block.
-        pmbNewFree = (PMEMBLOCK) ((char *) pmbOldFree + HDR_SIZE + uRequest );
-        pmbNewFree->ulSignature = SIGNATURE;
-        pmbNewFree->uSize = pmbOldFree->uSize - (uRequest + HDR_SIZE);
-        pmbNewFree->pmbNext = pmbOldFree->pmbNext;
-
-        // Update the size of the free block that was passed in.
-        pmbOldFree->uSize -= (pmbNewFree->uSize + HDR_SIZE);
-    }
-
-    return pmbNewFree;
-}
-
-
-/**@internal _msize
- */
-unsigned _msize(void NEAR *pvBlock)
-{
-    PMEMBLOCK pmb;
-
-    if (!pvBlock)
-        return 0;
-
-    pmb = (PMEMBLOCK) ((char NEAR *) pvBlock - HDR_SIZE);
-    
-    return pmb->uSize;
-}
-
-
-/**@internal pmbAllocateBlock
+
+ @internal pmbAllocateBlock
  *  Update all data structures for allocation of one memory block.  It's
  *  assumed, on entry, that the block is large enough for the requested
@@ -286 +239 @@
  *  suitable for return to malloc() caller.
  */
-void NEAR *npvAllocateBlock( PMEMBLOCK pmb, ULONG uRequest, PMEMBLOCK pmbPrev )
-{
+void NEAR *npvAllocateBlock( PMEMBLOCK pmb, ULONG ulRequest, PMEMBLOCK pmbPrev )
+{
+
     //pmb points to the selected block.
     //pmbPrev points to the block prior to the selected block, NULL if pmbFree.
@@ -294 +248 @@
 
     // Split this block into an allocated + free part if it's big enough.
-    pmbNewFree = make_new_free( pmb, uRequest );
+        pmbNewFree = 0;
+        if (pmb->ulSize >= (ulRequest + MIN_Leftover)) {
+                // We've got enough leftover to make a new free block.
+
+                /* create the new free block */
+                pmbNewFree = (PMEMBLOCK) ((char __near *) pmb + HDR_SIZE + ulRequest );
+                pmbNewFree->ulSignature = SIGNATURE;
+                pmbNewFree->ulSize = pmb->ulSize - (ulRequest + HDR_SIZE);
+                pmbNewFree->pmbNext = pmb->pmbNext;
+
+                // Update the size of the original free block that was passed in.
+                pmb->ulSize -= (pmbNewFree->ulSize + HDR_SIZE);
+        }
 
     // Update global memory counter.
-    uMemFree -= (pmb->uSize + HDR_SIZE);
+    uMemFree -= (pmb->ulSize + HDR_SIZE);
 
     // Add this block into the front of the Allocated list.
@@ -305 +271 @@
 
     // Remove the new allocation from the Free list.
-    if (pmbNewFree) {                // If we split off a new free block
-        pmbNewFree->pmbNext = pmbOldNext;
-        if (pmbPrev)                  // If we're not at head of Free list
-            pmbPrev->pmbNext = pmbNewFree;
-        else
-            pmbFree = pmbNewFree;
-    }
-    else {                           // We allocated the entire free block.
-        if (pmbPrev)                  // If we're not at head of Free list
-            pmbPrev->pmbNext = pmbOldNext;
-        else
-            if (pmbOldNext)
-                pmbFree = pmbOldNext;
+    if (pmbNewFree) { // If we split off a new free block
+        pmbNewFree->pmbNext = pmbOldNext; // If we're not at head of Free list
+        if (pmbPrev) pmbPrev->pmbNext = pmbNewFree;
+        else pmbFree = pmbNewFree;
+    } else { // We allocated the entire free block.
+        if (pmbPrev) pmbPrev->pmbNext = pmbOldNext; // If we're not at head of Free list
+        else pmbFree = pmbOldNext;
     }
 
@@ -336 +296 @@
 
 #ifdef DEBUGHEAP
-void NEAR *malloc(unsigned uSize, const char *filename, int lineno)
-#else
-void NEAR *malloc( unsigned uSize )
-#endif
-{
-    ULONG uRequest;                    // Request size after alignment.
+void NEAR *malloc(ULONG ulSize, const char *filename, int lineno)
+#else
+void NEAR *malloc( ULONG ulSize )
+#endif
+{
+    ULONG ulRequest;                    // Request size after alignment.
     PMEMBLOCK pmb, pmbPrev;             // Use to walk free lists.
-    void NEAR *npvReturn = 0;         // Return value.
-    ULONG cpuflags;
-
-#ifdef DEBUG
-//    dprintf(("malloc(). size: %d",uSize));
-#endif
-    if(acHeap == NULL) {
-        if (!HeapInit(HEAP_SIZE))
-        {
-#ifdef DEBUG
-            dprintf(("malloc(): error heap initing"));
-#endif
-            return 0;
-        }
-    }
-#ifdef DEBUG
-//    dprintf(("malloc(): heap inited"));
-#endif
-    if (!uSize || uSize > HEAP_SIZE) {
+    void NEAR *npvReturn;         // Return value.
+    ULONG ulCpuFlags;
+
+    //dprintf(("malloc(). size: %d", ulSize));
+    if(acHeap == NULL) return 0;
+    if (!ulSize || ulSize > HEAP_SIZE) {
         DebugInt3();
         return 0;
     }
 
-    cpuflags = DevPushfCli();
-    ++nAllocCalls;                      // Diagnostics.
+    ulCpuFlags = DevPushfCli();
+        npvReturn = 0;
+    ++ulnAllocCalls;                      // Diagnostics.
     HeapCheck((PSZ) "malloc() entry" );
-#ifdef DEBUG
-//    dprintf(("malloc(): heap checked. pmbFree %x",pmbFree));
-#endif
-
-    uRequest = (uSize + 3) & -4;        // Force DWORD alignment.
-
-    if (pmbFree->uSize >= uRequest)
-        npvReturn = npvAllocateBlock( pmbFree, uRequest, NULL );
-    else {
-        pmbPrev = pmbFree;
-        for ( pmb=pmbFree->pmbNext; pmb; pmbPrev=pmb, pmb=pmb->pmbNext)
-        {
-#ifdef DEBUG
-//    dprintf(("malloc(): for. pmb %x",pmb));
-#endif
-            if (pmb->uSize >= uRequest) {
-                npvReturn = npvAllocateBlock( pmb, uRequest, pmbPrev );
-                break;
-            }
-        }
-    }
+
+    ulRequest = (ulSize + 3) & -4;        // Force DWORD alignment.
+
+        for (pmbPrev=NULL, pmb=pmbFree; pmb; pmbPrev=pmb, pmb=pmb->pmbNext) {
+                if (pmb->ulSize >= ulRequest) {
+                        npvReturn = npvAllocateBlock(pmb, ulRequest, pmbPrev);
+                        break;
+                }
+        }
 
     if (npvReturn) {
@@ -399 +335 @@
 #endif
         SignatureCheck( (PMEMBLOCK) (((PUCHAR) npvReturn) - HDR_SIZE), (PSZ) "malloc() exit, allocated block" );
-    }
-    else {
-#ifdef DEBUG
-    dprintf(("malloc(): out of memory"));
-#endif
-        // Out of Memory !!!
+    } else {
+                dprintf(("malloc(): out of memory"));
         DebugInt3();
     }
 
     HeapCheck((PSZ) "malloc() exit" );
-#ifdef DEBUG
-//    dprintf(("malloc(): malloc exit"));
-#endif
-
-    DevPopf(cpuflags);
+    DevPopf(ulCpuFlags);
     return npvReturn;
 }
@@ -448 +376 @@
 Also, the newly freed block can only be adjacent to at most two other
 blocks.  Therefore, the operation of combining two adjacent free blocks can
-only happen at most twice.  The variable nFreed counts the number of times
-two blocks are combined.  The function exits if nFreed reaches two.  nFreed
+only happen at most twice.  The variable ulnFreed counts the number of times
+two blocks are combined.  The function exits if ulnFreed reaches two.  ulnFreed
 is initially 0.
 
@@ -459 +387 @@
 */
 
-#define after(pmb) ((PMEMBLOCK) ((char *) pmb + pmb->uSize + HDR_SIZE))
+#define after(pmb) ((PMEMBLOCK) ((char *) pmb + pmb->ulSize + HDR_SIZE))
 
 void remove(PMEMBLOCK pmb)
@@ -470 +398 @@
     }
 
-    for (pmbPrev=pmbFree; pmbPrev; pmbPrev=pmbPrev->pmbNext)
+    for (pmbPrev=pmbFree; pmbPrev; pmbPrev=pmbPrev->pmbNext) {
         if (pmbPrev->pmbNext == pmb) {
             pmbPrev->pmbNext = pmb->pmbNext;
             return;
         }
+        }
 }
 //*****************************************************************************
@@ -481 +410 @@
 {
     PMEMBLOCK pmb;
-    int iFreed = 0;
-
+    SHORT sFreed;
+
+        sFreed = 0;
     for (pmb=pmbFree->pmbNext; pmb; pmb=pmb->pmbNext) {
-        if (pmb == pmb->pmbNext) {
-//         ddprintf("HEAP: heap loop, %p points to itself\n", (void __far *) pmb);
-            DebugInt3();
+        if (after(pmb)  == pmbFree) {
+                        // ddprintf("HEAP: compact found pointer %p (size=%ui) before pmbFree %p\n", (void __far *) pmb, pmb->uSize, (void __far *) pmbFree);
+            pmb->ulSize += HDR_SIZE + pmbFree->ulSize;
+            remove(pmbFree);
+            if (++sFreed == 2) break;
+        } else if (after(pmbFree) == pmb) {
+                        // ddprintf("HEAP: compact found pointer %p (size=%ui) after pmbFree %p\n", (void __far *) pmb, pmb->uSize, (void __far *) pmbFree);
+            pmbFree->ulSize += HDR_SIZE + pmb->ulSize;
+            remove(pmb);
+            if (++sFreed == 2) break;
         }
-
-        if (after(pmb)  == pmbFree) {
-// ddprintf("HEAP: compact found pointer %p (size=%ui) before pmbFree %p\n", (void __far *) pmb, pmb->uSize, (void __far *) pmbFree);
-            pmb->uSize += HDR_SIZE + pmbFree->uSize;
-            remove(pmbFree);
-            if (++iFreed == 2) goto exit;
-        } 
-        else 
-        if (after(pmbFree) == pmb) {
-// ddprintf("HEAP: compact found pointer %p (size=%ui) after pmbFree %p\n", (void __far *) pmb, pmb->uSize, (void __far *) pmbFree);
-            pmbFree->uSize += HDR_SIZE + pmb->uSize;
-            remove(pmb);
-            if (++iFreed == 2) goto exit;
-        }
-    }
-
-exit:
-    nCompact += iFreed;
+    }
+
+    ulnCompact += sFreed;
 }
 //*****************************************************************************
@@ -516 +438 @@
 {
     PMEMBLOCK pmb,pmbPrev,pmbBlock;
-    int fSentinel;
-    ULONG cpuflags;
+    ULONG ulCpuFlags;
 
     if(acHeap == NULL) {
@@ -524 +445 @@
     }
 
-    ++nFreeCalls;
+    ++ulnFreeCalls;
     if (!pvBlock) return;     // support freeing of NULL
 
-    cpuflags = DevPushfCli();
+    ulCpuFlags = DevPushfCli();
     pmbBlock=(PMEMBLOCK) ((char NEAR *) pvBlock - HDR_SIZE);
 
@@ -533 +454 @@
     HeapCheck((PSZ) "free() entry" );
 
-    uMemFree += pmbBlock->uSize + HDR_SIZE;
-
-    if (pmbBlock == pmbUsed) {       // are we freeing the first block?
-        pmbUsed = pmbUsed->pmbNext;   // the 2nd block is now the 1st
-        pmbBlock->pmbNext = pmbFree;  // this block is now free, so it points to 1st free block
-        pmbFree = pmbBlock;           // this is now the 1st free block
-        compact();
-        goto exit;
-    }
-
-    pmbPrev=pmbUsed;
-    fSentinel = FALSE;
-    for (pmb=pmbUsed->pmbNext; pmb; pmbPrev=pmb, pmb=pmb->pmbNext) {
-        if (pmb == pmbBlock) {
-            if (fSentinel) {
-                dprintf(("HEAP: free sentinel triggered, pmb=%p\n", (void __far *) pmb));
-                DebugInt3();
-            }
-            pmbPrev->pmbNext = pmb->pmbNext;   // delete this block from the chain
-            pmbBlock->pmbNext = pmbFree;
-            pmbFree = pmbBlock;
-            compact();
-            fSentinel = TRUE;
-        }
-    }
-
-exit: //--- Check things are still intact.
+    uMemFree += pmbBlock->ulSize + HDR_SIZE;
+
+        /* find the block on the used chain */
+        for (pmbPrev=NULL, pmb=pmbUsed; pmb; pmbPrev=pmb, pmb=pmb->pmbNext) {
+                if (pmb == pmbBlock) { /* found the block */
+                        if (pmbPrev) { /* it is in the middle of the chain */
+                                pmbPrev->pmbNext = pmb->pmbNext; /* delete this block from the chain */
+                        } else { /* it is the first block on the used list */
+                                pmbUsed = pmbUsed->pmbNext;     // the 2nd block is now the head
+                        }
+                        pmbBlock->pmbNext = pmbFree; /* This block is now free, so it points to the first free block */
+                        pmbFree = pmbBlock; /* This is now the first free block */
+                        break;
+                }
+        }
+        if (pmb == 0) {
+                dprintf(("free: block not found %x\n", pmb));
+                DebugInt3();
+        }
+        compact();
+
     HeapCheck((PSZ) "free() exit" );
-    DevPopf(cpuflags);
+    DevPopf(ulCpuFlags);
 }
 //*****************************************************************************
@@ -571 +486 @@
 //*****************************************************************************
 //*****************************************************************************
-#ifdef DEBUGHEAP
-void NEAR *realloc(void NEAR *pvBlock, unsigned usLength, const char *filename, int lineno)
-#else
-void NEAR *realloc(void NEAR *pvBlock, unsigned usLength)
+/**@internal _msize
+ */
+unsigned _msize(void NEAR *pvBlock)
+{
+    PMEMBLOCK pmb;
+
+    if (!pvBlock)
+        return 0;
+
+    pmb = (PMEMBLOCK) ((char NEAR *) pvBlock - HDR_SIZE);
+
+    return pmb->ulSize;
+}
+
+
+#ifdef DEBUGHEAP
+void NEAR *realloc(void NEAR *pvBlock, ULONG ulLength, const char *filename, int lineno)
+#else
+void NEAR *realloc(void NEAR *pvBlock, ULONG ulLength)
 #endif
 {
@@ -581 +511 @@
     if (!pvBlock)                 // if ptr is null, alloc block
 #ifdef DEBUGHEAP
-        return malloc(usLength, filename, lineno);
-#else
-        return malloc(usLength);
-#endif
-
-    if (!usLength) {              // if length is 0, free block
+        return malloc(ulLength, filename, lineno);
+#else
+        return malloc(ulLength);
+#endif
+
+    if (!ulLength) {              // if length is 0, free block
 #ifdef DEBUGHEAP
         free(pvBlock, filename, lineno);
@@ -596 +526 @@
 
 #ifdef DEBUGHEAP
-    pv = malloc(usLength, filename, lineno);          // attempt to allocate the new block
-#else
-    pv = malloc(usLength);          // attempt to allocate the new block
+    pv = malloc(ulLength, filename, lineno);          // attempt to allocate the new block
+#else
+    pv = malloc(ulLength);          // attempt to allocate the new block
 #endif
     if (!pv)                      // can't do it?
         return 0;                  // just fail.  Version 2 will try harder
-    
-    memcpy(pv, pvBlock, min( _msize(pvBlock), usLength));
+
+    memcpy(pv, pvBlock, min( _msize(pvBlock), ulLength));
 
 #ifdef DEBUGHEAP
@@ -614 +544 @@
 //*****************************************************************************
 //*****************************************************************************
-BOOL IsHeapAddr(ULONG addr) 
+BOOL IsHeapAddr(ULONG addr)
 {
     int bGoodPointer;
@@ -626 +556 @@
 extern "C" APIRET VMAlloc(ULONG size, ULONG flags, LINEAR *pAddr) ;
 //*****************************************************************************
-unsigned HeapInit(unsigned uSize)
+ULONG HeapInit(ULONG ulSize)
 {
     LINEAR addr;
     SHORT sel;
 
-    if (!uSize)
-        uSize = DEFAULT_HEAP;
-
-    if (uSize > HEAP_SIZE)
-        uSize = HEAP_SIZE;
-
-    if(VMAlloc(uSize, VMDHA_FIXED, &addr)) {
+    if (!ulSize) ulSize = DEFAULT_HEAP;
+
+    if (ulSize > HEAP_SIZE) ulSize = HEAP_SIZE;
+
+    if(VMAlloc(ulSize, VMDHA_FIXED, &addr)) {
             DebugInt3();
             return 0;
     }
     acHeap = addr;
-#ifdef DEBUG
-//    dprintf(("HeapInit(): addr: %x", acHeap));
-#endif
+        //dprintf(("HeapInit(): addr: %x", acHeap));
 
     pmbFree = (PMEMBLOCK) acHeap;
-    pmbFree->uSize = uSize - HDR_SIZE;
+    pmbFree->ulSize = ulSize - HDR_SIZE;
     pmbFree->ulSignature = SIGNATURE;
     pmbFree->pmbNext = 0;
-    uMemFree = pmbFree->uSize;
-    return pmbFree->uSize;
-}
-//*****************************************************************************
-//*****************************************************************************
+    uMemFree = pmbFree->ulSize;
+    return pmbFree->ulSize;
+}
+//*****************************************************************************
+//*****************************************************************************

GPL/branches/uniaud32-2.1.x/lib32/memory.cpp

@@ -197 +197 @@
         *pAddr = (LINEAR)addr;
         if (flags & VMDHA_USEHIGHMEM)
-            dprintf((("allocated %X in HIGH memory\n"), size));
-        else dprintf((("allocated %X in LOW memory\n"), size));
-    }
-    if ((rc == 87) &&
-        (flags & VMDHA_USEHIGHMEM))
+            dprintf1((("allocated %X in HIGH memory\n"), size));
+        else dprintf1((("allocated %X in LOW memory\n"), size));
+    }
+    if ((rc == 87) && (flags & VMDHA_USEHIGHMEM))
     {
         // EARLYMEMINIT workaround
@@ -280 +279 @@
         //only done to save size of memory block
         AddBaseAddress(addr, addr, size);
-#ifdef DEBUG
         dprintf(("get_free_dma_pages %d -> %x (phys %x)", size, (ULONG)addr, virt_to_phys((void *)addr)));
-#endif
         ulget_free_pagesMemUsed += size;
-#ifdef DEBUG
         dprintf(("get_free_dma_pages: total alloc size %d", ulget_free_pagesMemUsed));
-#endif
     }
 
@@ -331 +326 @@
                 return 0;
         }
-////    dprintf(("__get_free_pages %d returned %x", order*PAGE_SIZE, addr));
+        //dprintf(("__get_free_pages %d returned %x", order*PAGE_SIZE, addr));
     if(gfp_mask & (GFP_DMA|GFP_DMAHIGHMEM))
     {//must be aligned at 64kb boundary
@@ -359 +354 @@
     }
     if(addr) {
-#ifdef DEBUG
         dprintf(("get_free_pages %d (%d) -> %x (phys %x)", allocsize, size, (ULONG)addr, virt_to_phys((void *)addr)));
-#endif
         ulget_free_pagesMemUsed += allocsize;
-#ifdef DEBUG
         dprintf(("get_free_pages: total alloc size %d", ulget_free_pagesMemUsed));
-#endif
     }
     return (void *)addr;
@@ -382 +373 @@
     }
     else {
-#ifdef DEBUG
         dprintf(("free_pages %x size %d", (ULONG)addr, size));
-#endif
         ulget_free_pagesMemUsed -= size;
-#ifdef DEBUG
         dprintf(("free_pages: total alloc size %d", ulget_free_pagesMemUsed));
-#endif
-    }
-////    dprintf(("free_pages %x", addr));
+    }
+        //dprintf(("free_pages %x", addr));
         return 0;
 }
@@ -409 +396 @@
         }
     if(addr) {
-#ifdef DEBUG
         //dprintf(("vmalloc %d -> %x (phys %x)", size, addr, virt_to_phys((void *)addr)));
-#endif
         //only done to save size of memory block
         AddBaseAddress(addr, addr, size);
         ulget_free_pagesMemUsed += size;
-#ifdef DEBUG
         //dprintf(("vmalloc: total alloc size %d", ulget_free_pagesMemUsed));
-#endif
     }
     return (void *)addr;
@@ -434 +417 @@
     }
     else {
-#ifdef DEBUG
         //dprintf(("vfree %x size %d", (ULONG)ptr, size));
-#endif
         ulget_free_pagesMemUsed -= size;
-#ifdef DEBUG
         //dprintf(("vfree: total alloc size %d", ulget_free_pagesMemUsed));
-#endif
     }
 }
@@ -474 +453 @@
 
     //round to next page boundary
-//    size = size + PAGE_SIZE - 1;
-//    size &= 0xFFFFF000;
+        //size = size + PAGE_SIZE - 1;
+        //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
@@ -616 +595 @@
         return 0;
     }
-////    dprintf(("kmalloc %d returned %x", size, addr));
+        //dprintf(("kmalloc %d returned %x", size, addr));
     return addr;
 }
@@ -634 +613 @@
         return;
     }
-////  dprintf(("kfree %x", addr));
+        //dprintf(("kfree %x", addr));
     if(IsHeapAddr(addr)) {
 #ifdef DEBUGHEAP

GPL/branches/uniaud32-2.1.x/lib32/ossidc.cpp

@@ -110 +110 @@
         return OSSERR_INIT_FAILED;
     }
-    dprintf(("\nUniaud version %s\n",UNIAUD_VERSION));
+    rprintf(("\nUniaud version %s\n",UNIAUD_VERSION));
     dprintf(("OSS32_Initialize. Start address: %X", OffsetBeginCS32));
-//    DebugInt3();
+        //DebugInt3();
 
     if(call_module_init(alsa_sound_init) != 0)       return OSSERR_INIT_FAILED;
@@ -286 +286 @@
             FillCaps(i);
         }
-        dprintf(("OSS32_Initialize: SUCCESS. nr. of cards: %d",nrCardsDetected));
+        dprintf(("OSS32_Initialize: SUCCESS. Cards=%d", nrCardsDetected));
         return OSSERR_SUCCESS;
     }
@@ -340 +340 @@
 int OSS32_DebugString(char *buffer, ULONG size)
 {
-    dprintf(("U16: %s",buffer));
+    rprintf(("U16: %s", buffer));
     return size;
 }

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

@@ -696 +696 @@
     //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);
     if (ret)

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

@@ -13 +13 @@
 # ex RC3  GA  FIXPACK2 beta_47
 # Comment out to avoid a fixpack line in bldlevel
-FIXPACK = BETA SVN r499
+FIXPACK = BETA SVN r504
 
 # ALSA BUILD VERSION