RTC源代码分析
花了一个下午时间，把rtc代码的架构弄懂了，如下图所示：
下面附上各个包含详细注释的C文件源代码：
class.c源代码：
1 /* 2 * RTC subsystem, base class 3 * 4 * Copyright (C) 2005 Tower Technologies 5 * Author: Alessandro Zummo <[email protected]> 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 本c文件工作总结: 13 1.在init函数中: 14 (1):创建sysfs文件系统的/sys/class/rtc目录，并且初始化rtc类的相关成员 15 作用:向用户空间提供设备的信息，驱动程序不需要直接处理类 16 (2):动态分配rtc字符设备的设备号 17 (3):初始化rtc的/sys/class/rtc目录中的属性文件 18 2.在exit函数中: 19 (1):注销rtc设备号 20 (2):注销sysfs文件系统的/sys/class/rtc目录。 21 3.在rtc_device_register中 22 (1):申请一个idr整数ID管理机制结构体，并且初始化相关成员 23 (2):将设备dev关联sysfs下的rtc类 24 (3):初始化rtc结构体的信号量 25 (4):初始化rtc结构体中的中断 26 (5):设置rtc的名字 27 (6):初始化rtc字符设备的设备号，然后注册rtc设备,自动创建/dev/rtc(n)设备节点文件 28 (7):注册字符设备 29 (8):在/sys/rtc/目录下创建一个闹钟属性文件 30 (9):创建/proc/driver/rtc目录 31 4.在rtc_device_unregister中 32 (1):删除sysfs中的rtc设备,即删除/sys/class/rtc目录 33 (2):删除dev下的/dev/rtc(n)设备节点文件 34 (3):删除虚拟文件系统接口,即删除/proc/driver/rtc目录 35 (4):卸载字符设备 36 (5):清空rtc的操作函数指针rtc->ops 37 (6):释放rtc的device结构体 38 5.在rtc_device_release函数中 39 (1):卸载idr数字管理机制结构体 40 (2):释放rtc结构体的内存 41 */ 42 43 #include <linux/module.h> 44 #include <linux/rtc.h> 45 #include <linux/kdev_t.h> 46 #include <linux/idr.h> 47 48 #include "rtc-core.h" 49 static DEFINE_MUTEX 50 51 static DEFINE_IDR(rtc_idr); //定义整数ID管理机制idr结构体 52 (idr_lock); 53 struct class *rtc_class; //定义sysfs的类结构体 54 55 static void rtc_device_release(struct device *dev) 56 { 57 struct rtc_device *rtc = to_rtc_device(dev); 58 mutex_lock(&idr_lock); 59 idr_remove(&rtc_idr, rtc->id); //卸载idr数字管理机制结构体 60 mutex_unlock(&idr_lock); 61 kfree(rtc); //释放rtc结构体的内存 62 } 63 64 #if defined(CONFIG_PM) && defined(CONFIG_RTC_HCTOSYS_DEVICE) 65 66 /* 67 * On suspend(), measure the delta between one RTC and the 68 * system's wall clock; restore it on resume(). 69 */ 70 71 static struct timespec delta; 72 static time_t oldtime; 73 74 static int rtc_suspend(struct device *dev, pm_message_t mesg) 75 { 76 struct rtc_device *rtc = to_rtc_device(dev); 77 struct rtc_time tm; 78 struct timespec ts = current_kernel_time(); 79 80 if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0) 81 return 0; 82 83 rtc_read_time(rtc, &tm); 84 rtc_tm_to_time(&tm, &oldtime); 85 86 /* RTC precision is 1 second; adjust delta for avg 1/2 sec err */ 87 set_normalized_timespec(&delta, 88 ts.tv_sec - oldtime, 89 ts.tv_nsec - (NSEC_PER_SEC >> 1)); 90 91 return 0; 92 } 93 94 static int rtc_resume(struct device *dev) 95 { 96 struct rtc_device *rtc = to_rtc_device(dev); 97 struct rtc_time tm; 98 time_t newtime; 99 struct timespec time; 100 101 if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0) 102 return 0; 103 104 rtc_read_time(rtc, &tm); 105 if (rtc_valid_tm(&tm) != 0) { 106 pr_debug("%s: bogus resume time\n", dev_name(&rtc->dev)); 107 return 0; 108 } 109 rtc_tm_to_time(&tm, &newtime); 110 if (newtime <= oldtime) { 111 if (newtime < oldtime) 112 pr_debug("%s: time travel!\n", dev_name(&rtc->dev)); 113 return 0; 114 } 115 116 /* restore wall clock using delta against this RTC; 117 * adjust again for avg 1/2 second RTC sampling error 118 */ 119 set_normalized_timespec(&time, 120 newtime + delta.tv_sec, 121 (NSEC_PER_SEC >> 1) + delta.tv_nsec); 122 do_settimeofday(&time); 123 124 return 0; 125 } 126 127 #else 128 #define rtc_suspend NULL 129 #define rtc_resume NULL 130 #endif 131 132 133 /** 134 * rtc_device_register - register w/ RTC class 135 * @dev: the device to register 136 * 137 * rtc_device_unregister() must be called when the class device is no 138 * longer needed. 139 * 140 * Returns the pointer to the new struct class device. 141 */ 142 struct rtc_device *rtc_device_register(const char *name, struct device *dev, 143 const struct rtc_class_ops *ops, 144 struct module *owner) 145 { 146 struct rtc_device *rtc; 147 int id, err; 148 //整数ID管理机制 149 if (idr_pre_get(&rtc_idr, GFP_KERNEL) == 0) { //检测IDR是否能正常获取 150 err = -ENOMEM; 151 goto exit; 152 } 153 154 155 mutex_lock(&idr_lock); //原子操作，上锁，防止被打断 156 err = idr_get_new(&rtc_idr, NULL, &id); //获取一个idr结构，并与id相关联 157 mutex_unlock(&idr_lock); //解锁 158 159 if (err < 0) 160 goto exit; 161 162 id = id & MAX_ID_MASK; //将32为id的无效高位清零 163 164 rtc = kzalloc(sizeof(struct rtc_device), GFP_KERNEL); //分配一个rtc_device结构体 165 if (rtc == NULL) { 166 err = -ENOMEM; 167 goto exit_idr; 168 } 169 170 rtc->id = id; //整数ID管理机制 171 rtc->ops = ops; //关联定义的操作函数结构体 open,release,ioctl等函数 172 rtc->owner = owner; //所属模块的相关信息 173 rtc->max_user_freq = 64; //最大使用数量 64 174 rtc->dev.parent = dev; //父设备 175 rtc->dev.class = rtc_class; //包含的sysfs下面的类 176 rtc->dev.release = rtc_device_release; //释放函数 177 178 mutex_init(&rtc->ops_lock); //初始化信号量 179 spin_lock_init(&rtc->irq_lock); 180 spin_lock_init(&rtc->irq_task_lock); 181 init_waitqueue_head(&rtc->irq_queue); //定义rtc中断 182 183 strlcpy(rtc->name, name, RTC_DEVICE_NAME_SIZE); //设置rtc的名字 184 dev_set_name(&rtc->dev, "rtc%d", id); 185 186 rtc_dev_prepare(rtc); //初始化rtc字符设备的设备号 187 188 err = device_register(&rtc->dev); //注册rtc设备，这样rtc会自动创建设备文件rtc(n) 189 if (err) 190 goto exit_kfree; 191 192 rtc_dev_add_device(rtc); //注册字符设备 193 rtc_sysfs_add_device(rtc); //为设备添加一个闹钟属性，在/sys/rtc下面创建闹钟属性文件 194 rtc_proc_add_device(rtc); //穿件proc文件结构体 在/proc目录下创建 driver/rtc 195 196 dev_info(dev, "rtc core: registered %s as %s\n", 197 rtc->name, dev_name(&rtc->dev)); //打印信息 198 199 return rtc; 200 201 exit_kfree: 202 kfree(rtc); 203 204 exit_idr: 205 mutex_lock(&idr_lock); 206 idr_remove(&rtc_idr, id); 207 mutex_unlock(&idr_lock); 208 209 exit: 210 dev_err(dev, "rtc core: unable to register %s, err = %d\n", 211 name, err); 212 return ERR_PTR(err); 213 } 214 EXPORT_SYMBOL_GPL(rtc_device_register); 215 216 217 /** 218 * rtc_device_unregister - removes the previously registered RTC class device 219 * 220 * @rtc: the RTC class device to destroy 221 */ 222 void rtc_device_unregister(struct rtc_device *rtc) 223 { 224 if (get_device(&rtc->dev) != NULL) { 225 mutex_lock(&rtc->ops_lock); //上锁 226 /* remove innards of this RTC, then disable it, before 227 * letting any rtc_class_open() users access it again 228 */ 229 rtc_sysfs_del_device(rtc); //删除sysfs下面的rtc设备 230 rtc_dev_del_device(rtc); //删除dev下的rtc 231 rtc_proc_del_device(rtc); //删除虚拟文件系统接口 232 device_unregister(&rtc->dev); //卸载字符设备 233 rtc->ops = NULL; //将rtc的操作函数指针清空 234 mutex_unlock(&rtc->ops_lock); //解锁 235 put_device(&rtc->dev); //释放rtc的device结构体 236 } 237 } 238 EXPORT_SYMBOL_GPL(rtc_device_unregister); 239 240 static int __init rtc_init(void) 241 { 242 rtc_class = class_create(THIS_MODULE, "rtc");//在/sys/class下面创建类目录,类名为rtc 243 if (IS_ERR(rtc_class)) { 244 printk(KERN_ERR "%s: couldn't create class\n", __FILE__); 245 return PTR_ERR(rtc_class); 246 } 247 //类的作用就是向用户空间提供设备的信息，驱动程序不需要直接处理类 248 rtc_class->suspend = rtc_suspend; //初始化类结构体的相关成员 249 rtc_class->resume = rtc_resume; //动态分配rtc的设备号 250 rtc_dev_init(); //动态分配 251 rtc_sysfs_init(rtc_class); //初始化rtc的属性文件 252 return 0; 253 } 254 255 static void __exit rtc_exit(void) 256 { 257 rtc_dev_exit(); //注销rtc设备号 258 class_destroy(rtc_class); //注销/sys/class下的类目录 259 } 260 261 subsys_initcall(rtc_init); 262 module_exit(rtc_exit); 263 264 MODULE_AUTHOR("Alessandro Zummo <[email protected]>"); 265 MODULE_DESCRIPTION("RTC class support"); 266 MODULE_LICENSE("GPL");
rtc-dev.c源代码：
1 /* 2 * RTC subsystem, dev interface 3 * 4 * Copyright (C) 2005 Tower Technologies 5 * Author: Alessandro Zummo <[email protected]> 6 * 7 * based on arch/arm/common/rtctime.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 1.在init函数中动态的申请字符设备的设备号 15 2.实现struct file_operations rtc_dev_fops 结构体及其默认函数 16 3.在exit中注销字符设备设备号 17 */ 18 19 #include <linux/module.h> 20 #include <linux/rtc.h> 21 #include "rtc-core.h" 22 23 static dev_t rtc_devt; 24 25 #define RTC_DEV_MAX 16 /* 16 RTCs should be enough for everyone... */ 26 27 static int rtc_dev_open(struct inode *inode, struct file *file) 28 { 29 int err; 30 struct rtc_device *rtc = container_of(inode->i_cdev, 31 struct rtc_device, char_dev); 32 const struct rtc_class_ops *ops = rtc->ops; 33 34 if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags)) 35 return -EBUSY; 36 37 file->private_data = rtc; 38 39 err = ops->open ? ops->open(rtc->dev.parent) : 0; 40 if (err == 0) { 41 spin_lock_irq(&rtc->irq_lock); 42 rtc->irq_data = 0; 43 spin_unlock_irq(&rtc->irq_lock); 44 45 return 0; 46 } 47 48 /* something has gone wrong */ 49 clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags); 50 return err; 51 } 52 53 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL 54 /* 55 * Routine to poll RTC seconds field for change as often as possible, 56 * after first RTC_UIE use timer to reduce polling 57 */ 58 static void rtc_uie_task(struct work_struct *work) 59 { 60 struct rtc_device *rtc = 61 container_of(work, struct rtc_device, uie_task); 62 struct rtc_time tm; 63 int num = 0; 64 int err; 65 66 err = rtc_read_time(rtc, &tm); 67 68 spin_lock_irq(&rtc->irq_lock); 69 if (rtc->stop_uie_polling || err) { 70 rtc->uie_task_active = 0; 71 } else if (rtc->oldsecs != tm.tm_sec) { 72 num = (tm.tm_sec + 60 - rtc->oldsecs) % 60; 73 rtc->oldsecs = tm.tm_sec; 74 rtc->uie_timer.expires = jiffies + HZ - (HZ/10); 75 rtc->uie_timer_active = 1; 76 rtc->uie_task_active = 0; 77 add_timer(&rtc->uie_timer); 78 } else if (schedule_work(&rtc->uie_task) == 0) { 79 rtc->uie_task_active = 0; 80 } 81 spin_unlock_irq(&rtc->irq_lock); 82 if (num) 83 rtc_update_irq(rtc, num, RTC_UF | RTC_IRQF); 84 } 85 static void rtc_uie_timer(unsigned long data) 86 { 87 struct rtc_device *rtc = (struct rtc_device *)data; 88 unsigned long flags; 89 90 spin_lock_irqsave(&rtc->irq_lock, flags); 91 rtc->uie_timer_active = 0; 92 rtc->uie_task_active = 1; 93 if ((schedule_work(&rtc->uie_task) == 0)) 94 rtc->uie_task_active = 0; 95 spin_unlock_irqrestore(&rtc->irq_lock, flags); 96 } 97 98 static int clear_uie(struct rtc_device *rtc) 99 { 100 spin_lock_irq(&rtc->irq_lock); 101 if (rtc->uie_irq_active) { 102 rtc->stop_uie_polling = 1; 103 if (rtc->uie_timer_active) { 104 spin_unlock_irq(&rtc->irq_lock); 105 del_timer_sync(&rtc->uie_timer); 106 spin_lock_irq(&rtc->irq_lock); 107 rtc->uie_timer_active = 0; 108 } 109 if (rtc->uie_task_active) { 110 spin_unlock_irq(&rtc->irq_lock); 111 flush_scheduled_work(); 112 spin_lock_irq(&rtc->irq_lock); 113 } 114 rtc->uie_irq_active = 0; 115 } 116 spin_unlock_irq(&rtc->irq_lock); 117 return 0; 118 } 119 120 static int set_uie(struct rtc_device *rtc) 121 { 122 struct rtc_time tm; 123 int err; 124 125 err = rtc_read_time(rtc, &tm); 126 if (err) 127 return err; 128 spin_lock_irq(&rtc->irq_lock); 129 if (!rtc->uie_irq_active) { 130 rtc->uie_irq_active = 1; 131 rtc->stop_uie_polling = 0; 132 rtc->oldsecs = tm.tm_sec; 133 rtc->uie_task_active = 1; 134 if (schedule_work(&rtc->uie_task) == 0) 135 rtc->uie_task_active = 0; 136 } 137 rtc->irq_data = 0; 138 spin_unlock_irq(&rtc->irq_lock); 139 return 0; 140 } 141 142 int rtc_dev_update_irq_enable_emul(struct rtc_device *rtc, unsigned int enabled) 143 { 144 if (enabled) 145 return set_uie(rtc); 146 else 147 return clear_uie(rtc); 148 } 149 EXPORT_SYMBOL(rtc_dev_update_irq_enable_emul); 150 151 #endif /* CONFIG_RTC_INTF_DEV_UIE_EMUL */ 152 153 static ssize_t 154 rtc_dev_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) 155 { 156 struct rtc_device *rtc = file->private_data; 157 158 DECLARE_WAITQUEUE(wait, current); //声明一个等待队列入口 159 unsigned long data; 160 ssize_t ret; 161 162 if (count != sizeof(unsigned int) && count < sizeof(unsigned long)) 163 return -EINVAL; 164 165 add_wait_queue(&rtc->irq_queue, &wait);//将这个等待队列的入口加入到rtc的irq等待队列中 166 do { 167 __set_current_state(TASK_INTERRUPTIBLE);//把当前进程的状态修改为TASK_INTERRUPTIBLE 168 169 spin_lock_irq(&rtc->irq_lock); //保护代码段不被抢占（禁止 IRQ 同时也就隐式地禁止了抢占），既禁止本地中断，又禁止内核抢占。 170 data = rtc->irq_data; 171 rtc->irq_data = 0; 172 spin_unlock_irq(&rtc->irq_lock); 173 174 if (data != 0) { //如果数据不是零的话说明发生过一次中断 175 ret = 0; 176 break; 177 } 178 if (file->f_flags & O_NONBLOCK) { //如果打开方式为不阻塞的话，直接返回 179 ret = -EAGAIN; 180 break; 181 } 182 if (signal_pending(current)) { //检查当前进程是否有信号处理，返回不为0表示有信号需要处理。 183 ret = -ERESTARTSYS; 184 break; 185 } 186 schedule(); //如果没有发生过中断，并且也没有信号处理，则调度 187 } while (1); 188 set_current_state(TASK_RUNNING);//把当前进程的状态修改为TASK_RUNNING 189 190 remove_wait_queue(&rtc->irq_queue, &wait); //移除等待队列 191 192 if (ret == 0) { //如果发生过中断 193 /* Check for any data updates */ 194 if (rtc->ops->read_callback) 195 data = rtc->ops->read_callback(rtc->dev.parent, 196 data); 197 198 if (sizeof(int) != sizeof(long) && 199 count == sizeof(unsigned int)) 200 ret = put_user(data, (unsigned int __user *)buf) ?: 201 sizeof(unsigned int); 202 else 203 ret = put_user(data, (unsigned long __user *)buf) ?: 204 sizeof(unsigned long); 205 } 206 return ret; 207 } 208 209 static unsigned int rtc_dev_poll(struct file *file, poll_table *wait) 210 { 211 struct rtc_device *rtc = file->private_data; 212 unsigned long data; 213 214 poll_wait(file, &rtc->irq_queue, wait); //监控文件，加入等待队列 215 216 data = rtc->irq_data; 217 218 return (data != 0) ? (POLLIN | POLLRDNORM) : 0; 219 } 220 221 static long rtc_dev_ioctl(struct file *file, 222 unsigned int cmd, unsigned long arg) 223 { 224 int err = 0; 225 struct rtc_device *rtc = file->private_data; 226 const struct rtc_class_ops *ops = rtc->ops; 227 struct rtc_time tm; 228 struct rtc_wkalrm alarm; 229 void __user *uarg = (void __user *) arg; 230 231 err = mutex_lock_interruptible(&rtc->ops_lock); 232 if (err) 233 return err; 234 235 /* check that the calling task has appropriate permissions 236 * for certain ioctls. doing this check here is useful 237 * to avoid duplicate code in each driver. 238 */ 239 switch (cmd) { 240 case RTC_EPOCH_SET: 241 case RTC_SET_TIME: 242 if (!capable(CAP_SYS_TIME)) 243 err = -EACCES; 244 break; 245 246 case RTC_IRQP_SET: 247 if (arg > rtc->max_user_freq && !capable(CAP_SYS_RESOURCE)) 248 err = -EACCES; 249 break; 250 251 case RTC_PIE_ON: 252 if (rtc->irq_freq > rtc->max_user_freq && 253 !capable(CAP_SYS_RESOURCE)) 254 err = -EACCES; 255 break; 256 } 257 258 if (err) 259 goto done; 260 261 /* try the driver's ioctl interface */ 262 if (ops->ioctl) { 263 err = ops->ioctl(rtc->dev.parent, cmd, arg); 264 if (err != -ENOIOCTLCMD) { 265 mutex_unlock(&rtc->ops_lock); 266 return err; 267 } 268 } 269 270 /* if the driver does not provide the ioctl interface 271 * or if that particular ioctl was not implemented 272 * (-ENOIOCTLCMD), we will try to emulate here. 273 * 274 * Drivers *SHOULD NOT* provide ioctl implementations 275 * for these requests. Instead, provide methods to 276 * support the following code, so that the RTC's main 277 * features are accessible without using ioctls. 278 * 279 * RTC and alarm times will be in UTC, by preference, 280 * but dual-booting with MS-Windows implies RTCs must 281 * use the local wall clock time. 282 */ 283 284 switch (cmd) { 285 case RTC_ALM_READ: 286 mutex_unlock(&rtc->ops_lock); 287 288 err = rtc_read_alarm(rtc, &alarm); 289 if (err < 0) 290 return err; 291 292 if (copy_to_user(uarg, &alarm.time, sizeof(tm))) 293 err = -EFAULT; 294 return err; 295 296 case RTC_ALM_SET: 297 mutex_unlock(&rtc->ops_lock); 298 299 if (copy_from_user(&alarm.time, uarg, sizeof(tm))) 300 return -EFAULT; 301 302 alarm.enabled = 0; 303 alarm.pending = 0; 304 alarm.time.tm_wday = -1; 305 alarm.time.tm_yday = -1; 306 alarm.time.tm_isdst = -1; 307 308 /* RTC_ALM_SET alarms may be up to 24 hours in the future. 309 * Rather than expecting every RTC to implement "don't care" 310 * for day/month/year fields, just force the alarm to have 311 * the right values for those fields. 312 * 313 * RTC_WKALM_SET should be used instead. Not only does it 314 * eliminate the need for a separate RTC_AIE_ON call, it 315 * doesn't have the "alarm 23:59:59 in the future" race. 316 * 317 * NOTE: some legacy code may have used invalid fields as 318 * wildcards, exposing hardware "periodic alarm" capabilities. 319 * Not supported here. 320 */ 321 { 322 unsigned long now, then; 323 324 err = rtc_read_time(rtc, &tm); 325 if (err < 0) 326 return err; 327 rtc_tm_to_time(&tm, &now); 328 329 alarm.time.tm_mday = tm.tm_mday; 330 alarm.time.tm_mon = tm.tm_mon; 331 alarm.time.tm_year = tm.tm_year; 332 err = rtc_valid_tm(&alarm.time); 333 if (err < 0) 334 return err; 335 rtc_tm_to_time(&alarm.time, &then); 336 337 /* alarm may need to wrap into tomorrow */ 338 if (then < now) { 339 rtc_time_to_tm(now + 24 * 60 * 60, &tm); 340 alarm.time.tm_mday = tm.tm_mday; 341 alarm.time.tm_mon = tm.tm_mon; 342 alarm.time.tm_year = tm.tm_year; 343 } 344 } 345 346 return rtc_set_alarm(rtc, &alarm); 347 348 case RTC_RD_TIME: 349 mutex_unlock(&rtc->ops_lock); 350 351 err = rtc_read_time(rtc, &tm); 352 if (err < 0) 353 return err; 354 355 if (copy_to_user(uarg, &tm, sizeof(tm))) 356 err = -EFAULT; 357 return err; 358 359 case RTC_SET_TIME: 360 mutex_unlock(&rtc->ops_lock); 361 362 if (copy_from_user(&tm, uarg, sizeof(tm))) 363 return -EFAULT; 364 365 return rtc_set_time(rtc, &tm); 366 367 case RTC_PIE_ON: 368 err = rtc_irq_set_state(rtc, NULL, 1); 369 break; 370 371 case RTC_PIE_OFF: 372 err = rtc_irq_set_state(rtc, NULL, 0); 373 break; 374 375 case RTC_AIE_ON: 376 mutex_unlock(&rtc->ops_lock); 377 return rtc_alarm_irq_enable(rtc, 1); 378 379 case RTC_AIE_OFF: 380 mutex_unlock(&rtc->ops_lock); 381 return rtc_alarm_irq_enable(rtc, 0); 382 383 case RTC_UIE_ON: 384 mutex_unlock(&rtc->ops_lock); 385 return rtc_update_irq_enable(rtc, 1); 386 387 case RTC_UIE_OFF: 388 mutex_unlock(&rtc->ops_lock); 389 return rtc_update_irq_enable(rtc, 0); 390 391 case RTC_IRQP_SET: 392 err = rtc_irq_set_freq(rtc, NULL, arg); 393 break; 394 395 case RTC_IRQP_READ: 396 err = put_user(rtc->irq_freq, (unsigned long __user *)uarg); 397 break; 398 399 #if 0 400 case RTC_EPOCH_SET: 401 #ifndef rtc_epoch 402 /* 403 * There were no RTC clocks before 1900. 404 */ 405 if (arg < 1900) { 406 err = -EINVAL; 407 break; 408 } 409 rtc_epoch = arg; 410 err = 0; 411 #endif 412 break; 413 414 case RTC_EPOCH_READ: 415 err = put_user(rtc_epoch, (unsigned long __user *)uarg); 416 break; 417 #endif 418 case RTC_WKALM_SET: 419 mutex_unlock(&rtc->ops_lock); 420 if (copy_from_user(&alarm, uarg, sizeof(alarm))) 421 return -EFAULT; 422 423 return rtc_set_alarm(rtc, &alarm); 424 425 case RTC_WKALM_RD: 426 mutex_unlock(&rtc->ops_lock); 427 err = rtc_read_alarm(rtc, &alarm); 428 if (err < 0) 429 return err; 430 431 if (copy_to_user(uarg, &alarm, sizeof(alarm))) 432 err = -EFAULT; 433 return err; 434 435 default: 436 err = -ENOTTY; 437 break; 438 } 439 440 done: 441 mutex_unlock(&rtc->ops_lock); 442 return err; 443 } 444 445 static int rtc_dev_fasync(int fd, struct file *file, int on) 446 { 447 struct rtc_device *rtc = file->private_data; 448 return fasync_helper(fd, file, on, &rtc->async_queue); 449 } 450 451 static int rtc_dev_release(struct inode *inode, struct file *file) 452 { 453 struct rtc_device *rtc = file->private_data; 454 455 /* We shut down the repeating IRQs that userspace enabled, 456 * since nothing is listening to them. 457 * - Update (UIE) ... currently only managed through ioctls 458 * - Periodic (PIE) ... also used through rtc_*() interface calls 459 * 460 * Leave the alarm alone; it may be set to trigger a system wakeup 461 * later, or be used by kernel code, and is a one-shot event anyway. 462 */ 463 464 /* Keep ioctl until all drivers are converted */ 465 rtc_dev_ioctl(file, RTC_UIE_OFF, 0); 466 rtc_update_irq_enable(rtc, 0); 467 rtc_irq_set_state(rtc, NULL, 0); 468 469 if (rtc->ops->release) 470 rtc->ops->release(rtc->dev.parent); 471 472 clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags); 473 return 0; 474 } 475 476 static const struct file_operations rtc_dev_fops = { 477 .owner = THIS_MODULE, 478 .llseek = no_llseek, 479 .read = rtc_dev_read, 480 .poll = rtc_dev_poll, 481 .unlocked_ioctl = rtc_dev_ioctl, 482 .open = rtc_dev_open, 483 .release = rtc_dev_release, 484 .fasync = rtc_dev_fasync, 485 }; 486 487 /* insertion/removal hooks */ 488 489 void rtc_dev_prepare(struct rtc_device *rtc) 490 { 491 if (!rtc_devt) 492 return; 493 494 if (rtc->id >= RTC_DEV_MAX) { 495 pr_debug("%s: too many RTC devices\n", rtc->name); 496 return; 497 } 498 499 rtc->dev.devt = MKDEV(MAJOR(rtc_devt), rtc->id); //获取rtc的设备号 500 501 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL 502 INIT_WORK(&rtc->uie_task, rtc_uie_task); 503 setup_timer(&rtc->uie_timer, rtc_uie_timer, (unsigned long)rtc); 504 #endif 505 506 cdev_init(&rtc->char_dev, &rtc_dev_fops); 507 rtc->char_dev.owner = rtc->owner; 508 } 509 510 void rtc_dev_add_device(struct rtc_device *rtc) 511 { 512 if (cdev_add(&rtc->char_dev, rtc->dev.devt, 1)) 513 printk(KERN_WARNING "%s: failed to add char device %d:%d\n", 514 rtc->name, MAJOR(rtc_devt), rtc->id); 515 else 516 pr_debug("%s: dev (%d:%d)\n", rtc->name, 517 MAJOR(rtc_devt), rtc->id); 518 } 519 520 void rtc_dev_del_device(struct rtc_device *rtc) 521 { 522 if (rtc->dev.devt) 523 cdev_del(&rtc->char_dev); 524 } 525 526 void __init rtc_dev_init(void) 527 { 528 int err; 529 530 err = alloc_chrdev_region(&rtc_devt, 0, RTC_DEV_MAX, "rtc"); //动态分配rtc的设备号 531 if (err < 0) 532 printk(KERN_ERR "%s: failed to allocate char dev region\n", 533 __FILE__); 534 } 535 536 void __exit rtc_dev_exit(void) 537 { 538 if (rtc_devt) 539 unregister_chrdev_region(rtc_devt, RTC_DEV_MAX); //注销设备号 540 }
interface.c源代码：
1 /* 2 * RTC subsystem, interface functions 3 * 4 * Copyright (C) 2005 Tower Technologies 5 * Author: Alessandro Zummo <[email protected]> 6 * 7 * based on arch/arm/common/rtctime.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 本函数中主要就是实现 前面我们rtc-dev.c中ioctl的各种命令函数 14 RTC_ALM_READ rtc_read_alarm 读取闹钟时间 15 RTC_ALM_SET rtc_set_alarm 设置闹钟时间 16 RTC_RD_TIME rtc_read_time 读取时间与日期 17 RTC_SET_TIME rtc_set_time 设置时间与日期 18 RTC_PIE_ON RTC_PIE_OFF rtc_irq_set_state 开关RTC全局中断的函数 19 RTC_AIE_ON RTC_AIE_OFF rtc_alarm_irq_enable 使能禁止RTC闹钟中断 20 RTC_UIE_OFF RTC_UIE_ON rtc_update_irq_enable 使能禁止RTC更新中断 21 RTC_IRQP_SET rtc_irq_set_freq 设置中断的频率 22 23 */ 24 25 #include <linux/rtc.h> 26 #include <linux/log2.h> 27 28 int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm) 29 { 30 int err; 31 32 err = mutex_lock_interruptible(&rtc->ops_lock); //上锁，用了一个信号来保证在同一时刻只有一个进程可以获取时间 33 if (err) 34 return err; 35 36 if (!rtc->ops) //如果rtc的ops结构体为空，则直接返回 37 err = -ENODEV; 38 else if (!rtc->ops->read_time) //如果未定义ops的read_time函数，直接返回 39 err = -EINVAL; 40 else { 41 memset(tm, 0, sizeof(struct rtc_time)); //将内存清零，清空tm结构体 42 err = rtc->ops->read_time(rtc->dev.parent, tm);//读取时间 43 } 44 45 mutex_unlock(&rtc->ops_lock);//解锁 46 return err; 47 } 48 EXPORT_SYMBOL_GPL(rtc_read_time); 49 50 int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm) 51 { 52 int err; 53 54 err = rtc_valid_tm(tm); 55 if (err != 0) 56 return err; 57 58 err = mutex_lock_interruptible(&rtc->ops_lock); 59 if (err) 60 return err; 61 62 if (!rtc->ops) 63 err = -ENODEV; 64 else if (rtc->ops->set_time) 65 err = rtc->ops->set_time(rtc->dev.parent, tm); 66 else if (rtc->ops->set_mmss) { 67 unsigned long secs; 68 err = rtc_tm_to_time(tm, &secs); 69 if (err == 0) 70 err = rtc->ops->set_mmss(rtc->dev.parent, secs); 71 } else 72 err = -EINVAL; 73 74 mutex_unlock(&rtc->ops_lock); 75 return err; 76 } 77 EXPORT_SYMBOL_GPL(rtc_set_time); 78 79 int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs) 80 { 81 int err; 82 83 err = mutex_lock_interruptible(&rtc->ops_lock); 84 if (err) 85 return err; 86 87 if (!rtc->ops) 88 err = -ENODEV; 89 else if (rtc->ops->set_mmss) 90 err = rtc->ops->set_mmss(rtc->dev.parent, secs); 91 else if (rtc->ops->read_time && rtc->ops->set_time) { 92 struct rtc_time new, old; 93 94 err = rtc->ops->read_time(rtc->dev.parent, &old); 95 if (err == 0) { 96 rtc_time_to_tm(secs, &new); 97 98 /* 99 * avoid writing when we're going to change the day of 100 * the month. We will retry in the next minute. This 101 * basically means that if the RTC must not drift 102 * by more than 1 minute in 11 minutes. 103 */ 104 if (!((old.tm_hour == 23 && old.tm_min == 59) || 105 (new.tm_hour == 23 && new.tm_min == 59))) 106 err = rtc->ops->set_time(rtc->dev.parent, 107 &new); 108 } 109 } 110 else 111 err = -EINVAL; 112 113 mutex_unlock(&rtc->ops_lock); 114 115 return err; 116 } 117 EXPORT_SYMBOL_GPL(rtc_set_mmss); 118 119 static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 120 { 121 int err; 122 123 err = mutex_lock_interruptible(&rtc->ops_lock); 124 if (err) 125 return err; 126 127 if (rtc->ops == NULL) 128 err = -ENODEV; 129 else if (!rtc->ops->read_alarm) 130 err = -EINVAL; 131 else { 132 memset(alarm, 0, sizeof(struct rtc_wkalrm)); 133 err = rtc->ops->read_alarm(rtc->dev.parent, alarm); 134 } 135 136 mutex_unlock(&rtc->ops_lock); 137 return err; 138 } 139 140 int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 141 { 142 int err; 143 struct rtc_time before, now; 144 int first_time = 1; 145 unsigned long t_now, t_alm; 146 enum { none, day, month, year } missing = none; 147 unsigned days; 148 149 /* The lower level RTC driver may return -1 in some fields, 150 * creating invalid alarm->time values, for reasons like: 151 * 152 * - The hardware may not be capable of filling them in; 153 * many alarms match only on time-of-day fields, not 154 * day/month/year calendar data. 155 * 156 * - Some hardware uses illegal values as "wildcard" match 157 * values, which non-Linux firmware (like a BIOS) may try 158 * to set up as e.g. "alarm 15 minutes after each hour". 159 * Linux uses only oneshot alarms. 160 * 161 * When we see that here, we deal with it by using values from 162 * a current RTC timestamp for any missing (-1) values. The 163 * RTC driver prevents "periodic alarm" modes. 164 * 165 * But this can be racey, because some fields of the RTC timestamp 166 * may have wrapped in the interval since we read the RTC alarm, 167 * which would lead to us inserting inconsistent values in place 168 * of the -1 fields. 169 * 170 * Reading the alarm and timestamp in the reverse sequence 171 * would have the same race condition, and not solve the issue. 172 * 173 * So, we must first read the RTC timestamp, 174 * then read the RTC alarm value, 175 * and then read a second RTC timestamp. 176 * 177 * If any fields of the second timestamp have changed 178 * when compared with the first timestamp, then we know 179 * our timestamp may be inconsistent with that used by 180 * the low-level rtc_read_alarm_internal() function. 181 * 182 * So, when the two timestamps disagree, we just loop and do 183 * the process again to get a fully consistent set of values. 184 * 185 * This could all instead be done in the lower level driver, 186 * but since more than one lower level RTC implementation needs it, 187 * then it's probably best best to do it here instead of there.. 188 */ 189 190 /* Get the "before" timestamp */ 191 err = rtc_read_time(rtc, &before); 192 if (err < 0) 193 return err; 194 do { 195 if (!first_time) 196 memcpy(&before, &now, sizeof(struct rtc_time)); 197 first_time = 0; 198 199 /* get the RTC alarm values, which may be incomplete */ 200 err = rtc_read_alarm_internal(rtc, alarm); 201 if (err) 202 return err; 203 if (!alarm->enabled) 204 return 0; 205 206 /* full-function RTCs won't have such missing fields */ 207 if (rtc_valid_tm(&alarm->time) == 0) 208 return 0; 209 210 /* get the "after" timestamp, to detect wrapped fields */ 211 err = rtc_read_time(rtc, &now); 212 if (err < 0) 213 return err; 214 215 /* note that tm_sec is a "don't care" value here: */ 216 } while ( before.tm_min != now.tm_min 217 || before.tm_hour != now.tm_hour 218 || before.tm_mon != now.tm_mon 219 || before.tm_year != now.tm_year); 220 221 /* Fill in the missing alarm fields using the timestamp; we 222 * know there's at least one since alarm->time is invalid. 223 */ 224 if (alarm->time.tm_sec == -1) 225 alarm->time.tm_sec = now.tm_sec; 226 if (alarm->time.tm_min == -1) 227 alarm->time.tm_min = now.tm_min; 228 if (alarm->time.tm_hour == -1) 229 alarm->time.tm_hour = now.tm_hour; 230 231 /* For simplicity, only support date rollover for now */ 232 if (alarm->time.tm_mday == -1) { 233 alarm->time.tm_mday = now.tm_mday; 234 missing = day; 235 } 236 if (alarm->time.tm_mon == -1) { 237 alarm->time.tm_mon = now.tm_mon; 238 if (missing == none) 239 missing = month; 240 } 241 if (alarm->time.tm_year == -1) { 242 alarm->time.tm_year = now.tm_year; 243 if (missing == none) 244 missing = year; 245 } 246 247 /* with luck, no rollover is needed */ 248 rtc_tm_to_time(&now, &t_now); 249 rtc_tm_to_time(&alarm->time, &t_alm); 250 if (t_now < t_alm) 251 goto done; 252 253 switch (missing) { 254 255 /* 24 hour rollover ... if it's now 10am Monday, an alarm that 256 * that will trigger at 5am will do so at 5am Tuesday, which 257 * could also be in the next month or year. This is a common 258 * case, especially for PCs. 259 */ 260 case day: 261 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "day"); 262 t_alm += 24 * 60 * 60; 263 rtc_time_to_tm(t_alm, &alarm->time); 264 break; 265 266 /* Month rollover ... if it's the 31th, an alarm on the 3rd will 267 * be next month. An alarm matching on the 30th, 29th, or 28th 268 * may end up in the month after that! Many newer PCs support 269 * this type of alarm. 270 */ 271 case month: 272 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "month"); 273 do { 274 if (alarm->time.tm_mon < 11) 275 alarm->time.tm_mon++; 276 else { 277 alarm->time.tm_mon = 0; 278 alarm->time.tm_year++; 279 } 280 days = rtc_month_days(alarm->time.tm_mon, 281 alarm->time.tm_year); 282 } while (days < alarm->time.tm_mday); 283 break; 284 285 /* Year rollover ... easy except for leap years! */ 286 case year: 287 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "year"); 288 do { 289 alarm->time.tm_year++; 290 } while (rtc_valid_tm(&alarm->time) != 0); 291 break; 292 293 default: 294 dev_warn(&rtc->dev, "alarm rollover not handled\n"); 295 } 296 297 done: 298 return 0; 299 } 300 EXPORT_SYMBOL_GPL(rtc_read_alarm); 301 302 int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm) 303 { 304 int err; 305 306 err = rtc_valid_tm(&alarm->time); 307 if (err != 0) 308 return err; 309 310 err = mutex_lock_interruptible(&rtc->ops_lock); 311 if (err) 312 return err; 313 314 if (!rtc->ops) 315 err = -ENODEV; 316 else if (!rtc->ops->set_alarm) 317 err = -EINVAL; 318 else 319 err = rtc->ops->set_alarm(rtc->dev.parent, alarm); 320 321 mutex_unlock(&rtc->ops_lock); 322 return err; 323 } 324 EXPORT_SYMBOL_GPL(rtc_set_alarm); 325 326 int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled) 327 { 328 int err = mutex_lock_interruptible(&rtc->ops_lock); 329 if (err) 330 return err; 331 332 if (!rtc->ops) 333 err = -ENODEV; 334 else if (!rtc->ops->alarm_irq_enable) 335 err = -EINVAL; 336 else 337 err = rtc->ops->alarm_irq_enable(rtc->dev.parent, enabled); 338 339 mutex_unlock(&rtc->ops_lock); 340 return err; 341 } 342 EXPORT_SYMBOL_GPL(rtc_alarm_irq_enable); 343 344 int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled) 345 { 346 int err = mutex_lock_interruptible(&rtc->ops_lock); 347 if (err) 348 return err; 349 350 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL 351 if (enabled == 0 && rtc->uie_irq_active) { 352 mutex_unlock(&rtc->ops_lock); 353 return rtc_dev_update_irq_enable_emul(rtc, enabled); 354 } 355 #endif 356 357 if (!rtc->ops) 358 err = -ENODEV; 359 else if (!rtc->ops->update_irq_enable) 360 err = -EINVAL; 361 else 362 err = rtc->ops->update_irq_enable(rtc->dev.parent, enabled); 363 364 mutex_unlock(&rtc->ops_lock); 365 366 #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL 367 /* 368 * Enable emulation if the driver did not provide 369 * the update_irq_enable function pointer or if returned 370 * -EINVAL to signal that it has been configured without 371 * interrupts or that are not available at the moment. 372 */ 373 if (err == -EINVAL) 374 err = rtc_dev_update_irq_enable_emul(rtc, enabled); 375 #endif 376 return err; 377 } 378 EXPORT_SYMBOL_GPL(rtc_update_irq_enable); 379 380 /** 381 * rtc_update_irq - report RTC periodic, alarm, and/or update irqs 382 * @rtc: the rtc device 383 * @num: how many irqs are being reported (usually one) 384 * @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF 385 * Context: any 386 */ 387 void rtc_update_irq(struct rtc_device *rtc, 388 unsigned long num, unsigned long events) 389 { 390 unsigned long flags; 391 392 spin_lock_irqsave(&rtc->irq_lock, flags); 393 rtc->irq_data = (rtc->irq_data + (num << 8)) | events; 394 spin_unlock_irqrestore(&rtc->irq_lock, flags); 395 396 spin_lock_irqsave(&rtc->irq_task_lock, flags); 397 if (rtc->irq_task) 398 rtc->irq_task->func(rtc->irq_task->private_data); 399 spin_unlock_irqrestore(&rtc->irq_task_lock, flags); 400 401 wake_up_interruptible(&rtc->irq_queue); 402 kill_fasync(&rtc->async_queue, SIGIO, POLL_IN); 403 } 404 EXPORT_SYMBOL_GPL(rtc_update_irq); 405 406 static int __rtc_match(struct device *dev, void *data) 407 { 408 char *name = (char *)data; 409 410 if (strcmp(dev_name(dev), name) == 0) 411 return 1; 412 return 0; 413 } 414 415 struct rtc_device *rtc_class_open(char *name) 416 { 417 struct device *dev; 418 struct rtc_device *rtc = NULL; 419 420 dev = class_find_device(rtc_class, NULL, name, __rtc_match); 421 if (dev) 422 rtc = to_rtc_device(dev); 423 424 if (rtc) { 425 if (!try_module_get(rtc->owner)) { 426 put_device(dev); 427 rtc = NULL; 428 } 429 } 430 431 return rtc; 432 } 433 EXPORT_SYMBOL_GPL(rtc_class_open); 434 435 void rtc_class_close(struct rtc_device *rtc) 436 { 437 module_put(rtc->owner); 438 put_device(&rtc->dev); 439 } 440 EXPORT_SYMBOL_GPL(rtc_class_close); 441 442 int rtc_irq_register(struct rtc_device *rtc, struct rtc_task *task) 443 { 444 int retval = -EBUSY; 445 446 if (task == NULL || task->func == NULL) 447 return -EINVAL; 448 449 /* Cannot register while the char dev is in use */ 450 if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags)) 451 return -EBUSY; 452 453 spin_lock_irq(&rtc->irq_task_lock); 454 if (rtc->irq_task == NULL) { 455 rtc->irq_task = task; 456 retval = 0; 457 } 458 spin_unlock_irq(&rtc->irq_task_lock); 459 460 clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags); 461 462 return retval; 463 } 464 EXPORT_SYMBOL_GPL(rtc_irq_register); 465 466 void rtc_irq_unregister(struct rtc_device *rtc, struct rtc_task *task) 467 { 468 spin_lock_irq(&rtc->irq_task_lock); 469 if (rtc->irq_task == task) 470 rtc->irq_task = NULL; 471 spin_unlock_irq(&rtc->irq_task_lock); 472 } 473 EXPORT_SYMBOL_GPL(rtc_irq_unregister); 474 475 /** 476 * rtc_irq_set_state - enable/disable 2^N Hz periodic IRQs 477 * @rtc: the rtc device 478 * @task: currently registered with rtc_irq_register() 479 * @enabled: true to enable periodic IRQs 480 * Context: any 481 * 482 * Note that rtc_irq_set_freq() should previously have been used to 483 * specify the desired frequency of periodic IRQ task->func() callbacks. 484 */ 485 int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled) 486 { 487 int err = 0; 488 unsigned long flags; 489 490 if (rtc->ops->irq_set_state == NULL) 491 return -ENXIO; 492 493 spin_lock_irqsave(&rtc->irq_task_lock, flags); 494 if (rtc->irq_task != NULL && task == NULL) 495 err = -EBUSY; 496 if (rtc->irq_task != task) 497 err = -EACCES; 498 spin_unlock_irqrestore(&rtc->irq_task_lock, flags); 499 500 if (err == 0) 501 err = rtc->ops->irq_set_state(rtc->dev.parent, enabled); 502 503 return err; 504 } 505 EXPORT_SYMBOL_GPL(rtc_irq_set_state); 506 507 /** 508 * rtc_irq_set_freq - set 2^N Hz periodic IRQ frequency for IRQ 509 * @rtc: the rtc device 510 * @task: currently registered with rtc_irq_register() 511 * @freq: positive frequency with which task->func() will be called 512 * Context: any 513 * 514 * Note that rtc_irq_set_state() is used to enable or disable the 515 * periodic IRQs. 516 */ 517 int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq) 518 { 519 int err = 0; 520 unsigned long flags; 521 522 if (rtc->ops->irq_set_freq == NULL) 523 return -ENXIO; 524 525 spin_lock_irqsave(&rtc->irq_task_lock, flags); 526 if (rtc->irq_task != NULL && task == NULL) 527 err = -EBUSY; 528 if (rtc->irq_task != task) 529 err = -EACCES; 530 spin_unlock_irqrestore(&rtc->irq_task_lock, flags); 531 532 if (err == 0) { 533 err = rtc->ops->irq_set_freq(rtc->dev.parent, freq); 534 if (err == 0) 535 rtc->irq_freq = freq; 536 } 537 return err; 538 } 539 EXPORT_SYMBOL_GPL(rtc_irq_set_freq);
rtc-sysfs.c源代码：
1 /* 2 * RTC subsystem, sysfs interface 3 * 4 * Copyright (C) 2005 Tower Technologies 5 * Author: Alessandro Zummo <[email protected]> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 本文主要工作: 11 1.在init给rtc时钟增加闹钟属性 12 2.初始化一个struct device_attribute rtc_attrs[]属性结构体数组 13 3.在函数rtc_sysfs_add_device中增加闹钟属性文件 14 4.在函数rtc_sysfs_del_device中删除闹钟属性文件 15 */ 16 17 #include <linux/module.h> 18 #include <linux/rtc.h> 19 20 #include "rtc-core.h" 21 22 23 /* device attributes */ 24 25 /* 26 * NOTE: RTC times displayed in sysfs use the RTC's timezone. That's 27 * ideally UTC. However, PCs that also boot to MS-Windows normally use 28 * the local time and change to match daylight savings time. That affects 29 * attributes including date, time, since_epoch, and wakealarm. 30 */ 31 32 static ssize_t 33 rtc_sysfs_show_name(struct device *dev, struct device_attribute *attr, 34 char *buf) 35 { 36 return sprintf(buf, "%s\n", to_rtc_device(dev)->name); 37 } 38 39 static ssize_t 40 rtc_sysfs_show_date(struct device *dev, struct device_attribute *attr, 41 char *buf) 42 { 43 ssize_t retval; 44 struct rtc_time tm; 45 46 retval = rtc_read_time(to_rtc_device(dev), &tm); 47 if (retval == 0) { 48 retval = sprintf(buf, "%04d-%02d-%02d\n", 49 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday); 50 } 51 52 return retval; 53 } 54 55 static ssize_t 56 rtc_sysfs_show_time(struct device *dev, struct device_attribute *attr, 57 char *buf) 58 { 59 ssize_t retval; 60 struct rtc_time tm; 61 62 retval = rtc_read_time(to_rtc_device(dev), &tm); 63 if (retval == 0) { 64 retval = sprintf(buf, "%02d:%02d:%02d\n", 65 tm.tm_hour, tm.tm_min, tm.tm_sec); 66 } 67 68 return retval; 69 } 70 71 static ssize_t 72 rtc_sysfs_show_since_epoch(struct device *dev, struct device_attribute *attr, 73 char *buf) 74 { 75 ssize_t retval; 76 struct rtc_time tm; 77 78 retval = rtc_read_time(to_rtc_device(dev), &tm); 79 if (retval == 0) { 80 unsigned long time; 81 rtc_tm_to_time(&tm, &time); 82 retval = sprintf(buf, "%lu\n", time); 83 } 84 85 return retval; 86 } 87 88 static ssize_t 89 rtc_sysfs_show_max_user_freq(struct device *dev, struct device_attribute *attr, 90 char *buf) 91 { 92 return sprintf(buf, "%d\n", to_rtc_device(dev)->max_user_freq); 93 } 94 95 static ssize_t 96 rtc_sysfs_set_max_user_freq(struct device *dev, struct device_attribute *attr, 97 const char *buf, size_t n) 98 { 99 struct rtc_device *rtc = to_rtc_device(dev); 100 unsigned long val = simple_strtoul(buf, NULL, 0); 101 102 if (val >= 4096 || val == 0) 103 return -EINVAL; 104 105 rtc->max_user_freq = (int)val; 106 107 return n; 108 } 109 110 static struct device_attribute rtc_attrs[] = { 111 __ATTR(name, S_IRUGO, rtc_sysfs_show_name, NULL), 112 __ATTR(date, S_IRUGO, rtc_sysfs_show_date, NULL), 113 __ATTR(time, S_IRUGO, rtc_sysfs_show_time, NULL), 114 __ATTR(since_epoch, S_IRUGO, rtc_sysfs_show_since_epoch, NULL), 115 __ATTR(max_user_freq, S_IRUGO | S_IWUSR, rtc_sysfs_show_max_user_freq, 116 rtc_sysfs_set_max_user_freq), 117 { }, 118 }; 119 120 static ssize_t 121 rtc_sysfs_show_wakealarm(struct device *dev, struct device_attribute *attr, 122 char *buf) 123 { 124 ssize_t retval; 125 unsigned long alarm; 126 struct rtc_wkalrm alm; 127 128 /* Don't show disabled alarms. For uniformity, RTC alarms are 129 * conceptually one-shot, even though some common RTCs (on PCs) 130 * don't actually work that way. 131 * 132 * NOTE: RTC implementations where the alarm doesn't match an 133 * exact YYYY-MM-DD HH:MM[:SS] date *must* disable their RTC 134 * alarms after they trigger, to ensure one-shot semantics. 135 */ 136 retval = rtc_read_alarm(to_rtc_device(dev), &alm); 137 if (retval == 0 && alm.enabled) { 138 rtc_tm_to_time(&alm.time, &alarm); 139 retval = sprintf(buf, "%lu\n", alarm); 140 } 141 142 return retval; 143 } 144 145 static ssize_t 146 rtc_sysfs_set_wakealarm(struct device *dev, struct device_attribute *attr, 147 const char *buf, size_t n) 148 { 149 ssize_t retval; 150 unsigned long now, alarm; 151 struct rtc_wkalrm alm; 152 struct rtc_device *rtc = to_rtc_device(dev); 153 char *buf_ptr; 154 int adjust = 0; 155 156 /* Only request alarms that trigger in the future. Disable them 157 * by writing another time, e.g. 0 meaning Jan 1 1970 UTC. 158 */ 159 retval = rtc_read_time(rtc, &alm.time); 160 if (retval < 0) 161 return retval; 162 rtc_tm_to_time(&alm.time, &now); 163 164 buf_ptr = (char *)buf; 165 if (*buf_ptr == '+') { 166 buf_ptr++; 167 adjust = 1; 168 } 169 alarm = simple_strtoul(buf_ptr, NULL, 0); 170 if (adjust) { 171 alarm += now; 172 } 173 if (alarm > now) { 174 /* Avoid accidentally clobbering active alarms; we can't 175 * entirely prevent that here, without even the minimal 176 * locking from the /dev/rtcN api. 177 */ 178 retval = rtc_read_alarm(rtc, &alm); 179 if (retval < 0) 180 return retval; 181 if (alm.enabled) 182 return -EBUSY; 183 184 alm.enabled = 1; 185 } else { 186 alm.enabled = 0; 187 188 /* Provide a valid future alarm time. Linux isn't EFI, 189 * this time won't be ignored when disabling the alarm. 190 */ 191 alarm = now + 300; 192 } 193 rtc_time_to_tm(alarm, &alm.time); 194 195 retval = rtc_set_alarm(rtc, &alm); 196 return (retval < 0) ? retval : n; 197 } 198 static DEVICE_ATTR(wakealarm, S_IRUGO | S_IWUSR, 199 rtc_sysfs_show_wakealarm, rtc_sysfs_set_wakealarm); 200 201 202 /* The reason to trigger an alarm with no process watching it (via sysfs) 203 * is its side effect: waking from a system state like suspend-to-RAM or 204 * suspend-to-disk. So: no attribute unless that side effect is possible. 205 * (Userspace may disable that mechanism later.) 206 */ 207 static inline int rtc_does_wakealarm(struct rtc_device *rtc) 208 { 209 if (!device_can_wakeup(rtc->dev.parent)) 210 return 0; 211 return rtc->ops->set_alarm != NULL; 212 } 213 214 215 void rtc_sysfs_add_device(struct rtc_device *rtc) 216 { 217 int err; 218 219 /* not all RTCs support both alarms and wakeup */ 220 if (!rtc_does_wakealarm(rtc)) 221 return; 222 223 err = device_create_file(&rtc->dev, &dev_attr_wakealarm); 224 if (err) 225 dev_err(rtc->dev.parent, 226 "failed to create alarm attribute, %d\n", err); 227 } 228 229 void rtc_sysfs_del_device(struct rtc_device *rtc) 230 { 231 /* REVISIT did we add it successfully? */ 232 if (rtc_does_wakealarm(rtc)) 233 device_remove_file(&rtc->dev, &dev_attr_wakealarm); 234 } 235 236 void __init rtc_sysfs_init(struct class *rtc_class) 237 { 238 rtc_class->dev_attrs = rtc_attrs; //给rtc的类dev_attrs赋值rtc_attrs这个属性指针 239 }
rtc-proc.c源代码：
1 /* 2 * RTC subsystem, proc interface 3 * 4 * Copyright (C) 2005-06 Tower Technologies 5 * Author: Alessandro Zummo <[email protected]> 6 * 7 * based on arch/arm/common/rtctime.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/proc_fs.h> 17 #include <linux/seq_file.h> 18 19 #include "rtc-core.h" 20 21 22 static int rtc_proc_show(struct seq_file *seq, void *offset) 23 { 24 int err; 25 struct rtc_device *rtc = seq->private; 26 const struct rtc_class_ops *ops = rtc->ops; 27 struct rtc_wkalrm alrm; 28 struct rtc_time tm; 29 30 err = rtc_read_time(rtc, &tm); 31 if (err == 0) { 32 seq_printf(seq, 33 "rtc_time\t: %02d:%02d:%02d\n" 34 "rtc_date\t: %04d-%02d-%02d\n", 35 tm.tm_hour, tm.tm_min, tm.tm_sec, 36 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday); 37 } 38 39 err = rtc_read_alarm(rtc, &alrm); 40 if (err == 0) { 41 seq_printf(seq, "alrm_time\t: "); 42 if ((unsigned int)alrm.time.tm_hour <= 24) 43 seq_printf(seq, "%02d:", alrm.time.tm_hour); 44 else 45 seq_printf(seq, "**:"); 46 if ((unsigned int)alrm.time.tm_min <= 59) 47 seq_printf(seq, "%02d:", alrm.time.tm_min); 48 else 49 seq_printf(seq, "**:"); 50 if ((unsigned int)alrm.time.tm_sec <= 59) 51 seq_printf(seq, "%02d\n", alrm.time.tm_sec); 52 else 53 seq_printf(seq, "**\n"); 54 55 seq_printf(seq, "alrm_date\t: "); 56 if ((unsigned int)alrm.time.tm_year <= 200) 57 seq_printf(seq, "%04d-", alrm.time.tm_year + 1900); 58 else 59 seq_printf(seq, "****-"); 60 if ((unsigned int)alrm.time.tm_mon <= 11) 61 seq_printf(seq, "%02d-", alrm.time.tm_mon + 1); 62 else 63 seq_printf(seq, "**-"); 64 if (alrm.time.tm_mday && (unsigned int)alrm.time.tm_mday <= 31) 65 seq_printf(seq, "%02d\n", alrm.time.tm_mday); 66 else 67 seq_printf(seq, "**\n"); 68 seq_printf(seq, "alarm_IRQ\t: %s\n", 69 alrm.enabled ? "yes" : "no"); 70 seq_printf(seq, "alrm_pending\t: %s\n", 71 alrm.pending ? "yes" : "no"); 72 } 73 74 seq_printf(seq, "24hr\t\t: yes\n"); 75 76 if (ops->proc) 77 ops->proc(rtc->dev.parent, seq); 78 79 return 0; 80 } 81 82 static int rtc_proc_open(struct inode *inode, struct file *file) 83 { 84 struct rtc_device *rtc = PDE(inode)->data; 85 86 if (!try_module_get(THIS_MODULE)) 87 return -ENODEV; 88 89 return single_open(file, rtc_proc_show, rtc); 90 } 91 92 static int rtc_proc_release(struct inode *inode, struct file *file) 93 { 94 int res = single_release(inode, file); 95 module_put(THIS_MODULE); 96 return res; 97 } 98 99 static const struct file_operations rtc_proc_fops = { 100 .open = rtc_proc_open, 101 .read = seq_read, 102 .llseek = seq_lseek, 103 .release = rtc_proc_release, 104 }; 105 106 void rtc_proc_add_device(struct rtc_device *rtc) 107 { 108 if (rtc->id == 0) 109 proc_create_data("driver/rtc", 0, NULL, &rtc_proc_fops, rtc); 110 //proc_create_data完成创建文件节点的作用，并将文件的操作函数与节点联系起来 111 } 112 113 void rtc_proc_del_device(struct rtc_device *rtc) 114 { 115 if (rtc->id == 0) 116 remove_proc_entry("driver/rtc", NULL); 117 }