drivers/net/ethernet/intel/ixgbe/ixgbe_debugfs.c

   1 /*******************************************************************************
   2
   3   Intel 10 Gigabit PCI Express Linux driver
   4   Copyright(c) 1999 - 2013 Intel Corporation.
   5
   6   This program is free software; you can redistribute it and/or modify it
   7   under the terms and conditions of the GNU General Public License,
   8   version 2, as published by the Free Software Foundation.
   9
  10   This program is distributed in the hope it will be useful, but WITHOUT
  11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13   more details.
  14
  15   You should have received a copy of the GNU General Public License along with
  16   this program; if not, write to the Free Software Foundation, Inc.,
  17   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  18
  19   The full GNU General Public License is included in this distribution in
  20   the file called "COPYING".
  21
  22   Contact Information:
  23   Linux NICS <[email protected]>
  24   e1000-devel Mailing List <[email protected]>
  25   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  26
  27 *******************************************************************************/
  28 #include <linux/debugfs.h>
  29 #include <linux/module.h>
  30
  31 #include "ixgbe.h"
  32
  33 static struct dentry *ixgbe_dbg_root;
  34
  35 static char ixgbe_dbg_reg_ops_buf[256] = "";
  36
  37 /**
  38  * ixgbe_dbg_reg_ops_read - read for reg_ops datum
  39  * @filp: the opened file
  40  * @buffer: where to write the data for the user to read
  41  * @count: the size of the user's buffer
  42  * @ppos: file position offset
  43  **/
  44 static ssize_t ixgbe_dbg_reg_ops_read(struct file *filp, char __user *buffer,
  45                                     size_t count, loff_t *ppos)
  46 {
  47         struct ixgbe_adapter *adapter = filp->private_data;
  48         char *buf;
  49         int len;
  50
  51         /* don't allow partial reads */
  52         if (*ppos != 0)
  53                 return 0;
  54
  55         buf = kasprintf(GFP_KERNEL, "%s: %s\n",
  56                         adapter->netdev->name,
  57                         ixgbe_dbg_reg_ops_buf);
  58         if (!buf)
  59                 return -ENOMEM;
  60
  61         if (count < strlen(buf)) {
  62                 kfree(buf);
  63                 return -ENOSPC;
  64         }
  65
  66         len = simple_read_from_buffer(buffer, count, ppos, buf, strlen(buf));
  67
  68         kfree(buf);
  69         return len;
  70 }
  71
  72 /**
  73  * ixgbe_dbg_reg_ops_write - write into reg_ops datum
  74  * @filp: the opened file
  75  * @buffer: where to find the user's data
  76  * @count: the length of the user's data
  77  * @ppos: file position offset
  78  **/
  79 static ssize_t ixgbe_dbg_reg_ops_write(struct file *filp,
  80                                      const char __user *buffer,
  81                                      size_t count, loff_t *ppos)
  82 {
  83         struct ixgbe_adapter *adapter = filp->private_data;
  84         int len;
  85
  86         /* don't allow partial writes */
  87         if (*ppos != 0)
  88                 return 0;
  89         if (count >= sizeof(ixgbe_dbg_reg_ops_buf))
  90                 return -ENOSPC;
  91
  92         len = simple_write_to_buffer(ixgbe_dbg_reg_ops_buf,
  93                                      sizeof(ixgbe_dbg_reg_ops_buf)-1,
  94                                      ppos,
  95                                      buffer,
  96                                      count);
  97         if (len < 0)
  98                 return len;
  99
 100         ixgbe_dbg_reg_ops_buf[len] = '\0';
 101
 102         if (strncmp(ixgbe_dbg_reg_ops_buf, "write", 5) == 0) {
 103                 u32 reg, value;
 104                 int cnt;
 105                 cnt = sscanf(&ixgbe_dbg_reg_ops_buf[5], "%x %x", &reg, &value);
 106                 if (cnt == 2) {
 107                         IXGBE_WRITE_REG(&adapter->hw, reg, value);
 108                         value = IXGBE_READ_REG(&adapter->hw, reg);
 109                         e_dev_info("write: 0x%08x = 0x%08x\n", reg, value);
 110                 } else {
 111                         e_dev_info("write <reg> <value>\n");
 112                 }
 113         } else if (strncmp(ixgbe_dbg_reg_ops_buf, "read", 4) == 0) {
 114                 u32 reg, value;
 115                 int cnt;
 116                 cnt = sscanf(&ixgbe_dbg_reg_ops_buf[4], "%x", &reg);
 117                 if (cnt == 1) {
 118                         value = IXGBE_READ_REG(&adapter->hw, reg);
 119                         e_dev_info("read 0x%08x = 0x%08x\n", reg, value);
 120                 } else {
 121                         e_dev_info("read <reg>\n");
 122                 }
 123         } else {
 124                 e_dev_info("Unknown command %s\n", ixgbe_dbg_reg_ops_buf);
 125                 e_dev_info("Available commands:\n");
 126                 e_dev_info("   read <reg>\n");
 127                 e_dev_info("   write <reg> <value>\n");
 128         }
 129         return count;
 130 }
 131
 132 static const struct file_operations ixgbe_dbg_reg_ops_fops = {
 133         .owner = THIS_MODULE,
 134         .open = simple_open,
 135         .read =  ixgbe_dbg_reg_ops_read,
 136         .write = ixgbe_dbg_reg_ops_write,
 137 };
 138
 139 static char ixgbe_dbg_netdev_ops_buf[256] = "";
 140
 141 /**
 142  * ixgbe_dbg_netdev_ops_read - read for netdev_ops datum
 143  * @filp: the opened file
 144  * @buffer: where to write the data for the user to read
 145  * @count: the size of the user's buffer
 146  * @ppos: file position offset
 147  **/
 148 static ssize_t ixgbe_dbg_netdev_ops_read(struct file *filp,
 149                                          char __user *buffer,
 150                                          size_t count, loff_t *ppos)
 151 {
 152         struct ixgbe_adapter *adapter = filp->private_data;
 153         char *buf;
 154         int len;
 155
 156         /* don't allow partial reads */
 157         if (*ppos != 0)
 158                 return 0;
 159
 160         buf = kasprintf(GFP_KERNEL, "%s: %s\n",
 161                         adapter->netdev->name,
 162                         ixgbe_dbg_netdev_ops_buf);
 163         if (!buf)
 164                 return -ENOMEM;
 165
 166         if (count < strlen(buf)) {
 167                 kfree(buf);
 168                 return -ENOSPC;
 169         }
 170
 171         len = simple_read_from_buffer(buffer, count, ppos, buf, strlen(buf));
 172
 173         kfree(buf);
 174         return len;
 175 }
 176
 177 /**
 178  * ixgbe_dbg_netdev_ops_write - write into netdev_ops datum
 179  * @filp: the opened file
 180  * @buffer: where to find the user's data
 181  * @count: the length of the user's data
 182  * @ppos: file position offset
 183  **/
 184 static ssize_t ixgbe_dbg_netdev_ops_write(struct file *filp,
 185                                           const char __user *buffer,
 186                                           size_t count, loff_t *ppos)
 187 {
 188         struct ixgbe_adapter *adapter = filp->private_data;
 189         int len;
 190
 191         /* don't allow partial writes */
 192         if (*ppos != 0)
 193                 return 0;
 194         if (count >= sizeof(ixgbe_dbg_netdev_ops_buf))
 195                 return -ENOSPC;
 196
 197         len = simple_write_to_buffer(ixgbe_dbg_netdev_ops_buf,
 198                                      sizeof(ixgbe_dbg_netdev_ops_buf)-1,
 199                                      ppos,
 200                                      buffer,
 201                                      count);
 202         if (len < 0)
 203                 return len;
 204
 205         ixgbe_dbg_netdev_ops_buf[len] = '\0';
 206
 207         if (strncmp(ixgbe_dbg_netdev_ops_buf, "tx_timeout", 10) == 0) {
 208                 adapter->netdev->netdev_ops->ndo_tx_timeout(adapter->netdev);
 209                 e_dev_info("tx_timeout called\n");
 210         } else {
 211                 e_dev_info("Unknown command: %s\n", ixgbe_dbg_netdev_ops_buf);
 212                 e_dev_info("Available commands:\n");
 213                 e_dev_info("    tx_timeout\n");
 214         }
 215         return count;
 216 }
 217
 218 static const struct file_operations ixgbe_dbg_netdev_ops_fops = {
 219         .owner = THIS_MODULE,
 220         .open = simple_open,
 221         .read = ixgbe_dbg_netdev_ops_read,
 222         .write = ixgbe_dbg_netdev_ops_write,
 223 };
 224
 225 /**
 226  * ixgbe_dbg_adapter_init - setup the debugfs directory for the adapter
 227  * @adapter: the adapter that is starting up
 228  **/
 229 void ixgbe_dbg_adapter_init(struct ixgbe_adapter *adapter)
 230 {
 231         const char *name = pci_name(adapter->pdev);
 232         struct dentry *pfile;
 233         adapter->ixgbe_dbg_adapter = debugfs_create_dir(name, ixgbe_dbg_root);
 234         if (adapter->ixgbe_dbg_adapter) {
 235                 pfile = debugfs_create_file("reg_ops", 0600,
 236                                             adapter->ixgbe_dbg_adapter, adapter,
 237                                             &ixgbe_dbg_reg_ops_fops);
 238                 if (!pfile)
 239                         e_dev_err("debugfs reg_ops for %s failed\n", name);
 240                 pfile = debugfs_create_file("netdev_ops", 0600,
 241                                             adapter->ixgbe_dbg_adapter, adapter,
 242                                             &ixgbe_dbg_netdev_ops_fops);
 243                 if (!pfile)
 244                         e_dev_err("debugfs netdev_ops for %s failed\n", name);
 245         } else {
 246                 e_dev_err("debugfs entry for %s failed\n", name);
 247         }
 248 }
 249
 250 /**
 251  * ixgbe_dbg_adapter_exit - clear out the adapter's debugfs entries
 252  * @pf: the pf that is stopping
 253  **/
 254 void ixgbe_dbg_adapter_exit(struct ixgbe_adapter *adapter)
 255 {
 256         debugfs_remove_recursive(adapter->ixgbe_dbg_adapter);
 257         adapter->ixgbe_dbg_adapter = NULL;
 258 }
 259
 260 /**
 261  * ixgbe_dbg_init - start up debugfs for the driver
 262  **/
 263 void ixgbe_dbg_init(void)
 264 {
 265         ixgbe_dbg_root = debugfs_create_dir(ixgbe_driver_name, NULL);
 266         if (ixgbe_dbg_root == NULL)
 267                 pr_err("init of debugfs failed\n");
 268 }
 269
 270 /**
 271  * ixgbe_dbg_exit - clean out the driver's debugfs entries
 272  **/
 273 void ixgbe_dbg_exit(void)
 274 {
 275         debugfs_remove_recursive(ixgbe_dbg_root);
 276 }