1 /* 2 * Copyright (C) Freescale Semicondutor, Inc. 2007, 2008. 3 * Copyright (C) Semihalf 2009 4 * 5 * Written by Piotr Ziecik <kosmo@semihalf.com>. Hardware description 6 * (defines, structures and comments) was taken from MPC5121 DMA driver 7 * written by Hongjun Chen <hong-jun.chen@freescale.com>. 8 * 9 * Approved as OSADL project by a majority of OSADL members and funded 10 * by OSADL membership fees in 2009; for details see www.osadl.org. 11 * 12 * This program is free software; you can redistribute it and/or modify it 13 * under the terms of the GNU General Public License as published by the Free 14 * Software Foundation; either version 2 of the License, or (at your option) 15 * any later version. 16 * 17 * This program is distributed in the hope that it will be useful, but WITHOUT 18 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 19 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 20 * more details. 21 * 22 * You should have received a copy of the GNU General Public License along with 23 * this program; if not, write to the Free Software Foundation, Inc., 59 24 * Temple Place - Suite 330, Boston, MA 02111-1307, USA. 25 * 26 * The full GNU General Public License is included in this distribution in the 27 * file called COPYING. 28 */ 29 30 /* 31 * This is initial version of MPC5121 DMA driver. Only memory to memory 32 * transfers are supported (tested using dmatest module). 33 */ 34 35 #include <linux/module.h> 36 #include <linux/dmaengine.h> 37 #include <linux/dma-mapping.h> 38 #include <linux/interrupt.h> 39 #include <linux/io.h> 40 #include <linux/of_device.h> 41 #include <linux/of_platform.h> 42 43 #include <linux/random.h> 44 45 /* Number of DMA Transfer descriptors allocated per channel */ 46 #define MPC_DMA_DESCRIPTORS 64 47 48 /* Macro definitions */ 49 #define MPC_DMA_CHANNELS 64 50 #define MPC_DMA_TCD_OFFSET 0x1000 51 52 /* Arbitration mode of group and channel */ 53 #define MPC_DMA_DMACR_EDCG (1 << 31) 54 #define MPC_DMA_DMACR_ERGA (1 << 3) 55 #define MPC_DMA_DMACR_ERCA (1 << 2) 56 57 /* Error codes */ 58 #define MPC_DMA_DMAES_VLD (1 << 31) 59 #define MPC_DMA_DMAES_GPE (1 << 15) 60 #define MPC_DMA_DMAES_CPE (1 << 14) 61 #define MPC_DMA_DMAES_ERRCHN(err) \ 62 (((err) >> 8) & 0x3f) 63 #define MPC_DMA_DMAES_SAE (1 << 7) 64 #define MPC_DMA_DMAES_SOE (1 << 6) 65 #define MPC_DMA_DMAES_DAE (1 << 5) 66 #define MPC_DMA_DMAES_DOE (1 << 4) 67 #define MPC_DMA_DMAES_NCE (1 << 3) 68 #define MPC_DMA_DMAES_SGE (1 << 2) 69 #define MPC_DMA_DMAES_SBE (1 << 1) 70 #define MPC_DMA_DMAES_DBE (1 << 0) 71 72 #define MPC_DMA_TSIZE_1 0x00 73 #define MPC_DMA_TSIZE_2 0x01 74 #define MPC_DMA_TSIZE_4 0x02 75 #define MPC_DMA_TSIZE_16 0x04 76 #define MPC_DMA_TSIZE_32 0x05 77 78 /* MPC5121 DMA engine registers */ 79 struct __attribute__ ((__packed__)) mpc_dma_regs { 80 /* 0x00 */ 81 u32 dmacr; /* DMA control register */ 82 u32 dmaes; /* DMA error status */ 83 /* 0x08 */ 84 u32 dmaerqh; /* DMA enable request high(channels 63~32) */ 85 u32 dmaerql; /* DMA enable request low(channels 31~0) */ 86 u32 dmaeeih; /* DMA enable error interrupt high(ch63~32) */ 87 u32 dmaeeil; /* DMA enable error interrupt low(ch31~0) */ 88 /* 0x18 */ 89 u8 dmaserq; /* DMA set enable request */ 90 u8 dmacerq; /* DMA clear enable request */ 91 u8 dmaseei; /* DMA set enable error interrupt */ 92 u8 dmaceei; /* DMA clear enable error interrupt */ 93 /* 0x1c */ 94 u8 dmacint; /* DMA clear interrupt request */ 95 u8 dmacerr; /* DMA clear error */ 96 u8 dmassrt; /* DMA set start bit */ 97 u8 dmacdne; /* DMA clear DONE status bit */ 98 /* 0x20 */ 99 u32 dmainth; /* DMA interrupt request high(ch63~32) */ 100 u32 dmaintl; /* DMA interrupt request low(ch31~0) */ 101 u32 dmaerrh; /* DMA error high(ch63~32) */ 102 u32 dmaerrl; /* DMA error low(ch31~0) */ 103 /* 0x30 */ 104 u32 dmahrsh; /* DMA hw request status high(ch63~32) */ 105 u32 dmahrsl; /* DMA hardware request status low(ch31~0) */ 106 u32 dmaihsa; /* DMA interrupt high select AXE(ch63~32) */ 107 u32 dmailsa; /* DMA interrupt low select AXE(ch31~0) */ 108 /* 0x40 ~ 0xff */ 109 u32 reserve0[48]; /* Reserved */ 110 /* 0x100 */ 111 u8 dchpri[MPC_DMA_CHANNELS]; 112 /* DMA channels(0~63) priority */ 113 }; 114 115 struct __attribute__ ((__packed__)) mpc_dma_tcd { 116 /* 0x00 */ 117 u32 saddr; /* Source address */ 118 119 u32 smod:5; /* Source address modulo */ 120 u32 ssize:3; /* Source data transfer size */ 121 u32 dmod:5; /* Destination address modulo */ 122 u32 dsize:3; /* Destination data transfer size */ 123 u32 soff:16; /* Signed source address offset */ 124 125 /* 0x08 */ 126 u32 nbytes; /* Inner "minor" byte count */ 127 u32 slast; /* Last source address adjustment */ 128 u32 daddr; /* Destination address */ 129 130 /* 0x14 */ 131 u32 citer_elink:1; /* Enable channel-to-channel linking on 132 * minor loop complete 133 */ 134 u32 citer_linkch:6; /* Link channel for minor loop complete */ 135 u32 citer:9; /* Current "major" iteration count */ 136 u32 doff:16; /* Signed destination address offset */ 137 138 /* 0x18 */ 139 u32 dlast_sga; /* Last Destination address adjustment/scatter 140 * gather address 141 */ 142 143 /* 0x1c */ 144 u32 biter_elink:1; /* Enable channel-to-channel linking on major 145 * loop complete 146 */ 147 u32 biter_linkch:6; 148 u32 biter:9; /* Beginning "major" iteration count */ 149 u32 bwc:2; /* Bandwidth control */ 150 u32 major_linkch:6; /* Link channel number */ 151 u32 done:1; /* Channel done */ 152 u32 active:1; /* Channel active */ 153 u32 major_elink:1; /* Enable channel-to-channel linking on major 154 * loop complete 155 */ 156 u32 e_sg:1; /* Enable scatter/gather processing */ 157 u32 d_req:1; /* Disable request */ 158 u32 int_half:1; /* Enable an interrupt when major counter is 159 * half complete 160 */ 161 u32 int_maj:1; /* Enable an interrupt when major iteration 162 * count completes 163 */ 164 u32 start:1; /* Channel start */ 165 }; 166 167 struct mpc_dma_desc { 168 struct dma_async_tx_descriptor desc; 169 struct mpc_dma_tcd *tcd; 170 dma_addr_t tcd_paddr; 171 int error; 172 struct list_head node; 173 }; 174 175 struct mpc_dma_chan { 176 struct dma_chan chan; 177 struct list_head free; 178 struct list_head prepared; 179 struct list_head queued; 180 struct list_head active; 181 struct list_head completed; 182 struct mpc_dma_tcd *tcd; 183 dma_addr_t tcd_paddr; 184 dma_cookie_t completed_cookie; 185 186 /* Lock for this structure */ 187 spinlock_t lock; 188 }; 189 190 struct mpc_dma { 191 struct dma_device dma; 192 struct tasklet_struct tasklet; 193 struct mpc_dma_chan channels[MPC_DMA_CHANNELS]; 194 struct mpc_dma_regs __iomem *regs; 195 struct mpc_dma_tcd __iomem *tcd; 196 int irq; 197 uint error_status; 198 199 /* Lock for error_status field in this structure */ 200 spinlock_t error_status_lock; 201 }; 202 203 #define DRV_NAME "mpc512x_dma" 204 205 /* Convert struct dma_chan to struct mpc_dma_chan */ 206 static inline struct mpc_dma_chan *dma_chan_to_mpc_dma_chan(struct dma_chan *c) 207 { 208 return container_of(c, struct mpc_dma_chan, chan); 209 } 210 211 /* Convert struct dma_chan to struct mpc_dma */ 212 static inline struct mpc_dma *dma_chan_to_mpc_dma(struct dma_chan *c) 213 { 214 struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(c); 215 return container_of(mchan, struct mpc_dma, channels[c->chan_id]); 216 } 217 218 /* 219 * Execute all queued DMA descriptors. 220 * 221 * Following requirements must be met while calling mpc_dma_execute(): 222 * a) mchan->lock is acquired, 223 * b) mchan->active list is empty, 224 * c) mchan->queued list contains at least one entry. 225 */ 226 static void mpc_dma_execute(struct mpc_dma_chan *mchan) 227 { 228 struct mpc_dma *mdma = dma_chan_to_mpc_dma(&mchan->chan); 229 struct mpc_dma_desc *first = NULL; 230 struct mpc_dma_desc *prev = NULL; 231 struct mpc_dma_desc *mdesc; 232 int cid = mchan->chan.chan_id; 233 234 /* Move all queued descriptors to active list */ 235 list_splice_tail_init(&mchan->queued, &mchan->active); 236 237 /* Chain descriptors into one transaction */ 238 list_for_each_entry(mdesc, &mchan->active, node) { 239 if (!first) 240 first = mdesc; 241 242 if (!prev) { 243 prev = mdesc; 244 continue; 245 } 246 247 prev->tcd->dlast_sga = mdesc->tcd_paddr; 248 prev->tcd->e_sg = 1; 249 mdesc->tcd->start = 1; 250 251 prev = mdesc; 252 } 253 254 prev->tcd->start = 0; 255 prev->tcd->int_maj = 1; 256 257 /* Send first descriptor in chain into hardware */ 258 memcpy_toio(&mdma->tcd[cid], first->tcd, sizeof(struct mpc_dma_tcd)); 259 out_8(&mdma->regs->dmassrt, cid); 260 } 261 262 /* Handle interrupt on one half of DMA controller (32 channels) */ 263 static void mpc_dma_irq_process(struct mpc_dma *mdma, u32 is, u32 es, int off) 264 { 265 struct mpc_dma_chan *mchan; 266 struct mpc_dma_desc *mdesc; 267 u32 status = is | es; 268 int ch; 269 270 while ((ch = fls(status) - 1) >= 0) { 271 status &= ~(1 << ch); 272 mchan = &mdma->channels[ch + off]; 273 274 spin_lock(&mchan->lock); 275 276 /* Check error status */ 277 if (es & (1 << ch)) 278 list_for_each_entry(mdesc, &mchan->active, node) 279 mdesc->error = -EIO; 280 281 /* Execute queued descriptors */ 282 list_splice_tail_init(&mchan->active, &mchan->completed); 283 if (!list_empty(&mchan->queued)) 284 mpc_dma_execute(mchan); 285 286 spin_unlock(&mchan->lock); 287 } 288 } 289 290 /* Interrupt handler */ 291 static irqreturn_t mpc_dma_irq(int irq, void *data) 292 { 293 struct mpc_dma *mdma = data; 294 uint es; 295 296 /* Save error status register */ 297 es = in_be32(&mdma->regs->dmaes); 298 spin_lock(&mdma->error_status_lock); 299 if ((es & MPC_DMA_DMAES_VLD) && mdma->error_status == 0) 300 mdma->error_status = es; 301 spin_unlock(&mdma->error_status_lock); 302 303 /* Handle interrupt on each channel */ 304 mpc_dma_irq_process(mdma, in_be32(&mdma->regs->dmainth), 305 in_be32(&mdma->regs->dmaerrh), 32); 306 mpc_dma_irq_process(mdma, in_be32(&mdma->regs->dmaintl), 307 in_be32(&mdma->regs->dmaerrl), 0); 308 309 /* Ack interrupt on all channels */ 310 out_be32(&mdma->regs->dmainth, 0xFFFFFFFF); 311 out_be32(&mdma->regs->dmaintl, 0xFFFFFFFF); 312 out_be32(&mdma->regs->dmaerrh, 0xFFFFFFFF); 313 out_be32(&mdma->regs->dmaerrl, 0xFFFFFFFF); 314 315 /* Schedule tasklet */ 316 tasklet_schedule(&mdma->tasklet); 317 318 return IRQ_HANDLED; 319 } 320 321 /* DMA Tasklet */ 322 static void mpc_dma_tasklet(unsigned long data) 323 { 324 struct mpc_dma *mdma = (void *)data; 325 dma_cookie_t last_cookie = 0; 326 struct mpc_dma_chan *mchan; 327 struct mpc_dma_desc *mdesc; 328 struct dma_async_tx_descriptor *desc; 329 unsigned long flags; 330 LIST_HEAD(list); 331 uint es; 332 int i; 333 334 spin_lock_irqsave(&mdma->error_status_lock, flags); 335 es = mdma->error_status; 336 mdma->error_status = 0; 337 spin_unlock_irqrestore(&mdma->error_status_lock, flags); 338 339 /* Print nice error report */ 340 if (es) { 341 dev_err(mdma->dma.dev, 342 "Hardware reported following error(s) on channel %u:\n", 343 MPC_DMA_DMAES_ERRCHN(es)); 344 345 if (es & MPC_DMA_DMAES_GPE) 346 dev_err(mdma->dma.dev, "- Group Priority Error\n"); 347 if (es & MPC_DMA_DMAES_CPE) 348 dev_err(mdma->dma.dev, "- Channel Priority Error\n"); 349 if (es & MPC_DMA_DMAES_SAE) 350 dev_err(mdma->dma.dev, "- Source Address Error\n"); 351 if (es & MPC_DMA_DMAES_SOE) 352 dev_err(mdma->dma.dev, "- Source Offset" 353 " Configuration Error\n"); 354 if (es & MPC_DMA_DMAES_DAE) 355 dev_err(mdma->dma.dev, "- Destination Address" 356 " Error\n"); 357 if (es & MPC_DMA_DMAES_DOE) 358 dev_err(mdma->dma.dev, "- Destination Offset" 359 " Configuration Error\n"); 360 if (es & MPC_DMA_DMAES_NCE) 361 dev_err(mdma->dma.dev, "- NBytes/Citter" 362 " Configuration Error\n"); 363 if (es & MPC_DMA_DMAES_SGE) 364 dev_err(mdma->dma.dev, "- Scatter/Gather" 365 " Configuration Error\n"); 366 if (es & MPC_DMA_DMAES_SBE) 367 dev_err(mdma->dma.dev, "- Source Bus Error\n"); 368 if (es & MPC_DMA_DMAES_DBE) 369 dev_err(mdma->dma.dev, "- Destination Bus Error\n"); 370 } 371 372 for (i = 0; i < mdma->dma.chancnt; i++) { 373 mchan = &mdma->channels[i]; 374 375 /* Get all completed descriptors */ 376 spin_lock_irqsave(&mchan->lock, flags); 377 if (!list_empty(&mchan->completed)) 378 list_splice_tail_init(&mchan->completed, &list); 379 spin_unlock_irqrestore(&mchan->lock, flags); 380 381 if (list_empty(&list)) 382 continue; 383 384 /* Execute callbacks and run dependencies */ 385 list_for_each_entry(mdesc, &list, node) { 386 desc = &mdesc->desc; 387 388 if (desc->callback) 389 desc->callback(desc->callback_param); 390 391 last_cookie = desc->cookie; 392 dma_run_dependencies(desc); 393 } 394 395 /* Free descriptors */ 396 spin_lock_irqsave(&mchan->lock, flags); 397 list_splice_tail_init(&list, &mchan->free); 398 mchan->completed_cookie = last_cookie; 399 spin_unlock_irqrestore(&mchan->lock, flags); 400 } 401 } 402 403 /* Submit descriptor to hardware */ 404 static dma_cookie_t mpc_dma_tx_submit(struct dma_async_tx_descriptor *txd) 405 { 406 struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(txd->chan); 407 struct mpc_dma_desc *mdesc; 408 unsigned long flags; 409 dma_cookie_t cookie; 410 411 mdesc = container_of(txd, struct mpc_dma_desc, desc); 412 413 spin_lock_irqsave(&mchan->lock, flags); 414 415 /* Move descriptor to queue */ 416 list_move_tail(&mdesc->node, &mchan->queued); 417 418 /* If channel is idle, execute all queued descriptors */ 419 if (list_empty(&mchan->active)) 420 mpc_dma_execute(mchan); 421 422 /* Update cookie */ 423 cookie = mchan->chan.cookie + 1; 424 if (cookie <= 0) 425 cookie = 1; 426 427 mchan->chan.cookie = cookie; 428 mdesc->desc.cookie = cookie; 429 430 spin_unlock_irqrestore(&mchan->lock, flags); 431 432 return cookie; 433 } 434 435 /* Alloc channel resources */ 436 static int mpc_dma_alloc_chan_resources(struct dma_chan *chan) 437 { 438 struct mpc_dma *mdma = dma_chan_to_mpc_dma(chan); 439 struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(chan); 440 struct mpc_dma_desc *mdesc; 441 struct mpc_dma_tcd *tcd; 442 dma_addr_t tcd_paddr; 443 unsigned long flags; 444 LIST_HEAD(descs); 445 int i; 446 447 /* Alloc DMA memory for Transfer Control Descriptors */ 448 tcd = dma_alloc_coherent(mdma->dma.dev, 449 MPC_DMA_DESCRIPTORS * sizeof(struct mpc_dma_tcd), 450 &tcd_paddr, GFP_KERNEL); 451 if (!tcd) 452 return -ENOMEM; 453 454 /* Alloc descriptors for this channel */ 455 for (i = 0; i < MPC_DMA_DESCRIPTORS; i++) { 456 mdesc = kzalloc(sizeof(struct mpc_dma_desc), GFP_KERNEL); 457 if (!mdesc) { 458 dev_notice(mdma->dma.dev, "Memory allocation error. " 459 "Allocated only %u descriptors\n", i); 460 break; 461 } 462 463 dma_async_tx_descriptor_init(&mdesc->desc, chan); 464 mdesc->desc.flags = DMA_CTRL_ACK; 465 mdesc->desc.tx_submit = mpc_dma_tx_submit; 466 467 mdesc->tcd = &tcd[i]; 468 mdesc->tcd_paddr = tcd_paddr + (i * sizeof(struct mpc_dma_tcd)); 469 470 list_add_tail(&mdesc->node, &descs); 471 } 472 473 /* Return error only if no descriptors were allocated */ 474 if (i == 0) { 475 dma_free_coherent(mdma->dma.dev, 476 MPC_DMA_DESCRIPTORS * sizeof(struct mpc_dma_tcd), 477 tcd, tcd_paddr); 478 return -ENOMEM; 479 } 480 481 spin_lock_irqsave(&mchan->lock, flags); 482 mchan->tcd = tcd; 483 mchan->tcd_paddr = tcd_paddr; 484 list_splice_tail_init(&descs, &mchan->free); 485 spin_unlock_irqrestore(&mchan->lock, flags); 486 487 /* Enable Error Interrupt */ 488 out_8(&mdma->regs->dmaseei, chan->chan_id); 489 490 return 0; 491 } 492 493 /* Free channel resources */ 494 static void mpc_dma_free_chan_resources(struct dma_chan *chan) 495 { 496 struct mpc_dma *mdma = dma_chan_to_mpc_dma(chan); 497 struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(chan); 498 struct mpc_dma_desc *mdesc, *tmp; 499 struct mpc_dma_tcd *tcd; 500 dma_addr_t tcd_paddr; 501 unsigned long flags; 502 LIST_HEAD(descs); 503 504 spin_lock_irqsave(&mchan->lock, flags); 505 506 /* Channel must be idle */ 507 BUG_ON(!list_empty(&mchan->prepared)); 508 BUG_ON(!list_empty(&mchan->queued)); 509 BUG_ON(!list_empty(&mchan->active)); 510 BUG_ON(!list_empty(&mchan->completed)); 511 512 /* Move data */ 513 list_splice_tail_init(&mchan->free, &descs); 514 tcd = mchan->tcd; 515 tcd_paddr = mchan->tcd_paddr; 516 517 spin_unlock_irqrestore(&mchan->lock, flags); 518 519 /* Free DMA memory used by descriptors */ 520 dma_free_coherent(mdma->dma.dev, 521 MPC_DMA_DESCRIPTORS * sizeof(struct mpc_dma_tcd), 522 tcd, tcd_paddr); 523 524 /* Free descriptors */ 525 list_for_each_entry_safe(mdesc, tmp, &descs, node) 526 kfree(mdesc); 527 528 /* Disable Error Interrupt */ 529 out_8(&mdma->regs->dmaceei, chan->chan_id); 530 } 531 532 /* Send all pending descriptor to hardware */ 533 static void mpc_dma_issue_pending(struct dma_chan *chan) 534 { 535 /* 536 * We are posting descriptors to the hardware as soon as 537 * they are ready, so this function does nothing. 538 */ 539 } 540 541 /* Check request completion status */ 542 static enum dma_status 543 mpc_dma_tx_status(struct dma_chan *chan, dma_cookie_t cookie, 544 struct dma_tx_state *txstate) 545 { 546 struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(chan); 547 unsigned long flags; 548 dma_cookie_t last_used; 549 dma_cookie_t last_complete; 550 551 spin_lock_irqsave(&mchan->lock, flags); 552 last_used = mchan->chan.cookie; 553 last_complete = mchan->completed_cookie; 554 spin_unlock_irqrestore(&mchan->lock, flags); 555 556 dma_set_tx_state(txstate, last_complete, last_used, 0); 557 return dma_async_is_complete(cookie, last_complete, last_used); 558 } 559 560 /* Prepare descriptor for memory to memory copy */ 561 static struct dma_async_tx_descriptor * 562 mpc_dma_prep_memcpy(struct dma_chan *chan, dma_addr_t dst, dma_addr_t src, 563 size_t len, unsigned long flags) 564 { 565 struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(chan); 566 struct mpc_dma_desc *mdesc = NULL; 567 struct mpc_dma_tcd *tcd; 568 unsigned long iflags; 569 570 /* Get free descriptor */ 571 spin_lock_irqsave(&mchan->lock, iflags); 572 if (!list_empty(&mchan->free)) { 573 mdesc = list_first_entry(&mchan->free, struct mpc_dma_desc, 574 node); 575 list_del(&mdesc->node); 576 } 577 spin_unlock_irqrestore(&mchan->lock, iflags); 578 579 if (!mdesc) 580 return NULL; 581 582 mdesc->error = 0; 583 tcd = mdesc->tcd; 584 585 /* Prepare Transfer Control Descriptor for this transaction */ 586 memset(tcd, 0, sizeof(struct mpc_dma_tcd)); 587 588 if (IS_ALIGNED(src | dst | len, 32)) { 589 tcd->ssize = MPC_DMA_TSIZE_32; 590 tcd->dsize = MPC_DMA_TSIZE_32; 591 tcd->soff = 32; 592 tcd->doff = 32; 593 } else if (IS_ALIGNED(src | dst | len, 16)) { 594 tcd->ssize = MPC_DMA_TSIZE_16; 595 tcd->dsize = MPC_DMA_TSIZE_16; 596 tcd->soff = 16; 597 tcd->doff = 16; 598 } else if (IS_ALIGNED(src | dst | len, 4)) { 599 tcd->ssize = MPC_DMA_TSIZE_4; 600 tcd->dsize = MPC_DMA_TSIZE_4; 601 tcd->soff = 4; 602 tcd->doff = 4; 603 } else if (IS_ALIGNED(src | dst | len, 2)) { 604 tcd->ssize = MPC_DMA_TSIZE_2; 605 tcd->dsize = MPC_DMA_TSIZE_2; 606 tcd->soff = 2; 607 tcd->doff = 2; 608 } else { 609 tcd->ssize = MPC_DMA_TSIZE_1; 610 tcd->dsize = MPC_DMA_TSIZE_1; 611 tcd->soff = 1; 612 tcd->doff = 1; 613 } 614 615 tcd->saddr = src; 616 tcd->daddr = dst; 617 tcd->nbytes = len; 618 tcd->biter = 1; 619 tcd->citer = 1; 620 621 /* Place descriptor in prepared list */ 622 spin_lock_irqsave(&mchan->lock, iflags); 623 list_add_tail(&mdesc->node, &mchan->prepared); 624 spin_unlock_irqrestore(&mchan->lock, iflags); 625 626 return &mdesc->desc; 627 } 628 629 static int __devinit mpc_dma_probe(struct of_device *op, 630 const struct of_device_id *match) 631 { 632 struct device_node *dn = op->node; 633 struct device *dev = &op->dev; 634 struct dma_device *dma; 635 struct mpc_dma *mdma; 636 struct mpc_dma_chan *mchan; 637 struct resource res; 638 ulong regs_start, regs_size; 639 int retval, i; 640 641 mdma = devm_kzalloc(dev, sizeof(struct mpc_dma), GFP_KERNEL); 642 if (!mdma) { 643 dev_err(dev, "Memory exhausted!\n"); 644 return -ENOMEM; 645 } 646 647 mdma->irq = irq_of_parse_and_map(dn, 0); 648 if (mdma->irq == NO_IRQ) { 649 dev_err(dev, "Error mapping IRQ!\n"); 650 return -EINVAL; 651 } 652 653 retval = of_address_to_resource(dn, 0, &res); 654 if (retval) { 655 dev_err(dev, "Error parsing memory region!\n"); 656 return retval; 657 } 658 659 regs_start = res.start; 660 regs_size = res.end - res.start + 1; 661 662 if (!devm_request_mem_region(dev, regs_start, regs_size, DRV_NAME)) { 663 dev_err(dev, "Error requesting memory region!\n"); 664 return -EBUSY; 665 } 666 667 mdma->regs = devm_ioremap(dev, regs_start, regs_size); 668 if (!mdma->regs) { 669 dev_err(dev, "Error mapping memory region!\n"); 670 return -ENOMEM; 671 } 672 673 mdma->tcd = (struct mpc_dma_tcd *)((u8 *)(mdma->regs) 674 + MPC_DMA_TCD_OFFSET); 675 676 retval = devm_request_irq(dev, mdma->irq, &mpc_dma_irq, 0, DRV_NAME, 677 mdma); 678 if (retval) { 679 dev_err(dev, "Error requesting IRQ!\n"); 680 return -EINVAL; 681 } 682 683 spin_lock_init(&mdma->error_status_lock); 684 685 dma = &mdma->dma; 686 dma->dev = dev; 687 dma->chancnt = MPC_DMA_CHANNELS; 688 dma->device_alloc_chan_resources = mpc_dma_alloc_chan_resources; 689 dma->device_free_chan_resources = mpc_dma_free_chan_resources; 690 dma->device_issue_pending = mpc_dma_issue_pending; 691 dma->device_tx_status = mpc_dma_tx_status; 692 dma->device_prep_dma_memcpy = mpc_dma_prep_memcpy; 693 694 INIT_LIST_HEAD(&dma->channels); 695 dma_cap_set(DMA_MEMCPY, dma->cap_mask); 696 697 for (i = 0; i < dma->chancnt; i++) { 698 mchan = &mdma->channels[i]; 699 700 mchan->chan.device = dma; 701 mchan->chan.chan_id = i; 702 mchan->chan.cookie = 1; 703 mchan->completed_cookie = mchan->chan.cookie; 704 705 INIT_LIST_HEAD(&mchan->free); 706 INIT_LIST_HEAD(&mchan->prepared); 707 INIT_LIST_HEAD(&mchan->queued); 708 INIT_LIST_HEAD(&mchan->active); 709 INIT_LIST_HEAD(&mchan->completed); 710 711 spin_lock_init(&mchan->lock); 712 list_add_tail(&mchan->chan.device_node, &dma->channels); 713 } 714 715 tasklet_init(&mdma->tasklet, mpc_dma_tasklet, (unsigned long)mdma); 716 717 /* 718 * Configure DMA Engine: 719 * - Dynamic clock, 720 * - Round-robin group arbitration, 721 * - Round-robin channel arbitration. 722 */ 723 out_be32(&mdma->regs->dmacr, MPC_DMA_DMACR_EDCG | 724 MPC_DMA_DMACR_ERGA | MPC_DMA_DMACR_ERCA); 725 726 /* Disable hardware DMA requests */ 727 out_be32(&mdma->regs->dmaerqh, 0); 728 out_be32(&mdma->regs->dmaerql, 0); 729 730 /* Disable error interrupts */ 731 out_be32(&mdma->regs->dmaeeih, 0); 732 out_be32(&mdma->regs->dmaeeil, 0); 733 734 /* Clear interrupts status */ 735 out_be32(&mdma->regs->dmainth, 0xFFFFFFFF); 736 out_be32(&mdma->regs->dmaintl, 0xFFFFFFFF); 737 out_be32(&mdma->regs->dmaerrh, 0xFFFFFFFF); 738 out_be32(&mdma->regs->dmaerrl, 0xFFFFFFFF); 739 740 /* Route interrupts to IPIC */ 741 out_be32(&mdma->regs->dmaihsa, 0); 742 out_be32(&mdma->regs->dmailsa, 0); 743 744 /* Register DMA engine */ 745 dev_set_drvdata(dev, mdma); 746 retval = dma_async_device_register(dma); 747 if (retval) { 748 devm_free_irq(dev, mdma->irq, mdma); 749 irq_dispose_mapping(mdma->irq); 750 } 751 752 return retval; 753 } 754 755 static int __devexit mpc_dma_remove(struct of_device *op) 756 { 757 struct device *dev = &op->dev; 758 struct mpc_dma *mdma = dev_get_drvdata(dev); 759 760 dma_async_device_unregister(&mdma->dma); 761 devm_free_irq(dev, mdma->irq, mdma); 762 irq_dispose_mapping(mdma->irq); 763 764 return 0; 765 } 766 767 static struct of_device_id mpc_dma_match[] = { 768 { .compatible = "fsl,mpc5121-dma", }, 769 {}, 770 }; 771 772 static struct of_platform_driver mpc_dma_driver = { 773 .match_table = mpc_dma_match, 774 .probe = mpc_dma_probe, 775 .remove = __devexit_p(mpc_dma_remove), 776 .driver = { 777 .name = DRV_NAME, 778 .owner = THIS_MODULE, 779 }, 780 }; 781 782 static int __init mpc_dma_init(void) 783 { 784 return of_register_platform_driver(&mpc_dma_driver); 785 } 786 module_init(mpc_dma_init); 787 788 static void __exit mpc_dma_exit(void) 789 { 790 of_unregister_platform_driver(&mpc_dma_driver); 791 } 792 module_exit(mpc_dma_exit); 793 794 MODULE_LICENSE("GPL"); 795 MODULE_AUTHOR("Piotr Ziecik <kosmo@semihalf.com>"); 796