MKBYTE(rSlaveControl));
 
        rSlaveControl_Save = rSlaveControl;
-       rSlaveControl.ConfigMode = TRUE;
+       rSlaveControl.ConfigMode = true;
 
        PRINTK_2(TRACE_3780I,
                "3780i::dsp3780i_WriteGenCfg entry rSlaveControl+ConfigMode %x\n",
 
        MKBYTE(rSlaveControl) = InByteDsp(DSP_IsaSlaveControl);
        rSlaveControl_Save = rSlaveControl;
-       rSlaveControl.ConfigMode = TRUE;
+       rSlaveControl.ConfigMode = true;
        OutByteDsp(DSP_IsaSlaveControl, MKBYTE(rSlaveControl));
        OutByteDsp(DSP_ConfigAddress, (unsigned char) uIndex);
        ucValue = InByteDsp(DSP_ConfigData);
                        rUartCfg1.BaseIO = 3;
                        break;
                }
-               rUartCfg2.Enable = TRUE;
+               rUartCfg2.Enable = true;
        }
 
        rHBridgeCfg1.Reserved = rHBridgeCfg2.Reserved = 0;
        rHBridgeCfg1.IrqPulse = pSettings->bDspIrqPulse;
        rHBridgeCfg1.Irq = (unsigned char) pIrqMap[pSettings->usDspIrq];
        rHBridgeCfg1.AccessMode = 1;
-       rHBridgeCfg2.Enable = TRUE;
+       rHBridgeCfg2.Enable = true;
 
 
        rBusmasterCfg2.Reserved = 0;
        * soft-reset active for 10ms.
        */
        rSlaveControl.ClockControl = 0;
-       rSlaveControl.SoftReset = TRUE;
-       rSlaveControl.ConfigMode = FALSE;
+       rSlaveControl.SoftReset = true;
+       rSlaveControl.ConfigMode = false;
        rSlaveControl.Reserved = 0;
 
        PRINTK_4(TRACE_3780I,
        for (i = 0; i < 11; i++)
                udelay(2000);
 
-       rSlaveControl.SoftReset = FALSE;
+       rSlaveControl.SoftReset = false;
        OutWordDsp(DSP_IsaSlaveControl, MKWORD(rSlaveControl));
 
        MKWORD(tval) = InWordDsp(DSP_IsaSlaveControl);
        }
 
 
