target/linux/coldfire/patches/051-m547x_8x_mcdma_1.0.patch

   1 From 6c9df5dff79b6d09d1a31681067e7fbd85285f80 Mon Sep 17 00:00:00 2001
   2 From: Kurt Mahan <kmahan@freescale.com>
   3 Date: Wed, 30 Apr 2008 12:22:03 -0600
   4 Subject: [PATCH] Update MultiChannel DMA to code version 1.0.
   5
   6 Changes since previous:
   7 - Updated FEC RX task to work around bug where it would not update
   8   the RX buffer descriptors correctly and adjusted size accordingly.
   9 - Added flag MCD_TT_FLAGS_PI for use with DSPI on MCD547x/8x.
  10 - Fixed cleanup of paused tasks in MCD_killDma.
  11 - Cosmetic changes to cleanup MCD_dmaApi.c.
  12
  13 LTIBName: m547x-8x-mcdma-1.0
  14 Signed-off-by: Kurt Mahan <kmahan@freescale.com>
  15 ---
  16  arch/m68k/coldfire/Makefile       |    3 +-
  17  arch/m68k/coldfire/dma.c          |  532 ----
  18  arch/m68k/coldfire/m547x_8x-dma.c |  516 ++++
  19  drivers/dma/MCD_dma.h             |  786 +++---
  20  drivers/dma/MCD_dmaApi.c          |  417 ++--
  21  drivers/dma/MCD_progCheck.h       |   45 +-
  22  drivers/dma/MCD_tasks.c           | 4917 +++++++++++++++++++------------------
  23  drivers/dma/MCD_tasksInit.c       |  402 ++--
  24  drivers/dma/MCD_tasksInit.h       |   49 +-
  25  9 files changed, 3785 insertions(+), 3882 deletions(-)
  26  delete mode 100644 arch/m68k/coldfire/dma.c
  27  create mode 100644 arch/m68k/coldfire/m547x_8x-dma.c
  28
  29 --- a/arch/m68k/coldfire/Makefile
  30 +++ b/arch/m68k/coldfire/Makefile
  31 @@ -10,5 +10,4 @@ endif
  32
  33  obj-$(CONFIG_PCI)      += pci.o mcf5445x-pci.o iomap.o
  34  obj-$(CONFIG_M54455)   += mcf5445x-devices.o
  35 -
  36 -obj-$(CONFIG_MCD_DMA)  += dma.o
  37 +obj-$(CONFIG_MCD_DMA)  += m547x_8x-dma.o
  38 --- a/arch/m68k/coldfire/dma.c
  39 +++ /dev/null
  40 @@ -1,532 +0,0 @@
  41 -#include <linux/kernel.h>
  42 -#include <linux/sched.h>
  43 -#include <linux/mm.h>
  44 -#include <linux/init.h>
  45 -#include <linux/interrupt.h>
  46 -#include <asm/io.h>
  47 -#include <asm/irq.h>
  48 -#include <asm/dma.h>
  49 -#include <asm/coldfire.h>
  50 -#include <asm/m5485sram.h>
  51 -#include <asm/mcfsim.h>
  52 -
  53 -
  54 -
  55 -void dma_interrupt_handler(int irq, void *dev_id, struct pt_regs *regs);
  56 -
  57 -/*
  58 - * This global keeps track of which initiators have been
  59 - * used of the available assignments.  Initiators 0-15 are
  60 - * hardwired.  Initiators 16-31 are multiplexed and controlled
  61 - * via the Initiatior Mux Control Registe (IMCR).  The
  62 - * assigned requestor is stored with the associated initiator
  63 - * number.
  64 - */
  65 -static int used_reqs[32] = {
  66 -       DMA_ALWAYS, DMA_DSPI_RX, DMA_DSPI_TX, DMA_DREQ0,
  67 -       DMA_PSC0_RX, DMA_PSC0_TX, DMA_USBEP0, DMA_USBEP1,
  68 -       DMA_USBEP2, DMA_USBEP3, DMA_PCI_TX, DMA_PCI_RX,
  69 -       DMA_PSC1_RX, DMA_PSC1_TX, DMA_I2C_RX, DMA_I2C_TX,
  70 -       0, 0, 0, 0,
  71 -       0, 0, 0, 0,
  72 -       0, 0, 0, 0,
  73 -       0, 0, 0, 0
  74 -};
  75 -
  76 -/*
  77 - * This global keeps track of which channels have been assigned
  78 - * to tasks.  This methology assumes that no single initiator
  79 - * will be tied to more than one task/channel
  80 - */
  81 -static char used_channel[16] = {
  82 -       -1, -1, -1, -1, -1, -1, -1, -1,
  83 -       -1, -1, -1, -1, -1, -1, -1, -1
  84 -};
  85 -
  86 -unsigned int connected_channel[16] = {
  87 -       0, 0, 0, 0, 0, 0, 0, 0,
  88 -       0, 0, 0, 0, 0, 0, 0, 0
  89 -};
  90 -
  91 -/********************************************************************/
  92 -/*
  93 - * Attempt to enable the provided Initiator in the Initiator
  94 - * Mux Control Register
  95 - *
  96 - * Parameters:
  97 - *  initiator   Initiator identifier
  98 - *
  99 - * Return Value:
 100 - *  1   if unable to make the assignment
 101 - *  0   successful
 102 - */
 103 -int
 104 -dma_set_initiator(int initiator)
 105 -{
 106 -       switch (initiator) {    /*
 107 -                                * These initiators are always active
 108 -                                */
 109 -       case DMA_ALWAYS:
 110 -       case DMA_DSPI_RX:
 111 -       case DMA_DSPI_TX:
 112 -       case DMA_DREQ0:
 113 -       case DMA_PSC0_RX:
 114 -       case DMA_PSC0_TX:
 115 -       case DMA_USBEP0:
 116 -       case DMA_USBEP1:
 117 -       case DMA_USBEP2:
 118 -       case DMA_USBEP3:
 119 -       case DMA_PCI_TX:
 120 -       case DMA_PCI_RX:
 121 -       case DMA_PSC1_RX:
 122 -       case DMA_PSC1_TX:
 123 -       case DMA_I2C_RX:
 124 -       case DMA_I2C_TX:
 125 -               break;
 126 -
 127 -       case DMA_FEC0_RX:
 128 -               MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC16(3))
 129 -                   | MCF_DMA_IMCR_SRC16_FEC0RX;
 130 -               used_reqs[16] = DMA_FEC0_RX;
 131 -               break;
 132 -
 133 -       case DMA_FEC0_TX:
 134 -               MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC17(3))
 135 -                   | MCF_DMA_IMCR_SRC17_FEC0TX;
 136 -               used_reqs[17] = DMA_FEC0_TX;
 137 -               break;
 138 -
 139 -       case DMA_FEC1_RX:
 140 -               MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC20(3))
 141 -                   | MCF_DMA_IMCR_SRC20_FEC1RX;
 142 -               used_reqs[20] = DMA_FEC1_RX;
 143 -               break;
 144 -
 145 -       case DMA_FEC1_TX:
 146 -               if (used_reqs[21] == 0) {
 147 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC21(3))
 148 -                           | MCF_DMA_IMCR_SRC21_FEC1TX;
 149 -                       used_reqs[21] = DMA_FEC1_TX;
 150 -               } else if (used_reqs[25] == 0) {
 151 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC25(3))
 152 -                           | MCF_DMA_IMCR_SRC25_FEC1TX;
 153 -                       used_reqs[25] = DMA_FEC1_TX;
 154 -               } else if (used_reqs[31] == 0) {
 155 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC31(3))
 156 -                           | MCF_DMA_IMCR_SRC31_FEC1TX;
 157 -                       used_reqs[31] = DMA_FEC1_TX;
 158 -               } else          /* No empty slots */
 159 -                       return 1;
 160 -               break;
 161 -
 162 -       case DMA_DREQ1:
 163 -               if (used_reqs[29] == 0) {
 164 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC29(3))
 165 -                           | MCF_DMA_IMCR_SRC29_DREQ1;
 166 -                       used_reqs[29] = DMA_DREQ1;
 167 -               } else if (used_reqs[21] == 0) {
 168 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC21(3))
 169 -                           | MCF_DMA_IMCR_SRC21_DREQ1;
 170 -                       used_reqs[21] = DMA_DREQ1;
 171 -               } else          /* No empty slots */
 172 -                       return 1;
 173 -               break;
 174 -
 175 -       case DMA_CTM0:
 176 -               if (used_reqs[24] == 0) {
 177 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC24(3))
 178 -                           | MCF_DMA_IMCR_SRC24_CTM0;
 179 -                       used_reqs[24] = DMA_CTM0;
 180 -               } else          /* No empty slots */
 181 -                       return 1;
 182 -               break;
 183 -
 184 -       case DMA_CTM1:
 185 -               if (used_reqs[25] == 0) {
 186 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC25(3))
 187 -                           | MCF_DMA_IMCR_SRC25_CTM1;
 188 -                       used_reqs[25] = DMA_CTM1;
 189 -               } else          /* No empty slots */
 190 -                       return 1;
 191 -               break;
 192 -
 193 -       case DMA_CTM2:
 194 -               if (used_reqs[26] == 0) {
 195 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC26(3))
 196 -                           | MCF_DMA_IMCR_SRC26_CTM2;
 197 -                       used_reqs[26] = DMA_CTM2;
 198 -               } else          /* No empty slots */
 199 -                       return 1;
 200 -               break;
 201 -
 202 -       case DMA_CTM3:
 203 -               if (used_reqs[27] == 0) {
 204 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC27(3))
 205 -                           | MCF_DMA_IMCR_SRC27_CTM3;
 206 -                       used_reqs[27] = DMA_CTM3;
 207 -               } else          /* No empty slots */
 208 -                       return 1;
 209 -               break;
 210 -
 211 -       case DMA_CTM4:
 212 -               if (used_reqs[28] == 0) {
 213 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC28(3))
 214 -                           | MCF_DMA_IMCR_SRC28_CTM4;
 215 -                       used_reqs[28] = DMA_CTM4;
 216 -               } else          /* No empty slots */
 217 -                       return 1;
 218 -               break;
 219 -
 220 -       case DMA_CTM5:
 221 -               if (used_reqs[29] == 0) {
 222 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC29(3))
 223 -                           | MCF_DMA_IMCR_SRC29_CTM5;
 224 -                       used_reqs[29] = DMA_CTM5;
 225 -               } else          /* No empty slots */
 226 -                       return 1;
 227 -               break;
 228 -
 229 -       case DMA_CTM6:
 230 -               if (used_reqs[30] == 0) {
 231 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC30(3))
 232 -                           | MCF_DMA_IMCR_SRC30_CTM6;
 233 -                       used_reqs[30] = DMA_CTM6;
 234 -               } else          /* No empty slots */
 235 -                       return 1;
 236 -               break;
 237 -
 238 -       case DMA_CTM7:
 239 -               if (used_reqs[31] == 0) {
 240 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC31(3))
 241 -                           | MCF_DMA_IMCR_SRC31_CTM7;
 242 -                       used_reqs[31] = DMA_CTM7;
 243 -               } else          /* No empty slots */
 244 -                       return 1;
 245 -               break;
 246 -
 247 -       case DMA_USBEP4:
 248 -               if (used_reqs[26] == 0) {
 249 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC26(3))
 250 -                           | MCF_DMA_IMCR_SRC26_USBEP4;
 251 -                       used_reqs[26] = DMA_USBEP4;
 252 -               } else          /* No empty slots */
 253 -                       return 1;
 254 -               break;
 255 -
 256 -       case DMA_USBEP5:
 257 -               if (used_reqs[27] == 0) {
 258 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC27(3))
 259 -                           | MCF_DMA_IMCR_SRC27_USBEP5;
 260 -                       used_reqs[27] = DMA_USBEP5;
 261 -               } else          /* No empty slots */
 262 -                       return 1;
 263 -               break;
 264 -
 265 -       case DMA_USBEP6:
 266 -               if (used_reqs[28] == 0) {
 267 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC28(3))
 268 -                           | MCF_DMA_IMCR_SRC28_USBEP6;
 269 -                       used_reqs[28] = DMA_USBEP6;
 270 -               } else          /* No empty slots */
 271 -                       return 1;
 272 -               break;
 273 -
 274 -       case DMA_PSC2_RX:
 275 -               if (used_reqs[28] == 0) {
 276 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC28(3))
 277 -                           | MCF_DMA_IMCR_SRC28_PSC2RX;
 278 -                       used_reqs[28] = DMA_PSC2_RX;
 279 -               } else          /* No empty slots */
 280 -                       return 1;
 281 -               break;
 282 -
 283 -       case DMA_PSC2_TX:
 284 -               if (used_reqs[29] == 0) {
 285 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC29(3))
 286 -                           | MCF_DMA_IMCR_SRC29_PSC2TX;
 287 -                       used_reqs[29] = DMA_PSC2_TX;
 288 -               } else          /* No empty slots */
 289 -                       return 1;
 290 -               break;
 291 -
 292 -       case DMA_PSC3_RX:
 293 -               if (used_reqs[30] == 0) {
 294 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC30(3))
 295 -                           | MCF_DMA_IMCR_SRC30_PSC3RX;
 296 -                       used_reqs[30] = DMA_PSC3_RX;
 297 -               } else          /* No empty slots */
 298 -                       return 1;
 299 -               break;
 300 -
 301 -       case DMA_PSC3_TX:
 302 -               if (used_reqs[31] == 0) {
 303 -                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC31(3))
 304 -                           | MCF_DMA_IMCR_SRC31_PSC3TX;
 305 -                       used_reqs[31] = DMA_PSC3_TX;
 306 -               } else          /* No empty slots */
 307 -                       return 1;
 308 -               break;
 309 -
 310 -       default:
 311 -               return 1;
 312 -       }
 313 -       return 0;
 314 -}
 315 -
 316 -/********************************************************************/
 317 -/*
 318 - * Return the initiator number for the given requestor
 319 - *
 320 - * Parameters:
 321 - *  requestor   Initiator/Requestor identifier
 322 - *
 323 - * Return Value:
 324 - *  The initiator number (0-31) if initiator has been assigned
 325 - *  0 (always initiator) otherwise
 326 - */
 327 -unsigned int
 328 -dma_get_initiator(int requestor)
 329 -{
 330 -       u32 i;
 331 -
 332 -       for (i = 0; i < sizeof (used_reqs); ++i) {
 333 -               if (used_reqs[i] == requestor)
 334 -                       return i;
 335 -       }
 336 -       return 0;
 337 -}
 338 -
 339 -/********************************************************************/
 340 -/*
 341 - * Remove the given initiator from the active list
 342 - *
 343 - * Parameters:
 344 - *  requestor   Initiator/Requestor identifier
 345 - */
 346 -void
 347 -dma_remove_initiator(int requestor)
 348 -{
 349 -       u32 i;
 350 -
 351 -       for (i = 0; i < sizeof (used_reqs); ++i) {
 352 -               if (used_reqs[i] == requestor) {
 353 -                       used_reqs[i] = -1;
 354 -                       break;
 355 -               }
 356 -       }
 357 -}
 358 -
 359 -/********************************************************************/
 360 -/*
 361 - * Attempt to find an available channel for FEC and mark is as used
 362 - *
 363 - * Parameters:
 364 - *  requestor   Initiator/Requestor identifier
 365 - *
 366 - * Return Value:
 367 - *  First available channel (from 0 to 5) or -1 if they are all occupied
 368 - */
 369 -int
 370 -dma_set_channel_fec(int requestor)
 371 -{
 372 -       u32 i, t;
 373 -
 374 -#ifdef CONFIG_FEC_548x_ENABLE_FEC2
 375 -       t = 4;
 376 -#else
 377 -       t = 2;
 378 -#endif
 379 -
 380 -
 381 -
 382 -       for (i = 0; i < t ; ++i)
 383 -               if (used_channel[i] == -1) {
 384 -                       used_channel[i] = requestor;
 385 -                       return i;
 386 -               }
 387 -       /* All channels taken */
 388 -       return -1;
 389 -}
 390 -
 391 -/********************************************************************/
 392 -/*
 393 - * Attempt to find an available channel and mark is as used
 394 - *
 395 - * Parameters:
 396 - *  requestor   Initiator/Requestor identifier
 397 - *
 398 - * Return Value:
 399 - *  First available channel (from 6 to 15) or -1 if they are all occupied
 400 - */
 401 -int
 402 -dma_set_channel(int requestor)
 403 -{
 404 -       u32 i;
 405 -#ifdef CONFIG_NET_FEC2
 406 -       i = 4;
 407 -#else
 408 -       i = 2;
 409 -#endif
 410 -
 411 -       for (; i < 16; ++i)
 412 -               if (used_channel[i] == -1) {
 413 -                       used_channel[i] = requestor;
 414 -                       return i;
 415 -               }
 416 -
 417 -       /* All channels taken */
 418 -       return -1;
 419 -}
 420 -
 421 -/********************************************************************/
 422 -/*
 423 - * Return the channel being initiated by the given requestor
 424 - *
 425 - * Parameters:
 426 - *  requestor   Initiator/Requestor identifier
 427 - */
 428 -int
 429 -dma_get_channel(int requestor)
 430 -{
 431 -       u32 i;
 432 -
 433 -       for (i = 0; i < sizeof (used_channel); ++i) {
 434 -               if (used_channel[i] == requestor)
 435 -                       return i;
 436 -       }
 437 -       return -1;
 438 -}
 439 -
 440 -/********************************************************************/
 441 -/*
 442 - * Connects a channel with reference on your data
 443 - *
 444 - * Parameters:
 445 - *  channel   channel number
 446 - *  reference addres of your data
 447 -  */
 448 -int
 449 -dma_connect(int channel, int address)
 450 -{
 451 -       if ((channel < 16) && (channel >= 0))
 452 -               connected_channel[channel] = address;
 453 -       else
 454 -               return -1;
 455 -       return 0;
 456 -}
 457 -
 458 -/********************************************************************/
 459 -/*
 460 - * Disconnects a channel with reference on your data
 461 - *
 462 - * Parameters:
 463 - *  channel   channel number
 464 -*/
 465 -int
 466 -dma_disconnect(int channel)
 467 -{
 468 -       if ((channel < 16) && (channel >= 0))
 469 -               connected_channel[channel] = 0;
 470 -       else
 471 -               return -1;
 472 -       return 0;
 473 -}
 474 -
 475 -/********************************************************************/
 476 -/*
 477 - * Remove the channel being initiated by the given requestor from
 478 - * the active list
 479 - *
 480 - * Parameters:
 481 - *  requestor   Initiator/Requestor identifier
 482 - */
 483 -void
 484 -dma_remove_channel(int requestor)
 485 -{
 486 -       u32 i;
 487 -
 488 -       for (i = 0; i < sizeof (used_channel); ++i) {
 489 -               if (used_channel[i] == requestor) {
 490 -                       used_channel[i] = -1;
 491 -                       break;
 492 -               }
 493 -       }
 494 -}
 495 -
 496 -/********************************************************************/
 497 -/*
 498 - * This is the catch-all interrupt handler for the mult-channel DMA
 499 - */
 500 -volatile u8 dma_iflag[16];
 501 -u32 tx = 0;
 502 -
 503 -void
 504 -dma_interrupt_handler(int irq, void *dev_id, struct pt_regs *regs)
 505 -{
 506 -       u32 i, interrupts/*, mask, temp*/;
 507 -
 508 -       /*
 509 -        * Determine which interrupt(s) triggered by AND'ing the
 510 -        * pending interrupts with those that aren't masked.
 511 -        */
 512 -/*     mask = MCF_DMA_DIMR;
 513 -       MCF_DMA_DIMR = 0xffffffff;
 514 -*/
 515 -       interrupts = MCF_DMA_DIPR;
 516 -       MCF_DMA_DIPR |= interrupts;
 517 -//     temp = interrupts;
 518 -
 519 -       //MCF_DMA_DIPR = interrupts;
 520 -       for (i = 0; i < 16; ++i, interrupts >>= 1)
 521 -               if (interrupts & 0x1)
 522 -                       if (connected_channel[i] != 0)
 523 -                               ((void (*)(void)) (connected_channel[i])) ();
 524 -
 525 -/*     MCF_DMA_DIPR |= temp;
 526 -       MCF_DMA_DIMR = mask;*/
 527 -}
 528 -
 529 -void
 530 -dma_remove_channel_by_number(int channel)
 531 -{
 532 -       if (channel < sizeof (used_channel) && channel >= 0)
 533 -               used_channel[channel] = -1;
 534 -}
 535 -
 536 -int __devinit
 537 -dma_init()
 538 -{
 539 -       int result;
 540 -       char *dma_version_str;
 541 -
 542 -       MCD_getVersion(&dma_version_str);
 543 -       printk("Initialize %s\n", dma_version_str);
 544 -
 545 -       if (request_irq
 546 -           (64 + ISC_DMA,
 547 -            dma_interrupt_handler,
 548 -            IRQF_DISABLED,
 549 -            "MCD-DMA",
 550 -            NULL)) {
 551 -               printk("Cannot allocate the DMA IRQ(48)\n");
 552 -               return 1;
 553 -       }
 554 -
 555 -       MCF_DMA_DIMR = 0;
 556 -       MCF_DMA_DIPR = 0xFFFFFFFF;
 557 -
 558 -       MCF_ICR(ISC_DMA) = ILP_DMA;
 559 -
 560 -       result = MCD_initDma((dmaRegs *) (MCF_MBAR + 0x8000),
 561 -                       (void *) SYS_SRAM_DMA_START, MCD_RELOC_TASKS);
 562 -       if (result != MCD_OK) {
 563 -               printk("Cannot perform DMA initialization\n");
 564 -               free_irq(64 + ISC_DMA, NULL);
 565 -               return 1;
 566 -       }
 567 -
 568 -       return 0;
 569 -}
 570 -
 571 -device_initcall(dma_init);
 572 -
 573 --- /dev/null
 574 +++ b/arch/m68k/coldfire/m547x_8x-dma.c
 575 @@ -0,0 +1,516 @@
 576 +/*
 577 + * arch/m68k/coldfire/m547x_8x-dma.c
 578 + *
 579 + * Coldfire M547x/M548x DMA
 580 + *
 581 + * Copyright (c) 2008 Freescale Semiconductor, Inc.
 582 + *     Kurt Mahan <kmahan@freescale.com>
 583 + *
 584 + * This code is based on patches from the Freescale M547x_8x BSP
 585 + * release mcf547x_8x-20070107-ltib.iso
 586 + *
 587 + * This program is free software; you can redistribute it and/or modify
 588 + * it under the terms of the GNU General Public License as published by
 589 + * the Free Software Foundation; either version 2 of the License, or
 590 + * (at your option) any later version.
 591 + *
 592 + * This program is distributed in the hope that it will be useful,
 593 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 594 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 595 + * GNU General Public License for more details.
 596 + *
 597 + * You should have received a copy of the GNU General Public License
 598 + * along with this program; if not, write to the Free Software
 599 + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 600 + */
 601 +#include <linux/kernel.h>
 602 +#include <linux/sched.h>
 603 +#include <linux/mm.h>
 604 +#include <linux/init.h>
 605 +#include <linux/interrupt.h>
 606 +#include <asm/io.h>
 607 +#include <asm/irq.h>
 608 +#include <asm/dma.h>
 609 +#include <asm/coldfire.h>
 610 +#include <asm/m5485sram.h>
 611 +#include <asm/mcfsim.h>
 612 +
 613 +/*
 614 + * This global keeps track of which initiators have been
 615 + * used of the available assignments.  Initiators 0-15 are
 616 + * hardwired.  Initiators 16-31 are multiplexed and controlled
 617 + * via the Initiatior Mux Control Registe (IMCR).  The
 618 + * assigned requestor is stored with the associated initiator
 619 + * number.
 620 + */
 621 +static int used_reqs[32] = {
 622 +       DMA_ALWAYS, DMA_DSPI_RX, DMA_DSPI_TX, DMA_DREQ0,
 623 +       DMA_PSC0_RX, DMA_PSC0_TX, DMA_USBEP0, DMA_USBEP1,
 624 +       DMA_USBEP2, DMA_USBEP3, DMA_PCI_TX, DMA_PCI_RX,
 625 +       DMA_PSC1_RX, DMA_PSC1_TX, DMA_I2C_RX, DMA_I2C_TX,
 626 +       0, 0, 0, 0,
 627 +       0, 0, 0, 0,
 628 +       0, 0, 0, 0,
 629 +       0, 0, 0, 0
 630 +};
 631 +
 632 +/*
 633 + * This global keeps track of which channels have been assigned
 634 + * to tasks.  This methology assumes that no single initiator
 635 + * will be tied to more than one task/channel
 636 + */
 637 +static char used_channel[16] = {
 638 +       -1, -1, -1, -1, -1, -1, -1, -1,
 639 +       -1, -1, -1, -1, -1, -1, -1, -1
 640 +};
 641 +
 642 +unsigned int connected_channel[16] = {
 643 +       0, 0, 0, 0, 0, 0, 0, 0,
 644 +       0, 0, 0, 0, 0, 0, 0, 0
 645 +};
 646 +
 647 +/**
 648 + * dma_set_initiator - enable initiator
 649 + * @initiator: initiator identifier
 650 + *
 651 + * Returns 0 of successful, non-zero otherwise
 652 + *
 653 + * Attempt to enable the provided Initiator in the Initiator
 654 + * Mux Control Register.
 655 + */
 656 +int dma_set_initiator(int initiator)
 657 +{
 658 +       switch (initiator) {
 659 +       case DMA_ALWAYS:
 660 +       case DMA_DSPI_RX:
 661 +       case DMA_DSPI_TX:
 662 +       case DMA_DREQ0:
 663 +       case DMA_PSC0_RX:
 664 +       case DMA_PSC0_TX:
 665 +       case DMA_USBEP0:
 666 +       case DMA_USBEP1:
 667 +       case DMA_USBEP2:
 668 +       case DMA_USBEP3:
 669 +       case DMA_PCI_TX:
 670 +       case DMA_PCI_RX:
 671 +       case DMA_PSC1_RX:
 672 +       case DMA_PSC1_TX:
 673 +       case DMA_I2C_RX:
 674 +       case DMA_I2C_TX:
 675 +               /*
 676 +                * These initiators are always active
 677 +                */
 678 +               break;
 679 +
 680 +       case DMA_FEC0_RX:
 681 +               MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC16(3))
 682 +                   | MCF_DMA_IMCR_SRC16_FEC0RX;
 683 +               used_reqs[16] = DMA_FEC0_RX;
 684 +               break;
 685 +
 686 +       case DMA_FEC0_TX:
 687 +               MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC17(3))
 688 +                   | MCF_DMA_IMCR_SRC17_FEC0TX;
 689 +               used_reqs[17] = DMA_FEC0_TX;
 690 +               break;
 691 +
 692 +       case DMA_FEC1_RX:
 693 +               MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC20(3))
 694 +                   | MCF_DMA_IMCR_SRC20_FEC1RX;
 695 +               used_reqs[20] = DMA_FEC1_RX;
 696 +               break;
 697 +
 698 +       case DMA_FEC1_TX:
 699 +               if (used_reqs[21] == 0) {
 700 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC21(3))
 701 +                           | MCF_DMA_IMCR_SRC21_FEC1TX;
 702 +                       used_reqs[21] = DMA_FEC1_TX;
 703 +               } else if (used_reqs[25] == 0) {
 704 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC25(3))
 705 +                           | MCF_DMA_IMCR_SRC25_FEC1TX;
 706 +                       used_reqs[25] = DMA_FEC1_TX;
 707 +               } else if (used_reqs[31] == 0) {
 708 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC31(3))
 709 +                           | MCF_DMA_IMCR_SRC31_FEC1TX;
 710 +                       used_reqs[31] = DMA_FEC1_TX;
 711 +               } else          /* No empty slots */
 712 +                       return 1;
 713 +               break;
 714 +
 715 +       case DMA_DREQ1:
 716 +               if (used_reqs[29] == 0) {
 717 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC29(3))
 718 +                           | MCF_DMA_IMCR_SRC29_DREQ1;
 719 +                       used_reqs[29] = DMA_DREQ1;
 720 +               } else if (used_reqs[21] == 0) {
 721 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC21(3))
 722 +                           | MCF_DMA_IMCR_SRC21_DREQ1;
 723 +                       used_reqs[21] = DMA_DREQ1;
 724 +               } else          /* No empty slots */
 725 +                       return 1;
 726 +               break;
 727 +
 728 +       case DMA_CTM0:
 729 +               if (used_reqs[24] == 0) {
 730 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC24(3))
 731 +                           | MCF_DMA_IMCR_SRC24_CTM0;
 732 +                       used_reqs[24] = DMA_CTM0;
 733 +               } else          /* No empty slots */
 734 +                       return 1;
 735 +               break;
 736 +
 737 +       case DMA_CTM1:
 738 +               if (used_reqs[25] == 0) {
 739 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC25(3))
 740 +                           | MCF_DMA_IMCR_SRC25_CTM1;
 741 +                       used_reqs[25] = DMA_CTM1;
 742 +               } else          /* No empty slots */
 743 +                       return 1;
 744 +               break;
 745 +
 746 +       case DMA_CTM2:
 747 +               if (used_reqs[26] == 0) {
 748 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC26(3))
 749 +                           | MCF_DMA_IMCR_SRC26_CTM2;
 750 +                       used_reqs[26] = DMA_CTM2;
 751 +               } else          /* No empty slots */
 752 +                       return 1;
 753 +               break;
 754 +
 755 +       case DMA_CTM3:
 756 +               if (used_reqs[27] == 0) {
 757 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC27(3))
 758 +                           | MCF_DMA_IMCR_SRC27_CTM3;
 759 +                       used_reqs[27] = DMA_CTM3;
 760 +               } else          /* No empty slots */
 761 +                       return 1;
 762 +               break;
 763 +
 764 +       case DMA_CTM4:
 765 +               if (used_reqs[28] == 0) {
 766 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC28(3))
 767 +                           | MCF_DMA_IMCR_SRC28_CTM4;
 768 +                       used_reqs[28] = DMA_CTM4;
 769 +               } else          /* No empty slots */
 770 +                       return 1;
 771 +               break;
 772 +
 773 +       case DMA_CTM5:
 774 +               if (used_reqs[29] == 0) {
 775 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC29(3))
 776 +                           | MCF_DMA_IMCR_SRC29_CTM5;
 777 +                       used_reqs[29] = DMA_CTM5;
 778 +               } else          /* No empty slots */
 779 +                       return 1;
 780 +               break;
 781 +
 782 +       case DMA_CTM6:
 783 +               if (used_reqs[30] == 0) {
 784 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC30(3))
 785 +                           | MCF_DMA_IMCR_SRC30_CTM6;
 786 +                       used_reqs[30] = DMA_CTM6;
 787 +               } else          /* No empty slots */
 788 +                       return 1;
 789 +               break;
 790 +
 791 +       case DMA_CTM7:
 792 +               if (used_reqs[31] == 0) {
 793 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC31(3))
 794 +                           | MCF_DMA_IMCR_SRC31_CTM7;
 795 +                       used_reqs[31] = DMA_CTM7;
 796 +               } else          /* No empty slots */
 797 +                       return 1;
 798 +               break;
 799 +
 800 +       case DMA_USBEP4:
 801 +               if (used_reqs[26] == 0) {
 802 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC26(3))
 803 +                           | MCF_DMA_IMCR_SRC26_USBEP4;
 804 +                       used_reqs[26] = DMA_USBEP4;
 805 +               } else          /* No empty slots */
 806 +                       return 1;
 807 +               break;
 808 +
 809 +       case DMA_USBEP5:
 810 +               if (used_reqs[27] == 0) {
 811 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC27(3))
 812 +                           | MCF_DMA_IMCR_SRC27_USBEP5;
 813 +                       used_reqs[27] = DMA_USBEP5;
 814 +               } else          /* No empty slots */
 815 +                       return 1;
 816 +               break;
 817 +
 818 +       case DMA_USBEP6:
 819 +               if (used_reqs[28] == 0) {
 820 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC28(3))
 821 +                           | MCF_DMA_IMCR_SRC28_USBEP6;
 822 +                       used_reqs[28] = DMA_USBEP6;
 823 +               } else          /* No empty slots */
 824 +                       return 1;
 825 +               break;
 826 +
 827 +       case DMA_PSC2_RX:
 828 +               if (used_reqs[28] == 0) {
 829 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC28(3))
 830 +                           | MCF_DMA_IMCR_SRC28_PSC2RX;
 831 +                       used_reqs[28] = DMA_PSC2_RX;
 832 +               } else          /* No empty slots */
 833 +                       return 1;
 834 +               break;
 835 +
 836 +       case DMA_PSC2_TX:
 837 +               if (used_reqs[29] == 0) {
 838 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC29(3))
 839 +                           | MCF_DMA_IMCR_SRC29_PSC2TX;
 840 +                       used_reqs[29] = DMA_PSC2_TX;
 841 +               } else          /* No empty slots */
 842 +                       return 1;
 843 +               break;
 844 +
 845 +       case DMA_PSC3_RX:
 846 +               if (used_reqs[30] == 0) {
 847 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC30(3))
 848 +                           | MCF_DMA_IMCR_SRC30_PSC3RX;
 849 +                       used_reqs[30] = DMA_PSC3_RX;
 850 +               } else          /* No empty slots */
 851 +                       return 1;
 852 +               break;
 853 +
 854 +       case DMA_PSC3_TX:
 855 +               if (used_reqs[31] == 0) {
 856 +                       MCF_DMA_IMCR = (MCF_DMA_IMCR & ~MCF_DMA_IMCR_SRC31(3))
 857 +                           | MCF_DMA_IMCR_SRC31_PSC3TX;
 858 +                       used_reqs[31] = DMA_PSC3_TX;
 859 +               } else          /* No empty slots */
 860 +                       return 1;
 861 +               break;
 862 +
 863 +       default:
 864 +               return 1;
 865 +       }
 866 +       return 0;
 867 +}
 868 +
 869 +/**
 870 + * dma_get_initiator - get the initiator for the given requestor
 871 + * @requestor: initiator identifier
 872 + *
 873 + * Returns initiator number (0-31) if assigned or just 0
 874 + */
 875 +unsigned int dma_get_initiator(int requestor)
 876 +{
 877 +       u32 i;
 878 +
 879 +       for (i = 0; i < sizeof(used_reqs); ++i) {
 880 +               if (used_reqs[i] == requestor)
 881 +                       return i;
 882 +       }
 883 +       return 0;
 884 +}
 885 +
 886 +/**
 887 + * dma_remove_initiator - remove the given initiator from active list
 888 + * @requestor: requestor to remove
 889 + */
 890 +void dma_remove_initiator(int requestor)
 891 +{
 892 +       u32 i;
 893 +
 894 +       for (i = 0; i < sizeof(used_reqs); ++i) {
 895 +               if (used_reqs[i] == requestor) {
 896 +                       used_reqs[i] = -1;
 897 +                       break;
 898 +               }
 899 +       }
 900 +}
 901 +
 902 +/**
 903 + * dma_set_channel_fec: find available channel for fec and mark
 904 + * @requestor: initiator/requestor identifier
 905 + *
 906 + * Returns first avaialble channel (0-5) or -1 if all occupied
 907 + */
 908 +int dma_set_channel_fec(int requestor)
 909 +{
 910 +       u32 i, t;
 911 +
 912 +#ifdef CONFIG_FEC_548x_ENABLE_FEC2
 913 +       t = 4;
 914 +#else
 915 +       t = 2;
 916 +#endif
 917 +
 918 +       for (i = 0; i < t ; ++i) {
 919 +               if (used_channel[i] == -1) {
 920 +                       used_channel[i] = requestor;
 921 +                       return i;
 922 +               }
 923 +       }
 924 +       /* All channels taken */
 925 +       return -1;
 926 +}
 927 +
 928 +/**
 929 + * dma_set_channel - find an available channel and mark as used
 930 + * @requestor: initiator/requestor identifier
 931 + *
 932 + * Returns first available channel (6-15) or -1 if all occupied
 933 + */
 934 +int dma_set_channel(int requestor)
 935 +{
 936 +       u32 i;
 937 +#ifdef CONFIG_NET_FEC2
 938 +       i = 4;
 939 +#else
 940 +       i = 2;
 941 +#endif
 942 +
 943 +       for (; i < 16; ++i)
 944 +               if (used_channel[i] == -1) {
 945 +                       used_channel[i] = requestor;
 946 +                       return i;
 947 +               }
 948 +
 949 +       /* All channels taken */
 950 +       return -1;
 951 +}
 952 +
 953 +/**
 954 + * dma_get_channel - get the channel being initiated by the requestor
 955 + * @requestor: initiator/requestor identifier
 956 + *
 957 + * Returns Initiator for requestor or -1 if not found
 958 + */
 959 +int dma_get_channel(int requestor)
 960 +{
 961 +       u32 i;
 962 +
 963 +       for (i = 0; i < sizeof(used_channel); ++i) {
 964 +               if (used_channel[i] == requestor)
 965 +                       return i;
 966 +       }
 967 +       return -1;
 968 +}
 969 +
 970 +/**
 971 + * dma_connect - connect a channel with reference on data
 972 + * @channel: channel number
 973 + * @address: reference address of data
 974 + *
 975 + * Returns 0 if success or -1 if invalid channel
 976 + */
 977 +int dma_connect(int channel, int address)
 978 +{
 979 +       if ((channel < 16) && (channel >= 0)) {
 980 +               connected_channel[channel] = address;
 981 +               return 0;
 982 +       }
 983 +       return -1;
 984 +}
 985 +
 986 +/**
 987 + * dma_disconnect - disconnect a channel
 988 + * @channel: channel number
 989 + *
 990 + * Returns 0 if success or -1 if invalid channel
 991 + */
 992 +int dma_disconnect(int channel)
 993 +{
 994 +       if ((channel < 16) && (channel >= 0)) {
 995 +               connected_channel[channel] = 0;
 996 +               return 0;
 997 +       }
 998 +       return -1;
 999 +}
