Commit | Line | Data |
---|---|---|
74ba9207 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
d94ba80e RC |
2 | /* |
3 | * PTP 1588 clock support - sysfs interface. | |
4 | * | |
5 | * Copyright (C) 2010 OMICRON electronics GmbH | |
d94ba80e RC |
6 | */ |
7 | #include <linux/capability.h> | |
653104d1 | 8 | #include <linux/slab.h> |
d94ba80e RC |
9 | |
10 | #include "ptp_private.h" | |
11 | ||
12 | static ssize_t clock_name_show(struct device *dev, | |
13 | struct device_attribute *attr, char *page) | |
14 | { | |
15 | struct ptp_clock *ptp = dev_get_drvdata(dev); | |
16 | return snprintf(page, PAGE_SIZE-1, "%s\n", ptp->info->name); | |
17 | } | |
63215705 | 18 | static DEVICE_ATTR_RO(clock_name); |
d94ba80e | 19 | |
3499116b GKH |
20 | #define PTP_SHOW_INT(name, var) \ |
21 | static ssize_t var##_show(struct device *dev, \ | |
d94ba80e RC |
22 | struct device_attribute *attr, char *page) \ |
23 | { \ | |
24 | struct ptp_clock *ptp = dev_get_drvdata(dev); \ | |
3499116b GKH |
25 | return snprintf(page, PAGE_SIZE-1, "%d\n", ptp->info->var); \ |
26 | } \ | |
27 | static DEVICE_ATTR(name, 0444, var##_show, NULL); | |
d94ba80e | 28 | |
3499116b GKH |
29 | PTP_SHOW_INT(max_adjustment, max_adj); |
30 | PTP_SHOW_INT(n_alarms, n_alarm); | |
31 | PTP_SHOW_INT(n_external_timestamps, n_ext_ts); | |
32 | PTP_SHOW_INT(n_periodic_outputs, n_per_out); | |
653104d1 | 33 | PTP_SHOW_INT(n_programmable_pins, n_pins); |
3499116b | 34 | PTP_SHOW_INT(pps_available, pps); |
d94ba80e | 35 | |
d94ba80e RC |
36 | static ssize_t extts_enable_store(struct device *dev, |
37 | struct device_attribute *attr, | |
38 | const char *buf, size_t count) | |
39 | { | |
40 | struct ptp_clock *ptp = dev_get_drvdata(dev); | |
41 | struct ptp_clock_info *ops = ptp->info; | |
42 | struct ptp_clock_request req = { .type = PTP_CLK_REQ_EXTTS }; | |
43 | int cnt, enable; | |
44 | int err = -EINVAL; | |
45 | ||
46 | cnt = sscanf(buf, "%u %d", &req.extts.index, &enable); | |
47 | if (cnt != 2) | |
48 | goto out; | |
49 | if (req.extts.index >= ops->n_ext_ts) | |
50 | goto out; | |
51 | ||
52 | err = ops->enable(ops, &req, enable ? 1 : 0); | |
53 | if (err) | |
54 | goto out; | |
55 | ||
56 | return count; | |
57 | out: | |
58 | return err; | |
59 | } | |
af59e717 | 60 | static DEVICE_ATTR(extts_enable, 0220, NULL, extts_enable_store); |
d94ba80e RC |
61 | |
62 | static ssize_t extts_fifo_show(struct device *dev, | |
63 | struct device_attribute *attr, char *page) | |
64 | { | |
65 | struct ptp_clock *ptp = dev_get_drvdata(dev); | |
66 | struct timestamp_event_queue *queue = &ptp->tsevq; | |
67 | struct ptp_extts_event event; | |
68 | unsigned long flags; | |
69 | size_t qcnt; | |
70 | int cnt = 0; | |
71 | ||
72 | memset(&event, 0, sizeof(event)); | |
73 | ||
74 | if (mutex_lock_interruptible(&ptp->tsevq_mux)) | |
75 | return -ERESTARTSYS; | |
76 | ||
77 | spin_lock_irqsave(&queue->lock, flags); | |
78 | qcnt = queue_cnt(queue); | |
79 | if (qcnt) { | |
80 | event = queue->buf[queue->head]; | |
81 | queue->head = (queue->head + 1) % PTP_MAX_TIMESTAMPS; | |
82 | } | |
83 | spin_unlock_irqrestore(&queue->lock, flags); | |
84 | ||
85 | if (!qcnt) | |
86 | goto out; | |
87 | ||
88 | cnt = snprintf(page, PAGE_SIZE, "%u %lld %u\n", | |
89 | event.index, event.t.sec, event.t.nsec); | |
90 | out: | |
91 | mutex_unlock(&ptp->tsevq_mux); | |
92 | return cnt; | |
93 | } | |
af59e717 | 94 | static DEVICE_ATTR(fifo, 0444, extts_fifo_show, NULL); |
d94ba80e RC |
95 | |
96 | static ssize_t period_store(struct device *dev, | |
97 | struct device_attribute *attr, | |
98 | const char *buf, size_t count) | |
99 | { | |
100 | struct ptp_clock *ptp = dev_get_drvdata(dev); | |
101 | struct ptp_clock_info *ops = ptp->info; | |
102 | struct ptp_clock_request req = { .type = PTP_CLK_REQ_PEROUT }; | |
103 | int cnt, enable, err = -EINVAL; | |
104 | ||
105 | cnt = sscanf(buf, "%u %lld %u %lld %u", &req.perout.index, | |
106 | &req.perout.start.sec, &req.perout.start.nsec, | |
107 | &req.perout.period.sec, &req.perout.period.nsec); | |
108 | if (cnt != 5) | |
109 | goto out; | |
110 | if (req.perout.index >= ops->n_per_out) | |
111 | goto out; | |
112 | ||
113 | enable = req.perout.period.sec || req.perout.period.nsec; | |
114 | err = ops->enable(ops, &req, enable); | |
115 | if (err) | |
116 | goto out; | |
117 | ||
118 | return count; | |
119 | out: | |
120 | return err; | |
121 | } | |
af59e717 | 122 | static DEVICE_ATTR(period, 0220, NULL, period_store); |
d94ba80e RC |
123 | |
124 | static ssize_t pps_enable_store(struct device *dev, | |
125 | struct device_attribute *attr, | |
126 | const char *buf, size_t count) | |
127 | { | |
128 | struct ptp_clock *ptp = dev_get_drvdata(dev); | |
129 | struct ptp_clock_info *ops = ptp->info; | |
130 | struct ptp_clock_request req = { .type = PTP_CLK_REQ_PPS }; | |
131 | int cnt, enable; | |
132 | int err = -EINVAL; | |
133 | ||
134 | if (!capable(CAP_SYS_TIME)) | |
135 | return -EPERM; | |
136 | ||
137 | cnt = sscanf(buf, "%d", &enable); | |
138 | if (cnt != 1) | |
139 | goto out; | |
140 | ||
141 | err = ops->enable(ops, &req, enable ? 1 : 0); | |
142 | if (err) | |
143 | goto out; | |
144 | ||
145 | return count; | |
146 | out: | |
147 | return err; | |
148 | } | |
af59e717 DT |
149 | static DEVICE_ATTR(pps_enable, 0220, NULL, pps_enable_store); |
150 | ||
151 | static struct attribute *ptp_attrs[] = { | |
152 | &dev_attr_clock_name.attr, | |
153 | ||
154 | &dev_attr_max_adjustment.attr, | |
155 | &dev_attr_n_alarms.attr, | |
156 | &dev_attr_n_external_timestamps.attr, | |
157 | &dev_attr_n_periodic_outputs.attr, | |
158 | &dev_attr_n_programmable_pins.attr, | |
159 | &dev_attr_pps_available.attr, | |
160 | ||
161 | &dev_attr_extts_enable.attr, | |
162 | &dev_attr_fifo.attr, | |
163 | &dev_attr_period.attr, | |
164 | &dev_attr_pps_enable.attr, | |
165 | NULL | |
166 | }; | |
167 | ||
168 | static umode_t ptp_is_attribute_visible(struct kobject *kobj, | |
169 | struct attribute *attr, int n) | |
170 | { | |
171 | struct device *dev = kobj_to_dev(kobj); | |
172 | struct ptp_clock *ptp = dev_get_drvdata(dev); | |
173 | struct ptp_clock_info *info = ptp->info; | |
174 | umode_t mode = attr->mode; | |
175 | ||
176 | if (attr == &dev_attr_extts_enable.attr || | |
177 | attr == &dev_attr_fifo.attr) { | |
178 | if (!info->n_ext_ts) | |
179 | mode = 0; | |
180 | } else if (attr == &dev_attr_period.attr) { | |
181 | if (!info->n_per_out) | |
182 | mode = 0; | |
183 | } else if (attr == &dev_attr_pps_enable.attr) { | |
184 | if (!info->pps) | |
185 | mode = 0; | |
186 | } | |
187 | ||
188 | return mode; | |
189 | } | |
190 | ||
191 | static const struct attribute_group ptp_group = { | |
192 | .is_visible = ptp_is_attribute_visible, | |
193 | .attrs = ptp_attrs, | |
194 | }; | |
195 | ||
196 | const struct attribute_group *ptp_groups[] = { | |
197 | &ptp_group, | |
198 | NULL | |
199 | }; | |
d94ba80e | 200 | |
653104d1 RC |
201 | static int ptp_pin_name2index(struct ptp_clock *ptp, const char *name) |
202 | { | |
203 | int i; | |
204 | for (i = 0; i < ptp->info->n_pins; i++) { | |
205 | if (!strcmp(ptp->info->pin_config[i].name, name)) | |
206 | return i; | |
207 | } | |
208 | return -1; | |
209 | } | |
210 | ||
211 | static ssize_t ptp_pin_show(struct device *dev, struct device_attribute *attr, | |
212 | char *page) | |
213 | { | |
214 | struct ptp_clock *ptp = dev_get_drvdata(dev); | |
215 | unsigned int func, chan; | |
216 | int index; | |
217 | ||
218 | index = ptp_pin_name2index(ptp, attr->attr.name); | |
219 | if (index < 0) | |
220 | return -EINVAL; | |
221 | ||
222 | if (mutex_lock_interruptible(&ptp->pincfg_mux)) | |
223 | return -ERESTARTSYS; | |
224 | ||
225 | func = ptp->info->pin_config[index].func; | |
226 | chan = ptp->info->pin_config[index].chan; | |
227 | ||
228 | mutex_unlock(&ptp->pincfg_mux); | |
229 | ||
230 | return snprintf(page, PAGE_SIZE, "%u %u\n", func, chan); | |
231 | } | |
232 | ||
233 | static ssize_t ptp_pin_store(struct device *dev, struct device_attribute *attr, | |
234 | const char *buf, size_t count) | |
235 | { | |
236 | struct ptp_clock *ptp = dev_get_drvdata(dev); | |
237 | unsigned int func, chan; | |
238 | int cnt, err, index; | |
239 | ||
240 | cnt = sscanf(buf, "%u %u", &func, &chan); | |
241 | if (cnt != 2) | |
242 | return -EINVAL; | |
243 | ||
244 | index = ptp_pin_name2index(ptp, attr->attr.name); | |
245 | if (index < 0) | |
246 | return -EINVAL; | |
247 | ||
248 | if (mutex_lock_interruptible(&ptp->pincfg_mux)) | |
249 | return -ERESTARTSYS; | |
250 | err = ptp_set_pinfunc(ptp, index, func, chan); | |
251 | mutex_unlock(&ptp->pincfg_mux); | |
252 | if (err) | |
253 | return err; | |
254 | ||
255 | return count; | |
256 | } | |
257 | ||
85a66e55 | 258 | int ptp_populate_pin_groups(struct ptp_clock *ptp) |
d94ba80e | 259 | { |
653104d1 RC |
260 | struct ptp_clock_info *info = ptp->info; |
261 | int err = -ENOMEM, i, n_pins = info->n_pins; | |
262 | ||
85a66e55 DT |
263 | if (!n_pins) |
264 | return 0; | |
265 | ||
6f7aa56b | 266 | ptp->pin_dev_attr = kcalloc(n_pins, sizeof(*ptp->pin_dev_attr), |
653104d1 RC |
267 | GFP_KERNEL); |
268 | if (!ptp->pin_dev_attr) | |
269 | goto no_dev_attr; | |
270 | ||
6f7aa56b | 271 | ptp->pin_attr = kcalloc(1 + n_pins, sizeof(*ptp->pin_attr), GFP_KERNEL); |
653104d1 RC |
272 | if (!ptp->pin_attr) |
273 | goto no_pin_attr; | |
274 | ||
275 | for (i = 0; i < n_pins; i++) { | |
276 | struct device_attribute *da = &ptp->pin_dev_attr[i]; | |
277 | sysfs_attr_init(&da->attr); | |
278 | da->attr.name = info->pin_config[i].name; | |
279 | da->attr.mode = 0644; | |
280 | da->show = ptp_pin_show; | |
281 | da->store = ptp_pin_store; | |
282 | ptp->pin_attr[i] = &da->attr; | |
283 | } | |
284 | ||
285 | ptp->pin_attr_group.name = "pins"; | |
286 | ptp->pin_attr_group.attrs = ptp->pin_attr; | |
287 | ||
85a66e55 DT |
288 | ptp->pin_attr_groups[0] = &ptp->pin_attr_group; |
289 | ||
653104d1 RC |
290 | return 0; |
291 | ||
653104d1 RC |
292 | no_pin_attr: |
293 | kfree(ptp->pin_dev_attr); | |
294 | no_dev_attr: | |
295 | return err; | |
296 | } | |
297 | ||
85a66e55 | 298 | void ptp_cleanup_pin_groups(struct ptp_clock *ptp) |
d94ba80e | 299 | { |
85a66e55 DT |
300 | kfree(ptp->pin_attr); |
301 | kfree(ptp->pin_dev_attr); | |
d94ba80e | 302 | } |