1 /* 2 * Linux network driver for QLogic BR-series Converged Network Adapter. 3 * 4 * This program is free software; you can redistribute it and/or modify it 5 * under the terms of the GNU General Public License (GPL) Version 2 as 6 * published by the Free Software Foundation 7 * 8 * This program is distributed in the hope that it will be useful, but 9 * WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 * General Public License for more details. 12 */ 13 /* 14 * Copyright (c) 2005-2014 Brocade Communications Systems, Inc. 15 * Copyright (c) 2014-2015 QLogic Corporation 16 * All rights reserved 17 * www.qlogic.com 18 */ 19 20 #include <linux/debugfs.h> 21 #include <linux/module.h> 22 #include "bnad.h" 23 24 /* 25 * BNA debufs interface 26 * 27 * To access the interface, debugfs file system should be mounted 28 * if not already mounted using: 29 * mount -t debugfs none /sys/kernel/debug 30 * 31 * BNA Hierarchy: 32 * - bna/pci_dev:<pci_name> 33 * where the pci_name corresponds to the one under /sys/bus/pci/drivers/bna 34 * 35 * Debugging service available per pci_dev: 36 * fwtrc: To collect current firmware trace. 37 * fwsave: To collect last saved fw trace as a result of firmware crash. 38 * regwr: To write one word to chip register 39 * regrd: To read one or more words from chip register. 40 */ 41 42 struct bnad_debug_info { 43 char *debug_buffer; 44 void *i_private; 45 int buffer_len; 46 }; 47 48 static int 49 bnad_debugfs_open_fwtrc(struct inode *inode, struct file *file) 50 { 51 struct bnad *bnad = inode->i_private; 52 struct bnad_debug_info *fw_debug; 53 unsigned long flags; 54 int rc; 55 56 fw_debug = kzalloc(sizeof(struct bnad_debug_info), GFP_KERNEL); 57 if (!fw_debug) 58 return -ENOMEM; 59 60 fw_debug->buffer_len = BNA_DBG_FWTRC_LEN; 61 62 fw_debug->debug_buffer = kzalloc(fw_debug->buffer_len, GFP_KERNEL); 63 if (!fw_debug->debug_buffer) { 64 kfree(fw_debug); 65 fw_debug = NULL; 66 return -ENOMEM; 67 } 68 69 spin_lock_irqsave(&bnad->bna_lock, flags); 70 rc = bfa_nw_ioc_debug_fwtrc(&bnad->bna.ioceth.ioc, 71 fw_debug->debug_buffer, 72 &fw_debug->buffer_len); 73 spin_unlock_irqrestore(&bnad->bna_lock, flags); 74 if (rc != BFA_STATUS_OK) { 75 kfree(fw_debug->debug_buffer); 76 fw_debug->debug_buffer = NULL; 77 kfree(fw_debug); 78 fw_debug = NULL; 79 netdev_warn(bnad->netdev, "failed to collect fwtrc\n"); 80 return -ENOMEM; 81 } 82 83 file->private_data = fw_debug; 84 85 return 0; 86 } 87 88 static int 89 bnad_debugfs_open_fwsave(struct inode *inode, struct file *file) 90 { 91 struct bnad *bnad = inode->i_private; 92 struct bnad_debug_info *fw_debug; 93 unsigned long flags; 94 int rc; 95 96 fw_debug = kzalloc(sizeof(struct bnad_debug_info), GFP_KERNEL); 97 if (!fw_debug) 98 return -ENOMEM; 99 100 fw_debug->buffer_len = BNA_DBG_FWTRC_LEN; 101 102 fw_debug->debug_buffer = kzalloc(fw_debug->buffer_len, GFP_KERNEL); 103 if (!fw_debug->debug_buffer) { 104 kfree(fw_debug); 105 fw_debug = NULL; 106 return -ENOMEM; 107 } 108 109 spin_lock_irqsave(&bnad->bna_lock, flags); 110 rc = bfa_nw_ioc_debug_fwsave(&bnad->bna.ioceth.ioc, 111 fw_debug->debug_buffer, 112 &fw_debug->buffer_len); 113 spin_unlock_irqrestore(&bnad->bna_lock, flags); 114 if (rc != BFA_STATUS_OK && rc != BFA_STATUS_ENOFSAVE) { 115 kfree(fw_debug->debug_buffer); 116 fw_debug->debug_buffer = NULL; 117 kfree(fw_debug); 118 fw_debug = NULL; 119 netdev_warn(bnad->netdev, "failed to collect fwsave\n"); 120 return -ENOMEM; 121 } 122 123 file->private_data = fw_debug; 124 125 return 0; 126 } 127 128 static int 129 bnad_debugfs_open_reg(struct inode *inode, struct file *file) 130 { 131 struct bnad_debug_info *reg_debug; 132 133 reg_debug = kzalloc(sizeof(struct bnad_debug_info), GFP_KERNEL); 134 if (!reg_debug) 135 return -ENOMEM; 136 137 reg_debug->i_private = inode->i_private; 138 139 file->private_data = reg_debug; 140 141 return 0; 142 } 143 144 static int 145 bnad_get_debug_drvinfo(struct bnad *bnad, void *buffer, u32 len) 146 { 147 struct bnad_drvinfo *drvinfo = (struct bnad_drvinfo *) buffer; 148 struct bnad_iocmd_comp fcomp; 149 unsigned long flags = 0; 150 int ret = BFA_STATUS_FAILED; 151 152 /* Get IOC info */ 153 spin_lock_irqsave(&bnad->bna_lock, flags); 154 bfa_nw_ioc_get_attr(&bnad->bna.ioceth.ioc, &drvinfo->ioc_attr); 155 spin_unlock_irqrestore(&bnad->bna_lock, flags); 156 157 /* Retrieve CEE related info */ 158 fcomp.bnad = bnad; 159 fcomp.comp_status = 0; 160 init_completion(&fcomp.comp); 161 spin_lock_irqsave(&bnad->bna_lock, flags); 162 ret = bfa_nw_cee_get_attr(&bnad->bna.cee, &drvinfo->cee_attr, 163 bnad_cb_completion, &fcomp); 164 if (ret != BFA_STATUS_OK) { 165 spin_unlock_irqrestore(&bnad->bna_lock, flags); 166 goto out; 167 } 168 spin_unlock_irqrestore(&bnad->bna_lock, flags); 169 wait_for_completion(&fcomp.comp); 170 drvinfo->cee_status = fcomp.comp_status; 171 172 /* Retrieve flash partition info */ 173 fcomp.comp_status = 0; 174 reinit_completion(&fcomp.comp); 175 spin_lock_irqsave(&bnad->bna_lock, flags); 176 ret = bfa_nw_flash_get_attr(&bnad->bna.flash, &drvinfo->flash_attr, 177 bnad_cb_completion, &fcomp); 178 if (ret != BFA_STATUS_OK) { 179 spin_unlock_irqrestore(&bnad->bna_lock, flags); 180 goto out; 181 } 182 spin_unlock_irqrestore(&bnad->bna_lock, flags); 183 wait_for_completion(&fcomp.comp); 184 drvinfo->flash_status = fcomp.comp_status; 185 out: 186 return ret; 187 } 188 189 static int 190 bnad_debugfs_open_drvinfo(struct inode *inode, struct file *file) 191 { 192 struct bnad *bnad = inode->i_private; 193 struct bnad_debug_info *drv_info; 194 int rc; 195 196 drv_info = kzalloc(sizeof(struct bnad_debug_info), GFP_KERNEL); 197 if (!drv_info) 198 return -ENOMEM; 199 200 drv_info->buffer_len = sizeof(struct bnad_drvinfo); 201 202 drv_info->debug_buffer = kzalloc(drv_info->buffer_len, GFP_KERNEL); 203 if (!drv_info->debug_buffer) { 204 kfree(drv_info); 205 drv_info = NULL; 206 return -ENOMEM; 207 } 208 209 mutex_lock(&bnad->conf_mutex); 210 rc = bnad_get_debug_drvinfo(bnad, drv_info->debug_buffer, 211 drv_info->buffer_len); 212 mutex_unlock(&bnad->conf_mutex); 213 if (rc != BFA_STATUS_OK) { 214 kfree(drv_info->debug_buffer); 215 drv_info->debug_buffer = NULL; 216 kfree(drv_info); 217 drv_info = NULL; 218 netdev_warn(bnad->netdev, "failed to collect drvinfo\n"); 219 return -ENOMEM; 220 } 221 222 file->private_data = drv_info; 223 224 return 0; 225 } 226 227 /* Changes the current file position */ 228 static loff_t 229 bnad_debugfs_lseek(struct file *file, loff_t offset, int orig) 230 { 231 struct bnad_debug_info *debug = file->private_data; 232 233 if (!debug) 234 return -EINVAL; 235 236 return fixed_size_llseek(file, offset, orig, debug->buffer_len); 237 } 238 239 static ssize_t 240 bnad_debugfs_read(struct file *file, char __user *buf, 241 size_t nbytes, loff_t *pos) 242 { 243 struct bnad_debug_info *debug = file->private_data; 244 245 if (!debug || !debug->debug_buffer) 246 return 0; 247 248 return simple_read_from_buffer(buf, nbytes, pos, 249 debug->debug_buffer, debug->buffer_len); 250 } 251 252 #define BFA_REG_CT_ADDRSZ (0x40000) 253 #define BFA_REG_CB_ADDRSZ (0x20000) 254 #define BFA_REG_ADDRSZ(__ioc) \ 255 ((u32)(bfa_asic_id_ctc(bfa_ioc_devid(__ioc)) ? \ 256 BFA_REG_CT_ADDRSZ : BFA_REG_CB_ADDRSZ)) 257 #define BFA_REG_ADDRMSK(__ioc) (BFA_REG_ADDRSZ(__ioc) - 1) 258 259 /* 260 * Function to check if the register offset passed is valid. 261 */ 262 static int 263 bna_reg_offset_check(struct bfa_ioc *ioc, u32 offset, u32 len) 264 { 265 u8 area; 266 267 /* check [16:15] */ 268 area = (offset >> 15) & 0x7; 269 if (area == 0) { 270 /* PCIe core register */ 271 if (offset + (len << 2) > 0x8000) /* 8k dwords or 32KB */ 272 return BFA_STATUS_EINVAL; 273 } else if (area == 0x1) { 274 /* CB 32 KB memory page */ 275 if (offset + (len << 2) > 0x10000) /* 8k dwords or 32KB */ 276 return BFA_STATUS_EINVAL; 277 } else { 278 /* CB register space 64KB */ 279 if (offset + (len << 2) > BFA_REG_ADDRMSK(ioc)) 280 return BFA_STATUS_EINVAL; 281 } 282 return BFA_STATUS_OK; 283 } 284 285 static ssize_t 286 bnad_debugfs_read_regrd(struct file *file, char __user *buf, 287 size_t nbytes, loff_t *pos) 288 { 289 struct bnad_debug_info *regrd_debug = file->private_data; 290 struct bnad *bnad = (struct bnad *)regrd_debug->i_private; 291 ssize_t rc; 292 293 if (!bnad->regdata) 294 return 0; 295 296 rc = simple_read_from_buffer(buf, nbytes, pos, 297 bnad->regdata, bnad->reglen); 298 299 if ((*pos + nbytes) >= bnad->reglen) { 300 kfree(bnad->regdata); 301 bnad->regdata = NULL; 302 bnad->reglen = 0; 303 } 304 305 return rc; 306 } 307 308 static ssize_t 309 bnad_debugfs_write_regrd(struct file *file, const char __user *buf, 310 size_t nbytes, loff_t *ppos) 311 { 312 struct bnad_debug_info *regrd_debug = file->private_data; 313 struct bnad *bnad = (struct bnad *)regrd_debug->i_private; 314 struct bfa_ioc *ioc = &bnad->bna.ioceth.ioc; 315 int addr, len, rc, i; 316 u32 *regbuf; 317 void __iomem *rb, *reg_addr; 318 unsigned long flags; 319 void *kern_buf; 320 321 /* Copy the user space buf */ 322 kern_buf = memdup_user(buf, nbytes); 323 if (IS_ERR(kern_buf)) 324 return PTR_ERR(kern_buf); 325 326 rc = sscanf(kern_buf, "%x:%x", &addr, &len); 327 if (rc < 2) { 328 netdev_warn(bnad->netdev, "failed to read user buffer\n"); 329 kfree(kern_buf); 330 return -EINVAL; 331 } 332 333 kfree(kern_buf); 334 kfree(bnad->regdata); 335 bnad->reglen = 0; 336 337 bnad->regdata = kzalloc(len << 2, GFP_KERNEL); 338 if (!bnad->regdata) 339 return -ENOMEM; 340 341 bnad->reglen = len << 2; 342 rb = bfa_ioc_bar0(ioc); 343 addr &= BFA_REG_ADDRMSK(ioc); 344 345 /* offset and len sanity check */ 346 rc = bna_reg_offset_check(ioc, addr, len); 347 if (rc) { 348 netdev_warn(bnad->netdev, "failed reg offset check\n"); 349 kfree(bnad->regdata); 350 bnad->regdata = NULL; 351 bnad->reglen = 0; 352 return -EINVAL; 353 } 354 355 reg_addr = rb + addr; 356 regbuf = (u32 *)bnad->regdata; 357 spin_lock_irqsave(&bnad->bna_lock, flags); 358 for (i = 0; i < len; i++) { 359 *regbuf = readl(reg_addr); 360 regbuf++; 361 reg_addr += sizeof(u32); 362 } 363 spin_unlock_irqrestore(&bnad->bna_lock, flags); 364 365 return nbytes; 366 } 367 368 static ssize_t 369 bnad_debugfs_write_regwr(struct file *file, const char __user *buf, 370 size_t nbytes, loff_t *ppos) 371 { 372 struct bnad_debug_info *debug = file->private_data; 373 struct bnad *bnad = (struct bnad *)debug->i_private; 374 struct bfa_ioc *ioc = &bnad->bna.ioceth.ioc; 375 int addr, val, rc; 376 void __iomem *reg_addr; 377 unsigned long flags; 378 void *kern_buf; 379 380 /* Copy the user space buf */ 381 kern_buf = memdup_user(buf, nbytes); 382 if (IS_ERR(kern_buf)) 383 return PTR_ERR(kern_buf); 384 385 rc = sscanf(kern_buf, "%x:%x", &addr, &val); 386 if (rc < 2) { 387 netdev_warn(bnad->netdev, "failed to read user buffer\n"); 388 kfree(kern_buf); 389 return -EINVAL; 390 } 391 kfree(kern_buf); 392 393 addr &= BFA_REG_ADDRMSK(ioc); /* offset only 17 bit and word align */ 394 395 /* offset and len sanity check */ 396 rc = bna_reg_offset_check(ioc, addr, 1); 397 if (rc) { 398 netdev_warn(bnad->netdev, "failed reg offset check\n"); 399 return -EINVAL; 400 } 401 402 reg_addr = (bfa_ioc_bar0(ioc)) + addr; 403 spin_lock_irqsave(&bnad->bna_lock, flags); 404 writel(val, reg_addr); 405 spin_unlock_irqrestore(&bnad->bna_lock, flags); 406 407 return nbytes; 408 } 409 410 static int 411 bnad_debugfs_release(struct inode *inode, struct file *file) 412 { 413 struct bnad_debug_info *debug = file->private_data; 414 415 if (!debug) 416 return 0; 417 418 file->private_data = NULL; 419 kfree(debug); 420 return 0; 421 } 422 423 static int 424 bnad_debugfs_buffer_release(struct inode *inode, struct file *file) 425 { 426 struct bnad_debug_info *debug = file->private_data; 427 428 if (!debug) 429 return 0; 430 431 kfree(debug->debug_buffer); 432 433 file->private_data = NULL; 434 kfree(debug); 435 debug = NULL; 436 return 0; 437 } 438 439 static const struct file_operations bnad_debugfs_op_fwtrc = { 440 .owner = THIS_MODULE, 441 .open = bnad_debugfs_open_fwtrc, 442 .llseek = bnad_debugfs_lseek, 443 .read = bnad_debugfs_read, 444 .release = bnad_debugfs_buffer_release, 445 }; 446 447 static const struct file_operations bnad_debugfs_op_fwsave = { 448 .owner = THIS_MODULE, 449 .open = bnad_debugfs_open_fwsave, 450 .llseek = bnad_debugfs_lseek, 451 .read = bnad_debugfs_read, 452 .release = bnad_debugfs_buffer_release, 453 }; 454 455 static const struct file_operations bnad_debugfs_op_regrd = { 456 .owner = THIS_MODULE, 457 .open = bnad_debugfs_open_reg, 458 .llseek = bnad_debugfs_lseek, 459 .read = bnad_debugfs_read_regrd, 460 .write = bnad_debugfs_write_regrd, 461 .release = bnad_debugfs_release, 462 }; 463 464 static const struct file_operations bnad_debugfs_op_regwr = { 465 .owner = THIS_MODULE, 466 .open = bnad_debugfs_open_reg, 467 .llseek = bnad_debugfs_lseek, 468 .write = bnad_debugfs_write_regwr, 469 .release = bnad_debugfs_release, 470 }; 471 472 static const struct file_operations bnad_debugfs_op_drvinfo = { 473 .owner = THIS_MODULE, 474 .open = bnad_debugfs_open_drvinfo, 475 .llseek = bnad_debugfs_lseek, 476 .read = bnad_debugfs_read, 477 .release = bnad_debugfs_buffer_release, 478 }; 479 480 struct bnad_debugfs_entry { 481 const char *name; 482 umode_t mode; 483 const struct file_operations *fops; 484 }; 485 486 static const struct bnad_debugfs_entry bnad_debugfs_files[] = { 487 { "fwtrc", S_IFREG|S_IRUGO, &bnad_debugfs_op_fwtrc, }, 488 { "fwsave", S_IFREG|S_IRUGO, &bnad_debugfs_op_fwsave, }, 489 { "regrd", S_IFREG|S_IRUGO|S_IWUSR, &bnad_debugfs_op_regrd, }, 490 { "regwr", S_IFREG|S_IWUSR, &bnad_debugfs_op_regwr, }, 491 { "drvinfo", S_IFREG|S_IRUGO, &bnad_debugfs_op_drvinfo, }, 492 }; 493 494 static struct dentry *bna_debugfs_root; 495 static atomic_t bna_debugfs_port_count; 496 497 /* Initialize debugfs interface for BNA */ 498 void 499 bnad_debugfs_init(struct bnad *bnad) 500 { 501 const struct bnad_debugfs_entry *file; 502 char name[64]; 503 int i; 504 505 /* Setup the BNA debugfs root directory*/ 506 if (!bna_debugfs_root) { 507 bna_debugfs_root = debugfs_create_dir("bna", NULL); 508 atomic_set(&bna_debugfs_port_count, 0); 509 if (!bna_debugfs_root) { 510 netdev_warn(bnad->netdev, 511 "debugfs root dir creation failed\n"); 512 return; 513 } 514 } 515 516 /* Setup the pci_dev debugfs directory for the port */ 517 snprintf(name, sizeof(name), "pci_dev:%s", pci_name(bnad->pcidev)); 518 if (!bnad->port_debugfs_root) { 519 bnad->port_debugfs_root = 520 debugfs_create_dir(name, bna_debugfs_root); 521 if (!bnad->port_debugfs_root) { 522 netdev_warn(bnad->netdev, 523 "debugfs root dir creation failed\n"); 524 return; 525 } 526 527 atomic_inc(&bna_debugfs_port_count); 528 529 for (i = 0; i < ARRAY_SIZE(bnad_debugfs_files); i++) { 530 file = &bnad_debugfs_files[i]; 531 bnad->bnad_dentry_files[i] = 532 debugfs_create_file(file->name, 533 file->mode, 534 bnad->port_debugfs_root, 535 bnad, 536 file->fops); 537 if (!bnad->bnad_dentry_files[i]) { 538 netdev_warn(bnad->netdev, 539 "create %s entry failed\n", 540 file->name); 541 return; 542 } 543 } 544 } 545 } 546 547 /* Uninitialize debugfs interface for BNA */ 548 void 549 bnad_debugfs_uninit(struct bnad *bnad) 550 { 551 int i; 552 553 for (i = 0; i < ARRAY_SIZE(bnad_debugfs_files); i++) { 554 if (bnad->bnad_dentry_files[i]) { 555 debugfs_remove(bnad->bnad_dentry_files[i]); 556 bnad->bnad_dentry_files[i] = NULL; 557 } 558 } 559 560 /* Remove the pci_dev debugfs directory for the port */ 561 if (bnad->port_debugfs_root) { 562 debugfs_remove(bnad->port_debugfs_root); 563 bnad->port_debugfs_root = NULL; 564 atomic_dec(&bna_debugfs_port_count); 565 } 566 567 /* Remove the BNA debugfs root directory */ 568 if (atomic_read(&bna_debugfs_port_count) == 0) { 569 debugfs_remove(bna_debugfs_root); 570 bna_debugfs_root = NULL; 571 } 572 } 573