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