When calling debugfs functions, there is no need to ever check the return value. The function can work or not, but the code logic should never do something different based on this. This cleans up a lot of unneeded code and logic around the debugfs wimax files, making all of this much simpler and easier to understand.
Unified · Split
| @@ -30,15 +30,6 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_netdev_queue_stopped, · 29 unmodified lines | |||
| 30 | debugfs_netdev_queue_stopped_get, | 30 | debugfs_netdev_queue_stopped_get, |
| 31 | NULL, "%llu\n"); | 31 | NULL, "%llu\n"); |
| 32 | 32 | ||
| 33 | |||
| 34 | static | ||
| 35 | struct dentry *debugfs_create_netdev_queue_stopped( | ||
| 36 | const char *name, struct dentry *parent, struct i2400m *i2400m) | ||
| 37 | { | ||
| 38 | return debugfs_create_file(name, 0400, parent, i2400m, | ||
| 39 | &fops_netdev_queue_stopped); | ||
| 40 | } | ||
| 41 | |||
| 42 | /* | 33 | /* |
| 43 | * We don't allow partial reads of this file, as then the reader would | 34 | * We don't allow partial reads of this file, as then the reader would |
| 44 | * get weirdly confused data as it is updated. | 35 | * get weirdly confused data as it is updated. |
| @@ -167,15 +158,6 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_i2400m_suspend, · 122 unmodified lines | |||
| 167 | NULL, debugfs_i2400m_suspend_set, | 158 | NULL, debugfs_i2400m_suspend_set, |
| 168 | "%llu\n"); | 159 | "%llu\n"); |
| 169 | 160 | ||
| 170 | static | ||
| 171 | struct dentry *debugfs_create_i2400m_suspend( | ||
| 172 | const char *name, struct dentry *parent, struct i2400m *i2400m) | ||
| 173 | { | ||
| 174 | return debugfs_create_file(name, 0200, parent, i2400m, | ||
| 175 | &fops_i2400m_suspend); | ||
| 176 | } | ||
| 177 | |||
| 178 | |||
| 179 | /* | 161 | /* |
| 180 | * Reset the device | 162 | * Reset the device |
| 181 | * | 163 | * |
| @@ -205,73 +187,25 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_i2400m_reset, · 23 unmodified lines | |||
| 205 | NULL, debugfs_i2400m_reset_set, | 187 | NULL, debugfs_i2400m_reset_set, |
| 206 | "%llu\n"); | 188 | "%llu\n"); |
| 207 | 189 | ||
| 208 | static | 190 | void i2400m_debugfs_add(struct i2400m *i2400m) |
| 209 | struct dentry *debugfs_create_i2400m_reset( | ||
| 210 | const char *name, struct dentry *parent, struct i2400m *i2400m) | ||
| 211 | { | 191 | { |
| 212 | return debugfs_create_file(name, 0200, parent, i2400m, | ||
| 213 | &fops_i2400m_reset); | ||
| 214 | } | ||
| 215 | |||
| 216 | |||
| 217 | #define __debugfs_register(prefix, name, parent) \ | ||
| 218 | do { \ | ||
| 219 | result = d_level_register_debugfs(prefix, name, parent); \ | ||
| 220 | if (result < 0) \ | ||
| 221 | goto error; \ | ||
| 222 | } while (0) | ||
| 223 | |||
| 224 | |||
| 225 | int i2400m_debugfs_add(struct i2400m *i2400m) | ||
| 226 | { | ||
| 227 | int result; | ||
| 228 | struct device *dev = i2400m_dev(i2400m); | ||
| 229 | struct dentry *dentry = i2400m->wimax_dev.debugfs_dentry; | 192 | struct dentry *dentry = i2400m->wimax_dev.debugfs_dentry; |
| 230 | struct dentry *fd; | ||
| 231 | 193 | ||
| 232 | dentry = debugfs_create_dir("i2400m", dentry); | 194 | dentry = debugfs_create_dir("i2400m", dentry); |
| 233 | result = PTR_ERR(dentry); | ||
| 234 | if (IS_ERR(dentry)) { | ||
| 235 | if (result == -ENODEV) | ||
| 236 | result = 0; /* No debugfs support */ | ||
| 237 | goto error; | ||
| 238 | } | ||
| 239 | i2400m->debugfs_dentry = dentry; | 195 | i2400m->debugfs_dentry = dentry; |
| 240 | __debugfs_register("dl_", control, dentry); | ||
| 241 | __debugfs_register("dl_", driver, dentry); | ||
| 242 | __debugfs_register("dl_", debugfs, dentry); | ||
| 243 | __debugfs_register("dl_", fw, dentry); | ||
| 244 | __debugfs_register("dl_", netdev, dentry); | ||
| 245 | __debugfs_register("dl_", rfkill, dentry); | ||
| 246 | __debugfs_register("dl_", rx, dentry); | ||
| 247 | __debugfs_register("dl_", tx, dentry); | ||
| 248 | |||
| 249 | fd = debugfs_create_size_t("tx_in", 0400, dentry, | ||
| 250 | &i2400m->tx_in); | ||
| 251 | result = PTR_ERR(fd); | ||
| 252 | if (IS_ERR(fd) && result != -ENODEV) { | ||
| 253 | dev_err(dev, "Can't create debugfs entry " | ||
| 254 | "tx_in: %d\n", result); | ||
| 255 | goto error; | ||
| 256 | } | ||
| 257 | 196 | ||
| 258 | fd = debugfs_create_size_t("tx_out", 0400, dentry, | 197 | d_level_register_debugfs("dl_", control, dentry); |
| 259 | &i2400m->tx_out); | 198 | d_level_register_debugfs("dl_", driver, dentry); |
| 260 | result = PTR_ERR(fd); | 199 | d_level_register_debugfs("dl_", debugfs, dentry); |
| 261 | if (IS_ERR(fd) && result != -ENODEV) { | 200 | d_level_register_debugfs("dl_", fw, dentry); |
| 262 | dev_err(dev, "Can't create debugfs entry " | 201 | d_level_register_debugfs("dl_", netdev, dentry); |
| 263 | "tx_out: %d\n", result); | 202 | d_level_register_debugfs("dl_", rfkill, dentry); |
| 264 | goto error; | 203 | d_level_register_debugfs("dl_", rx, dentry); |
| 265 | } | 204 | d_level_register_debugfs("dl_", tx, dentry); |
| 266 | 205 | ||
| 267 | fd = debugfs_create_u32("state", 0600, dentry, | 206 | debugfs_create_size_t("tx_in", 0400, dentry, &i2400m->tx_in); |
| 268 | &i2400m->state); | 207 | debugfs_create_size_t("tx_out", 0400, dentry, &i2400m->tx_out); |
| 269 | result = PTR_ERR(fd); | 208 | debugfs_create_u32("state", 0600, dentry, &i2400m->state); |
| 270 | if (IS_ERR(fd) && result != -ENODEV) { | ||
| 271 | dev_err(dev, "Can't create debugfs entry " | ||
| 272 | "state: %d\n", result); | ||
| 273 | goto error; | ||
| 274 | } | ||
| 275 | 209 | ||
| 276 | /* | 210 | /* |
| 277 | * Trace received messages from user space | 211 | * Trace received messages from user space |
| @@ -295,60 +229,22 @@ int i2400m_debugfs_add(struct i2400m *i2400m) · 17 unmodified lines | |||
| 295 | * It is not really very atomic, but it is also not too | 229 | * It is not really very atomic, but it is also not too |
| 296 | * critical. | 230 | * critical. |
| 297 | */ | 231 | */ |
| 298 | fd = debugfs_create_u8("trace_msg_from_user", 0600, dentry, | 232 | debugfs_create_u8("trace_msg_from_user", 0600, dentry, |
| 299 | &i2400m->trace_msg_from_user); | 233 | &i2400m->trace_msg_from_user); |
| 300 | result = PTR_ERR(fd); | ||
| 301 | if (IS_ERR(fd) && result != -ENODEV) { | ||
| 302 | dev_err(dev, "Can't create debugfs entry " | ||
| 303 | "trace_msg_from_user: %d\n", result); | ||
| 304 | goto error; | ||
| 305 | } | ||
| 306 | 234 | ||
| 307 | fd = debugfs_create_netdev_queue_stopped("netdev_queue_stopped", | 235 | debugfs_create_file("netdev_queue_stopped", 0400, dentry, i2400m, |
| 308 | dentry, i2400m); | 236 | &fops_netdev_queue_stopped); |
| 309 | result = PTR_ERR(fd); | ||
| 310 | if (IS_ERR(fd) && result != -ENODEV) { | ||
| 311 | dev_err(dev, "Can't create debugfs entry " | ||
| 312 | "netdev_queue_stopped: %d\n", result); | ||
| 313 | goto error; | ||
| 314 | } | ||
| 315 | 237 | ||
| 316 | fd = debugfs_create_file("rx_stats", 0600, dentry, i2400m, | 238 | debugfs_create_file("rx_stats", 0600, dentry, i2400m, |
| 317 | &i2400m_rx_stats_fops); | 239 | &i2400m_rx_stats_fops); |
| 318 | result = PTR_ERR(fd); | ||
| 319 | if (IS_ERR(fd) && result != -ENODEV) { | ||
| 320 | dev_err(dev, "Can't create debugfs entry " | ||
| 321 | "rx_stats: %d\n", result); | ||
| 322 | goto error; | ||
| 323 | } | ||
| 324 | 240 | ||
| 325 | fd = debugfs_create_file("tx_stats", 0600, dentry, i2400m, | 241 | debugfs_create_file("tx_stats", 0600, dentry, i2400m, |
| 326 | &i2400m_tx_stats_fops); | 242 | &i2400m_tx_stats_fops); |
| 327 | result = PTR_ERR(fd); | ||
| 328 | if (IS_ERR(fd) && result != -ENODEV) { | ||
| 329 | dev_err(dev, "Can't create debugfs entry " | ||
| 330 | "tx_stats: %d\n", result); | ||
| 331 | goto error; | ||
| 332 | } | ||
| 333 | 243 | ||
| 334 | fd = debugfs_create_i2400m_suspend("suspend", dentry, i2400m); | 244 | debugfs_create_file("suspend", 0200, dentry, i2400m, |
| 335 | result = PTR_ERR(fd); | 245 | &fops_i2400m_suspend); |
| 336 | if (IS_ERR(fd) && result != -ENODEV) { | ||
| 337 | dev_err(dev, "Can't create debugfs entry suspend: %d\n", | ||
| 338 | result); | ||
| 339 | goto error; | ||
| 340 | } | ||
| 341 | 246 | ||
| 342 | fd = debugfs_create_i2400m_reset("reset", dentry, i2400m); | 247 | debugfs_create_file("reset", 0200, dentry, i2400m, &fops_i2400m_reset); |
| 343 | result = PTR_ERR(fd); | ||
| 344 | if (IS_ERR(fd) && result != -ENODEV) { | ||
| 345 | dev_err(dev, "Can't create debugfs entry reset: %d\n", result); | ||
| 346 | goto error; | ||
| 347 | } | ||
| 348 | |||
| 349 | result = 0; | ||
| 350 | error: | ||
| 351 | return result; | ||
| 352 | } | 248 | } |
| 353 | 249 | ||
| 354 | void i2400m_debugfs_rm(struct i2400m *i2400m) | 250 | void i2400m_debugfs_rm(struct i2400m *i2400m) |
| @@ -905,11 +905,7 @@ int i2400m_setup(struct i2400m *i2400m, enum i2400m_bri bm_flags) · 904 unmodified lines | |||
| 905 | goto error_sysfs_setup; | 905 | goto error_sysfs_setup; |
| 906 | } | 906 | } |
| 907 | 907 | ||
| 908 | result = i2400m_debugfs_add(i2400m); | 908 | i2400m_debugfs_add(i2400m); |
| 909 | if (result < 0) { | ||
| 910 | dev_err(dev, "cannot setup i2400m's debugfs: %d\n", result); | ||
| 911 | goto error_debugfs_setup; | ||
| 912 | } | ||
| 913 | 909 | ||
| 914 | result = i2400m_dev_start(i2400m, bm_flags); | 910 | result = i2400m_dev_start(i2400m, bm_flags); |
| 915 | if (result < 0) | 911 | if (result < 0) |
| @@ -919,7 +915,6 @@ int i2400m_setup(struct i2400m *i2400m, enum i2400m_bri bm_flags) · 3 unmodified lines | |||
| 919 | 915 | ||
| 920 | error_dev_start: | 916 | error_dev_start: |
| 921 | i2400m_debugfs_rm(i2400m); | 917 | i2400m_debugfs_rm(i2400m); |
| 922 | error_debugfs_setup: | ||
| 923 | sysfs_remove_group(&i2400m->wimax_dev.net_dev->dev.kobj, | 918 | sysfs_remove_group(&i2400m->wimax_dev.net_dev->dev.kobj, |
| 924 | &i2400m_dev_attr_group); | 919 | &i2400m_dev_attr_group); |
| 925 | error_sysfs_setup: | 920 | error_sysfs_setup: |
| @@ -812,13 +812,10 @@ enum i2400m_pt; · 811 unmodified lines | |||
| 812 | int i2400m_tx(struct i2400m *, const void *, size_t, enum i2400m_pt); | 812 | int i2400m_tx(struct i2400m *, const void *, size_t, enum i2400m_pt); |
| 813 | 813 | ||
| 814 | #ifdef CONFIG_DEBUG_FS | 814 | #ifdef CONFIG_DEBUG_FS |
| 815 | int i2400m_debugfs_add(struct i2400m *); | 815 | void i2400m_debugfs_add(struct i2400m *); |
| 816 | void i2400m_debugfs_rm(struct i2400m *); | 816 | void i2400m_debugfs_rm(struct i2400m *); |
| 817 | #else | 817 | #else |
| 818 | static inline int i2400m_debugfs_add(struct i2400m *i2400m) | 818 | static inline void i2400m_debugfs_add(struct i2400m *i2400m) {} |
| 819 | { | ||
| 820 | return 0; | ||
| 821 | } | ||
| 822 | static inline void i2400m_debugfs_rm(struct i2400m *i2400m) {} | 819 | static inline void i2400m_debugfs_rm(struct i2400m *i2400m) {} |
| 823 | #endif | 820 | #endif |
| 824 | 821 | ||
| @@ -366,61 +366,25 @@ struct d_level D_LEVEL[] = { · 365 unmodified lines | |||
| 366 | }; | 366 | }; |
| 367 | size_t D_LEVEL_SIZE = ARRAY_SIZE(D_LEVEL); | 367 | size_t D_LEVEL_SIZE = ARRAY_SIZE(D_LEVEL); |
| 368 | 368 | ||
| 369 | |||
| 370 | #define __debugfs_register(prefix, name, parent) \ | ||
| 371 | do { \ | ||
| 372 | result = d_level_register_debugfs(prefix, name, parent); \ | ||
| 373 | if (result < 0) \ | ||
| 374 | goto error; \ | ||
| 375 | } while (0) | ||
| 376 | |||
| 377 | |||
| 378 | static | 369 | static |
| 379 | int i2400mu_debugfs_add(struct i2400mu *i2400mu) | 370 | void i2400mu_debugfs_add(struct i2400mu *i2400mu) |
| 380 | { | 371 | { |
| 381 | int result; | ||
| 382 | struct device *dev = &i2400mu->usb_iface->dev; | ||
| 383 | struct dentry *dentry = i2400mu->i2400m.wimax_dev.debugfs_dentry; | 372 | struct dentry *dentry = i2400mu->i2400m.wimax_dev.debugfs_dentry; |
| 384 | struct dentry *fd; | ||
| 385 | 373 | ||
| 386 | dentry = debugfs_create_dir("i2400m-usb", dentry); | 374 | dentry = debugfs_create_dir("i2400m-usb", dentry); |
| 387 | result = PTR_ERR(dentry); | ||
| 388 | if (IS_ERR(dentry)) { | ||
| 389 | if (result == -ENODEV) | ||
| 390 | result = 0; /* No debugfs support */ | ||
| 391 | goto error; | ||
| 392 | } | ||
| 393 | i2400mu->debugfs_dentry = dentry; | 375 | i2400mu->debugfs_dentry = dentry; |
| 394 | __debugfs_register("dl_", usb, dentry); | ||
| 395 | __debugfs_register("dl_", fw, dentry); | ||
| 396 | __debugfs_register("dl_", notif, dentry); | ||
| 397 | __debugfs_register("dl_", rx, dentry); | ||
| 398 | __debugfs_register("dl_", tx, dentry); | ||
| 399 | 376 | ||
| 400 | /* Don't touch these if you don't know what you are doing */ | 377 | d_level_register_debugfs("dl_", usb, dentry); |
| 401 | fd = debugfs_create_u8("rx_size_auto_shrink", 0600, dentry, | 378 | d_level_register_debugfs("dl_", fw, dentry); |
| 402 | &i2400mu->rx_size_auto_shrink); | 379 | d_level_register_debugfs("dl_", notif, dentry); |
| 403 | result = PTR_ERR(fd); | 380 | d_level_register_debugfs("dl_", rx, dentry); |
| 404 | if (IS_ERR(fd) && result != -ENODEV) { | 381 | d_level_register_debugfs("dl_", tx, dentry); |
| 405 | dev_err(dev, "Can't create debugfs entry " | ||
| 406 | "rx_size_auto_shrink: %d\n", result); | ||
| 407 | goto error; | ||
| 408 | } | ||
| 409 | 382 | ||
| 410 | fd = debugfs_create_size_t("rx_size", 0600, dentry, | 383 | /* Don't touch these if you don't know what you are doing */ |
| 411 | &i2400mu->rx_size); | 384 | debugfs_create_u8("rx_size_auto_shrink", 0600, dentry, |
| 412 | result = PTR_ERR(fd); | 385 | &i2400mu->rx_size_auto_shrink); |
| 413 | if (IS_ERR(fd) && result != -ENODEV) { | ||
| 414 | dev_err(dev, "Can't create debugfs entry " | ||
| 415 | "rx_size: %d\n", result); | ||
| 416 | goto error; | ||
| 417 | } | ||
| 418 | |||
| 419 | return 0; | ||
| 420 | 386 | ||
| 421 | error: | 387 | debugfs_create_size_t("rx_size", 0600, dentry, &i2400mu->rx_size); |
| 422 | debugfs_remove_recursive(i2400mu->debugfs_dentry); | ||
| 423 | return result; | ||
| 424 | } | 388 | } |
| 425 | 389 | ||
| 426 | 390 | ||
| @@ -534,15 +498,9 @@ int i2400mu_probe(struct usb_interface *iface, · 107 unmodified lines | |||
| 534 | dev_err(dev, "cannot setup device: %d\n", result); | 498 | dev_err(dev, "cannot setup device: %d\n", result); |
| 535 | goto error_setup; | 499 | goto error_setup; |
| 536 | } | 500 | } |
| 537 | result = i2400mu_debugfs_add(i2400mu); | 501 | i2400mu_debugfs_add(i2400mu); |
| 538 | if (result < 0) { | ||
| 539 | dev_err(dev, "Can't register i2400mu's debugfs: %d\n", result); | ||
| 540 | goto error_debugfs_add; | ||
| 541 | } | ||
| 542 | return 0; | 502 | return 0; |
| 543 | 503 | ||
| 544 | error_debugfs_add: | ||
| 545 | i2400m_release(i2400m); | ||
| 546 | error_setup: | 504 | error_setup: |
| 547 | usb_set_intfdata(iface, NULL); | 505 | usb_set_intfdata(iface, NULL); |
| 548 | usb_put_dev(i2400mu->usb_dev); | 506 | usb_put_dev(i2400mu->usb_dev); |
| @@ -98,9 +98,7 @@ · 97 unmodified lines | |||
| 98 | * To manipulate from user space the levels, create a debugfs dentry | 98 | * To manipulate from user space the levels, create a debugfs dentry |
| 99 | * and then register each submodule with: | 99 | * and then register each submodule with: |
| 100 | * | 100 | * |
| 101 | * result = d_level_register_debugfs("PREFIX_", submodule_X, parent); | 101 | * d_level_register_debugfs("PREFIX_", submodule_X, parent); |
| 102 | * if (result < 0) | ||
| 103 | * goto error; | ||
| 104 | * | 102 | * |
| 105 | * Where PREFIX_ is a name of your chosing. This will create debugfs | 103 | * Where PREFIX_ is a name of your chosing. This will create debugfs |
| 106 | * file with a single numeric value that can be use to tweak it. To | 104 | * file with a single numeric value that can be use to tweak it. To |
| @@ -408,25 +406,13 @@ do { \ · 301 unmodified lines | |||
| 408 | * @submodule: name of submodule (not a string, just the name) | 406 | * @submodule: name of submodule (not a string, just the name) |
| 409 | * @dentry: debugfs parent dentry | 407 | * @dentry: debugfs parent dentry |
| 410 | * | 408 | * |
| 411 | * Returns: 0 if ok, < 0 errno on error. | ||
| 412 | * | ||
| 413 | * For removing, just use debugfs_remove_recursive() on the parent. | 409 | * For removing, just use debugfs_remove_recursive() on the parent. |
| 414 | */ | 410 | */ |
| 415 | #define d_level_register_debugfs(prefix, name, parent) \ | 411 | #define d_level_register_debugfs(prefix, name, parent) \ |
| 416 | ({ \ | 412 | ({ \ |
| 417 | int rc; \ | 413 | debugfs_create_u8( \ |
| 418 | struct dentry *fd; \ | 414 | prefix #name, 0600, parent, \ |
| 419 | struct dentry *verify_parent_type = parent; \ | ||
| 420 | fd = debugfs_create_u8( \ | ||
| 421 | prefix #name, 0600, verify_parent_type, \ | ||
| 422 | &(D_LEVEL[__D_SUBMODULE_ ## name].level)); \ | 415 | &(D_LEVEL[__D_SUBMODULE_ ## name].level)); \ |
| 423 | rc = PTR_ERR(fd); \ | ||
| 424 | if (IS_ERR(fd) && rc != -ENODEV) \ | ||
| 425 | printk(KERN_ERR "%s: Can't create debugfs entry %s: " \ | ||
| 426 | "%d\n", __func__, prefix #name, rc); \ | ||
| 427 | else \ | ||
| 428 | rc = 0; \ | ||
| 429 | rc; \ | ||
| 430 | }) | 416 | }) |
| 431 | 417 | ||
| 432 | 418 | ||
| @@ -13,49 +13,23 @@ · 12 unmodified lines | |||
| 13 | #define D_SUBMODULE debugfs | 13 | #define D_SUBMODULE debugfs |
| 14 | #include "debug-levels.h" | 14 | #include "debug-levels.h" |
| 15 | 15 | ||
| 16 | 16 | void wimax_debugfs_add(struct wimax_dev *wimax_dev) | |
| 17 | #define __debugfs_register(prefix, name, parent) \ | ||
| 18 | do { \ | ||
| 19 | result = d_level_register_debugfs(prefix, name, parent); \ | ||
| 20 | if (result < 0) \ | ||
| 21 | goto error; \ | ||
| 22 | } while (0) | ||
| 23 | |||
| 24 | |||
| 25 | int wimax_debugfs_add(struct wimax_dev *wimax_dev) | ||
| 26 | { | 17 | { |
| 27 | int result; | ||
| 28 | struct net_device *net_dev = wimax_dev->net_dev; | 18 | struct net_device *net_dev = wimax_dev->net_dev; |
| 29 | struct device *dev = net_dev->dev.parent; | ||
| 30 | struct dentry *dentry; | 19 | struct dentry *dentry; |
| 31 | char buf[128]; | 20 | char buf[128]; |
| 32 | 21 | ||
| 33 | snprintf(buf, sizeof(buf), "wimax:%s", net_dev->name); | 22 | snprintf(buf, sizeof(buf), "wimax:%s", net_dev->name); |
| 34 | dentry = debugfs_create_dir(buf, NULL); | 23 | dentry = debugfs_create_dir(buf, NULL); |
| 35 | result = PTR_ERR(dentry); | ||
| 36 | if (IS_ERR(dentry)) { | ||
| 37 | if (result == -ENODEV) | ||
| 38 | result = 0; /* No debugfs support */ | ||
| 39 | else | ||
| 40 | dev_err(dev, "Can't create debugfs dentry: %d\n", | ||
| 41 | result); | ||
| 42 | goto out; | ||
| 43 | } | ||
| 44 | wimax_dev->debugfs_dentry = dentry; | 24 | wimax_dev->debugfs_dentry = dentry; |
| 45 | __debugfs_register("wimax_dl_", debugfs, dentry); | ||
| 46 | __debugfs_register("wimax_dl_", id_table, dentry); | ||
| 47 | __debugfs_register("wimax_dl_", op_msg, dentry); | ||
| 48 | __debugfs_register("wimax_dl_", op_reset, dentry); | ||
| 49 | __debugfs_register("wimax_dl_", op_rfkill, dentry); | ||
| 50 | __debugfs_register("wimax_dl_", op_state_get, dentry); | ||
| 51 | __debugfs_register("wimax_dl_", stack, dentry); | ||
| 52 | result = 0; | ||
| 53 | out: | ||
| 54 | return result; | ||
| 55 | 25 | ||
| 56 | error: | 26 | d_level_register_debugfs("wimax_dl_", debugfs, dentry); |
| 57 | debugfs_remove_recursive(wimax_dev->debugfs_dentry); | 27 | d_level_register_debugfs("wimax_dl_", id_table, dentry); |
| 58 | return result; | 28 | d_level_register_debugfs("wimax_dl_", op_msg, dentry); |
| 29 | d_level_register_debugfs("wimax_dl_", op_reset, dentry); | ||
| 30 | d_level_register_debugfs("wimax_dl_", op_rfkill, dentry); | ||
| 31 | d_level_register_debugfs("wimax_dl_", op_state_get, dentry); | ||
| 32 | d_level_register_debugfs("wimax_dl_", stack, dentry); | ||
| 59 | } | 33 | } |
| 60 | 34 | ||
| 61 | void wimax_debugfs_rm(struct wimax_dev *wimax_dev) | 35 | void wimax_debugfs_rm(struct wimax_dev *wimax_dev) |
| @@ -481,12 +481,7 @@ int wimax_dev_add(struct wimax_dev *wimax_dev, struct net_device *net_dev) · 480 unmodified lines | |||
| 481 | /* Set up user-space interaction */ | 481 | /* Set up user-space interaction */ |
| 482 | mutex_lock(&wimax_dev->mutex); | 482 | mutex_lock(&wimax_dev->mutex); |
| 483 | wimax_id_table_add(wimax_dev); | 483 | wimax_id_table_add(wimax_dev); |
| 484 | result = wimax_debugfs_add(wimax_dev); | 484 | wimax_debugfs_add(wimax_dev); |
| 485 | if (result < 0) { | ||
| 486 | dev_err(dev, "cannot initialize debugfs: %d\n", | ||
| 487 | result); | ||
| 488 | goto error_debugfs_add; | ||
| 489 | } | ||
| 490 | 485 | ||
| 491 | __wimax_state_set(wimax_dev, WIMAX_ST_DOWN); | 486 | __wimax_state_set(wimax_dev, WIMAX_ST_DOWN); |
| 492 | mutex_unlock(&wimax_dev->mutex); | 487 | mutex_unlock(&wimax_dev->mutex); |
| @@ -498,10 +493,6 @@ int wimax_dev_add(struct wimax_dev *wimax_dev, struct net_device *net_dev) · 5 unmodified lines | |||
| 498 | d_fnend(3, dev, "(wimax_dev %p net_dev %p) = 0\n", wimax_dev, net_dev); | 493 | d_fnend(3, dev, "(wimax_dev %p net_dev %p) = 0\n", wimax_dev, net_dev); |
| 499 | return 0; | 494 | return 0; |
| 500 | 495 | ||
| 501 | error_debugfs_add: | ||
| 502 | wimax_id_table_rm(wimax_dev); | ||
| 503 | mutex_unlock(&wimax_dev->mutex); | ||
| 504 | wimax_rfkill_rm(wimax_dev); | ||
| 505 | error_rfkill_add: | 496 | error_rfkill_add: |
| 506 | d_fnend(3, dev, "(wimax_dev %p net_dev %p) = %d\n", | 497 | d_fnend(3, dev, "(wimax_dev %p net_dev %p) = %d\n", |
| 507 | wimax_dev, net_dev, result); | 498 | wimax_dev, net_dev, result); |
| @@ -57,13 +57,10 @@ void __wimax_state_set(struct wimax_dev *wimax_dev, enum wimax_st state) · 56 unmodified lines | |||
| 57 | void __wimax_state_change(struct wimax_dev *, enum wimax_st); | 57 | void __wimax_state_change(struct wimax_dev *, enum wimax_st); |
| 58 | 58 | ||
| 59 | #ifdef CONFIG_DEBUG_FS | 59 | #ifdef CONFIG_DEBUG_FS |
| 60 | int wimax_debugfs_add(struct wimax_dev *); | 60 | void wimax_debugfs_add(struct wimax_dev *); |
| 61 | void wimax_debugfs_rm(struct wimax_dev *); | 61 | void wimax_debugfs_rm(struct wimax_dev *); |
| 62 | #else | 62 | #else |
| 63 | static inline int wimax_debugfs_add(struct wimax_dev *wimax_dev) | 63 | static inline void wimax_debugfs_add(struct wimax_dev *wimax_dev) {} |
| 64 | { | ||
| 65 | return 0; | ||
| 66 | } | ||
| 67 | static inline void wimax_debugfs_rm(struct wimax_dev *wimax_dev) {} | 64 | static inline void wimax_debugfs_rm(struct wimax_dev *wimax_dev) {} |
| 68 | #endif | 65 | #endif |
| 69 | 66 | ||