Commit | Line | Data |
---|---|---|
0c86edc0 AZ |
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 | ||
5726fb20 DB |
19 | #include "rtc-core.h" |
20 | ||
21 | ||
0c86edc0 AZ |
22 | static DEFINE_IDR(rtc_idr); |
23 | static DEFINE_MUTEX(idr_lock); | |
24 | struct class *rtc_class; | |
25 | ||
26 | static void rtc_device_release(struct class_device *class_dev) | |
27 | { | |
28 | struct rtc_device *rtc = to_rtc_device(class_dev); | |
29 | mutex_lock(&idr_lock); | |
30 | idr_remove(&rtc_idr, rtc->id); | |
31 | mutex_unlock(&idr_lock); | |
32 | kfree(rtc); | |
33 | } | |
34 | ||
35 | /** | |
36 | * rtc_device_register - register w/ RTC class | |
37 | * @dev: the device to register | |
38 | * | |
39 | * rtc_device_unregister() must be called when the class device is no | |
40 | * longer needed. | |
41 | * | |
42 | * Returns the pointer to the new struct class device. | |
43 | */ | |
44 | struct rtc_device *rtc_device_register(const char *name, struct device *dev, | |
ff8371ac | 45 | const struct rtc_class_ops *ops, |
0c86edc0 AZ |
46 | struct module *owner) |
47 | { | |
48 | struct rtc_device *rtc; | |
49 | int id, err; | |
50 | ||
51 | if (idr_pre_get(&rtc_idr, GFP_KERNEL) == 0) { | |
52 | err = -ENOMEM; | |
53 | goto exit; | |
54 | } | |
55 | ||
56 | ||
57 | mutex_lock(&idr_lock); | |
58 | err = idr_get_new(&rtc_idr, NULL, &id); | |
59 | mutex_unlock(&idr_lock); | |
60 | ||
61 | if (err < 0) | |
62 | goto exit; | |
63 | ||
64 | id = id & MAX_ID_MASK; | |
65 | ||
66 | rtc = kzalloc(sizeof(struct rtc_device), GFP_KERNEL); | |
67 | if (rtc == NULL) { | |
68 | err = -ENOMEM; | |
69 | goto exit_idr; | |
70 | } | |
71 | ||
72 | rtc->id = id; | |
73 | rtc->ops = ops; | |
74 | rtc->owner = owner; | |
110d693d | 75 | rtc->max_user_freq = 64; |
0c86edc0 AZ |
76 | rtc->class_dev.dev = dev; |
77 | rtc->class_dev.class = rtc_class; | |
78 | rtc->class_dev.release = rtc_device_release; | |
79 | ||
80 | mutex_init(&rtc->ops_lock); | |
81 | spin_lock_init(&rtc->irq_lock); | |
82 | spin_lock_init(&rtc->irq_task_lock); | |
83 | ||
84 | strlcpy(rtc->name, name, RTC_DEVICE_NAME_SIZE); | |
85 | snprintf(rtc->class_dev.class_id, BUS_ID_SIZE, "rtc%d", id); | |
86 | ||
87 | err = class_device_register(&rtc->class_dev); | |
88 | if (err) | |
89 | goto exit_kfree; | |
90 | ||
5726fb20 | 91 | rtc_dev_add_device(rtc); |
446ecbd9 | 92 | rtc_sysfs_add_device(rtc); |
5726fb20 | 93 | |
0c86edc0 AZ |
94 | dev_info(dev, "rtc core: registered %s as %s\n", |
95 | rtc->name, rtc->class_dev.class_id); | |
96 | ||
97 | return rtc; | |
98 | ||
99 | exit_kfree: | |
100 | kfree(rtc); | |
101 | ||
102 | exit_idr: | |
6ac12dfe | 103 | mutex_lock(&idr_lock); |
0c86edc0 | 104 | idr_remove(&rtc_idr, id); |
6ac12dfe | 105 | mutex_unlock(&idr_lock); |
0c86edc0 AZ |
106 | |
107 | exit: | |
d1d65b77 AZ |
108 | dev_err(dev, "rtc core: unable to register %s, err = %d\n", |
109 | name, err); | |
0c86edc0 AZ |
110 | return ERR_PTR(err); |
111 | } | |
112 | EXPORT_SYMBOL_GPL(rtc_device_register); | |
113 | ||
114 | ||
115 | /** | |
116 | * rtc_device_unregister - removes the previously registered RTC class device | |
117 | * | |
118 | * @rtc: the RTC class device to destroy | |
119 | */ | |
120 | void rtc_device_unregister(struct rtc_device *rtc) | |
121 | { | |
e109ebd1 DB |
122 | if (class_device_get(&rtc->class_dev) != NULL) { |
123 | mutex_lock(&rtc->ops_lock); | |
124 | /* remove innards of this RTC, then disable it, before | |
125 | * letting any rtc_class_open() users access it again | |
126 | */ | |
446ecbd9 | 127 | rtc_sysfs_del_device(rtc); |
5726fb20 | 128 | rtc_dev_del_device(rtc); |
e109ebd1 DB |
129 | class_device_unregister(&rtc->class_dev); |
130 | rtc->ops = NULL; | |
131 | mutex_unlock(&rtc->ops_lock); | |
132 | class_device_put(&rtc->class_dev); | |
133 | } | |
0c86edc0 AZ |
134 | } |
135 | EXPORT_SYMBOL_GPL(rtc_device_unregister); | |
136 | ||
137 | int rtc_interface_register(struct class_interface *intf) | |
138 | { | |
139 | intf->class = rtc_class; | |
140 | return class_interface_register(intf); | |
141 | } | |
142 | EXPORT_SYMBOL_GPL(rtc_interface_register); | |
143 | ||
144 | static int __init rtc_init(void) | |
145 | { | |
146 | rtc_class = class_create(THIS_MODULE, "rtc"); | |
147 | if (IS_ERR(rtc_class)) { | |
148 | printk(KERN_ERR "%s: couldn't create class\n", __FILE__); | |
149 | return PTR_ERR(rtc_class); | |
150 | } | |
5726fb20 | 151 | rtc_dev_init(); |
446ecbd9 | 152 | rtc_sysfs_init(rtc_class); |
0c86edc0 AZ |
153 | return 0; |
154 | } | |
155 | ||
156 | static void __exit rtc_exit(void) | |
157 | { | |
5726fb20 | 158 | rtc_dev_exit(); |
0c86edc0 AZ |
159 | class_destroy(rtc_class); |
160 | } | |
161 | ||
818a8674 | 162 | subsys_initcall(rtc_init); |
0c86edc0 AZ |
163 | module_exit(rtc_exit); |
164 | ||
818a8674 | 165 | MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>"); |
0c86edc0 AZ |
166 | MODULE_DESCRIPTION("RTC class support"); |
167 | MODULE_LICENSE("GPL"); |