watchdog: Create watchdog device in watchdog_dev.c

The watchdog character device is currently created in watchdog_dev.c,
and the watchdog device in watchdog_core.c. This results in
cross-dependencies, since device creation needs to know the watchdog
character device number as well as the watchdog class, both of which
reside in watchdog_dev.c.

Create the watchdog device in watchdog_dev.c to simplify the code.

Inspired by earlier patch set from Damien Riegel.

Cc: Damien Riegel <damien.riegel@savoirfairelinux.com>
Signed-off-by: Guenter Roeck <linux@roeck-us.net>
Signed-off-by: Wim Van Sebroeck <wim@iguana.be>

diff --git a/drivers/watchdog/watchdog_core.c b/drivers/watchdog/watchdog_core.c
index 551af042867c4f59e7860d35a3c4ca53e4ec95bc..f0293f7d2b80f0df909e64dd368d23fab0fe919a 100644 (file)
--- a/drivers/watchdog/watchdog_core.c
+++ b/drivers/watchdog/watchdog_core.c
@@ -42,7 +42,6 @@
 #include "watchdog_core.h"     /* For watchdog_dev_register/... */
 
 static DEFINE_IDA(watchdog_ida);
-static struct class *watchdog_class;
 
 /*
  * Deferred Registration infrastructure.
@@ -194,7 +193,7 @@ EXPORT_SYMBOL_GPL(watchdog_set_restart_priority);
 
 static int __watchdog_register_device(struct watchdog_device *wdd)
 {
-       int ret, id = -1, devno;
+       int ret, id = -1;
 
        if (wdd == NULL || wdd->info == NULL || wdd->ops == NULL)
                return -EINVAL;
@@ -247,16 +246,6 @@ static int __watchdog_register_device(struct watchdog_device *wdd)
                }
        }
 
-       devno = wdd->cdev.dev;
-       wdd->dev = device_create(watchdog_class, wdd->parent, devno,
-                                       wdd, "watchdog%d", wdd->id);
-       if (IS_ERR(wdd->dev)) {
-               watchdog_dev_unregister(wdd);
-               ida_simple_remove(&watchdog_ida, id);
-               ret = PTR_ERR(wdd->dev);
-               return ret;
-       }
-
        if (test_bit(WDOG_STOP_ON_REBOOT, &wdd->status)) {
                wdd->reboot_nb.notifier_call = watchdog_reboot_notifier;
 
@@ -265,9 +254,7 @@ static int __watchdog_register_device(struct watchdog_device *wdd)
                        dev_err(wdd->dev, "Cannot register reboot notifier (%d)\n",
                                ret);
                        watchdog_dev_unregister(wdd);
-                       device_destroy(watchdog_class, devno);
                        ida_simple_remove(&watchdog_ida, wdd->id);
-                       wdd->dev = NULL;
                        return ret;
                }
        }
@@ -311,9 +298,6 @@ EXPORT_SYMBOL_GPL(watchdog_register_device);
 
 static void __watchdog_unregister_device(struct watchdog_device *wdd)
 {
-       int ret;
-       int devno;
-
        if (wdd == NULL)
                return;
 
@@ -323,13 +307,8 @@ static void __watchdog_unregister_device(struct watchdog_device *wdd)
        if (test_bit(WDOG_STOP_ON_REBOOT, &wdd->status))
                unregister_reboot_notifier(&wdd->reboot_nb);
 
-       devno = wdd->cdev.dev;
-       ret = watchdog_dev_unregister(wdd);
-       if (ret)
-               pr_err("error unregistering /dev/watchdog (err=%d)\n", ret);
-       device_destroy(watchdog_class, devno);
+       watchdog_dev_unregister(wdd);
        ida_simple_remove(&watchdog_ida, wdd->id);
-       wdd->dev = NULL;
 }
 
 /**
@@ -370,9 +349,11 @@ static int __init watchdog_deferred_registration(void)
 
 static int __init watchdog_init(void)
 {
-       watchdog_class = watchdog_dev_init();
-       if (IS_ERR(watchdog_class))
-               return PTR_ERR(watchdog_class);
+       int err;
+
+       err = watchdog_dev_init();
+       if (err < 0)
+               return err;
 
        watchdog_deferred_registration();
        return 0;

diff --git a/drivers/watchdog/watchdog_core.h b/drivers/watchdog/watchdog_core.h
index 1c8d6b0e68c779cbc3cbba9f6fbf21db3d82a5f0..86ff962d1e15db97a1c64d6bd42989319ca0bc63 100644 (file)
--- a/drivers/watchdog/watchdog_core.h
+++ b/drivers/watchdog/watchdog_core.h
@@ -32,6 +32,6 @@
  *     Functions/procedures to be called by the core
  */
 extern int watchdog_dev_register(struct watchdog_device *);
-extern int watchdog_dev_unregister(struct watchdog_device *);
-extern struct class * __init watchdog_dev_init(void);
+extern void watchdog_dev_unregister(struct watchdog_device *);
+extern int __init watchdog_dev_init(void);
 extern void __exit watchdog_dev_exit(void);

