cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

lpfc_debugfs.c (195692B)


      1/*******************************************************************
      2 * This file is part of the Emulex Linux Device Driver for         *
      3 * Fibre Channel Host Bus Adapters.                                *
      4 * Copyright (C) 2017-2021 Broadcom. All Rights Reserved. The term *
      5 * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.  *
      6 * Copyright (C) 2007-2015 Emulex.  All rights reserved.           *
      7 * EMULEX and SLI are trademarks of Emulex.                        *
      8 * www.broadcom.com                                                *
      9 *                                                                 *
     10 * This program is free software; you can redistribute it and/or   *
     11 * modify it under the terms of version 2 of the GNU General       *
     12 * Public License as published by the Free Software Foundation.    *
     13 * This program is distributed in the hope that it will be useful. *
     14 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
     15 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
     16 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
     17 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
     18 * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
     19 * more details, a copy of which can be found in the file COPYING  *
     20 * included with this package.                                     *
     21 *******************************************************************/
     22
     23#include <linux/blkdev.h>
     24#include <linux/delay.h>
     25#include <linux/module.h>
     26#include <linux/dma-mapping.h>
     27#include <linux/idr.h>
     28#include <linux/interrupt.h>
     29#include <linux/kthread.h>
     30#include <linux/slab.h>
     31#include <linux/pci.h>
     32#include <linux/spinlock.h>
     33#include <linux/ctype.h>
     34#include <linux/vmalloc.h>
     35
     36#include <scsi/scsi.h>
     37#include <scsi/scsi_device.h>
     38#include <scsi/scsi_host.h>
     39#include <scsi/scsi_transport_fc.h>
     40#include <scsi/fc/fc_fs.h>
     41
     42#include "lpfc_hw4.h"
     43#include "lpfc_hw.h"
     44#include "lpfc_sli.h"
     45#include "lpfc_sli4.h"
     46#include "lpfc_nl.h"
     47#include "lpfc_disc.h"
     48#include "lpfc.h"
     49#include "lpfc_scsi.h"
     50#include "lpfc_nvme.h"
     51#include "lpfc_logmsg.h"
     52#include "lpfc_crtn.h"
     53#include "lpfc_vport.h"
     54#include "lpfc_version.h"
     55#include "lpfc_compat.h"
     56#include "lpfc_debugfs.h"
     57#include "lpfc_bsg.h"
     58
     59#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
     60/*
     61 * debugfs interface
     62 *
     63 * To access this interface the user should:
     64 * # mount -t debugfs none /sys/kernel/debug
     65 *
     66 * The lpfc debugfs directory hierarchy is:
     67 * /sys/kernel/debug/lpfc/fnX/vportY
     68 * where X is the lpfc hba function unique_id
     69 * where Y is the vport VPI on that hba
     70 *
     71 * Debugging services available per vport:
     72 * discovery_trace
     73 * This is an ACSII readable file that contains a trace of the last
     74 * lpfc_debugfs_max_disc_trc events that happened on a specific vport.
     75 * See lpfc_debugfs.h for different categories of  discovery events.
     76 * To enable the discovery trace, the following module parameters must be set:
     77 * lpfc_debugfs_enable=1         Turns on lpfc debugfs filesystem support
     78 * lpfc_debugfs_max_disc_trc=X   Where X is the event trace depth for
     79 *                               EACH vport. X MUST also be a power of 2.
     80 * lpfc_debugfs_mask_disc_trc=Y  Where Y is an event mask as defined in
     81 *                               lpfc_debugfs.h .
     82 *
     83 * slow_ring_trace
     84 * This is an ACSII readable file that contains a trace of the last
     85 * lpfc_debugfs_max_slow_ring_trc events that happened on a specific HBA.
     86 * To enable the slow ring trace, the following module parameters must be set:
     87 * lpfc_debugfs_enable=1         Turns on lpfc debugfs filesystem support
     88 * lpfc_debugfs_max_slow_ring_trc=X   Where X is the event trace depth for
     89 *                               the HBA. X MUST also be a power of 2.
     90 */
     91static int lpfc_debugfs_enable = 1;
     92module_param(lpfc_debugfs_enable, int, S_IRUGO);
     93MODULE_PARM_DESC(lpfc_debugfs_enable, "Enable debugfs services");
     94
     95/* This MUST be a power of 2 */
     96static int lpfc_debugfs_max_disc_trc;
     97module_param(lpfc_debugfs_max_disc_trc, int, S_IRUGO);
     98MODULE_PARM_DESC(lpfc_debugfs_max_disc_trc,
     99	"Set debugfs discovery trace depth");
    100
    101/* This MUST be a power of 2 */
    102static int lpfc_debugfs_max_slow_ring_trc;
    103module_param(lpfc_debugfs_max_slow_ring_trc, int, S_IRUGO);
    104MODULE_PARM_DESC(lpfc_debugfs_max_slow_ring_trc,
    105	"Set debugfs slow ring trace depth");
    106
    107/* This MUST be a power of 2 */
    108static int lpfc_debugfs_max_nvmeio_trc;
    109module_param(lpfc_debugfs_max_nvmeio_trc, int, 0444);
    110MODULE_PARM_DESC(lpfc_debugfs_max_nvmeio_trc,
    111		 "Set debugfs NVME IO trace depth");
    112
    113static int lpfc_debugfs_mask_disc_trc;
    114module_param(lpfc_debugfs_mask_disc_trc, int, S_IRUGO);
    115MODULE_PARM_DESC(lpfc_debugfs_mask_disc_trc,
    116	"Set debugfs discovery trace mask");
    117
    118#include <linux/debugfs.h>
    119
    120static atomic_t lpfc_debugfs_seq_trc_cnt = ATOMIC_INIT(0);
    121static unsigned long lpfc_debugfs_start_time = 0L;
    122
    123/* iDiag */
    124static struct lpfc_idiag idiag;
    125
    126/**
    127 * lpfc_debugfs_disc_trc_data - Dump discovery logging to a buffer
    128 * @vport: The vport to gather the log info from.
    129 * @buf: The buffer to dump log into.
    130 * @size: The maximum amount of data to process.
    131 *
    132 * Description:
    133 * This routine gathers the lpfc discovery debugfs data from the @vport and
    134 * dumps it to @buf up to @size number of bytes. It will start at the next entry
    135 * in the log and process the log until the end of the buffer. Then it will
    136 * gather from the beginning of the log and process until the current entry.
    137 *
    138 * Notes:
    139 * Discovery logging will be disabled while while this routine dumps the log.
    140 *
    141 * Return Value:
    142 * This routine returns the amount of bytes that were dumped into @buf and will
    143 * not exceed @size.
    144 **/
    145static int
    146lpfc_debugfs_disc_trc_data(struct lpfc_vport *vport, char *buf, int size)
    147{
    148	int i, index, len, enable;
    149	uint32_t ms;
    150	struct lpfc_debugfs_trc *dtp;
    151	char *buffer;
    152
    153	buffer = kmalloc(LPFC_DEBUG_TRC_ENTRY_SIZE, GFP_KERNEL);
    154	if (!buffer)
    155		return 0;
    156
    157	enable = lpfc_debugfs_enable;
    158	lpfc_debugfs_enable = 0;
    159
    160	len = 0;
    161	index = (atomic_read(&vport->disc_trc_cnt) + 1) &
    162		(lpfc_debugfs_max_disc_trc - 1);
    163	for (i = index; i < lpfc_debugfs_max_disc_trc; i++) {
    164		dtp = vport->disc_trc + i;
    165		if (!dtp->fmt)
    166			continue;
    167		ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
    168		snprintf(buffer,
    169			LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
    170			dtp->seq_cnt, ms, dtp->fmt);
    171		len +=  scnprintf(buf+len, size-len, buffer,
    172			dtp->data1, dtp->data2, dtp->data3);
    173	}
    174	for (i = 0; i < index; i++) {
    175		dtp = vport->disc_trc + i;
    176		if (!dtp->fmt)
    177			continue;
    178		ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
    179		snprintf(buffer,
    180			LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
    181			dtp->seq_cnt, ms, dtp->fmt);
    182		len +=  scnprintf(buf+len, size-len, buffer,
    183			dtp->data1, dtp->data2, dtp->data3);
    184	}
    185
    186	lpfc_debugfs_enable = enable;
    187	kfree(buffer);
    188
    189	return len;
    190}
    191
    192/**
    193 * lpfc_debugfs_slow_ring_trc_data - Dump slow ring logging to a buffer
    194 * @phba: The HBA to gather the log info from.
    195 * @buf: The buffer to dump log into.
    196 * @size: The maximum amount of data to process.
    197 *
    198 * Description:
    199 * This routine gathers the lpfc slow ring debugfs data from the @phba and
    200 * dumps it to @buf up to @size number of bytes. It will start at the next entry
    201 * in the log and process the log until the end of the buffer. Then it will
    202 * gather from the beginning of the log and process until the current entry.
    203 *
    204 * Notes:
    205 * Slow ring logging will be disabled while while this routine dumps the log.
    206 *
    207 * Return Value:
    208 * This routine returns the amount of bytes that were dumped into @buf and will
    209 * not exceed @size.
    210 **/
    211static int
    212lpfc_debugfs_slow_ring_trc_data(struct lpfc_hba *phba, char *buf, int size)
    213{
    214	int i, index, len, enable;
    215	uint32_t ms;
    216	struct lpfc_debugfs_trc *dtp;
    217	char *buffer;
    218
    219	buffer = kmalloc(LPFC_DEBUG_TRC_ENTRY_SIZE, GFP_KERNEL);
    220	if (!buffer)
    221		return 0;
    222
    223	enable = lpfc_debugfs_enable;
    224	lpfc_debugfs_enable = 0;
    225
    226	len = 0;
    227	index = (atomic_read(&phba->slow_ring_trc_cnt) + 1) &
    228		(lpfc_debugfs_max_slow_ring_trc - 1);
    229	for (i = index; i < lpfc_debugfs_max_slow_ring_trc; i++) {
    230		dtp = phba->slow_ring_trc + i;
    231		if (!dtp->fmt)
    232			continue;
    233		ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
    234		snprintf(buffer,
    235			LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
    236			dtp->seq_cnt, ms, dtp->fmt);
    237		len +=  scnprintf(buf+len, size-len, buffer,
    238			dtp->data1, dtp->data2, dtp->data3);
    239	}
    240	for (i = 0; i < index; i++) {
    241		dtp = phba->slow_ring_trc + i;
    242		if (!dtp->fmt)
    243			continue;
    244		ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
    245		snprintf(buffer,
    246			LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
    247			dtp->seq_cnt, ms, dtp->fmt);
    248		len +=  scnprintf(buf+len, size-len, buffer,
    249			dtp->data1, dtp->data2, dtp->data3);
    250	}
    251
    252	lpfc_debugfs_enable = enable;
    253	kfree(buffer);
    254
    255	return len;
    256}
    257
    258static int lpfc_debugfs_last_hbq = -1;
    259
    260/**
    261 * lpfc_debugfs_hbqinfo_data - Dump host buffer queue info to a buffer
    262 * @phba: The HBA to gather host buffer info from.
    263 * @buf: The buffer to dump log into.
    264 * @size: The maximum amount of data to process.
    265 *
    266 * Description:
    267 * This routine dumps the host buffer queue info from the @phba to @buf up to
    268 * @size number of bytes. A header that describes the current hbq state will be
    269 * dumped to @buf first and then info on each hbq entry will be dumped to @buf
    270 * until @size bytes have been dumped or all the hbq info has been dumped.
    271 *
    272 * Notes:
    273 * This routine will rotate through each configured HBQ each time called.
    274 *
    275 * Return Value:
    276 * This routine returns the amount of bytes that were dumped into @buf and will
    277 * not exceed @size.
    278 **/
    279static int
    280lpfc_debugfs_hbqinfo_data(struct lpfc_hba *phba, char *buf, int size)
    281{
    282	int len = 0;
    283	int i, j, found, posted, low;
    284	uint32_t phys, raw_index, getidx;
    285	struct lpfc_hbq_init *hip;
    286	struct hbq_s *hbqs;
    287	struct lpfc_hbq_entry *hbqe;
    288	struct lpfc_dmabuf *d_buf;
    289	struct hbq_dmabuf *hbq_buf;
    290
    291	if (phba->sli_rev != 3)
    292		return 0;
    293
    294	spin_lock_irq(&phba->hbalock);
    295
    296	/* toggle between multiple hbqs, if any */
    297	i = lpfc_sli_hbq_count();
    298	if (i > 1) {
    299		 lpfc_debugfs_last_hbq++;
    300		 if (lpfc_debugfs_last_hbq >= i)
    301			lpfc_debugfs_last_hbq = 0;
    302	}
    303	else
    304		lpfc_debugfs_last_hbq = 0;
    305
    306	i = lpfc_debugfs_last_hbq;
    307
    308	len +=  scnprintf(buf+len, size-len, "HBQ %d Info\n", i);
    309
    310	hbqs =  &phba->hbqs[i];
    311	posted = 0;
    312	list_for_each_entry(d_buf, &hbqs->hbq_buffer_list, list)
    313		posted++;
    314
    315	hip =  lpfc_hbq_defs[i];
    316	len +=  scnprintf(buf+len, size-len,
    317		"idx:%d prof:%d rn:%d bufcnt:%d icnt:%d acnt:%d posted %d\n",
    318		hip->hbq_index, hip->profile, hip->rn,
    319		hip->buffer_count, hip->init_count, hip->add_count, posted);
    320
    321	raw_index = phba->hbq_get[i];
    322	getidx = le32_to_cpu(raw_index);
    323	len +=  scnprintf(buf+len, size-len,
    324		"entries:%d bufcnt:%d Put:%d nPut:%d localGet:%d hbaGet:%d\n",
    325		hbqs->entry_count, hbqs->buffer_count, hbqs->hbqPutIdx,
    326		hbqs->next_hbqPutIdx, hbqs->local_hbqGetIdx, getidx);
    327
    328	hbqe = (struct lpfc_hbq_entry *) phba->hbqs[i].hbq_virt;
    329	for (j=0; j<hbqs->entry_count; j++) {
    330		len +=  scnprintf(buf+len, size-len,
    331			"%03d: %08x %04x %05x ", j,
    332			le32_to_cpu(hbqe->bde.addrLow),
    333			le32_to_cpu(hbqe->bde.tus.w),
    334			le32_to_cpu(hbqe->buffer_tag));
    335		i = 0;
    336		found = 0;
    337
    338		/* First calculate if slot has an associated posted buffer */
    339		low = hbqs->hbqPutIdx - posted;
    340		if (low >= 0) {
    341			if ((j >= hbqs->hbqPutIdx) || (j < low)) {
    342				len +=  scnprintf(buf + len, size - len,
    343						"Unused\n");
    344				goto skipit;
    345			}
    346		}
    347		else {
    348			if ((j >= hbqs->hbqPutIdx) &&
    349				(j < (hbqs->entry_count+low))) {
    350				len +=  scnprintf(buf + len, size - len,
    351						"Unused\n");
    352				goto skipit;
    353			}
    354		}
    355
    356		/* Get the Buffer info for the posted buffer */
    357		list_for_each_entry(d_buf, &hbqs->hbq_buffer_list, list) {
    358			hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
    359			phys = ((uint64_t)hbq_buf->dbuf.phys & 0xffffffff);
    360			if (phys == le32_to_cpu(hbqe->bde.addrLow)) {
    361				len +=  scnprintf(buf+len, size-len,
    362					"Buf%d: x%px %06x\n", i,
    363					hbq_buf->dbuf.virt, hbq_buf->tag);
    364				found = 1;
    365				break;
    366			}
    367			i++;
    368		}
    369		if (!found) {
    370			len +=  scnprintf(buf+len, size-len, "No DMAinfo?\n");
    371		}
    372skipit:
    373		hbqe++;
    374		if (len > LPFC_HBQINFO_SIZE - 54)
    375			break;
    376	}
    377	spin_unlock_irq(&phba->hbalock);
    378	return len;
    379}
    380
    381static int lpfc_debugfs_last_xripool;
    382
    383/**
    384 * lpfc_debugfs_commonxripools_data - Dump Hardware Queue info to a buffer
    385 * @phba: The HBA to gather host buffer info from.
    386 * @buf: The buffer to dump log into.
    387 * @size: The maximum amount of data to process.
    388 *
    389 * Description:
    390 * This routine dumps the Hardware Queue info from the @phba to @buf up to
    391 * @size number of bytes. A header that describes the current hdwq state will be
    392 * dumped to @buf first and then info on each hdwq entry will be dumped to @buf
    393 * until @size bytes have been dumped or all the hdwq info has been dumped.
    394 *
    395 * Notes:
    396 * This routine will rotate through each configured Hardware Queue each
    397 * time called.
    398 *
    399 * Return Value:
    400 * This routine returns the amount of bytes that were dumped into @buf and will
    401 * not exceed @size.
    402 **/
    403static int
    404lpfc_debugfs_commonxripools_data(struct lpfc_hba *phba, char *buf, int size)
    405{
    406	struct lpfc_sli4_hdw_queue *qp;
    407	int len = 0;
    408	int i, out;
    409	unsigned long iflag;
    410
    411	for (i = 0; i < phba->cfg_hdw_queue; i++) {
    412		if (len > (LPFC_DUMP_MULTIXRIPOOL_SIZE - 80))
    413			break;
    414		qp = &phba->sli4_hba.hdwq[lpfc_debugfs_last_xripool];
    415
    416		len += scnprintf(buf + len, size - len, "HdwQ %d Info ", i);
    417		spin_lock_irqsave(&qp->abts_io_buf_list_lock, iflag);
    418		spin_lock(&qp->io_buf_list_get_lock);
    419		spin_lock(&qp->io_buf_list_put_lock);
    420		out = qp->total_io_bufs - (qp->get_io_bufs + qp->put_io_bufs +
    421			qp->abts_scsi_io_bufs + qp->abts_nvme_io_bufs);
    422		len += scnprintf(buf + len, size - len,
    423				 "tot:%d get:%d put:%d mt:%d "
    424				 "ABTS scsi:%d nvme:%d Out:%d\n",
    425			qp->total_io_bufs, qp->get_io_bufs, qp->put_io_bufs,
    426			qp->empty_io_bufs, qp->abts_scsi_io_bufs,
    427			qp->abts_nvme_io_bufs, out);
    428		spin_unlock(&qp->io_buf_list_put_lock);
    429		spin_unlock(&qp->io_buf_list_get_lock);
    430		spin_unlock_irqrestore(&qp->abts_io_buf_list_lock, iflag);
    431
    432		lpfc_debugfs_last_xripool++;
    433		if (lpfc_debugfs_last_xripool >= phba->cfg_hdw_queue)
    434			lpfc_debugfs_last_xripool = 0;
    435	}
    436
    437	return len;
    438}
    439
    440/**
    441 * lpfc_debugfs_multixripools_data - Display multi-XRI pools information
    442 * @phba: The HBA to gather host buffer info from.
    443 * @buf: The buffer to dump log into.
    444 * @size: The maximum amount of data to process.
    445 *
    446 * Description:
    447 * This routine displays current multi-XRI pools information including XRI
    448 * count in public, private and txcmplq. It also displays current high and
    449 * low watermark.
    450 *
    451 * Return Value:
    452 * This routine returns the amount of bytes that were dumped into @buf and will
    453 * not exceed @size.
    454 **/
    455static int
    456lpfc_debugfs_multixripools_data(struct lpfc_hba *phba, char *buf, int size)
    457{
    458	u32 i;
    459	u32 hwq_count;
    460	struct lpfc_sli4_hdw_queue *qp;
    461	struct lpfc_multixri_pool *multixri_pool;
    462	struct lpfc_pvt_pool *pvt_pool;
    463	struct lpfc_pbl_pool *pbl_pool;
    464	u32 txcmplq_cnt;
    465	char tmp[LPFC_DEBUG_OUT_LINE_SZ] = {0};
    466
    467	if (phba->sli_rev != LPFC_SLI_REV4)
    468		return 0;
    469
    470	if (!phba->sli4_hba.hdwq)
    471		return 0;
    472
    473	if (!phba->cfg_xri_rebalancing) {
    474		i = lpfc_debugfs_commonxripools_data(phba, buf, size);
    475		return i;
    476	}
    477
    478	/*
    479	 * Pbl: Current number of free XRIs in public pool
    480	 * Pvt: Current number of free XRIs in private pool
    481	 * Busy: Current number of outstanding XRIs
    482	 * HWM: Current high watermark
    483	 * pvt_empty: Incremented by 1 when IO submission fails (no xri)
    484	 * pbl_empty: Incremented by 1 when all pbl_pool are empty during
    485	 *            IO submission
    486	 */
    487	scnprintf(tmp, sizeof(tmp),
    488		  "HWQ:  Pbl  Pvt Busy  HWM |  pvt_empty  pbl_empty ");
    489	if (strlcat(buf, tmp, size) >= size)
    490		return strnlen(buf, size);
    491
    492#ifdef LPFC_MXP_STAT
    493	/*
    494	 * MAXH: Max high watermark seen so far
    495	 * above_lmt: Incremented by 1 if xri_owned > xri_limit during
    496	 *            IO submission
    497	 * below_lmt: Incremented by 1 if xri_owned <= xri_limit  during
    498	 *            IO submission
    499	 * locPbl_hit: Incremented by 1 if successfully get a batch of XRI from
    500	 *             local pbl_pool
    501	 * othPbl_hit: Incremented by 1 if successfully get a batch of XRI from
    502	 *             other pbl_pool
    503	 */
    504	scnprintf(tmp, sizeof(tmp),
    505		  "MAXH  above_lmt  below_lmt locPbl_hit othPbl_hit");
    506	if (strlcat(buf, tmp, size) >= size)
    507		return strnlen(buf, size);
    508
    509	/*
    510	 * sPbl: snapshot of Pbl 15 sec after stat gets cleared
    511	 * sPvt: snapshot of Pvt 15 sec after stat gets cleared
    512	 * sBusy: snapshot of Busy 15 sec after stat gets cleared
    513	 */
    514	scnprintf(tmp, sizeof(tmp),
    515		  " | sPbl sPvt sBusy");
    516	if (strlcat(buf, tmp, size) >= size)
    517		return strnlen(buf, size);
    518#endif
    519
    520	scnprintf(tmp, sizeof(tmp), "\n");
    521	if (strlcat(buf, tmp, size) >= size)
    522		return strnlen(buf, size);
    523
    524	hwq_count = phba->cfg_hdw_queue;
    525	for (i = 0; i < hwq_count; i++) {
    526		qp = &phba->sli4_hba.hdwq[i];
    527		multixri_pool = qp->p_multixri_pool;
    528		if (!multixri_pool)
    529			continue;
    530		pbl_pool = &multixri_pool->pbl_pool;
    531		pvt_pool = &multixri_pool->pvt_pool;
    532		txcmplq_cnt = qp->io_wq->pring->txcmplq_cnt;
    533
    534		scnprintf(tmp, sizeof(tmp),
    535			  "%03d: %4d %4d %4d %4d | %10d %10d ",
    536			  i, pbl_pool->count, pvt_pool->count,
    537			  txcmplq_cnt, pvt_pool->high_watermark,
    538			  qp->empty_io_bufs, multixri_pool->pbl_empty_count);
    539		if (strlcat(buf, tmp, size) >= size)
    540			break;
    541
    542#ifdef LPFC_MXP_STAT
    543		scnprintf(tmp, sizeof(tmp),
    544			  "%4d %10d %10d %10d %10d",
    545			  multixri_pool->stat_max_hwm,
    546			  multixri_pool->above_limit_count,
    547			  multixri_pool->below_limit_count,
    548			  multixri_pool->local_pbl_hit_count,
    549			  multixri_pool->other_pbl_hit_count);
    550		if (strlcat(buf, tmp, size) >= size)
    551			break;
    552
    553		scnprintf(tmp, sizeof(tmp),
    554			  " | %4d %4d %5d",
    555			  multixri_pool->stat_pbl_count,
    556			  multixri_pool->stat_pvt_count,
    557			  multixri_pool->stat_busy_count);
    558		if (strlcat(buf, tmp, size) >= size)
    559			break;
    560#endif
    561
    562		scnprintf(tmp, sizeof(tmp), "\n");
    563		if (strlcat(buf, tmp, size) >= size)
    564			break;
    565	}
    566	return strnlen(buf, size);
    567}
    568
    569
    570#ifdef LPFC_HDWQ_LOCK_STAT
    571static int lpfc_debugfs_last_lock;
    572
    573/**
    574 * lpfc_debugfs_lockstat_data - Dump Hardware Queue info to a buffer
    575 * @phba: The HBA to gather host buffer info from.
    576 * @buf: The buffer to dump log into.
    577 * @size: The maximum amount of data to process.
    578 *
    579 * Description:
    580 * This routine dumps the Hardware Queue info from the @phba to @buf up to
    581 * @size number of bytes. A header that describes the current hdwq state will be
    582 * dumped to @buf first and then info on each hdwq entry will be dumped to @buf
    583 * until @size bytes have been dumped or all the hdwq info has been dumped.
    584 *
    585 * Notes:
    586 * This routine will rotate through each configured Hardware Queue each
    587 * time called.
    588 *
    589 * Return Value:
    590 * This routine returns the amount of bytes that were dumped into @buf and will
    591 * not exceed @size.
    592 **/
    593static int
    594lpfc_debugfs_lockstat_data(struct lpfc_hba *phba, char *buf, int size)
    595{
    596	struct lpfc_sli4_hdw_queue *qp;
    597	int len = 0;
    598	int i;
    599
    600	if (phba->sli_rev != LPFC_SLI_REV4)
    601		return 0;
    602
    603	if (!phba->sli4_hba.hdwq)
    604		return 0;
    605
    606	for (i = 0; i < phba->cfg_hdw_queue; i++) {
    607		if (len > (LPFC_HDWQINFO_SIZE - 100))
    608			break;
    609		qp = &phba->sli4_hba.hdwq[lpfc_debugfs_last_lock];
    610
    611		len += scnprintf(buf + len, size - len, "HdwQ %03d Lock ", i);
    612		if (phba->cfg_xri_rebalancing) {
    613			len += scnprintf(buf + len, size - len,
    614					 "get_pvt:%d mv_pvt:%d "
    615					 "mv2pub:%d mv2pvt:%d "
    616					 "put_pvt:%d put_pub:%d wq:%d\n",
    617					 qp->lock_conflict.alloc_pvt_pool,
    618					 qp->lock_conflict.mv_from_pvt_pool,
    619					 qp->lock_conflict.mv_to_pub_pool,
    620					 qp->lock_conflict.mv_to_pvt_pool,
    621					 qp->lock_conflict.free_pvt_pool,
    622					 qp->lock_conflict.free_pub_pool,
    623					 qp->lock_conflict.wq_access);
    624		} else {
    625			len += scnprintf(buf + len, size - len,
    626					 "get:%d put:%d free:%d wq:%d\n",
    627					 qp->lock_conflict.alloc_xri_get,
    628					 qp->lock_conflict.alloc_xri_put,
    629					 qp->lock_conflict.free_xri,
    630					 qp->lock_conflict.wq_access);
    631		}
    632
    633		lpfc_debugfs_last_lock++;
    634		if (lpfc_debugfs_last_lock >= phba->cfg_hdw_queue)
    635			lpfc_debugfs_last_lock = 0;
    636	}
    637
    638	return len;
    639}
    640#endif
    641
    642static int lpfc_debugfs_last_hba_slim_off;
    643
    644/**
    645 * lpfc_debugfs_dumpHBASlim_data - Dump HBA SLIM info to a buffer
    646 * @phba: The HBA to gather SLIM info from.
    647 * @buf: The buffer to dump log into.
    648 * @size: The maximum amount of data to process.
    649 *
    650 * Description:
    651 * This routine dumps the current contents of HBA SLIM for the HBA associated
    652 * with @phba to @buf up to @size bytes of data. This is the raw HBA SLIM data.
    653 *
    654 * Notes:
    655 * This routine will only dump up to 1024 bytes of data each time called and
    656 * should be called multiple times to dump the entire HBA SLIM.
    657 *
    658 * Return Value:
    659 * This routine returns the amount of bytes that were dumped into @buf and will
    660 * not exceed @size.
    661 **/
    662static int
    663lpfc_debugfs_dumpHBASlim_data(struct lpfc_hba *phba, char *buf, int size)
    664{
    665	int len = 0;
    666	int i, off;
    667	uint32_t *ptr;
    668	char *buffer;
    669
    670	buffer = kmalloc(1024, GFP_KERNEL);
    671	if (!buffer)
    672		return 0;
    673
    674	off = 0;
    675	spin_lock_irq(&phba->hbalock);
    676
    677	len +=  scnprintf(buf+len, size-len, "HBA SLIM\n");
    678	lpfc_memcpy_from_slim(buffer,
    679		phba->MBslimaddr + lpfc_debugfs_last_hba_slim_off, 1024);
    680
    681	ptr = (uint32_t *)&buffer[0];
    682	off = lpfc_debugfs_last_hba_slim_off;
    683
    684	/* Set it up for the next time */
    685	lpfc_debugfs_last_hba_slim_off += 1024;
    686	if (lpfc_debugfs_last_hba_slim_off >= 4096)
    687		lpfc_debugfs_last_hba_slim_off = 0;
    688
    689	i = 1024;
    690	while (i > 0) {
    691		len +=  scnprintf(buf+len, size-len,
    692		"%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
    693		off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
    694		*(ptr+5), *(ptr+6), *(ptr+7));
    695		ptr += 8;
    696		i -= (8 * sizeof(uint32_t));
    697		off += (8 * sizeof(uint32_t));
    698	}
    699
    700	spin_unlock_irq(&phba->hbalock);
    701	kfree(buffer);
    702
    703	return len;
    704}
    705
    706/**
    707 * lpfc_debugfs_dumpHostSlim_data - Dump host SLIM info to a buffer
    708 * @phba: The HBA to gather Host SLIM info from.
    709 * @buf: The buffer to dump log into.
    710 * @size: The maximum amount of data to process.
    711 *
    712 * Description:
    713 * This routine dumps the current contents of host SLIM for the host associated
    714 * with @phba to @buf up to @size bytes of data. The dump will contain the
    715 * Mailbox, PCB, Rings, and Registers that are located in host memory.
    716 *
    717 * Return Value:
    718 * This routine returns the amount of bytes that were dumped into @buf and will
    719 * not exceed @size.
    720 **/
    721static int
    722lpfc_debugfs_dumpHostSlim_data(struct lpfc_hba *phba, char *buf, int size)
    723{
    724	int len = 0;
    725	int i, off;
    726	uint32_t word0, word1, word2, word3;
    727	uint32_t *ptr;
    728	struct lpfc_pgp *pgpp;
    729	struct lpfc_sli *psli = &phba->sli;
    730	struct lpfc_sli_ring *pring;
    731
    732	off = 0;
    733	spin_lock_irq(&phba->hbalock);
    734
    735	len +=  scnprintf(buf+len, size-len, "SLIM Mailbox\n");
    736	ptr = (uint32_t *)phba->slim2p.virt;
    737	i = sizeof(MAILBOX_t);
    738	while (i > 0) {
    739		len +=  scnprintf(buf+len, size-len,
    740		"%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
    741		off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
    742		*(ptr+5), *(ptr+6), *(ptr+7));
    743		ptr += 8;
    744		i -= (8 * sizeof(uint32_t));
    745		off += (8 * sizeof(uint32_t));
    746	}
    747
    748	len +=  scnprintf(buf+len, size-len, "SLIM PCB\n");
    749	ptr = (uint32_t *)phba->pcb;
    750	i = sizeof(PCB_t);
    751	while (i > 0) {
    752		len +=  scnprintf(buf+len, size-len,
    753		"%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
    754		off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
    755		*(ptr+5), *(ptr+6), *(ptr+7));
    756		ptr += 8;
    757		i -= (8 * sizeof(uint32_t));
    758		off += (8 * sizeof(uint32_t));
    759	}
    760
    761	if (phba->sli_rev <= LPFC_SLI_REV3) {
    762		for (i = 0; i < 4; i++) {
    763			pgpp = &phba->port_gp[i];
    764			pring = &psli->sli3_ring[i];
    765			len +=  scnprintf(buf+len, size-len,
    766					 "Ring %d: CMD GetInx:%d "
    767					 "(Max:%d Next:%d "
    768					 "Local:%d flg:x%x)  "
    769					 "RSP PutInx:%d Max:%d\n",
    770					 i, pgpp->cmdGetInx,
    771					 pring->sli.sli3.numCiocb,
    772					 pring->sli.sli3.next_cmdidx,
    773					 pring->sli.sli3.local_getidx,
    774					 pring->flag, pgpp->rspPutInx,
    775					 pring->sli.sli3.numRiocb);
    776		}
    777
    778		word0 = readl(phba->HAregaddr);
    779		word1 = readl(phba->CAregaddr);
    780		word2 = readl(phba->HSregaddr);
    781		word3 = readl(phba->HCregaddr);
    782		len +=  scnprintf(buf+len, size-len, "HA:%08x CA:%08x HS:%08x "
    783				 "HC:%08x\n", word0, word1, word2, word3);
    784	}
    785	spin_unlock_irq(&phba->hbalock);
    786	return len;
    787}
    788
    789/**
    790 * lpfc_debugfs_nodelist_data - Dump target node list to a buffer
    791 * @vport: The vport to gather target node info from.
    792 * @buf: The buffer to dump log into.
    793 * @size: The maximum amount of data to process.
    794 *
    795 * Description:
    796 * This routine dumps the current target node list associated with @vport to
    797 * @buf up to @size bytes of data. Each node entry in the dump will contain a
    798 * node state, DID, WWPN, WWNN, RPI, flags, type, and other useful fields.
    799 *
    800 * Return Value:
    801 * This routine returns the amount of bytes that were dumped into @buf and will
    802 * not exceed @size.
    803 **/
    804static int
    805lpfc_debugfs_nodelist_data(struct lpfc_vport *vport, char *buf, int size)
    806{
    807	int len = 0;
    808	int i, iocnt, outio, cnt;
    809	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
    810	struct lpfc_hba  *phba = vport->phba;
    811	struct lpfc_nodelist *ndlp;
    812	unsigned char *statep;
    813	struct nvme_fc_local_port *localport;
    814	struct nvme_fc_remote_port *nrport = NULL;
    815	struct lpfc_nvme_rport *rport;
    816
    817	cnt = (LPFC_NODELIST_SIZE / LPFC_NODELIST_ENTRY_SIZE);
    818	outio = 0;
    819
    820	len += scnprintf(buf+len, size-len, "\nFCP Nodelist Entries ...\n");
    821	spin_lock_irq(shost->host_lock);
    822	list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
    823		iocnt = 0;
    824		if (!cnt) {
    825			len +=  scnprintf(buf+len, size-len,
    826				"Missing Nodelist Entries\n");
    827			break;
    828		}
    829		cnt--;
    830		switch (ndlp->nlp_state) {
    831		case NLP_STE_UNUSED_NODE:
    832			statep = "UNUSED";
    833			break;
    834		case NLP_STE_PLOGI_ISSUE:
    835			statep = "PLOGI ";
    836			break;
    837		case NLP_STE_ADISC_ISSUE:
    838			statep = "ADISC ";
    839			break;
    840		case NLP_STE_REG_LOGIN_ISSUE:
    841			statep = "REGLOG";
    842			break;
    843		case NLP_STE_PRLI_ISSUE:
    844			statep = "PRLI  ";
    845			break;
    846		case NLP_STE_LOGO_ISSUE:
    847			statep = "LOGO  ";
    848			break;
    849		case NLP_STE_UNMAPPED_NODE:
    850			statep = "UNMAP ";
    851			iocnt = 1;
    852			break;
    853		case NLP_STE_MAPPED_NODE:
    854			statep = "MAPPED";
    855			iocnt = 1;
    856			break;
    857		case NLP_STE_NPR_NODE:
    858			statep = "NPR   ";
    859			break;
    860		default:
    861			statep = "UNKNOWN";
    862		}
    863		len += scnprintf(buf+len, size-len, "%s DID:x%06x ",
    864				statep, ndlp->nlp_DID);
    865		len += scnprintf(buf+len, size-len,
    866				"WWPN x%016llx ",
    867				wwn_to_u64(ndlp->nlp_portname.u.wwn));
    868		len += scnprintf(buf+len, size-len,
    869				"WWNN x%016llx ",
    870				wwn_to_u64(ndlp->nlp_nodename.u.wwn));
    871		len += scnprintf(buf+len, size-len, "RPI:x%04x ",
    872				 ndlp->nlp_rpi);
    873		len +=  scnprintf(buf+len, size-len, "flag:x%08x ",
    874			ndlp->nlp_flag);
    875		if (!ndlp->nlp_type)
    876			len += scnprintf(buf+len, size-len, "UNKNOWN_TYPE ");
    877		if (ndlp->nlp_type & NLP_FC_NODE)
    878			len += scnprintf(buf+len, size-len, "FC_NODE ");
    879		if (ndlp->nlp_type & NLP_FABRIC) {
    880			len += scnprintf(buf+len, size-len, "FABRIC ");
    881			iocnt = 0;
    882		}
    883		if (ndlp->nlp_type & NLP_FCP_TARGET)
    884			len += scnprintf(buf+len, size-len, "FCP_TGT sid:%d ",
    885				ndlp->nlp_sid);
    886		if (ndlp->nlp_type & NLP_FCP_INITIATOR)
    887			len += scnprintf(buf+len, size-len, "FCP_INITIATOR ");
    888		if (ndlp->nlp_type & NLP_NVME_TARGET)
    889			len += scnprintf(buf + len,
    890					size - len, "NVME_TGT sid:%d ",
    891					NLP_NO_SID);
    892		if (ndlp->nlp_type & NLP_NVME_INITIATOR)
    893			len += scnprintf(buf + len,
    894					size - len, "NVME_INITIATOR ");
    895		len += scnprintf(buf+len, size-len, "refcnt:%d",
    896			kref_read(&ndlp->kref));
    897		if (iocnt) {
    898			i = atomic_read(&ndlp->cmd_pending);
    899			len += scnprintf(buf + len, size - len,
    900					" OutIO:x%x Qdepth x%x",
    901					i, ndlp->cmd_qdepth);
    902			outio += i;
    903		}
    904		len += scnprintf(buf+len, size-len, " xpt:x%x",
    905				 ndlp->fc4_xpt_flags);
    906		if (ndlp->nlp_defer_did != NLP_EVT_NOTHING_PENDING)
    907			len += scnprintf(buf+len, size-len, " defer:%x",
    908					 ndlp->nlp_defer_did);
    909		len +=  scnprintf(buf+len, size-len, "\n");
    910	}
    911	spin_unlock_irq(shost->host_lock);
    912
    913	len += scnprintf(buf + len, size - len,
    914			"\nOutstanding IO x%x\n",  outio);
    915
    916	if (phba->nvmet_support && phba->targetport && (vport == phba->pport)) {
    917		len += scnprintf(buf + len, size - len,
    918				"\nNVME Targetport Entry ...\n");
    919
    920		/* Port state is only one of two values for now. */
    921		if (phba->targetport->port_id)
    922			statep = "REGISTERED";
    923		else
    924			statep = "INIT";
    925		len += scnprintf(buf + len, size - len,
    926				"TGT WWNN x%llx WWPN x%llx State %s\n",
    927				wwn_to_u64(vport->fc_nodename.u.wwn),
    928				wwn_to_u64(vport->fc_portname.u.wwn),
    929				statep);
    930		len += scnprintf(buf + len, size - len,
    931				"    Targetport DID x%06x\n",
    932				phba->targetport->port_id);
    933		goto out_exit;
    934	}
    935
    936	len += scnprintf(buf + len, size - len,
    937				"\nNVME Lport/Rport Entries ...\n");
    938
    939	localport = vport->localport;
    940	if (!localport)
    941		goto out_exit;
    942
    943	spin_lock_irq(shost->host_lock);
    944
    945	/* Port state is only one of two values for now. */
    946	if (localport->port_id)
    947		statep = "ONLINE";
    948	else
    949		statep = "UNKNOWN ";
    950
    951	len += scnprintf(buf + len, size - len,
    952			"Lport DID x%06x PortState %s\n",
    953			localport->port_id, statep);
    954
    955	len += scnprintf(buf + len, size - len, "\tRport List:\n");
    956	list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
    957		/* local short-hand pointer. */
    958		spin_lock(&ndlp->lock);
    959		rport = lpfc_ndlp_get_nrport(ndlp);
    960		if (rport)
    961			nrport = rport->remoteport;
    962		else
    963			nrport = NULL;
    964		spin_unlock(&ndlp->lock);
    965		if (!nrport)
    966			continue;
    967
    968		/* Port state is only one of two values for now. */
    969		switch (nrport->port_state) {
    970		case FC_OBJSTATE_ONLINE:
    971			statep = "ONLINE";
    972			break;
    973		case FC_OBJSTATE_UNKNOWN:
    974			statep = "UNKNOWN ";
    975			break;
    976		default:
    977			statep = "UNSUPPORTED";
    978			break;
    979		}
    980
    981		/* Tab in to show lport ownership. */
    982		len += scnprintf(buf + len, size - len,
    983				"\t%s Port ID:x%06x ",
    984				statep, nrport->port_id);
    985		len += scnprintf(buf + len, size - len, "WWPN x%llx ",
    986				nrport->port_name);
    987		len += scnprintf(buf + len, size - len, "WWNN x%llx ",
    988				nrport->node_name);
    989
    990		/* An NVME rport can have multiple roles. */
    991		if (nrport->port_role & FC_PORT_ROLE_NVME_INITIATOR)
    992			len +=  scnprintf(buf + len, size - len,
    993					 "INITIATOR ");
    994		if (nrport->port_role & FC_PORT_ROLE_NVME_TARGET)
    995			len +=  scnprintf(buf + len, size - len,
    996					 "TARGET ");
    997		if (nrport->port_role & FC_PORT_ROLE_NVME_DISCOVERY)
    998			len +=  scnprintf(buf + len, size - len,
    999					 "DISCSRVC ");
   1000		if (nrport->port_role & ~(FC_PORT_ROLE_NVME_INITIATOR |
   1001					  FC_PORT_ROLE_NVME_TARGET |
   1002					  FC_PORT_ROLE_NVME_DISCOVERY))
   1003			len +=  scnprintf(buf + len, size - len,
   1004					 "UNKNOWN ROLE x%x",
   1005					 nrport->port_role);
   1006		/* Terminate the string. */
   1007		len +=  scnprintf(buf + len, size - len, "\n");
   1008	}
   1009
   1010	spin_unlock_irq(shost->host_lock);
   1011 out_exit:
   1012	return len;
   1013}
   1014
   1015/**
   1016 * lpfc_debugfs_nvmestat_data - Dump target node list to a buffer
   1017 * @vport: The vport to gather target node info from.
   1018 * @buf: The buffer to dump log into.
   1019 * @size: The maximum amount of data to process.
   1020 *
   1021 * Description:
   1022 * This routine dumps the NVME statistics associated with @vport
   1023 *
   1024 * Return Value:
   1025 * This routine returns the amount of bytes that were dumped into @buf and will
   1026 * not exceed @size.
   1027 **/
   1028static int
   1029lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
   1030{
   1031	struct lpfc_hba   *phba = vport->phba;
   1032	struct lpfc_nvmet_tgtport *tgtp;
   1033	struct lpfc_async_xchg_ctx *ctxp, *next_ctxp;
   1034	struct nvme_fc_local_port *localport;
   1035	struct lpfc_fc4_ctrl_stat *cstat;
   1036	struct lpfc_nvme_lport *lport;
   1037	uint64_t data1, data2, data3;
   1038	uint64_t tot, totin, totout;
   1039	int cnt, i;
   1040	int len = 0;
   1041
   1042	if (phba->nvmet_support) {
   1043		if (!phba->targetport)
   1044			return len;
   1045		tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private;
   1046		len += scnprintf(buf + len, size - len,
   1047				"\nNVME Targetport Statistics\n");
   1048
   1049		len += scnprintf(buf + len, size - len,
   1050				"LS: Rcv %08x Drop %08x Abort %08x\n",
   1051				atomic_read(&tgtp->rcv_ls_req_in),
   1052				atomic_read(&tgtp->rcv_ls_req_drop),
   1053				atomic_read(&tgtp->xmt_ls_abort));
   1054		if (atomic_read(&tgtp->rcv_ls_req_in) !=
   1055		    atomic_read(&tgtp->rcv_ls_req_out)) {
   1056			len += scnprintf(buf + len, size - len,
   1057					"Rcv LS: in %08x != out %08x\n",
   1058					atomic_read(&tgtp->rcv_ls_req_in),
   1059					atomic_read(&tgtp->rcv_ls_req_out));
   1060		}
   1061
   1062		len += scnprintf(buf + len, size - len,
   1063				"LS: Xmt %08x Drop %08x Cmpl %08x\n",
   1064				atomic_read(&tgtp->xmt_ls_rsp),
   1065				atomic_read(&tgtp->xmt_ls_drop),
   1066				atomic_read(&tgtp->xmt_ls_rsp_cmpl));
   1067
   1068		len += scnprintf(buf + len, size - len,
   1069				"LS: RSP Abort %08x xb %08x Err %08x\n",
   1070				atomic_read(&tgtp->xmt_ls_rsp_aborted),
   1071				atomic_read(&tgtp->xmt_ls_rsp_xb_set),
   1072				atomic_read(&tgtp->xmt_ls_rsp_error));
   1073
   1074		len += scnprintf(buf + len, size - len,
   1075				"FCP: Rcv %08x Defer %08x Release %08x "
   1076				"Drop %08x\n",
   1077				atomic_read(&tgtp->rcv_fcp_cmd_in),
   1078				atomic_read(&tgtp->rcv_fcp_cmd_defer),
   1079				atomic_read(&tgtp->xmt_fcp_release),
   1080				atomic_read(&tgtp->rcv_fcp_cmd_drop));
   1081
   1082		if (atomic_read(&tgtp->rcv_fcp_cmd_in) !=
   1083		    atomic_read(&tgtp->rcv_fcp_cmd_out)) {
   1084			len += scnprintf(buf + len, size - len,
   1085					"Rcv FCP: in %08x != out %08x\n",
   1086					atomic_read(&tgtp->rcv_fcp_cmd_in),
   1087					atomic_read(&tgtp->rcv_fcp_cmd_out));
   1088		}
   1089
   1090		len += scnprintf(buf + len, size - len,
   1091				"FCP Rsp: read %08x readrsp %08x "
   1092				"write %08x rsp %08x\n",
   1093				atomic_read(&tgtp->xmt_fcp_read),
   1094				atomic_read(&tgtp->xmt_fcp_read_rsp),
   1095				atomic_read(&tgtp->xmt_fcp_write),
   1096				atomic_read(&tgtp->xmt_fcp_rsp));
   1097
   1098		len += scnprintf(buf + len, size - len,
   1099				"FCP Rsp Cmpl: %08x err %08x drop %08x\n",
   1100				atomic_read(&tgtp->xmt_fcp_rsp_cmpl),
   1101				atomic_read(&tgtp->xmt_fcp_rsp_error),
   1102				atomic_read(&tgtp->xmt_fcp_rsp_drop));
   1103
   1104		len += scnprintf(buf + len, size - len,
   1105				"FCP Rsp Abort: %08x xb %08x xricqe  %08x\n",
   1106				atomic_read(&tgtp->xmt_fcp_rsp_aborted),
   1107				atomic_read(&tgtp->xmt_fcp_rsp_xb_set),
   1108				atomic_read(&tgtp->xmt_fcp_xri_abort_cqe));
   1109
   1110		len += scnprintf(buf + len, size - len,
   1111				"ABORT: Xmt %08x Cmpl %08x\n",
   1112				atomic_read(&tgtp->xmt_fcp_abort),
   1113				atomic_read(&tgtp->xmt_fcp_abort_cmpl));
   1114
   1115		len += scnprintf(buf + len, size - len,
   1116				"ABORT: Sol %08x  Usol %08x Err %08x Cmpl %08x",
   1117				atomic_read(&tgtp->xmt_abort_sol),
   1118				atomic_read(&tgtp->xmt_abort_unsol),
   1119				atomic_read(&tgtp->xmt_abort_rsp),
   1120				atomic_read(&tgtp->xmt_abort_rsp_error));
   1121
   1122		len +=  scnprintf(buf + len, size - len, "\n");
   1123
   1124		cnt = 0;
   1125		spin_lock(&phba->sli4_hba.abts_nvmet_buf_list_lock);
   1126		list_for_each_entry_safe(ctxp, next_ctxp,
   1127				&phba->sli4_hba.lpfc_abts_nvmet_ctx_list,
   1128				list) {
   1129			cnt++;
   1130		}
   1131		spin_unlock(&phba->sli4_hba.abts_nvmet_buf_list_lock);
   1132		if (cnt) {
   1133			len += scnprintf(buf + len, size - len,
   1134					"ABORT: %d ctx entries\n", cnt);
   1135			spin_lock(&phba->sli4_hba.abts_nvmet_buf_list_lock);
   1136			list_for_each_entry_safe(ctxp, next_ctxp,
   1137				    &phba->sli4_hba.lpfc_abts_nvmet_ctx_list,
   1138				    list) {
   1139				if (len >= (size - LPFC_DEBUG_OUT_LINE_SZ))
   1140					break;
   1141				len += scnprintf(buf + len, size - len,
   1142						"Entry: oxid %x state %x "
   1143						"flag %x\n",
   1144						ctxp->oxid, ctxp->state,
   1145						ctxp->flag);
   1146			}
   1147			spin_unlock(&phba->sli4_hba.abts_nvmet_buf_list_lock);
   1148		}
   1149
   1150		/* Calculate outstanding IOs */
   1151		tot = atomic_read(&tgtp->rcv_fcp_cmd_drop);
   1152		tot += atomic_read(&tgtp->xmt_fcp_release);
   1153		tot = atomic_read(&tgtp->rcv_fcp_cmd_in) - tot;
   1154
   1155		len += scnprintf(buf + len, size - len,
   1156				"IO_CTX: %08x  WAIT: cur %08x tot %08x\n"
   1157				"CTX Outstanding %08llx\n",
   1158				phba->sli4_hba.nvmet_xri_cnt,
   1159				phba->sli4_hba.nvmet_io_wait_cnt,
   1160				phba->sli4_hba.nvmet_io_wait_total,
   1161				tot);
   1162	} else {
   1163		if (!(vport->cfg_enable_fc4_type & LPFC_ENABLE_NVME))
   1164			return len;
   1165
   1166		localport = vport->localport;
   1167		if (!localport)
   1168			return len;
   1169		lport = (struct lpfc_nvme_lport *)localport->private;
   1170		if (!lport)
   1171			return len;
   1172
   1173		len += scnprintf(buf + len, size - len,
   1174				"\nNVME HDWQ Statistics\n");
   1175
   1176		len += scnprintf(buf + len, size - len,
   1177				"LS: Xmt %016x Cmpl %016x\n",
   1178				atomic_read(&lport->fc4NvmeLsRequests),
   1179				atomic_read(&lport->fc4NvmeLsCmpls));
   1180
   1181		totin = 0;
   1182		totout = 0;
   1183		for (i = 0; i < phba->cfg_hdw_queue; i++) {
   1184			cstat = &phba->sli4_hba.hdwq[i].nvme_cstat;
   1185			tot = cstat->io_cmpls;
   1186			totin += tot;
   1187			data1 = cstat->input_requests;
   1188			data2 = cstat->output_requests;
   1189			data3 = cstat->control_requests;
   1190			totout += (data1 + data2 + data3);
   1191
   1192			/* Limit to 32, debugfs display buffer limitation */
   1193			if (i >= 32)
   1194				continue;
   1195
   1196			len += scnprintf(buf + len, PAGE_SIZE - len,
   1197					"HDWQ (%d): Rd %016llx Wr %016llx "
   1198					"IO %016llx ",
   1199					i, data1, data2, data3);
   1200			len += scnprintf(buf + len, PAGE_SIZE - len,
   1201					"Cmpl %016llx OutIO %016llx\n",
   1202					tot, ((data1 + data2 + data3) - tot));
   1203		}
   1204		len += scnprintf(buf + len, PAGE_SIZE - len,
   1205				"Total FCP Cmpl %016llx Issue %016llx "
   1206				"OutIO %016llx\n",
   1207				totin, totout, totout - totin);
   1208
   1209		len += scnprintf(buf + len, size - len,
   1210				"LS Xmt Err: Abrt %08x Err %08x  "
   1211				"Cmpl Err: xb %08x Err %08x\n",
   1212				atomic_read(&lport->xmt_ls_abort),
   1213				atomic_read(&lport->xmt_ls_err),
   1214				atomic_read(&lport->cmpl_ls_xb),
   1215				atomic_read(&lport->cmpl_ls_err));
   1216
   1217		len += scnprintf(buf + len, size - len,
   1218				"FCP Xmt Err: noxri %06x nondlp %06x "
   1219				"qdepth %06x wqerr %06x err %06x Abrt %06x\n",
   1220				atomic_read(&lport->xmt_fcp_noxri),
   1221				atomic_read(&lport->xmt_fcp_bad_ndlp),
   1222				atomic_read(&lport->xmt_fcp_qdepth),
   1223				atomic_read(&lport->xmt_fcp_wqerr),
   1224				atomic_read(&lport->xmt_fcp_err),
   1225				atomic_read(&lport->xmt_fcp_abort));
   1226
   1227		len += scnprintf(buf + len, size - len,
   1228				"FCP Cmpl Err: xb %08x Err %08x\n",
   1229				atomic_read(&lport->cmpl_fcp_xb),
   1230				atomic_read(&lport->cmpl_fcp_err));
   1231
   1232	}
   1233
   1234	return len;
   1235}
   1236
   1237/**
   1238 * lpfc_debugfs_scsistat_data - Dump target node list to a buffer
   1239 * @vport: The vport to gather target node info from.
   1240 * @buf: The buffer to dump log into.
   1241 * @size: The maximum amount of data to process.
   1242 *
   1243 * Description:
   1244 * This routine dumps the SCSI statistics associated with @vport
   1245 *
   1246 * Return Value:
   1247 * This routine returns the amount of bytes that were dumped into @buf and will
   1248 * not exceed @size.
   1249 **/
   1250static int
   1251lpfc_debugfs_scsistat_data(struct lpfc_vport *vport, char *buf, int size)
   1252{
   1253	int len;
   1254	struct lpfc_hba *phba = vport->phba;
   1255	struct lpfc_fc4_ctrl_stat *cstat;
   1256	u64 data1, data2, data3;
   1257	u64 tot, totin, totout;
   1258	int i;
   1259	char tmp[LPFC_MAX_SCSI_INFO_TMP_LEN] = {0};
   1260
   1261	if (!(vport->cfg_enable_fc4_type & LPFC_ENABLE_FCP) ||
   1262	    (phba->sli_rev != LPFC_SLI_REV4))
   1263		return 0;
   1264
   1265	scnprintf(buf, size, "SCSI HDWQ Statistics\n");
   1266
   1267	totin = 0;
   1268	totout = 0;
   1269	for (i = 0; i < phba->cfg_hdw_queue; i++) {
   1270		cstat = &phba->sli4_hba.hdwq[i].scsi_cstat;
   1271		tot = cstat->io_cmpls;
   1272		totin += tot;
   1273		data1 = cstat->input_requests;
   1274		data2 = cstat->output_requests;
   1275		data3 = cstat->control_requests;
   1276		totout += (data1 + data2 + data3);
   1277
   1278		scnprintf(tmp, sizeof(tmp), "HDWQ (%d): Rd %016llx Wr %016llx "
   1279			  "IO %016llx ", i, data1, data2, data3);
   1280		if (strlcat(buf, tmp, size) >= size)
   1281			goto buffer_done;
   1282
   1283		scnprintf(tmp, sizeof(tmp), "Cmpl %016llx OutIO %016llx\n",
   1284			  tot, ((data1 + data2 + data3) - tot));
   1285		if (strlcat(buf, tmp, size) >= size)
   1286			goto buffer_done;
   1287	}
   1288	scnprintf(tmp, sizeof(tmp), "Total FCP Cmpl %016llx Issue %016llx "
   1289		  "OutIO %016llx\n", totin, totout, totout - totin);
   1290	strlcat(buf, tmp, size);
   1291
   1292buffer_done:
   1293	len = strnlen(buf, size);
   1294
   1295	return len;
   1296}
   1297
   1298void
   1299lpfc_io_ktime(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
   1300{
   1301	uint64_t seg1, seg2, seg3, seg4;
   1302	uint64_t segsum;
   1303
   1304	if (!lpfc_cmd->ts_last_cmd ||
   1305	    !lpfc_cmd->ts_cmd_start ||
   1306	    !lpfc_cmd->ts_cmd_wqput ||
   1307	    !lpfc_cmd->ts_isr_cmpl ||
   1308	    !lpfc_cmd->ts_data_io)
   1309		return;
   1310
   1311	if (lpfc_cmd->ts_data_io < lpfc_cmd->ts_cmd_start)
   1312		return;
   1313	if (lpfc_cmd->ts_cmd_start < lpfc_cmd->ts_last_cmd)
   1314		return;
   1315	if (lpfc_cmd->ts_cmd_wqput < lpfc_cmd->ts_cmd_start)
   1316		return;
   1317	if (lpfc_cmd->ts_isr_cmpl < lpfc_cmd->ts_cmd_wqput)
   1318		return;
   1319	if (lpfc_cmd->ts_data_io < lpfc_cmd->ts_isr_cmpl)
   1320		return;
   1321	/*
   1322	 * Segment 1 - Time from Last FCP command cmpl is handed
   1323	 * off to NVME Layer to start of next command.
   1324	 * Segment 2 - Time from Driver receives a IO cmd start
   1325	 * from NVME Layer to WQ put is done on IO cmd.
   1326	 * Segment 3 - Time from Driver WQ put is done on IO cmd
   1327	 * to MSI-X ISR for IO cmpl.
   1328	 * Segment 4 - Time from MSI-X ISR for IO cmpl to when
   1329	 * cmpl is handled off to the NVME Layer.
   1330	 */
   1331	seg1 = lpfc_cmd->ts_cmd_start - lpfc_cmd->ts_last_cmd;
   1332	if (seg1 > 5000000)  /* 5 ms - for sequential IOs only */
   1333		seg1 = 0;
   1334
   1335	/* Calculate times relative to start of IO */
   1336	seg2 = (lpfc_cmd->ts_cmd_wqput - lpfc_cmd->ts_cmd_start);
   1337	segsum = seg2;
   1338	seg3 = lpfc_cmd->ts_isr_cmpl - lpfc_cmd->ts_cmd_start;
   1339	if (segsum > seg3)
   1340		return;
   1341	seg3 -= segsum;
   1342	segsum += seg3;
   1343
   1344	seg4 = lpfc_cmd->ts_data_io - lpfc_cmd->ts_cmd_start;
   1345	if (segsum > seg4)
   1346		return;
   1347	seg4 -= segsum;
   1348
   1349	phba->ktime_data_samples++;
   1350	phba->ktime_seg1_total += seg1;
   1351	if (seg1 < phba->ktime_seg1_min)
   1352		phba->ktime_seg1_min = seg1;
   1353	else if (seg1 > phba->ktime_seg1_max)
   1354		phba->ktime_seg1_max = seg1;
   1355	phba->ktime_seg2_total += seg2;
   1356	if (seg2 < phba->ktime_seg2_min)
   1357		phba->ktime_seg2_min = seg2;
   1358	else if (seg2 > phba->ktime_seg2_max)
   1359		phba->ktime_seg2_max = seg2;
   1360	phba->ktime_seg3_total += seg3;
   1361	if (seg3 < phba->ktime_seg3_min)
   1362		phba->ktime_seg3_min = seg3;
   1363	else if (seg3 > phba->ktime_seg3_max)
   1364		phba->ktime_seg3_max = seg3;
   1365	phba->ktime_seg4_total += seg4;
   1366	if (seg4 < phba->ktime_seg4_min)
   1367		phba->ktime_seg4_min = seg4;
   1368	else if (seg4 > phba->ktime_seg4_max)
   1369		phba->ktime_seg4_max = seg4;
   1370
   1371	lpfc_cmd->ts_last_cmd = 0;
   1372	lpfc_cmd->ts_cmd_start = 0;
   1373	lpfc_cmd->ts_cmd_wqput  = 0;
   1374	lpfc_cmd->ts_isr_cmpl = 0;
   1375	lpfc_cmd->ts_data_io = 0;
   1376}
   1377
   1378/**
   1379 * lpfc_debugfs_ioktime_data - Dump target node list to a buffer
   1380 * @vport: The vport to gather target node info from.
   1381 * @buf: The buffer to dump log into.
   1382 * @size: The maximum amount of data to process.
   1383 *
   1384 * Description:
   1385 * This routine dumps the NVME statistics associated with @vport
   1386 *
   1387 * Return Value:
   1388 * This routine returns the amount of bytes that were dumped into @buf and will
   1389 * not exceed @size.
   1390 **/
   1391static int
   1392lpfc_debugfs_ioktime_data(struct lpfc_vport *vport, char *buf, int size)
   1393{
   1394	struct lpfc_hba   *phba = vport->phba;
   1395	int len = 0;
   1396
   1397	if (phba->nvmet_support == 0) {
   1398		/* Initiator */
   1399		len += scnprintf(buf + len, PAGE_SIZE - len,
   1400				"ktime %s: Total Samples: %lld\n",
   1401				(phba->ktime_on ?  "Enabled" : "Disabled"),
   1402				phba->ktime_data_samples);
   1403		if (phba->ktime_data_samples == 0)
   1404			return len;
   1405
   1406		len += scnprintf(
   1407			buf + len, PAGE_SIZE - len,
   1408			"Segment 1: Last Cmd cmpl "
   1409			"done -to- Start of next Cmd (in driver)\n");
   1410		len += scnprintf(
   1411			buf + len, PAGE_SIZE - len,
   1412			"avg:%08lld min:%08lld max %08lld\n",
   1413			div_u64(phba->ktime_seg1_total,
   1414				phba->ktime_data_samples),
   1415			phba->ktime_seg1_min,
   1416			phba->ktime_seg1_max);
   1417		len += scnprintf(
   1418			buf + len, PAGE_SIZE - len,
   1419			"Segment 2: Driver start of Cmd "
   1420			"-to- Firmware WQ doorbell\n");
   1421		len += scnprintf(
   1422			buf + len, PAGE_SIZE - len,
   1423			"avg:%08lld min:%08lld max %08lld\n",
   1424			div_u64(phba->ktime_seg2_total,
   1425				phba->ktime_data_samples),
   1426			phba->ktime_seg2_min,
   1427			phba->ktime_seg2_max);
   1428		len += scnprintf(
   1429			buf + len, PAGE_SIZE - len,
   1430			"Segment 3: Firmware WQ doorbell -to- "
   1431			"MSI-X ISR cmpl\n");
   1432		len += scnprintf(
   1433			buf + len, PAGE_SIZE - len,
   1434			"avg:%08lld min:%08lld max %08lld\n",
   1435			div_u64(phba->ktime_seg3_total,
   1436				phba->ktime_data_samples),
   1437			phba->ktime_seg3_min,
   1438			phba->ktime_seg3_max);
   1439		len += scnprintf(
   1440			buf + len, PAGE_SIZE - len,
   1441			"Segment 4: MSI-X ISR cmpl -to- "
   1442			"Cmd cmpl done\n");
   1443		len += scnprintf(
   1444			buf + len, PAGE_SIZE - len,
   1445			"avg:%08lld min:%08lld max %08lld\n",
   1446			div_u64(phba->ktime_seg4_total,
   1447				phba->ktime_data_samples),
   1448			phba->ktime_seg4_min,
   1449			phba->ktime_seg4_max);
   1450		len += scnprintf(
   1451			buf + len, PAGE_SIZE - len,
   1452			"Total IO avg time: %08lld\n",
   1453			div_u64(phba->ktime_seg1_total +
   1454			phba->ktime_seg2_total  +
   1455			phba->ktime_seg3_total +
   1456			phba->ktime_seg4_total,
   1457			phba->ktime_data_samples));
   1458		return len;
   1459	}
   1460
   1461	/* NVME Target */
   1462	len += scnprintf(buf + len, PAGE_SIZE-len,
   1463			"ktime %s: Total Samples: %lld %lld\n",
   1464			(phba->ktime_on ? "Enabled" : "Disabled"),
   1465			phba->ktime_data_samples,
   1466			phba->ktime_status_samples);
   1467	if (phba->ktime_data_samples == 0)
   1468		return len;
   1469
   1470	len += scnprintf(buf + len, PAGE_SIZE-len,
   1471			"Segment 1: MSI-X ISR Rcv cmd -to- "
   1472			"cmd pass to NVME Layer\n");
   1473	len += scnprintf(buf + len, PAGE_SIZE-len,
   1474			"avg:%08lld min:%08lld max %08lld\n",
   1475			div_u64(phba->ktime_seg1_total,
   1476				phba->ktime_data_samples),
   1477			phba->ktime_seg1_min,
   1478			phba->ktime_seg1_max);
   1479	len += scnprintf(buf + len, PAGE_SIZE-len,
   1480			"Segment 2: cmd pass to NVME Layer- "
   1481			"-to- Driver rcv cmd OP (action)\n");
   1482	len += scnprintf(buf + len, PAGE_SIZE-len,
   1483			"avg:%08lld min:%08lld max %08lld\n",
   1484			div_u64(phba->ktime_seg2_total,
   1485				phba->ktime_data_samples),
   1486			phba->ktime_seg2_min,
   1487			phba->ktime_seg2_max);
   1488	len += scnprintf(buf + len, PAGE_SIZE-len,
   1489			"Segment 3: Driver rcv cmd OP -to- "
   1490			"Firmware WQ doorbell: cmd\n");
   1491	len += scnprintf(buf + len, PAGE_SIZE-len,
   1492			"avg:%08lld min:%08lld max %08lld\n",
   1493			div_u64(phba->ktime_seg3_total,
   1494				phba->ktime_data_samples),
   1495			phba->ktime_seg3_min,
   1496			phba->ktime_seg3_max);
   1497	len += scnprintf(buf + len, PAGE_SIZE-len,
   1498			"Segment 4: Firmware WQ doorbell: cmd "
   1499			"-to- MSI-X ISR for cmd cmpl\n");
   1500	len += scnprintf(buf + len, PAGE_SIZE-len,
   1501			"avg:%08lld min:%08lld max %08lld\n",
   1502			div_u64(phba->ktime_seg4_total,
   1503				phba->ktime_data_samples),
   1504			phba->ktime_seg4_min,
   1505			phba->ktime_seg4_max);
   1506	len += scnprintf(buf + len, PAGE_SIZE-len,
   1507			"Segment 5: MSI-X ISR for cmd cmpl "
   1508			"-to- NVME layer passed cmd done\n");
   1509	len += scnprintf(buf + len, PAGE_SIZE-len,
   1510			"avg:%08lld min:%08lld max %08lld\n",
   1511			div_u64(phba->ktime_seg5_total,
   1512				phba->ktime_data_samples),
   1513			phba->ktime_seg5_min,
   1514			phba->ktime_seg5_max);
   1515
   1516	if (phba->ktime_status_samples == 0) {
   1517		len += scnprintf(buf + len, PAGE_SIZE-len,
   1518				"Total: cmd received by MSI-X ISR "
   1519				"-to- cmd completed on wire\n");
   1520		len += scnprintf(buf + len, PAGE_SIZE-len,
   1521				"avg:%08lld min:%08lld "
   1522				"max %08lld\n",
   1523				div_u64(phba->ktime_seg10_total,
   1524					phba->ktime_data_samples),
   1525				phba->ktime_seg10_min,
   1526				phba->ktime_seg10_max);
   1527		return len;
   1528	}
   1529
   1530	len += scnprintf(buf + len, PAGE_SIZE-len,
   1531			"Segment 6: NVME layer passed cmd done "
   1532			"-to- Driver rcv rsp status OP\n");
   1533	len += scnprintf(buf + len, PAGE_SIZE-len,
   1534			"avg:%08lld min:%08lld max %08lld\n",
   1535			div_u64(phba->ktime_seg6_total,
   1536				phba->ktime_status_samples),
   1537			phba->ktime_seg6_min,
   1538			phba->ktime_seg6_max);
   1539	len += scnprintf(buf + len, PAGE_SIZE-len,
   1540			"Segment 7: Driver rcv rsp status OP "
   1541			"-to- Firmware WQ doorbell: status\n");
   1542	len += scnprintf(buf + len, PAGE_SIZE-len,
   1543			"avg:%08lld min:%08lld max %08lld\n",
   1544			div_u64(phba->ktime_seg7_total,
   1545				phba->ktime_status_samples),
   1546			phba->ktime_seg7_min,
   1547			phba->ktime_seg7_max);
   1548	len += scnprintf(buf + len, PAGE_SIZE-len,
   1549			"Segment 8: Firmware WQ doorbell: status"
   1550			" -to- MSI-X ISR for status cmpl\n");
   1551	len += scnprintf(buf + len, PAGE_SIZE-len,
   1552			"avg:%08lld min:%08lld max %08lld\n",
   1553			div_u64(phba->ktime_seg8_total,
   1554				phba->ktime_status_samples),
   1555			phba->ktime_seg8_min,
   1556			phba->ktime_seg8_max);
   1557	len += scnprintf(buf + len, PAGE_SIZE-len,
   1558			"Segment 9: MSI-X ISR for status cmpl  "
   1559			"-to- NVME layer passed status done\n");
   1560	len += scnprintf(buf + len, PAGE_SIZE-len,
   1561			"avg:%08lld min:%08lld max %08lld\n",
   1562			div_u64(phba->ktime_seg9_total,
   1563				phba->ktime_status_samples),
   1564			phba->ktime_seg9_min,
   1565			phba->ktime_seg9_max);
   1566	len += scnprintf(buf + len, PAGE_SIZE-len,
   1567			"Total: cmd received by MSI-X ISR -to- "
   1568			"cmd completed on wire\n");
   1569	len += scnprintf(buf + len, PAGE_SIZE-len,
   1570			"avg:%08lld min:%08lld max %08lld\n",
   1571			div_u64(phba->ktime_seg10_total,
   1572				phba->ktime_status_samples),
   1573			phba->ktime_seg10_min,
   1574			phba->ktime_seg10_max);
   1575	return len;
   1576}
   1577
   1578/**
   1579 * lpfc_debugfs_nvmeio_trc_data - Dump NVME IO trace list to a buffer
   1580 * @phba: The phba to gather target node info from.
   1581 * @buf: The buffer to dump log into.
   1582 * @size: The maximum amount of data to process.
   1583 *
   1584 * Description:
   1585 * This routine dumps the NVME IO trace associated with @phba
   1586 *
   1587 * Return Value:
   1588 * This routine returns the amount of bytes that were dumped into @buf and will
   1589 * not exceed @size.
   1590 **/
   1591static int
   1592lpfc_debugfs_nvmeio_trc_data(struct lpfc_hba *phba, char *buf, int size)
   1593{
   1594	struct lpfc_debugfs_nvmeio_trc *dtp;
   1595	int i, state, index, skip;
   1596	int len = 0;
   1597
   1598	state = phba->nvmeio_trc_on;
   1599
   1600	index = (atomic_read(&phba->nvmeio_trc_cnt) + 1) &
   1601		(phba->nvmeio_trc_size - 1);
   1602	skip = phba->nvmeio_trc_output_idx;
   1603
   1604	len += scnprintf(buf + len, size - len,
   1605			"%s IO Trace %s: next_idx %d skip %d size %d\n",
   1606			(phba->nvmet_support ? "NVME" : "NVMET"),
   1607			(state ? "Enabled" : "Disabled"),
   1608			index, skip, phba->nvmeio_trc_size);
   1609
   1610	if (!phba->nvmeio_trc || state)
   1611		return len;
   1612
   1613	/* trace MUST bhe off to continue */
   1614
   1615	for (i = index; i < phba->nvmeio_trc_size; i++) {
   1616		if (skip) {
   1617			skip--;
   1618			continue;
   1619		}
   1620		dtp = phba->nvmeio_trc + i;
   1621		phba->nvmeio_trc_output_idx++;
   1622
   1623		if (!dtp->fmt)
   1624			continue;
   1625
   1626		len +=  scnprintf(buf + len, size - len, dtp->fmt,
   1627			dtp->data1, dtp->data2, dtp->data3);
   1628
   1629		if (phba->nvmeio_trc_output_idx >= phba->nvmeio_trc_size) {
   1630			phba->nvmeio_trc_output_idx = 0;
   1631			len += scnprintf(buf + len, size - len,
   1632					"Trace Complete\n");
   1633			goto out;
   1634		}
   1635
   1636		if (len >= (size - LPFC_DEBUG_OUT_LINE_SZ)) {
   1637			len += scnprintf(buf + len, size - len,
   1638					"Trace Continue (%d of %d)\n",
   1639					phba->nvmeio_trc_output_idx,
   1640					phba->nvmeio_trc_size);
   1641			goto out;
   1642		}
   1643	}
   1644	for (i = 0; i < index; i++) {
   1645		if (skip) {
   1646			skip--;
   1647			continue;
   1648		}
   1649		dtp = phba->nvmeio_trc + i;
   1650		phba->nvmeio_trc_output_idx++;
   1651
   1652		if (!dtp->fmt)
   1653			continue;
   1654
   1655		len +=  scnprintf(buf + len, size - len, dtp->fmt,
   1656			dtp->data1, dtp->data2, dtp->data3);
   1657
   1658		if (phba->nvmeio_trc_output_idx >= phba->nvmeio_trc_size) {
   1659			phba->nvmeio_trc_output_idx = 0;
   1660			len += scnprintf(buf + len, size - len,
   1661					"Trace Complete\n");
   1662			goto out;
   1663		}
   1664
   1665		if (len >= (size - LPFC_DEBUG_OUT_LINE_SZ)) {
   1666			len += scnprintf(buf + len, size - len,
   1667					"Trace Continue (%d of %d)\n",
   1668					phba->nvmeio_trc_output_idx,
   1669					phba->nvmeio_trc_size);
   1670			goto out;
   1671		}
   1672	}
   1673
   1674	len += scnprintf(buf + len, size - len,
   1675			"Trace Done\n");
   1676out:
   1677	return len;
   1678}
   1679
   1680/**
   1681 * lpfc_debugfs_hdwqstat_data - Dump I/O stats to a buffer
   1682 * @vport: The vport to gather target node info from.
   1683 * @buf: The buffer to dump log into.
   1684 * @size: The maximum amount of data to process.
   1685 *
   1686 * Description:
   1687 * This routine dumps the NVME + SCSI statistics associated with @vport
   1688 *
   1689 * Return Value:
   1690 * This routine returns the amount of bytes that were dumped into @buf and will
   1691 * not exceed @size.
   1692 **/
   1693static int
   1694lpfc_debugfs_hdwqstat_data(struct lpfc_vport *vport, char *buf, int size)
   1695{
   1696	struct lpfc_hba   *phba = vport->phba;
   1697	struct lpfc_hdwq_stat *c_stat;
   1698	int i, j, len;
   1699	uint32_t tot_xmt;
   1700	uint32_t tot_rcv;
   1701	uint32_t tot_cmpl;
   1702	char tmp[LPFC_MAX_SCSI_INFO_TMP_LEN] = {0};
   1703
   1704	scnprintf(tmp, sizeof(tmp), "HDWQ Stats:\n\n");
   1705	if (strlcat(buf, tmp, size) >= size)
   1706		goto buffer_done;
   1707
   1708	scnprintf(tmp, sizeof(tmp), "(NVME Accounting: %s) ",
   1709		  (phba->hdwqstat_on &
   1710		  (LPFC_CHECK_NVME_IO | LPFC_CHECK_NVMET_IO) ?
   1711		  "Enabled" : "Disabled"));
   1712	if (strlcat(buf, tmp, size) >= size)
   1713		goto buffer_done;
   1714
   1715	scnprintf(tmp, sizeof(tmp), "(SCSI Accounting: %s) ",
   1716		  (phba->hdwqstat_on & LPFC_CHECK_SCSI_IO ?
   1717		  "Enabled" : "Disabled"));
   1718	if (strlcat(buf, tmp, size) >= size)
   1719		goto buffer_done;
   1720
   1721	scnprintf(tmp, sizeof(tmp), "\n\n");
   1722	if (strlcat(buf, tmp, size) >= size)
   1723		goto buffer_done;
   1724
   1725	for (i = 0; i < phba->cfg_hdw_queue; i++) {
   1726		tot_rcv = 0;
   1727		tot_xmt = 0;
   1728		tot_cmpl = 0;
   1729
   1730		for_each_present_cpu(j) {
   1731			c_stat = per_cpu_ptr(phba->sli4_hba.c_stat, j);
   1732
   1733			/* Only display for this HDWQ */
   1734			if (i != c_stat->hdwq_no)
   1735				continue;
   1736
   1737			/* Only display non-zero counters */
   1738			if (!c_stat->xmt_io && !c_stat->cmpl_io &&
   1739			    !c_stat->rcv_io)
   1740				continue;
   1741
   1742			if (!tot_xmt && !tot_cmpl && !tot_rcv) {
   1743				/* Print HDWQ string only the first time */
   1744				scnprintf(tmp, sizeof(tmp), "[HDWQ %d]:\t", i);
   1745				if (strlcat(buf, tmp, size) >= size)
   1746					goto buffer_done;
   1747			}
   1748
   1749			tot_xmt += c_stat->xmt_io;
   1750			tot_cmpl += c_stat->cmpl_io;
   1751			if (phba->nvmet_support)
   1752				tot_rcv += c_stat->rcv_io;
   1753
   1754			scnprintf(tmp, sizeof(tmp), "| [CPU %d]: ", j);
   1755			if (strlcat(buf, tmp, size) >= size)
   1756				goto buffer_done;
   1757
   1758			if (phba->nvmet_support) {
   1759				scnprintf(tmp, sizeof(tmp),
   1760					  "XMT 0x%x CMPL 0x%x RCV 0x%x |",
   1761					  c_stat->xmt_io, c_stat->cmpl_io,
   1762					  c_stat->rcv_io);
   1763				if (strlcat(buf, tmp, size) >= size)
   1764					goto buffer_done;
   1765			} else {
   1766				scnprintf(tmp, sizeof(tmp),
   1767					  "XMT 0x%x CMPL 0x%x |",
   1768					  c_stat->xmt_io, c_stat->cmpl_io);
   1769				if (strlcat(buf, tmp, size) >= size)
   1770					goto buffer_done;
   1771			}
   1772		}
   1773
   1774		/* Check if nothing to display */
   1775		if (!tot_xmt && !tot_cmpl && !tot_rcv)
   1776			continue;
   1777
   1778		scnprintf(tmp, sizeof(tmp), "\t->\t[HDWQ Total: ");
   1779		if (strlcat(buf, tmp, size) >= size)
   1780			goto buffer_done;
   1781
   1782		if (phba->nvmet_support) {
   1783			scnprintf(tmp, sizeof(tmp),
   1784				  "XMT 0x%x CMPL 0x%x RCV 0x%x]\n\n",
   1785				  tot_xmt, tot_cmpl, tot_rcv);
   1786			if (strlcat(buf, tmp, size) >= size)
   1787				goto buffer_done;
   1788		} else {
   1789			scnprintf(tmp, sizeof(tmp),
   1790				  "XMT 0x%x CMPL 0x%x]\n\n",
   1791				  tot_xmt, tot_cmpl);
   1792			if (strlcat(buf, tmp, size) >= size)
   1793				goto buffer_done;
   1794		}
   1795	}
   1796
   1797buffer_done:
   1798	len = strnlen(buf, size);
   1799	return len;
   1800}
   1801
   1802#endif
   1803
   1804/**
   1805 * lpfc_debugfs_disc_trc - Store discovery trace log
   1806 * @vport: The vport to associate this trace string with for retrieval.
   1807 * @mask: Log entry classification.
   1808 * @fmt: Format string to be displayed when dumping the log.
   1809 * @data1: 1st data parameter to be applied to @fmt.
   1810 * @data2: 2nd data parameter to be applied to @fmt.
   1811 * @data3: 3rd data parameter to be applied to @fmt.
   1812 *
   1813 * Description:
   1814 * This routine is used by the driver code to add a debugfs log entry to the
   1815 * discovery trace buffer associated with @vport. Only entries with a @mask that
   1816 * match the current debugfs discovery mask will be saved. Entries that do not
   1817 * match will be thrown away. @fmt, @data1, @data2, and @data3 are used like
   1818 * printf when displaying the log.
   1819 **/
   1820inline void
   1821lpfc_debugfs_disc_trc(struct lpfc_vport *vport, int mask, char *fmt,
   1822	uint32_t data1, uint32_t data2, uint32_t data3)
   1823{
   1824#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
   1825	struct lpfc_debugfs_trc *dtp;
   1826	int index;
   1827
   1828	if (!(lpfc_debugfs_mask_disc_trc & mask))
   1829		return;
   1830
   1831	if (!lpfc_debugfs_enable || !lpfc_debugfs_max_disc_trc ||
   1832		!vport || !vport->disc_trc)
   1833		return;
   1834
   1835	index = atomic_inc_return(&vport->disc_trc_cnt) &
   1836		(lpfc_debugfs_max_disc_trc - 1);
   1837	dtp = vport->disc_trc + index;
   1838	dtp->fmt = fmt;
   1839	dtp->data1 = data1;
   1840	dtp->data2 = data2;
   1841	dtp->data3 = data3;
   1842	dtp->seq_cnt = atomic_inc_return(&lpfc_debugfs_seq_trc_cnt);
   1843	dtp->jif = jiffies;
   1844#endif
   1845	return;
   1846}
   1847
   1848/**
   1849 * lpfc_debugfs_slow_ring_trc - Store slow ring trace log
   1850 * @phba: The phba to associate this trace string with for retrieval.
   1851 * @fmt: Format string to be displayed when dumping the log.
   1852 * @data1: 1st data parameter to be applied to @fmt.
   1853 * @data2: 2nd data parameter to be applied to @fmt.
   1854 * @data3: 3rd data parameter to be applied to @fmt.
   1855 *
   1856 * Description:
   1857 * This routine is used by the driver code to add a debugfs log entry to the
   1858 * discovery trace buffer associated with @vport. @fmt, @data1, @data2, and
   1859 * @data3 are used like printf when displaying the log.
   1860 **/
   1861inline void
   1862lpfc_debugfs_slow_ring_trc(struct lpfc_hba *phba, char *fmt,
   1863	uint32_t data1, uint32_t data2, uint32_t data3)
   1864{
   1865#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
   1866	struct lpfc_debugfs_trc *dtp;
   1867	int index;
   1868
   1869	if (!lpfc_debugfs_enable || !lpfc_debugfs_max_slow_ring_trc ||
   1870		!phba || !phba->slow_ring_trc)
   1871		return;
   1872
   1873	index = atomic_inc_return(&phba->slow_ring_trc_cnt) &
   1874		(lpfc_debugfs_max_slow_ring_trc - 1);
   1875	dtp = phba->slow_ring_trc + index;
   1876	dtp->fmt = fmt;
   1877	dtp->data1 = data1;
   1878	dtp->data2 = data2;
   1879	dtp->data3 = data3;
   1880	dtp->seq_cnt = atomic_inc_return(&lpfc_debugfs_seq_trc_cnt);
   1881	dtp->jif = jiffies;
   1882#endif
   1883	return;
   1884}
   1885
   1886/**
   1887 * lpfc_debugfs_nvme_trc - Store NVME/NVMET trace log
   1888 * @phba: The phba to associate this trace string with for retrieval.
   1889 * @fmt: Format string to be displayed when dumping the log.
   1890 * @data1: 1st data parameter to be applied to @fmt.
   1891 * @data2: 2nd data parameter to be applied to @fmt.
   1892 * @data3: 3rd data parameter to be applied to @fmt.
   1893 *
   1894 * Description:
   1895 * This routine is used by the driver code to add a debugfs log entry to the
   1896 * nvme trace buffer associated with @phba. @fmt, @data1, @data2, and
   1897 * @data3 are used like printf when displaying the log.
   1898 **/
   1899inline void
   1900lpfc_debugfs_nvme_trc(struct lpfc_hba *phba, char *fmt,
   1901		      uint16_t data1, uint16_t data2, uint32_t data3)
   1902{
   1903#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
   1904	struct lpfc_debugfs_nvmeio_trc *dtp;
   1905	int index;
   1906
   1907	if (!phba->nvmeio_trc_on || !phba->nvmeio_trc)
   1908		return;
   1909
   1910	index = atomic_inc_return(&phba->nvmeio_trc_cnt) &
   1911		(phba->nvmeio_trc_size - 1);
   1912	dtp = phba->nvmeio_trc + index;
   1913	dtp->fmt = fmt;
   1914	dtp->data1 = data1;
   1915	dtp->data2 = data2;
   1916	dtp->data3 = data3;
   1917#endif
   1918}
   1919
   1920#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
   1921/**
   1922 * lpfc_debugfs_disc_trc_open - Open the discovery trace log
   1923 * @inode: The inode pointer that contains a vport pointer.
   1924 * @file: The file pointer to attach the log output.
   1925 *
   1926 * Description:
   1927 * This routine is the entry point for the debugfs open file operation. It gets
   1928 * the vport from the i_private field in @inode, allocates the necessary buffer
   1929 * for the log, fills the buffer from the in-memory log for this vport, and then
   1930 * returns a pointer to that log in the private_data field in @file.
   1931 *
   1932 * Returns:
   1933 * This function returns zero if successful. On error it will return a negative
   1934 * error value.
   1935 **/
   1936static int
   1937lpfc_debugfs_disc_trc_open(struct inode *inode, struct file *file)
   1938{
   1939	struct lpfc_vport *vport = inode->i_private;
   1940	struct lpfc_debug *debug;
   1941	int size;
   1942	int rc = -ENOMEM;
   1943
   1944	if (!lpfc_debugfs_max_disc_trc) {
   1945		rc = -ENOSPC;
   1946		goto out;
   1947	}
   1948
   1949	debug = kmalloc(sizeof(*debug), GFP_KERNEL);
   1950	if (!debug)
   1951		goto out;
   1952
   1953	/* Round to page boundary */
   1954	size =  (lpfc_debugfs_max_disc_trc * LPFC_DEBUG_TRC_ENTRY_SIZE);
   1955	size = PAGE_ALIGN(size);
   1956
   1957	debug->buffer = kmalloc(size, GFP_KERNEL);
   1958	if (!debug->buffer) {
   1959		kfree(debug);
   1960		goto out;
   1961	}
   1962
   1963	debug->len = lpfc_debugfs_disc_trc_data(vport, debug->buffer, size);
   1964	file->private_data = debug;
   1965
   1966	rc = 0;
   1967out:
   1968	return rc;
   1969}
   1970
   1971/**
   1972 * lpfc_debugfs_slow_ring_trc_open - Open the Slow Ring trace log
   1973 * @inode: The inode pointer that contains a vport pointer.
   1974 * @file: The file pointer to attach the log output.
   1975 *
   1976 * Description:
   1977 * This routine is the entry point for the debugfs open file operation. It gets
   1978 * the vport from the i_private field in @inode, allocates the necessary buffer
   1979 * for the log, fills the buffer from the in-memory log for this vport, and then
   1980 * returns a pointer to that log in the private_data field in @file.
   1981 *
   1982 * Returns:
   1983 * This function returns zero if successful. On error it will return a negative
   1984 * error value.
   1985 **/
   1986static int
   1987lpfc_debugfs_slow_ring_trc_open(struct inode *inode, struct file *file)
   1988{
   1989	struct lpfc_hba *phba = inode->i_private;
   1990	struct lpfc_debug *debug;
   1991	int size;
   1992	int rc = -ENOMEM;
   1993
   1994	if (!lpfc_debugfs_max_slow_ring_trc) {
   1995		rc = -ENOSPC;
   1996		goto out;
   1997	}
   1998
   1999	debug = kmalloc(sizeof(*debug), GFP_KERNEL);
   2000	if (!debug)
   2001		goto out;
   2002
   2003	/* Round to page boundary */
   2004	size =  (lpfc_debugfs_max_slow_ring_trc * LPFC_DEBUG_TRC_ENTRY_SIZE);
   2005	size = PAGE_ALIGN(size);
   2006
   2007	debug->buffer = kmalloc(size, GFP_KERNEL);
   2008	if (!debug->buffer) {
   2009		kfree(debug);
   2010		goto out;
   2011	}
   2012
   2013	debug->len = lpfc_debugfs_slow_ring_trc_data(phba, debug->buffer, size);
   2014	file->private_data = debug;
   2015
   2016	rc = 0;
   2017out:
   2018	return rc;
   2019}
   2020
   2021/**
   2022 * lpfc_debugfs_hbqinfo_open - Open the hbqinfo debugfs buffer
   2023 * @inode: The inode pointer that contains a vport pointer.
   2024 * @file: The file pointer to attach the log output.
   2025 *
   2026 * Description:
   2027 * This routine is the entry point for the debugfs open file operation. It gets
   2028 * the vport from the i_private field in @inode, allocates the necessary buffer
   2029 * for the log, fills the buffer from the in-memory log for this vport, and then
   2030 * returns a pointer to that log in the private_data field in @file.
   2031 *
   2032 * Returns:
   2033 * This function returns zero if successful. On error it will return a negative
   2034 * error value.
   2035 **/
   2036static int
   2037lpfc_debugfs_hbqinfo_open(struct inode *inode, struct file *file)
   2038{
   2039	struct lpfc_hba *phba = inode->i_private;
   2040	struct lpfc_debug *debug;
   2041	int rc = -ENOMEM;
   2042
   2043	debug = kmalloc(sizeof(*debug), GFP_KERNEL);
   2044	if (!debug)
   2045		goto out;
   2046
   2047	/* Round to page boundary */
   2048	debug->buffer = kmalloc(LPFC_HBQINFO_SIZE, GFP_KERNEL);
   2049	if (!debug->buffer) {
   2050		kfree(debug);
   2051		goto out;
   2052	}
   2053
   2054	debug->len = lpfc_debugfs_hbqinfo_data(phba, debug->buffer,
   2055		LPFC_HBQINFO_SIZE);
   2056	file->private_data = debug;
   2057
   2058	rc = 0;
   2059out:
   2060	return rc;
   2061}
   2062
   2063/**
   2064 * lpfc_debugfs_multixripools_open - Open the multixripool debugfs buffer
   2065 * @inode: The inode pointer that contains a hba pointer.
   2066 * @file: The file pointer to attach the log output.
   2067 *
   2068 * Description:
   2069 * This routine is the entry point for the debugfs open file operation. It gets
   2070 * the hba from the i_private field in @inode, allocates the necessary buffer
   2071 * for the log, fills the buffer from the in-memory log for this hba, and then
   2072 * returns a pointer to that log in the private_data field in @file.
   2073 *
   2074 * Returns:
   2075 * This function returns zero if successful. On error it will return a negative
   2076 * error value.
   2077 **/
   2078static int
   2079lpfc_debugfs_multixripools_open(struct inode *inode, struct file *file)
   2080{
   2081	struct lpfc_hba *phba = inode->i_private;
   2082	struct lpfc_debug *debug;
   2083	int rc = -ENOMEM;
   2084
   2085	debug = kmalloc(sizeof(*debug), GFP_KERNEL);
   2086	if (!debug)
   2087		goto out;
   2088
   2089	/* Round to page boundary */
   2090	debug->buffer = kzalloc(LPFC_DUMP_MULTIXRIPOOL_SIZE, GFP_KERNEL);
   2091	if (!debug->buffer) {
   2092		kfree(debug);
   2093		goto out;
   2094	}
   2095
   2096	debug->len = lpfc_debugfs_multixripools_data(
   2097		phba, debug->buffer, LPFC_DUMP_MULTIXRIPOOL_SIZE);
   2098
   2099	debug->i_private = inode->i_private;
   2100	file->private_data = debug;
   2101
   2102	rc = 0;
   2103out:
   2104	return rc;
   2105}
   2106
   2107#ifdef LPFC_HDWQ_LOCK_STAT
   2108/**
   2109 * lpfc_debugfs_lockstat_open - Open the lockstat debugfs buffer
   2110 * @inode: The inode pointer that contains a vport pointer.
   2111 * @file: The file pointer to attach the log output.
   2112 *
   2113 * Description:
   2114 * This routine is the entry point for the debugfs open file operation. It gets
   2115 * the vport from the i_private field in @inode, allocates the necessary buffer
   2116 * for the log, fills the buffer from the in-memory log for this vport, and then
   2117 * returns a pointer to that log in the private_data field in @file.
   2118 *
   2119 * Returns:
   2120 * This function returns zero if successful. On error it will return a negative
   2121 * error value.
   2122 **/
   2123static int
   2124lpfc_debugfs_lockstat_open(struct inode *inode, struct file *file)
   2125{
   2126	struct lpfc_hba *phba = inode->i_private;
   2127	struct lpfc_debug *debug;
   2128	int rc = -ENOMEM;
   2129
   2130	debug = kmalloc(sizeof(*debug), GFP_KERNEL);
   2131	if (!debug)
   2132		goto out;
   2133
   2134	/* Round to page boundary */
   2135	debug->buffer = kmalloc(LPFC_HDWQINFO_SIZE, GFP_KERNEL);
   2136	if (!debug->buffer) {
   2137		kfree(debug);
   2138		goto out;
   2139	}
   2140
   2141	debug->len = lpfc_debugfs_lockstat_data(phba, debug->buffer,
   2142		LPFC_HBQINFO_SIZE);
   2143	file->private_data = debug;
   2144
   2145	rc = 0;
   2146out:
   2147	return rc;
   2148}
   2149
   2150static ssize_t
   2151lpfc_debugfs_lockstat_write(struct file *file, const char __user *buf,
   2152			    size_t nbytes, loff_t *ppos)
   2153{
   2154	struct lpfc_debug *debug = file->private_data;
   2155	struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
   2156	struct lpfc_sli4_hdw_queue *qp;
   2157	char mybuf[64];
   2158	char *pbuf;
   2159	int i;
   2160
   2161	memset(mybuf, 0, sizeof(mybuf));
   2162
   2163	if (copy_from_user(mybuf, buf, nbytes))
   2164		return -EFAULT;
   2165	pbuf = &mybuf[0];
   2166
   2167	if ((strncmp(pbuf, "reset", strlen("reset")) == 0) ||
   2168	    (strncmp(pbuf, "zero", strlen("zero")) == 0)) {
   2169		for (i = 0; i < phba->cfg_hdw_queue; i++) {
   2170			qp = &phba->sli4_hba.hdwq[i];
   2171			qp->lock_conflict.alloc_xri_get = 0;
   2172			qp->lock_conflict.alloc_xri_put = 0;
   2173			qp->lock_conflict.free_xri = 0;
   2174			qp->lock_conflict.wq_access = 0;
   2175			qp->lock_conflict.alloc_pvt_pool = 0;
   2176			qp->lock_conflict.mv_from_pvt_pool = 0;
   2177			qp->lock_conflict.mv_to_pub_pool = 0;
   2178			qp->lock_conflict.mv_to_pvt_pool = 0;
   2179			qp->lock_conflict.free_pvt_pool = 0;
   2180			qp->lock_conflict.free_pub_pool = 0;
   2181			qp->lock_conflict.wq_access = 0;
   2182		}
   2183	}
   2184	return nbytes;
   2185}
   2186#endif
   2187
   2188static int lpfc_debugfs_ras_log_data(struct lpfc_hba *phba,
   2189				     char *buffer, int size)
   2190{
   2191	int copied = 0;
   2192	struct lpfc_dmabuf *dmabuf, *next;
   2193
   2194	memset(buffer, 0, size);
   2195
   2196	spin_lock_irq(&phba->hbalock);
   2197	if (phba->ras_fwlog.state != ACTIVE) {
   2198		spin_unlock_irq(&phba->hbalock);
   2199		return -EINVAL;
   2200	}
   2201	spin_unlock_irq(&phba->hbalock);
   2202
   2203	list_for_each_entry_safe(dmabuf, next,
   2204				 &phba->ras_fwlog.fwlog_buff_list, list) {
   2205		/* Check if copying will go over size and a '\0' char */
   2206		if ((copied + LPFC_RAS_MAX_ENTRY_SIZE) >= (size - 1)) {
   2207			memcpy(buffer + copied, dmabuf->virt,
   2208			       size - copied - 1);
   2209			copied += size - copied - 1;
   2210			break;
   2211		}
   2212		memcpy(buffer + copied, dmabuf->virt, LPFC_RAS_MAX_ENTRY_SIZE);
   2213		copied += LPFC_RAS_MAX_ENTRY_SIZE;
   2214	}
   2215	return copied;
   2216}
   2217
   2218static int
   2219lpfc_debugfs_ras_log_release(struct inode *inode, struct file *file)
   2220{
   2221	struct lpfc_debug *debug = file->private_data;
   2222
   2223	vfree(debug->buffer);
   2224	kfree(debug);
   2225
   2226	return 0;
   2227}
   2228
   2229/**
   2230 * lpfc_debugfs_ras_log_open - Open the RAS log debugfs buffer
   2231 * @inode: The inode pointer that contains a vport pointer.
   2232 * @file: The file pointer to attach the log output.
   2233 *
   2234 * Description:
   2235 * This routine is the entry point for the debugfs open file operation. It gets
   2236 * the vport from the i_private field in @inode, allocates the necessary buffer
   2237 * for the log, fills the buffer from the in-memory log for this vport, and then
   2238 * returns a pointer to that log in the private_data field in @file.
   2239 *
   2240 * Returns:
   2241 * This function returns zero if successful. On error it will return a negative
   2242 * error value.
   2243 **/
   2244static int
   2245lpfc_debugfs_ras_log_open(struct inode *inode, struct file *file)
   2246{
   2247	struct lpfc_hba *phba = inode->i_private;
   2248	struct lpfc_debug *debug;
   2249	int size;
   2250	int rc = -ENOMEM;
   2251
   2252	spin_lock_irq(&phba->hbalock);
   2253	if (phba->ras_fwlog.state != ACTIVE) {
   2254		spin_unlock_irq(&phba->hbalock);
   2255		rc = -EINVAL;
   2256		goto out;
   2257	}
   2258	spin_unlock_irq(&phba->hbalock);
   2259	debug = kmalloc(sizeof(*debug), GFP_KERNEL);
   2260	if (!debug)
   2261		goto out;
   2262
   2263	size = LPFC_RAS_MIN_BUFF_POST_SIZE * phba->cfg_ras_fwlog_buffsize;
   2264	debug->buffer = vmalloc(size);
   2265	if (!debug->buffer)
   2266		goto free_debug;
   2267
   2268	debug->len = lpfc_debugfs_ras_log_data(phba, debug->buffer, size);
   2269	if (debug->len < 0) {
   2270		rc = -EINVAL;
   2271		goto free_buffer;
   2272	}
   2273	file->private_data = debug;
   2274
   2275	return 0;
   2276
   2277free_buffer:
   2278	vfree(debug->buffer);
   2279free_debug:
   2280	kfree(debug);
   2281out:
   2282	return rc;
   2283}
   2284
   2285/**
   2286 * lpfc_debugfs_dumpHBASlim_open - Open the Dump HBA SLIM debugfs buffer
   2287 * @inode: The inode pointer that contains a vport pointer.
   2288 * @file: The file pointer to attach the log output.
   2289 *
   2290 * Description:
   2291 * This routine is the entry point for the debugfs open file operation. It gets
   2292 * the vport from the i_private field in @inode, allocates the necessary buffer
   2293 * for the log, fills the buffer from the in-memory log for this vport, and then
   2294 * returns a pointer to that log in the private_data field in @file.
   2295 *
   2296 * Returns:
   2297 * This function returns zero if successful. On error it will return a negative
   2298 * error value.
   2299 **/
   2300static int
   2301lpfc_debugfs_dumpHBASlim_open(struct inode *inode, struct file *file)
   2302{
   2303	struct lpfc_hba *phba = inode->i_private;
   2304	struct lpfc_debug *debug;
   2305	int rc = -ENOMEM;
   2306
   2307	debug = kmalloc(sizeof(*debug), GFP_KERNEL);
   2308	if (!debug)
   2309		goto out;
   2310
   2311	/* Round to page boundary */
   2312	debug->buffer = kmalloc(LPFC_DUMPHBASLIM_SIZE, GFP_KERNEL);
   2313	if (!debug->buffer) {
   2314		kfree(debug);
   2315		goto out;
   2316	}
   2317
   2318	debug->len = lpfc_debugfs_dumpHBASlim_data(phba, debug->buffer,
   2319		LPFC_DUMPHBASLIM_SIZE);
   2320	file->private_data = debug;
   2321
   2322	rc = 0;
   2323out:
   2324	return rc;
   2325}
   2326
   2327/**
   2328 * lpfc_debugfs_dumpHostSlim_open - Open the Dump Host SLIM debugfs buffer
   2329 * @inode: The inode pointer that contains a vport pointer.
   2330 * @file: The file pointer to attach the log output.
   2331 *
   2332 * Description:
   2333 * This routine is the entry point for the debugfs open file operation. It gets
   2334 * the vport from the i_private field in @inode, allocates the necessary buffer
   2335 * for the log, fills the buffer from the in-memory log for this vport, and then
   2336 * returns a pointer to that log in the private_data field in @file.
   2337 *
   2338 * Returns:
   2339 * This function returns zero if successful. On error it will return a negative
   2340 * error value.
   2341 **/
   2342static int
   2343lpfc_debugfs_dumpHostSlim_open(struct inode *inode, struct file *file)
   2344{
   2345	struct lpfc_hba *phba = inode->i_private;
   2346	struct lpfc_debug *debug;
   2347	int rc = -ENOMEM;
   2348
   2349	debug = kmalloc(sizeof(*debug), GFP_KERNEL);
   2350	if (!debug)
   2351		goto out;
   2352
   2353	/* Round to page boundary */
   2354	debug->buffer = kmalloc(LPFC_DUMPHOSTSLIM_SIZE, GFP_KERNEL);
   2355	if (!debug->buffer) {
   2356		kfree(debug);
   2357		goto out;
   2358	}
   2359
   2360	debug->len = lpfc_debugfs_dumpHostSlim_data(phba, debug->buffer,
   2361		LPFC_DUMPHOSTSLIM_SIZE);
   2362	file->private_data = debug;
   2363
   2364	rc = 0;
   2365out:
   2366	return rc;
   2367}
   2368
   2369static ssize_t
   2370lpfc_debugfs_dif_err_read(struct file *file, char __user *buf,
   2371	size_t nbytes, loff_t *ppos)
   2372{
   2373	struct dentry *dent = file->f_path.dentry;
   2374	struct lpfc_hba *phba = file->private_data;
   2375	char cbuf[32];
   2376	uint64_t tmp = 0;
   2377	int cnt = 0;
   2378
   2379	if (dent == phba->debug_writeGuard)
   2380		cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_wgrd_cnt);
   2381	else if (dent == phba->debug_writeApp)
   2382		cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_wapp_cnt);
   2383	else if (dent == phba->debug_writeRef)
   2384		cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_wref_cnt);
   2385	else if (dent == phba->debug_readGuard)
   2386		cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_rgrd_cnt);
   2387	else if (dent == phba->debug_readApp)
   2388		cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_rapp_cnt);
   2389	else if (dent == phba->debug_readRef)
   2390		cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_rref_cnt);
   2391	else if (dent == phba->debug_InjErrNPortID)
   2392		cnt = scnprintf(cbuf, 32, "0x%06x\n",
   2393				phba->lpfc_injerr_nportid);
   2394	else if (dent == phba->debug_InjErrWWPN) {
   2395		memcpy(&tmp, &phba->lpfc_injerr_wwpn, sizeof(struct lpfc_name));
   2396		tmp = cpu_to_be64(tmp);
   2397		cnt = scnprintf(cbuf, 32, "0x%016llx\n", tmp);
   2398	} else if (dent == phba->debug_InjErrLBA) {
   2399		if (phba->lpfc_injerr_lba == (sector_t)(-1))
   2400			cnt = scnprintf(cbuf, 32, "off\n");
   2401		else
   2402			cnt = scnprintf(cbuf, 32, "0x%llx\n",
   2403				 (uint64_t) phba->lpfc_injerr_lba);
   2404	} else
   2405		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
   2406			 "0547 Unknown debugfs error injection entry\n");
   2407
   2408	return simple_read_from_buffer(buf, nbytes, ppos, &cbuf, cnt);
   2409}
   2410
   2411static ssize_t
   2412lpfc_debugfs_dif_err_write(struct file *file, const char __user *buf,
   2413	size_t nbytes, loff_t *ppos)
   2414{
   2415	struct dentry *dent = file->f_path.dentry;
   2416	struct lpfc_hba *phba = file->private_data;
   2417	char dstbuf[33];
   2418	uint64_t tmp = 0;
   2419	int size;
   2420
   2421	memset(dstbuf, 0, 33);
   2422	size = (nbytes < 32) ? nbytes : 32;
   2423	if (copy_from_user(dstbuf, buf, size))
   2424		return -EFAULT;
   2425
   2426	if (dent == phba->debug_InjErrLBA) {
   2427		if ((dstbuf[0] == 'o') && (dstbuf[1] == 'f') &&
   2428		    (dstbuf[2] == 'f'))
   2429			tmp = (uint64_t)(-1);
   2430	}
   2431
   2432	if ((tmp == 0) && (kstrtoull(dstbuf, 0, &tmp)))
   2433		return -EINVAL;
   2434
   2435	if (dent == phba->debug_writeGuard)
   2436		phba->lpfc_injerr_wgrd_cnt = (uint32_t)tmp;
   2437	else if (dent == phba->debug_writeApp)
   2438		phba->lpfc_injerr_wapp_cnt = (uint32_t)tmp;
   2439	else if (dent == phba->debug_writeRef)
   2440		phba->lpfc_injerr_wref_cnt = (uint32_t)tmp;
   2441	else if (dent == phba->debug_readGuard)
   2442		phba->lpfc_injerr_rgrd_cnt = (uint32_t)tmp;
   2443	else if (dent == phba->debug_readApp)
   2444		phba->lpfc_injerr_rapp_cnt = (uint32_t)tmp;
   2445	else if (dent == phba->debug_readRef)
   2446		phba->lpfc_injerr_rref_cnt = (uint32_t)tmp;
   2447	else if (dent == phba->debug_InjErrLBA)
   2448		phba->lpfc_injerr_lba = (sector_t)tmp;
   2449	else if (dent == phba->debug_InjErrNPortID)
   2450		phba->lpfc_injerr_nportid = (uint32_t)(tmp & Mask_DID);
   2451	else if (dent == phba->debug_InjErrWWPN) {
   2452		tmp = cpu_to_be64(tmp);
   2453		memcpy(&phba->lpfc_injerr_wwpn, &tmp, sizeof(struct lpfc_name));
   2454	} else
   2455		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
   2456			 "0548 Unknown debugfs error injection entry\n");
   2457
   2458	return nbytes;
   2459}
   2460
   2461static int
   2462lpfc_debugfs_dif_err_release(struct inode *inode, struct file *file)
   2463{
   2464	return 0;
   2465}
   2466
   2467/**
   2468 * lpfc_debugfs_nodelist_open - Open the nodelist debugfs file
   2469 * @inode: The inode pointer that contains a vport pointer.
   2470 * @file: The file pointer to attach the log output.
   2471 *
   2472 * Description:
   2473 * This routine is the entry point for the debugfs open file operation. It gets
   2474 * the vport from the i_private field in @inode, allocates the necessary buffer
   2475 * for the log, fills the buffer from the in-memory log for this vport, and then
   2476 * returns a pointer to that log in the private_data field in @file.
   2477 *
   2478 * Returns:
   2479 * This function returns zero if successful. On error it will return a negative
   2480 * error value.
   2481 **/
   2482static int
   2483lpfc_debugfs_nodelist_open(struct inode *inode, struct file *file)
   2484{
   2485	struct lpfc_vport *vport = inode->i_private;
   2486	struct lpfc_debug *debug;
   2487	int rc = -ENOMEM;
   2488
   2489	debug = kmalloc(sizeof(*debug), GFP_KERNEL);
   2490	if (!debug)
   2491		goto out;
   2492
   2493	/* Round to page boundary */
   2494	debug->buffer = kmalloc(LPFC_NODELIST_SIZE, GFP_KERNEL);
   2495	if (!debug->buffer) {
   2496		kfree(debug);
   2497		goto out;
   2498	}
   2499
   2500	debug->len = lpfc_debugfs_nodelist_data(vport, debug->buffer,
   2501		LPFC_NODELIST_SIZE);
   2502	file->private_data = debug;
   2503
   2504	rc = 0;
   2505out:
   2506	return rc;
   2507}
   2508
   2509/**
   2510 * lpfc_debugfs_lseek - Seek through a debugfs file
   2511 * @file: The file pointer to seek through.
   2512 * @off: The offset to seek to or the amount to seek by.
   2513 * @whence: Indicates how to seek.
   2514 *
   2515 * Description:
   2516 * This routine is the entry point for the debugfs lseek file operation. The
   2517 * @whence parameter indicates whether @off is the offset to directly seek to,
   2518 * or if it is a value to seek forward or reverse by. This function figures out
   2519 * what the new offset of the debugfs file will be and assigns that value to the
   2520 * f_pos field of @file.
   2521 *
   2522 * Returns:
   2523 * This function returns the new offset if successful and returns a negative
   2524 * error if unable to process the seek.
   2525 **/
   2526static loff_t
   2527lpfc_debugfs_lseek(struct file *file, loff_t off, int whence)
   2528{
   2529	struct lpfc_debug *debug = file->private_data;
   2530	return fixed_size_llseek(file, off, whence, debug->len);
   2531}
   2532
   2533/**
   2534 * lpfc_debugfs_read - Read a debugfs file
   2535 * @file: The file pointer to read from.
   2536 * @buf: The buffer to copy the data to.
   2537 * @nbytes: The number of bytes to read.
   2538 * @ppos: The position in the file to start reading from.
   2539 *
   2540 * Description:
   2541 * This routine reads data from from the buffer indicated in the private_data
   2542 * field of @file. It will start reading at @ppos and copy up to @nbytes of
   2543 * data to @buf.
   2544 *
   2545 * Returns:
   2546 * This function returns the amount of data that was read (this could be less
   2547 * than @nbytes if the end of the file was reached) or a negative error value.
   2548 **/
   2549static ssize_t
   2550lpfc_debugfs_read(struct file *file, char __user *buf,
   2551		  size_t nbytes, loff_t *ppos)
   2552{
   2553	struct lpfc_debug *debug = file->private_data;
   2554
   2555	return simple_read_from_buffer(buf, nbytes, ppos, debug->buffer,
   2556				       debug->len);
   2557}
   2558
   2559/**
   2560 * lpfc_debugfs_release - Release the buffer used to store debugfs file data
   2561 * @inode: The inode pointer that contains a vport pointer. (unused)
   2562 * @file: The file pointer that contains the buffer to release.
   2563 *
   2564 * Description:
   2565 * This routine frees the buffer that was allocated when the debugfs file was
   2566 * opened.
   2567 *
   2568 * Returns:
   2569 * This function returns zero.
   2570 **/
   2571static int
   2572lpfc_debugfs_release(struct inode *inode, struct file *file)
   2573{
   2574	struct lpfc_debug *debug = file->private_data;
   2575
   2576	kfree(debug->buffer);
   2577	kfree(debug);
   2578
   2579	return 0;
   2580}
   2581
   2582/**
   2583 * lpfc_debugfs_multixripools_write - Clear multi-XRI pools statistics
   2584 * @file: The file pointer to read from.
   2585 * @buf: The buffer to copy the user data from.
   2586 * @nbytes: The number of bytes to get.
   2587 * @ppos: The position in the file to start reading from.
   2588 *
   2589 * Description:
   2590 * This routine clears multi-XRI pools statistics when buf contains "clear".
   2591 *
   2592 * Return Value:
   2593 * It returns the @nbytges passing in from debugfs user space when successful.
   2594 * In case of error conditions, it returns proper error code back to the user
   2595 * space.
   2596 **/
   2597static ssize_t
   2598lpfc_debugfs_multixripools_write(struct file *file, const char __user *buf,
   2599				 size_t nbytes, loff_t *ppos)
   2600{
   2601	struct lpfc_debug *debug = file->private_data;
   2602	struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
   2603	char mybuf[64];
   2604	char *pbuf;
   2605	u32 i;
   2606	u32 hwq_count;
   2607	struct lpfc_sli4_hdw_queue *qp;
   2608	struct lpfc_multixri_pool *multixri_pool;
   2609
   2610	if (nbytes > 64)
   2611		nbytes = 64;
   2612
   2613	memset(mybuf, 0, sizeof(mybuf));
   2614
   2615	if (copy_from_user(mybuf, buf, nbytes))
   2616		return -EFAULT;
   2617	pbuf = &mybuf[0];
   2618
   2619	if ((strncmp(pbuf, "clear", strlen("clear"))) == 0) {
   2620		hwq_count = phba->cfg_hdw_queue;
   2621		for (i = 0; i < hwq_count; i++) {
   2622			qp = &phba->sli4_hba.hdwq[i];
   2623			multixri_pool = qp->p_multixri_pool;
   2624			if (!multixri_pool)
   2625				continue;
   2626
   2627			qp->empty_io_bufs = 0;
   2628			multixri_pool->pbl_empty_count = 0;
   2629#ifdef LPFC_MXP_STAT
   2630			multixri_pool->above_limit_count = 0;
   2631			multixri_pool->below_limit_count = 0;
   2632			multixri_pool->stat_max_hwm = 0;
   2633			multixri_pool->local_pbl_hit_count = 0;
   2634			multixri_pool->other_pbl_hit_count = 0;
   2635
   2636			multixri_pool->stat_pbl_count = 0;
   2637			multixri_pool->stat_pvt_count = 0;
   2638			multixri_pool->stat_busy_count = 0;
   2639			multixri_pool->stat_snapshot_taken = 0;
   2640#endif
   2641		}
   2642		return strlen(pbuf);
   2643	}
   2644
   2645	return -EINVAL;
   2646}
   2647
   2648static int
   2649lpfc_debugfs_nvmestat_open(struct inode *inode, struct file *file)
   2650{
   2651	struct lpfc_vport *vport = inode->i_private;
   2652	struct lpfc_debug *debug;
   2653	int rc = -ENOMEM;
   2654
   2655	debug = kmalloc(sizeof(*debug), GFP_KERNEL);
   2656	if (!debug)
   2657		goto out;
   2658
   2659	 /* Round to page boundary */
   2660	debug->buffer = kmalloc(LPFC_NVMESTAT_SIZE, GFP_KERNEL);
   2661	if (!debug->buffer) {
   2662		kfree(debug);
   2663		goto out;
   2664	}
   2665
   2666	debug->len = lpfc_debugfs_nvmestat_data(vport, debug->buffer,
   2667		LPFC_NVMESTAT_SIZE);
   2668
   2669	debug->i_private = inode->i_private;
   2670	file->private_data = debug;
   2671
   2672	rc = 0;
   2673out:
   2674	return rc;
   2675}
   2676
   2677static ssize_t
   2678lpfc_debugfs_nvmestat_write(struct file *file, const char __user *buf,
   2679			    size_t nbytes, loff_t *ppos)
   2680{
   2681	struct lpfc_debug *debug = file->private_data;
   2682	struct lpfc_vport *vport = (struct lpfc_vport *)debug->i_private;
   2683	struct lpfc_hba   *phba = vport->phba;
   2684	struct lpfc_nvmet_tgtport *tgtp;
   2685	char mybuf[64];
   2686	char *pbuf;
   2687
   2688	if (!phba->targetport)
   2689		return -ENXIO;
   2690
   2691	if (nbytes > 64)
   2692		nbytes = 64;
   2693
   2694	memset(mybuf, 0, sizeof(mybuf));
   2695
   2696	if (copy_from_user(mybuf, buf, nbytes))
   2697		return -EFAULT;
   2698	pbuf = &mybuf[0];
   2699
   2700	tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private;
   2701	if ((strncmp(pbuf, "reset", strlen("reset")) == 0) ||
   2702	    (strncmp(pbuf, "zero", strlen("zero")) == 0)) {
   2703		atomic_set(&tgtp->rcv_ls_req_in, 0);
   2704		atomic_set(&tgtp->rcv_ls_req_out, 0);
   2705		atomic_set(&tgtp->rcv_ls_req_drop, 0);
   2706		atomic_set(&tgtp->xmt_ls_abort, 0);
   2707		atomic_set(&tgtp->xmt_ls_abort_cmpl, 0);
   2708		atomic_set(&tgtp->xmt_ls_rsp, 0);
   2709		atomic_set(&tgtp->xmt_ls_drop, 0);
   2710		atomic_set(&tgtp->xmt_ls_rsp_error, 0);
   2711		atomic_set(&tgtp->xmt_ls_rsp_cmpl, 0);
   2712
   2713		atomic_set(&tgtp->rcv_fcp_cmd_in, 0);
   2714		atomic_set(&tgtp->rcv_fcp_cmd_out, 0);
   2715		atomic_set(&tgtp->rcv_fcp_cmd_drop, 0);
   2716		atomic_set(&tgtp->xmt_fcp_drop, 0);
   2717		atomic_set(&tgtp->xmt_fcp_read_rsp, 0);
   2718		atomic_set(&tgtp->xmt_fcp_read, 0);
   2719		atomic_set(&tgtp->xmt_fcp_write, 0);
   2720		atomic_set(&tgtp->xmt_fcp_rsp, 0);
   2721		atomic_set(&tgtp->xmt_fcp_release, 0);
   2722		atomic_set(&tgtp->xmt_fcp_rsp_cmpl, 0);
   2723		atomic_set(&tgtp->xmt_fcp_rsp_error, 0);
   2724		atomic_set(&tgtp->xmt_fcp_rsp_drop, 0);
   2725
   2726		atomic_set(&tgtp->xmt_fcp_abort, 0);
   2727		atomic_set(&tgtp->xmt_fcp_abort_cmpl, 0);
   2728		atomic_set(&tgtp->xmt_abort_sol, 0);
   2729		atomic_set(&tgtp->xmt_abort_unsol, 0);
   2730		atomic_set(&tgtp->xmt_abort_rsp, 0);
   2731		atomic_set(&tgtp->xmt_abort_rsp_error, 0);
   2732	}
   2733	return nbytes;
   2734}
   2735
   2736static int
   2737lpfc_debugfs_scsistat_open(struct inode *inode, struct file *file)
   2738{
   2739	struct lpfc_vport *vport = inode->i_private;
   2740	struct lpfc_debug *debug;
   2741	int rc = -ENOMEM;
   2742
   2743	debug = kmalloc(sizeof(*debug), GFP_KERNEL);
   2744	if (!debug)
   2745		goto out;
   2746
   2747	 /* Round to page boundary */
   2748	debug->buffer = kzalloc(LPFC_SCSISTAT_SIZE, GFP_KERNEL);
   2749	if (!debug->buffer) {
   2750		kfree(debug);
   2751		goto out;
   2752	}
   2753
   2754	debug->len = lpfc_debugfs_scsistat_data(vport, debug->buffer,
   2755		LPFC_SCSISTAT_SIZE);
   2756
   2757	debug->i_private = inode->i_private;
   2758	file->private_data = debug;
   2759
   2760	rc = 0;
   2761out:
   2762	return rc;
   2763}
   2764
   2765static ssize_t
   2766lpfc_debugfs_scsistat_write(struct file *file, const char __user *buf,
   2767			    size_t nbytes, loff_t *ppos)
   2768{
   2769	struct lpfc_debug *debug = file->private_data;
   2770	struct lpfc_vport *vport = (struct lpfc_vport *)debug->i_private;
   2771	struct lpfc_hba *phba = vport->phba;
   2772	char mybuf[6] = {0};
   2773	int i;
   2774
   2775	if (copy_from_user(mybuf, buf, (nbytes >= sizeof(mybuf)) ?
   2776				       (sizeof(mybuf) - 1) : nbytes))
   2777		return -EFAULT;
   2778
   2779	if ((strncmp(&mybuf[0], "reset", strlen("reset")) == 0) ||
   2780	    (strncmp(&mybuf[0], "zero", strlen("zero")) == 0)) {
   2781		for (i = 0; i < phba->cfg_hdw_queue; i++) {
   2782			memset(&phba->sli4_hba.hdwq[i].scsi_cstat, 0,
   2783			       sizeof(phba->sli4_hba.hdwq[i].scsi_cstat));
   2784		}
   2785	}
   2786
   2787	return nbytes;
   2788}
   2789
   2790static int
   2791lpfc_debugfs_ioktime_open(struct inode *inode, struct file *file)
   2792{
   2793	struct lpfc_vport *vport = inode->i_private;
   2794	struct lpfc_debug *debug;
   2795	int rc = -ENOMEM;
   2796
   2797	debug = kmalloc(sizeof(*debug), GFP_KERNEL);
   2798	if (!debug)
   2799		goto out;
   2800
   2801	 /* Round to page boundary */
   2802	debug->buffer = kmalloc(LPFC_IOKTIME_SIZE, GFP_KERNEL);
   2803	if (!debug->buffer) {
   2804		kfree(debug);
   2805		goto out;
   2806	}
   2807
   2808	debug->len = lpfc_debugfs_ioktime_data(vport, debug->buffer,
   2809		LPFC_IOKTIME_SIZE);
   2810
   2811	debug->i_private = inode->i_private;
   2812	file->private_data = debug;
   2813
   2814	rc = 0;
   2815out:
   2816	return rc;
   2817}
   2818
   2819static ssize_t
   2820lpfc_debugfs_ioktime_write(struct file *file, const char __user *buf,
   2821			   size_t nbytes, loff_t *ppos)
   2822{
   2823	struct lpfc_debug *debug = file->private_data;
   2824	struct lpfc_vport *vport = (struct lpfc_vport *)debug->i_private;
   2825	struct lpfc_hba   *phba = vport->phba;
   2826	char mybuf[64];
   2827	char *pbuf;
   2828
   2829	if (nbytes > 64)
   2830		nbytes = 64;
   2831
   2832	memset(mybuf, 0, sizeof(mybuf));
   2833
   2834	if (copy_from_user(mybuf, buf, nbytes))
   2835		return -EFAULT;
   2836	pbuf = &mybuf[0];
   2837
   2838	if ((strncmp(pbuf, "on", sizeof("on") - 1) == 0)) {
   2839		phba->ktime_data_samples = 0;
   2840		phba->ktime_status_samples = 0;
   2841		phba->ktime_seg1_total = 0;
   2842		phba->ktime_seg1_max = 0;
   2843		phba->ktime_seg1_min = 0xffffffff;
   2844		phba->ktime_seg2_total = 0;
   2845		phba->ktime_seg2_max = 0;
   2846		phba->ktime_seg2_min = 0xffffffff;
   2847		phba->ktime_seg3_total = 0;
   2848		phba->ktime_seg3_max = 0;
   2849		phba->ktime_seg3_min = 0xffffffff;
   2850		phba->ktime_seg4_total = 0;
   2851		phba->ktime_seg4_max = 0;
   2852		phba->ktime_seg4_min = 0xffffffff;
   2853		phba->ktime_seg5_total = 0;
   2854		phba->ktime_seg5_max = 0;
   2855		phba->ktime_seg5_min = 0xffffffff;
   2856		phba->ktime_seg6_total = 0;
   2857		phba->ktime_seg6_max = 0;
   2858		phba->ktime_seg6_min = 0xffffffff;
   2859		phba->ktime_seg7_total = 0;
   2860		phba->ktime_seg7_max = 0;
   2861		phba->ktime_seg7_min = 0xffffffff;
   2862		phba->ktime_seg8_total = 0;
   2863		phba->ktime_seg8_max = 0;
   2864		phba->ktime_seg8_min = 0xffffffff;
   2865		phba->ktime_seg9_total = 0;
   2866		phba->ktime_seg9_max = 0;
   2867		phba->ktime_seg9_min = 0xffffffff;
   2868		phba->ktime_seg10_total = 0;
   2869		phba->ktime_seg10_max = 0;
   2870		phba->ktime_seg10_min = 0xffffffff;
   2871
   2872		phba->ktime_on = 1;
   2873		return strlen(pbuf);
   2874	} else if ((strncmp(pbuf, "off",
   2875		   sizeof("off") - 1) == 0)) {
   2876		phba->ktime_on = 0;
   2877		return strlen(pbuf);
   2878	} else if ((strncmp(pbuf, "zero",
   2879		   sizeof("zero") - 1) == 0)) {
   2880		phba->ktime_data_samples = 0;
   2881		phba->ktime_status_samples = 0;
   2882		phba->ktime_seg1_total = 0;
   2883		phba->ktime_seg1_max = 0;
   2884		phba->ktime_seg1_min = 0xffffffff;
   2885		phba->ktime_seg2_total = 0;
   2886		phba->ktime_seg2_max = 0;
   2887		phba->ktime_seg2_min = 0xffffffff;
   2888		phba->ktime_seg3_total = 0;
   2889		phba->ktime_seg3_max = 0;
   2890		phba->ktime_seg3_min = 0xffffffff;
   2891		phba->ktime_seg4_total = 0;
   2892		phba->ktime_seg4_max = 0;
   2893		phba->ktime_seg4_min = 0xffffffff;
   2894		phba->ktime_seg5_total = 0;
   2895		phba->ktime_seg5_max = 0;
   2896		phba->ktime_seg5_min = 0xffffffff;
   2897		phba->ktime_seg6_total = 0;
   2898		phba->ktime_seg6_max = 0;
   2899		phba->ktime_seg6_min = 0xffffffff;
   2900		phba->ktime_seg7_total = 0;
   2901		phba->ktime_seg7_max = 0;
   2902		phba->ktime_seg7_min = 0xffffffff;
   2903		phba->ktime_seg8_total = 0;
   2904		phba->ktime_seg8_max = 0;
   2905		phba->ktime_seg8_min = 0xffffffff;
   2906		phba->ktime_seg9_total = 0;
   2907		phba->ktime_seg9_max = 0;
   2908		phba->ktime_seg9_min = 0xffffffff;
   2909		phba->ktime_seg10_total = 0;
   2910		phba->ktime_seg10_max = 0;
   2911		phba->ktime_seg10_min = 0xffffffff;
   2912		return strlen(pbuf);
   2913	}
   2914	return -EINVAL;
   2915}
   2916
   2917static int
   2918lpfc_debugfs_nvmeio_trc_open(struct inode *inode, struct file *file)
   2919{
   2920	struct lpfc_hba *phba = inode->i_private;
   2921	struct lpfc_debug *debug;
   2922	int rc = -ENOMEM;
   2923
   2924	debug = kmalloc(sizeof(*debug), GFP_KERNEL);
   2925	if (!debug)
   2926		goto out;
   2927
   2928	 /* Round to page boundary */
   2929	debug->buffer = kmalloc(LPFC_NVMEIO_TRC_SIZE, GFP_KERNEL);
   2930	if (!debug->buffer) {
   2931		kfree(debug);
   2932		goto out;
   2933	}
   2934
   2935	debug->len = lpfc_debugfs_nvmeio_trc_data(phba, debug->buffer,
   2936		LPFC_NVMEIO_TRC_SIZE);
   2937
   2938	debug->i_private = inode->i_private;
   2939	file->private_data = debug;
   2940
   2941	rc = 0;
   2942out:
   2943	return rc;
   2944}
   2945
   2946static ssize_t
   2947lpfc_debugfs_nvmeio_trc_write(struct file *file, const char __user *buf,
   2948			      size_t nbytes, loff_t *ppos)
   2949{
   2950	struct lpfc_debug *debug = file->private_data;
   2951	struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
   2952	int i;
   2953	unsigned long sz;
   2954	char mybuf[64];
   2955	char *pbuf;
   2956
   2957	if (nbytes > 63)
   2958		nbytes = 63;
   2959
   2960	memset(mybuf, 0, sizeof(mybuf));
   2961
   2962	if (copy_from_user(mybuf, buf, nbytes))
   2963		return -EFAULT;
   2964	pbuf = &mybuf[0];
   2965
   2966	if ((strncmp(pbuf, "off", sizeof("off") - 1) == 0)) {
   2967		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
   2968				"0570 nvmeio_trc_off\n");
   2969		phba->nvmeio_trc_output_idx = 0;
   2970		phba->nvmeio_trc_on = 0;
   2971		return strlen(pbuf);
   2972	} else if ((strncmp(pbuf, "on", sizeof("on") - 1) == 0)) {
   2973		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
   2974				"0571 nvmeio_trc_on\n");
   2975		phba->nvmeio_trc_output_idx = 0;
   2976		phba->nvmeio_trc_on = 1;
   2977		return strlen(pbuf);
   2978	}
   2979
   2980	/* We must be off to allocate the trace buffer */
   2981	if (phba->nvmeio_trc_on != 0)
   2982		return -EINVAL;
   2983
   2984	/* If not on or off, the parameter is the trace buffer size */
   2985	i = kstrtoul(pbuf, 0, &sz);
   2986	if (i)
   2987		return -EINVAL;
   2988	phba->nvmeio_trc_size = (uint32_t)sz;
   2989
   2990	/* It must be a power of 2 - round down */
   2991	i = 0;
   2992	while (sz > 1) {
   2993		sz = sz >> 1;
   2994		i++;
   2995	}
   2996	sz = (1 << i);
   2997	if (phba->nvmeio_trc_size != sz)
   2998		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
   2999				"0572 nvmeio_trc_size changed to %ld\n",
   3000				sz);
   3001	phba->nvmeio_trc_size = (uint32_t)sz;
   3002
   3003	/* If one previously exists, free it */
   3004	kfree(phba->nvmeio_trc);
   3005
   3006	/* Allocate new trace buffer and initialize */
   3007	phba->nvmeio_trc = kzalloc((sizeof(struct lpfc_debugfs_nvmeio_trc) *
   3008				    sz), GFP_KERNEL);
   3009	if (!phba->nvmeio_trc) {
   3010		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
   3011				"0573 Cannot create debugfs "
   3012				"nvmeio_trc buffer\n");
   3013		return -ENOMEM;
   3014	}
   3015	atomic_set(&phba->nvmeio_trc_cnt, 0);
   3016	phba->nvmeio_trc_on = 0;
   3017	phba->nvmeio_trc_output_idx = 0;
   3018
   3019	return strlen(pbuf);
   3020}
   3021
   3022static int
   3023lpfc_debugfs_hdwqstat_open(struct inode *inode, struct file *file)
   3024{
   3025	struct lpfc_vport *vport = inode->i_private;
   3026	struct lpfc_debug *debug;
   3027	int rc = -ENOMEM;
   3028
   3029	debug = kmalloc(sizeof(*debug), GFP_KERNEL);
   3030	if (!debug)
   3031		goto out;
   3032
   3033	 /* Round to page boundary */
   3034	debug->buffer = kcalloc(1, LPFC_SCSISTAT_SIZE, GFP_KERNEL);
   3035	if (!debug->buffer) {
   3036		kfree(debug);
   3037		goto out;
   3038	}
   3039
   3040	debug->len = lpfc_debugfs_hdwqstat_data(vport, debug->buffer,
   3041						LPFC_SCSISTAT_SIZE);
   3042
   3043	debug->i_private = inode->i_private;
   3044	file->private_data = debug;
   3045
   3046	rc = 0;
   3047out:
   3048	return rc;
   3049}
   3050
   3051static ssize_t
   3052lpfc_debugfs_hdwqstat_write(struct file *file, const char __user *buf,
   3053			    size_t nbytes, loff_t *ppos)
   3054{
   3055	struct lpfc_debug *debug = file->private_data;
   3056	struct lpfc_vport *vport = (struct lpfc_vport *)debug->i_private;
   3057	struct lpfc_hba   *phba = vport->phba;
   3058	struct lpfc_hdwq_stat *c_stat;
   3059	char mybuf[64];
   3060	char *pbuf;
   3061	int i;
   3062
   3063	if (nbytes > 64)
   3064		nbytes = 64;
   3065
   3066	memset(mybuf, 0, sizeof(mybuf));
   3067
   3068	if (copy_from_user(mybuf, buf, nbytes))
   3069		return -EFAULT;
   3070	pbuf = &mybuf[0];
   3071
   3072	if ((strncmp(pbuf, "on", sizeof("on") - 1) == 0)) {
   3073		if (phba->nvmet_support)
   3074			phba->hdwqstat_on |= LPFC_CHECK_NVMET_IO;
   3075		else
   3076			phba->hdwqstat_on |= (LPFC_CHECK_NVME_IO |
   3077				LPFC_CHECK_SCSI_IO);
   3078		return strlen(pbuf);
   3079	} else if ((strncmp(pbuf, "nvme_on", sizeof("nvme_on") - 1) == 0)) {
   3080		if (phba->nvmet_support)
   3081			phba->hdwqstat_on |= LPFC_CHECK_NVMET_IO;
   3082		else
   3083			phba->hdwqstat_on |= LPFC_CHECK_NVME_IO;
   3084		return strlen(pbuf);
   3085	} else if ((strncmp(pbuf, "scsi_on", sizeof("scsi_on") - 1) == 0)) {
   3086		if (!phba->nvmet_support)
   3087			phba->hdwqstat_on |= LPFC_CHECK_SCSI_IO;
   3088		return strlen(pbuf);
   3089	} else if ((strncmp(pbuf, "nvme_off", sizeof("nvme_off") - 1) == 0)) {
   3090		phba->hdwqstat_on &= ~(LPFC_CHECK_NVME_IO |
   3091				       LPFC_CHECK_NVMET_IO);
   3092		return strlen(pbuf);
   3093	} else if ((strncmp(pbuf, "scsi_off", sizeof("scsi_off") - 1) == 0)) {
   3094		phba->hdwqstat_on &= ~LPFC_CHECK_SCSI_IO;
   3095		return strlen(pbuf);
   3096	} else if ((strncmp(pbuf, "off",
   3097		   sizeof("off") - 1) == 0)) {
   3098		phba->hdwqstat_on = LPFC_CHECK_OFF;
   3099		return strlen(pbuf);
   3100	} else if ((strncmp(pbuf, "zero",
   3101		   sizeof("zero") - 1) == 0)) {
   3102		for_each_present_cpu(i) {
   3103			c_stat = per_cpu_ptr(phba->sli4_hba.c_stat, i);
   3104			c_stat->xmt_io = 0;
   3105			c_stat->cmpl_io = 0;
   3106			c_stat->rcv_io = 0;
   3107		}
   3108		return strlen(pbuf);
   3109	}
   3110	return -EINVAL;
   3111}
   3112
   3113/*
   3114 * ---------------------------------
   3115 * iDiag debugfs file access methods
   3116 * ---------------------------------
   3117 *
   3118 * All access methods are through the proper SLI4 PCI function's debugfs
   3119 * iDiag directory:
   3120 *
   3121 *     /sys/kernel/debug/lpfc/fn<#>/iDiag
   3122 */
   3123
   3124/**
   3125 * lpfc_idiag_cmd_get - Get and parse idiag debugfs comands from user space
   3126 * @buf: The pointer to the user space buffer.
   3127 * @nbytes: The number of bytes in the user space buffer.
   3128 * @idiag_cmd: pointer to the idiag command struct.
   3129 *
   3130 * This routine reads data from debugfs user space buffer and parses the
   3131 * buffer for getting the idiag command and arguments. The while space in
   3132 * between the set of data is used as the parsing separator.
   3133 *
   3134 * This routine returns 0 when successful, it returns proper error code
   3135 * back to the user space in error conditions.
   3136 */
   3137static int lpfc_idiag_cmd_get(const char __user *buf, size_t nbytes,
   3138			      struct lpfc_idiag_cmd *idiag_cmd)
   3139{
   3140	char mybuf[64];
   3141	char *pbuf, *step_str;
   3142	int i;
   3143	size_t bsize;
   3144
   3145	memset(mybuf, 0, sizeof(mybuf));
   3146	memset(idiag_cmd, 0, sizeof(*idiag_cmd));
   3147	bsize = min(nbytes, (sizeof(mybuf)-1));
   3148
   3149	if (copy_from_user(mybuf, buf, bsize))
   3150		return -EFAULT;
   3151	pbuf = &mybuf[0];
   3152	step_str = strsep(&pbuf, "\t ");
   3153
   3154	/* The opcode must present */
   3155	if (!step_str)
   3156		return -EINVAL;
   3157
   3158	idiag_cmd->opcode = simple_strtol(step_str, NULL, 0);
   3159	if (idiag_cmd->opcode == 0)
   3160		return -EINVAL;
   3161
   3162	for (i = 0; i < LPFC_IDIAG_CMD_DATA_SIZE; i++) {
   3163		step_str = strsep(&pbuf, "\t ");
   3164		if (!step_str)
   3165			return i;
   3166		idiag_cmd->data[i] = simple_strtol(step_str, NULL, 0);
   3167	}
   3168	return i;
   3169}
   3170
   3171/**
   3172 * lpfc_idiag_open - idiag open debugfs
   3173 * @inode: The inode pointer that contains a pointer to phba.
   3174 * @file: The file pointer to attach the file operation.
   3175 *
   3176 * Description:
   3177 * This routine is the entry point for the debugfs open file operation. It
   3178 * gets the reference to phba from the i_private field in @inode, it then
   3179 * allocates buffer for the file operation, performs the necessary PCI config
   3180 * space read into the allocated buffer according to the idiag user command
   3181 * setup, and then returns a pointer to buffer in the private_data field in
   3182 * @file.
   3183 *
   3184 * Returns:
   3185 * This function returns zero if successful. On error it will return an
   3186 * negative error value.
   3187 **/
   3188static int
   3189lpfc_idiag_open(struct inode *inode, struct file *file)
   3190{
   3191	struct lpfc_debug *debug;
   3192
   3193	debug = kmalloc(sizeof(*debug), GFP_KERNEL);
   3194	if (!debug)
   3195		return -ENOMEM;
   3196
   3197	debug->i_private = inode->i_private;
   3198	debug->buffer = NULL;
   3199	file->private_data = debug;
   3200
   3201	return 0;
   3202}
   3203
   3204/**
   3205 * lpfc_idiag_release - Release idiag access file operation
   3206 * @inode: The inode pointer that contains a vport pointer. (unused)
   3207 * @file: The file pointer that contains the buffer to release.
   3208 *
   3209 * Description:
   3210 * This routine is the generic release routine for the idiag access file
   3211 * operation, it frees the buffer that was allocated when the debugfs file
   3212 * was opened.
   3213 *
   3214 * Returns:
   3215 * This function returns zero.
   3216 **/
   3217static int
   3218lpfc_idiag_release(struct inode *inode, struct file *file)
   3219{
   3220	struct lpfc_debug *debug = file->private_data;
   3221
   3222	/* Free the buffers to the file operation */
   3223	kfree(debug->buffer);
   3224	kfree(debug);
   3225
   3226	return 0;
   3227}
   3228
   3229/**
   3230 * lpfc_idiag_cmd_release - Release idiag cmd access file operation
   3231 * @inode: The inode pointer that contains a vport pointer. (unused)
   3232 * @file: The file pointer that contains the buffer to release.
   3233 *
   3234 * Description:
   3235 * This routine frees the buffer that was allocated when the debugfs file
   3236 * was opened. It also reset the fields in the idiag command struct in the
   3237 * case of command for write operation.
   3238 *
   3239 * Returns:
   3240 * This function returns zero.
   3241 **/
   3242static int
   3243lpfc_idiag_cmd_release(struct inode *inode, struct file *file)
   3244{
   3245	struct lpfc_debug *debug = file->private_data;
   3246
   3247	if (debug->op == LPFC_IDIAG_OP_WR) {
   3248		switch (idiag.cmd.opcode) {
   3249		case LPFC_IDIAG_CMD_PCICFG_WR:
   3250		case LPFC_IDIAG_CMD_PCICFG_ST:
   3251		case LPFC_IDIAG_CMD_PCICFG_CL:
   3252		case LPFC_IDIAG_CMD_QUEACC_WR:
   3253		case LPFC_IDIAG_CMD_QUEACC_ST:
   3254		case LPFC_IDIAG_CMD_QUEACC_CL:
   3255			memset(&idiag, 0, sizeof(idiag));
   3256			break;
   3257		default:
   3258			break;
   3259		}
   3260	}
   3261
   3262	/* Free the buffers to the file operation */
   3263	kfree(debug->buffer);
   3264	kfree(debug);
   3265
   3266	return 0;
   3267}
   3268
   3269/**
   3270 * lpfc_idiag_pcicfg_read - idiag debugfs read pcicfg
   3271 * @file: The file pointer to read from.
   3272 * @buf: The buffer to copy the data to.
   3273 * @nbytes: The number of bytes to read.
   3274 * @ppos: The position in the file to start reading from.
   3275 *
   3276 * Description:
   3277 * This routine reads data from the @phba pci config space according to the
   3278 * idiag command, and copies to user @buf. Depending on the PCI config space
   3279 * read command setup, it does either a single register read of a byte
   3280 * (8 bits), a word (16 bits), or a dword (32 bits) or browsing through all
   3281 * registers from the 4K extended PCI config space.
   3282 *
   3283 * Returns:
   3284 * This function returns the amount of data that was read (this could be less
   3285 * than @nbytes if the end of the file was reached) or a negative error value.
   3286 **/
   3287static ssize_t
   3288lpfc_idiag_pcicfg_read(struct file *file, char __user *buf, size_t nbytes,
   3289		       loff_t *ppos)
   3290{
   3291	struct lpfc_debug *debug = file->private_data;
   3292	struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
   3293	int offset_label, offset, len = 0, index = LPFC_PCI_CFG_RD_SIZE;
   3294	int where, count;
   3295	char *pbuffer;
   3296	struct pci_dev *pdev;
   3297	uint32_t u32val;
   3298	uint16_t u16val;
   3299	uint8_t u8val;
   3300
   3301	pdev = phba->pcidev;
   3302	if (!pdev)
   3303		return 0;
   3304
   3305	/* This is a user read operation */
   3306	debug->op = LPFC_IDIAG_OP_RD;
   3307
   3308	if (!debug->buffer)
   3309		debug->buffer = kmalloc(LPFC_PCI_CFG_SIZE, GFP_KERNEL);
   3310	if (!debug->buffer)
   3311		return 0;
   3312	pbuffer = debug->buffer;
   3313
   3314	if (*ppos)
   3315		return 0;
   3316
   3317	if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_RD) {
   3318		where = idiag.cmd.data[IDIAG_PCICFG_WHERE_INDX];
   3319		count = idiag.cmd.data[IDIAG_PCICFG_COUNT_INDX];
   3320	} else
   3321		return 0;
   3322
   3323	/* Read single PCI config space register */
   3324	switch (count) {
   3325	case SIZE_U8: /* byte (8 bits) */
   3326		pci_read_config_byte(pdev, where, &u8val);
   3327		len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
   3328				"%03x: %02x\n", where, u8val);
   3329		break;
   3330	case SIZE_U16: /* word (16 bits) */
   3331		pci_read_config_word(pdev, where, &u16val);
   3332		len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
   3333				"%03x: %04x\n", where, u16val);
   3334		break;
   3335	case SIZE_U32: /* double word (32 bits) */
   3336		pci_read_config_dword(pdev, where, &u32val);
   3337		len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
   3338				"%03x: %08x\n", where, u32val);
   3339		break;
   3340	case LPFC_PCI_CFG_BROWSE: /* browse all */
   3341		goto pcicfg_browse;
   3342	default:
   3343		/* illegal count */
   3344		len = 0;
   3345		break;
   3346	}
   3347	return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
   3348
   3349pcicfg_browse:
   3350
   3351	/* Browse all PCI config space registers */
   3352	offset_label = idiag.offset.last_rd;
   3353	offset = offset_label;
   3354
   3355	/* Read PCI config space */
   3356	len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
   3357			"%03x: ", offset_label);
   3358	while (index > 0) {
   3359		pci_read_config_dword(pdev, offset, &u32val);
   3360		len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
   3361				"%08x ", u32val);
   3362		offset += sizeof(uint32_t);
   3363		if (offset >= LPFC_PCI_CFG_SIZE) {
   3364			len += scnprintf(pbuffer+len,
   3365					LPFC_PCI_CFG_SIZE-len, "\n");
   3366			break;
   3367		}
   3368		index -= sizeof(uint32_t);
   3369		if (!index)
   3370			len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
   3371					"\n");
   3372		else if (!(index % (8 * sizeof(uint32_t)))) {
   3373			offset_label += (8 * sizeof(uint32_t));
   3374			len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
   3375					"\n%03x: ", offset_label);
   3376		}
   3377	}
   3378
   3379	/* Set up the offset for next portion of pci cfg read */
   3380	if (index == 0) {
   3381		idiag.offset.last_rd += LPFC_PCI_CFG_RD_SIZE;
   3382		if (idiag.offset.last_rd >= LPFC_PCI_CFG_SIZE)
   3383			idiag.offset.last_rd = 0;
   3384	} else
   3385		idiag.offset.last_rd = 0;
   3386
   3387	return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
   3388}
   3389
   3390/**
   3391 * lpfc_idiag_pcicfg_write - Syntax check and set up idiag pcicfg commands
   3392 * @file: The file pointer to read from.
   3393 * @buf: The buffer to copy the user data from.
   3394 * @nbytes: The number of bytes to get.
   3395 * @ppos: The position in the file to start reading from.
   3396 *
   3397 * This routine get the debugfs idiag command struct from user space and
   3398 * then perform the syntax check for PCI config space read or write command
   3399 * accordingly. In the case of PCI config space read command, it sets up
   3400 * the command in the idiag command struct for the debugfs read operation.
   3401 * In the case of PCI config space write operation, it executes the write
   3402 * operation into the PCI config space accordingly.
   3403 *
   3404 * It returns the @nbytges passing in from debugfs user space when successful.
   3405 * In case of error conditions, it returns proper error code back to the user
   3406 * space.
   3407 */
   3408static ssize_t
   3409lpfc_idiag_pcicfg_write(struct file *file, const char __user *buf,
   3410			size_t nbytes, loff_t *ppos)
   3411{
   3412	struct lpfc_debug *debug = file->private_data;
   3413	struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
   3414	uint32_t where, value, count;
   3415	uint32_t u32val;
   3416	uint16_t u16val;
   3417	uint8_t u8val;
   3418	struct pci_dev *pdev;
   3419	int rc;
   3420
   3421	pdev = phba->pcidev;
   3422	if (!pdev)
   3423		return -EFAULT;
   3424
   3425	/* This is a user write operation */
   3426	debug->op = LPFC_IDIAG_OP_WR;
   3427
   3428	rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
   3429	if (rc < 0)
   3430		return rc;
   3431
   3432	if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_RD) {
   3433		/* Sanity check on PCI config read command line arguments */
   3434		if (rc != LPFC_PCI_CFG_RD_CMD_ARG)
   3435			goto error_out;
   3436		/* Read command from PCI config space, set up command fields */
   3437		where = idiag.cmd.data[IDIAG_PCICFG_WHERE_INDX];
   3438		count = idiag.cmd.data[IDIAG_PCICFG_COUNT_INDX];
   3439		if (count == LPFC_PCI_CFG_BROWSE) {
   3440			if (where % sizeof(uint32_t))
   3441				goto error_out;
   3442			/* Starting offset to browse */
   3443			idiag.offset.last_rd = where;
   3444		} else if ((count != sizeof(uint8_t)) &&
   3445			   (count != sizeof(uint16_t)) &&
   3446			   (count != sizeof(uint32_t)))
   3447			goto error_out;
   3448		if (count == sizeof(uint8_t)) {
   3449			if (where > LPFC_PCI_CFG_SIZE - sizeof(uint8_t))
   3450				goto error_out;
   3451			if (where % sizeof(uint8_t))
   3452				goto error_out;
   3453		}
   3454		if (count == sizeof(uint16_t)) {
   3455			if (where > LPFC_PCI_CFG_SIZE - sizeof(uint16_t))
   3456				goto error_out;
   3457			if (where % sizeof(uint16_t))
   3458				goto error_out;
   3459		}
   3460		if (count == sizeof(uint32_t)) {
   3461			if (where > LPFC_PCI_CFG_SIZE - sizeof(uint32_t))
   3462				goto error_out;
   3463			if (where % sizeof(uint32_t))
   3464				goto error_out;
   3465		}
   3466	} else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR ||
   3467		   idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST ||
   3468		   idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) {
   3469		/* Sanity check on PCI config write command line arguments */
   3470		if (rc != LPFC_PCI_CFG_WR_CMD_ARG)
   3471			goto error_out;
   3472		/* Write command to PCI config space, read-modify-write */
   3473		where = idiag.cmd.data[IDIAG_PCICFG_WHERE_INDX];
   3474		count = idiag.cmd.data[IDIAG_PCICFG_COUNT_INDX];
   3475		value = idiag.cmd.data[IDIAG_PCICFG_VALUE_INDX];
   3476		/* Sanity checks */
   3477		if ((count != sizeof(uint8_t)) &&
   3478		    (count != sizeof(uint16_t)) &&
   3479		    (count != sizeof(uint32_t)))
   3480			goto error_out;
   3481		if (count == sizeof(uint8_t)) {
   3482			if (where > LPFC_PCI_CFG_SIZE - sizeof(uint8_t))
   3483				goto error_out;
   3484			if (where % sizeof(uint8_t))
   3485				goto error_out;
   3486			if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR)
   3487				pci_write_config_byte(pdev, where,
   3488						      (uint8_t)value);
   3489			if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST) {
   3490				rc = pci_read_config_byte(pdev, where, &u8val);
   3491				if (!rc) {
   3492					u8val |= (uint8_t)value;
   3493					pci_write_config_byte(pdev, where,
   3494							      u8val);
   3495				}
   3496			}
   3497			if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) {
   3498				rc = pci_read_config_byte(pdev, where, &u8val);
   3499				if (!rc) {
   3500					u8val &= (uint8_t)(~value);
   3501					pci_write_config_byte(pdev, where,
   3502							      u8val);
   3503				}
   3504			}
   3505		}
   3506		if (count == sizeof(uint16_t)) {
   3507			if (where > LPFC_PCI_CFG_SIZE - sizeof(uint16_t))
   3508				goto error_out;
   3509			if (where % sizeof(uint16_t))
   3510				goto error_out;
   3511			if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR)
   3512				pci_write_config_word(pdev, where,
   3513						      (uint16_t)value);
   3514			if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST) {
   3515				rc = pci_read_config_word(pdev, where, &u16val);
   3516				if (!rc) {
   3517					u16val |= (uint16_t)value;
   3518					pci_write_config_word(pdev, where,
   3519							      u16val);
   3520				}
   3521			}
   3522			if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) {
   3523				rc = pci_read_config_word(pdev, where, &u16val);
   3524				if (!rc) {
   3525					u16val &= (uint16_t)(~value);
   3526					pci_write_config_word(pdev, where,
   3527							      u16val);
   3528				}
   3529			}
   3530		}
   3531		if (count == sizeof(uint32_t)) {
   3532			if (where > LPFC_PCI_CFG_SIZE - sizeof(uint32_t))
   3533				goto error_out;
   3534			if (where % sizeof(uint32_t))
   3535				goto error_out;
   3536			if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR)
   3537				pci_write_config_dword(pdev, where, value);
   3538			if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST) {
   3539				rc = pci_read_config_dword(pdev, where,
   3540							   &u32val);
   3541				if (!rc) {
   3542					u32val |= value;
   3543					pci_write_config_dword(pdev, where,
   3544							       u32val);
   3545				}
   3546			}
   3547			if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) {
   3548				rc = pci_read_config_dword(pdev, where,
   3549							   &u32val);
   3550				if (!rc) {
   3551					u32val &= ~value;
   3552					pci_write_config_dword(pdev, where,
   3553							       u32val);
   3554				}
   3555			}
   3556		}
   3557	} else
   3558		/* All other opecodes are illegal for now */
   3559		goto error_out;
   3560
   3561	return nbytes;
   3562error_out:
   3563	memset(&idiag, 0, sizeof(idiag));
   3564	return -EINVAL;
   3565}
   3566
   3567/**
   3568 * lpfc_idiag_baracc_read - idiag debugfs pci bar access read
   3569 * @file: The file pointer to read from.
   3570 * @buf: The buffer to copy the data to.
   3571 * @nbytes: The number of bytes to read.
   3572 * @ppos: The position in the file to start reading from.
   3573 *
   3574 * Description:
   3575 * This routine reads data from the @phba pci bar memory mapped space
   3576 * according to the idiag command, and copies to user @buf.
   3577 *
   3578 * Returns:
   3579 * This function returns the amount of data that was read (this could be less
   3580 * than @nbytes if the end of the file was reached) or a negative error value.
   3581 **/
   3582static ssize_t
   3583lpfc_idiag_baracc_read(struct file *file, char __user *buf, size_t nbytes,
   3584		       loff_t *ppos)
   3585{
   3586	struct lpfc_debug *debug = file->private_data;
   3587	struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
   3588	int offset_label, offset, offset_run, len = 0, index;
   3589	int bar_num, acc_range, bar_size;
   3590	char *pbuffer;
   3591	void __iomem *mem_mapped_bar;
   3592	uint32_t if_type;
   3593	struct pci_dev *pdev;
   3594	uint32_t u32val;
   3595
   3596	pdev = phba->pcidev;
   3597	if (!pdev)
   3598		return 0;
   3599
   3600	/* This is a user read operation */
   3601	debug->op = LPFC_IDIAG_OP_RD;
   3602
   3603	if (!debug->buffer)
   3604		debug->buffer = kmalloc(LPFC_PCI_BAR_RD_BUF_SIZE, GFP_KERNEL);
   3605	if (!debug->buffer)
   3606		return 0;
   3607	pbuffer = debug->buffer;
   3608
   3609	if (*ppos)
   3610		return 0;
   3611
   3612	if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_RD) {
   3613		bar_num   = idiag.cmd.data[IDIAG_BARACC_BAR_NUM_INDX];
   3614		offset    = idiag.cmd.data[IDIAG_BARACC_OFF_SET_INDX];
   3615		acc_range = idiag.cmd.data[IDIAG_BARACC_ACC_MOD_INDX];
   3616		bar_size = idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX];
   3617	} else
   3618		return 0;
   3619
   3620	if (acc_range == 0)
   3621		return 0;
   3622
   3623	if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
   3624	if (if_type == LPFC_SLI_INTF_IF_TYPE_0) {
   3625		if (bar_num == IDIAG_BARACC_BAR_0)
   3626			mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p;
   3627		else if (bar_num == IDIAG_BARACC_BAR_1)
   3628			mem_mapped_bar = phba->sli4_hba.ctrl_regs_memmap_p;
   3629		else if (bar_num == IDIAG_BARACC_BAR_2)
   3630			mem_mapped_bar = phba->sli4_hba.drbl_regs_memmap_p;
   3631		else
   3632			return 0;
   3633	} else if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
   3634		if (bar_num == IDIAG_BARACC_BAR_0)
   3635			mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p;
   3636		else
   3637			return 0;
   3638	} else
   3639		return 0;
   3640
   3641	/* Read single PCI bar space register */
   3642	if (acc_range == SINGLE_WORD) {
   3643		offset_run = offset;
   3644		u32val = readl(mem_mapped_bar + offset_run);
   3645		len += scnprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
   3646				"%05x: %08x\n", offset_run, u32val);
   3647	} else
   3648		goto baracc_browse;
   3649
   3650	return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
   3651
   3652baracc_browse:
   3653
   3654	/* Browse all PCI bar space registers */
   3655	offset_label = idiag.offset.last_rd;
   3656	offset_run = offset_label;
   3657
   3658	/* Read PCI bar memory mapped space */
   3659	len += scnprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
   3660			"%05x: ", offset_label);
   3661	index = LPFC_PCI_BAR_RD_SIZE;
   3662	while (index > 0) {
   3663		u32val = readl(mem_mapped_bar + offset_run);
   3664		len += scnprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
   3665				"%08x ", u32val);
   3666		offset_run += sizeof(uint32_t);
   3667		if (acc_range == LPFC_PCI_BAR_BROWSE) {
   3668			if (offset_run >= bar_size) {
   3669				len += scnprintf(pbuffer+len,
   3670					LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n");
   3671				break;
   3672			}
   3673		} else {
   3674			if (offset_run >= offset +
   3675			    (acc_range * sizeof(uint32_t))) {
   3676				len += scnprintf(pbuffer+len,
   3677					LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n");
   3678				break;
   3679			}
   3680		}
   3681		index -= sizeof(uint32_t);
   3682		if (!index)
   3683			len += scnprintf(pbuffer+len,
   3684					LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n");
   3685		else if (!(index % (8 * sizeof(uint32_t)))) {
   3686			offset_label += (8 * sizeof(uint32_t));
   3687			len += scnprintf(pbuffer+len,
   3688					LPFC_PCI_BAR_RD_BUF_SIZE-len,
   3689					"\n%05x: ", offset_label);
   3690		}
   3691	}
   3692
   3693	/* Set up the offset for next portion of pci bar read */
   3694	if (index == 0) {
   3695		idiag.offset.last_rd += LPFC_PCI_BAR_RD_SIZE;
   3696		if (acc_range == LPFC_PCI_BAR_BROWSE) {
   3697			if (idiag.offset.last_rd >= bar_size)
   3698				idiag.offset.last_rd = 0;
   3699		} else {
   3700			if (offset_run >= offset +
   3701			    (acc_range * sizeof(uint32_t)))
   3702				idiag.offset.last_rd = offset;
   3703		}
   3704	} else {
   3705		if (acc_range == LPFC_PCI_BAR_BROWSE)
   3706			idiag.offset.last_rd = 0;
   3707		else
   3708			idiag.offset.last_rd = offset;
   3709	}
   3710
   3711	return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
   3712}
   3713
   3714/**
   3715 * lpfc_idiag_baracc_write - Syntax check and set up idiag bar access commands
   3716 * @file: The file pointer to read from.
   3717 * @buf: The buffer to copy the user data from.
   3718 * @nbytes: The number of bytes to get.
   3719 * @ppos: The position in the file to start reading from.
   3720 *
   3721 * This routine get the debugfs idiag command struct from user space and
   3722 * then perform the syntax check for PCI bar memory mapped space read or
   3723 * write command accordingly. In the case of PCI bar memory mapped space
   3724 * read command, it sets up the command in the idiag command struct for
   3725 * the debugfs read operation. In the case of PCI bar memorpy mapped space
   3726 * write operation, it executes the write operation into the PCI bar memory
   3727 * mapped space accordingly.
   3728 *
   3729 * It returns the @nbytges passing in from debugfs user space when successful.
   3730 * In case of error conditions, it returns proper error code back to the user
   3731 * space.
   3732 */
   3733static ssize_t
   3734lpfc_idiag_baracc_write(struct file *file, const char __user *buf,
   3735			size_t nbytes, loff_t *ppos)
   3736{
   3737	struct lpfc_debug *debug = file->private_data;
   3738	struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
   3739	uint32_t bar_num, bar_size, offset, value, acc_range;
   3740	struct pci_dev *pdev;
   3741	void __iomem *mem_mapped_bar;
   3742	uint32_t if_type;
   3743	uint32_t u32val;
   3744	int rc;
   3745
   3746	pdev = phba->pcidev;
   3747	if (!pdev)
   3748		return -EFAULT;
   3749
   3750	/* This is a user write operation */
   3751	debug->op = LPFC_IDIAG_OP_WR;
   3752
   3753	rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
   3754	if (rc < 0)
   3755		return rc;
   3756
   3757	if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
   3758	bar_num = idiag.cmd.data[IDIAG_BARACC_BAR_NUM_INDX];
   3759
   3760	if (if_type == LPFC_SLI_INTF_IF_TYPE_0) {
   3761		if ((bar_num != IDIAG_BARACC_BAR_0) &&
   3762		    (bar_num != IDIAG_BARACC_BAR_1) &&
   3763		    (bar_num != IDIAG_BARACC_BAR_2))
   3764			goto error_out;
   3765	} else if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
   3766		if (bar_num != IDIAG_BARACC_BAR_0)
   3767			goto error_out;
   3768	} else
   3769		goto error_out;
   3770
   3771	if (if_type == LPFC_SLI_INTF_IF_TYPE_0) {
   3772		if (bar_num == IDIAG_BARACC_BAR_0) {
   3773			idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] =
   3774				LPFC_PCI_IF0_BAR0_SIZE;
   3775			mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p;
   3776		} else if (bar_num == IDIAG_BARACC_BAR_1) {
   3777			idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] =
   3778				LPFC_PCI_IF0_BAR1_SIZE;
   3779			mem_mapped_bar = phba->sli4_hba.ctrl_regs_memmap_p;
   3780		} else if (bar_num == IDIAG_BARACC_BAR_2) {
   3781			idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] =
   3782				LPFC_PCI_IF0_BAR2_SIZE;
   3783			mem_mapped_bar = phba->sli4_hba.drbl_regs_memmap_p;
   3784		} else
   3785			goto error_out;
   3786	} else if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
   3787		if (bar_num == IDIAG_BARACC_BAR_0) {
   3788			idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] =
   3789				LPFC_PCI_IF2_BAR0_SIZE;
   3790			mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p;
   3791		} else
   3792			goto error_out;
   3793	} else
   3794		goto error_out;
   3795
   3796	offset = idiag.cmd.data[IDIAG_BARACC_OFF_SET_INDX];
   3797	if (offset % sizeof(uint32_t))
   3798		goto error_out;
   3799
   3800	bar_size = idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX];
   3801	if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_RD) {
   3802		/* Sanity check on PCI config read command line arguments */
   3803		if (rc != LPFC_PCI_BAR_RD_CMD_ARG)
   3804			goto error_out;
   3805		acc_range = idiag.cmd.data[IDIAG_BARACC_ACC_MOD_INDX];
   3806		if (acc_range == LPFC_PCI_BAR_BROWSE) {
   3807			if (offset > bar_size - sizeof(uint32_t))
   3808				goto error_out;
   3809			/* Starting offset to browse */
   3810			idiag.offset.last_rd = offset;
   3811		} else if (acc_range > SINGLE_WORD) {
   3812			if (offset + acc_range * sizeof(uint32_t) > bar_size)
   3813				goto error_out;
   3814			/* Starting offset to browse */
   3815			idiag.offset.last_rd = offset;
   3816		} else if (acc_range != SINGLE_WORD)
   3817			goto error_out;
   3818	} else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_WR ||
   3819		   idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_ST ||
   3820		   idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_CL) {
   3821		/* Sanity check on PCI bar write command line arguments */
   3822		if (rc != LPFC_PCI_BAR_WR_CMD_ARG)
   3823			goto error_out;
   3824		/* Write command to PCI bar space, read-modify-write */
   3825		acc_range = SINGLE_WORD;
   3826		value = idiag.cmd.data[IDIAG_BARACC_REG_VAL_INDX];
   3827		if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_WR) {
   3828			writel(value, mem_mapped_bar + offset);
   3829			readl(mem_mapped_bar + offset);
   3830		}
   3831		if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_ST) {
   3832			u32val = readl(mem_mapped_bar + offset);
   3833			u32val |= value;
   3834			writel(u32val, mem_mapped_bar + offset);
   3835			readl(mem_mapped_bar + offset);
   3836		}
   3837		if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_CL) {
   3838			u32val = readl(mem_mapped_bar + offset);
   3839			u32val &= ~value;
   3840			writel(u32val, mem_mapped_bar + offset);
   3841			readl(mem_mapped_bar + offset);
   3842		}
   3843	} else
   3844		/* All other opecodes are illegal for now */
   3845		goto error_out;
   3846
   3847	return nbytes;
   3848error_out:
   3849	memset(&idiag, 0, sizeof(idiag));
   3850	return -EINVAL;
   3851}
   3852
   3853static int
   3854__lpfc_idiag_print_wq(struct lpfc_queue *qp, char *wqtype,
   3855			char *pbuffer, int len)
   3856{
   3857	if (!qp)
   3858		return len;
   3859
   3860	len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
   3861			"\t\t%s WQ info: ", wqtype);
   3862	len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
   3863			"AssocCQID[%04d]: WQ-STAT[oflow:x%x posted:x%llx]\n",
   3864			qp->assoc_qid, qp->q_cnt_1,
   3865			(unsigned long long)qp->q_cnt_4);
   3866	len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
   3867			"\t\tWQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
   3868			"HST-IDX[%04d], PRT-IDX[%04d], NTFI[%03d]",
   3869			qp->queue_id, qp->entry_count,
   3870			qp->entry_size, qp->host_index,
   3871			qp->hba_index, qp->notify_interval);
   3872	len +=  scnprintf(pbuffer + len,
   3873			LPFC_QUE_INFO_GET_BUF_SIZE - len, "\n");
   3874	return len;
   3875}
   3876
   3877static int
   3878lpfc_idiag_wqs_for_cq(struct lpfc_hba *phba, char *wqtype, char *pbuffer,
   3879		int *len, int max_cnt, int cq_id)
   3880{
   3881	struct lpfc_queue *qp;
   3882	int qidx;
   3883
   3884	for (qidx = 0; qidx < phba->cfg_hdw_queue; qidx++) {
   3885		qp = phba->sli4_hba.hdwq[qidx].io_wq;
   3886		if (qp->assoc_qid != cq_id)
   3887			continue;
   3888		*len = __lpfc_idiag_print_wq(qp, wqtype, pbuffer, *len);
   3889		if (*len >= max_cnt)
   3890			return 1;
   3891	}
   3892	return 0;
   3893}
   3894
   3895static int
   3896__lpfc_idiag_print_cq(struct lpfc_queue *qp, char *cqtype,
   3897			char *pbuffer, int len)
   3898{
   3899	if (!qp)
   3900		return len;
   3901
   3902	len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
   3903			"\t%s CQ info: ", cqtype);
   3904	len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
   3905			"AssocEQID[%02d]: CQ STAT[max:x%x relw:x%x "
   3906			"xabt:x%x wq:x%llx]\n",
   3907			qp->assoc_qid, qp->q_cnt_1, qp->q_cnt_2,
   3908			qp->q_cnt_3, (unsigned long long)qp->q_cnt_4);
   3909	len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
   3910			"\tCQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
   3911			"HST-IDX[%04d], NTFI[%03d], PLMT[%03d]",
   3912			qp->queue_id, qp->entry_count,
   3913			qp->entry_size, qp->host_index,
   3914			qp->notify_interval, qp->max_proc_limit);
   3915
   3916	len +=  scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
   3917			"\n");
   3918
   3919	return len;
   3920}
   3921
   3922static int
   3923__lpfc_idiag_print_rqpair(struct lpfc_queue *qp, struct lpfc_queue *datqp,
   3924			char *rqtype, char *pbuffer, int len)
   3925{
   3926	if (!qp || !datqp)
   3927		return len;
   3928
   3929	len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
   3930			"\t\t%s RQ info: ", rqtype);
   3931	len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
   3932			"AssocCQID[%02d]: RQ-STAT[nopost:x%x nobuf:x%x "
   3933			"posted:x%x rcv:x%llx]\n",
   3934			qp->assoc_qid, qp->q_cnt_1, qp->q_cnt_2,
   3935			qp->q_cnt_3, (unsigned long long)qp->q_cnt_4);
   3936	len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
   3937			"\t\tHQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
   3938			"HST-IDX[%04d], PRT-IDX[%04d], NTFI[%03d]\n",
   3939			qp->queue_id, qp->entry_count, qp->entry_size,
   3940			qp->host_index, qp->hba_index, qp->notify_interval);
   3941	len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
   3942			"\t\tDQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
   3943			"HST-IDX[%04d], PRT-IDX[%04d], NTFI[%03d]\n",
   3944			datqp->queue_id, datqp->entry_count,
   3945			datqp->entry_size, datqp->host_index,
   3946			datqp->hba_index, datqp->notify_interval);
   3947	return len;
   3948}
   3949
   3950static int
   3951lpfc_idiag_cqs_for_eq(struct lpfc_hba *phba, char *pbuffer,
   3952		int *len, int max_cnt, int eqidx, int eq_id)
   3953{
   3954	struct lpfc_queue *qp;
   3955	int rc;
   3956
   3957	qp = phba->sli4_hba.hdwq[eqidx].io_cq;
   3958
   3959	*len = __lpfc_idiag_print_cq(qp, "IO", pbuffer, *len);
   3960
   3961	/* Reset max counter */
   3962	qp->CQ_max_cqe = 0;
   3963
   3964	if (*len >= max_cnt)
   3965		return 1;
   3966
   3967	rc = lpfc_idiag_wqs_for_cq(phba, "IO", pbuffer, len,
   3968				   max_cnt, qp->queue_id);
   3969	if (rc)
   3970		return 1;
   3971
   3972	if ((eqidx < phba->cfg_nvmet_mrq) && phba->nvmet_support) {
   3973		/* NVMET CQset */
   3974		qp = phba->sli4_hba.nvmet_cqset[eqidx];
   3975		*len = __lpfc_idiag_print_cq(qp, "NVMET CQset", pbuffer, *len);
   3976
   3977		/* Reset max counter */
   3978		qp->CQ_max_cqe = 0;
   3979
   3980		if (*len >= max_cnt)
   3981			return 1;
   3982
   3983		/* RQ header */
   3984		qp = phba->sli4_hba.nvmet_mrq_hdr[eqidx];
   3985		*len = __lpfc_idiag_print_rqpair(qp,
   3986				phba->sli4_hba.nvmet_mrq_data[eqidx],
   3987				"NVMET MRQ", pbuffer, *len);
   3988
   3989		if (*len >= max_cnt)
   3990			return 1;
   3991	}
   3992
   3993	return 0;
   3994}
   3995
   3996static int
   3997__lpfc_idiag_print_eq(struct lpfc_queue *qp, char *eqtype,
   3998			char *pbuffer, int len)
   3999{
   4000	if (!qp)
   4001		return len;
   4002
   4003	len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
   4004			"\n%s EQ info: EQ-STAT[max:x%x noE:x%x "
   4005			"cqe_proc:x%x eqe_proc:x%llx eqd %d]\n",
   4006			eqtype, qp->q_cnt_1, qp->q_cnt_2, qp->q_cnt_3,
   4007			(unsigned long long)qp->q_cnt_4, qp->q_mode);
   4008	len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
   4009			"EQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
   4010			"HST-IDX[%04d], NTFI[%03d], PLMT[%03d], AFFIN[%03d]",
   4011			qp->queue_id, qp->entry_count, qp->entry_size,
   4012			qp->host_index, qp->notify_interval,
   4013			qp->max_proc_limit, qp->chann);
   4014	len +=  scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
   4015			"\n");
   4016
   4017	return len;
   4018}
   4019
   4020/**
   4021 * lpfc_idiag_queinfo_read - idiag debugfs read queue information
   4022 * @file: The file pointer to read from.
   4023 * @buf: The buffer to copy the data to.
   4024 * @nbytes: The number of bytes to read.
   4025 * @ppos: The position in the file to start reading from.
   4026 *
   4027 * Description:
   4028 * This routine reads data from the @phba SLI4 PCI function queue information,
   4029 * and copies to user @buf.
   4030 * This routine only returns 1 EQs worth of information. It remembers the last
   4031 * EQ read and jumps to the next EQ. Thus subsequent calls to queInfo will
   4032 * retrieve all EQs allocated for the phba.
   4033 *
   4034 * Returns:
   4035 * This function returns the amount of data that was read (this could be less
   4036 * than @nbytes if the end of the file was reached) or a negative error value.
   4037 **/
   4038static ssize_t
   4039lpfc_idiag_queinfo_read(struct file *file, char __user *buf, size_t nbytes,
   4040			loff_t *ppos)
   4041{
   4042	struct lpfc_debug *debug = file->private_data;
   4043	struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
   4044	char *pbuffer;
   4045	int max_cnt, rc, x, len = 0;
   4046	struct lpfc_queue *qp = NULL;
   4047
   4048	if (!debug->buffer)
   4049		debug->buffer = kmalloc(LPFC_QUE_INFO_GET_BUF_SIZE, GFP_KERNEL);
   4050	if (!debug->buffer)
   4051		return 0;
   4052	pbuffer = debug->buffer;
   4053	max_cnt = LPFC_QUE_INFO_GET_BUF_SIZE - 256;
   4054
   4055	if (*ppos)
   4056		return 0;
   4057
   4058	spin_lock_irq(&phba->hbalock);
   4059
   4060	/* Fast-path event queue */
   4061	if (phba->sli4_hba.hdwq && phba->cfg_hdw_queue) {
   4062
   4063		x = phba->lpfc_idiag_last_eq;
   4064		phba->lpfc_idiag_last_eq++;
   4065		if (phba->lpfc_idiag_last_eq >= phba->cfg_hdw_queue)
   4066			phba->lpfc_idiag_last_eq = 0;
   4067
   4068		len += scnprintf(pbuffer + len,
   4069				 LPFC_QUE_INFO_GET_BUF_SIZE - len,
   4070				 "HDWQ %d out of %d HBA HDWQs\n",
   4071				 x, phba->cfg_hdw_queue);
   4072
   4073		/* Fast-path EQ */
   4074		qp = phba->sli4_hba.hdwq[x].hba_eq;
   4075		if (!qp)
   4076			goto out;
   4077
   4078		len = __lpfc_idiag_print_eq(qp, "HBA", pbuffer, len);
   4079
   4080		/* Reset max counter */
   4081		qp->EQ_max_eqe = 0;
   4082
   4083		if (len >= max_cnt)
   4084			goto too_big;
   4085
   4086		/* will dump both fcp and nvme cqs/wqs for the eq */
   4087		rc = lpfc_idiag_cqs_for_eq(phba, pbuffer, &len,
   4088			max_cnt, x, qp->queue_id);
   4089		if (rc)
   4090			goto too_big;
   4091
   4092		/* Only EQ 0 has slow path CQs configured */
   4093		if (x)
   4094			goto out;
   4095
   4096		/* Slow-path mailbox CQ */
   4097		qp = phba->sli4_hba.mbx_cq;
   4098		len = __lpfc_idiag_print_cq(qp, "MBX", pbuffer, len);
   4099		if (len >= max_cnt)
   4100			goto too_big;
   4101
   4102		/* Slow-path MBOX MQ */
   4103		qp = phba->sli4_hba.mbx_wq;
   4104		len = __lpfc_idiag_print_wq(qp, "MBX", pbuffer, len);
   4105		if (len >= max_cnt)
   4106			goto too_big;
   4107
   4108		/* Slow-path ELS response CQ */
   4109		qp = phba->sli4_hba.els_cq;
   4110		len = __lpfc_idiag_print_cq(qp, "ELS", pbuffer, len);
   4111		/* Reset max counter */
   4112		if (qp)
   4113			qp->CQ_max_cqe = 0;
   4114		if (len >= max_cnt)
   4115			goto too_big;
   4116
   4117		/* Slow-path ELS WQ */
   4118		qp = phba->sli4_hba.els_wq;
   4119		len = __lpfc_idiag_print_wq(qp, "ELS", pbuffer, len);
   4120		if (len >= max_cnt)
   4121			goto too_big;
   4122
   4123		qp = phba->sli4_hba.hdr_rq;
   4124		len = __lpfc_idiag_print_rqpair(qp, phba->sli4_hba.dat_rq,
   4125						"ELS RQpair", pbuffer, len);
   4126		if (len >= max_cnt)
   4127			goto too_big;
   4128
   4129		/* Slow-path NVME LS response CQ */
   4130		qp = phba->sli4_hba.nvmels_cq;
   4131		len = __lpfc_idiag_print_cq(qp, "NVME LS",
   4132						pbuffer, len);
   4133		/* Reset max counter */
   4134		if (qp)
   4135			qp->CQ_max_cqe = 0;
   4136		if (len >= max_cnt)
   4137			goto too_big;
   4138
   4139		/* Slow-path NVME LS WQ */
   4140		qp = phba->sli4_hba.nvmels_wq;
   4141		len = __lpfc_idiag_print_wq(qp, "NVME LS",
   4142						pbuffer, len);
   4143		if (len >= max_cnt)
   4144			goto too_big;
   4145
   4146		goto out;
   4147	}
   4148
   4149	spin_unlock_irq(&phba->hbalock);
   4150	return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
   4151
   4152too_big:
   4153	len +=  scnprintf(pbuffer + len,
   4154		LPFC_QUE_INFO_GET_BUF_SIZE - len, "Truncated ...\n");
   4155out:
   4156	spin_unlock_irq(&phba->hbalock);
   4157	return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
   4158}
   4159
   4160/**
   4161 * lpfc_idiag_que_param_check - queue access command parameter sanity check
   4162 * @q: The pointer to queue structure.
   4163 * @index: The index into a queue entry.
   4164 * @count: The number of queue entries to access.
   4165 *
   4166 * Description:
   4167 * The routine performs sanity check on device queue access method commands.
   4168 *
   4169 * Returns:
   4170 * This function returns -EINVAL when fails the sanity check, otherwise, it
   4171 * returns 0.
   4172 **/
   4173static int
   4174lpfc_idiag_que_param_check(struct lpfc_queue *q, int index, int count)
   4175{
   4176	/* Only support single entry read or browsing */
   4177	if ((count != 1) && (count != LPFC_QUE_ACC_BROWSE))
   4178		return -EINVAL;
   4179	if (index > q->entry_count - 1)
   4180		return -EINVAL;
   4181	return 0;
   4182}
   4183
   4184/**
   4185 * lpfc_idiag_queacc_read_qe - read a single entry from the given queue index
   4186 * @pbuffer: The pointer to buffer to copy the read data into.
   4187 * @len: Length of the buffer.
   4188 * @pque: The pointer to the queue to be read.
   4189 * @index: The index into the queue entry.
   4190 *
   4191 * Description:
   4192 * This routine reads out a single entry from the given queue's index location
   4193 * and copies it into the buffer provided.
   4194 *
   4195 * Returns:
   4196 * This function returns 0 when it fails, otherwise, it returns the length of
   4197 * the data read into the buffer provided.
   4198 **/
   4199static int
   4200lpfc_idiag_queacc_read_qe(char *pbuffer, int len, struct lpfc_queue *pque,
   4201			  uint32_t index)
   4202{
   4203	int offset, esize;
   4204	uint32_t *pentry;
   4205
   4206	if (!pbuffer || !pque)
   4207		return 0;
   4208
   4209	esize = pque->entry_size;
   4210	len += scnprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len,
   4211			"QE-INDEX[%04d]:\n", index);
   4212
   4213	offset = 0;
   4214	pentry = lpfc_sli4_qe(pque, index);
   4215	while (esize > 0) {
   4216		len += scnprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len,
   4217				"%08x ", *pentry);
   4218		pentry++;
   4219		offset += sizeof(uint32_t);
   4220		esize -= sizeof(uint32_t);
   4221		if (esize > 0 && !(offset % (4 * sizeof(uint32_t))))
   4222			len += scnprintf(pbuffer+len,
   4223					LPFC_QUE_ACC_BUF_SIZE-len, "\n");
   4224	}
   4225	len += scnprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len, "\n");
   4226
   4227	return len;
   4228}
   4229
   4230/**
   4231 * lpfc_idiag_queacc_read - idiag debugfs read port queue
   4232 * @file: The file pointer to read from.
   4233 * @buf: The buffer to copy the data to.
   4234 * @nbytes: The number of bytes to read.
   4235 * @ppos: The position in the file to start reading from.
   4236 *
   4237 * Description:
   4238 * This routine reads data from the @phba device queue memory according to the
   4239 * idiag command, and copies to user @buf. Depending on the queue dump read
   4240 * command setup, it does either a single queue entry read or browing through
   4241 * all entries of the queue.
   4242 *
   4243 * Returns:
   4244 * This function returns the amount of data that was read (this could be less
   4245 * than @nbytes if the end of the file was reached) or a negative error value.
   4246 **/
   4247static ssize_t
   4248lpfc_idiag_queacc_read(struct file *file, char __user *buf, size_t nbytes,
   4249		       loff_t *ppos)
   4250{
   4251	struct lpfc_debug *debug = file->private_data;
   4252	uint32_t last_index, index, count;
   4253	struct lpfc_queue *pque = NULL;
   4254	char *pbuffer;
   4255	int len = 0;
   4256
   4257	/* This is a user read operation */
   4258	debug->op = LPFC_IDIAG_OP_RD;
   4259
   4260	if (!debug->buffer)
   4261		debug->buffer = kmalloc(LPFC_QUE_ACC_BUF_SIZE, GFP_KERNEL);
   4262	if (!debug->buffer)
   4263		return 0;
   4264	pbuffer = debug->buffer;
   4265
   4266	if (*ppos)
   4267		return 0;
   4268
   4269	if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_RD) {
   4270		index = idiag.cmd.data[IDIAG_QUEACC_INDEX_INDX];
   4271		count = idiag.cmd.data[IDIAG_QUEACC_COUNT_INDX];
   4272		pque = (struct lpfc_queue *)idiag.ptr_private;
   4273	} else
   4274		return 0;
   4275
   4276	/* Browse the queue starting from index */
   4277	if (count == LPFC_QUE_ACC_BROWSE)
   4278		goto que_browse;
   4279
   4280	/* Read a single entry from the queue */
   4281	len = lpfc_idiag_queacc_read_qe(pbuffer, len, pque, index);
   4282
   4283	return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
   4284
   4285que_browse:
   4286
   4287	/* Browse all entries from the queue */
   4288	last_index = idiag.offset.last_rd;
   4289	index = last_index;
   4290
   4291	while (len < LPFC_QUE_ACC_SIZE - pque->entry_size) {
   4292		len = lpfc_idiag_queacc_read_qe(pbuffer, len, pque, index);
   4293		index++;
   4294		if (index > pque->entry_count - 1)
   4295			break;
   4296	}
   4297
   4298	/* Set up the offset for next portion of pci cfg read */
   4299	if (index > pque->entry_count - 1)
   4300		index = 0;
   4301	idiag.offset.last_rd = index;
   4302
   4303	return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
   4304}
   4305
   4306/**
   4307 * lpfc_idiag_queacc_write - Syntax check and set up idiag queacc commands
   4308 * @file: The file pointer to read from.
   4309 * @buf: The buffer to copy the user data from.
   4310 * @nbytes: The number of bytes to get.
   4311 * @ppos: The position in the file to start reading from.
   4312 *
   4313 * This routine get the debugfs idiag command struct from user space and then
   4314 * perform the syntax check for port queue read (dump) or write (set) command
   4315 * accordingly. In the case of port queue read command, it sets up the command
   4316 * in the idiag command struct for the following debugfs read operation. In
   4317 * the case of port queue write operation, it executes the write operation
   4318 * into the port queue entry accordingly.
   4319 *
   4320 * It returns the @nbytges passing in from debugfs user space when successful.
   4321 * In case of error conditions, it returns proper error code back to the user
   4322 * space.
   4323 **/
   4324static ssize_t
   4325lpfc_idiag_queacc_write(struct file *file, const char __user *buf,
   4326			size_t nbytes, loff_t *ppos)
   4327{
   4328	struct lpfc_debug *debug = file->private_data;
   4329	struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
   4330	uint32_t qidx, quetp, queid, index, count, offset, value;
   4331	uint32_t *pentry;
   4332	struct lpfc_queue *pque, *qp;
   4333	int rc;
   4334
   4335	/* This is a user write operation */
   4336	debug->op = LPFC_IDIAG_OP_WR;
   4337
   4338	rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
   4339	if (rc < 0)
   4340		return rc;
   4341
   4342	/* Get and sanity check on command feilds */
   4343	quetp  = idiag.cmd.data[IDIAG_QUEACC_QUETP_INDX];
   4344	queid  = idiag.cmd.data[IDIAG_QUEACC_QUEID_INDX];
   4345	index  = idiag.cmd.data[IDIAG_QUEACC_INDEX_INDX];
   4346	count  = idiag.cmd.data[IDIAG_QUEACC_COUNT_INDX];
   4347	offset = idiag.cmd.data[IDIAG_QUEACC_OFFST_INDX];
   4348	value  = idiag.cmd.data[IDIAG_QUEACC_VALUE_INDX];
   4349
   4350	/* Sanity check on command line arguments */
   4351	if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_WR ||
   4352	    idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_ST ||
   4353	    idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_CL) {
   4354		if (rc != LPFC_QUE_ACC_WR_CMD_ARG)
   4355			goto error_out;
   4356		if (count != 1)
   4357			goto error_out;
   4358	} else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_RD) {
   4359		if (rc != LPFC_QUE_ACC_RD_CMD_ARG)
   4360			goto error_out;
   4361	} else
   4362		goto error_out;
   4363
   4364	switch (quetp) {
   4365	case LPFC_IDIAG_EQ:
   4366		/* HBA event queue */
   4367		if (phba->sli4_hba.hdwq) {
   4368			for (qidx = 0; qidx < phba->cfg_hdw_queue; qidx++) {
   4369				qp = phba->sli4_hba.hdwq[qidx].hba_eq;
   4370				if (qp && qp->queue_id == queid) {
   4371					/* Sanity check */
   4372					rc = lpfc_idiag_que_param_check(qp,
   4373						index, count);
   4374					if (rc)
   4375						goto error_out;
   4376					idiag.ptr_private = qp;
   4377					goto pass_check;
   4378				}
   4379			}
   4380		}
   4381		goto error_out;
   4382
   4383	case LPFC_IDIAG_CQ:
   4384		/* MBX complete queue */
   4385		if (phba->sli4_hba.mbx_cq &&
   4386		    phba->sli4_hba.mbx_cq->queue_id == queid) {
   4387			/* Sanity check */
   4388			rc = lpfc_idiag_que_param_check(
   4389					phba->sli4_hba.mbx_cq, index, count);
   4390			if (rc)
   4391				goto error_out;
   4392			idiag.ptr_private = phba->sli4_hba.mbx_cq;
   4393			goto pass_check;
   4394		}
   4395		/* ELS complete queue */
   4396		if (phba->sli4_hba.els_cq &&
   4397		    phba->sli4_hba.els_cq->queue_id == queid) {
   4398			/* Sanity check */
   4399			rc = lpfc_idiag_que_param_check(
   4400					phba->sli4_hba.els_cq, index, count);
   4401			if (rc)
   4402				goto error_out;
   4403			idiag.ptr_private = phba->sli4_hba.els_cq;
   4404			goto pass_check;
   4405		}
   4406		/* NVME LS complete queue */
   4407		if (phba->sli4_hba.nvmels_cq &&
   4408		    phba->sli4_hba.nvmels_cq->queue_id == queid) {
   4409			/* Sanity check */
   4410			rc = lpfc_idiag_que_param_check(
   4411					phba->sli4_hba.nvmels_cq, index, count);
   4412			if (rc)
   4413				goto error_out;
   4414			idiag.ptr_private = phba->sli4_hba.nvmels_cq;
   4415			goto pass_check;
   4416		}
   4417		/* FCP complete queue */
   4418		if (phba->sli4_hba.hdwq) {
   4419			for (qidx = 0; qidx < phba->cfg_hdw_queue;
   4420								qidx++) {
   4421				qp = phba->sli4_hba.hdwq[qidx].io_cq;
   4422				if (qp && qp->queue_id == queid) {
   4423					/* Sanity check */
   4424					rc = lpfc_idiag_que_param_check(
   4425						qp, index, count);
   4426					if (rc)
   4427						goto error_out;
   4428					idiag.ptr_private = qp;
   4429					goto pass_check;
   4430				}
   4431			}
   4432		}
   4433		goto error_out;
   4434
   4435	case LPFC_IDIAG_MQ:
   4436		/* MBX work queue */
   4437		if (phba->sli4_hba.mbx_wq &&
   4438		    phba->sli4_hba.mbx_wq->queue_id == queid) {
   4439			/* Sanity check */
   4440			rc = lpfc_idiag_que_param_check(
   4441					phba->sli4_hba.mbx_wq, index, count);
   4442			if (rc)
   4443				goto error_out;
   4444			idiag.ptr_private = phba->sli4_hba.mbx_wq;
   4445			goto pass_check;
   4446		}
   4447		goto error_out;
   4448
   4449	case LPFC_IDIAG_WQ:
   4450		/* ELS work queue */
   4451		if (phba->sli4_hba.els_wq &&
   4452		    phba->sli4_hba.els_wq->queue_id == queid) {
   4453			/* Sanity check */
   4454			rc = lpfc_idiag_que_param_check(
   4455					phba->sli4_hba.els_wq, index, count);
   4456			if (rc)
   4457				goto error_out;
   4458			idiag.ptr_private = phba->sli4_hba.els_wq;
   4459			goto pass_check;
   4460		}
   4461		/* NVME LS work queue */
   4462		if (phba->sli4_hba.nvmels_wq &&
   4463		    phba->sli4_hba.nvmels_wq->queue_id == queid) {
   4464			/* Sanity check */
   4465			rc = lpfc_idiag_que_param_check(
   4466					phba->sli4_hba.nvmels_wq, index, count);
   4467			if (rc)
   4468				goto error_out;
   4469			idiag.ptr_private = phba->sli4_hba.nvmels_wq;
   4470			goto pass_check;
   4471		}
   4472
   4473		if (phba->sli4_hba.hdwq) {
   4474			/* FCP/SCSI work queue */
   4475			for (qidx = 0; qidx < phba->cfg_hdw_queue; qidx++) {
   4476				qp = phba->sli4_hba.hdwq[qidx].io_wq;
   4477				if (qp && qp->queue_id == queid) {
   4478					/* Sanity check */
   4479					rc = lpfc_idiag_que_param_check(
   4480						qp, index, count);
   4481					if (rc)
   4482						goto error_out;
   4483					idiag.ptr_private = qp;
   4484					goto pass_check;
   4485				}
   4486			}
   4487		}
   4488		goto error_out;
   4489
   4490	case LPFC_IDIAG_RQ:
   4491		/* HDR queue */
   4492		if (phba->sli4_hba.hdr_rq &&
   4493		    phba->sli4_hba.hdr_rq->queue_id == queid) {
   4494			/* Sanity check */
   4495			rc = lpfc_idiag_que_param_check(
   4496					phba->sli4_hba.hdr_rq, index, count);
   4497			if (rc)
   4498				goto error_out;
   4499			idiag.ptr_private = phba->sli4_hba.hdr_rq;
   4500			goto pass_check;
   4501		}
   4502		/* DAT queue */
   4503		if (phba->sli4_hba.dat_rq &&
   4504		    phba->sli4_hba.dat_rq->queue_id == queid) {
   4505			/* Sanity check */
   4506			rc = lpfc_idiag_que_param_check(
   4507					phba->sli4_hba.dat_rq, index, count);
   4508			if (rc)
   4509				goto error_out;
   4510			idiag.ptr_private = phba->sli4_hba.dat_rq;
   4511			goto pass_check;
   4512		}
   4513		goto error_out;
   4514	default:
   4515		goto error_out;
   4516	}
   4517
   4518pass_check:
   4519
   4520	if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_RD) {
   4521		if (count == LPFC_QUE_ACC_BROWSE)
   4522			idiag.offset.last_rd = index;
   4523	}
   4524
   4525	if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_WR ||
   4526	    idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_ST ||
   4527	    idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_CL) {
   4528		/* Additional sanity checks on write operation */
   4529		pque = (struct lpfc_queue *)idiag.ptr_private;
   4530		if (offset > pque->entry_size/sizeof(uint32_t) - 1)
   4531			goto error_out;
   4532		pentry = lpfc_sli4_qe(pque, index);
   4533		pentry += offset;
   4534		if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_WR)
   4535			*pentry = value;
   4536		if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_ST)
   4537			*pentry |= value;
   4538		if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_CL)
   4539			*pentry &= ~value;
   4540	}
   4541	return nbytes;
   4542
   4543error_out:
   4544	/* Clean out command structure on command error out */
   4545	memset(&idiag, 0, sizeof(idiag));
   4546	return -EINVAL;
   4547}
   4548
   4549/**
   4550 * lpfc_idiag_drbacc_read_reg - idiag debugfs read a doorbell register
   4551 * @phba: The pointer to hba structure.
   4552 * @pbuffer: The pointer to the buffer to copy the data to.
   4553 * @len: The length of bytes to copied.
   4554 * @drbregid: The id to doorbell registers.
   4555 *
   4556 * Description:
   4557 * This routine reads a doorbell register and copies its content to the
   4558 * user buffer pointed to by @pbuffer.
   4559 *
   4560 * Returns:
   4561 * This function returns the amount of data that was copied into @pbuffer.
   4562 **/
   4563static int
   4564lpfc_idiag_drbacc_read_reg(struct lpfc_hba *phba, char *pbuffer,
   4565			   int len, uint32_t drbregid)
   4566{
   4567
   4568	if (!pbuffer)
   4569		return 0;
   4570
   4571	switch (drbregid) {
   4572	case LPFC_DRB_EQ:
   4573		len += scnprintf(pbuffer + len, LPFC_DRB_ACC_BUF_SIZE-len,
   4574				"EQ-DRB-REG: 0x%08x\n",
   4575				readl(phba->sli4_hba.EQDBregaddr));
   4576		break;
   4577	case LPFC_DRB_CQ:
   4578		len += scnprintf(pbuffer + len, LPFC_DRB_ACC_BUF_SIZE - len,
   4579				"CQ-DRB-REG: 0x%08x\n",
   4580				readl(phba->sli4_hba.CQDBregaddr));
   4581		break;
   4582	case LPFC_DRB_MQ:
   4583		len += scnprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
   4584				"MQ-DRB-REG:   0x%08x\n",
   4585				readl(phba->sli4_hba.MQDBregaddr));
   4586		break;
   4587	case LPFC_DRB_WQ:
   4588		len += scnprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
   4589				"WQ-DRB-REG:   0x%08x\n",
   4590				readl(phba->sli4_hba.WQDBregaddr));
   4591		break;
   4592	case LPFC_DRB_RQ:
   4593		len += scnprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
   4594				"RQ-DRB-REG:   0x%08x\n",
   4595				readl(phba->sli4_hba.RQDBregaddr));
   4596		break;
   4597	default:
   4598		break;
   4599	}
   4600
   4601	return len;
   4602}
   4603
   4604/**
   4605 * lpfc_idiag_drbacc_read - idiag debugfs read port doorbell
   4606 * @file: The file pointer to read from.
   4607 * @buf: The buffer to copy the data to.
   4608 * @nbytes: The number of bytes to read.
   4609 * @ppos: The position in the file to start reading from.
   4610 *
   4611 * Description:
   4612 * This routine reads data from the @phba device doorbell register according
   4613 * to the idiag command, and copies to user @buf. Depending on the doorbell
   4614 * register read command setup, it does either a single doorbell register
   4615 * read or dump all doorbell registers.
   4616 *
   4617 * Returns:
   4618 * This function returns the amount of data that was read (this could be less
   4619 * than @nbytes if the end of the file was reached) or a negative error value.
   4620 **/
   4621static ssize_t
   4622lpfc_idiag_drbacc_read(struct file *file, char __user *buf, size_t nbytes,
   4623		       loff_t *ppos)
   4624{
   4625	struct lpfc_debug *debug = file->private_data;
   4626	struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
   4627	uint32_t drb_reg_id, i;
   4628	char *pbuffer;
   4629	int len = 0;
   4630
   4631	/* This is a user read operation */
   4632	debug->op = LPFC_IDIAG_OP_RD;
   4633
   4634	if (!debug->buffer)
   4635		debug->buffer = kmalloc(LPFC_DRB_ACC_BUF_SIZE, GFP_KERNEL);
   4636	if (!debug->buffer)
   4637		return 0;
   4638	pbuffer = debug->buffer;
   4639
   4640	if (*ppos)
   4641		return 0;
   4642
   4643	if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_RD)
   4644		drb_reg_id = idiag.cmd.data[IDIAG_DRBACC_REGID_INDX];
   4645	else
   4646		return 0;
   4647
   4648	if (drb_reg_id == LPFC_DRB_ACC_ALL)
   4649		for (i = 1; i <= LPFC_DRB_MAX; i++)
   4650			len = lpfc_idiag_drbacc_read_reg(phba,
   4651							 pbuffer, len, i);
   4652	else
   4653		len = lpfc_idiag_drbacc_read_reg(phba,
   4654						 pbuffer, len, drb_reg_id);
   4655
   4656	return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
   4657}
   4658
   4659/**
   4660 * lpfc_idiag_drbacc_write - Syntax check and set up idiag drbacc commands
   4661 * @file: The file pointer to read from.
   4662 * @buf: The buffer to copy the user data from.
   4663 * @nbytes: The number of bytes to get.
   4664 * @ppos: The position in the file to start reading from.
   4665 *
   4666 * This routine get the debugfs idiag command struct from user space and then
   4667 * perform the syntax check for port doorbell register read (dump) or write
   4668 * (set) command accordingly. In the case of port queue read command, it sets
   4669 * up the command in the idiag command struct for the following debugfs read
   4670 * operation. In the case of port doorbell register write operation, it
   4671 * executes the write operation into the port doorbell register accordingly.
   4672 *
   4673 * It returns the @nbytges passing in from debugfs user space when successful.
   4674 * In case of error conditions, it returns proper error code back to the user
   4675 * space.
   4676 **/
   4677static ssize_t
   4678lpfc_idiag_drbacc_write(struct file *file, const char __user *buf,
   4679			size_t nbytes, loff_t *ppos)
   4680{
   4681	struct lpfc_debug *debug = file->private_data;
   4682	struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
   4683	uint32_t drb_reg_id, value, reg_val = 0;
   4684	void __iomem *drb_reg;
   4685	int rc;
   4686
   4687	/* This is a user write operation */
   4688	debug->op = LPFC_IDIAG_OP_WR;
   4689
   4690	rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
   4691	if (rc < 0)
   4692		return rc;
   4693
   4694	/* Sanity check on command line arguments */
   4695	drb_reg_id = idiag.cmd.data[IDIAG_DRBACC_REGID_INDX];
   4696	value = idiag.cmd.data[IDIAG_DRBACC_VALUE_INDX];
   4697
   4698	if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_WR ||
   4699	    idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_ST ||
   4700	    idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_CL) {
   4701		if (rc != LPFC_DRB_ACC_WR_CMD_ARG)
   4702			goto error_out;
   4703		if (drb_reg_id > LPFC_DRB_MAX)
   4704			goto error_out;
   4705	} else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_RD) {
   4706		if (rc != LPFC_DRB_ACC_RD_CMD_ARG)
   4707			goto error_out;
   4708		if ((drb_reg_id > LPFC_DRB_MAX) &&
   4709		    (drb_reg_id != LPFC_DRB_ACC_ALL))
   4710			goto error_out;
   4711	} else
   4712		goto error_out;
   4713
   4714	/* Perform the write access operation */
   4715	if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_WR ||
   4716	    idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_ST ||
   4717	    idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_CL) {
   4718		switch (drb_reg_id) {
   4719		case LPFC_DRB_EQ:
   4720			drb_reg = phba->sli4_hba.EQDBregaddr;
   4721			break;
   4722		case LPFC_DRB_CQ:
   4723			drb_reg = phba->sli4_hba.CQDBregaddr;
   4724			break;
   4725		case LPFC_DRB_MQ:
   4726			drb_reg = phba->sli4_hba.MQDBregaddr;
   4727			break;
   4728		case LPFC_DRB_WQ:
   4729			drb_reg = phba->sli4_hba.WQDBregaddr;
   4730			break;
   4731		case LPFC_DRB_RQ:
   4732			drb_reg = phba->sli4_hba.RQDBregaddr;
   4733			break;
   4734		default:
   4735			goto error_out;
   4736		}
   4737
   4738		if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_WR)
   4739			reg_val = value;
   4740		if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_ST) {
   4741			reg_val = readl(drb_reg);
   4742			reg_val |= value;
   4743		}
   4744		if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_CL) {
   4745			reg_val = readl(drb_reg);
   4746			reg_val &= ~value;
   4747		}
   4748		writel(reg_val, drb_reg);
   4749		readl(drb_reg); /* flush */
   4750	}
   4751	return nbytes;
   4752
   4753error_out:
   4754	/* Clean out command structure on command error out */
   4755	memset(&idiag, 0, sizeof(idiag));
   4756	return -EINVAL;
   4757}
   4758
   4759/**
   4760 * lpfc_idiag_ctlacc_read_reg - idiag debugfs read a control registers
   4761 * @phba: The pointer to hba structure.
   4762 * @pbuffer: The pointer to the buffer to copy the data to.
   4763 * @len: The length of bytes to copied.
   4764 * @ctlregid: The id to doorbell registers.
   4765 *
   4766 * Description:
   4767 * This routine reads a control register and copies its content to the
   4768 * user buffer pointed to by @pbuffer.
   4769 *
   4770 * Returns:
   4771 * This function returns the amount of data that was copied into @pbuffer.
   4772 **/
   4773static int
   4774lpfc_idiag_ctlacc_read_reg(struct lpfc_hba *phba, char *pbuffer,
   4775			   int len, uint32_t ctlregid)
   4776{
   4777
   4778	if (!pbuffer)
   4779		return 0;
   4780
   4781	switch (ctlregid) {
   4782	case LPFC_CTL_PORT_SEM:
   4783		len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
   4784				"Port SemReg:   0x%08x\n",
   4785				readl(phba->sli4_hba.conf_regs_memmap_p +
   4786				      LPFC_CTL_PORT_SEM_OFFSET));
   4787		break;
   4788	case LPFC_CTL_PORT_STA:
   4789		len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
   4790				"Port StaReg:   0x%08x\n",
   4791				readl(phba->sli4_hba.conf_regs_memmap_p +
   4792				      LPFC_CTL_PORT_STA_OFFSET));
   4793		break;
   4794	case LPFC_CTL_PORT_CTL:
   4795		len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
   4796				"Port CtlReg:   0x%08x\n",
   4797				readl(phba->sli4_hba.conf_regs_memmap_p +
   4798				      LPFC_CTL_PORT_CTL_OFFSET));
   4799		break;
   4800	case LPFC_CTL_PORT_ER1:
   4801		len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
   4802				"Port Er1Reg:   0x%08x\n",
   4803				readl(phba->sli4_hba.conf_regs_memmap_p +
   4804				      LPFC_CTL_PORT_ER1_OFFSET));
   4805		break;
   4806	case LPFC_CTL_PORT_ER2:
   4807		len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
   4808				"Port Er2Reg:   0x%08x\n",
   4809				readl(phba->sli4_hba.conf_regs_memmap_p +
   4810				      LPFC_CTL_PORT_ER2_OFFSET));
   4811		break;
   4812	case LPFC_CTL_PDEV_CTL:
   4813		len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
   4814				"PDev CtlReg:   0x%08x\n",
   4815				readl(phba->sli4_hba.conf_regs_memmap_p +
   4816				      LPFC_CTL_PDEV_CTL_OFFSET));
   4817		break;
   4818	default:
   4819		break;
   4820	}
   4821	return len;
   4822}
   4823
   4824/**
   4825 * lpfc_idiag_ctlacc_read - idiag debugfs read port and device control register
   4826 * @file: The file pointer to read from.
   4827 * @buf: The buffer to copy the data to.
   4828 * @nbytes: The number of bytes to read.
   4829 * @ppos: The position in the file to start reading from.
   4830 *
   4831 * Description:
   4832 * This routine reads data from the @phba port and device registers according
   4833 * to the idiag command, and copies to user @buf.
   4834 *
   4835 * Returns:
   4836 * This function returns the amount of data that was read (this could be less
   4837 * than @nbytes if the end of the file was reached) or a negative error value.
   4838 **/
   4839static ssize_t
   4840lpfc_idiag_ctlacc_read(struct file *file, char __user *buf, size_t nbytes,
   4841		       loff_t *ppos)
   4842{
   4843	struct lpfc_debug *debug = file->private_data;
   4844	struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
   4845	uint32_t ctl_reg_id, i;
   4846	char *pbuffer;
   4847	int len = 0;
   4848
   4849	/* This is a user read operation */
   4850	debug->op = LPFC_IDIAG_OP_RD;
   4851
   4852	if (!debug->buffer)
   4853		debug->buffer = kmalloc(LPFC_CTL_ACC_BUF_SIZE, GFP_KERNEL);
   4854	if (!debug->buffer)
   4855		return 0;
   4856	pbuffer = debug->buffer;
   4857
   4858	if (*ppos)
   4859		return 0;
   4860
   4861	if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_RD)
   4862		ctl_reg_id = idiag.cmd.data[IDIAG_CTLACC_REGID_INDX];
   4863	else
   4864		return 0;
   4865
   4866	if (ctl_reg_id == LPFC_CTL_ACC_ALL)
   4867		for (i = 1; i <= LPFC_CTL_MAX; i++)
   4868			len = lpfc_idiag_ctlacc_read_reg(phba,
   4869							 pbuffer, len, i);
   4870	else
   4871		len = lpfc_idiag_ctlacc_read_reg(phba,
   4872						 pbuffer, len, ctl_reg_id);
   4873
   4874	return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
   4875}
   4876
   4877/**
   4878 * lpfc_idiag_ctlacc_write - Syntax check and set up idiag ctlacc commands
   4879 * @file: The file pointer to read from.
   4880 * @buf: The buffer to copy the user data from.
   4881 * @nbytes: The number of bytes to get.
   4882 * @ppos: The position in the file to start reading from.
   4883 *
   4884 * This routine get the debugfs idiag command struct from user space and then
   4885 * perform the syntax check for port and device control register read (dump)
   4886 * or write (set) command accordingly.
   4887 *
   4888 * It returns the @nbytges passing in from debugfs user space when successful.
   4889 * In case of error conditions, it returns proper error code back to the user
   4890 * space.
   4891 **/
   4892static ssize_t
   4893lpfc_idiag_ctlacc_write(struct file *file, const char __user *buf,
   4894			size_t nbytes, loff_t *ppos)
   4895{
   4896	struct lpfc_debug *debug = file->private_data;
   4897	struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
   4898	uint32_t ctl_reg_id, value, reg_val = 0;
   4899	void __iomem *ctl_reg;
   4900	int rc;
   4901
   4902	/* This is a user write operation */
   4903	debug->op = LPFC_IDIAG_OP_WR;
   4904
   4905	rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
   4906	if (rc < 0)
   4907		return rc;
   4908
   4909	/* Sanity check on command line arguments */
   4910	ctl_reg_id = idiag.cmd.data[IDIAG_CTLACC_REGID_INDX];
   4911	value = idiag.cmd.data[IDIAG_CTLACC_VALUE_INDX];
   4912
   4913	if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_WR ||
   4914	    idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_ST ||
   4915	    idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_CL) {
   4916		if (rc != LPFC_CTL_ACC_WR_CMD_ARG)
   4917			goto error_out;
   4918		if (ctl_reg_id > LPFC_CTL_MAX)
   4919			goto error_out;
   4920	} else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_RD) {
   4921		if (rc != LPFC_CTL_ACC_RD_CMD_ARG)
   4922			goto error_out;
   4923		if ((ctl_reg_id > LPFC_CTL_MAX) &&
   4924		    (ctl_reg_id != LPFC_CTL_ACC_ALL))
   4925			goto error_out;
   4926	} else
   4927		goto error_out;
   4928
   4929	/* Perform the write access operation */
   4930	if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_WR ||
   4931	    idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_ST ||
   4932	    idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_CL) {
   4933		switch (ctl_reg_id) {
   4934		case LPFC_CTL_PORT_SEM:
   4935			ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
   4936					LPFC_CTL_PORT_SEM_OFFSET;
   4937			break;
   4938		case LPFC_CTL_PORT_STA:
   4939			ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
   4940					LPFC_CTL_PORT_STA_OFFSET;
   4941			break;
   4942		case LPFC_CTL_PORT_CTL:
   4943			ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
   4944					LPFC_CTL_PORT_CTL_OFFSET;
   4945			break;
   4946		case LPFC_CTL_PORT_ER1:
   4947			ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
   4948					LPFC_CTL_PORT_ER1_OFFSET;
   4949			break;
   4950		case LPFC_CTL_PORT_ER2:
   4951			ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
   4952					LPFC_CTL_PORT_ER2_OFFSET;
   4953			break;
   4954		case LPFC_CTL_PDEV_CTL:
   4955			ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
   4956					LPFC_CTL_PDEV_CTL_OFFSET;
   4957			break;
   4958		default:
   4959			goto error_out;
   4960		}
   4961
   4962		if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_WR)
   4963			reg_val = value;
   4964		if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_ST) {
   4965			reg_val = readl(ctl_reg);
   4966			reg_val |= value;
   4967		}
   4968		if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_CL) {
   4969			reg_val = readl(ctl_reg);
   4970			reg_val &= ~value;
   4971		}
   4972		writel(reg_val, ctl_reg);
   4973		readl(ctl_reg); /* flush */
   4974	}
   4975	return nbytes;
   4976
   4977error_out:
   4978	/* Clean out command structure on command error out */
   4979	memset(&idiag, 0, sizeof(idiag));
   4980	return -EINVAL;
   4981}
   4982
   4983/**
   4984 * lpfc_idiag_mbxacc_get_setup - idiag debugfs get mailbox access setup
   4985 * @phba: Pointer to HBA context object.
   4986 * @pbuffer: Pointer to data buffer.
   4987 *
   4988 * Description:
   4989 * This routine gets the driver mailbox access debugfs setup information.
   4990 *
   4991 * Returns:
   4992 * This function returns the amount of data that was read (this could be less
   4993 * than @nbytes if the end of the file was reached) or a negative error value.
   4994 **/
   4995static int
   4996lpfc_idiag_mbxacc_get_setup(struct lpfc_hba *phba, char *pbuffer)
   4997{
   4998	uint32_t mbx_dump_map, mbx_dump_cnt, mbx_word_cnt, mbx_mbox_cmd;
   4999	int len = 0;
   5000
   5001	mbx_mbox_cmd = idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX];
   5002	mbx_dump_map = idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX];
   5003	mbx_dump_cnt = idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX];
   5004	mbx_word_cnt = idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX];
   5005
   5006	len += scnprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
   5007			"mbx_dump_map: 0x%08x\n", mbx_dump_map);
   5008	len += scnprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
   5009			"mbx_dump_cnt: %04d\n", mbx_dump_cnt);
   5010	len += scnprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
   5011			"mbx_word_cnt: %04d\n", mbx_word_cnt);
   5012	len += scnprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
   5013			"mbx_mbox_cmd: 0x%02x\n", mbx_mbox_cmd);
   5014
   5015	return len;
   5016}
   5017
   5018/**
   5019 * lpfc_idiag_mbxacc_read - idiag debugfs read on mailbox access
   5020 * @file: The file pointer to read from.
   5021 * @buf: The buffer to copy the data to.
   5022 * @nbytes: The number of bytes to read.
   5023 * @ppos: The position in the file to start reading from.
   5024 *
   5025 * Description:
   5026 * This routine reads data from the @phba driver mailbox access debugfs setup
   5027 * information.
   5028 *
   5029 * Returns:
   5030 * This function returns the amount of data that was read (this could be less
   5031 * than @nbytes if the end of the file was reached) or a negative error value.
   5032 **/
   5033static ssize_t
   5034lpfc_idiag_mbxacc_read(struct file *file, char __user *buf, size_t nbytes,
   5035		       loff_t *ppos)
   5036{
   5037	struct lpfc_debug *debug = file->private_data;
   5038	struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
   5039	char *pbuffer;
   5040	int len = 0;
   5041
   5042	/* This is a user read operation */
   5043	debug->op = LPFC_IDIAG_OP_RD;
   5044
   5045	if (!debug->buffer)
   5046		debug->buffer = kmalloc(LPFC_MBX_ACC_BUF_SIZE, GFP_KERNEL);
   5047	if (!debug->buffer)
   5048		return 0;
   5049	pbuffer = debug->buffer;
   5050
   5051	if (*ppos)
   5052		return 0;
   5053
   5054	if ((idiag.cmd.opcode != LPFC_IDIAG_CMD_MBXACC_DP) &&
   5055	    (idiag.cmd.opcode != LPFC_IDIAG_BSG_MBXACC_DP))
   5056		return 0;
   5057
   5058	len = lpfc_idiag_mbxacc_get_setup(phba, pbuffer);
   5059
   5060	return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
   5061}
   5062
   5063/**
   5064 * lpfc_idiag_mbxacc_write - Syntax check and set up idiag mbxacc commands
   5065 * @file: The file pointer to read from.
   5066 * @buf: The buffer to copy the user data from.
   5067 * @nbytes: The number of bytes to get.
   5068 * @ppos: The position in the file to start reading from.
   5069 *
   5070 * This routine get the debugfs idiag command struct from user space and then
   5071 * perform the syntax check for driver mailbox command (dump) and sets up the
   5072 * necessary states in the idiag command struct accordingly.
   5073 *
   5074 * It returns the @nbytges passing in from debugfs user space when successful.
   5075 * In case of error conditions, it returns proper error code back to the user
   5076 * space.
   5077 **/
   5078static ssize_t
   5079lpfc_idiag_mbxacc_write(struct file *file, const char __user *buf,
   5080			size_t nbytes, loff_t *ppos)
   5081{
   5082	struct lpfc_debug *debug = file->private_data;
   5083	uint32_t mbx_dump_map, mbx_dump_cnt, mbx_word_cnt, mbx_mbox_cmd;
   5084	int rc;
   5085
   5086	/* This is a user write operation */
   5087	debug->op = LPFC_IDIAG_OP_WR;
   5088
   5089	rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
   5090	if (rc < 0)
   5091		return rc;
   5092
   5093	/* Sanity check on command line arguments */
   5094	mbx_mbox_cmd = idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX];
   5095	mbx_dump_map = idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX];
   5096	mbx_dump_cnt = idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX];
   5097	mbx_word_cnt = idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX];
   5098
   5099	if (idiag.cmd.opcode == LPFC_IDIAG_CMD_MBXACC_DP) {
   5100		if (!(mbx_dump_map & LPFC_MBX_DMP_MBX_ALL))
   5101			goto error_out;
   5102		if ((mbx_dump_map & ~LPFC_MBX_DMP_MBX_ALL) &&
   5103		    (mbx_dump_map != LPFC_MBX_DMP_ALL))
   5104			goto error_out;
   5105		if (mbx_word_cnt > sizeof(MAILBOX_t))
   5106			goto error_out;
   5107	} else if (idiag.cmd.opcode == LPFC_IDIAG_BSG_MBXACC_DP) {
   5108		if (!(mbx_dump_map & LPFC_BSG_DMP_MBX_ALL))
   5109			goto error_out;
   5110		if ((mbx_dump_map & ~LPFC_BSG_DMP_MBX_ALL) &&
   5111		    (mbx_dump_map != LPFC_MBX_DMP_ALL))
   5112			goto error_out;
   5113		if (mbx_word_cnt > (BSG_MBOX_SIZE)/4)
   5114			goto error_out;
   5115		if (mbx_mbox_cmd != 0x9b)
   5116			goto error_out;
   5117	} else
   5118		goto error_out;
   5119
   5120	if (mbx_word_cnt == 0)
   5121		goto error_out;
   5122	if (rc != LPFC_MBX_DMP_ARG)
   5123		goto error_out;
   5124	if (mbx_mbox_cmd & ~0xff)
   5125		goto error_out;
   5126
   5127	/* condition for stop mailbox dump */
   5128	if (mbx_dump_cnt == 0)
   5129		goto reset_out;
   5130
   5131	return nbytes;
   5132
   5133reset_out:
   5134	/* Clean out command structure on command error out */
   5135	memset(&idiag, 0, sizeof(idiag));
   5136	return nbytes;
   5137
   5138error_out:
   5139	/* Clean out command structure on command error out */
   5140	memset(&idiag, 0, sizeof(idiag));
   5141	return -EINVAL;
   5142}
   5143
   5144/**
   5145 * lpfc_idiag_extacc_avail_get - get the available extents information
   5146 * @phba: pointer to lpfc hba data structure.
   5147 * @pbuffer: pointer to internal buffer.
   5148 * @len: length into the internal buffer data has been copied.
   5149 *
   5150 * Description:
   5151 * This routine is to get the available extent information.
   5152 *
   5153 * Returns:
   5154 * overall length of the data read into the internal buffer.
   5155 **/
   5156static int
   5157lpfc_idiag_extacc_avail_get(struct lpfc_hba *phba, char *pbuffer, int len)
   5158{
   5159	uint16_t ext_cnt, ext_size;
   5160
   5161	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5162			"\nAvailable Extents Information:\n");
   5163
   5164	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5165			"\tPort Available VPI extents: ");
   5166	lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_VPI,
   5167				       &ext_cnt, &ext_size);
   5168	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5169			"Count %3d, Size %3d\n", ext_cnt, ext_size);
   5170
   5171	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5172			"\tPort Available VFI extents: ");
   5173	lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_VFI,
   5174				       &ext_cnt, &ext_size);
   5175	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5176			"Count %3d, Size %3d\n", ext_cnt, ext_size);
   5177
   5178	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5179			"\tPort Available RPI extents: ");
   5180	lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_RPI,
   5181				       &ext_cnt, &ext_size);
   5182	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5183			"Count %3d, Size %3d\n", ext_cnt, ext_size);
   5184
   5185	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5186			"\tPort Available XRI extents: ");
   5187	lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_XRI,
   5188				       &ext_cnt, &ext_size);
   5189	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5190			"Count %3d, Size %3d\n", ext_cnt, ext_size);
   5191
   5192	return len;
   5193}
   5194
   5195/**
   5196 * lpfc_idiag_extacc_alloc_get - get the allocated extents information
   5197 * @phba: pointer to lpfc hba data structure.
   5198 * @pbuffer: pointer to internal buffer.
   5199 * @len: length into the internal buffer data has been copied.
   5200 *
   5201 * Description:
   5202 * This routine is to get the allocated extent information.
   5203 *
   5204 * Returns:
   5205 * overall length of the data read into the internal buffer.
   5206 **/
   5207static int
   5208lpfc_idiag_extacc_alloc_get(struct lpfc_hba *phba, char *pbuffer, int len)
   5209{
   5210	uint16_t ext_cnt, ext_size;
   5211	int rc;
   5212
   5213	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5214			"\nAllocated Extents Information:\n");
   5215
   5216	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5217			"\tHost Allocated VPI extents: ");
   5218	rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_VPI,
   5219					    &ext_cnt, &ext_size);
   5220	if (!rc)
   5221		len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5222				"Port %d Extent %3d, Size %3d\n",
   5223				phba->brd_no, ext_cnt, ext_size);
   5224	else
   5225		len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5226				"N/A\n");
   5227
   5228	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5229			"\tHost Allocated VFI extents: ");
   5230	rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_VFI,
   5231					    &ext_cnt, &ext_size);
   5232	if (!rc)
   5233		len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5234				"Port %d Extent %3d, Size %3d\n",
   5235				phba->brd_no, ext_cnt, ext_size);
   5236	else
   5237		len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5238				"N/A\n");
   5239
   5240	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5241			"\tHost Allocated RPI extents: ");
   5242	rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_RPI,
   5243					    &ext_cnt, &ext_size);
   5244	if (!rc)
   5245		len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5246				"Port %d Extent %3d, Size %3d\n",
   5247				phba->brd_no, ext_cnt, ext_size);
   5248	else
   5249		len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5250				"N/A\n");
   5251
   5252	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5253			"\tHost Allocated XRI extents: ");
   5254	rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_XRI,
   5255					    &ext_cnt, &ext_size);
   5256	if (!rc)
   5257		len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5258				"Port %d Extent %3d, Size %3d\n",
   5259				phba->brd_no, ext_cnt, ext_size);
   5260	else
   5261		len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5262				"N/A\n");
   5263
   5264	return len;
   5265}
   5266
   5267/**
   5268 * lpfc_idiag_extacc_drivr_get - get driver extent information
   5269 * @phba: pointer to lpfc hba data structure.
   5270 * @pbuffer: pointer to internal buffer.
   5271 * @len: length into the internal buffer data has been copied.
   5272 *
   5273 * Description:
   5274 * This routine is to get the driver extent information.
   5275 *
   5276 * Returns:
   5277 * overall length of the data read into the internal buffer.
   5278 **/
   5279static int
   5280lpfc_idiag_extacc_drivr_get(struct lpfc_hba *phba, char *pbuffer, int len)
   5281{
   5282	struct lpfc_rsrc_blks *rsrc_blks;
   5283	int index;
   5284
   5285	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5286			"\nDriver Extents Information:\n");
   5287
   5288	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5289			"\tVPI extents:\n");
   5290	index = 0;
   5291	list_for_each_entry(rsrc_blks, &phba->lpfc_vpi_blk_list, list) {
   5292		len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5293				"\t\tBlock %3d: Start %4d, Count %4d\n",
   5294				index, rsrc_blks->rsrc_start,
   5295				rsrc_blks->rsrc_size);
   5296		index++;
   5297	}
   5298	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5299			"\tVFI extents:\n");
   5300	index = 0;
   5301	list_for_each_entry(rsrc_blks, &phba->sli4_hba.lpfc_vfi_blk_list,
   5302			    list) {
   5303		len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5304				"\t\tBlock %3d: Start %4d, Count %4d\n",
   5305				index, rsrc_blks->rsrc_start,
   5306				rsrc_blks->rsrc_size);
   5307		index++;
   5308	}
   5309
   5310	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5311			"\tRPI extents:\n");
   5312	index = 0;
   5313	list_for_each_entry(rsrc_blks, &phba->sli4_hba.lpfc_rpi_blk_list,
   5314			    list) {
   5315		len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5316				"\t\tBlock %3d: Start %4d, Count %4d\n",
   5317				index, rsrc_blks->rsrc_start,
   5318				rsrc_blks->rsrc_size);
   5319		index++;
   5320	}
   5321
   5322	len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5323			"\tXRI extents:\n");
   5324	index = 0;
   5325	list_for_each_entry(rsrc_blks, &phba->sli4_hba.lpfc_xri_blk_list,
   5326			    list) {
   5327		len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
   5328				"\t\tBlock %3d: Start %4d, Count %4d\n",
   5329				index, rsrc_blks->rsrc_start,
   5330				rsrc_blks->rsrc_size);
   5331		index++;
   5332	}
   5333
   5334	return len;
   5335}
   5336
   5337/**
   5338 * lpfc_idiag_extacc_write - Syntax check and set up idiag extacc commands
   5339 * @file: The file pointer to read from.
   5340 * @buf: The buffer to copy the user data from.
   5341 * @nbytes: The number of bytes to get.
   5342 * @ppos: The position in the file to start reading from.
   5343 *
   5344 * This routine get the debugfs idiag command struct from user space and then
   5345 * perform the syntax check for extent information access commands and sets
   5346 * up the necessary states in the idiag command struct accordingly.
   5347 *
   5348 * It returns the @nbytges passing in from debugfs user space when successful.
   5349 * In case of error conditions, it returns proper error code back to the user
   5350 * space.
   5351 **/
   5352static ssize_t
   5353lpfc_idiag_extacc_write(struct file *file, const char __user *buf,
   5354			size_t nbytes, loff_t *ppos)
   5355{
   5356	struct lpfc_debug *debug = file->private_data;
   5357	uint32_t ext_map;
   5358	int rc;
   5359
   5360	/* This is a user write operation */
   5361	debug->op = LPFC_IDIAG_OP_WR;
   5362
   5363	rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
   5364	if (rc < 0)
   5365		return rc;
   5366
   5367	ext_map = idiag.cmd.data[IDIAG_EXTACC_EXMAP_INDX];
   5368
   5369	if (idiag.cmd.opcode != LPFC_IDIAG_CMD_EXTACC_RD)
   5370		goto error_out;
   5371	if (rc != LPFC_EXT_ACC_CMD_ARG)
   5372		goto error_out;
   5373	if (!(ext_map & LPFC_EXT_ACC_ALL))
   5374		goto error_out;
   5375
   5376	return nbytes;
   5377error_out:
   5378	/* Clean out command structure on command error out */
   5379	memset(&idiag, 0, sizeof(idiag));
   5380	return -EINVAL;
   5381}
   5382
   5383/**
   5384 * lpfc_idiag_extacc_read - idiag debugfs read access to extent information
   5385 * @file: The file pointer to read from.
   5386 * @buf: The buffer to copy the data to.
   5387 * @nbytes: The number of bytes to read.
   5388 * @ppos: The position in the file to start reading from.
   5389 *
   5390 * Description:
   5391 * This routine reads data from the proper extent information according to
   5392 * the idiag command, and copies to user @buf.
   5393 *
   5394 * Returns:
   5395 * This function returns the amount of data that was read (this could be less
   5396 * than @nbytes if the end of the file was reached) or a negative error value.
   5397 **/
   5398static ssize_t
   5399lpfc_idiag_extacc_read(struct file *file, char __user *buf, size_t nbytes,
   5400		       loff_t *ppos)
   5401{
   5402	struct lpfc_debug *debug = file->private_data;
   5403	struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
   5404	char *pbuffer;
   5405	uint32_t ext_map;
   5406	int len = 0;
   5407
   5408	/* This is a user read operation */
   5409	debug->op = LPFC_IDIAG_OP_RD;
   5410
   5411	if (!debug->buffer)
   5412		debug->buffer = kmalloc(LPFC_EXT_ACC_BUF_SIZE, GFP_KERNEL);
   5413	if (!debug->buffer)
   5414		return 0;
   5415	pbuffer = debug->buffer;
   5416	if (*ppos)
   5417		return 0;
   5418	if (idiag.cmd.opcode != LPFC_IDIAG_CMD_EXTACC_RD)
   5419		return 0;
   5420
   5421	ext_map = idiag.cmd.data[IDIAG_EXTACC_EXMAP_INDX];
   5422	if (ext_map & LPFC_EXT_ACC_AVAIL)
   5423		len = lpfc_idiag_extacc_avail_get(phba, pbuffer, len);
   5424	if (ext_map & LPFC_EXT_ACC_ALLOC)
   5425		len = lpfc_idiag_extacc_alloc_get(phba, pbuffer, len);
   5426	if (ext_map & LPFC_EXT_ACC_DRIVR)
   5427		len = lpfc_idiag_extacc_drivr_get(phba, pbuffer, len);
   5428
   5429	return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
   5430}
   5431
   5432static int
   5433lpfc_cgn_buffer_open(struct inode *inode, struct file *file)
   5434{
   5435	struct lpfc_debug *debug;
   5436	int rc = -ENOMEM;
   5437
   5438	debug = kmalloc(sizeof(*debug), GFP_KERNEL);
   5439	if (!debug)
   5440		goto out;
   5441
   5442	debug->buffer = vmalloc(LPFC_CGN_BUF_SIZE);
   5443	if (!debug->buffer) {
   5444		kfree(debug);
   5445		goto out;
   5446	}
   5447
   5448	debug->i_private = inode->i_private;
   5449	file->private_data = debug;
   5450
   5451	rc = 0;
   5452out:
   5453	return rc;
   5454}
   5455
   5456static ssize_t
   5457lpfc_cgn_buffer_read(struct file *file, char __user *buf, size_t nbytes,
   5458		     loff_t *ppos)
   5459{
   5460	struct lpfc_debug *debug = file->private_data;
   5461	struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
   5462	char *buffer = debug->buffer;
   5463	uint32_t *ptr;
   5464	int cnt, len = 0;
   5465
   5466	if (!phba->sli4_hba.pc_sli4_params.mi_ver || !phba->cgn_i) {
   5467		len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
   5468				 "Congestion Mgmt is not supported\n");
   5469		goto out;
   5470	}
   5471	ptr = (uint32_t *)phba->cgn_i->virt;
   5472	len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
   5473			 "Congestion Buffer Header\n");
   5474	/* Dump the first 32 bytes */
   5475	cnt = 32;
   5476	len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
   5477			 "000: %08x %08x %08x %08x %08x %08x %08x %08x\n",
   5478			 *ptr, *(ptr + 1), *(ptr + 2), *(ptr + 3),
   5479			 *(ptr + 4), *(ptr + 5), *(ptr + 6), *(ptr + 7));
   5480	ptr += 8;
   5481	len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
   5482			 "Congestion Buffer Data\n");
   5483	while (cnt < sizeof(struct lpfc_cgn_info)) {
   5484		if (len > (LPFC_CGN_BUF_SIZE - LPFC_DEBUG_OUT_LINE_SZ)) {
   5485			len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
   5486					 "Truncated . . .\n");
   5487			goto out;
   5488		}
   5489		len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
   5490				 "%03x: %08x %08x %08x %08x "
   5491				 "%08x %08x %08x %08x\n",
   5492				 cnt, *ptr, *(ptr + 1), *(ptr + 2),
   5493				 *(ptr + 3), *(ptr + 4), *(ptr + 5),
   5494				 *(ptr + 6), *(ptr + 7));
   5495		cnt += 32;
   5496		ptr += 8;
   5497	}
   5498	if (len > (LPFC_CGN_BUF_SIZE - LPFC_DEBUG_OUT_LINE_SZ)) {
   5499		len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
   5500				 "Truncated . . .\n");
   5501		goto out;
   5502	}
   5503	len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
   5504			 "Parameter Data\n");
   5505	ptr = (uint32_t *)&phba->cgn_p;
   5506	len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
   5507			 "%08x %08x %08x %08x\n",
   5508			 *ptr, *(ptr + 1), *(ptr + 2), *(ptr + 3));
   5509out:
   5510	return simple_read_from_buffer(buf, nbytes, ppos, buffer, len);
   5511}
   5512
   5513static int
   5514lpfc_cgn_buffer_release(struct inode *inode, struct file *file)
   5515{
   5516	struct lpfc_debug *debug = file->private_data;
   5517
   5518	vfree(debug->buffer);
   5519	kfree(debug);
   5520
   5521	return 0;
   5522}
   5523
   5524static int
   5525lpfc_rx_monitor_open(struct inode *inode, struct file *file)
   5526{
   5527	struct lpfc_rx_monitor_debug *debug;
   5528	int rc = -ENOMEM;
   5529
   5530	debug = kmalloc(sizeof(*debug), GFP_KERNEL);
   5531	if (!debug)
   5532		goto out;
   5533
   5534	debug->buffer = vmalloc(MAX_DEBUGFS_RX_TABLE_SIZE);
   5535	if (!debug->buffer) {
   5536		kfree(debug);
   5537		goto out;
   5538	}
   5539
   5540	debug->i_private = inode->i_private;
   5541	file->private_data = debug;
   5542
   5543	rc = 0;
   5544out:
   5545	return rc;
   5546}
   5547
   5548static ssize_t
   5549lpfc_rx_monitor_read(struct file *file, char __user *buf, size_t nbytes,
   5550		     loff_t *ppos)
   5551{
   5552	struct lpfc_rx_monitor_debug *debug = file->private_data;
   5553	struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
   5554	char *buffer = debug->buffer;
   5555	struct rxtable_entry *entry;
   5556	int i, len = 0, head, tail, last, start;
   5557
   5558	head = atomic_read(&phba->rxtable_idx_head);
   5559	while (head == LPFC_RXMONITOR_TABLE_IN_USE) {
   5560		/* Table is getting updated */
   5561		msleep(20);
   5562		head = atomic_read(&phba->rxtable_idx_head);
   5563	}
   5564
   5565	tail = atomic_xchg(&phba->rxtable_idx_tail, head);
   5566	if (!phba->rxtable || head == tail) {
   5567		len += scnprintf(buffer + len, MAX_DEBUGFS_RX_TABLE_SIZE - len,
   5568				"Rxtable is empty\n");
   5569		goto out;
   5570	}
   5571	last = (head > tail) ?  head : LPFC_MAX_RXMONITOR_ENTRY;
   5572	start = tail;
   5573
   5574	len += scnprintf(buffer + len, MAX_DEBUGFS_RX_TABLE_SIZE - len,
   5575			"        MaxBPI    Tot_Data_CMF Tot_Data_Cmd "
   5576			"Tot_Data_Cmpl  Lat(us)  Avg_IO  Max_IO "
   5577			"Bsy IO_cnt Info BWutil(ms)\n");
   5578get_table:
   5579	for (i = start; i < last; i++) {
   5580		entry = &phba->rxtable[i];
   5581		len += scnprintf(buffer + len, MAX_DEBUGFS_RX_TABLE_SIZE - len,
   5582				"%3d:%12lld %12lld %12lld %12lld "
   5583				"%7lldus %8lld %7lld "
   5584				"%2d   %4d   %2d   %2d(%2d)\n",
   5585				i, entry->max_bytes_per_interval,
   5586				entry->cmf_bytes,
   5587				entry->total_bytes,
   5588				entry->rcv_bytes,
   5589				entry->avg_io_latency,
   5590				entry->avg_io_size,
   5591				entry->max_read_cnt,
   5592				entry->cmf_busy,
   5593				entry->io_cnt,
   5594				entry->cmf_info,
   5595				entry->timer_utilization,
   5596				entry->timer_interval);
   5597	}
   5598
   5599	if (head != last) {
   5600		start = 0;
   5601		last = head;
   5602		goto get_table;
   5603	}
   5604out:
   5605	return simple_read_from_buffer(buf, nbytes, ppos, buffer, len);
   5606}
   5607
   5608static int
   5609lpfc_rx_monitor_release(struct inode *inode, struct file *file)
   5610{
   5611	struct lpfc_rx_monitor_debug *debug = file->private_data;
   5612
   5613	vfree(debug->buffer);
   5614	kfree(debug);
   5615
   5616	return 0;
   5617}
   5618
   5619#undef lpfc_debugfs_op_disc_trc
   5620static const struct file_operations lpfc_debugfs_op_disc_trc = {
   5621	.owner =        THIS_MODULE,
   5622	.open =         lpfc_debugfs_disc_trc_open,
   5623	.llseek =       lpfc_debugfs_lseek,
   5624	.read =         lpfc_debugfs_read,
   5625	.release =      lpfc_debugfs_release,
   5626};
   5627
   5628#undef lpfc_debugfs_op_nodelist
   5629static const struct file_operations lpfc_debugfs_op_nodelist = {
   5630	.owner =        THIS_MODULE,
   5631	.open =         lpfc_debugfs_nodelist_open,
   5632	.llseek =       lpfc_debugfs_lseek,
   5633	.read =         lpfc_debugfs_read,
   5634	.release =      lpfc_debugfs_release,
   5635};
   5636
   5637#undef lpfc_debugfs_op_multixripools
   5638static const struct file_operations lpfc_debugfs_op_multixripools = {
   5639	.owner =        THIS_MODULE,
   5640	.open =         lpfc_debugfs_multixripools_open,
   5641	.llseek =       lpfc_debugfs_lseek,
   5642	.read =         lpfc_debugfs_read,
   5643	.write =	lpfc_debugfs_multixripools_write,
   5644	.release =      lpfc_debugfs_release,
   5645};
   5646
   5647#undef lpfc_debugfs_op_hbqinfo
   5648static const struct file_operations lpfc_debugfs_op_hbqinfo = {
   5649	.owner =        THIS_MODULE,
   5650	.open =         lpfc_debugfs_hbqinfo_open,
   5651	.llseek =       lpfc_debugfs_lseek,
   5652	.read =         lpfc_debugfs_read,
   5653	.release =      lpfc_debugfs_release,
   5654};
   5655
   5656#ifdef LPFC_HDWQ_LOCK_STAT
   5657#undef lpfc_debugfs_op_lockstat
   5658static const struct file_operations lpfc_debugfs_op_lockstat = {
   5659	.owner =        THIS_MODULE,
   5660	.open =         lpfc_debugfs_lockstat_open,
   5661	.llseek =       lpfc_debugfs_lseek,
   5662	.read =         lpfc_debugfs_read,
   5663	.write =        lpfc_debugfs_lockstat_write,
   5664	.release =      lpfc_debugfs_release,
   5665};
   5666#endif
   5667
   5668#undef lpfc_debugfs_ras_log
   5669static const struct file_operations lpfc_debugfs_ras_log = {
   5670	.owner =        THIS_MODULE,
   5671	.open =         lpfc_debugfs_ras_log_open,
   5672	.llseek =       lpfc_debugfs_lseek,
   5673	.read =         lpfc_debugfs_read,
   5674	.release =      lpfc_debugfs_ras_log_release,
   5675};
   5676
   5677#undef lpfc_debugfs_op_dumpHBASlim
   5678static const struct file_operations lpfc_debugfs_op_dumpHBASlim = {
   5679	.owner =        THIS_MODULE,
   5680	.open =         lpfc_debugfs_dumpHBASlim_open,
   5681	.llseek =       lpfc_debugfs_lseek,
   5682	.read =         lpfc_debugfs_read,
   5683	.release =      lpfc_debugfs_release,
   5684};
   5685
   5686#undef lpfc_debugfs_op_dumpHostSlim
   5687static const struct file_operations lpfc_debugfs_op_dumpHostSlim = {
   5688	.owner =        THIS_MODULE,
   5689	.open =         lpfc_debugfs_dumpHostSlim_open,
   5690	.llseek =       lpfc_debugfs_lseek,
   5691	.read =         lpfc_debugfs_read,
   5692	.release =      lpfc_debugfs_release,
   5693};
   5694
   5695#undef lpfc_debugfs_op_nvmestat
   5696static const struct file_operations lpfc_debugfs_op_nvmestat = {
   5697	.owner =        THIS_MODULE,
   5698	.open =         lpfc_debugfs_nvmestat_open,
   5699	.llseek =       lpfc_debugfs_lseek,
   5700	.read =         lpfc_debugfs_read,
   5701	.write =	lpfc_debugfs_nvmestat_write,
   5702	.release =      lpfc_debugfs_release,
   5703};
   5704
   5705#undef lpfc_debugfs_op_scsistat
   5706static const struct file_operations lpfc_debugfs_op_scsistat = {
   5707	.owner =        THIS_MODULE,
   5708	.open =         lpfc_debugfs_scsistat_open,
   5709	.llseek =       lpfc_debugfs_lseek,
   5710	.read =         lpfc_debugfs_read,
   5711	.write =	lpfc_debugfs_scsistat_write,
   5712	.release =      lpfc_debugfs_release,
   5713};
   5714
   5715#undef lpfc_debugfs_op_ioktime
   5716static const struct file_operations lpfc_debugfs_op_ioktime = {
   5717	.owner =        THIS_MODULE,
   5718	.open =         lpfc_debugfs_ioktime_open,
   5719	.llseek =       lpfc_debugfs_lseek,
   5720	.read =         lpfc_debugfs_read,
   5721	.write =	lpfc_debugfs_ioktime_write,
   5722	.release =      lpfc_debugfs_release,
   5723};
   5724
   5725#undef lpfc_debugfs_op_nvmeio_trc
   5726static const struct file_operations lpfc_debugfs_op_nvmeio_trc = {
   5727	.owner =        THIS_MODULE,
   5728	.open =         lpfc_debugfs_nvmeio_trc_open,
   5729	.llseek =       lpfc_debugfs_lseek,
   5730	.read =         lpfc_debugfs_read,
   5731	.write =	lpfc_debugfs_nvmeio_trc_write,
   5732	.release =      lpfc_debugfs_release,
   5733};
   5734
   5735#undef lpfc_debugfs_op_hdwqstat
   5736static const struct file_operations lpfc_debugfs_op_hdwqstat = {
   5737	.owner =        THIS_MODULE,
   5738	.open =         lpfc_debugfs_hdwqstat_open,
   5739	.llseek =       lpfc_debugfs_lseek,
   5740	.read =         lpfc_debugfs_read,
   5741	.write =	lpfc_debugfs_hdwqstat_write,
   5742	.release =      lpfc_debugfs_release,
   5743};
   5744
   5745#undef lpfc_debugfs_op_dif_err
   5746static const struct file_operations lpfc_debugfs_op_dif_err = {
   5747	.owner =	THIS_MODULE,
   5748	.open =		simple_open,
   5749	.llseek =	lpfc_debugfs_lseek,
   5750	.read =		lpfc_debugfs_dif_err_read,
   5751	.write =	lpfc_debugfs_dif_err_write,
   5752	.release =	lpfc_debugfs_dif_err_release,
   5753};
   5754
   5755#undef lpfc_debugfs_op_slow_ring_trc
   5756static const struct file_operations lpfc_debugfs_op_slow_ring_trc = {
   5757	.owner =        THIS_MODULE,
   5758	.open =         lpfc_debugfs_slow_ring_trc_open,
   5759	.llseek =       lpfc_debugfs_lseek,
   5760	.read =         lpfc_debugfs_read,
   5761	.release =      lpfc_debugfs_release,
   5762};
   5763
   5764static struct dentry *lpfc_debugfs_root = NULL;
   5765static atomic_t lpfc_debugfs_hba_count;
   5766
   5767/*
   5768 * File operations for the iDiag debugfs
   5769 */
   5770#undef lpfc_idiag_op_pciCfg
   5771static const struct file_operations lpfc_idiag_op_pciCfg = {
   5772	.owner =        THIS_MODULE,
   5773	.open =         lpfc_idiag_open,
   5774	.llseek =       lpfc_debugfs_lseek,
   5775	.read =         lpfc_idiag_pcicfg_read,
   5776	.write =        lpfc_idiag_pcicfg_write,
   5777	.release =      lpfc_idiag_cmd_release,
   5778};
   5779
   5780#undef lpfc_idiag_op_barAcc
   5781static const struct file_operations lpfc_idiag_op_barAcc = {
   5782	.owner =        THIS_MODULE,
   5783	.open =         lpfc_idiag_open,
   5784	.llseek =       lpfc_debugfs_lseek,
   5785	.read =         lpfc_idiag_baracc_read,
   5786	.write =        lpfc_idiag_baracc_write,
   5787	.release =      lpfc_idiag_cmd_release,
   5788};
   5789
   5790#undef lpfc_idiag_op_queInfo
   5791static const struct file_operations lpfc_idiag_op_queInfo = {
   5792	.owner =        THIS_MODULE,
   5793	.open =         lpfc_idiag_open,
   5794	.read =         lpfc_idiag_queinfo_read,
   5795	.release =      lpfc_idiag_release,
   5796};
   5797
   5798#undef lpfc_idiag_op_queAcc
   5799static const struct file_operations lpfc_idiag_op_queAcc = {
   5800	.owner =        THIS_MODULE,
   5801	.open =         lpfc_idiag_open,
   5802	.llseek =       lpfc_debugfs_lseek,
   5803	.read =         lpfc_idiag_queacc_read,
   5804	.write =        lpfc_idiag_queacc_write,
   5805	.release =      lpfc_idiag_cmd_release,
   5806};
   5807
   5808#undef lpfc_idiag_op_drbAcc
   5809static const struct file_operations lpfc_idiag_op_drbAcc = {
   5810	.owner =        THIS_MODULE,
   5811	.open =         lpfc_idiag_open,
   5812	.llseek =       lpfc_debugfs_lseek,
   5813	.read =         lpfc_idiag_drbacc_read,
   5814	.write =        lpfc_idiag_drbacc_write,
   5815	.release =      lpfc_idiag_cmd_release,
   5816};
   5817
   5818#undef lpfc_idiag_op_ctlAcc
   5819static const struct file_operations lpfc_idiag_op_ctlAcc = {
   5820	.owner =        THIS_MODULE,
   5821	.open =         lpfc_idiag_open,
   5822	.llseek =       lpfc_debugfs_lseek,
   5823	.read =         lpfc_idiag_ctlacc_read,
   5824	.write =        lpfc_idiag_ctlacc_write,
   5825	.release =      lpfc_idiag_cmd_release,
   5826};
   5827
   5828#undef lpfc_idiag_op_mbxAcc
   5829static const struct file_operations lpfc_idiag_op_mbxAcc = {
   5830	.owner =        THIS_MODULE,
   5831	.open =         lpfc_idiag_open,
   5832	.llseek =       lpfc_debugfs_lseek,
   5833	.read =         lpfc_idiag_mbxacc_read,
   5834	.write =        lpfc_idiag_mbxacc_write,
   5835	.release =      lpfc_idiag_cmd_release,
   5836};
   5837
   5838#undef lpfc_idiag_op_extAcc
   5839static const struct file_operations lpfc_idiag_op_extAcc = {
   5840	.owner =        THIS_MODULE,
   5841	.open =         lpfc_idiag_open,
   5842	.llseek =       lpfc_debugfs_lseek,
   5843	.read =         lpfc_idiag_extacc_read,
   5844	.write =        lpfc_idiag_extacc_write,
   5845	.release =      lpfc_idiag_cmd_release,
   5846};
   5847#undef lpfc_cgn_buffer_op
   5848static const struct file_operations lpfc_cgn_buffer_op = {
   5849	.owner =        THIS_MODULE,
   5850	.open =         lpfc_cgn_buffer_open,
   5851	.llseek =       lpfc_debugfs_lseek,
   5852	.read =         lpfc_cgn_buffer_read,
   5853	.release =      lpfc_cgn_buffer_release,
   5854};
   5855
   5856#undef lpfc_rx_monitor_op
   5857static const struct file_operations lpfc_rx_monitor_op = {
   5858	.owner =        THIS_MODULE,
   5859	.open =         lpfc_rx_monitor_open,
   5860	.llseek =       lpfc_debugfs_lseek,
   5861	.read =         lpfc_rx_monitor_read,
   5862	.release =      lpfc_rx_monitor_release,
   5863};
   5864#endif
   5865
   5866/* lpfc_idiag_mbxacc_dump_bsg_mbox - idiag debugfs dump bsg mailbox command
   5867 * @phba: Pointer to HBA context object.
   5868 * @dmabuf: Pointer to a DMA buffer descriptor.
   5869 *
   5870 * Description:
   5871 * This routine dump a bsg pass-through non-embedded mailbox command with
   5872 * external buffer.
   5873 **/
   5874void
   5875lpfc_idiag_mbxacc_dump_bsg_mbox(struct lpfc_hba *phba, enum nemb_type nemb_tp,
   5876				enum mbox_type mbox_tp, enum dma_type dma_tp,
   5877				enum sta_type sta_tp,
   5878				struct lpfc_dmabuf *dmabuf, uint32_t ext_buf)
   5879{
   5880#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
   5881	uint32_t *mbx_mbox_cmd, *mbx_dump_map, *mbx_dump_cnt, *mbx_word_cnt;
   5882	char line_buf[LPFC_MBX_ACC_LBUF_SZ];
   5883	int len = 0;
   5884	uint32_t do_dump = 0;
   5885	uint32_t *pword;
   5886	uint32_t i;
   5887
   5888	if (idiag.cmd.opcode != LPFC_IDIAG_BSG_MBXACC_DP)
   5889		return;
   5890
   5891	mbx_mbox_cmd = &idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX];
   5892	mbx_dump_map = &idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX];
   5893	mbx_dump_cnt = &idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX];
   5894	mbx_word_cnt = &idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX];
   5895
   5896	if (!(*mbx_dump_map & LPFC_MBX_DMP_ALL) ||
   5897	    (*mbx_dump_cnt == 0) ||
   5898	    (*mbx_word_cnt == 0))
   5899		return;
   5900
   5901	if (*mbx_mbox_cmd != 0x9B)
   5902		return;
   5903
   5904	if ((mbox_tp == mbox_rd) && (dma_tp == dma_mbox)) {
   5905		if (*mbx_dump_map & LPFC_BSG_DMP_MBX_RD_MBX) {
   5906			do_dump |= LPFC_BSG_DMP_MBX_RD_MBX;
   5907			pr_err("\nRead mbox command (x%x), "
   5908			       "nemb:0x%x, extbuf_cnt:%d:\n",
   5909			       sta_tp, nemb_tp, ext_buf);
   5910		}
   5911	}
   5912	if ((mbox_tp == mbox_rd) && (dma_tp == dma_ebuf)) {
   5913		if (*mbx_dump_map & LPFC_BSG_DMP_MBX_RD_BUF) {
   5914			do_dump |= LPFC_BSG_DMP_MBX_RD_BUF;
   5915			pr_err("\nRead mbox buffer (x%x), "
   5916			       "nemb:0x%x, extbuf_seq:%d:\n",
   5917			       sta_tp, nemb_tp, ext_buf);
   5918		}
   5919	}
   5920	if ((mbox_tp == mbox_wr) && (dma_tp == dma_mbox)) {
   5921		if (*mbx_dump_map & LPFC_BSG_DMP_MBX_WR_MBX) {
   5922			do_dump |= LPFC_BSG_DMP_MBX_WR_MBX;
   5923			pr_err("\nWrite mbox command (x%x), "
   5924			       "nemb:0x%x, extbuf_cnt:%d:\n",
   5925			       sta_tp, nemb_tp, ext_buf);
   5926		}
   5927	}
   5928	if ((mbox_tp == mbox_wr) && (dma_tp == dma_ebuf)) {
   5929		if (*mbx_dump_map & LPFC_BSG_DMP_MBX_WR_BUF) {
   5930			do_dump |= LPFC_BSG_DMP_MBX_WR_BUF;
   5931			pr_err("\nWrite mbox buffer (x%x), "
   5932			       "nemb:0x%x, extbuf_seq:%d:\n",
   5933			       sta_tp, nemb_tp, ext_buf);
   5934		}
   5935	}
   5936
   5937	/* dump buffer content */
   5938	if (do_dump) {
   5939		pword = (uint32_t *)dmabuf->virt;
   5940		for (i = 0; i < *mbx_word_cnt; i++) {
   5941			if (!(i % 8)) {
   5942				if (i != 0)
   5943					pr_err("%s\n", line_buf);
   5944				len = 0;
   5945				len += scnprintf(line_buf+len,
   5946						LPFC_MBX_ACC_LBUF_SZ-len,
   5947						"%03d: ", i);
   5948			}
   5949			len += scnprintf(line_buf+len, LPFC_MBX_ACC_LBUF_SZ-len,
   5950					"%08x ", (uint32_t)*pword);
   5951			pword++;
   5952		}
   5953		if ((i - 1) % 8)
   5954			pr_err("%s\n", line_buf);
   5955		(*mbx_dump_cnt)--;
   5956	}
   5957
   5958	/* Clean out command structure on reaching dump count */
   5959	if (*mbx_dump_cnt == 0)
   5960		memset(&idiag, 0, sizeof(idiag));
   5961	return;
   5962#endif
   5963}
   5964
   5965/* lpfc_idiag_mbxacc_dump_issue_mbox - idiag debugfs dump issue mailbox command
   5966 * @phba: Pointer to HBA context object.
   5967 * @dmabuf: Pointer to a DMA buffer descriptor.
   5968 *
   5969 * Description:
   5970 * This routine dump a pass-through non-embedded mailbox command from issue
   5971 * mailbox command.
   5972 **/
   5973void
   5974lpfc_idiag_mbxacc_dump_issue_mbox(struct lpfc_hba *phba, MAILBOX_t *pmbox)
   5975{
   5976#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
   5977	uint32_t *mbx_dump_map, *mbx_dump_cnt, *mbx_word_cnt, *mbx_mbox_cmd;
   5978	char line_buf[LPFC_MBX_ACC_LBUF_SZ];
   5979	int len = 0;
   5980	uint32_t *pword;
   5981	uint8_t *pbyte;
   5982	uint32_t i, j;
   5983
   5984	if (idiag.cmd.opcode != LPFC_IDIAG_CMD_MBXACC_DP)
   5985		return;
   5986
   5987	mbx_mbox_cmd = &idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX];
   5988	mbx_dump_map = &idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX];
   5989	mbx_dump_cnt = &idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX];
   5990	mbx_word_cnt = &idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX];
   5991
   5992	if (!(*mbx_dump_map & LPFC_MBX_DMP_MBX_ALL) ||
   5993	    (*mbx_dump_cnt == 0) ||
   5994	    (*mbx_word_cnt == 0))
   5995		return;
   5996
   5997	if ((*mbx_mbox_cmd != LPFC_MBX_ALL_CMD) &&
   5998	    (*mbx_mbox_cmd != pmbox->mbxCommand))
   5999		return;
   6000
   6001	/* dump buffer content */
   6002	if (*mbx_dump_map & LPFC_MBX_DMP_MBX_WORD) {
   6003		pr_err("Mailbox command:0x%x dump by word:\n",
   6004		       pmbox->mbxCommand);
   6005		pword = (uint32_t *)pmbox;
   6006		for (i = 0; i < *mbx_word_cnt; i++) {
   6007			if (!(i % 8)) {
   6008				if (i != 0)
   6009					pr_err("%s\n", line_buf);
   6010				len = 0;
   6011				memset(line_buf, 0, LPFC_MBX_ACC_LBUF_SZ);
   6012				len += scnprintf(line_buf+len,
   6013						LPFC_MBX_ACC_LBUF_SZ-len,
   6014						"%03d: ", i);
   6015			}
   6016			len += scnprintf(line_buf+len, LPFC_MBX_ACC_LBUF_SZ-len,
   6017					"%08x ",
   6018					((uint32_t)*pword) & 0xffffffff);
   6019			pword++;
   6020		}
   6021		if ((i - 1) % 8)
   6022			pr_err("%s\n", line_buf);
   6023		pr_err("\n");
   6024	}
   6025	if (*mbx_dump_map & LPFC_MBX_DMP_MBX_BYTE) {
   6026		pr_err("Mailbox command:0x%x dump by byte:\n",
   6027		       pmbox->mbxCommand);
   6028		pbyte = (uint8_t *)pmbox;
   6029		for (i = 0; i < *mbx_word_cnt; i++) {
   6030			if (!(i % 8)) {
   6031				if (i != 0)
   6032					pr_err("%s\n", line_buf);
   6033				len = 0;
   6034				memset(line_buf, 0, LPFC_MBX_ACC_LBUF_SZ);
   6035				len += scnprintf(line_buf+len,
   6036						LPFC_MBX_ACC_LBUF_SZ-len,
   6037						"%03d: ", i);
   6038			}
   6039			for (j = 0; j < 4; j++) {
   6040				len += scnprintf(line_buf+len,
   6041						LPFC_MBX_ACC_LBUF_SZ-len,
   6042						"%02x",
   6043						((uint8_t)*pbyte) & 0xff);
   6044				pbyte++;
   6045			}
   6046			len += scnprintf(line_buf+len,
   6047					LPFC_MBX_ACC_LBUF_SZ-len, " ");
   6048		}
   6049		if ((i - 1) % 8)
   6050			pr_err("%s\n", line_buf);
   6051		pr_err("\n");
   6052	}
   6053	(*mbx_dump_cnt)--;
   6054
   6055	/* Clean out command structure on reaching dump count */
   6056	if (*mbx_dump_cnt == 0)
   6057		memset(&idiag, 0, sizeof(idiag));
   6058	return;
   6059#endif
   6060}
   6061
   6062/**
   6063 * lpfc_debugfs_initialize - Initialize debugfs for a vport
   6064 * @vport: The vport pointer to initialize.
   6065 *
   6066 * Description:
   6067 * When Debugfs is configured this routine sets up the lpfc debugfs file system.
   6068 * If not already created, this routine will create the lpfc directory, and
   6069 * lpfcX directory (for this HBA), and vportX directory for this vport. It will
   6070 * also create each file used to access lpfc specific debugfs information.
   6071 **/
   6072inline void
   6073lpfc_debugfs_initialize(struct lpfc_vport *vport)
   6074{
   6075#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
   6076	struct lpfc_hba   *phba = vport->phba;
   6077	char name[64];
   6078	uint32_t num, i;
   6079	bool pport_setup = false;
   6080
   6081	if (!lpfc_debugfs_enable)
   6082		return;
   6083
   6084	/* Setup lpfc root directory */
   6085	if (!lpfc_debugfs_root) {
   6086		lpfc_debugfs_root = debugfs_create_dir("lpfc", NULL);
   6087		atomic_set(&lpfc_debugfs_hba_count, 0);
   6088	}
   6089	if (!lpfc_debugfs_start_time)
   6090		lpfc_debugfs_start_time = jiffies;
   6091
   6092	/* Setup funcX directory for specific HBA PCI function */
   6093	snprintf(name, sizeof(name), "fn%d", phba->brd_no);
   6094	if (!phba->hba_debugfs_root) {
   6095		pport_setup = true;
   6096		phba->hba_debugfs_root =
   6097			debugfs_create_dir(name, lpfc_debugfs_root);
   6098		atomic_inc(&lpfc_debugfs_hba_count);
   6099		atomic_set(&phba->debugfs_vport_count, 0);
   6100
   6101		/* Multi-XRI pools */
   6102		snprintf(name, sizeof(name), "multixripools");
   6103		phba->debug_multixri_pools =
   6104			debugfs_create_file(name, S_IFREG | 0644,
   6105					    phba->hba_debugfs_root,
   6106					    phba,
   6107					    &lpfc_debugfs_op_multixripools);
   6108		if (!phba->debug_multixri_pools) {
   6109			lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
   6110					 "0527 Cannot create debugfs multixripools\n");
   6111			goto debug_failed;
   6112		}
   6113
   6114		/* Congestion Info Buffer */
   6115		scnprintf(name, sizeof(name), "cgn_buffer");
   6116		phba->debug_cgn_buffer =
   6117			debugfs_create_file(name, S_IFREG | 0644,
   6118					    phba->hba_debugfs_root,
   6119					    phba, &lpfc_cgn_buffer_op);
   6120		if (!phba->debug_cgn_buffer) {
   6121			lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
   6122					 "6527 Cannot create debugfs "
   6123					 "cgn_buffer\n");
   6124			goto debug_failed;
   6125		}
   6126
   6127		/* RX Monitor */
   6128		scnprintf(name, sizeof(name), "rx_monitor");
   6129		phba->debug_rx_monitor =
   6130			debugfs_create_file(name, S_IFREG | 0644,
   6131					    phba->hba_debugfs_root,
   6132					    phba, &lpfc_rx_monitor_op);
   6133		if (!phba->debug_rx_monitor) {
   6134			lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
   6135					 "6528 Cannot create debugfs "
   6136					 "rx_monitor\n");
   6137			goto debug_failed;
   6138		}
   6139
   6140		/* RAS log */
   6141		snprintf(name, sizeof(name), "ras_log");
   6142		phba->debug_ras_log =
   6143			debugfs_create_file(name, 0644,
   6144					    phba->hba_debugfs_root,
   6145					    phba, &lpfc_debugfs_ras_log);
   6146		if (!phba->debug_ras_log) {
   6147			lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
   6148					 "6148 Cannot create debugfs"
   6149					 " ras_log\n");
   6150			goto debug_failed;
   6151		}
   6152
   6153		/* Setup hbqinfo */
   6154		snprintf(name, sizeof(name), "hbqinfo");
   6155		phba->debug_hbqinfo =
   6156			debugfs_create_file(name, S_IFREG | 0644,
   6157					    phba->hba_debugfs_root,
   6158					    phba, &lpfc_debugfs_op_hbqinfo);
   6159
   6160#ifdef LPFC_HDWQ_LOCK_STAT
   6161		/* Setup lockstat */
   6162		snprintf(name, sizeof(name), "lockstat");
   6163		phba->debug_lockstat =
   6164			debugfs_create_file(name, S_IFREG | 0644,
   6165					    phba->hba_debugfs_root,
   6166					    phba, &lpfc_debugfs_op_lockstat);
   6167		if (!phba->debug_lockstat) {
   6168			lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
   6169					 "4610 Can't create debugfs lockstat\n");
   6170			goto debug_failed;
   6171		}
   6172#endif
   6173
   6174		/* Setup dumpHBASlim */
   6175		if (phba->sli_rev < LPFC_SLI_REV4) {
   6176			snprintf(name, sizeof(name), "dumpHBASlim");
   6177			phba->debug_dumpHBASlim =
   6178				debugfs_create_file(name,
   6179					S_IFREG|S_IRUGO|S_IWUSR,
   6180					phba->hba_debugfs_root,
   6181					phba, &lpfc_debugfs_op_dumpHBASlim);
   6182		} else
   6183			phba->debug_dumpHBASlim = NULL;
   6184
   6185		/* Setup dumpHostSlim */
   6186		if (phba->sli_rev < LPFC_SLI_REV4) {
   6187			snprintf(name, sizeof(name), "dumpHostSlim");
   6188			phba->debug_dumpHostSlim =
   6189				debugfs_create_file(name,
   6190					S_IFREG|S_IRUGO|S_IWUSR,
   6191					phba->hba_debugfs_root,
   6192					phba, &lpfc_debugfs_op_dumpHostSlim);
   6193		} else
   6194			phba->debug_dumpHostSlim = NULL;
   6195
   6196		/* Setup DIF Error Injections */
   6197		snprintf(name, sizeof(name), "InjErrLBA");
   6198		phba->debug_InjErrLBA =
   6199			debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6200			phba->hba_debugfs_root,
   6201			phba, &lpfc_debugfs_op_dif_err);
   6202		phba->lpfc_injerr_lba = LPFC_INJERR_LBA_OFF;
   6203
   6204		snprintf(name, sizeof(name), "InjErrNPortID");
   6205		phba->debug_InjErrNPortID =
   6206			debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6207			phba->hba_debugfs_root,
   6208			phba, &lpfc_debugfs_op_dif_err);
   6209
   6210		snprintf(name, sizeof(name), "InjErrWWPN");
   6211		phba->debug_InjErrWWPN =
   6212			debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6213			phba->hba_debugfs_root,
   6214			phba, &lpfc_debugfs_op_dif_err);
   6215
   6216		snprintf(name, sizeof(name), "writeGuardInjErr");
   6217		phba->debug_writeGuard =
   6218			debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6219			phba->hba_debugfs_root,
   6220			phba, &lpfc_debugfs_op_dif_err);
   6221
   6222		snprintf(name, sizeof(name), "writeAppInjErr");
   6223		phba->debug_writeApp =
   6224			debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6225			phba->hba_debugfs_root,
   6226			phba, &lpfc_debugfs_op_dif_err);
   6227
   6228		snprintf(name, sizeof(name), "writeRefInjErr");
   6229		phba->debug_writeRef =
   6230			debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6231			phba->hba_debugfs_root,
   6232			phba, &lpfc_debugfs_op_dif_err);
   6233
   6234		snprintf(name, sizeof(name), "readGuardInjErr");
   6235		phba->debug_readGuard =
   6236			debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6237			phba->hba_debugfs_root,
   6238			phba, &lpfc_debugfs_op_dif_err);
   6239
   6240		snprintf(name, sizeof(name), "readAppInjErr");
   6241		phba->debug_readApp =
   6242			debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6243			phba->hba_debugfs_root,
   6244			phba, &lpfc_debugfs_op_dif_err);
   6245
   6246		snprintf(name, sizeof(name), "readRefInjErr");
   6247		phba->debug_readRef =
   6248			debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6249			phba->hba_debugfs_root,
   6250			phba, &lpfc_debugfs_op_dif_err);
   6251
   6252		/* Setup slow ring trace */
   6253		if (lpfc_debugfs_max_slow_ring_trc) {
   6254			num = lpfc_debugfs_max_slow_ring_trc - 1;
   6255			if (num & lpfc_debugfs_max_slow_ring_trc) {
   6256				/* Change to be a power of 2 */
   6257				num = lpfc_debugfs_max_slow_ring_trc;
   6258				i = 0;
   6259				while (num > 1) {
   6260					num = num >> 1;
   6261					i++;
   6262				}
   6263				lpfc_debugfs_max_slow_ring_trc = (1 << i);
   6264				pr_err("lpfc_debugfs_max_disc_trc changed to "
   6265				       "%d\n", lpfc_debugfs_max_disc_trc);
   6266			}
   6267		}
   6268
   6269		snprintf(name, sizeof(name), "slow_ring_trace");
   6270		phba->debug_slow_ring_trc =
   6271			debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6272				 phba->hba_debugfs_root,
   6273				 phba, &lpfc_debugfs_op_slow_ring_trc);
   6274		if (!phba->slow_ring_trc) {
   6275			phba->slow_ring_trc = kcalloc(
   6276				lpfc_debugfs_max_slow_ring_trc,
   6277				sizeof(struct lpfc_debugfs_trc),
   6278				GFP_KERNEL);
   6279			if (!phba->slow_ring_trc) {
   6280				lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
   6281						 "0416 Cannot create debugfs "
   6282						 "slow_ring buffer\n");
   6283				goto debug_failed;
   6284			}
   6285			atomic_set(&phba->slow_ring_trc_cnt, 0);
   6286		}
   6287
   6288		snprintf(name, sizeof(name), "nvmeio_trc");
   6289		phba->debug_nvmeio_trc =
   6290			debugfs_create_file(name, 0644,
   6291					    phba->hba_debugfs_root,
   6292					    phba, &lpfc_debugfs_op_nvmeio_trc);
   6293
   6294		atomic_set(&phba->nvmeio_trc_cnt, 0);
   6295		if (lpfc_debugfs_max_nvmeio_trc) {
   6296			num = lpfc_debugfs_max_nvmeio_trc - 1;
   6297			if (num & lpfc_debugfs_max_disc_trc) {
   6298				/* Change to be a power of 2 */
   6299				num = lpfc_debugfs_max_nvmeio_trc;
   6300				i = 0;
   6301				while (num > 1) {
   6302					num = num >> 1;
   6303					i++;
   6304				}
   6305				lpfc_debugfs_max_nvmeio_trc = (1 << i);
   6306				lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
   6307						"0575 lpfc_debugfs_max_nvmeio_trc "
   6308						"changed to %d\n",
   6309						lpfc_debugfs_max_nvmeio_trc);
   6310			}
   6311			phba->nvmeio_trc_size = lpfc_debugfs_max_nvmeio_trc;
   6312
   6313			/* Allocate trace buffer and initialize */
   6314			phba->nvmeio_trc = kzalloc(
   6315				(sizeof(struct lpfc_debugfs_nvmeio_trc) *
   6316				phba->nvmeio_trc_size), GFP_KERNEL);
   6317
   6318			if (!phba->nvmeio_trc) {
   6319				lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
   6320						"0576 Cannot create debugfs "
   6321						"nvmeio_trc buffer\n");
   6322				goto nvmeio_off;
   6323			}
   6324			phba->nvmeio_trc_on = 1;
   6325			phba->nvmeio_trc_output_idx = 0;
   6326			phba->nvmeio_trc = NULL;
   6327		} else {
   6328nvmeio_off:
   6329			phba->nvmeio_trc_size = 0;
   6330			phba->nvmeio_trc_on = 0;
   6331			phba->nvmeio_trc_output_idx = 0;
   6332			phba->nvmeio_trc = NULL;
   6333		}
   6334	}
   6335
   6336	snprintf(name, sizeof(name), "vport%d", vport->vpi);
   6337	if (!vport->vport_debugfs_root) {
   6338		vport->vport_debugfs_root =
   6339			debugfs_create_dir(name, phba->hba_debugfs_root);
   6340		atomic_inc(&phba->debugfs_vport_count);
   6341	}
   6342
   6343	if (lpfc_debugfs_max_disc_trc) {
   6344		num = lpfc_debugfs_max_disc_trc - 1;
   6345		if (num & lpfc_debugfs_max_disc_trc) {
   6346			/* Change to be a power of 2 */
   6347			num = lpfc_debugfs_max_disc_trc;
   6348			i = 0;
   6349			while (num > 1) {
   6350				num = num >> 1;
   6351				i++;
   6352			}
   6353			lpfc_debugfs_max_disc_trc = (1 << i);
   6354			pr_err("lpfc_debugfs_max_disc_trc changed to %d\n",
   6355			       lpfc_debugfs_max_disc_trc);
   6356		}
   6357	}
   6358
   6359	vport->disc_trc = kzalloc(
   6360		(sizeof(struct lpfc_debugfs_trc) * lpfc_debugfs_max_disc_trc),
   6361		GFP_KERNEL);
   6362
   6363	if (!vport->disc_trc) {
   6364		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
   6365				 "0418 Cannot create debugfs disc trace "
   6366				 "buffer\n");
   6367		goto debug_failed;
   6368	}
   6369	atomic_set(&vport->disc_trc_cnt, 0);
   6370
   6371	snprintf(name, sizeof(name), "discovery_trace");
   6372	vport->debug_disc_trc =
   6373		debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6374				 vport->vport_debugfs_root,
   6375				 vport, &lpfc_debugfs_op_disc_trc);
   6376	snprintf(name, sizeof(name), "nodelist");
   6377	vport->debug_nodelist =
   6378		debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6379				 vport->vport_debugfs_root,
   6380				 vport, &lpfc_debugfs_op_nodelist);
   6381
   6382	snprintf(name, sizeof(name), "nvmestat");
   6383	vport->debug_nvmestat =
   6384		debugfs_create_file(name, 0644,
   6385				    vport->vport_debugfs_root,
   6386				    vport, &lpfc_debugfs_op_nvmestat);
   6387
   6388	snprintf(name, sizeof(name), "scsistat");
   6389	vport->debug_scsistat =
   6390		debugfs_create_file(name, 0644,
   6391				    vport->vport_debugfs_root,
   6392				    vport, &lpfc_debugfs_op_scsistat);
   6393	if (!vport->debug_scsistat) {
   6394		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
   6395				 "4611 Cannot create debugfs scsistat\n");
   6396		goto debug_failed;
   6397	}
   6398
   6399	snprintf(name, sizeof(name), "ioktime");
   6400	vport->debug_ioktime =
   6401		debugfs_create_file(name, 0644,
   6402				    vport->vport_debugfs_root,
   6403				    vport, &lpfc_debugfs_op_ioktime);
   6404	if (!vport->debug_ioktime) {
   6405		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
   6406				 "0815 Cannot create debugfs ioktime\n");
   6407		goto debug_failed;
   6408	}
   6409
   6410	snprintf(name, sizeof(name), "hdwqstat");
   6411	vport->debug_hdwqstat =
   6412		debugfs_create_file(name, 0644,
   6413				    vport->vport_debugfs_root,
   6414				    vport, &lpfc_debugfs_op_hdwqstat);
   6415
   6416	/*
   6417	 * The following section is for additional directories/files for the
   6418	 * physical port.
   6419	 */
   6420
   6421	if (!pport_setup)
   6422		goto debug_failed;
   6423
   6424	/*
   6425	 * iDiag debugfs root entry points for SLI4 device only
   6426	 */
   6427	if (phba->sli_rev < LPFC_SLI_REV4)
   6428		goto debug_failed;
   6429
   6430	snprintf(name, sizeof(name), "iDiag");
   6431	if (!phba->idiag_root) {
   6432		phba->idiag_root =
   6433			debugfs_create_dir(name, phba->hba_debugfs_root);
   6434		/* Initialize iDiag data structure */
   6435		memset(&idiag, 0, sizeof(idiag));
   6436	}
   6437
   6438	/* iDiag read PCI config space */
   6439	snprintf(name, sizeof(name), "pciCfg");
   6440	if (!phba->idiag_pci_cfg) {
   6441		phba->idiag_pci_cfg =
   6442			debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6443				phba->idiag_root, phba, &lpfc_idiag_op_pciCfg);
   6444		idiag.offset.last_rd = 0;
   6445	}
   6446
   6447	/* iDiag PCI BAR access */
   6448	snprintf(name, sizeof(name), "barAcc");
   6449	if (!phba->idiag_bar_acc) {
   6450		phba->idiag_bar_acc =
   6451			debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6452				phba->idiag_root, phba, &lpfc_idiag_op_barAcc);
   6453		idiag.offset.last_rd = 0;
   6454	}
   6455
   6456	/* iDiag get PCI function queue information */
   6457	snprintf(name, sizeof(name), "queInfo");
   6458	if (!phba->idiag_que_info) {
   6459		phba->idiag_que_info =
   6460			debugfs_create_file(name, S_IFREG|S_IRUGO,
   6461			phba->idiag_root, phba, &lpfc_idiag_op_queInfo);
   6462	}
   6463
   6464	/* iDiag access PCI function queue */
   6465	snprintf(name, sizeof(name), "queAcc");
   6466	if (!phba->idiag_que_acc) {
   6467		phba->idiag_que_acc =
   6468			debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6469				phba->idiag_root, phba, &lpfc_idiag_op_queAcc);
   6470	}
   6471
   6472	/* iDiag access PCI function doorbell registers */
   6473	snprintf(name, sizeof(name), "drbAcc");
   6474	if (!phba->idiag_drb_acc) {
   6475		phba->idiag_drb_acc =
   6476			debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6477				phba->idiag_root, phba, &lpfc_idiag_op_drbAcc);
   6478	}
   6479
   6480	/* iDiag access PCI function control registers */
   6481	snprintf(name, sizeof(name), "ctlAcc");
   6482	if (!phba->idiag_ctl_acc) {
   6483		phba->idiag_ctl_acc =
   6484			debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6485				phba->idiag_root, phba, &lpfc_idiag_op_ctlAcc);
   6486	}
   6487
   6488	/* iDiag access mbox commands */
   6489	snprintf(name, sizeof(name), "mbxAcc");
   6490	if (!phba->idiag_mbx_acc) {
   6491		phba->idiag_mbx_acc =
   6492			debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
   6493				phba->idiag_root, phba, &lpfc_idiag_op_mbxAcc);
   6494	}
   6495
   6496	/* iDiag extents access commands */
   6497	if (phba->sli4_hba.extents_in_use) {
   6498		snprintf(name, sizeof(name), "extAcc");
   6499		if (!phba->idiag_ext_acc) {
   6500			phba->idiag_ext_acc =
   6501				debugfs_create_file(name,
   6502						    S_IFREG|S_IRUGO|S_IWUSR,
   6503						    phba->idiag_root, phba,
   6504						    &lpfc_idiag_op_extAcc);
   6505		}
   6506	}
   6507
   6508debug_failed:
   6509	return;
   6510#endif
   6511}
   6512
   6513/**
   6514 * lpfc_debugfs_terminate -  Tear down debugfs infrastructure for this vport
   6515 * @vport: The vport pointer to remove from debugfs.
   6516 *
   6517 * Description:
   6518 * When Debugfs is configured this routine removes debugfs file system elements
   6519 * that are specific to this vport. It also checks to see if there are any
   6520 * users left for the debugfs directories associated with the HBA and driver. If
   6521 * this is the last user of the HBA directory or driver directory then it will
   6522 * remove those from the debugfs infrastructure as well.
   6523 **/
   6524inline void
   6525lpfc_debugfs_terminate(struct lpfc_vport *vport)
   6526{
   6527#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
   6528	struct lpfc_hba   *phba = vport->phba;
   6529
   6530	kfree(vport->disc_trc);
   6531	vport->disc_trc = NULL;
   6532
   6533	debugfs_remove(vport->debug_disc_trc); /* discovery_trace */
   6534	vport->debug_disc_trc = NULL;
   6535
   6536	debugfs_remove(vport->debug_nodelist); /* nodelist */
   6537	vport->debug_nodelist = NULL;
   6538
   6539	debugfs_remove(vport->debug_nvmestat); /* nvmestat */
   6540	vport->debug_nvmestat = NULL;
   6541
   6542	debugfs_remove(vport->debug_scsistat); /* scsistat */
   6543	vport->debug_scsistat = NULL;
   6544
   6545	debugfs_remove(vport->debug_ioktime); /* ioktime */
   6546	vport->debug_ioktime = NULL;
   6547
   6548	debugfs_remove(vport->debug_hdwqstat); /* hdwqstat */
   6549	vport->debug_hdwqstat = NULL;
   6550
   6551	if (vport->vport_debugfs_root) {
   6552		debugfs_remove(vport->vport_debugfs_root); /* vportX */
   6553		vport->vport_debugfs_root = NULL;
   6554		atomic_dec(&phba->debugfs_vport_count);
   6555	}
   6556
   6557	if (atomic_read(&phba->debugfs_vport_count) == 0) {
   6558
   6559		debugfs_remove(phba->debug_multixri_pools); /* multixripools*/
   6560		phba->debug_multixri_pools = NULL;
   6561
   6562		debugfs_remove(phba->debug_hbqinfo); /* hbqinfo */
   6563		phba->debug_hbqinfo = NULL;
   6564
   6565		debugfs_remove(phba->debug_cgn_buffer);
   6566		phba->debug_cgn_buffer = NULL;
   6567
   6568		debugfs_remove(phba->debug_rx_monitor);
   6569		phba->debug_rx_monitor = NULL;
   6570
   6571		debugfs_remove(phba->debug_ras_log);
   6572		phba->debug_ras_log = NULL;
   6573
   6574#ifdef LPFC_HDWQ_LOCK_STAT
   6575		debugfs_remove(phba->debug_lockstat); /* lockstat */
   6576		phba->debug_lockstat = NULL;
   6577#endif
   6578		debugfs_remove(phba->debug_dumpHBASlim); /* HBASlim */
   6579		phba->debug_dumpHBASlim = NULL;
   6580
   6581		debugfs_remove(phba->debug_dumpHostSlim); /* HostSlim */
   6582		phba->debug_dumpHostSlim = NULL;
   6583
   6584		debugfs_remove(phba->debug_InjErrLBA); /* InjErrLBA */
   6585		phba->debug_InjErrLBA = NULL;
   6586
   6587		debugfs_remove(phba->debug_InjErrNPortID);
   6588		phba->debug_InjErrNPortID = NULL;
   6589
   6590		debugfs_remove(phba->debug_InjErrWWPN); /* InjErrWWPN */
   6591		phba->debug_InjErrWWPN = NULL;
   6592
   6593		debugfs_remove(phba->debug_writeGuard); /* writeGuard */
   6594		phba->debug_writeGuard = NULL;
   6595
   6596		debugfs_remove(phba->debug_writeApp); /* writeApp */
   6597		phba->debug_writeApp = NULL;
   6598
   6599		debugfs_remove(phba->debug_writeRef); /* writeRef */
   6600		phba->debug_writeRef = NULL;
   6601
   6602		debugfs_remove(phba->debug_readGuard); /* readGuard */
   6603		phba->debug_readGuard = NULL;
   6604
   6605		debugfs_remove(phba->debug_readApp); /* readApp */
   6606		phba->debug_readApp = NULL;
   6607
   6608		debugfs_remove(phba->debug_readRef); /* readRef */
   6609		phba->debug_readRef = NULL;
   6610
   6611		kfree(phba->slow_ring_trc);
   6612		phba->slow_ring_trc = NULL;
   6613
   6614		/* slow_ring_trace */
   6615		debugfs_remove(phba->debug_slow_ring_trc);
   6616		phba->debug_slow_ring_trc = NULL;
   6617
   6618		debugfs_remove(phba->debug_nvmeio_trc);
   6619		phba->debug_nvmeio_trc = NULL;
   6620
   6621		kfree(phba->nvmeio_trc);
   6622		phba->nvmeio_trc = NULL;
   6623
   6624		/*
   6625		 * iDiag release
   6626		 */
   6627		if (phba->sli_rev == LPFC_SLI_REV4) {
   6628			/* iDiag extAcc */
   6629			debugfs_remove(phba->idiag_ext_acc);
   6630			phba->idiag_ext_acc = NULL;
   6631
   6632			/* iDiag mbxAcc */
   6633			debugfs_remove(phba->idiag_mbx_acc);
   6634			phba->idiag_mbx_acc = NULL;
   6635
   6636			/* iDiag ctlAcc */
   6637			debugfs_remove(phba->idiag_ctl_acc);
   6638			phba->idiag_ctl_acc = NULL;
   6639
   6640			/* iDiag drbAcc */
   6641			debugfs_remove(phba->idiag_drb_acc);
   6642			phba->idiag_drb_acc = NULL;
   6643
   6644			/* iDiag queAcc */
   6645			debugfs_remove(phba->idiag_que_acc);
   6646			phba->idiag_que_acc = NULL;
   6647
   6648			/* iDiag queInfo */
   6649			debugfs_remove(phba->idiag_que_info);
   6650			phba->idiag_que_info = NULL;
   6651
   6652			/* iDiag barAcc */
   6653			debugfs_remove(phba->idiag_bar_acc);
   6654			phba->idiag_bar_acc = NULL;
   6655
   6656			/* iDiag pciCfg */
   6657			debugfs_remove(phba->idiag_pci_cfg);
   6658			phba->idiag_pci_cfg = NULL;
   6659
   6660			/* Finally remove the iDiag debugfs root */
   6661			debugfs_remove(phba->idiag_root);
   6662			phba->idiag_root = NULL;
   6663		}
   6664
   6665		if (phba->hba_debugfs_root) {
   6666			debugfs_remove(phba->hba_debugfs_root); /* fnX */
   6667			phba->hba_debugfs_root = NULL;
   6668			atomic_dec(&lpfc_debugfs_hba_count);
   6669		}
   6670
   6671		if (atomic_read(&lpfc_debugfs_hba_count) == 0) {
   6672			debugfs_remove(lpfc_debugfs_root); /* lpfc */
   6673			lpfc_debugfs_root = NULL;
   6674		}
   6675	}
   6676#endif
   6677	return;
   6678}
   6679
   6680/*
   6681 * Driver debug utility routines outside of debugfs. The debug utility
   6682 * routines implemented here is intended to be used in the instrumented
   6683 * debug driver for debugging host or port issues.
   6684 */
   6685
   6686/**
   6687 * lpfc_debug_dump_all_queues - dump all the queues with a hba
   6688 * @phba: Pointer to HBA context object.
   6689 *
   6690 * This function dumps entries of all the queues asociated with the @phba.
   6691 **/
   6692void
   6693lpfc_debug_dump_all_queues(struct lpfc_hba *phba)
   6694{
   6695	int idx;
   6696
   6697	/*
   6698	 * Dump Work Queues (WQs)
   6699	 */
   6700	lpfc_debug_dump_wq(phba, DUMP_MBX, 0);
   6701	lpfc_debug_dump_wq(phba, DUMP_ELS, 0);
   6702	lpfc_debug_dump_wq(phba, DUMP_NVMELS, 0);
   6703
   6704	for (idx = 0; idx < phba->cfg_hdw_queue; idx++)
   6705		lpfc_debug_dump_wq(phba, DUMP_IO, idx);
   6706
   6707	lpfc_debug_dump_hdr_rq(phba);
   6708	lpfc_debug_dump_dat_rq(phba);
   6709	/*
   6710	 * Dump Complete Queues (CQs)
   6711	 */
   6712	lpfc_debug_dump_cq(phba, DUMP_MBX, 0);
   6713	lpfc_debug_dump_cq(phba, DUMP_ELS, 0);
   6714	lpfc_debug_dump_cq(phba, DUMP_NVMELS, 0);
   6715
   6716	for (idx = 0; idx < phba->cfg_hdw_queue; idx++)
   6717		lpfc_debug_dump_cq(phba, DUMP_IO, idx);
   6718
   6719	/*
   6720	 * Dump Event Queues (EQs)
   6721	 */
   6722	for (idx = 0; idx < phba->cfg_hdw_queue; idx++)
   6723		lpfc_debug_dump_hba_eq(phba, idx);
   6724}