1/*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 2003-2004 Poul-Henning Kamp
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 3. The names of the authors may not be used to endorse or promote
16 *    products derived from this software without specific prior written
17 *    permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 *
31 * This is a device driver or the Adlink 9812 and 9810 ADC cards, mainly
32 * intended to support Software Defined Radio reception of timesignals
33 * in the VLF band.  See http://phk.freebsd.dk/loran-c
34 *
35 * The driver is configured with ioctls which define a ringbuffer with
36 * a given number of chunks in it.  The a control structure and the
37 * ringbuffer can then be mmap(2)'ed into userland and the application
38 * can operate on the data directly.
39 *
40 * Tested with 10MHz external clock, divisor of 2 (ie: 5MHz sampling),
41 * One channel active (ie: 2 bytes per sample = 10MB/sec) on a 660MHz
42 * Celeron PC.
43 *
44 */
45
46#ifdef _KERNEL
47#include <sys/cdefs.h>
48__FBSDID("$FreeBSD$");
49
50#include <sys/param.h>
51#include <sys/systm.h>
52#include <sys/malloc.h>
53#include <sys/kernel.h>
54#include <sys/module.h>
55#include <sys/kthread.h>
56#include <sys/conf.h>
57#include <sys/bus.h>
58#include <machine/bus.h>
59#include <machine/resource.h>
60#include <sys/rman.h>
61#include <dev/pci/pcireg.h>
62#include <dev/pci/pcivar.h>
63#include <pci_if.h>
64#include <vm/vm.h>
65#include <vm/pmap.h>
66
67#endif /* _KERNEL */
68
69#include <sys/ioccom.h>
70
71#define ADLINK_SETDIVISOR	_IOWR('A', 255, u_int)	/* divisor */
72#define ADLINK_SETCHUNKSIZE	_IOWR('A', 254, u_int)	/* bytes */
73#define ADLINK_SETRINGSIZE	_IOWR('A', 253, u_int)	/* bytes */
74#define ADLINK_START		_IOWR('A', 252, u_int)	/* dummy */
75#define ADLINK_STOP		_IOWR('A', 251, u_int)	/* dummy */
76#define ADLINK_RESET		_IOWR('A', 250, u_int)	/* dummy */
77
78struct page0 {
79	u_int			version;
80	int			state;
81#	  define STATE_RESET	-1
82#	  define STATE_RUN	0
83	u_int			divisor;	/* int */
84	u_int			chunksize;	/* bytes */
85	u_int			ringsize;	/* chunks */
86	u_int			o_sample;	/*
87						 * offset of ring generation
88						 * array
89						 */
90	u_int			o_ring;		/* offset of ring */
91};
92
93#define PAGE0VERSION	20050219
94
95#ifdef _KERNEL
96
97struct pgstat {
98	uint64_t		*sample;
99	vm_paddr_t		phys;
100	void			*virt;
101	struct pgstat		*next;
102};
103
104struct softc {
105	device_t		device;
106	void			*intrhand;
107	struct resource		*res[3];
108	struct cdev		*dev;
109	off_t			mapvir;
110	int			error;
111	struct page0		*p0;
112	u_int			nchunks;
113	struct pgstat		*chunks;
114	struct pgstat		*next;
115	uint64_t		sample;
116};
117
118static d_ioctl_t adlink_ioctl;
119static d_mmap_t	adlink_mmap;
120static int adlink_intr(void *arg);
121
122static struct cdevsw adlink_cdevsw = {
123	.d_version =	D_VERSION,
124	.d_flags =	D_NEEDGIANT,
125	.d_ioctl =	adlink_ioctl,
126	.d_mmap =	adlink_mmap,
127	.d_name =	"adlink",
128};
129
130static int
131adlink_intr(void *arg)
132{
133	struct softc *sc;
134	struct pgstat *pg;
135	uint32_t u;
136
137	sc = arg;
138	u = bus_read_4(sc->res[0], 0x38);
139	if (!(u & 0x00800000))
140		return (FILTER_STRAY);
141	bus_write_4(sc->res[0], 0x38, u | 0x003f4000);
142
143	sc->sample += sc->p0->chunksize / 2;
144	pg = sc->next;
145	*(pg->sample) = sc->sample;
146
147	u = bus_read_4(sc->res[1], 0x18);
148	if (u & 1)
149		sc->p0->state = EIO;
150
151	if (sc->p0->state != STATE_RUN) {
152		printf("adlink: stopping %d\n", sc->p0->state);
153		return (FILTER_STRAY);
154	}
155
156	pg = pg->next;
157	sc->next = pg;
158	*(pg->sample) = 0;
159	bus_write_4(sc->res[0], 0x24, pg->phys);
160	bus_write_4(sc->res[0], 0x28, sc->p0->chunksize);
161	wakeup(sc);
162	return (FILTER_HANDLED);
163}
164
165static int
166adlink_mmap(struct cdev *dev, vm_ooffset_t offset, vm_paddr_t *paddr,
167    int nprot, vm_memattr_t *memattr)
168{
169	struct softc *sc;
170	vm_offset_t o;
171	int i;
172	struct pgstat *pg;
173
174	sc = dev->si_drv1;
175	if (nprot != VM_PROT_READ)
176		return (-1);
177	if (offset == 0) {
178		*paddr = vtophys(sc->p0);
179		return (0);
180	}
181	o = PAGE_SIZE;
182	pg = sc->chunks;
183	for (i = 0; i < sc->nchunks; i++, pg++) {
184		if (offset - o >= sc->p0->chunksize) {
185			o += sc->p0->chunksize;
186			continue;
187		}
188		*paddr = pg->phys + (offset - o);
189		return (0);
190	}
191	return (-1);
192}
193
194static int
195adlink_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
196{
197	struct softc *sc;
198	int i, error;
199	u_int u;
200	struct pgstat *pg;
201	uint64_t *sample;
202
203	sc = dev->si_drv1;
204	u = *(u_int*)data;
205	error = 0;
206	switch (cmd) {
207	case ADLINK_SETDIVISOR:
208		if (sc->p0->state == STATE_RUN)
209			return (EBUSY);
210		if (u & 1)
211			return (EINVAL);
212		sc->p0->divisor = u;
213		break;
214	case ADLINK_SETCHUNKSIZE:
215		if (sc->p0->state != STATE_RESET)
216			return (EBUSY);
217		if (u % PAGE_SIZE)
218			return (EINVAL);
219		if (sc->p0->ringsize != 0 && sc->p0->ringsize % u)
220			return (EINVAL);
221		sc->p0->chunksize = u;
222		break;
223	case ADLINK_SETRINGSIZE:
224		if (sc->p0->state != STATE_RESET)
225			return (EBUSY);
226		if (u % PAGE_SIZE)
227			return (EINVAL);
228		if (sc->p0->chunksize != 0 && u % sc->p0->chunksize)
229			return (EINVAL);
230		sc->p0->ringsize = u;
231		break;
232	case ADLINK_START:
233		if (sc->p0->state == STATE_RUN)
234			return (EBUSY);
235		if (sc->p0->state == STATE_RESET) {
236
237			if (sc->p0->chunksize == 0)
238				sc->p0->chunksize = 4 * PAGE_SIZE;
239			if (sc->p0->ringsize == 0)
240				sc->p0->ringsize = 16 * sc->p0->chunksize;
241			if (sc->p0->divisor == 0)
242				sc->p0->divisor = 4;
243
244			sc->nchunks = sc->p0->ringsize / sc->p0->chunksize;
245			if (sc->nchunks * sizeof (*pg->sample) +
246			    sizeof *sc->p0 > PAGE_SIZE)
247				return (EINVAL);
248			sc->p0->o_ring = PAGE_SIZE;
249			sample = (uint64_t *)(sc->p0 + 1);
250			sc->p0->o_sample =
251			    (uintptr_t)sample - (uintptr_t)(sc->p0);
252			pg = malloc(sizeof *pg * sc->nchunks,
253			    M_DEVBUF, M_WAITOK | M_ZERO);
254			sc->chunks = pg;
255			for (i = 0; i < sc->nchunks; i++) {
256				pg->sample = sample;
257				*pg->sample = 0;
258				sample++;
259				pg->virt = contigmalloc(sc->p0->chunksize,
260				    M_DEVBUF, M_WAITOK,
261				    0ul, 0xfffffffful,
262				    PAGE_SIZE, 0);
263				pg->phys = vtophys(pg->virt);
264				if (i == sc->nchunks - 1)
265					pg->next = sc->chunks;
266				else
267					pg->next = pg + 1;
268				pg++;
269			}
270			sc->next = sc->chunks;
271		}
272
273		/* Reset generation numbers */
274		pg = sc->chunks;
275		for (i = 0; i < sc->nchunks; i++) {
276			*pg->sample = 0;
277			pg++;
278		}
279
280		/* Enable interrupts on write complete */
281		bus_write_4(sc->res[0], 0x38, 0x00004000);
282
283		/* Sample CH0 only */
284		bus_write_4(sc->res[1], 0x00, 1);
285
286		/* Divide clock by four */
287		bus_write_4(sc->res[1], 0x04, sc->p0->divisor);
288
289		/* Software trigger mode: software */
290		bus_write_4(sc->res[1], 0x08, 0);
291
292		/* Trigger level zero */
293		bus_write_4(sc->res[1], 0x0c, 0);
294
295		/* Trigger source CH0 (not used) */
296		bus_write_4(sc->res[1], 0x10, 0);
297
298		/* Fifo control/status: flush */
299		bus_write_4(sc->res[1], 0x18, 3);
300
301		/* Clock source: external sine */
302		bus_write_4(sc->res[1], 0x20, 2);
303
304		/* Chipmunks are go! */
305		sc->p0->state = STATE_RUN;
306
307		/* Set up Write DMA */
308		pg = sc->next = sc->chunks;
309		*(pg->sample) = 0;
310		bus_write_4(sc->res[0], 0x24, pg->phys);
311		bus_write_4(sc->res[0], 0x28, sc->p0->chunksize);
312		u = bus_read_4(sc->res[0], 0x3c);
313		bus_write_4(sc->res[0], 0x3c, u | 0x00000600);
314
315		/* Acquisition Enable Register: go! */
316		bus_write_4(sc->res[1], 0x1c, 1);
317
318		break;
319	case ADLINK_STOP:
320		if (sc->p0->state == STATE_RESET)
321			break;
322		sc->p0->state = EINTR;
323		while (*(sc->next->sample) == 0)
324			tsleep(sc, PUSER | PCATCH, "adstop", 1);
325		break;
326#ifdef notyet
327	/*
328	 * I'm not sure we can actually do this.  How do we revoke
329	 * the mmap'ed pages from any process having them mmapped ?
330	 */
331	case ADLINK_RESET:
332		if (sc->p0->state == STATE_RESET)
333			break;
334		sc->p0->state = EINTR;
335		while (*(sc->next->samp) == 0)
336			tsleep(sc, PUSER | PCATCH, "adreset", 1);
337		/* deallocate ring buffer */
338		break;
339#endif
340	default:
341		error = ENOIOCTL;
342		break;
343	}
344	return (error);
345}
346
347static devclass_t adlink_devclass;
348
349struct pci_id
350{
351	uint16_t	vendor;
352	uint16_t	device;
353	const char	*desc;
354} adlink_id[] = {
355	{ .vendor = 0x10e8, .device = 0x80da,
356	  .desc ="Adlink PCI-9812 4 ch 12 bit 20 msps" }
357};
358
359static int
360adlink_probe(device_t self)
361{
362	int i;
363	uint16_t vendor, device;
364
365	vendor = pci_get_vendor(self);
366	device = pci_get_device(self);
367	for (i = 0; i < nitems(adlink_id); i++) {
368		if (adlink_id[i].vendor == vendor &&
369		    adlink_id[i].device == device) {
370			device_set_desc(self, adlink_id[i].desc);
371			return (BUS_PROBE_DEFAULT);
372		}
373	}
374	return (ENXIO);
375}
376
377static struct resource_spec adlink_res_spec[] = {
378	{ SYS_RES_IOPORT,	PCIR_BAR(0),	RF_ACTIVE},
379	{ SYS_RES_IOPORT,	PCIR_BAR(1),	RF_ACTIVE},
380	{ SYS_RES_IRQ,		0,		RF_ACTIVE | RF_SHAREABLE},
381	{ -1, 0, 0 }
382};
383
384static int
385adlink_attach(device_t self)
386{
387	struct softc *sc;
388	int i, error;
389
390	sc = device_get_softc(self);
391	bzero(sc, sizeof *sc);
392	sc->device = self;
393
394	error = bus_alloc_resources(self, adlink_res_spec, sc->res);
395	if (error)
396		return (error);
397
398	i = bus_setup_intr(self, sc->res[2], INTR_TYPE_MISC,
399	    adlink_intr, NULL, sc, &sc->intrhand);
400	if (i) {
401		printf("adlink: Couldn't get FAST intr\n");
402		i = bus_setup_intr(self, sc->res[2],
403		    INTR_MPSAFE | INTR_TYPE_MISC,
404		    NULL, (driver_intr_t *)adlink_intr, sc, &sc->intrhand);
405	}
406
407	if (i) {
408		bus_release_resources(self, adlink_res_spec, sc->res);
409		return (ENODEV);
410	}
411
412	sc->p0 = malloc(PAGE_SIZE, M_DEVBUF, M_WAITOK | M_ZERO);
413	sc->p0->version = PAGE0VERSION;
414	sc->p0->state = STATE_RESET;
415
416	sc->dev = make_dev(&adlink_cdevsw, device_get_unit(self),
417	    UID_ROOT, GID_WHEEL, 0444, "adlink%d", device_get_unit(self));
418	sc->dev->si_drv1 = sc;
419
420	return (0);
421}
422
423static device_method_t adlink_methods[] = {
424	/* Device interface */
425	DEVMETHOD(device_probe,		adlink_probe),
426	DEVMETHOD(device_attach,	adlink_attach),
427	DEVMETHOD(device_suspend,	bus_generic_suspend),
428	DEVMETHOD(device_resume,	bus_generic_resume),
429	DEVMETHOD(device_shutdown,	bus_generic_shutdown),
430
431	DEVMETHOD_END
432};
433
434static driver_t adlink_driver = {
435	"adlink",
436	adlink_methods,
437	sizeof(struct softc)
438};
439
440DRIVER_MODULE(adlink, pci, adlink_driver, adlink_devclass, 0, 0);
441MODULE_PNP_INFO("U16:vendor;U16:device;D:#", pci, adlink, adlink_id,
442    nitems(adlink_id));
443#endif /* _KERNEL */
444