John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 1 | /* |
| 2 | |
| 3 | Broadcom BCM43xx wireless driver |
| 4 | |
| 5 | debugfs driver debugging code |
| 6 | |
| 7 | Copyright (c) 2005 Michael Buesch <mbuesch@freenet.de> |
| 8 | |
| 9 | This program is free software; you can redistribute it and/or modify |
| 10 | it under the terms of the GNU General Public License as published by |
| 11 | the Free Software Foundation; either version 2 of the License, or |
| 12 | (at your option) any later version. |
| 13 | |
| 14 | This program is distributed in the hope that it will be useful, |
| 15 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 17 | GNU General Public License for more details. |
| 18 | |
| 19 | You should have received a copy of the GNU General Public License |
| 20 | along with this program; see the file COPYING. If not, write to |
| 21 | the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor, |
| 22 | Boston, MA 02110-1301, USA. |
| 23 | |
| 24 | */ |
| 25 | |
| 26 | |
| 27 | |
| 28 | #include <linux/fs.h> |
| 29 | #include <linux/debugfs.h> |
| 30 | #include <linux/slab.h> |
| 31 | #include <linux/netdevice.h> |
| 32 | #include <linux/pci.h> |
| 33 | #include <asm/io.h> |
| 34 | |
| 35 | #include "bcm43xx.h" |
| 36 | #include "bcm43xx_main.h" |
| 37 | #include "bcm43xx_debugfs.h" |
| 38 | #include "bcm43xx_dma.h" |
| 39 | #include "bcm43xx_pio.h" |
Michael Buesch | f398f02 | 2006-02-23 21:15:39 +0100 | [diff] [blame] | 40 | #include "bcm43xx_xmit.h" |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 41 | |
| 42 | #define REALLY_BIG_BUFFER_SIZE (1024*256) |
| 43 | |
| 44 | static struct bcm43xx_debugfs fs; |
| 45 | static char really_big_buffer[REALLY_BIG_BUFFER_SIZE]; |
| 46 | static DECLARE_MUTEX(big_buffer_sem); |
| 47 | |
| 48 | |
| 49 | static ssize_t write_file_dummy(struct file *file, const char __user *buf, |
| 50 | size_t count, loff_t *ppos) |
| 51 | { |
| 52 | return count; |
| 53 | } |
| 54 | |
| 55 | static int open_file_generic(struct inode *inode, struct file *file) |
| 56 | { |
| 57 | file->private_data = inode->u.generic_ip; |
| 58 | return 0; |
| 59 | } |
| 60 | |
| 61 | #define fappend(fmt, x...) pos += snprintf(buf + pos, len - pos, fmt , ##x) |
| 62 | |
| 63 | static ssize_t devinfo_read_file(struct file *file, char __user *userbuf, |
| 64 | size_t count, loff_t *ppos) |
| 65 | { |
| 66 | const size_t len = REALLY_BIG_BUFFER_SIZE; |
| 67 | |
| 68 | struct bcm43xx_private *bcm = file->private_data; |
| 69 | char *buf = really_big_buffer; |
| 70 | size_t pos = 0; |
| 71 | ssize_t res; |
| 72 | struct net_device *net_dev; |
| 73 | struct pci_dev *pci_dev; |
| 74 | unsigned long flags; |
| 75 | u16 tmp16; |
| 76 | int i; |
| 77 | |
| 78 | down(&big_buffer_sem); |
| 79 | |
Michael Buesch | efccb64 | 2006-03-11 13:39:14 +0100 | [diff] [blame] | 80 | bcm43xx_lock_mmio(bcm, flags); |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 81 | if (!bcm->initialized) { |
| 82 | fappend("Board not initialized.\n"); |
| 83 | goto out; |
| 84 | } |
| 85 | net_dev = bcm->net_dev; |
| 86 | pci_dev = bcm->pci_dev; |
| 87 | |
| 88 | /* This is where the information is written to the "devinfo" file */ |
| 89 | fappend("*** %s devinfo ***\n", net_dev->name); |
| 90 | fappend("vendor: 0x%04x device: 0x%04x\n", |
| 91 | pci_dev->vendor, pci_dev->device); |
| 92 | fappend("subsystem_vendor: 0x%04x subsystem_device: 0x%04x\n", |
| 93 | pci_dev->subsystem_vendor, pci_dev->subsystem_device); |
| 94 | fappend("IRQ: %d\n", bcm->irq); |
| 95 | fappend("mmio_addr: 0x%p mmio_len: %u\n", bcm->mmio_addr, bcm->mmio_len); |
| 96 | fappend("chip_id: 0x%04x chip_rev: 0x%02x\n", bcm->chip_id, bcm->chip_rev); |
| 97 | if ((bcm->core_80211[0].rev >= 3) && (bcm43xx_read32(bcm, 0x0158) & (1 << 16))) |
| 98 | fappend("Radio disabled by hardware!\n"); |
| 99 | if ((bcm->core_80211[0].rev < 3) && !(bcm43xx_read16(bcm, 0x049A) & (1 << 4))) |
| 100 | fappend("Radio disabled by hardware!\n"); |
| 101 | fappend("board_vendor: 0x%04x board_type: 0x%04x\n", bcm->board_vendor, |
| 102 | bcm->board_type); |
| 103 | |
| 104 | fappend("\nCores:\n"); |
| 105 | #define fappend_core(name, info) fappend("core \"" name "\" %s, %s, id: 0x%04x, " \ |
| 106 | "rev: 0x%02x, index: 0x%02x\n", \ |
Michael Buesch | e9357c0 | 2006-03-13 19:27:34 +0100 | [diff] [blame] | 107 | (info).available \ |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 108 | ? "available" : "nonavailable", \ |
Michael Buesch | e9357c0 | 2006-03-13 19:27:34 +0100 | [diff] [blame] | 109 | (info).enabled \ |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 110 | ? "enabled" : "disabled", \ |
| 111 | (info).id, (info).rev, (info).index) |
| 112 | fappend_core("CHIPCOMMON", bcm->core_chipcommon); |
| 113 | fappend_core("PCI", bcm->core_pci); |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 114 | fappend_core("first 80211", bcm->core_80211[0]); |
| 115 | fappend_core("second 80211", bcm->core_80211[1]); |
| 116 | #undef fappend_core |
| 117 | tmp16 = bcm43xx_read16(bcm, BCM43xx_MMIO_GPIO_CONTROL); |
| 118 | fappend("LEDs: "); |
| 119 | for (i = 0; i < BCM43xx_NR_LEDS; i++) |
| 120 | fappend("%d ", !!(tmp16 & (1 << i))); |
| 121 | fappend("\n"); |
| 122 | |
| 123 | out: |
Michael Buesch | efccb64 | 2006-03-11 13:39:14 +0100 | [diff] [blame] | 124 | bcm43xx_unlock_mmio(bcm, flags); |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 125 | res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); |
| 126 | up(&big_buffer_sem); |
| 127 | return res; |
| 128 | } |
| 129 | |
| 130 | static ssize_t drvinfo_read_file(struct file *file, char __user *userbuf, |
| 131 | size_t count, loff_t *ppos) |
| 132 | { |
| 133 | const size_t len = REALLY_BIG_BUFFER_SIZE; |
| 134 | |
| 135 | char *buf = really_big_buffer; |
| 136 | size_t pos = 0; |
| 137 | ssize_t res; |
| 138 | |
| 139 | down(&big_buffer_sem); |
| 140 | |
| 141 | /* This is where the information is written to the "driver" file */ |
Michael Buesch | 65f3f19 | 2006-01-31 20:11:38 +0100 | [diff] [blame] | 142 | fappend(KBUILD_MODNAME " driver\n"); |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 143 | fappend("Compiled at: %s %s\n", __DATE__, __TIME__); |
| 144 | |
| 145 | res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); |
| 146 | up(&big_buffer_sem); |
| 147 | return res; |
| 148 | } |
| 149 | |
| 150 | static ssize_t spromdump_read_file(struct file *file, char __user *userbuf, |
| 151 | size_t count, loff_t *ppos) |
| 152 | { |
| 153 | const size_t len = REALLY_BIG_BUFFER_SIZE; |
| 154 | |
| 155 | struct bcm43xx_private *bcm = file->private_data; |
| 156 | char *buf = really_big_buffer; |
| 157 | size_t pos = 0; |
| 158 | ssize_t res; |
| 159 | unsigned long flags; |
| 160 | |
| 161 | down(&big_buffer_sem); |
Michael Buesch | efccb64 | 2006-03-11 13:39:14 +0100 | [diff] [blame] | 162 | bcm43xx_lock_mmio(bcm, flags); |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 163 | if (!bcm->initialized) { |
| 164 | fappend("Board not initialized.\n"); |
| 165 | goto out; |
| 166 | } |
| 167 | |
| 168 | /* This is where the information is written to the "sprom_dump" file */ |
| 169 | fappend("boardflags: 0x%04x\n", bcm->sprom.boardflags); |
| 170 | |
| 171 | out: |
Michael Buesch | efccb64 | 2006-03-11 13:39:14 +0100 | [diff] [blame] | 172 | bcm43xx_unlock_mmio(bcm, flags); |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 173 | res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); |
| 174 | up(&big_buffer_sem); |
| 175 | return res; |
| 176 | } |
| 177 | |
| 178 | static ssize_t tsf_read_file(struct file *file, char __user *userbuf, |
| 179 | size_t count, loff_t *ppos) |
| 180 | { |
| 181 | const size_t len = REALLY_BIG_BUFFER_SIZE; |
| 182 | |
| 183 | struct bcm43xx_private *bcm = file->private_data; |
| 184 | char *buf = really_big_buffer; |
| 185 | size_t pos = 0; |
| 186 | ssize_t res; |
| 187 | unsigned long flags; |
| 188 | u64 tsf; |
| 189 | |
| 190 | down(&big_buffer_sem); |
Michael Buesch | efccb64 | 2006-03-11 13:39:14 +0100 | [diff] [blame] | 191 | bcm43xx_lock_mmio(bcm, flags); |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 192 | if (!bcm->initialized) { |
| 193 | fappend("Board not initialized.\n"); |
| 194 | goto out; |
| 195 | } |
| 196 | bcm43xx_tsf_read(bcm, &tsf); |
| 197 | fappend("0x%08x%08x\n", |
| 198 | (unsigned int)((tsf & 0xFFFFFFFF00000000ULL) >> 32), |
| 199 | (unsigned int)(tsf & 0xFFFFFFFFULL)); |
| 200 | |
| 201 | out: |
Michael Buesch | efccb64 | 2006-03-11 13:39:14 +0100 | [diff] [blame] | 202 | bcm43xx_unlock_mmio(bcm, flags); |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 203 | res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); |
| 204 | up(&big_buffer_sem); |
| 205 | return res; |
| 206 | } |
| 207 | |
| 208 | static ssize_t tsf_write_file(struct file *file, const char __user *user_buf, |
| 209 | size_t count, loff_t *ppos) |
| 210 | { |
| 211 | struct bcm43xx_private *bcm = file->private_data; |
| 212 | char *buf = really_big_buffer; |
| 213 | ssize_t buf_size; |
| 214 | ssize_t res; |
| 215 | unsigned long flags; |
| 216 | u64 tsf; |
| 217 | |
| 218 | buf_size = min(count, sizeof (really_big_buffer) - 1); |
| 219 | down(&big_buffer_sem); |
| 220 | if (copy_from_user(buf, user_buf, buf_size)) { |
| 221 | res = -EFAULT; |
| 222 | goto out_up; |
| 223 | } |
Michael Buesch | efccb64 | 2006-03-11 13:39:14 +0100 | [diff] [blame] | 224 | bcm43xx_lock_mmio(bcm, flags); |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 225 | if (!bcm->initialized) { |
| 226 | printk(KERN_INFO PFX "debugfs: Board not initialized.\n"); |
| 227 | res = -EFAULT; |
| 228 | goto out_unlock; |
| 229 | } |
| 230 | if (sscanf(buf, "%lli", &tsf) != 1) { |
| 231 | printk(KERN_INFO PFX "debugfs: invalid values for \"tsf\"\n"); |
| 232 | res = -EINVAL; |
| 233 | goto out_unlock; |
| 234 | } |
| 235 | bcm43xx_tsf_write(bcm, tsf); |
| 236 | res = buf_size; |
| 237 | |
| 238 | out_unlock: |
Michael Buesch | efccb64 | 2006-03-11 13:39:14 +0100 | [diff] [blame] | 239 | bcm43xx_unlock_mmio(bcm, flags); |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 240 | out_up: |
| 241 | up(&big_buffer_sem); |
| 242 | return res; |
| 243 | } |
| 244 | |
| 245 | static ssize_t txstat_read_file(struct file *file, char __user *userbuf, |
| 246 | size_t count, loff_t *ppos) |
| 247 | { |
| 248 | const size_t len = REALLY_BIG_BUFFER_SIZE; |
| 249 | |
| 250 | struct bcm43xx_private *bcm = file->private_data; |
| 251 | char *buf = really_big_buffer; |
| 252 | size_t pos = 0; |
| 253 | ssize_t res; |
| 254 | unsigned long flags; |
| 255 | struct bcm43xx_dfsentry *e; |
| 256 | struct bcm43xx_xmitstatus *status; |
| 257 | int i, cnt, j = 0; |
| 258 | |
| 259 | down(&big_buffer_sem); |
Michael Buesch | efccb64 | 2006-03-11 13:39:14 +0100 | [diff] [blame] | 260 | bcm43xx_lock(bcm, flags); |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 261 | |
| 262 | fappend("Last %d logged xmitstatus blobs (Latest first):\n\n", |
| 263 | BCM43xx_NR_LOGGED_XMITSTATUS); |
| 264 | e = bcm->dfsentry; |
| 265 | if (e->xmitstatus_printing == 0) { |
| 266 | /* At the beginning, make a copy of all data to avoid |
| 267 | * concurrency, as this function is called multiple |
| 268 | * times for big logs. Without copying, the data might |
| 269 | * change between reads. This would result in total trash. |
| 270 | */ |
| 271 | e->xmitstatus_printing = 1; |
| 272 | e->saved_xmitstatus_ptr = e->xmitstatus_ptr; |
| 273 | e->saved_xmitstatus_cnt = e->xmitstatus_cnt; |
| 274 | memcpy(e->xmitstatus_print_buffer, e->xmitstatus_buffer, |
| 275 | BCM43xx_NR_LOGGED_XMITSTATUS * sizeof(*(e->xmitstatus_buffer))); |
| 276 | } |
| 277 | i = e->saved_xmitstatus_ptr - 1; |
| 278 | if (i < 0) |
| 279 | i = BCM43xx_NR_LOGGED_XMITSTATUS - 1; |
| 280 | cnt = e->saved_xmitstatus_cnt; |
| 281 | while (cnt) { |
| 282 | status = e->xmitstatus_print_buffer + i; |
| 283 | fappend("0x%02x: cookie: 0x%04x, flags: 0x%02x, " |
| 284 | "cnt1: 0x%02x, cnt2: 0x%02x, seq: 0x%04x, " |
| 285 | "unk: 0x%04x\n", j, |
| 286 | status->cookie, status->flags, |
| 287 | status->cnt1, status->cnt2, status->seq, |
| 288 | status->unknown); |
| 289 | j++; |
| 290 | cnt--; |
| 291 | i--; |
| 292 | if (i < 0) |
| 293 | i = BCM43xx_NR_LOGGED_XMITSTATUS - 1; |
| 294 | } |
| 295 | |
Michael Buesch | efccb64 | 2006-03-11 13:39:14 +0100 | [diff] [blame] | 296 | bcm43xx_unlock(bcm, flags); |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 297 | res = simple_read_from_buffer(userbuf, count, ppos, buf, pos); |
Michael Buesch | efccb64 | 2006-03-11 13:39:14 +0100 | [diff] [blame] | 298 | bcm43xx_lock(bcm, flags); |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 299 | if (*ppos == pos) { |
| 300 | /* Done. Drop the copied data. */ |
| 301 | e->xmitstatus_printing = 0; |
| 302 | } |
Michael Buesch | efccb64 | 2006-03-11 13:39:14 +0100 | [diff] [blame] | 303 | bcm43xx_unlock(bcm, flags); |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 304 | up(&big_buffer_sem); |
| 305 | return res; |
| 306 | } |
| 307 | |
| 308 | #undef fappend |
| 309 | |
| 310 | |
| 311 | static struct file_operations devinfo_fops = { |
| 312 | .read = devinfo_read_file, |
| 313 | .write = write_file_dummy, |
| 314 | .open = open_file_generic, |
| 315 | }; |
| 316 | |
| 317 | static struct file_operations spromdump_fops = { |
| 318 | .read = spromdump_read_file, |
| 319 | .write = write_file_dummy, |
| 320 | .open = open_file_generic, |
| 321 | }; |
| 322 | |
| 323 | static struct file_operations drvinfo_fops = { |
| 324 | .read = drvinfo_read_file, |
| 325 | .write = write_file_dummy, |
| 326 | .open = open_file_generic, |
| 327 | }; |
| 328 | |
| 329 | static struct file_operations tsf_fops = { |
| 330 | .read = tsf_read_file, |
| 331 | .write = tsf_write_file, |
| 332 | .open = open_file_generic, |
| 333 | }; |
| 334 | |
| 335 | static struct file_operations txstat_fops = { |
| 336 | .read = txstat_read_file, |
| 337 | .write = write_file_dummy, |
| 338 | .open = open_file_generic, |
| 339 | }; |
| 340 | |
| 341 | |
| 342 | void bcm43xx_debugfs_add_device(struct bcm43xx_private *bcm) |
| 343 | { |
| 344 | struct bcm43xx_dfsentry *e; |
| 345 | char devdir[IFNAMSIZ]; |
| 346 | |
| 347 | assert(bcm); |
| 348 | e = kzalloc(sizeof(*e), GFP_KERNEL); |
| 349 | if (!e) { |
| 350 | printk(KERN_ERR PFX "out of memory\n"); |
| 351 | return; |
| 352 | } |
| 353 | e->bcm = bcm; |
| 354 | e->xmitstatus_buffer = kzalloc(BCM43xx_NR_LOGGED_XMITSTATUS |
| 355 | * sizeof(*(e->xmitstatus_buffer)), |
| 356 | GFP_KERNEL); |
| 357 | if (!e->xmitstatus_buffer) { |
| 358 | printk(KERN_ERR PFX "out of memory\n"); |
| 359 | kfree(e); |
| 360 | return; |
| 361 | } |
| 362 | e->xmitstatus_print_buffer = kzalloc(BCM43xx_NR_LOGGED_XMITSTATUS |
| 363 | * sizeof(*(e->xmitstatus_buffer)), |
| 364 | GFP_KERNEL); |
| 365 | if (!e->xmitstatus_print_buffer) { |
| 366 | printk(KERN_ERR PFX "out of memory\n"); |
| 367 | kfree(e); |
| 368 | return; |
| 369 | } |
| 370 | |
| 371 | |
| 372 | bcm->dfsentry = e; |
| 373 | |
| 374 | strncpy(devdir, bcm->net_dev->name, ARRAY_SIZE(devdir)); |
| 375 | e->subdir = debugfs_create_dir(devdir, fs.root); |
| 376 | e->dentry_devinfo = debugfs_create_file("devinfo", 0444, e->subdir, |
| 377 | bcm, &devinfo_fops); |
| 378 | if (!e->dentry_devinfo) |
| 379 | printk(KERN_ERR PFX "debugfs: creating \"devinfo\" for \"%s\" failed!\n", devdir); |
| 380 | e->dentry_spromdump = debugfs_create_file("sprom_dump", 0444, e->subdir, |
| 381 | bcm, &spromdump_fops); |
| 382 | if (!e->dentry_spromdump) |
| 383 | printk(KERN_ERR PFX "debugfs: creating \"sprom_dump\" for \"%s\" failed!\n", devdir); |
| 384 | e->dentry_tsf = debugfs_create_file("tsf", 0666, e->subdir, |
| 385 | bcm, &tsf_fops); |
| 386 | if (!e->dentry_tsf) |
| 387 | printk(KERN_ERR PFX "debugfs: creating \"tsf\" for \"%s\" failed!\n", devdir); |
| 388 | e->dentry_txstat = debugfs_create_file("tx_status", 0444, e->subdir, |
| 389 | bcm, &txstat_fops); |
| 390 | if (!e->dentry_txstat) |
| 391 | printk(KERN_ERR PFX "debugfs: creating \"tx_status\" for \"%s\" failed!\n", devdir); |
| 392 | } |
| 393 | |
| 394 | void bcm43xx_debugfs_remove_device(struct bcm43xx_private *bcm) |
| 395 | { |
| 396 | struct bcm43xx_dfsentry *e; |
| 397 | |
| 398 | if (!bcm) |
| 399 | return; |
| 400 | |
| 401 | e = bcm->dfsentry; |
| 402 | assert(e); |
| 403 | debugfs_remove(e->dentry_spromdump); |
| 404 | debugfs_remove(e->dentry_devinfo); |
| 405 | debugfs_remove(e->dentry_tsf); |
| 406 | debugfs_remove(e->dentry_txstat); |
| 407 | debugfs_remove(e->subdir); |
| 408 | kfree(e->xmitstatus_buffer); |
| 409 | kfree(e->xmitstatus_print_buffer); |
| 410 | kfree(e); |
| 411 | } |
| 412 | |
| 413 | void bcm43xx_debugfs_log_txstat(struct bcm43xx_private *bcm, |
| 414 | struct bcm43xx_xmitstatus *status) |
| 415 | { |
| 416 | struct bcm43xx_dfsentry *e; |
| 417 | struct bcm43xx_xmitstatus *savedstatus; |
| 418 | |
Michael Buesch | efccb64 | 2006-03-11 13:39:14 +0100 | [diff] [blame] | 419 | /* This is protected by bcm->_lock */ |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 420 | e = bcm->dfsentry; |
| 421 | assert(e); |
| 422 | savedstatus = e->xmitstatus_buffer + e->xmitstatus_ptr; |
| 423 | memcpy(savedstatus, status, sizeof(*status)); |
| 424 | e->xmitstatus_ptr++; |
| 425 | if (e->xmitstatus_ptr >= BCM43xx_NR_LOGGED_XMITSTATUS) |
| 426 | e->xmitstatus_ptr = 0; |
| 427 | if (e->xmitstatus_cnt < BCM43xx_NR_LOGGED_XMITSTATUS) |
| 428 | e->xmitstatus_cnt++; |
| 429 | } |
| 430 | |
| 431 | void bcm43xx_debugfs_init(void) |
| 432 | { |
| 433 | memset(&fs, 0, sizeof(fs)); |
Michael Buesch | 65f3f19 | 2006-01-31 20:11:38 +0100 | [diff] [blame] | 434 | fs.root = debugfs_create_dir(KBUILD_MODNAME, NULL); |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 435 | if (!fs.root) |
Michael Buesch | 65f3f19 | 2006-01-31 20:11:38 +0100 | [diff] [blame] | 436 | printk(KERN_ERR PFX "debugfs: creating \"" KBUILD_MODNAME "\" subdir failed!\n"); |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 437 | fs.dentry_driverinfo = debugfs_create_file("driver", 0444, fs.root, NULL, &drvinfo_fops); |
| 438 | if (!fs.dentry_driverinfo) |
Michael Buesch | 65f3f19 | 2006-01-31 20:11:38 +0100 | [diff] [blame] | 439 | printk(KERN_ERR PFX "debugfs: creating \"" KBUILD_MODNAME "/driver\" failed!\n"); |
John W. Linville | f222313 | 2006-01-23 16:59:58 -0500 | [diff] [blame] | 440 | } |
| 441 | |
| 442 | void bcm43xx_debugfs_exit(void) |
| 443 | { |
| 444 | debugfs_remove(fs.dentry_driverinfo); |
| 445 | debugfs_remove(fs.root); |
| 446 | } |
| 447 | |
| 448 | void bcm43xx_printk_dump(const char *data, |
| 449 | size_t size, |
| 450 | const char *description) |
| 451 | { |
| 452 | size_t i; |
| 453 | char c; |
| 454 | |
| 455 | printk(KERN_INFO PFX "Data dump (%s, %u bytes):", |
| 456 | description, size); |
| 457 | for (i = 0; i < size; i++) { |
| 458 | c = data[i]; |
| 459 | if (i % 8 == 0) |
| 460 | printk("\n" KERN_INFO PFX "0x%08x: 0x%02x, ", i, c & 0xff); |
| 461 | else |
| 462 | printk("0x%02x, ", c & 0xff); |
| 463 | } |
| 464 | printk("\n"); |
| 465 | } |
| 466 | |
| 467 | void bcm43xx_printk_bitdump(const unsigned char *data, |
| 468 | size_t bytes, int msb_to_lsb, |
| 469 | const char *description) |
| 470 | { |
| 471 | size_t i; |
| 472 | int j; |
| 473 | const unsigned char *d; |
| 474 | |
| 475 | printk(KERN_INFO PFX "*** Bitdump (%s, %u bytes, %s) ***", |
| 476 | description, bytes, msb_to_lsb ? "MSB to LSB" : "LSB to MSB"); |
| 477 | for (i = 0; i < bytes; i++) { |
| 478 | d = data + i; |
| 479 | if (i % 8 == 0) |
| 480 | printk("\n" KERN_INFO PFX "0x%08x: ", i); |
| 481 | if (msb_to_lsb) { |
| 482 | for (j = 7; j >= 0; j--) { |
| 483 | if (*d & (1 << j)) |
| 484 | printk("1"); |
| 485 | else |
| 486 | printk("0"); |
| 487 | } |
| 488 | } else { |
| 489 | for (j = 0; j < 8; j++) { |
| 490 | if (*d & (1 << j)) |
| 491 | printk("1"); |
| 492 | else |
| 493 | printk("0"); |
| 494 | } |
| 495 | } |
| 496 | printk(" "); |
| 497 | } |
| 498 | printk("\n"); |
| 499 | } |