-       rHBridgeControl.EnableDspInt = FALSE;
-       rHBridgeControl.MemAutoInc = TRUE;
-       rHBridgeControl.IoAutoInc = FALSE;
-       rHBridgeControl.DiagnosticMode = FALSE;
+       rHBridgeControl.EnableDspInt = false;
+       rHBridgeControl.MemAutoInc = true;
+       rHBridgeControl.IoAutoInc = false;
+       rHBridgeControl.DiagnosticMode = false;
 
        PRINTK_3(TRACE_3780I,
                "3780i::dsp3780i_EnableDSP DSP_HBridgeControl %x rHBridgeControl %x\n",
        ChipID = ReadMsaCfg(DSP_ChipID);
 
        PRINTK_2(TRACE_3780I,
-               "3780i::dsp3780I_EnableDSP exiting bRC=TRUE, ChipID %x\n",
+               "3780i::dsp3780I_EnableDSP exiting bRC=true, ChipID %x\n",
                ChipID);
 
        return 0;
        PRINTK_1(TRACE_3780I, "3780i::dsp3780i_DisableDSP entry\n");
 
        rSlaveControl.ClockControl = 0;
-       rSlaveControl.SoftReset = TRUE;
-       rSlaveControl.ConfigMode = FALSE;
+       rSlaveControl.SoftReset = true;
+       rSlaveControl.ConfigMode = false;
        rSlaveControl.Reserved = 0;
        spin_lock_irqsave(&dsp_lock, flags);
        OutWordDsp(DSP_IsaSlaveControl, MKWORD(rSlaveControl));
        PRINTK_2(TRACE_3780I, "3780i::dsp3780i_Reset rHBridgeControl %x\n",
                MKWORD(rHBridgeControl));
 
-       rHBridgeControl.EnableDspInt = FALSE;
+       rHBridgeControl.EnableDspInt = false;
        OutWordDsp(DSP_HBridgeControl, MKWORD(rHBridgeControl));
        spin_unlock_irqrestore(&dsp_lock, flags);
 
        /* Reset the core via the boot domain register */
-       rBootDomain.ResetCore = TRUE;
-       rBootDomain.Halt = TRUE;
-       rBootDomain.NMI = TRUE;
+       rBootDomain.ResetCore = true;
+       rBootDomain.Halt = true;
+       rBootDomain.NMI = true;
        rBootDomain.Reserved = 0;
 
        PRINTK_2(TRACE_3780I, "3780i::dsp3780i_Reset rBootDomain %x\n",
 
 
        /* Transition the core to a running state */
-       rBootDomain.ResetCore = TRUE;
-       rBootDomain.Halt = FALSE;
-       rBootDomain.NMI = TRUE;
+       rBootDomain.ResetCore = true;
+       rBootDomain.Halt = false;
+       rBootDomain.NMI = true;
        rBootDomain.Reserved = 0;
        WriteMsaCfg(DSP_MspBootDomain, MKWORD(rBootDomain));
 
        udelay(5);
 
-       rBootDomain.ResetCore = FALSE;
+       rBootDomain.ResetCore = false;
        WriteMsaCfg(DSP_MspBootDomain, MKWORD(rBootDomain));
        udelay(5);
 
-       rBootDomain.NMI = FALSE;
+       rBootDomain.NMI = false;
        WriteMsaCfg(DSP_MspBootDomain, MKWORD(rBootDomain));
        udelay(5);
 
        /* Enable DSP to PC interrupt */
        spin_lock_irqsave(&dsp_lock, flags);
        MKWORD(rHBridgeControl) = InWordDsp(DSP_HBridgeControl);
-       rHBridgeControl.EnableDspInt = TRUE;
+       rHBridgeControl.EnableDspInt = true;
 
        PRINTK_2(TRACE_3780I, "3780i::dsp3780i_Run rHBridgeControl %x\n",
                MKWORD(rHBridgeControl));
        spin_unlock_irqrestore(&dsp_lock, flags);
 
 
-       PRINTK_1(TRACE_3780I, "3780i::dsp3780i_Run exit bRC=TRUE\n");
+       PRINTK_1(TRACE_3780I, "3780i::dsp3780i_Run exit bRC=true\n");
 
        return 0;
 }
 
 
        PRINTK_1(TRACE_3780I,
-               "3780I::dsp3780I_ReadDStore exit bRC=TRUE\n");
+               "3780I::dsp3780I_ReadDStore exit bRC=true\n");
 
        return 0;
 }
 
 
        PRINTK_1(TRACE_3780I,
-               "3780I::dsp3780I_ReadAndClearDStore exit bRC=TRUE\n");
+               "3780I::dsp3780I_ReadAndClearDStore exit bRC=true\n");
 
        return 0;
 }
 
 
        PRINTK_1(TRACE_3780I,
-               "3780I::dsp3780D_WriteDStore exit bRC=TRUE\n");
+               "3780I::dsp3780D_WriteDStore exit bRC=true\n");
 
        return 0;
 }
        }
 
        PRINTK_1(TRACE_3780I,
-               "3780I::dsp3780I_ReadIStore exit bRC=TRUE\n");
+               "3780I::dsp3780I_ReadIStore exit bRC=true\n");
 
        return 0;
 }
        }
 
        PRINTK_1(TRACE_3780I,
-               "3780I::dsp3780I_WriteIStore exit bRC=TRUE\n");
+               "3780I::dsp3780I_WriteIStore exit bRC=true\n");
 
        return 0;
 }
        */
        spin_lock_irqsave(&dsp_lock, flags);
        MKWORD(rHBridgeControl) = InWordDsp(DSP_HBridgeControl);
-       rHBridgeControl.EnableDspInt = FALSE;
+       rHBridgeControl.EnableDspInt = false;
        OutWordDsp(DSP_HBridgeControl, MKWORD(rHBridgeControl));
 
        *pusIPCSource = InWordDsp(DSP_Interrupt);
 
        OutWordDsp(DSP_Interrupt, (unsigned short) ~(*pusIPCSource));
 
