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