Linux驱动之RTC子系统

date​

[root@XiaoLong /]# date​

Sat Apr 30 06:04:29 UTC 2016​

[root@xiaolong 2016-4-28]# date​

2016年 04月 30日 星期六 14:00:39 CST​

查看date帮助：​

[root@XiaoLong /]# date -help //嵌入式开发板​

[root@XiaoLong /]# man date //PClinux系统​

date [参数]... [+格式]​

date 可以用来显示或设定系统的日期与时间。​

使用示例： date '+%A'​

必要参数: ​

%H 小时(以00-23来表示)。 ​

%I 小时(以01-12来表示)。 ​

%K 小时(以0-23来表示)。 ​

%l 小时(以0-12来表示)。 ​

%M 分钟(以00-59来表示)。 ​

%P AM或PM。 ​

%r 时间(含时分秒，小时以12小时AM/PM来表示)。 ​

%s 总秒数。起算时间为1970-01-01 00:00:00 UTC。 ​

%S 秒(以本地的惯用法来表示)。 ​

%T 时间(含时分秒，小时以24小时制来表示)。 ​

%X 时间(以本地的惯用法来表示)。 ​

%Z 市区。 ​

%a 星期的缩写。 ​

%A 星期的完整名称。 ​

%b 月份英文名的缩写。 ​

%B 月份的完整英文名称。 ​

%c 日期与时间。只输入date指令也会显示同样的结果。 ​

%d 日期(以01-31来表示)。 ​

%D 日期(含年月日)。 ​

%j 该年中的第几天。 ​

%m 月份(以01-12来表示)。 ​

%U 该年中的周数。 ​

%w 该周的天数，0代表周日，1代表周一，异词类推。 ​

%x 日期(以本地的惯用法来表示)。 ​

%y 年份(以00-99来表示)。 ​

%Y 年份(以四位数来表示)。 ​

%n 在显示时，插入新的一行。 ​

%t 在显示时，插入tab。 ​

MM 月份(必要) ​

DD 日期(必要) ​

hh 小时(必要) ​

mm 分钟(必要)​

ss 秒(选择性) ​

选择参数:​

-d<字符串> 显示字符串所指的日期与时间。字符串前后必须加上双引号。 ​

-s<字符串> 根据字符串来设置日期与时间。字符串前后必须加上双引号。 ​

-u 显示GMT。 ​

--help 在线帮助。 ​

--version 显示版本信息 ​

%n : 下一行​

%t : 跳格​

%H : 小时(00..23)​

%I : 小时(01..12)​

%k : 小时(0..23)​

%l : 小时(1..12)​

%M : 分钟(00..59)​

%p : 显示本地 AM 或 PM​

%r : 直接显示时间 (12 小时制，格式为 hh:mm:ss [AP]M)​

%s : 从 1970 年 1 月 1 日 00:00:00 UTC 到目前为止的秒数​

%S : 秒(00..61)​

%T : 直接显示时间 (24 小时制)​

%X : 相当于 %H:%M:%S​

%Z : 显示时区 %a : 星期几 (Sun..Sat)​

%A : 星期几 (Sunday..Saturday)​

%b : 月份 (Jan..Dec)​

%B : 月份 (January..December)​

%c : 直接显示日期与时间​

%d : 日 (01..31)​

%D : 直接显示日期 (mm/dd/yy)​

%h : 同 %b​

%j : 一年中的第几天 (001..366)​

%m : 月份 (01..12)​

%U : 一年中的第几周 (00..53) (以 Sunday 为一周的第一天的情形)​

%w : 一周中的第几天 (0..6)​

%W : 一年中的第几周 (00..53) (以 Monday 为一周的第一天的情形)​

%x : 直接显示日期 (mm/dd/yy)​

%y : 年份的最后两位数字 (00.99)​

%Y : 完整年份 (0000..9999)​

[root@XiaoLong /]# date '+%c'​

Sat Apr 30 06:20:27 2016​

[root@XiaoLong /]# date '+%D'​

04/30/16​

[root@XiaoLong /]# date '+%x'​

04/30/16​

[root@XiaoLong /]# date '+%T'​

06:20:46​

[root@XiaoLong /]# date '+%X'​

06:20:51​

[root@XiaoLong /]# date --date 14:40:00设置时间为14点40分00秒​

Sat Apr 30 14:40:00 UTC 2016​

[root@XiaoLong /]# date -s 23:27:00设置时间为23点27分00秒​

Sat Apr 30 23:27:00 UTC 2016​

[root@XiaoLong /]# date -r app // -r选项可以打印出指定文件的最后修改时间 ​

Fri Apr 29 05:17:34 UTC 2016​