-       rHBridgeControl.EnableDspInt = TRUE;
+       rHBridgeControl.EnableDspInt = true;
        OutWordDsp(DSP_HBridgeControl, MKWORD(rHBridgeControl));
        spin_unlock_irqrestore(&dsp_lock, flags);
 
 
 } DSP_UART_CFG_1;
 
 typedef struct {
-       unsigned char Enable:1; /* RW: Enable I/O and IRQ: 0=FALSE, 1=TRUE */
+       unsigned char Enable:1; /* RW: Enable I/O and IRQ: 0=false, 1=true */
        unsigned char Reserved:7;       /* 0: Reserved */
 } DSP_UART_CFG_2;
 
 } DSP_HBRIDGE_CFG_1;
 
 typedef struct {
-       unsigned char Enable:1; /* RW: enable I/O and IRQ: 0=FALSE, 1=TRUE */
+       unsigned char Enable:1; /* RW: enable I/O and IRQ: 0=false, 1=true */
        unsigned char Reserved:7;       /* 0: Reserved */
 } DSP_HBRIDGE_CFG_2;
 
 
 
 typedef struct {
-       unsigned char GateIOCHRDY:1;    /* RW: Enable IOCHRDY gating: 0=FALSE, 1=TRUE */
+       unsigned char GateIOCHRDY:1;    /* RW: Enable IOCHRDY gating: 0=false, 1=true */
        unsigned char Reserved:7;       /* 0: Reserved */
 } DSP_ISA_PROT_CFG;
 
 typedef struct {
-       unsigned char Enable:1; /* RW: Enable low power suspend/resume 0=FALSE, 1=TRUE */
+       unsigned char Enable:1; /* RW: Enable low power suspend/resume 0=false, 1=true */
        unsigned char Reserved:7;       /* 0: Reserved */
 } DSP_POWER_MGMT_CFG;
 
 
                                pDrvData->IPCs[ipcnum].usIntCount);
 
                        mutex_lock(&mwave_mutex);
-                       pDrvData->IPCs[ipcnum].bIsHere = FALSE;
-                       pDrvData->IPCs[ipcnum].bIsEnabled = TRUE;
+                       pDrvData->IPCs[ipcnum].bIsHere = false;
+                       pDrvData->IPCs[ipcnum].bIsEnabled = true;
                        mutex_unlock(&mwave_mutex);
        
                        PRINTK_2(TRACE_MWAVE,
                                pDrvData->IPCs[ipcnum].usIntCount);
        
                        mutex_lock(&mwave_mutex);
-                       if (pDrvData->IPCs[ipcnum].bIsEnabled == TRUE) {
+                       if (pDrvData->IPCs[ipcnum].bIsEnabled == true) {
                                DECLARE_WAITQUEUE(wait, current);
 
                                PRINTK_2(TRACE_MWAVE,
                                        " ipc %x going to sleep\n",
                                        ipcnum);
                                add_wait_queue(&pDrvData->IPCs[ipcnum].ipc_wait_queue, &wait);
-                               pDrvData->IPCs[ipcnum].bIsHere = TRUE;
+                               pDrvData->IPCs[ipcnum].bIsHere = true;
                                set_current_state(TASK_INTERRUPTIBLE);
                                /* check whether an event was signalled by */
                                /* the interrupt handler while we were gone */
                                                " application\n",
                                                ipcnum);
                                }
-                               pDrvData->IPCs[ipcnum].bIsHere = FALSE;
+                               pDrvData->IPCs[ipcnum].bIsHere = false;
                                remove_wait_queue(&pDrvData->IPCs[ipcnum].ipc_wait_queue, &wait);
                                set_current_state(TASK_RUNNING);
                                PRINTK_2(TRACE_MWAVE,
                                return -EINVAL;
                        }
                        mutex_lock(&mwave_mutex);
