drivers/rtc/class.c

   1 /*
   2  * RTC subsystem, base class
   3  *
   4  * Copyright (C) 2005 Tower Technologies
   5  * Author: Alessandro Zummo <a.zummo@towertech.it>
   6  *
   7  * class skeleton from drivers/hwmon/hwmon.c
   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 version 2 as
  11  * published by the Free Software Foundation.
  12 */
  13
  14 #include <linux/module.h>
  15 #include <linux/rtc.h>
  16 #include <linux/kdev_t.h>
  17 #include <linux/idr.h>
  18
  19 static DEFINE_IDR(rtc_idr);
  20 static DEFINE_MUTEX(idr_lock);
  21 struct class *rtc_class;
  22
  23 static void rtc_device_release(struct class_device *class_dev)
  24 {
  25         struct rtc_device *rtc = to_rtc_device(class_dev);
  26         mutex_lock(&idr_lock);
  27         idr_remove(&rtc_idr, rtc->id);
  28         mutex_unlock(&idr_lock);
  29         kfree(rtc);
  30 }
  31
  32 /**
  33  * rtc_device_register - register w/ RTC class
  34  * @dev: the device to register
  35  *
  36  * rtc_device_unregister() must be called when the class device is no
  37  * longer needed.
  38  *
  39  * Returns the pointer to the new struct class device.
  40  */
  41 struct rtc_device *rtc_device_register(const char *name, struct device *dev,
  42                                         struct rtc_class_ops *ops,
  43                                         struct module *owner)
  44 {
  45         struct rtc_device *rtc;
  46         int id, err;
  47
  48         if (idr_pre_get(&rtc_idr, GFP_KERNEL) == 0) {
  49                 err = -ENOMEM;
  50                 goto exit;
  51         }
  52
  53
  54         mutex_lock(&idr_lock);
  55         err = idr_get_new(&rtc_idr, NULL, &id);
  56         mutex_unlock(&idr_lock);
  57
  58         if (err < 0)
  59                 goto exit;
  60
  61         id = id & MAX_ID_MASK;
  62
  63         rtc = kzalloc(sizeof(struct rtc_device), GFP_KERNEL);
  64         if (rtc == NULL) {
  65                 err = -ENOMEM;
  66                 goto exit_idr;
  67         }
  68
  69         rtc->id = id;
  70         rtc->ops = ops;
  71         rtc->owner = owner;
  72         rtc->class_dev.dev = dev;
  73         rtc->class_dev.class = rtc_class;
  74         rtc->class_dev.release = rtc_device_release;
  75
  76         mutex_init(&rtc->ops_lock);
  77         spin_lock_init(&rtc->irq_lock);
  78         spin_lock_init(&rtc->irq_task_lock);
  79
  80         strlcpy(rtc->name, name, RTC_DEVICE_NAME_SIZE);
  81         snprintf(rtc->class_dev.class_id, BUS_ID_SIZE, "rtc%d", id);
  82
  83         err = class_device_register(&rtc->class_dev);
  84         if (err)
  85                 goto exit_kfree;
  86
  87         dev_info(dev, "rtc core: registered %s as %s\n",
  88                         rtc->name, rtc->class_dev.class_id);
  89
  90         return rtc;
  91
  92 exit_kfree:
  93         kfree(rtc);
  94
  95 exit_idr:
  96         idr_remove(&rtc_idr, id);
  97
  98 exit:
  99         dev_err(dev, "rtc core: unable to register %s, err = %d\n",
 100                         name, err);
 101         return ERR_PTR(err);
 102 }
 103 EXPORT_SYMBOL_GPL(rtc_device_register);
 104
 105
 106 /**
 107  * rtc_device_unregister - removes the previously registered RTC class device
 108  *
 109  * @rtc: the RTC class device to destroy
 110  */
 111 void rtc_device_unregister(struct rtc_device *rtc)
 112 {
 113         mutex_lock(&rtc->ops_lock);
 114         rtc->ops = NULL;
 115         mutex_unlock(&rtc->ops_lock);
 116         class_device_unregister(&rtc->class_dev);
 117 }
 118 EXPORT_SYMBOL_GPL(rtc_device_unregister);
 119
 120 int rtc_interface_register(struct class_interface *intf)
 121 {
 122         intf->class = rtc_class;
 123         return class_interface_register(intf);
 124 }
 125 EXPORT_SYMBOL_GPL(rtc_interface_register);
 126
 127 static int __init rtc_init(void)
 128 {
 129         rtc_class = class_create(THIS_MODULE, "rtc");
 130         if (IS_ERR(rtc_class)) {
 131                 printk(KERN_ERR "%s: couldn't create class\n", __FILE__);
 132                 return PTR_ERR(rtc_class);
 133         }
 134         return 0;
 135 }
 136
 137 static void __exit rtc_exit(void)
 138 {
 139         class_destroy(rtc_class);
 140 }
 141
 142 module_init(rtc_init);
 143 module_exit(rtc_exit);
 144
 145 MODULE_AUTHOR("Alessandro Zummo <a.zummo@towerteh.it>");
 146 MODULE_DESCRIPTION("RTC class support");
 147 MODULE_LICENSE("GPL");