drivers/net/ethernet/brocade/bna/bnad_debugfs.c

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