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