1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2011
5 * Ben Gray <[email protected]>.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY 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 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 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/bus.h>
36 #include <sys/kernel.h>
37 #include <sys/lock.h>
38 #include <sys/interrupt.h>
39 #include <sys/module.h>
40 #include <sys/malloc.h>
41 #include <sys/mutex.h>
42 #include <sys/rman.h>
43 #include <sys/queue.h>
44 #include <sys/taskqueue.h>
45 #include <sys/timetc.h>
46 #include <machine/bus.h>
47 #include <machine/intr.h>
48
49 #include <dev/ofw/openfirm.h>
50 #include <dev/ofw/ofw_bus.h>
51 #include <dev/ofw/ofw_bus_subr.h>
52
53 #include <arm/ti/ti_cpuid.h>
54 #include <arm/ti/ti_prcm.h>
55 #include <arm/ti/ti_sdma.h>
56 #include <arm/ti/ti_sdmareg.h>
57
58 /**
59 * Kernel functions for using the DMA controller
60 *
61 *
62 * DMA TRANSFERS:
63 * A DMA transfer block consists of a number of frames (FN). Each frame
64 * consists of a number of elements, and each element can have a size of 8, 16,
65 * or 32 bits.
66 *
67 * OMAP44xx and newer chips support linked list (aka scatter gather) transfers,
68 * where a linked list of source/destination pairs can be placed in memory
69 * for the H/W to process. Earlier chips only allowed you to chain multiple
70 * channels together. However currently this linked list feature is not
71 * supported by the driver.
72 *
73 */
74
75 /**
76 * Data structure per DMA channel.
77 *
78 *
79 */
80 struct ti_sdma_channel {
81
82 /*
83 * The configuration registers for the given channel, these are modified
84 * by the set functions and only written to the actual registers when a
85 * transaction is started.
86 */
87 uint32_t reg_csdp;
88 uint32_t reg_ccr;
89 uint32_t reg_cicr;
90
91 /* Set when one of the configuration registers above change */
92 uint32_t need_reg_write;
93
94 /* Callback function used when an interrupt is tripped on the given channel */
95 void (*callback)(unsigned int ch, uint32_t ch_status, void *data);
96
97 /* Callback data passed in the callback ... duh */
98 void* callback_data;
99
100 };
101
102 /**
103 * DMA driver context, allocated and stored globally, this driver is not
104 * intetned to ever be unloaded (see ti_sdma_sc).
105 *
106 */
107 struct ti_sdma_softc {
108 device_t sc_dev;
109 struct resource* sc_irq_res;
110 struct resource* sc_mem_res;
111
112 /*
113 * I guess in theory we should have a mutex per DMA channel for register
114 * modifications. But since we know we are never going to be run on a SMP
115 * system, we can use just the single lock for all channels.
116 */
117 struct mtx sc_mtx;
118
119 /* Stores the H/W revision read from the registers */
120 uint32_t sc_hw_rev;
121
122 /*
123 * Bits in the sc_active_channels data field indicate if the channel has
124 * been activated.
125 */
126 uint32_t sc_active_channels;
127
128 struct ti_sdma_channel sc_channel[NUM_DMA_CHANNELS];
129
130 };
131
132 static struct ti_sdma_softc *ti_sdma_sc = NULL;
133
134 /**
135 * Macros for driver mutex locking
136 */
137 #define TI_SDMA_LOCK(_sc) mtx_lock_spin(&(_sc)->sc_mtx)
138 #define TI_SDMA_UNLOCK(_sc) mtx_unlock_spin(&(_sc)->sc_mtx)
139 #define TI_SDMA_LOCK_INIT(_sc) \
140 mtx_init(&_sc->sc_mtx, device_get_nameunit(_sc->sc_dev), \
141 "ti_sdma", MTX_SPIN)
142 #define TI_SDMA_LOCK_DESTROY(_sc) mtx_destroy(&_sc->sc_mtx);
143 #define TI_SDMA_ASSERT_LOCKED(_sc) mtx_assert(&_sc->sc_mtx, MA_OWNED);
144 #define TI_SDMA_ASSERT_UNLOCKED(_sc) mtx_assert(&_sc->sc_mtx, MA_NOTOWNED);
145
146 /**
147 * Function prototypes
148 *
149 */
150 static void ti_sdma_intr(void *);
151
152 /**
153 * ti_sdma_read_4 - reads a 32-bit value from one of the DMA registers
154 * @sc: DMA device context
155 * @off: The offset of a register from the DMA register address range
156 *
157 *
158 * RETURNS:
159 * 32-bit value read from the register.
160 */
161 static inline uint32_t
ti_sdma_read_4(struct ti_sdma_softc * sc,bus_size_t off)162 ti_sdma_read_4(struct ti_sdma_softc *sc, bus_size_t off)
163 {
164 return bus_read_4(sc->sc_mem_res, off);
165 }
166
167 /**
168 * ti_sdma_write_4 - writes a 32-bit value to one of the DMA registers
169 * @sc: DMA device context
170 * @off: The offset of a register from the DMA register address range
171 *
172 *
173 * RETURNS:
174 * 32-bit value read from the register.
175 */
176 static inline void
ti_sdma_write_4(struct ti_sdma_softc * sc,bus_size_t off,uint32_t val)177 ti_sdma_write_4(struct ti_sdma_softc *sc, bus_size_t off, uint32_t val)
178 {
179 bus_write_4(sc->sc_mem_res, off, val);
180 }
181
182 /**
183 * ti_sdma_is_omap3_rev - returns true if H/W is from OMAP3 series
184 * @sc: DMA device context
185 *
186 */
187 static inline int
ti_sdma_is_omap3_rev(struct ti_sdma_softc * sc)188 ti_sdma_is_omap3_rev(struct ti_sdma_softc *sc)
189 {
190 return (sc->sc_hw_rev == DMA4_OMAP3_REV);
191 }
192
193 /**
194 * ti_sdma_is_omap4_rev - returns true if H/W is from OMAP4 series
195 * @sc: DMA device context
196 *
197 */
198 static inline int
ti_sdma_is_omap4_rev(struct ti_sdma_softc * sc)199 ti_sdma_is_omap4_rev(struct ti_sdma_softc *sc)
200 {
201 return (sc->sc_hw_rev == DMA4_OMAP4_REV);
202 }
203
204 /**
205 * ti_sdma_intr - interrupt handler for all 4 DMA IRQs
206 * @arg: ignored
207 *
208 * Called when any of the four DMA IRQs are triggered.
209 *
210 * LOCKING:
211 * DMA registers protected by internal mutex
212 *
213 * RETURNS:
214 * nothing
215 */
216 static void
ti_sdma_intr(void * arg)217 ti_sdma_intr(void *arg)
218 {
219 struct ti_sdma_softc *sc = ti_sdma_sc;
220 uint32_t intr;
221 uint32_t csr;
222 unsigned int ch, j;
223 struct ti_sdma_channel* channel;
224
225 TI_SDMA_LOCK(sc);
226
227 for (j = 0; j < NUM_DMA_IRQS; j++) {
228
229 /* Get the flag interrupts (enabled) */
230 intr = ti_sdma_read_4(sc, DMA4_IRQSTATUS_L(j));
231 intr &= ti_sdma_read_4(sc, DMA4_IRQENABLE_L(j));
232 if (intr == 0x00000000)
233 continue;
234
235 /* Loop through checking the status bits */
236 for (ch = 0; ch < NUM_DMA_CHANNELS; ch++) {
237 if (intr & (1 << ch)) {
238 channel = &sc->sc_channel[ch];
239
240 /* Read the CSR regsiter and verify we don't have a spurious IRQ */
241 csr = ti_sdma_read_4(sc, DMA4_CSR(ch));
242 if (csr == 0) {
243 device_printf(sc->sc_dev, "Spurious DMA IRQ for channel "
244 "%d\n", ch);
245 continue;
246 }
247
248 /* Sanity check this channel is active */
249 if ((sc->sc_active_channels & (1 << ch)) == 0) {
250 device_printf(sc->sc_dev, "IRQ %d for a non-activated "
251 "channel %d\n", j, ch);
252 continue;
253 }
254
255 /* Check the status error codes */
256 if (csr & DMA4_CSR_DROP)
257 device_printf(sc->sc_dev, "Synchronization event drop "
258 "occurred during the transfer on channel %u\n",
259 ch);
260 if (csr & DMA4_CSR_SECURE_ERR)
261 device_printf(sc->sc_dev, "Secure transaction error event "
262 "on channel %u\n", ch);
263 if (csr & DMA4_CSR_MISALIGNED_ADRS_ERR)
264 device_printf(sc->sc_dev, "Misaligned address error event "
265 "on channel %u\n", ch);
266 if (csr & DMA4_CSR_TRANS_ERR) {
267 device_printf(sc->sc_dev, "Transaction error event on "
268 "channel %u\n", ch);
269 /*
270 * Apparently according to linux code, there is an errata
271 * that says the channel is not disabled upon this error.
272 * They explicitly disable the channel here .. since I
273 * haven't seen the errata, I'm going to ignore for now.
274 */
275 }
276
277 /* Clear the status flags for the IRQ */
278 ti_sdma_write_4(sc, DMA4_CSR(ch), DMA4_CSR_CLEAR_MASK);
279 ti_sdma_write_4(sc, DMA4_IRQSTATUS_L(j), (1 << ch));
280
281 /* Call the callback for the given channel */
282 if (channel->callback)
283 channel->callback(ch, csr, channel->callback_data);
284 }
285 }
286 }
287
288 TI_SDMA_UNLOCK(sc);
289
290 return;
291 }
292
293 /**
294 * ti_sdma_activate_channel - activates a DMA channel
295 * @ch: upon return contains the channel allocated
296 * @callback: a callback function to associate with the channel
297 * @data: optional data supplied when the callback is called
298 *
299 * Simply activates a channel be enabling and writing default values to the
300 * channel's register set. It doesn't start a transaction, just populates the
301 * internal data structures and sets defaults.
302 *
303 * Note this function doesn't enable interrupts, for that you need to call
304 * ti_sdma_enable_channel_irq(). If not using IRQ to detect the end of the
305 * transfer, you can use ti_sdma_status_poll() to detect a change in the
306 * status.
307 *
308 * A channel must be activated before any of the other DMA functions can be
309 * called on it.
310 *
311 * LOCKING:
312 * DMA registers protected by internal mutex
313 *
314 * RETURNS:
315 * 0 on success, otherwise an error code
316 */
317 int
ti_sdma_activate_channel(unsigned int * ch,void (* callback)(unsigned int ch,uint32_t status,void * data),void * data)318 ti_sdma_activate_channel(unsigned int *ch,
319 void (*callback)(unsigned int ch, uint32_t status, void *data),
320 void *data)
321 {
322 struct ti_sdma_softc *sc = ti_sdma_sc;
323 struct ti_sdma_channel *channel = NULL;
324 uint32_t addr;
325 unsigned int i;
326
327 /* Sanity check */
328 if (sc == NULL)
329 return (ENOMEM);
330
331 if (ch == NULL)
332 return (EINVAL);
333
334 TI_SDMA_LOCK(sc);
335
336 /* Check to see if all channels are in use */
337 if (sc->sc_active_channels == 0xffffffff) {
338 TI_SDMA_UNLOCK(sc);
339 return (ENOMEM);
340 }
341
342 /* Find the first non-active channel */
343 for (i = 0; i < NUM_DMA_CHANNELS; i++) {
344 if (!(sc->sc_active_channels & (0x1 << i))) {
345 sc->sc_active_channels |= (0x1 << i);
346 *ch = i;
347 break;
348 }
349 }
350
351 /* Get the channel struct and populate the fields */
352 channel = &sc->sc_channel[*ch];
353
354 channel->callback = callback;
355 channel->callback_data = data;
356
357 channel->need_reg_write = 1;
358
359 /* Set the default configuration for the DMA channel */
360 channel->reg_csdp = DMA4_CSDP_DATA_TYPE(0x2)
361 | DMA4_CSDP_SRC_BURST_MODE(0)
362 | DMA4_CSDP_DST_BURST_MODE(0)
363 | DMA4_CSDP_SRC_ENDIANISM(0)
364 | DMA4_CSDP_DST_ENDIANISM(0)
365 | DMA4_CSDP_WRITE_MODE(0)
366 | DMA4_CSDP_SRC_PACKED(0)
367 | DMA4_CSDP_DST_PACKED(0);
368
369 channel->reg_ccr = DMA4_CCR_DST_ADDRESS_MODE(1)
370 | DMA4_CCR_SRC_ADDRESS_MODE(1)
371 | DMA4_CCR_READ_PRIORITY(0)
372 | DMA4_CCR_WRITE_PRIORITY(0)
373 | DMA4_CCR_SYNC_TRIGGER(0)
374 | DMA4_CCR_FRAME_SYNC(0)
375 | DMA4_CCR_BLOCK_SYNC(0);
376
377 channel->reg_cicr = DMA4_CICR_TRANS_ERR_IE
378 | DMA4_CICR_SECURE_ERR_IE
379 | DMA4_CICR_SUPERVISOR_ERR_IE
380 | DMA4_CICR_MISALIGNED_ADRS_ERR_IE;
381
382 /* Clear all the channel registers, this should abort any transaction */
383 for (addr = DMA4_CCR(*ch); addr <= DMA4_COLOR(*ch); addr += 4)
384 ti_sdma_write_4(sc, addr, 0x00000000);
385
386 TI_SDMA_UNLOCK(sc);
387
388 return 0;
389 }
390
391 /**
392 * ti_sdma_deactivate_channel - deactivates a channel
393 * @ch: the channel to deactivate
394 *
395 *
396 *
397 * LOCKING:
398 * DMA registers protected by internal mutex
399 *
400 * RETURNS:
401 * EH_HANDLED or EH_NOT_HANDLED
402 */
403 int
ti_sdma_deactivate_channel(unsigned int ch)404 ti_sdma_deactivate_channel(unsigned int ch)
405 {
406 struct ti_sdma_softc *sc = ti_sdma_sc;
407 unsigned int j;
408 unsigned int addr;
409
410 /* Sanity check */
411 if (sc == NULL)
412 return (ENOMEM);
413
414 TI_SDMA_LOCK(sc);
415
416 /* First check if the channel is currently active */
417 if ((sc->sc_active_channels & (1 << ch)) == 0) {
418 TI_SDMA_UNLOCK(sc);
419 return (EBUSY);
420 }
421
422 /* Mark the channel as inactive */
423 sc->sc_active_channels &= ~(1 << ch);
424
425 /* Disable all DMA interrupts for the channel. */
426 ti_sdma_write_4(sc, DMA4_CICR(ch), 0);
427
428 /* Make sure the DMA transfer is stopped. */
429 ti_sdma_write_4(sc, DMA4_CCR(ch), 0);
430
431 /* Clear the CSR register and IRQ status register */
432 ti_sdma_write_4(sc, DMA4_CSR(ch), DMA4_CSR_CLEAR_MASK);
433 for (j = 0; j < NUM_DMA_IRQS; j++) {
434 ti_sdma_write_4(sc, DMA4_IRQSTATUS_L(j), (1 << ch));
435 }
436
437 /* Clear all the channel registers, this should abort any transaction */
438 for (addr = DMA4_CCR(ch); addr <= DMA4_COLOR(ch); addr += 4)
439 ti_sdma_write_4(sc, addr, 0x00000000);
440
441 TI_SDMA_UNLOCK(sc);
442
443 return 0;
444 }
445
446 /**
447 * ti_sdma_disable_channel_irq - disables IRQ's on the given channel
448 * @ch: the channel to disable IRQ's on
449 *
450 * Disable interrupt generation for the given channel.
451 *
452 * LOCKING:
453 * DMA registers protected by internal mutex
454 *
455 * RETURNS:
456 * EH_HANDLED or EH_NOT_HANDLED
457 */
458 int
ti_sdma_disable_channel_irq(unsigned int ch)459 ti_sdma_disable_channel_irq(unsigned int ch)
460 {
461 struct ti_sdma_softc *sc = ti_sdma_sc;
462 uint32_t irq_enable;
463 unsigned int j;
464
465 /* Sanity check */
466 if (sc == NULL)
467 return (ENOMEM);
468
469 TI_SDMA_LOCK(sc);
470
471 if ((sc->sc_active_channels & (1 << ch)) == 0) {
472 TI_SDMA_UNLOCK(sc);
473 return (EINVAL);
474 }
475
476 /* Disable all the individual error conditions */
477 sc->sc_channel[ch].reg_cicr = 0x0000;
478 ti_sdma_write_4(sc, DMA4_CICR(ch), 0x0000);
479
480 /* Disable the channel interrupt enable */
481 for (j = 0; j < NUM_DMA_IRQS; j++) {
482 irq_enable = ti_sdma_read_4(sc, DMA4_IRQENABLE_L(j));
483 irq_enable &= ~(1 << ch);
484
485 ti_sdma_write_4(sc, DMA4_IRQENABLE_L(j), irq_enable);
486 }
487
488 /* Indicate the registers need to be rewritten on the next transaction */
489 sc->sc_channel[ch].need_reg_write = 1;
490
491 TI_SDMA_UNLOCK(sc);
492
493 return (0);
494 }
495
496 /**
497 * ti_sdma_disable_channel_irq - enables IRQ's on the given channel
498 * @ch: the channel to enable IRQ's on
499 * @flags: bitmask of interrupt types to enable
500 *
501 * Flags can be a bitmask of the following options:
502 * DMA_IRQ_FLAG_DROP
503 * DMA_IRQ_FLAG_HALF_FRAME_COMPL
504 * DMA_IRQ_FLAG_FRAME_COMPL
505 * DMA_IRQ_FLAG_START_LAST_FRAME
506 * DMA_IRQ_FLAG_BLOCK_COMPL
507 * DMA_IRQ_FLAG_ENDOF_PKT
508 * DMA_IRQ_FLAG_DRAIN
509 *
510 *
511 * LOCKING:
512 * DMA registers protected by internal mutex
513 *
514 * RETURNS:
515 * EH_HANDLED or EH_NOT_HANDLED
516 */
517 int
ti_sdma_enable_channel_irq(unsigned int ch,uint32_t flags)518 ti_sdma_enable_channel_irq(unsigned int ch, uint32_t flags)
519 {
520 struct ti_sdma_softc *sc = ti_sdma_sc;
521 uint32_t irq_enable;
522
523 /* Sanity check */
524 if (sc == NULL)
525 return (ENOMEM);
526
527 TI_SDMA_LOCK(sc);
528
529 if ((sc->sc_active_channels & (1 << ch)) == 0) {
530 TI_SDMA_UNLOCK(sc);
531 return (EINVAL);
532 }
533
534 /* Always enable the error interrupts if we have interrupts enabled */
535 flags |= DMA4_CICR_TRANS_ERR_IE | DMA4_CICR_SECURE_ERR_IE |
536 DMA4_CICR_SUPERVISOR_ERR_IE | DMA4_CICR_MISALIGNED_ADRS_ERR_IE;
537
538 sc->sc_channel[ch].reg_cicr = flags;
539
540 /* Write the values to the register */
541 ti_sdma_write_4(sc, DMA4_CICR(ch), flags);
542
543 /* Enable the channel interrupt enable */
544 irq_enable = ti_sdma_read_4(sc, DMA4_IRQENABLE_L(0));
545 irq_enable |= (1 << ch);
546
547 ti_sdma_write_4(sc, DMA4_IRQENABLE_L(0), irq_enable);
548
549 /* Indicate the registers need to be rewritten on the next transaction */
550 sc->sc_channel[ch].need_reg_write = 1;
551
552 TI_SDMA_UNLOCK(sc);
553
554 return (0);
555 }
556
557 /**
558 * ti_sdma_get_channel_status - returns the status of a given channel
559 * @ch: the channel number to get the status of
560 * @status: upon return will contain the status bitmask, see below for possible
561 * values.
562 *
563 * DMA_STATUS_DROP
564 * DMA_STATUS_HALF
565 * DMA_STATUS_FRAME
566 * DMA_STATUS_LAST
567 * DMA_STATUS_BLOCK
568 * DMA_STATUS_SYNC
569 * DMA_STATUS_PKT
570 * DMA_STATUS_TRANS_ERR
571 * DMA_STATUS_SECURE_ERR
572 * DMA_STATUS_SUPERVISOR_ERR
573 * DMA_STATUS_MISALIGNED_ADRS_ERR
574 * DMA_STATUS_DRAIN_END
575 *
576 *
577 * LOCKING:
578 * DMA registers protected by internal mutex
579 *
580 * RETURNS:
581 * EH_HANDLED or EH_NOT_HANDLED
582 */
583 int
ti_sdma_get_channel_status(unsigned int ch,uint32_t * status)584 ti_sdma_get_channel_status(unsigned int ch, uint32_t *status)
585 {
586 struct ti_sdma_softc *sc = ti_sdma_sc;
587 uint32_t csr;
588
589 /* Sanity check */
590 if (sc == NULL)
591 return (ENOMEM);
592
593 TI_SDMA_LOCK(sc);
594
595 if ((sc->sc_active_channels & (1 << ch)) == 0) {
596 TI_SDMA_UNLOCK(sc);
597 return (EINVAL);
598 }
599
600 TI_SDMA_UNLOCK(sc);
601
602 csr = ti_sdma_read_4(sc, DMA4_CSR(ch));
603
604 if (status != NULL)
605 *status = csr;
606
607 return (0);
608 }
609
610 /**
611 * ti_sdma_start_xfer - starts a DMA transfer
612 * @ch: the channel number to set the endianness of
613 * @src_paddr: the source phsyical address
614 * @dst_paddr: the destination phsyical address
615 * @frmcnt: the number of frames per block
616 * @elmcnt: the number of elements in a frame, an element is either an 8, 16
617 * or 32-bit value as defined by ti_sdma_set_xfer_burst()
618 *
619 *
620 * LOCKING:
621 * DMA registers protected by internal mutex
622 *
623 * RETURNS:
624 * EH_HANDLED or EH_NOT_HANDLED
625 */
626 int
ti_sdma_start_xfer(unsigned int ch,unsigned int src_paddr,unsigned long dst_paddr,unsigned int frmcnt,unsigned int elmcnt)627 ti_sdma_start_xfer(unsigned int ch, unsigned int src_paddr,
628 unsigned long dst_paddr,
629 unsigned int frmcnt, unsigned int elmcnt)
630 {
631 struct ti_sdma_softc *sc = ti_sdma_sc;
632 struct ti_sdma_channel *channel;
633 uint32_t ccr;
634
635 /* Sanity check */
636 if (sc == NULL)
637 return (ENOMEM);
638
639 TI_SDMA_LOCK(sc);
640
641 if ((sc->sc_active_channels & (1 << ch)) == 0) {
642 TI_SDMA_UNLOCK(sc);
643 return (EINVAL);
644 }
645
646 channel = &sc->sc_channel[ch];
647
648 /* a) Write the CSDP register */
649 ti_sdma_write_4(sc, DMA4_CSDP(ch),
650 channel->reg_csdp | DMA4_CSDP_WRITE_MODE(1));
651
652 /* b) Set the number of element per frame CEN[23:0] */
653 ti_sdma_write_4(sc, DMA4_CEN(ch), elmcnt);
654
655 /* c) Set the number of frame per block CFN[15:0] */
656 ti_sdma_write_4(sc, DMA4_CFN(ch), frmcnt);
657
658 /* d) Set the Source/dest start address index CSSA[31:0]/CDSA[31:0] */
659 ti_sdma_write_4(sc, DMA4_CSSA(ch), src_paddr);
660 ti_sdma_write_4(sc, DMA4_CDSA(ch), dst_paddr);
661
662 /* e) Write the CCR register */
663 ti_sdma_write_4(sc, DMA4_CCR(ch), channel->reg_ccr);
664
665 /* f) - Set the source element index increment CSEI[15:0] */
666 ti_sdma_write_4(sc, DMA4_CSE(ch), 0x0001);
667
668 /* - Set the source frame index increment CSFI[15:0] */
669 ti_sdma_write_4(sc, DMA4_CSF(ch), 0x0001);
670
671 /* - Set the destination element index increment CDEI[15:0]*/
672 ti_sdma_write_4(sc, DMA4_CDE(ch), 0x0001);
673
674 /* - Set the destination frame index increment CDFI[31:0] */
675 ti_sdma_write_4(sc, DMA4_CDF(ch), 0x0001);
676
677 /* Clear the status register */
678 ti_sdma_write_4(sc, DMA4_CSR(ch), 0x1FFE);
679
680 /* Write the start-bit and away we go */
681 ccr = ti_sdma_read_4(sc, DMA4_CCR(ch));
682 ccr |= (1 << 7);
683 ti_sdma_write_4(sc, DMA4_CCR(ch), ccr);
684
685 /* Clear the reg write flag */
686 channel->need_reg_write = 0;
687
688 TI_SDMA_UNLOCK(sc);
689
690 return (0);
691 }
692
693 /**
694 * ti_sdma_start_xfer_packet - starts a packet DMA transfer
695 * @ch: the channel number to use for the transfer
696 * @src_paddr: the source physical address
697 * @dst_paddr: the destination physical address
698 * @frmcnt: the number of frames to transfer
699 * @elmcnt: the number of elements in a frame, an element is either an 8, 16
700 * or 32-bit value as defined by ti_sdma_set_xfer_burst()
701 * @pktsize: the number of elements in each transfer packet
702 *
703 * The @frmcnt and @elmcnt define the overall number of bytes to transfer,
704 * typically @frmcnt is 1 and @elmcnt contains the total number of elements.
705 * @pktsize is the size of each individual packet, there might be multiple
706 * packets per transfer. i.e. for the following with element size of 32-bits
707 *
708 * frmcnt = 1, elmcnt = 512, pktsize = 128
709 *
710 * Total transfer bytes = 1 * 512 = 512 elements or 2048 bytes
711 * Packets transferred = 128 / 512 = 4
712 *
713 *
714 * LOCKING:
715 * DMA registers protected by internal mutex
716 *
717 * RETURNS:
718 * EH_HANDLED or EH_NOT_HANDLED
719 */
720 int
ti_sdma_start_xfer_packet(unsigned int ch,unsigned int src_paddr,unsigned long dst_paddr,unsigned int frmcnt,unsigned int elmcnt,unsigned int pktsize)721 ti_sdma_start_xfer_packet(unsigned int ch, unsigned int src_paddr,
722 unsigned long dst_paddr, unsigned int frmcnt,
723 unsigned int elmcnt, unsigned int pktsize)
724 {
725 struct ti_sdma_softc *sc = ti_sdma_sc;
726 struct ti_sdma_channel *channel;
727 uint32_t ccr;
728
729 /* Sanity check */
730 if (sc == NULL)
731 return (ENOMEM);
732
733 TI_SDMA_LOCK(sc);
734
735 if ((sc->sc_active_channels & (1 << ch)) == 0) {
736 TI_SDMA_UNLOCK(sc);
737 return (EINVAL);
738 }
739
740 channel = &sc->sc_channel[ch];
741
742 /* a) Write the CSDP register */
743 if (channel->need_reg_write)
744 ti_sdma_write_4(sc, DMA4_CSDP(ch),
745 channel->reg_csdp | DMA4_CSDP_WRITE_MODE(1));
746
747 /* b) Set the number of elements to transfer CEN[23:0] */
748 ti_sdma_write_4(sc, DMA4_CEN(ch), elmcnt);
749
750 /* c) Set the number of frames to transfer CFN[15:0] */
751 ti_sdma_write_4(sc, DMA4_CFN(ch), frmcnt);
752
753 /* d) Set the Source/dest start address index CSSA[31:0]/CDSA[31:0] */
754 ti_sdma_write_4(sc, DMA4_CSSA(ch), src_paddr);
755 ti_sdma_write_4(sc, DMA4_CDSA(ch), dst_paddr);
756
757 /* e) Write the CCR register */
758 ti_sdma_write_4(sc, DMA4_CCR(ch),
759 channel->reg_ccr | DMA4_CCR_PACKET_TRANS);
760
761 /* f) - Set the source element index increment CSEI[15:0] */
762 ti_sdma_write_4(sc, DMA4_CSE(ch), 0x0001);
763
764 /* - Set the packet size, this is dependent on the sync source */
765 if (channel->reg_ccr & DMA4_CCR_SEL_SRC_DST_SYNC(1))
766 ti_sdma_write_4(sc, DMA4_CSF(ch), pktsize);
767 else
768 ti_sdma_write_4(sc, DMA4_CDF(ch), pktsize);
769
770 /* - Set the destination frame index increment CDFI[31:0] */
771 ti_sdma_write_4(sc, DMA4_CDE(ch), 0x0001);
772
773 /* Clear the status register */
774 ti_sdma_write_4(sc, DMA4_CSR(ch), 0x1FFE);
775
776 /* Write the start-bit and away we go */
777 ccr = ti_sdma_read_4(sc, DMA4_CCR(ch));
778 ccr |= (1 << 7);
779 ti_sdma_write_4(sc, DMA4_CCR(ch), ccr);
780
781 /* Clear the reg write flag */
782 channel->need_reg_write = 0;
783
784 TI_SDMA_UNLOCK(sc);
785
786 return (0);
787 }
788
789 /**
790 * ti_sdma_stop_xfer - stops any currently active transfers
791 * @ch: the channel number to set the endianness of
792 *
793 * This function call is effectively a NOP if no transaction is in progress.
794 *
795 * LOCKING:
796 * DMA registers protected by internal mutex
797 *
798 * RETURNS:
799 * EH_HANDLED or EH_NOT_HANDLED
800 */
801 int
ti_sdma_stop_xfer(unsigned int ch)802 ti_sdma_stop_xfer(unsigned int ch)
803 {
804 struct ti_sdma_softc *sc = ti_sdma_sc;
805 unsigned int j;
806
807 /* Sanity check */
808 if (sc == NULL)
809 return (ENOMEM);
810
811 TI_SDMA_LOCK(sc);
812
813 if ((sc->sc_active_channels & (1 << ch)) == 0) {
814 TI_SDMA_UNLOCK(sc);
815 return (EINVAL);
816 }
817
818 /* Disable all DMA interrupts for the channel. */
819 ti_sdma_write_4(sc, DMA4_CICR(ch), 0);
820
821 /* Make sure the DMA transfer is stopped. */
822 ti_sdma_write_4(sc, DMA4_CCR(ch), 0);
823
824 /* Clear the CSR register and IRQ status register */
825 ti_sdma_write_4(sc, DMA4_CSR(ch), DMA4_CSR_CLEAR_MASK);
826 for (j = 0; j < NUM_DMA_IRQS; j++) {
827 ti_sdma_write_4(sc, DMA4_IRQSTATUS_L(j), (1 << ch));
828 }
829
830 /* Configuration registers need to be re-written on the next xfer */
831 sc->sc_channel[ch].need_reg_write = 1;
832
833 TI_SDMA_UNLOCK(sc);
834
835 return (0);
836 }
837
838 /**
839 * ti_sdma_set_xfer_endianess - sets the endianness of subsequent transfers
840 * @ch: the channel number to set the endianness of
841 * @src: the source endianness (either DMA_ENDIAN_LITTLE or DMA_ENDIAN_BIG)
842 * @dst: the destination endianness (either DMA_ENDIAN_LITTLE or DMA_ENDIAN_BIG)
843 *
844 *
845 * LOCKING:
846 * DMA registers protected by internal mutex
847 *
848 * RETURNS:
849 * EH_HANDLED or EH_NOT_HANDLED
850 */
851 int
ti_sdma_set_xfer_endianess(unsigned int ch,unsigned int src,unsigned int dst)852 ti_sdma_set_xfer_endianess(unsigned int ch, unsigned int src, unsigned int dst)
853 {
854 struct ti_sdma_softc *sc = ti_sdma_sc;
855
856 /* Sanity check */
857 if (sc == NULL)
858 return (ENOMEM);
859
860 TI_SDMA_LOCK(sc);
861
862 if ((sc->sc_active_channels & (1 << ch)) == 0) {
863 TI_SDMA_UNLOCK(sc);
864 return (EINVAL);
865 }
866
867 sc->sc_channel[ch].reg_csdp &= ~DMA4_CSDP_SRC_ENDIANISM(1);
868 sc->sc_channel[ch].reg_csdp |= DMA4_CSDP_SRC_ENDIANISM(src);
869
870 sc->sc_channel[ch].reg_csdp &= ~DMA4_CSDP_DST_ENDIANISM(1);
871 sc->sc_channel[ch].reg_csdp |= DMA4_CSDP_DST_ENDIANISM(dst);
872
873 sc->sc_channel[ch].need_reg_write = 1;
874
875 TI_SDMA_UNLOCK(sc);
876
877 return 0;
878 }
879
880 /**
881 * ti_sdma_set_xfer_burst - sets the source and destination element size
882 * @ch: the channel number to set the burst settings of
883 * @src: the source endianness (either DMA_BURST_NONE, DMA_BURST_16, DMA_BURST_32
884 * or DMA_BURST_64)
885 * @dst: the destination endianness (either DMA_BURST_NONE, DMA_BURST_16,
886 * DMA_BURST_32 or DMA_BURST_64)
887 *
888 * This function sets the size of the elements for all subsequent transfers.
889 *
890 * LOCKING:
891 * DMA registers protected by internal mutex
892 *
893 * RETURNS:
894 * EH_HANDLED or EH_NOT_HANDLED
895 */
896 int
ti_sdma_set_xfer_burst(unsigned int ch,unsigned int src,unsigned int dst)897 ti_sdma_set_xfer_burst(unsigned int ch, unsigned int src, unsigned int dst)
898 {
899 struct ti_sdma_softc *sc = ti_sdma_sc;
900
901 /* Sanity check */
902 if (sc == NULL)
903 return (ENOMEM);
904
905 TI_SDMA_LOCK(sc);
906
907 if ((sc->sc_active_channels & (1 << ch)) == 0) {
908 TI_SDMA_UNLOCK(sc);
909 return (EINVAL);
910 }
911
912 sc->sc_channel[ch].reg_csdp &= ~DMA4_CSDP_SRC_BURST_MODE(0x3);
913 sc->sc_channel[ch].reg_csdp |= DMA4_CSDP_SRC_BURST_MODE(src);
914
915 sc->sc_channel[ch].reg_csdp &= ~DMA4_CSDP_DST_BURST_MODE(0x3);
916 sc->sc_channel[ch].reg_csdp |= DMA4_CSDP_DST_BURST_MODE(dst);
917
918 sc->sc_channel[ch].need_reg_write = 1;
919
920 TI_SDMA_UNLOCK(sc);
921
922 return 0;
923 }
924
925 /**
926 * ti_sdma_set_xfer_data_type - driver attach function
927 * @ch: the channel number to set the endianness of
928 * @type: the xfer data type (either DMA_DATA_8BITS_SCALAR, DMA_DATA_16BITS_SCALAR
929 * or DMA_DATA_32BITS_SCALAR)
930 *
931 *
932 * LOCKING:
933 * DMA registers protected by internal mutex
934 *
935 * RETURNS:
936 * EH_HANDLED or EH_NOT_HANDLED
937 */
938 int
ti_sdma_set_xfer_data_type(unsigned int ch,unsigned int type)939 ti_sdma_set_xfer_data_type(unsigned int ch, unsigned int type)
940 {
941 struct ti_sdma_softc *sc = ti_sdma_sc;
942
943 /* Sanity check */
944 if (sc == NULL)
945 return (ENOMEM);
946
947 TI_SDMA_LOCK(sc);
948
949 if ((sc->sc_active_channels & (1 << ch)) == 0) {
950 TI_SDMA_UNLOCK(sc);
951 return (EINVAL);
952 }
953
954 sc->sc_channel[ch].reg_csdp &= ~DMA4_CSDP_DATA_TYPE(0x3);
955 sc->sc_channel[ch].reg_csdp |= DMA4_CSDP_DATA_TYPE(type);
956
957 sc->sc_channel[ch].need_reg_write = 1;
958
959 TI_SDMA_UNLOCK(sc);
960
961 return 0;
962 }
963
964 /**
965 * ti_sdma_set_callback - driver attach function
966 * @dev: dma device handle
967 *
968 *
969 *
970 * LOCKING:
971 * DMA registers protected by internal mutex
972 *
973 * RETURNS:
974 * EH_HANDLED or EH_NOT_HANDLED
975 */
976 int
ti_sdma_set_callback(unsigned int ch,void (* callback)(unsigned int ch,uint32_t status,void * data),void * data)977 ti_sdma_set_callback(unsigned int ch,
978 void (*callback)(unsigned int ch, uint32_t status, void *data),
979 void *data)
980 {
981 struct ti_sdma_softc *sc = ti_sdma_sc;
982
983 /* Sanity check */
984 if (sc == NULL)
985 return (ENOMEM);
986
987 TI_SDMA_LOCK(sc);
988
989 if ((sc->sc_active_channels & (1 << ch)) == 0) {
990 TI_SDMA_UNLOCK(sc);
991 return (EINVAL);
992 }
993
994 sc->sc_channel[ch].callback = callback;
995 sc->sc_channel[ch].callback_data = data;
996
997 sc->sc_channel[ch].need_reg_write = 1;
998
999 TI_SDMA_UNLOCK(sc);
1000
1001 return 0;
1002 }
1003
1004 /**
1005 * ti_sdma_sync_params - sets channel sync settings
1006 * @ch: the channel number to set the sync on
1007 * @trigger: the number of the sync trigger, this depends on what other H/W
1008 * module is triggering/receiving the DMA transactions
1009 * @mode: flags describing the sync mode to use, it may have one or more of
1010 * the following bits set; TI_SDMA_SYNC_FRAME,
1011 * TI_SDMA_SYNC_BLOCK, TI_SDMA_SYNC_TRIG_ON_SRC.
1012 *
1013 *
1014 *
1015 * LOCKING:
1016 * DMA registers protected by internal mutex
1017 *
1018 * RETURNS:
1019 * EH_HANDLED or EH_NOT_HANDLED
1020 */
1021 int
ti_sdma_sync_params(unsigned int ch,unsigned int trigger,unsigned int mode)1022 ti_sdma_sync_params(unsigned int ch, unsigned int trigger, unsigned int mode)
1023 {
1024 struct ti_sdma_softc *sc = ti_sdma_sc;
1025 uint32_t ccr;
1026
1027 /* Sanity check */
1028 if (sc == NULL)
1029 return (ENOMEM);
1030
1031 TI_SDMA_LOCK(sc);
1032
1033 if ((sc->sc_active_channels & (1 << ch)) == 0) {
1034 TI_SDMA_UNLOCK(sc);
1035 return (EINVAL);
1036 }
1037
1038 ccr = sc->sc_channel[ch].reg_ccr;
1039
1040 ccr &= ~DMA4_CCR_SYNC_TRIGGER(0x7F);
1041 ccr |= DMA4_CCR_SYNC_TRIGGER(trigger + 1);
1042
1043 if (mode & TI_SDMA_SYNC_FRAME)
1044 ccr |= DMA4_CCR_FRAME_SYNC(1);
1045 else
1046 ccr &= ~DMA4_CCR_FRAME_SYNC(1);
1047
1048 if (mode & TI_SDMA_SYNC_BLOCK)
1049 ccr |= DMA4_CCR_BLOCK_SYNC(1);
1050 else
1051 ccr &= ~DMA4_CCR_BLOCK_SYNC(1);
1052
1053 if (mode & TI_SDMA_SYNC_TRIG_ON_SRC)
1054 ccr |= DMA4_CCR_SEL_SRC_DST_SYNC(1);
1055 else
1056 ccr &= ~DMA4_CCR_SEL_SRC_DST_SYNC(1);
1057
1058 sc->sc_channel[ch].reg_ccr = ccr;
1059
1060 sc->sc_channel[ch].need_reg_write = 1;
1061
1062 TI_SDMA_UNLOCK(sc);
1063
1064 return 0;
1065 }
1066
1067 /**
1068 * ti_sdma_set_addr_mode - driver attach function
1069 * @ch: the channel number to set the endianness of
1070 * @rd_mode: the xfer source addressing mode (either DMA_ADDR_CONSTANT,
1071 * DMA_ADDR_POST_INCREMENT, DMA_ADDR_SINGLE_INDEX or
1072 * DMA_ADDR_DOUBLE_INDEX)
1073 * @wr_mode: the xfer destination addressing mode (either DMA_ADDR_CONSTANT,
1074 * DMA_ADDR_POST_INCREMENT, DMA_ADDR_SINGLE_INDEX or
1075 * DMA_ADDR_DOUBLE_INDEX)
1076 *
1077 *
1078 * LOCKING:
1079 * DMA registers protected by internal mutex
1080 *
1081 * RETURNS:
1082 * EH_HANDLED or EH_NOT_HANDLED
1083 */
1084 int
ti_sdma_set_addr_mode(unsigned int ch,unsigned int src_mode,unsigned int dst_mode)1085 ti_sdma_set_addr_mode(unsigned int ch, unsigned int src_mode,
1086 unsigned int dst_mode)
1087 {
1088 struct ti_sdma_softc *sc = ti_sdma_sc;
1089 uint32_t ccr;
1090
1091 /* Sanity check */
1092 if (sc == NULL)
1093 return (ENOMEM);
1094
1095 TI_SDMA_LOCK(sc);
1096
1097 if ((sc->sc_active_channels & (1 << ch)) == 0) {
1098 TI_SDMA_UNLOCK(sc);
1099 return (EINVAL);
1100 }
1101
1102 ccr = sc->sc_channel[ch].reg_ccr;
1103
1104 ccr &= ~DMA4_CCR_SRC_ADDRESS_MODE(0x3);
1105 ccr |= DMA4_CCR_SRC_ADDRESS_MODE(src_mode);
1106
1107 ccr &= ~DMA4_CCR_DST_ADDRESS_MODE(0x3);
1108 ccr |= DMA4_CCR_DST_ADDRESS_MODE(dst_mode);
1109
1110 sc->sc_channel[ch].reg_ccr = ccr;
1111
1112 sc->sc_channel[ch].need_reg_write = 1;
1113
1114 TI_SDMA_UNLOCK(sc);
1115
1116 return 0;
1117 }
1118
1119 /**
1120 * ti_sdma_probe - driver probe function
1121 * @dev: dma device handle
1122 *
1123 *
1124 *
1125 * RETURNS:
1126 * Always returns 0.
1127 */
1128 static int
ti_sdma_probe(device_t dev)1129 ti_sdma_probe(device_t dev)
1130 {
1131
1132 if (!ofw_bus_status_okay(dev))
1133 return (ENXIO);
1134
1135 if (!ofw_bus_is_compatible(dev, "ti,omap4430-sdma"))
1136 return (ENXIO);
1137
1138 device_set_desc(dev, "TI sDMA Controller");
1139 return (0);
1140 }
1141
1142 /**
1143 * ti_sdma_attach - driver attach function
1144 * @dev: dma device handle
1145 *
1146 * Initialises memory mapping/pointers to the DMA register set and requests
1147 * IRQs. This is effectively the setup function for the driver.
1148 *
1149 * RETURNS:
1150 * 0 on success or a negative error code failure.
1151 */
1152 static int
ti_sdma_attach(device_t dev)1153 ti_sdma_attach(device_t dev)
1154 {
1155 struct ti_sdma_softc *sc = device_get_softc(dev);
1156 unsigned int timeout;
1157 unsigned int i;
1158 int rid;
1159 void *ihl;
1160 int err;
1161
1162 /* Setup the basics */
1163 sc->sc_dev = dev;
1164
1165 /* No channels active at the moment */
1166 sc->sc_active_channels = 0x00000000;
1167
1168 /* Mutex to protect the shared data structures */
1169 TI_SDMA_LOCK_INIT(sc);
1170
1171 /* Get the memory resource for the register mapping */
1172 rid = 0;
1173 sc->sc_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, RF_ACTIVE);
1174 if (sc->sc_mem_res == NULL)
1175 panic("%s: Cannot map registers", device_get_name(dev));
1176
1177 /* Enable the interface and functional clocks */
1178 ti_prcm_clk_enable(SDMA_CLK);
1179
1180 /* Read the sDMA revision register and sanity check it's known */
1181 sc->sc_hw_rev = ti_sdma_read_4(sc, DMA4_REVISION);
1182 device_printf(dev, "sDMA revision %08x\n", sc->sc_hw_rev);
1183
1184 if (!ti_sdma_is_omap4_rev(sc) && !ti_sdma_is_omap3_rev(sc)) {
1185 device_printf(sc->sc_dev, "error - unknown sDMA H/W revision\n");
1186 return (EINVAL);
1187 }
1188
1189 /* Disable all interrupts */
1190 for (i = 0; i < NUM_DMA_IRQS; i++) {
1191 ti_sdma_write_4(sc, DMA4_IRQENABLE_L(i), 0x00000000);
1192 }
1193
1194 /* Soft-reset is only supported on pre-OMAP44xx devices */
1195 if (ti_sdma_is_omap3_rev(sc)) {
1196
1197 /* Soft-reset */
1198 ti_sdma_write_4(sc, DMA4_OCP_SYSCONFIG, 0x0002);
1199
1200 /* Set the timeout to 100ms*/
1201 timeout = (hz < 10) ? 1 : ((100 * hz) / 1000);
1202
1203 /* Wait for DMA reset to complete */
1204 while ((ti_sdma_read_4(sc, DMA4_SYSSTATUS) & 0x1) == 0x0) {
1205
1206 /* Sleep for a tick */
1207 pause("DMARESET", 1);
1208
1209 if (timeout-- == 0) {
1210 device_printf(sc->sc_dev, "sDMA reset operation timed out\n");
1211 return (EINVAL);
1212 }
1213 }
1214 }
1215
1216 /*
1217 * Install interrupt handlers for the for possible interrupts. Any channel
1218 * can trip one of the four IRQs
1219 */
1220 rid = 0;
1221 sc->sc_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
1222 RF_ACTIVE | RF_SHAREABLE);
1223 if (sc->sc_irq_res == NULL)
1224 panic("Unable to setup the dma irq handler.\n");
1225
1226 err = bus_setup_intr(dev, sc->sc_irq_res, INTR_TYPE_MISC | INTR_MPSAFE,
1227 NULL, ti_sdma_intr, NULL, &ihl);
1228 if (err)
1229 panic("%s: Cannot register IRQ", device_get_name(dev));
1230
1231 /* Store the DMA structure globally ... this driver should never be unloaded */
1232 ti_sdma_sc = sc;
1233
1234 return (0);
1235 }
1236
1237 static device_method_t ti_sdma_methods[] = {
1238 DEVMETHOD(device_probe, ti_sdma_probe),
1239 DEVMETHOD(device_attach, ti_sdma_attach),
1240 {0, 0},
1241 };
1242
1243 static driver_t ti_sdma_driver = {
1244 "ti_sdma",
1245 ti_sdma_methods,
1246 sizeof(struct ti_sdma_softc),
1247 };
1248 static devclass_t ti_sdma_devclass;
1249
1250 DRIVER_MODULE(ti_sdma, simplebus, ti_sdma_driver, ti_sdma_devclass, 0, 0);
1251 MODULE_DEPEND(ti_sdma, ti_prcm, 1, 1, 1);
1252