tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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
188struct 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
197struct 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
206struct lpfc_idiag_offset {
207 uint32_t last_rd;
208};
209
210#define LPFC_IDIAG_CMD_DATA_SIZE 8
211struct 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
246struct 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 **/
286static inline void
287lpfc_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 **/
334static inline void
335lpfc_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 **/
365static inline void
366lpfc_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 **/
385static inline void
386lpfc_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 **/
415static inline void
416lpfc_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 **/
455static inline void
456lpfc_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 **/
469static inline void
470lpfc_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 **/
483static inline void
484lpfc_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 **/
497static inline void
498lpfc_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 **/
511static inline void
512lpfc_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 **/
526static inline void
527lpfc_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 **/
541static inline void
542lpfc_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 **/
562static inline void
563lpfc_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 **/
590static inline void
591lpfc_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 **/
607static inline void
608lpfc_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 **/
629static inline void
630lpfc_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 **/
665static inline void
666lpfc_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
687void lpfc_debug_dump_all_queues(struct lpfc_hba *);