xref: /freebsd/sys/dev/adlink/adlink.c (revision 2546665afcaf0d53dc2c7058fee96354b3680f5a) 
1 /*-
2  * Copyright (c) 2003 Poul-Henning Kamp
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. The names of the authors may not be used to endorse or promote
14  *    products derived from this software without specific prior written
15  *    permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29 
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
32 
33 #ifdef _KERNEL
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/malloc.h>
37 #include <sys/kernel.h>
38 #include <sys/module.h>
39 #include <sys/kthread.h>
40 #include <sys/conf.h>
41 #include <sys/bus.h>
42 #include <machine/bus.h>
43 #include <machine/resource.h>
44 #include <sys/rman.h>
45 #include <dev/pci/pcireg.h>
46 #include <dev/pci/pcivar.h>
47 #include <pci_if.h>
48 #include <vm/vm.h>
49 #include <vm/pmap.h>
50 
51 #endif /* _KERNEL */
52 
53 #include <sys/ioccom.h>
54 
55 struct wave {
56 	int			index;
57 	int			period;
58 	int			offset;
59 	int			length;
60 	int			avg;
61 	off_t			mapvir;
62 	int			flags;
63 
64 	int			npages;
65 	void			**virtual;
66 };
67 
68 #define ADLINK_SETWAVE		_IOWR('A', 232, struct wave)
69 #define ADLINK_GETWAVE		_IOWR('A', 233, struct wave)
70 
71 #ifdef _KERNEL
72 
73 #define INTPERPAGE (PAGE_SIZE / sizeof(int))
74 #define I16PERPAGE (PAGE_SIZE / sizeof(int16_t))
75 
76 /*
77  * Sample rate
78  */
79 #define SPS	1250000
80 
81 /*
82  * We sample one channel (= 16 bits) at 1.25 msps giving 2.5Mbyte/sec,
83  * 100 pages will give us about 1/6 second buffering.
84  */
85 #define NRING	100
86 
87 /*
88  * How many waves are we willing to entertain
89  */
90 #define NWAVE	25
91 
92 struct info {
93 	int			nring;
94 	off_t			o_ring;
95 
96 	int			ngri;
97 	int			ppgri;
98 	off_t			o_gri;
99 };
100 
101 struct softc {
102 	device_t		device;
103 	void			*intrhand;
104 	struct resource		*r0, *r1, *ri;
105 	bus_space_tag_t		t0, t1;
106 	bus_space_handle_t	h0, h1;
107 	struct cdev *dev;
108 	off_t			mapvir;
109 
110 	struct proc		*procp;
111 
112 	struct info		*info;
113 
114 	struct wave		*wave[NWAVE];
115 
116 	int			idx;
117 	void			*ring[NRING];
118 	vm_paddr_t		pring[NRING];
119 	int			stat[NRING];
120 
121 	uint64_t		cnt;
122 
123 	u_char			flags[I16PERPAGE];
124 };
125 
126 static void
127 adlink_wave(struct softc *sc, struct wave *wp, int16_t *sp)
128 {
129 	int f, i, k, m, *ip;
130 
131 	f = 0;
132 	for (i = 0; i < I16PERPAGE; ) {
133 		k = (sc->cnt - wp->offset + i) % wp->period;
134 		if (k >= wp->length) {
135 			i += wp->period - k;
136 			sp += wp->period - k;
137 			continue;
138 		}
139 		m = k % INTPERPAGE;
140 		ip = (int *)(wp->virtual[k / INTPERPAGE]) + m;
141 		while (m < INTPERPAGE && i < I16PERPAGE && k < wp->length) {
142 			if (sc->flags[i] >= wp->index)
143 				*ip += (*sp * 8 - *ip) >> wp->avg;
144 			if (wp->flags & 1)
145 				sc->flags[i] = wp->index;
146 			sp++;
147 			ip++;
148 			m++;
149 			i++;
150 			k++;
151 		}
152 	}
153 }
154 
155 static void
156 adlink_tickle(struct softc *sc)
157 {
158 
159 	wakeup(sc);
160 	tsleep(&sc->ring, PUSER | PCATCH, "tickle", 1);
161 }
162 
163 static int
164 adlink_new_wave(struct softc *sc, int index, int period, int offset, int length, int avg, int flags)
165 {
166 	struct wave *wp;
167 	int l, i;
168 	void **oldvir, **newvir;
169 
170 	if (index < 0 || index >= NWAVE)
171 		return (EINVAL);
172 	wp = sc->wave[index];
173 	if (wp == NULL) {
174 		adlink_tickle(sc);
175 		wp = malloc(sizeof *wp, M_DEVBUF, M_WAITOK | M_ZERO);
176 	}
177 	l = howmany(length, INTPERPAGE);
178 	/* Setting a high average here to neuter the realtime bits */
179 	wp->avg = 31;
180 	if (wp->npages < l) {
181 		oldvir = wp->virtual;
182 		adlink_tickle(sc);
183 		newvir = malloc(sizeof(void *) * l, M_DEVBUF, M_WAITOK | M_ZERO);
184 		if (wp->npages > 0) {
185 			adlink_tickle(sc);
186 			bcopy(oldvir, newvir, wp->npages * sizeof(void *));
187 		}
188 		for (i = wp->npages; i < l; i++) {
189 			adlink_tickle(sc);
190 			newvir[i] = malloc(PAGE_SIZE, M_DEVBUF, M_WAITOK);
191 		}
192 		wp->virtual = newvir;
193 		wp->npages = l;
194 		wp->mapvir = sc->mapvir;
195 		sc->mapvir += l * PAGE_SIZE;
196 	} else {
197 		oldvir = NULL;
198 	}
199 	wp->index = index;
200 	wp->period = period;
201 	wp->offset = offset;
202 	wp->length = length;
203 	wp->flags = flags;
204 
205 	for (i = 0; i < l; i++) {
206 		adlink_tickle(sc);
207 		bzero(wp->virtual[i], PAGE_SIZE);
208 	}
209 	wp->avg = avg;
210 	sc->wave[index] = wp;
211 	printf("Wave[%d] {period %d, offset %d, length %d, avg %d, flags %x}\n",
212 	    wp->index, wp->period, wp->offset, wp->length, wp->avg, wp->flags);
213 	free(oldvir, M_DEVBUF);
214 	return (0);
215 }
216 
217 static void
218 adlink_loran(void *arg)
219 {
220 	struct softc *sc;
221 	int idx, i;
222 
223 	sc = arg;
224 	idx = 0;
225 	mtx_lock(&Giant);
226 	for (;;) {
227 		while (sc->stat[idx] == 0)
228 			msleep(sc, NULL, PRIBIO, "loran", 1);
229 		memset(sc->flags, NWAVE, sizeof sc->flags);
230 		for (i = 0; i < NWAVE; i++) {
231 			if (sc->wave[i] != NULL)
232 				adlink_wave(sc, sc->wave[i], sc->ring[idx]);
233 		}
234 		sc->cnt += I16PERPAGE;
235 		sc->stat[idx] = 0;
236 		idx++;
237 		idx %= NRING;
238 	}
239 	mtx_unlock(&Giant);
240 	kthread_exit(0);
241 }
242 
243 static int
244 adlink_open(struct cdev *dev, int oflags, int devtype, struct thread *td)
245 {
246 	static int once;
247 	struct softc *sc;
248 	int i, error;
249 	uint32_t u;
250 
251 	if (once)
252 		return (0);
253 	once = 1;
254 
255 	sc = dev->si_drv1;
256 	sc->info = malloc(PAGE_SIZE, M_DEVBUF, M_ZERO | M_WAITOK);
257 	sc->info->nring = NRING;
258 
259 	sc->info->o_ring = PAGE_SIZE;
260 	for (i = 0; i < NRING; i++) {
261 		sc->ring[i] = malloc(PAGE_SIZE, M_DEVBUF, M_ZERO | M_WAITOK);
262 		sc->pring[i] = vtophys(sc->ring[i]);
263 	}
264 
265 	error = adlink_new_wave(sc, NWAVE - 1, SPS, 0, SPS, 7, 0);
266 	if (error)
267 		return (error);
268 
269 	error = kthread_create(adlink_loran, sc, &sc->procp,
270 	    0, 0, "adlink%d", device_get_unit(sc->device));
271 	if (error)
272 		return (error);
273 
274 	/* Enable interrupts on write complete */
275 	bus_space_write_4(sc->t0, sc->h0, 0x38, 0x00004000);
276 
277 	/* Sample CH0 only */
278 	bus_space_write_4(sc->t1, sc->h1, 0x00, 1);
279 
280 	/* Divide clock by four */
281 	bus_space_write_4(sc->t1, sc->h1, 0x04, 4);
282 
283 	/* Software trigger mode: software */
284 	bus_space_write_4(sc->t1, sc->h1, 0x08, 0);
285 
286 	/* Trigger level zero */
287 	bus_space_write_4(sc->t1, sc->h1, 0x0c, 0);
288 
289 	/* Trigger source CH0 (not used) */
290 	bus_space_write_4(sc->t1, sc->h1, 0x10, 0);
291 
292 	/* Fifo control/status: flush */
293 	bus_space_write_4(sc->t1, sc->h1, 0x18, 3);
294 
295 	/* Clock source: external sine */
296 	bus_space_write_4(sc->t1, sc->h1, 0x20, 2);
297 
298 	/* Set up Write DMA */
299 	bus_space_write_4(sc->t0, sc->h0, 0x24, sc->pring[i]);
300 	bus_space_write_4(sc->t0, sc->h0, 0x28, PAGE_SIZE);
301 	u = bus_space_read_4(sc->t0, sc->h0, 0x3c);
302 	bus_space_write_4(sc->t0, sc->h0, 0x3c, u | 0x00000600);
303 
304 	/* Acquisition Enable Register: go! */
305 	bus_space_write_4(sc->t1, sc->h1, 0x1c, 1);
306 	return (0);
307 }
308 
309 static int
310 adlink_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
311 {
312 	struct softc *sc;
313 	struct wave *wp;
314 	int i, error;
315 
316 	sc = dev->si_drv1;
317 	wp = (struct wave *)data;
318 	i = wp->index;
319 	if (i < 0 || i >= NWAVE)
320 		return (EINVAL);
321 	if (cmd == ADLINK_GETWAVE) {
322 		if (sc->wave[i] == NULL)
323 			return (ENOENT);
324 		bcopy(sc->wave[i], wp, sizeof(*wp));
325 		return (0);
326 	}
327 	if (cmd == ADLINK_SETWAVE) {
328 		error = adlink_new_wave(sc,
329 			i,
330 			wp->period,
331 			wp->offset,
332 			wp->length,
333 			wp->avg,
334 			wp->flags);
335 		if (error)
336 			return (error);
337 		bcopy(sc->wave[i], wp, sizeof(*wp));
338 		return (0);
339 	}
340 	return (ENOIOCTL);
341 }
342 
343 static int
344 adlink_mmap(struct cdev *dev, vm_offset_t offset, vm_paddr_t *paddr, int nprot)
345 {
346 	struct softc *sc;
347 	struct wave *wp;
348 	int i, j;
349 
350 	sc = dev->si_drv1;
351 	if (nprot != VM_PROT_READ)
352 		return (-1);
353 	for (i = 0; i < NWAVE; i++) {
354 		if (sc->wave[i] == NULL)
355 			continue;
356 		wp = sc->wave[i];
357 		if (offset < wp->mapvir)
358 			continue;
359 		j = (offset - wp->mapvir) / PAGE_SIZE;
360 		if (j >= wp->npages)
361 			continue;
362 		*paddr = vtophys(wp->virtual[j]);
363 		return (0);
364 	}
365 	return (-1);
366 }
367 
368 static void
369 adlink_intr(void *arg)
370 {
371 	struct softc *sc;
372 	uint32_t u;
373 	int i, j;
374 
375 	sc = arg;
376 	u = bus_space_read_4(sc->t0, sc->h0, 0x38);
377 	if (!(u & 0x00800000))
378 		return;
379 	bus_space_write_4(sc->t0, sc->h0, 0x38, u | 0x003f4000);
380 
381 	j = sc->idx;
382 	sc->stat[j] = 1;
383 	i = (j + 1) % NRING;
384 	sc->idx = i;
385 	u = bus_space_read_4(sc->t1, sc->h1, 0x18);
386 	if (u & 1) {
387 		printf("adlink FIFO overrun\n");
388 		return;
389 	}
390 	bus_space_write_4(sc->t0, sc->h0, 0x24, sc->pring[i]);
391 	bus_space_write_4(sc->t0, sc->h0, 0x28, PAGE_SIZE);
392 	wakeup(sc);
393 	if (sc->stat[i]) {
394 		printf("adlink page busy\n");
395 	}
396 }
397 
398 static struct cdevsw adlink_cdevsw = {
399 	.d_version =	D_VERSION,
400 	.d_flags =	D_NEEDGIANT,
401 	.d_open =	adlink_open,
402 	.d_ioctl =	adlink_ioctl,
403 	.d_mmap =	adlink_mmap,
404 	.d_name =	"adlink",
405 };
406 
407 static devclass_t adlink_devclass;
408 
409 static int
410 adlink_probe(device_t self)
411 {
412 
413 	if (pci_get_devid(self) != 0x80da10e8)
414 		return (ENXIO);
415 	device_set_desc(self, "Adlink PCI-9812 4 ch 12 bit 20 msps");
416 	return (0);
417 }
418 
419 static int
420 adlink_attach(device_t self)
421 {
422 	struct softc *sc;
423 	int rid, i;
424 
425 	sc = device_get_softc(self);
426 	bzero(sc, sizeof *sc);
427 	sc->device = self;
428 
429 	/*
430 	 * This is the PCI mapped registers of the AMCC 9535 "matchmaker"
431 	 * chip.
432 	 */
433 	rid = 0x10;
434 	sc->r0 = bus_alloc_resource_any(self, SYS_RES_IOPORT, &rid, RF_ACTIVE);
435 	if (sc->r0 == NULL)
436 		return(ENODEV);
437 	sc->t0 = rman_get_bustag(sc->r0);
438 	sc->h0 = rman_get_bushandle(sc->r0);
439 	printf("Res0 %x %x\n", sc->t0, sc->h0);
440 
441 	/*
442 	 * This is the PCI mapped registers of the ADC hardware, they
443 	 * are described in the manual which comes with the card.
444 	 */
445 	rid = 0x14;
446 	sc->r1 =  bus_alloc_resource_any(self, SYS_RES_IOPORT, &rid, RF_ACTIVE);
447 	if (sc->r1 == NULL)
448 		return(ENODEV);
449 	sc->t1 = rman_get_bustag(sc->r1);
450 	sc->h1 = rman_get_bushandle(sc->r1);
451 	printf("Res1 %x %x\n", sc->t1, sc->h1);
452 
453 	rid = 0x0;
454 	sc->ri =  bus_alloc_resource_any(self, SYS_RES_IRQ, &rid,
455             RF_ACTIVE | RF_SHAREABLE);
456 	if (sc->ri == NULL)
457 		return (ENODEV);
458 
459 	i = bus_setup_intr(self, sc->ri, INTR_MPSAFE | INTR_TYPE_MISC | INTR_FAST,
460 	    adlink_intr, sc, &sc->intrhand);
461 	if (i) {
462 		printf("adlink: Couldn't get FAST intr\n");
463 		i = bus_setup_intr(self, sc->ri, INTR_TYPE_MISC,
464 		    adlink_intr, sc, &sc->intrhand);
465 	}
466 
467 	if (i)
468 		return (ENODEV);
469 
470 	sc->dev = make_dev(&adlink_cdevsw, device_get_unit(self),
471 	    UID_ROOT, GID_WHEEL, 0444, "adlink%d", device_get_unit(self));
472 	sc->dev->si_drv1 = sc;
473 
474 	return (0);
475 }
476 
477 static device_method_t adlink_methods[] = {
478 	/* Device interface */
479 	DEVMETHOD(device_probe,		adlink_probe),
480 	DEVMETHOD(device_attach,	adlink_attach),
481 	DEVMETHOD(device_suspend,	bus_generic_suspend),
482 	DEVMETHOD(device_resume,	bus_generic_resume),
483 	DEVMETHOD(device_shutdown,	bus_generic_shutdown),
484 	{0, 0}
485 };
486 
487 static driver_t adlink_driver = {
488 	"adlink",
489 	adlink_methods,
490 	sizeof(struct softc)
491 };
492 
493 DRIVER_MODULE(adlink, pci, adlink_driver, adlink_devclass, 0, 0);
494 #endif /* _KERNEL */
495