RTC subsystem
Subsystems (2)
cover RTC subsystem
Hello,
updated version of my proposal for an RTC Subsystem.
I've fixed some locking issues, thanks to Dmitry Torokhov and added a driver for the Dallas/Maxim DS1672 Timekeeping chip.
The subsystem should now be capable to handle all of the existing standalone drivers.
As usual, your feedback is highly appreciated.
--
Best regards,
Alessandro Zummo,
Tower Technologies - Turin, Italy
PATCH 1/8 RTC subsystem, class
This patch adds the basic RTC subsytem infrastructure to the kernel.
rtc/class.c - registration facilities for RTC drivers rtc/interface.c - kernel/rtc interface functions rtc/utils.c - misc rtc-related utility functions
--
drivers/Kconfig | 2 drivers/Makefile | 1 drivers/rtc/Kconfig | 25 ++++++ drivers/rtc/Makefile | 8 ++ drivers/rtc/class.c | 143 ++++++++++++++++++++++++++++++++++++ drivers/rtc/interface.c | 189 ++++++++++++++++++++++++++++++++++++++++++++++++ drivers/rtc/utils.c | 97 ++++++++++++++++++++++++ include/linux/rtc.h | 73 ++++++++++++++++++ 8 files changed, 538 insertions(+)
include/linux/rtc.h +73 -0
@@ -91,8 +91,81 @@ struct rtc_pll_info {#define RTC_PLL_GET _IOR('p', 0x11, struct rtc_pll_info)/* Get PLL correction */ #define RTC_PLL_SET _IOW('p', 0x12, struct rtc_pll_info)/* Set PLL correction */ +/* interrupt flags */ +#define RTC_IRQF 0x80/* any of the following is active */ +#define RTC_PF 0x40 +#define RTC_AF 0x20 +#define RTC_UF 0x10 + #ifdef __KERNEL__ +#include <linux/device.h> +#include <linux/seq_file.h> +#include <linux/cdev.h> +#include <linux/poll.h> + +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 (*irq_set_state)(struct device *, int enabled); + int (*irq_set_freq)(struct device *, int freq); +}; + +#define RTC_DEVICE_NAME_SIZE 20 +struct rtc_task; + +struct rtc_device +{ + int id; + struct module *owner; + struct class_device class_dev; + struct semaphore ops_lock; + struct rtc_class_ops *ops; + char name[RTC_DEVICE_NAME_SIZE]; + + struct cdev char_dev; + struct semaphore char_sem; + + unsigned long irq_data; + spinlock_t irq_lock; + wait_queue_head_t irq_queue; + struct fasync_struct *async_queue; + + spinlock_t irq_task_lock; + struct rtc_task *irq_task; + int irq_freq; +}; +#define to_rtc_device(d) container_of(d, struct rtc_device, class_dev) + +extern struct rtc_device *rtc_device_register(char *name, + struct device *dev, + struct rtc_class_ops *ops, + struct module *owner); +extern void rtc_device_unregister(struct rtc_device *rdev); +extern int rtc_interface_register(struct class_interface *intf); + + +extern int rtc_month_days(unsigned int month, unsigned int year); +extern int rtc_valid_tm(struct rtc_time *tm); +extern int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time); +extern void rtc_time_to_tm(unsigned long time, struct rtc_time *tm); + +extern int rtc_read_time(struct class_device *class_dev, struct rtc_time *tm); +extern int rtc_set_time(struct class_device *class_dev, struct rtc_time *tm); +extern int rtc_read_alarm(struct class_device *class_dev, + struct rtc_wkalrm *alrm); +extern int rtc_set_alarm(struct class_device *class_dev, + struct rtc_wkalrm *alrm); +extern void rtc_update_irq(struct class_device *class_dev, + unsigned long num, unsigned long events); + typedef struct rtc_task { void (*func)(void *private_data); void *private_data;
drivers/Kconfig +2 -0
@@ -66,4 +66,6 @@ source "drivers/infiniband/Kconfig" source "drivers/sn/Kconfig" +source "drivers/rtc/Kconfig" + endmenu
drivers/Makefile +1 -0
@@ -54,6 +54,7 @@ obj-$(CONFIG_USB_GADGET) += usb/gadget/ obj-$(CONFIG_GAMEPORT) += input/gameport/ obj-$(CONFIG_INPUT) += input/ obj-$(CONFIG_I2O) += message/ +obj-y += rtc/ obj-$(CONFIG_I2C) += i2c/ obj-$(CONFIG_W1) += w1/ obj-$(CONFIG_HWMON) += hwmon/
drivers/rtc/class.c new file +143 -0
143 lines not on this page · raw message
drivers/rtc/Kconfig new file +25 -0
@@ -0,0 +1,25 @@ +# +# RTC class/drivers configuration +# + +menu "Real Time Clock" + +config RTC_CLASS + tristate "RTC class" + depends on EXPERIMENTAL + default y + help + Generic RTC class support. If you say yes here, you will + be allowed to plug one or more RTCs to your system. You will + probably want to enable one of more of the interfaces below. + + This driver can also be built as a module. If so, the module + will be called rtc-class. + +comment "RTC interfaces" + depends on RTC_CLASS + +comment "RTC drivers" + depends on RTC_CLASS + +endmenu
drivers/rtc/Makefile new file +8 -0
@@ -0,0 +1,8 @@ +# +# Makefile for RTC class/drivers. +# + +obj-y += utils.o +obj-$(CONFIG_RTC_CLASS) += rtc-core.o +rtc-core-y := class.o interface.o +
drivers/rtc/interface.c new file +189 -0
189 lines not on this page · raw message
drivers/rtc/utils.c new file +97 -0
97 lines not on this page · raw message
--
PATCH 2/8 RTC subsystem, ARM cleanup
In reply to Alessandro ZummoThis patch removes from the ARM subsytem some of the rtc-related functions that have been included in the RTC subsystem.
ARM Kconfig is modified to include the RTC subsystem.
--
arch/arm/Kconfig | 2 arch/arm/common/rtctime.c | 107 +++++----------------------------------------- include/asm-arm/rtc.h | 3 - 3 files changed, 14 insertions(+), 98 deletions(-)
arch/arm/Kconfig +2 -0
@@ -750,6 +750,8 @@ source "drivers/usb/Kconfig" source "drivers/mmc/Kconfig" +source "drivers/rtc/Kconfig" + endmenu source "fs/Kconfig"
arch/arm/common/rtctime.c +12 -95
178 lines not on this page · raw message
include/asm-arm/rtc.h +0 -3
@@ -25,9 +25,6 @@ struct rtc_ops {int (*proc)(char *buf); }; -void rtc_time_to_tm (unsigned long ,struct rtc_time *); -int rtc_tm_to_time (struct rtc_time *,unsigned long *); -int rtc_valid_tm (struct rtc_time *);void rtc_next_alarm_time (struct rtc_time *,struct rtc_time *,struct rtc_time *);void rtc_update (unsigned long ,unsigned long );int register_rtc (struct rtc_ops *);
--
PATCH 3/8 RTC subsystem, sysfs interface
In reply to Alessandro ZummoThis patch adds the sysfs interface to the
RTC subsystem.
Each RTC client will have his own entry
under /sys/classs/rtc/rtcN .
Within this entry some attributes are
exported by the subsystem, like date and time.
--
drivers/rtc/Kconfig | 11 ++++ drivers/rtc/Makefile | 2 drivers/rtc/rtc-sysfs.c | 129 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 141 insertions(+), 1 deletion(-)
drivers/rtc/rtc-sysfs.c new file +129 -0
@@ -0,0 +1,129 @@ +/* +* RTC subsystem, sysfs interface +* +* Copyright (C) 2005 Tower Technologies +* Author: Alessandro Zummo <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation; version 2 of the License. +*/ + +#include <linux/module.h> +#include <linux/rtc.h> + +/* device attributes */ + +static ssize_t rtc_sysfs_show_name (struct class_device *dev,char *buf) +{ +return sprintf (buf,"%s\n" ,to_rtc_device (dev)->name); +} +static CLASS_DEVICE_ATTR(name, S_IRUGO, rtc_sysfs_show_name, NULL); + +static ssize_t rtc_sysfs_show_date (struct class_device *dev,char *buf) +{ +ssize_t retval = -ENODEV ; +struct rtc_device *rtc =to_rtc_device (dev); +struct rtc_time tm; + +if ((retval =down_interruptible (&rtc->ops_lock))) +return retval; + +if (rtc->ops && ((retval =rtc_read_time (dev, &tm)) ==0 )) { + retval =sprintf (buf,"%04d-%02d-%02d\n" , + tm.tm_year +1900 , tm.tm_mon +1 , tm.tm_mday); + } + +up (&rtc->ops_lock); + +return retval; +} +static CLASS_DEVICE_ATTR(date, S_IRUGO, rtc_sysfs_show_date, NULL); + +static ssize_t rtc_sysfs_show_time (struct class_device *dev,char *buf) +{ +ssize_t retval = -ENODEV ; +struct rtc_device *rtc =to_rtc_device (dev); +struct rtc_time tm; + +if ((retval =down_interruptible (&rtc->ops_lock))) +return retval; + + +if (rtc->ops && ((retval =rtc_read_time (dev, &tm)) ==0 )) { + retval =sprintf (buf,"%02d:%02d:%02d\n" , + tm.tm_hour, tm.tm_min, tm.tm_sec); + } + +up (&rtc->ops_lock); + +return retval; +} +static CLASS_DEVICE_ATTR(time, S_IRUGO, rtc_sysfs_show_time, NULL); + +static ssize_t rtc_sysfs_show_since_epoch (struct class_device *dev,char *buf) +{ +ssize_t retval = -ENODEV ; +struct rtc_device *rtc =to_rtc_device (dev); +struct rtc_time tm; + +if ((retval =down_interruptible (&rtc->ops_lock))) +return retval; + +if (rtc->ops && ((retval =rtc_read_time (dev, &tm)) ==0 )) { +unsigned long time; +rtc_tm_to_time (&tm, &time); + retval =sprintf (buf,"%lu\n" , time); + } + +up (&rtc->ops_lock); + +return retval; +} +static CLASS_DEVICE_ATTR(since_epoch, S_IRUGO, rtc_sysfs_show_since_epoch, NULL); + +/* insertion/removal hooks */ + +static int __devinit rtc_sysfs_add_device (struct class_device *class_dev, +struct class_interface *class_intf) +{ +class_device_create_file (class_dev, &class_device_attr_name); +class_device_create_file (class_dev, &class_device_attr_date); +class_device_create_file (class_dev, &class_device_attr_time); +class_device_create_file (class_dev, &class_device_attr_since_epoch); +dev_info (class_dev->dev,"rtc intf: sysfs\n" ); +return 0 ; +} + +static void rtc_sysfs_remove_device (struct class_device *class_dev, +struct class_interface *class_intf) +{ +class_device_remove_file (class_dev, &class_device_attr_name); +class_device_remove_file (class_dev, &class_device_attr_date); +class_device_remove_file (class_dev, &class_device_attr_time); +class_device_remove_file (class_dev, &class_device_attr_since_epoch); +} + +/* interface registration */ + +struct class_interface rtc_sysfs_interface = { + .add = &rtc_sysfs_add_device, + .remove = &rtc_sysfs_remove_device, +}; + +static int __init rtc_sysfs_init (void ) +{ +return rtc_interface_register (&rtc_sysfs_interface); +} + +static void __exit rtc_sysfs_exit(void) +{ +class_interface_unregister (&rtc_sysfs_interface); +} + +module_init (rtc_sysfs_init); +module_exit (rtc_sysfs_exit); + +MODULE_AUTHOR ("Alessandro Zummo <[email protected]>" ); +MODULE_DESCRIPTION ("RTC class sysfs interface" ); +MODULE_LICENSE ("GPL" );
drivers/rtc/Kconfig +11 -0
@@ -19,6 +19,17 @@ config RTC_CLASS comment "RTC interfaces" depends on RTC_CLASS +config RTC_INTF_SYSFS + tristate "sysfs" + depends on RTC_CLASS && SYSFS + default RTC_CLASS + help + Say yes here if you want to use your RTC using the sysfs + interface, /sys/class/rtc/rtcX . + + This driver can also be built as a module. If so, the module + will be called rtc-sysfs. + comment "RTC drivers" depends on RTC_CLASS
drivers/rtc/Makefile +1 -1
@@ -5,4 +5,4 @@ obj-y += utils.o obj-$(CONFIG_RTC_CLASS) += rtc-core.o rtc-core-y := class.o interface.o - +obj-$(CONFIG_RTC_INTF_SYSFS) += rtc-sysfs.o
--
A message that is not in the archive (sent off-list or not yet received): [email protected]
Re: [PATCH 3/8] RTC subsystem, sysfs interface
Quoted 6 lines · On Sun, 8 Jan 2006 21:02:40 -0500 Dmitry Torokhov <[email protected]>…
Quoted 5 lines · Alessandro Zummo
drivers/rtc/rtc-sysfs.c new file +5
-0+static ssize_t rtc_sysfs_show_date (struct class_device *dev,char *buf) +{ + ssize_t retval = -ENODEV; + struct rtc_device *rtc = to_rtc_device(dev); + struct rtc_time tm;
[...]
Quoted 3 lines
ops locking is a mess here. Half of the code accesses it under protection of
ops_lockwhile other half is unlocked. I think it would be better if that lock was taken inrtc_read_timeand friends.
Good point. I'll move them, thanks.
Signature · 6 lines
Best regards, Alessandro Zummo, Tower Technologies - Turin, Italy http://www.towertech.it
PATCH 4/8 RTC subsystem, proc interface
In reply to Alessandro ZummoThis patch adds the proc interface to the
RTC subsystem.
The first RTC driver which registers with the class will be accessible by /proc/driver/rtc .
--
drivers/rtc/Kconfig | 11 +++ drivers/rtc/Makefile | 1 drivers/rtc/rtc-proc.c | 158 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 170 insertions(+)
drivers/rtc/rtc-proc.c new file +158 -0
@@ -0,0 +1,158 @@ +/* +* RTC subsystem, proc interface +* +* Copyright (C) 2005 Tower Technologies +* Author: Alessandro Zummo <[email protected]> +* +* based on arch/arm/common/rtctime.c +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation; version 2 of the License. +*/ + +#include <linux/module.h> +#include <linux/rtc.h> +#include <linux/proc_fs.h> +#include <linux/seq_file.h> + +static struct class_device *rtc_dev =NULL ; +static DECLARE_MUTEX (rtc_sem); + +static int rtc_proc_show (struct seq_file *seq,void *offset) +{ +struct class_device *class_dev = seq->private; +struct rtc_class_ops *ops =to_rtc_device (class_dev)->ops; +struct rtc_wkalrm alrm; +struct rtc_time tm; + +if (rtc_read_time (class_dev, &tm) ==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); + } + +if (rtc_read_alarm (class_dev, &alrm) ==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 ((unsigned int )alrm.time.tm_mday <=31 ) +seq_printf (seq,"%02d\n" , alrm.time.tm_mday); +else +seq_printf (seq,"**\n" ); +seq_printf (seq,"alrm_wakeup\t: %s\n" , + alrm.enabled ?"yes" :"no" ); +seq_printf (seq,"alrm_pending\t: %s\n" , + alrm.pending ?"yes" :"no" ); + } + +if (ops->proc) + ops->proc (class_dev->dev, seq); + +return 0 ; +} + +static int rtc_proc_open (struct inode *inode,struct file *file) +{ +struct class_device *class_dev =PDE (inode)->data; + +if (!try_module_get (THIS_MODULE )) +return -ENODEV ; + +return single_open (file, rtc_proc_show, class_dev); +} + +static int rtc_proc_release (struct inode *inode,struct file *file) +{ +int res =single_release (inode, file); +module_put (THIS_MODULE ); +return res; +} + +static struct file_operations rtc_proc_fops = { + .open = rtc_proc_open, + .read = seq_read, + .llseek = seq_lseek, + .release = rtc_proc_release, +}; + +static int rtc_proc_add_device (struct class_device *class_dev, +struct class_interface *class_intf) +{ +down (&rtc_sem); +if (rtc_dev ==NULL ) { +struct proc_dir_entry *ent; + + rtc_dev = class_dev; + +if ((ent =create_proc_entry ("driver/rtc" ,0 ,NULL ))) { +struct rtc_device *rtc =to_rtc_device (class_dev); + + ent->proc_fops = &rtc_proc_fops; + ent->owner = rtc->owner; + ent->data = class_dev; + +dev_info (class_dev->dev,"rtc intf: proc\n" ); + } +else + rtc_dev =NULL ; + } +up (&rtc_sem); + +return 0 ; +} + +static void rtc_proc_remove_device (struct class_device *class_dev, +struct class_interface *class_intf) +{ +down (&rtc_sem); +if (rtc_dev == class_dev) { +remove_proc_entry ("driver/rtc" ,NULL ); + rtc_dev =NULL ; + } +up (&rtc_sem); +} + +struct class_interface rtc_proc_interface = { + .add = &rtc_proc_add_device, + .remove = &rtc_proc_remove_device, +}; + +static int __init rtc_proc_init (void ) +{ +return rtc_interface_register (&rtc_proc_interface); +} + +static void __exit rtc_proc_exit(void) +{ +class_interface_unregister (&rtc_proc_interface); +} + +module_init (rtc_proc_init); +module_exit (rtc_proc_exit); + +MODULE_AUTHOR ("Alessandro Zummo <[email protected]>" ); +MODULE_DESCRIPTION ("RTC class proc interface" ); +MODULE_LICENSE ("GPL" );
drivers/rtc/Kconfig +11 -0
@@ -30,6 +30,17 @@ config RTC_INTF_SYSFS This driver can also be built as a module. If so, the module will be called rtc-sysfs. +config RTC_INTF_PROC + tristate "proc" + depends on RTC_CLASS && PROC_FS + default RTC_CLASS + help + Say yes here if you want to use your RTC using the proc + interface, /proc/driver/rtc . + + This driver can also be built as a module. If so, the module + will be called rtc-proc. + comment "RTC drivers" depends on RTC_CLASS
drivers/rtc/Makefile +1 -0
@@ -6,3 +6,4 @@ obj-y += utils.o obj-$(CONFIG_RTC_CLASS) += rtc-core.o rtc-core-y := class.o interface.o obj-$(CONFIG_RTC_INTF_SYSFS) += rtc-sysfs.o +obj-$(CONFIG_RTC_INTF_PROC) += rtc-proc.o
--
A message that is not in the archive (sent off-list or not yet received): [email protected]
Re: [PATCH 4/8] RTC subsystem, proc interface
Quoted 6 lines · On Sun, 8 Jan 2006 20:56:29 -0500 Dmitry Torokhov <[email protected]>…
Quoted 6 lines
drivers/rtc/rtc-proc.c new file +6
-0+static void rtc_proc_remove_device (struct class_device *class_dev, + struct class_interface *class_intf) +{ + down(&rtc_sem); + if (rtc_dev == class_dev) { + remove_proc_entry("driver/rtc", NULL);
Quoted 8 lines
Quoted 4 lines
+ rtc_dev = NULL;
+ }
+ up(&rtc_sem);
+}What if I happen to remove (unregister) rtc devices in order other than they were registered in? You need a counter there instead of storing the first device created.
Only the first device that registers will get the /proc/driver/rtc entry, which will be removed when the driver unregisters.
/proc/driver/rtc is a legacy interface, thus supporting it for more than one RTC is useless. Any system that uses more than one RTCs should access them via /dev/rtcX or via sysfs.
Signature · 6 lines
Best regards, Alessandro Zummo, Tower Technologies - Turin, Italy http://www.towertech.it
Re: [PATCH 4/8] RTC subsystem, proc interface
Quoted 18 lines · Alessandro Zummo
Quoted 6 lines · On Sun, 8 Jan 2006 20:56:29 -0500 Dmitry Torokhov <[email protected]>…
Quoted 6 lines
drivers/rtc/rtc-proc.c new file +6
-0+static void rtc_proc_remove_device (struct class_device *class_dev, + struct class_interface *class_intf) +{ + down(&rtc_sem); + if (rtc_dev == class_dev) { + remove_proc_entry("driver/rtc", NULL);Quoted 8 lines
Quoted 4 lines
+ rtc_dev = NULL;
+ }
+ up(&rtc_sem);
+}What if I happen to remove (unregister) rtc devices in order other than they were registered in? You need a counter there instead of storing the first device created.
Quoted 8 lines
Only the first device that registers will get the
/proc/driver/rtcentry, which will be removed when the driver unregisters.
/proc/driver/rtcis a legacy interface, thus supporting it for more than one RTC is useless. Any system that uses more than one RTCs should access them via/dev/rtcXor via sysfs.
Oh, I see. Ignore me then...
Signature · 1 line
Dmitry
PATCH 5/8 RTC subsystem, dev interface
In reply to Alessandro ZummoThis patch adds the dev interface to the RTC
subsystem.
The first RTC driver that registers with the class will be available under /dev/rtc .
--
drivers/rtc/Kconfig | 11 + drivers/rtc/Makefile | 1 drivers/rtc/rtc-dev.c | 372 ++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 384 insertions(+)
drivers/rtc/rtc-dev.c new file +372 -0
@@ -0,0 +1,372 @@ +/* +* RTC subsystem, dev interface +* +* Copyright (C) 2005 Tower Technologies +* Author: Alessandro Zummo <[email protected]> +* +* based on arch/arm/common/rtctime.c +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation; version 2 of the License. +*/ + +#include <linux/module.h> +#include <linux/rtc.h> + +static dev_t rtc_devt; + +#define RTC_DEV_MAX 16/* 16 RTCs should be enough for everyone... */ + +static int rtc_dev_open (struct inode *inode,struct file *file) +{ +int err; +struct rtc_device *rtc =container_of (inode->i_cdev, + struct rtc_device, char_dev); +struct rtc_class_ops *ops = rtc->ops; + +/* We keep the lock as long as the device is in use +* and return immediately if busy +*/ +if (down_trylock (&rtc->char_sem)) +return -EBUSY ; + + file->private_data = &rtc->class_dev; + + err = ops->open ? ops->open (rtc->class_dev.dev) :0 ; +if (err ==0 ) { + +spin_lock_irq (&rtc->irq_lock); + rtc->irq_data =0 ; +spin_unlock_irq (&rtc->irq_lock); + +return 0 ; + } + +/* something has gone wrong, release the lock */ +up (&rtc->char_sem); +return err; +} + + +static ssize_t +rtc_dev_read (struct file *file,char __user *buf,size_t count,loff_t *ppos) +{ +struct rtc_device *rtc =to_rtc_device (file->private_data); + +DECLARE_WAITQUEUE (wait, current); +unsigned long data; +ssize_t ret; + +if (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 (); + }while (1 ); +set_current_state (TASK_RUNNING ); +remove_wait_queue (&rtc->irq_queue, &wait); + +if (ret ==0 ) { + ret =put_user (data, (unsigned long __user *)buf); +if (ret ==0 ) + ret =sizeof (unsigned long ); + } +return ret; +} + +static unsigned int rtc_dev_poll (struct file *file,poll_table *wait) +{ +struct rtc_device *rtc =to_rtc_device (file->private_data); +unsigned long data; + +poll_wait (file, &rtc->irq_queue, wait); + +spin_lock_irq (&rtc->irq_lock); + data = rtc->irq_data; +spin_unlock_irq (&rtc->irq_lock); + +return data !=0 ?POLLIN |POLLRDNORM :0 ; +} + +static int rtc_dev_ioctl (struct inode *inode,struct file *file,unsigned int cmd, +unsigned long arg) +{ +int err =0 ; +struct class_device *class_dev = file->private_data; +struct rtc_device *rtc =to_rtc_device (class_dev); +struct rtc_class_ops *ops = rtc->ops; +struct rtc_time tm; +struct rtc_wkalrm alarm; +void __user *uarg = (void __user *) arg; + +/* avoid conflicting IRQ users */ +if (cmd ==RTC_PIE_ON || cmd ==RTC_PIE_OFF || cmd ==RTC_IRQP_SET ) { +spin_lock (&rtc->irq_task_lock); +if (rtc->irq_task) + err = -EBUSY ; +spin_unlock (&rtc->irq_task_lock); + +if (err <0 ) +return err; + } + +/* try the driver's ioctl interface */ +if (ops->ioctl) { + err = ops->ioctl (class_dev->dev, cmd, arg); +if (err <0 && err != -EINVAL ) +return err; + } + +/* if the driver does not provide the ioctl interface +* or if that particular ioctl was not implemented +* (-EINVAL), we will try to emulate here. +*/ + +switch (cmd) { +case RTC_ALM_READ : +if ((err =rtc_read_alarm (class_dev, &alarm)) <0 ) +return err; + +if ((err =copy_to_user (uarg, &alarm.time,sizeof (tm)))) +return -EFAULT ; +break ; + +case RTC_ALM_SET : +if ((err =copy_from_user (&alarm.time, uarg,sizeof (tm)))) +return -EFAULT ; + + alarm.enabled =0 ; + alarm.pending =0 ; + alarm.time.tm_mday =-1 ; + alarm.time.tm_mon =-1 ; + alarm.time.tm_year =-1 ; + alarm.time.tm_wday =-1 ; + alarm.time.tm_yday =-1 ; + alarm.time.tm_isdst =-1 ; + err =rtc_set_alarm (class_dev, &alarm); +break ; + +case RTC_RD_TIME : +if ((err =rtc_read_time (class_dev, &tm)) <0 ) +return err; + +if ((err =copy_to_user (uarg, &tm,sizeof (tm)))) +return -EFAULT ; +break ; + +case RTC_SET_TIME : +if (!capable (CAP_SYS_TIME )) +return -EACCES ; + +if ((err =copy_from_user (&tm, uarg,sizeof (tm)))) +return -EFAULT ; + + err =rtc_set_time (class_dev, &tm); +break ; +#if 0 +case RTC_EPOCH_SET : +#ifndef rtc_epoch +/* +* There were no RTC clocks before 1900. +*/ +if (arg <1900 ) { + err = -EINVAL ; +break ; + } +if (!capable (CAP_SYS_TIME )) { + err = -EACCES ; +break ; + } + rtc_epoch = arg; + err =0 ; +#endif +break ; + +case RTC_EPOCH_READ : + err =put_user (rtc_epoch, (unsigned long __user *)uarg); +break ; +#endif +case RTC_WKALM_SET : +if ((err =copy_from_user (&alarm, uarg,sizeof (alarm)))) +return -EFAULT ; + + err =rtc_set_alarm (class_dev, &alarm); +break ; + +case RTC_WKALM_RD : +if ((err =rtc_read_alarm (class_dev, &alarm)) <0 ) +return err; + +if ((err =copy_to_user (uarg, &alarm,sizeof (alarm)))) +return -EFAULT ; +break ; + +default : + err = -EINVAL ; +break ; + } + +return err; +} + +static int rtc_dev_release (struct inode *inode,struct file *file) +{ +struct rtc_device *rtc =to_rtc_device (file->private_data); + +if (rtc->ops->release) + rtc->ops->release (rtc->class_dev.dev); + +spin_lock_irq (&rtc->irq_lock); + rtc->irq_data =0 ; +spin_unlock_irq (&rtc->irq_lock); + +up (&rtc->char_sem); +return 0 ; +} + +static int rtc_dev_fasync (int fd,struct file *file,int on) +{ +struct rtc_device *rtc =to_rtc_device (file->private_data); +return fasync_helper (fd, file, on, &rtc->async_queue); +} + +static struct file_operations rtc_dev_fops = { + .owner =THIS_MODULE , + .llseek = no_llseek, + .read = rtc_dev_read, + .poll = rtc_dev_poll, + .ioctl = rtc_dev_ioctl, + .open = rtc_dev_open, + .release = rtc_dev_release, + .fasync = rtc_dev_fasync, +}; + +static ssize_t rtc_dev_show_dev (struct class_device *class_dev,char *buf) +{ +return print_dev_t (buf, class_dev->devt); +} +static CLASS_DEVICE_ATTR(dev, S_IRUGO, rtc_dev_show_dev, NULL); + +/* insertion/removal hooks */ + +static int rtc_dev_add_device (struct class_device *class_dev, +struct class_interface *class_intf) +{ +struct rtc_device *rtc =to_rtc_device (class_dev); + +if (rtc->id >=RTC_DEV_MAX ) { +dev_err (class_dev->dev,"too many RTCs\n" ); +return -EINVAL ; + } + +init_MUTEX (&rtc->char_sem); +spin_lock_init (&rtc->irq_lock); +init_waitqueue_head (&rtc->irq_queue); + +cdev_init (&rtc->char_dev, &rtc_dev_fops); + rtc->char_dev.owner = rtc->owner; + class_dev->devt =MKDEV (MAJOR (rtc_devt), rtc->id); + +if (cdev_add (&rtc->char_dev, class_dev->devt,1 )) { +cdev_del (&rtc->char_dev); + +dev_err (class_dev->dev, +"failed to add char device %d:%d\n" , +MAJOR (class_dev->devt), +MINOR (class_dev->devt)); + + class_dev->devt =MKDEV (0 ,0 ); +return -ENODEV ; + } + +class_device_create_file (class_dev, &class_device_attr_dev); + +dev_info (class_dev->dev,"rtc intf: dev (%d:%d)\n" , +MAJOR (class_dev->devt), +MINOR (class_dev->devt)); + +kobject_hotplug (&class_dev->kobj,KOBJ_ADD ); + +return 0 ; +} + +static void rtc_dev_remove_device (struct class_device *class_dev, +struct class_interface *class_intf) +{ +struct rtc_device *rtc =to_rtc_device (class_dev); + +class_device_remove_file (class_dev, &class_device_attr_dev); + +if (MAJOR (class_dev->devt)) { +dev_dbg (class_dev->dev,"removing char %d:%d\n" , +MAJOR (class_dev->devt), +MINOR (class_dev->devt)); +cdev_del (&rtc->char_dev); + +kobject_hotplug (&class_dev->kobj,KOBJ_REMOVE ); + + class_dev->devt =MKDEV (0 ,0 ); + } +} + +/* interface registration */ + +struct class_interface rtc_dev_interface = { + .add = &rtc_dev_add_device, + .remove = &rtc_dev_remove_device, +}; + +static int __init rtc_dev_init (void ) +{ +int err; + +if ((err =alloc_chrdev_region (&rtc_devt,0 ,RTC_DEV_MAX ,"rtc" )) <0 ) { +printk (KERN_ERR "%s: failed to allocate char dev region\n" , + __FILE__); +return err; + } + +if ((err =rtc_interface_register (&rtc_dev_interface)) <0 ) { +printk (KERN_ERR "%s: failed to register the interface\n" , + __FILE__); +unregister_chrdev_region (rtc_devt,RTC_DEV_MAX ); +return err; + } + +return 0 ; +} + +static void __exit rtc_dev_exit(void) +{ +class_interface_unregister (&rtc_dev_interface); + +unregister_chrdev_region (rtc_devt,RTC_DEV_MAX ); +} + +module_init (rtc_dev_init); +module_exit (rtc_dev_exit); + +MODULE_AUTHOR ("Alessandro Zummo <[email protected]>" ); +MODULE_DESCRIPTION ("RTC class dev interface" ); +MODULE_LICENSE ("GPL" );
drivers/rtc/Kconfig +11 -0
@@ -41,6 +41,17 @@ config RTC_INTF_PROC This driver can also be built as a module. If so, the module will be called rtc-proc. +config RTC_INTF_DEV + tristate "dev" + depends on RTC_CLASS + default RTC_CLASS + help + Say yes here if you want to use your RTC using the dev + interface, /dev/rtc . + + This driver can also be built as a module. If so, the module + will be called rtc-dev. + comment "RTC drivers" depends on RTC_CLASS
drivers/rtc/Makefile +1 -0
@@ -7,3 +7,4 @@ obj-$(CONFIG_RTC_CLASS) += rtc-core.o rtc-core-y := class.o interface.o obj-$(CONFIG_RTC_INTF_SYSFS) += rtc-sysfs.o obj-$(CONFIG_RTC_INTF_PROC) += rtc-proc.o +obj-$(CONFIG_RTC_INTF_DEV) += rtc-dev.o
--
Re: [PATCH 5/8] RTC subsystem, dev interface
Quoted 4 lines · Alessandro Zummo
drivers/rtc/rtc-dev.c new file +4
-0+ +static int rtc_dev_open (struct inode *inode,struct file *file) +{ +int err;
drivers/rtc/rtc-dev.c line 33
Quoted 10 lines
drivers/rtc/rtc-dev.c new file +10
-0+struct rtc_device *rtc =container_of (inode->i_cdev, + struct rtc_device, char_dev); +struct rtc_class_ops *ops = rtc->ops; + +/* We keep the lock as long as the device is in use +* and return immediately if busy +*/ +if (down_trylock (&rtc->char_sem)) +return -EBUSY ; +
Does the device have to be opened for exclusively? Can it support concurrent reads?
Quoted 46 lines
drivers/rtc/rtc-dev.c new file +46
-0+ file->private_data = &rtc->class_dev; + + err = ops->open ? ops->open (rtc->class_dev.dev) :0 ; +if (err ==0 ) { + +spin_lock_irq (&rtc->irq_lock); + rtc->irq_data =0 ; +spin_unlock_irq (&rtc->irq_lock); + +return 0 ; + } + +/* something has gone wrong, release the lock */ +up (&rtc->char_sem); +return err; +} + + +static ssize_t +rtc_dev_read (struct file *file,char __user *buf,size_t count,loff_t *ppos) +{ +struct rtc_device *rtc =to_rtc_device (file->private_data); + +DECLARE_WAITQUEUE (wait, current); +unsigned long data; +ssize_t ret; + +if (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;
drivers/rtc/rtc-dev.c line 89
Quoted 10 lines
drivers/rtc/rtc-dev.c new file +10
-0+ } +if (signal_pending (current)) { + ret = -ERESTARTSYS ; +break ; + } +schedule (); + }while (1 ); +set_current_state (TASK_RUNNING ); +remove_wait_queue (&rtc->irq_queue, &wait); +
The above looks very much like open-coded wait_event_interruptible();
Quoted 11 lines
drivers/rtc/rtc-dev.c new file +11
-0+if (ret ==0 ) { + ret =put_user (data, (unsigned long __user *)buf); +if (ret ==0 ) + ret =sizeof (unsigned long ); + } +return ret; +} + +static unsigned int rtc_dev_poll (struct file *file,poll_table *wait) +{ +struct rtc_device *rtc =to_rtc_device (file->private_data);
drivers/rtc/rtc-dev.c line 110
Quoted 10 lines
drivers/rtc/rtc-dev.c new file +10
-0+unsigned long data; + +poll_wait (file, &rtc->irq_queue, wait); + +spin_lock_irq (&rtc->irq_lock); + data = rtc->irq_data; +spin_unlock_irq (&rtc->irq_lock); + +return data !=0 ?POLLIN |POLLRDNORM :0 ; +}
What does the lock above protect? Once it is released rtc->irq_data may change so reader that was woken up may not see any data anyway.
Quoted 122 lines
drivers/rtc/rtc-dev.c new file +122
-0+static int rtc_dev_ioctl (struct inode *inode,struct file *file,unsigned int cmd, +unsigned long arg) +{ +int err =0 ; +struct class_device *class_dev = file->private_data; +struct rtc_device *rtc =to_rtc_device (class_dev); +struct rtc_class_ops *ops = rtc->ops; +struct rtc_time tm; +struct rtc_wkalrm alarm; +void __user *uarg = (void __user *) arg; + +/* avoid conflicting IRQ users */ +if (cmd ==RTC_PIE_ON || cmd ==RTC_PIE_OFF || cmd ==RTC_IRQP_SET ) { +spin_lock (&rtc->irq_task_lock); +if (rtc->irq_task) + err = -EBUSY ; +spin_unlock (&rtc->irq_task_lock); + +if (err <0 ) +return err; + } + +/* try the driver's ioctl interface */ +if (ops->ioctl) { + err = ops->ioctl (class_dev->dev, cmd, arg); +if (err <0 && err != -EINVAL ) +return err; + } + +/* if the driver does not provide the ioctl interface +* or if that particular ioctl was not implemented +* (-EINVAL), we will try to emulate here. +*/ + +switch (cmd) { +case RTC_ALM_READ : +if ((err =rtc_read_alarm (class_dev, &alarm)) <0 ) +return err; + +if ((err =copy_to_user (uarg, &alarm.time,sizeof (tm)))) +return -EFAULT ; +break ; + +case RTC_ALM_SET : +if ((err =copy_from_user (&alarm.time, uarg,sizeof (tm)))) +return -EFAULT ; + + alarm.enabled =0 ; + alarm.pending =0 ; + alarm.time.tm_mday =-1 ; + alarm.time.tm_mon =-1 ; + alarm.time.tm_year =-1 ; + alarm.time.tm_wday =-1 ; + alarm.time.tm_yday =-1 ; + alarm.time.tm_isdst =-1 ; + err =rtc_set_alarm (class_dev, &alarm); +break ; + +case RTC_RD_TIME : +if ((err =rtc_read_time (class_dev, &tm)) <0 ) +return err; + +if ((err =copy_to_user (uarg, &tm,sizeof (tm)))) +return -EFAULT ; +break ; + +case RTC_SET_TIME : +if (!capable (CAP_SYS_TIME )) +return -EACCES ; + +if ((err =copy_from_user (&tm, uarg,sizeof (tm)))) +return -EFAULT ; + + err =rtc_set_time (class_dev, &tm); +break ; +#if 0 +case RTC_EPOCH_SET : +#ifndef rtc_epoch +/* +* There were no RTC clocks before 1900. +*/ +if (arg <1900 ) { + err = -EINVAL ; +break ; + } +if (!capable (CAP_SYS_TIME )) { + err = -EACCES ; +break ; + } + rtc_epoch = arg; + err =0 ; +#endif +break ; + +case RTC_EPOCH_READ : + err =put_user (rtc_epoch, (unsigned long __user *)uarg); +break ; +#endif +case RTC_WKALM_SET : +if ((err =copy_from_user (&alarm, uarg,sizeof (alarm)))) +return -EFAULT ; + + err =rtc_set_alarm (class_dev, &alarm); +break ; + +case RTC_WKALM_RD : +if ((err =rtc_read_alarm (class_dev, &alarm)) <0 ) +return err; + +if ((err =copy_to_user (uarg, &alarm,sizeof (alarm)))) +return -EFAULT ; +break ; + +default : + err = -EINVAL ; +break ; + } + +return err; +} + +static int rtc_dev_release (struct inode *inode,struct file *file)
drivers/rtc/rtc-dev.c line 243
Quoted 10 lines
drivers/rtc/rtc-dev.c new file +10
-0+{ +struct rtc_device *rtc =to_rtc_device (file->private_data); + +if (rtc->ops->release) + rtc->ops->release (rtc->class_dev.dev); + +spin_lock_irq (&rtc->irq_lock); + rtc->irq_data =0 ; +spin_unlock_irq (&rtc->irq_lock); +
Why is the above needed?
Quoted 57 lines
drivers/rtc/rtc-dev.c new file +57
-0+up (&rtc->char_sem); +return 0 ; +} + +static int rtc_dev_fasync (int fd,struct file *file,int on) +{ +struct rtc_device *rtc =to_rtc_device (file->private_data); +return fasync_helper (fd, file, on, &rtc->async_queue); +} + +static struct file_operations rtc_dev_fops = { + .owner =THIS_MODULE , + .llseek = no_llseek, + .read = rtc_dev_read, + .poll = rtc_dev_poll, + .ioctl = rtc_dev_ioctl, + .open = rtc_dev_open, + .release = rtc_dev_release, + .fasync = rtc_dev_fasync, +}; + +static ssize_t rtc_dev_show_dev (struct class_device *class_dev,char *buf) +{ +return print_dev_t (buf, class_dev->devt); +} +static CLASS_DEVICE_ATTR(dev, S_IRUGO, rtc_dev_show_dev, NULL); + +/* insertion/removal hooks */ + +static int rtc_dev_add_device (struct class_device *class_dev, +struct class_interface *class_intf) +{ +struct rtc_device *rtc =to_rtc_device (class_dev); + +if (rtc->id >=RTC_DEV_MAX ) { +dev_err (class_dev->dev,"too many RTCs\n" ); +return -EINVAL ; + } + +init_MUTEX (&rtc->char_sem); +spin_lock_init (&rtc->irq_lock); +init_waitqueue_head (&rtc->irq_queue); + +cdev_init (&rtc->char_dev, &rtc_dev_fops); + rtc->char_dev.owner = rtc->owner; + class_dev->devt =MKDEV (MAJOR (rtc_devt), rtc->id); + +if (cdev_add (&rtc->char_dev, class_dev->devt,1 )) { +cdev_del (&rtc->char_dev); + +dev_err (class_dev->dev, +"failed to add char device %d:%d\n" , +MAJOR (class_dev->devt), +MINOR (class_dev->devt)); + + class_dev->devt =MKDEV (0 ,0 ); +return -ENODEV ;
drivers/rtc/rtc-dev.c line 310
Quoted 10 lines
drivers/rtc/rtc-dev.c new file +10
-0+ } + +class_device_create_file (class_dev, &class_device_attr_dev); + +dev_info (class_dev->dev,"rtc intf: dev (%d:%d)\n" , +MAJOR (class_dev->devt), +MINOR (class_dev->devt)); + +kobject_hotplug (&class_dev->kobj,KOBJ_ADD ); +
This is kobject_hotplug abuse; you are not adding a new object here.
Quoted 8 lines
drivers/rtc/rtc-dev.c new file +8
-0+return 0 ; +} + +static void rtc_dev_remove_device (struct class_device *class_dev, +struct class_interface *class_intf) +{ +struct rtc_device *rtc =to_rtc_device (class_dev); +
drivers/rtc/rtc-dev.c line 328
Quoted 10 lines
drivers/rtc/rtc-dev.c new file +10
-0+class_device_remove_file (class_dev, &class_device_attr_dev); + +if (MAJOR (class_dev->devt)) { +dev_dbg (class_dev->dev,"removing char %d:%d\n" , +MAJOR (class_dev->devt), +MINOR (class_dev->devt)); +cdev_del (&rtc->char_dev); + +kobject_hotplug (&class_dev->kobj,KOBJ_REMOVE ); +
Same here...
drivers/rtc/rtc-dev.c line 339
Quoted 11 lines
drivers/rtc/rtc-dev.c new file +11
-0+ class_dev->devt =MKDEV (0 ,0 ); + } +} + +/* interface registration */ + +struct class_interface rtc_dev_interface = { + .add = &rtc_dev_add_device, + .remove = &rtc_dev_remove_device, +}; +
I wonder if doing rtc dev as a class device interface is a good idea. It may be cleaner to fold it into the core.
Quoted 68 lines
drivers/rtc/rtc-dev.c new file +33
-0+static int __init rtc_dev_init (void ) +{ +int err; + +if ((err =alloc_chrdev_region (&rtc_devt,0 ,RTC_DEV_MAX ,"rtc" )) <0 ) { +printk (KERN_ERR "%s: failed to allocate char dev region\n" , + __FILE__); +return err; + } + +if ((err =rtc_interface_register (&rtc_dev_interface)) <0 ) { +printk (KERN_ERR "%s: failed to register the interface\n" , + __FILE__); +unregister_chrdev_region (rtc_devt,RTC_DEV_MAX ); +return err; + } + +return 0 ; +} + +static void __exit rtc_dev_exit(void) +{ +class_interface_unregister (&rtc_dev_interface); + +unregister_chrdev_region (rtc_devt,RTC_DEV_MAX ); +} + +module_init (rtc_dev_init); +module_exit (rtc_dev_exit); + +MODULE_AUTHOR ("Alessandro Zummo <[email protected]>" ); +MODULE_DESCRIPTION ("RTC class dev interface" ); +MODULE_LICENSE ("GPL" );drivers/rtc/Kconfig +11
-0@@ -41,6 +41,17 @@ config RTC_INTF_PROC This driver can also be built as a module. If so, the module will be called rtc-proc. +config RTC_INTF_DEV + tristate "dev" + depends on RTC_CLASS + default RTC_CLASS + help + Say yes here if you want to use your RTC using the dev + interface, /dev/rtc . + + This driver can also be built as a module. If so, the module + will be called rtc-dev. + comment "RTC drivers" depends on RTC_CLASSdrivers/rtc/Makefile +1
-2@@ -7,3 +7,4 @@ obj-$(CONFIG_RTC_CLASS) += rtc-core.o rtc-core-y := class.o interface.o obj-$(CONFIG_RTC_INTF_SYSFS) += rtc-sysfs.o obj-$(CONFIG_RTC_INTF_PROC) += rtc-proc.o +obj-$(CONFIG_RTC_INTF_DEV) += rtc-dev.o -- -To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Signature · 1 line
Dmitry
Re: [PATCH 5/8] RTC subsystem, dev interface
On Sun, 8 Jan 2006 21:50:21 -0500
Dmitry Torokhov <[email protected]> wrote:
Hi,
I will reply in two different emails as I need
to do some research on some questions of yours.
Quoted 6 lines
drivers/rtc/rtc-dev.c line 33
Quoted 3 lines
drivers/rtc/rtc-dev.c new file +3
-0+if (down_trylock (&rtc->char_sem)) +return -EBUSY ; +Does the device have to be opened for exclusively? Can it support concurrent reads?
I'm trying to make the things work the same way as with the old interface. Once this new code will be as stable as the old one, new features can be added.
Concurrent reads are certainly possible, but we'd need to lock out writes in proper places, and I do not feel safe to do it at this stage.
[..]
Quoted 11 lines
drivers/rtc/rtc-dev.c line 89
Quoted 8 lines
drivers/rtc/rtc-dev.c new file +8
-0+ ret = -ERESTARTSYS ; +break ; + } +schedule (); + }while (1 ); +set_current_state (TASK_RUNNING ); +remove_wait_queue (&rtc->irq_queue, &wait); +The above looks very much like open-coded
wait_event_interruptible();
Ditto, plus there's the irq data inside
Quoted 4 lines
drivers/rtc/rtc-dev.c line 310
Quoted 2 lines
drivers/rtc/rtc-dev.c new file +2
-0+kobject_hotplug (&class_dev->kobj,KOBJ_ADD ); +This is
kobject_hotplugabuse; you are not adding a new object here.
Yes. But I've checked the code and should not harm. I've asked for that a couple of weeks ago in this same mailing list and got no answer. If there's a working alternative to obtain the same result, I'm obviously willing to try.
Quoted 10 lines
drivers/rtc/rtc-dev.c line 339
Quoted 7 lines
drivers/rtc/rtc-dev.c new file +7
-0+/* interface registration */ + +struct class_interface rtc_dev_interface = { + .add = &rtc_dev_add_device, + .remove = &rtc_dev_remove_device, +}; +I wonder if doing rtc dev as a class device interface is a good idea. It may be cleaner to fold it into the core.
What the code implements is actually an interface, so this should be the riht place. It is also fully optional, everything could work without it. Probably the interface implementation hasn't all the primitives to handle this kind of work, but I'm not willing to go into that right now ;)
Thank you for your hard work Dmitry, after weeks viewing the same code I'm going to be lost in all of those locks issues ;)
Signature · 6 lines
Best regards, Alessandro Zummo, Tower Technologies - Turin, Italy http://www.towertech.it
Re: [PATCH 5/8] RTC subsystem, dev interface
Quoted 11 lines · Alessandro Zummo
Quoted 10 lines
drivers/rtc/rtc-dev.c line 339
Quoted 7 lines
drivers/rtc/rtc-dev.c new file +7
-0+/* interface registration */ + +struct class_interface rtc_dev_interface = { + .add = &rtc_dev_add_device, + .remove = &rtc_dev_remove_device, +}; +I wonder if doing rtc dev as a class device interface is a good idea. It may be cleaner to fold it into the core.
Quoted 5 lines
What the code implements is actually an interface, so this should be the riht place. It is also fully optional, everything could work without it. Probably the interface implementation hasn't all the primitives to handle this kind of work, but I'm not willing to go into that right now ;)
Yes, it is an interface. What I am trying to say - is it a main interface? What is the preferred, most efficient way to interface with RTC? If it is through this interface it may make sence to fold it into the core. Otherwise do what input layer does and have interface create another class device which reprsesents your /dev node.
Signature · 1 line
Dmitry
Re: [PATCH 5/8] RTC subsystem, dev interface
Quoted 11 lines · On Mon, 9 Jan 2006 01:39:29 -0500 Dmitry Torokhov <[email protected]>…
Quoted 5 lines
What the code implements is actually an interface, so this should be the riht place. It is also fully optional, everything could work without it. Probably the interface implementation hasn't all the primitives to handle this kind of work, but I'm not willing to go into that right now ;)
Yes, it is an interface. What I am trying to say - is it a main interface? What is the preferred, most efficient way to interface with RTC? If it is through this interface it may make sence to fold it into the core. Otherwise do what input layer does and have interface create another class device which reprsesents your /dev node.
I think it depends on what you want to do. On desktop systems is certainly the dev interface, on some embedded you may want to go via sysfs.
I would keep it that way until the system can react on a change of the dev attribute.
Signature · 6 lines
Best regards, Alessandro Zummo, Tower Technologies - Turin, Italy http://www.towertech.it
PATCH 6/8 RTC subsystem, X1205 driver
In reply to Alessandro ZummoThis patch is a port of the existing x1205 driver under the new RTC subsystem.
It is actually under test within the NSLU2 project (http://www.nslu2-linux.org) and it is working quite well.
It is the first driver under this new subsystem and should be used as a guide to port other drivers.
Ideally, at some point in the future, all RTC drivers will reside under linux/rtc.
--
drivers/rtc/Kconfig | 10 drivers/rtc/Makefile | 3 drivers/rtc/rtc-x1205.c | 725 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 738 insertions(+)
drivers/rtc/Kconfig +10 -0
@@ -55,4 +55,14 @@ config RTC_INTF_DEV comment "RTC drivers" depends on RTC_CLASS +config RTC_DRV_X1205 + tristate "Xicor/Intersil X1205 RTC chip" + depends on RTC_CLASS && I2C + help + If you say yes here you get support for the + Xicor/Intersil X1205 RTC chip. + + This driver can also be built as a module. If so, the module + will be called rtc-x1205. + endmenu
drivers/rtc/Makefile +3 -0
@@ -8,3 +8,6 @@ rtc-core-y := class.o interface.o obj-$(CONFIG_RTC_INTF_SYSFS) += rtc-sysfs.o obj-$(CONFIG_RTC_INTF_PROC) += rtc-proc.o obj-$(CONFIG_RTC_INTF_DEV) += rtc-dev.o + +obj-$(CONFIG_RTC_DRV_X1205) += rtc-x1205.o +
drivers/rtc/rtc-x1205.c new file +725 -0
725 lines not on this page · raw message
--
PATCH 7/8 RTC subsystem, test device/driver
In reply to Alessandro ZummoInterrupts can be generated by
echo "alarm|tick|update" >/sys/class/rtc/rtcX/device/irq
--
drivers/rtc/Kconfig | 15 +++ drivers/rtc/Makefile | 1 drivers/rtc/rtc-test.c | 206 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 222 insertions(+)
drivers/rtc/Kconfig +15 -0
@@ -65,4 +65,19 @@ config RTC_DRV_X1205 This driver can also be built as a module. If so, the module will be called rtc-x1205. +config RTC_DRV_TEST + tristate "Test driver/device" + depends on RTC_CLASS + help + If you say yes here you get support for the + RTC test driver. It's a software RTC which can be + used to test the RTC subsystem APIs. It gets + the time from the system clock. + You want this driver only if you are doing development + on the RTC subsystem. Please read the source code + for further details. + + This driver can also be built as a module. If so, the module + will be called rtc-test. + endmenu
drivers/rtc/Makefile +1 -0
@@ -10,4 +10,5 @@ obj-$(CONFIG_RTC_INTF_PROC) += rtc-proc. obj-$(CONFIG_RTC_INTF_DEV) += rtc-dev.o obj-$(CONFIG_RTC_DRV_X1205) += rtc-x1205.o +obj-$(CONFIG_RTC_DRV_TEST) += rtc-test.o
drivers/rtc/rtc-test.c new file +206 -0
206 lines not on this page · raw message
--
PATCH 8/8 RTC subsystem, DS1672 driver
In reply to Alessandro ZummoDriver for the Dallas/Maxim DS1672 chip, found
on the Loft (http://www.giantshoulderinc.com) .
--
drivers/rtc/Kconfig | 10 + drivers/rtc/Makefile | 1 drivers/rtc/rtc-ds1672.c | 266 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 277 insertions(+)
drivers/rtc/Kconfig +10 -0
@@ -65,6 +65,16 @@ config RTC_DRV_X1205 This driver can also be built as a module. If so, the module will be called rtc-x1205. +config RTC_DRV_DS1672 + tristate "Dallas/Maxim DS1672" + depends on RTC_CLASS && I2C + help + If you say yes here you get support for the + Dallas/Maxim DS1672 timekeeping chip. + + This driver can also be built as a module. If so, the module + will be called rtc-ds1672. + config RTC_DRV_TEST tristate "Test driver/device" depends on RTC_CLASS
drivers/rtc/Makefile +1 -0
@@ -11,4 +11,5 @@ obj-$(CONFIG_RTC_INTF_DEV) += rtc-dev.o obj-$(CONFIG_RTC_DRV_X1205) += rtc-x1205.o obj-$(CONFIG_RTC_DRV_TEST) += rtc-test.o +obj-$(CONFIG_RTC_DRV_DS1672) += rtc-ds1672.o
drivers/rtc/rtc-ds1672.c new file +266 -0
266 lines not on this page · raw message
--