sound/soc/codecs/mc1n2/mcdebuglog.c

   1 /****************************************************************************
   2  *
   3  *              Copyright(c) 2010 Yamaha Corporation. All rights reserved.
   4  *
   5  *              Module          : mcdebuglog.c
   6  *
   7  *              Description     : MC Driver debug log
   8  *
   9  *              Version         : 1.0.0         2010.09.10
  10  *
  11  ****************************************************************************/
  12
  13
  14 #include "mcdebuglog.h"
  15 #include "mcresctrl.h"
  16
  17 #if MCDRV_DEBUG_LEVEL
  18
  19 #include "mcdefs.h"
  20 #include "mcdevprof.h"
  21 #include "mcservice.h"
  22 #include "mcmachdep.h"
  23
  24
  25
  26 typedef char    CHAR;
  27
  28 static CHAR     gsbLogString[8192];
  29 static CHAR     gsbLFCode[]     = "\n";
  30
  31 static const CHAR       gsbCmdName[][20]        =
  32 {
  33         "init",
  34         "term",
  35         "read_reg",
  36         "write_reg",
  37         "get_path",
  38         "set_path",
  39         "get_volume",
  40         "set_volume",
  41         "get_digitalio",
  42         "set_digitalio",
  43         "get_dac",
  44         "set_dac",
  45         "get_adc",
  46         "set_adc",
  47         "get_sp",
  48         "set_sp",
  49         "get_dng",
  50         "set_dng",
  51         "set_ae",
  52         "set_aeex",
  53         "set_cdsp",
  54         "get_cdspparam",
  55         "set_cdspparam",
  56         "reg_cdsp_cb",
  57         "get_pdm",
  58         "set_pdm",
  59         "set_dtmf",
  60         "config_gp",
  61         "mask_gp",
  62         "getset_gp",
  63         "get_peak",
  64         "irq",
  65         "update_clock",
  66         "switch_clock",
  67         "get_syseq",
  68         "set_syseq"
  69 };
  70
  71
  72 static void     OutputRegDump(void);
  73 static void     GetRegDump_B(CHAR* psbLogString, UINT8 bSlaveAddr, UINT8 bADRAddr, UINT8 bWINDOWAddr, UINT8 bRegType);
  74
  75 static void     MakeInitInfoLog(const MCDRV_INIT_INFO* pParam);
  76 static void     MakeRegInfoLog(const MCDRV_REG_INFO* pParam);
  77 static void     MakeClockInfoLog(const MCDRV_CLOCK_INFO* pParam);
  78 static void     MakeClockSwInfoLog(const MCDRV_CLKSW_INFO* pParam);
  79 static void     MakePathInfoLog(const MCDRV_PATH_INFO* pParam);
  80 static void     MakeVolInfoLog(const MCDRV_VOL_INFO* pParam);
  81 static void     MakeDIOInfoLog(const MCDRV_DIO_INFO* pParam);
  82 static void     MakeDACInfoLog(const MCDRV_DAC_INFO* pParam);
  83 static void     MakeADCInfoLog(const MCDRV_ADC_INFO* pParam);
  84 static void     MakeSpInfoLog(const MCDRV_SP_INFO* pParam);
  85 static void     MakeDNGInfoLog(const MCDRV_DNG_INFO* pParam);
  86 static void     MakeAEInfoLog(const MCDRV_AE_INFO* pParam);
  87 static void     MakeAEExInfoLog(const UINT16* pParam);
  88 static void     MakeSetCDSPLog(const UINT16* pParam);
  89 static void     MakeCDSPParamLog(const MCDRV_CDSPPARAM* pParam);
  90 static void     MakeCDSPCBLog(const void* pParam);
  91 static void     MakePDMInfoLog(const MCDRV_PDM_INFO* pParam);
  92 static void     MakeDTMFInfoLog(const MCDRV_DTMF_INFO* pParam);
  93 static void     MakeGPModeLog(const MCDRV_GP_MODE* pParam);
  94 static void     MakeGPMaskLog(const UINT8* pParam);
  95 static void     MakeGetSetGPLog(const UINT8* pParam);
  96 static void     MakePeakLog(const MCDRV_PEAK* pParam);
  97 static void     MakeSysEQInfoLog(const MCDRV_SYSEQ_INFO* pParam);
  98
  99 /****************************************************************************
 100  *      McDebugLog_CmdIn
 101  *
 102  *      Description:
 103  *                      Output Function entrance log.
 104  *      Arguments:
 105  *                      dCmd            Command ID
 106  *                      pvParam         pointer to parameter
 107  *                      dUpdateInfo     Update info
 108  *      Return:
 109  *                      none
 110  *
 111  ****************************************************************************/
 112 void    McDebugLog_CmdIn
 113 (
 114         UINT32          dCmd,
 115         const void*     pvParam,
 116         UINT32          dUpdateInfo
 117 )
 118 {
 119         CHAR    sbStr[80];
 120         UINT8   bLevel  = MCDRV_DEBUG_LEVEL;
 121
 122         if(dCmd >= sizeof(gsbCmdName)/sizeof(gsbCmdName[0]))
 123         {
 124                 return;
 125         }
 126
 127         strcpy(gsbLogString, gsbCmdName[dCmd]);
 128         strcat(gsbLogString, " In");
 129
 130         if(bLevel < 2)
 131         {
 132                 strcat(gsbLogString, gsbLFCode);
 133                 machdep_DebugPrint((UINT8*)(void*)gsbLogString);
 134                 return;
 135         }
 136
 137         switch(dCmd)
 138         {
 139         case    MCDRV_INIT:
 140                 MakeInitInfoLog((MCDRV_INIT_INFO*)pvParam);
 141                 break;
 142         case    MCDRV_READ_REG:
 143         case    MCDRV_WRITE_REG:
 144                 MakeRegInfoLog((MCDRV_REG_INFO*)pvParam);
 145                 break;
 146         case    MCDRV_UPDATE_CLOCK:
 147                 MakeClockInfoLog((MCDRV_CLOCK_INFO*)pvParam);
 148                 break;
 149         case    MCDRV_SWITCH_CLOCK:
 150                 MakeClockSwInfoLog((MCDRV_CLKSW_INFO*)pvParam);
 151                 break;
 152         case    MCDRV_SET_PATH:
 153                 MakePathInfoLog((MCDRV_PATH_INFO*)pvParam);
 154                 break;
 155         case    MCDRV_SET_VOLUME:
 156                 MakeVolInfoLog((MCDRV_VOL_INFO*)pvParam);
 157                 break;
 158         case    MCDRV_SET_DIGITALIO:
 159                 MakeDIOInfoLog((MCDRV_DIO_INFO*)pvParam);
 160                 sprintf(sbStr, " dPrm=%08lX", dUpdateInfo);
 161                 strcat(gsbLogString, sbStr);
 162                 break;
 163         case    MCDRV_SET_DAC:
 164                 MakeDACInfoLog((MCDRV_DAC_INFO*)pvParam);
 165                 sprintf(sbStr, " dPrm=%08lX", dUpdateInfo);
 166                 strcat(gsbLogString, sbStr);
 167                 break;
 168         case    MCDRV_SET_ADC:
 169                 MakeADCInfoLog((MCDRV_ADC_INFO*)pvParam);
 170                 sprintf(sbStr, " dPrm=%08lX", dUpdateInfo);
 171                 strcat(gsbLogString, sbStr);
 172                 break;
 173         case    MCDRV_SET_SP:
 174                 MakeSpInfoLog((MCDRV_SP_INFO*)pvParam);
 175                 break;
 176         case    MCDRV_SET_DNG:
 177                 MakeDNGInfoLog((MCDRV_DNG_INFO*)pvParam);
 178                 sprintf(sbStr, " dPrm=%08lX", dUpdateInfo);
 179                 strcat(gsbLogString, sbStr);
 180                 break;
 181         case    MCDRV_SET_AUDIOENGINE:
 182                 MakeAEInfoLog((MCDRV_AE_INFO*)pvParam);
 183                 sprintf(sbStr, " dPrm=%08lX", dUpdateInfo);
 184                 strcat(gsbLogString, sbStr);
 185                 break;
 186         case    MCDRV_SET_AUDIOENGINE_EX:
 187                 MakeAEExInfoLog((UINT16*)pvParam);
 188                 sprintf(sbStr, " dPrm=%08lX", dUpdateInfo);
 189                 strcat(gsbLogString, sbStr);
 190                 break;
 191         case    MCDRV_SET_CDSP:
 192                 MakeSetCDSPLog((UINT16*)pvParam);
 193                 sprintf(sbStr, " dPrm=%08lX", dUpdateInfo);
 194                 strcat(gsbLogString, sbStr);
 195                 break;
 196         case    MCDRV_SET_CDSP_PARAM:
 197                 MakeCDSPParamLog((MCDRV_CDSPPARAM*)pvParam);
 198                 break;
 199         case    MCDRV_REGISTER_CDSP_CB:
 200                 MakeCDSPCBLog(pvParam);
 201                 break;
 202         case    MCDRV_SET_PDM:
 203                 MakePDMInfoLog((MCDRV_PDM_INFO*)pvParam);
 204                 sprintf(sbStr, " dPrm=%08lX", dUpdateInfo);
 205                 strcat(gsbLogString, sbStr);
 206                 break;
 207         case    MCDRV_SET_DTMF:
 208                 MakeDTMFInfoLog((MCDRV_DTMF_INFO*)pvParam);
 209                 break;
 210         case    MCDRV_CONFIG_GP:
 211                 MakeGPModeLog((MCDRV_GP_MODE*)pvParam);
 212                 break;
 213         case    MCDRV_MASK_GP:
 214                 MakeGPMaskLog((UINT8*)pvParam);
 215                 sprintf(sbStr, " dPrm=%08lX", dUpdateInfo);
 216                 strcat(gsbLogString, sbStr);
 217                 break;
 218         case    MCDRV_GETSET_GP:
 219                 MakeGetSetGPLog((UINT8*)pvParam);
 220                 sprintf(sbStr, " dPrm=%08lX", dUpdateInfo);
 221                 strcat(gsbLogString, sbStr);
 222                 break;
 223         case    MCDRV_SET_SYSEQ:
 224                 MakeSysEQInfoLog((MCDRV_SYSEQ_INFO*)pvParam);
 225                 sprintf(sbStr, " dPrm=%08lX", dUpdateInfo);
 226                 strcat(gsbLogString, sbStr);
 227                 break;
 228
 229         default:
 230                 break;
 231         }
 232
 233         strcat(gsbLogString, gsbLFCode);
 234         machdep_DebugPrint((UINT8*)(void*)gsbLogString);
 235 }
 236
 237 /****************************************************************************
 238  *      McDebugLog_CmdOut
 239  *
 240  *      Description:
 241  *                      Output Function exit log.
 242  *      Arguments:
 243  *                      dCmd            Command ID
 244  *                      psdRet          retrun value
 245  *                      pvParam         pointer to parameter
 246  *      Return:
 247  *                      none
 248  *
 249  ****************************************************************************/
 250 void    McDebugLog_CmdOut
 251 (
 252         UINT32                  dCmd,
 253         const SINT32*   psdRet,
 254         const void*             pvParam
 255 )
 256 {
 257         CHAR    sbStr[80];
 258         UINT8   bLevel  = MCDRV_DEBUG_LEVEL;
 259
 260         if(dCmd >= sizeof(gsbCmdName)/sizeof(gsbCmdName[0]))
 261         {
 262                 return;
 263         }
 264
 265         strcpy(gsbLogString, gsbCmdName[dCmd]);
 266         strcat(gsbLogString, " Out");
 267         if(psdRet != NULL)
 268         {
 269                 sprintf(sbStr, " ret=%ld", *psdRet);
 270                 strcat(gsbLogString, sbStr);
 271         }
 272
 273         if(bLevel < 2)
 274         {
 275                 strcat(gsbLogString, gsbLFCode);
 276                 machdep_DebugPrint((UINT8*)(void*)gsbLogString);
 277                 return;
 278         }
 279
 280         switch(dCmd)
 281         {
 282         case    MCDRV_READ_REG:
 283                 MakeRegInfoLog((MCDRV_REG_INFO*)pvParam);
 284                 break;
 285         case    MCDRV_GET_PATH:
 286                 MakePathInfoLog((MCDRV_PATH_INFO*)pvParam);
 287                 break;
 288         case    MCDRV_GET_VOLUME:
 289                 MakeVolInfoLog((MCDRV_VOL_INFO*)pvParam);
 290                 break;
 291         case    MCDRV_GET_DIGITALIO:
 292                 MakeDIOInfoLog((MCDRV_DIO_INFO*)pvParam);
 293                 break;
 294         case    MCDRV_GET_DAC:
 295                 MakeDACInfoLog((MCDRV_DAC_INFO*)pvParam);
 296                 break;
 297         case    MCDRV_GET_ADC:
 298                 MakeADCInfoLog((MCDRV_ADC_INFO*)pvParam);
 299                 break;
 300         case    MCDRV_GET_SP:
 301                 MakeSpInfoLog((MCDRV_SP_INFO*)pvParam);
 302                 break;
 303         case    MCDRV_GET_DNG:
 304                 MakeDNGInfoLog((MCDRV_DNG_INFO*)pvParam);
 305                 break;
 306         case    MCDRV_GET_CDSP_PARAM:
 307                 MakeCDSPParamLog((MCDRV_CDSPPARAM*)pvParam);
 308                 break;
 309         case    MCDRV_GET_PDM:
 310                 MakePDMInfoLog((MCDRV_PDM_INFO*)pvParam);
 311                 break;
 312         case    MCDRV_GETSET_GP:
 313                 MakeGetSetGPLog((UINT8*)pvParam);
 314                 break;
 315         case    MCDRV_GET_PEAK:
 316                 MakePeakLog((MCDRV_PEAK*)pvParam);
 317                 break;
 318         case    MCDRV_GET_SYSEQ:
 319                 MakeSysEQInfoLog((MCDRV_SYSEQ_INFO*)pvParam);
 320                 break;
 321
 322         default:
 323                 break;
 324         }
 325         strcat(gsbLogString, gsbLFCode);
 326         machdep_DebugPrint((UINT8*)(void*)gsbLogString);
 327
 328         if(bLevel < 3)
 329         {
 330                 return;
 331         }
 332
 333         OutputRegDump();
 334 }
 335
 336 /****************************************************************************
 337  *      McDebugLog_FuncIn
 338  *
 339  *      Description:
 340  *                      Output Function entrance log.
 341  *      Arguments:
 342  *                      pbFuncName      function name
 343  *      Return:
 344  *                      none
 345  *
 346  ****************************************************************************/
 347 void    McDebugLog_FuncIn
 348 (
 349         void*   pvFuncName
 350 )
 351 {
 352         strcpy(gsbLogString, (CHAR*)pvFuncName);
 353         strcat(gsbLogString, " In");
 354
 355         strcat(gsbLogString, gsbLFCode);
 356         machdep_DebugPrint((UINT8*)(void*)gsbLogString);
 357 }
 358
 359 /****************************************************************************
 360  *      McDebugLog_FuncOut
 361  *
 362  *      Description:
 363  *                      Output Function exit log.
 364  *      Arguments:
 365  *                      pbFuncName      function name
 366  *                      psdRet          retrun value
 367  *      Return:
 368  *                      none
 369  *
 370  ****************************************************************************/
 371 void    McDebugLog_FuncOut
 372 (
 373         void*                   pvFuncName,
 374         const SINT32*   psdRet
 375 )
 376 {
 377         CHAR    sbStr[80];
 378
 379         strcpy(gsbLogString, (CHAR*)pvFuncName);
 380         strcat(gsbLogString, " Out");
 381         if(psdRet != NULL)
 382         {
 383                 sprintf(sbStr, " ret=%ld", *psdRet);
 384                 strcat(gsbLogString, sbStr);
 385         }
 386
 387         strcat(gsbLogString, gsbLFCode);
 388         machdep_DebugPrint((UINT8*)(void*)gsbLogString);
 389 }
 390
 391
 392 /****************************************************************************
 393  *      OutputRegDump
 394  *
 395  *      Description:
 396  *                      Output Register dump.
 397  *      Arguments:
 398  *                      none
 399  *      Return:
 400  *                      none
 401  *
 402  ****************************************************************************/
 403 static void     OutputRegDump
 404 (
 405         void
 406 )
 407 {
 408         UINT16  i;
 409         CHAR    sbStr[10];
 410         CHAR    sbLogString[2500]="";
 411         UINT8   bSlaveAddr      = McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_DIG);
 412         MCDRV_REG_INFO  sRegInfo;
 413
 414         /*      A_ADR   */
 415         sRegInfo.bRegType       = MCDRV_REGTYPE_A;
 416         strcpy(sbLogString, "A_ADR:");
 417         for(i = 0; i < 256UL; i++)
 418         {
 419                 sRegInfo.bAddress       = (UINT8)i;
 420                 if((McResCtrl_GetRegAccess(&sRegInfo) & eMCDRV_READ_ONLY) != 0)
 421                 {
 422                         sprintf(sbStr, "[%d]=%02X", i, McSrv_ReadI2C(bSlaveAddr, i));
 423                         strcat(sbLogString, sbStr);
 424                         if(i < 255UL)
 425                         {
 426                                 strcat(sbLogString, " ");
 427                         }
 428                 }
 429         }
 430         strcat(sbLogString, gsbLFCode);
 431         machdep_DebugPrint((UINT8*)(void*)sbLogString);
 432
 433         /*      BASE_ADR        */
 434         strcpy(sbLogString, "BASE_ADR:");
 435         GetRegDump_B(sbLogString, bSlaveAddr, MCI_BASE_ADR, MCI_BASE_WINDOW, MCDRV_REGTYPE_B_BASE);
 436         strcat(sbLogString, gsbLFCode);
 437         machdep_DebugPrint((UINT8*)(void*)sbLogString);
 438
 439         /*      ANA_ADR */
 440         strcpy(sbLogString, "ANA_ADR:");
 441         GetRegDump_B(sbLogString, McDevProf_GetSlaveAddr(eMCDRV_SLAVE_ADDR_ANA), MCI_ANA_ADR, MCI_ANA_WINDOW, MCDRV_REGTYPE_B_ANALOG);
 442         strcat(sbLogString, gsbLFCode);
 443         machdep_DebugPrint((UINT8*)(void*)sbLogString);
 444
 445         /*      CD_ADR  */
 446         strcpy(sbLogString, "CD_ADR:");
 447         GetRegDump_B(sbLogString, bSlaveAddr, MCI_CD_ADR, MCI_CD_WINDOW, MCDRV_REGTYPE_B_CODEC);
 448         strcat(sbLogString, gsbLFCode);
 449         machdep_DebugPrint((UINT8*)(void*)sbLogString);
 450
 451         /*      MIX_ADR */
 452         strcpy(sbLogString, "MIX_ADR:");
 453         GetRegDump_B(sbLogString, bSlaveAddr, MCI_MIX_ADR, MCI_MIX_WINDOW, MCDRV_REGTYPE_B_MIXER);
 454         strcat(sbLogString, gsbLFCode);
 455         machdep_DebugPrint((UINT8*)(void*)sbLogString);
 456
 457 #if 0
 458         /*      AE_ADR  */
 459         strcpy(sbLogString, "AE_ADR:");
 460         GetRegDump_B(sbLogString, bSlaveAddr, MCI_AE_ADR, MCI_AE_WINDOW, MCDRV_REGTYPE_B_AE);
 461         strcat(sbLogString, gsbLFCode);
 462         machdep_DebugPrint((UINT8*)(void*)sbLogString);
 463 #endif
 464 }
 465
 466 /****************************************************************************
 467  *      GetRegDump_B
 468  *
 469  *      Description:
 470  *                      Get B-ADR Register dump string.
 471  *      Arguments:
 472  *                      psbLogString    string buffer
 473  *                      bSlaveAddr              Slave address
 474  *                      bADRAddr                ADR address
 475  *                      bWINDOWAddr             WINDOW address
 476  *                      bRegType                register type
 477  *      Return:
 478  *                      none
 479  *
 480  ****************************************************************************/
 481 static void     GetRegDump_B
 482 (
 483         CHAR*   psbLogString,
 484         UINT8   bSlaveAddr,
 485         UINT8   bADRAddr,
 486         UINT8   bWINDOWAddr,
 487         UINT8   bRegType
 488 )
 489 {
 490         UINT16  i;
 491         CHAR    sbStr[10];
 492         UINT8   abData[2];
 493         MCDRV_REG_INFO  sRegInfo;
 494
 495         abData[0]       = bADRAddr<<1;
 496         sRegInfo.bRegType       = bRegType;
 497
 498         for(i = 0; i < 256UL; i++)
 499         {
 500                 sRegInfo.bAddress       = (UINT8)i;
 501                 if((McResCtrl_GetRegAccess(&sRegInfo) & eMCDRV_READ_ONLY) != 0)
 502                 {
 503                         abData[1]       = (UINT8)i;
 504                         McSrv_WriteI2C(bSlaveAddr, abData, 2);
 505                         sprintf(sbStr, "[%d]=%02X", i, McSrv_ReadI2C(bSlaveAddr, bWINDOWAddr));
 506                         strcat(psbLogString, sbStr);
 507                         if(i < 255UL)
 508                         {
 509                                 strcat(psbLogString, " ");
 510                         }
 511                 }
 512         }
 513 }
 514
 515 /****************************************************************************
 516  *      MakeInitInfoLog
 517  *
 518  *      Description:
 519  *                      Make Init Parameter log.
 520  *      Arguments:
 521  *                      pParam  pointer to parameter
 522  *      Return:
 523  *                      none
 524  *
 525  ****************************************************************************/
 526 static void     MakeInitInfoLog
 527 (
 528         const MCDRV_INIT_INFO*  pParam
 529 )
 530 {
 531         CHAR    sbStr[80];
 532
 533         if(pParam == NULL)
 534         {
 535                 strcat(gsbLogString, " param=NULL");
 536                 return;
 537         }
 538
 539         sprintf(sbStr, " bCkSel=%02X", pParam->bCkSel);
 540         strcat(gsbLogString, sbStr);
 541         sprintf(sbStr, " bDivR0=%02X", pParam->bDivR0);
 542         strcat(gsbLogString, sbStr);
 543         sprintf(sbStr, " bDivF0=%02X", pParam->bDivF0);
 544         strcat(gsbLogString, sbStr);
 545         sprintf(sbStr, " bDivR1=%02X", pParam->bDivR1);
 546         strcat(gsbLogString, sbStr);
 547         sprintf(sbStr, " bDivF1=%02X", pParam->bDivF1);
 548         strcat(gsbLogString, sbStr);
 549         sprintf(sbStr, " bRange0=%02X", pParam->bRange0);
 550         strcat(gsbLogString, sbStr);
 551         sprintf(sbStr, " bRange1=%02X", pParam->bRange1);
 552         strcat(gsbLogString, sbStr);
 553         sprintf(sbStr, " bBypass=%02X", pParam->bBypass);
 554         strcat(gsbLogString, sbStr);
 555         sprintf(sbStr, " bDioSdo0Hiz=%02X", pParam->bDioSdo0Hiz);
 556         strcat(gsbLogString, sbStr);
 557         sprintf(sbStr, " bDioSdo1Hiz=%02X", pParam->bDioSdo1Hiz);
 558         strcat(gsbLogString, sbStr);
 559         sprintf(sbStr, " bDioSdo2Hiz=%02X", pParam->bDioSdo2Hiz);
 560         strcat(gsbLogString, sbStr);
 561         sprintf(sbStr, " bDioClk0Hiz=%02X", pParam->bDioClk0Hiz);
 562         strcat(gsbLogString, sbStr);
 563         sprintf(sbStr, " bDioClk1Hiz=%02X", pParam->bDioClk1Hiz);
 564         strcat(gsbLogString, sbStr);
 565         sprintf(sbStr, " bDioClk2Hiz=%02X", pParam->bDioClk2Hiz);
 566         strcat(gsbLogString, sbStr);
 567         sprintf(sbStr, " bPcmHiz=%02X", pParam->bPcmHiz);
 568         strcat(gsbLogString, sbStr);
 569         sprintf(sbStr, " bLineIn1Dif=%02X", pParam->bLineIn1Dif);
 570         strcat(gsbLogString, sbStr);
 571         sprintf(sbStr, " bLineIn2Dif=%02X", pParam->bLineIn2Dif);
 572         strcat(gsbLogString, sbStr);
 573         sprintf(sbStr, " bLineOut1Dif=%02X", pParam->bLineOut1Dif);
 574         strcat(gsbLogString, sbStr);
 575         sprintf(sbStr, " bLineOut2Dif=%02X", pParam->bLineOut2Dif);
 576         strcat(gsbLogString, sbStr);
 577         sprintf(sbStr, " bSpmn=%02X", pParam->bSpmn);
 578         strcat(gsbLogString, sbStr);
 579         sprintf(sbStr, " bMic1Sng=%02X", pParam->bMic1Sng);
 580         strcat(gsbLogString, sbStr);
 581         sprintf(sbStr, " bMic2Sng=%02X", pParam->bMic2Sng);
 582         strcat(gsbLogString, sbStr);
 583         sprintf(sbStr, " bMic3Sng=%02X", pParam->bMic3Sng);
 584         strcat(gsbLogString, sbStr);
 585         sprintf(sbStr, " bPowerMode=%02X", pParam->bPowerMode);
 586         strcat(gsbLogString, sbStr);
 587         sprintf(sbStr, " bSpHiz=%02X", pParam->bSpHiz);
 588         strcat(gsbLogString, sbStr);
 589         sprintf(sbStr, " bLdo=%02X", pParam->bLdo);
 590         strcat(gsbLogString, sbStr);
 591         sprintf(sbStr, " bPad0Func=%02X", pParam->bPad0Func);
 592         strcat(gsbLogString, sbStr);
 593         sprintf(sbStr, " bPad1Func=%02X", pParam->bPad1Func);
 594         strcat(gsbLogString, sbStr);
 595         sprintf(sbStr, " bPad2Func=%02X", pParam->bPad2Func);
 596         strcat(gsbLogString, sbStr);
 597         sprintf(sbStr, " bAvddLev=%02X", pParam->bAvddLev);
 598         strcat(gsbLogString, sbStr);
 599         sprintf(sbStr, " bVrefLev=%02X", pParam->bVrefLev);
 600         strcat(gsbLogString, sbStr);
 601         sprintf(sbStr, " bDclGain=%02X", pParam->bDclGain);
 602         strcat(gsbLogString, sbStr);
 603         sprintf(sbStr, " bDclLimit=%02X", pParam->bDclLimit);
 604         strcat(gsbLogString, sbStr);
 605         sprintf(sbStr, " bCpMod=%02X", pParam->bCpMod);
 606         strcat(gsbLogString, sbStr);
 607         sprintf(sbStr, " bReserved1=%02X", pParam->bReserved1);
 608         strcat(gsbLogString, sbStr);
 609         sprintf(sbStr, " bReserved2=%02X", pParam->bReserved2);
 610         strcat(gsbLogString, sbStr);
 611         sprintf(sbStr, " bReserved3=%02X", pParam->bReserved3);
 612         strcat(gsbLogString, sbStr);
 613         sprintf(sbStr, " bReserved4=%02X", pParam->bReserved4);
 614         strcat(gsbLogString, sbStr);
 615         sprintf(sbStr, " bReserved5=%02X", pParam->bReserved5);
 616         strcat(gsbLogString, sbStr);
 617         sprintf(sbStr, " sWaitTime.dAdHpf=%08lX", pParam->sWaitTime.dAdHpf);
 618         strcat(gsbLogString, sbStr);
 619         sprintf(sbStr, " sWaitTime.dMic1Cin=%08lX", pParam->sWaitTime.dMic1Cin);
 620         strcat(gsbLogString, sbStr);
 621         sprintf(sbStr, " sWaitTime.dMic2Cin=%08lX", pParam->sWaitTime.dMic2Cin);
 622         strcat(gsbLogString, sbStr);
 623         sprintf(sbStr, " sWaitTime.dMic3Cin=%08lX", pParam->sWaitTime.dMic3Cin);
 624         strcat(gsbLogString, sbStr);
 625         sprintf(sbStr, " sWaitTime.dLine1Cin=%08lX", pParam->sWaitTime.dLine1Cin);
 626         strcat(gsbLogString, sbStr);
 627         sprintf(sbStr, " sWaitTime.dLine2Cin=%08lX", pParam->sWaitTime.dLine2Cin);
 628         strcat(gsbLogString, sbStr);
 629         sprintf(sbStr, " sWaitTime.dVrefRdy1=%08lX", pParam->sWaitTime.dVrefRdy1);
 630         strcat(gsbLogString, sbStr);
 631         sprintf(sbStr, " sWaitTime.dVrefRdy2=%08lX", pParam->sWaitTime.dVrefRdy2);
 632         strcat(gsbLogString, sbStr);
 633         sprintf(sbStr, " sWaitTime.dHpRdy=%08lX", pParam->sWaitTime.dHpRdy);
 634         strcat(gsbLogString, sbStr);
 635         sprintf(sbStr, " sWaitTime.dSpRdy=%08lX", pParam->sWaitTime.dSpRdy);
 636         strcat(gsbLogString, sbStr);
 637         sprintf(sbStr, " sWaitTime.dPdm=%08lX", pParam->sWaitTime.dPdm);
 638         strcat(gsbLogString, sbStr);
 639         sprintf(sbStr, " sWaitTime.dAnaRdyInterval=%08lX", pParam->sWaitTime.dAnaRdyInterval);
 640         strcat(gsbLogString, sbStr);
 641         sprintf(sbStr, " sWaitTime.dSvolInterval=%08lX", pParam->sWaitTime.dSvolInterval);
 642         strcat(gsbLogString, sbStr);
 643         sprintf(sbStr, " sWaitTime.dAnaRdyTimeOut=%08lX", pParam->sWaitTime.dAnaRdyTimeOut);
 644         strcat(gsbLogString, sbStr);
 645         sprintf(sbStr, " sWaitTime.dSvolTimeOut=%08lX", pParam->sWaitTime.dSvolTimeOut);
 646         strcat(gsbLogString, sbStr);
 647 }
 648
 649 /****************************************************************************
 650  *      MakeRegInfoLog
 651  *
 652  *      Description:
 653  *                      Make Reg Info Parameter log.
 654  *      Arguments:
 655  *                      pParam  pointer to parameter
 656  *      Return:
 657  *                      none
 658  *
 659  ****************************************************************************/
 660 static void     MakeRegInfoLog
 661 (
 662         const MCDRV_REG_INFO* pParam
 663 )
 664 {
 665         CHAR    sbStr[80];
 666
 667         if(pParam == NULL)
 668         {
 669                 strcat(gsbLogString, " param=NULL");
 670                 return;
 671         }
 672
 673         sprintf(sbStr, " bRegType=%02X", pParam->bRegType);
 674         strcat(gsbLogString, sbStr);
 675         sprintf(sbStr, " bAddress=%02X", pParam->bAddress);
 676         strcat(gsbLogString, sbStr);
 677         sprintf(sbStr, " bData=%02X", pParam->bData);
 678         strcat(gsbLogString, sbStr);
 679 }
 680
 681 /****************************************************************************
 682  *      MakeClockInfoLog
 683  *
 684  *      Description:
 685  *                      Make Clock Info Parameter log.
 686  *      Arguments:
 687  *                      pParam  pointer to parameter
 688  *      Return:
 689  *                      none
 690  *
 691  ****************************************************************************/
 692 static void     MakeClockInfoLog
 693 (
 694         const MCDRV_CLOCK_INFO* pParam
 695 )
 696 {
 697         CHAR    sbStr[80];
 698
 699         if(pParam == NULL)
 700         {
 701                 strcat(gsbLogString, " param=NULL");
 702                 return;
 703         }
 704
 705         sprintf(sbStr, " bCkSel=%02X", pParam->bCkSel);
 706         strcat(gsbLogString, sbStr);
 707         sprintf(sbStr, " bDivR0=%02X", pParam->bDivR0);
 708         strcat(gsbLogString, sbStr);
 709         sprintf(sbStr, " bDivF0=%02X", pParam->bDivF0);
 710         strcat(gsbLogString, sbStr);
 711         sprintf(sbStr, " bDivR1=%02X", pParam->bDivR1);
 712         strcat(gsbLogString, sbStr);
 713         sprintf(sbStr, " bDivF1=%02X", pParam->bDivF1);
 714         strcat(gsbLogString, sbStr);
 715         sprintf(sbStr, " bRange0=%02X", pParam->bRange0);
 716         strcat(gsbLogString, sbStr);
 717         sprintf(sbStr, " bRange1=%02X", pParam->bRange1);
 718         strcat(gsbLogString, sbStr);
 719         sprintf(sbStr, " bBypass=%02X", pParam->bBypass);
 720         strcat(gsbLogString, sbStr);
 721 }
 722
 723 /****************************************************************************
 724  *      MakeClockSwInfoLog
 725  *
 726  *      Description:
 727  *                      Make Clock Switch Info Parameter log.
 728  *      Arguments:
 729  *                      pParam  pointer to parameter
 730  *      Return:
 731  *                      none
 732  *
 733  ****************************************************************************/
 734 static void     MakeClockSwInfoLog
 735 (
 736         const MCDRV_CLKSW_INFO* pParam
 737 )
 738 {
 739         CHAR    sbStr[80];
 740
 741         if(pParam == NULL)
 742         {
 743                 strcat(gsbLogString, " param=NULL");
 744                 return;
 745         }
 746
 747         sprintf(sbStr, " bClkSrc=%02X", pParam->bClkSrc);
 748         strcat(gsbLogString, sbStr);
 749 }
 750
 751 /****************************************************************************
 752  *      MakePathInfoLog
 753  *
 754  *      Description:
 755  *                      Make Path Info Parameter log.
 756  *      Arguments:
 757  *                      pParam  pointer to parameter
 758  *      Return:
 759  *                      none
 760  *
 761  ****************************************************************************/
 762 static void     MakePathInfoLog
 763 (
 764         const MCDRV_PATH_INFO* pParam
 765 )
 766 {
 767         UINT8   bBlock, bCh;
 768         CHAR    sbStr[80];
 769
 770         if(pParam == NULL)
 771         {
 772                 strcat(gsbLogString, " param=NULL");
 773                 return;
 774         }
 775
 776         for(bCh = 0; bCh < HP_PATH_CHANNELS; bCh++)
 777         {
 778                 for(bBlock = 0; bBlock < SOURCE_BLOCK_NUM; bBlock++)
 779                 {
 780                         sprintf(sbStr, " asHpOut[%d].abSrcOnOff[%d]=%02X", bCh, bBlock, pParam->asHpOut[bCh].abSrcOnOff[bBlock]);
 781                         strcat(gsbLogString, sbStr);
 782                 }
 783         }
 784         for(bCh = 0; bCh < SP_PATH_CHANNELS; bCh++)
 785         {
 786                 for(bBlock = 0; bBlock < SOURCE_BLOCK_NUM; bBlock++)
 787                 {
 788                         sprintf(sbStr, " asSpOut[%d].abSrcOnOff[%d]=%02X", bCh, bBlock, pParam->asSpOut[bCh].abSrcOnOff[bBlock]);
 789                         strcat(gsbLogString, sbStr);
 790                 }
 791         }
 792         for(bCh = 0; bCh < RC_PATH_CHANNELS; bCh++)
 793         {
 794                 for(bBlock = 0; bBlock < SOURCE_BLOCK_NUM; bBlock++)
 795                 {
 796                         sprintf(sbStr, " asRcOut[%d].abSrcOnOff[%d]=%02X", bCh, bBlock, pParam->asRcOut[bCh].abSrcOnOff[bBlock]);
 797                         strcat(gsbLogString, sbStr);
 798                 }
 799         }
 800         for(bCh = 0; bCh < LOUT1_PATH_CHANNELS; bCh++)
 801         {
 802                 for(bBlock = 0; bBlock < SOURCE_BLOCK_NUM; bBlock++)
 803                 {
 804                         sprintf(sbStr, " asLout1[%d].abSrcOnOff[%d]=%02X", bCh, bBlock, pParam->asLout1[bCh].abSrcOnOff[bBlock]);
 805                         strcat(gsbLogString, sbStr);
 806                 }
 807         }
 808         for(bCh = 0; bCh < LOUT2_PATH_CHANNELS; bCh++)
 809         {
 810                 for(bBlock = 0; bBlock < SOURCE_BLOCK_NUM; bBlock++)
 811                 {
 812                         sprintf(sbStr, " asLout2[%d].abSrcOnOff[%d]=%02X", bCh, bBlock, pParam->asLout2[bCh].abSrcOnOff[bBlock]);
 813                         strcat(gsbLogString, sbStr);
 814                 }
 815         }
 816         for(bCh = 0; bCh < PEAK_PATH_CHANNELS; bCh++)
 817         {
 818                 for(bBlock = 0; bBlock < SOURCE_BLOCK_NUM; bBlock++)
 819                 {
 820                         sprintf(sbStr, " asPeak[%d].abSrcOnOff[%d]=%02X", bCh, bBlock, pParam->asPeak[bCh].abSrcOnOff[bBlock]);
 821                         strcat(gsbLogString, sbStr);
 822                 }
 823         }
 824         for(bCh = 0; bCh < DIT0_PATH_CHANNELS; bCh++)
 825         {
 826                 for(bBlock = 0; bBlock < SOURCE_BLOCK_NUM; bBlock++)
 827                 {
 828                         sprintf(sbStr, " asDit0[%d].abSrcOnOff[%d]=%02X", bCh, bBlock, pParam->asDit0[bCh].abSrcOnOff[bBlock]);
 829                         strcat(gsbLogString, sbStr);
 830                 }
 831         }
 832         for(bCh = 0; bCh < DIT1_PATH_CHANNELS; bCh++)
 833         {
 834                 for(bBlock = 0; bBlock < SOURCE_BLOCK_NUM; bBlock++)
 835                 {
 836                         sprintf(sbStr, " asDit1[%d].abSrcOnOff[%d]=%02X", bCh, bBlock, pParam->asDit1[bCh].abSrcOnOff[bBlock]);
 837                         strcat(gsbLogString, sbStr);
 838                 }
 839         }
 840         for(bCh = 0; bCh < DIT2_PATH_CHANNELS; bCh++)
 841         {
 842                 for(bBlock = 0; bBlock < SOURCE_BLOCK_NUM; bBlock++)
 843                 {
 844                         sprintf(sbStr, " asDit2[%d].abSrcOnOff[%d]=%02X", bCh, bBlock, pParam->asDit2[bCh].abSrcOnOff[bBlock]);
 845                         strcat(gsbLogString, sbStr);
 846                 }
 847         }
 848         for(bCh = 0; bCh < DAC_PATH_CHANNELS; bCh++)
 849         {
 850                 for(bBlock = 0; bBlock < SOURCE_BLOCK_NUM; bBlock++)
 851                 {
 852                         sprintf(sbStr, " asDac[%d].abSrcOnOff[%d]=%02X", bCh, bBlock, pParam->asDac[bCh].abSrcOnOff[bBlock]);
 853                         strcat(gsbLogString, sbStr);
 854                 }
 855         }
 856         for(bCh = 0; bCh < AE_PATH_CHANNELS; bCh++)
 857         {
 858                 for(bBlock = 0; bBlock < SOURCE_BLOCK_NUM; bBlock++)
 859                 {
 860                         sprintf(sbStr, " asAe[%d].abSrcOnOff[%d]=%02X", bCh, bBlock, pParam->asAe[bCh].abSrcOnOff[bBlock]);
 861                         strcat(gsbLogString, sbStr);
 862                 }
 863         }
 864         for(bCh = 0; bCh < CDSP_PATH_CHANNELS; bCh++)
 865         {
 866                 for(bBlock = 0; bBlock < SOURCE_BLOCK_NUM; bBlock++)
 867                 {
 868                         sprintf(sbStr, " asCdsp[%d].abSrcOnOff[%d]=%02X", bCh, bBlock, pParam->asCdsp[bCh].abSrcOnOff[bBlock]);
 869                         strcat(gsbLogString, sbStr);
 870                 }
 871         }
 872         for(bCh = 0; bCh < ADC0_PATH_CHANNELS; bCh++)
 873         {
 874                 for(bBlock = 0; bBlock < SOURCE_BLOCK_NUM; bBlock++)
 875                 {
 876                         sprintf(sbStr, " asAdc0[%d].abSrcOnOff[%d]=%02X", bCh, bBlock, pParam->asAdc0[bCh].abSrcOnOff[bBlock]);
 877                         strcat(gsbLogString, sbStr);
 878                 }
 879         }
 880         for(bCh = 0; bCh < ADC1_PATH_CHANNELS; bCh++)
 881         {
 882                 for(bBlock = 0; bBlock < SOURCE_BLOCK_NUM; bBlock++)
 883                 {
 884                         sprintf(sbStr, " asAdc1[%d].abSrcOnOff[%d]=%02X", bCh, bBlock, pParam->asAdc1[bCh].abSrcOnOff[bBlock]);
 885                         strcat(gsbLogString, sbStr);
 886                 }
 887         }
 888         for(bCh = 0; bCh < MIX_PATH_CHANNELS; bCh++)
 889         {
 890                 for(bBlock = 0; bBlock < SOURCE_BLOCK_NUM; bBlock++)
 891                 {
 892                         sprintf(sbStr, " asMix[%d].abSrcOnOff[%d]=%02X", bCh, bBlock, pParam->asMix[bCh].abSrcOnOff[bBlock]);
 893                         strcat(gsbLogString, sbStr);
 894                 }
 895         }
 896         for(bCh = 0; bCh < BIAS_PATH_CHANNELS; bCh++)
 897         {
 898                 for(bBlock = 0; bBlock < SOURCE_BLOCK_NUM; bBlock++)
 899                 {
 900                         sprintf(sbStr, " asBias[%d].abSrcOnOff[%d]=%02X", bCh, bBlock, pParam->asBias[bCh].abSrcOnOff[bBlock]);
 901                         strcat(gsbLogString, sbStr);
 902                 }
 903         }
 904 }
 905
 906 /****************************************************************************
 907  *      MakeVolInfoLog
 908  *
 909  *      Description:
 910  *                      Make Volume Info Parameter log.
 911  *      Arguments:
 912  *                      pParam  pointer to parameter
 913  *      Return:
 914  *                      none
 915  *
 916  ****************************************************************************/
 917 static void     MakeVolInfoLog
 918 (
 919         const MCDRV_VOL_INFO* pParam
 920 )
 921 {
 922         UINT8   bCh;
 923         CHAR    sbStr[80];
 924
 925         if(pParam == NULL)
 926         {
 927                 strcat(gsbLogString, " param=NULL");
 928                 return;
 929         }
 930
 931         for(bCh = 0; bCh < AD0_VOL_CHANNELS; bCh++)
 932         {
 933                 sprintf(sbStr, " aswD_Ad0[%d]=%04X", bCh, (UINT16)pParam->aswD_Ad0[bCh]);
 934                 strcat(gsbLogString, sbStr);
 935         }
 936         for(bCh = 0; bCh < AD1_VOL_CHANNELS; bCh++)
 937         {
 938                 sprintf(sbStr, " aswD_Ad1[%d]=%04X", bCh, (UINT16)pParam->aswD_Ad1[bCh]);
 939                 strcat(gsbLogString, sbStr);
 940         }
 941         for(bCh = 0; bCh < AENG6_VOL_CHANNELS; bCh++)
 942         {
 943                 sprintf(sbStr, " aswD_Aeng6[%d]=%04X", bCh, (UINT16)pParam->aswD_Aeng6[bCh]);
 944                 strcat(gsbLogString, sbStr);
 945         }
 946         for(bCh = 0; bCh < PDM_VOL_CHANNELS; bCh++)
 947         {
 948                 sprintf(sbStr, " aswD_Pdm[%d]=%04X", bCh, (UINT16)pParam->aswD_Pdm[bCh]);
 949                 strcat(gsbLogString, sbStr);
 950         }
 951         for(bCh = 0; bCh < DTMF_VOL_CHANNELS; bCh++)
 952         {
 953                 sprintf(sbStr, " aswD_Dtmfb[%d]=%04X", bCh, (UINT16)pParam->aswD_Dtmfb[bCh]);
 954                 strcat(gsbLogString, sbStr);
 955         }
 956         for(bCh = 0; bCh < DIO0_VOL_CHANNELS; bCh++)
 957         {
 958                 sprintf(sbStr, " aswD_Dir0[%d]=%04X", bCh, (UINT16)pParam->aswD_Dir0[bCh]);
 959                 strcat(gsbLogString, sbStr);
 960         }
 961         for(bCh = 0; bCh < DIO1_VOL_CHANNELS; bCh++)
 962         {
 963                 sprintf(sbStr, " aswD_Dir1[%d]=%04X", bCh, (UINT16)pParam->aswD_Dir1[bCh]);
 964                 strcat(gsbLogString, sbStr);
 965         }
 966         for(bCh = 0; bCh < DIO2_VOL_CHANNELS; bCh++)
 967         {
 968                 sprintf(sbStr, " aswD_Dir2[%d]=%04X", bCh, (UINT16)pParam->aswD_Dir2[bCh]);
 969                 strcat(gsbLogString, sbStr);
 970         }
 971         for(bCh = 0; bCh < AD0_VOL_CHANNELS; bCh++)
 972         {
 973                 sprintf(sbStr, " aswD_Ad0Att[%d]=%04X", bCh, (UINT16)pParam->aswD_Ad0Att[bCh]);
 974                 strcat(gsbLogString, sbStr);
 975         }
 976         for(bCh = 0; bCh < AD1_VOL_CHANNELS; bCh++)
 977         {
 978                 sprintf(sbStr, " aswD_Ad1Att[%d]=%04X", bCh, (UINT16)pParam->aswD_Ad1Att[bCh]);
 979                 strcat(gsbLogString, sbStr);
 980         }
 981         for(bCh = 0; bCh < DIO0_VOL_CHANNELS; bCh++)
 982         {
 983                 sprintf(sbStr, " aswD_Dir0Att[%d]=%04X", bCh, (UINT16)pParam->aswD_Dir0Att[bCh]);
 984                 strcat(gsbLogString, sbStr);
 985         }
 986         for(bCh = 0; bCh < DIO1_VOL_CHANNELS; bCh++)
 987         {
 988                 sprintf(sbStr, " aswD_Dir1Att[%d]=%04X", bCh, (UINT16)pParam->aswD_Dir1Att[bCh]);
 989                 strcat(gsbLogString, sbStr);
 990         }
 991         for(bCh = 0; bCh < DIO2_VOL_CHANNELS; bCh++)
 992         {
 993                 sprintf(sbStr, " aswD_Dir2Att[%d]=%04X", bCh, (UINT16)pParam->aswD_Dir2Att[bCh]);
 994                 strcat(gsbLogString, sbStr);
 995         }
 996         for(bCh = 0; bCh < PDM_VOL_CHANNELS; bCh++)
 997         {
 998                 sprintf(sbStr, " aswD_SideTone[%d]=%04X", bCh, (UINT16)pParam->aswD_SideTone[bCh]);
 999                 strcat(gsbLogString, sbStr);
1000         }
1001         for(bCh = 0; bCh < DTFM_VOL_CHANNELS; bCh++)
1002         {
1003                 sprintf(sbStr, " aswD_DtmfAtt[%d]=%04X", bCh, (UINT16)pParam->aswD_DtmfAtt[bCh]);
1004                 strcat(gsbLogString, sbStr);
1005         }
1006         for(bCh = 0; bCh < DAC_VOL_CHANNELS; bCh++)
1007         {
1008                 sprintf(sbStr, " aswD_DacMaster[%d]=%04X", bCh, (UINT16)pParam->aswD_DacMaster[bCh]);
1009                 strcat(gsbLogString, sbStr);
1010         }
1011         for(bCh = 0; bCh < DAC_VOL_CHANNELS; bCh++)
1012         {
1013                 sprintf(sbStr, " aswD_DacVoice[%d]=%04X", bCh, (UINT16)pParam->aswD_DacVoice[bCh]);
1014                 strcat(gsbLogString, sbStr);
1015         }
1016         for(bCh = 0; bCh < DAC_VOL_CHANNELS; bCh++)
1017         {
1018                 sprintf(sbStr, " aswD_DacAtt[%d]=%04X", bCh, (UINT16)pParam->aswD_DacAtt[bCh]);
1019                 strcat(gsbLogString, sbStr);
1020         }
1021         for(bCh = 0; bCh < DIO0_VOL_CHANNELS; bCh++)
1022         {
1023                 sprintf(sbStr, " aswD_Dit0[%d]=%04X",bCh, (UINT16)pParam->aswD_Dit0[bCh]);
1024                 strcat(gsbLogString, sbStr);
1025         }
1026         for(bCh = 0; bCh < DIO1_VOL_CHANNELS; bCh++)
1027         {
1028                 sprintf(sbStr, " aswD_Dit1[%d]=%04X", bCh, (UINT16)pParam->aswD_Dit1[bCh]);
1029                 strcat(gsbLogString, sbStr);
1030         }
1031         for(bCh = 0; bCh < DIO2_VOL_CHANNELS; bCh++)
1032         {
1033                 sprintf(sbStr, " aswD_Dit2[%d]=%04X", bCh, (UINT16)pParam->aswD_Dit2[bCh]);
1034                 strcat(gsbLogString, sbStr);
1035         }
1036         for(bCh = 0; bCh < AD0_VOL_CHANNELS; bCh++)
1037         {
1038                 sprintf(sbStr, " aswA_Ad0[%d]=%04X", bCh, (UINT16)pParam->aswA_Ad0[bCh]);
1039                 strcat(gsbLogString, sbStr);
1040         }
1041         for(bCh = 0; bCh < AD1_VOL_CHANNELS; bCh++)
1042         {
1043                 sprintf(sbStr, " aswA_Ad1[%d]=%04X", bCh, (UINT16)pParam->aswA_Ad1[bCh]);
1044                 strcat(gsbLogString, sbStr);
1045         }
1046         for(bCh = 0; bCh <LIN1_VOL_CHANNELS ; bCh++)
1047         {
1048                 sprintf(sbStr, " aswA_Lin1[%d]=%04X", bCh, (UINT16)pParam->aswA_Lin1[bCh]);
1049                 strcat(gsbLogString, sbStr);
1050         }
1051         for(bCh = 0; bCh < LIN2_VOL_CHANNELS; bCh++)
1052         {
1053                 sprintf(sbStr, " aswA_Lin2[%d]=%04X", bCh, (UINT16)pParam->aswA_Lin2[bCh]);
1054                 strcat(gsbLogString, sbStr);
1055         }
1056         for(bCh = 0; bCh < MIC1_VOL_CHANNELS; bCh++)
1057         {
1058                 sprintf(sbStr, " aswA_Mic1[%d]=%04X", bCh, (UINT16)pParam->aswA_Mic1[bCh]);
1059                 strcat(gsbLogString, sbStr);
1060         }
1061         for(bCh = 0; bCh < MIC2_VOL_CHANNELS; bCh++)
1062         {
1063                 sprintf(sbStr, " aswA_Mic2[%d]=%04X", bCh, (UINT16)pParam->aswA_Mic2[bCh]);
1064                 strcat(gsbLogString, sbStr);
1065         }
1066         for(bCh = 0; bCh < MIC3_VOL_CHANNELS; bCh++)
1067         {
1068                 sprintf(sbStr, " aswA_Mic3[%d]=%04X", bCh, (UINT16)pParam->aswA_Mic3[bCh]);
1069                 strcat(gsbLogString, sbStr);
1070         }
1071         for(bCh = 0; bCh < HP_VOL_CHANNELS; bCh++)
1072         {
1073                 sprintf(sbStr, " aswA_Hp[%d]=%04X", bCh, (UINT16)pParam->aswA_Hp[bCh]);
1074                 strcat(gsbLogString, sbStr);
1075         }
1076         for(bCh = 0; bCh < SP_VOL_CHANNELS; bCh++)
1077         {
1078                 sprintf(sbStr, " aswA_Sp[%d]=%04X", bCh, (UINT16)pParam->aswA_Sp[bCh]);
1079                 strcat(gsbLogString, sbStr);
1080         }
1081         for(bCh = 0; bCh < RC_VOL_CHANNELS; bCh++)
1082         {
1083                 sprintf(sbStr, " aswA_Rc[%d]=%04X", bCh, (UINT16)pParam->aswA_Rc[bCh]);
1084                 strcat(gsbLogString, sbStr);
1085         }
1086         for(bCh = 0; bCh < LOUT1_VOL_CHANNELS; bCh++)
1087         {
1088                 sprintf(sbStr, " aswA_Lout1[%d]=%04X", bCh, (UINT16)pParam->aswA_Lout1[bCh]);
1089                 strcat(gsbLogString, sbStr);
1090         }
1091         for(bCh = 0; bCh < LOUT2_VOL_CHANNELS; bCh++)
1092         {
1093                 sprintf(sbStr, " aswA_Lout2[%d]=%04X", bCh, (UINT16)pParam->aswA_Lout2[bCh]);
1094                 strcat(gsbLogString, sbStr);
1095         }
1096         for(bCh = 0; bCh < MIC1_VOL_CHANNELS; bCh++)
1097         {
1098                 sprintf(sbStr, " aswA_Mic1Gain[%d]=%04X", bCh, (UINT16)pParam->aswA_Mic1Gain[bCh]);
1099                 strcat(gsbLogString, sbStr);
1100         }
1101         for(bCh = 0; bCh < MIC2_VOL_CHANNELS; bCh++)
1102         {
1103                 sprintf(sbStr, " aswA_Mic2Gain[%d]=%04X", bCh, (UINT16)pParam->aswA_Mic2Gain[bCh]);
1104                 strcat(gsbLogString, sbStr);
1105         }
1106         for(bCh = 0; bCh < MIC3_VOL_CHANNELS; bCh++)
1107         {
1108                 sprintf(sbStr, " aswA_Mic3Gain[%d]=%04X", bCh, (UINT16)pParam->aswA_Mic3Gain[bCh]);
1109                 strcat(gsbLogString, sbStr);
1110         }
1111         for(bCh = 0; bCh < HPGAIN_VOL_CHANNELS; bCh++)
1112         {
1113                 sprintf(sbStr, " aswA_HpGain[%d]=%04X", bCh, (UINT16)pParam->aswA_HpGain[bCh]);
1114                 strcat(gsbLogString, sbStr);
1115         }
1116 }
1117
1118 /****************************************************************************
1119  *      MakeDIOInfoLog
1120  *
1121  *      Description:
1122  *                      Make Digital I/O Info Parameter log.
1123  *      Arguments:
1124  *                      pParam  pointer to parameter
1125  *      Return:
1126  *                      none
1127  *
1128  ****************************************************************************/
1129 static void     MakeDIOInfoLog
1130 (
1131         const MCDRV_DIO_INFO* pParam
1132 )
1133 {
1134         CHAR    sbStr[80];
1135         UINT8   bPort, bCh;
1136
1137         if(pParam == NULL)
1138         {
1139                 strcat(gsbLogString, " param=NULL");
1140                 return;
1141         }
1142
1143         for(bPort = 0; bPort < IOPORT_NUM; bPort++)
1144         {
1145                 sprintf(sbStr, " asPortInfo[%d].sDioCommon.bMasterSlave=%02X", bPort, pParam->asPortInfo[bPort].sDioCommon.bMasterSlave);
1146                 strcat(gsbLogString, sbStr);
1147                 sprintf(sbStr, " asPortInfo[%d].sDioCommon.bAutoFs=%02X", bPort, pParam->asPortInfo[bPort].sDioCommon.bAutoFs);
1148                 strcat(gsbLogString, sbStr);
1149                 sprintf(sbStr, " asPortInfo[%d].sDioCommon.bFs=%02X", bPort, pParam->asPortInfo[bPort].sDioCommon.bFs);
1150                 strcat(gsbLogString, sbStr);
1151                 sprintf(sbStr, " asPortInfo[%d].sDioCommon.bBckFs=%02X", bPort, pParam->asPortInfo[bPort].sDioCommon.bBckFs);
1152                 strcat(gsbLogString, sbStr);
1153                 sprintf(sbStr, " asPortInfo[%d].sDioCommon.bInterface=%02X", bPort, pParam->asPortInfo[bPort].sDioCommon.bInterface);
1154                 strcat(gsbLogString, sbStr);
1155                 sprintf(sbStr, " asPortInfo[%d].sDioCommon.bBckInvert=%02X", bPort, pParam->asPortInfo[bPort].sDioCommon.bBckInvert);
1156                 strcat(gsbLogString, sbStr);
1157                 sprintf(sbStr, " asPortInfo[%d].sDioCommon.bPcmHizTim=%02X", bPort, pParam->asPortInfo[bPort].sDioCommon.bPcmHizTim);
1158                 strcat(gsbLogString, sbStr);
1159                 sprintf(sbStr, " asPortInfo[%d].sDioCommon.bPcmClkDown=%02X", bPort, pParam->asPortInfo[bPort].sDioCommon.bPcmClkDown);
1160                 strcat(gsbLogString, sbStr);
1161                 sprintf(sbStr, " asPortInfo[%d].sDioCommon.bPcmFrame=%02X", bPort, pParam->asPortInfo[bPort].sDioCommon.bPcmFrame);
1162                 strcat(gsbLogString, sbStr);
1163                 sprintf(sbStr, " asPortInfo[%d].sDioCommon.bPcmHighPeriod=%02X", bPort, pParam->asPortInfo[bPort].sDioCommon.bPcmHighPeriod);
1164                 strcat(gsbLogString, sbStr);
1165
1166                 sprintf(sbStr, " asPortInfo[%d].sDir.wSrcRate=%04X", bPort, pParam->asPortInfo[bPort].sDir.wSrcRate);
1167                 strcat(gsbLogString, sbStr);
1168                 sprintf(sbStr, " asPortInfo[%d].sDir.sDaFormat.bBitSel=%02X", bPort, pParam->asPortInfo[bPort].sDir.sDaFormat.bBitSel);
1169                 strcat(gsbLogString, sbStr);
1170                 sprintf(sbStr, " asPortInfo[%d].sDir.sDaFormat.bMode=%02X", bPort, pParam->asPortInfo[bPort].sDir.sDaFormat.bMode);
1171                 strcat(gsbLogString, sbStr);
1172                 sprintf(sbStr, " asPortInfo[%d].sDir.sPcmFormat.bMono=%02X", bPort, pParam->asPortInfo[bPort].sDir.sPcmFormat.bMono);
1173                 strcat(gsbLogString, sbStr);
1174                 sprintf(sbStr, " asPortInfo[%d].sDir.sPcmFormat.bOrder=%02X", bPort, pParam->asPortInfo[bPort].sDir.sPcmFormat.bOrder);
1175                 strcat(gsbLogString, sbStr);
1176                 sprintf(sbStr, " asPortInfo[%d].sDir.sPcmFormat.bLaw=%02X", bPort, pParam->asPortInfo[bPort].sDir.sPcmFormat.bLaw);
1177                 strcat(gsbLogString, sbStr);
1178                 sprintf(sbStr, " asPortInfo[%d].sDir.sPcmFormat.bBitSel=%02X", bPort, pParam->asPortInfo[bPort].sDir.sPcmFormat.bBitSel);
1179                 strcat(gsbLogString, sbStr);
1180                 for(bCh = 0; bCh < DIO_CHANNELS; bCh++)
1181                 {
1182                         sprintf(sbStr, " asPortInfo[%d].sDir.abSlot[%d]=%02X", bPort, bCh, pParam->asPortInfo[bPort].sDir.abSlot[bCh]);
1183                         strcat(gsbLogString, sbStr);
1184                 }
1185
1186                 sprintf(sbStr, " asPortInfo[%d].sDit.wSrcRate=%04X", bPort, pParam->asPortInfo[bPort].sDit.wSrcRate);
1187                 strcat(gsbLogString, sbStr);
1188                 sprintf(sbStr, " asPortInfo[%d].sDit.sDaFormat.bBitSel=%02X", bPort, pParam->asPortInfo[bPort].sDit.sDaFormat.bBitSel);
1189                 strcat(gsbLogString, sbStr);
1190                 sprintf(sbStr, " asPortInfo[%d].sDit.sDaFormat.bMode=%02X", bPort, pParam->asPortInfo[bPort].sDit.sDaFormat.bMode);
1191                 strcat(gsbLogString, sbStr);
1192                 sprintf(sbStr, " asPortInfo[%d].sDit.sPcmFormat.bMono=%02X", bPort, pParam->asPortInfo[bPort].sDit.sPcmFormat.bMono);
1193                 strcat(gsbLogString, sbStr);
1194                 sprintf(sbStr, " asPortInfo[%d].sDit.sPcmFormat.bOrder=%02X", bPort, pParam->asPortInfo[bPort].sDit.sPcmFormat.bOrder);
1195                 strcat(gsbLogString, sbStr);
1196                 sprintf(sbStr, " asPortInfo[%d].sDit.sPcmFormat.bLaw=%02X", bPort, pParam->asPortInfo[bPort].sDit.sPcmFormat.bLaw);
1197                 strcat(gsbLogString, sbStr);
1198                 sprintf(sbStr, " asPortInfo[%d].sDit.sPcmFormat.bBitSel=%02X", bPort, pParam->asPortInfo[bPort].sDit.sPcmFormat.bBitSel);
1199                 strcat(gsbLogString, sbStr);
1200                 for(bCh = 0; bCh < DIO_CHANNELS; bCh++)
1201                 {
1202                         sprintf(sbStr, " asPortInfo[%d].sDit.abSlot[%d]=%02X", bPort, bCh, pParam->asPortInfo[bPort].sDit.abSlot[bCh]);
1203                         strcat(gsbLogString, sbStr);
1204                 }
1205         }
1206 }
1207
1208 /****************************************************************************
1209  *      MakeDACInfoLog
1210  *
1211  *      Description:
1212  *                      Make DAC Info Parameter log.
1213  *      Arguments:
1214  *                      pParam  pointer to parameter
1215  *      Return:
1216  *                      none
1217  *
1218  ****************************************************************************/
1219 static void     MakeDACInfoLog
1220 (
1221         const MCDRV_DAC_INFO* pParam
1222 )
1223 {
1224         CHAR    sbStr[80];
1225
1226         if(pParam == NULL)
1227         {
1228                 strcat(gsbLogString, " param=NULL");
1229                 return;
1230         }
1231
1232         sprintf(sbStr, " bMasterSwap=%02X", pParam->bMasterSwap);
1233         strcat(gsbLogString, sbStr);
1234         sprintf(sbStr, " bVoiceSwap=%02X", pParam->bVoiceSwap);
1235         strcat(gsbLogString, sbStr);
1236         sprintf(sbStr, " bDcCut=%02X", pParam->bDcCut);
1237         strcat(gsbLogString, sbStr);
1238 }
1239
1240 /****************************************************************************
1241  *      MakeADCInfoLog
1242  *
1243  *      Description:
1244  *                      Make ADC Info Parameter log.
1245  *      Arguments:
1246  *                      pParam  pointer to parameter
1247  *      Return:
1248  *                      none
1249  *
1250  ****************************************************************************/
1251 static void     MakeADCInfoLog
1252 (
1253         const MCDRV_ADC_INFO* pParam
1254 )
1255 {
1256         CHAR    sbStr[80];
1257
1258         if(pParam == NULL)
1259         {
1260                 strcat(gsbLogString, " param=NULL");
1261                 return;
1262         }
1263
1264         sprintf(sbStr, " bAgcAdjust=%02X", pParam->bAgcAdjust);
1265         strcat(gsbLogString, sbStr);
1266         sprintf(sbStr, " bAgcOn=%02X", pParam->bAgcOn);
1267         strcat(gsbLogString, sbStr);
1268         sprintf(sbStr, " bMono=%02X", pParam->bMono);
1269         strcat(gsbLogString, sbStr);
1270 }
1271
1272 /****************************************************************************
1273  *      MakeSpInfoLog
1274  *
1275  *      Description:
1276  *                      Make Sp Info Parameter log.
1277  *      Arguments:
1278  *                      pParam  pointer to parameter
1279  *      Return:
1280  *                      none
1281  *
1282  ****************************************************************************/
1283 static void     MakeSpInfoLog
1284 (
1285         const MCDRV_SP_INFO* pParam
1286 )
1287 {
1288         CHAR    sbStr[80];
1289
1290         if(pParam == NULL)
1291         {
1292                 strcat(gsbLogString, " param=NULL");
1293                 return;
1294         }
1295
1296         sprintf(sbStr, " bSwap=%02X", pParam->bSwap);
1297         strcat(gsbLogString, sbStr);
1298 }
1299
1300 /****************************************************************************
1301  *      MakeDNGInfoLog
1302  *
1303  *      Description:
1304  *                      Make DNG Info Parameter log.
1305  *      Arguments:
1306  *                      pParam  pointer to parameter
1307  *      Return:
1308  *                      none
1309  *
1310  ****************************************************************************/
1311 static void     MakeDNGInfoLog
1312 (
1313         const MCDRV_DNG_INFO* pParam
1314 )
1315 {
1316         CHAR    sbStr[80];
1317         UINT8   bItem;
1318
1319         if(pParam == NULL)
1320         {
1321                 strcat(gsbLogString, " param=NULL");
1322                 return;
1323         }
1324
1325         for(bItem = 0; bItem < DNG_ITEM_NUM; bItem++)
1326         {
1327                 sprintf(sbStr, " abOnOff[%d]=%02X", bItem, pParam->abOnOff[bItem]);
1328                 strcat(gsbLogString, sbStr);
1329                 sprintf(sbStr, " abThreshold[%d]=%02X", bItem, pParam->abThreshold[bItem]);
1330                 strcat(gsbLogString, sbStr);
1331                 sprintf(sbStr, " abHold[%d]=%02X", bItem, pParam->abHold[bItem]);
1332                 strcat(gsbLogString, sbStr);
1333                 sprintf(sbStr, " abAttack[%d]=%02X", bItem, pParam->abAttack[bItem]);
1334                 strcat(gsbLogString, sbStr);
1335                 sprintf(sbStr, " abRelease[%d]=%02X", bItem, pParam->abRelease[bItem]);
1336                 strcat(gsbLogString, sbStr);
1337                 sprintf(sbStr, " abTarget[%d]=%02X", bItem, pParam->abTarget[bItem]);
1338                 strcat(gsbLogString, sbStr);
1339         }
1340 }
1341
1342 /****************************************************************************
1343  *      MakeAEInfoLog
1344  *
1345  *      Description:
1346  *                      Make AudioEngine Info Parameter log.
1347  *      Arguments:
1348  *                      pParam  pointer to parameter
1349  *      Return:
1350  *                      none
1351  *
1352  ****************************************************************************/
1353 static void     MakeAEInfoLog
1354 (
1355         const MCDRV_AE_INFO* pParam
1356 )
1357 {
1358         CHAR    sbStr[80];
1359         UINT16  wIdx;
1360
1361         if(pParam == NULL)
1362         {
1363                 strcat(gsbLogString, " param=NULL");
1364                 return;
1365         }
1366
1367         sprintf(sbStr, " bOnOff=%02X", pParam->bOnOff);
1368         strcat(gsbLogString, sbStr);
1369
1370         for(wIdx = 0; wIdx < BEX_PARAM_SIZE; wIdx++)
1371         {
1372                 sprintf(sbStr, " abBex[%d]=%02X", wIdx, pParam->abBex[wIdx]);
1373                 strcat(gsbLogString, sbStr);
1374         }
1375         for(wIdx = 0; wIdx < WIDE_PARAM_SIZE; wIdx++)
1376         {
1377                 sprintf(sbStr, " abWide[%d]=%02X", wIdx, pParam->abWide[wIdx]);
1378                 strcat(gsbLogString, sbStr);
1379         }
1380         for(wIdx = 0; wIdx < DRC_PARAM_SIZE; wIdx++)
1381         {
1382                 sprintf(sbStr, " abDrc[%d]=%02X", wIdx, pParam->abDrc[wIdx]);
1383                 strcat(gsbLogString, sbStr);
1384         }
1385         for(wIdx = 0; wIdx < EQ5_PARAM_SIZE; wIdx++)
1386         {
1387                 sprintf(sbStr, " abEq5[%d]=%02X", wIdx, pParam->abEq5[wIdx]);
1388                 strcat(gsbLogString, sbStr);
1389         }
1390         for(wIdx = 0; wIdx < EQ3_PARAM_SIZE; wIdx++)
1391         {
1392                 sprintf(sbStr, " abEq3[%d]=%02X", wIdx, pParam->abEq3[wIdx]);
1393                 strcat(gsbLogString, sbStr);
1394         }
1395 }
1396
1397 /****************************************************************************
1398  *      MakeAEExInfoLog
1399  *
1400  *      Description:
1401  *                      Make AudioEngineEx Info Parameter log.
1402  *      Arguments:
1403  *                      pParam  pointer to parameter
1404  *      Return:
1405  *                      none
1406  *
1407  ****************************************************************************/
1408 static void     MakeAEExInfoLog
1409 (
1410         const UINT16* pParam
1411 )
1412 {
1413         CHAR    sbStr[80];
1414
1415         if(pParam == NULL)
1416         {
1417                 strcat(gsbLogString, " param=NULL");
1418                 return;
1419         }
1420
1421         sprintf(sbStr, " param=%04X", *pParam);
1422         strcat(gsbLogString, sbStr);
1423 }
1424
1425 /****************************************************************************
1426  *      MakeSetCDSPLog
1427  *
1428  *      Description:
1429  *                      Make CDSP Parameter log.
1430  *      Arguments:
1431  *                      pParam  pointer to parameter
1432  *      Return:
1433  *                      none
1434  *
1435  ****************************************************************************/
1436 static void     MakeSetCDSPLog
1437 (
1438         const UINT16* pParam
1439 )
1440 {
1441         CHAR    sbStr[80];
1442
1443         if(pParam == NULL)
1444         {
1445                 strcat(gsbLogString, " param=NULL");
1446                 return;
1447         }
1448
1449         sprintf(sbStr, " param=%04X", *pParam);
1450         strcat(gsbLogString, sbStr);
1451 }
1452
1453 /****************************************************************************
1454  *      MakeCDSPParamLog
1455  *
1456  *      Description:
1457  *                      Make CDSP Parameter log.
1458  *      Arguments:
1459  *                      pParam  pointer to parameter
1460  *      Return:
1461  *                      none
1462  *
1463  ****************************************************************************/
1464 static void     MakeCDSPParamLog
1465 (
1466         const MCDRV_CDSPPARAM* pParam
1467 )
1468 {
1469         CHAR    sbStr[80];
1470         UINT8   bIdx;
1471
1472         if(pParam == NULL)
1473         {
1474                 strcat(gsbLogString, " param=NULL");
1475                 return;
1476         }
1477
1478         sprintf(sbStr, " bId=%02X", pParam->bId);
1479         strcat(gsbLogString, sbStr);
1480         for(bIdx = 0; bIdx < 16; bIdx++)
1481         {
1482                 sprintf(sbStr, " abParam[%d]=%02X", bIdx, pParam->abParam[bIdx]);
1483                 strcat(gsbLogString, sbStr);
1484         }
1485 }
1486
1487 /****************************************************************************
1488  *      MakeCDSPCBLog
1489  *
1490  *      Description:
1491  *                      Make CDSP Callback Parameter log.
1492  *      Arguments:
1493  *                      pParam  pointer to parameter
1494  *      Return:
1495  *                      none
1496  *
1497  ****************************************************************************/
1498 static void     MakeCDSPCBLog
1499 (
1500         const void* pParam
1501 )
1502 {
1503         CHAR    sbStr[80];
1504
1505         if(pParam == NULL)
1506         {
1507                 strcat(gsbLogString, " param=NULL");
1508                 return;
1509         }
1510
1511         sprintf(sbStr, " param=%08lX", *(UINT32*)pParam);
1512         strcat(gsbLogString, sbStr);
1513 }
1514
1515 /****************************************************************************
1516  *      MakePDMInfoLog
1517  *
1518  *      Description:
1519  *                      Make PDM Info Parameter log.
1520  *      Arguments:
1521  *                      pParam  pointer to parameter
1522  *      Return:
1523  *                      none
1524  *
1525  ****************************************************************************/
1526 static void     MakePDMInfoLog
1527 (
1528         const MCDRV_PDM_INFO* pParam
1529 )
1530 {
1531         CHAR    sbStr[80];
1532
1533         if(pParam == NULL)
1534         {
1535                 strcat(gsbLogString, " param=NULL");
1536                 return;
1537         }
1538
1539         sprintf(sbStr, " bClk=%02X", pParam->bClk);
1540         strcat(gsbLogString, sbStr);
1541         sprintf(sbStr, " bAgcAdjust=%02X", pParam->bAgcAdjust);
1542         strcat(gsbLogString, sbStr);
1543         sprintf(sbStr, " bAgcOn=%02X", pParam->bAgcOn);
1544         strcat(gsbLogString, sbStr);
1545         sprintf(sbStr, " bPdmEdge=%02X", pParam->bPdmEdge);
1546         strcat(gsbLogString, sbStr);
1547         sprintf(sbStr, " bPdmWait=%02X", pParam->bPdmWait);
1548         strcat(gsbLogString, sbStr);
1549         sprintf(sbStr, " bPdmSel=%02X", pParam->bPdmSel);
1550         strcat(gsbLogString, sbStr);
1551         sprintf(sbStr, " bMono=%02X", pParam->bMono);
1552         strcat(gsbLogString, sbStr);
1553 }
1554
1555 /****************************************************************************
1556  *      MakeDTMFInfoLog
1557  *
1558  *      Description:
1559  *                      Make DTMF Info Parameter log.
1560  *      Arguments:
1561  *                      pParam  pointer to parameter
1562  *      Return:
1563  *                      none
1564  *
1565  ****************************************************************************/
1566 static void     MakeDTMFInfoLog
1567 (
1568         const MCDRV_DTMF_INFO* pParam
1569 )
1570 {
1571         CHAR    sbStr[80];
1572
1573         if(pParam == NULL)
1574         {
1575                 strcat(gsbLogString, " param=NULL");
1576                 return;
1577         }
1578
1579         sprintf(sbStr, " bOnOff=%02X", pParam->bOnOff);
1580         strcat(gsbLogString, sbStr);
1581
1582         sprintf(sbStr, " sParam.bSinGen0Vol=%02X", pParam->sParam.bSinGen0Vol);
1583         strcat(gsbLogString, sbStr);
1584         sprintf(sbStr, " sParam.bSinGen1Vol=%02X", pParam->sParam.bSinGen1Vol);
1585         strcat(gsbLogString, sbStr);
1586         sprintf(sbStr, " sParam.wSinGen0Freq=%04X", pParam->sParam.wSinGen0Freq);
1587         strcat(gsbLogString, sbStr);
1588         sprintf(sbStr, " sParam.wSinGen1Freq=%04X", pParam->sParam.wSinGen1Freq);
1589         strcat(gsbLogString, sbStr);
1590         sprintf(sbStr, " sParam.bSinGenGate=%02X", pParam->sParam.bSinGenGate);
1591         strcat(gsbLogString, sbStr);
1592         sprintf(sbStr, " sParam.=bSinGenMode%02X", pParam->sParam.bSinGenMode);
1593         strcat(gsbLogString, sbStr);
1594         sprintf(sbStr, " sParam.bSinGenLoop=%02X", pParam->sParam.bSinGenLoop);
1595         strcat(gsbLogString, sbStr);
1596 }
1597
1598 /****************************************************************************
1599  *      MakeGPModeLog
1600  *
1601  *      Description:
1602  *                      Make GPIO mode Info Parameter log.
1603  *      Arguments:
1604  *                      pParam  pointer to parameter
1605  *      Return:
1606  *                      none
1607  *
1608  ****************************************************************************/
1609 static void     MakeGPModeLog
1610 (
1611         const MCDRV_GP_MODE* pParam
1612 )
1613 {
1614         CHAR    sbStr[80];
1615         UINT8   bPadNo;
1616
1617         if(pParam == NULL)
1618         {
1619                 strcat(gsbLogString, " param=NULL");
1620                 return;
1621         }
1622
1623         for(bPadNo = 0; bPadNo < GPIO_PAD_NUM; bPadNo++)
1624         {
1625                 sprintf(sbStr, " abGpDdr[%d]=%02X", bPadNo, pParam->abGpDdr[bPadNo]);
1626                 strcat(gsbLogString, sbStr);
1627         }
1628         for(bPadNo = 0; bPadNo < GPIO_PAD_NUM; bPadNo++)
1629         {
1630                 sprintf(sbStr, " abGpMode[%d]=%02X", bPadNo, pParam->abGpMode[bPadNo]);
1631                 strcat(gsbLogString, sbStr);
1632         }
1633         for(bPadNo = 0; bPadNo < GPIO_PAD_NUM; bPadNo++)
1634         {
1635                 sprintf(sbStr, " abGpHost[%d]=%02X", bPadNo, pParam->abGpHost[bPadNo]);
1636                 strcat(gsbLogString, sbStr);
1637         }
1638         for(bPadNo = 0; bPadNo < GPIO_PAD_NUM; bPadNo++)
1639         {
1640                 sprintf(sbStr, " abGpInvert[%d]=%02X", bPadNo, pParam->abGpInvert[bPadNo]);
1641                 strcat(gsbLogString, sbStr);
1642         }
1643 }
1644
1645 /****************************************************************************
1646  *      MakeGPMaskLog
1647  *
1648  *      Description:
1649  *                      Make GPIO Mask Info Parameter log.
1650  *      Arguments:
1651  *                      pParam  pointer to parameter
1652  *      Return:
1653  *                      none
1654  *
1655  ****************************************************************************/
1656 static void     MakeGPMaskLog
1657 (
1658         const UINT8* pParam
1659 )
1660 {
1661         CHAR    sbStr[80];
1662
1663         if(pParam == NULL)
1664         {
1665                 strcat(gsbLogString, " param=NULL");
1666                 return;
1667         }
1668
1669         sprintf(sbStr, " mask=%02X", *pParam);
1670         strcat(gsbLogString, sbStr);
1671 }
1672
1673 /****************************************************************************
1674  *      MakeGetSetGPLog
1675  *
1676  *      Description:
1677  *                      Make Get/Set GPIO Info Parameter log.
1678  *      Arguments:
1679  *                      pParam  pointer to parameter
1680  *      Return:
1681  *                      none
1682  *
1683  ****************************************************************************/
1684 static void     MakeGetSetGPLog
1685 (
1686         const UINT8* pParam
1687 )
1688 {
1689         CHAR    sbStr[80];
1690
1691         if(pParam == NULL)
1692         {
1693                 strcat(gsbLogString, " param=NULL");
1694                 return;
1695         }
1696
1697         sprintf(sbStr, " HiLow=%02X", *pParam);
1698         strcat(gsbLogString, sbStr);
1699 }
1700
1701 /****************************************************************************
1702  *      MakePeakLog
1703  *
1704  *      Description:
1705  *                      Make Peak Parameter log.
1706  *      Arguments:
1707  *                      pParam  pointer to parameter
1708  *      Return:
1709  *                      none
1710  *
1711  ****************************************************************************/
1712 static void     MakePeakLog
1713 (
1714         const MCDRV_PEAK* pParam
1715 )
1716 {
1717         CHAR    sbStr[80];
1718         UINT8   bIdx;
1719
1720         if(pParam == NULL)
1721         {
1722                 strcat(gsbLogString, " param=NULL");
1723                 return;
1724         }
1725
1726         for(bIdx = 0; bIdx < PEAK_CHANNELS; bIdx++)
1727         {
1728                 sprintf(sbStr, " aswPeak[%d]=%02X", bIdx, pParam->aswPeak[bIdx]);
1729                 strcat(gsbLogString, sbStr);
1730         }
1731 }
1732
1733 /****************************************************************************
1734  *      MakeSysEQInfoLog
1735  *
1736  *      Description:
1737  *                      Make System EQ Info Parameter log.
1738  *      Arguments:
1739  *                      pParam  pointer to parameter
1740  *      Return:
1741  *                      none
1742  *
1743  ****************************************************************************/
1744 static void     MakeSysEQInfoLog
1745 (
1746         const MCDRV_SYSEQ_INFO* pParam
1747 )
1748 {
1749         CHAR    sbStr[80];
1750         UINT8   bIdx;
1751
1752         if(pParam == NULL)
1753         {
1754                 strcat(gsbLogString, " param=NULL");
1755                 return;
1756         }
1757
1758         sprintf(sbStr, " bOnOff=%02X", pParam->bOnOff);
1759         strcat(gsbLogString, sbStr);
1760
1761         for(bIdx = 0; bIdx < 15; bIdx++)
1762         {
1763                 sprintf(sbStr, " abParam[%d]=%02X", bIdx, pParam->abParam[bIdx]);
1764                 strcat(gsbLogString, sbStr);
1765         }
1766 }
1767
1768
1769
1770
1771 #endif  /*      MCDRV_DEBUG_LEVEL       */