Eric Lee / smarc-fsl-linux-kernel

Commit 4ae0ff16efeffe7d06726fd3022cdb2f3e9e6892

Authored by Linus Torvalds 14 years ago

Exists in master and in 39 other branches

Merge branch 'timer-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kerne…

…l/git/tip/linux-2.6-tip

* 'timer-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip:
  RTC: rtc-omap: Fix a leak of the IRQ during init failure
  posix clocks: Replace mutex with reader/writer semaphore

Showing 3 changed files Inline Diff

drivers/rtc/rtc-omap.c
include/linux/posix-clock.h
kernel/time/posix-clock.c

drivers/rtc/rtc-omap.c

Diff comments View file @ 4ae0ff1

include/linux/posix-clock.h

Diff comments View file @ 4ae0ff1

 /*
  * posix-clock.h - support for dynamic clock devices
  *
  * Copyright (C) 2010 OMICRON electronics GmbH
  *
  *  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; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 #ifndef _LINUX_POSIX_CLOCK_H_
 #define _LINUX_POSIX_CLOCK_H_
 #include <linux/cdev.h>
 #include <linux/fs.h>
 #include <linux/poll.h>
 #include <linux/posix-timers.h>
+#include <linux/rwsem.h>
 struct posix_clock;
 /**
  * struct posix_clock_operations - functional interface to the clock
  *
  * Every posix clock is represented by a character device. Drivers may
  * optionally offer extended capabilities by implementing the
  * character device methods. The character device file operations are
  * first handled by the clock device layer, then passed on to the
  * driver by calling these functions.
  *
  * @owner:          The clock driver should set to THIS_MODULE
  * @clock_adjtime:  Adjust the clock
  * @clock_gettime:  Read the current time
  * @clock_getres:   Get the clock resolution
  * @clock_settime:  Set the current time value
  * @timer_create:   Create a new timer
  * @timer_delete:   Remove a previously created timer
  * @timer_gettime:  Get remaining time and interval of a timer
  * @timer_setttime: Set a timer's initial expiration and interval
  * @fasync:         Optional character device fasync method
  * @mmap:           Optional character device mmap method
  * @open:           Optional character device open method
  * @release:        Optional character device release method
  * @ioctl:          Optional character device ioctl method
  * @read:           Optional character device read method
  * @poll:           Optional character device poll method
  */
 struct posix_clock_operations {
 	struct module *owner;
 	int  (*clock_adjtime)(struct posix_clock *pc, struct timex *tx);
 	int  (*clock_gettime)(struct posix_clock *pc, struct timespec *ts);
 	int  (*clock_getres) (struct posix_clock *pc, struct timespec *ts);
 	int  (*clock_settime)(struct posix_clock *pc,
 			      const struct timespec *ts);
 	int  (*timer_create) (struct posix_clock *pc, struct k_itimer *kit);
 	int  (*timer_delete) (struct posix_clock *pc, struct k_itimer *kit);
 	void (*timer_gettime)(struct posix_clock *pc,
 			      struct k_itimer *kit, struct itimerspec *tsp);
 	int  (*timer_settime)(struct posix_clock *pc,
 			      struct k_itimer *kit, int flags,
 			      struct itimerspec *tsp, struct itimerspec *old);
 	/*
 	 * Optional character device methods:
 	 */
 	int     (*fasync)  (struct posix_clock *pc,
 			    int fd, struct file *file, int on);
 	long    (*ioctl)   (struct posix_clock *pc,
 			    unsigned int cmd, unsigned long arg);
 	int     (*mmap)    (struct posix_clock *pc,
 			    struct vm_area_struct *vma);
 	int     (*open)    (struct posix_clock *pc, fmode_t f_mode);
 	uint    (*poll)    (struct posix_clock *pc,
 			    struct file *file, poll_table *wait);
 	int     (*release) (struct posix_clock *pc);
 	ssize_t (*read)    (struct posix_clock *pc,
 			    uint flags, char __user *buf, size_t cnt);
 };
 /**
  * struct posix_clock - represents a dynamic posix clock
  *
  * @ops:     Functional interface to the clock
  * @cdev:    Character device instance for this clock
  * @kref:    Reference count.
- * @mutex:   Protects the 'zombie' field from concurrent access.
+ * @rwsem:   Protects the 'zombie' field from concurrent access.
  * @zombie:  If 'zombie' is true, then the hardware has disappeared.
  * @release: A function to free the structure when the reference count reaches
  *           zero. May be NULL if structure is statically allocated.
  *
  * Drivers should embed their struct posix_clock within a private
  * structure, obtaining a reference to it during callbacks using
  * container_of().
  */
 struct posix_clock {
 	struct posix_clock_operations ops;
 	struct cdev cdev;
 	struct kref kref;
-	struct mutex mutex;
+	struct rw_semaphore rwsem;
 	bool zombie;
 	void (*release)(struct posix_clock *clk);
 };
 /**
  * posix_clock_register() - register a new clock
  * @clk:   Pointer to the clock. Caller must provide 'ops' and 'release'
  * @devid: Allocated device id
  *
  * A clock driver calls this function to register itself with the
  * clock device subsystem. If 'clk' points to dynamically allocated
  * memory, then the caller must provide a 'release' function to free
  * that memory.
  *
  * Returns zero on success, non-zero otherwise.
  */
 int posix_clock_register(struct posix_clock *clk, dev_t devid);
 /**
  * posix_clock_unregister() - unregister a clock
  * @clk: Clock instance previously registered via posix_clock_register()
  *
  * A clock driver calls this function to remove itself from the clock
  * device subsystem. The posix_clock itself will remain (in an
  * inactive state) until its reference count drops to zero, at which
  * point it will be deallocated with its 'release' method.
  */
 void posix_clock_unregister(struct posix_clock *clk);
 #endif