diff --git a/drivers/watchdog/watchdog_dev.c b/drivers/watchdog/watchdog_dev.c
index f06fbcf0bea248381565b8d62341632afbd7f835..7ba3fc6157c70c3b53ad4c363dbc1abc81b9dfeb 100644 (file)
--- a/drivers/watchdog/watchdog_dev.c
+++ b/drivers/watchdog/watchdog_dev.c
@@ -628,17 +628,18 @@ static struct miscdevice watchdog_miscdev = {
 };
 
 /*
- *     watchdog_dev_register: register a watchdog device
+ *     watchdog_cdev_register: register watchdog character device
  *     @wdd: watchdog device
+ *     @devno: character device number
  *
- *     Register a watchdog device including handling the legacy
+ *     Register a watchdog character device including handling the legacy
  *     /dev/watchdog node. /dev/watchdog is actually a miscdevice and
  *     thus we set it up like that.
  */
 
-int watchdog_dev_register(struct watchdog_device *wdd)
+static int watchdog_cdev_register(struct watchdog_device *wdd, dev_t devno)
 {
-       int err, devno;
+       int err;
 
        if (wdd->id == 0) {
                old_wdd = wdd;
@@ -656,7 +657,6 @@ int watchdog_dev_register(struct watchdog_device *wdd)
        }
 
        /* Fill in the data structures */
-       devno = MKDEV(MAJOR(watchdog_devt), wdd->id);
        cdev_init(&wdd->cdev, &watchdog_fops);
        wdd->cdev.owner = wdd->ops->owner;
 
@@ -674,13 +674,14 @@ int watchdog_dev_register(struct watchdog_device *wdd)
 }
 
 /*
- *     watchdog_dev_unregister: unregister a watchdog device
+ *     watchdog_cdev_unregister: unregister watchdog character device
  *     @watchdog: watchdog device
  *
- *     Unregister the watchdog and if needed the legacy /dev/watchdog device.
+ *     Unregister watchdog character device and if needed the legacy
+ *     /dev/watchdog device.
  */
 
-int watchdog_dev_unregister(struct watchdog_device *wdd)
+static void watchdog_cdev_unregister(struct watchdog_device *wdd)
 {
        mutex_lock(&wdd->lock);
        set_bit(WDOG_UNREGISTERED, &wdd->status);
@@ -691,7 +692,6 @@ int watchdog_dev_unregister(struct watchdog_device *wdd)
                misc_deregister(&watchdog_miscdev);
                old_wdd = NULL;
        }
-       return 0;
 }
 
 static struct class watchdog_class = {
@@ -700,30 +700,77 @@ static struct class watchdog_class = {
        .dev_groups =   wdt_groups,
 };
 
+/*
+ *     watchdog_dev_register: register a watchdog device
+ *     @wdd: watchdog device
+ *
+ *     Register a watchdog device including handling the legacy
+ *     /dev/watchdog node. /dev/watchdog is actually a miscdevice and
+ *     thus we set it up like that.
+ */
+
+int watchdog_dev_register(struct watchdog_device *wdd)
+{
+       struct device *dev;
+       dev_t devno;
+       int ret;
+
+       devno = MKDEV(MAJOR(watchdog_devt), wdd->id);
+
+       ret = watchdog_cdev_register(wdd, devno);
+       if (ret)
+               return ret;
+
+       dev = device_create(&watchdog_class, wdd->parent, devno, wdd,
+                           "watchdog%d", wdd->id);
+       if (IS_ERR(dev)) {
+               watchdog_cdev_unregister(wdd);
+               return PTR_ERR(dev);
+       }
+       wdd->dev = dev;
+
+       return ret;
+}
+
+/*
+ *     watchdog_dev_unregister: unregister a watchdog device
+ *     @watchdog: watchdog device
+ *
+ *     Unregister watchdog device and if needed the legacy
+ *     /dev/watchdog device.
+ */
+
+void watchdog_dev_unregister(struct watchdog_device *wdd)
+{
+       watchdog_cdev_unregister(wdd);
+       device_destroy(&watchdog_class, wdd->dev->devt);
+       wdd->dev = NULL;
+}
+
 /*
  *     watchdog_dev_init: init dev part of watchdog core
  *
  *     Allocate a range of chardev nodes to use for watchdog devices
  */
 
-struct class * __init watchdog_dev_init(void)
+int __init watchdog_dev_init(void)
 {
        int err;
 
        err = class_register(&watchdog_class);
        if (err < 0) {
                pr_err("couldn't register class\n");
-               return ERR_PTR(err);
+               return err;
        }
 
        err = alloc_chrdev_region(&watchdog_devt, 0, MAX_DOGS, "watchdog");
        if (err < 0) {
                pr_err("watchdog: unable to allocate char dev region\n");
                class_unregister(&watchdog_class);
-               return ERR_PTR(err);
+               return err;
        }
 
-       return &watchdog_class;
+       return 0;
 }
 
 /*