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 (phba->intr_type == MSIX) { 399 if (fcp_cqidx >= phba->cfg_fcp_eq_count) 400 return; 401 } else { 402 if (fcp_cqidx > 0) 403 return; 404 } 405 406 printk(KERN_ERR "FCP CQ: WQ[Idx:%d|Qid%d]->CQ[Idx%d|Qid%d]:\n", 407 fcp_wqidx, phba->sli4_hba.fcp_wq[fcp_wqidx]->queue_id, 408 fcp_cqidx, fcp_cqid); 409 lpfc_debug_dump_q(phba->sli4_hba.fcp_cq[fcp_cqidx]); 410 } 411 412 /** 413 * lpfc_debug_dump_fcp_eq - dump all entries from a fcp work queue's evt queue 414 * @phba: Pointer to HBA context object. 415 * @fcp_wqidx: Index to a FCP work queue. 416 * 417 * This function dumps all entries from a FCP event queue which is 418 * associated to the FCP work queue specified by the @fcp_wqidx. 419 **/ 420 static inline void 421 lpfc_debug_dump_fcp_eq(struct lpfc_hba *phba, int fcp_wqidx) 422 { 423 struct lpfc_queue *qdesc; 424 int fcp_eqidx, fcp_eqid; 425 int fcp_cqidx, fcp_cqid; 426 427 /* sanity check */ 428 if (fcp_wqidx >= phba->cfg_fcp_wq_count) 429 return; 430 fcp_cqid = phba->sli4_hba.fcp_wq[fcp_wqidx]->assoc_qid; 431 for (fcp_cqidx = 0; fcp_cqidx < phba->cfg_fcp_eq_count; fcp_cqidx++) 432 if (phba->sli4_hba.fcp_cq[fcp_cqidx]->queue_id == fcp_cqid) 433 break; 434 if (phba->intr_type == MSIX) { 435 if (fcp_cqidx >= phba->cfg_fcp_eq_count) 436 return; 437 } else { 438 if (fcp_cqidx > 0) 439 return; 440 } 441 442 if (phba->cfg_fcp_eq_count == 0) { 443 fcp_eqidx = -1; 444 fcp_eqid = phba->sli4_hba.sp_eq->queue_id; 445 qdesc = phba->sli4_hba.sp_eq; 446 } else { 447 fcp_eqidx = fcp_cqidx; 448 fcp_eqid = phba->sli4_hba.fp_eq[fcp_eqidx]->queue_id; 449 qdesc = phba->sli4_hba.fp_eq[fcp_eqidx]; 450 } 451 452 printk(KERN_ERR "FCP EQ: WQ[Idx:%d|Qid:%d]->CQ[Idx:%d|Qid:%d]->" 453 "EQ[Idx:%d|Qid:%d]\n", 454 fcp_wqidx, phba->sli4_hba.fcp_wq[fcp_wqidx]->queue_id, 455 fcp_cqidx, fcp_cqid, fcp_eqidx, fcp_eqid); 456 lpfc_debug_dump_q(qdesc); 457 } 458 459 /** 460 * lpfc_debug_dump_els_wq - dump all entries from the els work queue 461 * @phba: Pointer to HBA context object. 462 * 463 * This function dumps all entries from the ELS work queue. 464 **/ 465 static inline void 466 lpfc_debug_dump_els_wq(struct lpfc_hba *phba) 467 { 468 printk(KERN_ERR "ELS WQ: WQ[Qid:%d]:\n", 469 phba->sli4_hba.els_wq->queue_id); 470 lpfc_debug_dump_q(phba->sli4_hba.els_wq); 471 } 472 473 /** 474 * lpfc_debug_dump_mbx_wq - dump all entries from the mbox work queue 475 * @phba: Pointer to HBA context object. 476 * 477 * This function dumps all entries from the MBOX work queue. 478 **/ 479 static inline void 480 lpfc_debug_dump_mbx_wq(struct lpfc_hba *phba) 481 { 482 printk(KERN_ERR "MBX WQ: WQ[Qid:%d]\n", 483 phba->sli4_hba.mbx_wq->queue_id); 484 lpfc_debug_dump_q(phba->sli4_hba.mbx_wq); 485 } 486 487 /** 488 * lpfc_debug_dump_dat_rq - dump all entries from the receive data queue 489 * @phba: Pointer to HBA context object. 490 * 491 * This function dumps all entries from the receive data queue. 492 **/ 493 static inline void 494 lpfc_debug_dump_dat_rq(struct lpfc_hba *phba) 495 { 496 printk(KERN_ERR "DAT RQ: RQ[Qid:%d]\n", 497 phba->sli4_hba.dat_rq->queue_id); 498 lpfc_debug_dump_q(phba->sli4_hba.dat_rq); 499 } 500 501 /** 502 * lpfc_debug_dump_hdr_rq - dump all entries from the receive header queue 503 * @phba: Pointer to HBA context object. 504 * 505 * This function dumps all entries from the receive header queue. 506 **/ 507 static inline void 508 lpfc_debug_dump_hdr_rq(struct lpfc_hba *phba) 509 { 510 printk(KERN_ERR "HDR RQ: RQ[Qid:%d]\n", 511 phba->sli4_hba.hdr_rq->queue_id); 512 lpfc_debug_dump_q(phba->sli4_hba.hdr_rq); 513 } 514 515 /** 516 * lpfc_debug_dump_els_cq - dump all entries from the els complete queue 517 * @phba: Pointer to HBA context object. 518 * 519 * This function dumps all entries from the els complete queue. 520 **/ 521 static inline void 522 lpfc_debug_dump_els_cq(struct lpfc_hba *phba) 523 { 524 printk(KERN_ERR "ELS CQ: WQ[Qid:%d]->CQ[Qid:%d]\n", 525 phba->sli4_hba.els_wq->queue_id, 526 phba->sli4_hba.els_cq->queue_id); 527 lpfc_debug_dump_q(phba->sli4_hba.els_cq); 528 } 529 530 /** 531 * lpfc_debug_dump_mbx_cq - dump all entries from the mbox complete queue 532 * @phba: Pointer to HBA context object. 533 * 534 * This function dumps all entries from the mbox complete queue. 535 **/ 536 static inline void 537 lpfc_debug_dump_mbx_cq(struct lpfc_hba *phba) 538 { 539 printk(KERN_ERR "MBX CQ: WQ[Qid:%d]->CQ[Qid:%d]\n", 540 phba->sli4_hba.mbx_wq->queue_id, 541 phba->sli4_hba.mbx_cq->queue_id); 542 lpfc_debug_dump_q(phba->sli4_hba.mbx_cq); 543 } 544 545 /** 546 * lpfc_debug_dump_sp_eq - dump all entries from slow-path event queue 547 * @phba: Pointer to HBA context object. 548 * 549 * This function dumps all entries from the slow-path event queue. 550 **/ 551 static inline void 552 lpfc_debug_dump_sp_eq(struct lpfc_hba *phba) 553 { 554 printk(KERN_ERR "SP EQ: WQ[Qid:%d/Qid:%d]->CQ[Qid:%d/Qid:%d]->" 555 "EQ[Qid:%d]:\n", 556 phba->sli4_hba.mbx_wq->queue_id, 557 phba->sli4_hba.els_wq->queue_id, 558 phba->sli4_hba.mbx_cq->queue_id, 559 phba->sli4_hba.els_cq->queue_id, 560 phba->sli4_hba.sp_eq->queue_id); 561 lpfc_debug_dump_q(phba->sli4_hba.sp_eq); 562 } 563 564 /** 565 * lpfc_debug_dump_wq_by_id - dump all entries from a work queue by queue id 566 * @phba: Pointer to HBA context object. 567 * @qid: Work queue identifier. 568 * 569 * This function dumps all entries from a work queue identified by the queue 570 * identifier. 571 **/ 572 static inline void 573 lpfc_debug_dump_wq_by_id(struct lpfc_hba *phba, int qid) 574 { 575 int wq_idx; 576 577 for (wq_idx = 0; wq_idx < phba->cfg_fcp_wq_count; wq_idx++) 578 if (phba->sli4_hba.fcp_wq[wq_idx]->queue_id == qid) 579 break; 580 if (wq_idx < phba->cfg_fcp_wq_count) { 581 printk(KERN_ERR "FCP WQ[Idx:%d|Qid:%d]\n", wq_idx, qid); 582 lpfc_debug_dump_q(phba->sli4_hba.fcp_wq[wq_idx]); 583 return; 584 } 585 586 if (phba->sli4_hba.els_wq->queue_id == qid) { 587 printk(KERN_ERR "ELS WQ[Qid:%d]\n", qid); 588 lpfc_debug_dump_q(phba->sli4_hba.els_wq); 589 } 590 } 591 592 /** 593 * lpfc_debug_dump_mq_by_id - dump all entries from a mbox queue by queue id 594 * @phba: Pointer to HBA context object. 595 * @qid: Mbox work queue identifier. 596 * 597 * This function dumps all entries from a mbox work queue identified by the 598 * queue identifier. 599 **/ 600 static inline void 601 lpfc_debug_dump_mq_by_id(struct lpfc_hba *phba, int qid) 602 { 603 if (phba->sli4_hba.mbx_wq->queue_id == qid) { 604 printk(KERN_ERR "MBX WQ[Qid:%d]\n", qid); 605 lpfc_debug_dump_q(phba->sli4_hba.mbx_wq); 606 } 607 } 608 609 /** 610 * lpfc_debug_dump_rq_by_id - dump all entries from a receive queue by queue id 611 * @phba: Pointer to HBA context object. 612 * @qid: Receive queue identifier. 613 * 614 * This function dumps all entries from a receive queue identified by the 615 * queue identifier. 616 **/ 617 static inline void 618 lpfc_debug_dump_rq_by_id(struct lpfc_hba *phba, int qid) 619 { 620 if (phba->sli4_hba.hdr_rq->queue_id == qid) { 621 printk(KERN_ERR "HDR RQ[Qid:%d]\n", qid); 622 lpfc_debug_dump_q(phba->sli4_hba.hdr_rq); 623 return; 624 } 625 if (phba->sli4_hba.dat_rq->queue_id == qid) { 626 printk(KERN_ERR "DAT RQ[Qid:%d]\n", qid); 627 lpfc_debug_dump_q(phba->sli4_hba.dat_rq); 628 } 629 } 630 631 /** 632 * lpfc_debug_dump_cq_by_id - dump all entries from a cmpl queue by queue id 633 * @phba: Pointer to HBA context object. 634 * @qid: Complete queue identifier. 635 * 636 * This function dumps all entries from a complete queue identified by the 637 * queue identifier. 638 **/ 639 static inline void 640 lpfc_debug_dump_cq_by_id(struct lpfc_hba *phba, int qid) 641 { 642 int cq_idx = 0; 643 644 do { 645 if (phba->sli4_hba.fcp_cq[cq_idx]->queue_id == qid) 646 break; 647 } while (++cq_idx < phba->cfg_fcp_eq_count); 648 649 if (cq_idx < phba->cfg_fcp_eq_count) { 650 printk(KERN_ERR "FCP CQ[Idx:%d|Qid:%d]\n", cq_idx, qid); 651 lpfc_debug_dump_q(phba->sli4_hba.fcp_cq[cq_idx]); 652 return; 653 } 654 655 if (phba->sli4_hba.els_cq->queue_id == qid) { 656 printk(KERN_ERR "ELS CQ[Qid:%d]\n", qid); 657 lpfc_debug_dump_q(phba->sli4_hba.els_cq); 658 return; 659 } 660 661 if (phba->sli4_hba.mbx_cq->queue_id == qid) { 662 printk(KERN_ERR "MBX CQ[Qid:%d]\n", qid); 663 lpfc_debug_dump_q(phba->sli4_hba.mbx_cq); 664 } 665 } 666 667 /** 668 * lpfc_debug_dump_eq_by_id - dump all entries from an event queue by queue id 669 * @phba: Pointer to HBA context object. 670 * @qid: Complete queue identifier. 671 * 672 * This function dumps all entries from an event queue identified by the 673 * queue identifier. 674 **/ 675 static inline void 676 lpfc_debug_dump_eq_by_id(struct lpfc_hba *phba, int qid) 677 { 678 int eq_idx; 679 680 for (eq_idx = 0; eq_idx < phba->cfg_fcp_eq_count; eq_idx++) { 681 if (phba->sli4_hba.fp_eq[eq_idx]->queue_id == qid) 682 break; 683 } 684 685 if (eq_idx < phba->cfg_fcp_eq_count) { 686 printk(KERN_ERR "FCP EQ[Idx:%d|Qid:%d]\n", eq_idx, qid); 687 lpfc_debug_dump_q(phba->sli4_hba.fp_eq[eq_idx]); 688 return; 689 } 690 691 if (phba->sli4_hba.sp_eq->queue_id == qid) { 692 printk(KERN_ERR "SP EQ[|Qid:%d]\n", qid); 693 lpfc_debug_dump_q(phba->sli4_hba.sp_eq); 694 } 695 } 696 697 void lpfc_debug_dump_all_queues(struct lpfc_hba *); 698