rtc: remove rest of class_device

[powerpc.git] / drivers / rtc / class.c

diff --git a/drivers/rtc/class.c b/drivers/rtc/class.c
index 413c7d5..d58d74c 100644 (file)
--- a/drivers/rtc/class.c
+++ b/drivers/rtc/class.c
@@ -16,13 +16,16 @@
 #include <linux/kdev_t.h>
 #include <linux/idr.h>
 
+#include "rtc-core.h"
+
+
 static DEFINE_IDR(rtc_idr);
 static DEFINE_MUTEX(idr_lock);
 struct class *rtc_class;
 
-static void rtc_device_release(struct class_device *class_dev)
+static void rtc_device_release(struct device *dev)
 {
-       struct rtc_device *rtc = to_rtc_device(class_dev);
+       struct rtc_device *rtc = to_rtc_device(dev);
        mutex_lock(&idr_lock);
        idr_remove(&rtc_idr, rtc->id);
        mutex_unlock(&idr_lock);
@@ -39,7 +42,7 @@ static void rtc_device_release(struct class_device *class_dev)
  * Returns the pointer to the new struct class device.
  */
 struct rtc_device *rtc_device_register(const char *name, struct device *dev,
-                                       struct rtc_class_ops *ops,
+                                       const struct rtc_class_ops *ops,
                                        struct module *owner)
 {
        struct rtc_device *rtc;
@@ -69,23 +72,28 @@ struct rtc_device *rtc_device_register(const char *name, struct device *dev,
        rtc->id = id;
        rtc->ops = ops;
        rtc->owner = owner;
-       rtc->class_dev.dev = dev;
-       rtc->class_dev.class = rtc_class;
-       rtc->class_dev.release = rtc_device_release;
+       rtc->max_user_freq = 64;
+       rtc->dev.parent = dev;
+       rtc->dev.class = rtc_class;
+       rtc->dev.release = rtc_device_release;
 
        mutex_init(&rtc->ops_lock);
        spin_lock_init(&rtc->irq_lock);
        spin_lock_init(&rtc->irq_task_lock);
 
        strlcpy(rtc->name, name, RTC_DEVICE_NAME_SIZE);
-       snprintf(rtc->class_dev.class_id, BUS_ID_SIZE, "rtc%d", id);
+       snprintf(rtc->dev.bus_id, BUS_ID_SIZE, "rtc%d", id);
 
-       err = class_device_register(&rtc->class_dev);
+       err = device_register(&rtc->dev);
        if (err)
                goto exit_kfree;
 
+       rtc_dev_add_device(rtc);
+       rtc_sysfs_add_device(rtc);
+       rtc_proc_add_device(rtc);
+
        dev_info(dev, "rtc core: registered %s as %s\n",
-                       rtc->name, rtc->class_dev.class_id);
+                       rtc->name, rtc->dev.bus_id);
 
        return rtc;
 
@@ -93,7 +101,9 @@ exit_kfree:
        kfree(rtc);
 
 exit_idr:
+       mutex_lock(&idr_lock);
        idr_remove(&rtc_idr, id);
+       mutex_unlock(&idr_lock);
 
 exit:
        dev_err(dev, "rtc core: unable to register %s, err = %d\n",
@@ -110,20 +120,22 @@ EXPORT_SYMBOL_GPL(rtc_device_register);
  */
 void rtc_device_unregister(struct rtc_device *rtc)
 {
-       mutex_lock(&rtc->ops_lock);
-       rtc->ops = NULL;
-       mutex_unlock(&rtc->ops_lock);
-       class_device_unregister(&rtc->class_dev);
+       if (get_device(&rtc->dev) != NULL) {
+               mutex_lock(&rtc->ops_lock);
+               /* remove innards of this RTC, then disable it, before
+                * letting any rtc_class_open() users access it again
+                */
+               rtc_sysfs_del_device(rtc);
+               rtc_dev_del_device(rtc);
+               rtc_proc_del_device(rtc);
+               device_unregister(&rtc->dev);
+               rtc->ops = NULL;
+               mutex_unlock(&rtc->ops_lock);
+               put_device(&rtc->dev);
+       }
 }
 EXPORT_SYMBOL_GPL(rtc_device_unregister);
 
-int rtc_interface_register(struct class_interface *intf)
-{
-       intf->class = rtc_class;
-       return class_interface_register(intf);
-}
-EXPORT_SYMBOL_GPL(rtc_interface_register);
-
 static int __init rtc_init(void)
 {
        rtc_class = class_create(THIS_MODULE, "rtc");
@@ -131,17 +143,20 @@ static int __init rtc_init(void)
                printk(KERN_ERR "%s: couldn't create class\n", __FILE__);
                return PTR_ERR(rtc_class);
        }
+       rtc_dev_init();
+       rtc_sysfs_init(rtc_class);
        return 0;
 }
 
 static void __exit rtc_exit(void)
 {
+       rtc_dev_exit();
        class_destroy(rtc_class);
 }
 
-module_init(rtc_init);
+subsys_initcall(rtc_init);
 module_exit(rtc_exit);
 
-MODULE_AUTHOR("Alessandro Zummo <a.zummo@towerteh.it>");
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
 MODULE_DESCRIPTION("RTC class support");
 MODULE_LICENSE("GPL");