[root@XiaoLong /]# date -d 23:39:00 //打印出指定格式时间（只是打印效果没有其他效果）​

Sat Apr 30 23:39:00 UTC 2016​

[root@XiaoLong /]# date -s 12:20:30 //设置系统时间为12点20分30秒​

Sat Apr 30 12:20:30 UTC 2016​

[root@XiaoLong /]# date -s 2016.04.30-23:20:10 //设置系统时间为2016年4月30日23点20分10秒​

Sat Apr 30 23:20:10 UTC 2016​

[root@XiaoLong /]# hwclock -s​

[root@XiaoLong /]# hwclock -r​

Sun May 1 00:09:36 2016 0.000000 seconds​

[root@XiaoLong /]# ​

[root@XiaoLong /]# cat /proc/driver/rtc​

rtc_time : 00:09:27​

rtc_date : 2016-05-01​

alrm_time : 23:24:07​

alrm_date : 2016-05-01​

alarm_IRQ : no​

alrm_pending : no​

update IRQ enabled : no​

periodic IRQ enabled : no​

periodic IRQ frequency : 1​

max user IRQ frequency : 32768​

24hr : yes​

periodic_IRQ : no​

\linux-3.5\drivers\rtc\目录下全是RTC驱动示例代码​

其中：rtc-s3c.c 是三星公司编写的RTC驱动​

struct rtc_device​

{​

struct device dev;​

struct module *owner;​

int id;​

char name[RTC_DEVICE_NAME_SIZE];​

const struct rtc_class_ops *ops;​

struct mutex ops_lock;​

struct cdev char_dev;​

unsigned long flags;​

unsigned long irq_data;​

spinlock_t irq_lock;​

wait_queue_head_t irq_queue;​

struct fasync_struct *async_queue;​

struct rtc_task *irq_task;​

spinlock_t irq_task_lock;​

int irq_freq;​

int max_user_freq;​

struct timerqueue_head timerqueue;​

struct rtc_timer aie_timer;​

struct rtc_timer uie_rtctimer;​

struct hrtimer pie_timer; /* sub second exp, so needs hrtimer */​

int pie_enabled;​

struct work_struct irqwork;​

/* Some hardware can't support UIE mode */​

int uie_unsupported;​

#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL​

struct work_struct uie_task;​

struct timer_list uie_timer;​

/* Those fields are protected by rtc->irq_lock */​

unsigned int oldsecs;​

unsigned int uie_irq_active:1;​

unsigned int stop_uie_polling:1;​

unsigned int uie_task_active:1;​

unsigned int uie_timer_active:1;​

#endif​

};​

struct rtc_class_ops {​

int (*open)(struct device *);​

void (*release)(struct device *);​

int (*ioctl)(struct device *, unsigned int, unsigned long);​

int (*read_time)(struct device *, struct rtc_time *);​

int (*set_time)(struct device *, struct rtc_time *);​

int (*read_alarm)(struct device *, struct rtc_wkalrm *);​

int (*set_alarm)(struct device *, struct rtc_wkalrm *);​

int (*proc)(struct device *, struct seq_file *);​

int (*set_mmss)(struct device *, unsigned long secs);​

int (*read_callback)(struct device *, int data);​

int (*alarm_irq_enable)(struct device *, unsigned int enabled);​

};​

#define RTC_RD_TIME_IOR(RTC_MAGIC, 0x09, struct rtc_time)/* Read RTC time. */​

#define RTC_SET_TIME_IOW(RTC_MAGIC, 0x0a, struct rtc_time)/* Set RTC time. */​

struct rtc_time {​

int tm_sec; //秒​

int tm_min; //分钟​

int tm_hour; //小时​

int tm_mday; //天​

int tm_mon; //月​

int tm_year; //年​

int tm_wday; //一周中的某一天​

int tm_yday; //一年中的某一天​

int tm_isdst; //夏令时有效​

};​

//注销RTC​

static void __exit rtc_exit(void)​

{​

rtc_dev_exit();​

class_destroy(rtc_class);​

ida_destroy(&rtc_ida);​

}​

struct rtc_device *rtc_device_register(const char *name, struct device *dev,​

const struct rtc_class_ops *ops,​

struct module *owner)​

{​

struct rtc_device *rtc;​

struct rtc_wkalrm alrm;​

int id, err;​

/* （1）：处理一个idr的结构，idr在linux内核中指的就是整数ID管理机制，从本质上来说，idr是一种将整数ID号和特定指针关联在一起的机制。*/​

id = ida_simple_get(&rtc_ida, 0, 0, GFP_KERNEL);​

if (id < 0) {​

err = id;​

goto exit;​

}​

/*（2）：分配了一个rtc_device的结构--rtc，并且初始化了相关的成员：id, rtc_class_ops等等*/​

rtc = kzalloc(sizeof(struct rtc_device), GFP_KERNEL);​

if (rtc == NULL) {​

err = -ENOMEM;​

goto exit_ida;​

}​

rtc->id = id;​

rtc->ops = ops;​

rtc->owner = owner;​

rtc->irq_freq = 1;​

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);​

