1 /******************************************************************* 2 * This file is part of the Emulex Linux Device Driver for * 3 * Fibre Channel Host Bus Adapters. * 4 * Copyright (C) 2007-2011 Emulex. All rights reserved. * 5 * EMULEX and SLI are trademarks of Emulex. * 6 * www.emulex.com * 7 * * 8 * This program is free software; you can redistribute it and/or * 9 * modify it under the terms of version 2 of the GNU General * 10 * Public License as published by the Free Software Foundation. * 11 * This program is distributed in the hope that it will be useful. * 12 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND * 13 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, * 14 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE * 15 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD * 16 * TO BE LEGALLY INVALID. See the GNU General Public License for * 17 * more details, a copy of which can be found in the file COPYING * 18 * included with this package. * 19 *******************************************************************/ 20 21 #include <linux/blkdev.h> 22 #include <linux/delay.h> 23 #include <linux/dma-mapping.h> 24 #include <linux/idr.h> 25 #include <linux/interrupt.h> 26 #include <linux/kthread.h> 27 #include <linux/slab.h> 28 #include <linux/pci.h> 29 #include <linux/spinlock.h> 30 #include <linux/ctype.h> 31 32 #include <scsi/scsi.h> 33 #include <scsi/scsi_device.h> 34 #include <scsi/scsi_host.h> 35 #include <scsi/scsi_transport_fc.h> 36 37 #include "lpfc_hw4.h" 38 #include "lpfc_hw.h" 39 #include "lpfc_sli.h" 40 #include "lpfc_sli4.h" 41 #include "lpfc_nl.h" 42 #include "lpfc_disc.h" 43 #include "lpfc_scsi.h" 44 #include "lpfc.h" 45 #include "lpfc_logmsg.h" 46 #include "lpfc_crtn.h" 47 #include "lpfc_vport.h" 48 #include "lpfc_version.h" 49 #include "lpfc_compat.h" 50 #include "lpfc_debugfs.h" 51 #include "lpfc_bsg.h" 52 53 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 54 /* 55 * debugfs interface 56 * 57 * To access this interface the user should: 58 * # mount -t debugfs none /sys/kernel/debug 59 * 60 * The lpfc debugfs directory hierarchy is: 61 * /sys/kernel/debug/lpfc/fnX/vportY 62 * where X is the lpfc hba function unique_id 63 * where Y is the vport VPI on that hba 64 * 65 * Debugging services available per vport: 66 * discovery_trace 67 * This is an ACSII readable file that contains a trace of the last 68 * lpfc_debugfs_max_disc_trc events that happened on a specific vport. 69 * See lpfc_debugfs.h for different categories of discovery events. 70 * To enable the discovery trace, the following module parameters must be set: 71 * lpfc_debugfs_enable=1 Turns on lpfc debugfs filesystem support 72 * lpfc_debugfs_max_disc_trc=X Where X is the event trace depth for 73 * EACH vport. X MUST also be a power of 2. 74 * lpfc_debugfs_mask_disc_trc=Y Where Y is an event mask as defined in 75 * lpfc_debugfs.h . 76 * 77 * slow_ring_trace 78 * This is an ACSII readable file that contains a trace of the last 79 * lpfc_debugfs_max_slow_ring_trc events that happened on a specific HBA. 80 * To enable the slow ring trace, the following module parameters must be set: 81 * lpfc_debugfs_enable=1 Turns on lpfc debugfs filesystem support 82 * lpfc_debugfs_max_slow_ring_trc=X Where X is the event trace depth for 83 * the HBA. X MUST also be a power of 2. 84 */ 85 static int lpfc_debugfs_enable = 1; 86 module_param(lpfc_debugfs_enable, int, S_IRUGO); 87 MODULE_PARM_DESC(lpfc_debugfs_enable, "Enable debugfs services"); 88 89 /* This MUST be a power of 2 */ 90 static int lpfc_debugfs_max_disc_trc; 91 module_param(lpfc_debugfs_max_disc_trc, int, S_IRUGO); 92 MODULE_PARM_DESC(lpfc_debugfs_max_disc_trc, 93 "Set debugfs discovery trace depth"); 94 95 /* This MUST be a power of 2 */ 96 static int lpfc_debugfs_max_slow_ring_trc; 97 module_param(lpfc_debugfs_max_slow_ring_trc, int, S_IRUGO); 98 MODULE_PARM_DESC(lpfc_debugfs_max_slow_ring_trc, 99 "Set debugfs slow ring trace depth"); 100 101 static int lpfc_debugfs_mask_disc_trc; 102 module_param(lpfc_debugfs_mask_disc_trc, int, S_IRUGO); 103 MODULE_PARM_DESC(lpfc_debugfs_mask_disc_trc, 104 "Set debugfs discovery trace mask"); 105 106 #include <linux/debugfs.h> 107 108 static atomic_t lpfc_debugfs_seq_trc_cnt = ATOMIC_INIT(0); 109 static unsigned long lpfc_debugfs_start_time = 0L; 110 111 /* iDiag */ 112 static struct lpfc_idiag idiag; 113 114 /** 115 * lpfc_debugfs_disc_trc_data - Dump discovery logging to a buffer 116 * @vport: The vport to gather the log info from. 117 * @buf: The buffer to dump log into. 118 * @size: The maximum amount of data to process. 119 * 120 * Description: 121 * This routine gathers the lpfc discovery debugfs data from the @vport and 122 * dumps it to @buf up to @size number of bytes. It will start at the next entry 123 * in the log and process the log until the end of the buffer. Then it will 124 * gather from the beginning of the log and process until the current entry. 125 * 126 * Notes: 127 * Discovery logging will be disabled while while this routine dumps the log. 128 * 129 * Return Value: 130 * This routine returns the amount of bytes that were dumped into @buf and will 131 * not exceed @size. 132 **/ 133 static int 134 lpfc_debugfs_disc_trc_data(struct lpfc_vport *vport, char *buf, int size) 135 { 136 int i, index, len, enable; 137 uint32_t ms; 138 struct lpfc_debugfs_trc *dtp; 139 char *buffer; 140 141 buffer = kmalloc(LPFC_DEBUG_TRC_ENTRY_SIZE, GFP_KERNEL); 142 if (!buffer) 143 return 0; 144 145 enable = lpfc_debugfs_enable; 146 lpfc_debugfs_enable = 0; 147 148 len = 0; 149 index = (atomic_read(&vport->disc_trc_cnt) + 1) & 150 (lpfc_debugfs_max_disc_trc - 1); 151 for (i = index; i < lpfc_debugfs_max_disc_trc; i++) { 152 dtp = vport->disc_trc + i; 153 if (!dtp->fmt) 154 continue; 155 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time); 156 snprintf(buffer, 157 LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n", 158 dtp->seq_cnt, ms, dtp->fmt); 159 len += snprintf(buf+len, size-len, buffer, 160 dtp->data1, dtp->data2, dtp->data3); 161 } 162 for (i = 0; i < index; i++) { 163 dtp = vport->disc_trc + i; 164 if (!dtp->fmt) 165 continue; 166 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time); 167 snprintf(buffer, 168 LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n", 169 dtp->seq_cnt, ms, dtp->fmt); 170 len += snprintf(buf+len, size-len, buffer, 171 dtp->data1, dtp->data2, dtp->data3); 172 } 173 174 lpfc_debugfs_enable = enable; 175 kfree(buffer); 176 177 return len; 178 } 179 180 /** 181 * lpfc_debugfs_slow_ring_trc_data - Dump slow ring logging to a buffer 182 * @phba: The HBA to gather the log info from. 183 * @buf: The buffer to dump log into. 184 * @size: The maximum amount of data to process. 185 * 186 * Description: 187 * This routine gathers the lpfc slow ring debugfs data from the @phba and 188 * dumps it to @buf up to @size number of bytes. It will start at the next entry 189 * in the log and process the log until the end of the buffer. Then it will 190 * gather from the beginning of the log and process until the current entry. 191 * 192 * Notes: 193 * Slow ring logging will be disabled while while this routine dumps the log. 194 * 195 * Return Value: 196 * This routine returns the amount of bytes that were dumped into @buf and will 197 * not exceed @size. 198 **/ 199 static int 200 lpfc_debugfs_slow_ring_trc_data(struct lpfc_hba *phba, char *buf, int size) 201 { 202 int i, index, len, enable; 203 uint32_t ms; 204 struct lpfc_debugfs_trc *dtp; 205 char *buffer; 206 207 buffer = kmalloc(LPFC_DEBUG_TRC_ENTRY_SIZE, GFP_KERNEL); 208 if (!buffer) 209 return 0; 210 211 enable = lpfc_debugfs_enable; 212 lpfc_debugfs_enable = 0; 213 214 len = 0; 215 index = (atomic_read(&phba->slow_ring_trc_cnt) + 1) & 216 (lpfc_debugfs_max_slow_ring_trc - 1); 217 for (i = index; i < lpfc_debugfs_max_slow_ring_trc; i++) { 218 dtp = phba->slow_ring_trc + i; 219 if (!dtp->fmt) 220 continue; 221 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time); 222 snprintf(buffer, 223 LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n", 224 dtp->seq_cnt, ms, dtp->fmt); 225 len += snprintf(buf+len, size-len, buffer, 226 dtp->data1, dtp->data2, dtp->data3); 227 } 228 for (i = 0; i < index; i++) { 229 dtp = phba->slow_ring_trc + i; 230 if (!dtp->fmt) 231 continue; 232 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time); 233 snprintf(buffer, 234 LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n", 235 dtp->seq_cnt, ms, dtp->fmt); 236 len += snprintf(buf+len, size-len, buffer, 237 dtp->data1, dtp->data2, dtp->data3); 238 } 239 240 lpfc_debugfs_enable = enable; 241 kfree(buffer); 242 243 return len; 244 } 245 246 static int lpfc_debugfs_last_hbq = -1; 247 248 /** 249 * lpfc_debugfs_hbqinfo_data - Dump host buffer queue info to a buffer 250 * @phba: The HBA to gather host buffer info from. 251 * @buf: The buffer to dump log into. 252 * @size: The maximum amount of data to process. 253 * 254 * Description: 255 * This routine dumps the host buffer queue info from the @phba to @buf up to 256 * @size number of bytes. A header that describes the current hbq state will be 257 * dumped to @buf first and then info on each hbq entry will be dumped to @buf 258 * until @size bytes have been dumped or all the hbq info has been dumped. 259 * 260 * Notes: 261 * This routine will rotate through each configured HBQ each time called. 262 * 263 * Return Value: 264 * This routine returns the amount of bytes that were dumped into @buf and will 265 * not exceed @size. 266 **/ 267 static int 268 lpfc_debugfs_hbqinfo_data(struct lpfc_hba *phba, char *buf, int size) 269 { 270 int len = 0; 271 int cnt, i, j, found, posted, low; 272 uint32_t phys, raw_index, getidx; 273 struct lpfc_hbq_init *hip; 274 struct hbq_s *hbqs; 275 struct lpfc_hbq_entry *hbqe; 276 struct lpfc_dmabuf *d_buf; 277 struct hbq_dmabuf *hbq_buf; 278 279 if (phba->sli_rev != 3) 280 return 0; 281 cnt = LPFC_HBQINFO_SIZE; 282 spin_lock_irq(&phba->hbalock); 283 284 /* toggle between multiple hbqs, if any */ 285 i = lpfc_sli_hbq_count(); 286 if (i > 1) { 287 lpfc_debugfs_last_hbq++; 288 if (lpfc_debugfs_last_hbq >= i) 289 lpfc_debugfs_last_hbq = 0; 290 } 291 else 292 lpfc_debugfs_last_hbq = 0; 293 294 i = lpfc_debugfs_last_hbq; 295 296 len += snprintf(buf+len, size-len, "HBQ %d Info\n", i); 297 298 hbqs = &phba->hbqs[i]; 299 posted = 0; 300 list_for_each_entry(d_buf, &hbqs->hbq_buffer_list, list) 301 posted++; 302 303 hip = lpfc_hbq_defs[i]; 304 len += snprintf(buf+len, size-len, 305 "idx:%d prof:%d rn:%d bufcnt:%d icnt:%d acnt:%d posted %d\n", 306 hip->hbq_index, hip->profile, hip->rn, 307 hip->buffer_count, hip->init_count, hip->add_count, posted); 308 309 raw_index = phba->hbq_get[i]; 310 getidx = le32_to_cpu(raw_index); 311 len += snprintf(buf+len, size-len, 312 "entrys:%d bufcnt:%d Put:%d nPut:%d localGet:%d hbaGet:%d\n", 313 hbqs->entry_count, hbqs->buffer_count, hbqs->hbqPutIdx, 314 hbqs->next_hbqPutIdx, hbqs->local_hbqGetIdx, getidx); 315 316 hbqe = (struct lpfc_hbq_entry *) phba->hbqs[i].hbq_virt; 317 for (j=0; j<hbqs->entry_count; j++) { 318 len += snprintf(buf+len, size-len, 319 "%03d: %08x %04x %05x ", j, 320 le32_to_cpu(hbqe->bde.addrLow), 321 le32_to_cpu(hbqe->bde.tus.w), 322 le32_to_cpu(hbqe->buffer_tag)); 323 i = 0; 324 found = 0; 325 326 /* First calculate if slot has an associated posted buffer */ 327 low = hbqs->hbqPutIdx - posted; 328 if (low >= 0) { 329 if ((j >= hbqs->hbqPutIdx) || (j < low)) { 330 len += snprintf(buf+len, size-len, "Unused\n"); 331 goto skipit; 332 } 333 } 334 else { 335 if ((j >= hbqs->hbqPutIdx) && 336 (j < (hbqs->entry_count+low))) { 337 len += snprintf(buf+len, size-len, "Unused\n"); 338 goto skipit; 339 } 340 } 341 342 /* Get the Buffer info for the posted buffer */ 343 list_for_each_entry(d_buf, &hbqs->hbq_buffer_list, list) { 344 hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf); 345 phys = ((uint64_t)hbq_buf->dbuf.phys & 0xffffffff); 346 if (phys == le32_to_cpu(hbqe->bde.addrLow)) { 347 len += snprintf(buf+len, size-len, 348 "Buf%d: %p %06x\n", i, 349 hbq_buf->dbuf.virt, hbq_buf->tag); 350 found = 1; 351 break; 352 } 353 i++; 354 } 355 if (!found) { 356 len += snprintf(buf+len, size-len, "No DMAinfo?\n"); 357 } 358 skipit: 359 hbqe++; 360 if (len > LPFC_HBQINFO_SIZE - 54) 361 break; 362 } 363 spin_unlock_irq(&phba->hbalock); 364 return len; 365 } 366 367 static int lpfc_debugfs_last_hba_slim_off; 368 369 /** 370 * lpfc_debugfs_dumpHBASlim_data - Dump HBA SLIM info to a buffer 371 * @phba: The HBA to gather SLIM info from. 372 * @buf: The buffer to dump log into. 373 * @size: The maximum amount of data to process. 374 * 375 * Description: 376 * This routine dumps the current contents of HBA SLIM for the HBA associated 377 * with @phba to @buf up to @size bytes of data. This is the raw HBA SLIM data. 378 * 379 * Notes: 380 * This routine will only dump up to 1024 bytes of data each time called and 381 * should be called multiple times to dump the entire HBA SLIM. 382 * 383 * Return Value: 384 * This routine returns the amount of bytes that were dumped into @buf and will 385 * not exceed @size. 386 **/ 387 static int 388 lpfc_debugfs_dumpHBASlim_data(struct lpfc_hba *phba, char *buf, int size) 389 { 390 int len = 0; 391 int i, off; 392 uint32_t *ptr; 393 char *buffer; 394 395 buffer = kmalloc(1024, GFP_KERNEL); 396 if (!buffer) 397 return 0; 398 399 off = 0; 400 spin_lock_irq(&phba->hbalock); 401 402 len += snprintf(buf+len, size-len, "HBA SLIM\n"); 403 lpfc_memcpy_from_slim(buffer, 404 phba->MBslimaddr + lpfc_debugfs_last_hba_slim_off, 1024); 405 406 ptr = (uint32_t *)&buffer[0]; 407 off = lpfc_debugfs_last_hba_slim_off; 408 409 /* Set it up for the next time */ 410 lpfc_debugfs_last_hba_slim_off += 1024; 411 if (lpfc_debugfs_last_hba_slim_off >= 4096) 412 lpfc_debugfs_last_hba_slim_off = 0; 413 414 i = 1024; 415 while (i > 0) { 416 len += snprintf(buf+len, size-len, 417 "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n", 418 off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4), 419 *(ptr+5), *(ptr+6), *(ptr+7)); 420 ptr += 8; 421 i -= (8 * sizeof(uint32_t)); 422 off += (8 * sizeof(uint32_t)); 423 } 424 425 spin_unlock_irq(&phba->hbalock); 426 kfree(buffer); 427 428 return len; 429 } 430 431 /** 432 * lpfc_debugfs_dumpHostSlim_data - Dump host SLIM info to a buffer 433 * @phba: The HBA to gather Host SLIM info from. 434 * @buf: The buffer to dump log into. 435 * @size: The maximum amount of data to process. 436 * 437 * Description: 438 * This routine dumps the current contents of host SLIM for the host associated 439 * with @phba to @buf up to @size bytes of data. The dump will contain the 440 * Mailbox, PCB, Rings, and Registers that are located in host memory. 441 * 442 * Return Value: 443 * This routine returns the amount of bytes that were dumped into @buf and will 444 * not exceed @size. 445 **/ 446 static int 447 lpfc_debugfs_dumpHostSlim_data(struct lpfc_hba *phba, char *buf, int size) 448 { 449 int len = 0; 450 int i, off; 451 uint32_t word0, word1, word2, word3; 452 uint32_t *ptr; 453 struct lpfc_pgp *pgpp; 454 struct lpfc_sli *psli = &phba->sli; 455 struct lpfc_sli_ring *pring; 456 457 off = 0; 458 spin_lock_irq(&phba->hbalock); 459 460 len += snprintf(buf+len, size-len, "SLIM Mailbox\n"); 461 ptr = (uint32_t *)phba->slim2p.virt; 462 i = sizeof(MAILBOX_t); 463 while (i > 0) { 464 len += snprintf(buf+len, size-len, 465 "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n", 466 off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4), 467 *(ptr+5), *(ptr+6), *(ptr+7)); 468 ptr += 8; 469 i -= (8 * sizeof(uint32_t)); 470 off += (8 * sizeof(uint32_t)); 471 } 472 473 len += snprintf(buf+len, size-len, "SLIM PCB\n"); 474 ptr = (uint32_t *)phba->pcb; 475 i = sizeof(PCB_t); 476 while (i > 0) { 477 len += snprintf(buf+len, size-len, 478 "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n", 479 off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4), 480 *(ptr+5), *(ptr+6), *(ptr+7)); 481 ptr += 8; 482 i -= (8 * sizeof(uint32_t)); 483 off += (8 * sizeof(uint32_t)); 484 } 485 486 for (i = 0; i < 4; i++) { 487 pgpp = &phba->port_gp[i]; 488 pring = &psli->ring[i]; 489 len += snprintf(buf+len, size-len, 490 "Ring %d: CMD GetInx:%d (Max:%d Next:%d " 491 "Local:%d flg:x%x) RSP PutInx:%d Max:%d\n", 492 i, pgpp->cmdGetInx, pring->numCiocb, 493 pring->next_cmdidx, pring->local_getidx, 494 pring->flag, pgpp->rspPutInx, pring->numRiocb); 495 } 496 497 if (phba->sli_rev <= LPFC_SLI_REV3) { 498 word0 = readl(phba->HAregaddr); 499 word1 = readl(phba->CAregaddr); 500 word2 = readl(phba->HSregaddr); 501 word3 = readl(phba->HCregaddr); 502 len += snprintf(buf+len, size-len, "HA:%08x CA:%08x HS:%08x " 503 "HC:%08x\n", word0, word1, word2, word3); 504 } 505 spin_unlock_irq(&phba->hbalock); 506 return len; 507 } 508 509 /** 510 * lpfc_debugfs_nodelist_data - Dump target node list to a buffer 511 * @vport: The vport to gather target node info from. 512 * @buf: The buffer to dump log into. 513 * @size: The maximum amount of data to process. 514 * 515 * Description: 516 * This routine dumps the current target node list associated with @vport to 517 * @buf up to @size bytes of data. Each node entry in the dump will contain a 518 * node state, DID, WWPN, WWNN, RPI, flags, type, and other useful fields. 519 * 520 * Return Value: 521 * This routine returns the amount of bytes that were dumped into @buf and will 522 * not exceed @size. 523 **/ 524 static int 525 lpfc_debugfs_nodelist_data(struct lpfc_vport *vport, char *buf, int size) 526 { 527 int len = 0; 528 int cnt; 529 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 530 struct lpfc_nodelist *ndlp; 531 unsigned char *statep, *name; 532 533 cnt = (LPFC_NODELIST_SIZE / LPFC_NODELIST_ENTRY_SIZE); 534 535 spin_lock_irq(shost->host_lock); 536 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) { 537 if (!cnt) { 538 len += snprintf(buf+len, size-len, 539 "Missing Nodelist Entries\n"); 540 break; 541 } 542 cnt--; 543 switch (ndlp->nlp_state) { 544 case NLP_STE_UNUSED_NODE: 545 statep = "UNUSED"; 546 break; 547 case NLP_STE_PLOGI_ISSUE: 548 statep = "PLOGI "; 549 break; 550 case NLP_STE_ADISC_ISSUE: 551 statep = "ADISC "; 552 break; 553 case NLP_STE_REG_LOGIN_ISSUE: 554 statep = "REGLOG"; 555 break; 556 case NLP_STE_PRLI_ISSUE: 557 statep = "PRLI "; 558 break; 559 case NLP_STE_UNMAPPED_NODE: 560 statep = "UNMAP "; 561 break; 562 case NLP_STE_MAPPED_NODE: 563 statep = "MAPPED"; 564 break; 565 case NLP_STE_NPR_NODE: 566 statep = "NPR "; 567 break; 568 default: 569 statep = "UNKNOWN"; 570 } 571 len += snprintf(buf+len, size-len, "%s DID:x%06x ", 572 statep, ndlp->nlp_DID); 573 name = (unsigned char *)&ndlp->nlp_portname; 574 len += snprintf(buf+len, size-len, 575 "WWPN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x ", 576 *name, *(name+1), *(name+2), *(name+3), 577 *(name+4), *(name+5), *(name+6), *(name+7)); 578 name = (unsigned char *)&ndlp->nlp_nodename; 579 len += snprintf(buf+len, size-len, 580 "WWNN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x ", 581 *name, *(name+1), *(name+2), *(name+3), 582 *(name+4), *(name+5), *(name+6), *(name+7)); 583 len += snprintf(buf+len, size-len, "RPI:%03d flag:x%08x ", 584 ndlp->nlp_rpi, ndlp->nlp_flag); 585 if (!ndlp->nlp_type) 586 len += snprintf(buf+len, size-len, "UNKNOWN_TYPE "); 587 if (ndlp->nlp_type & NLP_FC_NODE) 588 len += snprintf(buf+len, size-len, "FC_NODE "); 589 if (ndlp->nlp_type & NLP_FABRIC) 590 len += snprintf(buf+len, size-len, "FABRIC "); 591 if (ndlp->nlp_type & NLP_FCP_TARGET) 592 len += snprintf(buf+len, size-len, "FCP_TGT sid:%d ", 593 ndlp->nlp_sid); 594 if (ndlp->nlp_type & NLP_FCP_INITIATOR) 595 len += snprintf(buf+len, size-len, "FCP_INITIATOR "); 596 len += snprintf(buf+len, size-len, "usgmap:%x ", 597 ndlp->nlp_usg_map); 598 len += snprintf(buf+len, size-len, "refcnt:%x", 599 atomic_read(&ndlp->kref.refcount)); 600 len += snprintf(buf+len, size-len, "\n"); 601 } 602 spin_unlock_irq(shost->host_lock); 603 return len; 604 } 605 #endif 606 607 /** 608 * lpfc_debugfs_disc_trc - Store discovery trace log 609 * @vport: The vport to associate this trace string with for retrieval. 610 * @mask: Log entry classification. 611 * @fmt: Format string to be displayed when dumping the log. 612 * @data1: 1st data parameter to be applied to @fmt. 613 * @data2: 2nd data parameter to be applied to @fmt. 614 * @data3: 3rd data parameter to be applied to @fmt. 615 * 616 * Description: 617 * This routine is used by the driver code to add a debugfs log entry to the 618 * discovery trace buffer associated with @vport. Only entries with a @mask that 619 * match the current debugfs discovery mask will be saved. Entries that do not 620 * match will be thrown away. @fmt, @data1, @data2, and @data3 are used like 621 * printf when displaying the log. 622 **/ 623 inline void 624 lpfc_debugfs_disc_trc(struct lpfc_vport *vport, int mask, char *fmt, 625 uint32_t data1, uint32_t data2, uint32_t data3) 626 { 627 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 628 struct lpfc_debugfs_trc *dtp; 629 int index; 630 631 if (!(lpfc_debugfs_mask_disc_trc & mask)) 632 return; 633 634 if (!lpfc_debugfs_enable || !lpfc_debugfs_max_disc_trc || 635 !vport || !vport->disc_trc) 636 return; 637 638 index = atomic_inc_return(&vport->disc_trc_cnt) & 639 (lpfc_debugfs_max_disc_trc - 1); 640 dtp = vport->disc_trc + index; 641 dtp->fmt = fmt; 642 dtp->data1 = data1; 643 dtp->data2 = data2; 644 dtp->data3 = data3; 645 dtp->seq_cnt = atomic_inc_return(&lpfc_debugfs_seq_trc_cnt); 646 dtp->jif = jiffies; 647 #endif 648 return; 649 } 650 651 /** 652 * lpfc_debugfs_slow_ring_trc - Store slow ring trace log 653 * @phba: The phba to associate this trace string with for retrieval. 654 * @fmt: Format string to be displayed when dumping the log. 655 * @data1: 1st data parameter to be applied to @fmt. 656 * @data2: 2nd data parameter to be applied to @fmt. 657 * @data3: 3rd data parameter to be applied to @fmt. 658 * 659 * Description: 660 * This routine is used by the driver code to add a debugfs log entry to the 661 * discovery trace buffer associated with @vport. @fmt, @data1, @data2, and 662 * @data3 are used like printf when displaying the log. 663 **/ 664 inline void 665 lpfc_debugfs_slow_ring_trc(struct lpfc_hba *phba, char *fmt, 666 uint32_t data1, uint32_t data2, uint32_t data3) 667 { 668 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 669 struct lpfc_debugfs_trc *dtp; 670 int index; 671 672 if (!lpfc_debugfs_enable || !lpfc_debugfs_max_slow_ring_trc || 673 !phba || !phba->slow_ring_trc) 674 return; 675 676 index = atomic_inc_return(&phba->slow_ring_trc_cnt) & 677 (lpfc_debugfs_max_slow_ring_trc - 1); 678 dtp = phba->slow_ring_trc + index; 679 dtp->fmt = fmt; 680 dtp->data1 = data1; 681 dtp->data2 = data2; 682 dtp->data3 = data3; 683 dtp->seq_cnt = atomic_inc_return(&lpfc_debugfs_seq_trc_cnt); 684 dtp->jif = jiffies; 685 #endif 686 return; 687 } 688 689 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 690 /** 691 * lpfc_debugfs_disc_trc_open - Open the discovery trace log 692 * @inode: The inode pointer that contains a vport pointer. 693 * @file: The file pointer to attach the log output. 694 * 695 * Description: 696 * This routine is the entry point for the debugfs open file operation. It gets 697 * the vport from the i_private field in @inode, allocates the necessary buffer 698 * for the log, fills the buffer from the in-memory log for this vport, and then 699 * returns a pointer to that log in the private_data field in @file. 700 * 701 * Returns: 702 * This function returns zero if successful. On error it will return an negative 703 * error value. 704 **/ 705 static int 706 lpfc_debugfs_disc_trc_open(struct inode *inode, struct file *file) 707 { 708 struct lpfc_vport *vport = inode->i_private; 709 struct lpfc_debug *debug; 710 int size; 711 int rc = -ENOMEM; 712 713 if (!lpfc_debugfs_max_disc_trc) { 714 rc = -ENOSPC; 715 goto out; 716 } 717 718 debug = kmalloc(sizeof(*debug), GFP_KERNEL); 719 if (!debug) 720 goto out; 721 722 /* Round to page boundary */ 723 size = (lpfc_debugfs_max_disc_trc * LPFC_DEBUG_TRC_ENTRY_SIZE); 724 size = PAGE_ALIGN(size); 725 726 debug->buffer = kmalloc(size, GFP_KERNEL); 727 if (!debug->buffer) { 728 kfree(debug); 729 goto out; 730 } 731 732 debug->len = lpfc_debugfs_disc_trc_data(vport, debug->buffer, size); 733 file->private_data = debug; 734 735 rc = 0; 736 out: 737 return rc; 738 } 739 740 /** 741 * lpfc_debugfs_slow_ring_trc_open - Open the Slow Ring trace log 742 * @inode: The inode pointer that contains a vport pointer. 743 * @file: The file pointer to attach the log output. 744 * 745 * Description: 746 * This routine is the entry point for the debugfs open file operation. It gets 747 * the vport from the i_private field in @inode, allocates the necessary buffer 748 * for the log, fills the buffer from the in-memory log for this vport, and then 749 * returns a pointer to that log in the private_data field in @file. 750 * 751 * Returns: 752 * This function returns zero if successful. On error it will return an negative 753 * error value. 754 **/ 755 static int 756 lpfc_debugfs_slow_ring_trc_open(struct inode *inode, struct file *file) 757 { 758 struct lpfc_hba *phba = inode->i_private; 759 struct lpfc_debug *debug; 760 int size; 761 int rc = -ENOMEM; 762 763 if (!lpfc_debugfs_max_slow_ring_trc) { 764 rc = -ENOSPC; 765 goto out; 766 } 767 768 debug = kmalloc(sizeof(*debug), GFP_KERNEL); 769 if (!debug) 770 goto out; 771 772 /* Round to page boundary */ 773 size = (lpfc_debugfs_max_slow_ring_trc * LPFC_DEBUG_TRC_ENTRY_SIZE); 774 size = PAGE_ALIGN(size); 775 776 debug->buffer = kmalloc(size, GFP_KERNEL); 777 if (!debug->buffer) { 778 kfree(debug); 779 goto out; 780 } 781 782 debug->len = lpfc_debugfs_slow_ring_trc_data(phba, debug->buffer, size); 783 file->private_data = debug; 784 785 rc = 0; 786 out: 787 return rc; 788 } 789 790 /** 791 * lpfc_debugfs_hbqinfo_open - Open the hbqinfo debugfs buffer 792 * @inode: The inode pointer that contains a vport pointer. 793 * @file: The file pointer to attach the log output. 794 * 795 * Description: 796 * This routine is the entry point for the debugfs open file operation. It gets 797 * the vport from the i_private field in @inode, allocates the necessary buffer 798 * for the log, fills the buffer from the in-memory log for this vport, and then 799 * returns a pointer to that log in the private_data field in @file. 800 * 801 * Returns: 802 * This function returns zero if successful. On error it will return an negative 803 * error value. 804 **/ 805 static int 806 lpfc_debugfs_hbqinfo_open(struct inode *inode, struct file *file) 807 { 808 struct lpfc_hba *phba = inode->i_private; 809 struct lpfc_debug *debug; 810 int rc = -ENOMEM; 811 812 debug = kmalloc(sizeof(*debug), GFP_KERNEL); 813 if (!debug) 814 goto out; 815 816 /* Round to page boundary */ 817 debug->buffer = kmalloc(LPFC_HBQINFO_SIZE, GFP_KERNEL); 818 if (!debug->buffer) { 819 kfree(debug); 820 goto out; 821 } 822 823 debug->len = lpfc_debugfs_hbqinfo_data(phba, debug->buffer, 824 LPFC_HBQINFO_SIZE); 825 file->private_data = debug; 826 827 rc = 0; 828 out: 829 return rc; 830 } 831 832 /** 833 * lpfc_debugfs_dumpHBASlim_open - Open the Dump HBA SLIM debugfs buffer 834 * @inode: The inode pointer that contains a vport pointer. 835 * @file: The file pointer to attach the log output. 836 * 837 * Description: 838 * This routine is the entry point for the debugfs open file operation. It gets 839 * the vport from the i_private field in @inode, allocates the necessary buffer 840 * for the log, fills the buffer from the in-memory log for this vport, and then 841 * returns a pointer to that log in the private_data field in @file. 842 * 843 * Returns: 844 * This function returns zero if successful. On error it will return an negative 845 * error value. 846 **/ 847 static int 848 lpfc_debugfs_dumpHBASlim_open(struct inode *inode, struct file *file) 849 { 850 struct lpfc_hba *phba = inode->i_private; 851 struct lpfc_debug *debug; 852 int rc = -ENOMEM; 853 854 debug = kmalloc(sizeof(*debug), GFP_KERNEL); 855 if (!debug) 856 goto out; 857 858 /* Round to page boundary */ 859 debug->buffer = kmalloc(LPFC_DUMPHBASLIM_SIZE, GFP_KERNEL); 860 if (!debug->buffer) { 861 kfree(debug); 862 goto out; 863 } 864 865 debug->len = lpfc_debugfs_dumpHBASlim_data(phba, debug->buffer, 866 LPFC_DUMPHBASLIM_SIZE); 867 file->private_data = debug; 868 869 rc = 0; 870 out: 871 return rc; 872 } 873 874 /** 875 * lpfc_debugfs_dumpHostSlim_open - Open the Dump Host SLIM debugfs buffer 876 * @inode: The inode pointer that contains a vport pointer. 877 * @file: The file pointer to attach the log output. 878 * 879 * Description: 880 * This routine is the entry point for the debugfs open file operation. It gets 881 * the vport from the i_private field in @inode, allocates the necessary buffer 882 * for the log, fills the buffer from the in-memory log for this vport, and then 883 * returns a pointer to that log in the private_data field in @file. 884 * 885 * Returns: 886 * This function returns zero if successful. On error it will return an negative 887 * error value. 888 **/ 889 static int 890 lpfc_debugfs_dumpHostSlim_open(struct inode *inode, struct file *file) 891 { 892 struct lpfc_hba *phba = inode->i_private; 893 struct lpfc_debug *debug; 894 int rc = -ENOMEM; 895 896 debug = kmalloc(sizeof(*debug), GFP_KERNEL); 897 if (!debug) 898 goto out; 899 900 /* Round to page boundary */ 901 debug->buffer = kmalloc(LPFC_DUMPHOSTSLIM_SIZE, GFP_KERNEL); 902 if (!debug->buffer) { 903 kfree(debug); 904 goto out; 905 } 906 907 debug->len = lpfc_debugfs_dumpHostSlim_data(phba, debug->buffer, 908 LPFC_DUMPHOSTSLIM_SIZE); 909 file->private_data = debug; 910 911 rc = 0; 912 out: 913 return rc; 914 } 915 916 static int 917 lpfc_debugfs_dumpData_open(struct inode *inode, struct file *file) 918 { 919 struct lpfc_debug *debug; 920 int rc = -ENOMEM; 921 922 if (!_dump_buf_data) 923 return -EBUSY; 924 925 debug = kmalloc(sizeof(*debug), GFP_KERNEL); 926 if (!debug) 927 goto out; 928 929 /* Round to page boundary */ 930 printk(KERN_ERR "9059 BLKGRD: %s: _dump_buf_data=0x%p\n", 931 __func__, _dump_buf_data); 932 debug->buffer = _dump_buf_data; 933 if (!debug->buffer) { 934 kfree(debug); 935 goto out; 936 } 937 938 debug->len = (1 << _dump_buf_data_order) << PAGE_SHIFT; 939 file->private_data = debug; 940 941 rc = 0; 942 out: 943 return rc; 944 } 945 946 static int 947 lpfc_debugfs_dumpDif_open(struct inode *inode, struct file *file) 948 { 949 struct lpfc_debug *debug; 950 int rc = -ENOMEM; 951 952 if (!_dump_buf_dif) 953 return -EBUSY; 954 955 debug = kmalloc(sizeof(*debug), GFP_KERNEL); 956 if (!debug) 957 goto out; 958 959 /* Round to page boundary */ 960 printk(KERN_ERR "9060 BLKGRD: %s: _dump_buf_dif=0x%p file=%s\n", 961 __func__, _dump_buf_dif, file->f_dentry->d_name.name); 962 debug->buffer = _dump_buf_dif; 963 if (!debug->buffer) { 964 kfree(debug); 965 goto out; 966 } 967 968 debug->len = (1 << _dump_buf_dif_order) << PAGE_SHIFT; 969 file->private_data = debug; 970 971 rc = 0; 972 out: 973 return rc; 974 } 975 976 static ssize_t 977 lpfc_debugfs_dumpDataDif_write(struct file *file, const char __user *buf, 978 size_t nbytes, loff_t *ppos) 979 { 980 /* 981 * The Data/DIF buffers only save one failing IO 982 * The write op is used as a reset mechanism after an IO has 983 * already been saved to the next one can be saved 984 */ 985 spin_lock(&_dump_buf_lock); 986 987 memset((void *)_dump_buf_data, 0, 988 ((1 << PAGE_SHIFT) << _dump_buf_data_order)); 989 memset((void *)_dump_buf_dif, 0, 990 ((1 << PAGE_SHIFT) << _dump_buf_dif_order)); 991 992 _dump_buf_done = 0; 993 994 spin_unlock(&_dump_buf_lock); 995 996 return nbytes; 997 } 998 999 static int 1000 lpfc_debugfs_dif_err_open(struct inode *inode, struct file *file) 1001 { 1002 file->private_data = inode->i_private; 1003 return 0; 1004 } 1005 1006 static ssize_t 1007 lpfc_debugfs_dif_err_read(struct file *file, char __user *buf, 1008 size_t nbytes, loff_t *ppos) 1009 { 1010 struct dentry *dent = file->f_dentry; 1011 struct lpfc_hba *phba = file->private_data; 1012 char cbuf[16]; 1013 int cnt = 0; 1014 1015 if (dent == phba->debug_writeGuard) 1016 cnt = snprintf(cbuf, 16, "%u\n", phba->lpfc_injerr_wgrd_cnt); 1017 else if (dent == phba->debug_writeApp) 1018 cnt = snprintf(cbuf, 16, "%u\n", phba->lpfc_injerr_wapp_cnt); 1019 else if (dent == phba->debug_writeRef) 1020 cnt = snprintf(cbuf, 16, "%u\n", phba->lpfc_injerr_wref_cnt); 1021 else if (dent == phba->debug_readApp) 1022 cnt = snprintf(cbuf, 16, "%u\n", phba->lpfc_injerr_rapp_cnt); 1023 else if (dent == phba->debug_readRef) 1024 cnt = snprintf(cbuf, 16, "%u\n", phba->lpfc_injerr_rref_cnt); 1025 else if (dent == phba->debug_InjErrLBA) 1026 cnt = snprintf(cbuf, 16, "0x%lx\n", 1027 (unsigned long) phba->lpfc_injerr_lba); 1028 else 1029 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 1030 "0547 Unknown debugfs error injection entry\n"); 1031 1032 return simple_read_from_buffer(buf, nbytes, ppos, &cbuf, cnt); 1033 } 1034 1035 static ssize_t 1036 lpfc_debugfs_dif_err_write(struct file *file, const char __user *buf, 1037 size_t nbytes, loff_t *ppos) 1038 { 1039 struct dentry *dent = file->f_dentry; 1040 struct lpfc_hba *phba = file->private_data; 1041 char dstbuf[32]; 1042 unsigned long tmp; 1043 int size; 1044 1045 memset(dstbuf, 0, 32); 1046 size = (nbytes < 32) ? nbytes : 32; 1047 if (copy_from_user(dstbuf, buf, size)) 1048 return 0; 1049 1050 if (strict_strtoul(dstbuf, 0, &tmp)) 1051 return 0; 1052 1053 if (dent == phba->debug_writeGuard) 1054 phba->lpfc_injerr_wgrd_cnt = (uint32_t)tmp; 1055 else if (dent == phba->debug_writeApp) 1056 phba->lpfc_injerr_wapp_cnt = (uint32_t)tmp; 1057 else if (dent == phba->debug_writeRef) 1058 phba->lpfc_injerr_wref_cnt = (uint32_t)tmp; 1059 else if (dent == phba->debug_readApp) 1060 phba->lpfc_injerr_rapp_cnt = (uint32_t)tmp; 1061 else if (dent == phba->debug_readRef) 1062 phba->lpfc_injerr_rref_cnt = (uint32_t)tmp; 1063 else if (dent == phba->debug_InjErrLBA) 1064 phba->lpfc_injerr_lba = (sector_t)tmp; 1065 else 1066 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 1067 "0548 Unknown debugfs error injection entry\n"); 1068 1069 return nbytes; 1070 } 1071 1072 static int 1073 lpfc_debugfs_dif_err_release(struct inode *inode, struct file *file) 1074 { 1075 return 0; 1076 } 1077 1078 /** 1079 * lpfc_debugfs_nodelist_open - Open the nodelist debugfs file 1080 * @inode: The inode pointer that contains a vport pointer. 1081 * @file: The file pointer to attach the log output. 1082 * 1083 * Description: 1084 * This routine is the entry point for the debugfs open file operation. It gets 1085 * the vport from the i_private field in @inode, allocates the necessary buffer 1086 * for the log, fills the buffer from the in-memory log for this vport, and then 1087 * returns a pointer to that log in the private_data field in @file. 1088 * 1089 * Returns: 1090 * This function returns zero if successful. On error it will return an negative 1091 * error value. 1092 **/ 1093 static int 1094 lpfc_debugfs_nodelist_open(struct inode *inode, struct file *file) 1095 { 1096 struct lpfc_vport *vport = inode->i_private; 1097 struct lpfc_debug *debug; 1098 int rc = -ENOMEM; 1099 1100 debug = kmalloc(sizeof(*debug), GFP_KERNEL); 1101 if (!debug) 1102 goto out; 1103 1104 /* Round to page boundary */ 1105 debug->buffer = kmalloc(LPFC_NODELIST_SIZE, GFP_KERNEL); 1106 if (!debug->buffer) { 1107 kfree(debug); 1108 goto out; 1109 } 1110 1111 debug->len = lpfc_debugfs_nodelist_data(vport, debug->buffer, 1112 LPFC_NODELIST_SIZE); 1113 file->private_data = debug; 1114 1115 rc = 0; 1116 out: 1117 return rc; 1118 } 1119 1120 /** 1121 * lpfc_debugfs_lseek - Seek through a debugfs file 1122 * @file: The file pointer to seek through. 1123 * @off: The offset to seek to or the amount to seek by. 1124 * @whence: Indicates how to seek. 1125 * 1126 * Description: 1127 * This routine is the entry point for the debugfs lseek file operation. The 1128 * @whence parameter indicates whether @off is the offset to directly seek to, 1129 * or if it is a value to seek forward or reverse by. This function figures out 1130 * what the new offset of the debugfs file will be and assigns that value to the 1131 * f_pos field of @file. 1132 * 1133 * Returns: 1134 * This function returns the new offset if successful and returns a negative 1135 * error if unable to process the seek. 1136 **/ 1137 static loff_t 1138 lpfc_debugfs_lseek(struct file *file, loff_t off, int whence) 1139 { 1140 struct lpfc_debug *debug; 1141 loff_t pos = -1; 1142 1143 debug = file->private_data; 1144 1145 switch (whence) { 1146 case 0: 1147 pos = off; 1148 break; 1149 case 1: 1150 pos = file->f_pos + off; 1151 break; 1152 case 2: 1153 pos = debug->len - off; 1154 } 1155 return (pos < 0 || pos > debug->len) ? -EINVAL : (file->f_pos = pos); 1156 } 1157 1158 /** 1159 * lpfc_debugfs_read - Read a debugfs file 1160 * @file: The file pointer to read from. 1161 * @buf: The buffer to copy the data to. 1162 * @nbytes: The number of bytes to read. 1163 * @ppos: The position in the file to start reading from. 1164 * 1165 * Description: 1166 * This routine reads data from from the buffer indicated in the private_data 1167 * field of @file. It will start reading at @ppos and copy up to @nbytes of 1168 * data to @buf. 1169 * 1170 * Returns: 1171 * This function returns the amount of data that was read (this could be less 1172 * than @nbytes if the end of the file was reached) or a negative error value. 1173 **/ 1174 static ssize_t 1175 lpfc_debugfs_read(struct file *file, char __user *buf, 1176 size_t nbytes, loff_t *ppos) 1177 { 1178 struct lpfc_debug *debug = file->private_data; 1179 1180 return simple_read_from_buffer(buf, nbytes, ppos, debug->buffer, 1181 debug->len); 1182 } 1183 1184 /** 1185 * lpfc_debugfs_release - Release the buffer used to store debugfs file data 1186 * @inode: The inode pointer that contains a vport pointer. (unused) 1187 * @file: The file pointer that contains the buffer to release. 1188 * 1189 * Description: 1190 * This routine frees the buffer that was allocated when the debugfs file was 1191 * opened. 1192 * 1193 * Returns: 1194 * This function returns zero. 1195 **/ 1196 static int 1197 lpfc_debugfs_release(struct inode *inode, struct file *file) 1198 { 1199 struct lpfc_debug *debug = file->private_data; 1200 1201 kfree(debug->buffer); 1202 kfree(debug); 1203 1204 return 0; 1205 } 1206 1207 static int 1208 lpfc_debugfs_dumpDataDif_release(struct inode *inode, struct file *file) 1209 { 1210 struct lpfc_debug *debug = file->private_data; 1211 1212 debug->buffer = NULL; 1213 kfree(debug); 1214 1215 return 0; 1216 } 1217 1218 /* 1219 * --------------------------------- 1220 * iDiag debugfs file access methods 1221 * --------------------------------- 1222 * 1223 * All access methods are through the proper SLI4 PCI function's debugfs 1224 * iDiag directory: 1225 * 1226 * /sys/kernel/debug/lpfc/fn<#>/iDiag 1227 */ 1228 1229 /** 1230 * lpfc_idiag_cmd_get - Get and parse idiag debugfs comands from user space 1231 * @buf: The pointer to the user space buffer. 1232 * @nbytes: The number of bytes in the user space buffer. 1233 * @idiag_cmd: pointer to the idiag command struct. 1234 * 1235 * This routine reads data from debugfs user space buffer and parses the 1236 * buffer for getting the idiag command and arguments. The while space in 1237 * between the set of data is used as the parsing separator. 1238 * 1239 * This routine returns 0 when successful, it returns proper error code 1240 * back to the user space in error conditions. 1241 */ 1242 static int lpfc_idiag_cmd_get(const char __user *buf, size_t nbytes, 1243 struct lpfc_idiag_cmd *idiag_cmd) 1244 { 1245 char mybuf[64]; 1246 char *pbuf, *step_str; 1247 int i; 1248 size_t bsize; 1249 1250 /* Protect copy from user */ 1251 if (!access_ok(VERIFY_READ, buf, nbytes)) 1252 return -EFAULT; 1253 1254 memset(mybuf, 0, sizeof(mybuf)); 1255 memset(idiag_cmd, 0, sizeof(*idiag_cmd)); 1256 bsize = min(nbytes, (sizeof(mybuf)-1)); 1257 1258 if (copy_from_user(mybuf, buf, bsize)) 1259 return -EFAULT; 1260 pbuf = &mybuf[0]; 1261 step_str = strsep(&pbuf, "\t "); 1262 1263 /* The opcode must present */ 1264 if (!step_str) 1265 return -EINVAL; 1266 1267 idiag_cmd->opcode = simple_strtol(step_str, NULL, 0); 1268 if (idiag_cmd->opcode == 0) 1269 return -EINVAL; 1270 1271 for (i = 0; i < LPFC_IDIAG_CMD_DATA_SIZE; i++) { 1272 step_str = strsep(&pbuf, "\t "); 1273 if (!step_str) 1274 return i; 1275 idiag_cmd->data[i] = simple_strtol(step_str, NULL, 0); 1276 } 1277 return i; 1278 } 1279 1280 /** 1281 * lpfc_idiag_open - idiag open debugfs 1282 * @inode: The inode pointer that contains a pointer to phba. 1283 * @file: The file pointer to attach the file operation. 1284 * 1285 * Description: 1286 * This routine is the entry point for the debugfs open file operation. It 1287 * gets the reference to phba from the i_private field in @inode, it then 1288 * allocates buffer for the file operation, performs the necessary PCI config 1289 * space read into the allocated buffer according to the idiag user command 1290 * setup, and then returns a pointer to buffer in the private_data field in 1291 * @file. 1292 * 1293 * Returns: 1294 * This function returns zero if successful. On error it will return an 1295 * negative error value. 1296 **/ 1297 static int 1298 lpfc_idiag_open(struct inode *inode, struct file *file) 1299 { 1300 struct lpfc_debug *debug; 1301 1302 debug = kmalloc(sizeof(*debug), GFP_KERNEL); 1303 if (!debug) 1304 return -ENOMEM; 1305 1306 debug->i_private = inode->i_private; 1307 debug->buffer = NULL; 1308 file->private_data = debug; 1309 1310 return 0; 1311 } 1312 1313 /** 1314 * lpfc_idiag_release - Release idiag access file operation 1315 * @inode: The inode pointer that contains a vport pointer. (unused) 1316 * @file: The file pointer that contains the buffer to release. 1317 * 1318 * Description: 1319 * This routine is the generic release routine for the idiag access file 1320 * operation, it frees the buffer that was allocated when the debugfs file 1321 * was opened. 1322 * 1323 * Returns: 1324 * This function returns zero. 1325 **/ 1326 static int 1327 lpfc_idiag_release(struct inode *inode, struct file *file) 1328 { 1329 struct lpfc_debug *debug = file->private_data; 1330 1331 /* Free the buffers to the file operation */ 1332 kfree(debug->buffer); 1333 kfree(debug); 1334 1335 return 0; 1336 } 1337 1338 /** 1339 * lpfc_idiag_cmd_release - Release idiag cmd access file operation 1340 * @inode: The inode pointer that contains a vport pointer. (unused) 1341 * @file: The file pointer that contains the buffer to release. 1342 * 1343 * Description: 1344 * This routine frees the buffer that was allocated when the debugfs file 1345 * was opened. It also reset the fields in the idiag command struct in the 1346 * case of command for write operation. 1347 * 1348 * Returns: 1349 * This function returns zero. 1350 **/ 1351 static int 1352 lpfc_idiag_cmd_release(struct inode *inode, struct file *file) 1353 { 1354 struct lpfc_debug *debug = file->private_data; 1355 1356 if (debug->op == LPFC_IDIAG_OP_WR) { 1357 switch (idiag.cmd.opcode) { 1358 case LPFC_IDIAG_CMD_PCICFG_WR: 1359 case LPFC_IDIAG_CMD_PCICFG_ST: 1360 case LPFC_IDIAG_CMD_PCICFG_CL: 1361 case LPFC_IDIAG_CMD_QUEACC_WR: 1362 case LPFC_IDIAG_CMD_QUEACC_ST: 1363 case LPFC_IDIAG_CMD_QUEACC_CL: 1364 memset(&idiag, 0, sizeof(idiag)); 1365 break; 1366 default: 1367 break; 1368 } 1369 } 1370 1371 /* Free the buffers to the file operation */ 1372 kfree(debug->buffer); 1373 kfree(debug); 1374 1375 return 0; 1376 } 1377 1378 /** 1379 * lpfc_idiag_pcicfg_read - idiag debugfs read pcicfg 1380 * @file: The file pointer to read from. 1381 * @buf: The buffer to copy the data to. 1382 * @nbytes: The number of bytes to read. 1383 * @ppos: The position in the file to start reading from. 1384 * 1385 * Description: 1386 * This routine reads data from the @phba pci config space according to the 1387 * idiag command, and copies to user @buf. Depending on the PCI config space 1388 * read command setup, it does either a single register read of a byte 1389 * (8 bits), a word (16 bits), or a dword (32 bits) or browsing through all 1390 * registers from the 4K extended PCI config space. 1391 * 1392 * Returns: 1393 * This function returns the amount of data that was read (this could be less 1394 * than @nbytes if the end of the file was reached) or a negative error value. 1395 **/ 1396 static ssize_t 1397 lpfc_idiag_pcicfg_read(struct file *file, char __user *buf, size_t nbytes, 1398 loff_t *ppos) 1399 { 1400 struct lpfc_debug *debug = file->private_data; 1401 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private; 1402 int offset_label, offset, len = 0, index = LPFC_PCI_CFG_RD_SIZE; 1403 int where, count; 1404 char *pbuffer; 1405 struct pci_dev *pdev; 1406 uint32_t u32val; 1407 uint16_t u16val; 1408 uint8_t u8val; 1409 1410 pdev = phba->pcidev; 1411 if (!pdev) 1412 return 0; 1413 1414 /* This is a user read operation */ 1415 debug->op = LPFC_IDIAG_OP_RD; 1416 1417 if (!debug->buffer) 1418 debug->buffer = kmalloc(LPFC_PCI_CFG_SIZE, GFP_KERNEL); 1419 if (!debug->buffer) 1420 return 0; 1421 pbuffer = debug->buffer; 1422 1423 if (*ppos) 1424 return 0; 1425 1426 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_RD) { 1427 where = idiag.cmd.data[IDIAG_PCICFG_WHERE_INDX]; 1428 count = idiag.cmd.data[IDIAG_PCICFG_COUNT_INDX]; 1429 } else 1430 return 0; 1431 1432 /* Read single PCI config space register */ 1433 switch (count) { 1434 case SIZE_U8: /* byte (8 bits) */ 1435 pci_read_config_byte(pdev, where, &u8val); 1436 len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len, 1437 "%03x: %02x\n", where, u8val); 1438 break; 1439 case SIZE_U16: /* word (16 bits) */ 1440 pci_read_config_word(pdev, where, &u16val); 1441 len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len, 1442 "%03x: %04x\n", where, u16val); 1443 break; 1444 case SIZE_U32: /* double word (32 bits) */ 1445 pci_read_config_dword(pdev, where, &u32val); 1446 len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len, 1447 "%03x: %08x\n", where, u32val); 1448 break; 1449 case LPFC_PCI_CFG_BROWSE: /* browse all */ 1450 goto pcicfg_browse; 1451 break; 1452 default: 1453 /* illegal count */ 1454 len = 0; 1455 break; 1456 } 1457 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len); 1458 1459 pcicfg_browse: 1460 1461 /* Browse all PCI config space registers */ 1462 offset_label = idiag.offset.last_rd; 1463 offset = offset_label; 1464 1465 /* Read PCI config space */ 1466 len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len, 1467 "%03x: ", offset_label); 1468 while (index > 0) { 1469 pci_read_config_dword(pdev, offset, &u32val); 1470 len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len, 1471 "%08x ", u32val); 1472 offset += sizeof(uint32_t); 1473 if (offset >= LPFC_PCI_CFG_SIZE) { 1474 len += snprintf(pbuffer+len, 1475 LPFC_PCI_CFG_SIZE-len, "\n"); 1476 break; 1477 } 1478 index -= sizeof(uint32_t); 1479 if (!index) 1480 len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len, 1481 "\n"); 1482 else if (!(index % (8 * sizeof(uint32_t)))) { 1483 offset_label += (8 * sizeof(uint32_t)); 1484 len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len, 1485 "\n%03x: ", offset_label); 1486 } 1487 } 1488 1489 /* Set up the offset for next portion of pci cfg read */ 1490 if (index == 0) { 1491 idiag.offset.last_rd += LPFC_PCI_CFG_RD_SIZE; 1492 if (idiag.offset.last_rd >= LPFC_PCI_CFG_SIZE) 1493 idiag.offset.last_rd = 0; 1494 } else 1495 idiag.offset.last_rd = 0; 1496 1497 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len); 1498 } 1499 1500 /** 1501 * lpfc_idiag_pcicfg_write - Syntax check and set up idiag pcicfg commands 1502 * @file: The file pointer to read from. 1503 * @buf: The buffer to copy the user data from. 1504 * @nbytes: The number of bytes to get. 1505 * @ppos: The position in the file to start reading from. 1506 * 1507 * This routine get the debugfs idiag command struct from user space and 1508 * then perform the syntax check for PCI config space read or write command 1509 * accordingly. In the case of PCI config space read command, it sets up 1510 * the command in the idiag command struct for the debugfs read operation. 1511 * In the case of PCI config space write operation, it executes the write 1512 * operation into the PCI config space accordingly. 1513 * 1514 * It returns the @nbytges passing in from debugfs user space when successful. 1515 * In case of error conditions, it returns proper error code back to the user 1516 * space. 1517 */ 1518 static ssize_t 1519 lpfc_idiag_pcicfg_write(struct file *file, const char __user *buf, 1520 size_t nbytes, loff_t *ppos) 1521 { 1522 struct lpfc_debug *debug = file->private_data; 1523 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private; 1524 uint32_t where, value, count; 1525 uint32_t u32val; 1526 uint16_t u16val; 1527 uint8_t u8val; 1528 struct pci_dev *pdev; 1529 int rc; 1530 1531 pdev = phba->pcidev; 1532 if (!pdev) 1533 return -EFAULT; 1534 1535 /* This is a user write operation */ 1536 debug->op = LPFC_IDIAG_OP_WR; 1537 1538 rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd); 1539 if (rc < 0) 1540 return rc; 1541 1542 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_RD) { 1543 /* Sanity check on PCI config read command line arguments */ 1544 if (rc != LPFC_PCI_CFG_RD_CMD_ARG) 1545 goto error_out; 1546 /* Read command from PCI config space, set up command fields */ 1547 where = idiag.cmd.data[IDIAG_PCICFG_WHERE_INDX]; 1548 count = idiag.cmd.data[IDIAG_PCICFG_COUNT_INDX]; 1549 if (count == LPFC_PCI_CFG_BROWSE) { 1550 if (where % sizeof(uint32_t)) 1551 goto error_out; 1552 /* Starting offset to browse */ 1553 idiag.offset.last_rd = where; 1554 } else if ((count != sizeof(uint8_t)) && 1555 (count != sizeof(uint16_t)) && 1556 (count != sizeof(uint32_t))) 1557 goto error_out; 1558 if (count == sizeof(uint8_t)) { 1559 if (where > LPFC_PCI_CFG_SIZE - sizeof(uint8_t)) 1560 goto error_out; 1561 if (where % sizeof(uint8_t)) 1562 goto error_out; 1563 } 1564 if (count == sizeof(uint16_t)) { 1565 if (where > LPFC_PCI_CFG_SIZE - sizeof(uint16_t)) 1566 goto error_out; 1567 if (where % sizeof(uint16_t)) 1568 goto error_out; 1569 } 1570 if (count == sizeof(uint32_t)) { 1571 if (where > LPFC_PCI_CFG_SIZE - sizeof(uint32_t)) 1572 goto error_out; 1573 if (where % sizeof(uint32_t)) 1574 goto error_out; 1575 } 1576 } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR || 1577 idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST || 1578 idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) { 1579 /* Sanity check on PCI config write command line arguments */ 1580 if (rc != LPFC_PCI_CFG_WR_CMD_ARG) 1581 goto error_out; 1582 /* Write command to PCI config space, read-modify-write */ 1583 where = idiag.cmd.data[IDIAG_PCICFG_WHERE_INDX]; 1584 count = idiag.cmd.data[IDIAG_PCICFG_COUNT_INDX]; 1585 value = idiag.cmd.data[IDIAG_PCICFG_VALUE_INDX]; 1586 /* Sanity checks */ 1587 if ((count != sizeof(uint8_t)) && 1588 (count != sizeof(uint16_t)) && 1589 (count != sizeof(uint32_t))) 1590 goto error_out; 1591 if (count == sizeof(uint8_t)) { 1592 if (where > LPFC_PCI_CFG_SIZE - sizeof(uint8_t)) 1593 goto error_out; 1594 if (where % sizeof(uint8_t)) 1595 goto error_out; 1596 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR) 1597 pci_write_config_byte(pdev, where, 1598 (uint8_t)value); 1599 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST) { 1600 rc = pci_read_config_byte(pdev, where, &u8val); 1601 if (!rc) { 1602 u8val |= (uint8_t)value; 1603 pci_write_config_byte(pdev, where, 1604 u8val); 1605 } 1606 } 1607 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) { 1608 rc = pci_read_config_byte(pdev, where, &u8val); 1609 if (!rc) { 1610 u8val &= (uint8_t)(~value); 1611 pci_write_config_byte(pdev, where, 1612 u8val); 1613 } 1614 } 1615 } 1616 if (count == sizeof(uint16_t)) { 1617 if (where > LPFC_PCI_CFG_SIZE - sizeof(uint16_t)) 1618 goto error_out; 1619 if (where % sizeof(uint16_t)) 1620 goto error_out; 1621 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR) 1622 pci_write_config_word(pdev, where, 1623 (uint16_t)value); 1624 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST) { 1625 rc = pci_read_config_word(pdev, where, &u16val); 1626 if (!rc) { 1627 u16val |= (uint16_t)value; 1628 pci_write_config_word(pdev, where, 1629 u16val); 1630 } 1631 } 1632 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) { 1633 rc = pci_read_config_word(pdev, where, &u16val); 1634 if (!rc) { 1635 u16val &= (uint16_t)(~value); 1636 pci_write_config_word(pdev, where, 1637 u16val); 1638 } 1639 } 1640 } 1641 if (count == sizeof(uint32_t)) { 1642 if (where > LPFC_PCI_CFG_SIZE - sizeof(uint32_t)) 1643 goto error_out; 1644 if (where % sizeof(uint32_t)) 1645 goto error_out; 1646 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR) 1647 pci_write_config_dword(pdev, where, value); 1648 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST) { 1649 rc = pci_read_config_dword(pdev, where, 1650 &u32val); 1651 if (!rc) { 1652 u32val |= value; 1653 pci_write_config_dword(pdev, where, 1654 u32val); 1655 } 1656 } 1657 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) { 1658 rc = pci_read_config_dword(pdev, where, 1659 &u32val); 1660 if (!rc) { 1661 u32val &= ~value; 1662 pci_write_config_dword(pdev, where, 1663 u32val); 1664 } 1665 } 1666 } 1667 } else 1668 /* All other opecodes are illegal for now */ 1669 goto error_out; 1670 1671 return nbytes; 1672 error_out: 1673 memset(&idiag, 0, sizeof(idiag)); 1674 return -EINVAL; 1675 } 1676 1677 /** 1678 * lpfc_idiag_baracc_read - idiag debugfs pci bar access read 1679 * @file: The file pointer to read from. 1680 * @buf: The buffer to copy the data to. 1681 * @nbytes: The number of bytes to read. 1682 * @ppos: The position in the file to start reading from. 1683 * 1684 * Description: 1685 * This routine reads data from the @phba pci bar memory mapped space 1686 * according to the idiag command, and copies to user @buf. 1687 * 1688 * Returns: 1689 * This function returns the amount of data that was read (this could be less 1690 * than @nbytes if the end of the file was reached) or a negative error value. 1691 **/ 1692 static ssize_t 1693 lpfc_idiag_baracc_read(struct file *file, char __user *buf, size_t nbytes, 1694 loff_t *ppos) 1695 { 1696 struct lpfc_debug *debug = file->private_data; 1697 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private; 1698 int offset_label, offset, offset_run, len = 0, index; 1699 int bar_num, acc_range, bar_size; 1700 char *pbuffer; 1701 void __iomem *mem_mapped_bar; 1702 uint32_t if_type; 1703 struct pci_dev *pdev; 1704 uint32_t u32val; 1705 1706 pdev = phba->pcidev; 1707 if (!pdev) 1708 return 0; 1709 1710 /* This is a user read operation */ 1711 debug->op = LPFC_IDIAG_OP_RD; 1712 1713 if (!debug->buffer) 1714 debug->buffer = kmalloc(LPFC_PCI_BAR_RD_BUF_SIZE, GFP_KERNEL); 1715 if (!debug->buffer) 1716 return 0; 1717 pbuffer = debug->buffer; 1718 1719 if (*ppos) 1720 return 0; 1721 1722 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_RD) { 1723 bar_num = idiag.cmd.data[IDIAG_BARACC_BAR_NUM_INDX]; 1724 offset = idiag.cmd.data[IDIAG_BARACC_OFF_SET_INDX]; 1725 acc_range = idiag.cmd.data[IDIAG_BARACC_ACC_MOD_INDX]; 1726 bar_size = idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX]; 1727 } else 1728 return 0; 1729 1730 if (acc_range == 0) 1731 return 0; 1732 1733 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf); 1734 if (if_type == LPFC_SLI_INTF_IF_TYPE_0) { 1735 if (bar_num == IDIAG_BARACC_BAR_0) 1736 mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p; 1737 else if (bar_num == IDIAG_BARACC_BAR_1) 1738 mem_mapped_bar = phba->sli4_hba.ctrl_regs_memmap_p; 1739 else if (bar_num == IDIAG_BARACC_BAR_2) 1740 mem_mapped_bar = phba->sli4_hba.drbl_regs_memmap_p; 1741 else 1742 return 0; 1743 } else if (if_type == LPFC_SLI_INTF_IF_TYPE_2) { 1744 if (bar_num == IDIAG_BARACC_BAR_0) 1745 mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p; 1746 else 1747 return 0; 1748 } else 1749 return 0; 1750 1751 /* Read single PCI bar space register */ 1752 if (acc_range == SINGLE_WORD) { 1753 offset_run = offset; 1754 u32val = readl(mem_mapped_bar + offset_run); 1755 len += snprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len, 1756 "%05x: %08x\n", offset_run, u32val); 1757 } else 1758 goto baracc_browse; 1759 1760 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len); 1761 1762 baracc_browse: 1763 1764 /* Browse all PCI bar space registers */ 1765 offset_label = idiag.offset.last_rd; 1766 offset_run = offset_label; 1767 1768 /* Read PCI bar memory mapped space */ 1769 len += snprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len, 1770 "%05x: ", offset_label); 1771 index = LPFC_PCI_BAR_RD_SIZE; 1772 while (index > 0) { 1773 u32val = readl(mem_mapped_bar + offset_run); 1774 len += snprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len, 1775 "%08x ", u32val); 1776 offset_run += sizeof(uint32_t); 1777 if (acc_range == LPFC_PCI_BAR_BROWSE) { 1778 if (offset_run >= bar_size) { 1779 len += snprintf(pbuffer+len, 1780 LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n"); 1781 break; 1782 } 1783 } else { 1784 if (offset_run >= offset + 1785 (acc_range * sizeof(uint32_t))) { 1786 len += snprintf(pbuffer+len, 1787 LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n"); 1788 break; 1789 } 1790 } 1791 index -= sizeof(uint32_t); 1792 if (!index) 1793 len += snprintf(pbuffer+len, 1794 LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n"); 1795 else if (!(index % (8 * sizeof(uint32_t)))) { 1796 offset_label += (8 * sizeof(uint32_t)); 1797 len += snprintf(pbuffer+len, 1798 LPFC_PCI_BAR_RD_BUF_SIZE-len, 1799 "\n%05x: ", offset_label); 1800 } 1801 } 1802 1803 /* Set up the offset for next portion of pci bar read */ 1804 if (index == 0) { 1805 idiag.offset.last_rd += LPFC_PCI_BAR_RD_SIZE; 1806 if (acc_range == LPFC_PCI_BAR_BROWSE) { 1807 if (idiag.offset.last_rd >= bar_size) 1808 idiag.offset.last_rd = 0; 1809 } else { 1810 if (offset_run >= offset + 1811 (acc_range * sizeof(uint32_t))) 1812 idiag.offset.last_rd = offset; 1813 } 1814 } else { 1815 if (acc_range == LPFC_PCI_BAR_BROWSE) 1816 idiag.offset.last_rd = 0; 1817 else 1818 idiag.offset.last_rd = offset; 1819 } 1820 1821 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len); 1822 } 1823 1824 /** 1825 * lpfc_idiag_baracc_write - Syntax check and set up idiag bar access commands 1826 * @file: The file pointer to read from. 1827 * @buf: The buffer to copy the user data from. 1828 * @nbytes: The number of bytes to get. 1829 * @ppos: The position in the file to start reading from. 1830 * 1831 * This routine get the debugfs idiag command struct from user space and 1832 * then perform the syntax check for PCI bar memory mapped space read or 1833 * write command accordingly. In the case of PCI bar memory mapped space 1834 * read command, it sets up the command in the idiag command struct for 1835 * the debugfs read operation. In the case of PCI bar memorpy mapped space 1836 * write operation, it executes the write operation into the PCI bar memory 1837 * mapped space accordingly. 1838 * 1839 * It returns the @nbytges passing in from debugfs user space when successful. 1840 * In case of error conditions, it returns proper error code back to the user 1841 * space. 1842 */ 1843 static ssize_t 1844 lpfc_idiag_baracc_write(struct file *file, const char __user *buf, 1845 size_t nbytes, loff_t *ppos) 1846 { 1847 struct lpfc_debug *debug = file->private_data; 1848 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private; 1849 uint32_t bar_num, bar_size, offset, value, acc_range; 1850 struct pci_dev *pdev; 1851 void __iomem *mem_mapped_bar; 1852 uint32_t if_type; 1853 uint32_t u32val; 1854 int rc; 1855 1856 pdev = phba->pcidev; 1857 if (!pdev) 1858 return -EFAULT; 1859 1860 /* This is a user write operation */ 1861 debug->op = LPFC_IDIAG_OP_WR; 1862 1863 rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd); 1864 if (rc < 0) 1865 return rc; 1866 1867 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf); 1868 bar_num = idiag.cmd.data[IDIAG_BARACC_BAR_NUM_INDX]; 1869 1870 if (if_type == LPFC_SLI_INTF_IF_TYPE_0) { 1871 if ((bar_num != IDIAG_BARACC_BAR_0) && 1872 (bar_num != IDIAG_BARACC_BAR_1) && 1873 (bar_num != IDIAG_BARACC_BAR_2)) 1874 goto error_out; 1875 } else if (if_type == LPFC_SLI_INTF_IF_TYPE_2) { 1876 if (bar_num != IDIAG_BARACC_BAR_0) 1877 goto error_out; 1878 } else 1879 goto error_out; 1880 1881 if (if_type == LPFC_SLI_INTF_IF_TYPE_0) { 1882 if (bar_num == IDIAG_BARACC_BAR_0) { 1883 idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] = 1884 LPFC_PCI_IF0_BAR0_SIZE; 1885 mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p; 1886 } else if (bar_num == IDIAG_BARACC_BAR_1) { 1887 idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] = 1888 LPFC_PCI_IF0_BAR1_SIZE; 1889 mem_mapped_bar = phba->sli4_hba.ctrl_regs_memmap_p; 1890 } else if (bar_num == IDIAG_BARACC_BAR_2) { 1891 idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] = 1892 LPFC_PCI_IF0_BAR2_SIZE; 1893 mem_mapped_bar = phba->sli4_hba.drbl_regs_memmap_p; 1894 } else 1895 goto error_out; 1896 } else if (if_type == LPFC_SLI_INTF_IF_TYPE_2) { 1897 if (bar_num == IDIAG_BARACC_BAR_0) { 1898 idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] = 1899 LPFC_PCI_IF2_BAR0_SIZE; 1900 mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p; 1901 } else 1902 goto error_out; 1903 } else 1904 goto error_out; 1905 1906 offset = idiag.cmd.data[IDIAG_BARACC_OFF_SET_INDX]; 1907 if (offset % sizeof(uint32_t)) 1908 goto error_out; 1909 1910 bar_size = idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX]; 1911 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_RD) { 1912 /* Sanity check on PCI config read command line arguments */ 1913 if (rc != LPFC_PCI_BAR_RD_CMD_ARG) 1914 goto error_out; 1915 acc_range = idiag.cmd.data[IDIAG_BARACC_ACC_MOD_INDX]; 1916 if (acc_range == LPFC_PCI_BAR_BROWSE) { 1917 if (offset > bar_size - sizeof(uint32_t)) 1918 goto error_out; 1919 /* Starting offset to browse */ 1920 idiag.offset.last_rd = offset; 1921 } else if (acc_range > SINGLE_WORD) { 1922 if (offset + acc_range * sizeof(uint32_t) > bar_size) 1923 goto error_out; 1924 /* Starting offset to browse */ 1925 idiag.offset.last_rd = offset; 1926 } else if (acc_range != SINGLE_WORD) 1927 goto error_out; 1928 } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_WR || 1929 idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_ST || 1930 idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_CL) { 1931 /* Sanity check on PCI bar write command line arguments */ 1932 if (rc != LPFC_PCI_BAR_WR_CMD_ARG) 1933 goto error_out; 1934 /* Write command to PCI bar space, read-modify-write */ 1935 acc_range = SINGLE_WORD; 1936 value = idiag.cmd.data[IDIAG_BARACC_REG_VAL_INDX]; 1937 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_WR) { 1938 writel(value, mem_mapped_bar + offset); 1939 readl(mem_mapped_bar + offset); 1940 } 1941 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_ST) { 1942 u32val = readl(mem_mapped_bar + offset); 1943 u32val |= value; 1944 writel(u32val, mem_mapped_bar + offset); 1945 readl(mem_mapped_bar + offset); 1946 } 1947 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_CL) { 1948 u32val = readl(mem_mapped_bar + offset); 1949 u32val &= ~value; 1950 writel(u32val, mem_mapped_bar + offset); 1951 readl(mem_mapped_bar + offset); 1952 } 1953 } else 1954 /* All other opecodes are illegal for now */ 1955 goto error_out; 1956 1957 return nbytes; 1958 error_out: 1959 memset(&idiag, 0, sizeof(idiag)); 1960 return -EINVAL; 1961 } 1962 1963 /** 1964 * lpfc_idiag_queinfo_read - idiag debugfs read queue information 1965 * @file: The file pointer to read from. 1966 * @buf: The buffer to copy the data to. 1967 * @nbytes: The number of bytes to read. 1968 * @ppos: The position in the file to start reading from. 1969 * 1970 * Description: 1971 * This routine reads data from the @phba SLI4 PCI function queue information, 1972 * and copies to user @buf. 1973 * 1974 * Returns: 1975 * This function returns the amount of data that was read (this could be less 1976 * than @nbytes if the end of the file was reached) or a negative error value. 1977 **/ 1978 static ssize_t 1979 lpfc_idiag_queinfo_read(struct file *file, char __user *buf, size_t nbytes, 1980 loff_t *ppos) 1981 { 1982 struct lpfc_debug *debug = file->private_data; 1983 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private; 1984 int len = 0, fcp_qidx; 1985 char *pbuffer; 1986 1987 if (!debug->buffer) 1988 debug->buffer = kmalloc(LPFC_QUE_INFO_GET_BUF_SIZE, GFP_KERNEL); 1989 if (!debug->buffer) 1990 return 0; 1991 pbuffer = debug->buffer; 1992 1993 if (*ppos) 1994 return 0; 1995 1996 /* Get slow-path event queue information */ 1997 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 1998 "Slow-path EQ information:\n"); 1999 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2000 "\tEQID[%02d], " 2001 "QE-COUNT[%04d], QE-SIZE[%04d], " 2002 "HOST-INDEX[%04d], PORT-INDEX[%04d]\n\n", 2003 phba->sli4_hba.sp_eq->queue_id, 2004 phba->sli4_hba.sp_eq->entry_count, 2005 phba->sli4_hba.sp_eq->entry_size, 2006 phba->sli4_hba.sp_eq->host_index, 2007 phba->sli4_hba.sp_eq->hba_index); 2008 2009 /* Get fast-path event queue information */ 2010 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2011 "Fast-path EQ information:\n"); 2012 for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; fcp_qidx++) { 2013 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2014 "\tEQID[%02d], " 2015 "QE-COUNT[%04d], QE-SIZE[%04d], " 2016 "HOST-INDEX[%04d], PORT-INDEX[%04d]\n", 2017 phba->sli4_hba.fp_eq[fcp_qidx]->queue_id, 2018 phba->sli4_hba.fp_eq[fcp_qidx]->entry_count, 2019 phba->sli4_hba.fp_eq[fcp_qidx]->entry_size, 2020 phba->sli4_hba.fp_eq[fcp_qidx]->host_index, 2021 phba->sli4_hba.fp_eq[fcp_qidx]->hba_index); 2022 } 2023 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, "\n"); 2024 2025 /* Get mailbox complete queue information */ 2026 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2027 "Slow-path MBX CQ information:\n"); 2028 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2029 "Associated EQID[%02d]:\n", 2030 phba->sli4_hba.mbx_cq->assoc_qid); 2031 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2032 "\tCQID[%02d], " 2033 "QE-COUNT[%04d], QE-SIZE[%04d], " 2034 "HOST-INDEX[%04d], PORT-INDEX[%04d]\n\n", 2035 phba->sli4_hba.mbx_cq->queue_id, 2036 phba->sli4_hba.mbx_cq->entry_count, 2037 phba->sli4_hba.mbx_cq->entry_size, 2038 phba->sli4_hba.mbx_cq->host_index, 2039 phba->sli4_hba.mbx_cq->hba_index); 2040 2041 /* Get slow-path complete queue information */ 2042 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2043 "Slow-path ELS CQ information:\n"); 2044 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2045 "Associated EQID[%02d]:\n", 2046 phba->sli4_hba.els_cq->assoc_qid); 2047 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2048 "\tCQID [%02d], " 2049 "QE-COUNT[%04d], QE-SIZE[%04d], " 2050 "HOST-INDEX[%04d], PORT-INDEX[%04d]\n\n", 2051 phba->sli4_hba.els_cq->queue_id, 2052 phba->sli4_hba.els_cq->entry_count, 2053 phba->sli4_hba.els_cq->entry_size, 2054 phba->sli4_hba.els_cq->host_index, 2055 phba->sli4_hba.els_cq->hba_index); 2056 2057 /* Get fast-path complete queue information */ 2058 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2059 "Fast-path FCP CQ information:\n"); 2060 fcp_qidx = 0; 2061 do { 2062 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2063 "Associated EQID[%02d]:\n", 2064 phba->sli4_hba.fcp_cq[fcp_qidx]->assoc_qid); 2065 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2066 "\tCQID[%02d], " 2067 "QE-COUNT[%04d], QE-SIZE[%04d], " 2068 "HOST-INDEX[%04d], PORT-INDEX[%04d]\n", 2069 phba->sli4_hba.fcp_cq[fcp_qidx]->queue_id, 2070 phba->sli4_hba.fcp_cq[fcp_qidx]->entry_count, 2071 phba->sli4_hba.fcp_cq[fcp_qidx]->entry_size, 2072 phba->sli4_hba.fcp_cq[fcp_qidx]->host_index, 2073 phba->sli4_hba.fcp_cq[fcp_qidx]->hba_index); 2074 } while (++fcp_qidx < phba->cfg_fcp_eq_count); 2075 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, "\n"); 2076 2077 /* Get mailbox queue information */ 2078 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2079 "Slow-path MBX MQ information:\n"); 2080 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2081 "Associated CQID[%02d]:\n", 2082 phba->sli4_hba.mbx_wq->assoc_qid); 2083 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2084 "\tWQID[%02d], " 2085 "QE-COUNT[%04d], QE-SIZE[%04d], " 2086 "HOST-INDEX[%04d], PORT-INDEX[%04d]\n\n", 2087 phba->sli4_hba.mbx_wq->queue_id, 2088 phba->sli4_hba.mbx_wq->entry_count, 2089 phba->sli4_hba.mbx_wq->entry_size, 2090 phba->sli4_hba.mbx_wq->host_index, 2091 phba->sli4_hba.mbx_wq->hba_index); 2092 2093 /* Get slow-path work queue information */ 2094 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2095 "Slow-path ELS WQ information:\n"); 2096 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2097 "Associated CQID[%02d]:\n", 2098 phba->sli4_hba.els_wq->assoc_qid); 2099 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2100 "\tWQID[%02d], " 2101 "QE-COUNT[%04d], QE-SIZE[%04d], " 2102 "HOST-INDEX[%04d], PORT-INDEX[%04d]\n\n", 2103 phba->sli4_hba.els_wq->queue_id, 2104 phba->sli4_hba.els_wq->entry_count, 2105 phba->sli4_hba.els_wq->entry_size, 2106 phba->sli4_hba.els_wq->host_index, 2107 phba->sli4_hba.els_wq->hba_index); 2108 2109 /* Get fast-path work queue information */ 2110 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2111 "Fast-path FCP WQ information:\n"); 2112 for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_wq_count; fcp_qidx++) { 2113 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2114 "Associated CQID[%02d]:\n", 2115 phba->sli4_hba.fcp_wq[fcp_qidx]->assoc_qid); 2116 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2117 "\tWQID[%02d], " 2118 "QE-COUNT[%04d], WQE-SIZE[%04d], " 2119 "HOST-INDEX[%04d], PORT-INDEX[%04d]\n", 2120 phba->sli4_hba.fcp_wq[fcp_qidx]->queue_id, 2121 phba->sli4_hba.fcp_wq[fcp_qidx]->entry_count, 2122 phba->sli4_hba.fcp_wq[fcp_qidx]->entry_size, 2123 phba->sli4_hba.fcp_wq[fcp_qidx]->host_index, 2124 phba->sli4_hba.fcp_wq[fcp_qidx]->hba_index); 2125 } 2126 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, "\n"); 2127 2128 /* Get receive queue information */ 2129 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2130 "Slow-path RQ information:\n"); 2131 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2132 "Associated CQID[%02d]:\n", 2133 phba->sli4_hba.hdr_rq->assoc_qid); 2134 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2135 "\tHQID[%02d], " 2136 "QE-COUNT[%04d], QE-SIZE[%04d], " 2137 "HOST-INDEX[%04d], PORT-INDEX[%04d]\n", 2138 phba->sli4_hba.hdr_rq->queue_id, 2139 phba->sli4_hba.hdr_rq->entry_count, 2140 phba->sli4_hba.hdr_rq->entry_size, 2141 phba->sli4_hba.hdr_rq->host_index, 2142 phba->sli4_hba.hdr_rq->hba_index); 2143 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, 2144 "\tDQID[%02d], " 2145 "QE-COUNT[%04d], QE-SIZE[%04d], " 2146 "HOST-INDEX[%04d], PORT-INDEX[%04d]\n", 2147 phba->sli4_hba.dat_rq->queue_id, 2148 phba->sli4_hba.dat_rq->entry_count, 2149 phba->sli4_hba.dat_rq->entry_size, 2150 phba->sli4_hba.dat_rq->host_index, 2151 phba->sli4_hba.dat_rq->hba_index); 2152 2153 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len); 2154 } 2155 2156 /** 2157 * lpfc_idiag_que_param_check - queue access command parameter sanity check 2158 * @q: The pointer to queue structure. 2159 * @index: The index into a queue entry. 2160 * @count: The number of queue entries to access. 2161 * 2162 * Description: 2163 * The routine performs sanity check on device queue access method commands. 2164 * 2165 * Returns: 2166 * This function returns -EINVAL when fails the sanity check, otherwise, it 2167 * returns 0. 2168 **/ 2169 static int 2170 lpfc_idiag_que_param_check(struct lpfc_queue *q, int index, int count) 2171 { 2172 /* Only support single entry read or browsing */ 2173 if ((count != 1) && (count != LPFC_QUE_ACC_BROWSE)) 2174 return -EINVAL; 2175 if (index > q->entry_count - 1) 2176 return -EINVAL; 2177 return 0; 2178 } 2179 2180 /** 2181 * lpfc_idiag_queacc_read_qe - read a single entry from the given queue index 2182 * @pbuffer: The pointer to buffer to copy the read data into. 2183 * @pque: The pointer to the queue to be read. 2184 * @index: The index into the queue entry. 2185 * 2186 * Description: 2187 * This routine reads out a single entry from the given queue's index location 2188 * and copies it into the buffer provided. 2189 * 2190 * Returns: 2191 * This function returns 0 when it fails, otherwise, it returns the length of 2192 * the data read into the buffer provided. 2193 **/ 2194 static int 2195 lpfc_idiag_queacc_read_qe(char *pbuffer, int len, struct lpfc_queue *pque, 2196 uint32_t index) 2197 { 2198 int offset, esize; 2199 uint32_t *pentry; 2200 2201 if (!pbuffer || !pque) 2202 return 0; 2203 2204 esize = pque->entry_size; 2205 len += snprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len, 2206 "QE-INDEX[%04d]:\n", index); 2207 2208 offset = 0; 2209 pentry = pque->qe[index].address; 2210 while (esize > 0) { 2211 len += snprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len, 2212 "%08x ", *pentry); 2213 pentry++; 2214 offset += sizeof(uint32_t); 2215 esize -= sizeof(uint32_t); 2216 if (esize > 0 && !(offset % (4 * sizeof(uint32_t)))) 2217 len += snprintf(pbuffer+len, 2218 LPFC_QUE_ACC_BUF_SIZE-len, "\n"); 2219 } 2220 len += snprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len, "\n"); 2221 2222 return len; 2223 } 2224 2225 /** 2226 * lpfc_idiag_queacc_read - idiag debugfs read port queue 2227 * @file: The file pointer to read from. 2228 * @buf: The buffer to copy the data to. 2229 * @nbytes: The number of bytes to read. 2230 * @ppos: The position in the file to start reading from. 2231 * 2232 * Description: 2233 * This routine reads data from the @phba device queue memory according to the 2234 * idiag command, and copies to user @buf. Depending on the queue dump read 2235 * command setup, it does either a single queue entry read or browing through 2236 * all entries of the queue. 2237 * 2238 * Returns: 2239 * This function returns the amount of data that was read (this could be less 2240 * than @nbytes if the end of the file was reached) or a negative error value. 2241 **/ 2242 static ssize_t 2243 lpfc_idiag_queacc_read(struct file *file, char __user *buf, size_t nbytes, 2244 loff_t *ppos) 2245 { 2246 struct lpfc_debug *debug = file->private_data; 2247 uint32_t last_index, index, count; 2248 struct lpfc_queue *pque = NULL; 2249 char *pbuffer; 2250 int len = 0; 2251 2252 /* This is a user read operation */ 2253 debug->op = LPFC_IDIAG_OP_RD; 2254 2255 if (!debug->buffer) 2256 debug->buffer = kmalloc(LPFC_QUE_ACC_BUF_SIZE, GFP_KERNEL); 2257 if (!debug->buffer) 2258 return 0; 2259 pbuffer = debug->buffer; 2260 2261 if (*ppos) 2262 return 0; 2263 2264 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_RD) { 2265 index = idiag.cmd.data[IDIAG_QUEACC_INDEX_INDX]; 2266 count = idiag.cmd.data[IDIAG_QUEACC_COUNT_INDX]; 2267 pque = (struct lpfc_queue *)idiag.ptr_private; 2268 } else 2269 return 0; 2270 2271 /* Browse the queue starting from index */ 2272 if (count == LPFC_QUE_ACC_BROWSE) 2273 goto que_browse; 2274 2275 /* Read a single entry from the queue */ 2276 len = lpfc_idiag_queacc_read_qe(pbuffer, len, pque, index); 2277 2278 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len); 2279 2280 que_browse: 2281 2282 /* Browse all entries from the queue */ 2283 last_index = idiag.offset.last_rd; 2284 index = last_index; 2285 2286 while (len < LPFC_QUE_ACC_SIZE - pque->entry_size) { 2287 len = lpfc_idiag_queacc_read_qe(pbuffer, len, pque, index); 2288 index++; 2289 if (index > pque->entry_count - 1) 2290 break; 2291 } 2292 2293 /* Set up the offset for next portion of pci cfg read */ 2294 if (index > pque->entry_count - 1) 2295 index = 0; 2296 idiag.offset.last_rd = index; 2297 2298 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len); 2299 } 2300 2301 /** 2302 * lpfc_idiag_queacc_write - Syntax check and set up idiag queacc commands 2303 * @file: The file pointer to read from. 2304 * @buf: The buffer to copy the user data from. 2305 * @nbytes: The number of bytes to get. 2306 * @ppos: The position in the file to start reading from. 2307 * 2308 * This routine get the debugfs idiag command struct from user space and then 2309 * perform the syntax check for port queue read (dump) or write (set) command 2310 * accordingly. In the case of port queue read command, it sets up the command 2311 * in the idiag command struct for the following debugfs read operation. In 2312 * the case of port queue write operation, it executes the write operation 2313 * into the port queue entry accordingly. 2314 * 2315 * It returns the @nbytges passing in from debugfs user space when successful. 2316 * In case of error conditions, it returns proper error code back to the user 2317 * space. 2318 **/ 2319 static ssize_t 2320 lpfc_idiag_queacc_write(struct file *file, const char __user *buf, 2321 size_t nbytes, loff_t *ppos) 2322 { 2323 struct lpfc_debug *debug = file->private_data; 2324 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private; 2325 uint32_t qidx, quetp, queid, index, count, offset, value; 2326 uint32_t *pentry; 2327 struct lpfc_queue *pque; 2328 int rc; 2329 2330 /* This is a user write operation */ 2331 debug->op = LPFC_IDIAG_OP_WR; 2332 2333 rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd); 2334 if (rc < 0) 2335 return rc; 2336 2337 /* Get and sanity check on command feilds */ 2338 quetp = idiag.cmd.data[IDIAG_QUEACC_QUETP_INDX]; 2339 queid = idiag.cmd.data[IDIAG_QUEACC_QUEID_INDX]; 2340 index = idiag.cmd.data[IDIAG_QUEACC_INDEX_INDX]; 2341 count = idiag.cmd.data[IDIAG_QUEACC_COUNT_INDX]; 2342 offset = idiag.cmd.data[IDIAG_QUEACC_OFFST_INDX]; 2343 value = idiag.cmd.data[IDIAG_QUEACC_VALUE_INDX]; 2344 2345 /* Sanity check on command line arguments */ 2346 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_WR || 2347 idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_ST || 2348 idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_CL) { 2349 if (rc != LPFC_QUE_ACC_WR_CMD_ARG) 2350 goto error_out; 2351 if (count != 1) 2352 goto error_out; 2353 } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_RD) { 2354 if (rc != LPFC_QUE_ACC_RD_CMD_ARG) 2355 goto error_out; 2356 } else 2357 goto error_out; 2358 2359 switch (quetp) { 2360 case LPFC_IDIAG_EQ: 2361 /* Slow-path event queue */ 2362 if (phba->sli4_hba.sp_eq->queue_id == queid) { 2363 /* Sanity check */ 2364 rc = lpfc_idiag_que_param_check( 2365 phba->sli4_hba.sp_eq, index, count); 2366 if (rc) 2367 goto error_out; 2368 idiag.ptr_private = phba->sli4_hba.sp_eq; 2369 goto pass_check; 2370 } 2371 /* Fast-path event queue */ 2372 for (qidx = 0; qidx < phba->cfg_fcp_eq_count; qidx++) { 2373 if (phba->sli4_hba.fp_eq[qidx]->queue_id == queid) { 2374 /* Sanity check */ 2375 rc = lpfc_idiag_que_param_check( 2376 phba->sli4_hba.fp_eq[qidx], 2377 index, count); 2378 if (rc) 2379 goto error_out; 2380 idiag.ptr_private = phba->sli4_hba.fp_eq[qidx]; 2381 goto pass_check; 2382 } 2383 } 2384 goto error_out; 2385 break; 2386 case LPFC_IDIAG_CQ: 2387 /* MBX complete queue */ 2388 if (phba->sli4_hba.mbx_cq->queue_id == queid) { 2389 /* Sanity check */ 2390 rc = lpfc_idiag_que_param_check( 2391 phba->sli4_hba.mbx_cq, index, count); 2392 if (rc) 2393 goto error_out; 2394 idiag.ptr_private = phba->sli4_hba.mbx_cq; 2395 goto pass_check; 2396 } 2397 /* ELS complete queue */ 2398 if (phba->sli4_hba.els_cq->queue_id == queid) { 2399 /* Sanity check */ 2400 rc = lpfc_idiag_que_param_check( 2401 phba->sli4_hba.els_cq, index, count); 2402 if (rc) 2403 goto error_out; 2404 idiag.ptr_private = phba->sli4_hba.els_cq; 2405 goto pass_check; 2406 } 2407 /* FCP complete queue */ 2408 qidx = 0; 2409 do { 2410 if (phba->sli4_hba.fcp_cq[qidx]->queue_id == queid) { 2411 /* Sanity check */ 2412 rc = lpfc_idiag_que_param_check( 2413 phba->sli4_hba.fcp_cq[qidx], 2414 index, count); 2415 if (rc) 2416 goto error_out; 2417 idiag.ptr_private = 2418 phba->sli4_hba.fcp_cq[qidx]; 2419 goto pass_check; 2420 } 2421 } while (++qidx < phba->cfg_fcp_eq_count); 2422 goto error_out; 2423 break; 2424 case LPFC_IDIAG_MQ: 2425 /* MBX work queue */ 2426 if (phba->sli4_hba.mbx_wq->queue_id == queid) { 2427 /* Sanity check */ 2428 rc = lpfc_idiag_que_param_check( 2429 phba->sli4_hba.mbx_wq, index, count); 2430 if (rc) 2431 goto error_out; 2432 idiag.ptr_private = phba->sli4_hba.mbx_wq; 2433 goto pass_check; 2434 } 2435 break; 2436 case LPFC_IDIAG_WQ: 2437 /* ELS work queue */ 2438 if (phba->sli4_hba.els_wq->queue_id == queid) { 2439 /* Sanity check */ 2440 rc = lpfc_idiag_que_param_check( 2441 phba->sli4_hba.els_wq, index, count); 2442 if (rc) 2443 goto error_out; 2444 idiag.ptr_private = phba->sli4_hba.els_wq; 2445 goto pass_check; 2446 } 2447 /* FCP work queue */ 2448 for (qidx = 0; qidx < phba->cfg_fcp_wq_count; qidx++) { 2449 if (phba->sli4_hba.fcp_wq[qidx]->queue_id == queid) { 2450 /* Sanity check */ 2451 rc = lpfc_idiag_que_param_check( 2452 phba->sli4_hba.fcp_wq[qidx], 2453 index, count); 2454 if (rc) 2455 goto error_out; 2456 idiag.ptr_private = 2457 phba->sli4_hba.fcp_wq[qidx]; 2458 goto pass_check; 2459 } 2460 } 2461 goto error_out; 2462 break; 2463 case LPFC_IDIAG_RQ: 2464 /* HDR queue */ 2465 if (phba->sli4_hba.hdr_rq->queue_id == queid) { 2466 /* Sanity check */ 2467 rc = lpfc_idiag_que_param_check( 2468 phba->sli4_hba.hdr_rq, index, count); 2469 if (rc) 2470 goto error_out; 2471 idiag.ptr_private = phba->sli4_hba.hdr_rq; 2472 goto pass_check; 2473 } 2474 /* DAT queue */ 2475 if (phba->sli4_hba.dat_rq->queue_id == queid) { 2476 /* Sanity check */ 2477 rc = lpfc_idiag_que_param_check( 2478 phba->sli4_hba.dat_rq, index, count); 2479 if (rc) 2480 goto error_out; 2481 idiag.ptr_private = phba->sli4_hba.dat_rq; 2482 goto pass_check; 2483 } 2484 goto error_out; 2485 break; 2486 default: 2487 goto error_out; 2488 break; 2489 } 2490 2491 pass_check: 2492 2493 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_RD) { 2494 if (count == LPFC_QUE_ACC_BROWSE) 2495 idiag.offset.last_rd = index; 2496 } 2497 2498 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_WR || 2499 idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_ST || 2500 idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_CL) { 2501 /* Additional sanity checks on write operation */ 2502 pque = (struct lpfc_queue *)idiag.ptr_private; 2503 if (offset > pque->entry_size/sizeof(uint32_t) - 1) 2504 goto error_out; 2505 pentry = pque->qe[index].address; 2506 pentry += offset; 2507 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_WR) 2508 *pentry = value; 2509 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_ST) 2510 *pentry |= value; 2511 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_CL) 2512 *pentry &= ~value; 2513 } 2514 return nbytes; 2515 2516 error_out: 2517 /* Clean out command structure on command error out */ 2518 memset(&idiag, 0, sizeof(idiag)); 2519 return -EINVAL; 2520 } 2521 2522 /** 2523 * lpfc_idiag_drbacc_read_reg - idiag debugfs read a doorbell register 2524 * @phba: The pointer to hba structure. 2525 * @pbuffer: The pointer to the buffer to copy the data to. 2526 * @len: The lenght of bytes to copied. 2527 * @drbregid: The id to doorbell registers. 2528 * 2529 * Description: 2530 * This routine reads a doorbell register and copies its content to the 2531 * user buffer pointed to by @pbuffer. 2532 * 2533 * Returns: 2534 * This function returns the amount of data that was copied into @pbuffer. 2535 **/ 2536 static int 2537 lpfc_idiag_drbacc_read_reg(struct lpfc_hba *phba, char *pbuffer, 2538 int len, uint32_t drbregid) 2539 { 2540 2541 if (!pbuffer) 2542 return 0; 2543 2544 switch (drbregid) { 2545 case LPFC_DRB_EQCQ: 2546 len += snprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len, 2547 "EQCQ-DRB-REG: 0x%08x\n", 2548 readl(phba->sli4_hba.EQCQDBregaddr)); 2549 break; 2550 case LPFC_DRB_MQ: 2551 len += snprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len, 2552 "MQ-DRB-REG: 0x%08x\n", 2553 readl(phba->sli4_hba.MQDBregaddr)); 2554 break; 2555 case LPFC_DRB_WQ: 2556 len += snprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len, 2557 "WQ-DRB-REG: 0x%08x\n", 2558 readl(phba->sli4_hba.WQDBregaddr)); 2559 break; 2560 case LPFC_DRB_RQ: 2561 len += snprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len, 2562 "RQ-DRB-REG: 0x%08x\n", 2563 readl(phba->sli4_hba.RQDBregaddr)); 2564 break; 2565 default: 2566 break; 2567 } 2568 2569 return len; 2570 } 2571 2572 /** 2573 * lpfc_idiag_drbacc_read - idiag debugfs read port doorbell 2574 * @file: The file pointer to read from. 2575 * @buf: The buffer to copy the data to. 2576 * @nbytes: The number of bytes to read. 2577 * @ppos: The position in the file to start reading from. 2578 * 2579 * Description: 2580 * This routine reads data from the @phba device doorbell register according 2581 * to the idiag command, and copies to user @buf. Depending on the doorbell 2582 * register read command setup, it does either a single doorbell register 2583 * read or dump all doorbell registers. 2584 * 2585 * Returns: 2586 * This function returns the amount of data that was read (this could be less 2587 * than @nbytes if the end of the file was reached) or a negative error value. 2588 **/ 2589 static ssize_t 2590 lpfc_idiag_drbacc_read(struct file *file, char __user *buf, size_t nbytes, 2591 loff_t *ppos) 2592 { 2593 struct lpfc_debug *debug = file->private_data; 2594 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private; 2595 uint32_t drb_reg_id, i; 2596 char *pbuffer; 2597 int len = 0; 2598 2599 /* This is a user read operation */ 2600 debug->op = LPFC_IDIAG_OP_RD; 2601 2602 if (!debug->buffer) 2603 debug->buffer = kmalloc(LPFC_DRB_ACC_BUF_SIZE, GFP_KERNEL); 2604 if (!debug->buffer) 2605 return 0; 2606 pbuffer = debug->buffer; 2607 2608 if (*ppos) 2609 return 0; 2610 2611 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_RD) 2612 drb_reg_id = idiag.cmd.data[IDIAG_DRBACC_REGID_INDX]; 2613 else 2614 return 0; 2615 2616 if (drb_reg_id == LPFC_DRB_ACC_ALL) 2617 for (i = 1; i <= LPFC_DRB_MAX; i++) 2618 len = lpfc_idiag_drbacc_read_reg(phba, 2619 pbuffer, len, i); 2620 else 2621 len = lpfc_idiag_drbacc_read_reg(phba, 2622 pbuffer, len, drb_reg_id); 2623 2624 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len); 2625 } 2626 2627 /** 2628 * lpfc_idiag_drbacc_write - Syntax check and set up idiag drbacc commands 2629 * @file: The file pointer to read from. 2630 * @buf: The buffer to copy the user data from. 2631 * @nbytes: The number of bytes to get. 2632 * @ppos: The position in the file to start reading from. 2633 * 2634 * This routine get the debugfs idiag command struct from user space and then 2635 * perform the syntax check for port doorbell register read (dump) or write 2636 * (set) command accordingly. In the case of port queue read command, it sets 2637 * up the command in the idiag command struct for the following debugfs read 2638 * operation. In the case of port doorbell register write operation, it 2639 * executes the write operation into the port doorbell register accordingly. 2640 * 2641 * It returns the @nbytges passing in from debugfs user space when successful. 2642 * In case of error conditions, it returns proper error code back to the user 2643 * space. 2644 **/ 2645 static ssize_t 2646 lpfc_idiag_drbacc_write(struct file *file, const char __user *buf, 2647 size_t nbytes, loff_t *ppos) 2648 { 2649 struct lpfc_debug *debug = file->private_data; 2650 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private; 2651 uint32_t drb_reg_id, value, reg_val = 0; 2652 void __iomem *drb_reg; 2653 int rc; 2654 2655 /* This is a user write operation */ 2656 debug->op = LPFC_IDIAG_OP_WR; 2657 2658 rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd); 2659 if (rc < 0) 2660 return rc; 2661 2662 /* Sanity check on command line arguments */ 2663 drb_reg_id = idiag.cmd.data[IDIAG_DRBACC_REGID_INDX]; 2664 value = idiag.cmd.data[IDIAG_DRBACC_VALUE_INDX]; 2665 2666 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_WR || 2667 idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_ST || 2668 idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_CL) { 2669 if (rc != LPFC_DRB_ACC_WR_CMD_ARG) 2670 goto error_out; 2671 if (drb_reg_id > LPFC_DRB_MAX) 2672 goto error_out; 2673 } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_RD) { 2674 if (rc != LPFC_DRB_ACC_RD_CMD_ARG) 2675 goto error_out; 2676 if ((drb_reg_id > LPFC_DRB_MAX) && 2677 (drb_reg_id != LPFC_DRB_ACC_ALL)) 2678 goto error_out; 2679 } else 2680 goto error_out; 2681 2682 /* Perform the write access operation */ 2683 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_WR || 2684 idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_ST || 2685 idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_CL) { 2686 switch (drb_reg_id) { 2687 case LPFC_DRB_EQCQ: 2688 drb_reg = phba->sli4_hba.EQCQDBregaddr; 2689 break; 2690 case LPFC_DRB_MQ: 2691 drb_reg = phba->sli4_hba.MQDBregaddr; 2692 break; 2693 case LPFC_DRB_WQ: 2694 drb_reg = phba->sli4_hba.WQDBregaddr; 2695 break; 2696 case LPFC_DRB_RQ: 2697 drb_reg = phba->sli4_hba.RQDBregaddr; 2698 break; 2699 default: 2700 goto error_out; 2701 } 2702 2703 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_WR) 2704 reg_val = value; 2705 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_ST) { 2706 reg_val = readl(drb_reg); 2707 reg_val |= value; 2708 } 2709 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_CL) { 2710 reg_val = readl(drb_reg); 2711 reg_val &= ~value; 2712 } 2713 writel(reg_val, drb_reg); 2714 readl(drb_reg); /* flush */ 2715 } 2716 return nbytes; 2717 2718 error_out: 2719 /* Clean out command structure on command error out */ 2720 memset(&idiag, 0, sizeof(idiag)); 2721 return -EINVAL; 2722 } 2723 2724 /** 2725 * lpfc_idiag_ctlacc_read_reg - idiag debugfs read a control registers 2726 * @phba: The pointer to hba structure. 2727 * @pbuffer: The pointer to the buffer to copy the data to. 2728 * @len: The lenght of bytes to copied. 2729 * @drbregid: The id to doorbell registers. 2730 * 2731 * Description: 2732 * This routine reads a control register and copies its content to the 2733 * user buffer pointed to by @pbuffer. 2734 * 2735 * Returns: 2736 * This function returns the amount of data that was copied into @pbuffer. 2737 **/ 2738 static int 2739 lpfc_idiag_ctlacc_read_reg(struct lpfc_hba *phba, char *pbuffer, 2740 int len, uint32_t ctlregid) 2741 { 2742 2743 if (!pbuffer) 2744 return 0; 2745 2746 switch (ctlregid) { 2747 case LPFC_CTL_PORT_SEM: 2748 len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len, 2749 "Port SemReg: 0x%08x\n", 2750 readl(phba->sli4_hba.conf_regs_memmap_p + 2751 LPFC_CTL_PORT_SEM_OFFSET)); 2752 break; 2753 case LPFC_CTL_PORT_STA: 2754 len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len, 2755 "Port StaReg: 0x%08x\n", 2756 readl(phba->sli4_hba.conf_regs_memmap_p + 2757 LPFC_CTL_PORT_STA_OFFSET)); 2758 break; 2759 case LPFC_CTL_PORT_CTL: 2760 len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len, 2761 "Port CtlReg: 0x%08x\n", 2762 readl(phba->sli4_hba.conf_regs_memmap_p + 2763 LPFC_CTL_PORT_CTL_OFFSET)); 2764 break; 2765 case LPFC_CTL_PORT_ER1: 2766 len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len, 2767 "Port Er1Reg: 0x%08x\n", 2768 readl(phba->sli4_hba.conf_regs_memmap_p + 2769 LPFC_CTL_PORT_ER1_OFFSET)); 2770 break; 2771 case LPFC_CTL_PORT_ER2: 2772 len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len, 2773 "Port Er2Reg: 0x%08x\n", 2774 readl(phba->sli4_hba.conf_regs_memmap_p + 2775 LPFC_CTL_PORT_ER2_OFFSET)); 2776 break; 2777 case LPFC_CTL_PDEV_CTL: 2778 len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len, 2779 "PDev CtlReg: 0x%08x\n", 2780 readl(phba->sli4_hba.conf_regs_memmap_p + 2781 LPFC_CTL_PDEV_CTL_OFFSET)); 2782 break; 2783 default: 2784 break; 2785 } 2786 return len; 2787 } 2788 2789 /** 2790 * lpfc_idiag_ctlacc_read - idiag debugfs read port and device control register 2791 * @file: The file pointer to read from. 2792 * @buf: The buffer to copy the data to. 2793 * @nbytes: The number of bytes to read. 2794 * @ppos: The position in the file to start reading from. 2795 * 2796 * Description: 2797 * This routine reads data from the @phba port and device registers according 2798 * to the idiag command, and copies to user @buf. 2799 * 2800 * Returns: 2801 * This function returns the amount of data that was read (this could be less 2802 * than @nbytes if the end of the file was reached) or a negative error value. 2803 **/ 2804 static ssize_t 2805 lpfc_idiag_ctlacc_read(struct file *file, char __user *buf, size_t nbytes, 2806 loff_t *ppos) 2807 { 2808 struct lpfc_debug *debug = file->private_data; 2809 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private; 2810 uint32_t ctl_reg_id, i; 2811 char *pbuffer; 2812 int len = 0; 2813 2814 /* This is a user read operation */ 2815 debug->op = LPFC_IDIAG_OP_RD; 2816 2817 if (!debug->buffer) 2818 debug->buffer = kmalloc(LPFC_CTL_ACC_BUF_SIZE, GFP_KERNEL); 2819 if (!debug->buffer) 2820 return 0; 2821 pbuffer = debug->buffer; 2822 2823 if (*ppos) 2824 return 0; 2825 2826 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_RD) 2827 ctl_reg_id = idiag.cmd.data[IDIAG_CTLACC_REGID_INDX]; 2828 else 2829 return 0; 2830 2831 if (ctl_reg_id == LPFC_CTL_ACC_ALL) 2832 for (i = 1; i <= LPFC_CTL_MAX; i++) 2833 len = lpfc_idiag_ctlacc_read_reg(phba, 2834 pbuffer, len, i); 2835 else 2836 len = lpfc_idiag_ctlacc_read_reg(phba, 2837 pbuffer, len, ctl_reg_id); 2838 2839 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len); 2840 } 2841 2842 /** 2843 * lpfc_idiag_ctlacc_write - Syntax check and set up idiag ctlacc commands 2844 * @file: The file pointer to read from. 2845 * @buf: The buffer to copy the user data from. 2846 * @nbytes: The number of bytes to get. 2847 * @ppos: The position in the file to start reading from. 2848 * 2849 * This routine get the debugfs idiag command struct from user space and then 2850 * perform the syntax check for port and device control register read (dump) 2851 * or write (set) command accordingly. 2852 * 2853 * It returns the @nbytges passing in from debugfs user space when successful. 2854 * In case of error conditions, it returns proper error code back to the user 2855 * space. 2856 **/ 2857 static ssize_t 2858 lpfc_idiag_ctlacc_write(struct file *file, const char __user *buf, 2859 size_t nbytes, loff_t *ppos) 2860 { 2861 struct lpfc_debug *debug = file->private_data; 2862 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private; 2863 uint32_t ctl_reg_id, value, reg_val = 0; 2864 void __iomem *ctl_reg; 2865 int rc; 2866 2867 /* This is a user write operation */ 2868 debug->op = LPFC_IDIAG_OP_WR; 2869 2870 rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd); 2871 if (rc < 0) 2872 return rc; 2873 2874 /* Sanity check on command line arguments */ 2875 ctl_reg_id = idiag.cmd.data[IDIAG_CTLACC_REGID_INDX]; 2876 value = idiag.cmd.data[IDIAG_CTLACC_VALUE_INDX]; 2877 2878 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_WR || 2879 idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_ST || 2880 idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_CL) { 2881 if (rc != LPFC_CTL_ACC_WR_CMD_ARG) 2882 goto error_out; 2883 if (ctl_reg_id > LPFC_CTL_MAX) 2884 goto error_out; 2885 } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_RD) { 2886 if (rc != LPFC_CTL_ACC_RD_CMD_ARG) 2887 goto error_out; 2888 if ((ctl_reg_id > LPFC_CTL_MAX) && 2889 (ctl_reg_id != LPFC_CTL_ACC_ALL)) 2890 goto error_out; 2891 } else 2892 goto error_out; 2893 2894 /* Perform the write access operation */ 2895 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_WR || 2896 idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_ST || 2897 idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_CL) { 2898 switch (ctl_reg_id) { 2899 case LPFC_CTL_PORT_SEM: 2900 ctl_reg = phba->sli4_hba.conf_regs_memmap_p + 2901 LPFC_CTL_PORT_SEM_OFFSET; 2902 break; 2903 case LPFC_CTL_PORT_STA: 2904 ctl_reg = phba->sli4_hba.conf_regs_memmap_p + 2905 LPFC_CTL_PORT_STA_OFFSET; 2906 break; 2907 case LPFC_CTL_PORT_CTL: 2908 ctl_reg = phba->sli4_hba.conf_regs_memmap_p + 2909 LPFC_CTL_PORT_CTL_OFFSET; 2910 break; 2911 case LPFC_CTL_PORT_ER1: 2912 ctl_reg = phba->sli4_hba.conf_regs_memmap_p + 2913 LPFC_CTL_PORT_ER1_OFFSET; 2914 break; 2915 case LPFC_CTL_PORT_ER2: 2916 ctl_reg = phba->sli4_hba.conf_regs_memmap_p + 2917 LPFC_CTL_PORT_ER2_OFFSET; 2918 break; 2919 case LPFC_CTL_PDEV_CTL: 2920 ctl_reg = phba->sli4_hba.conf_regs_memmap_p + 2921 LPFC_CTL_PDEV_CTL_OFFSET; 2922 break; 2923 default: 2924 goto error_out; 2925 } 2926 2927 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_WR) 2928 reg_val = value; 2929 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_ST) { 2930 reg_val = readl(ctl_reg); 2931 reg_val |= value; 2932 } 2933 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_CL) { 2934 reg_val = readl(ctl_reg); 2935 reg_val &= ~value; 2936 } 2937 writel(reg_val, ctl_reg); 2938 readl(ctl_reg); /* flush */ 2939 } 2940 return nbytes; 2941 2942 error_out: 2943 /* Clean out command structure on command error out */ 2944 memset(&idiag, 0, sizeof(idiag)); 2945 return -EINVAL; 2946 } 2947 2948 /** 2949 * lpfc_idiag_mbxacc_get_setup - idiag debugfs get mailbox access setup 2950 * @phba: Pointer to HBA context object. 2951 * @pbuffer: Pointer to data buffer. 2952 * 2953 * Description: 2954 * This routine gets the driver mailbox access debugfs setup information. 2955 * 2956 * Returns: 2957 * This function returns the amount of data that was read (this could be less 2958 * than @nbytes if the end of the file was reached) or a negative error value. 2959 **/ 2960 static int 2961 lpfc_idiag_mbxacc_get_setup(struct lpfc_hba *phba, char *pbuffer) 2962 { 2963 uint32_t mbx_dump_map, mbx_dump_cnt, mbx_word_cnt, mbx_mbox_cmd; 2964 int len = 0; 2965 2966 mbx_mbox_cmd = idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX]; 2967 mbx_dump_map = idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX]; 2968 mbx_dump_cnt = idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX]; 2969 mbx_word_cnt = idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX]; 2970 2971 len += snprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len, 2972 "mbx_dump_map: 0x%08x\n", mbx_dump_map); 2973 len += snprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len, 2974 "mbx_dump_cnt: %04d\n", mbx_dump_cnt); 2975 len += snprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len, 2976 "mbx_word_cnt: %04d\n", mbx_word_cnt); 2977 len += snprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len, 2978 "mbx_mbox_cmd: 0x%02x\n", mbx_mbox_cmd); 2979 2980 return len; 2981 } 2982 2983 /** 2984 * lpfc_idiag_mbxacc_read - idiag debugfs read on mailbox access 2985 * @file: The file pointer to read from. 2986 * @buf: The buffer to copy the data to. 2987 * @nbytes: The number of bytes to read. 2988 * @ppos: The position in the file to start reading from. 2989 * 2990 * Description: 2991 * This routine reads data from the @phba driver mailbox access debugfs setup 2992 * information. 2993 * 2994 * Returns: 2995 * This function returns the amount of data that was read (this could be less 2996 * than @nbytes if the end of the file was reached) or a negative error value. 2997 **/ 2998 static ssize_t 2999 lpfc_idiag_mbxacc_read(struct file *file, char __user *buf, size_t nbytes, 3000 loff_t *ppos) 3001 { 3002 struct lpfc_debug *debug = file->private_data; 3003 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private; 3004 char *pbuffer; 3005 int len = 0; 3006 3007 /* This is a user read operation */ 3008 debug->op = LPFC_IDIAG_OP_RD; 3009 3010 if (!debug->buffer) 3011 debug->buffer = kmalloc(LPFC_MBX_ACC_BUF_SIZE, GFP_KERNEL); 3012 if (!debug->buffer) 3013 return 0; 3014 pbuffer = debug->buffer; 3015 3016 if (*ppos) 3017 return 0; 3018 3019 if ((idiag.cmd.opcode != LPFC_IDIAG_CMD_MBXACC_DP) && 3020 (idiag.cmd.opcode != LPFC_IDIAG_BSG_MBXACC_DP)) 3021 return 0; 3022 3023 len = lpfc_idiag_mbxacc_get_setup(phba, pbuffer); 3024 3025 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len); 3026 } 3027 3028 /** 3029 * lpfc_idiag_mbxacc_write - Syntax check and set up idiag mbxacc commands 3030 * @file: The file pointer to read from. 3031 * @buf: The buffer to copy the user data from. 3032 * @nbytes: The number of bytes to get. 3033 * @ppos: The position in the file to start reading from. 3034 * 3035 * This routine get the debugfs idiag command struct from user space and then 3036 * perform the syntax check for driver mailbox command (dump) and sets up the 3037 * necessary states in the idiag command struct accordingly. 3038 * 3039 * It returns the @nbytges passing in from debugfs user space when successful. 3040 * In case of error conditions, it returns proper error code back to the user 3041 * space. 3042 **/ 3043 static ssize_t 3044 lpfc_idiag_mbxacc_write(struct file *file, const char __user *buf, 3045 size_t nbytes, loff_t *ppos) 3046 { 3047 struct lpfc_debug *debug = file->private_data; 3048 uint32_t mbx_dump_map, mbx_dump_cnt, mbx_word_cnt, mbx_mbox_cmd; 3049 int rc; 3050 3051 /* This is a user write operation */ 3052 debug->op = LPFC_IDIAG_OP_WR; 3053 3054 rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd); 3055 if (rc < 0) 3056 return rc; 3057 3058 /* Sanity check on command line arguments */ 3059 mbx_mbox_cmd = idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX]; 3060 mbx_dump_map = idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX]; 3061 mbx_dump_cnt = idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX]; 3062 mbx_word_cnt = idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX]; 3063 3064 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_MBXACC_DP) { 3065 if (!(mbx_dump_map & LPFC_MBX_DMP_MBX_ALL)) 3066 goto error_out; 3067 if ((mbx_dump_map & ~LPFC_MBX_DMP_MBX_ALL) && 3068 (mbx_dump_map != LPFC_MBX_DMP_ALL)) 3069 goto error_out; 3070 if (mbx_word_cnt > sizeof(MAILBOX_t)) 3071 goto error_out; 3072 } else if (idiag.cmd.opcode == LPFC_IDIAG_BSG_MBXACC_DP) { 3073 if (!(mbx_dump_map & LPFC_BSG_DMP_MBX_ALL)) 3074 goto error_out; 3075 if ((mbx_dump_map & ~LPFC_BSG_DMP_MBX_ALL) && 3076 (mbx_dump_map != LPFC_MBX_DMP_ALL)) 3077 goto error_out; 3078 if (mbx_word_cnt > (BSG_MBOX_SIZE)/4) 3079 goto error_out; 3080 if (mbx_mbox_cmd != 0x9b) 3081 goto error_out; 3082 } else 3083 goto error_out; 3084 3085 if (mbx_word_cnt == 0) 3086 goto error_out; 3087 if (rc != LPFC_MBX_DMP_ARG) 3088 goto error_out; 3089 if (mbx_mbox_cmd & ~0xff) 3090 goto error_out; 3091 3092 /* condition for stop mailbox dump */ 3093 if (mbx_dump_cnt == 0) 3094 goto reset_out; 3095 3096 return nbytes; 3097 3098 reset_out: 3099 /* Clean out command structure on command error out */ 3100 memset(&idiag, 0, sizeof(idiag)); 3101 return nbytes; 3102 3103 error_out: 3104 /* Clean out command structure on command error out */ 3105 memset(&idiag, 0, sizeof(idiag)); 3106 return -EINVAL; 3107 } 3108 3109 /** 3110 * lpfc_idiag_extacc_avail_get - get the available extents information 3111 * @phba: pointer to lpfc hba data structure. 3112 * @pbuffer: pointer to internal buffer. 3113 * @len: length into the internal buffer data has been copied. 3114 * 3115 * Description: 3116 * This routine is to get the available extent information. 3117 * 3118 * Returns: 3119 * overall lenth of the data read into the internal buffer. 3120 **/ 3121 static int 3122 lpfc_idiag_extacc_avail_get(struct lpfc_hba *phba, char *pbuffer, int len) 3123 { 3124 uint16_t ext_cnt, ext_size; 3125 3126 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3127 "\nAvailable Extents Information:\n"); 3128 3129 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3130 "\tPort Available VPI extents: "); 3131 lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_VPI, 3132 &ext_cnt, &ext_size); 3133 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3134 "Count %3d, Size %3d\n", ext_cnt, ext_size); 3135 3136 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3137 "\tPort Available VFI extents: "); 3138 lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_VFI, 3139 &ext_cnt, &ext_size); 3140 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3141 "Count %3d, Size %3d\n", ext_cnt, ext_size); 3142 3143 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3144 "\tPort Available RPI extents: "); 3145 lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_RPI, 3146 &ext_cnt, &ext_size); 3147 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3148 "Count %3d, Size %3d\n", ext_cnt, ext_size); 3149 3150 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3151 "\tPort Available XRI extents: "); 3152 lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_XRI, 3153 &ext_cnt, &ext_size); 3154 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3155 "Count %3d, Size %3d\n", ext_cnt, ext_size); 3156 3157 return len; 3158 } 3159 3160 /** 3161 * lpfc_idiag_extacc_alloc_get - get the allocated extents information 3162 * @phba: pointer to lpfc hba data structure. 3163 * @pbuffer: pointer to internal buffer. 3164 * @len: length into the internal buffer data has been copied. 3165 * 3166 * Description: 3167 * This routine is to get the allocated extent information. 3168 * 3169 * Returns: 3170 * overall lenth of the data read into the internal buffer. 3171 **/ 3172 static int 3173 lpfc_idiag_extacc_alloc_get(struct lpfc_hba *phba, char *pbuffer, int len) 3174 { 3175 uint16_t ext_cnt, ext_size; 3176 int rc; 3177 3178 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3179 "\nAllocated Extents Information:\n"); 3180 3181 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3182 "\tHost Allocated VPI extents: "); 3183 rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_VPI, 3184 &ext_cnt, &ext_size); 3185 if (!rc) 3186 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3187 "Port %d Extent %3d, Size %3d\n", 3188 phba->brd_no, ext_cnt, ext_size); 3189 else 3190 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3191 "N/A\n"); 3192 3193 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3194 "\tHost Allocated VFI extents: "); 3195 rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_VFI, 3196 &ext_cnt, &ext_size); 3197 if (!rc) 3198 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3199 "Port %d Extent %3d, Size %3d\n", 3200 phba->brd_no, ext_cnt, ext_size); 3201 else 3202 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3203 "N/A\n"); 3204 3205 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3206 "\tHost Allocated RPI extents: "); 3207 rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_RPI, 3208 &ext_cnt, &ext_size); 3209 if (!rc) 3210 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3211 "Port %d Extent %3d, Size %3d\n", 3212 phba->brd_no, ext_cnt, ext_size); 3213 else 3214 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3215 "N/A\n"); 3216 3217 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3218 "\tHost Allocated XRI extents: "); 3219 rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_XRI, 3220 &ext_cnt, &ext_size); 3221 if (!rc) 3222 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3223 "Port %d Extent %3d, Size %3d\n", 3224 phba->brd_no, ext_cnt, ext_size); 3225 else 3226 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3227 "N/A\n"); 3228 3229 return len; 3230 } 3231 3232 /** 3233 * lpfc_idiag_extacc_drivr_get - get driver extent information 3234 * @phba: pointer to lpfc hba data structure. 3235 * @pbuffer: pointer to internal buffer. 3236 * @len: length into the internal buffer data has been copied. 3237 * 3238 * Description: 3239 * This routine is to get the driver extent information. 3240 * 3241 * Returns: 3242 * overall lenth of the data read into the internal buffer. 3243 **/ 3244 static int 3245 lpfc_idiag_extacc_drivr_get(struct lpfc_hba *phba, char *pbuffer, int len) 3246 { 3247 struct lpfc_rsrc_blks *rsrc_blks; 3248 int index; 3249 3250 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3251 "\nDriver Extents Information:\n"); 3252 3253 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3254 "\tVPI extents:\n"); 3255 index = 0; 3256 list_for_each_entry(rsrc_blks, &phba->lpfc_vpi_blk_list, list) { 3257 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3258 "\t\tBlock %3d: Start %4d, Count %4d\n", 3259 index, rsrc_blks->rsrc_start, 3260 rsrc_blks->rsrc_size); 3261 index++; 3262 } 3263 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3264 "\tVFI extents:\n"); 3265 index = 0; 3266 list_for_each_entry(rsrc_blks, &phba->sli4_hba.lpfc_vfi_blk_list, 3267 list) { 3268 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3269 "\t\tBlock %3d: Start %4d, Count %4d\n", 3270 index, rsrc_blks->rsrc_start, 3271 rsrc_blks->rsrc_size); 3272 index++; 3273 } 3274 3275 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3276 "\tRPI extents:\n"); 3277 index = 0; 3278 list_for_each_entry(rsrc_blks, &phba->sli4_hba.lpfc_rpi_blk_list, 3279 list) { 3280 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3281 "\t\tBlock %3d: Start %4d, Count %4d\n", 3282 index, rsrc_blks->rsrc_start, 3283 rsrc_blks->rsrc_size); 3284 index++; 3285 } 3286 3287 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3288 "\tXRI extents:\n"); 3289 index = 0; 3290 list_for_each_entry(rsrc_blks, &phba->sli4_hba.lpfc_xri_blk_list, 3291 list) { 3292 len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len, 3293 "\t\tBlock %3d: Start %4d, Count %4d\n", 3294 index, rsrc_blks->rsrc_start, 3295 rsrc_blks->rsrc_size); 3296 index++; 3297 } 3298 3299 return len; 3300 } 3301 3302 /** 3303 * lpfc_idiag_extacc_write - Syntax check and set up idiag extacc commands 3304 * @file: The file pointer to read from. 3305 * @buf: The buffer to copy the user data from. 3306 * @nbytes: The number of bytes to get. 3307 * @ppos: The position in the file to start reading from. 3308 * 3309 * This routine get the debugfs idiag command struct from user space and then 3310 * perform the syntax check for extent information access commands and sets 3311 * up the necessary states in the idiag command struct accordingly. 3312 * 3313 * It returns the @nbytges passing in from debugfs user space when successful. 3314 * In case of error conditions, it returns proper error code back to the user 3315 * space. 3316 **/ 3317 static ssize_t 3318 lpfc_idiag_extacc_write(struct file *file, const char __user *buf, 3319 size_t nbytes, loff_t *ppos) 3320 { 3321 struct lpfc_debug *debug = file->private_data; 3322 uint32_t ext_map; 3323 int rc; 3324 3325 /* This is a user write operation */ 3326 debug->op = LPFC_IDIAG_OP_WR; 3327 3328 rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd); 3329 if (rc < 0) 3330 return rc; 3331 3332 ext_map = idiag.cmd.data[IDIAG_EXTACC_EXMAP_INDX]; 3333 3334 if (idiag.cmd.opcode != LPFC_IDIAG_CMD_EXTACC_RD) 3335 goto error_out; 3336 if (rc != LPFC_EXT_ACC_CMD_ARG) 3337 goto error_out; 3338 if (!(ext_map & LPFC_EXT_ACC_ALL)) 3339 goto error_out; 3340 3341 return nbytes; 3342 error_out: 3343 /* Clean out command structure on command error out */ 3344 memset(&idiag, 0, sizeof(idiag)); 3345 return -EINVAL; 3346 } 3347 3348 /** 3349 * lpfc_idiag_extacc_read - idiag debugfs read access to extent information 3350 * @file: The file pointer to read from. 3351 * @buf: The buffer to copy the data to. 3352 * @nbytes: The number of bytes to read. 3353 * @ppos: The position in the file to start reading from. 3354 * 3355 * Description: 3356 * This routine reads data from the proper extent information according to 3357 * the idiag command, and copies to user @buf. 3358 * 3359 * Returns: 3360 * This function returns the amount of data that was read (this could be less 3361 * than @nbytes if the end of the file was reached) or a negative error value. 3362 **/ 3363 static ssize_t 3364 lpfc_idiag_extacc_read(struct file *file, char __user *buf, size_t nbytes, 3365 loff_t *ppos) 3366 { 3367 struct lpfc_debug *debug = file->private_data; 3368 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private; 3369 char *pbuffer; 3370 uint32_t ext_map; 3371 int len = 0; 3372 3373 /* This is a user read operation */ 3374 debug->op = LPFC_IDIAG_OP_RD; 3375 3376 if (!debug->buffer) 3377 debug->buffer = kmalloc(LPFC_EXT_ACC_BUF_SIZE, GFP_KERNEL); 3378 if (!debug->buffer) 3379 return 0; 3380 pbuffer = debug->buffer; 3381 if (*ppos) 3382 return 0; 3383 if (idiag.cmd.opcode != LPFC_IDIAG_CMD_EXTACC_RD) 3384 return 0; 3385 3386 ext_map = idiag.cmd.data[IDIAG_EXTACC_EXMAP_INDX]; 3387 if (ext_map & LPFC_EXT_ACC_AVAIL) 3388 len = lpfc_idiag_extacc_avail_get(phba, pbuffer, len); 3389 if (ext_map & LPFC_EXT_ACC_ALLOC) 3390 len = lpfc_idiag_extacc_alloc_get(phba, pbuffer, len); 3391 if (ext_map & LPFC_EXT_ACC_DRIVR) 3392 len = lpfc_idiag_extacc_drivr_get(phba, pbuffer, len); 3393 3394 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len); 3395 } 3396 3397 #undef lpfc_debugfs_op_disc_trc 3398 static const struct file_operations lpfc_debugfs_op_disc_trc = { 3399 .owner = THIS_MODULE, 3400 .open = lpfc_debugfs_disc_trc_open, 3401 .llseek = lpfc_debugfs_lseek, 3402 .read = lpfc_debugfs_read, 3403 .release = lpfc_debugfs_release, 3404 }; 3405 3406 #undef lpfc_debugfs_op_nodelist 3407 static const struct file_operations lpfc_debugfs_op_nodelist = { 3408 .owner = THIS_MODULE, 3409 .open = lpfc_debugfs_nodelist_open, 3410 .llseek = lpfc_debugfs_lseek, 3411 .read = lpfc_debugfs_read, 3412 .release = lpfc_debugfs_release, 3413 }; 3414 3415 #undef lpfc_debugfs_op_hbqinfo 3416 static const struct file_operations lpfc_debugfs_op_hbqinfo = { 3417 .owner = THIS_MODULE, 3418 .open = lpfc_debugfs_hbqinfo_open, 3419 .llseek = lpfc_debugfs_lseek, 3420 .read = lpfc_debugfs_read, 3421 .release = lpfc_debugfs_release, 3422 }; 3423 3424 #undef lpfc_debugfs_op_dumpHBASlim 3425 static const struct file_operations lpfc_debugfs_op_dumpHBASlim = { 3426 .owner = THIS_MODULE, 3427 .open = lpfc_debugfs_dumpHBASlim_open, 3428 .llseek = lpfc_debugfs_lseek, 3429 .read = lpfc_debugfs_read, 3430 .release = lpfc_debugfs_release, 3431 }; 3432 3433 #undef lpfc_debugfs_op_dumpHostSlim 3434 static const struct file_operations lpfc_debugfs_op_dumpHostSlim = { 3435 .owner = THIS_MODULE, 3436 .open = lpfc_debugfs_dumpHostSlim_open, 3437 .llseek = lpfc_debugfs_lseek, 3438 .read = lpfc_debugfs_read, 3439 .release = lpfc_debugfs_release, 3440 }; 3441 3442 #undef lpfc_debugfs_op_dumpData 3443 static const struct file_operations lpfc_debugfs_op_dumpData = { 3444 .owner = THIS_MODULE, 3445 .open = lpfc_debugfs_dumpData_open, 3446 .llseek = lpfc_debugfs_lseek, 3447 .read = lpfc_debugfs_read, 3448 .write = lpfc_debugfs_dumpDataDif_write, 3449 .release = lpfc_debugfs_dumpDataDif_release, 3450 }; 3451 3452 #undef lpfc_debugfs_op_dumpDif 3453 static const struct file_operations lpfc_debugfs_op_dumpDif = { 3454 .owner = THIS_MODULE, 3455 .open = lpfc_debugfs_dumpDif_open, 3456 .llseek = lpfc_debugfs_lseek, 3457 .read = lpfc_debugfs_read, 3458 .write = lpfc_debugfs_dumpDataDif_write, 3459 .release = lpfc_debugfs_dumpDataDif_release, 3460 }; 3461 3462 #undef lpfc_debugfs_op_dif_err 3463 static const struct file_operations lpfc_debugfs_op_dif_err = { 3464 .owner = THIS_MODULE, 3465 .open = lpfc_debugfs_dif_err_open, 3466 .llseek = lpfc_debugfs_lseek, 3467 .read = lpfc_debugfs_dif_err_read, 3468 .write = lpfc_debugfs_dif_err_write, 3469 .release = lpfc_debugfs_dif_err_release, 3470 }; 3471 3472 #undef lpfc_debugfs_op_slow_ring_trc 3473 static const struct file_operations lpfc_debugfs_op_slow_ring_trc = { 3474 .owner = THIS_MODULE, 3475 .open = lpfc_debugfs_slow_ring_trc_open, 3476 .llseek = lpfc_debugfs_lseek, 3477 .read = lpfc_debugfs_read, 3478 .release = lpfc_debugfs_release, 3479 }; 3480 3481 static struct dentry *lpfc_debugfs_root = NULL; 3482 static atomic_t lpfc_debugfs_hba_count; 3483 3484 /* 3485 * File operations for the iDiag debugfs 3486 */ 3487 #undef lpfc_idiag_op_pciCfg 3488 static const struct file_operations lpfc_idiag_op_pciCfg = { 3489 .owner = THIS_MODULE, 3490 .open = lpfc_idiag_open, 3491 .llseek = lpfc_debugfs_lseek, 3492 .read = lpfc_idiag_pcicfg_read, 3493 .write = lpfc_idiag_pcicfg_write, 3494 .release = lpfc_idiag_cmd_release, 3495 }; 3496 3497 #undef lpfc_idiag_op_barAcc 3498 static const struct file_operations lpfc_idiag_op_barAcc = { 3499 .owner = THIS_MODULE, 3500 .open = lpfc_idiag_open, 3501 .llseek = lpfc_debugfs_lseek, 3502 .read = lpfc_idiag_baracc_read, 3503 .write = lpfc_idiag_baracc_write, 3504 .release = lpfc_idiag_cmd_release, 3505 }; 3506 3507 #undef lpfc_idiag_op_queInfo 3508 static const struct file_operations lpfc_idiag_op_queInfo = { 3509 .owner = THIS_MODULE, 3510 .open = lpfc_idiag_open, 3511 .read = lpfc_idiag_queinfo_read, 3512 .release = lpfc_idiag_release, 3513 }; 3514 3515 #undef lpfc_idiag_op_queAcc 3516 static const struct file_operations lpfc_idiag_op_queAcc = { 3517 .owner = THIS_MODULE, 3518 .open = lpfc_idiag_open, 3519 .llseek = lpfc_debugfs_lseek, 3520 .read = lpfc_idiag_queacc_read, 3521 .write = lpfc_idiag_queacc_write, 3522 .release = lpfc_idiag_cmd_release, 3523 }; 3524 3525 #undef lpfc_idiag_op_drbAcc 3526 static const struct file_operations lpfc_idiag_op_drbAcc = { 3527 .owner = THIS_MODULE, 3528 .open = lpfc_idiag_open, 3529 .llseek = lpfc_debugfs_lseek, 3530 .read = lpfc_idiag_drbacc_read, 3531 .write = lpfc_idiag_drbacc_write, 3532 .release = lpfc_idiag_cmd_release, 3533 }; 3534 3535 #undef lpfc_idiag_op_ctlAcc 3536 static const struct file_operations lpfc_idiag_op_ctlAcc = { 3537 .owner = THIS_MODULE, 3538 .open = lpfc_idiag_open, 3539 .llseek = lpfc_debugfs_lseek, 3540 .read = lpfc_idiag_ctlacc_read, 3541 .write = lpfc_idiag_ctlacc_write, 3542 .release = lpfc_idiag_cmd_release, 3543 }; 3544 3545 #undef lpfc_idiag_op_mbxAcc 3546 static const struct file_operations lpfc_idiag_op_mbxAcc = { 3547 .owner = THIS_MODULE, 3548 .open = lpfc_idiag_open, 3549 .llseek = lpfc_debugfs_lseek, 3550 .read = lpfc_idiag_mbxacc_read, 3551 .write = lpfc_idiag_mbxacc_write, 3552 .release = lpfc_idiag_cmd_release, 3553 }; 3554 3555 #undef lpfc_idiag_op_extAcc 3556 static const struct file_operations lpfc_idiag_op_extAcc = { 3557 .owner = THIS_MODULE, 3558 .open = lpfc_idiag_open, 3559 .llseek = lpfc_debugfs_lseek, 3560 .read = lpfc_idiag_extacc_read, 3561 .write = lpfc_idiag_extacc_write, 3562 .release = lpfc_idiag_cmd_release, 3563 }; 3564 3565 #endif 3566 3567 /* lpfc_idiag_mbxacc_dump_bsg_mbox - idiag debugfs dump bsg mailbox command 3568 * @phba: Pointer to HBA context object. 3569 * @dmabuf: Pointer to a DMA buffer descriptor. 3570 * 3571 * Description: 3572 * This routine dump a bsg pass-through non-embedded mailbox command with 3573 * external buffer. 3574 **/ 3575 void 3576 lpfc_idiag_mbxacc_dump_bsg_mbox(struct lpfc_hba *phba, enum nemb_type nemb_tp, 3577 enum mbox_type mbox_tp, enum dma_type dma_tp, 3578 enum sta_type sta_tp, 3579 struct lpfc_dmabuf *dmabuf, uint32_t ext_buf) 3580 { 3581 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 3582 uint32_t *mbx_mbox_cmd, *mbx_dump_map, *mbx_dump_cnt, *mbx_word_cnt; 3583 char line_buf[LPFC_MBX_ACC_LBUF_SZ]; 3584 int len = 0; 3585 uint32_t do_dump = 0; 3586 uint32_t *pword; 3587 uint32_t i; 3588 3589 if (idiag.cmd.opcode != LPFC_IDIAG_BSG_MBXACC_DP) 3590 return; 3591 3592 mbx_mbox_cmd = &idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX]; 3593 mbx_dump_map = &idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX]; 3594 mbx_dump_cnt = &idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX]; 3595 mbx_word_cnt = &idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX]; 3596 3597 if (!(*mbx_dump_map & LPFC_MBX_DMP_ALL) || 3598 (*mbx_dump_cnt == 0) || 3599 (*mbx_word_cnt == 0)) 3600 return; 3601 3602 if (*mbx_mbox_cmd != 0x9B) 3603 return; 3604 3605 if ((mbox_tp == mbox_rd) && (dma_tp == dma_mbox)) { 3606 if (*mbx_dump_map & LPFC_BSG_DMP_MBX_RD_MBX) { 3607 do_dump |= LPFC_BSG_DMP_MBX_RD_MBX; 3608 printk(KERN_ERR "\nRead mbox command (x%x), " 3609 "nemb:0x%x, extbuf_cnt:%d:\n", 3610 sta_tp, nemb_tp, ext_buf); 3611 } 3612 } 3613 if ((mbox_tp == mbox_rd) && (dma_tp == dma_ebuf)) { 3614 if (*mbx_dump_map & LPFC_BSG_DMP_MBX_RD_BUF) { 3615 do_dump |= LPFC_BSG_DMP_MBX_RD_BUF; 3616 printk(KERN_ERR "\nRead mbox buffer (x%x), " 3617 "nemb:0x%x, extbuf_seq:%d:\n", 3618 sta_tp, nemb_tp, ext_buf); 3619 } 3620 } 3621 if ((mbox_tp == mbox_wr) && (dma_tp == dma_mbox)) { 3622 if (*mbx_dump_map & LPFC_BSG_DMP_MBX_WR_MBX) { 3623 do_dump |= LPFC_BSG_DMP_MBX_WR_MBX; 3624 printk(KERN_ERR "\nWrite mbox command (x%x), " 3625 "nemb:0x%x, extbuf_cnt:%d:\n", 3626 sta_tp, nemb_tp, ext_buf); 3627 } 3628 } 3629 if ((mbox_tp == mbox_wr) && (dma_tp == dma_ebuf)) { 3630 if (*mbx_dump_map & LPFC_BSG_DMP_MBX_WR_BUF) { 3631 do_dump |= LPFC_BSG_DMP_MBX_WR_BUF; 3632 printk(KERN_ERR "\nWrite mbox buffer (x%x), " 3633 "nemb:0x%x, extbuf_seq:%d:\n", 3634 sta_tp, nemb_tp, ext_buf); 3635 } 3636 } 3637 3638 /* dump buffer content */ 3639 if (do_dump) { 3640 pword = (uint32_t *)dmabuf->virt; 3641 for (i = 0; i < *mbx_word_cnt; i++) { 3642 if (!(i % 8)) { 3643 if (i != 0) 3644 printk(KERN_ERR "%s\n", line_buf); 3645 len = 0; 3646 len += snprintf(line_buf+len, 3647 LPFC_MBX_ACC_LBUF_SZ-len, 3648 "%03d: ", i); 3649 } 3650 len += snprintf(line_buf+len, LPFC_MBX_ACC_LBUF_SZ-len, 3651 "%08x ", (uint32_t)*pword); 3652 pword++; 3653 } 3654 if ((i - 1) % 8) 3655 printk(KERN_ERR "%s\n", line_buf); 3656 (*mbx_dump_cnt)--; 3657 } 3658 3659 /* Clean out command structure on reaching dump count */ 3660 if (*mbx_dump_cnt == 0) 3661 memset(&idiag, 0, sizeof(idiag)); 3662 return; 3663 #endif 3664 } 3665 3666 /* lpfc_idiag_mbxacc_dump_issue_mbox - idiag debugfs dump issue mailbox command 3667 * @phba: Pointer to HBA context object. 3668 * @dmabuf: Pointer to a DMA buffer descriptor. 3669 * 3670 * Description: 3671 * This routine dump a pass-through non-embedded mailbox command from issue 3672 * mailbox command. 3673 **/ 3674 void 3675 lpfc_idiag_mbxacc_dump_issue_mbox(struct lpfc_hba *phba, MAILBOX_t *pmbox) 3676 { 3677 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 3678 uint32_t *mbx_dump_map, *mbx_dump_cnt, *mbx_word_cnt, *mbx_mbox_cmd; 3679 char line_buf[LPFC_MBX_ACC_LBUF_SZ]; 3680 int len = 0; 3681 uint32_t *pword; 3682 uint8_t *pbyte; 3683 uint32_t i, j; 3684 3685 if (idiag.cmd.opcode != LPFC_IDIAG_CMD_MBXACC_DP) 3686 return; 3687 3688 mbx_mbox_cmd = &idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX]; 3689 mbx_dump_map = &idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX]; 3690 mbx_dump_cnt = &idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX]; 3691 mbx_word_cnt = &idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX]; 3692 3693 if (!(*mbx_dump_map & LPFC_MBX_DMP_MBX_ALL) || 3694 (*mbx_dump_cnt == 0) || 3695 (*mbx_word_cnt == 0)) 3696 return; 3697 3698 if ((*mbx_mbox_cmd != LPFC_MBX_ALL_CMD) && 3699 (*mbx_mbox_cmd != pmbox->mbxCommand)) 3700 return; 3701 3702 /* dump buffer content */ 3703 if (*mbx_dump_map & LPFC_MBX_DMP_MBX_WORD) { 3704 printk(KERN_ERR "Mailbox command:0x%x dump by word:\n", 3705 pmbox->mbxCommand); 3706 pword = (uint32_t *)pmbox; 3707 for (i = 0; i < *mbx_word_cnt; i++) { 3708 if (!(i % 8)) { 3709 if (i != 0) 3710 printk(KERN_ERR "%s\n", line_buf); 3711 len = 0; 3712 memset(line_buf, 0, LPFC_MBX_ACC_LBUF_SZ); 3713 len += snprintf(line_buf+len, 3714 LPFC_MBX_ACC_LBUF_SZ-len, 3715 "%03d: ", i); 3716 } 3717 len += snprintf(line_buf+len, LPFC_MBX_ACC_LBUF_SZ-len, 3718 "%08x ", 3719 ((uint32_t)*pword) & 0xffffffff); 3720 pword++; 3721 } 3722 if ((i - 1) % 8) 3723 printk(KERN_ERR "%s\n", line_buf); 3724 printk(KERN_ERR "\n"); 3725 } 3726 if (*mbx_dump_map & LPFC_MBX_DMP_MBX_BYTE) { 3727 printk(KERN_ERR "Mailbox command:0x%x dump by byte:\n", 3728 pmbox->mbxCommand); 3729 pbyte = (uint8_t *)pmbox; 3730 for (i = 0; i < *mbx_word_cnt; i++) { 3731 if (!(i % 8)) { 3732 if (i != 0) 3733 printk(KERN_ERR "%s\n", line_buf); 3734 len = 0; 3735 memset(line_buf, 0, LPFC_MBX_ACC_LBUF_SZ); 3736 len += snprintf(line_buf+len, 3737 LPFC_MBX_ACC_LBUF_SZ-len, 3738 "%03d: ", i); 3739 } 3740 for (j = 0; j < 4; j++) { 3741 len += snprintf(line_buf+len, 3742 LPFC_MBX_ACC_LBUF_SZ-len, 3743 "%02x", 3744 ((uint8_t)*pbyte) & 0xff); 3745 pbyte++; 3746 } 3747 len += snprintf(line_buf+len, 3748 LPFC_MBX_ACC_LBUF_SZ-len, " "); 3749 } 3750 if ((i - 1) % 8) 3751 printk(KERN_ERR "%s\n", line_buf); 3752 printk(KERN_ERR "\n"); 3753 } 3754 (*mbx_dump_cnt)--; 3755 3756 /* Clean out command structure on reaching dump count */ 3757 if (*mbx_dump_cnt == 0) 3758 memset(&idiag, 0, sizeof(idiag)); 3759 return; 3760 #endif 3761 } 3762 3763 /** 3764 * lpfc_debugfs_initialize - Initialize debugfs for a vport 3765 * @vport: The vport pointer to initialize. 3766 * 3767 * Description: 3768 * When Debugfs is configured this routine sets up the lpfc debugfs file system. 3769 * If not already created, this routine will create the lpfc directory, and 3770 * lpfcX directory (for this HBA), and vportX directory for this vport. It will 3771 * also create each file used to access lpfc specific debugfs information. 3772 **/ 3773 inline void 3774 lpfc_debugfs_initialize(struct lpfc_vport *vport) 3775 { 3776 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 3777 struct lpfc_hba *phba = vport->phba; 3778 char name[64]; 3779 uint32_t num, i; 3780 3781 if (!lpfc_debugfs_enable) 3782 return; 3783 3784 /* Setup lpfc root directory */ 3785 if (!lpfc_debugfs_root) { 3786 lpfc_debugfs_root = debugfs_create_dir("lpfc", NULL); 3787 atomic_set(&lpfc_debugfs_hba_count, 0); 3788 if (!lpfc_debugfs_root) { 3789 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3790 "0408 Cannot create debugfs root\n"); 3791 goto debug_failed; 3792 } 3793 } 3794 if (!lpfc_debugfs_start_time) 3795 lpfc_debugfs_start_time = jiffies; 3796 3797 /* Setup funcX directory for specific HBA PCI function */ 3798 snprintf(name, sizeof(name), "fn%d", phba->brd_no); 3799 if (!phba->hba_debugfs_root) { 3800 phba->hba_debugfs_root = 3801 debugfs_create_dir(name, lpfc_debugfs_root); 3802 if (!phba->hba_debugfs_root) { 3803 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3804 "0412 Cannot create debugfs hba\n"); 3805 goto debug_failed; 3806 } 3807 atomic_inc(&lpfc_debugfs_hba_count); 3808 atomic_set(&phba->debugfs_vport_count, 0); 3809 3810 /* Setup hbqinfo */ 3811 snprintf(name, sizeof(name), "hbqinfo"); 3812 phba->debug_hbqinfo = 3813 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 3814 phba->hba_debugfs_root, 3815 phba, &lpfc_debugfs_op_hbqinfo); 3816 if (!phba->debug_hbqinfo) { 3817 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3818 "0411 Cannot create debugfs hbqinfo\n"); 3819 goto debug_failed; 3820 } 3821 3822 /* Setup dumpHBASlim */ 3823 if (phba->sli_rev < LPFC_SLI_REV4) { 3824 snprintf(name, sizeof(name), "dumpHBASlim"); 3825 phba->debug_dumpHBASlim = 3826 debugfs_create_file(name, 3827 S_IFREG|S_IRUGO|S_IWUSR, 3828 phba->hba_debugfs_root, 3829 phba, &lpfc_debugfs_op_dumpHBASlim); 3830 if (!phba->debug_dumpHBASlim) { 3831 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3832 "0413 Cannot create debugfs " 3833 "dumpHBASlim\n"); 3834 goto debug_failed; 3835 } 3836 } else 3837 phba->debug_dumpHBASlim = NULL; 3838 3839 /* Setup dumpHostSlim */ 3840 if (phba->sli_rev < LPFC_SLI_REV4) { 3841 snprintf(name, sizeof(name), "dumpHostSlim"); 3842 phba->debug_dumpHostSlim = 3843 debugfs_create_file(name, 3844 S_IFREG|S_IRUGO|S_IWUSR, 3845 phba->hba_debugfs_root, 3846 phba, &lpfc_debugfs_op_dumpHostSlim); 3847 if (!phba->debug_dumpHostSlim) { 3848 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3849 "0414 Cannot create debugfs " 3850 "dumpHostSlim\n"); 3851 goto debug_failed; 3852 } 3853 } else 3854 phba->debug_dumpHBASlim = NULL; 3855 3856 /* Setup dumpData */ 3857 snprintf(name, sizeof(name), "dumpData"); 3858 phba->debug_dumpData = 3859 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 3860 phba->hba_debugfs_root, 3861 phba, &lpfc_debugfs_op_dumpData); 3862 if (!phba->debug_dumpData) { 3863 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3864 "0800 Cannot create debugfs dumpData\n"); 3865 goto debug_failed; 3866 } 3867 3868 /* Setup dumpDif */ 3869 snprintf(name, sizeof(name), "dumpDif"); 3870 phba->debug_dumpDif = 3871 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 3872 phba->hba_debugfs_root, 3873 phba, &lpfc_debugfs_op_dumpDif); 3874 if (!phba->debug_dumpDif) { 3875 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3876 "0801 Cannot create debugfs dumpDif\n"); 3877 goto debug_failed; 3878 } 3879 3880 /* Setup DIF Error Injections */ 3881 snprintf(name, sizeof(name), "InjErrLBA"); 3882 phba->debug_InjErrLBA = 3883 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 3884 phba->hba_debugfs_root, 3885 phba, &lpfc_debugfs_op_dif_err); 3886 if (!phba->debug_InjErrLBA) { 3887 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3888 "0807 Cannot create debugfs InjErrLBA\n"); 3889 goto debug_failed; 3890 } 3891 phba->lpfc_injerr_lba = LPFC_INJERR_LBA_OFF; 3892 3893 snprintf(name, sizeof(name), "writeGuardInjErr"); 3894 phba->debug_writeGuard = 3895 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 3896 phba->hba_debugfs_root, 3897 phba, &lpfc_debugfs_op_dif_err); 3898 if (!phba->debug_writeGuard) { 3899 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3900 "0802 Cannot create debugfs writeGuard\n"); 3901 goto debug_failed; 3902 } 3903 3904 snprintf(name, sizeof(name), "writeAppInjErr"); 3905 phba->debug_writeApp = 3906 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 3907 phba->hba_debugfs_root, 3908 phba, &lpfc_debugfs_op_dif_err); 3909 if (!phba->debug_writeApp) { 3910 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3911 "0803 Cannot create debugfs writeApp\n"); 3912 goto debug_failed; 3913 } 3914 3915 snprintf(name, sizeof(name), "writeRefInjErr"); 3916 phba->debug_writeRef = 3917 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 3918 phba->hba_debugfs_root, 3919 phba, &lpfc_debugfs_op_dif_err); 3920 if (!phba->debug_writeRef) { 3921 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3922 "0804 Cannot create debugfs writeRef\n"); 3923 goto debug_failed; 3924 } 3925 3926 snprintf(name, sizeof(name), "readAppInjErr"); 3927 phba->debug_readApp = 3928 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 3929 phba->hba_debugfs_root, 3930 phba, &lpfc_debugfs_op_dif_err); 3931 if (!phba->debug_readApp) { 3932 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3933 "0805 Cannot create debugfs readApp\n"); 3934 goto debug_failed; 3935 } 3936 3937 snprintf(name, sizeof(name), "readRefInjErr"); 3938 phba->debug_readRef = 3939 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 3940 phba->hba_debugfs_root, 3941 phba, &lpfc_debugfs_op_dif_err); 3942 if (!phba->debug_readRef) { 3943 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3944 "0806 Cannot create debugfs readApp\n"); 3945 goto debug_failed; 3946 } 3947 3948 /* Setup slow ring trace */ 3949 if (lpfc_debugfs_max_slow_ring_trc) { 3950 num = lpfc_debugfs_max_slow_ring_trc - 1; 3951 if (num & lpfc_debugfs_max_slow_ring_trc) { 3952 /* Change to be a power of 2 */ 3953 num = lpfc_debugfs_max_slow_ring_trc; 3954 i = 0; 3955 while (num > 1) { 3956 num = num >> 1; 3957 i++; 3958 } 3959 lpfc_debugfs_max_slow_ring_trc = (1 << i); 3960 printk(KERN_ERR 3961 "lpfc_debugfs_max_disc_trc changed to " 3962 "%d\n", lpfc_debugfs_max_disc_trc); 3963 } 3964 } 3965 3966 snprintf(name, sizeof(name), "slow_ring_trace"); 3967 phba->debug_slow_ring_trc = 3968 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 3969 phba->hba_debugfs_root, 3970 phba, &lpfc_debugfs_op_slow_ring_trc); 3971 if (!phba->debug_slow_ring_trc) { 3972 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3973 "0415 Cannot create debugfs " 3974 "slow_ring_trace\n"); 3975 goto debug_failed; 3976 } 3977 if (!phba->slow_ring_trc) { 3978 phba->slow_ring_trc = kmalloc( 3979 (sizeof(struct lpfc_debugfs_trc) * 3980 lpfc_debugfs_max_slow_ring_trc), 3981 GFP_KERNEL); 3982 if (!phba->slow_ring_trc) { 3983 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 3984 "0416 Cannot create debugfs " 3985 "slow_ring buffer\n"); 3986 goto debug_failed; 3987 } 3988 atomic_set(&phba->slow_ring_trc_cnt, 0); 3989 memset(phba->slow_ring_trc, 0, 3990 (sizeof(struct lpfc_debugfs_trc) * 3991 lpfc_debugfs_max_slow_ring_trc)); 3992 } 3993 } 3994 3995 snprintf(name, sizeof(name), "vport%d", vport->vpi); 3996 if (!vport->vport_debugfs_root) { 3997 vport->vport_debugfs_root = 3998 debugfs_create_dir(name, phba->hba_debugfs_root); 3999 if (!vport->vport_debugfs_root) { 4000 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 4001 "0417 Can't create debugfs\n"); 4002 goto debug_failed; 4003 } 4004 atomic_inc(&phba->debugfs_vport_count); 4005 } 4006 4007 if (lpfc_debugfs_max_disc_trc) { 4008 num = lpfc_debugfs_max_disc_trc - 1; 4009 if (num & lpfc_debugfs_max_disc_trc) { 4010 /* Change to be a power of 2 */ 4011 num = lpfc_debugfs_max_disc_trc; 4012 i = 0; 4013 while (num > 1) { 4014 num = num >> 1; 4015 i++; 4016 } 4017 lpfc_debugfs_max_disc_trc = (1 << i); 4018 printk(KERN_ERR 4019 "lpfc_debugfs_max_disc_trc changed to %d\n", 4020 lpfc_debugfs_max_disc_trc); 4021 } 4022 } 4023 4024 vport->disc_trc = kzalloc( 4025 (sizeof(struct lpfc_debugfs_trc) * lpfc_debugfs_max_disc_trc), 4026 GFP_KERNEL); 4027 4028 if (!vport->disc_trc) { 4029 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 4030 "0418 Cannot create debugfs disc trace " 4031 "buffer\n"); 4032 goto debug_failed; 4033 } 4034 atomic_set(&vport->disc_trc_cnt, 0); 4035 4036 snprintf(name, sizeof(name), "discovery_trace"); 4037 vport->debug_disc_trc = 4038 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 4039 vport->vport_debugfs_root, 4040 vport, &lpfc_debugfs_op_disc_trc); 4041 if (!vport->debug_disc_trc) { 4042 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 4043 "0419 Cannot create debugfs " 4044 "discovery_trace\n"); 4045 goto debug_failed; 4046 } 4047 snprintf(name, sizeof(name), "nodelist"); 4048 vport->debug_nodelist = 4049 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 4050 vport->vport_debugfs_root, 4051 vport, &lpfc_debugfs_op_nodelist); 4052 if (!vport->debug_nodelist) { 4053 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 4054 "2985 Can't create debugfs nodelist\n"); 4055 goto debug_failed; 4056 } 4057 4058 /* 4059 * iDiag debugfs root entry points for SLI4 device only 4060 */ 4061 if (phba->sli_rev < LPFC_SLI_REV4) 4062 goto debug_failed; 4063 4064 snprintf(name, sizeof(name), "iDiag"); 4065 if (!phba->idiag_root) { 4066 phba->idiag_root = 4067 debugfs_create_dir(name, phba->hba_debugfs_root); 4068 if (!phba->idiag_root) { 4069 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 4070 "2922 Can't create idiag debugfs\n"); 4071 goto debug_failed; 4072 } 4073 /* Initialize iDiag data structure */ 4074 memset(&idiag, 0, sizeof(idiag)); 4075 } 4076 4077 /* iDiag read PCI config space */ 4078 snprintf(name, sizeof(name), "pciCfg"); 4079 if (!phba->idiag_pci_cfg) { 4080 phba->idiag_pci_cfg = 4081 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 4082 phba->idiag_root, phba, &lpfc_idiag_op_pciCfg); 4083 if (!phba->idiag_pci_cfg) { 4084 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 4085 "2923 Can't create idiag debugfs\n"); 4086 goto debug_failed; 4087 } 4088 idiag.offset.last_rd = 0; 4089 } 4090 4091 /* iDiag PCI BAR access */ 4092 snprintf(name, sizeof(name), "barAcc"); 4093 if (!phba->idiag_bar_acc) { 4094 phba->idiag_bar_acc = 4095 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 4096 phba->idiag_root, phba, &lpfc_idiag_op_barAcc); 4097 if (!phba->idiag_bar_acc) { 4098 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 4099 "3056 Can't create idiag debugfs\n"); 4100 goto debug_failed; 4101 } 4102 idiag.offset.last_rd = 0; 4103 } 4104 4105 /* iDiag get PCI function queue information */ 4106 snprintf(name, sizeof(name), "queInfo"); 4107 if (!phba->idiag_que_info) { 4108 phba->idiag_que_info = 4109 debugfs_create_file(name, S_IFREG|S_IRUGO, 4110 phba->idiag_root, phba, &lpfc_idiag_op_queInfo); 4111 if (!phba->idiag_que_info) { 4112 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 4113 "2924 Can't create idiag debugfs\n"); 4114 goto debug_failed; 4115 } 4116 } 4117 4118 /* iDiag access PCI function queue */ 4119 snprintf(name, sizeof(name), "queAcc"); 4120 if (!phba->idiag_que_acc) { 4121 phba->idiag_que_acc = 4122 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 4123 phba->idiag_root, phba, &lpfc_idiag_op_queAcc); 4124 if (!phba->idiag_que_acc) { 4125 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 4126 "2926 Can't create idiag debugfs\n"); 4127 goto debug_failed; 4128 } 4129 } 4130 4131 /* iDiag access PCI function doorbell registers */ 4132 snprintf(name, sizeof(name), "drbAcc"); 4133 if (!phba->idiag_drb_acc) { 4134 phba->idiag_drb_acc = 4135 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 4136 phba->idiag_root, phba, &lpfc_idiag_op_drbAcc); 4137 if (!phba->idiag_drb_acc) { 4138 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 4139 "2927 Can't create idiag debugfs\n"); 4140 goto debug_failed; 4141 } 4142 } 4143 4144 /* iDiag access PCI function control registers */ 4145 snprintf(name, sizeof(name), "ctlAcc"); 4146 if (!phba->idiag_ctl_acc) { 4147 phba->idiag_ctl_acc = 4148 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 4149 phba->idiag_root, phba, &lpfc_idiag_op_ctlAcc); 4150 if (!phba->idiag_ctl_acc) { 4151 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 4152 "2981 Can't create idiag debugfs\n"); 4153 goto debug_failed; 4154 } 4155 } 4156 4157 /* iDiag access mbox commands */ 4158 snprintf(name, sizeof(name), "mbxAcc"); 4159 if (!phba->idiag_mbx_acc) { 4160 phba->idiag_mbx_acc = 4161 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR, 4162 phba->idiag_root, phba, &lpfc_idiag_op_mbxAcc); 4163 if (!phba->idiag_mbx_acc) { 4164 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 4165 "2980 Can't create idiag debugfs\n"); 4166 goto debug_failed; 4167 } 4168 } 4169 4170 /* iDiag extents access commands */ 4171 if (phba->sli4_hba.extents_in_use) { 4172 snprintf(name, sizeof(name), "extAcc"); 4173 if (!phba->idiag_ext_acc) { 4174 phba->idiag_ext_acc = 4175 debugfs_create_file(name, 4176 S_IFREG|S_IRUGO|S_IWUSR, 4177 phba->idiag_root, phba, 4178 &lpfc_idiag_op_extAcc); 4179 if (!phba->idiag_ext_acc) { 4180 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, 4181 "2986 Cant create " 4182 "idiag debugfs\n"); 4183 goto debug_failed; 4184 } 4185 } 4186 } 4187 4188 debug_failed: 4189 return; 4190 #endif 4191 } 4192 4193 /** 4194 * lpfc_debugfs_terminate - Tear down debugfs infrastructure for this vport 4195 * @vport: The vport pointer to remove from debugfs. 4196 * 4197 * Description: 4198 * When Debugfs is configured this routine removes debugfs file system elements 4199 * that are specific to this vport. It also checks to see if there are any 4200 * users left for the debugfs directories associated with the HBA and driver. If 4201 * this is the last user of the HBA directory or driver directory then it will 4202 * remove those from the debugfs infrastructure as well. 4203 **/ 4204 inline void 4205 lpfc_debugfs_terminate(struct lpfc_vport *vport) 4206 { 4207 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 4208 struct lpfc_hba *phba = vport->phba; 4209 4210 if (vport->disc_trc) { 4211 kfree(vport->disc_trc); 4212 vport->disc_trc = NULL; 4213 } 4214 if (vport->debug_disc_trc) { 4215 debugfs_remove(vport->debug_disc_trc); /* discovery_trace */ 4216 vport->debug_disc_trc = NULL; 4217 } 4218 if (vport->debug_nodelist) { 4219 debugfs_remove(vport->debug_nodelist); /* nodelist */ 4220 vport->debug_nodelist = NULL; 4221 } 4222 if (vport->vport_debugfs_root) { 4223 debugfs_remove(vport->vport_debugfs_root); /* vportX */ 4224 vport->vport_debugfs_root = NULL; 4225 atomic_dec(&phba->debugfs_vport_count); 4226 } 4227 if (atomic_read(&phba->debugfs_vport_count) == 0) { 4228 4229 if (phba->debug_hbqinfo) { 4230 debugfs_remove(phba->debug_hbqinfo); /* hbqinfo */ 4231 phba->debug_hbqinfo = NULL; 4232 } 4233 if (phba->debug_dumpHBASlim) { 4234 debugfs_remove(phba->debug_dumpHBASlim); /* HBASlim */ 4235 phba->debug_dumpHBASlim = NULL; 4236 } 4237 if (phba->debug_dumpHostSlim) { 4238 debugfs_remove(phba->debug_dumpHostSlim); /* HostSlim */ 4239 phba->debug_dumpHostSlim = NULL; 4240 } 4241 if (phba->debug_dumpData) { 4242 debugfs_remove(phba->debug_dumpData); /* dumpData */ 4243 phba->debug_dumpData = NULL; 4244 } 4245 4246 if (phba->debug_dumpDif) { 4247 debugfs_remove(phba->debug_dumpDif); /* dumpDif */ 4248 phba->debug_dumpDif = NULL; 4249 } 4250 if (phba->debug_InjErrLBA) { 4251 debugfs_remove(phba->debug_InjErrLBA); /* InjErrLBA */ 4252 phba->debug_InjErrLBA = NULL; 4253 } 4254 if (phba->debug_writeGuard) { 4255 debugfs_remove(phba->debug_writeGuard); /* writeGuard */ 4256 phba->debug_writeGuard = NULL; 4257 } 4258 if (phba->debug_writeApp) { 4259 debugfs_remove(phba->debug_writeApp); /* writeApp */ 4260 phba->debug_writeApp = NULL; 4261 } 4262 if (phba->debug_writeRef) { 4263 debugfs_remove(phba->debug_writeRef); /* writeRef */ 4264 phba->debug_writeRef = NULL; 4265 } 4266 if (phba->debug_readApp) { 4267 debugfs_remove(phba->debug_readApp); /* readApp */ 4268 phba->debug_readApp = NULL; 4269 } 4270 if (phba->debug_readRef) { 4271 debugfs_remove(phba->debug_readRef); /* readRef */ 4272 phba->debug_readRef = NULL; 4273 } 4274 4275 if (phba->slow_ring_trc) { 4276 kfree(phba->slow_ring_trc); 4277 phba->slow_ring_trc = NULL; 4278 } 4279 if (phba->debug_slow_ring_trc) { 4280 /* slow_ring_trace */ 4281 debugfs_remove(phba->debug_slow_ring_trc); 4282 phba->debug_slow_ring_trc = NULL; 4283 } 4284 4285 /* 4286 * iDiag release 4287 */ 4288 if (phba->sli_rev == LPFC_SLI_REV4) { 4289 if (phba->idiag_ext_acc) { 4290 /* iDiag extAcc */ 4291 debugfs_remove(phba->idiag_ext_acc); 4292 phba->idiag_ext_acc = NULL; 4293 } 4294 if (phba->idiag_mbx_acc) { 4295 /* iDiag mbxAcc */ 4296 debugfs_remove(phba->idiag_mbx_acc); 4297 phba->idiag_mbx_acc = NULL; 4298 } 4299 if (phba->idiag_ctl_acc) { 4300 /* iDiag ctlAcc */ 4301 debugfs_remove(phba->idiag_ctl_acc); 4302 phba->idiag_ctl_acc = NULL; 4303 } 4304 if (phba->idiag_drb_acc) { 4305 /* iDiag drbAcc */ 4306 debugfs_remove(phba->idiag_drb_acc); 4307 phba->idiag_drb_acc = NULL; 4308 } 4309 if (phba->idiag_que_acc) { 4310 /* iDiag queAcc */ 4311 debugfs_remove(phba->idiag_que_acc); 4312 phba->idiag_que_acc = NULL; 4313 } 4314 if (phba->idiag_que_info) { 4315 /* iDiag queInfo */ 4316 debugfs_remove(phba->idiag_que_info); 4317 phba->idiag_que_info = NULL; 4318 } 4319 if (phba->idiag_bar_acc) { 4320 /* iDiag barAcc */ 4321 debugfs_remove(phba->idiag_bar_acc); 4322 phba->idiag_bar_acc = NULL; 4323 } 4324 if (phba->idiag_pci_cfg) { 4325 /* iDiag pciCfg */ 4326 debugfs_remove(phba->idiag_pci_cfg); 4327 phba->idiag_pci_cfg = NULL; 4328 } 4329 4330 /* Finally remove the iDiag debugfs root */ 4331 if (phba->idiag_root) { 4332 /* iDiag root */ 4333 debugfs_remove(phba->idiag_root); 4334 phba->idiag_root = NULL; 4335 } 4336 } 4337 4338 if (phba->hba_debugfs_root) { 4339 debugfs_remove(phba->hba_debugfs_root); /* fnX */ 4340 phba->hba_debugfs_root = NULL; 4341 atomic_dec(&lpfc_debugfs_hba_count); 4342 } 4343 4344 if (atomic_read(&lpfc_debugfs_hba_count) == 0) { 4345 debugfs_remove(lpfc_debugfs_root); /* lpfc */ 4346 lpfc_debugfs_root = NULL; 4347 } 4348 } 4349 #endif 4350 return; 4351 } 4352