1 /*-
2 * SPDX-License-Identifier: Beerware
3 *
4 * ----------------------------------------------------------------------------
5 * "THE BEER-WARE LICENSE" (Revision 42):
6 * <phk@FreeBSD.org> wrote this file. As long as you retain this notice you
7 * can do whatever you want with this stuff. If we meet some day, and you think
8 * this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
9 * ----------------------------------------------------------------------------
10 *
11 *
12 * This driver implements a draft-mogul-pps-api-02.txt PPS source.
13 *
14 * The input pin is pin#10
15 * The echo output pin is pin#14
16 *
17 */
18
19 #include <sys/param.h>
20 #include <sys/lock.h>
21 #include <sys/kernel.h>
22 #include <sys/systm.h>
23 #include <sys/module.h>
24 #include <sys/sx.h>
25 #include <sys/bus.h>
26 #include <sys/conf.h>
27 #include <sys/timepps.h>
28 #include <machine/bus.h>
29 #include <machine/resource.h>
30 #include <sys/rman.h>
31
32 #include <dev/ppbus/ppbconf.h>
33 #include "ppbus_if.h"
34 #include <dev/ppbus/ppbio.h>
35
36 #define PPS_NAME "pps" /* our official name */
37
38 #define PRVERBOSE(fmt, arg...) if (bootverbose) printf(fmt, ##arg);
39
40 struct pps_data {
41 struct ppb_device pps_dev;
42 struct pps_state pps[9];
43 struct cdev *devs[9];
44 device_t ppsdev;
45 device_t ppbus;
46 int busy;
47 struct callout timeout;
48 int lastdata;
49
50 struct sx lock;
51 struct resource *intr_resource; /* interrupt resource */
52 void *intr_cookie; /* interrupt registration cookie */
53 };
54
55 static void ppsintr(void *arg);
56 static void ppshcpoll(void *arg);
57
58 #define DEVTOSOFTC(dev) \
59 ((struct pps_data *)device_get_softc(dev))
60
61 static d_open_t ppsopen;
62 static d_close_t ppsclose;
63 static d_ioctl_t ppsioctl;
64
65 static struct cdevsw pps_cdevsw = {
66 .d_version = D_VERSION,
67 .d_open = ppsopen,
68 .d_close = ppsclose,
69 .d_ioctl = ppsioctl,
70 .d_name = PPS_NAME,
71 };
72
73 static void
ppsidentify(driver_t * driver,device_t parent)74 ppsidentify(driver_t *driver, device_t parent)
75 {
76
77 device_t dev;
78
79 dev = device_find_child(parent, PPS_NAME, DEVICE_UNIT_ANY);
80 if (!dev)
81 BUS_ADD_CHILD(parent, 0, PPS_NAME, DEVICE_UNIT_ANY);
82 }
83
84 static int
ppstry(device_t ppbus,int send,int expect)85 ppstry(device_t ppbus, int send, int expect)
86 {
87 int i;
88
89 ppb_wdtr(ppbus, send);
90 i = ppb_rdtr(ppbus);
91 PRVERBOSE("S: %02x E: %02x G: %02x\n", send, expect, i);
92 return (i != expect);
93 }
94
95 static int
ppsprobe(device_t ppsdev)96 ppsprobe(device_t ppsdev)
97 {
98 device_set_desc(ppsdev, "Pulse per second Timing Interface");
99
100 return (0);
101 }
102
103 static int
ppsattach(device_t dev)104 ppsattach(device_t dev)
105 {
106 struct pps_data *sc = DEVTOSOFTC(dev);
107 device_t ppbus = device_get_parent(dev);
108 struct cdev *d;
109 int error, i, unit, rid = 0;
110
111 /* declare our interrupt handler */
112 sc->intr_resource = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
113 RF_SHAREABLE);
114
115 /* interrupts seem mandatory */
116 if (sc->intr_resource == NULL) {
117 device_printf(dev, "Unable to allocate interrupt resource\n");
118 return (ENXIO);
119 }
120
121 error = bus_setup_intr(dev, sc->intr_resource,
122 INTR_TYPE_TTY | INTR_MPSAFE, NULL, ppsintr,
123 sc, &sc->intr_cookie);
124 if (error) {
125 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->intr_resource);
126 device_printf(dev, "Unable to register interrupt handler\n");
127 return (error);
128 }
129
130 sx_init(&sc->lock, "pps");
131 ppb_init_callout(ppbus, &sc->timeout, 0);
132 sc->ppsdev = dev;
133 sc->ppbus = ppbus;
134 unit = device_get_unit(ppbus);
135 d = make_dev(&pps_cdevsw, unit,
136 UID_ROOT, GID_WHEEL, 0600, PPS_NAME "%d", unit);
137 sc->devs[0] = d;
138 sc->pps[0].ppscap = PPS_CAPTUREASSERT | PPS_ECHOASSERT;
139 sc->pps[0].driver_abi = PPS_ABI_VERSION;
140 sc->pps[0].driver_mtx = ppb_get_lock(ppbus);
141 d->si_drv1 = sc;
142 d->si_drv2 = (void*)0;
143 pps_init_abi(&sc->pps[0]);
144
145 ppb_lock(ppbus);
146 if (ppb_request_bus(ppbus, dev, PPB_DONTWAIT)) {
147 ppb_unlock(ppbus);
148 return (0);
149 }
150
151 do {
152 i = ppb_set_mode(sc->ppbus, PPB_EPP);
153 PRVERBOSE("EPP: %d %d\n", i, PPB_IN_EPP_MODE(sc->ppbus));
154 if (i == -1)
155 break;
156 i = 0;
157 ppb_wctr(ppbus, i);
158 if (ppstry(ppbus, 0x00, 0x00))
159 break;
160 if (ppstry(ppbus, 0x55, 0x55))
161 break;
162 if (ppstry(ppbus, 0xaa, 0xaa))
163 break;
164 if (ppstry(ppbus, 0xff, 0xff))
165 break;
166
167 i = IRQENABLE | PCD | STROBE | nINIT | SELECTIN;
168 ppb_wctr(ppbus, i);
169 PRVERBOSE("CTR = %02x (%02x)\n", ppb_rctr(ppbus), i);
170 if (ppstry(ppbus, 0x00, 0x00))
171 break;
172 if (ppstry(ppbus, 0x55, 0x00))
173 break;
174 if (ppstry(ppbus, 0xaa, 0x00))
175 break;
176 if (ppstry(ppbus, 0xff, 0x00))
177 break;
178
179 i = IRQENABLE | PCD | nINIT | SELECTIN;
180 ppb_wctr(ppbus, i);
181 PRVERBOSE("CTR = %02x (%02x)\n", ppb_rctr(ppbus), i);
182 ppstry(ppbus, 0x00, 0xff);
183 ppstry(ppbus, 0x55, 0xff);
184 ppstry(ppbus, 0xaa, 0xff);
185 ppstry(ppbus, 0xff, 0xff);
186 ppb_unlock(ppbus);
187
188 for (i = 1; i < 9; i++) {
189 d = make_dev(&pps_cdevsw, unit + 0x10000 * i,
190 UID_ROOT, GID_WHEEL, 0600, PPS_NAME "%db%d", unit, i - 1);
191 sc->devs[i] = d;
192 sc->pps[i].ppscap = PPS_CAPTUREASSERT | PPS_CAPTURECLEAR;
193 sc->pps[i].driver_abi = PPS_ABI_VERSION;
194 sc->pps[i].driver_mtx = ppb_get_lock(ppbus);
195 d->si_drv1 = sc;
196 d->si_drv2 = (void *)(intptr_t)i;
197 pps_init_abi(&sc->pps[i]);
198 }
199 ppb_lock(ppbus);
200 } while (0);
201 i = ppb_set_mode(sc->ppbus, PPB_COMPATIBLE);
202 ppb_release_bus(ppbus, dev);
203 ppb_unlock(ppbus);
204
205 return (0);
206 }
207
208 static int
ppsopen(struct cdev * dev,int flags,int fmt,struct thread * td)209 ppsopen(struct cdev *dev, int flags, int fmt, struct thread *td)
210 {
211 struct pps_data *sc = dev->si_drv1;
212 device_t ppbus = sc->ppbus;
213 int subdev = (intptr_t)dev->si_drv2;
214 int i;
215
216 /*
217 * The sx lock is here solely to serialize open()'s to close
218 * the race of concurrent open()'s when pps(4) doesn't own the
219 * ppbus.
220 */
221 sx_xlock(&sc->lock);
222 ppb_lock(ppbus);
223 if (!sc->busy) {
224 device_t ppsdev = sc->ppsdev;
225
226 if (ppb_request_bus(ppbus, ppsdev, PPB_WAIT|PPB_INTR)) {
227 ppb_unlock(ppbus);
228 sx_xunlock(&sc->lock);
229 return (EINTR);
230 }
231
232 i = ppb_set_mode(sc->ppbus, PPB_PS2);
233 PRVERBOSE("EPP: %d %d\n", i, PPB_IN_EPP_MODE(sc->ppbus));
234
235 i = IRQENABLE | PCD | nINIT | SELECTIN;
236 ppb_wctr(ppbus, i);
237 }
238 if (subdev > 0 && !(sc->busy & ~1)) {
239 /* XXX: Timeout of 1? hz/100 instead perhaps? */
240 callout_reset(&sc->timeout, 1, ppshcpoll, sc);
241 sc->lastdata = ppb_rdtr(sc->ppbus);
242 }
243 sc->busy |= (1 << subdev);
244 ppb_unlock(ppbus);
245 sx_xunlock(&sc->lock);
246 return(0);
247 }
248
249 static int
ppsclose(struct cdev * dev,int flags,int fmt,struct thread * td)250 ppsclose(struct cdev *dev, int flags, int fmt, struct thread *td)
251 {
252 struct pps_data *sc = dev->si_drv1;
253 int subdev = (intptr_t)dev->si_drv2;
254
255 sx_xlock(&sc->lock);
256 sc->pps[subdev].ppsparam.mode = 0; /* PHK ??? */
257 ppb_lock(sc->ppbus);
258 sc->busy &= ~(1 << subdev);
259 if (subdev > 0 && !(sc->busy & ~1))
260 callout_stop(&sc->timeout);
261 if (!sc->busy) {
262 device_t ppsdev = sc->ppsdev;
263 device_t ppbus = sc->ppbus;
264
265 ppb_wdtr(ppbus, 0);
266 ppb_wctr(ppbus, 0);
267
268 ppb_set_mode(ppbus, PPB_COMPATIBLE);
269 ppb_release_bus(ppbus, ppsdev);
270 }
271 ppb_unlock(sc->ppbus);
272 sx_xunlock(&sc->lock);
273 return(0);
274 }
275
276 static void
ppshcpoll(void * arg)277 ppshcpoll(void *arg)
278 {
279 struct pps_data *sc = arg;
280 int i, j, k, l;
281
282 KASSERT(sc->busy & ~1, ("pps polling w/o opened devices"));
283 i = ppb_rdtr(sc->ppbus);
284 if (i == sc->lastdata)
285 return;
286 l = sc->lastdata ^ i;
287 k = 1;
288 for (j = 1; j < 9; j ++) {
289 if (l & k) {
290 pps_capture(&sc->pps[j]);
291 pps_event(&sc->pps[j],
292 i & k ? PPS_CAPTUREASSERT : PPS_CAPTURECLEAR);
293 }
294 k += k;
295 }
296 sc->lastdata = i;
297 callout_reset(&sc->timeout, 1, ppshcpoll, sc);
298 }
299
300 static void
ppsintr(void * arg)301 ppsintr(void *arg)
302 {
303 struct pps_data *sc = (struct pps_data *)arg;
304
305 ppb_assert_locked(sc->ppbus);
306 pps_capture(&sc->pps[0]);
307 if (!(ppb_rstr(sc->ppbus) & nACK))
308 return;
309
310 if (sc->pps[0].ppsparam.mode & PPS_ECHOASSERT)
311 ppb_wctr(sc->ppbus, IRQENABLE | AUTOFEED);
312 pps_event(&sc->pps[0], PPS_CAPTUREASSERT);
313 if (sc->pps[0].ppsparam.mode & PPS_ECHOASSERT)
314 ppb_wctr(sc->ppbus, IRQENABLE);
315 }
316
317 static int
ppsioctl(struct cdev * dev,u_long cmd,caddr_t data,int flags,struct thread * td)318 ppsioctl(struct cdev *dev, u_long cmd, caddr_t data, int flags, struct thread *td)
319 {
320 struct pps_data *sc = dev->si_drv1;
321 int subdev = (intptr_t)dev->si_drv2;
322 int err;
323
324 ppb_lock(sc->ppbus);
325 err = pps_ioctl(cmd, data, &sc->pps[subdev]);
326 ppb_unlock(sc->ppbus);
327 return (err);
328 }
329
330 static device_method_t pps_methods[] = {
331 /* device interface */
332 DEVMETHOD(device_identify, ppsidentify),
333 DEVMETHOD(device_probe, ppsprobe),
334 DEVMETHOD(device_attach, ppsattach),
335 { 0, 0 }
336 };
337
338 static driver_t pps_driver = {
339 PPS_NAME,
340 pps_methods,
341 sizeof(struct pps_data),
342 };
343
344 DRIVER_MODULE(pps, ppbus, pps_driver, 0, 0);
345 MODULE_DEPEND(pps, ppbus, 1, 1, 1);
346