drivers/scsi/lpfc/lpfc_debugfs.c

   1 /*******************************************************************
   2  * This file is part of the Emulex Linux Device Driver for         *
   3  * Fibre Channel Host Bus Adapters.                                *
   4  * Copyright (C) 2017-2020 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  */
  91 static int lpfc_debugfs_enable = 1;
  92 module_param(lpfc_debugfs_enable, int, S_IRUGO);
  93 MODULE_PARM_DESC(lpfc_debugfs_enable, "Enable debugfs services");
  94
  95 /* This MUST be a power of 2 */
  96 static int lpfc_debugfs_max_disc_trc;
  97 module_param(lpfc_debugfs_max_disc_trc, int, S_IRUGO);
  98 MODULE_PARM_DESC(lpfc_debugfs_max_disc_trc,
  99         "Set debugfs discovery trace depth");
 100
 101 /* This MUST be a power of 2 */
 102 static int lpfc_debugfs_max_slow_ring_trc;
 103 module_param(lpfc_debugfs_max_slow_ring_trc, int, S_IRUGO);
 104 MODULE_PARM_DESC(lpfc_debugfs_max_slow_ring_trc,
 105         "Set debugfs slow ring trace depth");
 106
 107 /* This MUST be a power of 2 */
 108 static int lpfc_debugfs_max_nvmeio_trc;
 109 module_param(lpfc_debugfs_max_nvmeio_trc, int, 0444);
 110 MODULE_PARM_DESC(lpfc_debugfs_max_nvmeio_trc,
 111                  "Set debugfs NVME IO trace depth");
 112
 113 static int lpfc_debugfs_mask_disc_trc;
 114 module_param(lpfc_debugfs_mask_disc_trc, int, S_IRUGO);
 115 MODULE_PARM_DESC(lpfc_debugfs_mask_disc_trc,
 116         "Set debugfs discovery trace mask");
 117
 118 #include <linux/debugfs.h>
 119
 120 static atomic_t lpfc_debugfs_seq_trc_cnt = ATOMIC_INIT(0);
 121 static unsigned long lpfc_debugfs_start_time = 0L;
 122
 123 /* iDiag */
 124 static 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  **/
 145 static int
 146 lpfc_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  **/
 211 static int
 212 lpfc_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
 258 static 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  **/
 279 static int
 280 lpfc_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                 }
 372 skipit:
 373                 hbqe++;
 374                 if (len > LPFC_HBQINFO_SIZE - 54)
 375                         break;
 376         }
 377         spin_unlock_irq(&phba->hbalock);
 378         return len;
 379 }
 380
 381 static int lpfc_debugfs_last_xripool;
 382
 383 /**
 384  * lpfc_debugfs_common_xri_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  **/
 403 static int
 404 lpfc_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  **/
 455 static int
 456 lpfc_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
 571 static 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  **/
 593 static int
 594 lpfc_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
 642 static 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  **/
 662 static int
 663 lpfc_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  **/
 721 static int
 722 lpfc_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  **/
 804 static int
 805 lpfc_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%llx ",
 867                                 wwn_to_u64(ndlp->nlp_portname.u.wwn));
 868                 len += scnprintf(buf+len, size-len,
 869                                 "WWNN x%llx ",
 870                                 wwn_to_u64(ndlp->nlp_nodename.u.wwn));
 871                 if (ndlp->nlp_flag & NLP_RPI_REGISTERED)
 872                         len += scnprintf(buf+len, size-len, "RPI:%03d ",
 873                                         ndlp->nlp_rpi);
 874                 else
 875                         len += scnprintf(buf+len, size-len, "RPI:none ");
 876                 len +=  scnprintf(buf+len, size-len, "flag:x%08x ",
 877                         ndlp->nlp_flag);
 878                 if (!ndlp->nlp_type)
 879                         len += scnprintf(buf+len, size-len, "UNKNOWN_TYPE ");
 880                 if (ndlp->nlp_type & NLP_FC_NODE)
 881                         len += scnprintf(buf+len, size-len, "FC_NODE ");
 882                 if (ndlp->nlp_type & NLP_FABRIC) {
 883                         len += scnprintf(buf+len, size-len, "FABRIC ");
 884                         iocnt = 0;
 885                 }
 886                 if (ndlp->nlp_type & NLP_FCP_TARGET)
 887                         len += scnprintf(buf+len, size-len, "FCP_TGT sid:%d ",
 888                                 ndlp->nlp_sid);
 889                 if (ndlp->nlp_type & NLP_FCP_INITIATOR)
 890                         len += scnprintf(buf+len, size-len, "FCP_INITIATOR ");
 891                 if (ndlp->nlp_type & NLP_NVME_TARGET)
 892                         len += scnprintf(buf + len,
 893                                         size - len, "NVME_TGT sid:%d ",
 894                                         NLP_NO_SID);
 895                 if (ndlp->nlp_type & NLP_NVME_INITIATOR)
 896                         len += scnprintf(buf + len,
 897                                         size - len, "NVME_INITIATOR ");
 898                 len += scnprintf(buf+len, size-len, "refcnt:%x",
 899                         kref_read(&ndlp->kref));
 900                 if (iocnt) {
 901                         i = atomic_read(&ndlp->cmd_pending);
 902                         len += scnprintf(buf + len, size - len,
 903                                         " OutIO:x%x Qdepth x%x",
 904                                         i, ndlp->cmd_qdepth);
 905                         outio += i;
 906                 }
 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  **/