kernel/time/posix-clock.c

Diff comments View file @ 4ae0ff1

1	/*	1	/*
2	* posix-clock.c - support for dynamic clock devices	2	* posix-clock.c - support for dynamic clock devices
3	*	3	*
4	* Copyright (C) 2010 OMICRON electronics GmbH	4	* Copyright (C) 2010 OMICRON electronics GmbH
5	*	5	*
6	* This program is free software; you can redistribute it and/or modify	6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by	7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 2 of the License, or	8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.	9	* (at your option) any later version.
10	*	10	*
11	* This program is distributed in the hope that it will be useful,	11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.	14	* GNU General Public License for more details.
15	*	15	*
16	* You should have received a copy of the GNU General Public License	16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software	17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	18	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19	*/	19	*/
20	#include <linux/device.h>	20	#include <linux/device.h>
21	#include <linux/file.h>	21	#include <linux/file.h>
22	#include <linux/mutex.h>
23	#include <linux/posix-clock.h>	22	#include <linux/posix-clock.h>
24	#include <linux/slab.h>	23	#include <linux/slab.h>
25	#include <linux/syscalls.h>	24	#include <linux/syscalls.h>
26	#include <linux/uaccess.h>	25	#include <linux/uaccess.h>
27		26
28	static void delete_clock(struct kref *kref);	27	static void delete_clock(struct kref *kref);
29		28
30	/*	29	/*
31	* Returns NULL if the posix_clock instance attached to 'fp' is old and stale.	30	* Returns NULL if the posix_clock instance attached to 'fp' is old and stale.
32	*/	31	*/
33	static struct posix_clock get_posix_clock(struct file fp)	32	static struct posix_clock get_posix_clock(struct file fp)
34	{	33	{
35	struct posix_clock *clk = fp->private_data;	34	struct posix_clock *clk = fp->private_data;
36		35
37	mutex_lock(&clk->mutex);	36	down_read(&clk->rwsem);
38		37
39	if (!clk->zombie)	38	if (!clk->zombie)
40	return clk;	39	return clk;
41		40
42	mutex_unlock(&clk->mutex);	41	up_read(&clk->rwsem);
43		42
44	return NULL;	43	return NULL;
45	}	44	}
46		45
47	static void put_posix_clock(struct posix_clock *clk)	46	static void put_posix_clock(struct posix_clock *clk)
48	{	47	{
49	mutex_unlock(&clk->mutex);	48	up_read(&clk->rwsem);
50	}	49	}
51		50
52	static ssize_t posix_clock_read(struct file fp, char __user buf,	51	static ssize_t posix_clock_read(struct file fp, char __user buf,
53	size_t count, loff_t *ppos)	52	size_t count, loff_t *ppos)
54	{	53	{
55	struct posix_clock *clk = get_posix_clock(fp);	54	struct posix_clock *clk = get_posix_clock(fp);
56	int err = -EINVAL;	55	int err = -EINVAL;
57		56
58	if (!clk)	57	if (!clk)
59	return -ENODEV;	58	return -ENODEV;
60		59
61	if (clk->ops.read)	60	if (clk->ops.read)
62	err = clk->ops.read(clk, fp->f_flags, buf, count);	61	err = clk->ops.read(clk, fp->f_flags, buf, count);
63		62
64	put_posix_clock(clk);	63	put_posix_clock(clk);
65		64
66	return err;	65	return err;
67	}	66	}
68		67
69	static unsigned int posix_clock_poll(struct file fp, poll_table wait)	68	static unsigned int posix_clock_poll(struct file fp, poll_table wait)
70	{	69	{
71	struct posix_clock *clk = get_posix_clock(fp);	70	struct posix_clock *clk = get_posix_clock(fp);
72	int result = 0;	71	int result = 0;
73		72
74	if (!clk)	73	if (!clk)
75	return -ENODEV;	74	return -ENODEV;
76		75
77	if (clk->ops.poll)	76	if (clk->ops.poll)
78	result = clk->ops.poll(clk, fp, wait);	77	result = clk->ops.poll(clk, fp, wait);
79		78
80	put_posix_clock(clk);	79	put_posix_clock(clk);
81		80
82	return result;	81	return result;
83	}	82	}
84		83
85	static int posix_clock_fasync(int fd, struct file *fp, int on)	84	static int posix_clock_fasync(int fd, struct file *fp, int on)
86	{	85	{
87	struct posix_clock *clk = get_posix_clock(fp);	86	struct posix_clock *clk = get_posix_clock(fp);
88	int err = 0;	87	int err = 0;
89		88
90	if (!clk)	89	if (!clk)
91	return -ENODEV;	90	return -ENODEV;
92		91
93	if (clk->ops.fasync)	92	if (clk->ops.fasync)
94	err = clk->ops.fasync(clk, fd, fp, on);	93	err = clk->ops.fasync(clk, fd, fp, on);
95		94
96	put_posix_clock(clk);	95	put_posix_clock(clk);
97		96
98	return err;	97	return err;
99	}	98	}
100		99
101	static int posix_clock_mmap(struct file fp, struct vm_area_struct vma)	100	static int posix_clock_mmap(struct file fp, struct vm_area_struct vma)
102	{	101	{
103	struct posix_clock *clk = get_posix_clock(fp);	102	struct posix_clock *clk = get_posix_clock(fp);
104	int err = -ENODEV;	103	int err = -ENODEV;
105		104
106	if (!clk)	105	if (!clk)
107	return -ENODEV;	106	return -ENODEV;
108		107
109	if (clk->ops.mmap)	108	if (clk->ops.mmap)
110	err = clk->ops.mmap(clk, vma);	109	err = clk->ops.mmap(clk, vma);
111		110
112	put_posix_clock(clk);	111	put_posix_clock(clk);
113		112
114	return err;	113	return err;
115	}	114	}
116		115
117	static long posix_clock_ioctl(struct file *fp,	116	static long posix_clock_ioctl(struct file *fp,
118	unsigned int cmd, unsigned long arg)	117	unsigned int cmd, unsigned long arg)
119	{	118	{
120	struct posix_clock *clk = get_posix_clock(fp);	119	struct posix_clock *clk = get_posix_clock(fp);
121	int err = -ENOTTY;	120	int err = -ENOTTY;
122		121
123	if (!clk)	122	if (!clk)
124	return -ENODEV;	123	return -ENODEV;
125		124
126	if (clk->ops.ioctl)	125	if (clk->ops.ioctl)
127	err = clk->ops.ioctl(clk, cmd, arg);	126	err = clk->ops.ioctl(clk, cmd, arg);
128		127
129	put_posix_clock(clk);	128	put_posix_clock(clk);
130		129
131	return err;	130	return err;
132	}	131	}
133		132
134	#ifdef CONFIG_COMPAT	133	#ifdef CONFIG_COMPAT
135	static long posix_clock_compat_ioctl(struct file *fp,	134	static long posix_clock_compat_ioctl(struct file *fp,
136	unsigned int cmd, unsigned long arg)	135	unsigned int cmd, unsigned long arg)
137	{	136	{
138	struct posix_clock *clk = get_posix_clock(fp);	137	struct posix_clock *clk = get_posix_clock(fp);
139	int err = -ENOTTY;	138	int err = -ENOTTY;
140		139
141	if (!clk)	140	if (!clk)
142	return -ENODEV;	141	return -ENODEV;
143		142
144	if (clk->ops.ioctl)	143	if (clk->ops.ioctl)
145	err = clk->ops.ioctl(clk, cmd, arg);	144	err = clk->ops.ioctl(clk, cmd, arg);
146		145
147	put_posix_clock(clk);	146	put_posix_clock(clk);
148		147
149	return err;	148	return err;
150	}	149	}
151	#endif	150	#endif
152		151
153	static int posix_clock_open(struct inode inode, struct file fp)	152	static int posix_clock_open(struct inode inode, struct file fp)
154	{	153	{
155	int err;	154	int err;
156	struct posix_clock *clk =	155	struct posix_clock *clk =
157	container_of(inode->i_cdev, struct posix_clock, cdev);	156	container_of(inode->i_cdev, struct posix_clock, cdev);
158		157
159	mutex_lock(&clk->mutex);	158	down_read(&clk->rwsem);
160		159
161	if (clk->zombie) {	160	if (clk->zombie) {
162	err = -ENODEV;	161	err = -ENODEV;
163	goto out;	162	goto out;
164	}	163	}
165	if (clk->ops.open)	164	if (clk->ops.open)
166	err = clk->ops.open(clk, fp->f_mode);	165	err = clk->ops.open(clk, fp->f_mode);
167	else	166	else
168	err = 0;	167	err = 0;
169		168
170	if (!err) {	169	if (!err) {
171	kref_get(&clk->kref);	170	kref_get(&clk->kref);
172	fp->private_data = clk;	171	fp->private_data = clk;
173	}	172	}
174	out:	173	out:
175	mutex_unlock(&clk->mutex);	174	up_read(&clk->rwsem);
176	return err;	175	return err;
177	}	176	}
178		177
179	static int posix_clock_release(struct inode inode, struct file fp)	178	static int posix_clock_release(struct inode inode, struct file fp)
180	{	179	{
181	struct posix_clock *clk = fp->private_data;	180	struct posix_clock *clk = fp->private_data;
182	int err = 0;	181	int err = 0;
183		182
184	if (clk->ops.release)	183	if (clk->ops.release)
185	err = clk->ops.release(clk);	184	err = clk->ops.release(clk);
186		185
187	kref_put(&clk->kref, delete_clock);	186	kref_put(&clk->kref, delete_clock);
188		187
189	fp->private_data = NULL;	188	fp->private_data = NULL;
190		189
191	return err;	190	return err;
192	}	191	}
193		192
194	static const struct file_operations posix_clock_file_operations = {	193	static const struct file_operations posix_clock_file_operations = {
195	.owner = THIS_MODULE,	194	.owner = THIS_MODULE,
196	.llseek = no_llseek,	195	.llseek = no_llseek,
197	.read = posix_clock_read,	196	.read = posix_clock_read,
198	.poll = posix_clock_poll,	197	.poll = posix_clock_poll,
199	.unlocked_ioctl = posix_clock_ioctl,	198	.unlocked_ioctl = posix_clock_ioctl,
200	.open = posix_clock_open,	199	.open = posix_clock_open,
201	.release = posix_clock_release,	200	.release = posix_clock_release,
202	.fasync = posix_clock_fasync,	201	.fasync = posix_clock_fasync,
203	.mmap = posix_clock_mmap,	202	.mmap = posix_clock_mmap,
204	#ifdef CONFIG_COMPAT	203	#ifdef CONFIG_COMPAT
205	.compat_ioctl = posix_clock_compat_ioctl,	204	.compat_ioctl = posix_clock_compat_ioctl,
206	#endif	205	#endif
207	};	206	};
208		207
209	int posix_clock_register(struct posix_clock *clk, dev_t devid)	208	int posix_clock_register(struct posix_clock *clk, dev_t devid)
210	{	209	{
211	int err;	210	int err;
212		211
213	kref_init(&clk->kref);	212	kref_init(&clk->kref);
214	mutex_init(&clk->mutex);	213	init_rwsem(&clk->rwsem);
215		214
216	cdev_init(&clk->cdev, &posix_clock_file_operations);	215	cdev_init(&clk->cdev, &posix_clock_file_operations);
217	clk->cdev.owner = clk->ops.owner;	216	clk->cdev.owner = clk->ops.owner;
218	err = cdev_add(&clk->cdev, devid, 1);	217	err = cdev_add(&clk->cdev, devid, 1);
219	if (err)
220	goto no_cdev;
221		218
222	return err;	219	return err;
223	no_cdev:
224	mutex_destroy(&clk->mutex);
225	return err;
226	}	220	}
227	EXPORT_SYMBOL_GPL(posix_clock_register);	221	EXPORT_SYMBOL_GPL(posix_clock_register);
228		222
229	static void delete_clock(struct kref *kref)	223	static void delete_clock(struct kref *kref)
230	{	224	{
231	struct posix_clock *clk = container_of(kref, struct posix_clock, kref);	225	struct posix_clock *clk = container_of(kref, struct posix_clock, kref);
232	mutex_destroy(&clk->mutex);	226
233	if (clk->release)	227	if (clk->release)
234	clk->release(clk);	228	clk->release(clk);
235	}	229	}
236		230
237	void posix_clock_unregister(struct posix_clock *clk)	231	void posix_clock_unregister(struct posix_clock *clk)
238	{	232	{
239	cdev_del(&clk->cdev);	233	cdev_del(&clk->cdev);
240		234
241	mutex_lock(&clk->mutex);	235	down_write(&clk->rwsem);
242	clk->zombie = true;	236	clk->zombie = true;
243	mutex_unlock(&clk->mutex);	237	up_write(&clk->rwsem);
244		238
245	kref_put(&clk->kref, delete_clock);	239	kref_put(&clk->kref, delete_clock);
246	}	240	}
247	EXPORT_SYMBOL_GPL(posix_clock_unregister);	241	EXPORT_SYMBOL_GPL(posix_clock_unregister);
248		242
249	struct posix_clock_desc {	243	struct posix_clock_desc {
250	struct file *fp;	244	struct file *fp;
251	struct posix_clock *clk;	245	struct posix_clock *clk;
252	};	246	};
253		247
254	static int get_clock_desc(const clockid_t id, struct posix_clock_desc *cd)	248	static int get_clock_desc(const clockid_t id, struct posix_clock_desc *cd)
255	{	249	{
256	struct file *fp = fget(CLOCKID_TO_FD(id));	250	struct file *fp = fget(CLOCKID_TO_FD(id));
257	int err = -EINVAL;	251	int err = -EINVAL;
258		252
259	if (!fp)	253	if (!fp)
260	return err;	254	return err;
261		255
262	if (fp->f_op->open != posix_clock_open \|\| !fp->private_data)	256	if (fp->f_op->open != posix_clock_open \|\| !fp->private_data)
263	goto out;	257	goto out;
264		258
265	cd->fp = fp;	259	cd->fp = fp;
266	cd->clk = get_posix_clock(fp);	260	cd->clk = get_posix_clock(fp);
267		261
268	err = cd->clk ? 0 : -ENODEV;	262	err = cd->clk ? 0 : -ENODEV;
269	out:	263	out:
270	if (err)	264	if (err)
271	fput(fp);	265	fput(fp);
272	return err;	266	return err;
273	}	267	}
274		268
275	static void put_clock_desc(struct posix_clock_desc *cd)	269	static void put_clock_desc(struct posix_clock_desc *cd)
276	{	270	{
277	put_posix_clock(cd->clk);	271	put_posix_clock(cd->clk);
278	fput(cd->fp);	272	fput(cd->fp);
279	}	273	}
280		274
281	static int pc_clock_adjtime(clockid_t id, struct timex *tx)	275	static int pc_clock_adjtime(clockid_t id, struct timex *tx)
282	{	276	{
283	struct posix_clock_desc cd;	277	struct posix_clock_desc cd;
284	int err;	278	int err;
285		279
286	err = get_clock_desc(id, &cd);	280	err = get_clock_desc(id, &cd);
287	if (err)	281	if (err)
288	return err;	282	return err;
289		283
290	if ((cd.fp->f_mode & FMODE_WRITE) == 0) {	284	if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
291	err = -EACCES;	285	err = -EACCES;
292	goto out;	286	goto out;
293	}	287	}
294		288
295	if (cd.clk->ops.clock_adjtime)	289	if (cd.clk->ops.clock_adjtime)
296	err = cd.clk->ops.clock_adjtime(cd.clk, tx);	290	err = cd.clk->ops.clock_adjtime(cd.clk, tx);
297	else	291	else
298	err = -EOPNOTSUPP;	292	err = -EOPNOTSUPP;
299	out:	293	out:
300	put_clock_desc(&cd);	294	put_clock_desc(&cd);
301		295
302	return err;	296	return err;
303	}	297	}
304		298
305	static int pc_clock_gettime(clockid_t id, struct timespec *ts)	299	static int pc_clock_gettime(clockid_t id, struct timespec *ts)
306	{	300	{
307	struct posix_clock_desc cd;	301	struct posix_clock_desc cd;
308	int err;	302	int err;
309		303
310	err = get_clock_desc(id, &cd);	304	err = get_clock_desc(id, &cd);
311	if (err)	305	if (err)
312	return err;	306	return err;
313		307
314	if (cd.clk->ops.clock_gettime)	308	if (cd.clk->ops.clock_gettime)
315	err = cd.clk->ops.clock_gettime(cd.clk, ts);	309	err = cd.clk->ops.clock_gettime(cd.clk, ts);
316	else	310	else
317	err = -EOPNOTSUPP;	311	err = -EOPNOTSUPP;
318		312
319	put_clock_desc(&cd);	313	put_clock_desc(&cd);
320		314
321	return err;	315	return err;
322	}	316	}
323		317
324	static int pc_clock_getres(clockid_t id, struct timespec *ts)	318	static int pc_clock_getres(clockid_t id, struct timespec *ts)
325	{	319	{
326	struct posix_clock_desc cd;	320	struct posix_clock_desc cd;
327	int err;	321	int err;
328		322
329	err = get_clock_desc(id, &cd);	323	err = get_clock_desc(id, &cd);
330	if (err)	324	if (err)
331	return err;	325	return err;
332		326
333	if (cd.clk->ops.clock_getres)	327	if (cd.clk->ops.clock_getres)
334	err = cd.clk->ops.clock_getres(cd.clk, ts);	328	err = cd.clk->ops.clock_getres(cd.clk, ts);
335	else	329	else
336	err = -EOPNOTSUPP;	330	err = -EOPNOTSUPP;
337		331
338	put_clock_desc(&cd);	332	put_clock_desc(&cd);
339		333
340	return err;	334	return err;
341	}	335	}
342		336
343	static int pc_clock_settime(clockid_t id, const struct timespec *ts)	337	static int pc_clock_settime(clockid_t id, const struct timespec *ts)
344	{	338	{
345	struct posix_clock_desc cd;	339	struct posix_clock_desc cd;
346	int err;	340	int err;
347		341
348	err = get_clock_desc(id, &cd);	342	err = get_clock_desc(id, &cd);
349	if (err)	343	if (err)
350	return err;	344	return err;
351		345
352	if ((cd.fp->f_mode & FMODE_WRITE) == 0) {	346	if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
353	err = -EACCES;	347	err = -EACCES;
354	goto out;	348	goto out;
355	}	349	}
356		350
357	if (cd.clk->ops.clock_settime)	351	if (cd.clk->ops.clock_settime)
358	err = cd.clk->ops.clock_settime(cd.clk, ts);	352	err = cd.clk->ops.clock_settime(cd.clk, ts);
359	else	353	else
360	err = -EOPNOTSUPP;	354	err = -EOPNOTSUPP;
361	out:	355	out:
362	put_clock_desc(&cd);	356	put_clock_desc(&cd);
363		357
364	return err;	358	return err;
365	}	359	}
366		360
367	static int pc_timer_create(struct k_itimer *kit)	361	static int pc_timer_create(struct k_itimer *kit)
368	{	362	{
369	clockid_t id = kit->it_clock;	363	clockid_t id = kit->it_clock;
370	struct posix_clock_desc cd;	364	struct posix_clock_desc cd;
371	int err;	365	int err;
372		366
373	err = get_clock_desc(id, &cd);	367	err = get_clock_desc(id, &cd);
374	if (err)	368	if (err)
375	return err;	369	return err;
376		370
377	if (cd.clk->ops.timer_create)	371	if (cd.clk->ops.timer_create)
378	err = cd.clk->ops.timer_create(cd.clk, kit);	372	err = cd.clk->ops.timer_create(cd.clk, kit);
379	else	373	else
380	err = -EOPNOTSUPP;	374	err = -EOPNOTSUPP;
381		375
382	put_clock_desc(&cd);	376	put_clock_desc(&cd);
383		377
384	return err;	378	return err;
385	}	379	}
386		380
387	static int pc_timer_delete(struct k_itimer *kit)	381	static int pc_timer_delete(struct k_itimer *kit)
388	{	382	{
389	clockid_t id = kit->it_clock;	383	clockid_t id = kit->it_clock;
390	struct posix_clock_desc cd;	384	struct posix_clock_desc cd;
391	int err;	385	int err;
392		386
393	err = get_clock_desc(id, &cd);	387	err = get_clock_desc(id, &cd);
394	if (err)	388	if (err)
395	return err;	389	return err;
396		390
397	if (cd.clk->ops.timer_delete)	391	if (cd.clk->ops.timer_delete)
398	err = cd.clk->ops.timer_delete(cd.clk, kit);	392	err = cd.clk->ops.timer_delete(cd.clk, kit);
399	else	393	else
400	err = -EOPNOTSUPP;	394	err = -EOPNOTSUPP;
401		395
402	put_clock_desc(&cd);	396	put_clock_desc(&cd);
403		397
404	return err;	398	return err;
405	}	399	}
406		400
407	static void pc_timer_gettime(struct k_itimer kit, struct itimerspec ts)	401	static void pc_timer_gettime(struct k_itimer kit, struct itimerspec ts)
408	{	402	{
409	clockid_t id = kit->it_clock;	403	clockid_t id = kit->it_clock;
410	struct posix_clock_desc cd;	404	struct posix_clock_desc cd;
411		405
412	if (get_clock_desc(id, &cd))	406	if (get_clock_desc(id, &cd))
413	return;	407	return;
414		408
415	if (cd.clk->ops.timer_gettime)	409	if (cd.clk->ops.timer_gettime)
416	cd.clk->ops.timer_gettime(cd.clk, kit, ts);	410	cd.clk->ops.timer_gettime(cd.clk, kit, ts);
417		411
418	put_clock_desc(&cd);	412	put_clock_desc(&cd);
419	}	413	}
420		414
421	static int pc_timer_settime(struct k_itimer *kit, int flags,	415	static int pc_timer_settime(struct k_itimer *kit, int flags,
422	struct itimerspec ts, struct itimerspec old)	416	struct itimerspec ts, struct itimerspec old)
423	{	417	{
424	clockid_t id = kit->it_clock;	418	clockid_t id = kit->it_clock;
425	struct posix_clock_desc cd;	419	struct posix_clock_desc cd;
426	int err;	420	int err;
427		421
428	err = get_clock_desc(id, &cd);	422	err = get_clock_desc(id, &cd);
429	if (err)	423	if (err)
430	return err;	424	return err;
431		425
432	if (cd.clk->ops.timer_settime)	426	if (cd.clk->ops.timer_settime)
433	err = cd.clk->ops.timer_settime(cd.clk, kit, flags, ts, old);	427	err = cd.clk->ops.timer_settime(cd.clk, kit, flags, ts, old);
434	else	428	else
435	err = -EOPNOTSUPP;	429	err = -EOPNOTSUPP;
436		430
437	put_clock_desc(&cd);	431	put_clock_desc(&cd);
438		432
439	return err;	433	return err;
440	}	434	}
441		435
442	struct k_clock clock_posix_dynamic = {	436	struct k_clock clock_posix_dynamic = {
443	.clock_getres = pc_clock_getres,	437	.clock_getres = pc_clock_getres,
444	.clock_set = pc_clock_settime,	438	.clock_set = pc_clock_settime,
445	.clock_get = pc_clock_gettime,	439	.clock_get = pc_clock_gettime,
446	.clock_adj = pc_clock_adjtime,	440	.clock_adj = pc_clock_adjtime,
447	.timer_create = pc_timer_create,	441	.timer_create = pc_timer_create,
448	.timer_set = pc_timer_settime,	442	.timer_set = pc_timer_settime,
449	.timer_del = pc_timer_delete,	443	.timer_del = pc_timer_delete,
450	.timer_get = pc_timer_gettime,	444	.timer_get = pc_timer_gettime,
451	};	445	};
452		446

