drivers/misc/mediatek/connectivity/combo/drv_wlan/mt6628/wlan/common/dump.c

   1 /*
   2 ** $Id: //Department/DaVinci/BRANCHES/MT6620_WIFI_DRIVER_V2_3/common/dump.c#1 $
   3 */
   4
   5 /*! \file   "dump.c"
   6     \brief  Provide memory dump function for debugging.
   7
   8     Provide memory dump function for debugging.
   9 */
  10
  11
  12
  13 /*
  14 ** $Log: dump.c $
  15  *
  16  * 11 24 2011 wh.su
  17  * [WCXRP00001078] [MT6620 Wi-Fi][Driver] Adding the mediatek log improment support : XLOG
  18  * Adjust code for DBG and CONFIG_XLOG.
  19  *
  20  * 11 10 2011 wh.su
  21  * [WCXRP00001078] [MT6620 Wi-Fi][Driver] Adding the mediatek log improment support : XLOG
  22  * Using the new XLOG define for dum Memory.
  23  *
  24  * 11 03 2011 wh.su
  25  * [WCXRP00001078] [MT6620 Wi-Fi][Driver] Adding the mediatek log improment support : XLOG
  26  * Add dumpMemory8 at XLOG support.
  27  *
  28  * 07 08 2010 cp.wu
  29  *
  30  * [WPD00003833] [MT6620 and MT5931] Driver migration - move to new repository.
  31  *
  32  * 06 06 2010 kevin.huang
  33  * [WPD00003832][MT6620 5931] Create driver base
  34  * [MT6620 5931] Create driver base
  35 **  \main\maintrunk.MT6620WiFiDriver_Prj\2 2009-03-10 19:58:51 GMT mtk01426
  36 **  Init develop
  37 **
  38 */
  39
  40 /*******************************************************************************
  41 *                         C O M P I L E R   F L A G S
  42 ********************************************************************************
  43 */
  44
  45 /*******************************************************************************
  46 *                    E X T E R N A L   R E F E R E N C E S
  47 ********************************************************************************
  48 */
  49 #include "precomp.h"
  50
  51 /*******************************************************************************
  52 *                              C O N S T A N T S
  53 ********************************************************************************
  54 */
  55
  56 /*******************************************************************************
  57 *                             D A T A   T Y P E S
  58 ********************************************************************************
  59 */
  60
  61 /*******************************************************************************
  62 *                            P U B L I C   D A T A
  63 ********************************************************************************
  64 */
  65
  66 /*******************************************************************************
  67 *                           P R I V A T E   D A T A
  68 ********************************************************************************
  69 */
  70
  71 /*******************************************************************************
  72 *                                 M A C R O S
  73 ********************************************************************************
  74 */
  75
  76 /*******************************************************************************
  77 *                   F U N C T I O N   D E C L A R A T I O N S
  78 ********************************************************************************
  79 */
  80
  81 /*******************************************************************************
  82 *                              F U N C T I O N S
  83 ********************************************************************************
  84 */
  85 #if DBG
  86 /*----------------------------------------------------------------------------*/
  87 /*!
  88 * \brief This routine is called to dump a segment of memory in bytes.
  89 *
  90 * \param[in] pucStartAddr   Pointer to the starting address of the memory to be dumped.
  91 * \param[in] u4Length       Length of the memory to be dumped.
  92 *
  93 * \return (none)
  94 */
  95 /*----------------------------------------------------------------------------*/
  96 VOID dumpMemory8(IN PUINT_8 pucStartAddr, IN UINT_32 u4Length)
  97 {
  98         ASSERT(pucStartAddr);
  99
 100         LOG_FUNC("DUMP8 ADDRESS: %08lx, Length: %ld\n", (UINT_32) pucStartAddr, u4Length);
 101
 102         while (u4Length > 0) {
 103                 if (u4Length >= 16) {
 104                         LOG_FUNC
 105                             ("(%08lx) %02x %02x %02x %02x  %02x %02x %02x %02x - %02x %02x %02x %02x  %02x %02x %02x %02x\n",
 106                              (UINT_32) pucStartAddr, pucStartAddr[0], pucStartAddr[1],
 107                              pucStartAddr[2], pucStartAddr[3], pucStartAddr[4], pucStartAddr[5],
 108                              pucStartAddr[6], pucStartAddr[7], pucStartAddr[8], pucStartAddr[9],
 109                              pucStartAddr[10], pucStartAddr[11], pucStartAddr[12], pucStartAddr[13],
 110                              pucStartAddr[14], pucStartAddr[15]);
 111                         u4Length -= 16;
 112                         pucStartAddr += 16;
 113                 } else {
 114                         switch (u4Length) {
 115                         case 1:
 116                                 LOG_FUNC("(%08lx) %02x\n", (UINT_32) pucStartAddr, pucStartAddr[0]);
 117                                 break;
 118                         case 2:
 119                                 LOG_FUNC("(%08lx) %02x %02x\n",
 120                                          (UINT_32) pucStartAddr, pucStartAddr[0], pucStartAddr[1]);
 121                                 break;
 122                         case 3:
 123                                 LOG_FUNC("(%08lx) %02x %02x %02x\n",
 124                                          (UINT_32) pucStartAddr,
 125                                          pucStartAddr[0], pucStartAddr[1], pucStartAddr[2]);
 126                                 break;
 127                         case 4:
 128                                 LOG_FUNC("(%08lx) %02x %02x %02x %02x\n",
 129                                          (UINT_32) pucStartAddr,
 130                                          pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 131                                          pucStartAddr[3]);
 132                                 break;
 133                         case 5:
 134                                 LOG_FUNC("(%08lx) %02x %02x %02x %02x  %02x\n",
 135                                          (UINT_32) pucStartAddr,
 136                                          pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 137                                          pucStartAddr[3], pucStartAddr[4]);
 138                                 break;
 139                         case 6:
 140                                 LOG_FUNC("(%08lx) %02x %02x %02x %02x  %02x %02x\n",
 141                                          (UINT_32) pucStartAddr,
 142                                          pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 143                                          pucStartAddr[3], pucStartAddr[4], pucStartAddr[5]);
 144                                 break;
 145                         case 7:
 146                                 LOG_FUNC("(%08lx) %02x %02x %02x %02x  %02x %02x %02x\n",
 147                                          (UINT_32) pucStartAddr,
 148                                          pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 149                                          pucStartAddr[3], pucStartAddr[4], pucStartAddr[5],
 150                                          pucStartAddr[6]);
 151                                 break;
 152                         case 8:
 153                                 LOG_FUNC("(%08lx) %02x %02x %02x %02x  %02x %02x %02x %02x\n",
 154                                          (UINT_32) pucStartAddr,
 155                                          pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 156                                          pucStartAddr[3], pucStartAddr[4], pucStartAddr[5],
 157                                          pucStartAddr[6], pucStartAddr[7]);
 158                                 break;
 159                         case 9:
 160                                 LOG_FUNC
 161                                     ("(%08lx) %02x %02x %02x %02x  %02x %02x %02x %02x - %02x\n",
 162                                      (UINT_32) pucStartAddr, pucStartAddr[0], pucStartAddr[1],
 163                                      pucStartAddr[2], pucStartAddr[3], pucStartAddr[4],
 164                                      pucStartAddr[5], pucStartAddr[6], pucStartAddr[7],
 165                                      pucStartAddr[8]);
 166                                 break;
 167                         case 10:
 168                                 LOG_FUNC
 169                                     ("(%08lx) %02x %02x %02x %02x  %02x %02x %02x %02x - %02x %02x\n",
 170                                      (UINT_32) pucStartAddr, pucStartAddr[0], pucStartAddr[1],
 171                                      pucStartAddr[2], pucStartAddr[3], pucStartAddr[4],
 172                                      pucStartAddr[5], pucStartAddr[6], pucStartAddr[7],
 173                                      pucStartAddr[8], pucStartAddr[9]);
 174                                 break;
 175                         case 11:
 176                                 LOG_FUNC
 177                                     ("(%08lx) %02x %02x %02x %02x  %02x %02x %02x %02x - %02x %02x %02x\n",
 178                                      (UINT_32) pucStartAddr, pucStartAddr[0], pucStartAddr[1],
 179                                      pucStartAddr[2], pucStartAddr[3], pucStartAddr[4],
 180                                      pucStartAddr[5], pucStartAddr[6], pucStartAddr[7],
 181                                      pucStartAddr[8], pucStartAddr[9], pucStartAddr[10]);
 182                                 break;
 183                         case 12:
 184                                 LOG_FUNC
 185                                     ("(%08lx) %02x %02x %02x %02x  %02x %02x %02x %02x - %02x %02x %02x %02x\n",
 186                                      (UINT_32) pucStartAddr, pucStartAddr[0], pucStartAddr[1],
 187                                      pucStartAddr[2], pucStartAddr[3], pucStartAddr[4],
 188                                      pucStartAddr[5], pucStartAddr[6], pucStartAddr[7],
 189                                      pucStartAddr[8], pucStartAddr[9], pucStartAddr[10],
 190                                      pucStartAddr[11]);
 191                                 break;
 192                         case 13:
 193                                 LOG_FUNC
 194                                     ("(%08lx) %02x %02x %02x %02x  %02x %02x %02x %02x - %02x %02x %02x %02x  %02x\n",
 195                                      (UINT_32) pucStartAddr, pucStartAddr[0], pucStartAddr[1],
 196                                      pucStartAddr[2], pucStartAddr[3], pucStartAddr[4],
 197                                      pucStartAddr[5], pucStartAddr[6], pucStartAddr[7],
 198                                      pucStartAddr[8], pucStartAddr[9], pucStartAddr[10],
 199                                      pucStartAddr[11], pucStartAddr[12]);
 200                                 break;
 201                         case 14:
 202                                 LOG_FUNC
 203                                     ("(%08lx) %02x %02x %02x %02x  %02x %02x %02x %02x - %02x %02x %02x %02x  %02x %02x\n",
 204                                      (UINT_32) pucStartAddr, pucStartAddr[0], pucStartAddr[1],
 205                                      pucStartAddr[2], pucStartAddr[3], pucStartAddr[4],
 206                                      pucStartAddr[5], pucStartAddr[6], pucStartAddr[7],
 207                                      pucStartAddr[8], pucStartAddr[9], pucStartAddr[10],
 208                                      pucStartAddr[11], pucStartAddr[12], pucStartAddr[13]);
 209                                 break;
 210                         case 15:
 211                                 LOG_FUNC
 212                                     ("(%08lx) %02x %02x %02x %02x  %02x %02x %02x %02x - %02x %02x %02x %02x  %02x %02x %02x\n",
 213                                      (UINT_32) pucStartAddr, pucStartAddr[0], pucStartAddr[1],
 214                                      pucStartAddr[2], pucStartAddr[3], pucStartAddr[4],
 215                                      pucStartAddr[5], pucStartAddr[6], pucStartAddr[7],
 216                                      pucStartAddr[8], pucStartAddr[9], pucStartAddr[10],
 217                                      pucStartAddr[11], pucStartAddr[12], pucStartAddr[13],
 218                                      pucStartAddr[14]);
 219                                 break;
 220                         default:
 221                                 break;
 222                         }
 223                         u4Length = 0;
 224                 }
 225         }
 226
 227         LOG_FUNC("\n");
 228
 229         return;
 230 }                               /* end of dumpMemory8() */
 231
 232
 233 /*----------------------------------------------------------------------------*/
 234 /*!
 235 * \brief This routine is called to dump a segment of memory in double words.
 236 *
 237 * \param[in] pucStartAddr   Pointer to the starting address of the memory to be dumped.
 238 * \param[in] u4Length       Length of the memory to be dumped.
 239 *
 240 * \return (none)
 241 */
 242 /*----------------------------------------------------------------------------*/
 243 VOID dumpMemory32(IN PUINT_32 pu4StartAddr, IN UINT_32 u4Length)
 244 {
 245         PUINT_8 pucAddr;
 246
 247
 248         ASSERT(pu4StartAddr);
 249
 250         LOG_FUNC("DUMP32 ADDRESS: %08lx, Length: %ld\n", (UINT_32) pu4StartAddr, u4Length);
 251
 252         if (IS_NOT_ALIGN_4((UINT_32) pu4StartAddr)) {
 253                 UINT_32 u4ProtrudeLen = sizeof(UINT_32) - ((UINT_32) pu4StartAddr % 4);
 254
 255
 256                 u4ProtrudeLen = ((u4Length < u4ProtrudeLen) ? u4Length : u4ProtrudeLen);
 257                 LOG_FUNC("pu4StartAddr is not at DW boundary.\n");
 258                 pucAddr = (PUINT_8) &pu4StartAddr[0];
 259
 260                 switch (u4ProtrudeLen) {
 261                 case 1:
 262                         LOG_FUNC("(%08lx) %02x------\n", (UINT_32) pu4StartAddr, pucAddr[0]);
 263                         break;
 264                 case 2:
 265                         LOG_FUNC("(%08lx) %02x%02x----\n",
 266                                  (UINT_32) pu4StartAddr, pucAddr[1], pucAddr[0]);
 267                         break;
 268                 case 3:
 269                         LOG_FUNC("(%08lx) %02x%02x%02x--\n",
 270                                  (UINT_32) pu4StartAddr, pucAddr[2], pucAddr[1], pucAddr[0]);
 271                         break;
 272                 default:
 273                         break;
 274                 }
 275
 276                 u4Length -= u4ProtrudeLen;
 277                 pu4StartAddr = (PUINT_32) ((UINT_32) pu4StartAddr + u4ProtrudeLen);
 278         }
 279
 280         while (u4Length > 0) {
 281                 if (u4Length >= 16) {
 282                         LOG_FUNC("(%08lx) %08lx %08lx %08lx %08lx\n",
 283                                  (UINT_32) pu4StartAddr,
 284                                  pu4StartAddr[0], pu4StartAddr[1], pu4StartAddr[2],
 285                                  pu4StartAddr[3]);
 286                         pu4StartAddr += 4;
 287                         u4Length -= 16;
 288                 } else {
 289                         switch (u4Length) {
 290                         case 1:
 291                                 pucAddr = (PUINT_8) &pu4StartAddr[0];
 292                                 LOG_FUNC("(%08lx) ------%02x\n",
 293                                          (UINT_32) pu4StartAddr, pucAddr[0]);
 294                                 break;
 295                         case 2:
 296                                 pucAddr = (PUINT_8) &pu4StartAddr[0];
 297                                 LOG_FUNC("(%08lx) ----%02x%02x\n",
 298                                          (UINT_32) pu4StartAddr, pucAddr[1], pucAddr[0]);
 299                                 break;
 300                         case 3:
 301                                 pucAddr = (PUINT_8) &pu4StartAddr[0];
 302                                 LOG_FUNC("(%08lx) --%02x%02x%02x\n",
 303                                          (UINT_32) pu4StartAddr,
 304                                          pucAddr[2], pucAddr[1], pucAddr[0]);
 305                                 break;
 306                         case 4:
 307                                 LOG_FUNC("(%08lx) %08lx\n",
 308                                          (UINT_32) pu4StartAddr, pu4StartAddr[0]);
 309                                 break;
 310                         case 5:
 311                                 pucAddr = (PUINT_8) &pu4StartAddr[1];
 312                                 LOG_FUNC("(%08lx) %08lx ------%02x\n",
 313                                          (UINT_32) pu4StartAddr, pu4StartAddr[0], pucAddr[0]);
 314                                 break;
 315                         case 6:
 316                                 pucAddr = (PUINT_8) &pu4StartAddr[1];
 317                                 LOG_FUNC("(%08lx) %08lx ----%02x%02x\n",
 318                                          (UINT_32) pu4StartAddr,
 319                                          pu4StartAddr[0], pucAddr[1], pucAddr[0]);
 320                                 break;
 321                         case 7:
 322                                 pucAddr = (PUINT_8) &pu4StartAddr[1];
 323                                 LOG_FUNC("(%08lx) %08lx --%02x%02x%02x\n",
 324                                          (UINT_32) pu4StartAddr,
 325                                          pu4StartAddr[0], pucAddr[2], pucAddr[1], pucAddr[0]);
 326                                 break;
 327                         case 8:
 328                                 LOG_FUNC("(%08lx) %08lx %08lx\n",
 329                                          (UINT_32) pu4StartAddr, pu4StartAddr[0], pu4StartAddr[1]);
 330                                 break;
 331                         case 9:
 332                                 pucAddr = (PUINT_8) &pu4StartAddr[2];
 333                                 LOG_FUNC("(%08lx) %08lx %08lx ------%02x\n",
 334                                          (UINT_32) pu4StartAddr,
 335                                          pu4StartAddr[0], pu4StartAddr[1], pucAddr[0]);
 336                                 break;
 337                         case 10:
 338                                 pucAddr = (PUINT_8) &pu4StartAddr[2];
 339                                 LOG_FUNC("(%08lx) %08lx %08lx ----%02x%02x\n",
 340                                          (UINT_32) pu4StartAddr,
 341                                          pu4StartAddr[0], pu4StartAddr[1], pucAddr[1], pucAddr[0]);
 342                                 break;
 343                         case 11:
 344                                 pucAddr = (PUINT_8) &pu4StartAddr[2];
 345                                 LOG_FUNC("(%08lx) %08lx %08lx --%02x%02x%02x\n",
 346                                          (UINT_32) pu4StartAddr,
 347                                          pu4StartAddr[0], pu4StartAddr[1],
 348                                          pucAddr[2], pucAddr[1], pucAddr[0]);
 349                                 break;
 350                         case 12:
 351                                 LOG_FUNC("(%08lx) %08lx %08lx %08lx\n",
 352                                          (UINT_32) pu4StartAddr,
 353                                          pu4StartAddr[0], pu4StartAddr[1], pu4StartAddr[2]);
 354                                 break;
 355                         case 13:
 356                                 pucAddr = (PUINT_8) &pu4StartAddr[3];
 357                                 LOG_FUNC("(%08lx) %08lx %08lx %08lx ------%02x\n",
 358                                          (UINT_32) pu4StartAddr,
 359                                          pu4StartAddr[0], pu4StartAddr[1], pu4StartAddr[2],
 360                                          pucAddr[0]);
 361                                 break;
 362                         case 14:
 363                                 pucAddr = (PUINT_8) &pu4StartAddr[3];
 364                                 LOG_FUNC("(%08lx) %08lx %08lx %08lx ----%02x%02x\n",
 365                                          (UINT_32) pu4StartAddr,
 366                                          pu4StartAddr[0], pu4StartAddr[1], pu4StartAddr[2],
 367                                          pucAddr[1], pucAddr[0]);
 368                                 break;
 369                         case 15:
 370                                 pucAddr = (PUINT_8) &pu4StartAddr[3];
 371                                 LOG_FUNC("(%08lx) %08lx %08lx %08lx --%02x%02x%02x\n",
 372                                          (UINT_32) pu4StartAddr,
 373                                          pu4StartAddr[0], pu4StartAddr[1], pu4StartAddr[2],
 374                                          pucAddr[2], pucAddr[1], pucAddr[0]);
 375                                 break;
 376                         default:
 377                                 break;
 378                         }
 379                         u4Length = 0;
 380                 }
 381         }
 382
 383         return;
 384 }                               /* end of dumpMemory32() */
 385 #elif CFG_SUPPORT_XLOG
 386
 387 /*----------------------------------------------------------------------------*/
 388 /*!
 389 * \brief This routine is called to dump a segment of memory in bytes.
 390 *
 391 * \param[in] pucStartAddr   Pointer to the starting address of the memory to be dumped.
 392 * \param[in] u4Length       Length of the memory to be dumped.
 393 *
 394 * \return (none)
 395 */
 396 /*----------------------------------------------------------------------------*/
 397 VOID dumpMemory8(IN UINT_32 log_level, IN PUINT_8 pucStartAddr, IN UINT_32 u4Length)
 398 {
 399         ASSERT(pucStartAddr);
 400
 401         if (log_level == ANDROID_LOG_ERROR) {
 402                 xlog_printk(ANDROID_LOG_ERROR, XLOG_TAG, "DUMP8 ADDRESS: %08lx, Length: %ld\n",
 403                             (UINT_32) pucStartAddr, u4Length);
 404         } else if (log_level == ANDROID_LOG_WARN) {
 405                 xlog_printk(ANDROID_LOG_WARN, XLOG_TAG, "DUMP8 ADDRESS: %08lx, Length: %ld\n",
 406                             (UINT_32) pucStartAddr, u4Length);
 407         } else if (log_level == ANDROID_LOG_INFO) {
 408                 xlog_printk(ANDROID_LOG_INFO, XLOG_TAG, "DUMP8 ADDRESS: %08lx, Length: %ld\n",
 409                             (UINT_32) pucStartAddr, u4Length);
 410         } else if (log_level == ANDROID_LOG_DEBUG) {
 411                 xlog_printk(ANDROID_LOG_DEBUG, XLOG_TAG, "DUMP8 ADDRESS: %08lx, Length: %ld\n",
 412                             (UINT_32) pucStartAddr, u4Length);
 413         } else if (log_level == ANDROID_LOG_VERBOSE) {
 414                 xlog_printk(ANDROID_LOG_VERBOSE, XLOG_TAG, "DUMP8 ADDRESS: %08lx, Length: %ld\n",
 415                             (UINT_32) pucStartAddr, u4Length);
 416         }
 417
 418         while (u4Length > 0) {
 419                 if (u4Length >= 16) {
 420                         XLOG_FUNC(log_level,
 421                                   "%02x %02x %02x %02x  %02x %02x %02x %02x - %02x %02x %02x %02x  %02x %02x %02x %02x\n",
 422                                   pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 423                                   pucStartAddr[3], pucStartAddr[4], pucStartAddr[5],
 424                                   pucStartAddr[6], pucStartAddr[7], pucStartAddr[8],
 425                                   pucStartAddr[9], pucStartAddr[10], pucStartAddr[11],
 426                                   pucStartAddr[12], pucStartAddr[13], pucStartAddr[14],
 427                                   pucStartAddr[15]);
 428                         u4Length -= 16;
 429                         pucStartAddr += 16;
 430                 } else {
 431                         switch (u4Length) {
 432                         case 1:
 433                                 XLOG_FUNC(log_level, "%02x\n", pucStartAddr[0]);
 434                                 break;
 435                         case 2:
 436                                 XLOG_FUNC(log_level, "%02x %02x\n",
 437                                           pucStartAddr[0], pucStartAddr[1]);
 438                                 break;
 439                         case 3:
 440                                 XLOG_FUNC(log_level, "%02x %02x %02x\n",
 441                                           pucStartAddr[0], pucStartAddr[1], pucStartAddr[2]);
 442                                 break;
 443                         case 4:
 444                                 XLOG_FUNC(log_level, "%02x %02x %02x %02x\n",
 445                                           pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 446                                           pucStartAddr[3]);
 447                                 break;
 448                         case 5:
 449                                 XLOG_FUNC(log_level, "%02x %02x %02x %02x  %02x\n",
 450                                           pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 451                                           pucStartAddr[3], pucStartAddr[4]);
 452                                 break;
 453                         case 6:
 454                                 XLOG_FUNC(log_level, "%02x %02x %02x %02x  %02x %02x\n",
 455                                           pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 456                                           pucStartAddr[3], pucStartAddr[4], pucStartAddr[5]);
 457                                 break;
 458                         case 7:
 459                                 XLOG_FUNC(log_level, "%02x %02x %02x %02x  %02x %02x %02x\n",
 460                                           pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 461                                           pucStartAddr[3], pucStartAddr[4], pucStartAddr[5],
 462                                           pucStartAddr[6]);
 463                                 break;
 464                         case 8:
 465                                 XLOG_FUNC(log_level, "%02x %02x %02x %02x  %02x %02x %02x %02x\n",
 466                                           pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 467                                           pucStartAddr[3], pucStartAddr[4], pucStartAddr[5],
 468                                           pucStartAddr[6], pucStartAddr[7]);
 469                                 break;
 470                         case 9:
 471                                 XLOG_FUNC(log_level,
 472                                           "%02x %02x %02x %02x  %02x %02x %02x %02x - %02x\n",
 473                                           pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 474                                           pucStartAddr[3], pucStartAddr[4], pucStartAddr[5],
 475                                           pucStartAddr[6], pucStartAddr[7], pucStartAddr[8]);
 476                                 break;
 477                         case 10:
 478                                 XLOG_FUNC(log_level,
 479                                           "%02x %02x %02x %02x  %02x %02x %02x %02x - %02x %02x\n",
 480                                           pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 481                                           pucStartAddr[3], pucStartAddr[4], pucStartAddr[5],
 482                                           pucStartAddr[6], pucStartAddr[7], pucStartAddr[8],
 483                                           pucStartAddr[9]);
 484                                 break;
 485                         case 11:
 486                                 XLOG_FUNC(log_level,
 487                                           "%02x %02x %02x %02x  %02x %02x %02x %02x - %02x %02x %02x\n",
 488                                           pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 489                                           pucStartAddr[3], pucStartAddr[4], pucStartAddr[5],
 490                                           pucStartAddr[6], pucStartAddr[7], pucStartAddr[8],
 491                                           pucStartAddr[9], pucStartAddr[10]);
 492                                 break;
 493                         case 12:
 494                                 XLOG_FUNC(log_level,
 495                                           "%02x %02x %02x %02x  %02x %02x %02x %02x - %02x %02x %02x %02x\n",
 496                                           pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 497                                           pucStartAddr[3], pucStartAddr[4], pucStartAddr[5],
 498                                           pucStartAddr[6], pucStartAddr[7], pucStartAddr[8],
 499                                           pucStartAddr[9], pucStartAddr[10], pucStartAddr[11]);
 500                                 break;
 501                         case 13:
 502                                 XLOG_FUNC(log_level,
 503                                           "%02x %02x %02x %02x  %02x %02x %02x %02x - %02x %02x %02x %02x  %02x\n",
 504                                           pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 505                                           pucStartAddr[3], pucStartAddr[4], pucStartAddr[5],
 506                                           pucStartAddr[6], pucStartAddr[7], pucStartAddr[8],
 507                                           pucStartAddr[9], pucStartAddr[10], pucStartAddr[11],
 508                                           pucStartAddr[12]);
 509                                 break;
 510                         case 14:
 511                                 XLOG_FUNC(log_level,
 512                                           "%02x %02x %02x %02x  %02x %02x %02x %02x - %02x %02x %02x %02x  %02x %02x\n",
 513                                           pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 514                                           pucStartAddr[3], pucStartAddr[4], pucStartAddr[5],
 515                                           pucStartAddr[6], pucStartAddr[7], pucStartAddr[8],
 516                                           pucStartAddr[9], pucStartAddr[10], pucStartAddr[11],
 517                                           pucStartAddr[12], pucStartAddr[13]);
 518                                 break;
 519                         case 15:
 520                                 XLOG_FUNC(log_level,
 521                                           "%02x %02x %02x %02x  %02x %02x %02x %02x - %02x %02x %02x %02x  %02x %02x %02x\n",
 522                                           pucStartAddr[0], pucStartAddr[1], pucStartAddr[2],
 523                                           pucStartAddr[3], pucStartAddr[4], pucStartAddr[5],
 524                                           pucStartAddr[6], pucStartAddr[7], pucStartAddr[8],
 525                                           pucStartAddr[9], pucStartAddr[10], pucStartAddr[11],
 526                                           pucStartAddr[12], pucStartAddr[13], pucStartAddr[14]);
 527                                 break;
 528                         default:
 529                                 break;
 530                         }
 531                         u4Length = 0;
 532                 }
 533         }
 534
 535
 536         return;
 537 }                               /* end of dumpMemory8() */
 538 #endif                          /* DBG */