init_waitqueue_head(&rtc->irq_queue);​

/* Init timerqueue */​

timerqueue_init_head(&rtc->timerqueue);​

INIT_WORK(&rtc->irqwork, rtc_timer_do_work);​

/* Init aie timer */​

rtc_timer_init(&rtc->aie_timer, rtc_aie_update_irq, (void *)rtc);​

/* Init uie timer */​

rtc_timer_init(&rtc->uie_rtctimer, rtc_uie_update_irq, (void *)rtc);​

/* Init pie timer */​

hrtimer_init(&rtc->pie_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);​

rtc->pie_timer.function = rtc_pie_update_irq;​

rtc->pie_enabled = 0;​

/* Check to see if there is an ALARM already set in hw */​

err = __rtc_read_alarm(rtc, &alrm);​

if (!err && !rtc_valid_tm(&alrm.time))​

rtc_initialize_alarm(rtc, &alrm);​

strlcpy(rtc->name, name, RTC_DEVICE_NAME_SIZE);​

dev_set_name(&rtc->dev, "rtc%d", id);​

/*（3）首先调用rtc_dev_prepare（在rtc-dev.c中定义）。因为RTC设备本质来讲还是字符设备，所以这里初始化了字符设备相关的结构：设备号以及文件操作。然后调用device_register将设备注册到linux设备模型核心。这样在模块加载的时候，udev daemon就会自动为我们创建设备文件rtc(n)。*/​

rtc_dev_prepare(rtc);​

err = device_register(&rtc->dev);​

if (err) {​

put_device(&rtc->dev);​

goto exit_kfree;​

}​

/*（4）：先后调用rtc_dev_add_device，rtc_sysfs_add_device，rtc_proc_add_device三个函数。rtc_dev_add_device注册字符设备，rtc_sysfs_add_device只是为设备添加了一个闹钟属性，rtc_proc_add_device 创建proc文件系统接口。*/​

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, dev_name(&rtc->dev));​

return rtc;​

exit_kfree:​

kfree(rtc);​

exit_ida:​

ida_simple_remove(&rtc_ida, id);​

exit:​

dev_err(dev, "rtc core: unable to register %s, err = %d\n",​

name, err);​

return ERR_PTR(err);​

}​

/*实现的文件操作集合接口*/​

static const struct file_operations rtc_dev_fops = {​

.owner= THIS_MODULE,​

.llseek= no_llseek,​

.read= rtc_dev_read,​

.poll= rtc_dev_poll,​

.unlocked_ioctl= rtc_dev_ioctl,​

.open= rtc_dev_open,​

.release= rtc_dev_release,​

.fasync= rtc_dev_fasync,​

};​

static ssize_t​

rtc_dev_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)​

{​

struct rtc_device *rtc = file->private_data;​

DECLARE_WAITQUEUE(wait, current); /*等待队列头*/​

unsigned long data;​

ssize_t ret;​

if (count != sizeof(unsigned int) && count < sizeof(unsigned long))​

return -EINVAL;​

add_wait_queue(&rtc->irq_queue, &wait); /*将当前进程加入到队列中*/​

do {​

__set_current_state(TASK_INTERRUPTIBLE); /*设状态置当前进程状态*/​

spin_lock_irq(&rtc->irq_lock);​

data = rtc->irq_data;​

rtc->irq_data = 0;​

spin_unlock_irq(&rtc->irq_lock);​

if (data != 0) {​

ret = 0;​

break;​

}​

if (file->f_flags & O_NONBLOCK) { /*如果是非阻塞就退出*/​

ret = -EAGAIN;​

break;​

}​

if (signal_pending(current)) {​

ret = -ERESTARTSYS;​

break;​

}​

schedule(); /*该函数值linux内核核心的调度函数,让出CPU*/​

} while (1);​

set_current_state(TASK_RUNNING);//设置进程可运行状态​

remove_wait_queue(&rtc->irq_queue, &wait);​

if (ret == 0) {​

/* Check for any data updates */​

if (rtc->ops->read_callback)​

data = rtc->ops->read_callback(rtc->dev.parent,​

data);​

拷贝数据给应用层*/​

if (sizeof(int) != sizeof(long) &&​

count == sizeof(unsigned int))​

ret = put_user(data, (unsigned int __user *)buf) ?:​

sizeof(unsigned int);​

else​

ret = put_user(data, (unsigned long __user *)buf) ?:​

sizeof(unsigned long);​

}​

return ret;​

}​

