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