drivers/scsi/lpfc/lpfc_debugfs.h

   1 /*******************************************************************
   2  * This file is part of the Emulex Linux Device Driver for         *
   3  * Fibre Channel Host Bus Adapters.                                *
   4  * Copyright (C) 2007-2011 Emulex.  All rights reserved.           *
   5  * EMULEX and SLI are trademarks of Emulex.                        *
   6  * www.emulex.com                                                  *
   7  *                                                                 *
   8  * This program is free software; you can redistribute it and/or   *
   9  * modify it under the terms of version 2 of the GNU General       *
  10  * Public License as published by the Free Software Foundation.    *
  11  * This program is distributed in the hope that it will be useful. *
  12  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
  13  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
  14  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
  15  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
  16  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
  17  * more details, a copy of which can be found in the file COPYING  *
  18  * included with this package.                                     *
  19  *******************************************************************/
  20
  21 #ifndef _H_LPFC_DEBUG_FS
  22 #define _H_LPFC_DEBUG_FS
  23
  24 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
  25
  26 /* size of output line, for discovery_trace and slow_ring_trace */
  27 #define LPFC_DEBUG_TRC_ENTRY_SIZE 100
  28
  29 /* nodelist output buffer size */
  30 #define LPFC_NODELIST_SIZE 8192
  31 #define LPFC_NODELIST_ENTRY_SIZE 120
  32
  33 /* dumpHBASlim output buffer size */
  34 #define LPFC_DUMPHBASLIM_SIZE 4096
  35
  36 /* dumpHostSlim output buffer size */
  37 #define LPFC_DUMPHOSTSLIM_SIZE 4096
  38
  39 /* hbqinfo output buffer size */
  40 #define LPFC_HBQINFO_SIZE 8192
  41
  42 /*
  43  * For SLI4 iDiag debugfs diagnostics tool
  44  */
  45
  46 /* pciConf */
  47 #define LPFC_PCI_CFG_BROWSE 0xffff
  48 #define LPFC_PCI_CFG_RD_CMD_ARG 2
  49 #define LPFC_PCI_CFG_WR_CMD_ARG 3
  50 #define LPFC_PCI_CFG_SIZE 4096
  51 #define LPFC_PCI_CFG_RD_SIZE (LPFC_PCI_CFG_SIZE/4)
  52
  53 #define IDIAG_PCICFG_WHERE_INDX 0
  54 #define IDIAG_PCICFG_COUNT_INDX 1
  55 #define IDIAG_PCICFG_VALUE_INDX 2
  56
  57 /* barAcc */
  58 #define LPFC_PCI_BAR_BROWSE 0xffff
  59 #define LPFC_PCI_BAR_RD_CMD_ARG 3
  60 #define LPFC_PCI_BAR_WR_CMD_ARG 3
  61
  62 #define LPFC_PCI_IF0_BAR0_SIZE (1024 *  16)
  63 #define LPFC_PCI_IF0_BAR1_SIZE (1024 * 128)
  64 #define LPFC_PCI_IF0_BAR2_SIZE (1024 * 128)
  65 #define LPFC_PCI_IF2_BAR0_SIZE (1024 *  32)
  66
  67 #define LPFC_PCI_BAR_RD_BUF_SIZE 4096
  68 #define LPFC_PCI_BAR_RD_SIZE (LPFC_PCI_BAR_RD_BUF_SIZE/4)
  69
  70 #define LPFC_PCI_IF0_BAR0_RD_SIZE (LPFC_PCI_IF0_BAR0_SIZE/4)
  71 #define LPFC_PCI_IF0_BAR1_RD_SIZE (LPFC_PCI_IF0_BAR1_SIZE/4)
  72 #define LPFC_PCI_IF0_BAR2_RD_SIZE (LPFC_PCI_IF0_BAR2_SIZE/4)
  73 #define LPFC_PCI_IF2_BAR0_RD_SIZE (LPFC_PCI_IF2_BAR0_SIZE/4)
  74
  75 #define IDIAG_BARACC_BAR_NUM_INDX 0
  76 #define IDIAG_BARACC_OFF_SET_INDX 1
  77 #define IDIAG_BARACC_ACC_MOD_INDX 2
  78 #define IDIAG_BARACC_REG_VAL_INDX 2
  79 #define IDIAG_BARACC_BAR_SZE_INDX 3
  80
  81 #define IDIAG_BARACC_BAR_0 0
  82 #define IDIAG_BARACC_BAR_1 1
  83 #define IDIAG_BARACC_BAR_2 2
  84
  85 #define SINGLE_WORD 1
  86
  87 /* queue info */
  88 #define LPFC_QUE_INFO_GET_BUF_SIZE 4096
  89
  90 /* queue acc */
  91 #define LPFC_QUE_ACC_BROWSE 0xffff
  92 #define LPFC_QUE_ACC_RD_CMD_ARG 4
  93 #define LPFC_QUE_ACC_WR_CMD_ARG 6
  94 #define LPFC_QUE_ACC_BUF_SIZE 4096
  95 #define LPFC_QUE_ACC_SIZE (LPFC_QUE_ACC_BUF_SIZE/2)
  96
  97 #define LPFC_IDIAG_EQ 1
  98 #define LPFC_IDIAG_CQ 2
  99 #define LPFC_IDIAG_MQ 3
 100 #define LPFC_IDIAG_WQ 4
 101 #define LPFC_IDIAG_RQ 5
 102
 103 #define IDIAG_QUEACC_QUETP_INDX 0
 104 #define IDIAG_QUEACC_QUEID_INDX 1
 105 #define IDIAG_QUEACC_INDEX_INDX 2
 106 #define IDIAG_QUEACC_COUNT_INDX 3
 107 #define IDIAG_QUEACC_OFFST_INDX 4
 108 #define IDIAG_QUEACC_VALUE_INDX 5
 109
 110 /* doorbell register acc */
 111 #define LPFC_DRB_ACC_ALL 0xffff
 112 #define LPFC_DRB_ACC_RD_CMD_ARG 1
 113 #define LPFC_DRB_ACC_WR_CMD_ARG 2
 114 #define LPFC_DRB_ACC_BUF_SIZE 256
 115
 116 #define LPFC_DRB_EQCQ 1
 117 #define LPFC_DRB_MQ   2
 118 #define LPFC_DRB_WQ   3
 119 #define LPFC_DRB_RQ   4
 120
 121 #define LPFC_DRB_MAX  4
 122
 123 #define IDIAG_DRBACC_REGID_INDX 0
 124 #define IDIAG_DRBACC_VALUE_INDX 1
 125
 126 /* control register acc */
 127 #define LPFC_CTL_ACC_ALL 0xffff
 128 #define LPFC_CTL_ACC_RD_CMD_ARG 1
 129 #define LPFC_CTL_ACC_WR_CMD_ARG 2
 130 #define LPFC_CTL_ACC_BUF_SIZE 256
 131
 132 #define LPFC_CTL_PORT_SEM  1
 133 #define LPFC_CTL_PORT_STA  2
 134 #define LPFC_CTL_PORT_CTL  3
 135 #define LPFC_CTL_PORT_ER1  4
 136 #define LPFC_CTL_PORT_ER2  5
 137 #define LPFC_CTL_PDEV_CTL  6
 138
 139 #define LPFC_CTL_MAX  6
 140
 141 #define IDIAG_CTLACC_REGID_INDX 0
 142 #define IDIAG_CTLACC_VALUE_INDX 1
 143
 144 /* mailbox access */
 145 #define LPFC_MBX_DMP_ARG 4
 146
 147 #define LPFC_MBX_ACC_BUF_SIZE 512
 148 #define LPFC_MBX_ACC_LBUF_SZ 128
 149
 150 #define LPFC_MBX_DMP_MBX_WORD 0x00000001
 151 #define LPFC_MBX_DMP_MBX_BYTE 0x00000002
 152 #define LPFC_MBX_DMP_MBX_ALL (LPFC_MBX_DMP_MBX_WORD | LPFC_MBX_DMP_MBX_BYTE)
 153
 154 #define LPFC_BSG_DMP_MBX_RD_MBX 0x00000001
 155 #define LPFC_BSG_DMP_MBX_RD_BUF 0x00000002
 156 #define LPFC_BSG_DMP_MBX_WR_MBX 0x00000004
 157 #define LPFC_BSG_DMP_MBX_WR_BUF 0x00000008
 158 #define LPFC_BSG_DMP_MBX_ALL (LPFC_BSG_DMP_MBX_RD_MBX | \
 159                               LPFC_BSG_DMP_MBX_RD_BUF | \
 160                               LPFC_BSG_DMP_MBX_WR_MBX | \
 161                               LPFC_BSG_DMP_MBX_WR_BUF)
 162
 163 #define LPFC_MBX_DMP_ALL 0xffff
 164 #define LPFC_MBX_ALL_CMD 0xff
 165
 166 #define IDIAG_MBXACC_MBCMD_INDX 0
 167 #define IDIAG_MBXACC_DPMAP_INDX 1
 168 #define IDIAG_MBXACC_DPCNT_INDX 2
 169 #define IDIAG_MBXACC_WDCNT_INDX 3
 170
 171 /* extents access */
 172 #define LPFC_EXT_ACC_CMD_ARG 1
 173 #define LPFC_EXT_ACC_BUF_SIZE 4096
 174
 175 #define LPFC_EXT_ACC_AVAIL 0x1
 176 #define LPFC_EXT_ACC_ALLOC 0x2
 177 #define LPFC_EXT_ACC_DRIVR 0x4
 178 #define LPFC_EXT_ACC_ALL   (LPFC_EXT_ACC_DRIVR | \
 179                             LPFC_EXT_ACC_AVAIL | \
 180                             LPFC_EXT_ACC_ALLOC)
 181
 182 #define IDIAG_EXTACC_EXMAP_INDX 0
 183
 184 #define SIZE_U8  sizeof(uint8_t)
 185 #define SIZE_U16 sizeof(uint16_t)
 186 #define SIZE_U32 sizeof(uint32_t)
 187
 188 struct lpfc_debug {
 189         char *i_private;
 190         char op;
 191 #define LPFC_IDIAG_OP_RD 1
 192 #define LPFC_IDIAG_OP_WR 2
 193         char *buffer;
 194         int  len;
 195 };
 196
 197 struct lpfc_debugfs_trc {
 198         char *fmt;
 199         uint32_t data1;
 200         uint32_t data2;
 201         uint32_t data3;
 202         uint32_t seq_cnt;
 203         unsigned long jif;
 204 };
 205
 206 struct lpfc_idiag_offset {
 207         uint32_t last_rd;
 208 };
 209
 210 #define LPFC_IDIAG_CMD_DATA_SIZE 8
 211 struct lpfc_idiag_cmd {
 212         uint32_t opcode;
 213 #define LPFC_IDIAG_CMD_PCICFG_RD 0x00000001
 214 #define LPFC_IDIAG_CMD_PCICFG_WR 0x00000002
 215 #define LPFC_IDIAG_CMD_PCICFG_ST 0x00000003
 216 #define LPFC_IDIAG_CMD_PCICFG_CL 0x00000004
 217
 218 #define LPFC_IDIAG_CMD_BARACC_RD 0x00000008
 219 #define LPFC_IDIAG_CMD_BARACC_WR 0x00000009
 220 #define LPFC_IDIAG_CMD_BARACC_ST 0x0000000a
 221 #define LPFC_IDIAG_CMD_BARACC_CL 0x0000000b
 222
 223 #define LPFC_IDIAG_CMD_QUEACC_RD 0x00000011
 224 #define LPFC_IDIAG_CMD_QUEACC_WR 0x00000012
 225 #define LPFC_IDIAG_CMD_QUEACC_ST 0x00000013
 226 #define LPFC_IDIAG_CMD_QUEACC_CL 0x00000014
 227
 228 #define LPFC_IDIAG_CMD_DRBACC_RD 0x00000021
 229 #define LPFC_IDIAG_CMD_DRBACC_WR 0x00000022
 230 #define LPFC_IDIAG_CMD_DRBACC_ST 0x00000023
 231 #define LPFC_IDIAG_CMD_DRBACC_CL 0x00000024
 232
 233 #define LPFC_IDIAG_CMD_CTLACC_RD 0x00000031
 234 #define LPFC_IDIAG_CMD_CTLACC_WR 0x00000032
 235 #define LPFC_IDIAG_CMD_CTLACC_ST 0x00000033
 236 #define LPFC_IDIAG_CMD_CTLACC_CL 0x00000034
 237
 238 #define LPFC_IDIAG_CMD_MBXACC_DP 0x00000041
 239 #define LPFC_IDIAG_BSG_MBXACC_DP 0x00000042
 240
 241 #define LPFC_IDIAG_CMD_EXTACC_RD 0x00000051
 242
 243         uint32_t data[LPFC_IDIAG_CMD_DATA_SIZE];
 244 };
 245
 246 struct lpfc_idiag {
 247         uint32_t active;
 248         struct lpfc_idiag_cmd cmd;
 249         struct lpfc_idiag_offset offset;
 250         void *ptr_private;
 251 };
 252 #endif
 253
 254 /* Mask for discovery_trace */
 255 #define LPFC_DISC_TRC_ELS_CMD           0x1     /* Trace ELS commands */
 256 #define LPFC_DISC_TRC_ELS_RSP           0x2     /* Trace ELS response */
 257 #define LPFC_DISC_TRC_ELS_UNSOL         0x4     /* Trace ELS rcv'ed   */
 258 #define LPFC_DISC_TRC_ELS_ALL           0x7     /* Trace ELS */
 259 #define LPFC_DISC_TRC_MBOX_VPORT        0x8     /* Trace vport MBOXs */
 260 #define LPFC_DISC_TRC_MBOX              0x10    /* Trace other MBOXs */
 261 #define LPFC_DISC_TRC_MBOX_ALL          0x18    /* Trace all MBOXs */
 262 #define LPFC_DISC_TRC_CT                0x20    /* Trace disc CT requests */
 263 #define LPFC_DISC_TRC_DSM               0x40    /* Trace DSM events */
 264 #define LPFC_DISC_TRC_RPORT             0x80    /* Trace rport events */
 265 #define LPFC_DISC_TRC_NODE              0x100   /* Trace ndlp state changes */
 266
 267 #define LPFC_DISC_TRC_DISCOVERY         0xef    /* common mask for general
 268                                                  * discovery */
 269 #endif /* H_LPFC_DEBUG_FS */
 270
 271
 272 /*
 273  * Driver debug utility routines outside of debugfs. The debug utility
 274  * routines implemented here is intended to be used in the instrumented
 275  * debug driver for debugging host or port issues.
 276  */
 277
 278 /**
 279  * lpfc_debug_dump_qe - dump an specific entry from a queue
 280  * @q: Pointer to the queue descriptor.
 281  * @idx: Index to the entry on the queue.
 282  *
 283  * This function dumps an entry indexed by @idx from a queue specified by the
 284  * queue descriptor @q.
 285  **/
 286 static inline void
 287 lpfc_debug_dump_qe(struct lpfc_queue *q, uint32_t idx)
 288 {
 289         char line_buf[LPFC_LBUF_SZ];
 290         int i, esize, qe_word_cnt, len;
 291         uint32_t *pword;
 292
 293         /* sanity checks */
 294         if (!q)
 295                 return;
 296         if (idx >= q->entry_count)
 297                 return;
 298
 299         esize = q->entry_size;
 300         qe_word_cnt = esize / sizeof(uint32_t);
 301         pword = q->qe[idx].address;
 302
 303         len = 0;
 304         len += snprintf(line_buf+len, LPFC_LBUF_SZ-len, "QE[%04d]: ", idx);
 305         if (qe_word_cnt > 8)
 306                 printk(KERN_ERR "%s\n", line_buf);
 307
 308         for (i = 0; i < qe_word_cnt; i++) {
 309                 if (!(i % 8)) {
 310                         if (i != 0)
 311                                 printk(KERN_ERR "%s\n", line_buf);
 312                         if (qe_word_cnt > 8) {
 313                                 len = 0;
 314                                 memset(line_buf, 0, LPFC_LBUF_SZ);
 315                                 len += snprintf(line_buf+len, LPFC_LBUF_SZ-len,
 316                                                 "%03d: ", i);
 317                         }
 318                 }
 319                 len += snprintf(line_buf+len, LPFC_LBUF_SZ-len, "%08x ",
 320                                 ((uint32_t)*pword) & 0xffffffff);
 321                 pword++;
 322         }
 323         if (qe_word_cnt <= 8 || (i - 1) % 8)
 324                 printk(KERN_ERR "%s\n", line_buf);
 325 }
 326
 327 /**
 328  * lpfc_debug_dump_q - dump all entries from an specific queue
 329  * @q: Pointer to the queue descriptor.
 330  *
 331  * This function dumps all entries from a queue specified by the queue
 332  * descriptor @q.
 333  **/
 334 static inline void
 335 lpfc_debug_dump_q(struct lpfc_queue *q)
 336 {
 337         int idx, entry_count;
 338
 339         /* sanity check */
 340         if (!q)
 341                 return;
 342
 343         dev_printk(KERN_ERR, &(((q->phba))->pcidev)->dev,
 344                 "%d: [qid:%d, type:%d, subtype:%d, "
 345                 "qe_size:%d, qe_count:%d, "
 346                 "host_index:%d, port_index:%d]\n",
 347                 (q->phba)->brd_no,
 348                 q->queue_id, q->type, q->subtype,
 349                 q->entry_size, q->entry_count,
 350                 q->host_index, q->hba_index);
 351         entry_count = q->entry_count;
 352         for (idx = 0; idx < entry_count; idx++)
 353                 lpfc_debug_dump_qe(q, idx);
 354         printk(KERN_ERR "\n");
 355 }
 356
 357 /**
 358  * lpfc_debug_dump_fcp_wq - dump all entries from a fcp work queue
 359  * @phba: Pointer to HBA context object.
 360  * @fcp_wqidx: Index to a FCP work queue.
 361  *
 362  * This function dumps all entries from a FCP work queue specified by the
 363  * @fcp_wqidx.
 364  **/
 365 static inline void
 366 lpfc_debug_dump_fcp_wq(struct lpfc_hba *phba, int fcp_wqidx)
 367 {
 368         /* sanity check */
 369         if (fcp_wqidx >= phba->cfg_fcp_wq_count)
 370                 return;
 371
 372         printk(KERN_ERR "FCP WQ: WQ[Idx:%d|Qid:%d]\n",
 373                 fcp_wqidx, phba->sli4_hba.fcp_wq[fcp_wqidx]->queue_id);
 374         lpfc_debug_dump_q(phba->sli4_hba.fcp_wq[fcp_wqidx]);
 375 }
 376
 377 /**
 378  * lpfc_debug_dump_fcp_cq - dump all entries from a fcp work queue's cmpl queue
 379  * @phba: Pointer to HBA context object.
 380  * @fcp_wqidx: Index to a FCP work queue.
 381  *
 382  * This function dumps all entries from a FCP complete queue which is
 383  * associated to the FCP work queue specified by the @fcp_wqidx.
 384  **/
 385 static inline void
 386 lpfc_debug_dump_fcp_cq(struct lpfc_hba *phba, int fcp_wqidx)
 387 {
 388         int fcp_cqidx, fcp_cqid;
 389
 390         /* sanity check */
 391         if (fcp_wqidx >= phba->cfg_fcp_wq_count)
 392                 return;
 393
 394         fcp_cqid = phba->sli4_hba.fcp_wq[fcp_wqidx]->assoc_qid;
 395         for (fcp_cqidx = 0; fcp_cqidx < phba->cfg_fcp_eq_count; fcp_cqidx++)
 396                 if (phba->sli4_hba.fcp_cq[fcp_cqidx]->queue_id == fcp_cqid)
 397                         break;
 398         if (fcp_cqidx >= phba->cfg_fcp_eq_count)
 399                 return;
 400
 401         printk(KERN_ERR "FCP CQ: WQ[Idx:%d|Qid%d]->CQ[Idx%d|Qid%d]:\n",
 402                 fcp_wqidx, phba->sli4_hba.fcp_wq[fcp_wqidx]->queue_id,
 403                 fcp_cqidx, fcp_cqid);
 404         lpfc_debug_dump_q(phba->sli4_hba.fcp_cq[fcp_cqidx]);
 405 }
 406
 407 /**
 408  * lpfc_debug_dump_fcp_eq - dump all entries from a fcp work queue's evt queue
 409  * @phba: Pointer to HBA context object.
 410  * @fcp_wqidx: Index to a FCP work queue.
 411  *
 412  * This function dumps all entries from a FCP event queue which is
 413  * associated to the FCP work queue specified by the @fcp_wqidx.
 414  **/
 415 static inline void
 416 lpfc_debug_dump_fcp_eq(struct lpfc_hba *phba, int fcp_wqidx)
 417 {
 418         struct lpfc_queue *qdesc;
 419         int fcp_eqidx, fcp_eqid;
 420         int fcp_cqidx, fcp_cqid;
 421
 422         /* sanity check */
 423         if (fcp_wqidx >= phba->cfg_fcp_wq_count)
 424                 return;
 425         fcp_cqid = phba->sli4_hba.fcp_wq[fcp_wqidx]->assoc_qid;
 426         for (fcp_cqidx = 0; fcp_cqidx < phba->cfg_fcp_eq_count; fcp_cqidx++)
 427                 if (phba->sli4_hba.fcp_cq[fcp_cqidx]->queue_id == fcp_cqid)
 428                         break;
 429         if (fcp_cqidx >= phba->cfg_fcp_eq_count)
 430                 return;
 431
 432         if (phba->cfg_fcp_eq_count == 0) {
 433                 fcp_eqidx = -1;
 434                 fcp_eqid = phba->sli4_hba.sp_eq->queue_id;
 435                 qdesc = phba->sli4_hba.sp_eq;
 436         } else {
 437                 fcp_eqidx = fcp_cqidx;
 438                 fcp_eqid = phba->sli4_hba.fp_eq[fcp_eqidx]->queue_id;
 439                 qdesc = phba->sli4_hba.fp_eq[fcp_eqidx];
 440         }
 441
 442         printk(KERN_ERR "FCP EQ: WQ[Idx:%d|Qid:%d]->CQ[Idx:%d|Qid:%d]->"
 443                 "EQ[Idx:%d|Qid:%d]\n",
 444                 fcp_wqidx, phba->sli4_hba.fcp_wq[fcp_wqidx]->queue_id,
 445                 fcp_cqidx, fcp_cqid, fcp_eqidx, fcp_eqid);
 446         lpfc_debug_dump_q(qdesc);
 447 }
 448
 449 /**
 450  * lpfc_debug_dump_els_wq - dump all entries from the els work queue
 451  * @phba: Pointer to HBA context object.
 452  *
 453  * This function dumps all entries from the ELS work queue.
 454  **/
 455 static inline void
 456 lpfc_debug_dump_els_wq(struct lpfc_hba *phba)
 457 {
 458         printk(KERN_ERR "ELS WQ: WQ[Qid:%d]:\n",
 459                 phba->sli4_hba.els_wq->queue_id);
 460         lpfc_debug_dump_q(phba->sli4_hba.els_wq);
 461 }
 462
 463 /**
 464  * lpfc_debug_dump_mbx_wq - dump all entries from the mbox work queue
 465  * @phba: Pointer to HBA context object.
 466  *
 467  * This function dumps all entries from the MBOX work queue.
 468  **/
 469 static inline void
 470 lpfc_debug_dump_mbx_wq(struct lpfc_hba *phba)
 471 {
 472         printk(KERN_ERR "MBX WQ: WQ[Qid:%d]\n",
 473                 phba->sli4_hba.mbx_wq->queue_id);
 474         lpfc_debug_dump_q(phba->sli4_hba.mbx_wq);
 475 }
 476
 477 /**
 478  * lpfc_debug_dump_dat_rq - dump all entries from the receive data queue
 479  * @phba: Pointer to HBA context object.
 480  *
 481  * This function dumps all entries from the receive data queue.
 482  **/
 483 static inline void
 484 lpfc_debug_dump_dat_rq(struct lpfc_hba *phba)
 485 {
 486         printk(KERN_ERR "DAT RQ: RQ[Qid:%d]\n",
 487                 phba->sli4_hba.dat_rq->queue_id);
 488         lpfc_debug_dump_q(phba->sli4_hba.dat_rq);
 489 }
 490
 491 /**
 492  * lpfc_debug_dump_hdr_rq - dump all entries from the receive header queue
 493  * @phba: Pointer to HBA context object.
 494  *
 495  * This function dumps all entries from the receive header queue.
 496  **/
 497 static inline void
 498 lpfc_debug_dump_hdr_rq(struct lpfc_hba *phba)
 499 {
 500         printk(KERN_ERR "HDR RQ: RQ[Qid:%d]\n",
 501                 phba->sli4_hba.hdr_rq->queue_id);
 502         lpfc_debug_dump_q(phba->sli4_hba.hdr_rq);
 503 }
 504
 505 /**
 506  * lpfc_debug_dump_els_cq - dump all entries from the els complete queue
 507  * @phba: Pointer to HBA context object.
 508  *
 509  * This function dumps all entries from the els complete queue.
 510  **/
 511 static inline void
 512 lpfc_debug_dump_els_cq(struct lpfc_hba *phba)
 513 {
 514         printk(KERN_ERR "ELS CQ: WQ[Qid:%d]->CQ[Qid:%d]\n",
 515                 phba->sli4_hba.els_wq->queue_id,
 516                 phba->sli4_hba.els_cq->queue_id);
 517         lpfc_debug_dump_q(phba->sli4_hba.els_cq);
 518 }
 519
 520 /**
 521  * lpfc_debug_dump_mbx_cq - dump all entries from the mbox complete queue
 522  * @phba: Pointer to HBA context object.
 523  *
 524  * This function dumps all entries from the mbox complete queue.
 525  **/
 526 static inline void
 527 lpfc_debug_dump_mbx_cq(struct lpfc_hba *phba)
 528 {
 529         printk(KERN_ERR "MBX CQ: WQ[Qid:%d]->CQ[Qid:%d]\n",
 530                 phba->sli4_hba.mbx_wq->queue_id,
 531                 phba->sli4_hba.mbx_cq->queue_id);
 532         lpfc_debug_dump_q(phba->sli4_hba.mbx_cq);
 533 }
 534
 535 /**
 536  * lpfc_debug_dump_sp_eq - dump all entries from slow-path event queue
 537  * @phba: Pointer to HBA context object.
 538  *
 539  * This function dumps all entries from the slow-path event queue.
 540  **/
 541 static inline void
 542 lpfc_debug_dump_sp_eq(struct lpfc_hba *phba)
 543 {
 544         printk(KERN_ERR "SP EQ: WQ[Qid:%d/Qid:%d]->CQ[Qid:%d/Qid:%d]->"
 545                 "EQ[Qid:%d]:\n",
 546                 phba->sli4_hba.mbx_wq->queue_id,
 547                 phba->sli4_hba.els_wq->queue_id,
 548                 phba->sli4_hba.mbx_cq->queue_id,
 549                 phba->sli4_hba.els_cq->queue_id,
 550                 phba->sli4_hba.sp_eq->queue_id);
 551         lpfc_debug_dump_q(phba->sli4_hba.sp_eq);
 552 }
 553
 554 /**
 555  * lpfc_debug_dump_wq_by_id - dump all entries from a work queue by queue id
 556  * @phba: Pointer to HBA context object.
 557  * @qid: Work queue identifier.
 558  *
 559  * This function dumps all entries from a work queue identified by the queue
 560  * identifier.
 561  **/
 562 static inline void
 563 lpfc_debug_dump_wq_by_id(struct lpfc_hba *phba, int qid)
 564 {
 565         int wq_idx;
 566
 567         for (wq_idx = 0; wq_idx < phba->cfg_fcp_wq_count; wq_idx++)
 568                 if (phba->sli4_hba.fcp_wq[wq_idx]->queue_id == qid)
 569                         break;
 570         if (wq_idx < phba->cfg_fcp_wq_count) {
 571                 printk(KERN_ERR "FCP WQ[Idx:%d|Qid:%d]\n", wq_idx, qid);
 572                 lpfc_debug_dump_q(phba->sli4_hba.fcp_wq[wq_idx]);
 573                 return;
 574         }
 575
 576         if (phba->sli4_hba.els_wq->queue_id == qid) {
 577                 printk(KERN_ERR "ELS WQ[Qid:%d]\n", qid);
 578                 lpfc_debug_dump_q(phba->sli4_hba.els_wq);
 579         }
 580 }
 581
 582 /**
 583  * lpfc_debug_dump_mq_by_id - dump all entries from a mbox queue by queue id
 584  * @phba: Pointer to HBA context object.
 585  * @qid: Mbox work queue identifier.
 586  *
 587  * This function dumps all entries from a mbox work queue identified by the
 588  * queue identifier.
 589  **/
 590 static inline void
 591 lpfc_debug_dump_mq_by_id(struct lpfc_hba *phba, int qid)
 592 {
 593         if (phba->sli4_hba.mbx_wq->queue_id == qid) {
 594                 printk(KERN_ERR "MBX WQ[Qid:%d]\n", qid);
 595                 lpfc_debug_dump_q(phba->sli4_hba.mbx_wq);
 596         }
 597 }
 598
 599 /**
 600  * lpfc_debug_dump_rq_by_id - dump all entries from a receive queue by queue id
 601  * @phba: Pointer to HBA context object.
 602  * @qid: Receive queue identifier.
 603  *
 604  * This function dumps all entries from a receive queue identified by the
 605  * queue identifier.
 606  **/
 607 static inline void
 608 lpfc_debug_dump_rq_by_id(struct lpfc_hba *phba, int qid)
 609 {
 610         if (phba->sli4_hba.hdr_rq->queue_id == qid) {
 611                 printk(KERN_ERR "HDR RQ[Qid:%d]\n", qid);
 612                 lpfc_debug_dump_q(phba->sli4_hba.hdr_rq);
 613                 return;
 614         }
 615         if (phba->sli4_hba.dat_rq->queue_id == qid) {
 616                 printk(KERN_ERR "DAT RQ[Qid:%d]\n", qid);
 617                 lpfc_debug_dump_q(phba->sli4_hba.dat_rq);
 618         }
 619 }
 620
 621 /**
 622  * lpfc_debug_dump_cq_by_id - dump all entries from a cmpl queue by queue id
 623  * @phba: Pointer to HBA context object.
 624  * @qid: Complete queue identifier.
 625  *
 626  * This function dumps all entries from a complete queue identified by the
 627  * queue identifier.
 628  **/
 629 static inline void
 630 lpfc_debug_dump_cq_by_id(struct lpfc_hba *phba, int qid)
 631 {
 632         int cq_idx = 0;
 633
 634         do {
 635                 if (phba->sli4_hba.fcp_cq[cq_idx]->queue_id == qid)
 636                         break;
 637         } while (++cq_idx < phba->cfg_fcp_eq_count);
 638
 639         if (cq_idx < phba->cfg_fcp_eq_count) {
 640                 printk(KERN_ERR "FCP CQ[Idx:%d|Qid:%d]\n", cq_idx, qid);
 641                 lpfc_debug_dump_q(phba->sli4_hba.fcp_cq[cq_idx]);
 642                 return;
 643         }
 644
 645         if (phba->sli4_hba.els_cq->queue_id == qid) {
 646                 printk(KERN_ERR "ELS CQ[Qid:%d]\n", qid);
 647                 lpfc_debug_dump_q(phba->sli4_hba.els_cq);
 648                 return;
 649         }
 650
 651         if (phba->sli4_hba.mbx_cq->queue_id == qid) {
 652                 printk(KERN_ERR "MBX CQ[Qid:%d]\n", qid);
 653                 lpfc_debug_dump_q(phba->sli4_hba.mbx_cq);
 654         }
 655 }
 656
 657 /**
 658  * lpfc_debug_dump_eq_by_id - dump all entries from an event queue by queue id
 659  * @phba: Pointer to HBA context object.
 660  * @qid: Complete queue identifier.
 661  *
 662  * This function dumps all entries from an event queue identified by the
 663  * queue identifier.
 664  **/
 665 static inline void
 666 lpfc_debug_dump_eq_by_id(struct lpfc_hba *phba, int qid)
 667 {
 668         int eq_idx;
 669
 670         for (eq_idx = 0; eq_idx < phba->cfg_fcp_eq_count; eq_idx++) {
 671                 if (phba->sli4_hba.fp_eq[eq_idx]->queue_id == qid)
 672                         break;
 673         }
 674
 675         if (eq_idx < phba->cfg_fcp_eq_count) {
 676                 printk(KERN_ERR "FCP EQ[Idx:%d|Qid:%d]\n", eq_idx, qid);
 677                 lpfc_debug_dump_q(phba->sli4_hba.fp_eq[eq_idx]);
 678                 return;
 679         }
 680
 681         if (phba->sli4_hba.sp_eq->queue_id == qid) {
 682                 printk(KERN_ERR "SP EQ[|Qid:%d]\n", qid);
 683                 lpfc_debug_dump_q(phba->sli4_hba.sp_eq);
 684         }
 685 }
 686
 687 void lpfc_debug_dump_all_queues(struct lpfc_hba *);