1	/*	1	/*
2	* TI OMAP1 Real Time Clock interface for Linux	2	* TI OMAP1 Real Time Clock interface for Linux
3	*	3	*
4	* Copyright (C) 2003 MontaVista Software, Inc.	4	* Copyright (C) 2003 MontaVista Software, Inc.
5	* Author: George G. Davis <gdavis@mvista.com> or <source@mvista.com>	5	* Author: George G. Davis <gdavis@mvista.com> or <source@mvista.com>
6	*	6	*
7	* Copyright (C) 2006 David Brownell (new RTC framework)	7	* Copyright (C) 2006 David Brownell (new RTC framework)
8	*	8	*
9	* This program is free software; you can redistribute it and/or	9	* This program is free software; you can redistribute it and/or
10	* modify it under the terms of the GNU General Public License	10	* modify it under the terms of the GNU General Public License
11	* as published by the Free Software Foundation; either version	11	* as published by the Free Software Foundation; either version
12	* 2 of the License, or (at your option) any later version.	12	* 2 of the License, or (at your option) any later version.
13	*/	13	*/
14		14
15	#include <linux/kernel.h>	15	#include <linux/kernel.h>
16	#include <linux/init.h>	16	#include <linux/init.h>
17	#include <linux/module.h>	17	#include <linux/module.h>
18	#include <linux/ioport.h>	18	#include <linux/ioport.h>
19	#include <linux/delay.h>	19	#include <linux/delay.h>
20	#include <linux/rtc.h>	20	#include <linux/rtc.h>
21	#include <linux/bcd.h>	21	#include <linux/bcd.h>
22	#include <linux/platform_device.h>	22	#include <linux/platform_device.h>
23		23
24	#include <asm/io.h>	24	#include <asm/io.h>
25		25
26		26
27	/* The OMAP1 RTC is a year/month/day/hours/minutes/seconds BCD clock	27	/* The OMAP1 RTC is a year/month/day/hours/minutes/seconds BCD clock
28	* with century-range alarm matching, driven by the 32kHz clock.	28	* with century-range alarm matching, driven by the 32kHz clock.
29	*	29	*
30	* The main user-visible ways it differs from PC RTCs are by omitting	30	* The main user-visible ways it differs from PC RTCs are by omitting
31	* "don't care" alarm fields and sub-second periodic IRQs, and having	31	* "don't care" alarm fields and sub-second periodic IRQs, and having
32	* an autoadjust mechanism to calibrate to the true oscillator rate.	32	* an autoadjust mechanism to calibrate to the true oscillator rate.
33	*	33	*
34	* Board-specific wiring options include using split power mode with	34	* Board-specific wiring options include using split power mode with
35	* RTC_OFF_NOFF used as the reset signal (so the RTC won't be reset),	35	* RTC_OFF_NOFF used as the reset signal (so the RTC won't be reset),
36	* and wiring RTC_WAKE_INT (so the RTC alarm can wake the system from	36	* and wiring RTC_WAKE_INT (so the RTC alarm can wake the system from
37	* low power modes) for OMAP1 boards (OMAP-L138 has this built into	37	* low power modes) for OMAP1 boards (OMAP-L138 has this built into
38	* the SoC). See the BOARD-SPECIFIC CUSTOMIZATION comment.	38	* the SoC). See the BOARD-SPECIFIC CUSTOMIZATION comment.
39	*/	39	*/
40		40