Commit | Line | Data |
---|---|---|
eae9d2ba RG |
1 | /* |
2 | * kernel API | |
3 | * | |
4 | * | |
5 | * Copyright (C) 2005-2009 Rodolfo Giometti <giometti@linux.it> | |
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 as published by | |
9 | * the Free Software Foundation; either version 2 of the License, or | |
10 | * (at your option) any later version. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | * GNU General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License | |
18 | * along with this program; if not, write to the Free Software | |
19 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
20 | */ | |
21 | ||
7f7cce74 | 22 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
eae9d2ba RG |
23 | |
24 | #include <linux/kernel.h> | |
25 | #include <linux/module.h> | |
26 | #include <linux/init.h> | |
27 | #include <linux/sched.h> | |
28 | #include <linux/time.h> | |
29 | #include <linux/spinlock.h> | |
eae9d2ba RG |
30 | #include <linux/fs.h> |
31 | #include <linux/pps_kernel.h> | |
5a0e3ad6 | 32 | #include <linux/slab.h> |
eae9d2ba | 33 | |
eae9d2ba RG |
34 | /* |
35 | * Local functions | |
36 | */ | |
37 | ||
38 | static void pps_add_offset(struct pps_ktime *ts, struct pps_ktime *offset) | |
39 | { | |
40 | ts->nsec += offset->nsec; | |
41 | while (ts->nsec >= NSEC_PER_SEC) { | |
42 | ts->nsec -= NSEC_PER_SEC; | |
43 | ts->sec++; | |
44 | } | |
45 | while (ts->nsec < 0) { | |
46 | ts->nsec += NSEC_PER_SEC; | |
47 | ts->sec--; | |
48 | } | |
49 | ts->sec += offset->sec; | |
50 | } | |
51 | ||
52 | /* | |
53 | * Exported functions | |
54 | */ | |
55 | ||
eae9d2ba RG |
56 | /* pps_register_source - add a PPS source in the system |
57 | * @info: the PPS info struct | |
58 | * @default_params: the default PPS parameters of the new source | |
59 | * | |
60 | * This function is used to add a new PPS source in the system. The new | |
61 | * source is described by info's fields and it will have, as default PPS | |
62 | * parameters, the ones specified into default_params. | |
63 | * | |
5e196d34 | 64 | * The function returns, in case of success, the PPS device. Otherwise NULL. |
eae9d2ba RG |
65 | */ |
66 | ||
5e196d34 AG |
67 | struct pps_device *pps_register_source(struct pps_source_info *info, |
68 | int default_params) | |
eae9d2ba RG |
69 | { |
70 | struct pps_device *pps; | |
eae9d2ba RG |
71 | int err; |
72 | ||
73 | /* Sanity checks */ | |
74 | if ((info->mode & default_params) != default_params) { | |
7f7cce74 | 75 | pr_err("%s: unsupported default parameters\n", |
eae9d2ba RG |
76 | info->name); |
77 | err = -EINVAL; | |
78 | goto pps_register_source_exit; | |
79 | } | |
80 | if ((info->mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)) != 0 && | |
81 | info->echo == NULL) { | |
7f7cce74 | 82 | pr_err("%s: echo function is not defined\n", |
eae9d2ba RG |
83 | info->name); |
84 | err = -EINVAL; | |
85 | goto pps_register_source_exit; | |
86 | } | |
87 | if ((info->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) { | |
7f7cce74 | 88 | pr_err("%s: unspecified time format\n", |
eae9d2ba RG |
89 | info->name); |
90 | err = -EINVAL; | |
91 | goto pps_register_source_exit; | |
92 | } | |
93 | ||
94 | /* Allocate memory for the new PPS source struct */ | |
95 | pps = kzalloc(sizeof(struct pps_device), GFP_KERNEL); | |
96 | if (pps == NULL) { | |
97 | err = -ENOMEM; | |
98 | goto pps_register_source_exit; | |
99 | } | |
100 | ||
101 | /* These initializations must be done before calling idr_get_new() | |
102 | * in order to avoid reces into pps_event(). | |
103 | */ | |
104 | pps->params.api_version = PPS_API_VERS; | |
105 | pps->params.mode = default_params; | |
106 | pps->info = *info; | |
107 | ||
108 | init_waitqueue_head(&pps->queue); | |
109 | spin_lock_init(&pps->lock); | |
eae9d2ba | 110 | |
eae9d2ba RG |
111 | /* Create the char device */ |
112 | err = pps_register_cdev(pps); | |
113 | if (err < 0) { | |
7f7cce74 | 114 | pr_err("%s: unable to create char device\n", |
eae9d2ba | 115 | info->name); |
083e5866 | 116 | goto kfree_pps; |
eae9d2ba RG |
117 | } |
118 | ||
7f7cce74 | 119 | dev_info(pps->dev, "new PPS source %s\n", info->name); |
eae9d2ba | 120 | |
5e196d34 | 121 | return pps; |
eae9d2ba | 122 | |
eae9d2ba RG |
123 | kfree_pps: |
124 | kfree(pps); | |
125 | ||
126 | pps_register_source_exit: | |
7f7cce74 | 127 | pr_err("%s: unable to register source\n", info->name); |
eae9d2ba | 128 | |
5e196d34 | 129 | return NULL; |
eae9d2ba RG |
130 | } |
131 | EXPORT_SYMBOL(pps_register_source); | |
132 | ||
133 | /* pps_unregister_source - remove a PPS source from the system | |
5e196d34 | 134 | * @pps: the PPS source |
eae9d2ba RG |
135 | * |
136 | * This function is used to remove a previously registered PPS source from | |
137 | * the system. | |
138 | */ | |
139 | ||
5e196d34 | 140 | void pps_unregister_source(struct pps_device *pps) |
eae9d2ba | 141 | { |
5e196d34 | 142 | pps_unregister_cdev(pps); |
eae9d2ba | 143 | |
083e5866 AG |
144 | /* don't have to kfree(pps) here because it will be done on |
145 | * device destruction */ | |
eae9d2ba RG |
146 | } |
147 | EXPORT_SYMBOL(pps_unregister_source); | |
148 | ||
149 | /* pps_event - register a PPS event into the system | |
5e196d34 | 150 | * @pps: the PPS device |
eae9d2ba RG |
151 | * @ts: the event timestamp |
152 | * @event: the event type | |
153 | * @data: userdef pointer | |
154 | * | |
155 | * This function is used by each PPS client in order to register a new | |
156 | * PPS event into the system (it's usually called inside an IRQ handler). | |
157 | * | |
5e196d34 | 158 | * If an echo function is associated with the PPS device it will be called |
eae9d2ba | 159 | * as: |
5e196d34 | 160 | * pps->info.echo(pps, event, data); |
eae9d2ba | 161 | */ |
5e196d34 AG |
162 | void pps_event(struct pps_device *pps, struct pps_event_time *ts, int event, |
163 | void *data) | |
eae9d2ba | 164 | { |
eae9d2ba | 165 | unsigned long flags; |
276b282e | 166 | int captured = 0; |
6f4229b5 | 167 | struct pps_ktime ts_real; |
eae9d2ba RG |
168 | |
169 | if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0) { | |
5e196d34 | 170 | dev_err(pps->dev, "unknown event (%x)\n", event); |
eae9d2ba RG |
171 | return; |
172 | } | |
173 | ||
5e196d34 AG |
174 | dev_dbg(pps->dev, "PPS event at %ld.%09ld\n", |
175 | ts->ts_real.tv_sec, ts->ts_real.tv_nsec); | |
6f4229b5 AG |
176 | |
177 | timespec_to_pps_ktime(&ts_real, ts->ts_real); | |
eae9d2ba RG |
178 | |
179 | spin_lock_irqsave(&pps->lock, flags); | |
180 | ||
181 | /* Must call the echo function? */ | |
182 | if ((pps->params.mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR))) | |
5e196d34 | 183 | pps->info.echo(pps, event, data); |
eae9d2ba RG |
184 | |
185 | /* Check the event */ | |
186 | pps->current_mode = pps->params.mode; | |
276b282e RG |
187 | if ((event & PPS_CAPTUREASSERT) & |
188 | (pps->params.mode & PPS_CAPTUREASSERT)) { | |
eae9d2ba RG |
189 | /* We have to add an offset? */ |
190 | if (pps->params.mode & PPS_OFFSETASSERT) | |
6f4229b5 AG |
191 | pps_add_offset(&ts_real, |
192 | &pps->params.assert_off_tu); | |
eae9d2ba RG |
193 | |
194 | /* Save the time stamp */ | |
6f4229b5 | 195 | pps->assert_tu = ts_real; |
eae9d2ba | 196 | pps->assert_sequence++; |
5e196d34 AG |
197 | dev_dbg(pps->dev, "capture assert seq #%u\n", |
198 | pps->assert_sequence); | |
276b282e RG |
199 | |
200 | captured = ~0; | |
eae9d2ba | 201 | } |
276b282e RG |
202 | if ((event & PPS_CAPTURECLEAR) & |
203 | (pps->params.mode & PPS_CAPTURECLEAR)) { | |
eae9d2ba RG |
204 | /* We have to add an offset? */ |
205 | if (pps->params.mode & PPS_OFFSETCLEAR) | |
6f4229b5 AG |
206 | pps_add_offset(&ts_real, |
207 | &pps->params.clear_off_tu); | |
eae9d2ba RG |
208 | |
209 | /* Save the time stamp */ | |
6f4229b5 | 210 | pps->clear_tu = ts_real; |
eae9d2ba | 211 | pps->clear_sequence++; |
5e196d34 AG |
212 | dev_dbg(pps->dev, "capture clear seq #%u\n", |
213 | pps->clear_sequence); | |
276b282e RG |
214 | |
215 | captured = ~0; | |
eae9d2ba RG |
216 | } |
217 | ||
7a21a3cc | 218 | /* Wake up if captured something */ |
276b282e | 219 | if (captured) { |
3003d55b AG |
220 | pps->last_ev++; |
221 | wake_up_interruptible_all(&pps->queue); | |
eae9d2ba | 222 | |
276b282e RG |
223 | kill_fasync(&pps->async_queue, SIGIO, POLL_IN); |
224 | } | |
eae9d2ba RG |
225 | |
226 | spin_unlock_irqrestore(&pps->lock, flags); | |
eae9d2ba RG |
227 | } |
228 | EXPORT_SYMBOL(pps_event); |