1 /******************************************************************************* 2 3 Intel 10 Gigabit PCI Express Linux driver 4 Copyright(c) 1999 - 2012 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 e1000-devel Mailing List <e1000-devel@lists.sourceforge.net> 24 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 25 26 *******************************************************************************/ 27 28 #ifdef CONFIG_DEBUG_FS 29 30 #include <linux/debugfs.h> 31 #include <linux/module.h> 32 33 #include "ixgbe.h" 34 35 static struct dentry *ixgbe_dbg_root; 36 37 static char ixgbe_dbg_reg_ops_buf[256] = ""; 38 39 /** 40 * ixgbe_dbg_reg_ops_read - read for reg_ops datum 41 * @filp: the opened file 42 * @buffer: where to write the data for the user to read 43 * @count: the size of the user's buffer 44 * @ppos: file position offset 45 **/ 46 static ssize_t ixgbe_dbg_reg_ops_read(struct file *filp, char __user *buffer, 47 size_t count, loff_t *ppos) 48 { 49 struct ixgbe_adapter *adapter = filp->private_data; 50 char *buf; 51 int len; 52 53 /* don't allow partial reads */ 54 if (*ppos != 0) 55 return 0; 56 57 buf = kasprintf(GFP_KERNEL, "%s: %s\n", 58 adapter->netdev->name, 59 ixgbe_dbg_reg_ops_buf); 60 if (!buf) 61 return -ENOMEM; 62 63 if (count < strlen(buf)) { 64 kfree(buf); 65 return -ENOSPC; 66 } 67 68 len = simple_read_from_buffer(buffer, count, ppos, buf, strlen(buf)); 69 70 kfree(buf); 71 return len; 72 } 73 74 /** 75 * ixgbe_dbg_reg_ops_write - write into reg_ops datum 76 * @filp: the opened file 77 * @buffer: where to find the user's data 78 * @count: the length of the user's data 79 * @ppos: file position offset 80 **/ 81 static ssize_t ixgbe_dbg_reg_ops_write(struct file *filp, 82 const char __user *buffer, 83 size_t count, loff_t *ppos) 84 { 85 struct ixgbe_adapter *adapter = filp->private_data; 86 int len; 87 88 /* don't allow partial writes */ 89 if (*ppos != 0) 90 return 0; 91 if (count >= sizeof(ixgbe_dbg_reg_ops_buf)) 92 return -ENOSPC; 93 94 len = simple_write_to_buffer(ixgbe_dbg_reg_ops_buf, 95 sizeof(ixgbe_dbg_reg_ops_buf)-1, 96 ppos, 97 buffer, 98 count); 99 if (len < 0) 100 return len; 101 102 ixgbe_dbg_reg_ops_buf[len] = '\0'; 103 104 if (strncmp(ixgbe_dbg_reg_ops_buf, "write", 5) == 0) { 105 u32 reg, value; 106 int cnt; 107 cnt = sscanf(&ixgbe_dbg_reg_ops_buf[5], "%x %x", ®, &value); 108 if (cnt == 2) { 109 IXGBE_WRITE_REG(&adapter->hw, reg, value); 110 value = IXGBE_READ_REG(&adapter->hw, reg); 111 e_dev_info("write: 0x%08x = 0x%08x\n", reg, value); 112 } else { 113 e_dev_info("write <reg> <value>\n"); 114 } 115 } else if (strncmp(ixgbe_dbg_reg_ops_buf, "read", 4) == 0) { 116 u32 reg, value; 117 int cnt; 118 cnt = sscanf(&ixgbe_dbg_reg_ops_buf[4], "%x", ®); 119 if (cnt == 1) { 120 value = IXGBE_READ_REG(&adapter->hw, reg); 121 e_dev_info("read 0x%08x = 0x%08x\n", reg, value); 122 } else { 123 e_dev_info("read <reg>\n"); 124 } 125 } else { 126 e_dev_info("Unknown command %s\n", ixgbe_dbg_reg_ops_buf); 127 e_dev_info("Available commands:\n"); 128 e_dev_info(" read <reg>\n"); 129 e_dev_info(" write <reg> <value>\n"); 130 } 131 return count; 132 } 133 134 static const struct file_operations ixgbe_dbg_reg_ops_fops = { 135 .owner = THIS_MODULE, 136 .open = simple_open, 137 .read = ixgbe_dbg_reg_ops_read, 138 .write = ixgbe_dbg_reg_ops_write, 139 }; 140 141 static char ixgbe_dbg_netdev_ops_buf[256] = ""; 142 143 /** 144 * ixgbe_dbg_netdev_ops_read - read for netdev_ops datum 145 * @filp: the opened file 146 * @buffer: where to write the data for the user to read 147 * @count: the size of the user's buffer 148 * @ppos: file position offset 149 **/ 150 static ssize_t ixgbe_dbg_netdev_ops_read(struct file *filp, 151 char __user *buffer, 152 size_t count, loff_t *ppos) 153 { 154 struct ixgbe_adapter *adapter = filp->private_data; 155 char *buf; 156 int len; 157 158 /* don't allow partial reads */ 159 if (*ppos != 0) 160 return 0; 161 162 buf = kasprintf(GFP_KERNEL, "%s: %s\n", 163 adapter->netdev->name, 164 ixgbe_dbg_netdev_ops_buf); 165 if (!buf) 166 return -ENOMEM; 167 168 if (count < strlen(buf)) { 169 kfree(buf); 170 return -ENOSPC; 171 } 172 173 len = simple_read_from_buffer(buffer, count, ppos, buf, strlen(buf)); 174 175 kfree(buf); 176 return len; 177 } 178 179 /** 180 * ixgbe_dbg_netdev_ops_write - write into netdev_ops datum 181 * @filp: the opened file 182 * @buffer: where to find the user's data 183 * @count: the length of the user's data 184 * @ppos: file position offset 185 **/ 186 static ssize_t ixgbe_dbg_netdev_ops_write(struct file *filp, 187 const char __user *buffer, 188 size_t count, loff_t *ppos) 189 { 190 struct ixgbe_adapter *adapter = filp->private_data; 191 int len; 192 193 /* don't allow partial writes */ 194 if (*ppos != 0) 195 return 0; 196 if (count >= sizeof(ixgbe_dbg_netdev_ops_buf)) 197 return -ENOSPC; 198 199 len = simple_write_to_buffer(ixgbe_dbg_netdev_ops_buf, 200 sizeof(ixgbe_dbg_netdev_ops_buf)-1, 201 ppos, 202 buffer, 203 count); 204 if (len < 0) 205 return len; 206 207 ixgbe_dbg_netdev_ops_buf[len] = '\0'; 208 209 if (strncmp(ixgbe_dbg_netdev_ops_buf, "tx_timeout", 10) == 0) { 210 adapter->netdev->netdev_ops->ndo_tx_timeout(adapter->netdev); 211 e_dev_info("tx_timeout called\n"); 212 } else { 213 e_dev_info("Unknown command: %s\n", ixgbe_dbg_netdev_ops_buf); 214 e_dev_info("Available commands:\n"); 215 e_dev_info(" tx_timeout\n"); 216 } 217 return count; 218 } 219 220 static const struct file_operations ixgbe_dbg_netdev_ops_fops = { 221 .owner = THIS_MODULE, 222 .open = simple_open, 223 .read = ixgbe_dbg_netdev_ops_read, 224 .write = ixgbe_dbg_netdev_ops_write, 225 }; 226 227 /** 228 * ixgbe_dbg_adapter_init - setup the debugfs directory for the adapter 229 * @adapter: the adapter that is starting up 230 **/ 231 void ixgbe_dbg_adapter_init(struct ixgbe_adapter *adapter) 232 { 233 const char *name = pci_name(adapter->pdev); 234 struct dentry *pfile; 235 adapter->ixgbe_dbg_adapter = debugfs_create_dir(name, ixgbe_dbg_root); 236 if (adapter->ixgbe_dbg_adapter) { 237 pfile = debugfs_create_file("reg_ops", 0600, 238 adapter->ixgbe_dbg_adapter, adapter, 239 &ixgbe_dbg_reg_ops_fops); 240 if (!pfile) 241 e_dev_err("debugfs reg_ops for %s failed\n", name); 242 pfile = debugfs_create_file("netdev_ops", 0600, 243 adapter->ixgbe_dbg_adapter, adapter, 244 &ixgbe_dbg_netdev_ops_fops); 245 if (!pfile) 246 e_dev_err("debugfs netdev_ops for %s failed\n", name); 247 } else { 248 e_dev_err("debugfs entry for %s failed\n", name); 249 } 250 } 251 252 /** 253 * ixgbe_dbg_adapter_exit - clear out the adapter's debugfs entries 254 * @pf: the pf that is stopping 255 **/ 256 void ixgbe_dbg_adapter_exit(struct ixgbe_adapter *adapter) 257 { 258 if (adapter->ixgbe_dbg_adapter) 259 debugfs_remove_recursive(adapter->ixgbe_dbg_adapter); 260 adapter->ixgbe_dbg_adapter = NULL; 261 } 262 263 /** 264 * ixgbe_dbg_init - start up debugfs for the driver 265 **/ 266 void ixgbe_dbg_init(void) 267 { 268 ixgbe_dbg_root = debugfs_create_dir(ixgbe_driver_name, NULL); 269 if (ixgbe_dbg_root == NULL) 270 pr_err("init of debugfs failed\n"); 271 } 272 273 /** 274 * ixgbe_dbg_exit - clean out the driver's debugfs entries 275 **/ 276 void ixgbe_dbg_exit(void) 277 { 278 debugfs_remove_recursive(ixgbe_dbg_root); 279 } 280 281 #endif /* CONFIG_DEBUG_FS */ 282