/*​

自01-01-1970就是将公历日期转换为秒。​

*/​

int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time)​

{​

*time = mktime(tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,​

tm->tm_hour, tm->tm_min, tm->tm_sec);​

return 0;​

}​

static struct device_attribute rtc_attrs[] = {​

__ATTR(name, S_IRUGO, rtc_sysfs_show_name, NULL),​

__ATTR(date, S_IRUGO, rtc_sysfs_show_date, NULL),​

__ATTR(time, S_IRUGO, rtc_sysfs_show_time, NULL),​

__ATTR(since_epoch, S_IRUGO, rtc_sysfs_show_since_epoch, NULL),​

__ATTR(max_user_freq, S_IRUGO | S_IWUSR, rtc_sysfs_show_max_user_freq,​

rtc_sysfs_set_max_user_freq),​

__ATTR(hctosys, S_IRUGO, rtc_sysfs_show_hctosys, NULL),​

{ },​

};​

static const struct file_operations rtc_proc_fops = {​

.open= rtc_proc_open,​

.read= seq_read,​

.llseek= seq_lseek,​

.release= rtc_proc_release,​

};​

void rtc_proc_add_device(struct rtc_device *rtc)​

{​

if (rtc->id == 0)​

proc_create_data("driver/rtc", 0, NULL, &rtc_proc_fops, rtc);​

}​

static int rtc_proc_open(struct inode *inode, struct file *file)​

{​

int ret;​

struct rtc_device *rtc = PDE(inode)->data;​

if (!try_module_get(THIS_MODULE))​

return -ENODEV;​

ret = single_open(file, rtc_proc_show, rtc);​

if (ret)​

module_put(THIS_MODULE);​

return ret;​

}​

static int rtc_proc_show(struct seq_file *seq, void *offset)​

{​

int err;​

struct rtc_device *rtc = seq->private;​

const struct rtc_class_ops *ops = rtc->ops;​

struct rtc_wkalrm alrm;​

struct rtc_time tm;​

err = rtc_read_time(rtc, &tm);​

if (err == 0) {​

seq_printf(seq,​

"rtc_time\t: %02d:%02d:%02d\n"​

"rtc_date\t: %04d-%02d-%02d\n",​

tm.tm_hour, tm.tm_min, tm.tm_sec,​

tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);​

}​

err = rtc_read_alarm(rtc, &alrm);​

if (err == 0) {​

seq_printf(seq, "alrm_time\t: ");​

if ((unsigned int)alrm.time.tm_hour <= 24)​

seq_printf(seq, "%02d:", alrm.time.tm_hour);​

else​

seq_printf(seq, "**:");​

if ((unsigned int)alrm.time.tm_min <= 59)​

seq_printf(seq, "%02d:", alrm.time.tm_min);​

else​

seq_printf(seq, "**:");​

if ((unsigned int)alrm.time.tm_sec <= 59)​

seq_printf(seq, "%02d\n", alrm.time.tm_sec);​

else​

seq_printf(seq, "**\n");​

seq_printf(seq, "alrm_date\t: ");​

if ((unsigned int)alrm.time.tm_year <= 200)​

seq_printf(seq, "%04d-", alrm.time.tm_year + 1900);​

else​

seq_printf(seq, "****-");​

if ((unsigned int)alrm.time.tm_mon <= 11)​

seq_printf(seq, "%02d-", alrm.time.tm_mon + 1);​

else​

seq_printf(seq, "**-");​

if (alrm.time.tm_mday && (unsigned int)alrm.time.tm_mday <= 31)​

seq_printf(seq, "%02d\n", alrm.time.tm_mday);​

else​

seq_printf(seq, "**\n");​

seq_printf(seq, "alarm_IRQ\t: %s\n",​

alrm.enabled ? "yes" : "no");​

seq_printf(seq, "alrm_pending\t: %s\n",​

alrm.pending ? "yes" : "no");​

seq_printf(seq, "update IRQ enabled\t: %s\n",​

(rtc->uie_rtctimer.enabled) ? "yes" : "no");​

seq_printf(seq, "periodic IRQ enabled\t: %s\n",​

(rtc->pie_enabled) ? "yes" : "no");​

seq_printf(seq, "periodic IRQ frequency\t: %d\n",​

rtc->irq_freq);​

seq_printf(seq, "max user IRQ frequency\t: %d\n",​

rtc->max_user_freq);​

}​

seq_printf(seq, "24hr\t\t: yes\n");​

if (ops->proc)​

ops->proc(rtc->dev.parent, seq);​

return 0;​

}​