1000 +
1001 +/**
1002 + * dma_remove_channel - remove channel from the active list
1003 + * @requestor: initiator/requestor identifier
1004 + */
1005 +void dma_remove_channel(int requestor)
1006 +{
1007 +       u32 i;
1008 +
1009 +       for (i = 0; i < sizeof(used_channel); ++i) {
1010 +               if (used_channel[i] == requestor) {
1011 +                       used_channel[i] = -1;
1012 +                       break;
1013 +               }
1014 +       }
1015 +}
1016 +
1017 +/**
1018 + * dma_interrupt_handler - dma interrupt handler
1019 + * @irq: interrupt number
1020 + * @dev_id: data
1021 + *
1022 + * Returns IRQ_HANDLED
1023 + */
1024 +irqreturn_t dma_interrupt_handler(int irq, void *dev_id)
1025 +{
1026 +       u32 i, interrupts;
1027 +
1028 +       /*
1029 +        * Determine which interrupt(s) triggered by AND'ing the
1030 +        * pending interrupts with those that aren't masked.
1031 +        */
1032 +       interrupts = MCF_DMA_DIPR;
1033 +       MCF_DMA_DIPR |= interrupts;
1034 +
1035 +       for (i = 0; i < 16; ++i, interrupts >>= 1) {
1036 +               if (interrupts & 0x1)
1037 +                       if (connected_channel[i] != 0)
1038 +                               ((void (*)(void)) (connected_channel[i])) ();
1039 +       }
1040 +
1041 +       return IRQ_HANDLED;
1042 +}
1043 +
1044 +/**
1045 + * dma_remove_channel_by_number - clear dma channel
1046 + * @channel: channel number to clear
1047 + */
1048 +void dma_remove_channel_by_number(int channel)
1049 +{
1050 +       if ((channel < sizeof(used_channel)) && (channel >= 0))
1051 +               used_channel[channel] = -1;
1052 +}
1053 +
1054 +/**
1055 + * dma_init - initialize the dma subsystem
1056 + *
1057 + * Returns 0 if success non-zero if failure
1058 + *
1059 + * Handles the DMA initialization during device setup.
1060 + */
1061 +int __devinit dma_init()
1062 +{
1063 +       int result;
1064 +       char *dma_version_str;
1065 +
1066 +       MCD_getVersion(&dma_version_str);
1067 +       printk(KERN_INFO "m547x_8x DMA: Initialize %s\n", dma_version_str);
1068 +
1069 +       /* attempt to setup dma interrupt handler */
1070 +       if (request_irq(64 + ISC_DMA, dma_interrupt_handler, IRQF_DISABLED,
1071 +                       "MCD-DMA", NULL)) {
1072 +               printk(KERN_ERR "MCD-DMA: Cannot allocate the DMA IRQ(48)\n");
1073 +               return 1;
1074 +       }
1075 +
1076 +       MCF_DMA_DIMR = 0;
1077 +       MCF_DMA_DIPR = 0xFFFFFFFF;
1078 +
1079 +       MCF_ICR(ISC_DMA) = ILP_DMA;
1080 +
1081 +       result = MCD_initDma((dmaRegs *) (MCF_MBAR + 0x8000),
1082 +                       (void *) SYS_SRAM_DMA_START, MCD_RELOC_TASKS);
1083 +       if (result != MCD_OK) {
1084 +               printk(KERN_ERR "MCD-DMA: Cannot perform DMA initialization\n");
1085 +               free_irq(64 + ISC_DMA, NULL);
1086 +               return 1;
1087 +       }
1088 +
1089 +       return 0;
1090 +}
1091 +device_initcall(dma_init);
1092 --- a/drivers/dma/MCD_dma.h
1093 +++ b/drivers/dma/MCD_dma.h
1094 @@ -1,45 +1,27 @@
1095 -/*********************************************************************
1096 - *
1097 - * Copyright (C) 2004  Motorola, Inc.
1098 - *  MOTOROLA, INC. All Rights Reserved.
1099 - *  You are hereby granted a copyright license to use
1100 - *  the SOFTWARE so long as this entire notice is
1101 - *  retained without alteration in any modified and/or redistributed
1102 - *  versions, and that such modified versions are clearly identified
1103 - *  as such. No licenses are granted by implication, estoppel or
1104 - *  otherwise under any patents or trademarks of Motorola, Inc. This
1105 - *  software is provided on an "AS IS" basis and without warranty.
1106 +/*
1107 + * drivers/dma/MCD_dma.h
1108   *
1109 - *  To the maximum extent permitted by applicable law, MOTOROLA
1110 - *  DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED, INCLUDING
1111 - *  IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR
1112 - *  PURPOSE AND ANY WARRANTY AGAINST INFRINGEMENT WITH REGARD TO THE
1113 - *  SOFTWARE (INCLUDING ANY MODIFIED VERSIONS THEREOF) AND ANY
1114 - *  ACCOMPANYING WRITTEN MATERIALS.
1115 + * Copyright (C) 2004-2008 Freescale Semiconductor, Inc.
1116 + *     Kurt Mahan <kmahan@freescale.com>
1117   *
1118 - *  To the maximum extent permitted by applicable law, IN NO EVENT
1119 - *  SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER (INCLUDING
1120 - *  WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS
1121 - *  INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY
1122 - *  LOSS) ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.
1123 + * This program is free software; you can redistribute it and/or
1124 + * modify it under the terms of the GNU General Public License as
1125 + * published by the Free Software Foundation; either version 2 of
1126 + * the License, or (at your option) any later version.
1127   *
1128 - *  Motorola assumes no responsibility for the maintenance and support
1129 - *  of this software
1130 - ********************************************************************/
1131 -
1132 -/*
1133 - * File:        MCD_dma.h
1134 - * Purpose:     Main header file for multi-channel DMA API.
1135 + * This program is distributed in the hope that it will be useful,
1136 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1137 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1138 + * GNU General Public License for more details.
1139   *
1140 - * Notes:
1141 - *
1142 - * Modifications:
1143 + * You should have received a copy of the GNU General Public License
1144 + * along with this program; if not, write to the Free Software
1145 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
1146 + * MA 02111-1307 USA
1147   */
1148  #ifndef _MCD_API_H
1149  #define _MCD_API_H
1150
1151 -#include <asm/types.h>
1152 -
1153  /*
1154   * Turn Execution Unit tasks ON (#define) or OFF (#undef)
1155   */
1156 @@ -79,26 +61,13 @@
1157  /*
1158   * Portability typedefs
1159   */
1160 - /*
1161 -#ifndef s32
1162  typedef int s32;
1163 -#endif
1164 -#ifndef u32
1165  typedef unsigned int u32;
1166 -#endif
1167 -#ifndef s16
1168  typedef short s16;
1169 -#endif
1170 -#ifndef u16
1171  typedef unsigned short u16;
1172 -#endif
1173 -#ifndef s8
1174  typedef char s8;
1175 -#endif
1176 -#ifndef u8
1177  typedef unsigned char u8;
1178 -#endif
1179 -*/
1180 +
1181  /*
1182   * These structures represent the internal registers of the
1183   * multi-channel DMA
1184 @@ -233,6 +202,7 @@ typedef volatile struct dmaRegs_s dmaReg
1185  #define MCD_TT_FLAGS_RL   0x00000001 /* Read line */
1186  #define MCD_TT_FLAGS_CW   0x00000002 /* Combine Writes */
1187  #define MCD_TT_FLAGS_SP   0x00000004 /* Speculative prefetch(XLB) MCF547x/548x ONLY  */
1188 +#define MCD_TT_FLAGS_PI   0x00000040 /* Precise Increment */
1189  #define MCD_TT_FLAGS_MASK 0x000000ff
1190  #define MCD_TT_FLAGS_DEF  (MCD_TT_FLAGS_RL | MCD_TT_FLAGS_CW)
1191
1192 --- a/drivers/dma/MCD_dmaApi.c
1193 +++ b/drivers/dma/MCD_dmaApi.c
1194 @@ -1,46 +1,26 @@
1195 -/*********************************************************************
1196 - *
1197 - * Copyright (C) 2004  Motorola, Inc.
1198 - *  MOTOROLA, INC. All Rights Reserved.
1199 - *  You are hereby granted a copyright license to use
1200 - *  the SOFTWARE so long as this entire notice is
1201 - *  retained without alteration in any modified and/or redistributed
1202 - *  versions, and that such modified versions are clearly identified
1203 - *  as such. No licenses are granted by implication, estoppel or
1204 - *  otherwise under any patents or trademarks of Motorola, Inc. This
1205 - *  software is provided on an "AS IS" basis and without warranty.
1206 - *
1207 - *  To the maximum extent permitted by applicable law, MOTOROLA
1208 - *  DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED, INCLUDING
1209 - *  IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR
1210 - *  PURPOSE AND ANY WARRANTY AGAINST INFRINGEMENT WITH REGARD TO THE
1211 - *  SOFTWARE (INCLUDING ANY MODIFIED VERSIONS THEREOF) AND ANY
1212 - *  ACCOMPANYING WRITTEN MATERIALS.
1213 - *
1214 - *  To the maximum extent permitted by applicable law, IN NO EVENT
1215 - *  SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER (INCLUDING
1216 - *  WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS
1217 - *  INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY
1218 - *  LOSS) ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.
1219 - *
1220 - *  Motorola assumes no responsibility for the maintenance and support
1221 - *  of this software
1222 - ********************************************************************/
1223 -
1224  /*
1225 - * File:        MCD_dmaApi.c
1226 - * Purpose:     Main C file for multi-channel DMA API.
1227 - *
1228 - * Notes:
1229 + * drivers/dma/MCD_dmaApi.c
1230   *
1231 + * Copyright (C) 2004-2008 Freescale Semiconductor, Inc.
1232 + *     Kurt Mahan <kmahan@freescale.com>
1233   *
1234 - * Modifications:
1235 + * This program is free software; you can redistribute it and/or
1236 + * modify it under the terms of the GNU General Public License as
1237 + * published by the Free Software Foundation; either version 2 of
1238 + * the License, or (at your option) any later version.
1239   *
1240 + * This program is distributed in the hope that it will be useful,
1241 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1242 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1243 + * GNU General Public License for more details.
1244   *
1245 + * You should have received a copy of the GNU General Public License
1246 + * along with this program; if not, write to the Free Software
1247 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
1248 + * MA 02111-1307 USA
1249   */
1250 -#include <asm/types.h>
1251 -#include <asm/MCD_dma.h>
1252 -#include <asm/virtconvert.h>
1253 +
1254 +#include "MCD_dma.h"
1255  #include "MCD_tasksInit.h"
1256  #include "MCD_progCheck.h"
1257
1258 @@ -148,7 +128,6 @@ MCD_bufDesc *MCD_relocBuffDesc;
1259
1260  /*
1261   * Structure to remember which variant is on which channel
1262 - * TBD- need this?
1263   */
1264  typedef struct MCD_remVariants_struct MCD_remVariant;
1265  struct MCD_remVariants_struct
1266 @@ -164,6 +143,7 @@ struct MCD_remVariants_struct
1267   * Structure to remember the startDma parameters for each channel
1268   */
1269  MCD_remVariant MCD_remVariants;
1270 +
1271  /********************************************************************/
1272  /*
1273   * Function: MCD_initDma
1274 @@ -185,15 +165,14 @@ int MCD_initDma (dmaRegs *dmaBarAddr, vo
1275      int i;
1276      TaskTableEntry *entryPtr;
1277
1278 -    /* setup the local pointer to register set */
1279 +    /* Setup the local pointer to register set */
1280      MCD_dmaBar = dmaBarAddr;
1281
1282 -    /* do we need to move/create a task table */
1283 +    /* Do we need to move/create a task table */
1284      if ((flags & MCD_RELOC_TASKS) != 0)
1285      {
1286          int fixedSize;
1287          u32 *fixedPtr;
1288 -        /*int *tablePtr = taskTableDest;TBD*/
1289          int varTabsOffset, funcDescTabsOffset, contextSavesOffset;
1290          int taskDescTabsOffset;
1291          int taskTableSize, varTabsSize, funcDescTabsSize, contextSavesSize;
1292 @@ -201,7 +180,7 @@ int MCD_initDma (dmaRegs *dmaBarAddr, vo
1293
1294          int i;
1295
1296 -        /* check if physical address is aligned on 512 byte boundary */
1297 +        /* Check if physical address is aligned on 512 byte boundary */
1298          if (((u32)taskTableDest & 0x000001ff) != 0)
1299              return(MCD_TABLE_UNALIGNED);
1300
1301 @@ -215,13 +194,12 @@ int MCD_initDma (dmaRegs *dmaBarAddr, vo
1302           * - copy over model task table with the the actual task descriptor
1303           *   tables
1304           */
1305 -
1306          taskTableSize = NCHANNELS * sizeof(TaskTableEntry);
1307 -        /* align variable tables to size */
1308 +        /* Align variable tables to size */
1309          varTabsOffset = taskTableSize + (u32)taskTableDest;
1310          if ((varTabsOffset & (VAR_TAB_SIZE - 1)) != 0)
1311              varTabsOffset = (varTabsOffset + VAR_TAB_SIZE) & (~VAR_TAB_SIZE);
1312 -        /* align function descriptor tables */
1313 +        /* Align function descriptor tables */
1314          varTabsSize = NCHANNELS * VAR_TAB_SIZE;
1315          funcDescTabsOffset = varTabsOffset + varTabsSize;
1316
1317 @@ -235,13 +213,13 @@ int MCD_initDma (dmaRegs *dmaBarAddr, vo
1318          fixedSize = taskTableSize + varTabsSize + funcDescTabsSize +
1319                      contextSavesSize;
1320
1321 -        /* zero the thing out */
1322 +        /* Zero the thing out */
1323          fixedPtr = (u32 *)taskTableDest;
1324          for (i = 0;i<(fixedSize/4);i++)
1325              fixedPtr[i] = 0;
1326
1327          entryPtr = (TaskTableEntry*)MCD_taskTable;
1328 -        /* set up fixed pointers */
1329 +        /* Set up fixed pointers */
1330          for (i = 0; i < NCHANNELS; i++)
1331          {
1332              entryPtr[i].varTab = (u32)varTabsOffset; /* update ptr to local value */
1333 @@ -253,25 +231,25 @@ int MCD_initDma (dmaRegs *dmaBarAddr, vo
1334  #endif
1335              contextSavesOffset += CONTEXT_SAVE_SIZE;
1336          }
1337 -        /* copy over the function descriptor table */
1338 +        /* Copy over the function descriptor table */
1339          for ( i = 0; i < FUNCDESC_TAB_NUM; i++)
1340          {
1341              MCD_memcpy((void*)(entryPtr[i].FDTandFlags & ~MCD_TT_FLAGS_MASK),
1342                         (void*)MCD_funcDescTab0, FUNCDESC_TAB_SIZE);
1343          }
1344
1345 -        /* copy model task table to where the context saves stuff leaves off*/
1346 +        /* Copy model task table to where the context save stuff leaves off */
1347          MCD_modelTaskTable = (TaskTableEntry*)contextSavesOffset;
1348
1349          MCD_memcpy ((void*)MCD_modelTaskTable, (void*)MCD_modelTaskTableSrc,
1350                      NUMOFVARIANTS * sizeof(TaskTableEntry));
1351
1352 -        entryPtr = MCD_modelTaskTable; /* point to local version of
1353 -                                                            model task table */
1354 +        /* Point to local version of model task table */
1355 +        entryPtr = MCD_modelTaskTable;
1356          taskDescTabsOffset = (u32)MCD_modelTaskTable +
1357                              (NUMOFVARIANTS * sizeof(TaskTableEntry));
1358
1359 -        /* copy actual task code and update TDT ptrs in local model task table */
1360 +        /* Copy actual task code and update TDT ptrs in local model task table */
1361          for (i = 0; i < NUMOFVARIANTS; i++)
1362          {
1363              taskDescTabSize = entryPtr[i].TDTend - entryPtr[i].TDTstart + 4;
1364 @@ -280,25 +258,29 @@ int MCD_initDma (dmaRegs *dmaBarAddr, vo
1365              taskDescTabsOffset += taskDescTabSize;
1366              entryPtr[i].TDTend = (u32)taskDescTabsOffset - 4;
1367          }
1368 -#ifdef MCD_INCLUDE_EU /* Tack single DMA BDs onto end of code so API controls
1369 -                         where they are since DMA might write to them */
1370 +#ifdef MCD_INCLUDE_EU
1371 +        /*
1372 +         * Tack single DMA BDs onto end of code so API controls where
1373 +         * they are since DMA might write to them
1374 +         */
1375          MCD_relocBuffDesc = (MCD_bufDesc*)(entryPtr[NUMOFVARIANTS - 1].TDTend + 4);
1376 -#else /* DMA does not touch them so they can be wherever and we don't need to
1377 -         waste SRAM on them */
1378 +#else
1379 +        /*
1380 +         * DMA does not touch them so they can be wherever and we don't need to
1381 +         * waste SRAM on them
1382 +         */
1383          MCD_relocBuffDesc = MCD_singleBufDescs;
1384  #endif
1385      }
1386      else
1387      {
1388 -        /* point the would-be relocated task tables and the
1389 -        buffer descriptors to the ones the linker generated */
1390 -
1391 +        /*
1392 +         * Point the would-be relocated task tables and the buffer descriptors
1393 +         * to the ones the linker generated
1394 +         */
1395          if (((u32)MCD_realTaskTableSrc & 0x000001ff) != 0)
1396              return(MCD_TABLE_UNALIGNED);
1397
1398 -        /* need to add code to make sure that every thing else is aligned properly TBD*/
1399 -        /* this is problematic if we init more than once or after running tasks,
1400 -            need to add variable to see if we have aleady init'd */
1401          entryPtr = MCD_realTaskTableSrc;
1402          for (i = 0; i < NCHANNELS; i++)
1403          {
1404 @@ -312,9 +294,7 @@ int MCD_initDma (dmaRegs *dmaBarAddr, vo
1405          MCD_relocBuffDesc = MCD_singleBufDescs;
1406      }
1407
1408 -
1409 -    /* Make all channels as totally inactive, and remember them as such: */
1410 -
1411 +    /* Make all channels inactive, and remember them as such: */
1412      MCD_dmaBar->taskbar = (u32) MCD_taskTable;
1413      for (i = 0;  i < NCHANNELS;  i++)
1414      {
1415 @@ -323,13 +303,12 @@ int MCD_initDma (dmaRegs *dmaBarAddr, vo
1416      }
1417
1418     /* Set up pausing mechanism to inactive state: */
1419 -    MCD_dmaBar->debugComp1 = 0;  /* no particular values yet for either comparator registers */
1420 +    MCD_dmaBar->debugComp1 = 0;
1421      MCD_dmaBar->debugComp2 = 0;
1422      MCD_dmaBar->debugControl = DBG_CTL_DISABLE;
1423      MCD_dmaBar->debugStatus = DBG_KILL_ALL_STAT;
1424
1425 -    /* enable or disable commbus prefetch, really need an ifdef or
1426 -       something to keep from trying to set this in the 8220 */
1427 +    /* Enable or disable commbus prefetch */
1428      if ((flags & MCD_COMM_PREFETCH_EN) != 0)
1429          MCD_dmaBar->ptdControl &= ~PTD_CTL_COMM_PREFETCH;
1430      else
1431 @@ -354,8 +333,7 @@ int MCD_dmaStatus (int channel)
1432
1433      tcrValue = MCD_dmaBar->taskControl[channel];
1434      if ((tcrValue & TASK_CTL_EN) == 0)
1435 -    {  /* nothing running */
1436 -        /* if last reported with task enabled */
1437 +    {   /* Nothing running if last reported with task enabled */
1438          if (   MCD_chStatus[channel] == MCD_RUNNING
1439              || MCD_chStatus[channel] == MCD_IDLE)
1440              MCD_chStatus[channel] = MCD_DONE;
1441 @@ -367,13 +345,12 @@ int MCD_dmaStatus (int channel)
1442              || MCD_chStatus[channel] == MCD_IDLE)
1443          {
1444              MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT;
1445 -            /* This register is selected to know which initiator is
1446 -            actually asserted. */
1447 +            /* Determine which initiator is asserted. */
1448              if ((MCD_dmaBar->ptdDebug >> channel ) & 0x1 )
1449                  MCD_chStatus[channel] = MCD_RUNNING;
1450              else
1451                  MCD_chStatus[channel] = MCD_IDLE;
1452 -        /* do not change the status if it is already paused. */
1453 +            /* Do not change the status if it is already paused */
1454          }
1455      }
1456      return MCD_chStatus[channel];
1457 @@ -414,67 +391,86 @@ int MCD_startDma (
1458
1459      if((channel < 0) || (channel >= NCHANNELS))
1460          return(MCD_CHANNEL_INVALID);
1461 -
1462 -    /* tbd - need to determine the proper response to a bad funcDesc when not
1463 -       including EU functions, for now, assign a benign funcDesc, but maybe
1464 -       should return an error */
1465 +
1466  #ifndef MCD_INCLUDE_EU
1467      funcDesc = MCD_FUNC_NOEU1;
1468  #endif
1469 -
1470 +
1471  #ifdef MCD_DEBUG
1472  printf("startDma:Setting up params\n");
1473  #endif
1474 -   /* Set us up for task-wise priority.  We don't technically need to do this on every start, but
1475 -      since the register involved is in the same longword as other registers that users are in control
1476 -      of, setting it more than once is probably preferable.  That since the documentation doesn't seem
1477 -      to be completely consistent about the nature of the PTD control register. */
1478 +
1479 +   /* Enable task-wise priority */
1480      MCD_dmaBar->ptdControl |= (u16) 0x8000;
1481 -#if 1 /* Not sure what we need to keep here rtm TBD */
1482 +
1483      /* Calculate additional parameters to the regular DMA calls. */
1484      srcRsdIncr = srcIncr < 0 ? -1 : (srcIncr > 0 ? 1 : 0);
1485      destRsdIncr = destIncr < 0 ? -1 : (destIncr > 0 ? 1 : 0);
1486 -
1487      xferSizeIncr = (xferSize & 0xffff) | 0x20000000;
1488
1489 -    /* Remember for each channel which variant is running. */
1490 +    /* Remember which variant is running for each channel */
1491      MCD_remVariants.remSrcRsdIncr[channel] = srcRsdIncr;
1492      MCD_remVariants.remDestRsdIncr[channel] = destRsdIncr;
1493      MCD_remVariants.remDestIncr[channel] = destIncr;
1494      MCD_remVariants.remSrcIncr[channel] = srcIncr;
1495      MCD_remVariants.remXferSize[channel] = xferSize;
1496 -#endif
1497
1498 -    cSave = (int*)(MCD_taskTable[channel].contextSaveSpace) + CSAVE_OFFSET + CURRBD;
1499 +    cSave = (int*)(MCD_taskTable[channel].contextSaveSpace)
1500 +            + CSAVE_OFFSET
1501 +            + CURRBD;
1502
1503 -#ifdef MCD_INCLUDE_EU /* may move this to EU specific calls */
1504 +#ifdef MCD_INCLUDE_EU
1505      realFuncArray = (u32 *) (MCD_taskTable[channel].FDTandFlags & 0xffffff00);
1506 -    /* Modify the LURC's normal and byte-residue-loop functions according to parameter. */
1507 -    realFuncArray[(LURC*16)] = xferSize == 4 ?
1508 -                                 funcDesc : xferSize == 2 ?
1509 -                                     funcDesc & 0xfffff00f : funcDesc & 0xffff000f;
1510 -    realFuncArray[(LURC*16+1)] = (funcDesc & MCD_BYTE_SWAP_KILLER) | MCD_NO_BYTE_SWAP_ATALL;
1511 -#endif
1512 -   /* Write the initiator field in the TCR, and also set the initiator-hold
1513 -      bit.  Note that,due to a hardware quirk, this could collide with an
1514 -      MDE access to the initiator-register file, so we have to verify that the write
1515 -      reads back correctly. */
1516
1517 -    MCD_dmaBar->taskControl[channel] =
1518 -        (initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM;
1519 +    /*
1520 +     * Modify the LURC's normal and byte-residue-loop functions
1521 +     * according to parameter.
1522 +     */
1523 +    switch (xferSize)
1524 +    {
1525 +        case 4:
1526 +            realFuncArray[(LURC*16)] = funcDesc;
1527 +            break;
1528 +        case 2:
1529 +            realFuncArray[(LURC*16)] = funcDesc & 0xfffff00f;
1530 +            break;
1531 +        case 1:
1532 +        default:
1533 +            realFuncArray[(LURC*16)] = funcDesc & 0xffff000f;
1534 +            break;
1535 +    }
1536
1537 +    realFuncArray[(LURC*16+1)] = 0
1538 +        | (funcDesc & MCD_BYTE_SWAP_KILLER)
1539 +        | MCD_NO_BYTE_SWAP_ATALL;
1540 +#endif
1541 +
1542 +   /* Write the initiator field in the TCR and set the initiator-hold bit*/
1543 +    MCD_dmaBar->taskControl[channel] = 0
1544 +        | (initiator << 8)
1545 +        | TASK_CTL_HIPRITSKEN
1546 +        | TASK_CTL_HLDINITNUM;
1547 +
1548 +    /*
1549 +     * Current versions of the MPC8220 MCD have a hardware quirk that could
1550 +     * cause the write to the TCR to collide with an MDE access to the
1551 +     * initiator-register file, so we have to verify that the write occurred
1552 +     * correctly by reading back the value.  On MCF547x/8x devices and any
1553 +     * future revisions of the MPC8220, this loop will not be entered.
1554 +     */
1555      while(((MCD_dmaBar->taskControl[channel] & 0x1fff) !=
1556            ((initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM)) &&
1557              (tcrCount < 1000))
1558      {
1559          tcrCount++;
1560 -        /*MCD_dmaBar->ptd_tcr[channel] = (initiator << 8) | 0x0020;*/
1561 -        MCD_dmaBar->taskControl[channel] =
1562 -            (initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM;
1563 +        MCD_dmaBar->taskControl[channel] = 0
1564 +            | (initiator << 8)
1565 +            | TASK_CTL_HIPRITSKEN
1566 +            | TASK_CTL_HLDINITNUM;
1567      }
1568
1569      MCD_dmaBar->priority[channel] = (u8)priority & PRIORITY_PRI_MASK;
1570 -    /* should be albe to handle this stuff with only one write to ts reg - tbd */
1571 +
1572      if (channel < 8 && channel >= 0)
1573      {
1574          MCD_dmaBar->taskSize0 &= ~(0xf << (7-channel)*4);
1575 @@ -488,7 +484,7 @@ printf("startDma:Setting up params\n");
1576          MCD_dmaBar->taskSize1 |= (xferSize & 3) << ((15 - channel)*4);
1577      }
1578
1579 -    /* setup task table flags/options which mostly control the line buffers */
1580 +    /* Setup task table flags/options */
1581      MCD_taskTable[channel].FDTandFlags &= ~MCD_TT_FLAGS_MASK;
1582      MCD_taskTable[channel].FDTandFlags |= (MCD_TT_FLAGS_MASK & flags);
1583
1584 @@ -508,79 +504,86 @@ printf("startDma:Setting up params\n");
1585      }
1586      else if(flags & MCD_SINGLE_DMA)
1587      {
1588 -        /* this buffer descriptor is used for storing off initial parameters for later
1589 -           progress query calculation and for the DMA to write the resulting checksum
1590 -           The DMA does not use this to determine how to operate, that info is passed
1591 -           with the init routine*/
1592 +        /*
1593 +         * This buffer descriptor is used for storing off initial parameters
1594 +         * for later progress query calculation and for the DMA to write the
1595 +         * resulting checksum. The DMA does not use this to determine how to
1596 +         * operate, that info is passed with the init routine
1597 +         */
1598          MCD_relocBuffDesc[channel].srcAddr = srcAddr;
1599          MCD_relocBuffDesc[channel].destAddr = destAddr;
1600 -        MCD_relocBuffDesc[channel].lastDestAddr = destAddr;  /* definitely not its final value */
1601 +        MCD_relocBuffDesc[channel].lastDestAddr = destAddr;
1602          MCD_relocBuffDesc[channel].dmaSize = dmaSize;
1603          MCD_relocBuffDesc[channel].flags = 0;       /* not used */
1604          MCD_relocBuffDesc[channel].csumResult = 0;  /* not used */
1605          MCD_relocBuffDesc[channel].next = 0;        /* not used */
1606
1607          /* Initialize the progress-querying stuff to show no progress:*/
1608 -        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET] = (int)srcAddr;
1609 -        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET] = (int)destAddr;
1610 -        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET] = 0;
1611 -        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET] =
1612 -                                             (u32) &(MCD_relocBuffDesc[channel]);
1613 -        /* tbd - need to keep the user from trying to call the EU routine
1614 -           when MCD_INCLUDE_EU is not defined */
1615 +        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET]
1616 +            = (int)srcAddr;
1617 +        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET]
1618 +            = (int)destAddr;
1619 +        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET]
1620 +            = 0;
1621 +        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET]
1622 +            = (u32) &(MCD_relocBuffDesc[channel]);
1623 +
1624          if( funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2)
1625          {
1626 -           /* TDTStart and TDTEnd */
1627 -           MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_SINGLENOEU].TDTstart;
1628 -           MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_SINGLENOEU].TDTend;
1629 -           MCD_startDmaSingleNoEu(srcAddr, srcIncr, destAddr, destIncr, dmaSize, dmaSize,
1630 -                                xferSizeIncr, flags, (int *)&(MCD_relocBuffDesc[channel]), cSave,
1631 -                                MCD_taskTable, channel);
1632 +            /* TDTStart and TDTEnd */
1633 +            MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_SINGLENOEU].TDTstart;
1634 +            MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_SINGLENOEU].TDTend;
1635 +            MCD_startDmaSingleNoEu(srcAddr, srcIncr, destAddr, destIncr, dmaSize,
1636 +                                xferSizeIncr, flags, (int *)&(MCD_relocBuffDesc[channel]),
1637 +                                cSave, MCD_taskTable, channel);
1638          }
1639          else
1640          {
1641 -           /* TDTStart and TDTEnd */
1642 -           MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_SINGLEEU].TDTstart;
1643 -           MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_SINGLEEU].TDTend;
1644 -           MCD_startDmaSingleEu(srcAddr, srcIncr, destAddr, destIncr, dmaSize, dmaSize,
1645 -                              xferSizeIncr, flags, (int *)&(MCD_relocBuffDesc[channel]), cSave,
1646 -                              MCD_taskTable, channel);
1647 +            /* TDTStart and TDTEnd */
1648 +            MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_SINGLEEU].TDTstart;
1649 +            MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_SINGLEEU].TDTend;
1650 +            MCD_startDmaSingleEu(srcAddr, srcIncr, destAddr, destIncr, dmaSize,
1651 +                                xferSizeIncr, flags, (int *)&(MCD_relocBuffDesc[channel]),
1652 +                                cSave, MCD_taskTable, channel);
1653          }
1654      }
1655 -    else
1656 -    { /* chained DMAS */
1657 +    else /* Chained DMA */
1658 +    {
1659          /* Initialize the progress-querying stuff to show no progress:*/
1660  #if 1 /* (!defined(MCD_NEED_ADDR_TRANS)) */
1661          ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET]
1662 -          = (int)((MCD_bufDesc*) phys_to_virt(srcAddr))->srcAddr;
1663 +            = (int)((MCD_bufDesc*) srcAddr)->srcAddr;
1664          ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET]
1665 -          = (int)((MCD_bufDesc*) phys_to_virt(srcAddr))->destAddr;
1666 +            = (int)((MCD_bufDesc*) srcAddr)->destAddr;
1667  #else /* if using address translation, need the virtual addr of the first buffdesc */
1668          ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET]
1669            = (int)((MCD_bufDesc*) srcAddrVirt)->srcAddr;
1670          ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET]
1671            = (int)((MCD_bufDesc*) srcAddrVirt)->destAddr;
1672  #endif
1673 -        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET] = 0;
1674 -        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET] = (u32) srcAddr;
1675 +        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET]
1676 +          = 0;
1677 +        ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET]
1678 +          = (u32) srcAddr;
1679
1680          if( funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2)
1681          {
1682 -          /*TDTStart and TDTEnd*/
1683 -          MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_CHAINNOEU].TDTstart;
1684 -          MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_CHAINNOEU].TDTend;
1685 -          MCD_startDmaChainNoEu((int *)srcAddr, srcIncr, destIncr, xferSize,
1686 +            /* TDTStart and TDTEnd */
1687 +            MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_CHAINNOEU].TDTstart;
1688 +            MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_CHAINNOEU].TDTend;
1689 +            MCD_startDmaChainNoEu((int *)srcAddr, srcIncr, destIncr, xferSize,
1690                                      xferSizeIncr, cSave, MCD_taskTable, channel);
1691          }
1692          else
1693          {
1694 -          /*TDTStart and TDTEnd*/
1695 -          MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_CHAINEU].TDTstart;
1696 -          MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_CHAINEU].TDTend;
1697 -          MCD_startDmaChainEu((int *)srcAddr, srcIncr, destIncr, xferSize,
1698 +            /* TDTStart and TDTEnd */
1699 +            MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_CHAINEU].TDTstart;
1700 +            MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_CHAINEU].TDTend;
1701 +            MCD_startDmaChainEu((int *)srcAddr, srcIncr, destIncr, xferSize,
1702                                   xferSizeIncr, cSave, MCD_taskTable, channel);
1703          }
1704      }
1705 +
1706      MCD_chStatus[channel] = MCD_IDLE;
1707      return(MCD_OK);
1708  }
1709 @@ -597,7 +600,7 @@ printf("startDma:Setting up params\n");
1710   * Notes:
1711   *  MCD_XferProgrQuery() upon completing or after aborting a DMA, or
1712   *  while the DMA is in progress, this function returns the first
1713 - *  DMA-destination address not (or not yet) used in the DMA. When
1714 + *  DMA-destination address not (or not yet) used in the DMA. When
1715   *  encountering a non-ready buffer descriptor, the information for
1716   *  the last completed descriptor is returned.
1717   *
1718 @@ -642,11 +645,13 @@ int MCD_XferProgrQuery (int channel, MCD
1719      prevRep.dmaSize = ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET];
1720      prevRep.currBufDesc =
1721            (MCD_bufDesc*) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET];
1722 +
1723      /* Repeatedly reread those values until they match previous values: */
1724      do {
1725 -        /* Waste a little bit of time to ensure stability: */
1726 +        /* Take a little bit of time to ensure stability: */
1727          for (i = 0;  i < STABTIME;  i++)
1728 -            i += i >> 2;  /* make sure this loop does something so that it doesn't get optimized out */
1729 +            i += i >> 2;  /* make sure this loop does something so that it
1730 +                             doesn't get optimized out */
1731          /* Check them again: */
1732          progRep->lastSrcAddr =
1733              (s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET];
1734 @@ -655,31 +660,33 @@ int MCD_XferProgrQuery (int channel, MCD
1735          progRep->dmaSize = ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET];
1736          progRep->currBufDesc =
1737              (MCD_bufDesc*) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET];
1738 -       /* See if they match: */
1739 -       if (   prevRep.lastSrcAddr != progRep->lastSrcAddr
1740 -           || prevRep.lastDestAddr != progRep->lastDestAddr
1741 -           || prevRep.dmaSize != progRep->dmaSize
1742 -           || prevRep.currBufDesc != progRep->currBufDesc)
1743 -       {
1744 -          /* If they don't match, remember previous values and try again:*/
1745 -          prevRep.lastSrcAddr = progRep->lastSrcAddr;
1746 -          prevRep.lastDestAddr = progRep->lastDestAddr;
1747 -          prevRep.dmaSize = progRep->dmaSize;
1748 -          prevRep.currBufDesc = progRep->currBufDesc;
1749 -          again = MCD_TRUE;
1750 -       }
1751 -       else
1752 +
1753 +        /* See if they match: */
1754 +        if (   prevRep.lastSrcAddr  != progRep->lastSrcAddr
1755 +            || prevRep.lastDestAddr != progRep->lastDestAddr
1756 +            || prevRep.dmaSize      != progRep->dmaSize
1757 +            || prevRep.currBufDesc  != progRep->currBufDesc)
1758 +        {
1759 +            /* If they don't match, remember previous values and try again:*/
1760 +            prevRep.lastSrcAddr = progRep->lastSrcAddr;
1761 +            prevRep.lastDestAddr = progRep->lastDestAddr;
1762 +            prevRep.dmaSize = progRep->dmaSize;
1763 +            prevRep.currBufDesc = progRep->currBufDesc;
1764 +            again = MCD_TRUE;
1765 +        }
1766 +        else
1767            again = MCD_FALSE;
1768      } while (again == MCD_TRUE);
1769
1770
1771 -    /* Update the dCount, srcAddr and destAddr */
1772 -    /* To calculate dmaCount, we consider destination address. C
1773 -       overs M1,P1,Z for destination */
1774 -    switch(MCD_remVariants.remDestRsdIncr[channel]) {
1775 +    /* Update dmaSize and lastDestAddr */
1776 +    switch(MCD_remVariants.remDestRsdIncr[channel])
1777 +    {
1778          case MINUS1:
1779 -           subModVal = ((int)progRep->lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) - 1);
1780 -           addModVal = ((int)progRep->currBufDesc->destAddr) & ((MCD_remVariants.remXferSize[channel]) - 1);
1781 +           subModVal = ((int)progRep->lastDestAddr)
1782 +                        & ((MCD_remVariants.remXferSize[channel]) - 1);
1783 +           addModVal = ((int)progRep->currBufDesc->destAddr)
1784 +                        & ((MCD_remVariants.remXferSize[channel]) - 1);
1785             LWAlignedInitDestAddr = (progRep->currBufDesc->destAddr) - addModVal;
1786             LWAlignedCurrDestAddr = (progRep->lastDestAddr) - subModVal;
1787             destDiffBytes = LWAlignedInitDestAddr - LWAlignedCurrDestAddr;
1788 @@ -692,25 +699,28 @@ int MCD_XferProgrQuery (int channel, MCD
1789             progRep->lastDestAddr = progRep->currBufDesc->destAddr;
1790             break;
1791          case PLUS1:
1792 -           /* This value has to be subtracted from the final calculated dCount. */
1793 -           subModVal = ((int)progRep->currBufDesc->destAddr) & ((MCD_remVariants.remXferSize[channel]) - 1);
1794 +           /* This value has to be subtracted from the final calculated dmaSize. */
1795 +            subModVal = ((int)progRep->currBufDesc->destAddr)
1796 +                        & ((MCD_remVariants.remXferSize[channel]) - 1);
1797             /* These bytes are already in lastDestAddr. */
1798 -            addModVal = ((int)progRep->lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) - 1);
1799 +            addModVal = ((int)progRep->lastDestAddr)
1800 +                        & ((MCD_remVariants.remXferSize[channel]) - 1);
1801              LWAlignedInitDestAddr = (progRep->currBufDesc->destAddr) - subModVal;
1802              LWAlignedCurrDestAddr = (progRep->lastDestAddr) - addModVal;
1803              destDiffBytes = (progRep->lastDestAddr - LWAlignedInitDestAddr);
1804              numIterations = ( LWAlignedCurrDestAddr - LWAlignedInitDestAddr)/MCD_remVariants.remDestIncr[channel];
1805              bytesNotXfered =  numIterations *
1806 -                ( MCD_remVariants.remDestIncr[channel]
1807 -                  - MCD_remVariants.remXferSize[channel]);
1808 -           progRep->dmaSize = destDiffBytes - bytesNotXfered - subModVal;
1809 -           break;
1810 +                              (MCD_remVariants.remDestIncr[channel]
1811 +                             - MCD_remVariants.remXferSize[channel]);
1812 +            progRep->dmaSize = destDiffBytes - bytesNotXfered - subModVal;
1813 +            break;
1814          default:
1815 -           break;
1816 +            break;
1817      }
1818
1819      /* This covers M1,P1,Z for source */
1820 -    switch(MCD_remVariants.remSrcRsdIncr[channel]) {
1821 +    switch(MCD_remVariants.remSrcRsdIncr[channel])
1822 +    {
1823          case MINUS1:
1824              progRep->lastSrcAddr =
1825                  progRep->currBufDesc->srcAddr +
1826 @@ -720,13 +730,14 @@ int MCD_XferProgrQuery (int channel, MCD
1827          case ZERO:
1828              progRep->lastSrcAddr = progRep->currBufDesc->srcAddr;
1829              break;
1830 -       case PLUS1:
1831 +        case PLUS1:
1832              progRep->lastSrcAddr =
1833                  progRep->currBufDesc->srcAddr +
1834                   ( MCD_remVariants.remSrcIncr[channel] *
1835                     (progRep->dmaSize/MCD_remVariants.remXferSize[channel]));
1836 -          break;
1837 -       default: break;
1838 +            break;
1839 +        default:
1840 +            break;
1841      }
1842
1843      return(MCD_OK);
1844 @@ -744,8 +755,10 @@ static void MCD_resmActions (int channel
1845  {
1846     MCD_dmaBar->debugControl = DBG_CTL_DISABLE;
1847     MCD_dmaBar->debugStatus = MCD_dmaBar->debugStatus;
1848 -   MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT; /* This register is selected to know
1849 -                                        which initiator is actually asserted. */
1850 +
1851 +   /* Determine which initiators are asserted */
1852 +   MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT;
1853 +
1854     if((MCD_dmaBar->ptdDebug >> channel ) & 0x1)
1855         MCD_chStatus[channel] = MCD_RUNNING;
1856     else
1857 @@ -767,27 +780,20 @@ static void MCD_resmActions (int channel
1858   */
1859  int MCD_killDma (int channel)
1860  {
1861 -   /* MCD_XferProg progRep; */
1862 -
1863      if((channel < 0) || (channel >= NCHANNELS))
1864          return(MCD_CHANNEL_INVALID);
1865
1866      MCD_dmaBar->taskControl[channel] = 0x0;
1867 -    MCD_resumeDma (channel);
1868 -    /*
1869 -     * This must be after the write to the TCR so that the task doesn't
1870 -     * start up again momentarily, and before the status assignment so
1871 -     * as to override whatever MCD_resumeDma() may do to the channel
1872 -     * status.
1873 -     */
1874 +
1875 +    /* Clean up after a paused task */
1876 +    if (MCD_chStatus[channel] == MCD_PAUSED)
1877 +    {
1878 +        MCD_dmaBar->debugControl = DBG_CTL_DISABLE;
1879 +        MCD_dmaBar->debugStatus = MCD_dmaBar->debugStatus;
1880 +    }
1881 +
1882      MCD_chStatus[channel] = MCD_HALTED;
1883
1884 -    /*
1885 -     * Update the current buffer descriptor's lastDestAddr field
1886 -     *
1887 -     * MCD_XferProgrQuery (channel, &progRep);
1888 -     * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr;
1889 -     */
1890      return(MCD_OK);
1891  }
1892  /************************ End of MCD_killDma() **********************/
1893 @@ -843,7 +849,7 @@ int MCD_continDma (int channel)
1894   * this means that bits 14 and 0 must enable debug functions before
1895   * bits 1 and 2, respectively, have any effect.
1896   *
1897 - * NOTE: It's extremely important to not pause more than one DMA channel
1898 + * NOTE: It's extremely important to not pause more than one DMA channel
1899   *  at a time.
1900   ********************************************************************/
1901
1902 @@ -856,8 +862,6 @@ int MCD_continDma (int channel)
1903   */
1904  int MCD_pauseDma (int channel)
1905  {
1906 -    /* MCD_XferProg progRep; */
1907 -
1908      if((channel < 0) || (channel >= NCHANNELS))
1909          return(MCD_CHANNEL_INVALID);
1910
1911 @@ -866,13 +870,6 @@ int MCD_pauseDma (int channel)
1912          MCD_dmaBar->debugComp1 = channel;
1913          MCD_dmaBar->debugControl = DBG_CTL_ENABLE | (1 << (channel + 16));
1914          MCD_chStatus[channel] = MCD_PAUSED;
1915 -
1916 -        /*
1917 -         * Update the current buffer descriptor's lastDestAddr field
1918 -         *
1919 -         * MCD_XferProgrQuery (channel, &progRep);
1920 -         * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr;
1921 -         */
1922      }
1923      return(MCD_OK);
1924  }
1925 @@ -929,9 +926,9 @@ int MCD_csumQuery (int channel, u32 *csu
1926  int MCD_getCodeSize(void)
1927  {
1928  #ifdef MCD_INCLUDE_EU
1929 -    return(0x2b5c);
1930 +    return(0x2b64);
1931  #else
1932 -    return(0x173c);
1933 +    return(0x1744);
1934  #endif
1935  }
1936  /********************** End of MCD_getCodeSize() ********************/
1937 @@ -943,9 +940,9 @@ int MCD_getCodeSize(void)
1938   *                    which points to the version string
1939   * Returns:     Version number and version string (by reference)
1940   */
1941 -char MCD_versionString[] = "Multi-channel DMA API Alpha v0.3 (2004-04-26)";
1942 -#define MCD_REV_MAJOR   0x00
1943 -#define MCD_REV_MINOR   0x03
1944 +char MCD_versionString[] = "Multi-channel DMA API v1.0";
1945 +#define MCD_REV_MAJOR   0x01
1946 +#define MCD_REV_MINOR   0x00
1947
1948  int MCD_getVersion(char **longVersion)
1949  {
1950 --- a/drivers/dma/MCD_progCheck.h
1951 +++ b/drivers/dma/MCD_progCheck.h
1952 @@ -1,32 +1,27 @@
1953 -/*********************************************************************
1954 +/*
1955 + * drivers/dma/MCD_progCheck.h
1956   *
1957 - * Copyright (C) 2004  Motorola, Inc.
1958 - *  MOTOROLA, INC. All Rights Reserved.
1959 - *  You are hereby granted a copyright license to use
1960 - *  the SOFTWARE so long as this entire notice is
1961 - *  retained without alteration in any modified and/or redistributed
1962 - *  versions, and that such modified versions are clearly identified
1963 - *  as such. No licenses are granted by implication, estoppel or
1964 - *  otherwise under any patents or trademarks of Motorola, Inc. This
1965 - *  software is provided on an "AS IS" basis and without warranty.
1966 + * Copyright (C) 2004-2008 Freescale Semiconductor, Inc.
1967 + *     Kurt Mahan <kmahan@freescale.com>
1968   *
1969 - *  To the maximum extent permitted by applicable law, MOTOROLA
1970 - *  DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED, INCLUDING
1971 - *  IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR
1972 - *  PURPOSE AND ANY WARRANTY AGAINST INFRINGEMENT WITH REGARD TO THE
1973 - *  SOFTWARE (INCLUDING ANY MODIFIED VERSIONS THEREOF) AND ANY
1974 - *  ACCOMPANYING WRITTEN MATERIALS.
1975 + * This program is free software; you can redistribute it and/or
1976 + * modify it under the terms of the GNU General Public License as
1977 + * published by the Free Software Foundation; either version 2 of
1978 + * the License, or (at your option) any later version.
1979   *
1980 - *  To the maximum extent permitted by applicable law, IN NO EVENT
1981 - *  SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER (INCLUDING
1982 - *  WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS
1983 - *  INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY
1984 - *  LOSS) ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.
1985 + * This program is distributed in the hope that it will be useful,
1986 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1987 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1988 + * GNU General Public License for more details.
1989   *
1990 - *  Motorola assumes no responsibility for the maintenance and support
1991 - *  of this software
1992 - ********************************************************************/
1993 - /* This file is autogenerated. Do not change */
1994 + * You should have received a copy of the GNU General Public License
1995 + * along with this program; if not, write to the Free Software
1996 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
1997 + * MA 02111-1307 USA
1998 + */
1999 +
2000 +/* This file is autogenerated. Do not change */
2001 +
2002  #define CURRBD 4
2003  #define DCOUNT 6
2004  #define DESTPTR 5
2005 --- a/drivers/dma/MCD_tasks.c
2006 +++ b/drivers/dma/MCD_tasks.c
2007 @@ -1,44 +1,26 @@
2008 -/*********************************************************************
2009 - *
2010 - * Copyright (C) 2004  Motorola, Inc.
2011 - *  MOTOROLA, INC. All Rights Reserved.
2012 - *  You are hereby granted a copyright license to use
2013 - *  the SOFTWARE so long as this entire notice is
2014 - *  retained without alteration in any modified and/or redistributed
2015 - *  versions, and that such modified versions are clearly identified
2016 - *  as such. No licenses are granted by implication, estoppel or
2017 - *  otherwise under any patents or trademarks of Motorola, Inc. This
2018 - *  software is provided on an "AS IS" basis and without warranty.
2019 - *
2020 - *  To the maximum extent permitted by applicable law, MOTOROLA
2021 - *  DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED, INCLUDING
2022 - *  IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR
2023 - *  PURPOSE AND ANY WARRANTY AGAINST INFRINGEMENT WITH REGARD TO THE
2024 - *  SOFTWARE (INCLUDING ANY MODIFIED VERSIONS THEREOF) AND ANY
2025 - *  ACCOMPANYING WRITTEN MATERIALS.
2026 - *
2027 - *  To the maximum extent permitted by applicable law, IN NO EVENT
2028 - *  SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER (INCLUDING
2029 - *  WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS
2030 - *  INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY
2031 - *  LOSS) ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.
2032 - *
2033 - *  Motorola assumes no responsibility for the maintenance and support
2034 - *  of this software
2035 - ********************************************************************/
2036  /*
2037 - * File:        MCD_tasks.c
2038 - * Purpose:     Contains task code and structures for Multi-channel DMA
2039 - *
2040 - * Notes:
2041 + * drivers/dma/MCD_tasks.c
2042   *
2043 + * Copyright (C) 2004-2008 Freescale Semiconductor, Inc.
2044 + *     Kurt Mahan <kmahan@freescale.com>
2045   *
2046 - * Modifications:
2047 + * This program is free software; you can redistribute it and/or
2048 + * modify it under the terms of the GNU General Public License as
2049 + * published by the Free Software Foundation; either version 2 of
2050 + * the License, or (at your option) any later version.
2051   *
2052 + * This program is distributed in the hope that it will be useful,
2053 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
2054 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2055 + * GNU General Public License for more details.
2056   *
2057 + * You should have received a copy of the GNU General Public License
2058 + * along with this program; if not, write to the Free Software
2059 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
2060 + * MA 02111-1307 USA
2061   */
2062
2063 -#include <asm/MCD_dma.h>
2064 +#include "MCD_dma.h"
2065
2066  u32 MCD_varTab0[];
2067  u32 MCD_varTab1[];
2068 @@ -922,13 +904,13 @@ u32 MCD_funcDescTab0[]=
2069      0x20400000, /* add(), EU# 3 */
2070      0x20500000, /* sub(), EU# 3 */
2071      0x205a0000, /* andNot(), EU# 3 */
2072 +    0x20a00000, /* shiftR(), EU# 3 */
2073      0x202fa000, /* andReadyBit(), EU# 3 */
2074      0x202f9000, /* andNotReadyBit(), EU# 3 */
2075      0x202ea000, /* andWrapBit(), EU# 3 */
2076 -    0x202da000, /* andEndFrameBit(), EU# 3 */
2077 +    0x202da000, /* andLastBit(), EU# 3 */
2078      0x202e2000, /* andInterruptBit(), EU# 3 */
2079 -    0x202f2000, /* andLoopBit(), EU# 3 */
2080 -    0x2020a000, /* andCrcRestartBit(), EU# 3 */
2081 +    0x202f2000, /* andCrcRestartBit(), EU# 3 */
2082  };
2083
2084  #ifdef MCD_INCLUDE_EU
2085 @@ -991,13 +973,13 @@ u32 MCD_funcDescTab1[]=
2086      0x20400000, /* add(), EU# 3 */
2087      0x20500000, /* sub(), EU# 3 */
2088      0x205a0000, /* andNot(), EU# 3 */
2089 +    0x20a00000, /* shiftR(), EU# 3 */
2090      0x202fa000, /* andReadyBit(), EU# 3 */
2091      0x202f9000, /* andNotReadyBit(), EU# 3 */
2092      0x202ea000, /* andWrapBit(), EU# 3 */
2093 -    0x202da000, /* andEndFrameBit(), EU# 3 */
2094 +    0x202da000, /* andLastBit(), EU# 3 */
2095      0x202e2000, /* andInterruptBit(), EU# 3 */
2096 -    0x202f2000, /* andLoopBit(), EU# 3 */
2097 -    0x2020a000, /* andCrcRestartBit(), EU# 3 */
2098 +    0x202f2000, /* andCrcRestartBit(), EU# 3 */
2099  };
2100
2101  u32 MCD_funcDescTab2[]=
2102 @@ -1059,13 +1041,13 @@ u32 MCD_funcDescTab2[]=
2103      0x20400000, /* add(), EU# 3 */
2104      0x20500000, /* sub(), EU# 3 */
2105      0x205a0000, /* andNot(), EU# 3 */
2106 +    0x20a00000, /* shiftR(), EU# 3 */
2107      0x202fa000, /* andReadyBit(), EU# 3 */
2108      0x202f9000, /* andNotReadyBit(), EU# 3 */
2109      0x202ea000, /* andWrapBit(), EU# 3 */
2110 -    0x202da000, /* andEndFrameBit(), EU# 3 */
2111 +    0x202da000, /* andLastBit(), EU# 3 */
2112      0x202e2000, /* andInterruptBit(), EU# 3 */
2113 -    0x202f2000, /* andLoopBit(), EU# 3 */
2114 -    0x2020a000, /* andCrcRestartBit(), EU# 3 */
2115 +    0x202f2000, /* andCrcRestartBit(), EU# 3 */
2116  };
2117
2118  u32 MCD_funcDescTab3[]=
2119 @@ -1127,13 +1109,13 @@ u32 MCD_funcDescTab3[]=
2120      0x20400000, /* add(), EU# 3 */
2121      0x20500000, /* sub(), EU# 3 */
2122      0x205a0000, /* andNot(), EU# 3 */
2123 +    0x20a00000, /* shiftR(), EU# 3 */
2124      0x202fa000, /* andReadyBit(), EU# 3 */
2125      0x202f9000, /* andNotReadyBit(), EU# 3 */
2126      0x202ea000, /* andWrapBit(), EU# 3 */
2127 -    0x202da000, /* andEndFrameBit(), EU# 3 */
2128 +    0x202da000, /* andLastBit(), EU# 3 */
2129      0x202e2000, /* andInterruptBit(), EU# 3 */
2130 -    0x202f2000, /* andLoopBit(), EU# 3 */
2131 -    0x2020a000, /* andCrcRestartBit(), EU# 3 */
2132 +    0x202f2000, /* andCrcRestartBit(), EU# 3 */
2133  };
2134
2135  u32 MCD_funcDescTab4[]=
2136 @@ -1195,13 +1177,13 @@ u32 MCD_funcDescTab4[]=
2137      0x20400000, /* add(), EU# 3 */
2138      0x20500000, /* sub(), EU# 3 */
2139      0x205a0000, /* andNot(), EU# 3 */
2140 +    0x20a00000, /* shiftR(), EU# 3 */
2141      0x202fa000, /* andReadyBit(), EU# 3 */
2142      0x202f9000, /* andNotReadyBit(), EU# 3 */
2143      0x202ea000, /* andWrapBit(), EU# 3 */
2144 -    0x202da000, /* andEndFrameBit(), EU# 3 */
2145 +    0x202da000, /* andLastBit(), EU# 3 */
2146      0x202e2000, /* andInterruptBit(), EU# 3 */
2147 -    0x202f2000, /* andLoopBit(), EU# 3 */
2148 -    0x2020a000, /* andCrcRestartBit(), EU# 3 */
2149 +    0x202f2000, /* andCrcRestartBit(), EU# 3 */
2150  };
2151
2152  u32 MCD_funcDescTab5[]=
2153 @@ -1263,13 +1245,13 @@ u32 MCD_funcDescTab5[]=
2154      0x20400000, /* add(), EU# 3 */
2155      0x20500000, /* sub(), EU# 3 */
2156      0x205a0000, /* andNot(), EU# 3 */
2157 +    0x20a00000, /* shiftR(), EU# 3 */
2158      0x202fa000, /* andReadyBit(), EU# 3 */
2159      0x202f9000, /* andNotReadyBit(), EU# 3 */
2160      0x202ea000, /* andWrapBit(), EU# 3 */
2161 -    0x202da000, /* andEndFrameBit(), EU# 3 */
2162 +    0x202da000, /* andLastBit(), EU# 3 */
2163      0x202e2000, /* andInterruptBit(), EU# 3 */
2164 -    0x202f2000, /* andLoopBit(), EU# 3 */
2165 -    0x2020a000, /* andCrcRestartBit(), EU# 3 */
2166 +    0x202f2000, /* andCrcRestartBit(), EU# 3 */
2167  };
2168
2169  u32 MCD_funcDescTab6[]=
2170 @@ -1331,13 +1313,13 @@ u32 MCD_funcDescTab6[]=
2171      0x20400000, /* add(), EU# 3 */
2172      0x20500000, /* sub(), EU# 3 */
2173      0x205a0000, /* andNot(), EU# 3 */
2174 +    0x20a00000, /* shiftR(), EU# 3 */
2175      0x202fa000, /* andReadyBit(), EU# 3 */
2176      0x202f9000, /* andNotReadyBit(), EU# 3 */
2177      0x202ea000, /* andWrapBit(), EU# 3 */
2178 -    0x202da000, /* andEndFrameBit(), EU# 3 */
2179 +    0x202da000, /* andLastBit(), EU# 3 */
2180      0x202e2000, /* andInterruptBit(), EU# 3 */
2181 -    0x202f2000, /* andLoopBit(), EU# 3 */
2182 -    0x2020a000, /* andCrcRestartBit(), EU# 3 */
2183 +    0x202f2000, /* andCrcRestartBit(), EU# 3 */
2184  };
2185
2186  u32 MCD_funcDescTab7[]=
2187 @@ -1399,13 +1381,13 @@ u32 MCD_funcDescTab7[]=
2188      0x20400000, /* add(), EU# 3 */
2189      0x20500000, /* sub(), EU# 3 */
2190      0x205a0000, /* andNot(), EU# 3 */
2191 +    0x20a00000, /* shiftR(), EU# 3 */
2192      0x202fa000, /* andReadyBit(), EU# 3 */
2193      0x202f9000, /* andNotReadyBit(), EU# 3 */
2194      0x202ea000, /* andWrapBit(), EU# 3 */
2195 -    0x202da000, /* andEndFrameBit(), EU# 3 */
2196 +    0x202da000, /* andLastBit(), EU# 3 */
2197      0x202e2000, /* andInterruptBit(), EU# 3 */
2198 -    0x202f2000, /* andLoopBit(), EU# 3 */
2199 -    0x2020a000, /* andCrcRestartBit(), EU# 3 */
2200 +    0x202f2000, /* andCrcRestartBit(), EU# 3 */
2201  };
2202
2203  u32 MCD_funcDescTab8[]=
2204 @@ -1467,13 +1449,13 @@ u32 MCD_funcDescTab8[]=
2205      0x20400000, /* add(), EU# 3 */
2206      0x20500000, /* sub(), EU# 3 */
2207      0x205a0000, /* andNot(), EU# 3 */
2208 +    0x20a00000, /* shiftR(), EU# 3 */
2209      0x202fa000, /* andReadyBit(), EU# 3 */
2210      0x202f9000, /* andNotReadyBit(), EU# 3 */
2211      0x202ea000, /* andWrapBit(), EU# 3 */
2212 -    0x202da000, /* andEndFrameBit(), EU# 3 */
2213 +    0x202da000, /* andLastBit(), EU# 3 */
2214      0x202e2000, /* andInterruptBit(), EU# 3 */
2215 -    0x202f2000, /* andLoopBit(), EU# 3 */
2216 -    0x2020a000, /* andCrcRestartBit(), EU# 3 */
2217 +    0x202f2000, /* andCrcRestartBit(), EU# 3 */
2218  };
2219
2220  u32 MCD_funcDescTab9[]=
2221 @@ -1535,13 +1517,13 @@ u32 MCD_funcDescTab9[]=
2222      0x20400000, /* add(), EU# 3 */
2223      0x20500000, /* sub(), EU# 3 */
2224      0x205a0000, /* andNot(), EU# 3 */
2225 +    0x20a00000, /* shiftR(), EU# 3 */
2226      0x202fa000, /* andReadyBit(), EU# 3 */
2227      0x202f9000, /* andNotReadyBit(), EU# 3 */
2228      0x202ea000, /* andWrapBit(), EU# 3 */
2229 -    0x202da000, /* andEndFrameBit(), EU# 3 */
2230 +    0x202da000, /* andLastBit(), EU# 3 */
2231      0x202e2000, /* andInterruptBit(), EU# 3 */
2232 -    0x202f2000, /* andLoopBit(), EU# 3 */
2233 -    0x2020a000, /* andCrcRestartBit(), EU# 3 */
2234 +    0x202f2000, /* andCrcRestartBit(), EU# 3 */
2235  };
2236
2237  u32 MCD_funcDescTab10[]=
2238 @@ -1603,13 +1585,13 @@ u32 MCD_funcDescTab10[]=
2239      0x20400000, /* add(), EU# 3 */
2240      0x20500000, /* sub(), EU# 3 */
2241      0x205a0000, /* andNot(), EU# 3 */
2242 +    0x20a00000, /* shiftR(), EU# 3 */
2243      0x202fa000, /* andReadyBit(), EU# 3 */
2244      0x202f9000, /* andNotReadyBit(), EU# 3 */
2245      0x202ea000, /* andWrapBit(), EU# 3 */
2246 -    0x202da000, /* andEndFrameBit(), EU# 3 */
2247 +    0x202da000, /* andLastBit(), EU# 3 */
2248      0x202e2000, /* andInterruptBit(), EU# 3 */
2249 -    0x202f2000, /* andLoopBit(), EU# 3 */
2250 -    0x2020a000, /* andCrcRestartBit(), EU# 3 */
2251 +    0x202f2000, /* andCrcRestartBit(), EU# 3 */
2252  };
2253
2254  u32 MCD_funcDescTab11[]=
2255 @@ -1671,13 +1653,13 @@ u32 MCD_funcDescTab11[]=
2256      0x20400000, /* add(), EU# 3 */
2257      0x20500000, /* sub(), EU# 3 */
2258      0x205a0000, /* andNot(), EU# 3 */
2259 +    0x20a00000, /* shiftR(), EU# 3 */
2260      0x202fa000, /* andReadyBit(), EU# 3 */
2261      0x202f9000, /* andNotReadyBit(), EU# 3 */
2262      0x202ea000, /* andWrapBit(), EU# 3 */
2263 -    0x202da000, /* andEndFrameBit(), EU# 3 */
2264 +    0x202da000, /* andLastBit(), EU# 3 */
2265      0x202e2000, /* andInterruptBit(), EU# 3 */
2266 -    0x202f2000, /* andLoopBit(), EU# 3 */
2267 -    0x2020a000, /* andCrcRestartBit(), EU# 3 */
2268 +    0x202f2000, /* andCrcRestartBit(), EU# 3 */
2269  };
2270
2271  u32 MCD_funcDescTab12[]=
2272 @@ -1739,13 +1721,13 @@ u32 MCD_funcDescTab12[]=
2273      0x20400000, /* add(), EU# 3 */
2274      0x20500000, /* sub(), EU# 3 */
2275      0x205a0000, /* andNot(), EU# 3 */
2276 +    0x20a00000, /* shiftR(), EU# 3 */
2277      0x202fa000, /* andReadyBit(), EU# 3 */
2278      0x202f9000, /* andNotReadyBit(), EU# 3 */
2279      0x202ea000, /* andWrapBit(), EU# 3 */
2280 -    0x202da000, /* andEndFrameBit(), EU# 3 */
2281 +    0x202da000, /* andLastBit(), EU# 3 */
2282      0x202e2000, /* andInterruptBit(), EU# 3 */
2283 -    0x202f2000, /* andLoopBit(), EU# 3 */
2284 -    0x2020a000, /* andCrcRestartBit(), EU# 3 */
2285 +    0x202f2000, /* andCrcRestartBit(), EU# 3 */
2286  };
2287
2288  u32 MCD_funcDescTab13[]=
2289 @@ -1807,13 +1789,13 @@ u32 MCD_funcDescTab13[]=
2290      0x20400000, /* add(), EU# 3 */
2291      0x20500000, /* sub(), EU# 3 */
2292      0x205a0000, /* andNot(), EU# 3 */
2293 +    0x20a00000, /* shiftR(), EU# 3 */
2294      0x202fa000, /* andReadyBit(), EU# 3 */
2295      0x202f9000, /* andNotReadyBit(), EU# 3 */
2296      0x202ea000, /* andWrapBit(), EU# 3 */
2297 -    0x202da000, /* andEndFrameBit(), EU# 3 */
2298 +    0x202da000, /* andLastBit(), EU# 3 */
2299      0x202e2000, /* andInterruptBit(), EU# 3 */
2300 -    0x202f2000, /* andLoopBit(), EU# 3 */
2301 -    0x2020a000, /* andCrcRestartBit(), EU# 3 */
2302 +    0x202f2000, /* andCrcRestartBit(), EU# 3 */
2303  };
2304
2305  u32 MCD_funcDescTab14[]=
2306 @@ -1875,13 +1857,13 @@ u32 MCD_funcDescTab14[]=
2307      0x20400000, /* add(), EU# 3 */
2308      0x20500000, /* sub(), EU# 3 */
2309      0x205a0000, /* andNot(), EU# 3 */
2310 +    0x20a00000, /* shiftR(), EU# 3 */
2311      0x202fa000, /* andReadyBit(), EU# 3 */
2312      0x202f9000, /* andNotReadyBit(), EU# 3 */
2313      0x202ea000, /* andWrapBit(), EU# 3 */
2314 -    0x202da000, /* andEndFrameBit(), EU# 3 */
2315 +    0x202da000, /* andLastBit(), EU# 3 */
2316      0x202e2000, /* andInterruptBit(), EU# 3 */
2317 -    0x202f2000, /* andLoopBit(), EU# 3 */
2318 -    0x2020a000, /* andCrcRestartBit(), EU# 3 */
2319 +    0x202f2000, /* andCrcRestartBit(), EU# 3 */
2320  };
2321
2322  u32 MCD_funcDescTab15[]=
2323 @@ -1943,13 +1925,13 @@ u32 MCD_funcDescTab15[]=
2324      0x20400000, /* add(), EU# 3 */
2325      0x20500000, /* sub(), EU# 3 */
2326      0x205a0000, /* andNot(), EU# 3 */
2327 +    0x20a00000, /* shiftR(), EU# 3 */
2328      0x202fa000, /* andReadyBit(), EU# 3 */
2329      0x202f9000, /* andNotReadyBit(), EU# 3 */
2330      0x202ea000, /* andWrapBit(), EU# 3 */
2331 -    0x202da000, /* andEndFrameBit(), EU# 3 */
2332 +    0x202da000, /* andLastBit(), EU# 3 */
2333      0x202e2000, /* andInterruptBit(), EU# 3 */
2334 -    0x202f2000, /* andLoopBit(), EU# 3 */
2335 -    0x2020a000, /* andCrcRestartBit(), EU# 3 */
2336 +    0x202f2000, /* andCrcRestartBit(), EU# 3 */
2337  };
2338  #endif /*MCD_INCLUDE_EU*/
2339
2340 @@ -1970,7 +1952,6 @@ u32 MCD_contextSave13[128]; /* Task 13 c
2341  u32 MCD_contextSave14[128]; /* Task 14 context save space */
2342  u32 MCD_contextSave15[128]; /* Task 15 context save space */
2343
2344 -/* Task Descriptor Tables - the guts */
2345  u32 MCD_ChainNoEu_TDT[];
2346  u32 MCD_SingleNoEu_TDT[];
2347  #ifdef MCD_INCLUDE_EU
2348 @@ -1983,7 +1964,7 @@ u32 MCD_ENetXmit_TDT[];
2349  u32 MCD_modelTaskTableSrc[]=
2350  {
2351      (u32)MCD_ChainNoEu_TDT,
2352 -    (u32)&((u8*)MCD_ChainNoEu_TDT)[0x00000178],
2353 +    (u32)&((u8*)MCD_ChainNoEu_TDT)[0x0000016c],
2354      0x00000000,
2355      0x00000000,
2356      0x00000000,
2357 @@ -2000,7 +1981,7 @@ u32 MCD_modelTaskTableSrc[]=
2358      0x00000000,
2359  #ifdef MCD_INCLUDE_EU
2360      (u32)MCD_ChainEu_TDT,
2361 -    (u32)&((u8*)MCD_ChainEu_TDT)[0x00000180],
2362 +    (u32)&((u8*)MCD_ChainEu_TDT)[0x000001b4],
2363      0x00000000,
2364      0x00000000,
2365      0x00000000,
2366 @@ -2008,7 +1989,7 @@ u32 MCD_modelTaskTableSrc[]=
2367      0x00000000,
2368      0x00000000,
2369      (u32)MCD_SingleEu_TDT,
2370 -    (u32)&((u8*)MCD_SingleEu_TDT)[0x000000dc],
2371 +    (u32)&((u8*)MCD_SingleEu_TDT)[0x00000124],
2372      0x00000000,
2373      0x00000000,
2374      0x00000000,
2375 @@ -2017,7 +1998,7 @@ u32 MCD_modelTaskTableSrc[]=
2376      0x00000000,
2377  #endif
2378      (u32)MCD_ENetRcv_TDT,
2379 -    (u32)&((u8*)MCD_ENetRcv_TDT)[0x0000009C],
2380 +    (u32)&((u8*)MCD_ENetRcv_TDT)[0x000000a4],
2381      0x00000000,
2382      0x00000000,
2383      0x00000000,
2384 @@ -2033,420 +2014,452 @@ u32 MCD_modelTaskTableSrc[]=
2385      0x00000000,
2386      0x00000000,
2387  };
2388 -
2389  u32 MCD_ChainNoEu_TDT[]=
2390  {
2391      0x80004000, /* 0000(:370):  LCDEXT: idx0 = 0x00000000; ; */
2392      0x8118801b, /* 0004(:370):  LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */
2393 -    0xb8ca0018, /* 0008(:371):    LCD: idx2 = *(idx1 + var20); idx2 once var0; idx2 += inc3 */
2394 -    0x10004b10, /* 000C(:372):      DRD1A: var18 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2395 -    0x7000000c, /* 0010(:373):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT MORE init=0 WS=0 RS=0 */
2396 -    0x024cf89f, /* 0014(:373):      DRD2B1: var9 = EU3(); EU3(idx2)  */
2397 -    0x60000009, /* 0018(:374):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=9 EXT init=0 WS=0 RS=0 */
2398 +    0xb8c60018, /* 0008(:371):    LCD: idx2 = *(idx1 + var12); idx2 once var0; idx2 += inc3 */
2399 +    0x10002b10, /* 000C(:372):      DRD1A: var10 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2400 +    0x7000000d, /* 0010(:373):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
2401 +    0x018cf89f, /* 0014(:373):      DRD2B1: var6 = EU3(); EU3(idx2)  */
2402 +    0x6000000a, /* 0018(:374):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */
2403      0x080cf89f, /* 001C(:374):      DRD2B1: idx0 = EU3(); EU3(idx2)  */
2404      0x000001f8, /* 0020(:0):    NOP */
2405 -    0x98180524, /* 0024(:378):  LCD: idx0 = idx0; idx0 != var20; idx0 += inc4 */
2406 +    0x98180364, /* 0024(:378):  LCD: idx0 = idx0; idx0 == var13; idx0 += inc4 */
2407      0x8118801b, /* 0028(:380):    LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */
2408 -    0xf8ca001a, /* 002C(:381):      LCDEXT: idx2 = *(idx1 + var20 + 8); idx2 once var0; idx2 += inc3 */
2409 -    0xb8ca601b, /* 0030(:382):      LCD: idx3 = *(idx1 + var20 + 12); ; idx3 += inc3 */
2410 -    0x10004310, /* 0034(:384):        DRD1A: var16 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2411 -    0x00001718, /* 0038(:385):        DRD1A: var5 = idx3; FN=0 init=0 WS=0 RS=0 */
2412 -    0xb8ca001d, /* 003C(:387):      LCD: idx2 = *(idx1 + var20 + 20); idx2 once var0; idx2 += inc3 */
2413 -    0x10001f10, /* 0040(:388):        DRD1A: var7 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2414 +    0xf8c6001a, /* 002C(:381):      LCDEXT: idx2 = *(idx1 + var12 + 8); idx2 once var0; idx2 += inc3 */
2415 +    0xb8c6601b, /* 0030(:382):      LCD: idx3 = *(idx1 + var12 + 12); ; idx3 += inc3 */
2416 +    0x10002710, /* 0034(:384):        DRD1A: var9 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2417 +    0x00000f18, /* 0038(:385):        DRD1A: var3 = idx3; FN=0 init=0 WS=0 RS=0 */
2418 +    0xb8c6001d, /* 003C(:387):      LCD: idx2 = *(idx1 + var12 + 20); idx2 once var0; idx2 += inc3 */
2419 +    0x10001310, /* 0040(:388):        DRD1A: var4 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2420      0x60000007, /* 0044(:389):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=7 EXT init=0 WS=0 RS=0 */
2421 -    0x020cf893, /* 0048(:389):        DRD2B1: var8 = EU3(); EU3(idx2,var19)  */
2422 -    0x98ca001c, /* 004C(:391):      LCD: idx2 = idx1 + var20 + 4; idx2 once var0; idx2 += inc3 */
2423 +    0x014cf88b, /* 0048(:389):        DRD2B1: var5 = EU3(); EU3(idx2,var11)  */
2424 +    0x98c6001c, /* 004C(:391):      LCD: idx2 = idx1 + var12 + 4; idx2 once var0; idx2 += inc3 */
2425      0x00000710, /* 0050(:392):        DRD1A: var1 = idx2; FN=0 init=0 WS=0 RS=0 */
2426 -    0x98ca8018, /* 0054(:393):      LCD: idx2 = idx1 + var21; idx2 once var0; idx2 += inc3 */
2427 -    0x10002b10, /* 0058(:394):        DRD1A: var10 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2428 -    0x0000c828, /* 005C(:395):        DRD1A: *idx2 = var5; FN=0 init=0 WS=0 RS=0 */
2429 +    0x98c70018, /* 0054(:393):      LCD: idx2 = idx1 + var14; idx2 once var0; idx2 += inc3 */
2430 +    0x10001f10, /* 0058(:394):        DRD1A: var7 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2431 +    0x0000c818, /* 005C(:395):        DRD1A: *idx2 = var3; FN=0 init=0 WS=0 RS=0 */
2432      0x000001f8, /* 0060(:0):      NOP */
2433 -    0xc14ae018, /* 0064(:399):    LCDEXT: idx1 = var2 + var21; ; idx1 += inc3 */
2434 -    0xc004a51d, /* 0068(:399):    LCDEXT: idx2 = var0, idx3 = var9; idx3 == var20; idx2 += inc3, idx3 += inc5 */
2435 +    0xc1476018, /* 0064(:399):    LCDEXT: idx1 = var2 + var14; ; idx1 += inc3 */
2436 +    0xc003231d, /* 0068(:399):    LCDEXT: idx2 = var0, idx3 = var6; idx3 == var12; idx2 += inc3, idx3 += inc5 */
2437      0x811a601b, /* 006C(:400):    LCD: idx4 = var2; ; idx4 += inc3 */
2438 -    0xc28a21c2, /* 0070(:403):      LCDEXT: idx5 = var5, idx6 = var20; idx6 < var7; idx5 += inc0, idx6 += inc2 */
2439 -    0x881be009, /* 0074(:403):      LCD: idx7 = var16; ; idx7 += inc1 */
2440 +    0xc1862102, /* 0070(:403):      LCDEXT: idx5 = var3, idx6 = var12; idx6 < var4; idx5 += inc0, idx6 += inc2 */
2441 +    0x849be009, /* 0074(:403):      LCD: idx7 = var9; ; idx7 += inc1 */
2442      0x03fed7b8, /* 0078(:406):        DRD1A: *idx7; FN=0 init=31 WS=3 RS=3 */
2443      0xda9b001b, /* 007C(:408):      LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2444      0x9b9be01b, /* 0080(:408):      LCD: idx7 = idx7; ; idx7 += inc3 */
2445      0x1000cb20, /* 0084(:409):        DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */
2446      0x70000006, /* 0088(:410):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2447 -    0x088cf896, /* 008C(:410):        DRD2B1: idx2 = EU3(); EU3(idx2,var22)  */
2448 +    0x088cf88f, /* 008C(:410):        DRD2B1: idx2 = EU3(); EU3(idx2,var15)  */
2449      0x1000cb28, /* 0090(:411):        DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
2450      0x70000006, /* 0094(:412):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2451 -    0x088cf896, /* 0098(:412):        DRD2B1: idx2 = EU3(); EU3(idx2,var22)  */
2452 +    0x088cf88f, /* 0098(:412):        DRD2B1: idx2 = EU3(); EU3(idx2,var15)  */
2453      0x1000cb30, /* 009C(:413):        DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
2454      0x70000006, /* 00A0(:414):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2455 -    0x088cf896, /* 00A4(:414):        DRD2B1: idx2 = EU3(); EU3(idx2,var22)  */
2456 +    0x088cf88f, /* 00A4(:414):        DRD2B1: idx2 = EU3(); EU3(idx2,var15)  */
2457      0x1000cb38, /* 00A8(:415):        DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */
2458      0x0000c728, /* 00AC(:416):        DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */
2459      0x000001f8, /* 00B0(:0):      NOP */
2460 -    0xc14ae018, /* 00B4(:420):    LCDEXT: idx1 = var2 + var21; ; idx1 += inc3 */
2461 -    0xc004a5dd, /* 00B8(:420):    LCDEXT: idx2 = var0, idx3 = var9; idx3 == var23; idx2 += inc3, idx3 += inc5 */
2462 +    0xc1476018, /* 00B4(:420):    LCDEXT: idx1 = var2 + var14; ; idx1 += inc3 */
2463 +    0xc003241d, /* 00B8(:420):    LCDEXT: idx2 = var0, idx3 = var6; idx3 == var16; idx2 += inc3, idx3 += inc5 */
2464      0x811a601b, /* 00BC(:421):    LCD: idx4 = var2; ; idx4 += inc3 */
2465      0xda9b001b, /* 00C0(:424):      LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2466      0x9b9be01b, /* 00C4(:424):      LCD: idx7 = idx7; ; idx7 += inc3 */
2467      0x0000d3a0, /* 00C8(:425):        DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */
2468 -    0xc28a21c2, /* 00CC(:427):      LCDEXT: idx5 = var5, idx6 = var20; idx6 < var7; idx5 += inc0, idx6 += inc2 */
2469 -    0x881be009, /* 00D0(:427):      LCD: idx7 = var16; ; idx7 += inc1 */
2470 +    0xc1862102, /* 00CC(:427):      LCDEXT: idx5 = var3, idx6 = var12; idx6 < var4; idx5 += inc0, idx6 += inc2 */
2471 +    0x849be009, /* 00D0(:427):      LCD: idx7 = var9; ; idx7 += inc1 */
2472      0x0bfed7b8, /* 00D4(:430):        DRD1A: *idx7; FN=0 TFD init=31 WS=3 RS=3 */
2473      0xda9b001b, /* 00D8(:432):      LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2474      0x9b9be01b, /* 00DC(:432):      LCD: idx7 = idx7; ; idx7 += inc3 */
2475      0x1000cb20, /* 00E0(:433):        DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */
2476      0x70000006, /* 00E4(:434):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2477 -    0x088cf896, /* 00E8(:434):        DRD2B1: idx2 = EU3(); EU3(idx2,var22)  */
2478 +    0x088cf88f, /* 00E8(:434):        DRD2B1: idx2 = EU3(); EU3(idx2,var15)  */
2479      0x1000cb28, /* 00EC(:435):        DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
2480      0x70000006, /* 00F0(:436):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2481 -    0x088cf896, /* 00F4(:436):        DRD2B1: idx2 = EU3(); EU3(idx2,var22)  */
2482 +    0x088cf88f, /* 00F4(:436):        DRD2B1: idx2 = EU3(); EU3(idx2,var15)  */
2483      0x1000cb30, /* 00F8(:437):        DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
2484      0x70000006, /* 00FC(:438):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2485 -    0x088cf896, /* 0100(:438):        DRD2B1: idx2 = EU3(); EU3(idx2,var22)  */
2486 +    0x088cf88f, /* 0100(:438):        DRD2B1: idx2 = EU3(); EU3(idx2,var15)  */
2487      0x1000cb38, /* 0104(:439):        DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */
2488      0x0000c728, /* 0108(:440):        DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */
2489      0x000001f8, /* 010C(:0):      NOP */
2490      0x8118801b, /* 0110(:444):    LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */
2491 -    0x8a19001b, /* 0114(:446):      LCD: idx2 = var20; idx2 once var0; idx2 += inc3 */
2492 -    0x6000000e, /* 0118(:447):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */
2493 -    0x088cf49f, /* 011C(:447):        DRD2B1: idx2 = EU3(); EU3(var18)  */
2494 -    0xd9190536, /* 0120(:448):      LCDEXT: idx2 = idx2; idx2 == var20; idx2 += inc6 */
2495 -    0x98ca0018, /* 0124(:448):      LCD: idx3 = idx1 + var20; idx3 once var0; idx3 += inc3 */
2496 -    0x6000000a, /* 0128(:450):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */
2497 -    0x0cccfcdf, /* 012C(:450):        DRD2B1: *idx3 = EU3(); EU3(*idx3)  */
2498 -    0x000001f8, /* 0130(:0):      NOP */
2499 -    0xa14a001e, /* 0134(:453):    LCD: idx1 = *(var2 + var20 + 24); idx1 once var0; idx1 += inc3 */
2500 -    0x10000b08, /* 0138(:454):      DRD1A: var2 = idx1; FN=0 MORE init=0 WS=0 RS=0 */
2501 -    0x10002c90, /* 013C(:455):      DRD1A: var11 = var18; FN=0 MORE init=0 WS=0 RS=0 */
2502 -    0xb8ca0018, /* 0140(:456):      LCD: idx2 = *(idx1 + var20); idx2 once var0; idx2 += inc3 */
2503 -    0x10004b10, /* 0144(:457):        DRD1A: var18 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2504 -    0x70000009, /* 0148(:458):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=9 EXT MORE init=0 WS=0 RS=0 */
2505 -    0x080cf89f, /* 014C(:458):        DRD2B1: idx0 = EU3(); EU3(idx2)  */
2506 -    0x6000000c, /* 0150(:459):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT init=0 WS=0 RS=0 */
2507 -    0x024cf89f, /* 0154(:459):        DRD2B1: var9 = EU3(); EU3(idx2)  */
2508 -    0x000001f8, /* 0158(:0):      NOP */
2509 -    0x8a18801b, /* 015C(:465):    LCD: idx1 = var20; idx1 once var0; idx1 += inc3 */
2510 -    0x7000000d, /* 0160(:466):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
2511 -    0x084cf2df, /* 0164(:466):      DRD2B1: idx1 = EU3(); EU3(var11)  */
2512 -    0xd899053f, /* 0168(:467):      LCDEXT: idx2 = idx1; idx2 > var20; idx2 += inc7 */
2513 -    0x8019801b, /* 016C(:467):      LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */
2514 -    0x040001f8, /* 0170(:468):        DRD1A: FN=0 INT init=0 WS=0 RS=0 */
2515 -    0x000001f8, /* 0174(:0):      NOP */
2516 -    0x000001f8, /* 0178(:0):    NOP */
2517 +    0xd8c60018, /* 0114(:446):      LCDEXT: idx2 = idx1 + var12; idx2 once var0; idx2 += inc3 */
2518 +    0x98c6601c, /* 0118(:446):      LCD: idx3 = idx1 + var12 + 4; ; idx3 += inc3 */
2519 +    0x6000000b, /* 011C(:447):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=11 EXT init=0 WS=0 RS=0 */
2520 +    0x0c8cfc9f, /* 0120(:447):        DRD2B1: *idx2 = EU3(); EU3(*idx2)  */
2521 +    0x000001f8, /* 0124(:0):      NOP */
2522 +    0xa146001e, /* 0128(:450):    LCD: idx1 = *(var2 + var12 + 24); idx1 once var0; idx1 += inc3 */
2523 +    0x10000b08, /* 012C(:451):      DRD1A: var2 = idx1; FN=0 MORE init=0 WS=0 RS=0 */
2524 +    0x10002050, /* 0130(:452):      DRD1A: var8 = var10; FN=0 MORE init=0 WS=0 RS=0 */
2525 +    0xb8c60018, /* 0134(:453):      LCD: idx2 = *(idx1 + var12); idx2 once var0; idx2 += inc3 */
2526 +    0x10002b10, /* 0138(:454):        DRD1A: var10 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2527 +    0x7000000a, /* 013C(:455):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT MORE init=0 WS=0 RS=0 */
2528 +    0x080cf89f, /* 0140(:455):        DRD2B1: idx0 = EU3(); EU3(idx2)  */
2529 +    0x6000000d, /* 0144(:456):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT init=0 WS=0 RS=0 */
2530 +    0x018cf89f, /* 0148(:456):        DRD2B1: var6 = EU3(); EU3(idx2)  */
2531 +    0x000001f8, /* 014C(:0):      NOP */
2532 +    0x8618801b, /* 0150(:462):    LCD: idx1 = var12; idx1 once var0; idx1 += inc3 */
2533 +    0x7000000e, /* 0154(:463):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */
2534 +    0x084cf21f, /* 0158(:463):      DRD2B1: idx1 = EU3(); EU3(var8)  */
2535 +    0xd8990336, /* 015C(:464):      LCDEXT: idx2 = idx1; idx2 > var12; idx2 += inc6 */
2536 +    0x8019801b, /* 0160(:464):      LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */
2537 +    0x040001f8, /* 0164(:465):        DRD1A: FN=0 INT init=0 WS=0 RS=0 */
2538 +    0x000001f8, /* 0168(:0):      NOP */
2539 +    0x000001f8, /* 016C(:0):    NOP */
2540  };
2541  u32 MCD_SingleNoEu_TDT[]=
2542  {
2543 -    0x8318001b, /* 0000(:646):  LCD: idx0 = var6; idx0 once var0; idx0 += inc3 */
2544 -    0x7000000c, /* 0004(:647):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT MORE init=0 WS=0 RS=0 */
2545 -    0x080cf81f, /* 0008(:647):    DRD2B1: idx0 = EU3(); EU3(idx0)  */
2546 -    0x8318801b, /* 000C(:648):    LCD: idx1 = var6; idx1 once var0; idx1 += inc3 */
2547 -    0x6000000d, /* 0010(:649):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT init=0 WS=0 RS=0 */
2548 -    0x084cf85f, /* 0014(:649):      DRD2B1: idx1 = EU3(); EU3(idx1)  */
2549 +    0x8198001b, /* 0000(:657):  LCD: idx0 = var3; idx0 once var0; idx0 += inc3 */
2550 +    0x7000000d, /* 0004(:658):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
2551 +    0x080cf81f, /* 0008(:658):    DRD2B1: idx0 = EU3(); EU3(idx0)  */
2552 +    0x8198801b, /* 000C(:659):    LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */
2553 +    0x6000000e, /* 0010(:660):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */
2554 +    0x084cf85f, /* 0014(:660):      DRD2B1: idx1 = EU3(); EU3(idx1)  */
2555      0x000001f8, /* 0018(:0):    NOP */
2556 -    0x8498001b, /* 001C(:653):  LCD: idx0 = var9; idx0 once var0; idx0 += inc3 */
2557 -    0x7000000c, /* 0020(:654):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT MORE init=0 WS=0 RS=0 */
2558 -    0x020cf81f, /* 0024(:654):    DRD2B1: var8 = EU3(); EU3(idx0)  */
2559 -    0x6000000d, /* 0028(:655):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT init=0 WS=0 RS=0 */
2560 -    0x028cf81f, /* 002C(:655):    DRD2B1: var10 = EU3(); EU3(idx0)  */
2561 -    0xc404601b, /* 0030(:658):  LCDEXT: idx0 = var8, idx1 = var8; ; idx0 += inc3, idx1 += inc3 */
2562 -    0xc00423dc, /* 0034(:658):  LCDEXT: idx2 = var0, idx3 = var8; idx3 == var15; idx2 += inc3, idx3 += inc4 */
2563 -    0x809a601b, /* 0038(:659):  LCD: idx4 = var1; ; idx4 += inc3 */
2564 -    0xc207a182, /* 003C(:662):    LCDEXT: idx5 = var4, idx6 = var15; idx6 < var6; idx5 += inc0, idx6 += inc2 */
2565 -    0x869be009, /* 0040(:662):    LCD: idx7 = var13; ; idx7 += inc1 */
2566 -    0x03fed7b8, /* 0044(:665):      DRD1A: *idx7; FN=0 init=31 WS=3 RS=3 */
2567 -    0xda9b001b, /* 0048(:667):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2568 -    0x9b9be01b, /* 004C(:667):    LCD: idx7 = idx7; ; idx7 += inc3 */
2569 -    0x70000006, /* 0050(:669):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2570 -    0x088cf890, /* 0054(:669):      DRD2B1: idx2 = EU3(); EU3(idx2,var16)  */
2571 -    0x1000cb28, /* 0058(:670):      DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
2572 -    0x70000006, /* 005C(:671):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2573 -    0x088cf890, /* 0060(:671):      DRD2B1: idx2 = EU3(); EU3(idx2,var16)  */
2574 -    0x1000cb30, /* 0064(:672):      DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
2575 -    0x70000006, /* 0068(:673):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2576 -    0x088cf890, /* 006C(:673):      DRD2B1: idx2 = EU3(); EU3(idx2,var16)  */
2577 -    0x0000cb38, /* 0070(:674):      DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */
2578 +    0x8298001b, /* 001C(:664):  LCD: idx0 = var5; idx0 once var0; idx0 += inc3 */
2579 +    0x7000000d, /* 0020(:665):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
2580 +    0x010cf81f, /* 0024(:665):    DRD2B1: var4 = EU3(); EU3(idx0)  */
2581 +    0x6000000e, /* 0028(:666):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */
2582 +    0x018cf81f, /* 002C(:666):    DRD2B1: var6 = EU3(); EU3(idx0)  */
2583 +    0xc202601b, /* 0030(:669):  LCDEXT: idx0 = var4, idx1 = var4; ; idx0 += inc3, idx1 += inc3 */
2584 +    0xc002221c, /* 0034(:669):  LCDEXT: idx2 = var0, idx3 = var4; idx3 == var8; idx2 += inc3, idx3 += inc4 */
2585 +    0x809a601b, /* 0038(:670):  LCD: idx4 = var1; ; idx4 += inc3 */
2586 +    0xc10420c2, /* 003C(:673):    LCDEXT: idx5 = var2, idx6 = var8; idx6 < var3; idx5 += inc0, idx6 += inc2 */
2587 +    0x839be009, /* 0040(:673):    LCD: idx7 = var7; ; idx7 += inc1 */
2588 +    0x03fed7b8, /* 0044(:676):      DRD1A: *idx7; FN=0 init=31 WS=3 RS=3 */
2589 +    0xda9b001b, /* 0048(:678):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2590 +    0x9b9be01b, /* 004C(:678):    LCD: idx7 = idx7; ; idx7 += inc3 */
2591 +    0x70000006, /* 0050(:680):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2592 +    0x088cf889, /* 0054(:680):      DRD2B1: idx2 = EU3(); EU3(idx2,var9)  */
2593 +    0x1000cb28, /* 0058(:681):      DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
2594 +    0x70000006, /* 005C(:682):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2595 +    0x088cf889, /* 0060(:682):      DRD2B1: idx2 = EU3(); EU3(idx2,var9)  */
2596 +    0x1000cb30, /* 0064(:683):      DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
2597 +    0x70000006, /* 0068(:684):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2598 +    0x088cf889, /* 006C(:684):      DRD2B1: idx2 = EU3(); EU3(idx2,var9)  */
2599 +    0x0000cb38, /* 0070(:685):      DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */
2600      0x000001f8, /* 0074(:0):    NOP */
2601 -    0xc404601b, /* 0078(:678):  LCDEXT: idx0 = var8, idx1 = var8; ; idx0 += inc3, idx1 += inc3 */
2602 -    0xc004245c, /* 007C(:678):  LCDEXT: idx2 = var0, idx3 = var8; idx3 == var17; idx2 += inc3, idx3 += inc4 */
2603 -    0x809a601b, /* 0080(:679):  LCD: idx4 = var1; ; idx4 += inc3 */
2604 -    0xda9b001b, /* 0084(:682):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2605 -    0x9b9be01b, /* 0088(:682):    LCD: idx7 = idx7; ; idx7 += inc3 */
2606 -    0x0000d3a0, /* 008C(:683):      DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */
2607 -    0xc207a182, /* 0090(:685):    LCDEXT: idx5 = var4, idx6 = var15; idx6 < var6; idx5 += inc0, idx6 += inc2 */
2608 -    0x869be009, /* 0094(:685):    LCD: idx7 = var13; ; idx7 += inc1 */
2609 -    0x0bfed7b8, /* 0098(:688):      DRD1A: *idx7; FN=0 TFD init=31 WS=3 RS=3 */
2610 -    0xda9b001b, /* 009C(:690):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2611 -    0x9b9be01b, /* 00A0(:690):    LCD: idx7 = idx7; ; idx7 += inc3 */
2612 -    0x70000006, /* 00A4(:692):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2613 -    0x088cf890, /* 00A8(:692):      DRD2B1: idx2 = EU3(); EU3(idx2,var16)  */
2614 -    0x1000cb28, /* 00AC(:693):      DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
2615 -    0x70000006, /* 00B0(:694):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2616 -    0x088cf890, /* 00B4(:694):      DRD2B1: idx2 = EU3(); EU3(idx2,var16)  */
2617 -    0x1000cb30, /* 00B8(:695):      DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
2618 -    0x70000006, /* 00BC(:696):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2619 -    0x088cf890, /* 00C0(:696):      DRD2B1: idx2 = EU3(); EU3(idx2,var16)  */
2620 -    0x0000cb38, /* 00C4(:697):      DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */
2621 +    0xc202601b, /* 0078(:689):  LCDEXT: idx0 = var4, idx1 = var4; ; idx0 += inc3, idx1 += inc3 */
2622 +    0xc002229c, /* 007C(:689):  LCDEXT: idx2 = var0, idx3 = var4; idx3 == var10; idx2 += inc3, idx3 += inc4 */
2623 +    0x809a601b, /* 0080(:690):  LCD: idx4 = var1; ; idx4 += inc3 */
2624 +    0xda9b001b, /* 0084(:693):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2625 +    0x9b9be01b, /* 0088(:693):    LCD: idx7 = idx7; ; idx7 += inc3 */
2626 +    0x0000d3a0, /* 008C(:694):      DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */
2627 +    0xc10420c2, /* 0090(:696):    LCDEXT: idx5 = var2, idx6 = var8; idx6 < var3; idx5 += inc0, idx6 += inc2 */
2628 +    0x839be009, /* 0094(:696):    LCD: idx7 = var7; ; idx7 += inc1 */
2629 +    0x0bfed7b8, /* 0098(:699):      DRD1A: *idx7; FN=0 TFD init=31 WS=3 RS=3 */
2630 +    0xda9b001b, /* 009C(:701):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2631 +    0x9b9be01b, /* 00A0(:701):    LCD: idx7 = idx7; ; idx7 += inc3 */
2632 +    0x70000006, /* 00A4(:703):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2633 +    0x088cf889, /* 00A8(:703):      DRD2B1: idx2 = EU3(); EU3(idx2,var9)  */
2634 +    0x1000cb28, /* 00AC(:704):      DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
2635 +    0x70000006, /* 00B0(:705):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2636 +    0x088cf889, /* 00B4(:705):      DRD2B1: idx2 = EU3(); EU3(idx2,var9)  */
2637 +    0x1000cb30, /* 00B8(:706):      DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
2638 +    0x70000006, /* 00BC(:707):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2639 +    0x088cf889, /* 00C0(:707):      DRD2B1: idx2 = EU3(); EU3(idx2,var9)  */
2640 +    0x0000cb38, /* 00C4(:708):      DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */
2641      0x000001f8, /* 00C8(:0):    NOP */
2642 -    0xc51803ed, /* 00CC(:701):  LCDEXT: idx0 = var10; idx0 > var15; idx0 += inc5 */
2643 -    0x8018801b, /* 00D0(:701):  LCD: idx1 = var0; idx1 once var0; idx1 += inc3 */
2644 -    0x040001f8, /* 00D4(:702):    DRD1A: FN=0 INT init=0 WS=0 RS=0 */
2645 +    0xc318022d, /* 00CC(:712):  LCDEXT: idx0 = var6; idx0 > var8; idx0 += inc5 */
2646 +    0x8018801b, /* 00D0(:712):  LCD: idx1 = var0; idx1 once var0; idx1 += inc3 */
2647 +    0x040001f8, /* 00D4(:713):    DRD1A: FN=0 INT init=0 WS=0 RS=0 */
2648  };
2649  #ifdef MCD_INCLUDE_EU
2650  u32 MCD_ChainEu_TDT[]=
2651  {
2652 -    0x80004000, /* 0000(:928):  LCDEXT: idx0 = 0x00000000; ; */
2653 -    0x8118801b, /* 0004(:928):  LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */
2654 -    0xb8ca0018, /* 0008(:929):    LCD: idx2 = *(idx1 + var20); idx2 once var0; idx2 += inc3 */
2655 -    0x10004b10, /* 000C(:930):      DRD1A: var18 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2656 -    0x7000000c, /* 0010(:931):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT MORE init=0 WS=0 RS=0 */
2657 -    0x024cf89f, /* 0014(:931):      DRD2B1: var9 = EU3(); EU3(idx2)  */
2658 -    0x60000009, /* 0018(:932):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=9 EXT init=0 WS=0 RS=0 */
2659 -    0x080cf89f, /* 001C(:932):      DRD2B1: idx0 = EU3(); EU3(idx2)  */
2660 +    0x80004000, /* 0000(:947):  LCDEXT: idx0 = 0x00000000; ; */
2661 +    0x8198801b, /* 0004(:947):  LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */
2662 +    0xb8c68018, /* 0008(:948):    LCD: idx2 = *(idx1 + var13); idx2 once var0; idx2 += inc3 */
2663 +    0x10002f10, /* 000C(:949):      DRD1A: var11 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2664 +    0x7000000d, /* 0010(:950):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
2665 +    0x01ccf89f, /* 0014(:950):      DRD2B1: var7 = EU3(); EU3(idx2)  */
2666 +    0x6000000a, /* 0018(:951):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */
2667 +    0x080cf89f, /* 001C(:951):      DRD2B1: idx0 = EU3(); EU3(idx2)  */
2668      0x000001f8, /* 0020(:0):    NOP */
2669 -    0x98180524, /* 0024(:936):  LCD: idx0 = idx0; idx0 != var20; idx0 += inc4 */
2670 -    0x8118801b, /* 0028(:938):    LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */
2671 -    0xf8ca001a, /* 002C(:939):      LCDEXT: idx2 = *(idx1 + var20 + 8); idx2 once var0; idx2 += inc3 */
2672 -    0xb8ca601b, /* 0030(:940):      LCD: idx3 = *(idx1 + var20 + 12); ; idx3 += inc3 */
2673 -    0x10004310, /* 0034(:942):        DRD1A: var16 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2674 -    0x00001718, /* 0038(:943):        DRD1A: var5 = idx3; FN=0 init=0 WS=0 RS=0 */
2675 -    0xb8ca001d, /* 003C(:945):      LCD: idx2 = *(idx1 + var20 + 20); idx2 once var0; idx2 += inc3 */
2676 -    0x10001f10, /* 0040(:946):        DRD1A: var7 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2677 -    0x60000007, /* 0044(:947):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=7 EXT init=0 WS=0 RS=0 */
2678 -    0x020cf893, /* 0048(:947):        DRD2B1: var8 = EU3(); EU3(idx2,var19)  */
2679 -    0x98ca001c, /* 004C(:949):      LCD: idx2 = idx1 + var20 + 4; idx2 once var0; idx2 += inc3 */
2680 -    0x00000710, /* 0050(:950):        DRD1A: var1 = idx2; FN=0 init=0 WS=0 RS=0 */
2681 -    0x98ca8018, /* 0054(:951):      LCD: idx2 = idx1 + var21; idx2 once var0; idx2 += inc3 */
2682 -    0x10002b10, /* 0058(:952):        DRD1A: var10 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2683 -    0x0000c828, /* 005C(:953):        DRD1A: *idx2 = var5; FN=0 init=0 WS=0 RS=0 */
2684 +    0x981803a4, /* 0024(:955):  LCD: idx0 = idx0; idx0 == var14; idx0 += inc4 */
2685 +    0x8198801b, /* 0028(:957):    LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */
2686 +    0xf8c6801a, /* 002C(:958):      LCDEXT: idx2 = *(idx1 + var13 + 8); idx2 once var0; idx2 += inc3 */
2687 +    0xb8c6e01b, /* 0030(:959):      LCD: idx3 = *(idx1 + var13 + 12); ; idx3 += inc3 */
2688 +    0x10002b10, /* 0034(:961):        DRD1A: var10 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2689 +    0x00001318, /* 0038(:962):        DRD1A: var4 = idx3; FN=0 init=0 WS=0 RS=0 */
2690 +    0xb8c6801d, /* 003C(:964):      LCD: idx2 = *(idx1 + var13 + 20); idx2 once var0; idx2 += inc3 */
2691 +    0x10001710, /* 0040(:965):        DRD1A: var5 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2692 +    0x60000007, /* 0044(:966):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=7 EXT init=0 WS=0 RS=0 */
2693 +    0x018cf88c, /* 0048(:966):        DRD2B1: var6 = EU3(); EU3(idx2,var12)  */
2694 +    0x98c6801c, /* 004C(:968):      LCD: idx2 = idx1 + var13 + 4; idx2 once var0; idx2 += inc3 */
2695 +    0x00000b10, /* 0050(:969):        DRD1A: var2 = idx2; FN=0 init=0 WS=0 RS=0 */
2696 +    0x98c78018, /* 0054(:970):      LCD: idx2 = idx1 + var15; idx2 once var0; idx2 += inc3 */
2697 +    0x10002310, /* 0058(:971):        DRD1A: var8 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2698 +    0x0000c820, /* 005C(:972):        DRD1A: *idx2 = var4; FN=0 init=0 WS=0 RS=0 */
2699      0x000001f8, /* 0060(:0):      NOP */
2700 -    0xc14ae018, /* 0064(:957):    LCDEXT: idx1 = var2 + var21; ; idx1 += inc3 */
2701 -    0xc004a51d, /* 0068(:957):    LCDEXT: idx2 = var0, idx3 = var9; idx3 == var20; idx2 += inc3, idx3 += inc5 */
2702 -    0x811a601b, /* 006C(:958):    LCD: idx4 = var2; ; idx4 += inc3 */
2703 -    0xc28a21c2, /* 0070(:961):      LCDEXT: idx5 = var5, idx6 = var20; idx6 < var7; idx5 += inc0, idx6 += inc2 */
2704 -    0x881be009, /* 0074(:961):      LCD: idx7 = var16; ; idx7 += inc1 */
2705 -    0x63fe0000, /* 0078(:964):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 EXT init=31 WS=3 RS=3 */
2706 -    0x0d4cfddf, /* 007C(:964):        DRD2B1: *idx5 = EU3(); EU3(*idx7)  */
2707 -    0xda9b001b, /* 0080(:966):      LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2708 -    0x9b9be01b, /* 0084(:966):      LCD: idx7 = idx7; ; idx7 += inc3 */
2709 -    0x1000cb20, /* 0088(:967):        DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */
2710 -    0x70000006, /* 008C(:968):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2711 -    0x088cf896, /* 0090(:968):        DRD2B1: idx2 = EU3(); EU3(idx2,var22)  */
2712 -    0x1000cb28, /* 0094(:969):        DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
2713 -    0x70000006, /* 0098(:970):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2714 -    0x088cf896, /* 009C(:970):        DRD2B1: idx2 = EU3(); EU3(idx2,var22)  */
2715 -    0x1000cb30, /* 00A0(:971):        DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
2716 -    0x70000006, /* 00A4(:972):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2717 -    0x088cf896, /* 00A8(:972):        DRD2B1: idx2 = EU3(); EU3(idx2,var22)  */
2718 -    0x1000cb38, /* 00AC(:973):        DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */
2719 -    0x0000c728, /* 00B0(:974):        DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */
2720 -    0x000001f8, /* 00B4(:0):      NOP */
2721 -    0xc14ae018, /* 00B8(:978):    LCDEXT: idx1 = var2 + var21; ; idx1 += inc3 */
2722 -    0xc004a5dd, /* 00BC(:978):    LCDEXT: idx2 = var0, idx3 = var9; idx3 == var23; idx2 += inc3, idx3 += inc5 */
2723 -    0x811a601b, /* 00C0(:979):    LCD: idx4 = var2; ; idx4 += inc3 */
2724 -    0xda9b001b, /* 00C4(:982):      LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2725 -    0x9b9be01b, /* 00C8(:982):      LCD: idx7 = idx7; ; idx7 += inc3 */
2726 -    0x0000d3a0, /* 00CC(:983):        DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */
2727 -    0xc28a21c2, /* 00D0(:985):      LCDEXT: idx5 = var5, idx6 = var20; idx6 < var7; idx5 += inc0, idx6 += inc2 */
2728 -    0x881be009, /* 00D4(:985):      LCD: idx7 = var16; ; idx7 += inc1 */
2729 -    0x6bfe0000, /* 00D8(:988):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 TFD EXT init=31 WS=3 RS=3 */
2730 -    0x0d4cfddf, /* 00DC(:988):        DRD2B1: *idx5 = EU3(); EU3(*idx7)  */
2731 -    0xda9b001b, /* 00E0(:990):      LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2732 -    0x9b9be01b, /* 00E4(:990):      LCD: idx7 = idx7; ; idx7 += inc3 */
2733 -    0x1000cb20, /* 00E8(:991):        DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */
2734 -    0x70000006, /* 00EC(:992):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2735 -    0x088cf896, /* 00F0(:992):        DRD2B1: idx2 = EU3(); EU3(idx2,var22)  */
2736 -    0x1000cb28, /* 00F4(:993):        DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
2737 -    0x70000006, /* 00F8(:994):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2738 -    0x088cf896, /* 00FC(:994):        DRD2B1: idx2 = EU3(); EU3(idx2,var22)  */
2739 -    0x1000cb30, /* 0100(:995):        DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
2740 -    0x70000006, /* 0104(:996):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2741 -    0x088cf896, /* 0108(:996):        DRD2B1: idx2 = EU3(); EU3(idx2,var22)  */
2742 -    0x1000cb38, /* 010C(:997):        DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */
2743 -    0x0000c728, /* 0110(:998):        DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */
2744 -    0x000001f8, /* 0114(:0):      NOP */
2745 -    0x8118801b, /* 0118(:1002):    LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */
2746 -    0x8a19001b, /* 011C(:1004):      LCD: idx2 = var20; idx2 once var0; idx2 += inc3 */
2747 -    0x6000000e, /* 0120(:1005):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */
2748 -    0x088cf49f, /* 0124(:1005):        DRD2B1: idx2 = EU3(); EU3(var18)  */
2749 -    0xd9190536, /* 0128(:1006):      LCDEXT: idx2 = idx2; idx2 == var20; idx2 += inc6 */
2750 -    0x98ca0018, /* 012C(:1006):      LCD: idx3 = idx1 + var20; idx3 once var0; idx3 += inc3 */
2751 -    0x6000000a, /* 0130(:1008):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */
2752 -    0x0cccfcdf, /* 0134(:1008):        DRD2B1: *idx3 = EU3(); EU3(*idx3)  */
2753 -    0x000001f8, /* 0138(:0):      NOP */
2754 -    0xa14a001e, /* 013C(:1011):    LCD: idx1 = *(var2 + var20 + 24); idx1 once var0; idx1 += inc3 */
2755 -    0x10000b08, /* 0140(:1012):      DRD1A: var2 = idx1; FN=0 MORE init=0 WS=0 RS=0 */
2756 -    0x10002c90, /* 0144(:1013):      DRD1A: var11 = var18; FN=0 MORE init=0 WS=0 RS=0 */
2757 -    0xb8ca0018, /* 0148(:1014):      LCD: idx2 = *(idx1 + var20); idx2 once var0; idx2 += inc3 */
2758 -    0x10004b10, /* 014C(:1015):        DRD1A: var18 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2759 -    0x70000009, /* 0150(:1016):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=9 EXT MORE init=0 WS=0 RS=0 */
2760 -    0x080cf89f, /* 0154(:1016):        DRD2B1: idx0 = EU3(); EU3(idx2)  */
2761 -    0x6000000c, /* 0158(:1017):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT init=0 WS=0 RS=0 */
2762 -    0x024cf89f, /* 015C(:1017):        DRD2B1: var9 = EU3(); EU3(idx2)  */
2763 -    0x000001f8, /* 0160(:0):      NOP */
2764 -    0x8a18801b, /* 0164(:1023):    LCD: idx1 = var20; idx1 once var0; idx1 += inc3 */
2765 -    0x7000000d, /* 0168(:1024):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
2766 -    0x084cf2df, /* 016C(:1024):      DRD2B1: idx1 = EU3(); EU3(var11)  */
2767 -    0xd899053f, /* 0170(:1025):      LCDEXT: idx2 = idx1; idx2 > var20; idx2 += inc7 */
2768 -    0x8019801b, /* 0174(:1025):      LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */
2769 -    0x040001f8, /* 0178(:1026):        DRD1A: FN=0 INT init=0 WS=0 RS=0 */
2770 -    0x000001f8, /* 017C(:0):      NOP */
2771 -    0x000001f8, /* 0180(:0):    NOP */
2772 +    0x8698801b, /* 0064(:976):    LCD: idx1 = var13; idx1 once var0; idx1 += inc3 */
2773 +    0x7000000f, /* 0068(:977):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=15 EXT MORE init=0 WS=0 RS=0 */
2774 +    0x084cf2df, /* 006C(:977):      DRD2B1: idx1 = EU3(); EU3(var11)  */
2775 +    0xd899042d, /* 0070(:978):      LCDEXT: idx2 = idx1; idx2 >= var16; idx2 += inc5 */
2776 +    0x8019801b, /* 0074(:978):      LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */
2777 +    0x60000003, /* 0078(:979):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */
2778 +    0x2cd7c7df, /* 007C(:979):        DRD2B2: EU3(var13)  */
2779 +    0xd8990364, /* 0080(:980):      LCDEXT: idx2 = idx1; idx2 == var13; idx2 += inc4 */
2780 +    0x8019801b, /* 0084(:980):      LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */
2781 +    0x60000003, /* 0088(:981):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */
2782 +    0x2c17c7df, /* 008C(:981):        DRD2B2: EU3(var1)  */
2783 +    0x000001f8, /* 0090(:0):      NOP */
2784 +    0xc1c7e018, /* 0094(:984):    LCDEXT: idx1 = var3 + var15; ; idx1 += inc3 */
2785 +    0xc003a35e, /* 0098(:984):    LCDEXT: idx2 = var0, idx3 = var7; idx3 == var13; idx2 += inc3, idx3 += inc6 */
2786 +    0x819a601b, /* 009C(:985):    LCD: idx4 = var3; ; idx4 += inc3 */
2787 +    0xc206a142, /* 00A0(:988):      LCDEXT: idx5 = var4, idx6 = var13; idx6 < var5; idx5 += inc0, idx6 += inc2 */
2788 +    0x851be009, /* 00A4(:988):      LCD: idx7 = var10; ; idx7 += inc1 */
2789 +    0x63fe0000, /* 00A8(:991):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 EXT init=31 WS=3 RS=3 */
2790 +    0x0d4cfddf, /* 00AC(:991):        DRD2B1: *idx5 = EU3(); EU3(*idx7)  */
2791 +    0xda9b001b, /* 00B0(:993):      LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2792 +    0x9b9be01b, /* 00B4(:993):      LCD: idx7 = idx7; ; idx7 += inc3 */
2793 +    0x70000002, /* 00B8(:994):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */
2794 +    0x004cf81f, /* 00BC(:994):        DRD2B1: var1 = EU3(); EU3(idx0)  */
2795 +    0x1000cb20, /* 00C0(:995):        DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */
2796 +    0x70000006, /* 00C4(:996):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2797 +    0x088cf891, /* 00C8(:996):        DRD2B1: idx2 = EU3(); EU3(idx2,var17)  */
2798 +    0x1000cb28, /* 00CC(:997):        DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
2799 +    0x70000006, /* 00D0(:998):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2800 +    0x088cf891, /* 00D4(:998):        DRD2B1: idx2 = EU3(); EU3(idx2,var17)  */
2801 +    0x1000cb30, /* 00D8(:999):        DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
2802 +    0x70000006, /* 00DC(:1000):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2803 +    0x088cf891, /* 00E0(:1000):        DRD2B1: idx2 = EU3(); EU3(idx2,var17)  */
2804 +    0x1000cb38, /* 00E4(:1001):        DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */
2805 +    0x0000c728, /* 00E8(:1002):        DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */
2806 +    0x000001f8, /* 00EC(:0):      NOP */
2807 +    0xc1c7e018, /* 00F0(:1006):    LCDEXT: idx1 = var3 + var15; ; idx1 += inc3 */
2808 +    0xc003a49e, /* 00F4(:1006):    LCDEXT: idx2 = var0, idx3 = var7; idx3 == var18; idx2 += inc3, idx3 += inc6 */
2809 +    0x819a601b, /* 00F8(:1007):    LCD: idx4 = var3; ; idx4 += inc3 */
2810 +    0xda9b001b, /* 00FC(:1010):      LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2811 +    0x9b9be01b, /* 0100(:1010):      LCD: idx7 = idx7; ; idx7 += inc3 */
2812 +    0x0000d3a0, /* 0104(:1011):        DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */
2813 +    0xc206a142, /* 0108(:1013):      LCDEXT: idx5 = var4, idx6 = var13; idx6 < var5; idx5 += inc0, idx6 += inc2 */
2814 +    0x851be009, /* 010C(:1013):      LCD: idx7 = var10; ; idx7 += inc1 */
2815 +    0x6bfe0000, /* 0110(:1016):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 TFD EXT init=31 WS=3 RS=3 */
2816 +    0x0d4cfddf, /* 0114(:1016):        DRD2B1: *idx5 = EU3(); EU3(*idx7)  */
2817 +    0xda9b001b, /* 0118(:1018):      LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2818 +    0x9b9be01b, /* 011C(:1018):      LCD: idx7 = idx7; ; idx7 += inc3 */
2819 +    0x70000002, /* 0120(:1019):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */
2820 +    0x004cf81f, /* 0124(:1019):        DRD2B1: var1 = EU3(); EU3(idx0)  */
2821 +    0x1000cb20, /* 0128(:1020):        DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */
2822 +    0x70000006, /* 012C(:1021):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2823 +    0x088cf891, /* 0130(:1021):        DRD2B1: idx2 = EU3(); EU3(idx2,var17)  */
2824 +    0x1000cb28, /* 0134(:1022):        DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
2825 +    0x70000006, /* 0138(:1023):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2826 +    0x088cf891, /* 013C(:1023):        DRD2B1: idx2 = EU3(); EU3(idx2,var17)  */
2827 +    0x1000cb30, /* 0140(:1024):        DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
2828 +    0x70000006, /* 0144(:1025):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2829 +    0x088cf891, /* 0148(:1025):        DRD2B1: idx2 = EU3(); EU3(idx2,var17)  */
2830 +    0x1000cb38, /* 014C(:1026):        DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */
2831 +    0x0000c728, /* 0150(:1027):        DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */
2832 +    0x000001f8, /* 0154(:0):      NOP */
2833 +    0x8198801b, /* 0158(:1031):    LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */
2834 +    0xd8c68018, /* 015C(:1033):      LCDEXT: idx2 = idx1 + var13; idx2 once var0; idx2 += inc3 */
2835 +    0x98c6e01c, /* 0160(:1033):      LCD: idx3 = idx1 + var13 + 4; ; idx3 += inc3 */
2836 +    0x6000000b, /* 0164(:1034):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=11 EXT init=0 WS=0 RS=0 */
2837 +    0x0c8cfc9f, /* 0168(:1034):        DRD2B1: *idx2 = EU3(); EU3(*idx2)  */
2838 +    0x0000cc08, /* 016C(:1035):      DRD1A: *idx3 = var1; FN=0 init=0 WS=0 RS=0 */
2839 +    0xa1c6801e, /* 0170(:1038):    LCD: idx1 = *(var3 + var13 + 24); idx1 once var0; idx1 += inc3 */
2840 +    0x10000f08, /* 0174(:1039):      DRD1A: var3 = idx1; FN=0 MORE init=0 WS=0 RS=0 */
2841 +    0x10002458, /* 0178(:1040):      DRD1A: var9 = var11; FN=0 MORE init=0 WS=0 RS=0 */
2842 +    0xb8c68018, /* 017C(:1041):      LCD: idx2 = *(idx1 + var13); idx2 once var0; idx2 += inc3 */
2843 +    0x10002f10, /* 0180(:1042):        DRD1A: var11 = idx2; FN=0 MORE init=0 WS=0 RS=0 */
2844 +    0x7000000a, /* 0184(:1043):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT MORE init=0 WS=0 RS=0 */
2845 +    0x080cf89f, /* 0188(:1043):        DRD2B1: idx0 = EU3(); EU3(idx2)  */
2846 +    0x6000000d, /* 018C(:1044):        DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT init=0 WS=0 RS=0 */
2847 +    0x01ccf89f, /* 0190(:1044):        DRD2B1: var7 = EU3(); EU3(idx2)  */
2848 +    0x000001f8, /* 0194(:0):      NOP */
2849 +    0x8698801b, /* 0198(:1050):    LCD: idx1 = var13; idx1 once var0; idx1 += inc3 */
2850 +    0x7000000e, /* 019C(:1051):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */
2851 +    0x084cf25f, /* 01A0(:1051):      DRD2B1: idx1 = EU3(); EU3(var9)  */
2852 +    0xd899037f, /* 01A4(:1052):      LCDEXT: idx2 = idx1; idx2 > var13; idx2 += inc7 */
2853 +    0x8019801b, /* 01A8(:1052):      LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */
2854 +    0x040001f8, /* 01AC(:1053):        DRD1A: FN=0 INT init=0 WS=0 RS=0 */
2855 +    0x000001f8, /* 01B0(:0):      NOP */
2856 +    0x000001f8, /* 01B4(:0):    NOP */
2857  };
2858  u32 MCD_SingleEu_TDT[]=
2859  {
2860 -    0x8318001b, /* 0000(:1204):  LCD: idx0 = var6; idx0 once var0; idx0 += inc3 */
2861 -    0x7000000c, /* 0004(:1205):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT MORE init=0 WS=0 RS=0 */
2862 -    0x080cf81f, /* 0008(:1205):    DRD2B1: idx0 = EU3(); EU3(idx0)  */
2863 -    0x8318801b, /* 000C(:1206):    LCD: idx1 = var6; idx1 once var0; idx1 += inc3 */
2864 -    0x6000000d, /* 0010(:1207):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT init=0 WS=0 RS=0 */
2865 -    0x084cf85f, /* 0014(:1207):      DRD2B1: idx1 = EU3(); EU3(idx1)  */
2866 +    0x8218001b, /* 0000(:1248):  LCD: idx0 = var4; idx0 once var0; idx0 += inc3 */
2867 +    0x7000000d, /* 0004(:1249):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
2868 +    0x080cf81f, /* 0008(:1249):    DRD2B1: idx0 = EU3(); EU3(idx0)  */
2869 +    0x8218801b, /* 000C(:1250):    LCD: idx1 = var4; idx1 once var0; idx1 += inc3 */
2870 +    0x6000000e, /* 0010(:1251):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */
2871 +    0x084cf85f, /* 0014(:1251):      DRD2B1: idx1 = EU3(); EU3(idx1)  */
2872      0x000001f8, /* 0018(:0):    NOP */
2873 -    0x8498001b, /* 001C(:1211):  LCD: idx0 = var9; idx0 once var0; idx0 += inc3 */
2874 -    0x7000000c, /* 0020(:1212):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT MORE init=0 WS=0 RS=0 */
2875 -    0x020cf81f, /* 0024(:1212):    DRD2B1: var8 = EU3(); EU3(idx0)  */
2876 -    0x6000000d, /* 0028(:1213):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT init=0 WS=0 RS=0 */
2877 -    0x028cf81f, /* 002C(:1213):    DRD2B1: var10 = EU3(); EU3(idx0)  */
2878 -    0xc404601b, /* 0030(:1216):  LCDEXT: idx0 = var8, idx1 = var8; ; idx0 += inc3, idx1 += inc3 */
2879 -    0xc00423dc, /* 0034(:1216):  LCDEXT: idx2 = var0, idx3 = var8; idx3 == var15; idx2 += inc3, idx3 += inc4 */
2880 -    0x809a601b, /* 0038(:1217):  LCD: idx4 = var1; ; idx4 += inc3 */
2881 -    0xc207a182, /* 003C(:1220):    LCDEXT: idx5 = var4, idx6 = var15; idx6 < var6; idx5 += inc0, idx6 += inc2 */
2882 -    0x869be009, /* 0040(:1220):    LCD: idx7 = var13; ; idx7 += inc1 */
2883 -    0x63fe0000, /* 0044(:1223):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 EXT init=31 WS=3 RS=3 */
2884 -    0x0d4cfddf, /* 0048(:1223):      DRD2B1: *idx5 = EU3(); EU3(*idx7)  */
2885 -    0xda9b001b, /* 004C(:1225):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2886 -    0x9b9be01b, /* 0050(:1225):    LCD: idx7 = idx7; ; idx7 += inc3 */
2887 -    0x70000006, /* 0054(:1227):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2888 -    0x088cf890, /* 0058(:1227):      DRD2B1: idx2 = EU3(); EU3(idx2,var16)  */
2889 -    0x1000cb28, /* 005C(:1228):      DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
2890 -    0x70000006, /* 0060(:1229):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2891 -    0x088cf890, /* 0064(:1229):      DRD2B1: idx2 = EU3(); EU3(idx2,var16)  */
2892 -    0x1000cb30, /* 0068(:1230):      DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
2893 -    0x70000006, /* 006C(:1231):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2894 -    0x088cf890, /* 0070(:1231):      DRD2B1: idx2 = EU3(); EU3(idx2,var16)  */
2895 -    0x0000cb38, /* 0074(:1232):      DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */
2896 -    0x000001f8, /* 0078(:0):    NOP */
2897 -    0xc404601b, /* 007C(:1236):  LCDEXT: idx0 = var8, idx1 = var8; ; idx0 += inc3, idx1 += inc3 */
2898 -    0xc004245c, /* 0080(:1236):  LCDEXT: idx2 = var0, idx3 = var8; idx3 == var17; idx2 += inc3, idx3 += inc4 */
2899 -    0x809a601b, /* 0084(:1237):  LCD: idx4 = var1; ; idx4 += inc3 */
2900 -    0xda9b001b, /* 0088(:1240):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2901 -    0x9b9be01b, /* 008C(:1240):    LCD: idx7 = idx7; ; idx7 += inc3 */
2902 -    0x0000d3a0, /* 0090(:1241):      DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */
2903 -    0xc207a182, /* 0094(:1243):    LCDEXT: idx5 = var4, idx6 = var15; idx6 < var6; idx5 += inc0, idx6 += inc2 */
2904 -    0x869be009, /* 0098(:1243):    LCD: idx7 = var13; ; idx7 += inc1 */
2905 -    0x6bfe0000, /* 009C(:1246):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 TFD EXT init=31 WS=3 RS=3 */
2906 -    0x0d4cfddf, /* 00A0(:1246):      DRD2B1: *idx5 = EU3(); EU3(*idx7)  */
2907 -    0xda9b001b, /* 00A4(:1248):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2908 -    0x9b9be01b, /* 00A8(:1248):    LCD: idx7 = idx7; ; idx7 += inc3 */
2909 -    0x70000006, /* 00AC(:1250):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2910 -    0x088cf890, /* 00B0(:1250):      DRD2B1: idx2 = EU3(); EU3(idx2,var16)  */
2911 -    0x1000cb28, /* 00B4(:1251):      DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
2912 -    0x70000006, /* 00B8(:1252):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2913 -    0x088cf890, /* 00BC(:1252):      DRD2B1: idx2 = EU3(); EU3(idx2,var16)  */
2914 -    0x1000cb30, /* 00C0(:1253):      DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
2915 -    0x70000006, /* 00C4(:1254):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2916 -    0x088cf890, /* 00C8(:1254):      DRD2B1: idx2 = EU3(); EU3(idx2,var16)  */
2917 -    0x0000cb38, /* 00CC(:1255):      DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */
2918 -    0x000001f8, /* 00D0(:0):    NOP */
2919 -    0xc51803ed, /* 00D4(:1259):  LCDEXT: idx0 = var10; idx0 > var15; idx0 += inc5 */
2920 -    0x8018801b, /* 00D8(:1259):  LCD: idx1 = var0; idx1 once var0; idx1 += inc3 */
2921 -    0x040001f8, /* 00DC(:1260):    DRD1A: FN=0 INT init=0 WS=0 RS=0 */
2922 +    0x8318001b, /* 001C(:1255):  LCD: idx0 = var6; idx0 once var0; idx0 += inc3 */
2923 +    0x7000000d, /* 0020(:1256):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
2924 +    0x014cf81f, /* 0024(:1256):    DRD2B1: var5 = EU3(); EU3(idx0)  */
2925 +    0x6000000e, /* 0028(:1257):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */
2926 +    0x01ccf81f, /* 002C(:1257):    DRD2B1: var7 = EU3(); EU3(idx0)  */
2927 +    0x8498001b, /* 0030(:1260):  LCD: idx0 = var9; idx0 once var0; idx0 += inc3 */
2928 +    0x7000000f, /* 0034(:1261):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=15 EXT MORE init=0 WS=0 RS=0 */
2929 +    0x080cf19f, /* 0038(:1261):    DRD2B1: idx0 = EU3(); EU3(var6)  */
2930 +    0xd81882a4, /* 003C(:1262):    LCDEXT: idx1 = idx0; idx1 >= var10; idx1 += inc4 */
2931 +    0x8019001b, /* 0040(:1262):    LCD: idx2 = var0; idx2 once var0; idx2 += inc3 */
2932 +    0x60000003, /* 0044(:1263):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */
2933 +    0x2c97c7df, /* 0048(:1263):      DRD2B2: EU3(var9)  */
2934 +    0xd818826d, /* 004C(:1264):    LCDEXT: idx1 = idx0; idx1 == var9; idx1 += inc5 */
2935 +    0x8019001b, /* 0050(:1264):    LCD: idx2 = var0; idx2 once var0; idx2 += inc3 */
2936 +    0x60000003, /* 0054(:1265):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */
2937 +    0x2c17c7df, /* 0058(:1265):      DRD2B2: EU3(var1)  */
2938 +    0x000001f8, /* 005C(:0):    NOP */
2939 +    0xc282e01b, /* 0060(:1268):  LCDEXT: idx0 = var5, idx1 = var5; ; idx0 += inc3, idx1 += inc3 */
2940 +    0xc002a25e, /* 0064(:1268):  LCDEXT: idx2 = var0, idx3 = var5; idx3 == var9; idx2 += inc3, idx3 += inc6 */
2941 +    0x811a601b, /* 0068(:1269):  LCD: idx4 = var2; ; idx4 += inc3 */
2942 +    0xc184a102, /* 006C(:1272):    LCDEXT: idx5 = var3, idx6 = var9; idx6 < var4; idx5 += inc0, idx6 += inc2 */
2943 +    0x841be009, /* 0070(:1272):    LCD: idx7 = var8; ; idx7 += inc1 */
2944 +    0x63fe0000, /* 0074(:1275):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 EXT init=31 WS=3 RS=3 */
2945 +    0x0d4cfddf, /* 0078(:1275):      DRD2B1: *idx5 = EU3(); EU3(*idx7)  */
2946 +    0xda9b001b, /* 007C(:1277):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2947 +    0x9b9be01b, /* 0080(:1277):    LCD: idx7 = idx7; ; idx7 += inc3 */
2948 +    0x70000002, /* 0084(:1279):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */
2949 +    0x004cf99f, /* 0088(:1279):      DRD2B1: var1 = EU3(); EU3(idx6)  */
2950 +    0x70000006, /* 008C(:1280):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2951 +    0x088cf88b, /* 0090(:1280):      DRD2B1: idx2 = EU3(); EU3(idx2,var11)  */
2952 +    0x1000cb28, /* 0094(:1281):      DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
2953 +    0x70000006, /* 0098(:1282):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2954 +    0x088cf88b, /* 009C(:1282):      DRD2B1: idx2 = EU3(); EU3(idx2,var11)  */
2955 +    0x1000cb30, /* 00A0(:1283):      DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
2956 +    0x70000006, /* 00A4(:1284):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2957 +    0x088cf88b, /* 00A8(:1284):      DRD2B1: idx2 = EU3(); EU3(idx2,var11)  */
2958 +    0x0000cb38, /* 00AC(:1285):      DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */
2959 +    0x000001f8, /* 00B0(:0):    NOP */
2960 +    0xc282e01b, /* 00B4(:1289):  LCDEXT: idx0 = var5, idx1 = var5; ; idx0 += inc3, idx1 += inc3 */
2961 +    0xc002a31e, /* 00B8(:1289):  LCDEXT: idx2 = var0, idx3 = var5; idx3 == var12; idx2 += inc3, idx3 += inc6 */
2962 +    0x811a601b, /* 00BC(:1290):  LCD: idx4 = var2; ; idx4 += inc3 */
2963 +    0xda9b001b, /* 00C0(:1293):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2964 +    0x9b9be01b, /* 00C4(:1293):    LCD: idx7 = idx7; ; idx7 += inc3 */
2965 +    0x0000d3a0, /* 00C8(:1294):      DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */
2966 +    0xc184a102, /* 00CC(:1296):    LCDEXT: idx5 = var3, idx6 = var9; idx6 < var4; idx5 += inc0, idx6 += inc2 */
2967 +    0x841be009, /* 00D0(:1296):    LCD: idx7 = var8; ; idx7 += inc1 */
2968 +    0x6bfe0000, /* 00D4(:1299):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 TFD EXT init=31 WS=3 RS=3 */
2969 +    0x0d4cfddf, /* 00D8(:1299):      DRD2B1: *idx5 = EU3(); EU3(*idx7)  */
2970 +    0xda9b001b, /* 00DC(:1301):    LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */
2971 +    0x9b9be01b, /* 00E0(:1301):    LCD: idx7 = idx7; ; idx7 += inc3 */
2972 +    0x70000002, /* 00E4(:1303):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */
2973 +    0x004cf99f, /* 00E8(:1303):      DRD2B1: var1 = EU3(); EU3(idx6)  */
2974 +    0x70000006, /* 00EC(:1304):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2975 +    0x088cf88b, /* 00F0(:1304):      DRD2B1: idx2 = EU3(); EU3(idx2,var11)  */
2976 +    0x1000cb28, /* 00F4(:1305):      DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */
2977 +    0x70000006, /* 00F8(:1306):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2978 +    0x088cf88b, /* 00FC(:1306):      DRD2B1: idx2 = EU3(); EU3(idx2,var11)  */
2979 +    0x1000cb30, /* 0100(:1307):      DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */
2980 +    0x70000006, /* 0104(:1308):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */
2981 +    0x088cf88b, /* 0108(:1308):      DRD2B1: idx2 = EU3(); EU3(idx2,var11)  */
2982 +    0x0000cb38, /* 010C(:1309):      DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */
2983 +    0x000001f8, /* 0110(:0):    NOP */
2984 +    0x8144801c, /* 0114(:1312):  LCD: idx0 = var2 + var9 + 4; idx0 once var0; idx0 += inc3 */
2985 +    0x0000c008, /* 0118(:1313):    DRD1A: *idx0 = var1; FN=0 init=0 WS=0 RS=0 */
2986 +    0xc398027f, /* 011C(:1315):  LCDEXT: idx0 = var7; idx0 > var9; idx0 += inc7 */
2987 +    0x8018801b, /* 0120(:1315):  LCD: idx1 = var0; idx1 once var0; idx1 += inc3 */
2988 +    0x040001f8, /* 0124(:1316):    DRD1A: FN=0 INT init=0 WS=0 RS=0 */
2989  };
2990  #endif
2991  u32 MCD_ENetRcv_TDT[]=
2992  {
2993 -    0x80004000, /* 0000(:1334):  LCDEXT: idx0 = 0x00000000; ; */
2994 -    0x82188000, /* 0004(:1334):  LCD: idx1 = var4; idx1 once var0; idx1 += inc0 */
2995 -    0x10000788, /* 0008(:1335):    DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */
2996 -    0x60000009, /* 000C(:1336):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=9 EXT init=0 WS=0 RS=0 */
2997 -    0x080cf05f, /* 0010(:1336):    DRD2B1: idx0 = EU3(); EU3(var1)  */
2998 -    0x98180249, /* 0014(:1339):  LCD: idx0 = idx0; idx0 != var9; idx0 += inc1 */
2999 -    0x82448004, /* 0018(:1341):    LCD: idx1 = var4 + var9 + 4; idx1 once var0; idx1 += inc0 */
3000 -    0x7000000d, /* 001C(:1342):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
3001 -    0x014cf05f, /* 0020(:1342):      DRD2B1: var5 = EU3(); EU3(var1)  */
3002 -    0x7000000b, /* 0024(:1343):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=11 EXT MORE init=0 WS=0 RS=0 */
3003 -    0x020cf05f, /* 0028(:1343):      DRD2B1: var8 = EU3(); EU3(var1)  */
3004 -    0x70000004, /* 002C(:1344):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */
3005 -    0x018cf04a, /* 0030(:1344):      DRD2B1: var6 = EU3(); EU3(var1,var10)  */
3006 -    0x70000004, /* 0034(:1345):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */
3007 -    0x004cf04b, /* 0038(:1345):      DRD2B1: var1 = EU3(); EU3(var1,var11)  */
3008 -    0x00000b88, /* 003C(:1348):      DRD1A: var2 = *idx1; FN=0 init=0 WS=0 RS=0 */
3009 -    0xc4838190, /* 0040(:1351):    LCDEXT: idx1 = var9, idx2 = var7; idx1 < var6; idx1 += inc2, idx2 += inc0 */
3010 -    0x8119e012, /* 0044(:1351):    LCD: idx3 = var2; ; idx3 += inc2 */
3011 -    0x03e0cf90, /* 0048(:1354):      DRD1A: *idx3 = *idx2; FN=0 init=31 WS=0 RS=0 */
3012 -    0x81188000, /* 004C(:1357):    LCD: idx1 = var2; idx1 once var0; idx1 += inc0 */
3013 -    0x000ac788, /* 0050(:1358):      DRD1A: *idx1 = *idx1; FN=0 init=0 WS=1 RS=1 */
3014 -    0xc4838000, /* 0054(:1360):    LCDEXT: idx1 = var9, idx2 = var7; idx1 once var0; idx1 += inc0, idx2 += inc0 */
3015 -    0x8219e000, /* 0058(:1360):    LCD: idx3 = var4; ; idx3 += inc0 */
3016 -    0x70000004, /* 005C(:1368):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */
3017 -    0x084cfc8c, /* 0060(:1368):      DRD2B1: idx1 = EU3(); EU3(*idx2,var12)  */
3018 -    0x60000005, /* 0064(:1371):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=5 EXT init=0 WS=0 RS=0 */
3019 -    0x0cccf841, /* 0068(:1371):      DRD2B1: *idx3 = EU3(); EU3(idx1,var1)  */
3020 -    0x82468000, /* 006C(:1377):    LCD: idx1 = var4 + var13; idx1 once var0; idx1 += inc0 */
3021 -    0xc419025b, /* 0070(:1379):      LCDEXT: idx2 = var8; idx2 > var9; idx2 += inc3 */
3022 -    0x80198000, /* 0074(:1379):      LCD: idx3 = var0; idx3 once var0; idx3 += inc0 */
3023 -    0x00008400, /* 0078(:1380):        DRD1A: idx1 = var0; FN=0 init=0 WS=0 RS=0 */
3024 -    0x00001308, /* 007C(:1381):      DRD1A: var4 = idx1; FN=0 init=0 WS=0 RS=0 */
3025 -    0x82188000, /* 0080(:1384):    LCD: idx1 = var4; idx1 once var0; idx1 += inc0 */
3026 -    0x10000788, /* 0084(:1385):      DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */
3027 -    0x60000009, /* 0088(:1386):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=9 EXT init=0 WS=0 RS=0 */
3028 -    0x080cf05f, /* 008C(:1386):      DRD2B1: idx0 = EU3(); EU3(var1)  */
3029 -    0xc2988249, /* 0090(:1389):    LCDEXT: idx1 = var5; idx1 != var9; idx1 += inc1 */
3030 -    0x80190000, /* 0094(:1389):    LCD: idx2 = var0; idx2 once var0; idx2 += inc0 */
3031 -    0x040001f8, /* 0098(:1390):      DRD1A: FN=0 INT init=0 WS=0 RS=0 */
3032 -    0x000001f8, /* 009C(:0):    NOP */
3033 +    0x80004000, /* 0000(:1389):  LCDEXT: idx0 = 0x00000000; ; */
3034 +    0x81988000, /* 0004(:1389):  LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */
3035 +    0x10000788, /* 0008(:1390):    DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */
3036 +    0x6000000a, /* 000C(:1391):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */
3037 +    0x080cf05f, /* 0010(:1391):    DRD2B1: idx0 = EU3(); EU3(var1)  */
3038 +    0x98180209, /* 0014(:1394):  LCD: idx0 = idx0; idx0 != var8; idx0 += inc1 */
3039 +    0x81c40004, /* 0018(:1396):    LCD: idx1 = var3 + var8 + 4; idx1 once var0; idx1 += inc0 */
3040 +    0x7000000e, /* 001C(:1397):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */
3041 +    0x010cf05f, /* 0020(:1397):      DRD2B1: var4 = EU3(); EU3(var1)  */
3042 +    0x7000000c, /* 0024(:1398):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT MORE init=0 WS=0 RS=0 */
3043 +    0x01ccf05f, /* 0028(:1398):      DRD2B1: var7 = EU3(); EU3(var1)  */
3044 +    0x70000004, /* 002C(:1399):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */
3045 +    0x014cf049, /* 0030(:1399):      DRD2B1: var5 = EU3(); EU3(var1,var9)  */
3046 +    0x70000004, /* 0034(:1400):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */
3047 +    0x004cf04a, /* 0038(:1400):      DRD2B1: var1 = EU3(); EU3(var1,var10)  */
3048 +    0x00000b88, /* 003C(:1403):      DRD1A: var2 = *idx1; FN=0 init=0 WS=0 RS=0 */
3049 +    0xc4030150, /* 0040(:1406):    LCDEXT: idx1 = var8, idx2 = var6; idx1 < var5; idx1 += inc2, idx2 += inc0 */
3050 +    0x8119e012, /* 0044(:1406):    LCD: idx3 = var2; ; idx3 += inc2 */
3051 +    0x03e0cf90, /* 0048(:1409):      DRD1A: *idx3 = *idx2; FN=0 init=31 WS=0 RS=0 */
3052 +    0x81188000, /* 004C(:1412):    LCD: idx1 = var2; idx1 once var0; idx1 += inc0 */
3053 +    0x000ac788, /* 0050(:1413):      DRD1A: *idx1 = *idx1; FN=0 init=0 WS=1 RS=1 */
3054 +    0xc4030000, /* 0054(:1415):    LCDEXT: idx1 = var8, idx2 = var6; idx1 once var0; idx1 += inc0, idx2 += inc0 */
3055 +    0x8199e000, /* 0058(:1415):    LCD: idx3 = var3; ; idx3 += inc0 */
3056 +    0x63e00004, /* 005C(:1418):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT init=31 WS=0 RS=0 */
3057 +    0x084cfc8b, /* 0060(:1418):      DRD2B1: idx1 = EU3(); EU3(*idx2,var11)  */
3058 +    0xd8990000, /* 0064(:1421):    LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */
3059 +    0x9999e000, /* 0068(:1421):    LCD: idx3 = idx3; ; idx3 += inc0 */
3060 +    0x60000005, /* 006C(:1422):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=5 EXT init=0 WS=0 RS=0 */
3061 +    0x0cccf841, /* 0070(:1422):      DRD2B1: *idx3 = EU3(); EU3(idx1,var1)  */
3062 +    0x81c60000, /* 0074(:1427):    LCD: idx1 = var3 + var12; idx1 once var0; idx1 += inc0 */
3063 +    0xc399021b, /* 0078(:1429):      LCDEXT: idx2 = var7; idx2 > var8; idx2 += inc3 */
3064 +    0x80198000, /* 007C(:1429):      LCD: idx3 = var0; idx3 once var0; idx3 += inc0 */
3065 +    0x00008400, /* 0080(:1430):        DRD1A: idx1 = var0; FN=0 init=0 WS=0 RS=0 */
3066 +    0x00000f08, /* 0084(:1431):      DRD1A: var3 = idx1; FN=0 init=0 WS=0 RS=0 */
3067 +    0x81988000, /* 0088(:1434):    LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */
3068 +    0x10000788, /* 008C(:1435):      DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */
3069 +    0x6000000a, /* 0090(:1436):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */
3070 +    0x080cf05f, /* 0094(:1436):      DRD2B1: idx0 = EU3(); EU3(var1)  */
3071 +    0xc2188209, /* 0098(:1439):    LCDEXT: idx1 = var4; idx1 != var8; idx1 += inc1 */
3072 +    0x80190000, /* 009C(:1439):    LCD: idx2 = var0; idx2 once var0; idx2 += inc0 */
3073 +    0x040001f8, /* 00A0(:1440):      DRD1A: FN=0 INT init=0 WS=0 RS=0 */
3074 +    0x000001f8, /* 00A4(:0):    NOP */
3075  };
3076  u32 MCD_ENetXmit_TDT[]=
3077  {
3078 -    0x80004000, /* 0000(:1465):  LCDEXT: idx0 = 0x00000000; ; */
3079 -    0x81988000, /* 0004(:1465):  LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */
3080 -    0x10000788, /* 0008(:1466):    DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */
3081 -    0x60000009, /* 000C(:1467):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=9 EXT init=0 WS=0 RS=0 */
3082 -    0x080cf05f, /* 0010(:1467):    DRD2B1: idx0 = EU3(); EU3(var1)  */
3083 -    0x98180309, /* 0014(:1470):  LCD: idx0 = idx0; idx0 != var12; idx0 += inc1 */
3084 -    0x80004003, /* 0018(:1472):    LCDEXT: idx1 = 0x00000003; ; */
3085 -    0x81c60004, /* 001C(:1472):    LCD: idx2 = var3 + var12 + 4; idx2 once var0; idx2 += inc0 */
3086 -    0x7000000d, /* 0020(:1473):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
3087 -    0x014cf05f, /* 0024(:1473):      DRD2B1: var5 = EU3(); EU3(var1)  */
3088 -    0x7000000b, /* 0028(:1474):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=11 EXT MORE init=0 WS=0 RS=0 */
3089 -    0x028cf05f, /* 002C(:1474):      DRD2B1: var10 = EU3(); EU3(var1)  */
3090 -    0x7000000c, /* 0030(:1475):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT MORE init=0 WS=0 RS=0 */
3091 -    0x018cf05f, /* 0034(:1475):      DRD2B1: var6 = EU3(); EU3(var1)  */
3092 -    0x70000004, /* 0038(:1476):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */
3093 -    0x01ccf04d, /* 003C(:1476):      DRD2B1: var7 = EU3(); EU3(var1,var13)  */
3094 -    0x10000b90, /* 0040(:1477):      DRD1A: var2 = *idx2; FN=0 MORE init=0 WS=0 RS=0 */
3095 -    0x60000004, /* 0044(:1478):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT init=0 WS=0 RS=0 */
3096 -    0x020cf0a1, /* 0048(:1478):      DRD2B1: var8 = EU3(); EU3(var2,idx1)  */
3097 -    0xc3188312, /* 004C(:1481):    LCDEXT: idx1 = var6; idx1 > var12; idx1 += inc2 */
3098 -    0x83c70000, /* 0050(:1481):    LCD: idx2 = var7 + var14; idx2 once var0; idx2 += inc0 */
3099 -    0x00001f10, /* 0054(:1482):      DRD1A: var7 = idx2; FN=0 init=0 WS=0 RS=0 */
3100 -    0xc583a3c3, /* 0058(:1484):    LCDEXT: idx1 = var11, idx2 = var7; idx2 >= var15; idx1 += inc0, idx2 += inc3 */
3101 -    0x81042325, /* 005C(:1484):    LCD: idx3 = var2, idx4 = var8; idx4 == var12; idx3 += inc4, idx4 += inc5 */
3102 -    0x03e0c798, /* 0060(:1489):      DRD1A: *idx1 = *idx3; FN=0 init=31 WS=0 RS=0 */
3103 -    0xd8990000, /* 0064(:1492):    LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */
3104 -    0x9999e000, /* 0068(:1492):    LCD: idx3 = idx3; ; idx3 += inc0 */
3105 -    0x000acf98, /* 006C(:1493):      DRD1A: *idx3 = *idx3; FN=0 init=0 WS=1 RS=1 */
3106 -    0xd8992306, /* 0070(:1495):    LCDEXT: idx1 = idx1, idx2 = idx2; idx2 > var12; idx1 += inc0, idx2 += inc6 */
3107 -    0x9999e03f, /* 0074(:1495):    LCD: idx3 = idx3; ; idx3 += inc7 */
3108 -    0x03eac798, /* 0078(:1498):      DRD1A: *idx1 = *idx3; FN=0 init=31 WS=1 RS=1 */
3109 -    0xd8990000, /* 007C(:1501):    LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */
3110 -    0x9999e000, /* 0080(:1501):    LCD: idx3 = idx3; ; idx3 += inc0 */
3111 -    0x000acf98, /* 0084(:1502):      DRD1A: *idx3 = *idx3; FN=0 init=0 WS=1 RS=1 */
3112 -    0xd8990000, /* 0088(:1504):    LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */
3113 -    0x99832302, /* 008C(:1504):    LCD: idx3 = idx3, idx4 = var6; idx4 > var12; idx3 += inc0, idx4 += inc2 */
3114 -    0x0beac798, /* 0090(:1507):      DRD1A: *idx1 = *idx3; FN=0 TFD init=31 WS=1 RS=1 */
3115 -    0x81988000, /* 0094(:1509):    LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */
3116 -    0x6000000a, /* 0098(:1510):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */
3117 -    0x0c4cfc5f, /* 009C(:1510):      DRD2B1: *idx1 = EU3(); EU3(*idx1)  */
3118 -    0x81c80000, /* 00A0(:1512):    LCD: idx1 = var3 + var16; idx1 once var0; idx1 += inc0 */
3119 -    0xc5190312, /* 00A4(:1514):      LCDEXT: idx2 = var10; idx2 > var12; idx2 += inc2 */
3120 -    0x80198000, /* 00A8(:1514):      LCD: idx3 = var0; idx3 once var0; idx3 += inc0 */
3121 -    0x00008400, /* 00AC(:1515):        DRD1A: idx1 = var0; FN=0 init=0 WS=0 RS=0 */
3122 -    0x00000f08, /* 00B0(:1516):      DRD1A: var3 = idx1; FN=0 init=0 WS=0 RS=0 */
3123 -    0x81988000, /* 00B4(:1519):    LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */
3124 -    0x10000788, /* 00B8(:1520):      DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */
3125 -    0x60000009, /* 00BC(:1521):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=9 EXT init=0 WS=0 RS=0 */
3126 -    0x080cf05f, /* 00C0(:1521):      DRD2B1: idx0 = EU3(); EU3(var1)  */
3127 -    0xc2988309, /* 00C4(:1524):    LCDEXT: idx1 = var5; idx1 != var12; idx1 += inc1 */
3128 -    0x80190000, /* 00C8(:1524):    LCD: idx2 = var0; idx2 once var0; idx2 += inc0 */
3129 -    0x040001f8, /* 00CC(:1525):      DRD1A: FN=0 INT init=0 WS=0 RS=0 */
3130 +    0x80004000, /* 0000(:1515):  LCDEXT: idx0 = 0x00000000; ; */
3131 +    0x81988000, /* 0004(:1515):  LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */
3132 +    0x10000788, /* 0008(:1516):    DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */
3133 +    0x6000000a, /* 000C(:1517):    DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */
3134 +    0x080cf05f, /* 0010(:1517):    DRD2B1: idx0 = EU3(); EU3(var1)  */
3135 +    0x98180309, /* 0014(:1520):  LCD: idx0 = idx0; idx0 != var12; idx0 += inc1 */
3136 +    0x80004003, /* 0018(:1522):    LCDEXT: idx1 = 0x00000003; ; */
3137 +    0x81c60004, /* 001C(:1522):    LCD: idx2 = var3 + var12 + 4; idx2 once var0; idx2 += inc0 */
3138 +    0x7000000e, /* 0020(:1523):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */
3139 +    0x014cf05f, /* 0024(:1523):      DRD2B1: var5 = EU3(); EU3(var1)  */
3140 +    0x7000000c, /* 0028(:1524):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT MORE init=0 WS=0 RS=0 */
3141 +    0x028cf05f, /* 002C(:1524):      DRD2B1: var10 = EU3(); EU3(var1)  */
3142 +    0x7000000d, /* 0030(:1525):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */
3143 +    0x018cf05f, /* 0034(:1525):      DRD2B1: var6 = EU3(); EU3(var1)  */
3144 +    0x70000004, /* 0038(:1526):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */
3145 +    0x01ccf04d, /* 003C(:1526):      DRD2B1: var7 = EU3(); EU3(var1,var13)  */
3146 +    0x10000b90, /* 0040(:1527):      DRD1A: var2 = *idx2; FN=0 MORE init=0 WS=0 RS=0 */
3147 +    0x60000004, /* 0044(:1528):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT init=0 WS=0 RS=0 */
3148 +    0x020cf0a1, /* 0048(:1528):      DRD2B1: var8 = EU3(); EU3(var2,idx1)  */
3149 +    0xc3188312, /* 004C(:1531):    LCDEXT: idx1 = var6; idx1 > var12; idx1 += inc2 */
3150 +    0x83c70000, /* 0050(:1531):    LCD: idx2 = var7 + var14; idx2 once var0; idx2 += inc0 */
3151 +    0x00001f10, /* 0054(:1532):      DRD1A: var7 = idx2; FN=0 init=0 WS=0 RS=0 */
3152 +    0xc583a3c3, /* 0058(:1534):    LCDEXT: idx1 = var11, idx2 = var7; idx2 >= var15; idx1 += inc0, idx2 += inc3 */
3153 +    0x81042325, /* 005C(:1534):    LCD: idx3 = var2, idx4 = var8; idx4 == var12; idx3 += inc4, idx4 += inc5 */
3154 +    0x03e0c798, /* 0060(:1539):      DRD1A: *idx1 = *idx3; FN=0 init=31 WS=0 RS=0 */
3155 +    0xd8990000, /* 0064(:1542):    LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */
3156 +    0x9999e000, /* 0068(:1542):    LCD: idx3 = idx3; ; idx3 += inc0 */
3157 +    0x000acf98, /* 006C(:1543):      DRD1A: *idx3 = *idx3; FN=0 init=0 WS=1 RS=1 */
3158 +    0xd8992306, /* 0070(:1545):    LCDEXT: idx1 = idx1, idx2 = idx2; idx2 > var12; idx1 += inc0, idx2 += inc6 */
3159 +    0x9999e03f, /* 0074(:1545):    LCD: idx3 = idx3; ; idx3 += inc7 */
3160 +    0x03eac798, /* 0078(:1548):      DRD1A: *idx1 = *idx3; FN=0 init=31 WS=1 RS=1 */
3161 +    0xd8990000, /* 007C(:1551):    LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */
3162 +    0x9999e000, /* 0080(:1551):    LCD: idx3 = idx3; ; idx3 += inc0 */
3163 +    0x000acf98, /* 0084(:1552):      DRD1A: *idx3 = *idx3; FN=0 init=0 WS=1 RS=1 */
3164 +    0xd8990000, /* 0088(:1554):    LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */
3165 +    0x99832302, /* 008C(:1554):    LCD: idx3 = idx3, idx4 = var6; idx4 > var12; idx3 += inc0, idx4 += inc2 */
3166 +    0x0beac798, /* 0090(:1557):      DRD1A: *idx1 = *idx3; FN=0 TFD init=31 WS=1 RS=1 */
3167 +    0x81988000, /* 0094(:1559):    LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */
3168 +    0x6000000b, /* 0098(:1560):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=11 EXT init=0 WS=0 RS=0 */
3169 +    0x0c4cfc5f, /* 009C(:1560):      DRD2B1: *idx1 = EU3(); EU3(*idx1)  */
3170 +    0x81c80000, /* 00A0(:1562):    LCD: idx1 = var3 + var16; idx1 once var0; idx1 += inc0 */
3171 +    0xc5190312, /* 00A4(:1564):      LCDEXT: idx2 = var10; idx2 > var12; idx2 += inc2 */
3172 +    0x80198000, /* 00A8(:1564):      LCD: idx3 = var0; idx3 once var0; idx3 += inc0 */
3173 +    0x00008400, /* 00AC(:1565):        DRD1A: idx1 = var0; FN=0 init=0 WS=0 RS=0 */
3174 +    0x00000f08, /* 00B0(:1566):      DRD1A: var3 = idx1; FN=0 init=0 WS=0 RS=0 */
3175 +    0x81988000, /* 00B4(:1569):    LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */
3176 +    0x10000788, /* 00B8(:1570):      DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */
3177 +    0x6000000a, /* 00BC(:1571):      DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */
3178 +    0x080cf05f, /* 00C0(:1571):      DRD2B1: idx0 = EU3(); EU3(var1)  */
3179 +    0xc2988309, /* 00C4(:1574):    LCDEXT: idx1 = var5; idx1 != var12; idx1 += inc1 */
3180 +    0x80190000, /* 00C8(:1574):    LCD: idx2 = var0; idx2 once var0; idx2 += inc0 */
3181 +    0x040001f8, /* 00CC(:1575):      DRD1A: FN=0 INT init=0 WS=0 RS=0 */
3182      0x000001f8, /* 00D0(:0):    NOP */
3183  };
3184
3185 +#ifdef MCD_INCLUDE_EU
3186 +MCD_bufDesc MCD_singleBufDescs[NCHANNELS];
3187 +#endif
3188 --- a/drivers/dma/MCD_tasksInit.c
3189 +++ b/drivers/dma/MCD_tasksInit.c
3190 @@ -1,51 +1,34 @@
3191 -/*********************************************************************
3192 - *
3193 - * Copyright (C) 2004  Motorola, Inc.
3194 - *     MOTOROLA, INC. All Rights Reserved.
3195 - *  You are hereby granted a copyright license to use
3196 - *  the SOFTWARE so long as this entire notice is
3197 - *  retained without alteration in any modified and/or redistributed
3198 - *  versions, and that such modified versions are clearly identified
3199 - *  as such. No licenses are granted by implication, estoppel or
3200 - *  otherwise under any patents or trademarks of Motorola, Inc. This
3201 - *  software is provided on an "AS IS" basis and without warranty.
3202 - *
3203 - *  To the maximum extent permitted by applicable law, MOTOROLA
3204 - *  DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED, INCLUDING
3205 - *  IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR
3206 - *  PURPOSE AND ANY WARRANTY AGAINST INFRINGEMENT WITH REGARD TO THE
3207 - *  SOFTWARE (INCLUDING ANY MODIFIED VERSIONS THEREOF) AND ANY
3208 - *  ACCOMPANYING WRITTEN MATERIALS.
3209 - *
3210 - *  To the maximum extent permitted by applicable law, IN NO EVENT
3211 - *  SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER (INCLUDING
3212 - *  WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS
3213 - *  INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY
3214 - *  LOSS) ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.
3215 - *
3216 - *  Motorola assumes no responsibility for the maintenance and support
3217 - *  of this software
3218 - ********************************************************************/
3219  /*
3220 - * Do not edit!
3221 - */
3222 - /*
3223 - * File:               MCD_tasksInit.c
3224 - * Purpose:            Function for initialize variable tables of different
3225 - *              types of tasks.
3226 + * drivers/dma/MCD_tasksInit.c
3227   *
3228 - * Notes:
3229 + * Copyright (C) 2004-2008 Freescale Semiconductor, Inc.
3230 + *     Kurt Mahan <kmahan@freescale.com>
3231   *
3232 + * This program is free software; you can redistribute it and/or
3233 + * modify it under the terms of the GNU General Public License as
3234 + * published by the Free Software Foundation; either version 2 of
3235 + * the License, or (at your option) any later version.
3236   *
3237 - * Modifications:
3238 - *
3239 + * This program is distributed in the hope that it will be useful,
3240 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
3241 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3242 + * GNU General Public License for more details.
3243   *
3244 - */
3245 + * You should have received a copy of the GNU General Public License
3246 + * along with this program; if not, write to the Free Software
3247 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
3248 + * MA 02111-1307 USA
3249 + */
3250
3251 -#include <asm/MCD_dma.h>
3252 +/*
3253 + * Autogenerated - Do not edit!
3254 + */
3255 +
3256 +#include "MCD_dma.h"
3257
3258  extern dmaRegs *MCD_dmaBar;
3259
3260 +
3261  /*
3262   * Task 0
3263   */
3264 @@ -53,232 +36,203 @@ extern dmaRegs *MCD_dmaBar;
3265  void  MCD_startDmaChainNoEu(int *currBD, short srcIncr, short destIncr, int xferSize, short xferSizeIncr, int *cSave, volatile TaskTableEntry *taskTable, int channel)
3266  {
3267
3268 -       MCD_SET_VAR(taskTable+channel, 2, (u32)currBD); /* var[2] */
3269 -       MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr));   /* inc[1] */
3270 -       MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr));  /* inc[0] */
3271 -       MCD_SET_VAR(taskTable+channel, 19, (u32)xferSize);      /* var[19] */
3272 -       MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr));      /* inc[2] */
3273 -       MCD_SET_VAR(taskTable+channel, 0, (u32)cSave);  /* var[0] */
3274 -       MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000);     /* var[1] */
3275 -       MCD_SET_VAR(taskTable+channel, 3, (u32)0x00000000);     /* var[3] */
3276 -       MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000);     /* var[4] */
3277 -       MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000);     /* var[5] */
3278 -       MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000);     /* var[6] */
3279 -       MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000);     /* var[7] */
3280 -       MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000);     /* var[8] */
3281 -       MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000);     /* var[9] */
3282 -       MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000000);    /* var[10] */
3283 -       MCD_SET_VAR(taskTable+channel, 11, (u32)0x00000000);    /* var[11] */
3284 -       MCD_SET_VAR(taskTable+channel, 12, (u32)0x00000000);    /* var[12] */
3285 -       MCD_SET_VAR(taskTable+channel, 13, (u32)0x00000000);    /* var[13] */
3286 -       MCD_SET_VAR(taskTable+channel, 14, (u32)0x00000000);    /* var[14] */
3287 -       MCD_SET_VAR(taskTable+channel, 15, (u32)0x00000000);    /* var[15] */
3288 -       MCD_SET_VAR(taskTable+channel, 16, (u32)0x00000000);    /* var[16] */
3289 -       MCD_SET_VAR(taskTable+channel, 17, (u32)0x00000000);    /* var[17] */
3290 -       MCD_SET_VAR(taskTable+channel, 18, (u32)0x00000000);    /* var[18] */
3291 -       MCD_SET_VAR(taskTable+channel, 20, (u32)0x00000000);    /* var[20] */
3292 -       MCD_SET_VAR(taskTable+channel, 21, (u32)0x00000010);    /* var[21] */
3293 -       MCD_SET_VAR(taskTable+channel, 22, (u32)0x00000004);    /* var[22] */
3294 -       MCD_SET_VAR(taskTable+channel, 23, (u32)0x00000080);    /* var[23] */
3295 -       MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000);    /* inc[3] */
3296 -       MCD_SET_VAR(taskTable+channel, 28, (u32)0x60000000);    /* inc[4] */
3297 -       MCD_SET_VAR(taskTable+channel, 29, (u32)0x80000001);    /* inc[5] */
3298 -       MCD_SET_VAR(taskTable+channel, 30, (u32)0x80000000);    /* inc[6] */
3299 -       MCD_SET_VAR(taskTable+channel, 31, (u32)0x40000000);    /* inc[7] */
3300 +    MCD_SET_VAR(taskTable+channel, 2, (u32)currBD); /* var[2] */
3301 +    MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr));   /* inc[1] */
3302 +    MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr));  /* inc[0] */
3303 +    MCD_SET_VAR(taskTable+channel, 11, (u32)xferSize);  /* var[11] */
3304 +    MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr));  /* inc[2] */
3305 +    MCD_SET_VAR(taskTable+channel, 0, (u32)cSave);  /* var[0] */
3306 +    MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */
3307 +    MCD_SET_VAR(taskTable+channel, 3, (u32)0x00000000); /* var[3] */
3308 +    MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */
3309 +    MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */
3310 +    MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000); /* var[6] */
3311 +    MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */
3312 +    MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */
3313 +    MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000); /* var[9] */
3314 +    MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000000);    /* var[10] */
3315 +    MCD_SET_VAR(taskTable+channel, 12, (u32)0x00000000);    /* var[12] */
3316 +    MCD_SET_VAR(taskTable+channel, 13, (u32)0x80000000);    /* var[13] */
3317 +    MCD_SET_VAR(taskTable+channel, 14, (u32)0x00000010);    /* var[14] */
3318 +    MCD_SET_VAR(taskTable+channel, 15, (u32)0x00000004);    /* var[15] */
3319 +    MCD_SET_VAR(taskTable+channel, 16, (u32)0x08000000);    /* var[16] */
3320 +    MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000);    /* inc[3] */
3321 +    MCD_SET_VAR(taskTable+channel, 28, (u32)0x80000000);    /* inc[4] */
3322 +    MCD_SET_VAR(taskTable+channel, 29, (u32)0x80000001);    /* inc[5] */
3323 +    MCD_SET_VAR(taskTable+channel, 30, (u32)0x40000000);    /* inc[6] */
3324
3325      /* Set the task's Enable bit in its Task Control Register */
3326 -    MCD_dmaBar->taskControl[channel] |= (u16)0x8000; /* add a MACRO HERE TBD*/
3327 -
3328 -
3329 +    MCD_dmaBar->taskControl[channel] |= (u16)0x8000;
3330  }
3331
3332
3333  /*
3334   * Task 1
3335   */
3336 -
3337 -void  MCD_startDmaSingleNoEu(char *srcAddr, short srcIncr, char *destAddr, short destIncr, int dmaSize, int dmaSizeMXferSize, short xferSizeIncr, int flags, int *currBD, int *cSave, volatile TaskTableEntry *taskTable, int channel)
3338 +
3339 +void  MCD_startDmaSingleNoEu(char *srcAddr, short srcIncr, char *destAddr, short destIncr, int dmaSize, short xferSizeIncr, int flags, int *currBD, int *cSave, volatile TaskTableEntry *taskTable, int channel)
3340  {
3341 -
3342 -       MCD_SET_VAR(taskTable+channel, 13, (u32)srcAddr);       /* var[13] */
3343 -       MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr));   /* inc[1] */
3344 -       MCD_SET_VAR(taskTable+channel, 4, (u32)destAddr);       /* var[4] */
3345 -       MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr));  /* inc[0] */
3346 -       MCD_SET_VAR(taskTable+channel, 6, (u32)dmaSize);        /* var[6] */
3347 -       MCD_SET_VAR(taskTable+channel, 7, (u32)dmaSizeMXferSize);       /* var[7] */
3348 -       MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr));      /* inc[2] */
3349 -       MCD_SET_VAR(taskTable+channel, 9, (u32)flags);  /* var[9] */
3350 -       MCD_SET_VAR(taskTable+channel, 1, (u32)currBD); /* var[1] */
3351 -       MCD_SET_VAR(taskTable+channel, 0, (u32)cSave);  /* var[0] */
3352 -       MCD_SET_VAR(taskTable+channel, 2, (u32)0x00000000);     /* var[2] */
3353 -       MCD_SET_VAR(taskTable+channel, 3, (u32)0x00000000);     /* var[3] */
3354 -       MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000);     /* var[5] */
3355 -       MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000);     /* var[8] */
3356 -       MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000000);    /* var[10] */
3357 -       MCD_SET_VAR(taskTable+channel, 11, (u32)0x00000000);    /* var[11] */
3358 -       MCD_SET_VAR(taskTable+channel, 12, (u32)0x00000000);    /* var[12] */
3359 -       MCD_SET_VAR(taskTable+channel, 14, (u32)0x00000000);    /* var[14] */
3360 -       MCD_SET_VAR(taskTable+channel, 15, (u32)0x00000000);    /* var[15] */
3361 -       MCD_SET_VAR(taskTable+channel, 16, (u32)0x00000004);    /* var[16] */
3362 -       MCD_SET_VAR(taskTable+channel, 17, (u32)0x00000080);    /* var[17] */
3363 -       MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000);    /* inc[3] */
3364 -       MCD_SET_VAR(taskTable+channel, 28, (u32)0x80000001);    /* inc[4] */
3365 -       MCD_SET_VAR(taskTable+channel, 29, (u32)0x40000000);    /* inc[5] */
3366
3367 +    MCD_SET_VAR(taskTable+channel, 7, (u32)srcAddr);    /* var[7] */
3368 +    MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr));   /* inc[1] */
3369 +    MCD_SET_VAR(taskTable+channel, 2, (u32)destAddr);   /* var[2] */
3370 +    MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr));  /* inc[0] */
3371 +    MCD_SET_VAR(taskTable+channel, 3, (u32)dmaSize);    /* var[3] */
3372 +    MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr));  /* inc[2] */
3373 +    MCD_SET_VAR(taskTable+channel, 5, (u32)flags);  /* var[5] */
3374 +    MCD_SET_VAR(taskTable+channel, 1, (u32)currBD); /* var[1] */
3375 +    MCD_SET_VAR(taskTable+channel, 0, (u32)cSave);  /* var[0] */
3376 +    MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */
3377 +    MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000); /* var[6] */
3378 +    MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */
3379 +    MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000004); /* var[9] */
3380 +    MCD_SET_VAR(taskTable+channel, 10, (u32)0x08000000);    /* var[10] */
3381 +    MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000);    /* inc[3] */
3382 +    MCD_SET_VAR(taskTable+channel, 28, (u32)0x80000001);    /* inc[4] */
3383 +    MCD_SET_VAR(taskTable+channel, 29, (u32)0x40000000);    /* inc[5] */
3384
3385 -    /* enable the task */
3386 -    MCD_dmaBar->taskControl[channel] |= (u16)0x8000; /* add a MACRO HERE TBD*/
3387 +    /* Set the task's Enable bit in its Task Control Register */
3388 +    MCD_dmaBar->taskControl[channel] |= (u16)0x8000;
3389  }
3390
3391
3392  /*
3393   * Task 2
3394   */
3395 -
3396 +
3397  void  MCD_startDmaChainEu(int *currBD, short srcIncr, short destIncr, int xferSize, short xferSizeIncr, int *cSave, volatile TaskTableEntry *taskTable, int channel)
3398  {
3399 -
3400 -       MCD_SET_VAR(taskTable+channel, 2, (u32)currBD); /* var[2] */
3401 -       MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr));   /* inc[1] */
3402 -       MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr));  /* inc[0] */
3403 -       MCD_SET_VAR(taskTable+channel, 19, (u32)xferSize);      /* var[19] */
3404 -       MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr));      /* inc[2] */
3405 -       MCD_SET_VAR(taskTable+channel, 0, (u32)cSave);  /* var[0] */
3406 -       MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000);     /* var[1] */
3407 -       MCD_SET_VAR(taskTable+channel, 3, (u32)0x00000000);     /* var[3] */
3408 -       MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000);     /* var[4] */
3409 -       MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000);     /* var[5] */
3410 -       MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000);     /* var[6] */
3411 -       MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000);     /* var[7] */
3412 -       MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000);     /* var[8] */
3413 -       MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000);     /* var[9] */
3414 -       MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000000);    /* var[10] */
3415 -       MCD_SET_VAR(taskTable+channel, 11, (u32)0x00000000);    /* var[11] */
3416 -       MCD_SET_VAR(taskTable+channel, 12, (u32)0x00000000);    /* var[12] */
3417 -       MCD_SET_VAR(taskTable+channel, 13, (u32)0x00000000);    /* var[13] */
3418 -       MCD_SET_VAR(taskTable+channel, 14, (u32)0x00000000);    /* var[14] */
3419 -       MCD_SET_VAR(taskTable+channel, 15, (u32)0x00000000);    /* var[15] */
3420 -       MCD_SET_VAR(taskTable+channel, 16, (u32)0x00000000);    /* var[16] */
3421 -       MCD_SET_VAR(taskTable+channel, 17, (u32)0x00000000);    /* var[17] */
3422 -       MCD_SET_VAR(taskTable+channel, 18, (u32)0x00000000);    /* var[18] */
3423 -       MCD_SET_VAR(taskTable+channel, 20, (u32)0x00000000);    /* var[20] */
3424 -       MCD_SET_VAR(taskTable+channel, 21, (u32)0x00000010);    /* var[21] */
3425 -       MCD_SET_VAR(taskTable+channel, 22, (u32)0x00000004);    /* var[22] */
3426 -       MCD_SET_VAR(taskTable+channel, 23, (u32)0x00000080);    /* var[23] */
3427 -       MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000);    /* inc[3] */
3428 -       MCD_SET_VAR(taskTable+channel, 28, (u32)0x60000000);    /* inc[4] */
3429 -       MCD_SET_VAR(taskTable+channel, 29, (u32)0x80000001);    /* inc[5] */
3430 -       MCD_SET_VAR(taskTable+channel, 30, (u32)0x80000000);    /* inc[6] */
3431 -       MCD_SET_VAR(taskTable+channel, 31, (u32)0x40000000);    /* inc[7] */
3432
3433 -    /*enable the task*/
3434 -    MCD_dmaBar->taskControl[channel] |= (u16)0x8000; /* add a MACRO HERE TBD*/
3435 +    MCD_SET_VAR(taskTable+channel, 3, (u32)currBD); /* var[3] */
3436 +    MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr));   /* inc[1] */
3437 +    MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr));  /* inc[0] */
3438 +    MCD_SET_VAR(taskTable+channel, 12, (u32)xferSize);  /* var[12] */
3439 +    MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr));  /* inc[2] */
3440 +    MCD_SET_VAR(taskTable+channel, 0, (u32)cSave);  /* var[0] */
3441 +    MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */
3442 +    MCD_SET_VAR(taskTable+channel, 2, (u32)0x00000000); /* var[2] */
3443 +    MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */
3444 +    MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */
3445 +    MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000); /* var[6] */
3446 +    MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */
3447 +    MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */
3448 +    MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000); /* var[9] */
3449 +    MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000000);    /* var[10] */
3450 +    MCD_SET_VAR(taskTable+channel, 11, (u32)0x00000000);    /* var[11] */
3451 +    MCD_SET_VAR(taskTable+channel, 13, (u32)0x00000000);    /* var[13] */
3452 +    MCD_SET_VAR(taskTable+channel, 14, (u32)0x80000000);    /* var[14] */
3453 +    MCD_SET_VAR(taskTable+channel, 15, (u32)0x00000010);    /* var[15] */
3454 +    MCD_SET_VAR(taskTable+channel, 16, (u32)0x00000001);    /* var[16] */
3455 +    MCD_SET_VAR(taskTable+channel, 17, (u32)0x00000004);    /* var[17] */
3456 +    MCD_SET_VAR(taskTable+channel, 18, (u32)0x08000000);    /* var[18] */
3457 +    MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000);    /* inc[3] */
3458 +    MCD_SET_VAR(taskTable+channel, 28, (u32)0x80000000);    /* inc[4] */
3459 +    MCD_SET_VAR(taskTable+channel, 29, (u32)0xc0000000);    /* inc[5] */
3460 +    MCD_SET_VAR(taskTable+channel, 30, (u32)0x80000001);    /* inc[6] */
3461 +    MCD_SET_VAR(taskTable+channel, 31, (u32)0x40000000);    /* inc[7] */
3462 +
3463 +    /* Set the task's Enable bit in its Task Control Register */
3464 +    MCD_dmaBar->taskControl[channel] |= (u16)0x8000;
3465  }
3466
3467
3468  /*
3469   * Task 3
3470   */
3471 -
3472 -void  MCD_startDmaSingleEu(char *srcAddr, short srcIncr, char *destAddr, short destIncr, int dmaSize, int dmaSizeMXferSize, short xferSizeIncr, int flags, int *currBD, int *cSave, volatile TaskTableEntry *taskTable, int channel)
3473 +
3474 +void  MCD_startDmaSingleEu(char *srcAddr, short srcIncr, char *destAddr, short destIncr, int dmaSize, short xferSizeIncr, int flags, int *currBD, int *cSave, volatile TaskTableEntry *taskTable, int channel)
3475  {
3476 -
3477 -       MCD_SET_VAR(taskTable+channel, 13, (u32)srcAddr);       /* var[13] */
3478 -       MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr));   /* inc[1] */
3479 -       MCD_SET_VAR(taskTable+channel, 4, (u32)destAddr);       /* var[4] */
3480 -       MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr));  /* inc[0] */
3481 -       MCD_SET_VAR(taskTable+channel, 6, (u32)dmaSize);        /* var[6] */
3482 -       MCD_SET_VAR(taskTable+channel, 7, (u32)dmaSizeMXferSize);       /* var[7] */
3483 -       MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr));      /* inc[2] */
3484 -       MCD_SET_VAR(taskTable+channel, 9, (u32)flags);  /* var[9] */
3485 -       MCD_SET_VAR(taskTable+channel, 1, (u32)currBD); /* var[1] */
3486 -       MCD_SET_VAR(taskTable+channel, 0, (u32)cSave);  /* var[0] */
3487 -       MCD_SET_VAR(taskTable+channel, 2, (u32)0x00000000);     /* var[2] */
3488 -       MCD_SET_VAR(taskTable+channel, 3, (u32)0x00000000);     /* var[3] */
3489 -       MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000);     /* var[5] */
3490 -       MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000);     /* var[8] */
3491 -       MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000000);    /* var[10] */
3492 -       MCD_SET_VAR(taskTable+channel, 11, (u32)0x00000000);    /* var[11] */
3493 -       MCD_SET_VAR(taskTable+channel, 12, (u32)0x00000000);    /* var[12] */
3494 -       MCD_SET_VAR(taskTable+channel, 14, (u32)0x00000000);    /* var[14] */
3495 -       MCD_SET_VAR(taskTable+channel, 15, (u32)0x00000000);    /* var[15] */
3496 -       MCD_SET_VAR(taskTable+channel, 16, (u32)0x00000004);    /* var[16] */
3497 -       MCD_SET_VAR(taskTable+channel, 17, (u32)0x00000080);    /* var[17] */
3498 -       MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000);    /* inc[3] */
3499 -       MCD_SET_VAR(taskTable+channel, 28, (u32)0x80000001);    /* inc[4] */
3500 -       MCD_SET_VAR(taskTable+channel, 29, (u32)0x40000000);    /* inc[5] */
3501
3502 -    /*enable the task*/
3503 -    MCD_dmaBar->taskControl[channel] |= (u16)0x8000; /* add a MACRO HERE TBD*/
3504 +    MCD_SET_VAR(taskTable+channel, 8, (u32)srcAddr);    /* var[8] */
3505 +    MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr));   /* inc[1] */
3506 +    MCD_SET_VAR(taskTable+channel, 3, (u32)destAddr);   /* var[3] */
3507 +    MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr));  /* inc[0] */
3508 +    MCD_SET_VAR(taskTable+channel, 4, (u32)dmaSize);    /* var[4] */
3509 +    MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr));  /* inc[2] */
3510 +    MCD_SET_VAR(taskTable+channel, 6, (u32)flags);  /* var[6] */
3511 +    MCD_SET_VAR(taskTable+channel, 2, (u32)currBD); /* var[2] */
3512 +    MCD_SET_VAR(taskTable+channel, 0, (u32)cSave);  /* var[0] */
3513 +    MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */
3514 +    MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */
3515 +    MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */
3516 +    MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000); /* var[9] */
3517 +    MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000001);    /* var[10] */
3518 +    MCD_SET_VAR(taskTable+channel, 11, (u32)0x00000004);    /* var[11] */
3519 +    MCD_SET_VAR(taskTable+channel, 12, (u32)0x08000000);    /* var[12] */
3520 +    MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000);    /* inc[3] */
3521 +    MCD_SET_VAR(taskTable+channel, 28, (u32)0xc0000000);    /* inc[4] */
3522 +    MCD_SET_VAR(taskTable+channel, 29, (u32)0x80000000);    /* inc[5] */
3523 +    MCD_SET_VAR(taskTable+channel, 30, (u32)0x80000001);    /* inc[6] */
3524 +    MCD_SET_VAR(taskTable+channel, 31, (u32)0x40000000);    /* inc[7] */
3525
3526 +    /* Set the task's Enable bit in its Task Control Register */
3527 +    MCD_dmaBar->taskControl[channel] |= (u16)0x8000;
3528  }
3529
3530
3531  /*
3532   * Task 4
3533   */
3534 -
3535 +
3536  void  MCD_startDmaENetRcv(char *bDBase, char *currBD, char *rcvFifoPtr, volatile TaskTableEntry *taskTable, int channel)
3537  {
3538 -
3539 -       MCD_SET_VAR(taskTable+channel, 0, (u32)bDBase); /* var[0] */
3540 -       MCD_SET_VAR(taskTable+channel, 4, (u32)currBD); /* var[4] */
3541 -       MCD_SET_VAR(taskTable+channel, 7, (u32)rcvFifoPtr);     /* var[7] */
3542 -       MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000);     /* var[1] */
3543 -       MCD_SET_VAR(taskTable+channel, 2, (u32)0x00000000);     /* var[2] */
3544 -       MCD_SET_VAR(taskTable+channel, 3, (u32)0x00000000);     /* var[3] */
3545 -       MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000);     /* var[5] */
3546 -       MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000);     /* var[6] */
3547 -       MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000);     /* var[8] */
3548 -       MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000);     /* var[9] */
3549 -       MCD_SET_VAR(taskTable+channel, 10, (u32)0x0000ffff);    /* var[10] */
3550 -       MCD_SET_VAR(taskTable+channel, 11, (u32)0x30000000);    /* var[11] */
3551 -       MCD_SET_VAR(taskTable+channel, 12, (u32)0x0fffffff);    /* var[12] */
3552 -       MCD_SET_VAR(taskTable+channel, 13, (u32)0x00000008);    /* var[13] */
3553 -       MCD_SET_VAR(taskTable+channel, 24, (u32)0x00000000);    /* inc[0] */
3554 -       MCD_SET_VAR(taskTable+channel, 25, (u32)0x60000000);    /* inc[1] */
3555 -       MCD_SET_VAR(taskTable+channel, 26, (u32)0x20000004);    /* inc[2] */
3556 -       MCD_SET_VAR(taskTable+channel, 27, (u32)0x40000000);    /* inc[3] */
3557 -    /*enable the task*/
3558 -    MCD_dmaBar->taskControl[channel] |= (u16)0x8000; /* add a MACRO HERE TBD*/
3559
3560 +    MCD_SET_VAR(taskTable+channel, 0, (u32)bDBase); /* var[0] */
3561 +    MCD_SET_VAR(taskTable+channel, 3, (u32)currBD); /* var[3] */
3562 +    MCD_SET_VAR(taskTable+channel, 6, (u32)rcvFifoPtr); /* var[6] */
3563 +    MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */
3564 +    MCD_SET_VAR(taskTable+channel, 2, (u32)0x00000000); /* var[2] */
3565 +    MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */
3566 +    MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */
3567 +    MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */
3568 +    MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */
3569 +    MCD_SET_VAR(taskTable+channel, 9, (u32)0x0000ffff); /* var[9] */
3570 +    MCD_SET_VAR(taskTable+channel, 10, (u32)0x30000000);    /* var[10] */
3571 +    MCD_SET_VAR(taskTable+channel, 11, (u32)0x0fffffff);    /* var[11] */
3572 +    MCD_SET_VAR(taskTable+channel, 12, (u32)0x00000008);    /* var[12] */
3573 +    MCD_SET_VAR(taskTable+channel, 24, (u32)0x00000000);    /* inc[0] */
3574 +    MCD_SET_VAR(taskTable+channel, 25, (u32)0x60000000);    /* inc[1] */
3575 +    MCD_SET_VAR(taskTable+channel, 26, (u32)0x20000004);    /* inc[2] */
3576 +    MCD_SET_VAR(taskTable+channel, 27, (u32)0x40000000);    /* inc[3] */
3577 +
3578 +    /* Set the task's Enable bit in its Task Control Register */
3579 +    MCD_dmaBar->taskControl[channel] |= (u16)0x8000;
3580  }
3581
3582
3583  /*
3584   * Task 5
3585   */
3586 -
3587 +
3588  void  MCD_startDmaENetXmit(char *bDBase, char *currBD, char *xmitFifoPtr, volatile TaskTableEntry *taskTable, int channel)
3589  {
3590 -
3591 -       MCD_SET_VAR(taskTable+channel, 0, (u32)bDBase); /* var[0] */
3592 -       MCD_SET_VAR(taskTable+channel, 3, (u32)currBD); /* var[3] */
3593 -       MCD_SET_VAR(taskTable+channel, 11, (u32)xmitFifoPtr);   /* var[11] */
3594 -       MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000);     /* var[1] */
3595 -       MCD_SET_VAR(taskTable+channel, 2, (u32)0x00000000);     /* var[2] */
3596 -       MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000);     /* var[4] */
3597 -       MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000);     /* var[5] */
3598 -       MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000);     /* var[6] */
3599 -       MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000);     /* var[7] */
3600 -       MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000);     /* var[8] */
3601 -       MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000);     /* var[9] */
3602 -       MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000000);    /* var[10] */
3603 -       MCD_SET_VAR(taskTable+channel, 12, (u32)0x00000000);    /* var[12] */
3604 -       MCD_SET_VAR(taskTable+channel, 13, (u32)0x0000ffff);    /* var[13] */
3605 -       MCD_SET_VAR(taskTable+channel, 14, (u32)0xffffffff);    /* var[14] */
3606 -       MCD_SET_VAR(taskTable+channel, 15, (u32)0x00000004);    /* var[15] */
3607 -       MCD_SET_VAR(taskTable+channel, 16, (u32)0x00000008);    /* var[16] */
3608 -       MCD_SET_VAR(taskTable+channel, 24, (u32)0x00000000);    /* inc[0] */
3609 -       MCD_SET_VAR(taskTable+channel, 25, (u32)0x60000000);    /* inc[1] */
3610 -       MCD_SET_VAR(taskTable+channel, 26, (u32)0x40000000);    /* inc[2] */
3611 -       MCD_SET_VAR(taskTable+channel, 27, (u32)0xc000fffc);    /* inc[3] */
3612 -       MCD_SET_VAR(taskTable+channel, 28, (u32)0xe0000004);    /* inc[4] */
3613 -       MCD_SET_VAR(taskTable+channel, 29, (u32)0x80000000);    /* inc[5] */
3614 -       MCD_SET_VAR(taskTable+channel, 30, (u32)0x4000ffff);    /* inc[6] */
3615 -       MCD_SET_VAR(taskTable+channel, 31, (u32)0xe0000001);    /* inc[7] */
3616
3617 -    /*enable the task*/
3618 -    MCD_dmaBar->taskControl[channel] |= (u16)0x8000; /* add a MACRO HERE TBD*/
3619 +    MCD_SET_VAR(taskTable+channel, 0, (u32)bDBase); /* var[0] */
3620 +    MCD_SET_VAR(taskTable+channel, 3, (u32)currBD); /* var[3] */
3621 +    MCD_SET_VAR(taskTable+channel, 11, (u32)xmitFifoPtr);   /* var[11] */
3622 +    MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */
3623 +    MCD_SET_VAR(taskTable+channel, 2, (u32)0x00000000); /* var[2] */
3624 +    MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */
3625 +    MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */
3626 +    MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000); /* var[6] */
3627 +    MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */
3628 +    MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */
3629 +    MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000); /* var[9] */
3630 +    MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000000);    /* var[10] */
3631 +    MCD_SET_VAR(taskTable+channel, 12, (u32)0x00000000);    /* var[12] */
3632 +    MCD_SET_VAR(taskTable+channel, 13, (u32)0x0000ffff);    /* var[13] */
3633 +    MCD_SET_VAR(taskTable+channel, 14, (u32)0xffffffff);    /* var[14] */
3634 +    MCD_SET_VAR(taskTable+channel, 15, (u32)0x00000004);    /* var[15] */
3635 +    MCD_SET_VAR(taskTable+channel, 16, (u32)0x00000008);    /* var[16] */
3636 +    MCD_SET_VAR(taskTable+channel, 24, (u32)0x00000000);    /* inc[0] */
3637 +    MCD_SET_VAR(taskTable+channel, 25, (u32)0x60000000);    /* inc[1] */
3638 +    MCD_SET_VAR(taskTable+channel, 26, (u32)0x40000000);    /* inc[2] */
3639 +    MCD_SET_VAR(taskTable+channel, 27, (u32)0xc000fffc);    /* inc[3] */
3640 +    MCD_SET_VAR(taskTable+channel, 28, (u32)0xe0000004);    /* inc[4] */
3641 +    MCD_SET_VAR(taskTable+channel, 29, (u32)0x80000000);    /* inc[5] */
3642 +    MCD_SET_VAR(taskTable+channel, 30, (u32)0x4000ffff);    /* inc[6] */
3643 +    MCD_SET_VAR(taskTable+channel, 31, (u32)0xe0000001);    /* inc[7] */
3644
3645 +    /* Set the task's Enable bit in its Task Control Register */
3646 +    MCD_dmaBar->taskControl[channel] |= (u16)0x8000;
3647  }
3648 --- a/drivers/dma/MCD_tasksInit.h
3649 +++ b/drivers/dma/MCD_tasksInit.h
3650 @@ -1,40 +1,31 @@
3651 -/*********************************************************************
3652 +/*
3653 + * drivers/dma/MCD_tasksInit.h
3654   *
3655 - * Copyright (C) 2004  Motorola, Inc.
3656 - *  MOTOROLA, INC. All Rights Reserved.
3657 - *  You are hereby granted a copyright license to use
3658 - *  the SOFTWARE so long as this entire notice is
3659 - *  retained without alteration in any modified and/or redistributed
3660 - *  versions, and that such modified versions are clearly identified
3661 - *  as such. No licenses are granted by implication, estoppel or
3662 - *  otherwise under any patents or trademarks of Motorola, Inc. This
3663 - *  software is provided on an "AS IS" basis and without warranty.
3664 + * Copyright (C) 2004-2008 Freescale Semiconductor, Inc.
3665 + *     Kurt Mahan <kmahan@freescale.com>
3666   *
3667 - *  To the maximum extent permitted by applicable law, MOTOROLA
3668 - *  DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED, INCLUDING
3669 - *  IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR
3670 - *  PURPOSE AND ANY WARRANTY AGAINST INFRINGEMENT WITH REGARD TO THE
3671 - *  SOFTWARE (INCLUDING ANY MODIFIED VERSIONS THEREOF) AND ANY
3672 - *  ACCOMPANYING WRITTEN MATERIALS.
3673 + * This program is free software; you can redistribute it and/or
3674 + * modify it under the terms of the GNU General Public License as
3675 + * published by the Free Software Foundation; either version 2 of
3676 + * the License, or (at your option) any later version.
3677   *
3678 - *  To the maximum extent permitted by applicable law, IN NO EVENT
3679 - *  SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER (INCLUDING
3680 - *  WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS
3681 - *  INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY
3682 - *  LOSS) ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.
3683 + * This program is distributed in the hope that it will be useful,
3684 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
3685 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3686 + * GNU General Public License for more details.
3687   *
3688 - *  Motorola assumes no responsibility for the maintenance and support
3689 - *  of this software
3690 - ********************************************************************/
3691 + * You should have received a copy of the GNU General Public License
3692 + * along with this program; if not, write to the Free Software
3693 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
3694 + * MA 02111-1307 USA
3695 + */
3696  #ifndef MCD_TSK_INIT_H
3697  #define MCD_TSK_INIT_H 1
3698
3699  /*
3700 - * Do not edit!
3701 + * Autogenerated - Do not edit!
3702   */
3703
3704 -
3705 -
3706  /*
3707   * Task 0
3708   */
3709 @@ -44,7 +35,7 @@ void  MCD_startDmaChainNoEu(int *currBD,
3710  /*
3711   * Task 1
3712   */
3713 -void  MCD_startDmaSingleNoEu(char *srcAddr, short srcIncr, char *destAddr, short destIncr, int dmaSize, int dmaSizeMXferSize, short xferSizeIncr, int flags, int *currBD, int *cSave, volatile TaskTableEntry *taskTable, int channel);
3714 +void  MCD_startDmaSingleNoEu(char *srcAddr, short srcIncr, char *destAddr, short destIncr, int dmaSize, short xferSizeIncr, int flags, int *currBD, int *cSave, volatile TaskTableEntry *taskTable, int channel);
3715
3716
3717  /*
3718 @@ -56,7 +47,7 @@ void  MCD_startDmaChainEu(int *currBD, s
3719  /*
3720   * Task 3
3721   */
3722 -void  MCD_startDmaSingleEu(char *srcAddr, short srcIncr, char *destAddr, short destIncr, int dmaSize, int dmaSizeMXferSize, short xferSizeIncr, int flags, int *currBD, int *cSave, volatile TaskTableEntry *taskTable, int channel);
3723 +void  MCD_startDmaSingleEu(char *srcAddr, short srcIncr, char *destAddr, short destIncr, int dmaSize, short xferSizeIncr, int flags, int *currBD, int *cSave, volatile TaskTableEntry *taskTable, int channel);
3724
3725
3726  /*