-                       if (pDrvData->IPCs[ipcnum].bIsEnabled == TRUE) {
-                               pDrvData->IPCs[ipcnum].bIsEnabled = FALSE;
-                               if (pDrvData->IPCs[ipcnum].bIsHere == TRUE) {
+                       if (pDrvData->IPCs[ipcnum].bIsEnabled == true) {
+                               pDrvData->IPCs[ipcnum].bIsEnabled = false;
+                               if (pDrvData->IPCs[ipcnum].bIsHere == true) {
                                        wake_up_interruptible(&pDrvData->IPCs[ipcnum].ipc_wait_queue);
                                }
                        }
 
        if (pDrvData->device_registered) {
                device_unregister(&mwave_device);
-               pDrvData->device_registered = FALSE;
+               pDrvData->device_registered = false;
        }
 #endif
 
 
        memset(&mwave_s_mdd, 0, sizeof(MWAVE_DEVICE_DATA));
 
-       pDrvData->bBDInitialized = FALSE;
-       pDrvData->bResourcesClaimed = FALSE;
-       pDrvData->bDSPEnabled = FALSE;
-       pDrvData->bDSPReset = FALSE;
-       pDrvData->bMwaveDevRegistered = FALSE;
+       pDrvData->bBDInitialized = false;
+       pDrvData->bResourcesClaimed = false;
+       pDrvData->bDSPEnabled = false;
+       pDrvData->bDSPReset = false;
+       pDrvData->bMwaveDevRegistered = false;
        pDrvData->sLine = -1;
 
        for (i = 0; i < ARRAY_SIZE(pDrvData->IPCs); i++) {
-               pDrvData->IPCs[i].bIsEnabled = FALSE;
-               pDrvData->IPCs[i].bIsHere = FALSE;
+               pDrvData->IPCs[i].bIsEnabled = false;
+               pDrvData->IPCs[i].bIsHere = false;
                pDrvData->IPCs[i].usIntCount = 0;       /* no ints received yet */
                init_waitqueue_head(&pDrvData->IPCs[i].ipc_wait_queue);
        }
                                " Failed to initialize board data\n");
                goto cleanup_error;
        }
-       pDrvData->bBDInitialized = TRUE;
+       pDrvData->bBDInitialized = true;
 
        retval = tp3780I_CalcResources(&pDrvData->rBDData);
        PRINTK_2(TRACE_MWAVE,
                                " Failed to claim resources\n");
                goto cleanup_error;
        }
-       pDrvData->bResourcesClaimed = TRUE;
+       pDrvData->bResourcesClaimed = true;
 
        retval = tp3780I_EnableDSP(&pDrvData->rBDData);
        PRINTK_2(TRACE_MWAVE,
                                " Failed to enable DSP\n");
                goto cleanup_error;
        }
-       pDrvData->bDSPEnabled = TRUE;
+       pDrvData->bDSPEnabled = true;
 
        if (misc_register(&mwave_misc_dev) < 0) {
                PRINTK_ERROR(KERN_ERR_MWAVE
                                " Failed to register misc device\n");
                goto cleanup_error;
        }
