xref: /freebsd/sys/arm/allwinner/a31_dmac.c (revision 123af6ec70016f5556da5972d4d63c7d175c06d3)
1 /*-
2  * Copyright (c) 2016 Jared D. McNeill <jmcneill@invisible.ca>
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  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
19  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
21  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  */
27 
28 /*
29  * Allwinner DMA controller
30  */
31 
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
34 
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/bus.h>
38 #include <sys/rman.h>
39 #include <sys/condvar.h>
40 #include <sys/kernel.h>
41 #include <sys/module.h>
42 #include <sys/endian.h>
43 
44 #include <machine/bus.h>
45 
46 #include <dev/ofw/ofw_bus.h>
47 #include <dev/ofw/ofw_bus_subr.h>
48 
49 #include <arm/allwinner/a10_dmac.h>
50 #include <dev/extres/clk/clk.h>
51 #include <dev/extres/hwreset/hwreset.h>
52 
53 #include "sunxi_dma_if.h"
54 
55 #define	DMA_IRQ_EN_REG0		0x00
56 #define	DMA_IRQ_EN_REG1		0x04
57 #define	DMA_IRQ_EN_REG(ch)	(DMA_IRQ_EN_REG0 + ((ch) / 8) * 4)
58 #define	 DMA_PKG_IRQ_EN(ch)	(1 << (((ch) % 8) * 4 + 1))
59 #define	 DMA_PKG_IRQ_MASK	0x2222222222222222ULL
60 #define	DMA_IRQ_PEND_REG0	0x10
61 #define	DMA_IRQ_PEND_REG1	0x14
62 #define	DMA_IRQ_PEND_REG(ch)	(DMA_IRQ_PEND_REG0 + ((ch) / 8) * 4)
63 #define	DMA_STA_REG		0x30
64 #define	DMA_EN_REG(n)		(0x100 + (n) * 0x40 + 0x00)
65 #define	 DMA_EN			(1 << 0)
66 #define	DMA_PAU_REG(n)		(0x100 + (n) * 0x40 + 0x04)
67 #define	DMA_STAR_ADDR_REG(n)	(0x100 + (n) * 0x40 + 0x08)
68 #define	DMA_CFG_REG(n)		(0x100 + (n) * 0x40 + 0x0c)
69 #define	 DMA_DEST_DATA_WIDTH		(0x3 << 25)
70 #define	 DMA_DEST_DATA_WIDTH_SHIFT	25
71 #define	 DMA_DEST_BST_LEN		(0x3 << 22)
72 #define	 DMA_DEST_BST_LEN_SHIFT		22
73 #define	 DMA_DEST_ADDR_MODE		(0x1 << 21)
74 #define	 DMA_DEST_ADDR_MODE_SHIFT	21
75 #define	 DMA_DEST_DRQ_TYPE		(0x1f << 16)
76 #define	 DMA_DEST_DRQ_TYPE_SHIFT	16
77 #define	 DMA_SRC_DATA_WIDTH		(0x3 << 9)
78 #define	 DMA_SRC_DATA_WIDTH_SHIFT	9
79 #define	 DMA_SRC_BST_LEN		(0x3 << 6)
80 #define	 DMA_SRC_BST_LEN_SHIFT		6
81 #define	 DMA_SRC_ADDR_MODE		(0x1 << 5)
82 #define	 DMA_SRC_ADDR_MODE_SHIFT	5
83 #define	 DMA_SRC_DRQ_TYPE		(0x1f << 0)
84 #define	 DMA_SRC_DRQ_TYPE_SHIFT		0
85 #define	 DMA_DATA_WIDTH_8BIT		0
86 #define	 DMA_DATA_WIDTH_16BIT		1
87 #define	 DMA_DATA_WIDTH_32BIT		2
88 #define	 DMA_DATA_WIDTH_64BIT		3
89 #define	 DMA_ADDR_MODE_LINEAR		0
90 #define	 DMA_ADDR_MODE_IO		1
91 #define	 DMA_BST_LEN_1			0
92 #define	 DMA_BST_LEN_4			1
93 #define	 DMA_BST_LEN_8			2
94 #define	 DMA_BST_LEN_16			3
95 #define	DMA_CUR_SRC_REG(n)	(0x100 + (n) * 0x40 + 0x10)
96 #define	DMA_CUR_DEST_REG(n)	(0x100 + (n) * 0x40 + 0x14)
97 #define	DMA_BCNT_LEFT_REG(n)	(0x100 + (n) * 0x40 + 0x18)
98 #define	DMA_PARA_REG(n)		(0x100 + (n) * 0x40 + 0x1c)
99 #define	 WAIT_CYC			(0xff << 0)
100 #define	 WAIT_CYC_SHIFT			0
101 
102 struct a31dmac_desc {
103 	uint32_t		config;
104 	uint32_t		srcaddr;
105 	uint32_t		dstaddr;
106 	uint32_t		bcnt;
107 	uint32_t		para;
108 	uint32_t		next;
109 #define	DMA_NULL		0xfffff800
110 };
111 #define	DESC_ALIGN		4
112 #define	DESC_SIZE		sizeof(struct a31dmac_desc)
113 
114 struct a31dmac_config {
115 	u_int			nchans;
116 };
117 
118 static const struct a31dmac_config a31_config = { .nchans = 16 };
119 static const struct a31dmac_config h3_config = { .nchans = 12 };
120 static const struct a31dmac_config a83t_config = { .nchans = 8 };
121 static const struct a31dmac_config a64_config = { .nchans = 8 };
122 
123 static struct ofw_compat_data compat_data[] = {
124 	{ "allwinner,sun6i-a31-dma",	(uintptr_t)&a31_config },
125 	{ "allwinner,sun8i-a83t-dma",	(uintptr_t)&a83t_config },
126 	{ "allwinner,sun8i-h3-dma",	(uintptr_t)&h3_config },
127 	{ "allwinner,sun50i-a64-dma",	(uintptr_t)&a64_config },
128 	{ NULL,				(uintptr_t)NULL }
129 };
130 
131 struct a31dmac_softc;
132 
133 struct a31dmac_channel {
134 	struct a31dmac_softc *		sc;
135 	uint8_t				index;
136 	void				(*callback)(void *);
137 	void *				callbackarg;
138 
139 	bus_dmamap_t			dmamap;
140 	struct a31dmac_desc		*desc;
141 	bus_addr_t			physaddr;
142 };
143 
144 struct a31dmac_softc {
145 	struct resource *		res[2];
146 	struct mtx			mtx;
147 	void *				ih;
148 
149 	bus_dma_tag_t			dmat;
150 
151 	u_int				nchans;
152 	struct a31dmac_channel *	chans;
153 };
154 
155 static struct resource_spec a31dmac_spec[] = {
156 	{ SYS_RES_MEMORY,	0,	RF_ACTIVE },
157 	{ SYS_RES_IRQ,		0,	RF_ACTIVE },
158 	{ -1, 0 }
159 };
160 
161 #define	DMA_READ(sc, reg)	bus_read_4((sc)->res[0], (reg))
162 #define	DMA_WRITE(sc, reg, val)	bus_write_4((sc)->res[0], (reg), (val))
163 
164 static void a31dmac_intr(void *);
165 static void a31dmac_dmamap_cb(void *, bus_dma_segment_t *, int, int);
166 
167 static int
168 a31dmac_probe(device_t dev)
169 {
170 	if (!ofw_bus_status_okay(dev))
171 		return (ENXIO);
172 
173 	if (!ofw_bus_search_compatible(dev, compat_data)->ocd_data)
174 		return (ENXIO);
175 
176 	device_set_desc(dev, "Allwinner DMA controller");
177 	return (BUS_PROBE_DEFAULT);
178 }
179 
180 static int
181 a31dmac_attach(device_t dev)
182 {
183 	struct a31dmac_softc *sc;
184 	struct a31dmac_config *conf;
185 	u_int index;
186 	hwreset_t rst;
187 	clk_t clk;
188 	int error;
189 
190 	sc = device_get_softc(dev);
191 	conf = (void *)ofw_bus_search_compatible(dev, compat_data)->ocd_data;
192 	clk = NULL;
193 	rst = NULL;
194 
195 	if (bus_alloc_resources(dev, a31dmac_spec, sc->res)) {
196 		device_printf(dev, "cannot allocate resources for device\n");
197 		return (ENXIO);
198 	}
199 
200 	mtx_init(&sc->mtx, "a31 dmac", NULL, MTX_SPIN);
201 
202 	/* Clock and reset setup */
203 	if (clk_get_by_ofw_index(dev, 0, 0, &clk) != 0) {
204 		device_printf(dev, "cannot get clock\n");
205 		goto fail;
206 	}
207 	if (clk_enable(clk) != 0) {
208 		device_printf(dev, "cannot enable clock\n");
209 		goto fail;
210 	}
211 	if (hwreset_get_by_ofw_idx(dev, 0, 0, &rst) != 0) {
212 		device_printf(dev, "cannot get hwreset\n");
213 		goto fail;
214 	}
215 	if (hwreset_deassert(rst) != 0) {
216 		device_printf(dev, "cannot de-assert reset\n");
217 		goto fail;
218 	}
219 
220 	/* Descriptor DMA */
221 	error = bus_dma_tag_create(
222 		bus_get_dma_tag(dev),		/* Parent tag */
223 		DESC_ALIGN, 0,			/* alignment, boundary */
224 		BUS_SPACE_MAXADDR_32BIT,	/* lowaddr */
225 		BUS_SPACE_MAXADDR,		/* highaddr */
226 		NULL, NULL,			/* filter, filterarg */
227 		DESC_SIZE, 1,			/* maxsize, nsegs */
228 		DESC_SIZE,			/* maxsegsize */
229 		0,				/* flags */
230 		NULL, NULL,			/* lockfunc, lockarg */
231 		&sc->dmat);
232 	if (error != 0) {
233 		device_printf(dev, "cannot create dma tag\n");
234 		goto fail;
235 	}
236 
237 	/* Disable all interrupts and clear pending status */
238 	DMA_WRITE(sc, DMA_IRQ_EN_REG0, 0);
239 	DMA_WRITE(sc, DMA_IRQ_EN_REG1, 0);
240 	DMA_WRITE(sc, DMA_IRQ_PEND_REG0, ~0);
241 	DMA_WRITE(sc, DMA_IRQ_PEND_REG1, ~0);
242 
243 	/* Initialize channels */
244 	sc->nchans = conf->nchans;
245 	sc->chans = malloc(sizeof(*sc->chans) * sc->nchans, M_DEVBUF,
246 	    M_WAITOK | M_ZERO);
247 
248 	for (index = 0; index < sc->nchans; index++) {
249 		sc->chans[index].sc = sc;
250 		sc->chans[index].index = index;
251 		sc->chans[index].callback = NULL;
252 		sc->chans[index].callbackarg = NULL;
253 
254 		error = bus_dmamem_alloc(sc->dmat,
255 		    (void **)&sc->chans[index].desc,
256 		    BUS_DMA_WAITOK | BUS_DMA_COHERENT,
257 		    &sc->chans[index].dmamap);
258 		if (error != 0) {
259 			device_printf(dev, "cannot allocate dma mem\n");
260 			goto fail;
261 		}
262 		error = bus_dmamap_load(sc->dmat, sc->chans[index].dmamap,
263 		    sc->chans[index].desc, sizeof(*sc->chans[index].desc),
264 		    a31dmac_dmamap_cb, &sc->chans[index], BUS_DMA_WAITOK);
265 		if (error != 0) {
266 			device_printf(dev, "cannot load dma map\n");
267 			goto fail;
268 		}
269 
270 		DMA_WRITE(sc, DMA_EN_REG(index), 0);
271 	}
272 
273 	error = bus_setup_intr(dev, sc->res[1], INTR_MPSAFE | INTR_TYPE_MISC,
274 	    NULL, a31dmac_intr, sc, &sc->ih);
275 	if (error != 0) {
276 		device_printf(dev, "could not setup interrupt handler\n");
277 		bus_release_resources(dev, a31dmac_spec, sc->res);
278 		mtx_destroy(&sc->mtx);
279 		return (ENXIO);
280 	}
281 
282 	OF_device_register_xref(OF_xref_from_node(ofw_bus_get_node(dev)), dev);
283 	return (0);
284 
285 fail:
286 	for (index = 0; index < sc->nchans; index++)
287 		if (sc->chans[index].desc != NULL) {
288 			bus_dmamap_unload(sc->dmat, sc->chans[index].dmamap);
289 			bus_dmamem_free(sc->dmat, sc->chans[index].desc,
290 			    sc->chans[index].dmamap);
291 		}
292 	if (sc->chans != NULL)
293 		free(sc->chans, M_DEVBUF);
294 	if (sc->ih != NULL)
295 		bus_teardown_intr(dev, sc->res[1], sc->ih);
296 	if (rst != NULL)
297 		hwreset_release(rst);
298 	if (clk != NULL)
299 		clk_release(clk);
300 	bus_release_resources(dev, a31dmac_spec, sc->res);
301 
302 	return (ENXIO);
303 }
304 
305 static void
306 a31dmac_dmamap_cb(void *priv, bus_dma_segment_t *segs, int nsegs, int error)
307 {
308 	struct a31dmac_channel *ch;
309 
310 	if (error != 0)
311 		return;
312 
313 	ch = priv;
314 	ch->physaddr = segs[0].ds_addr;
315 }
316 
317 static void
318 a31dmac_intr(void *priv)
319 {
320 	struct a31dmac_softc *sc;
321 	uint32_t pend0, pend1, bit;
322 	uint64_t pend, mask;
323 	u_int index;
324 
325 	sc = priv;
326 	pend0 = DMA_READ(sc, DMA_IRQ_PEND_REG0);
327 	pend1 = sc->nchans > 8 ? DMA_READ(sc, DMA_IRQ_PEND_REG1) : 0;
328 	if (pend0 == 0 && pend1 == 0)
329 		return;
330 
331 	if (pend0 != 0)
332 		DMA_WRITE(sc, DMA_IRQ_PEND_REG0, pend0);
333 	if (pend1 != 0)
334 		DMA_WRITE(sc, DMA_IRQ_PEND_REG1, pend1);
335 
336 	pend = pend0 | ((uint64_t)pend1 << 32);
337 
338 	while ((bit = ffsll(pend & DMA_PKG_IRQ_MASK)) != 0) {
339 		mask = (1U << (bit - 1));
340 		pend &= ~mask;
341 		index = (bit - 1) / 4;
342 
343 		if (index >= sc->nchans)
344 			continue;
345 		if (sc->chans[index].callback == NULL)
346 			continue;
347 		sc->chans[index].callback(sc->chans[index].callbackarg);
348 	}
349 }
350 
351 static int
352 a31dmac_set_config(device_t dev, void *priv, const struct sunxi_dma_config *cfg)
353 {
354 	struct a31dmac_channel *ch;
355 	uint32_t config, para;
356 	unsigned int dst_dw, dst_bl, dst_wc, dst_am;
357 	unsigned int src_dw, src_bl, src_wc, src_am;
358 
359 	ch = priv;
360 
361 	switch (cfg->dst_width) {
362 	case 8:
363 		dst_dw = DMA_DATA_WIDTH_8BIT;
364 		break;
365 	case 16:
366 		dst_dw = DMA_DATA_WIDTH_16BIT;
367 		break;
368 	case 32:
369 		dst_dw = DMA_DATA_WIDTH_32BIT;
370 		break;
371 	case 64:
372 		dst_dw = DMA_DATA_WIDTH_64BIT;
373 		break;
374 	default:
375 		return (EINVAL);
376 	}
377 	switch (cfg->dst_burst_len) {
378 	case 1:
379 		dst_bl = DMA_BST_LEN_1;
380 		break;
381 	case 4:
382 		dst_bl = DMA_BST_LEN_4;
383 		break;
384 	case 8:
385 		dst_bl = DMA_BST_LEN_8;
386 		break;
387 	case 16:
388 		dst_bl = DMA_BST_LEN_16;
389 		break;
390 	default:
391 		return (EINVAL);
392 	}
393 	switch (cfg->src_width) {
394 	case 8:
395 		src_dw = DMA_DATA_WIDTH_8BIT;
396 		break;
397 	case 16:
398 		src_dw = DMA_DATA_WIDTH_16BIT;
399 		break;
400 	case 32:
401 		src_dw = DMA_DATA_WIDTH_32BIT;
402 		break;
403 	case 64:
404 		src_dw = DMA_DATA_WIDTH_64BIT;
405 	default:
406 		return (EINVAL);
407 	}
408 	switch (cfg->src_burst_len) {
409 	case 1:
410 		src_bl = DMA_BST_LEN_1;
411 		break;
412 	case 4:
413 		src_bl = DMA_BST_LEN_4;
414 		break;
415 	case 8:
416 		src_bl = DMA_BST_LEN_8;
417 		break;
418 	case 16:
419 		src_bl = DMA_BST_LEN_16;
420 		break;
421 	default:
422 		return (EINVAL);
423 	}
424 	dst_am = cfg->dst_noincr ? DMA_ADDR_MODE_IO : DMA_ADDR_MODE_LINEAR;
425 	src_am = cfg->src_noincr ? DMA_ADDR_MODE_IO : DMA_ADDR_MODE_LINEAR;
426 	dst_wc = cfg->dst_wait_cyc;
427 	src_wc = cfg->src_wait_cyc;
428 	if (dst_wc != src_wc)
429 		return (EINVAL);
430 
431 	config = (dst_dw << DMA_DEST_DATA_WIDTH_SHIFT) |
432 		 (dst_bl << DMA_DEST_BST_LEN_SHIFT) |
433 		 (dst_am << DMA_DEST_ADDR_MODE_SHIFT) |
434 		 (cfg->dst_drqtype << DMA_DEST_DRQ_TYPE_SHIFT) |
435 		 (src_dw << DMA_SRC_DATA_WIDTH_SHIFT) |
436 		 (src_bl << DMA_SRC_BST_LEN_SHIFT) |
437 		 (src_am << DMA_SRC_ADDR_MODE_SHIFT) |
438 		 (cfg->src_drqtype << DMA_SRC_DRQ_TYPE_SHIFT);
439 	para = (dst_wc << WAIT_CYC_SHIFT);
440 
441 	ch->desc->config = htole32(config);
442 	ch->desc->para = htole32(para);
443 
444 	return (0);
445 }
446 
447 static void *
448 a31dmac_alloc(device_t dev, bool dedicated, void (*cb)(void *), void *cbarg)
449 {
450 	struct a31dmac_softc *sc;
451 	struct a31dmac_channel *ch;
452 	uint32_t irqen;
453 	u_int index;
454 
455 	sc = device_get_softc(dev);
456 	ch = NULL;
457 
458 	mtx_lock_spin(&sc->mtx);
459 	for (index = 0; index < sc->nchans; index++) {
460 		if (sc->chans[index].callback == NULL) {
461 			ch = &sc->chans[index];
462 			ch->callback = cb;
463 			ch->callbackarg = cbarg;
464 
465 			irqen = DMA_READ(sc, DMA_IRQ_EN_REG(index));
466 			irqen |= DMA_PKG_IRQ_EN(index);
467 			DMA_WRITE(sc, DMA_IRQ_EN_REG(index), irqen);
468 			break;
469 		}
470 	}
471 	mtx_unlock_spin(&sc->mtx);
472 
473 	return (ch);
474 }
475 
476 static void
477 a31dmac_free(device_t dev, void *priv)
478 {
479 	struct a31dmac_channel *ch;
480 	struct a31dmac_softc *sc;
481 	uint32_t irqen;
482 	u_int index;
483 
484 	ch = priv;
485 	sc = ch->sc;
486 	index = ch->index;
487 
488 	mtx_lock_spin(&sc->mtx);
489 
490 	irqen = DMA_READ(sc, DMA_IRQ_EN_REG(index));
491 	irqen &= ~DMA_PKG_IRQ_EN(index);
492 	DMA_WRITE(sc, DMA_IRQ_EN_REG(index), irqen);
493 	DMA_WRITE(sc, DMA_IRQ_PEND_REG(index), DMA_PKG_IRQ_EN(index));
494 
495 	ch->callback = NULL;
496 	ch->callbackarg = NULL;
497 
498 	mtx_unlock_spin(&sc->mtx);
499 }
500 
501 static int
502 a31dmac_transfer(device_t dev, void *priv, bus_addr_t src, bus_addr_t dst,
503     size_t nbytes)
504 {
505 	struct a31dmac_channel *ch;
506 	struct a31dmac_softc *sc;
507 
508 	ch = priv;
509 	sc = ch->sc;
510 
511 	ch->desc->srcaddr = htole32((uint32_t)src);
512 	ch->desc->dstaddr = htole32((uint32_t)dst);
513 	ch->desc->bcnt = htole32(nbytes);
514 	ch->desc->next = htole32(DMA_NULL);
515 
516 	DMA_WRITE(sc, DMA_STAR_ADDR_REG(ch->index), (uint32_t)ch->physaddr);
517 	DMA_WRITE(sc, DMA_EN_REG(ch->index), DMA_EN);
518 
519 	return (0);
520 }
521 
522 static void
523 a31dmac_halt(device_t dev, void *priv)
524 {
525 	struct a31dmac_channel *ch;
526 	struct a31dmac_softc *sc;
527 
528 	ch = priv;
529 	sc = ch->sc;
530 
531 	DMA_WRITE(sc, DMA_EN_REG(ch->index), 0);
532 }
533 
534 static device_method_t a31dmac_methods[] = {
535 	/* Device interface */
536 	DEVMETHOD(device_probe,		a31dmac_probe),
537 	DEVMETHOD(device_attach,	a31dmac_attach),
538 
539 	/* sunxi DMA interface */
540 	DEVMETHOD(sunxi_dma_alloc,	a31dmac_alloc),
541 	DEVMETHOD(sunxi_dma_free,	a31dmac_free),
542 	DEVMETHOD(sunxi_dma_set_config,	a31dmac_set_config),
543 	DEVMETHOD(sunxi_dma_transfer,	a31dmac_transfer),
544 	DEVMETHOD(sunxi_dma_halt,	a31dmac_halt),
545 
546 	DEVMETHOD_END
547 };
548 
549 static driver_t a31dmac_driver = {
550 	"a31dmac",
551 	a31dmac_methods,
552 	sizeof(struct a31dmac_softc)
553 };
554 
555 static devclass_t a31dmac_devclass;
556 
557 DRIVER_MODULE(a31dmac, simplebus, a31dmac_driver, a31dmac_devclass, 0, 0);
558