1028 static int
1029 lpfc_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  **/
1250 static int
1251 lpfc_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
1292 buffer_done:
1293         len = strnlen(buf, size);
1294
1295         return len;
1296 }
1297
1298 void
1299 lpfc_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  **/
1391 static int
1392 lpfc_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  **/
1591 static int
1592 lpfc_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");
1676 out:
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  **/
1693 static int
1694 lpfc_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
1797 buffer_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  **/
1820 inline void
1821 lpfc_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  **/
1861 inline void
1862 lpfc_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  **/
1899 inline void
1900 lpfc_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  **/
1936 static int
1937 lpfc_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;
1967 out:
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  **/
1986 static int
1987 lpfc_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;
2017 out:
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  **/
2036 static int
2037 lpfc_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;
2059 out:
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  **/
2078 static int
2079 lpfc_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;
2103 out:
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  **/
2123 static int
2124 lpfc_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;
2146 out:
2147         return rc;
2148 }
2149
2150 static ssize_t
2151 lpfc_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
2188 static 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
2218 static int
2219 lpfc_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  **/
2244 static int
2245 lpfc_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
2277 free_buffer:
2278         vfree(debug->buffer);
2279 free_debug:
2280         kfree(debug);
2281 out:
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  **/
2300 static int
2301 lpfc_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;
2323 out:
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  **/
2342 static int
2343 lpfc_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;
2365 out:
2366         return rc;
2367 }
2368
2369 static ssize_t
2370 lpfc_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
2411 static ssize_t
2412 lpfc_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 0;
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 0;
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
2461 static int
2462 lpfc_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  **/
2482 static int
2483 lpfc_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;
2505 out:
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  **/
2526 static loff_t
2527 lpfc_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  **/
2549 static ssize_t
2550 lpfc_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  **/
2571 static int
2572 lpfc_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  **/
2597 static ssize_t
2598 lpfc_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
2648 static int
2649 lpfc_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;
2673 out:
2674         return rc;
2675 }
2676
2677 static ssize_t
2678 lpfc_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
2736 static int
2737 lpfc_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;
2761 out:
2762         return rc;
2763 }
2764
2765 static ssize_t
2766 lpfc_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
2790 static int
2791 lpfc_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;
2815 out:
2816         return rc;
2817 }
2818
2819 static ssize_t
2820 lpfc_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
2917 static int
2918 lpfc_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;
2942 out:
2943         return rc;
2944 }
2945
2946 static ssize_t
2947 lpfc_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 > 64)
2958                 nbytes = 64;
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
3022 static int
3023 lpfc_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;
3047 out:
3048         return rc;
3049 }
3050
3051 static ssize_t
3052 lpfc_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  */
3137 static 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  **/
3188 static int
3189 lpfc_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  **/
3217 static int
3218 lpfc_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  **/
3242 static int
3243 lpfc_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  **/
3287 static ssize_t
3288 lpfc_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
3349 pcicfg_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  */
3408 static ssize_t
3409 lpfc_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;
3562 error_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  **/
3582 static ssize_t
3583 lpfc_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
3652 baracc_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  */
3733 static ssize_t
3734 lpfc_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;
3848 error_out:
3849         memset(&idiag, 0, sizeof(idiag));
3850         return -EINVAL;
3851 }
3852
3853 static 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
3877 static int
3878 lpfc_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
3895 static 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
3922 static 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
3950 static int
3951 lpfc_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
3996 static 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  **/
4038 static ssize_t
4039 lpfc_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
4152 too_big:
4153         len +=  scnprintf(pbuffer + len,
4154                 LPFC_QUE_INFO_GET_BUF_SIZE - len, "Truncated ...\n");
4155 out:
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  **/
4173 static int
4174 lpfc_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  **/
4199 static int
4200 lpfc_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  **/
4247 static ssize_t
4248 lpfc_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
4285 que_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  **/
4324 static ssize_t
4325 lpfc_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
4518 pass_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
4543 error_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  **/
4563 static int
4564 lpfc_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  **/
4621 static ssize_t
4622 lpfc_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  **/
4677 static ssize_t
4678 lpfc_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
4753 error_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  **/
4773 static int
4774 lpfc_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  **/
4839 static ssize_t
4840 lpfc_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  **/
4892 static ssize_t
4893 lpfc_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
4977 error_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  **/
4995 static int
4996 lpfc_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  **/
5033 static ssize_t
5034 lpfc_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  **/
5078 static ssize_t
5079 lpfc_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
5133 reset_out:
5134         /* Clean out command structure on command error out */
5135         memset(&idiag, 0, sizeof(idiag));
5136         return nbytes;
5137
5138 error_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 lenth of the data read into the internal buffer.
5155  **/
5156 static int
5157 lpfc_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 lenth of the data read into the internal buffer.
5206  **/
5207 static int
5208 lpfc_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 lenth of the data read into the internal buffer.
5278  **/
5279 static int
5280 lpfc_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  **/
5352 static ssize_t
5353 lpfc_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;
5377 error_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  **/
5398 static ssize_t
5399 lpfc_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
5432 #undef lpfc_debugfs_op_disc_trc
5433 static const struct file_operations lpfc_debugfs_op_disc_trc = {
5434         .owner =        THIS_MODULE,
5435         .open =         lpfc_debugfs_disc_trc_open,
5436         .llseek =       lpfc_debugfs_lseek,
5437         .read =         lpfc_debugfs_read,
5438         .release =      lpfc_debugfs_release,
5439 };
5440
5441 #undef lpfc_debugfs_op_nodelist
5442 static const struct file_operations lpfc_debugfs_op_nodelist = {
5443         .owner =        THIS_MODULE,
5444         .open =         lpfc_debugfs_nodelist_open,
5445         .llseek =       lpfc_debugfs_lseek,
5446         .read =         lpfc_debugfs_read,
5447         .release =      lpfc_debugfs_release,
5448 };
5449
5450 #undef lpfc_debugfs_op_multixripools
5451 static const struct file_operations lpfc_debugfs_op_multixripools = {
5452         .owner =        THIS_MODULE,
5453         .open =         lpfc_debugfs_multixripools_open,
5454         .llseek =       lpfc_debugfs_lseek,
5455         .read =         lpfc_debugfs_read,
5456         .write =        lpfc_debugfs_multixripools_write,
5457         .release =      lpfc_debugfs_release,
5458 };
5459
5460 #undef lpfc_debugfs_op_hbqinfo
5461 static const struct file_operations lpfc_debugfs_op_hbqinfo = {
5462         .owner =        THIS_MODULE,
5463         .open =         lpfc_debugfs_hbqinfo_open,
5464         .llseek =       lpfc_debugfs_lseek,
5465         .read =         lpfc_debugfs_read,
5466         .release =      lpfc_debugfs_release,
5467 };
5468
5469 #ifdef LPFC_HDWQ_LOCK_STAT
5470 #undef lpfc_debugfs_op_lockstat
5471 static const struct file_operations lpfc_debugfs_op_lockstat = {
5472         .owner =        THIS_MODULE,
5473         .open =         lpfc_debugfs_lockstat_open,
5474         .llseek =       lpfc_debugfs_lseek,
5475         .read =         lpfc_debugfs_read,
5476         .write =        lpfc_debugfs_lockstat_write,
5477         .release =      lpfc_debugfs_release,
5478 };
5479 #endif
5480
5481 #undef lpfc_debugfs_ras_log
5482 static const struct file_operations lpfc_debugfs_ras_log = {
5483         .owner =        THIS_MODULE,
5484         .open =         lpfc_debugfs_ras_log_open,
5485         .llseek =       lpfc_debugfs_lseek,
5486         .read =         lpfc_debugfs_read,
5487         .release =      lpfc_debugfs_ras_log_release,
5488 };
5489
5490 #undef lpfc_debugfs_op_dumpHBASlim
5491 static const struct file_operations lpfc_debugfs_op_dumpHBASlim = {
5492         .owner =        THIS_MODULE,
5493         .open =         lpfc_debugfs_dumpHBASlim_open,
5494         .llseek =       lpfc_debugfs_lseek,
5495         .read =         lpfc_debugfs_read,
5496         .release =      lpfc_debugfs_release,
5497 };
5498
5499 #undef lpfc_debugfs_op_dumpHostSlim
5500 static const struct file_operations lpfc_debugfs_op_dumpHostSlim = {
5501         .owner =        THIS_MODULE,
5502         .open =         lpfc_debugfs_dumpHostSlim_open,
5503         .llseek =       lpfc_debugfs_lseek,
5504         .read =         lpfc_debugfs_read,
5505         .release =      lpfc_debugfs_release,
5506 };
5507
5508 #undef lpfc_debugfs_op_nvmestat
5509 static const struct file_operations lpfc_debugfs_op_nvmestat = {
5510         .owner =        THIS_MODULE,
5511         .open =         lpfc_debugfs_nvmestat_open,
5512         .llseek =       lpfc_debugfs_lseek,
5513         .read =         lpfc_debugfs_read,
5514         .write =        lpfc_debugfs_nvmestat_write,
5515         .release =      lpfc_debugfs_release,
5516 };
5517
5518 #undef lpfc_debugfs_op_scsistat
5519 static const struct file_operations lpfc_debugfs_op_scsistat = {
5520         .owner =        THIS_MODULE,
5521         .open =         lpfc_debugfs_scsistat_open,
5522         .llseek =       lpfc_debugfs_lseek,
5523         .read =         lpfc_debugfs_read,
5524         .write =        lpfc_debugfs_scsistat_write,
5525         .release =      lpfc_debugfs_release,
5526 };
5527
5528 #undef lpfc_debugfs_op_ioktime
5529 static const struct file_operations lpfc_debugfs_op_ioktime = {
5530         .owner =        THIS_MODULE,
5531         .open =         lpfc_debugfs_ioktime_open,
5532         .llseek =       lpfc_debugfs_lseek,
5533         .read =         lpfc_debugfs_read,
5534         .write =        lpfc_debugfs_ioktime_write,
5535         .release =      lpfc_debugfs_release,
5536 };
5537
5538 #undef lpfc_debugfs_op_nvmeio_trc
5539 static const struct file_operations lpfc_debugfs_op_nvmeio_trc = {
5540         .owner =        THIS_MODULE,
5541         .open =         lpfc_debugfs_nvmeio_trc_open,
5542         .llseek =       lpfc_debugfs_lseek,
5543         .read =         lpfc_debugfs_read,
5544         .write =        lpfc_debugfs_nvmeio_trc_write,
5545         .release =      lpfc_debugfs_release,
5546 };
5547
5548 #undef lpfc_debugfs_op_hdwqstat
5549 static const struct file_operations lpfc_debugfs_op_hdwqstat = {
5550         .owner =        THIS_MODULE,
5551         .open =         lpfc_debugfs_hdwqstat_open,
5552         .llseek =       lpfc_debugfs_lseek,
5553         .read =         lpfc_debugfs_read,
5554         .write =        lpfc_debugfs_hdwqstat_write,
5555         .release =      lpfc_debugfs_release,
5556 };
5557
5558 #undef lpfc_debugfs_op_dif_err
5559 static const struct file_operations lpfc_debugfs_op_dif_err = {
5560         .owner =        THIS_MODULE,
5561         .open =         simple_open,
5562         .llseek =       lpfc_debugfs_lseek,
5563         .read =         lpfc_debugfs_dif_err_read,
5564         .write =        lpfc_debugfs_dif_err_write,
5565         .release =      lpfc_debugfs_dif_err_release,
5566 };
5567
5568 #undef lpfc_debugfs_op_slow_ring_trc
5569 static const struct file_operations lpfc_debugfs_op_slow_ring_trc = {
5570         .owner =        THIS_MODULE,
5571         .open =         lpfc_debugfs_slow_ring_trc_open,
5572         .llseek =       lpfc_debugfs_lseek,
5573         .read =         lpfc_debugfs_read,
5574         .release =      lpfc_debugfs_release,
5575 };
5576
5577 static struct dentry *lpfc_debugfs_root = NULL;
5578 static atomic_t lpfc_debugfs_hba_count;
5579
5580 /*
5581  * File operations for the iDiag debugfs
5582  */
5583 #undef lpfc_idiag_op_pciCfg
5584 static const struct file_operations lpfc_idiag_op_pciCfg = {
5585         .owner =        THIS_MODULE,
5586         .open =         lpfc_idiag_open,
5587         .llseek =       lpfc_debugfs_lseek,
5588         .read =         lpfc_idiag_pcicfg_read,
5589         .write =        lpfc_idiag_pcicfg_write,
5590         .release =      lpfc_idiag_cmd_release,
5591 };
5592
5593 #undef lpfc_idiag_op_barAcc
5594 static const struct file_operations lpfc_idiag_op_barAcc = {
5595         .owner =        THIS_MODULE,
5596         .open =         lpfc_idiag_open,
5597         .llseek =       lpfc_debugfs_lseek,
5598         .read =         lpfc_idiag_baracc_read,
5599         .write =        lpfc_idiag_baracc_write,
5600         .release =      lpfc_idiag_cmd_release,
5601 };
5602
5603 #undef lpfc_idiag_op_queInfo
5604 static const struct file_operations lpfc_idiag_op_queInfo = {
5605         .owner =        THIS_MODULE,
5606         .open =         lpfc_idiag_open,
5607         .read =         lpfc_idiag_queinfo_read,
5608         .release =      lpfc_idiag_release,
5609 };
5610
5611 #undef lpfc_idiag_op_queAcc
5612 static const struct file_operations lpfc_idiag_op_queAcc = {
5613         .owner =        THIS_MODULE,
5614         .open =         lpfc_idiag_open,
5615         .llseek =       lpfc_debugfs_lseek,
5616         .read =         lpfc_idiag_queacc_read,
5617         .write =        lpfc_idiag_queacc_write,
5618         .release =      lpfc_idiag_cmd_release,
5619 };
5620
5621 #undef lpfc_idiag_op_drbAcc
5622 static const struct file_operations lpfc_idiag_op_drbAcc = {
5623         .owner =        THIS_MODULE,
5624         .open =         lpfc_idiag_open,
5625         .llseek =       lpfc_debugfs_lseek,
5626         .read =         lpfc_idiag_drbacc_read,
5627         .write =        lpfc_idiag_drbacc_write,
5628         .release =      lpfc_idiag_cmd_release,
5629 };
5630
5631 #undef lpfc_idiag_op_ctlAcc
5632 static const struct file_operations lpfc_idiag_op_ctlAcc = {
5633         .owner =        THIS_MODULE,
5634         .open =         lpfc_idiag_open,
5635         .llseek =       lpfc_debugfs_lseek,
5636         .read =         lpfc_idiag_ctlacc_read,
5637         .write =        lpfc_idiag_ctlacc_write,
5638         .release =      lpfc_idiag_cmd_release,
5639 };
5640
5641 #undef lpfc_idiag_op_mbxAcc
5642 static const struct file_operations lpfc_idiag_op_mbxAcc = {
5643         .owner =        THIS_MODULE,
5644         .open =         lpfc_idiag_open,
5645         .llseek =       lpfc_debugfs_lseek,
5646         .read =         lpfc_idiag_mbxacc_read,
5647         .write =        lpfc_idiag_mbxacc_write,
5648         .release =      lpfc_idiag_cmd_release,
5649 };
5650
5651 #undef lpfc_idiag_op_extAcc
5652 static const struct file_operations lpfc_idiag_op_extAcc = {
5653         .owner =        THIS_MODULE,
5654         .open =         lpfc_idiag_open,
5655         .llseek =       lpfc_debugfs_lseek,
5656         .read =         lpfc_idiag_extacc_read,
5657         .write =        lpfc_idiag_extacc_write,
5658         .release =      lpfc_idiag_cmd_release,
5659 };
5660 #endif
5661
5662 /* lpfc_idiag_mbxacc_dump_bsg_mbox - idiag debugfs dump bsg mailbox command
5663  * @phba: Pointer to HBA context object.
5664  * @dmabuf: Pointer to a DMA buffer descriptor.
5665  *
5666  * Description:
5667  * This routine dump a bsg pass-through non-embedded mailbox command with
5668  * external buffer.
5669  **/
5670 void
5671 lpfc_idiag_mbxacc_dump_bsg_mbox(struct lpfc_hba *phba, enum nemb_type nemb_tp,
5672                                 enum mbox_type mbox_tp, enum dma_type dma_tp,
5673                                 enum sta_type sta_tp,
5674                                 struct lpfc_dmabuf *dmabuf, uint32_t ext_buf)
5675 {
5676 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
5677         uint32_t *mbx_mbox_cmd, *mbx_dump_map, *mbx_dump_cnt, *mbx_word_cnt;
5678         char line_buf[LPFC_MBX_ACC_LBUF_SZ];
5679         int len = 0;
5680         uint32_t do_dump = 0;
5681         uint32_t *pword;
5682         uint32_t i;
5683
5684         if (idiag.cmd.opcode != LPFC_IDIAG_BSG_MBXACC_DP)
5685                 return;
5686
5687         mbx_mbox_cmd = &idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX];
5688         mbx_dump_map = &idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX];
5689         mbx_dump_cnt = &idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX];
5690         mbx_word_cnt = &idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX];
5691
5692         if (!(*mbx_dump_map & LPFC_MBX_DMP_ALL) ||
5693             (*mbx_dump_cnt == 0) ||
5694             (*mbx_word_cnt == 0))
5695                 return;
5696
5697         if (*mbx_mbox_cmd != 0x9B)
5698                 return;
5699
5700         if ((mbox_tp == mbox_rd) && (dma_tp == dma_mbox)) {
5701                 if (*mbx_dump_map & LPFC_BSG_DMP_MBX_RD_MBX) {
5702                         do_dump |= LPFC_BSG_DMP_MBX_RD_MBX;
5703                         pr_err("\nRead mbox command (x%x), "
5704                                "nemb:0x%x, extbuf_cnt:%d:\n",
5705                                sta_tp, nemb_tp, ext_buf);
5706                 }
5707         }
5708         if ((mbox_tp == mbox_rd) && (dma_tp == dma_ebuf)) {
5709                 if (*mbx_dump_map & LPFC_BSG_DMP_MBX_RD_BUF) {
5710                         do_dump |= LPFC_BSG_DMP_MBX_RD_BUF;
5711                         pr_err("\nRead mbox buffer (x%x), "
5712                                "nemb:0x%x, extbuf_seq:%d:\n",
5713                                sta_tp, nemb_tp, ext_buf);
5714                 }
5715         }
5716         if ((mbox_tp == mbox_wr) && (dma_tp == dma_mbox)) {
5717                 if (*mbx_dump_map & LPFC_BSG_DMP_MBX_WR_MBX) {
5718                         do_dump |= LPFC_BSG_DMP_MBX_WR_MBX;
5719                         pr_err("\nWrite mbox command (x%x), "
5720                                "nemb:0x%x, extbuf_cnt:%d:\n",
5721                                sta_tp, nemb_tp, ext_buf);
5722                 }
5723         }
5724         if ((mbox_tp == mbox_wr) && (dma_tp == dma_ebuf)) {
5725                 if (*mbx_dump_map & LPFC_BSG_DMP_MBX_WR_BUF) {
5726                         do_dump |= LPFC_BSG_DMP_MBX_WR_BUF;
5727                         pr_err("\nWrite mbox buffer (x%x), "
5728                                "nemb:0x%x, extbuf_seq:%d:\n",
5729                                sta_tp, nemb_tp, ext_buf);
5730                 }
5731         }
5732
5733         /* dump buffer content */
5734         if (do_dump) {
5735                 pword = (uint32_t *)dmabuf->virt;
5736                 for (i = 0; i < *mbx_word_cnt; i++) {
5737                         if (!(i % 8)) {
5738                                 if (i != 0)
5739                                         pr_err("%s\n", line_buf);
5740                                 len = 0;
5741                                 len += scnprintf(line_buf+len,
5742                                                 LPFC_MBX_ACC_LBUF_SZ-len,
5743                                                 "%03d: ", i);
5744                         }
5745                         len += scnprintf(line_buf+len, LPFC_MBX_ACC_LBUF_SZ-len,
5746                                         "%08x ", (uint32_t)*pword);
5747                         pword++;
5748                 }
5749                 if ((i - 1) % 8)
5750                         pr_err("%s\n", line_buf);
5751                 (*mbx_dump_cnt)--;
5752         }
5753
5754         /* Clean out command structure on reaching dump count */
5755         if (*mbx_dump_cnt == 0)
5756                 memset(&idiag, 0, sizeof(idiag));
5757         return;
5758 #endif
5759 }
5760
5761 /* lpfc_idiag_mbxacc_dump_issue_mbox - idiag debugfs dump issue mailbox command
5762  * @phba: Pointer to HBA context object.
5763  * @dmabuf: Pointer to a DMA buffer descriptor.
5764  *
5765  * Description:
5766  * This routine dump a pass-through non-embedded mailbox command from issue
5767  * mailbox command.
5768  **/
5769 void
5770 lpfc_idiag_mbxacc_dump_issue_mbox(struct lpfc_hba *phba, MAILBOX_t *pmbox)
5771 {
5772 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
5773         uint32_t *mbx_dump_map, *mbx_dump_cnt, *mbx_word_cnt, *mbx_mbox_cmd;
5774         char line_buf[LPFC_MBX_ACC_LBUF_SZ];
5775         int len = 0;
5776         uint32_t *pword;
5777         uint8_t *pbyte;
5778         uint32_t i, j;
5779
5780         if (idiag.cmd.opcode != LPFC_IDIAG_CMD_MBXACC_DP)
5781                 return;
5782
5783         mbx_mbox_cmd = &idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX];
5784         mbx_dump_map = &idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX];
5785         mbx_dump_cnt = &idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX];
5786         mbx_word_cnt = &idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX];
5787
5788         if (!(*mbx_dump_map & LPFC_MBX_DMP_MBX_ALL) ||
5789             (*mbx_dump_cnt == 0) ||
5790             (*mbx_word_cnt == 0))
5791                 return;
5792
5793         if ((*mbx_mbox_cmd != LPFC_MBX_ALL_CMD) &&
5794             (*mbx_mbox_cmd != pmbox->mbxCommand))
5795                 return;
5796
5797         /* dump buffer content */
5798         if (*mbx_dump_map & LPFC_MBX_DMP_MBX_WORD) {
5799                 pr_err("Mailbox command:0x%x dump by word:\n",
5800                        pmbox->mbxCommand);
5801                 pword = (uint32_t *)pmbox;
5802                 for (i = 0; i < *mbx_word_cnt; i++) {
5803                         if (!(i % 8)) {
5804                                 if (i != 0)
5805                                         pr_err("%s\n", line_buf);
5806                                 len = 0;
5807                                 memset(line_buf, 0, LPFC_MBX_ACC_LBUF_SZ);
5808                                 len += scnprintf(line_buf+len,
5809                                                 LPFC_MBX_ACC_LBUF_SZ-len,
5810                                                 "%03d: ", i);
5811                         }
5812                         len += scnprintf(line_buf+len, LPFC_MBX_ACC_LBUF_SZ-len,
5813                                         "%08x ",
5814                                         ((uint32_t)*pword) & 0xffffffff);
5815                         pword++;
5816                 }
5817                 if ((i - 1) % 8)
5818                         pr_err("%s\n", line_buf);
5819                 pr_err("\n");
5820         }
5821         if (*mbx_dump_map & LPFC_MBX_DMP_MBX_BYTE) {
5822                 pr_err("Mailbox command:0x%x dump by byte:\n",
5823                        pmbox->mbxCommand);
5824                 pbyte = (uint8_t *)pmbox;
5825                 for (i = 0; i < *mbx_word_cnt; i++) {
5826                         if (!(i % 8)) {
5827                                 if (i != 0)
5828                                         pr_err("%s\n", line_buf);
5829                                 len = 0;
5830                                 memset(line_buf, 0, LPFC_MBX_ACC_LBUF_SZ);
5831                                 len += scnprintf(line_buf+len,
5832                                                 LPFC_MBX_ACC_LBUF_SZ-len,
5833                                                 "%03d: ", i);
5834                         }
5835                         for (j = 0; j < 4; j++) {
5836                                 len += scnprintf(line_buf+len,
5837                                                 LPFC_MBX_ACC_LBUF_SZ-len,
5838                                                 "%02x",
5839                                                 ((uint8_t)*pbyte) & 0xff);
5840                                 pbyte++;
5841                         }
5842                         len += scnprintf(line_buf+len,
5843                                         LPFC_MBX_ACC_LBUF_SZ-len, " ");
5844                 }
5845                 if ((i - 1) % 8)
5846                         pr_err("%s\n", line_buf);
5847                 pr_err("\n");
5848         }
5849         (*mbx_dump_cnt)--;
5850
5851         /* Clean out command structure on reaching dump count */
5852         if (*mbx_dump_cnt == 0)
5853                 memset(&idiag, 0, sizeof(idiag));
5854         return;
5855 #endif
5856 }
5857
5858 /**
5859  * lpfc_debugfs_initialize - Initialize debugfs for a vport
5860  * @vport: The vport pointer to initialize.
5861  *
5862  * Description:
5863  * When Debugfs is configured this routine sets up the lpfc debugfs file system.
5864  * If not already created, this routine will create the lpfc directory, and
5865  * lpfcX directory (for this HBA), and vportX directory for this vport. It will
5866  * also create each file used to access lpfc specific debugfs information.
5867  **/
5868 inline void
5869 lpfc_debugfs_initialize(struct lpfc_vport *vport)
5870 {
5871 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
5872         struct lpfc_hba   *phba = vport->phba;
5873         char name[64];
5874         uint32_t num, i;
5875         bool pport_setup = false;
5876
5877         if (!lpfc_debugfs_enable)
5878                 return;
5879
5880         /* Setup lpfc root directory */
5881         if (!lpfc_debugfs_root) {
5882                 lpfc_debugfs_root = debugfs_create_dir("lpfc", NULL);
5883                 atomic_set(&lpfc_debugfs_hba_count, 0);
5884         }
5885         if (!lpfc_debugfs_start_time)
5886                 lpfc_debugfs_start_time = jiffies;
5887
5888         /* Setup funcX directory for specific HBA PCI function */
5889         snprintf(name, sizeof(name), "fn%d", phba->brd_no);
5890         if (!phba->hba_debugfs_root) {
5891                 pport_setup = true;
5892                 phba->hba_debugfs_root =
5893                         debugfs_create_dir(name, lpfc_debugfs_root);
5894                 atomic_inc(&lpfc_debugfs_hba_count);
5895                 atomic_set(&phba->debugfs_vport_count, 0);
5896
5897                 /* Multi-XRI pools */
5898                 snprintf(name, sizeof(name), "multixripools");
5899                 phba->debug_multixri_pools =
5900                         debugfs_create_file(name, S_IFREG | 0644,
5901                                             phba->hba_debugfs_root,
5902                                             phba,
5903                                             &lpfc_debugfs_op_multixripools);
5904                 if (!phba->debug_multixri_pools) {
5905                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
5906                                          "0527 Cannot create debugfs multixripools\n");
5907                         goto debug_failed;
5908                 }
5909
5910                 /* RAS log */
5911                 snprintf(name, sizeof(name), "ras_log");
5912                 phba->debug_ras_log =
5913                         debugfs_create_file(name, 0644,
5914                                             phba->hba_debugfs_root,
5915                                             phba, &lpfc_debugfs_ras_log);
5916                 if (!phba->debug_ras_log) {
5917                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
5918                                          "6148 Cannot create debugfs"
5919                                          " ras_log\n");
5920                         goto debug_failed;
5921                 }
5922
5923                 /* Setup hbqinfo */
5924                 snprintf(name, sizeof(name), "hbqinfo");
5925                 phba->debug_hbqinfo =
5926                         debugfs_create_file(name, S_IFREG | 0644,
5927                                             phba->hba_debugfs_root,
5928                                             phba, &lpfc_debugfs_op_hbqinfo);
5929
5930 #ifdef LPFC_HDWQ_LOCK_STAT
5931                 /* Setup lockstat */
5932                 snprintf(name, sizeof(name), "lockstat");
5933                 phba->debug_lockstat =
5934                         debugfs_create_file(name, S_IFREG | 0644,
5935                                             phba->hba_debugfs_root,
5936                                             phba, &lpfc_debugfs_op_lockstat);
5937                 if (!phba->debug_lockstat) {
5938                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
5939                                          "4610 Can't create debugfs lockstat\n");
5940                         goto debug_failed;
5941                 }
5942 #endif
5943
5944                 /* Setup dumpHBASlim */
5945                 if (phba->sli_rev < LPFC_SLI_REV4) {
5946                         snprintf(name, sizeof(name), "dumpHBASlim");
5947                         phba->debug_dumpHBASlim =
5948                                 debugfs_create_file(name,
5949                                         S_IFREG|S_IRUGO|S_IWUSR,
5950                                         phba->hba_debugfs_root,
5951                                         phba, &lpfc_debugfs_op_dumpHBASlim);
5952                 } else
5953                         phba->debug_dumpHBASlim = NULL;
5954
5955                 /* Setup dumpHostSlim */
5956                 if (phba->sli_rev < LPFC_SLI_REV4) {
5957                         snprintf(name, sizeof(name), "dumpHostSlim");
5958                         phba->debug_dumpHostSlim =
5959                                 debugfs_create_file(name,
5960                                         S_IFREG|S_IRUGO|S_IWUSR,
5961                                         phba->hba_debugfs_root,
5962                                         phba, &lpfc_debugfs_op_dumpHostSlim);
5963                 } else
5964                         phba->debug_dumpHostSlim = NULL;
5965
5966                 /* Setup DIF Error Injections */
5967                 snprintf(name, sizeof(name), "InjErrLBA");
5968                 phba->debug_InjErrLBA =
5969                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
5970                         phba->hba_debugfs_root,
5971                         phba, &lpfc_debugfs_op_dif_err);
5972                 phba->lpfc_injerr_lba = LPFC_INJERR_LBA_OFF;
5973
5974                 snprintf(name, sizeof(name), "InjErrNPortID");
5975                 phba->debug_InjErrNPortID =
5976                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
5977                         phba->hba_debugfs_root,
5978                         phba, &lpfc_debugfs_op_dif_err);
5979
5980                 snprintf(name, sizeof(name), "InjErrWWPN");
5981                 phba->debug_InjErrWWPN =
5982                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
5983                         phba->hba_debugfs_root,
5984                         phba, &lpfc_debugfs_op_dif_err);
5985
5986                 snprintf(name, sizeof(name), "writeGuardInjErr");
5987                 phba->debug_writeGuard =
5988                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
5989                         phba->hba_debugfs_root,
5990                         phba, &lpfc_debugfs_op_dif_err);
5991
5992                 snprintf(name, sizeof(name), "writeAppInjErr");
5993                 phba->debug_writeApp =
5994                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
5995                         phba->hba_debugfs_root,
5996                         phba, &lpfc_debugfs_op_dif_err);
5997
5998                 snprintf(name, sizeof(name), "writeRefInjErr");
5999                 phba->debug_writeRef =
6000                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6001                         phba->hba_debugfs_root,
6002                         phba, &lpfc_debugfs_op_dif_err);
6003
6004                 snprintf(name, sizeof(name), "readGuardInjErr");
6005                 phba->debug_readGuard =
6006                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6007                         phba->hba_debugfs_root,
6008                         phba, &lpfc_debugfs_op_dif_err);
6009
6010                 snprintf(name, sizeof(name), "readAppInjErr");
6011                 phba->debug_readApp =
6012                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6013                         phba->hba_debugfs_root,
6014                         phba, &lpfc_debugfs_op_dif_err);
6015
6016                 snprintf(name, sizeof(name), "readRefInjErr");
6017                 phba->debug_readRef =
6018                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6019                         phba->hba_debugfs_root,
6020                         phba, &lpfc_debugfs_op_dif_err);
6021
6022                 /* Setup slow ring trace */
6023                 if (lpfc_debugfs_max_slow_ring_trc) {
6024                         num = lpfc_debugfs_max_slow_ring_trc - 1;
6025                         if (num & lpfc_debugfs_max_slow_ring_trc) {
6026                                 /* Change to be a power of 2 */
6027                                 num = lpfc_debugfs_max_slow_ring_trc;
6028                                 i = 0;
6029                                 while (num > 1) {
6030                                         num = num >> 1;
6031                                         i++;
6032                                 }
6033                                 lpfc_debugfs_max_slow_ring_trc = (1 << i);
6034                                 pr_err("lpfc_debugfs_max_disc_trc changed to "
6035                                        "%d\n", lpfc_debugfs_max_disc_trc);
6036                         }
6037                 }
6038
6039                 snprintf(name, sizeof(name), "slow_ring_trace");
6040                 phba->debug_slow_ring_trc =
6041                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6042                                  phba->hba_debugfs_root,
6043                                  phba, &lpfc_debugfs_op_slow_ring_trc);
6044                 if (!phba->slow_ring_trc) {
6045                         phba->slow_ring_trc = kmalloc(
6046                                 (sizeof(struct lpfc_debugfs_trc) *
6047                                 lpfc_debugfs_max_slow_ring_trc),
6048                                 GFP_KERNEL);
6049                         if (!phba->slow_ring_trc) {
6050                                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
6051                                                  "0416 Cannot create debugfs "
6052                                                  "slow_ring buffer\n");
6053                                 goto debug_failed;
6054                         }
6055                         atomic_set(&phba->slow_ring_trc_cnt, 0);
6056                         memset(phba->slow_ring_trc, 0,
6057                                 (sizeof(struct lpfc_debugfs_trc) *
6058                                 lpfc_debugfs_max_slow_ring_trc));
6059                 }
6060
6061                 snprintf(name, sizeof(name), "nvmeio_trc");
6062                 phba->debug_nvmeio_trc =
6063                         debugfs_create_file(name, 0644,
6064                                             phba->hba_debugfs_root,
6065                                             phba, &lpfc_debugfs_op_nvmeio_trc);
6066
6067                 atomic_set(&phba->nvmeio_trc_cnt, 0);
6068                 if (lpfc_debugfs_max_nvmeio_trc) {
6069                         num = lpfc_debugfs_max_nvmeio_trc - 1;
6070                         if (num & lpfc_debugfs_max_disc_trc) {
6071                                 /* Change to be a power of 2 */
6072                                 num = lpfc_debugfs_max_nvmeio_trc;
6073                                 i = 0;
6074                                 while (num > 1) {
6075                                         num = num >> 1;
6076                                         i++;
6077                                 }
6078                                 lpfc_debugfs_max_nvmeio_trc = (1 << i);
6079                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6080                                                 "0575 lpfc_debugfs_max_nvmeio_trc "
6081                                                 "changed to %d\n",
6082                                                 lpfc_debugfs_max_nvmeio_trc);
6083                         }
6084                         phba->nvmeio_trc_size = lpfc_debugfs_max_nvmeio_trc;
6085
6086                         /* Allocate trace buffer and initialize */
6087                         phba->nvmeio_trc = kzalloc(
6088                                 (sizeof(struct lpfc_debugfs_nvmeio_trc) *
6089                                 phba->nvmeio_trc_size), GFP_KERNEL);
6090
6091                         if (!phba->nvmeio_trc) {
6092                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6093                                                 "0576 Cannot create debugfs "
6094                                                 "nvmeio_trc buffer\n");
6095                                 goto nvmeio_off;
6096                         }
6097                         phba->nvmeio_trc_on = 1;
6098                         phba->nvmeio_trc_output_idx = 0;
6099                         phba->nvmeio_trc = NULL;
6100                 } else {
6101 nvmeio_off:
6102                         phba->nvmeio_trc_size = 0;
6103                         phba->nvmeio_trc_on = 0;
6104                         phba->nvmeio_trc_output_idx = 0;
6105                         phba->nvmeio_trc = NULL;
6106                 }
6107         }
6108
6109         snprintf(name, sizeof(name), "vport%d", vport->vpi);
6110         if (!vport->vport_debugfs_root) {
6111                 vport->vport_debugfs_root =
6112                         debugfs_create_dir(name, phba->hba_debugfs_root);
6113                 atomic_inc(&phba->debugfs_vport_count);
6114         }
6115
6116         if (lpfc_debugfs_max_disc_trc) {
6117                 num = lpfc_debugfs_max_disc_trc - 1;
6118                 if (num & lpfc_debugfs_max_disc_trc) {
6119                         /* Change to be a power of 2 */
6120                         num = lpfc_debugfs_max_disc_trc;
6121                         i = 0;
6122                         while (num > 1) {
6123                                 num = num >> 1;
6124                                 i++;
6125                         }
6126                         lpfc_debugfs_max_disc_trc = (1 << i);
6127                         pr_err("lpfc_debugfs_max_disc_trc changed to %d\n",
6128                                lpfc_debugfs_max_disc_trc);
6129                 }
6130         }
6131
6132         vport->disc_trc = kzalloc(
6133                 (sizeof(struct lpfc_debugfs_trc) * lpfc_debugfs_max_disc_trc),
6134                 GFP_KERNEL);
6135
6136         if (!vport->disc_trc) {
6137                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
6138                                  "0418 Cannot create debugfs disc trace "
6139                                  "buffer\n");
6140                 goto debug_failed;
6141         }
6142         atomic_set(&vport->disc_trc_cnt, 0);
6143
6144         snprintf(name, sizeof(name), "discovery_trace");
6145         vport->debug_disc_trc =
6146                 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6147                                  vport->vport_debugfs_root,
6148                                  vport, &lpfc_debugfs_op_disc_trc);
6149         snprintf(name, sizeof(name), "nodelist");
6150         vport->debug_nodelist =
6151                 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6152                                  vport->vport_debugfs_root,
6153                                  vport, &lpfc_debugfs_op_nodelist);
6154
6155         snprintf(name, sizeof(name), "nvmestat");
6156         vport->debug_nvmestat =
6157                 debugfs_create_file(name, 0644,
6158                                     vport->vport_debugfs_root,
6159                                     vport, &lpfc_debugfs_op_nvmestat);
6160
6161         snprintf(name, sizeof(name), "scsistat");
6162         vport->debug_scsistat =
6163                 debugfs_create_file(name, 0644,
6164                                     vport->vport_debugfs_root,
6165                                     vport, &lpfc_debugfs_op_scsistat);
6166         if (!vport->debug_scsistat) {
6167                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
6168                                  "4611 Cannot create debugfs scsistat\n");
6169                 goto debug_failed;
6170         }
6171
6172         snprintf(name, sizeof(name), "ioktime");
6173         vport->debug_ioktime =
6174                 debugfs_create_file(name, 0644,
6175                                     vport->vport_debugfs_root,
6176                                     vport, &lpfc_debugfs_op_ioktime);
6177         if (!vport->debug_ioktime) {
6178                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
6179                                  "0815 Cannot create debugfs ioktime\n");
6180                 goto debug_failed;
6181         }
6182
6183         snprintf(name, sizeof(name), "hdwqstat");
6184         vport->debug_hdwqstat =
6185                 debugfs_create_file(name, 0644,
6186                                     vport->vport_debugfs_root,
6187                                     vport, &lpfc_debugfs_op_hdwqstat);
6188
6189         /*
6190          * The following section is for additional directories/files for the
6191          * physical port.
6192          */
6193
6194         if (!pport_setup)
6195                 goto debug_failed;
6196
6197         /*
6198          * iDiag debugfs root entry points for SLI4 device only
6199          */
6200         if (phba->sli_rev < LPFC_SLI_REV4)
6201                 goto debug_failed;
6202
6203         snprintf(name, sizeof(name), "iDiag");
6204         if (!phba->idiag_root) {
6205                 phba->idiag_root =
6206                         debugfs_create_dir(name, phba->hba_debugfs_root);
6207                 /* Initialize iDiag data structure */
6208                 memset(&idiag, 0, sizeof(idiag));
6209         }
6210
6211         /* iDiag read PCI config space */
6212         snprintf(name, sizeof(name), "pciCfg");
6213         if (!phba->idiag_pci_cfg) {
6214                 phba->idiag_pci_cfg =
6215                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6216                                 phba->idiag_root, phba, &lpfc_idiag_op_pciCfg);
6217                 idiag.offset.last_rd = 0;
6218         }
6219
6220         /* iDiag PCI BAR access */
6221         snprintf(name, sizeof(name), "barAcc");
6222         if (!phba->idiag_bar_acc) {
6223                 phba->idiag_bar_acc =
6224                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6225                                 phba->idiag_root, phba, &lpfc_idiag_op_barAcc);
6226                 idiag.offset.last_rd = 0;
6227         }
6228
6229         /* iDiag get PCI function queue information */
6230         snprintf(name, sizeof(name), "queInfo");
6231         if (!phba->idiag_que_info) {
6232                 phba->idiag_que_info =
6233                         debugfs_create_file(name, S_IFREG|S_IRUGO,
6234                         phba->idiag_root, phba, &lpfc_idiag_op_queInfo);
6235         }
6236
6237         /* iDiag access PCI function queue */
6238         snprintf(name, sizeof(name), "queAcc");
6239         if (!phba->idiag_que_acc) {
6240                 phba->idiag_que_acc =
6241                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6242                                 phba->idiag_root, phba, &lpfc_idiag_op_queAcc);
6243         }
6244
6245         /* iDiag access PCI function doorbell registers */
6246         snprintf(name, sizeof(name), "drbAcc");
6247         if (!phba->idiag_drb_acc) {
6248                 phba->idiag_drb_acc =
6249                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6250                                 phba->idiag_root, phba, &lpfc_idiag_op_drbAcc);
6251         }
6252
6253         /* iDiag access PCI function control registers */
6254         snprintf(name, sizeof(name), "ctlAcc");
6255         if (!phba->idiag_ctl_acc) {
6256                 phba->idiag_ctl_acc =
6257                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6258                                 phba->idiag_root, phba, &lpfc_idiag_op_ctlAcc);
6259         }
6260
6261         /* iDiag access mbox commands */
6262         snprintf(name, sizeof(name), "mbxAcc");
6263         if (!phba->idiag_mbx_acc) {
6264                 phba->idiag_mbx_acc =
6265                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6266                                 phba->idiag_root, phba, &lpfc_idiag_op_mbxAcc);
6267         }
6268
6269         /* iDiag extents access commands */
6270         if (phba->sli4_hba.extents_in_use) {
6271                 snprintf(name, sizeof(name), "extAcc");
6272                 if (!phba->idiag_ext_acc) {
6273                         phba->idiag_ext_acc =
6274                                 debugfs_create_file(name,
6275                                                     S_IFREG|S_IRUGO|S_IWUSR,
6276                                                     phba->idiag_root, phba,
6277                                                     &lpfc_idiag_op_extAcc);
6278                 }
6279         }
6280
6281 debug_failed:
6282         return;
6283 #endif
6284 }
6285
6286 /**
6287  * lpfc_debugfs_terminate -  Tear down debugfs infrastructure for this vport
6288  * @vport: The vport pointer to remove from debugfs.
6289  *
6290  * Description:
6291  * When Debugfs is configured this routine removes debugfs file system elements
6292  * that are specific to this vport. It also checks to see if there are any
6293  * users left for the debugfs directories associated with the HBA and driver. If
6294  * this is the last user of the HBA directory or driver directory then it will
6295  * remove those from the debugfs infrastructure as well.
6296  **/
6297 inline void
6298 lpfc_debugfs_terminate(struct lpfc_vport *vport)
6299 {
6300 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
6301         struct lpfc_hba   *phba = vport->phba;
6302
6303         kfree(vport->disc_trc);
6304         vport->disc_trc = NULL;
6305
6306         debugfs_remove(vport->debug_disc_trc); /* discovery_trace */
6307         vport->debug_disc_trc = NULL;
6308
6309         debugfs_remove(vport->debug_nodelist); /* nodelist */
6310         vport->debug_nodelist = NULL;
6311
6312         debugfs_remove(vport->debug_nvmestat); /* nvmestat */
6313         vport->debug_nvmestat = NULL;
6314
6315         debugfs_remove(vport->debug_scsistat); /* scsistat */
6316         vport->debug_scsistat = NULL;
6317
6318         debugfs_remove(vport->debug_ioktime); /* ioktime */
6319         vport->debug_ioktime = NULL;
6320
6321         debugfs_remove(vport->debug_hdwqstat); /* hdwqstat */
6322         vport->debug_hdwqstat = NULL;
6323
6324         if (vport->vport_debugfs_root) {
6325                 debugfs_remove(vport->vport_debugfs_root); /* vportX */
6326                 vport->vport_debugfs_root = NULL;
6327                 atomic_dec(&phba->debugfs_vport_count);
6328         }
6329
6330         if (atomic_read(&phba->debugfs_vport_count) == 0) {
6331
6332                 debugfs_remove(phba->debug_multixri_pools); /* multixripools*/
6333                 phba->debug_multixri_pools = NULL;
6334
6335                 debugfs_remove(phba->debug_hbqinfo); /* hbqinfo */
6336                 phba->debug_hbqinfo = NULL;
6337
6338                 debugfs_remove(phba->debug_ras_log);
6339                 phba->debug_ras_log = NULL;
6340
6341 #ifdef LPFC_HDWQ_LOCK_STAT
6342                 debugfs_remove(phba->debug_lockstat); /* lockstat */
6343                 phba->debug_lockstat = NULL;
6344 #endif
6345                 debugfs_remove(phba->debug_dumpHBASlim); /* HBASlim */
6346                 phba->debug_dumpHBASlim = NULL;
6347
6348                 debugfs_remove(phba->debug_dumpHostSlim); /* HostSlim */
6349                 phba->debug_dumpHostSlim = NULL;
6350
6351                 debugfs_remove(phba->debug_InjErrLBA); /* InjErrLBA */
6352                 phba->debug_InjErrLBA = NULL;
6353
6354                 debugfs_remove(phba->debug_InjErrNPortID);
6355                 phba->debug_InjErrNPortID = NULL;
6356
6357                 debugfs_remove(phba->debug_InjErrWWPN); /* InjErrWWPN */
6358                 phba->debug_InjErrWWPN = NULL;
6359
6360                 debugfs_remove(phba->debug_writeGuard); /* writeGuard */
6361                 phba->debug_writeGuard = NULL;
6362
6363                 debugfs_remove(phba->debug_writeApp); /* writeApp */
6364                 phba->debug_writeApp = NULL;
6365
6366                 debugfs_remove(phba->debug_writeRef); /* writeRef */
6367                 phba->debug_writeRef = NULL;
6368
6369                 debugfs_remove(phba->debug_readGuard); /* readGuard */
6370                 phba->debug_readGuard = NULL;
6371
6372                 debugfs_remove(phba->debug_readApp); /* readApp */
6373                 phba->debug_readApp = NULL;
6374
6375                 debugfs_remove(phba->debug_readRef); /* readRef */
6376                 phba->debug_readRef = NULL;
6377
6378                 kfree(phba->slow_ring_trc);
6379                 phba->slow_ring_trc = NULL;
6380
6381                 /* slow_ring_trace */
6382                 debugfs_remove(phba->debug_slow_ring_trc);
6383                 phba->debug_slow_ring_trc = NULL;
6384
6385                 debugfs_remove(phba->debug_nvmeio_trc);
6386                 phba->debug_nvmeio_trc = NULL;
6387
6388                 kfree(phba->nvmeio_trc);
6389                 phba->nvmeio_trc = NULL;
6390
6391                 /*
6392                  * iDiag release
6393                  */
6394                 if (phba->sli_rev == LPFC_SLI_REV4) {
6395                         /* iDiag extAcc */
6396                         debugfs_remove(phba->idiag_ext_acc);
6397                         phba->idiag_ext_acc = NULL;
6398
6399                         /* iDiag mbxAcc */
6400                         debugfs_remove(phba->idiag_mbx_acc);
6401                         phba->idiag_mbx_acc = NULL;
6402
6403                         /* iDiag ctlAcc */
6404                         debugfs_remove(phba->idiag_ctl_acc);
6405                         phba->idiag_ctl_acc = NULL;
6406
6407                         /* iDiag drbAcc */
6408                         debugfs_remove(phba->idiag_drb_acc);
6409                         phba->idiag_drb_acc = NULL;
6410
6411                         /* iDiag queAcc */
6412                         debugfs_remove(phba->idiag_que_acc);
6413                         phba->idiag_que_acc = NULL;
6414
6415                         /* iDiag queInfo */
6416                         debugfs_remove(phba->idiag_que_info);
6417                         phba->idiag_que_info = NULL;
6418
6419                         /* iDiag barAcc */
6420                         debugfs_remove(phba->idiag_bar_acc);
6421                         phba->idiag_bar_acc = NULL;
6422
6423                         /* iDiag pciCfg */
6424                         debugfs_remove(phba->idiag_pci_cfg);
6425                         phba->idiag_pci_cfg = NULL;
6426
6427                         /* Finally remove the iDiag debugfs root */
6428                         debugfs_remove(phba->idiag_root);
6429                         phba->idiag_root = NULL;
6430                 }
6431
6432                 if (phba->hba_debugfs_root) {
6433                         debugfs_remove(phba->hba_debugfs_root); /* fnX */
6434                         phba->hba_debugfs_root = NULL;
6435                         atomic_dec(&lpfc_debugfs_hba_count);
6436                 }
6437
6438                 if (atomic_read(&lpfc_debugfs_hba_count) == 0) {
6439                         debugfs_remove(lpfc_debugfs_root); /* lpfc */
6440                         lpfc_debugfs_root = NULL;
6441                 }
6442         }
6443 #endif
6444         return;
6445 }
6446
6447 /*
6448  * Driver debug utility routines outside of debugfs. The debug utility
6449  * routines implemented here is intended to be used in the instrumented
6450  * debug driver for debugging host or port issues.
6451  */
6452
6453 /**
6454  * lpfc_debug_dump_all_queues - dump all the queues with a hba
6455  * @phba: Pointer to HBA context object.
6456  *
6457  * This function dumps entries of all the queues asociated with the @phba.
6458  **/
6459 void
6460 lpfc_debug_dump_all_queues(struct lpfc_hba *phba)
6461 {
6462         int idx;
6463
6464         /*
6465          * Dump Work Queues (WQs)
6466          */
6467         lpfc_debug_dump_wq(phba, DUMP_MBX, 0);
6468         lpfc_debug_dump_wq(phba, DUMP_ELS, 0);
6469         lpfc_debug_dump_wq(phba, DUMP_NVMELS, 0);
6470
6471         for (idx = 0; idx < phba->cfg_hdw_queue; idx++)
6472                 lpfc_debug_dump_wq(phba, DUMP_IO, idx);
6473
6474         lpfc_debug_dump_hdr_rq(phba);
6475         lpfc_debug_dump_dat_rq(phba);
6476         /*
6477          * Dump Complete Queues (CQs)
6478          */
6479         lpfc_debug_dump_cq(phba, DUMP_MBX, 0);
6480         lpfc_debug_dump_cq(phba, DUMP_ELS, 0);
6481         lpfc_debug_dump_cq(phba, DUMP_NVMELS, 0);
6482
6483         for (idx = 0; idx < phba->cfg_hdw_queue; idx++)
6484                 lpfc_debug_dump_cq(phba, DUMP_IO, idx);
6485
6486         /*
6487          * Dump Event Queues (EQs)
6488          */
6489         for (idx = 0; idx < phba->cfg_hdw_queue; idx++)
6490                 lpfc_debug_dump_hba_eq(phba, idx);
6491 }