-       pDrvData->bMwaveDevRegistered = TRUE;
+       pDrvData->bMwaveDevRegistered = true;
 
        pDrvData->sLine = register_serial_portandirq(
                pDrvData->rBDData.rDspSettings.usUartBaseIO,
 
        if (device_register(&mwave_device))
                goto cleanup_error;
-       pDrvData->device_registered = TRUE;
+       pDrvData->device_registered = true;
        for (i = 0; i < ARRAY_SIZE(mwave_dev_attrs); i++) {
                if(device_create_file(&mwave_device, mwave_dev_attrs[i])) {
                        PRINTK_ERROR(KERN_ERR_MWAVE
 
 
 typedef struct _MWAVE_IPC {
        unsigned short usIntCount;      /* 0=none, 1=first, 2=greater than 1st */
-       BOOLEAN bIsEnabled;
-       BOOLEAN bIsHere;
+       bool bIsEnabled;
+       bool bIsHere;
        /* entry spin lock */
        wait_queue_head_t ipc_wait_queue;
 } MWAVE_IPC;
        THINKPAD_BD_DATA rBDData;       /* board driver's data area */
        unsigned long ulIPCSource_ISR;  /* IPC source bits for recently processed intr, set during ISR processing */
        unsigned long ulIPCSource_DPC;  /* IPC source bits for recently processed intr, set during DPC processing */
-       BOOLEAN bBDInitialized;
-       BOOLEAN bResourcesClaimed;
-       BOOLEAN bDSPEnabled;
-       BOOLEAN bDSPReset;
+       bool bBDInitialized;
+       bool bResourcesClaimed;
+       bool bDSPEnabled;
+       bool bDSPReset;
        MWAVE_IPC IPCs[16];
-       BOOLEAN bMwaveDevRegistered;
+       bool bMwaveDevRegistered;
        short sLine;
        int nr_registered_attrs;
        int device_registered;
 
 }
 
 
-int smapi_set_DSP_power_state(BOOLEAN bOn)
+int smapi_set_DSP_power_state(bool bOn)
 {
        int bRC = -EIO;
        unsigned short usAX, usBX, usCX, usDX, usDI, usSI;
                        PRINTK_ERROR("smapi::smapi_init, ERROR unable to read from SMAPI port\n");
                } else {
                        PRINTK_2(TRACE_SMAPI,
-                               "smapi::smapi_init, exit TRUE g_usSmapiPort %x\n",
+                               "smapi::smapi_init, exit true g_usSmapiPort %x\n",
                                g_usSmapiPort);
                        retval = 0;
                        //SmapiQuerySystemID();
 
 #ifndef _LINUX_SMAPI_H
 #define _LINUX_SMAPI_H
 
-#define TRUE 1
-#define FALSE 0
-#define BOOLEAN int
-
 typedef struct {
        int bDSPPresent;
        int bDSPEnabled;
 int smapi_init(void);
 int smapi_query_DSP_cfg(SMAPI_DSP_SETTINGS * pSettings);
 int smapi_set_DSP_cfg(void);
-int smapi_set_DSP_power_state(BOOLEAN bOn);
+int smapi_set_DSP_power_state(bool bOn);
 
 
 #endif
 
        WriteMsaCfg(DSP_GpioModeControl_15_8, MKWORD(rGpioMode));
 
        MKWORD(rGpioDriverEnable) = 0;
-       rGpioDriverEnable.Enable10 = TRUE;
-       rGpioDriverEnable.Mask10 = TRUE;
+       rGpioDriverEnable.Enable10 = true;
+       rGpioDriverEnable.Mask10 = true;
        WriteMsaCfg(DSP_GpioDriverEnable_15_8, MKWORD(rGpioDriverEnable));
 
        MKWORD(rGpioOutputData) = 0;
        rGpioOutputData.Latch10 = 0;
-       rGpioOutputData.Mask10 = TRUE;
+       rGpioOutputData.Mask10 = true;
        WriteMsaCfg(DSP_GpioOutputData_15_8, MKWORD(rGpioOutputData));
 
        PRINTK_1(TRACE_TP3780I, "tp3780i::EnableSRAM exit\n");
                                PRINTK_2(TRACE_TP3780I,
                                        "tp3780i::DspInterrupt usIntCount %x\n",
                                        pDrvData->IPCs[usPCNum - 1].usIntCount);
-                               if (pDrvData->IPCs[usPCNum - 1].bIsEnabled == TRUE) {
+                               if (pDrvData->IPCs[usPCNum - 1].bIsEnabled == true) {
                                        PRINTK_2(TRACE_TP3780I,
                                                "tp3780i::DspInterrupt, waking up usPCNum %x\n",
                                                usPCNum - 1);
 
        PRINTK_2(TRACE_TP3780I, "tp3780i::tp3780I_InitializeBoardData entry pBDData %p\n", pBDData);
 
-       pBDData->bDSPEnabled = FALSE;
-       pSettings->bInterruptClaimed = FALSE;
+       pBDData->bDSPEnabled = false;
+       pSettings->bInterruptClaimed = false;
 
        retval = smapi_init();
        if (retval) {
 
        if (pSettings->bInterruptClaimed) {
                free_irq(pSettings->usDspIrq, NULL);
-               pSettings->bInterruptClaimed = FALSE;
+               pSettings->bInterruptClaimed = false;
        }
 
        PRINTK_2(TRACE_TP3780I,
 int tp3780I_EnableDSP(THINKPAD_BD_DATA * pBDData)
 {
        DSP_3780I_CONFIG_SETTINGS *pSettings = &pBDData->rDspSettings;
-       BOOLEAN bDSPPoweredUp = FALSE, bInterruptAllocated = FALSE;
+       bool bDSPPoweredUp = false, bInterruptAllocated = false;
 
        PRINTK_2(TRACE_TP3780I, "tp3780i::tp3780I_EnableDSP entry pBDData %p\n", pBDData);
 
                }
        }
 
-       pSettings->bDspIrqActiveLow = pSettings->bDspIrqPulse = TRUE;
-       pSettings->bUartIrqActiveLow = pSettings->bUartIrqPulse = TRUE;
+       pSettings->bDspIrqActiveLow = pSettings->bDspIrqPulse = true;
+       pSettings->bUartIrqActiveLow = pSettings->bUartIrqPulse = true;
 
        if (pBDData->bShareDspIrq) {
-               pSettings->bDspIrqActiveLow = FALSE;
+               pSettings->bDspIrqActiveLow = false;
        }
        if (pBDData->bShareUartIrq) {
-               pSettings->bUartIrqActiveLow = FALSE;
+               pSettings->bUartIrqActiveLow = false;
        }
 
        pSettings->usNumTransfers = TP_CFG_NumTransfers;
                PRINTK_3(TRACE_TP3780I,
                        "tp3780i::tp3780I_EnableDSP, got interrupt %x bShareDspIrq %x\n",
                        pSettings->usDspIrq, pBDData->bShareDspIrq);
-               bInterruptAllocated = TRUE;
-               pSettings->bInterruptClaimed = TRUE;
+               bInterruptAllocated = true;
+               pSettings->bInterruptClaimed = true;
        }
 
-       smapi_set_DSP_power_state(FALSE);
-       if (smapi_set_DSP_power_state(TRUE)) {
-               PRINTK_ERROR(KERN_ERR_MWAVE "tp3780i::tp3780I_EnableDSP: Error: smapi_set_DSP_power_state(TRUE) failed\n");
+       smapi_set_DSP_power_state(false);
+       if (smapi_set_DSP_power_state(true)) {
+               PRINTK_ERROR(KERN_ERR_MWAVE "tp3780i::tp3780I_EnableDSP: Error: smapi_set_DSP_power_state(true) failed\n");
                goto exit_cleanup;
        } else {
-               bDSPPoweredUp = TRUE;
+               bDSPPoweredUp = true;
        }
 
        if (dsp3780I_EnableDSP(pSettings, s_ausThinkpadIrqToField, s_ausThinkpadDmaToField)) {
 
        EnableSRAM(pBDData);
 
-       pBDData->bDSPEnabled = TRUE;
+       pBDData->bDSPEnabled = true;
 
        PRINTK_1(TRACE_TP3780I, "tp3780i::tp3780I_EnableDSP exit\n");
 
 exit_cleanup:
        PRINTK_ERROR("tp3780i::tp3780I_EnableDSP: Cleaning up\n");
        if (bDSPPoweredUp)
-               smapi_set_DSP_power_state(FALSE);
+               smapi_set_DSP_power_state(false);
        if (bInterruptAllocated) {
                free_irq(pSettings->usDspIrq, NULL);
-               pSettings->bInterruptClaimed = FALSE;
+               pSettings->bInterruptClaimed = false;
        }
        return -EIO;
 }
                dsp3780I_DisableDSP(&pBDData->rDspSettings);
                if (pSettings->bInterruptClaimed) {
                        free_irq(pSettings->usDspIrq, NULL);
-                       pSettings->bInterruptClaimed = FALSE;
+                       pSettings->bInterruptClaimed = false;
                }
-               smapi_set_DSP_power_state(FALSE);
-               pBDData->bDSPEnabled = FALSE;
+               smapi_set_DSP_power_state(false);
+               pBDData->bDSPEnabled = false;
        }
 
        PRINTK_2(TRACE_TP3780I, "tp3780i::tp3780I_DisableDSP exit retval %x\n", retval);
        int retval = 0;
        DSP_3780I_CONFIG_SETTINGS *pSettings = &pBDData->rDspSettings;
        unsigned short usDspBaseIO = pSettings->usDspBaseIO;
-       BOOLEAN bRC = 0;
+       bool bRC = 0;
 
        PRINTK_6(TRACE_TP3780I,
                "tp3780i::tp3780I_ReadWriteDspDStore entry pBDData %p, uOpcode %x, pvBuffer %p, uCount %x, ulDSPAddr %lx\n",
        int retval = 0;
        DSP_3780I_CONFIG_SETTINGS *pSettings = &pBDData->rDspSettings;
        unsigned short usDspBaseIO = pSettings->usDspBaseIO;
-       BOOLEAN bRC = 0;
+       bool bRC = 0;
 
        PRINTK_6(TRACE_TP3780I,
                "tp3780i::tp3780I_ReadWriteDspIStore entry pBDData %p, uOpcode %x, pvBuffer %p, uCount %x, ulDSPAddr %lx\n",