From 030afcd535737e3b69e22c33f8e310b337831c07 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?David=20G=C3=A1lvez?= Date: Mon, 9 Apr 2018 16:26:54 +0200 Subject: [PATCH] Sync from Fredi's source tree 13/05/2017 --- firebeeV1.mcp => BaS_2.mcp | Bin 110530 -> 110530 bytes flash_config.xml | 2 +- headers/MCD_dma.h | 362 +++ headers/MCD_dmaApi.c | 938 +++++++ headers/MCD_progCheck.h | 5 + headers/MCD_tasks.c | 2449 +++++++++++++++++ headers/MCD_tasksInit.c | 224 ++ headers/MCD_tasksInit.h | 44 + {sources => headers}/ii_add.h | 0 {sources => headers}/ii_and.h | 0 {sources => headers}/ii_dbcc.h | 0 {sources => headers}/ii_ewf.h | 0 {sources => headers}/ii_exg.h | 0 {sources => headers}/ii_func.h | 0 {sources => headers}/ii_jmp.h | 0 {sources => headers}/ii_lea.h | 0 {sources => headers}/ii_macro.h | 0 {sources => headers}/ii_move.h | 0 {sources => headers}/ii_movem.h | 1 + {sources => headers}/ii_movep.h | 0 {sources => headers}/ii_op.h | 0 {sources => headers}/ii_opc.h | 0 {sources => headers}/ii_or.h | 0 {sources => headers}/ii_pea.h | 0 {sources => headers}/ii_shd.h | 0 {sources => headers}/ii_shift.h | 0 {sources => headers}/ii_sub.h | 0 {sources => headers}/macro.h | 0 {sources => headers}/movem.h | 0 {sources => headers}/startcf.h | 6 +- {sources => headers}/sysinit.h | 0 lcf/DDRAM.lcf | 11 +- lcf/FLASH.lcf | 102 +- mcdapirev0p3/MCD_dmaApi.c | 933 +++++++ mcdapirev0p3/MCD_tasks.c | 2449 +++++++++++++++++ mcdapirev0p3/MCD_tasksInit.c | 224 ++ .../Multichannel_DMA_API_User's_Guide.pdf | Bin 0 -> 138124 bytes mcdapirev0p3/ReleaseNotes.txt | 26 + readme.txt | 152 + sources/BaS.c | 184 +- sources/MCD_dmaApi.c | 933 +++++++ sources/MCD_tasks.c | 2449 +++++++++++++++++ sources/MCD_tasksInit.c | 224 ++ sources/alt und div/BaS.c.neu | 350 +++ sources/alt und div/BaS.c.normal | 312 +++ sources/{ => alt und div}/div.s | 0 sources/{ => alt und div}/sd_ide.c | 0 sources/ewf.s | 5 +- sources/exceptions.s | 8 +- sources/illegal_instruction.s | 3 + sources/last.c | 11 - sources/last.s | 10 - sources/sd_card.c | 22 +- sources/sd_card.s | 406 --- sources/sd_ide.s | 458 --- sources/set_ide_access_mode.c | 134 + sources/startcf.c | 117 +- sources/sysinit.c | 336 ++- sources/sysinit.c.alt | 874 ++++++ 59 files changed, 13625 insertions(+), 1139 deletions(-) rename firebeeV1.mcp => BaS_2.mcp (78%) create mode 100644 headers/MCD_dma.h create mode 100644 headers/MCD_dmaApi.c create mode 100644 headers/MCD_progCheck.h create mode 100644 headers/MCD_tasks.c create mode 100644 headers/MCD_tasksInit.c create mode 100644 headers/MCD_tasksInit.h rename {sources => headers}/ii_add.h (100%) rename {sources => headers}/ii_and.h (100%) rename {sources => headers}/ii_dbcc.h (100%) rename {sources => headers}/ii_ewf.h (100%) rename {sources => headers}/ii_exg.h (100%) rename {sources => headers}/ii_func.h (100%) rename {sources => headers}/ii_jmp.h (100%) rename {sources => headers}/ii_lea.h (100%) rename {sources => headers}/ii_macro.h (100%) rename {sources => headers}/ii_move.h (100%) rename {sources => headers}/ii_movem.h (95%) rename {sources => headers}/ii_movep.h (100%) rename {sources => headers}/ii_op.h (100%) rename {sources => headers}/ii_opc.h (100%) rename {sources => headers}/ii_or.h (100%) rename {sources => headers}/ii_pea.h (100%) rename {sources => headers}/ii_shd.h (100%) rename {sources => headers}/ii_shift.h (100%) rename {sources => headers}/ii_sub.h (100%) rename {sources => headers}/macro.h (100%) rename {sources => headers}/movem.h (100%) rename {sources => headers}/startcf.h (94%) rename {sources => headers}/sysinit.h (100%) create mode 100644 mcdapirev0p3/MCD_dmaApi.c create mode 100644 mcdapirev0p3/MCD_tasks.c create mode 100644 mcdapirev0p3/MCD_tasksInit.c create mode 100644 mcdapirev0p3/Multichannel_DMA_API_User's_Guide.pdf create mode 100644 mcdapirev0p3/ReleaseNotes.txt create mode 100644 readme.txt create mode 100644 sources/MCD_dmaApi.c create mode 100644 sources/MCD_tasks.c create mode 100644 sources/MCD_tasksInit.c create mode 100644 sources/alt und div/BaS.c.neu create mode 100644 sources/alt und div/BaS.c.normal rename sources/{ => alt und div}/div.s (100%) rename sources/{ => alt und div}/sd_ide.c (100%) delete mode 100644 sources/last.c delete mode 100644 sources/last.s delete mode 100644 sources/sd_card.s delete mode 100644 sources/sd_ide.s create mode 100644 sources/set_ide_access_mode.c create mode 100644 sources/sysinit.c.alt diff --git a/firebeeV1.mcp b/BaS_2.mcp similarity index 78% rename from firebeeV1.mcp rename to BaS_2.mcp index af6610311b9139379d75980a8eb8c2741bdacbf3..b7b83025614028975269120c55224a82a1447c94 100644 GIT binary patch delta 3953 zcmb_edr(x@8UGIKT~@#iASsL7+wd?ZGoh$R)sci4Pzj2F82d<#xWb|c$Yw#~M8+Kx zqvU18tKMkS1e2&F!Ai5$t&Q50sM!2bo2jIkG=mvqM{3g<$66f*W`m&vV zv%h=3{hf2qIp6D?J8<4TaNgbD>q^~4L_I)?2ajZ;T~=y>@R{$qu7uOTWCJeXX*3w& zasy8Sg+LK-4^RR$0&9WCfla^@z-C|z&;?))R~EqY#9=<6z&c?9qA~!p)8E4U4^Q*5 zmYIfuB8~@3`DW4d$)?{kE>YN&FuUA$gcH!qGsOeklLD|k8o+b11!Dj&kO+(gU@Ij7 zw*aXCTRRR&2W|zv24ny}AQKo5zyb*!tu0tDQhiVe^W#C6IWp)q`v=`-wcBTXIZLFO zmM6u$%i~KNwb|V4zTG_I$=0@G2GjhVCoG;e{bQ=d4)frc!CRjJ`z){(cn;VGbej(+ z&KEn)qlxu$mCB@KE%)*1L#NG+p>dI5k}EFKKR82}WuDwD-u~ACHvRi(Y)9d5hD)lcas4rL@SYvB#p;mtjH8lk4LIHn6T~h;IYEKJvKnv9Q>+1vU z?RBkf4FRjiEwZDNlfb%c|IWXHN|Nk}_|KsAcW_W+Sb=z{0 z*IiRHmIJ`zMzxKN{GmLY=o5%wLBW#7rchvcAn>iix{BFzVCa%aN!2xBF8hr~Bu5qw z)p;YQm%X|u^77&Qq+2u+QnK;t7gT4i-d+`XWI%{W-)WaXj{e)c;8_1Rx$&P$+Rh8k zMRoj`Bif{ddOm$T!aQ^|LkR0oKvb^cW#?2@%*9X_w|o|I%V!_Ad>(RJsM;dcHma7- zNABOG+9%M~EUqobw6Y956|3u8)-(j#HS3{9k&(JtjoYHyF6+;YVxRTy3US4{uu{}m zmsjCY+am6idHIxeewoOV>A5wga+Y?-R8H1yF_m-nIT=!!y3fW`&fx7al@obkY%J&V zu9*6mGr)QjOWy3m+>qn>-}C0uJy!J#!X4T0PCbh!x;|6v z8*i@7$&Y+Im@JT8(_DP&MoWu@D?U1_SR8T7L$kx19=(2_aLHpb+E**wUVd)yTD5+$ z&bsP{AJYQxBZpG?k)x&j$N^J+hT~L)DIX{#i`RY@C3^@a=nOO2> zA2(Fu4JwM#dNUv@!hAe(Zv8)Vljq}&|MMJG3-SlRoJwm|qe%Q02^-Bx5*J>m=6Mn$CPK|+3@WEuA5J4#)&L{d5M?dq!D|A9Q zrJP=h+XZtmuYH+Ch^>_O>+w;5xtKrc)(L@@a=D4~fMbJr{LEC{xvB3;0FOJ8`Mop3 zx^rz$#S8qI!W~O6k$r{le+kzxE=uOlw(8Dxz5wHM)%f9gx^uP9JcwARjdqgmT=R4L z;ZenZv{;W_`TV)ohKcx6<^?X#)SdgkDngWx-7y7OJ|=ue5V zVKR?5{*uMt2vR1&oBSQd{G>{qaNSB-k9EVgi{?$y2`8A8a=gG76~FL}89KqkQutay zm*hwCblRi%Z-cZw*I%mhmy?u-Z3bZk%T~HjJP2;PF4{ z^eS`~-&t8zv1$lj(P>|dC)WimfEhRxWp0D^D?a_wXj$b;7gCpz^i zzB5%gRaO6mPOmAxCsR08HR}SZ;dRwq_U zk0Ow=>C9+ugytFaL&cBe38$(KjW_5J^IQ!t;sv{`=D-3}jg-zQ!YQlwQw{o&;=783 zQ&uOwW6+z5A4X{Gsv52_2*o62+jQYnRqGuF{aEqGN(6=NvO0(m99A9I?iEg1h4KwL zqIhrKX!4!B-=L`C--ZFUhdw~aexmr3;O(kfKFy$`ia!V5105j_2Y*p)5Xx9e`fTBp z)vwYGdQ0&I;O&WaxC}a`_!8!0Wfk06WzccOSIrkrRh1MPgzA&B2c>3L)!A!0{Y?5F zU7sxwPFeXhgWisfrkm9eMzSQ#iv&bCzN9f40=cL)4;nC9!~1( VQ;1F~{_c#2MmsDV{HIjM-vKS#0M7sb delta 4028 zcmcgudvH|M8UN1a-p%G|A|QF(s|krQl@x}UaWcFKNl0*kHOfr1F+?z-N)nb0D7ArA z9)=pL#tU8_ltx=1+E9>f-BtyWQdw}UGSfQNTC}xOGt@sa)uBvzw7>7(?{1KP+JD+_ z_P5`;zjN+6=X>rR{ltIt6aRrBEw`VD27%sGdYAng)(vVQ`EC*Hq_W&IL z`>_Z&V8hnqy1L_3ICLJHDZ=j46sdra^HzqOGchAT7(Ve0(|;|P_SHw2lx{D zVqhi!i}hvz?$IlNIshKfVV!;la3|0Lz)~HS>abLA1MUW3tqx1|cAyjJ0=j|Kz#6z) zk6_RPtOLFS@Fo6-2Y&6m6tXr4u2IU)U81fZ2o+en5~Z;(vL8v0mCfi)wR(D52SR1+ zY5QVOowxR#OpX2@ee<=evTG2ca^P~|$|wSOj$I1nO02j<&l?D7eEV2${)2w2I`4v2 zw!rXjx^GJ&t0^|G>7UA~Y0UF)p3;|S^t;cVsa!x@R4h75kc$bKF;~T3$yXUZ>>InZ z=-YuGZERj{O--$ce=%Ft=<&f^b;cLl^;V`9ixdY{mX2zN;DSE7V82bOWU466a0(uomMmB<2bOCAc%QgIu$}*@32=e)y}c&DMbCC|GvFq` z#n0~J25=ovL^Lpe!|cZTI_zH;Y^>)rWz8wen$wpx`b{E9Y%~3aNSGqL*Tu`;Dc+O&_se#Z? zng-9-);7&sWaS<|AD?-b@@Mn+#%!It*RA&IRjR~(ZIxQDbNBkL`&`+nLR`OEyM0xs zD$%)--Rn&0K@9JAhuqep?vT4%#9hlxZnZn)UKe(U-164AL+*Ut?vNYc1MZOfV2?ZG zcDT_UqE~1e+#xr|UU%4r;W~GS=Ak|04!L7)c8AQv?S^lp5OPEsMeCafBl zbAE7GkSiK%_5^G0v#e){t`yC^oq2Wx>kiR;OlWD-0&E8_BmWz_S9Gqsr@d#KeKD*i zM%jbBp3P*cvE?~`GVa<+W-6om?!q4m!XkYyb z>-7`6)0k>U=J~8?@7`dwog8)Avm0tF^iIg>(h})rtdmG{-qw%_r6kej-v&3@ z*62Is*8A_4J3kTqZUP|e=eS5dO|c`ZR1v3v^ZZpx?AgB0bK*Pt)bFk)wid{{>xrlX{@5#f)*&*PD*%pda` z)F=E0Nch`JDe6ot$TDb~Ox%b;DNg1W1}_!T_k>^kBvBP?V?O^}Aw4SmCJP740gs0b z>KFd^xC|S_>!;@$^qBCGV(`l4U#N~6^nIE5BVOR1$}hBFqsN7R>RF=gSuX!xmqAYm z{|~I6B$dI+9CX|pQFjcWL|HcFQli1zX|)JNjUt}ph33qw}6j& zE?PLvpl4)a2__I?=Y?-p8w3Y9vJAYJ6C))CJtzE1@Sf)m)EM-<@P%0H?Q_Q@gLVpk z_?O^a!=mB4aibr|#BYue1;w(DstnpCe8EwoR^dNuGU$iGPsRbBWruDvXi)g!x5r}K zvC5zqgnt+p^$Z?bV$h3@IhdRuu(e?|CHmq@oPr%#t|iRFzu|;ZcKjyFBgu0}j9r9Mk!JllBNd z{OMR(6_=WXoO9&JU!AgY)-V0cpdsPMXQ*UVt+-&&OTw@J)mT-{{WGcoN$N=TIF&4` z#NQ42iSS!5bK$^ECJhV!QT>?99{`WsbtDdpz1)Z_H0h_pH{`2iRqZb@X+QH^4X5ye zS5|ef;DEgFahXb%)d#sIy(0X`H&n8$4mX>0Q1~ygk5^TvLng(9AFWWys_MGIBovb) z2ae->udMbV1gIuQj4J%YL)LHzA{8dRD*V52fR}v78cd1{KM?`;lI%l->=(kfgZHXo z`OPMw2pm}l9v|L68a^?@q}OC(16a>>?~ga>b>Z#HHrlS4^oH;=aeFDN@Q%eM9TGk` zMrHw~_-$D4Sv>H$ sL8w+o9s}=%GHr@U$Tdgy)GG30jy-yI8qqP~hbK0TP1tDszm|!A0~Ex|JOBUy diff --git a/flash_config.xml b/flash_config.xml index ce2e67e..b464920 100644 --- a/flash_config.xml +++ b/flash_config.xml @@ -6,7 +6,7 @@ 5474 PEMICRO_USB true - C:\FireBee\codewarrior\firebeeV1\cfg\mem.cfg + 0x00000000 0x00006000 true diff --git a/headers/MCD_dma.h b/headers/MCD_dma.h new file mode 100644 index 0000000..49849e2 --- /dev/null +++ b/headers/MCD_dma.h @@ -0,0 +1,362 @@ +/* + * File: MCD_dma.h + * Purpose: Main header file for multi-channel DMA API. + * + * Notes: + */ +#ifndef _MCD_API_H +#define _MCD_API_H + +/* + * Turn Execution Unit tasks ON (#define) or OFF (#undef) + */ +#undef MCD_INCLUDE_EU + +/* + * Number of DMA channels + */ +#define NCHANNELS 16 + +/* + * Total number of variants + */ +#ifdef MCD_INCLUDE_EU +#define NUMOFVARIANTS 6 +#else +#define NUMOFVARIANTS 4 +#endif + +/* + * Define sizes of the various tables + */ +#define TASK_TABLE_SIZE (NCHANNELS*32) +#define VAR_TAB_SIZE (128) +#define CONTEXT_SAVE_SIZE (128) +#define FUNCDESC_TAB_SIZE (256) + +#ifdef MCD_INCLUDE_EU +#define FUNCDESC_TAB_NUM 16 +#else +#define FUNCDESC_TAB_NUM 1 +#endif + + +#ifndef DEFINESONLY + +/* + * Portability typedefs + */ +typedef int s32; +typedef unsigned int u32; +typedef short s16; +typedef unsigned short u16; +typedef char s8; +typedef unsigned char u8; + +/* + * These structures represent the internal registers of the + * multi-channel DMA + */ +struct dmaRegs_s { + u32 taskbar; /* task table base address register */ + u32 currPtr; + u32 endPtr; + u32 varTablePtr; + u16 dma_rsvd0; + u16 ptdControl; /* ptd control */ + u32 intPending; /* interrupt pending register */ + u32 intMask; /* interrupt mask register */ + u16 taskControl[16]; /* task control registers */ + u8 priority[32]; /* priority registers */ + u32 initiatorMux; /* initiator mux control */ + u32 taskSize0; /* task size control register 0. */ + u32 taskSize1; /* task size control register 1. */ + u32 dma_rsvd1; /* reserved */ + u32 dma_rsvd2; /* reserved */ + u32 debugComp1; /* debug comparator 1 */ + u32 debugComp2; /* debug comparator 2 */ + u32 debugControl; /* debug control */ + u32 debugStatus; /* debug status */ + u32 ptdDebug; /* priority task decode debug */ + u32 dma_rsvd3[31]; /* reserved */ +}; +typedef volatile struct dmaRegs_s dmaRegs; + +#endif + +/* + * PTD contrl reg bits + */ +#define PTD_CTL_TSK_PRI 0x8000 +#define PTD_CTL_COMM_PREFETCH 0x0001 + +/* + * Task Control reg bits and field masks + */ +#define TASK_CTL_EN 0x8000 +#define TASK_CTL_VALID 0x4000 +#define TASK_CTL_ALWAYS 0x2000 +#define TASK_CTL_INIT_MASK 0x1f00 +#define TASK_CTL_ASTRT 0x0080 +#define TASK_CTL_HIPRITSKEN 0x0040 +#define TASK_CTL_HLDINITNUM 0x0020 +#define TASK_CTL_ASTSKNUM_MASK 0x000f + +/* + * Priority reg bits and field masks + */ +#define PRIORITY_HLD 0x80 +#define PRIORITY_PRI_MASK 0x07 + +/* + * Debug Control reg bits and field masks + */ +#define DBG_CTL_BLOCK_TASKS_MASK 0xffff0000 +#define DBG_CTL_AUTO_ARM 0x00008000 +#define DBG_CTL_BREAK 0x00004000 +#define DBG_CTL_COMP1_TYP_MASK 0x00003800 +#define DBG_CTL_COMP2_TYP_MASK 0x00000070 +#define DBG_CTL_EXT_BREAK 0x00000004 +#define DBG_CTL_INT_BREAK 0x00000002 + +/* + * PTD Debug reg selector addresses + * This reg must be written with a value to show the contents of + * one of the desired internal register. + */ +#define PTD_DBG_REQ 0x00 /* shows the state of 31 initiators */ +#define PTD_DBG_TSK_VLD_INIT 0x01 /* shows which 16 tasks are valid and + have initiators asserted */ + + +/* + * General return values + */ +#define MCD_OK 0 +#define MCD_ERROR -1 +#define MCD_TABLE_UNALIGNED -2 +#define MCD_CHANNEL_INVALID -3 + +/* + * MCD_initDma input flags + */ +#define MCD_RELOC_TASKS 0x00000001 +#define MCD_NO_RELOC_TASKS 0x00000000 +#define MCD_COMM_PREFETCH_EN 0x00000002 /* Commbus Prefetching - MCF547x/548x ONLY */ + +/* + * MCD_dmaStatus Status Values for each channel + */ +#define MCD_NO_DMA 1 /* No DMA has been requested since reset */ +#define MCD_IDLE 2 /* DMA active, but the initiator is currently inactive */ +#define MCD_RUNNING 3 /* DMA active, and the initiator is currently active */ +#define MCD_PAUSED 4 /* DMA active but it is currently paused */ +#define MCD_HALTED 5 /* the most recent DMA has been killed with MCD_killTask() */ +#define MCD_DONE 6 /* the most recent DMA has completed. */ + + +/* + * MCD_startDma parameter defines + */ + +/* + * Constants for the funcDesc parameter + */ +/* Byte swapping: */ +#define MCD_NO_BYTE_SWAP 0x00045670 /* to disable byte swapping. */ +#define MCD_BYTE_REVERSE 0x00076540 /* to reverse the bytes of each u32 of the DMAed data. */ +#define MCD_U16_REVERSE 0x00067450 /* to reverse the 16-bit halves of + each 32-bit data value being DMAed.*/ +#define MCD_U16_BYTE_REVERSE 0x00054760 /* to reverse the byte halves of each + 16-bit half of each 32-bit data value DMAed */ +#define MCD_NO_BIT_REV 0x00000000 /* do not reverse the bits of each byte DMAed. */ +#define MCD_BIT_REV 0x00088880 /* reverse the bits of each byte DMAed */ +/* CRCing: */ +#define MCD_CRC16 0xc0100000 /* to perform CRC-16 on DMAed data. */ +#define MCD_CRCCCITT 0xc0200000 /* to perform CRC-CCITT on DMAed data. */ +#define MCD_CRC32 0xc0300000 /* to perform CRC-32 on DMAed data. */ +#define MCD_CSUMINET 0xc0400000 /* to perform internet checksums on DMAed data.*/ +#define MCD_NO_CSUM 0xa0000000 /* to perform no checksumming. */ + +#define MCD_FUNC_NOEU1 (MCD_NO_BYTE_SWAP | MCD_NO_BIT_REV | MCD_NO_CSUM) +#define MCD_FUNC_NOEU2 (MCD_NO_BYTE_SWAP | MCD_NO_CSUM) + +/* + * Constants for the flags parameter + */ +#define MCD_TT_FLAGS_RL 0x00000001 /* Read line */ +#define MCD_TT_FLAGS_CW 0x00000002 /* Combine Writes */ +#define MCD_TT_FLAGS_SP 0x00000004 /* Speculative prefetch(XLB) MCF547x/548x ONLY */ +#define MCD_TT_FLAGS_MASK 0x000000ff +#define MCD_TT_FLAGS_DEF (MCD_TT_FLAGS_RL | MCD_TT_FLAGS_CW) + +#define MCD_SINGLE_DMA 0x00000100 /* Unchained DMA */ +#define MCD_CHAIN_DMA /* TBD */ +#define MCD_EU_DMA /* TBD */ +#define MCD_FECTX_DMA 0x00001000 /* FEC TX ring DMA */ +#define MCD_FECRX_DMA 0x00002000 /* FEC RX ring DMA */ + + +/* these flags are valid for MCD_startDma and the chained buffer descriptors */ +#define MCD_BUF_READY 0x80000000 /* indicates that this buffer is now under the DMA's control */ +#define MCD_WRAP 0x20000000 /* to tell the FEC Dmas to wrap to the first BD */ +#define MCD_INTERRUPT 0x10000000 /* to generate an interrupt after completion of the DMA. */ +#define MCD_END_FRAME 0x08000000 /* tell the DMA to end the frame when transferring + last byte of data in buffer */ +#define MCD_CRC_RESTART 0x40000000 /* to empty out the accumulated checksum + prior to performing the DMA. */ + +/* Defines for the FEC buffer descriptor control/status word*/ +#define MCD_FEC_BUF_READY 0x8000 +#define MCD_FEC_WRAP 0x2000 +#define MCD_FEC_INTERRUPT 0x1000 +#define MCD_FEC_END_FRAME 0x0800 + + +/* + * Defines for general intuitiveness + */ + +#define MCD_TRUE 1 +#define MCD_FALSE 0 + +/* + * Three different cases for destination and source. + */ +#define MINUS1 -1 +#define ZERO 0 +#define PLUS1 1 + +#ifndef DEFINESONLY + +/* Task Table Entry struct*/ +typedef struct { + u32 TDTstart; /* task descriptor table start */ + u32 TDTend; /* task descriptor table end */ + u32 varTab; /* variable table start */ + u32 FDTandFlags; /* function descriptor table start and flags */ + volatile u32 descAddrAndStatus; + volatile u32 modifiedVarTab; + u32 contextSaveSpace; /* context save space start */ + u32 literalBases; +} TaskTableEntry; + + +/* Chained buffer descriptor */ +typedef volatile struct MCD_bufDesc_struct MCD_bufDesc; +struct MCD_bufDesc_struct { + u32 flags; /* flags describing the DMA */ + u32 csumResult; /* checksum from checksumming performed since last checksum reset */ + s8 *srcAddr; /* the address to move data from */ + s8 *destAddr; /* the address to move data to */ + s8 *lastDestAddr; /* the last address written to */ + u32 dmaSize; /* the number of bytes to transfer independent of the transfer size */ + MCD_bufDesc *next; /* next buffer descriptor in chain */ + u32 info; /* private information about this descriptor; DMA does not affect it */ +}; + +/* Progress Query struct */ +typedef volatile struct MCD_XferProg_struct { + s8 *lastSrcAddr; /* the most-recent or last, post-increment source address */ + s8 *lastDestAddr; /* the most-recent or last, post-increment destination address */ + u32 dmaSize; /* the amount of data transferred for the current buffer */ + MCD_bufDesc *currBufDesc;/* pointer to the current buffer descriptor being DMAed */ +} MCD_XferProg; + + +/* FEC buffer descriptor */ +typedef volatile struct MCD_bufDescFec_struct { + u16 statCtrl; + u16 length; + u32 dataPointer; +} MCD_bufDescFec; + + +/*************************************************************************/ +/* + * API function Prototypes - see MCD_dmaApi.c for further notes + */ + +/* + * MCD_startDma starts a particular kind of DMA . + */ +int MCD_startDma ( + int channel, /* the channel on which to run the DMA */ + s8 *srcAddr, /* the address to move data from, or buffer-descriptor address */ + s16 srcIncr, /* the amount to increment the source address per transfer */ + s8 *destAddr, /* the address to move data to */ + s16 destIncr, /* the amount to increment the destination address per transfer */ + u32 dmaSize, /* the number of bytes to transfer independent of the transfer size */ + u32 xferSize, /* the number bytes in of each data movement (1, 2, or 4) */ + u32 initiator, /* what device initiates the DMA */ + int priority, /* priority of the DMA */ + u32 flags, /* flags describing the DMA */ + u32 funcDesc /* a description of byte swapping, bit swapping, and CRC actions */ +); + +/* + * MCD_initDma() initializes the DMA API by setting up a pointer to the DMA + * registers, relocating and creating the appropriate task structures, and + * setting up some global settings + */ +int MCD_initDma (dmaRegs *sDmaBarAddr, void *taskTableDest, u32 flags); + +/* + * MCD_dmaStatus() returns the status of the DMA on the requested channel. + */ +int MCD_dmaStatus (int channel); + +/* + * MCD_XferProgrQuery() returns progress of DMA on requested channel + */ +int MCD_XferProgrQuery (int channel, MCD_XferProg *progRep); + +/* + * MCD_killDma() halts the DMA on the requested channel, without any + * intention of resuming the DMA. + */ +int MCD_killDma (int channel); + +/* + * MCD_continDma() continues a DMA which as stopped due to encountering an + * unready buffer descriptor. + */ +int MCD_continDma (int channel); + +/* + * MCD_pauseDma() pauses the DMA on the given channel ( if any DMA is + * running on that channel). + */ +int MCD_pauseDma (int channel); + +/* + * MCD_resumeDma() resumes the DMA on a given channel (if any DMA is + * running on that channel). + */ +int MCD_resumeDma (int channel); + +/* + * MCD_csumQuery provides the checksum/CRC after performing a non-chained DMA + */ +int MCD_csumQuery (int channel, u32 *csum); + +/* + * MCD_getCodeSize provides the packed size required by the microcoded task + * and structures. + */ +int MCD_getCodeSize(void); + +/* + * MCD_getVersion provides a pointer to a version string and returns a + * version number. + */ +int MCD_getVersion(char **longVersion); + +/* macro for setting a location in the variable table */ +#define MCD_SET_VAR(taskTab,idx,value) ((u32 *)(taskTab)->varTab)[idx] = value + /* Note that MCD_SET_VAR() is invoked many times in firing up a DMA function, + so I'm avoiding surrounding it with "do {} while(0)" */ + +#endif /* DEFINESONLY */ + +#endif /* _MCD_API_H */ diff --git a/headers/MCD_dmaApi.c b/headers/MCD_dmaApi.c new file mode 100644 index 0000000..1104600 --- /dev/null +++ b/headers/MCD_dmaApi.c @@ -0,0 +1,938 @@ +/* + * File: MCD_dmaApi.c + * Purpose: Main C file for multi-channel DMA API. + * + * Notes: + */ + +#include "MCD_dma.h" +#include "MCD_tasksInit.h" +#include "MCD_progCheck.h" + +/********************************************************************/ +/* + * This is an API-internal pointer to the DMA's registers + */ +dmaRegs *MCD_dmaBar; + +/* + * These are the real and model task tables as generated by the + * build process + */ +extern TaskTableEntry MCD_realTaskTableSrc[NCHANNELS]; +extern TaskTableEntry MCD_modelTaskTableSrc[NUMOFVARIANTS]; + +/* + * However, this (usually) gets relocated to on-chip SRAM, at which + * point we access them as these tables + */ +volatile TaskTableEntry *MCD_taskTable; +TaskTableEntry *MCD_modelTaskTable; + + +/* + * MCD_chStatus[] is an array of status indicators for remembering + * whether a DMA has ever been attempted on each channel, pausing + * status, etc. + */ +static int MCD_chStatus[NCHANNELS] = +{ + MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, + MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, + MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, + MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA +}; + +/* + * Prototypes for local functions + */ +static void MCD_memcpy (int *dest, int *src, u32 size); +static void MCD_resmActions (int channel); + +/* + * Buffer descriptors used for storage of progress info for single Dmas + * Also used as storage for the DMA for CRCs for single DMAs + * Otherwise, the DMA does not parse these buffer descriptors + */ +#ifdef MCD_INCLUDE_EU +extern MCD_bufDesc MCD_singleBufDescs[NCHANNELS]; +#else +MCD_bufDesc MCD_singleBufDescs[NCHANNELS]; +#endif +MCD_bufDesc *MCD_relocBuffDesc; + + +/* + * Defines for the debug control register's functions + */ +#define DBG_CTL_COMP1_TASK (0x00002000) /* have comparator 1 look for a task # */ +#define DBG_CTL_ENABLE (DBG_CTL_AUTO_ARM | \ + DBG_CTL_BREAK | \ + DBG_CTL_INT_BREAK | \ + DBG_CTL_COMP1_TASK) +#define DBG_CTL_DISABLE (DBG_CTL_AUTO_ARM | \ + DBG_CTL_INT_BREAK | \ + DBG_CTL_COMP1_TASK) +#define DBG_KILL_ALL_STAT (0xFFFFFFFF) + +/* + * Offset to context save area where progress info is stored + */ +#define CSAVE_OFFSET 10 + +/* + * Defines for Byte Swapping + */ +#define MCD_BYTE_SWAP_KILLER 0xFFF8888F +#define MCD_NO_BYTE_SWAP_ATALL 0x00040000 + +/* + * Execution Unit Identifiers + */ +#define MAC 0 /* legacy - not used */ +#define LUAC 1 /* legacy - not used */ +#define CRC 2 /* legacy - not used */ +#define LURC 3 /* Logic Unit with CRC */ + +/* + * Task Identifiers + */ +#define TASK_CHAINNOEU 0 +#define TASK_SINGLENOEU 1 +#ifdef MCD_INCLUDE_EU +#define TASK_CHAINEU 2 +#define TASK_SINGLEEU 3 +#define TASK_FECRX 4 +#define TASK_FECTX 5 +#else +#define TASK_CHAINEU 0 +#define TASK_SINGLEEU 1 +#define TASK_FECRX 2 +#define TASK_FECTX 3 +#endif + +/* + * Structure to remember which variant is on which channel + * TBD- need this? + */ +typedef struct MCD_remVariants_struct MCD_remVariant; +struct MCD_remVariants_struct +{ + int remDestRsdIncr[NCHANNELS]; /* -1,0,1 */ + int remSrcRsdIncr[NCHANNELS]; /* -1,0,1 */ + s16 remDestIncr[NCHANNELS]; /* DestIncr */ + s16 remSrcIncr[NCHANNELS]; /* srcIncr */ + u32 remXferSize[NCHANNELS]; /* xferSize */ +}; + +/* + * Structure to remember the startDma parameters for each channel + */ +MCD_remVariant MCD_remVariants; +/********************************************************************/ +/* + * Function: MCD_initDma + * Purpose: Initializes the DMA API by setting up a pointer to the DMA + * registers, relocating and creating the appropriate task + * structures, and setting up some global settings + * Arguments: + * dmaBarAddr - pointer to the multichannel DMA registers + * taskTableDest - location to move DMA task code and structs to + * flags - operational parameters + * Return Value: + * MCD_TABLE_UNALIGNED if taskTableDest is not 512-byte aligned + * MCD_OK otherwise + */ +extern u32 MCD_funcDescTab0[]; + +int MCD_initDma (dmaRegs *dmaBarAddr, void *taskTableDest, u32 flags) +{ + int marker; + int i; + TaskTableEntry *entryPtr; + + /* setup the local pointer to register set */ + MCD_dmaBar = dmaBarAddr; + + /* do we need to move/create a task table */ + if ((flags & MCD_RELOC_TASKS) != 0) + { + int fixedSize; + u32 *fixedPtr; + /*int *tablePtr = taskTableDest;TBD*/ + int varTabsOffset, funcDescTabsOffset, contextSavesOffset; + int taskDescTabsOffset; + int taskTableSize, varTabsSize, funcDescTabsSize, contextSavesSize; + int taskDescTabSize; + + int i; + + /* check if physical address is aligned on 512 byte boundary */ + if (((u32)taskTableDest & 0x000001ff) != 0) + return(MCD_TABLE_UNALIGNED); + + MCD_taskTable = taskTableDest; /* set up local pointer to task Table */ + + /* + * Create a task table: + * - compute aligned base offsets for variable tables and + * function descriptor tables, then + * - loop through the task table and setup the pointers + * - copy over model task table with the the actual task descriptor + * tables + */ + + taskTableSize = NCHANNELS * sizeof(TaskTableEntry); + /* align variable tables to size */ + varTabsOffset = taskTableSize + (u32)taskTableDest; + if ((varTabsOffset & (VAR_TAB_SIZE - 1)) != 0) + varTabsOffset = (varTabsOffset + VAR_TAB_SIZE) & (~VAR_TAB_SIZE); + /* align function descriptor tables */ + varTabsSize = NCHANNELS * VAR_TAB_SIZE; + funcDescTabsOffset = varTabsOffset + varTabsSize; + + if ((funcDescTabsOffset & (FUNCDESC_TAB_SIZE - 1)) != 0) + funcDescTabsOffset = (funcDescTabsOffset + FUNCDESC_TAB_SIZE) & + (~FUNCDESC_TAB_SIZE); + + funcDescTabsSize = FUNCDESC_TAB_NUM * FUNCDESC_TAB_SIZE; + contextSavesOffset = funcDescTabsOffset + funcDescTabsSize; + contextSavesSize = (NCHANNELS * CONTEXT_SAVE_SIZE); + fixedSize = taskTableSize + varTabsSize + funcDescTabsSize + + contextSavesSize; + + /* zero the thing out */ + fixedPtr = (u32 *)taskTableDest; + for (i = 0;i<(fixedSize/4);i++) + fixedPtr[i] = 0; + + entryPtr = (TaskTableEntry*)MCD_taskTable; + /* set up fixed pointers */ + for (i = 0; i < NCHANNELS; i++) + { + entryPtr[i].varTab = (u32)varTabsOffset; /* update ptr to local value */ + entryPtr[i].FDTandFlags = (u32)funcDescTabsOffset | MCD_TT_FLAGS_DEF; + entryPtr[i].contextSaveSpace = (u32)contextSavesOffset; + varTabsOffset += VAR_TAB_SIZE; +#ifdef MCD_INCLUDE_EU /* if not there is only one, just point to the same one */ + funcDescTabsOffset += FUNCDESC_TAB_SIZE; +#endif + contextSavesOffset += CONTEXT_SAVE_SIZE; + } + /* copy over the function descriptor table */ + for ( i = 0; i < FUNCDESC_TAB_NUM; i++) + { + MCD_memcpy((void*)(entryPtr[i].FDTandFlags & ~MCD_TT_FLAGS_MASK), + (void*)MCD_funcDescTab0, FUNCDESC_TAB_SIZE); + } + + /* copy model task table to where the context saves stuff leaves off*/ + MCD_modelTaskTable = (TaskTableEntry*)contextSavesOffset; + + MCD_memcpy ((void*)MCD_modelTaskTable, (void*)MCD_modelTaskTableSrc, + NUMOFVARIANTS * sizeof(TaskTableEntry)); + + entryPtr = MCD_modelTaskTable; /* point to local version of + model task table */ + taskDescTabsOffset = (u32)MCD_modelTaskTable + + (NUMOFVARIANTS * sizeof(TaskTableEntry)); + + /* copy actual task code and update TDT ptrs in local model task table */ + for (i = 0; i < NUMOFVARIANTS; i++) + { + asm + { + move.l #0x77777777,d0 + } + taskDescTabSize = entryPtr[i].TDTend - entryPtr[i].TDTstart + 4; + MCD_memcpy ((void*)taskDescTabsOffset, (void*)entryPtr[i].TDTstart, taskDescTabSize); + entryPtr[i].TDTstart = (u32)taskDescTabsOffset; + taskDescTabsOffset += taskDescTabSize; + entryPtr[i].TDTend = (u32)taskDescTabsOffset - 4; + } +#ifdef MCD_INCLUDE_EU /* Tack single DMA BDs onto end of code so API controls + where they are since DMA might write to them */ + MCD_relocBuffDesc = (MCD_bufDesc*)(entryPtr[NUMOFVARIANTS - 1].TDTend + 4); +#else /* DMA does not touch them so they can be wherever and we don't need to + waste SRAM on them */ + MCD_relocBuffDesc = MCD_singleBufDescs; +#endif + } + else + { + /* point the would-be relocated task tables and the + buffer descriptors to the ones the linker generated */ + + if (((u32)MCD_realTaskTableSrc & 0x000001ff) != 0) + return(MCD_TABLE_UNALIGNED); + + /* need to add code to make sure that every thing else is aligned properly TBD*/ + /* this is problematic if we init more than once or after running tasks, + need to add variable to see if we have aleady init'd */ + entryPtr = MCD_realTaskTableSrc; + for (i = 0; i < NCHANNELS; i++) + { + if (((entryPtr[i].varTab & (VAR_TAB_SIZE - 1)) != 0) || + ((entryPtr[i].FDTandFlags & (FUNCDESC_TAB_SIZE - 1)) != 0)) + return(MCD_TABLE_UNALIGNED); + } + + MCD_taskTable = MCD_realTaskTableSrc; + MCD_modelTaskTable = MCD_modelTaskTableSrc; + MCD_relocBuffDesc = MCD_singleBufDescs; + } + + + /* Make all channels as totally inactive, and remember them as such: */ + + MCD_dmaBar->taskbar = (u32) MCD_taskTable; + for (i = 0; i < NCHANNELS; i++) + { + MCD_dmaBar->taskControl[i] = 0x0; + MCD_chStatus[i] = MCD_NO_DMA; + } + + /* Set up pausing mechanism to inactive state: */ + MCD_dmaBar->debugComp1 = 0; /* no particular values yet for either comparator registers */ + MCD_dmaBar->debugComp2 = 0; + MCD_dmaBar->debugControl = DBG_CTL_DISABLE; + MCD_dmaBar->debugStatus = DBG_KILL_ALL_STAT; + + /* enable or disable commbus prefetch, really need an ifdef or + something to keep from trying to set this in the 8220 */ + if ((flags & MCD_COMM_PREFETCH_EN) != 0) + MCD_dmaBar->ptdControl &= ~PTD_CTL_COMM_PREFETCH; + else + MCD_dmaBar->ptdControl |= PTD_CTL_COMM_PREFETCH; + + return(MCD_OK); +} +/*********************** End of MCD_initDma() ***********************/ + +/********************************************************************/ +/* Function: MCD_dmaStatus + * Purpose: Returns the status of the DMA on the requested channel + * Arguments: channel - channel number + * Returns: Predefined status indicators + */ +int MCD_dmaStatus (int channel) +{ + u16 tcrValue; + + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + tcrValue = MCD_dmaBar->taskControl[channel]; + if ((tcrValue & TASK_CTL_EN) == 0) + { /* nothing running */ + /* if last reported with task enabled */ + if ( MCD_chStatus[channel] == MCD_RUNNING + || MCD_chStatus[channel] == MCD_IDLE) + MCD_chStatus[channel] = MCD_DONE; + } + else /* something is running */ + { + /* There are three possibilities: paused, running or idle. */ + if ( MCD_chStatus[channel] == MCD_RUNNING + || MCD_chStatus[channel] == MCD_IDLE) + { + MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT; + /* This register is selected to know which initiator is + actually asserted. */ + if ((MCD_dmaBar->ptdDebug >> channel ) & 0x1 ) + MCD_chStatus[channel] = MCD_RUNNING; + else + MCD_chStatus[channel] = MCD_IDLE; + /* do not change the status if it is already paused. */ + } + } + return MCD_chStatus[channel]; +} +/******************** End of MCD_dmaStatus() ************************/ + +/********************************************************************/ +/* Function: MCD_startDma + * Ppurpose: Starts a particular kind of DMA + * Arguments: see below + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + */ + +int MCD_startDma ( + int channel, /* the channel on which to run the DMA */ + s8 *srcAddr, /* the address to move data from, or physical buffer-descriptor address */ + s16 srcIncr, /* the amount to increment the source address per transfer */ + s8 *destAddr, /* the address to move data to */ + s16 destIncr, /* the amount to increment the destination address per transfer */ + u32 dmaSize, /* the number of bytes to transfer independent of the transfer size */ + u32 xferSize, /* the number bytes in of each data movement (1, 2, or 4) */ + u32 initiator, /* what device initiates the DMA */ + int priority, /* priority of the DMA */ + u32 flags, /* flags describing the DMA */ + u32 funcDesc /* a description of byte swapping, bit swapping, and CRC actions */ +#ifdef MCD_NEED_ADDR_TRANS + s8 *srcAddrVirt /* virtual buffer descriptor address TBD*/ +#endif +) +{ + int srcRsdIncr, destRsdIncr; + int *cSave; + short xferSizeIncr; + int tcrCount = 0; +#ifdef MCD_INCLUDE_EU + u32 *realFuncArray; +#endif + + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + /* tbd - need to determine the proper response to a bad funcDesc when not + including EU functions, for now, assign a benign funcDesc, but maybe + should return an error */ +#ifndef MCD_INCLUDE_EU + funcDesc = MCD_FUNC_NOEU1; +#endif + +#ifdef MCD_DEBUG +printf("startDma:Setting up params\n"); +#endif + /* Set us up for task-wise priority. We don't technically need to do this on every start, but + since the register involved is in the same longword as other registers that users are in control + of, setting it more than once is probably preferable. That since the documentation doesn't seem + to be completely consistent about the nature of the PTD control register. */ + MCD_dmaBar->ptdControl |= (u16) 0x8000; +#if 1 /* Not sure what we need to keep here rtm TBD */ + /* Calculate additional parameters to the regular DMA calls. */ + srcRsdIncr = srcIncr < 0 ? -1 : (srcIncr > 0 ? 1 : 0); + destRsdIncr = destIncr < 0 ? -1 : (destIncr > 0 ? 1 : 0); + + xferSizeIncr = (xferSize & 0xffff) | 0x20000000; + + /* Remember for each channel which variant is running. */ + MCD_remVariants.remSrcRsdIncr[channel] = srcRsdIncr; + MCD_remVariants.remDestRsdIncr[channel] = destRsdIncr; + MCD_remVariants.remDestIncr[channel] = destIncr; + MCD_remVariants.remSrcIncr[channel] = srcIncr; + MCD_remVariants.remXferSize[channel] = xferSize; +#endif + + cSave = (int*)(MCD_taskTable[channel].contextSaveSpace) + CSAVE_OFFSET + CURRBD; + +#ifdef MCD_INCLUDE_EU /* may move this to EU specific calls */ + realFuncArray = (u32 *) (MCD_taskTable[channel].FDTandFlags & 0xffffff00); + /* Modify the LURC's normal and byte-residue-loop functions according to parameter. */ + realFuncArray[(LURC*16)] = xferSize == 4 ? + funcDesc : xferSize == 2 ? + funcDesc & 0xfffff00f : funcDesc & 0xffff000f; + realFuncArray[(LURC*16+1)] = (funcDesc & MCD_BYTE_SWAP_KILLER) | MCD_NO_BYTE_SWAP_ATALL; +#endif + /* Write the initiator field in the TCR, and also set the initiator-hold + bit. Note that,due to a hardware quirk, this could collide with an + MDE access to the initiator-register file, so we have to verify that the write + reads back correctly. */ + + MCD_dmaBar->taskControl[channel] = + (initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM; + + while(((MCD_dmaBar->taskControl[channel] & 0x1fff) != + ((initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM)) && + (tcrCount < 1000)) + { + tcrCount++; + /*MCD_dmaBar->ptd_tcr[channel] = (initiator << 8) | 0x0020;*/ + MCD_dmaBar->taskControl[channel] = + (initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM; + } + + MCD_dmaBar->priority[channel] = (u8)priority & PRIORITY_PRI_MASK; + /* should be albe to handle this stuff with only one write to ts reg - tbd */ + if (channel < 8 && channel >= 0) + { + MCD_dmaBar->taskSize0 &= ~(0xf << (7-channel)*4); + MCD_dmaBar->taskSize0 |= (xferSize & 3) << (((7 - channel)*4) + 2); + MCD_dmaBar->taskSize0 |= (xferSize & 3) << ((7 - channel)*4); + } + else + { + MCD_dmaBar->taskSize1 &= ~(0xf << (15-channel)*4); + MCD_dmaBar->taskSize1 |= (xferSize & 3) << (((15 - channel)*4) + 2); + MCD_dmaBar->taskSize1 |= (xferSize & 3) << ((15 - channel)*4); + } + + /* setup task table flags/options which mostly control the line buffers */ + MCD_taskTable[channel].FDTandFlags &= ~MCD_TT_FLAGS_MASK; + MCD_taskTable[channel].FDTandFlags |= (MCD_TT_FLAGS_MASK & flags); + + if (flags & MCD_FECTX_DMA) + { + /* TDTStart and TDTEnd */ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_FECTX].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_FECTX].TDTend; + MCD_startDmaENetXmit(srcAddr, srcAddr, destAddr, MCD_taskTable, channel); + } + else if (flags & MCD_FECRX_DMA) + { + /* TDTStart and TDTEnd */ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_FECRX].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_FECRX].TDTend; + MCD_startDmaENetRcv(srcAddr, srcAddr, destAddr, MCD_taskTable, channel); + } + else if(flags & MCD_SINGLE_DMA) + { + /* this buffer descriptor is used for storing off initial parameters for later + progress query calculation and for the DMA to write the resulting checksum + The DMA does not use this to determine how to operate, that info is passed + with the init routine*/ + MCD_relocBuffDesc[channel].srcAddr = srcAddr; + MCD_relocBuffDesc[channel].destAddr = destAddr; + MCD_relocBuffDesc[channel].lastDestAddr = destAddr; /* definitely not its final value */ + MCD_relocBuffDesc[channel].dmaSize = dmaSize; + MCD_relocBuffDesc[channel].flags = 0; /* not used */ + MCD_relocBuffDesc[channel].csumResult = 0; /* not used */ + MCD_relocBuffDesc[channel].next = 0; /* not used */ + + /* Initialize the progress-querying stuff to show no progress:*/ + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET] = (int)srcAddr; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET] = (int)destAddr; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET] = 0; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET] = + (u32) &(MCD_relocBuffDesc[channel]); + /* tbd - need to keep the user from trying to call the EU routine + when MCD_INCLUDE_EU is not defined */ + if( funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2) + { + /* TDTStart and TDTEnd */ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_SINGLENOEU].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_SINGLENOEU].TDTend; + MCD_startDmaSingleNoEu(srcAddr, srcIncr, destAddr, destIncr, dmaSize, + xferSizeIncr, flags, (int *)&(MCD_relocBuffDesc[channel]), cSave, + MCD_taskTable, channel); + } + else + { + /* TDTStart and TDTEnd */ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_SINGLEEU].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_SINGLEEU].TDTend; + MCD_startDmaSingleEu(srcAddr, srcIncr, destAddr, destIncr, dmaSize, + xferSizeIncr, flags, (int *)&(MCD_relocBuffDesc[channel]), cSave, + MCD_taskTable, channel); + } + } + else + { /* chained DMAS */ + /* Initialize the progress-querying stuff to show no progress:*/ +#if 1 /* (!defined(MCD_NEED_ADDR_TRANS)) */ + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET] + = (int)((MCD_bufDesc*) srcAddr)->srcAddr; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET] + = (int)((MCD_bufDesc*) srcAddr)->destAddr; +#else /* if using address translation, need the virtual addr of the first buffdesc */ + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET] + = (int)((MCD_bufDesc*) srcAddrVirt)->srcAddr; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET] + = (int)((MCD_bufDesc*) srcAddrVirt)->destAddr; +#endif + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET] = 0; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET] = (u32) srcAddr; + + if( funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2) + { + /*TDTStart and TDTEnd*/ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_CHAINNOEU].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_CHAINNOEU].TDTend; + MCD_startDmaChainNoEu((int *)srcAddr, srcIncr, destIncr, xferSize, + xferSizeIncr, cSave, MCD_taskTable, channel); + } + else + { + /*TDTStart and TDTEnd*/ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_CHAINEU].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_CHAINEU].TDTend; + MCD_startDmaChainEu((int *)srcAddr, srcIncr, destIncr, xferSize, + xferSizeIncr, cSave, MCD_taskTable, channel); + } + } + MCD_chStatus[channel] = MCD_IDLE; + return(MCD_OK); +} + +/************************ End of MCD_startDma() *********************/ + +/********************************************************************/ +/* Function: MCD_XferProgrQuery + * Purpose: Returns progress of DMA on requested channel + * Arguments: channel - channel to retrieve progress for + * progRep - pointer to user supplied MCD_XferProg struct + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + * + * Notes: + * MCD_XferProgrQuery() upon completing or after aborting a DMA, or + * while the DMA is in progress, this function returns the first + * DMA-destination address not (or not yet) used in the DMA. When + * encountering a non-ready buffer descriptor, the information for + * the last completed descriptor is returned. + * + * MCD_XferProgQuery() has to avoid the possibility of getting + * partially-updated information in the event that we should happen + * to query DMA progress just as the DMA is updating it. It does that + * by taking advantage of the fact context is not saved frequently for + * the most part. We therefore read it at least twice until we get the + * same information twice in a row. + * + * Because a small, but not insignificant, amount of time is required + * to write out the progress-query information, especially upon + * completion of the DMA, it would be wise to guarantee some time lag + * between successive readings of the progress-query information. + */ + +/* + * How many iterations of the loop below to execute to stabilize values + */ +#define STABTIME 0 + +int MCD_XferProgrQuery (int channel, MCD_XferProg *progRep) +{ + MCD_XferProg prevRep; + int again; /* true if we are to try again to get consistent results */ + int i; /* used as a time-waste counter */ + int destDiffBytes; /* Total number of bytes that we think actually got xfered. */ + int numIterations; /* number of iterations */ + int bytesNotXfered; /* bytes that did not get xfered. */ + s8 *LWAlignedInitDestAddr, *LWAlignedCurrDestAddr; + int subModVal, addModVal; /* Mode values to added and subtracted from the + final destAddr */ + + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + /* Read a trial value for the progress-reporting values*/ + prevRep.lastSrcAddr = + (s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET]; + prevRep.lastDestAddr = + (s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET]; + prevRep.dmaSize = ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET]; + prevRep.currBufDesc = + (MCD_bufDesc*) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET]; + /* Repeatedly reread those values until they match previous values: */ + do { + /* Waste a little bit of time to ensure stability: */ + for (i = 0; i < STABTIME; i++) + i += i >> 2; /* make sure this loop does something so that it doesn't get optimized out */ + /* Check them again: */ + progRep->lastSrcAddr = + (s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET]; + progRep->lastDestAddr = + (s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET]; + progRep->dmaSize = ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET]; + progRep->currBufDesc = + (MCD_bufDesc*) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET]; + /* See if they match: */ + if ( prevRep.lastSrcAddr != progRep->lastSrcAddr + || prevRep.lastDestAddr != progRep->lastDestAddr + || prevRep.dmaSize != progRep->dmaSize + || prevRep.currBufDesc != progRep->currBufDesc) + { + /* If they don't match, remember previous values and try again:*/ + prevRep.lastSrcAddr = progRep->lastSrcAddr; + prevRep.lastDestAddr = progRep->lastDestAddr; + prevRep.dmaSize = progRep->dmaSize; + prevRep.currBufDesc = progRep->currBufDesc; + again = MCD_TRUE; + } + else + again = MCD_FALSE; + } while (again == MCD_TRUE); + + + /* Update the dCount, srcAddr and destAddr */ + /* To calculate dmaCount, we consider destination address. C + overs M1,P1,Z for destination */ + switch(MCD_remVariants.remDestRsdIncr[channel]) { + case MINUS1: + subModVal = ((int)progRep->lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) - 1); + addModVal = ((int)progRep->currBufDesc->destAddr) & ((MCD_remVariants.remXferSize[channel]) - 1); + LWAlignedInitDestAddr = (progRep->currBufDesc->destAddr) - addModVal; + LWAlignedCurrDestAddr = (progRep->lastDestAddr) - subModVal; + destDiffBytes = LWAlignedInitDestAddr - LWAlignedCurrDestAddr; + bytesNotXfered = (destDiffBytes/MCD_remVariants.remDestIncr[channel]) * + ( MCD_remVariants.remDestIncr[channel] + + MCD_remVariants.remXferSize[channel]); + progRep->dmaSize = destDiffBytes - bytesNotXfered + addModVal - subModVal; + break; + case ZERO: + progRep->lastDestAddr = progRep->currBufDesc->destAddr; + break; + case PLUS1: + /* This value has to be subtracted from the final calculated dCount. */ + subModVal = ((int)progRep->currBufDesc->destAddr) & ((MCD_remVariants.remXferSize[channel]) - 1); + /* These bytes are already in lastDestAddr. */ + addModVal = ((int)progRep->lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) - 1); + LWAlignedInitDestAddr = (progRep->currBufDesc->destAddr) - subModVal; + LWAlignedCurrDestAddr = (progRep->lastDestAddr) - addModVal; + destDiffBytes = (progRep->lastDestAddr - LWAlignedInitDestAddr); + numIterations = ( LWAlignedCurrDestAddr - LWAlignedInitDestAddr)/MCD_remVariants.remDestIncr[channel]; + bytesNotXfered = numIterations * + ( MCD_remVariants.remDestIncr[channel] + - MCD_remVariants.remXferSize[channel]); + progRep->dmaSize = destDiffBytes - bytesNotXfered - subModVal; + break; + default: + break; + } + + /* This covers M1,P1,Z for source */ + switch(MCD_remVariants.remSrcRsdIncr[channel]) { + case MINUS1: + progRep->lastSrcAddr = + progRep->currBufDesc->srcAddr + + ( MCD_remVariants.remSrcIncr[channel] * + (progRep->dmaSize/MCD_remVariants.remXferSize[channel])); + break; + case ZERO: + progRep->lastSrcAddr = progRep->currBufDesc->srcAddr; + break; + case PLUS1: + progRep->lastSrcAddr = + progRep->currBufDesc->srcAddr + + ( MCD_remVariants.remSrcIncr[channel] * + (progRep->dmaSize/MCD_remVariants.remXferSize[channel])); + break; + default: break; + } + + return(MCD_OK); +} +/******************* End of MCD_XferProgrQuery() ********************/ + +/********************************************************************/ +/* MCD_resmActions() does the majority of the actions of a DMA resume. + * It is called from MCD_killDma() and MCD_resumeDma(). It has to be + * a separate function because the kill function has to negate the task + * enable before resuming it, but the resume function has to do nothing + * if there is no DMA on that channel (i.e., if the enable bit is 0). + */ +static void MCD_resmActions (int channel) +{ + MCD_dmaBar->debugControl = DBG_CTL_DISABLE; + MCD_dmaBar->debugStatus = MCD_dmaBar->debugStatus; + MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT; /* This register is selected to know + which initiator is actually asserted. */ + if((MCD_dmaBar->ptdDebug >> channel ) & 0x1) + MCD_chStatus[channel] = MCD_RUNNING; + else + MCD_chStatus[channel] = MCD_IDLE; +} +/********************* End of MCD_resmActions() *********************/ + +/********************************************************************/ +/* Function: MCD_killDma + * Purpose: Halt the DMA on the requested channel, without any + * intention of resuming the DMA. + * Arguments: channel - requested channel + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + * + * Notes: + * A DMA may be killed from any state, including paused state, and it + * always goes to the MCD_HALTED state even if it is killed while in + * the MCD_NO_DMA or MCD_IDLE states. + */ +int MCD_killDma (int channel) +{ + /* MCD_XferProg progRep; */ + + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + MCD_dmaBar->taskControl[channel] = 0x0; + MCD_resumeDma (channel); + /* + * This must be after the write to the TCR so that the task doesn't + * start up again momentarily, and before the status assignment so + * as to override whatever MCD_resumeDma() may do to the channel + * status. + */ + MCD_chStatus[channel] = MCD_HALTED; + + /* + * Update the current buffer descriptor's lastDestAddr field + * + * MCD_XferProgrQuery (channel, &progRep); + * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr; + */ + return(MCD_OK); +} +/************************ End of MCD_killDma() **********************/ + +/********************************************************************/ +/* Function: MCD_continDma + * Purpose: Continue a DMA which as stopped due to encountering an + * unready buffer descriptor. + * Arguments: channel - channel to continue the DMA on + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + * + * Notes: + * This routine does not check to see if there is a task which can + * be continued. Also this routine should not be used with single DMAs. + */ +int MCD_continDma (int channel) +{ + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + MCD_dmaBar->taskControl[channel] |= TASK_CTL_EN; + MCD_chStatus[channel] = MCD_RUNNING; + + return(MCD_OK); +} +/********************** End of MCD_continDma() **********************/ + +/********************************************************************* + * MCD_pauseDma() and MCD_resumeDma() below use the DMA's debug unit + * to freeze a task and resume it. We freeze a task by breakpointing + * on the stated task. That is, not any specific place in the task, + * but any time that task executes. In particular, when that task + * executes, we want to freeze that task and only that task. + * + * The bits of the debug control register influence interrupts vs. + * breakpoints as follows: + * - Bits 14 and 0 enable or disable debug functions. If enabled, you + * will get the interrupt but you may or may not get a breakpoint. + * - Bits 2 and 1 decide whether you also get a breakpoint in addition + * to an interrupt. + * + * The debug unit can do these actions in response to either internally + * detected breakpoint conditions from the comparators, or in response + * to the external breakpoint pin, or both. + * - Bits 14 and 1 perform the above-described functions for + * internally-generated conditions, i.e., the debug comparators. + * - Bits 0 and 2 perform the above-described functions for external + * conditions, i.e., the breakpoint external pin. + * + * Note that, although you "always" get the interrupt when you turn + * the debug functions, the interrupt can nevertheless, if desired, be + * masked by the corresponding bit in the PTD's IMR. Note also that + * this means that bits 14 and 0 must enable debug functions before + * bits 1 and 2, respectively, have any effect. + * + * NOTE: It's extremely important to not pause more than one DMA channel + * at a time. + ********************************************************************/ + +/********************************************************************/ +/* Function: MCD_pauseDma + * Purpose: Pauses the DMA on a given channel (if any DMA is running + * on that channel). + * Arguments: channel + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + */ +int MCD_pauseDma (int channel) +{ + /* MCD_XferProg progRep; */ + + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + if (MCD_dmaBar->taskControl[channel] & TASK_CTL_EN) + { + MCD_dmaBar->debugComp1 = channel; + MCD_dmaBar->debugControl = DBG_CTL_ENABLE | (1 << (channel + 16)); + MCD_chStatus[channel] = MCD_PAUSED; + + /* + * Update the current buffer descriptor's lastDestAddr field + * + * MCD_XferProgrQuery (channel, &progRep); + * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr; + */ + } + return(MCD_OK); +} +/************************* End of MCD_pauseDma() ********************/ + +/********************************************************************/ +/* Function: MCD_resumeDma + * Purpose: Resumes the DMA on a given channel (if any DMA is + * running on that channel). + * Arguments: channel - channel on which to resume DMA + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + */ +int MCD_resumeDma (int channel) +{ + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + if (MCD_dmaBar->taskControl[channel] & TASK_CTL_EN) + MCD_resmActions (channel); + + return(MCD_OK); +} +/************************ End of MCD_resumeDma() ********************/ + +/********************************************************************/ +/* Function: MCD_csumQuery + * Purpose: Provide the checksum after performing a non-chained DMA + * Arguments: channel - channel to report on + * csum - pointer to where to write the checksum/CRC + * Returns: MCD_ERROR if the channel is invalid, else MCD_OK + * + * Notes: + * + */ +int MCD_csumQuery (int channel, u32 *csum) +{ +#ifdef MCD_INCLUDE_EU + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + *csum = MCD_relocBuffDesc[channel].csumResult; + return(MCD_OK); +#else + return(MCD_ERROR); +#endif +} +/*********************** End of MCD_resumeDma() *********************/ + +/********************************************************************/ +/* Function: MCD_getCodeSize + * Purpose: Provide the size requirements of the microcoded tasks + * Returns: Size in bytes + */ +int MCD_getCodeSize(void) +{ +#ifdef MCD_INCLUDE_EU + return(0x2b5c); +#else + return(0x173c); +#endif +} +/********************** End of MCD_getCodeSize() ********************/ + +/********************************************************************/ +/* Function: MCD_getVersion + * Purpose: Provide the version string and number + * Arguments: longVersion - user supplied pointer to a pointer to a char + * which points to the version string + * Returns: Version number and version string (by reference) + */ +char MCD_versionString[] = "Multi-channel DMA API Alpha v0.3 (2004-04-26)"; +#define MCD_REV_MAJOR 0x00 +#define MCD_REV_MINOR 0x03 + +int MCD_getVersion(char **longVersion) +{ + *longVersion = MCD_versionString; + return((MCD_REV_MAJOR << 8) | MCD_REV_MINOR); +} +/********************** End of MCD_getVersion() *********************/ + +/********************************************************************/ +/* Private version of memcpy() + * Note that everything this is used for is longword-aligned. + */ +static void MCD_memcpy (int *dest, int *src, u32 size) +{ + u32 i; + + for (i = 0; i < size; i += sizeof(int), dest++, src++) + *dest = *src; +} +/********************************************************************/ diff --git a/headers/MCD_progCheck.h b/headers/MCD_progCheck.h new file mode 100644 index 0000000..e0f578f --- /dev/null +++ b/headers/MCD_progCheck.h @@ -0,0 +1,5 @@ + /* This file is autogenerated. Do not change */ +#define CURRBD 4 +#define DCOUNT 6 +#define DESTPTR 5 +#define SRCPTR 7 diff --git a/headers/MCD_tasks.c b/headers/MCD_tasks.c new file mode 100644 index 0000000..76e8e37 --- /dev/null +++ b/headers/MCD_tasks.c @@ -0,0 +1,2449 @@ +/* + * File: MCD_tasks.c + * Purpose: Contains task code and structures for Multi-channel DMA + * + * Notes: + */ + +#include "MCD_dma.h" + +u32 MCD_varTab0[]; +u32 MCD_varTab1[]; +u32 MCD_varTab2[]; +u32 MCD_varTab3[]; +u32 MCD_varTab4[]; +u32 MCD_varTab5[]; +u32 MCD_varTab6[]; +u32 MCD_varTab7[]; +u32 MCD_varTab8[]; +u32 MCD_varTab9[]; +u32 MCD_varTab10[]; +u32 MCD_varTab11[]; +u32 MCD_varTab12[]; +u32 MCD_varTab13[]; +u32 MCD_varTab14[]; +u32 MCD_varTab15[]; + +u32 MCD_funcDescTab0[]; +#ifdef MCD_INCLUDE_EU +u32 MCD_funcDescTab1[]; +u32 MCD_funcDescTab2[]; +u32 MCD_funcDescTab3[]; +u32 MCD_funcDescTab4[]; +u32 MCD_funcDescTab5[]; +u32 MCD_funcDescTab6[]; +u32 MCD_funcDescTab7[]; +u32 MCD_funcDescTab8[]; +u32 MCD_funcDescTab9[]; +u32 MCD_funcDescTab10[]; +u32 MCD_funcDescTab11[]; +u32 MCD_funcDescTab12[]; +u32 MCD_funcDescTab13[]; +u32 MCD_funcDescTab14[]; +u32 MCD_funcDescTab15[]; +#endif + +u32 MCD_contextSave0[]; +u32 MCD_contextSave1[]; +u32 MCD_contextSave2[]; +u32 MCD_contextSave3[]; +u32 MCD_contextSave4[]; +u32 MCD_contextSave5[]; +u32 MCD_contextSave6[]; +u32 MCD_contextSave7[]; +u32 MCD_contextSave8[]; +u32 MCD_contextSave9[]; +u32 MCD_contextSave10[]; +u32 MCD_contextSave11[]; +u32 MCD_contextSave12[]; +u32 MCD_contextSave13[]; +u32 MCD_contextSave14[]; +u32 MCD_contextSave15[]; + +u32 MCD_realTaskTableSrc[] = +{ + 0x00000000, + 0x00000000, + (u32)MCD_varTab0, /* Task 0 Variable Table */ + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ + 0x00000000, + 0x00000000, + (u32)MCD_contextSave0, /* Task 0 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab1, /* Task 1 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab1, /* Task 1 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave1, /* Task 1 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab2, /* Task 2 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab2, /* Task 2 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave2, /* Task 2 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab3, /* Task 3 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab3, /* Task 3 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave3, /* Task 3 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab4, /* Task 4 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab4, /* Task 4 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave4, /* Task 4 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab5, /* Task 5 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab5, /* Task 5 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave5, /* Task 5 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab6, /* Task 6 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab6, /* Task 6 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave6, /* Task 6 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab7, /* Task 7 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab7, /* Task 7 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave7, /* Task 7 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab8, /* Task 8 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab8, /* Task 8 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave8, /* Task 8 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab9, /* Task 9 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab9, /* Task 9 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave9, /* Task 9 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab10, /* Task 10 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab10, /* Task 10 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave10, /* Task 10 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab11, /* Task 11 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab11, /* Task 11 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave11, /* Task 11 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab12, /* Task 12 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab12, /* Task 12 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave12, /* Task 12 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab13, /* Task 13 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab13, /* Task 13 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave13, /* Task 13 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab14, /* Task 14 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab14, /* Task 14 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave14, /* Task 14 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab15, /* Task 15 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab15, /* Task 15 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave15, /* Task 15 context save space */ + 0x00000000, +}; + + +u32 MCD_varTab0[] = +{ /* Task 0 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + + +u32 MCD_varTab1[] = +{ /* Task 1 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab2[]= +{ /* Task 2 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab3[]= +{ /* Task 3 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab4[]= +{ /* Task 4 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab5[]= +{ /* Task 5 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab6[]= +{ /* Task 6 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab7[]= +{ /* Task 7 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab8[]= +{ /* Task 8 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab9[]= +{ /* Task 9 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab10[]= +{ /* Task 10 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab11[]= +{ /* Task 11 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab12[]= +{ /* Task 12 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab13[]= +{ /* Task 13 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab14[]= +{ /* Task 14 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab15[]= +{ /* Task 15 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_funcDescTab0[]= +{ /* Task 0 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +#ifdef MCD_INCLUDE_EU +u32 MCD_funcDescTab1[]= +{ /* Task 1 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab2[]= +{ /* Task 2 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab3[]= +{ /* Task 3 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab4[]= +{ /* Task 4 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab5[]= +{ /* Task 5 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab6[]= +{ /* Task 6 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab7[]= +{ /* Task 7 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab8[]= +{ /* Task 8 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab9[]= +{ /* Task 9 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab10[]= +{ /* Task 10 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab11[]= +{ /* Task 11 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab12[]= +{ /* Task 12 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab13[]= +{ /* Task 13 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab14[]= +{ /* Task 14 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab15[]= +{ /* Task 15 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; +#endif /*MCD_INCLUDE_EU*/ + +u32 MCD_contextSave0[128]; /* Task 0 context save space */ +u32 MCD_contextSave1[128]; /* Task 1 context save space */ +u32 MCD_contextSave2[128]; /* Task 2 context save space */ +u32 MCD_contextSave3[128]; /* Task 3 context save space */ +u32 MCD_contextSave4[128]; /* Task 4 context save space */ +u32 MCD_contextSave5[128]; /* Task 5 context save space */ +u32 MCD_contextSave6[128]; /* Task 6 context save space */ +u32 MCD_contextSave7[128]; /* Task 7 context save space */ +u32 MCD_contextSave8[128]; /* Task 8 context save space */ +u32 MCD_contextSave9[128]; /* Task 9 context save space */ +u32 MCD_contextSave10[128]; /* Task 10 context save space */ +u32 MCD_contextSave11[128]; /* Task 11 context save space */ +u32 MCD_contextSave12[128]; /* Task 12 context save space */ +u32 MCD_contextSave13[128]; /* Task 13 context save space */ +u32 MCD_contextSave14[128]; /* Task 14 context save space */ +u32 MCD_contextSave15[128]; /* Task 15 context save space */ + + +u32 MCD_ChainNoEu_TDT[]; +u32 MCD_SingleNoEu_TDT[]; +#ifdef MCD_INCLUDE_EU +u32 MCD_ChainEu_TDT[]; +u32 MCD_SingleEu_TDT[]; +#endif +u32 MCD_ENetRcv_TDT[]; +u32 MCD_ENetXmit_TDT[]; + +u32 MCD_modelTaskTableSrc[]= +{ + (u32)MCD_ChainNoEu_TDT, + (u32)&((u8*)MCD_ChainNoEu_TDT)[0x0000016c], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_SingleNoEu_TDT, + (u32)&((u8*)MCD_SingleNoEu_TDT)[0x000000d4], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, +#ifdef MCD_INCLUDE_EU + (u32)MCD_ChainEu_TDT, + (u32)&((u8*)MCD_ChainEu_TDT)[0x000001b4], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_SingleEu_TDT, + (u32)&((u8*)MCD_SingleEu_TDT)[0x00000124], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, +#endif + (u32)MCD_ENetRcv_TDT, + (u32)&((u8*)MCD_ENetRcv_TDT)[0x0000009c], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_ENetXmit_TDT, + (u32)&((u8*)MCD_ENetXmit_TDT)[0x000000d0], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, +}; +u32 MCD_ChainNoEu_TDT[]= +{ + 0x80004000, /* 0000(:370): LCDEXT: idx0 = 0x00000000; ; */ + 0x8118801b, /* 0004(:370): LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */ + 0xb8c60018, /* 0008(:371): LCD: idx2 = *(idx1 + var12); idx2 once var0; idx2 += inc3 */ + 0x10002b10, /* 000C(:372): DRD1A: var10 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x7000000d, /* 0010(:373): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x018cf89f, /* 0014(:373): DRD2B1: var6 = EU3(); EU3(idx2) */ + 0x6000000a, /* 0018(:374): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf89f, /* 001C(:374): DRD2B1: idx0 = EU3(); EU3(idx2) */ + 0x000001f8, /* 0020(:0): NOP */ + 0x98180364, /* 0024(:378): LCD: idx0 = idx0; idx0 == var13; idx0 += inc4 */ + 0x8118801b, /* 0028(:380): LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */ + 0xf8c6001a, /* 002C(:381): LCDEXT: idx2 = *(idx1 + var12 + 8); idx2 once var0; idx2 += inc3 */ + 0xb8c6601b, /* 0030(:382): LCD: idx3 = *(idx1 + var12 + 12); ; idx3 += inc3 */ + 0x10002710, /* 0034(:384): DRD1A: var9 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x00000f18, /* 0038(:385): DRD1A: var3 = idx3; FN=0 init=0 WS=0 RS=0 */ + 0xb8c6001d, /* 003C(:387): LCD: idx2 = *(idx1 + var12 + 20); idx2 once var0; idx2 += inc3 */ + 0x10001310, /* 0040(:388): DRD1A: var4 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x60000007, /* 0044(:389): DRD2A: EU0=0 EU1=0 EU2=0 EU3=7 EXT init=0 WS=0 RS=0 */ + 0x014cf88b, /* 0048(:389): DRD2B1: var5 = EU3(); EU3(idx2,var11) */ + 0x98c6001c, /* 004C(:391): LCD: idx2 = idx1 + var12 + 4; idx2 once var0; idx2 += inc3 */ + 0x00000710, /* 0050(:392): DRD1A: var1 = idx2; FN=0 init=0 WS=0 RS=0 */ + 0x98c70018, /* 0054(:393): LCD: idx2 = idx1 + var14; idx2 once var0; idx2 += inc3 */ + 0x10001f10, /* 0058(:394): DRD1A: var7 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c818, /* 005C(:395): DRD1A: *idx2 = var3; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 0060(:0): NOP */ + 0xc1476018, /* 0064(:399): LCDEXT: idx1 = var2 + var14; ; idx1 += inc3 */ + 0xc003231d, /* 0068(:399): LCDEXT: idx2 = var0, idx3 = var6; idx3 == var12; idx2 += inc3, idx3 += inc5 */ + 0x811a601b, /* 006C(:400): LCD: idx4 = var2; ; idx4 += inc3 */ + 0xc1862102, /* 0070(:403): LCDEXT: idx5 = var3, idx6 = var12; idx6 < var4; idx5 += inc0, idx6 += inc2 */ + 0x849be009, /* 0074(:403): LCD: idx7 = var9; ; idx7 += inc1 */ + 0x03fed7b8, /* 0078(:406): DRD1A: *idx7; FN=0 init=31 WS=3 RS=3 */ + 0xda9b001b, /* 007C(:408): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 0080(:408): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x1000cb20, /* 0084(:409): DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0088(:410): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 008C(:410): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb28, /* 0090(:411): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0094(:412): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 0098(:412): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb30, /* 009C(:413): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00A0(:414): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 00A4(:414): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb38, /* 00A8(:415): DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c728, /* 00AC(:416): DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 00B0(:0): NOP */ + 0xc1476018, /* 00B4(:420): LCDEXT: idx1 = var2 + var14; ; idx1 += inc3 */ + 0xc003241d, /* 00B8(:420): LCDEXT: idx2 = var0, idx3 = var6; idx3 == var16; idx2 += inc3, idx3 += inc5 */ + 0x811a601b, /* 00BC(:421): LCD: idx4 = var2; ; idx4 += inc3 */ + 0xda9b001b, /* 00C0(:424): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00C4(:424): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x0000d3a0, /* 00C8(:425): DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */ + 0xc1862102, /* 00CC(:427): LCDEXT: idx5 = var3, idx6 = var12; idx6 < var4; idx5 += inc0, idx6 += inc2 */ + 0x849be009, /* 00D0(:427): LCD: idx7 = var9; ; idx7 += inc1 */ + 0x0bfed7b8, /* 00D4(:430): DRD1A: *idx7; FN=0 TFD init=31 WS=3 RS=3 */ + 0xda9b001b, /* 00D8(:432): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00DC(:432): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x1000cb20, /* 00E0(:433): DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00E4(:434): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 00E8(:434): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb28, /* 00EC(:435): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00F0(:436): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 00F4(:436): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb30, /* 00F8(:437): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00FC(:438): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 0100(:438): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb38, /* 0104(:439): DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c728, /* 0108(:440): DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 010C(:0): NOP */ + 0x8118801b, /* 0110(:444): LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */ + 0xd8c60018, /* 0114(:446): LCDEXT: idx2 = idx1 + var12; idx2 once var0; idx2 += inc3 */ + 0x98c6601c, /* 0118(:446): LCD: idx3 = idx1 + var12 + 4; ; idx3 += inc3 */ + 0x6000000b, /* 011C(:447): DRD2A: EU0=0 EU1=0 EU2=0 EU3=11 EXT init=0 WS=0 RS=0 */ + 0x0c8cfc9f, /* 0120(:447): DRD2B1: *idx2 = EU3(); EU3(*idx2) */ + 0x000001f8, /* 0124(:0): NOP */ + 0xa146001e, /* 0128(:450): LCD: idx1 = *(var2 + var12 + 24); idx1 once var0; idx1 += inc3 */ + 0x10000b08, /* 012C(:451): DRD1A: var2 = idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x10002050, /* 0130(:452): DRD1A: var8 = var10; FN=0 MORE init=0 WS=0 RS=0 */ + 0xb8c60018, /* 0134(:453): LCD: idx2 = *(idx1 + var12); idx2 once var0; idx2 += inc3 */ + 0x10002b10, /* 0138(:454): DRD1A: var10 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x7000000a, /* 013C(:455): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT MORE init=0 WS=0 RS=0 */ + 0x080cf89f, /* 0140(:455): DRD2B1: idx0 = EU3(); EU3(idx2) */ + 0x6000000d, /* 0144(:456): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT init=0 WS=0 RS=0 */ + 0x018cf89f, /* 0148(:456): DRD2B1: var6 = EU3(); EU3(idx2) */ + 0x000001f8, /* 014C(:0): NOP */ + 0x8618801b, /* 0150(:462): LCD: idx1 = var12; idx1 once var0; idx1 += inc3 */ + 0x7000000e, /* 0154(:463): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */ + 0x084cf21f, /* 0158(:463): DRD2B1: idx1 = EU3(); EU3(var8) */ + 0xd8990336, /* 015C(:464): LCDEXT: idx2 = idx1; idx2 > var12; idx2 += inc6 */ + 0x8019801b, /* 0160(:464): LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */ + 0x040001f8, /* 0164(:465): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ + 0x000001f8, /* 0168(:0): NOP */ + 0x000001f8, /* 016C(:0): NOP */ +}; +u32 MCD_SingleNoEu_TDT[]= +{ + 0x8198001b, /* 0000(:657): LCD: idx0 = var3; idx0 once var0; idx0 += inc3 */ + 0x7000000d, /* 0004(:658): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x080cf81f, /* 0008(:658): DRD2B1: idx0 = EU3(); EU3(idx0) */ + 0x8198801b, /* 000C(:659): LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */ + 0x6000000e, /* 0010(:660): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */ + 0x084cf85f, /* 0014(:660): DRD2B1: idx1 = EU3(); EU3(idx1) */ + 0x000001f8, /* 0018(:0): NOP */ + 0x8298001b, /* 001C(:664): LCD: idx0 = var5; idx0 once var0; idx0 += inc3 */ + 0x7000000d, /* 0020(:665): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x010cf81f, /* 0024(:665): DRD2B1: var4 = EU3(); EU3(idx0) */ + 0x6000000e, /* 0028(:666): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */ + 0x018cf81f, /* 002C(:666): DRD2B1: var6 = EU3(); EU3(idx0) */ + 0xc202601b, /* 0030(:669): LCDEXT: idx0 = var4, idx1 = var4; ; idx0 += inc3, idx1 += inc3 */ + 0xc002221c, /* 0034(:669): LCDEXT: idx2 = var0, idx3 = var4; idx3 == var8; idx2 += inc3, idx3 += inc4 */ + 0x809a601b, /* 0038(:670): LCD: idx4 = var1; ; idx4 += inc3 */ + 0xc10420c2, /* 003C(:673): LCDEXT: idx5 = var2, idx6 = var8; idx6 < var3; idx5 += inc0, idx6 += inc2 */ + 0x839be009, /* 0040(:673): LCD: idx7 = var7; ; idx7 += inc1 */ + 0x03fed7b8, /* 0044(:676): DRD1A: *idx7; FN=0 init=31 WS=3 RS=3 */ + 0xda9b001b, /* 0048(:678): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 004C(:678): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000006, /* 0050(:680): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 0054(:680): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x1000cb28, /* 0058(:681): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 005C(:682): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 0060(:682): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x1000cb30, /* 0064(:683): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0068(:684): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 006C(:684): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x0000cb38, /* 0070(:685): DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 0074(:0): NOP */ + 0xc202601b, /* 0078(:689): LCDEXT: idx0 = var4, idx1 = var4; ; idx0 += inc3, idx1 += inc3 */ + 0xc002229c, /* 007C(:689): LCDEXT: idx2 = var0, idx3 = var4; idx3 == var10; idx2 += inc3, idx3 += inc4 */ + 0x809a601b, /* 0080(:690): LCD: idx4 = var1; ; idx4 += inc3 */ + 0xda9b001b, /* 0084(:693): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 0088(:693): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x0000d3a0, /* 008C(:694): DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */ + 0xc10420c2, /* 0090(:696): LCDEXT: idx5 = var2, idx6 = var8; idx6 < var3; idx5 += inc0, idx6 += inc2 */ + 0x839be009, /* 0094(:696): LCD: idx7 = var7; ; idx7 += inc1 */ + 0x0bfed7b8, /* 0098(:699): DRD1A: *idx7; FN=0 TFD init=31 WS=3 RS=3 */ + 0xda9b001b, /* 009C(:701): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00A0(:701): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000006, /* 00A4(:703): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 00A8(:703): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x1000cb28, /* 00AC(:704): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00B0(:705): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 00B4(:705): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x1000cb30, /* 00B8(:706): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00BC(:707): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 00C0(:707): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x0000cb38, /* 00C4(:708): DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 00C8(:0): NOP */ + 0xc318022d, /* 00CC(:712): LCDEXT: idx0 = var6; idx0 > var8; idx0 += inc5 */ + 0x8018801b, /* 00D0(:712): LCD: idx1 = var0; idx1 once var0; idx1 += inc3 */ + 0x040001f8, /* 00D4(:713): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ +}; +#ifdef MCD_INCLUDE_EU +u32 MCD_ChainEu_TDT[]= +{ + 0x80004000, /* 0000(:947): LCDEXT: idx0 = 0x00000000; ; */ + 0x8198801b, /* 0004(:947): LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */ + 0xb8c68018, /* 0008(:948): LCD: idx2 = *(idx1 + var13); idx2 once var0; idx2 += inc3 */ + 0x10002f10, /* 000C(:949): DRD1A: var11 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x7000000d, /* 0010(:950): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x01ccf89f, /* 0014(:950): DRD2B1: var7 = EU3(); EU3(idx2) */ + 0x6000000a, /* 0018(:951): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf89f, /* 001C(:951): DRD2B1: idx0 = EU3(); EU3(idx2) */ + 0x000001f8, /* 0020(:0): NOP */ + 0x981803a4, /* 0024(:955): LCD: idx0 = idx0; idx0 == var14; idx0 += inc4 */ + 0x8198801b, /* 0028(:957): LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */ + 0xf8c6801a, /* 002C(:958): LCDEXT: idx2 = *(idx1 + var13 + 8); idx2 once var0; idx2 += inc3 */ + 0xb8c6e01b, /* 0030(:959): LCD: idx3 = *(idx1 + var13 + 12); ; idx3 += inc3 */ + 0x10002b10, /* 0034(:961): DRD1A: var10 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x00001318, /* 0038(:962): DRD1A: var4 = idx3; FN=0 init=0 WS=0 RS=0 */ + 0xb8c6801d, /* 003C(:964): LCD: idx2 = *(idx1 + var13 + 20); idx2 once var0; idx2 += inc3 */ + 0x10001710, /* 0040(:965): DRD1A: var5 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x60000007, /* 0044(:966): DRD2A: EU0=0 EU1=0 EU2=0 EU3=7 EXT init=0 WS=0 RS=0 */ + 0x018cf88c, /* 0048(:966): DRD2B1: var6 = EU3(); EU3(idx2,var12) */ + 0x98c6801c, /* 004C(:968): LCD: idx2 = idx1 + var13 + 4; idx2 once var0; idx2 += inc3 */ + 0x00000b10, /* 0050(:969): DRD1A: var2 = idx2; FN=0 init=0 WS=0 RS=0 */ + 0x98c78018, /* 0054(:970): LCD: idx2 = idx1 + var15; idx2 once var0; idx2 += inc3 */ + 0x10002310, /* 0058(:971): DRD1A: var8 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c820, /* 005C(:972): DRD1A: *idx2 = var4; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 0060(:0): NOP */ + 0x8698801b, /* 0064(:976): LCD: idx1 = var13; idx1 once var0; idx1 += inc3 */ + 0x7000000f, /* 0068(:977): DRD2A: EU0=0 EU1=0 EU2=0 EU3=15 EXT MORE init=0 WS=0 RS=0 */ + 0x084cf2df, /* 006C(:977): DRD2B1: idx1 = EU3(); EU3(var11) */ + 0xd899042d, /* 0070(:978): LCDEXT: idx2 = idx1; idx2 >= var16; idx2 += inc5 */ + 0x8019801b, /* 0074(:978): LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */ + 0x60000003, /* 0078(:979): DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */ + 0x2cd7c7df, /* 007C(:979): DRD2B2: EU3(var13) */ + 0xd8990364, /* 0080(:980): LCDEXT: idx2 = idx1; idx2 == var13; idx2 += inc4 */ + 0x8019801b, /* 0084(:980): LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */ + 0x60000003, /* 0088(:981): DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */ + 0x2c17c7df, /* 008C(:981): DRD2B2: EU3(var1) */ + 0x000001f8, /* 0090(:0): NOP */ + 0xc1c7e018, /* 0094(:984): LCDEXT: idx1 = var3 + var15; ; idx1 += inc3 */ + 0xc003a35e, /* 0098(:984): LCDEXT: idx2 = var0, idx3 = var7; idx3 == var13; idx2 += inc3, idx3 += inc6 */ + 0x819a601b, /* 009C(:985): LCD: idx4 = var3; ; idx4 += inc3 */ + 0xc206a142, /* 00A0(:988): LCDEXT: idx5 = var4, idx6 = var13; idx6 < var5; idx5 += inc0, idx6 += inc2 */ + 0x851be009, /* 00A4(:988): LCD: idx7 = var10; ; idx7 += inc1 */ + 0x63fe0000, /* 00A8(:991): DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 EXT init=31 WS=3 RS=3 */ + 0x0d4cfddf, /* 00AC(:991): DRD2B1: *idx5 = EU3(); EU3(*idx7) */ + 0xda9b001b, /* 00B0(:993): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00B4(:993): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000002, /* 00B8(:994): DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */ + 0x004cf81f, /* 00BC(:994): DRD2B1: var1 = EU3(); EU3(idx0) */ + 0x1000cb20, /* 00C0(:995): DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00C4(:996): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 00C8(:996): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb28, /* 00CC(:997): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00D0(:998): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 00D4(:998): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb30, /* 00D8(:999): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00DC(:1000): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 00E0(:1000): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb38, /* 00E4(:1001): DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c728, /* 00E8(:1002): DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 00EC(:0): NOP */ + 0xc1c7e018, /* 00F0(:1006): LCDEXT: idx1 = var3 + var15; ; idx1 += inc3 */ + 0xc003a49e, /* 00F4(:1006): LCDEXT: idx2 = var0, idx3 = var7; idx3 == var18; idx2 += inc3, idx3 += inc6 */ + 0x819a601b, /* 00F8(:1007): LCD: idx4 = var3; ; idx4 += inc3 */ + 0xda9b001b, /* 00FC(:1010): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 0100(:1010): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x0000d3a0, /* 0104(:1011): DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */ + 0xc206a142, /* 0108(:1013): LCDEXT: idx5 = var4, idx6 = var13; idx6 < var5; idx5 += inc0, idx6 += inc2 */ + 0x851be009, /* 010C(:1013): LCD: idx7 = var10; ; idx7 += inc1 */ + 0x6bfe0000, /* 0110(:1016): DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 TFD EXT init=31 WS=3 RS=3 */ + 0x0d4cfddf, /* 0114(:1016): DRD2B1: *idx5 = EU3(); EU3(*idx7) */ + 0xda9b001b, /* 0118(:1018): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 011C(:1018): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000002, /* 0120(:1019): DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */ + 0x004cf81f, /* 0124(:1019): DRD2B1: var1 = EU3(); EU3(idx0) */ + 0x1000cb20, /* 0128(:1020): DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 012C(:1021): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 0130(:1021): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb28, /* 0134(:1022): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0138(:1023): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 013C(:1023): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb30, /* 0140(:1024): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0144(:1025): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 0148(:1025): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb38, /* 014C(:1026): DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c728, /* 0150(:1027): DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 0154(:0): NOP */ + 0x8198801b, /* 0158(:1031): LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */ + 0xd8c68018, /* 015C(:1033): LCDEXT: idx2 = idx1 + var13; idx2 once var0; idx2 += inc3 */ + 0x98c6e01c, /* 0160(:1033): LCD: idx3 = idx1 + var13 + 4; ; idx3 += inc3 */ + 0x6000000b, /* 0164(:1034): DRD2A: EU0=0 EU1=0 EU2=0 EU3=11 EXT init=0 WS=0 RS=0 */ + 0x0c8cfc9f, /* 0168(:1034): DRD2B1: *idx2 = EU3(); EU3(*idx2) */ + 0x0000cc08, /* 016C(:1035): DRD1A: *idx3 = var1; FN=0 init=0 WS=0 RS=0 */ + 0xa1c6801e, /* 0170(:1038): LCD: idx1 = *(var3 + var13 + 24); idx1 once var0; idx1 += inc3 */ + 0x10000f08, /* 0174(:1039): DRD1A: var3 = idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x10002458, /* 0178(:1040): DRD1A: var9 = var11; FN=0 MORE init=0 WS=0 RS=0 */ + 0xb8c68018, /* 017C(:1041): LCD: idx2 = *(idx1 + var13); idx2 once var0; idx2 += inc3 */ + 0x10002f10, /* 0180(:1042): DRD1A: var11 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x7000000a, /* 0184(:1043): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT MORE init=0 WS=0 RS=0 */ + 0x080cf89f, /* 0188(:1043): DRD2B1: idx0 = EU3(); EU3(idx2) */ + 0x6000000d, /* 018C(:1044): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT init=0 WS=0 RS=0 */ + 0x01ccf89f, /* 0190(:1044): DRD2B1: var7 = EU3(); EU3(idx2) */ + 0x000001f8, /* 0194(:0): NOP */ + 0x8698801b, /* 0198(:1050): LCD: idx1 = var13; idx1 once var0; idx1 += inc3 */ + 0x7000000e, /* 019C(:1051): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */ + 0x084cf25f, /* 01A0(:1051): DRD2B1: idx1 = EU3(); EU3(var9) */ + 0xd899037f, /* 01A4(:1052): LCDEXT: idx2 = idx1; idx2 > var13; idx2 += inc7 */ + 0x8019801b, /* 01A8(:1052): LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */ + 0x040001f8, /* 01AC(:1053): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ + 0x000001f8, /* 01B0(:0): NOP */ + 0x000001f8, /* 01B4(:0): NOP */ +}; +u32 MCD_SingleEu_TDT[]= +{ + 0x8218001b, /* 0000(:1248): LCD: idx0 = var4; idx0 once var0; idx0 += inc3 */ + 0x7000000d, /* 0004(:1249): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x080cf81f, /* 0008(:1249): DRD2B1: idx0 = EU3(); EU3(idx0) */ + 0x8218801b, /* 000C(:1250): LCD: idx1 = var4; idx1 once var0; idx1 += inc3 */ + 0x6000000e, /* 0010(:1251): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */ + 0x084cf85f, /* 0014(:1251): DRD2B1: idx1 = EU3(); EU3(idx1) */ + 0x000001f8, /* 0018(:0): NOP */ + 0x8318001b, /* 001C(:1255): LCD: idx0 = var6; idx0 once var0; idx0 += inc3 */ + 0x7000000d, /* 0020(:1256): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x014cf81f, /* 0024(:1256): DRD2B1: var5 = EU3(); EU3(idx0) */ + 0x6000000e, /* 0028(:1257): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */ + 0x01ccf81f, /* 002C(:1257): DRD2B1: var7 = EU3(); EU3(idx0) */ + 0x8498001b, /* 0030(:1260): LCD: idx0 = var9; idx0 once var0; idx0 += inc3 */ + 0x7000000f, /* 0034(:1261): DRD2A: EU0=0 EU1=0 EU2=0 EU3=15 EXT MORE init=0 WS=0 RS=0 */ + 0x080cf19f, /* 0038(:1261): DRD2B1: idx0 = EU3(); EU3(var6) */ + 0xd81882a4, /* 003C(:1262): LCDEXT: idx1 = idx0; idx1 >= var10; idx1 += inc4 */ + 0x8019001b, /* 0040(:1262): LCD: idx2 = var0; idx2 once var0; idx2 += inc3 */ + 0x60000003, /* 0044(:1263): DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */ + 0x2c97c7df, /* 0048(:1263): DRD2B2: EU3(var9) */ + 0xd818826d, /* 004C(:1264): LCDEXT: idx1 = idx0; idx1 == var9; idx1 += inc5 */ + 0x8019001b, /* 0050(:1264): LCD: idx2 = var0; idx2 once var0; idx2 += inc3 */ + 0x60000003, /* 0054(:1265): DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */ + 0x2c17c7df, /* 0058(:1265): DRD2B2: EU3(var1) */ + 0x000001f8, /* 005C(:0): NOP */ + 0xc282e01b, /* 0060(:1268): LCDEXT: idx0 = var5, idx1 = var5; ; idx0 += inc3, idx1 += inc3 */ + 0xc002a25e, /* 0064(:1268): LCDEXT: idx2 = var0, idx3 = var5; idx3 == var9; idx2 += inc3, idx3 += inc6 */ + 0x811a601b, /* 0068(:1269): LCD: idx4 = var2; ; idx4 += inc3 */ + 0xc184a102, /* 006C(:1272): LCDEXT: idx5 = var3, idx6 = var9; idx6 < var4; idx5 += inc0, idx6 += inc2 */ + 0x841be009, /* 0070(:1272): LCD: idx7 = var8; ; idx7 += inc1 */ + 0x63fe0000, /* 0074(:1275): DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 EXT init=31 WS=3 RS=3 */ + 0x0d4cfddf, /* 0078(:1275): DRD2B1: *idx5 = EU3(); EU3(*idx7) */ + 0xda9b001b, /* 007C(:1277): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 0080(:1277): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000002, /* 0084(:1279): DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */ + 0x004cf99f, /* 0088(:1279): DRD2B1: var1 = EU3(); EU3(idx6) */ + 0x70000006, /* 008C(:1280): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 0090(:1280): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x1000cb28, /* 0094(:1281): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0098(:1282): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 009C(:1282): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x1000cb30, /* 00A0(:1283): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00A4(:1284): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 00A8(:1284): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x0000cb38, /* 00AC(:1285): DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 00B0(:0): NOP */ + 0xc282e01b, /* 00B4(:1289): LCDEXT: idx0 = var5, idx1 = var5; ; idx0 += inc3, idx1 += inc3 */ + 0xc002a31e, /* 00B8(:1289): LCDEXT: idx2 = var0, idx3 = var5; idx3 == var12; idx2 += inc3, idx3 += inc6 */ + 0x811a601b, /* 00BC(:1290): LCD: idx4 = var2; ; idx4 += inc3 */ + 0xda9b001b, /* 00C0(:1293): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00C4(:1293): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x0000d3a0, /* 00C8(:1294): DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */ + 0xc184a102, /* 00CC(:1296): LCDEXT: idx5 = var3, idx6 = var9; idx6 < var4; idx5 += inc0, idx6 += inc2 */ + 0x841be009, /* 00D0(:1296): LCD: idx7 = var8; ; idx7 += inc1 */ + 0x6bfe0000, /* 00D4(:1299): DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 TFD EXT init=31 WS=3 RS=3 */ + 0x0d4cfddf, /* 00D8(:1299): DRD2B1: *idx5 = EU3(); EU3(*idx7) */ + 0xda9b001b, /* 00DC(:1301): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00E0(:1301): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000002, /* 00E4(:1303): DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */ + 0x004cf99f, /* 00E8(:1303): DRD2B1: var1 = EU3(); EU3(idx6) */ + 0x70000006, /* 00EC(:1304): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 00F0(:1304): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x1000cb28, /* 00F4(:1305): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00F8(:1306): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 00FC(:1306): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x1000cb30, /* 0100(:1307): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0104(:1308): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 0108(:1308): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x0000cb38, /* 010C(:1309): DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 0110(:0): NOP */ + 0x8144801c, /* 0114(:1312): LCD: idx0 = var2 + var9 + 4; idx0 once var0; idx0 += inc3 */ + 0x0000c008, /* 0118(:1313): DRD1A: *idx0 = var1; FN=0 init=0 WS=0 RS=0 */ + 0xc398027f, /* 011C(:1315): LCDEXT: idx0 = var7; idx0 > var9; idx0 += inc7 */ + 0x8018801b, /* 0120(:1315): LCD: idx1 = var0; idx1 once var0; idx1 += inc3 */ + 0x040001f8, /* 0124(:1316): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ +}; +#endif +u32 MCD_ENetRcv_TDT[]= +{ + 0x80004000, /* 0000(:1389): LCDEXT: idx0 = 0x00000000; ; */ + 0x81988000, /* 0004(:1389): LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */ + 0x10000788, /* 0008(:1390): DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x6000000a, /* 000C(:1391): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf05f, /* 0010(:1391): DRD2B1: idx0 = EU3(); EU3(var1) */ + 0x98180209, /* 0014(:1394): LCD: idx0 = idx0; idx0 != var8; idx0 += inc1 */ + 0x81c40004, /* 0018(:1396): LCD: idx1 = var3 + var8 + 4; idx1 once var0; idx1 += inc0 */ + 0x7000000e, /* 001C(:1397): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */ + 0x010cf05f, /* 0020(:1397): DRD2B1: var4 = EU3(); EU3(var1) */ + 0x7000000c, /* 0024(:1398): DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT MORE init=0 WS=0 RS=0 */ + 0x01ccf05f, /* 0028(:1398): DRD2B1: var7 = EU3(); EU3(var1) */ + 0x70000004, /* 002C(:1399): DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */ + 0x014cf049, /* 0030(:1399): DRD2B1: var5 = EU3(); EU3(var1,var9) */ + 0x70000004, /* 0034(:1400): DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */ + 0x004cf04a, /* 0038(:1400): DRD2B1: var1 = EU3(); EU3(var1,var10) */ + 0x00000b88, /* 003C(:1403): DRD1A: var2 = *idx1; FN=0 init=0 WS=0 RS=0 */ + 0xc4030150, /* 0040(:1406): LCDEXT: idx1 = var8, idx2 = var6; idx1 < var5; idx1 += inc2, idx2 += inc0 */ + 0x8119e012, /* 0044(:1406): LCD: idx3 = var2; ; idx3 += inc2 */ + 0x03e0cf90, /* 0048(:1409): DRD1A: *idx3 = *idx2; FN=0 init=31 WS=0 RS=0 */ + 0x81188000, /* 004C(:1412): LCD: idx1 = var2; idx1 once var0; idx1 += inc0 */ + 0x000ac788, /* 0050(:1413): DRD1A: *idx1 = *idx1; FN=0 init=0 WS=1 RS=1 */ + 0xc4030000, /* 0054(:1415): LCDEXT: idx1 = var8, idx2 = var6; idx1 once var0; idx1 += inc0, idx2 += inc0 */ + 0x8199e000, /* 0058(:1415): LCD: idx3 = var3; ; idx3 += inc0 */ + 0x70000004, /* 005C(:1421): DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */ + 0x084cfc8b, /* 0060(:1421): DRD2B1: idx1 = EU3(); EU3(*idx2,var11) */ + 0x60000005, /* 0064(:1422): DRD2A: EU0=0 EU1=0 EU2=0 EU3=5 EXT init=0 WS=0 RS=0 */ + 0x0cccf841, /* 0068(:1422): DRD2B1: *idx3 = EU3(); EU3(idx1,var1) */ + 0x81c60000, /* 006C(:1428): LCD: idx1 = var3 + var12; idx1 once var0; idx1 += inc0 */ + 0xc399021b, /* 0070(:1430): LCDEXT: idx2 = var7; idx2 > var8; idx2 += inc3 */ + 0x80198000, /* 0074(:1430): LCD: idx3 = var0; idx3 once var0; idx3 += inc0 */ + 0x00008400, /* 0078(:1431): DRD1A: idx1 = var0; FN=0 init=0 WS=0 RS=0 */ + 0x00000f08, /* 007C(:1432): DRD1A: var3 = idx1; FN=0 init=0 WS=0 RS=0 */ + 0x81988000, /* 0080(:1435): LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */ + 0x10000788, /* 0084(:1436): DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x6000000a, /* 0088(:1437): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf05f, /* 008C(:1437): DRD2B1: idx0 = EU3(); EU3(var1) */ + 0xc2188209, /* 0090(:1440): LCDEXT: idx1 = var4; idx1 != var8; idx1 += inc1 */ + 0x80190000, /* 0094(:1440): LCD: idx2 = var0; idx2 once var0; idx2 += inc0 */ + 0x040001f8, /* 0098(:1441): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ + 0x000001f8, /* 009C(:0): NOP */ +}; +u32 MCD_ENetXmit_TDT[]= +{ + 0x80004000, /* 0000(:1516): LCDEXT: idx0 = 0x00000000; ; */ + 0x81988000, /* 0004(:1516): LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */ + 0x10000788, /* 0008(:1517): DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x6000000a, /* 000C(:1518): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf05f, /* 0010(:1518): DRD2B1: idx0 = EU3(); EU3(var1) */ + 0x98180309, /* 0014(:1521): LCD: idx0 = idx0; idx0 != var12; idx0 += inc1 */ + 0x80004003, /* 0018(:1523): LCDEXT: idx1 = 0x00000003; ; */ + 0x81c60004, /* 001C(:1523): LCD: idx2 = var3 + var12 + 4; idx2 once var0; idx2 += inc0 */ + 0x7000000e, /* 0020(:1524): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */ + 0x014cf05f, /* 0024(:1524): DRD2B1: var5 = EU3(); EU3(var1) */ + 0x7000000c, /* 0028(:1525): DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT MORE init=0 WS=0 RS=0 */ + 0x028cf05f, /* 002C(:1525): DRD2B1: var10 = EU3(); EU3(var1) */ + 0x7000000d, /* 0030(:1526): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x018cf05f, /* 0034(:1526): DRD2B1: var6 = EU3(); EU3(var1) */ + 0x70000004, /* 0038(:1527): DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */ + 0x01ccf04d, /* 003C(:1527): DRD2B1: var7 = EU3(); EU3(var1,var13) */ + 0x10000b90, /* 0040(:1528): DRD1A: var2 = *idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x60000004, /* 0044(:1529): DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT init=0 WS=0 RS=0 */ + 0x020cf0a1, /* 0048(:1529): DRD2B1: var8 = EU3(); EU3(var2,idx1) */ + 0xc3188312, /* 004C(:1532): LCDEXT: idx1 = var6; idx1 > var12; idx1 += inc2 */ + 0x83c70000, /* 0050(:1532): LCD: idx2 = var7 + var14; idx2 once var0; idx2 += inc0 */ + 0x00001f10, /* 0054(:1533): DRD1A: var7 = idx2; FN=0 init=0 WS=0 RS=0 */ + 0xc583a3c3, /* 0058(:1535): LCDEXT: idx1 = var11, idx2 = var7; idx2 >= var15; idx1 += inc0, idx2 += inc3 */ + 0x81042325, /* 005C(:1535): LCD: idx3 = var2, idx4 = var8; idx4 == var12; idx3 += inc4, idx4 += inc5 */ + 0x03e0c798, /* 0060(:1540): DRD1A: *idx1 = *idx3; FN=0 init=31 WS=0 RS=0 */ + 0xd8990000, /* 0064(:1543): LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */ + 0x9999e000, /* 0068(:1543): LCD: idx3 = idx3; ; idx3 += inc0 */ + 0x000acf98, /* 006C(:1544): DRD1A: *idx3 = *idx3; FN=0 init=0 WS=1 RS=1 */ + 0xd8992306, /* 0070(:1546): LCDEXT: idx1 = idx1, idx2 = idx2; idx2 > var12; idx1 += inc0, idx2 += inc6 */ + 0x9999e03f, /* 0074(:1546): LCD: idx3 = idx3; ; idx3 += inc7 */ + 0x03eac798, /* 0078(:1549): DRD1A: *idx1 = *idx3; FN=0 init=31 WS=1 RS=1 */ + 0xd8990000, /* 007C(:1552): LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */ + 0x9999e000, /* 0080(:1552): LCD: idx3 = idx3; ; idx3 += inc0 */ + 0x000acf98, /* 0084(:1553): DRD1A: *idx3 = *idx3; FN=0 init=0 WS=1 RS=1 */ + 0xd8990000, /* 0088(:1555): LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */ + 0x99832302, /* 008C(:1555): LCD: idx3 = idx3, idx4 = var6; idx4 > var12; idx3 += inc0, idx4 += inc2 */ + 0x0beac798, /* 0090(:1558): DRD1A: *idx1 = *idx3; FN=0 TFD init=31 WS=1 RS=1 */ + 0x81988000, /* 0094(:1560): LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */ + 0x6000000b, /* 0098(:1561): DRD2A: EU0=0 EU1=0 EU2=0 EU3=11 EXT init=0 WS=0 RS=0 */ + 0x0c4cfc5f, /* 009C(:1561): DRD2B1: *idx1 = EU3(); EU3(*idx1) */ + 0x81c80000, /* 00A0(:1563): LCD: idx1 = var3 + var16; idx1 once var0; idx1 += inc0 */ + 0xc5190312, /* 00A4(:1565): LCDEXT: idx2 = var10; idx2 > var12; idx2 += inc2 */ + 0x80198000, /* 00A8(:1565): LCD: idx3 = var0; idx3 once var0; idx3 += inc0 */ + 0x00008400, /* 00AC(:1566): DRD1A: idx1 = var0; FN=0 init=0 WS=0 RS=0 */ + 0x00000f08, /* 00B0(:1567): DRD1A: var3 = idx1; FN=0 init=0 WS=0 RS=0 */ + 0x81988000, /* 00B4(:1570): LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */ + 0x10000788, /* 00B8(:1571): DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x6000000a, /* 00BC(:1572): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf05f, /* 00C0(:1572): DRD2B1: idx0 = EU3(); EU3(var1) */ + 0xc2988309, /* 00C4(:1575): LCDEXT: idx1 = var5; idx1 != var12; idx1 += inc1 */ + 0x80190000, /* 00C8(:1575): LCD: idx2 = var0; idx2 once var0; idx2 += inc0 */ + 0x040001f8, /* 00CC(:1576): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ + 0x000001f8, /* 00D0(:0): NOP */ +}; + +#ifdef MCD_INCLUDE_EU +MCD_bufDesc MCD_singleBufDescs[NCHANNELS]; +#endif diff --git a/headers/MCD_tasksInit.c b/headers/MCD_tasksInit.c new file mode 100644 index 0000000..fd651b2 --- /dev/null +++ b/headers/MCD_tasksInit.c @@ -0,0 +1,224 @@ +/* + * File: MCD_tasksInit.c + * Purpose: Functions for initializing variable tables of different + * types of tasks. + * + * Notes: + */ + +/* + * Do not edit! + */ + +#include "MCD_dma.h" + +extern dmaRegs *MCD_dmaBar; + + +/* + * Task 0 + */ + +void MCD_startDmaChainNoEu(int *currBD, short srcIncr, short destIncr, int xferSize, short xferSizeIncr, int *cSave, volatile TaskTableEntry *taskTable, int channel) +{ + + MCD_SET_VAR(taskTable+channel, 2, (u32)currBD); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr)); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr)); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 11, (u32)xferSize); /* var[11] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr)); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 0, (u32)cSave); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 3, (u32)0x00000000); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000000); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 12, (u32)0x00000000); /* var[12] */ + MCD_SET_VAR(taskTable+channel, 13, (u32)0x80000000); /* var[13] */ + MCD_SET_VAR(taskTable+channel, 14, (u32)0x00000010); /* var[14] */ + MCD_SET_VAR(taskTable+channel, 15, (u32)0x00000004); /* var[15] */ + MCD_SET_VAR(taskTable+channel, 16, (u32)0x08000000); /* var[16] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000); /* inc[3] */ + MCD_SET_VAR(taskTable+channel, 28, (u32)0x80000000); /* inc[4] */ + MCD_SET_VAR(taskTable+channel, 29, (u32)0x80000001); /* inc[5] */ + MCD_SET_VAR(taskTable+channel, 30, (u32)0x40000000); /* inc[6] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} + + +/* + * Task 1 + */ + +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) +{ + + MCD_SET_VAR(taskTable+channel, 7, (u32)srcAddr); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr)); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 2, (u32)destAddr); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr)); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 3, (u32)dmaSize); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr)); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)flags); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)currBD); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 0, (u32)cSave); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000004); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x08000000); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000); /* inc[3] */ + MCD_SET_VAR(taskTable+channel, 28, (u32)0x80000001); /* inc[4] */ + MCD_SET_VAR(taskTable+channel, 29, (u32)0x40000000); /* inc[5] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} + + +/* + * Task 2 + */ + +void MCD_startDmaChainEu(int *currBD, short srcIncr, short destIncr, int xferSize, short xferSizeIncr, int *cSave, volatile TaskTableEntry *taskTable, int channel) +{ + + MCD_SET_VAR(taskTable+channel, 3, (u32)currBD); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr)); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr)); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 12, (u32)xferSize); /* var[12] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr)); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 0, (u32)cSave); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 2, (u32)0x00000000); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000000); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 11, (u32)0x00000000); /* var[11] */ + MCD_SET_VAR(taskTable+channel, 13, (u32)0x00000000); /* var[13] */ + MCD_SET_VAR(taskTable+channel, 14, (u32)0x80000000); /* var[14] */ + MCD_SET_VAR(taskTable+channel, 15, (u32)0x00000010); /* var[15] */ + MCD_SET_VAR(taskTable+channel, 16, (u32)0x00000001); /* var[16] */ + MCD_SET_VAR(taskTable+channel, 17, (u32)0x00000004); /* var[17] */ + MCD_SET_VAR(taskTable+channel, 18, (u32)0x08000000); /* var[18] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000); /* inc[3] */ + MCD_SET_VAR(taskTable+channel, 28, (u32)0x80000000); /* inc[4] */ + MCD_SET_VAR(taskTable+channel, 29, (u32)0xc0000000); /* inc[5] */ + MCD_SET_VAR(taskTable+channel, 30, (u32)0x80000001); /* inc[6] */ + MCD_SET_VAR(taskTable+channel, 31, (u32)0x40000000); /* inc[7] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} + + +/* + * Task 3 + */ + +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) +{ + + MCD_SET_VAR(taskTable+channel, 8, (u32)srcAddr); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr)); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 3, (u32)destAddr); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr)); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)dmaSize); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr)); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)flags); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 2, (u32)currBD); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 0, (u32)cSave); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000001); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 11, (u32)0x00000004); /* var[11] */ + MCD_SET_VAR(taskTable+channel, 12, (u32)0x08000000); /* var[12] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000); /* inc[3] */ + MCD_SET_VAR(taskTable+channel, 28, (u32)0xc0000000); /* inc[4] */ + MCD_SET_VAR(taskTable+channel, 29, (u32)0x80000000); /* inc[5] */ + MCD_SET_VAR(taskTable+channel, 30, (u32)0x80000001); /* inc[6] */ + MCD_SET_VAR(taskTable+channel, 31, (u32)0x40000000); /* inc[7] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} + + +/* + * Task 4 + */ + +void MCD_startDmaENetRcv(char *bDBase, char *currBD, char *rcvFifoPtr, volatile TaskTableEntry *taskTable, int channel) +{ + + MCD_SET_VAR(taskTable+channel, 0, (u32)bDBase); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 3, (u32)currBD); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)rcvFifoPtr); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 2, (u32)0x00000000); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x0000ffff); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x30000000); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 11, (u32)0x0fffffff); /* var[11] */ + MCD_SET_VAR(taskTable+channel, 12, (u32)0x00000008); /* var[12] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)0x00000000); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)0x60000000); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)0x20000004); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0x40000000); /* inc[3] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} + + +/* + * Task 5 + */ + +void MCD_startDmaENetXmit(char *bDBase, char *currBD, char *xmitFifoPtr, volatile TaskTableEntry *taskTable, int channel) +{ + + MCD_SET_VAR(taskTable+channel, 0, (u32)bDBase); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 3, (u32)currBD); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 11, (u32)xmitFifoPtr); /* var[11] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 2, (u32)0x00000000); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000000); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 12, (u32)0x00000000); /* var[12] */ + MCD_SET_VAR(taskTable+channel, 13, (u32)0x0000ffff); /* var[13] */ + MCD_SET_VAR(taskTable+channel, 14, (u32)0xffffffff); /* var[14] */ + MCD_SET_VAR(taskTable+channel, 15, (u32)0x00000004); /* var[15] */ + MCD_SET_VAR(taskTable+channel, 16, (u32)0x00000008); /* var[16] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)0x00000000); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)0x60000000); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)0x40000000); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0xc000fffc); /* inc[3] */ + MCD_SET_VAR(taskTable+channel, 28, (u32)0xe0000004); /* inc[4] */ + MCD_SET_VAR(taskTable+channel, 29, (u32)0x80000000); /* inc[5] */ + MCD_SET_VAR(taskTable+channel, 30, (u32)0x4000ffff); /* inc[6] */ + MCD_SET_VAR(taskTable+channel, 31, (u32)0xe0000001); /* inc[7] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} diff --git a/headers/MCD_tasksInit.h b/headers/MCD_tasksInit.h new file mode 100644 index 0000000..daf871c --- /dev/null +++ b/headers/MCD_tasksInit.h @@ -0,0 +1,44 @@ +#ifndef MCD_TSK_INIT_H +#define MCD_TSK_INIT_H 1 + +/* + * Do not edit! + */ + + +/* + * Task 0 + */ +void MCD_startDmaChainNoEu(int *currBD, short srcIncr, short destIncr, int xferSize, short xferSizeIncr, int *cSave, volatile TaskTableEntry *taskTable, int channel); + + +/* + * Task 1 + */ +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); + + +/* + * Task 2 + */ +void MCD_startDmaChainEu(int *currBD, short srcIncr, short destIncr, int xferSize, short xferSizeIncr, int *cSave, volatile TaskTableEntry *taskTable, int channel); + + +/* + * Task 3 + */ +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); + + +/* + * Task 4 + */ +void MCD_startDmaENetRcv(char *bDBase, char *currBD, char *rcvFifoPtr, volatile TaskTableEntry *taskTable, int channel); + + +/* + * Task 5 + */ +void MCD_startDmaENetXmit(char *bDBase, char *currBD, char *xmitFifoPtr, volatile TaskTableEntry *taskTable, int channel); + +#endif /* MCD_TSK_INIT_H */ diff --git a/sources/ii_add.h b/headers/ii_add.h similarity index 100% rename from sources/ii_add.h rename to headers/ii_add.h diff --git a/sources/ii_and.h b/headers/ii_and.h similarity index 100% rename from sources/ii_and.h rename to headers/ii_and.h diff --git a/sources/ii_dbcc.h b/headers/ii_dbcc.h similarity index 100% rename from sources/ii_dbcc.h rename to headers/ii_dbcc.h diff --git a/sources/ii_ewf.h b/headers/ii_ewf.h similarity index 100% rename from sources/ii_ewf.h rename to headers/ii_ewf.h diff --git a/sources/ii_exg.h b/headers/ii_exg.h similarity index 100% rename from sources/ii_exg.h rename to headers/ii_exg.h diff --git a/sources/ii_func.h b/headers/ii_func.h similarity index 100% rename from sources/ii_func.h rename to headers/ii_func.h diff --git a/sources/ii_jmp.h b/headers/ii_jmp.h similarity index 100% rename from sources/ii_jmp.h rename to headers/ii_jmp.h diff --git a/sources/ii_lea.h b/headers/ii_lea.h similarity index 100% rename from sources/ii_lea.h rename to headers/ii_lea.h diff --git a/sources/ii_macro.h b/headers/ii_macro.h similarity index 100% rename from sources/ii_macro.h rename to headers/ii_macro.h diff --git a/sources/ii_move.h b/headers/ii_move.h similarity index 100% rename from sources/ii_move.h rename to headers/ii_move.h diff --git a/sources/ii_movem.h b/headers/ii_movem.h similarity index 95% rename from sources/ii_movem.h rename to headers/ii_movem.h index 5e8a470..732b390 100644 --- a/sources/ii_movem.h +++ b/headers/ii_movem.h @@ -372,3 +372,4 @@ mmmr_na6\@: mmmr_na7\@: ii_end .endm + diff --git a/sources/ii_movep.h b/headers/ii_movep.h similarity index 100% rename from sources/ii_movep.h rename to headers/ii_movep.h diff --git a/sources/ii_op.h b/headers/ii_op.h similarity index 100% rename from sources/ii_op.h rename to headers/ii_op.h diff --git a/sources/ii_opc.h b/headers/ii_opc.h similarity index 100% rename from sources/ii_opc.h rename to headers/ii_opc.h diff --git a/sources/ii_or.h b/headers/ii_or.h similarity index 100% rename from sources/ii_or.h rename to headers/ii_or.h diff --git a/sources/ii_pea.h b/headers/ii_pea.h similarity index 100% rename from sources/ii_pea.h rename to headers/ii_pea.h diff --git a/sources/ii_shd.h b/headers/ii_shd.h similarity index 100% rename from sources/ii_shd.h rename to headers/ii_shd.h diff --git a/sources/ii_shift.h b/headers/ii_shift.h similarity index 100% rename from sources/ii_shift.h rename to headers/ii_shift.h diff --git a/sources/ii_sub.h b/headers/ii_sub.h similarity index 100% rename from sources/ii_sub.h rename to headers/ii_sub.h diff --git a/sources/macro.h b/headers/macro.h similarity index 100% rename from sources/macro.h rename to headers/macro.h diff --git a/sources/movem.h b/headers/movem.h similarity index 100% rename from sources/movem.h rename to headers/movem.h diff --git a/sources/startcf.h b/headers/startcf.h similarity index 94% rename from sources/startcf.h rename to headers/startcf.h index c538f16..50b6c97 100644 --- a/sources/startcf.h +++ b/headers/startcf.h @@ -20,10 +20,8 @@ */ /********************************************************************************/ +#ifdef ii_on -#define cf_stack - -//#define ii_on #define halten #define halten_dbcc #define halten_and @@ -40,6 +38,8 @@ #define halten_movep #define halten_ewf +#endif + #define DIP_SWITCH (*(vuint8 *)(&__MBAR[0xA2C])) #define DIP_SWITCHa ___MBAR + 0xA2C diff --git a/sources/sysinit.h b/headers/sysinit.h similarity index 100% rename from sources/sysinit.h rename to headers/sysinit.h diff --git a/lcf/DDRAM.lcf b/lcf/DDRAM.lcf index 795732d..f7d233c 100644 --- a/lcf/DDRAM.lcf +++ b/lcf/DDRAM.lcf @@ -68,8 +68,8 @@ _rt_mbar = ___RAMBAR0 + 0x844; # (c)0f # 32KB on-chip System SRAM ___SYS_SRAM = 0xFF010000; ___SYS_SRAM_SIZE = 0x00008000; - - + + .text : { startcf.c(.text) @@ -79,10 +79,13 @@ _rt_mbar = ___RAMBAR0 + 0x844; # (c)0f mmu.s(.text) exceptions.s(.text) supervisor.s(.text) - ewf.s(.text) illegal_instruction.s(.text) + MCD_dmaApi.c(.*) + MCD_tasksInit.c(.*) + MCD_tasks.c(.*) last.c(.text) - . = ALIGN (0x4); + __SDA_BASE = .; +# . = ALIGN (0x4); } > code } \ No newline at end of file diff --git a/lcf/FLASH.lcf b/lcf/FLASH.lcf index 0315e2f..f314eee 100644 --- a/lcf/FLASH.lcf +++ b/lcf/FLASH.lcf @@ -5,13 +5,15 @@ KEEP_SECTION {.vectortable} # Memory ranges MEMORY { - code (RX) : ORIGIN = 0xE0000000, LENGTH = 0x00200000 + userram (RWX) : ORIGIN = 0x00010000, LENGTH = 0x10000000 + code (RX) : ORIGIN = 0xE0000000, LENGTH = 0x00100000 } SECTIONS { - -#BaS Basis adresse - ___Bas_base = 0x1FE00000; + +# Heap and Stack sizes definition + ___heap_size = 0x10000; + ___stack_size = 0x10000; # Board Memory map definitions from linker command files: # __SDRAM,__SDRAM_SIZE, __CODE_FLASH, __CODE_FLASH_SIZE @@ -37,13 +39,11 @@ SECTIONS { # 4KB on-chip Core SRAM0: -> exception table and exception stack ___RAMBAR0 = 0xFF100000; ___RAMBAR0_SIZE = 0x00001000; - - ___SUP_SP = ___RAMBAR0 + ___RAMBAR0_SIZE - 4; - # 4KB on-chip Core SRAM1: -> modified code ___RAMBAR1 = 0xFF101000; ___RAMBAR1_SIZE = 0x00001000; + # Systemveriablem:****************************************** # RAMBAR0 0 bis 0x7FF -> exception vectoren _rt_mod = ___RAMBAR0 + 0x800; @@ -69,20 +69,86 @@ _rt_mbar = ___RAMBAR0 + 0x844; # (c)0f ___SYS_SRAM = 0xFF010000; ___SYS_SRAM_SIZE = 0x00008000; + ___SUP_SP = ___RAMBAR0 + ___RAMBAR0_SIZE - 4; + + .userram : {} > userram .code : {} > code .text : { - startcf.c(.text) - sysinit.c(.text) - BaS.c(.text) - sd_card.c(.text) - mmu.s(.text) - exceptions.s(.text) - supervisor.s(.text) - ewf.s(.text) - illegal_instruction.s(.text) - last.c(.text) + *(.text) + . = ALIGN (0x4); + *(.rodata) + . = ALIGN (0x4); + ___ROM_AT = .; + ___DATA_ROM = .; + } >> code -} \ No newline at end of file + .data : AT(___ROM_AT) + { + ___DATA_RAM = .; + . = ALIGN(0x4); + *(.exception) + . = ALIGN(0x4); + __exception_table_start__ = .; + EXCEPTION + __exception_table_end__ = .; + ___sinit__ = .; + STATICINIT + __START_DATA = .; + *(.data) + . = ALIGN (0x4); + __END_DATA = .; + __START_SDATA = .; + *(.sdata) + . = ALIGN (0x4); + __END_SDATA = .; + ___DATA_END = .; + __SDA_BASE = .; + . = ALIGN (0x4); + } >> userram + + .bss : + { + ___BSS_START = .; + __START_SBSS = .; + *(.sbss) + . = ALIGN (0x4); + *(SCOMMON) + __END_SBSS = .; + + __START_BSS = .; + *(.bss) + . = ALIGN (0x4); + *(COMMON) + __END_BSS = .; + ___BSS_END = .; + + . = ALIGN(0x4); + } >> userram + .custom : + { + ___HEAP_START = .; + ___heap_addr = ___HEAP_START; + ___HEAP_END = ___HEAP_START + ___heap_size; + ___SP_END = ___HEAP_END; + ___SP_INIT = ___SP_END + ___stack_size; + + . = ALIGN (0x4); + } >> userram + + __SP_INIT = ___SP_INIT; + + _romp_at = ___ROM_AT + SIZEOF(.data); + .romp : AT(_romp_at) + { + __S_romp = _romp_at; + WRITEW(___ROM_AT); + WRITEW(ADDR(.data)); + WRITEW(SIZEOF(.data)); + WRITEW(0); + WRITEW(0); + WRITEW(0); + } +} diff --git a/mcdapirev0p3/MCD_dmaApi.c b/mcdapirev0p3/MCD_dmaApi.c new file mode 100644 index 0000000..839fce1 --- /dev/null +++ b/mcdapirev0p3/MCD_dmaApi.c @@ -0,0 +1,933 @@ +/* + * File: MCD_dmaApi.c + * Purpose: Main C file for multi-channel DMA API. + * + * Notes: + */ + +#include "MCD_dma.h" +#include "MCD_tasksInit.h" +#include "MCD_progCheck.h" + +/********************************************************************/ +/* + * This is an API-internal pointer to the DMA's registers + */ +dmaRegs *MCD_dmaBar; + +/* + * These are the real and model task tables as generated by the + * build process + */ +extern TaskTableEntry MCD_realTaskTableSrc[NCHANNELS]; +extern TaskTableEntry MCD_modelTaskTableSrc[NUMOFVARIANTS]; + +/* + * However, this (usually) gets relocated to on-chip SRAM, at which + * point we access them as these tables + */ +volatile TaskTableEntry *MCD_taskTable; +TaskTableEntry *MCD_modelTaskTable; + + +/* + * MCD_chStatus[] is an array of status indicators for remembering + * whether a DMA has ever been attempted on each channel, pausing + * status, etc. + */ +static int MCD_chStatus[NCHANNELS] = +{ + MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, + MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, + MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, + MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA +}; + +/* + * Prototypes for local functions + */ +static void MCD_memcpy (int *dest, int *src, u32 size); +static void MCD_resmActions (int channel); + +/* + * Buffer descriptors used for storage of progress info for single Dmas + * Also used as storage for the DMA for CRCs for single DMAs + * Otherwise, the DMA does not parse these buffer descriptors + */ +#ifdef MCD_INCLUDE_EU +extern MCD_bufDesc MCD_singleBufDescs[NCHANNELS]; +#else +MCD_bufDesc MCD_singleBufDescs[NCHANNELS]; +#endif +MCD_bufDesc *MCD_relocBuffDesc; + + +/* + * Defines for the debug control register's functions + */ +#define DBG_CTL_COMP1_TASK (0x00002000) /* have comparator 1 look for a task # */ +#define DBG_CTL_ENABLE (DBG_CTL_AUTO_ARM | \ + DBG_CTL_BREAK | \ + DBG_CTL_INT_BREAK | \ + DBG_CTL_COMP1_TASK) +#define DBG_CTL_DISABLE (DBG_CTL_AUTO_ARM | \ + DBG_CTL_INT_BREAK | \ + DBG_CTL_COMP1_TASK) +#define DBG_KILL_ALL_STAT (0xFFFFFFFF) + +/* + * Offset to context save area where progress info is stored + */ +#define CSAVE_OFFSET 10 + +/* + * Defines for Byte Swapping + */ +#define MCD_BYTE_SWAP_KILLER 0xFFF8888F +#define MCD_NO_BYTE_SWAP_ATALL 0x00040000 + +/* + * Execution Unit Identifiers + */ +#define MAC 0 /* legacy - not used */ +#define LUAC 1 /* legacy - not used */ +#define CRC 2 /* legacy - not used */ +#define LURC 3 /* Logic Unit with CRC */ + +/* + * Task Identifiers + */ +#define TASK_CHAINNOEU 0 +#define TASK_SINGLENOEU 1 +#ifdef MCD_INCLUDE_EU +#define TASK_CHAINEU 2 +#define TASK_SINGLEEU 3 +#define TASK_FECRX 4 +#define TASK_FECTX 5 +#else +#define TASK_CHAINEU 0 +#define TASK_SINGLEEU 1 +#define TASK_FECRX 2 +#define TASK_FECTX 3 +#endif + +/* + * Structure to remember which variant is on which channel + * TBD- need this? + */ +typedef struct MCD_remVariants_struct MCD_remVariant; +struct MCD_remVariants_struct +{ + int remDestRsdIncr[NCHANNELS]; /* -1,0,1 */ + int remSrcRsdIncr[NCHANNELS]; /* -1,0,1 */ + s16 remDestIncr[NCHANNELS]; /* DestIncr */ + s16 remSrcIncr[NCHANNELS]; /* srcIncr */ + u32 remXferSize[NCHANNELS]; /* xferSize */ +}; + +/* + * Structure to remember the startDma parameters for each channel + */ +MCD_remVariant MCD_remVariants; +/********************************************************************/ +/* + * Function: MCD_initDma + * Purpose: Initializes the DMA API by setting up a pointer to the DMA + * registers, relocating and creating the appropriate task + * structures, and setting up some global settings + * Arguments: + * dmaBarAddr - pointer to the multichannel DMA registers + * taskTableDest - location to move DMA task code and structs to + * flags - operational parameters + * Return Value: + * MCD_TABLE_UNALIGNED if taskTableDest is not 512-byte aligned + * MCD_OK otherwise + */ +extern u32 MCD_funcDescTab0[]; + +int MCD_initDma (dmaRegs *dmaBarAddr, void *taskTableDest, u32 flags) +{ + int i; + TaskTableEntry *entryPtr; + + /* setup the local pointer to register set */ + MCD_dmaBar = dmaBarAddr; + + /* do we need to move/create a task table */ + if ((flags & MCD_RELOC_TASKS) != 0) + { + int fixedSize; + u32 *fixedPtr; + /*int *tablePtr = taskTableDest;TBD*/ + int varTabsOffset, funcDescTabsOffset, contextSavesOffset; + int taskDescTabsOffset; + int taskTableSize, varTabsSize, funcDescTabsSize, contextSavesSize; + int taskDescTabSize; + + int i; + + /* check if physical address is aligned on 512 byte boundary */ + if (((u32)taskTableDest & 0x000001ff) != 0) + return(MCD_TABLE_UNALIGNED); + + MCD_taskTable = taskTableDest; /* set up local pointer to task Table */ + + /* + * Create a task table: + * - compute aligned base offsets for variable tables and + * function descriptor tables, then + * - loop through the task table and setup the pointers + * - copy over model task table with the the actual task descriptor + * tables + */ + + taskTableSize = NCHANNELS * sizeof(TaskTableEntry); + /* align variable tables to size */ + varTabsOffset = taskTableSize + (u32)taskTableDest; + if ((varTabsOffset & (VAR_TAB_SIZE - 1)) != 0) + varTabsOffset = (varTabsOffset + VAR_TAB_SIZE) & (~VAR_TAB_SIZE); + /* align function descriptor tables */ + varTabsSize = NCHANNELS * VAR_TAB_SIZE; + funcDescTabsOffset = varTabsOffset + varTabsSize; + + if ((funcDescTabsOffset & (FUNCDESC_TAB_SIZE - 1)) != 0) + funcDescTabsOffset = (funcDescTabsOffset + FUNCDESC_TAB_SIZE) & + (~FUNCDESC_TAB_SIZE); + + funcDescTabsSize = FUNCDESC_TAB_NUM * FUNCDESC_TAB_SIZE; + contextSavesOffset = funcDescTabsOffset + funcDescTabsSize; + contextSavesSize = (NCHANNELS * CONTEXT_SAVE_SIZE); + fixedSize = taskTableSize + varTabsSize + funcDescTabsSize + + contextSavesSize; + + /* zero the thing out */ + fixedPtr = (u32 *)taskTableDest; + for (i = 0;i<(fixedSize/4);i++) + fixedPtr[i] = 0; + + entryPtr = (TaskTableEntry*)MCD_taskTable; + /* set up fixed pointers */ + for (i = 0; i < NCHANNELS; i++) + { + entryPtr[i].varTab = (u32)varTabsOffset; /* update ptr to local value */ + entryPtr[i].FDTandFlags = (u32)funcDescTabsOffset | MCD_TT_FLAGS_DEF; + entryPtr[i].contextSaveSpace = (u32)contextSavesOffset; + varTabsOffset += VAR_TAB_SIZE; +#ifdef MCD_INCLUDE_EU /* if not there is only one, just point to the same one */ + funcDescTabsOffset += FUNCDESC_TAB_SIZE; +#endif + contextSavesOffset += CONTEXT_SAVE_SIZE; + } + /* copy over the function descriptor table */ + for ( i = 0; i < FUNCDESC_TAB_NUM; i++) + { + MCD_memcpy((void*)(entryPtr[i].FDTandFlags & ~MCD_TT_FLAGS_MASK), + (void*)MCD_funcDescTab0, FUNCDESC_TAB_SIZE); + } + + /* copy model task table to where the context saves stuff leaves off*/ + MCD_modelTaskTable = (TaskTableEntry*)contextSavesOffset; + + MCD_memcpy ((void*)MCD_modelTaskTable, (void*)MCD_modelTaskTableSrc, + NUMOFVARIANTS * sizeof(TaskTableEntry)); + + entryPtr = MCD_modelTaskTable; /* point to local version of + model task table */ + taskDescTabsOffset = (u32)MCD_modelTaskTable + + (NUMOFVARIANTS * sizeof(TaskTableEntry)); + + /* copy actual task code and update TDT ptrs in local model task table */ + for (i = 0; i < NUMOFVARIANTS; i++) + { + taskDescTabSize = entryPtr[i].TDTend - entryPtr[i].TDTstart + 4; + MCD_memcpy ((void*)taskDescTabsOffset, (void*)entryPtr[i].TDTstart, taskDescTabSize); + entryPtr[i].TDTstart = (u32)taskDescTabsOffset; + taskDescTabsOffset += taskDescTabSize; + entryPtr[i].TDTend = (u32)taskDescTabsOffset - 4; + } +#ifdef MCD_INCLUDE_EU /* Tack single DMA BDs onto end of code so API controls + where they are since DMA might write to them */ + MCD_relocBuffDesc = (MCD_bufDesc*)(entryPtr[NUMOFVARIANTS - 1].TDTend + 4); +#else /* DMA does not touch them so they can be wherever and we don't need to + waste SRAM on them */ + MCD_relocBuffDesc = MCD_singleBufDescs; +#endif + } + else + { + /* point the would-be relocated task tables and the + buffer descriptors to the ones the linker generated */ + + if (((u32)MCD_realTaskTableSrc & 0x000001ff) != 0) + return(MCD_TABLE_UNALIGNED); + + /* need to add code to make sure that every thing else is aligned properly TBD*/ + /* this is problematic if we init more than once or after running tasks, + need to add variable to see if we have aleady init'd */ + entryPtr = MCD_realTaskTableSrc; + for (i = 0; i < NCHANNELS; i++) + { + if (((entryPtr[i].varTab & (VAR_TAB_SIZE - 1)) != 0) || + ((entryPtr[i].FDTandFlags & (FUNCDESC_TAB_SIZE - 1)) != 0)) + return(MCD_TABLE_UNALIGNED); + } + + MCD_taskTable = MCD_realTaskTableSrc; + MCD_modelTaskTable = MCD_modelTaskTableSrc; + MCD_relocBuffDesc = MCD_singleBufDescs; + } + + + /* Make all channels as totally inactive, and remember them as such: */ + + MCD_dmaBar->taskbar = (u32) MCD_taskTable; + for (i = 0; i < NCHANNELS; i++) + { + MCD_dmaBar->taskControl[i] = 0x0; + MCD_chStatus[i] = MCD_NO_DMA; + } + + /* Set up pausing mechanism to inactive state: */ + MCD_dmaBar->debugComp1 = 0; /* no particular values yet for either comparator registers */ + MCD_dmaBar->debugComp2 = 0; + MCD_dmaBar->debugControl = DBG_CTL_DISABLE; + MCD_dmaBar->debugStatus = DBG_KILL_ALL_STAT; + + /* enable or disable commbus prefetch, really need an ifdef or + something to keep from trying to set this in the 8220 */ + if ((flags & MCD_COMM_PREFETCH_EN) != 0) + MCD_dmaBar->ptdControl &= ~PTD_CTL_COMM_PREFETCH; + else + MCD_dmaBar->ptdControl |= PTD_CTL_COMM_PREFETCH; + + return(MCD_OK); +} +/*********************** End of MCD_initDma() ***********************/ + +/********************************************************************/ +/* Function: MCD_dmaStatus + * Purpose: Returns the status of the DMA on the requested channel + * Arguments: channel - channel number + * Returns: Predefined status indicators + */ +int MCD_dmaStatus (int channel) +{ + u16 tcrValue; + + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + tcrValue = MCD_dmaBar->taskControl[channel]; + if ((tcrValue & TASK_CTL_EN) == 0) + { /* nothing running */ + /* if last reported with task enabled */ + if ( MCD_chStatus[channel] == MCD_RUNNING + || MCD_chStatus[channel] == MCD_IDLE) + MCD_chStatus[channel] = MCD_DONE; + } + else /* something is running */ + { + /* There are three possibilities: paused, running or idle. */ + if ( MCD_chStatus[channel] == MCD_RUNNING + || MCD_chStatus[channel] == MCD_IDLE) + { + MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT; + /* This register is selected to know which initiator is + actually asserted. */ + if ((MCD_dmaBar->ptdDebug >> channel ) & 0x1 ) + MCD_chStatus[channel] = MCD_RUNNING; + else + MCD_chStatus[channel] = MCD_IDLE; + /* do not change the status if it is already paused. */ + } + } + return MCD_chStatus[channel]; +} +/******************** End of MCD_dmaStatus() ************************/ + +/********************************************************************/ +/* Function: MCD_startDma + * Ppurpose: Starts a particular kind of DMA + * Arguments: see below + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + */ + +int MCD_startDma ( + int channel, /* the channel on which to run the DMA */ + s8 *srcAddr, /* the address to move data from, or physical buffer-descriptor address */ + s16 srcIncr, /* the amount to increment the source address per transfer */ + s8 *destAddr, /* the address to move data to */ + s16 destIncr, /* the amount to increment the destination address per transfer */ + u32 dmaSize, /* the number of bytes to transfer independent of the transfer size */ + u32 xferSize, /* the number bytes in of each data movement (1, 2, or 4) */ + u32 initiator, /* what device initiates the DMA */ + int priority, /* priority of the DMA */ + u32 flags, /* flags describing the DMA */ + u32 funcDesc /* a description of byte swapping, bit swapping, and CRC actions */ +#ifdef MCD_NEED_ADDR_TRANS + s8 *srcAddrVirt /* virtual buffer descriptor address TBD*/ +#endif +) +{ + int srcRsdIncr, destRsdIncr; + int *cSave; + short xferSizeIncr; + int tcrCount = 0; +#ifdef MCD_INCLUDE_EU + u32 *realFuncArray; +#endif + + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + /* tbd - need to determine the proper response to a bad funcDesc when not + including EU functions, for now, assign a benign funcDesc, but maybe + should return an error */ +#ifndef MCD_INCLUDE_EU + funcDesc = MCD_FUNC_NOEU1; +#endif + +#ifdef MCD_DEBUG +printf("startDma:Setting up params\n"); +#endif + /* Set us up for task-wise priority. We don't technically need to do this on every start, but + since the register involved is in the same longword as other registers that users are in control + of, setting it more than once is probably preferable. That since the documentation doesn't seem + to be completely consistent about the nature of the PTD control register. */ + MCD_dmaBar->ptdControl |= (u16) 0x8000; +#if 1 /* Not sure what we need to keep here rtm TBD */ + /* Calculate additional parameters to the regular DMA calls. */ + srcRsdIncr = srcIncr < 0 ? -1 : (srcIncr > 0 ? 1 : 0); + destRsdIncr = destIncr < 0 ? -1 : (destIncr > 0 ? 1 : 0); + + xferSizeIncr = (xferSize & 0xffff) | 0x20000000; + + /* Remember for each channel which variant is running. */ + MCD_remVariants.remSrcRsdIncr[channel] = srcRsdIncr; + MCD_remVariants.remDestRsdIncr[channel] = destRsdIncr; + MCD_remVariants.remDestIncr[channel] = destIncr; + MCD_remVariants.remSrcIncr[channel] = srcIncr; + MCD_remVariants.remXferSize[channel] = xferSize; +#endif + + cSave = (int*)(MCD_taskTable[channel].contextSaveSpace) + CSAVE_OFFSET + CURRBD; + +#ifdef MCD_INCLUDE_EU /* may move this to EU specific calls */ + realFuncArray = (u32 *) (MCD_taskTable[channel].FDTandFlags & 0xffffff00); + /* Modify the LURC's normal and byte-residue-loop functions according to parameter. */ + realFuncArray[(LURC*16)] = xferSize == 4 ? + funcDesc : xferSize == 2 ? + funcDesc & 0xfffff00f : funcDesc & 0xffff000f; + realFuncArray[(LURC*16+1)] = (funcDesc & MCD_BYTE_SWAP_KILLER) | MCD_NO_BYTE_SWAP_ATALL; +#endif + /* Write the initiator field in the TCR, and also set the initiator-hold + bit. Note that,due to a hardware quirk, this could collide with an + MDE access to the initiator-register file, so we have to verify that the write + reads back correctly. */ + + MCD_dmaBar->taskControl[channel] = + (initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM; + + while(((MCD_dmaBar->taskControl[channel] & 0x1fff) != + ((initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM)) && + (tcrCount < 1000)) + { + tcrCount++; + /*MCD_dmaBar->ptd_tcr[channel] = (initiator << 8) | 0x0020;*/ + MCD_dmaBar->taskControl[channel] = + (initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM; + } + + MCD_dmaBar->priority[channel] = (u8)priority & PRIORITY_PRI_MASK; + /* should be albe to handle this stuff with only one write to ts reg - tbd */ + if (channel < 8 && channel >= 0) + { + MCD_dmaBar->taskSize0 &= ~(0xf << (7-channel)*4); + MCD_dmaBar->taskSize0 |= (xferSize & 3) << (((7 - channel)*4) + 2); + MCD_dmaBar->taskSize0 |= (xferSize & 3) << ((7 - channel)*4); + } + else + { + MCD_dmaBar->taskSize1 &= ~(0xf << (15-channel)*4); + MCD_dmaBar->taskSize1 |= (xferSize & 3) << (((15 - channel)*4) + 2); + MCD_dmaBar->taskSize1 |= (xferSize & 3) << ((15 - channel)*4); + } + + /* setup task table flags/options which mostly control the line buffers */ + MCD_taskTable[channel].FDTandFlags &= ~MCD_TT_FLAGS_MASK; + MCD_taskTable[channel].FDTandFlags |= (MCD_TT_FLAGS_MASK & flags); + + if (flags & MCD_FECTX_DMA) + { + /* TDTStart and TDTEnd */ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_FECTX].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_FECTX].TDTend; + MCD_startDmaENetXmit(srcAddr, srcAddr, destAddr, MCD_taskTable, channel); + } + else if (flags & MCD_FECRX_DMA) + { + /* TDTStart and TDTEnd */ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_FECRX].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_FECRX].TDTend; + MCD_startDmaENetRcv(srcAddr, srcAddr, destAddr, MCD_taskTable, channel); + } + else if(flags & MCD_SINGLE_DMA) + { + /* this buffer descriptor is used for storing off initial parameters for later + progress query calculation and for the DMA to write the resulting checksum + The DMA does not use this to determine how to operate, that info is passed + with the init routine*/ + MCD_relocBuffDesc[channel].srcAddr = srcAddr; + MCD_relocBuffDesc[channel].destAddr = destAddr; + MCD_relocBuffDesc[channel].lastDestAddr = destAddr; /* definitely not its final value */ + MCD_relocBuffDesc[channel].dmaSize = dmaSize; + MCD_relocBuffDesc[channel].flags = 0; /* not used */ + MCD_relocBuffDesc[channel].csumResult = 0; /* not used */ + MCD_relocBuffDesc[channel].next = 0; /* not used */ + + /* Initialize the progress-querying stuff to show no progress:*/ + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET] = (int)srcAddr; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET] = (int)destAddr; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET] = 0; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET] = + (u32) &(MCD_relocBuffDesc[channel]); + /* tbd - need to keep the user from trying to call the EU routine + when MCD_INCLUDE_EU is not defined */ + if( funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2) + { + /* TDTStart and TDTEnd */ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_SINGLENOEU].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_SINGLENOEU].TDTend; + MCD_startDmaSingleNoEu(srcAddr, srcIncr, destAddr, destIncr, dmaSize, + xferSizeIncr, flags, (int *)&(MCD_relocBuffDesc[channel]), cSave, + MCD_taskTable, channel); + } + else + { + /* TDTStart and TDTEnd */ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_SINGLEEU].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_SINGLEEU].TDTend; + MCD_startDmaSingleEu(srcAddr, srcIncr, destAddr, destIncr, dmaSize, + xferSizeIncr, flags, (int *)&(MCD_relocBuffDesc[channel]), cSave, + MCD_taskTable, channel); + } + } + else + { /* chained DMAS */ + /* Initialize the progress-querying stuff to show no progress:*/ +#if 1 /* (!defined(MCD_NEED_ADDR_TRANS)) */ + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET] + = (int)((MCD_bufDesc*) srcAddr)->srcAddr; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET] + = (int)((MCD_bufDesc*) srcAddr)->destAddr; +#else /* if using address translation, need the virtual addr of the first buffdesc */ + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET] + = (int)((MCD_bufDesc*) srcAddrVirt)->srcAddr; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET] + = (int)((MCD_bufDesc*) srcAddrVirt)->destAddr; +#endif + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET] = 0; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET] = (u32) srcAddr; + + if( funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2) + { + /*TDTStart and TDTEnd*/ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_CHAINNOEU].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_CHAINNOEU].TDTend; + MCD_startDmaChainNoEu((int *)srcAddr, srcIncr, destIncr, xferSize, + xferSizeIncr, cSave, MCD_taskTable, channel); + } + else + { + /*TDTStart and TDTEnd*/ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_CHAINEU].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_CHAINEU].TDTend; + MCD_startDmaChainEu((int *)srcAddr, srcIncr, destIncr, xferSize, + xferSizeIncr, cSave, MCD_taskTable, channel); + } + } + MCD_chStatus[channel] = MCD_IDLE; + return(MCD_OK); +} + +/************************ End of MCD_startDma() *********************/ + +/********************************************************************/ +/* Function: MCD_XferProgrQuery + * Purpose: Returns progress of DMA on requested channel + * Arguments: channel - channel to retrieve progress for + * progRep - pointer to user supplied MCD_XferProg struct + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + * + * Notes: + * MCD_XferProgrQuery() upon completing or after aborting a DMA, or + * while the DMA is in progress, this function returns the first + * DMA-destination address not (or not yet) used in the DMA. When + * encountering a non-ready buffer descriptor, the information for + * the last completed descriptor is returned. + * + * MCD_XferProgQuery() has to avoid the possibility of getting + * partially-updated information in the event that we should happen + * to query DMA progress just as the DMA is updating it. It does that + * by taking advantage of the fact context is not saved frequently for + * the most part. We therefore read it at least twice until we get the + * same information twice in a row. + * + * Because a small, but not insignificant, amount of time is required + * to write out the progress-query information, especially upon + * completion of the DMA, it would be wise to guarantee some time lag + * between successive readings of the progress-query information. + */ + +/* + * How many iterations of the loop below to execute to stabilize values + */ +#define STABTIME 0 + +int MCD_XferProgrQuery (int channel, MCD_XferProg *progRep) +{ + MCD_XferProg prevRep; + int again; /* true if we are to try again to get consistent results */ + int i; /* used as a time-waste counter */ + int destDiffBytes; /* Total number of bytes that we think actually got xfered. */ + int numIterations; /* number of iterations */ + int bytesNotXfered; /* bytes that did not get xfered. */ + s8 *LWAlignedInitDestAddr, *LWAlignedCurrDestAddr; + int subModVal, addModVal; /* Mode values to added and subtracted from the + final destAddr */ + + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + /* Read a trial value for the progress-reporting values*/ + prevRep.lastSrcAddr = + (s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET]; + prevRep.lastDestAddr = + (s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET]; + prevRep.dmaSize = ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET]; + prevRep.currBufDesc = + (MCD_bufDesc*) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET]; + /* Repeatedly reread those values until they match previous values: */ + do { + /* Waste a little bit of time to ensure stability: */ + for (i = 0; i < STABTIME; i++) + i += i >> 2; /* make sure this loop does something so that it doesn't get optimized out */ + /* Check them again: */ + progRep->lastSrcAddr = + (s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET]; + progRep->lastDestAddr = + (s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET]; + progRep->dmaSize = ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET]; + progRep->currBufDesc = + (MCD_bufDesc*) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET]; + /* See if they match: */ + if ( prevRep.lastSrcAddr != progRep->lastSrcAddr + || prevRep.lastDestAddr != progRep->lastDestAddr + || prevRep.dmaSize != progRep->dmaSize + || prevRep.currBufDesc != progRep->currBufDesc) + { + /* If they don't match, remember previous values and try again:*/ + prevRep.lastSrcAddr = progRep->lastSrcAddr; + prevRep.lastDestAddr = progRep->lastDestAddr; + prevRep.dmaSize = progRep->dmaSize; + prevRep.currBufDesc = progRep->currBufDesc; + again = MCD_TRUE; + } + else + again = MCD_FALSE; + } while (again == MCD_TRUE); + + + /* Update the dCount, srcAddr and destAddr */ + /* To calculate dmaCount, we consider destination address. C + overs M1,P1,Z for destination */ + switch(MCD_remVariants.remDestRsdIncr[channel]) { + case MINUS1: + subModVal = ((int)progRep->lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) - 1); + addModVal = ((int)progRep->currBufDesc->destAddr) & ((MCD_remVariants.remXferSize[channel]) - 1); + LWAlignedInitDestAddr = (progRep->currBufDesc->destAddr) - addModVal; + LWAlignedCurrDestAddr = (progRep->lastDestAddr) - subModVal; + destDiffBytes = LWAlignedInitDestAddr - LWAlignedCurrDestAddr; + bytesNotXfered = (destDiffBytes/MCD_remVariants.remDestIncr[channel]) * + ( MCD_remVariants.remDestIncr[channel] + + MCD_remVariants.remXferSize[channel]); + progRep->dmaSize = destDiffBytes - bytesNotXfered + addModVal - subModVal; + break; + case ZERO: + progRep->lastDestAddr = progRep->currBufDesc->destAddr; + break; + case PLUS1: + /* This value has to be subtracted from the final calculated dCount. */ + subModVal = ((int)progRep->currBufDesc->destAddr) & ((MCD_remVariants.remXferSize[channel]) - 1); + /* These bytes are already in lastDestAddr. */ + addModVal = ((int)progRep->lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) - 1); + LWAlignedInitDestAddr = (progRep->currBufDesc->destAddr) - subModVal; + LWAlignedCurrDestAddr = (progRep->lastDestAddr) - addModVal; + destDiffBytes = (progRep->lastDestAddr - LWAlignedInitDestAddr); + numIterations = ( LWAlignedCurrDestAddr - LWAlignedInitDestAddr)/MCD_remVariants.remDestIncr[channel]; + bytesNotXfered = numIterations * + ( MCD_remVariants.remDestIncr[channel] + - MCD_remVariants.remXferSize[channel]); + progRep->dmaSize = destDiffBytes - bytesNotXfered - subModVal; + break; + default: + break; + } + + /* This covers M1,P1,Z for source */ + switch(MCD_remVariants.remSrcRsdIncr[channel]) { + case MINUS1: + progRep->lastSrcAddr = + progRep->currBufDesc->srcAddr + + ( MCD_remVariants.remSrcIncr[channel] * + (progRep->dmaSize/MCD_remVariants.remXferSize[channel])); + break; + case ZERO: + progRep->lastSrcAddr = progRep->currBufDesc->srcAddr; + break; + case PLUS1: + progRep->lastSrcAddr = + progRep->currBufDesc->srcAddr + + ( MCD_remVariants.remSrcIncr[channel] * + (progRep->dmaSize/MCD_remVariants.remXferSize[channel])); + break; + default: break; + } + + return(MCD_OK); +} +/******************* End of MCD_XferProgrQuery() ********************/ + +/********************************************************************/ +/* MCD_resmActions() does the majority of the actions of a DMA resume. + * It is called from MCD_killDma() and MCD_resumeDma(). It has to be + * a separate function because the kill function has to negate the task + * enable before resuming it, but the resume function has to do nothing + * if there is no DMA on that channel (i.e., if the enable bit is 0). + */ +static void MCD_resmActions (int channel) +{ + MCD_dmaBar->debugControl = DBG_CTL_DISABLE; + MCD_dmaBar->debugStatus = MCD_dmaBar->debugStatus; + MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT; /* This register is selected to know + which initiator is actually asserted. */ + if((MCD_dmaBar->ptdDebug >> channel ) & 0x1) + MCD_chStatus[channel] = MCD_RUNNING; + else + MCD_chStatus[channel] = MCD_IDLE; +} +/********************* End of MCD_resmActions() *********************/ + +/********************************************************************/ +/* Function: MCD_killDma + * Purpose: Halt the DMA on the requested channel, without any + * intention of resuming the DMA. + * Arguments: channel - requested channel + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + * + * Notes: + * A DMA may be killed from any state, including paused state, and it + * always goes to the MCD_HALTED state even if it is killed while in + * the MCD_NO_DMA or MCD_IDLE states. + */ +int MCD_killDma (int channel) +{ + /* MCD_XferProg progRep; */ + + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + MCD_dmaBar->taskControl[channel] = 0x0; + MCD_resumeDma (channel); + /* + * This must be after the write to the TCR so that the task doesn't + * start up again momentarily, and before the status assignment so + * as to override whatever MCD_resumeDma() may do to the channel + * status. + */ + MCD_chStatus[channel] = MCD_HALTED; + + /* + * Update the current buffer descriptor's lastDestAddr field + * + * MCD_XferProgrQuery (channel, &progRep); + * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr; + */ + return(MCD_OK); +} +/************************ End of MCD_killDma() **********************/ + +/********************************************************************/ +/* Function: MCD_continDma + * Purpose: Continue a DMA which as stopped due to encountering an + * unready buffer descriptor. + * Arguments: channel - channel to continue the DMA on + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + * + * Notes: + * This routine does not check to see if there is a task which can + * be continued. Also this routine should not be used with single DMAs. + */ +int MCD_continDma (int channel) +{ + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + MCD_dmaBar->taskControl[channel] |= TASK_CTL_EN; + MCD_chStatus[channel] = MCD_RUNNING; + + return(MCD_OK); +} +/********************** End of MCD_continDma() **********************/ + +/********************************************************************* + * MCD_pauseDma() and MCD_resumeDma() below use the DMA's debug unit + * to freeze a task and resume it. We freeze a task by breakpointing + * on the stated task. That is, not any specific place in the task, + * but any time that task executes. In particular, when that task + * executes, we want to freeze that task and only that task. + * + * The bits of the debug control register influence interrupts vs. + * breakpoints as follows: + * - Bits 14 and 0 enable or disable debug functions. If enabled, you + * will get the interrupt but you may or may not get a breakpoint. + * - Bits 2 and 1 decide whether you also get a breakpoint in addition + * to an interrupt. + * + * The debug unit can do these actions in response to either internally + * detected breakpoint conditions from the comparators, or in response + * to the external breakpoint pin, or both. + * - Bits 14 and 1 perform the above-described functions for + * internally-generated conditions, i.e., the debug comparators. + * - Bits 0 and 2 perform the above-described functions for external + * conditions, i.e., the breakpoint external pin. + * + * Note that, although you "always" get the interrupt when you turn + * the debug functions, the interrupt can nevertheless, if desired, be + * masked by the corresponding bit in the PTD's IMR. Note also that + * this means that bits 14 and 0 must enable debug functions before + * bits 1 and 2, respectively, have any effect. + * + * NOTE: It's extremely important to not pause more than one DMA channel + * at a time. + ********************************************************************/ + +/********************************************************************/ +/* Function: MCD_pauseDma + * Purpose: Pauses the DMA on a given channel (if any DMA is running + * on that channel). + * Arguments: channel + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + */ +int MCD_pauseDma (int channel) +{ + /* MCD_XferProg progRep; */ + + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + if (MCD_dmaBar->taskControl[channel] & TASK_CTL_EN) + { + MCD_dmaBar->debugComp1 = channel; + MCD_dmaBar->debugControl = DBG_CTL_ENABLE | (1 << (channel + 16)); + MCD_chStatus[channel] = MCD_PAUSED; + + /* + * Update the current buffer descriptor's lastDestAddr field + * + * MCD_XferProgrQuery (channel, &progRep); + * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr; + */ + } + return(MCD_OK); +} +/************************* End of MCD_pauseDma() ********************/ + +/********************************************************************/ +/* Function: MCD_resumeDma + * Purpose: Resumes the DMA on a given channel (if any DMA is + * running on that channel). + * Arguments: channel - channel on which to resume DMA + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + */ +int MCD_resumeDma (int channel) +{ + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + if (MCD_dmaBar->taskControl[channel] & TASK_CTL_EN) + MCD_resmActions (channel); + + return(MCD_OK); +} +/************************ End of MCD_resumeDma() ********************/ + +/********************************************************************/ +/* Function: MCD_csumQuery + * Purpose: Provide the checksum after performing a non-chained DMA + * Arguments: channel - channel to report on + * csum - pointer to where to write the checksum/CRC + * Returns: MCD_ERROR if the channel is invalid, else MCD_OK + * + * Notes: + * + */ +int MCD_csumQuery (int channel, u32 *csum) +{ +#ifdef MCD_INCLUDE_EU + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + *csum = MCD_relocBuffDesc[channel].csumResult; + return(MCD_OK); +#else + return(MCD_ERROR); +#endif +} +/*********************** End of MCD_resumeDma() *********************/ + +/********************************************************************/ +/* Function: MCD_getCodeSize + * Purpose: Provide the size requirements of the microcoded tasks + * Returns: Size in bytes + */ +int MCD_getCodeSize(void) +{ +#ifdef MCD_INCLUDE_EU + return(0x2b5c); +#else + return(0x173c); +#endif +} +/********************** End of MCD_getCodeSize() ********************/ + +/********************************************************************/ +/* Function: MCD_getVersion + * Purpose: Provide the version string and number + * Arguments: longVersion - user supplied pointer to a pointer to a char + * which points to the version string + * Returns: Version number and version string (by reference) + */ +char MCD_versionString[] = "Multi-channel DMA API Alpha v0.3 (2004-04-26)"; +#define MCD_REV_MAJOR 0x00 +#define MCD_REV_MINOR 0x03 + +int MCD_getVersion(char **longVersion) +{ + *longVersion = MCD_versionString; + return((MCD_REV_MAJOR << 8) | MCD_REV_MINOR); +} +/********************** End of MCD_getVersion() *********************/ + +/********************************************************************/ +/* Private version of memcpy() + * Note that everything this is used for is longword-aligned. + */ +static void MCD_memcpy (int *dest, int *src, u32 size) +{ + u32 i; + + for (i = 0; i < size; i += sizeof(int), dest++, src++) + *dest = *src; +} +/********************************************************************/ diff --git a/mcdapirev0p3/MCD_tasks.c b/mcdapirev0p3/MCD_tasks.c new file mode 100644 index 0000000..76e8e37 --- /dev/null +++ b/mcdapirev0p3/MCD_tasks.c @@ -0,0 +1,2449 @@ +/* + * File: MCD_tasks.c + * Purpose: Contains task code and structures for Multi-channel DMA + * + * Notes: + */ + +#include "MCD_dma.h" + +u32 MCD_varTab0[]; +u32 MCD_varTab1[]; +u32 MCD_varTab2[]; +u32 MCD_varTab3[]; +u32 MCD_varTab4[]; +u32 MCD_varTab5[]; +u32 MCD_varTab6[]; +u32 MCD_varTab7[]; +u32 MCD_varTab8[]; +u32 MCD_varTab9[]; +u32 MCD_varTab10[]; +u32 MCD_varTab11[]; +u32 MCD_varTab12[]; +u32 MCD_varTab13[]; +u32 MCD_varTab14[]; +u32 MCD_varTab15[]; + +u32 MCD_funcDescTab0[]; +#ifdef MCD_INCLUDE_EU +u32 MCD_funcDescTab1[]; +u32 MCD_funcDescTab2[]; +u32 MCD_funcDescTab3[]; +u32 MCD_funcDescTab4[]; +u32 MCD_funcDescTab5[]; +u32 MCD_funcDescTab6[]; +u32 MCD_funcDescTab7[]; +u32 MCD_funcDescTab8[]; +u32 MCD_funcDescTab9[]; +u32 MCD_funcDescTab10[]; +u32 MCD_funcDescTab11[]; +u32 MCD_funcDescTab12[]; +u32 MCD_funcDescTab13[]; +u32 MCD_funcDescTab14[]; +u32 MCD_funcDescTab15[]; +#endif + +u32 MCD_contextSave0[]; +u32 MCD_contextSave1[]; +u32 MCD_contextSave2[]; +u32 MCD_contextSave3[]; +u32 MCD_contextSave4[]; +u32 MCD_contextSave5[]; +u32 MCD_contextSave6[]; +u32 MCD_contextSave7[]; +u32 MCD_contextSave8[]; +u32 MCD_contextSave9[]; +u32 MCD_contextSave10[]; +u32 MCD_contextSave11[]; +u32 MCD_contextSave12[]; +u32 MCD_contextSave13[]; +u32 MCD_contextSave14[]; +u32 MCD_contextSave15[]; + +u32 MCD_realTaskTableSrc[] = +{ + 0x00000000, + 0x00000000, + (u32)MCD_varTab0, /* Task 0 Variable Table */ + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ + 0x00000000, + 0x00000000, + (u32)MCD_contextSave0, /* Task 0 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab1, /* Task 1 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab1, /* Task 1 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave1, /* Task 1 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab2, /* Task 2 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab2, /* Task 2 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave2, /* Task 2 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab3, /* Task 3 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab3, /* Task 3 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave3, /* Task 3 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab4, /* Task 4 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab4, /* Task 4 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave4, /* Task 4 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab5, /* Task 5 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab5, /* Task 5 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave5, /* Task 5 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab6, /* Task 6 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab6, /* Task 6 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave6, /* Task 6 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab7, /* Task 7 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab7, /* Task 7 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave7, /* Task 7 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab8, /* Task 8 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab8, /* Task 8 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave8, /* Task 8 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab9, /* Task 9 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab9, /* Task 9 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave9, /* Task 9 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab10, /* Task 10 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab10, /* Task 10 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave10, /* Task 10 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab11, /* Task 11 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab11, /* Task 11 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave11, /* Task 11 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab12, /* Task 12 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab12, /* Task 12 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave12, /* Task 12 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab13, /* Task 13 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab13, /* Task 13 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave13, /* Task 13 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab14, /* Task 14 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab14, /* Task 14 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave14, /* Task 14 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab15, /* Task 15 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab15, /* Task 15 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave15, /* Task 15 context save space */ + 0x00000000, +}; + + +u32 MCD_varTab0[] = +{ /* Task 0 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + + +u32 MCD_varTab1[] = +{ /* Task 1 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab2[]= +{ /* Task 2 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab3[]= +{ /* Task 3 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab4[]= +{ /* Task 4 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab5[]= +{ /* Task 5 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab6[]= +{ /* Task 6 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab7[]= +{ /* Task 7 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab8[]= +{ /* Task 8 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab9[]= +{ /* Task 9 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab10[]= +{ /* Task 10 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab11[]= +{ /* Task 11 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab12[]= +{ /* Task 12 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab13[]= +{ /* Task 13 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab14[]= +{ /* Task 14 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab15[]= +{ /* Task 15 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_funcDescTab0[]= +{ /* Task 0 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +#ifdef MCD_INCLUDE_EU +u32 MCD_funcDescTab1[]= +{ /* Task 1 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab2[]= +{ /* Task 2 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab3[]= +{ /* Task 3 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab4[]= +{ /* Task 4 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab5[]= +{ /* Task 5 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab6[]= +{ /* Task 6 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab7[]= +{ /* Task 7 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab8[]= +{ /* Task 8 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab9[]= +{ /* Task 9 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab10[]= +{ /* Task 10 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab11[]= +{ /* Task 11 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab12[]= +{ /* Task 12 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab13[]= +{ /* Task 13 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab14[]= +{ /* Task 14 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab15[]= +{ /* Task 15 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; +#endif /*MCD_INCLUDE_EU*/ + +u32 MCD_contextSave0[128]; /* Task 0 context save space */ +u32 MCD_contextSave1[128]; /* Task 1 context save space */ +u32 MCD_contextSave2[128]; /* Task 2 context save space */ +u32 MCD_contextSave3[128]; /* Task 3 context save space */ +u32 MCD_contextSave4[128]; /* Task 4 context save space */ +u32 MCD_contextSave5[128]; /* Task 5 context save space */ +u32 MCD_contextSave6[128]; /* Task 6 context save space */ +u32 MCD_contextSave7[128]; /* Task 7 context save space */ +u32 MCD_contextSave8[128]; /* Task 8 context save space */ +u32 MCD_contextSave9[128]; /* Task 9 context save space */ +u32 MCD_contextSave10[128]; /* Task 10 context save space */ +u32 MCD_contextSave11[128]; /* Task 11 context save space */ +u32 MCD_contextSave12[128]; /* Task 12 context save space */ +u32 MCD_contextSave13[128]; /* Task 13 context save space */ +u32 MCD_contextSave14[128]; /* Task 14 context save space */ +u32 MCD_contextSave15[128]; /* Task 15 context save space */ + + +u32 MCD_ChainNoEu_TDT[]; +u32 MCD_SingleNoEu_TDT[]; +#ifdef MCD_INCLUDE_EU +u32 MCD_ChainEu_TDT[]; +u32 MCD_SingleEu_TDT[]; +#endif +u32 MCD_ENetRcv_TDT[]; +u32 MCD_ENetXmit_TDT[]; + +u32 MCD_modelTaskTableSrc[]= +{ + (u32)MCD_ChainNoEu_TDT, + (u32)&((u8*)MCD_ChainNoEu_TDT)[0x0000016c], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_SingleNoEu_TDT, + (u32)&((u8*)MCD_SingleNoEu_TDT)[0x000000d4], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, +#ifdef MCD_INCLUDE_EU + (u32)MCD_ChainEu_TDT, + (u32)&((u8*)MCD_ChainEu_TDT)[0x000001b4], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_SingleEu_TDT, + (u32)&((u8*)MCD_SingleEu_TDT)[0x00000124], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, +#endif + (u32)MCD_ENetRcv_TDT, + (u32)&((u8*)MCD_ENetRcv_TDT)[0x0000009c], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_ENetXmit_TDT, + (u32)&((u8*)MCD_ENetXmit_TDT)[0x000000d0], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, +}; +u32 MCD_ChainNoEu_TDT[]= +{ + 0x80004000, /* 0000(:370): LCDEXT: idx0 = 0x00000000; ; */ + 0x8118801b, /* 0004(:370): LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */ + 0xb8c60018, /* 0008(:371): LCD: idx2 = *(idx1 + var12); idx2 once var0; idx2 += inc3 */ + 0x10002b10, /* 000C(:372): DRD1A: var10 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x7000000d, /* 0010(:373): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x018cf89f, /* 0014(:373): DRD2B1: var6 = EU3(); EU3(idx2) */ + 0x6000000a, /* 0018(:374): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf89f, /* 001C(:374): DRD2B1: idx0 = EU3(); EU3(idx2) */ + 0x000001f8, /* 0020(:0): NOP */ + 0x98180364, /* 0024(:378): LCD: idx0 = idx0; idx0 == var13; idx0 += inc4 */ + 0x8118801b, /* 0028(:380): LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */ + 0xf8c6001a, /* 002C(:381): LCDEXT: idx2 = *(idx1 + var12 + 8); idx2 once var0; idx2 += inc3 */ + 0xb8c6601b, /* 0030(:382): LCD: idx3 = *(idx1 + var12 + 12); ; idx3 += inc3 */ + 0x10002710, /* 0034(:384): DRD1A: var9 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x00000f18, /* 0038(:385): DRD1A: var3 = idx3; FN=0 init=0 WS=0 RS=0 */ + 0xb8c6001d, /* 003C(:387): LCD: idx2 = *(idx1 + var12 + 20); idx2 once var0; idx2 += inc3 */ + 0x10001310, /* 0040(:388): DRD1A: var4 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x60000007, /* 0044(:389): DRD2A: EU0=0 EU1=0 EU2=0 EU3=7 EXT init=0 WS=0 RS=0 */ + 0x014cf88b, /* 0048(:389): DRD2B1: var5 = EU3(); EU3(idx2,var11) */ + 0x98c6001c, /* 004C(:391): LCD: idx2 = idx1 + var12 + 4; idx2 once var0; idx2 += inc3 */ + 0x00000710, /* 0050(:392): DRD1A: var1 = idx2; FN=0 init=0 WS=0 RS=0 */ + 0x98c70018, /* 0054(:393): LCD: idx2 = idx1 + var14; idx2 once var0; idx2 += inc3 */ + 0x10001f10, /* 0058(:394): DRD1A: var7 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c818, /* 005C(:395): DRD1A: *idx2 = var3; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 0060(:0): NOP */ + 0xc1476018, /* 0064(:399): LCDEXT: idx1 = var2 + var14; ; idx1 += inc3 */ + 0xc003231d, /* 0068(:399): LCDEXT: idx2 = var0, idx3 = var6; idx3 == var12; idx2 += inc3, idx3 += inc5 */ + 0x811a601b, /* 006C(:400): LCD: idx4 = var2; ; idx4 += inc3 */ + 0xc1862102, /* 0070(:403): LCDEXT: idx5 = var3, idx6 = var12; idx6 < var4; idx5 += inc0, idx6 += inc2 */ + 0x849be009, /* 0074(:403): LCD: idx7 = var9; ; idx7 += inc1 */ + 0x03fed7b8, /* 0078(:406): DRD1A: *idx7; FN=0 init=31 WS=3 RS=3 */ + 0xda9b001b, /* 007C(:408): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 0080(:408): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x1000cb20, /* 0084(:409): DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0088(:410): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 008C(:410): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb28, /* 0090(:411): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0094(:412): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 0098(:412): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb30, /* 009C(:413): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00A0(:414): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 00A4(:414): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb38, /* 00A8(:415): DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c728, /* 00AC(:416): DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 00B0(:0): NOP */ + 0xc1476018, /* 00B4(:420): LCDEXT: idx1 = var2 + var14; ; idx1 += inc3 */ + 0xc003241d, /* 00B8(:420): LCDEXT: idx2 = var0, idx3 = var6; idx3 == var16; idx2 += inc3, idx3 += inc5 */ + 0x811a601b, /* 00BC(:421): LCD: idx4 = var2; ; idx4 += inc3 */ + 0xda9b001b, /* 00C0(:424): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00C4(:424): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x0000d3a0, /* 00C8(:425): DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */ + 0xc1862102, /* 00CC(:427): LCDEXT: idx5 = var3, idx6 = var12; idx6 < var4; idx5 += inc0, idx6 += inc2 */ + 0x849be009, /* 00D0(:427): LCD: idx7 = var9; ; idx7 += inc1 */ + 0x0bfed7b8, /* 00D4(:430): DRD1A: *idx7; FN=0 TFD init=31 WS=3 RS=3 */ + 0xda9b001b, /* 00D8(:432): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00DC(:432): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x1000cb20, /* 00E0(:433): DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00E4(:434): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 00E8(:434): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb28, /* 00EC(:435): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00F0(:436): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 00F4(:436): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb30, /* 00F8(:437): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00FC(:438): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 0100(:438): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb38, /* 0104(:439): DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c728, /* 0108(:440): DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 010C(:0): NOP */ + 0x8118801b, /* 0110(:444): LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */ + 0xd8c60018, /* 0114(:446): LCDEXT: idx2 = idx1 + var12; idx2 once var0; idx2 += inc3 */ + 0x98c6601c, /* 0118(:446): LCD: idx3 = idx1 + var12 + 4; ; idx3 += inc3 */ + 0x6000000b, /* 011C(:447): DRD2A: EU0=0 EU1=0 EU2=0 EU3=11 EXT init=0 WS=0 RS=0 */ + 0x0c8cfc9f, /* 0120(:447): DRD2B1: *idx2 = EU3(); EU3(*idx2) */ + 0x000001f8, /* 0124(:0): NOP */ + 0xa146001e, /* 0128(:450): LCD: idx1 = *(var2 + var12 + 24); idx1 once var0; idx1 += inc3 */ + 0x10000b08, /* 012C(:451): DRD1A: var2 = idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x10002050, /* 0130(:452): DRD1A: var8 = var10; FN=0 MORE init=0 WS=0 RS=0 */ + 0xb8c60018, /* 0134(:453): LCD: idx2 = *(idx1 + var12); idx2 once var0; idx2 += inc3 */ + 0x10002b10, /* 0138(:454): DRD1A: var10 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x7000000a, /* 013C(:455): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT MORE init=0 WS=0 RS=0 */ + 0x080cf89f, /* 0140(:455): DRD2B1: idx0 = EU3(); EU3(idx2) */ + 0x6000000d, /* 0144(:456): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT init=0 WS=0 RS=0 */ + 0x018cf89f, /* 0148(:456): DRD2B1: var6 = EU3(); EU3(idx2) */ + 0x000001f8, /* 014C(:0): NOP */ + 0x8618801b, /* 0150(:462): LCD: idx1 = var12; idx1 once var0; idx1 += inc3 */ + 0x7000000e, /* 0154(:463): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */ + 0x084cf21f, /* 0158(:463): DRD2B1: idx1 = EU3(); EU3(var8) */ + 0xd8990336, /* 015C(:464): LCDEXT: idx2 = idx1; idx2 > var12; idx2 += inc6 */ + 0x8019801b, /* 0160(:464): LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */ + 0x040001f8, /* 0164(:465): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ + 0x000001f8, /* 0168(:0): NOP */ + 0x000001f8, /* 016C(:0): NOP */ +}; +u32 MCD_SingleNoEu_TDT[]= +{ + 0x8198001b, /* 0000(:657): LCD: idx0 = var3; idx0 once var0; idx0 += inc3 */ + 0x7000000d, /* 0004(:658): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x080cf81f, /* 0008(:658): DRD2B1: idx0 = EU3(); EU3(idx0) */ + 0x8198801b, /* 000C(:659): LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */ + 0x6000000e, /* 0010(:660): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */ + 0x084cf85f, /* 0014(:660): DRD2B1: idx1 = EU3(); EU3(idx1) */ + 0x000001f8, /* 0018(:0): NOP */ + 0x8298001b, /* 001C(:664): LCD: idx0 = var5; idx0 once var0; idx0 += inc3 */ + 0x7000000d, /* 0020(:665): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x010cf81f, /* 0024(:665): DRD2B1: var4 = EU3(); EU3(idx0) */ + 0x6000000e, /* 0028(:666): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */ + 0x018cf81f, /* 002C(:666): DRD2B1: var6 = EU3(); EU3(idx0) */ + 0xc202601b, /* 0030(:669): LCDEXT: idx0 = var4, idx1 = var4; ; idx0 += inc3, idx1 += inc3 */ + 0xc002221c, /* 0034(:669): LCDEXT: idx2 = var0, idx3 = var4; idx3 == var8; idx2 += inc3, idx3 += inc4 */ + 0x809a601b, /* 0038(:670): LCD: idx4 = var1; ; idx4 += inc3 */ + 0xc10420c2, /* 003C(:673): LCDEXT: idx5 = var2, idx6 = var8; idx6 < var3; idx5 += inc0, idx6 += inc2 */ + 0x839be009, /* 0040(:673): LCD: idx7 = var7; ; idx7 += inc1 */ + 0x03fed7b8, /* 0044(:676): DRD1A: *idx7; FN=0 init=31 WS=3 RS=3 */ + 0xda9b001b, /* 0048(:678): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 004C(:678): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000006, /* 0050(:680): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 0054(:680): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x1000cb28, /* 0058(:681): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 005C(:682): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 0060(:682): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x1000cb30, /* 0064(:683): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0068(:684): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 006C(:684): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x0000cb38, /* 0070(:685): DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 0074(:0): NOP */ + 0xc202601b, /* 0078(:689): LCDEXT: idx0 = var4, idx1 = var4; ; idx0 += inc3, idx1 += inc3 */ + 0xc002229c, /* 007C(:689): LCDEXT: idx2 = var0, idx3 = var4; idx3 == var10; idx2 += inc3, idx3 += inc4 */ + 0x809a601b, /* 0080(:690): LCD: idx4 = var1; ; idx4 += inc3 */ + 0xda9b001b, /* 0084(:693): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 0088(:693): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x0000d3a0, /* 008C(:694): DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */ + 0xc10420c2, /* 0090(:696): LCDEXT: idx5 = var2, idx6 = var8; idx6 < var3; idx5 += inc0, idx6 += inc2 */ + 0x839be009, /* 0094(:696): LCD: idx7 = var7; ; idx7 += inc1 */ + 0x0bfed7b8, /* 0098(:699): DRD1A: *idx7; FN=0 TFD init=31 WS=3 RS=3 */ + 0xda9b001b, /* 009C(:701): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00A0(:701): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000006, /* 00A4(:703): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 00A8(:703): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x1000cb28, /* 00AC(:704): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00B0(:705): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 00B4(:705): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x1000cb30, /* 00B8(:706): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00BC(:707): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 00C0(:707): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x0000cb38, /* 00C4(:708): DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 00C8(:0): NOP */ + 0xc318022d, /* 00CC(:712): LCDEXT: idx0 = var6; idx0 > var8; idx0 += inc5 */ + 0x8018801b, /* 00D0(:712): LCD: idx1 = var0; idx1 once var0; idx1 += inc3 */ + 0x040001f8, /* 00D4(:713): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ +}; +#ifdef MCD_INCLUDE_EU +u32 MCD_ChainEu_TDT[]= +{ + 0x80004000, /* 0000(:947): LCDEXT: idx0 = 0x00000000; ; */ + 0x8198801b, /* 0004(:947): LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */ + 0xb8c68018, /* 0008(:948): LCD: idx2 = *(idx1 + var13); idx2 once var0; idx2 += inc3 */ + 0x10002f10, /* 000C(:949): DRD1A: var11 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x7000000d, /* 0010(:950): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x01ccf89f, /* 0014(:950): DRD2B1: var7 = EU3(); EU3(idx2) */ + 0x6000000a, /* 0018(:951): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf89f, /* 001C(:951): DRD2B1: idx0 = EU3(); EU3(idx2) */ + 0x000001f8, /* 0020(:0): NOP */ + 0x981803a4, /* 0024(:955): LCD: idx0 = idx0; idx0 == var14; idx0 += inc4 */ + 0x8198801b, /* 0028(:957): LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */ + 0xf8c6801a, /* 002C(:958): LCDEXT: idx2 = *(idx1 + var13 + 8); idx2 once var0; idx2 += inc3 */ + 0xb8c6e01b, /* 0030(:959): LCD: idx3 = *(idx1 + var13 + 12); ; idx3 += inc3 */ + 0x10002b10, /* 0034(:961): DRD1A: var10 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x00001318, /* 0038(:962): DRD1A: var4 = idx3; FN=0 init=0 WS=0 RS=0 */ + 0xb8c6801d, /* 003C(:964): LCD: idx2 = *(idx1 + var13 + 20); idx2 once var0; idx2 += inc3 */ + 0x10001710, /* 0040(:965): DRD1A: var5 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x60000007, /* 0044(:966): DRD2A: EU0=0 EU1=0 EU2=0 EU3=7 EXT init=0 WS=0 RS=0 */ + 0x018cf88c, /* 0048(:966): DRD2B1: var6 = EU3(); EU3(idx2,var12) */ + 0x98c6801c, /* 004C(:968): LCD: idx2 = idx1 + var13 + 4; idx2 once var0; idx2 += inc3 */ + 0x00000b10, /* 0050(:969): DRD1A: var2 = idx2; FN=0 init=0 WS=0 RS=0 */ + 0x98c78018, /* 0054(:970): LCD: idx2 = idx1 + var15; idx2 once var0; idx2 += inc3 */ + 0x10002310, /* 0058(:971): DRD1A: var8 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c820, /* 005C(:972): DRD1A: *idx2 = var4; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 0060(:0): NOP */ + 0x8698801b, /* 0064(:976): LCD: idx1 = var13; idx1 once var0; idx1 += inc3 */ + 0x7000000f, /* 0068(:977): DRD2A: EU0=0 EU1=0 EU2=0 EU3=15 EXT MORE init=0 WS=0 RS=0 */ + 0x084cf2df, /* 006C(:977): DRD2B1: idx1 = EU3(); EU3(var11) */ + 0xd899042d, /* 0070(:978): LCDEXT: idx2 = idx1; idx2 >= var16; idx2 += inc5 */ + 0x8019801b, /* 0074(:978): LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */ + 0x60000003, /* 0078(:979): DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */ + 0x2cd7c7df, /* 007C(:979): DRD2B2: EU3(var13) */ + 0xd8990364, /* 0080(:980): LCDEXT: idx2 = idx1; idx2 == var13; idx2 += inc4 */ + 0x8019801b, /* 0084(:980): LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */ + 0x60000003, /* 0088(:981): DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */ + 0x2c17c7df, /* 008C(:981): DRD2B2: EU3(var1) */ + 0x000001f8, /* 0090(:0): NOP */ + 0xc1c7e018, /* 0094(:984): LCDEXT: idx1 = var3 + var15; ; idx1 += inc3 */ + 0xc003a35e, /* 0098(:984): LCDEXT: idx2 = var0, idx3 = var7; idx3 == var13; idx2 += inc3, idx3 += inc6 */ + 0x819a601b, /* 009C(:985): LCD: idx4 = var3; ; idx4 += inc3 */ + 0xc206a142, /* 00A0(:988): LCDEXT: idx5 = var4, idx6 = var13; idx6 < var5; idx5 += inc0, idx6 += inc2 */ + 0x851be009, /* 00A4(:988): LCD: idx7 = var10; ; idx7 += inc1 */ + 0x63fe0000, /* 00A8(:991): DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 EXT init=31 WS=3 RS=3 */ + 0x0d4cfddf, /* 00AC(:991): DRD2B1: *idx5 = EU3(); EU3(*idx7) */ + 0xda9b001b, /* 00B0(:993): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00B4(:993): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000002, /* 00B8(:994): DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */ + 0x004cf81f, /* 00BC(:994): DRD2B1: var1 = EU3(); EU3(idx0) */ + 0x1000cb20, /* 00C0(:995): DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00C4(:996): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 00C8(:996): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb28, /* 00CC(:997): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00D0(:998): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 00D4(:998): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb30, /* 00D8(:999): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00DC(:1000): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 00E0(:1000): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb38, /* 00E4(:1001): DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c728, /* 00E8(:1002): DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 00EC(:0): NOP */ + 0xc1c7e018, /* 00F0(:1006): LCDEXT: idx1 = var3 + var15; ; idx1 += inc3 */ + 0xc003a49e, /* 00F4(:1006): LCDEXT: idx2 = var0, idx3 = var7; idx3 == var18; idx2 += inc3, idx3 += inc6 */ + 0x819a601b, /* 00F8(:1007): LCD: idx4 = var3; ; idx4 += inc3 */ + 0xda9b001b, /* 00FC(:1010): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 0100(:1010): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x0000d3a0, /* 0104(:1011): DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */ + 0xc206a142, /* 0108(:1013): LCDEXT: idx5 = var4, idx6 = var13; idx6 < var5; idx5 += inc0, idx6 += inc2 */ + 0x851be009, /* 010C(:1013): LCD: idx7 = var10; ; idx7 += inc1 */ + 0x6bfe0000, /* 0110(:1016): DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 TFD EXT init=31 WS=3 RS=3 */ + 0x0d4cfddf, /* 0114(:1016): DRD2B1: *idx5 = EU3(); EU3(*idx7) */ + 0xda9b001b, /* 0118(:1018): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 011C(:1018): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000002, /* 0120(:1019): DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */ + 0x004cf81f, /* 0124(:1019): DRD2B1: var1 = EU3(); EU3(idx0) */ + 0x1000cb20, /* 0128(:1020): DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 012C(:1021): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 0130(:1021): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb28, /* 0134(:1022): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0138(:1023): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 013C(:1023): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb30, /* 0140(:1024): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0144(:1025): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 0148(:1025): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb38, /* 014C(:1026): DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c728, /* 0150(:1027): DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 0154(:0): NOP */ + 0x8198801b, /* 0158(:1031): LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */ + 0xd8c68018, /* 015C(:1033): LCDEXT: idx2 = idx1 + var13; idx2 once var0; idx2 += inc3 */ + 0x98c6e01c, /* 0160(:1033): LCD: idx3 = idx1 + var13 + 4; ; idx3 += inc3 */ + 0x6000000b, /* 0164(:1034): DRD2A: EU0=0 EU1=0 EU2=0 EU3=11 EXT init=0 WS=0 RS=0 */ + 0x0c8cfc9f, /* 0168(:1034): DRD2B1: *idx2 = EU3(); EU3(*idx2) */ + 0x0000cc08, /* 016C(:1035): DRD1A: *idx3 = var1; FN=0 init=0 WS=0 RS=0 */ + 0xa1c6801e, /* 0170(:1038): LCD: idx1 = *(var3 + var13 + 24); idx1 once var0; idx1 += inc3 */ + 0x10000f08, /* 0174(:1039): DRD1A: var3 = idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x10002458, /* 0178(:1040): DRD1A: var9 = var11; FN=0 MORE init=0 WS=0 RS=0 */ + 0xb8c68018, /* 017C(:1041): LCD: idx2 = *(idx1 + var13); idx2 once var0; idx2 += inc3 */ + 0x10002f10, /* 0180(:1042): DRD1A: var11 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x7000000a, /* 0184(:1043): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT MORE init=0 WS=0 RS=0 */ + 0x080cf89f, /* 0188(:1043): DRD2B1: idx0 = EU3(); EU3(idx2) */ + 0x6000000d, /* 018C(:1044): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT init=0 WS=0 RS=0 */ + 0x01ccf89f, /* 0190(:1044): DRD2B1: var7 = EU3(); EU3(idx2) */ + 0x000001f8, /* 0194(:0): NOP */ + 0x8698801b, /* 0198(:1050): LCD: idx1 = var13; idx1 once var0; idx1 += inc3 */ + 0x7000000e, /* 019C(:1051): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */ + 0x084cf25f, /* 01A0(:1051): DRD2B1: idx1 = EU3(); EU3(var9) */ + 0xd899037f, /* 01A4(:1052): LCDEXT: idx2 = idx1; idx2 > var13; idx2 += inc7 */ + 0x8019801b, /* 01A8(:1052): LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */ + 0x040001f8, /* 01AC(:1053): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ + 0x000001f8, /* 01B0(:0): NOP */ + 0x000001f8, /* 01B4(:0): NOP */ +}; +u32 MCD_SingleEu_TDT[]= +{ + 0x8218001b, /* 0000(:1248): LCD: idx0 = var4; idx0 once var0; idx0 += inc3 */ + 0x7000000d, /* 0004(:1249): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x080cf81f, /* 0008(:1249): DRD2B1: idx0 = EU3(); EU3(idx0) */ + 0x8218801b, /* 000C(:1250): LCD: idx1 = var4; idx1 once var0; idx1 += inc3 */ + 0x6000000e, /* 0010(:1251): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */ + 0x084cf85f, /* 0014(:1251): DRD2B1: idx1 = EU3(); EU3(idx1) */ + 0x000001f8, /* 0018(:0): NOP */ + 0x8318001b, /* 001C(:1255): LCD: idx0 = var6; idx0 once var0; idx0 += inc3 */ + 0x7000000d, /* 0020(:1256): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x014cf81f, /* 0024(:1256): DRD2B1: var5 = EU3(); EU3(idx0) */ + 0x6000000e, /* 0028(:1257): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */ + 0x01ccf81f, /* 002C(:1257): DRD2B1: var7 = EU3(); EU3(idx0) */ + 0x8498001b, /* 0030(:1260): LCD: idx0 = var9; idx0 once var0; idx0 += inc3 */ + 0x7000000f, /* 0034(:1261): DRD2A: EU0=0 EU1=0 EU2=0 EU3=15 EXT MORE init=0 WS=0 RS=0 */ + 0x080cf19f, /* 0038(:1261): DRD2B1: idx0 = EU3(); EU3(var6) */ + 0xd81882a4, /* 003C(:1262): LCDEXT: idx1 = idx0; idx1 >= var10; idx1 += inc4 */ + 0x8019001b, /* 0040(:1262): LCD: idx2 = var0; idx2 once var0; idx2 += inc3 */ + 0x60000003, /* 0044(:1263): DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */ + 0x2c97c7df, /* 0048(:1263): DRD2B2: EU3(var9) */ + 0xd818826d, /* 004C(:1264): LCDEXT: idx1 = idx0; idx1 == var9; idx1 += inc5 */ + 0x8019001b, /* 0050(:1264): LCD: idx2 = var0; idx2 once var0; idx2 += inc3 */ + 0x60000003, /* 0054(:1265): DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */ + 0x2c17c7df, /* 0058(:1265): DRD2B2: EU3(var1) */ + 0x000001f8, /* 005C(:0): NOP */ + 0xc282e01b, /* 0060(:1268): LCDEXT: idx0 = var5, idx1 = var5; ; idx0 += inc3, idx1 += inc3 */ + 0xc002a25e, /* 0064(:1268): LCDEXT: idx2 = var0, idx3 = var5; idx3 == var9; idx2 += inc3, idx3 += inc6 */ + 0x811a601b, /* 0068(:1269): LCD: idx4 = var2; ; idx4 += inc3 */ + 0xc184a102, /* 006C(:1272): LCDEXT: idx5 = var3, idx6 = var9; idx6 < var4; idx5 += inc0, idx6 += inc2 */ + 0x841be009, /* 0070(:1272): LCD: idx7 = var8; ; idx7 += inc1 */ + 0x63fe0000, /* 0074(:1275): DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 EXT init=31 WS=3 RS=3 */ + 0x0d4cfddf, /* 0078(:1275): DRD2B1: *idx5 = EU3(); EU3(*idx7) */ + 0xda9b001b, /* 007C(:1277): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 0080(:1277): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000002, /* 0084(:1279): DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */ + 0x004cf99f, /* 0088(:1279): DRD2B1: var1 = EU3(); EU3(idx6) */ + 0x70000006, /* 008C(:1280): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 0090(:1280): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x1000cb28, /* 0094(:1281): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0098(:1282): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 009C(:1282): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x1000cb30, /* 00A0(:1283): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00A4(:1284): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 00A8(:1284): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x0000cb38, /* 00AC(:1285): DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 00B0(:0): NOP */ + 0xc282e01b, /* 00B4(:1289): LCDEXT: idx0 = var5, idx1 = var5; ; idx0 += inc3, idx1 += inc3 */ + 0xc002a31e, /* 00B8(:1289): LCDEXT: idx2 = var0, idx3 = var5; idx3 == var12; idx2 += inc3, idx3 += inc6 */ + 0x811a601b, /* 00BC(:1290): LCD: idx4 = var2; ; idx4 += inc3 */ + 0xda9b001b, /* 00C0(:1293): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00C4(:1293): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x0000d3a0, /* 00C8(:1294): DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */ + 0xc184a102, /* 00CC(:1296): LCDEXT: idx5 = var3, idx6 = var9; idx6 < var4; idx5 += inc0, idx6 += inc2 */ + 0x841be009, /* 00D0(:1296): LCD: idx7 = var8; ; idx7 += inc1 */ + 0x6bfe0000, /* 00D4(:1299): DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 TFD EXT init=31 WS=3 RS=3 */ + 0x0d4cfddf, /* 00D8(:1299): DRD2B1: *idx5 = EU3(); EU3(*idx7) */ + 0xda9b001b, /* 00DC(:1301): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00E0(:1301): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000002, /* 00E4(:1303): DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */ + 0x004cf99f, /* 00E8(:1303): DRD2B1: var1 = EU3(); EU3(idx6) */ + 0x70000006, /* 00EC(:1304): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 00F0(:1304): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x1000cb28, /* 00F4(:1305): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00F8(:1306): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 00FC(:1306): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x1000cb30, /* 0100(:1307): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0104(:1308): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 0108(:1308): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x0000cb38, /* 010C(:1309): DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 0110(:0): NOP */ + 0x8144801c, /* 0114(:1312): LCD: idx0 = var2 + var9 + 4; idx0 once var0; idx0 += inc3 */ + 0x0000c008, /* 0118(:1313): DRD1A: *idx0 = var1; FN=0 init=0 WS=0 RS=0 */ + 0xc398027f, /* 011C(:1315): LCDEXT: idx0 = var7; idx0 > var9; idx0 += inc7 */ + 0x8018801b, /* 0120(:1315): LCD: idx1 = var0; idx1 once var0; idx1 += inc3 */ + 0x040001f8, /* 0124(:1316): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ +}; +#endif +u32 MCD_ENetRcv_TDT[]= +{ + 0x80004000, /* 0000(:1389): LCDEXT: idx0 = 0x00000000; ; */ + 0x81988000, /* 0004(:1389): LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */ + 0x10000788, /* 0008(:1390): DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x6000000a, /* 000C(:1391): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf05f, /* 0010(:1391): DRD2B1: idx0 = EU3(); EU3(var1) */ + 0x98180209, /* 0014(:1394): LCD: idx0 = idx0; idx0 != var8; idx0 += inc1 */ + 0x81c40004, /* 0018(:1396): LCD: idx1 = var3 + var8 + 4; idx1 once var0; idx1 += inc0 */ + 0x7000000e, /* 001C(:1397): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */ + 0x010cf05f, /* 0020(:1397): DRD2B1: var4 = EU3(); EU3(var1) */ + 0x7000000c, /* 0024(:1398): DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT MORE init=0 WS=0 RS=0 */ + 0x01ccf05f, /* 0028(:1398): DRD2B1: var7 = EU3(); EU3(var1) */ + 0x70000004, /* 002C(:1399): DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */ + 0x014cf049, /* 0030(:1399): DRD2B1: var5 = EU3(); EU3(var1,var9) */ + 0x70000004, /* 0034(:1400): DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */ + 0x004cf04a, /* 0038(:1400): DRD2B1: var1 = EU3(); EU3(var1,var10) */ + 0x00000b88, /* 003C(:1403): DRD1A: var2 = *idx1; FN=0 init=0 WS=0 RS=0 */ + 0xc4030150, /* 0040(:1406): LCDEXT: idx1 = var8, idx2 = var6; idx1 < var5; idx1 += inc2, idx2 += inc0 */ + 0x8119e012, /* 0044(:1406): LCD: idx3 = var2; ; idx3 += inc2 */ + 0x03e0cf90, /* 0048(:1409): DRD1A: *idx3 = *idx2; FN=0 init=31 WS=0 RS=0 */ + 0x81188000, /* 004C(:1412): LCD: idx1 = var2; idx1 once var0; idx1 += inc0 */ + 0x000ac788, /* 0050(:1413): DRD1A: *idx1 = *idx1; FN=0 init=0 WS=1 RS=1 */ + 0xc4030000, /* 0054(:1415): LCDEXT: idx1 = var8, idx2 = var6; idx1 once var0; idx1 += inc0, idx2 += inc0 */ + 0x8199e000, /* 0058(:1415): LCD: idx3 = var3; ; idx3 += inc0 */ + 0x70000004, /* 005C(:1421): DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */ + 0x084cfc8b, /* 0060(:1421): DRD2B1: idx1 = EU3(); EU3(*idx2,var11) */ + 0x60000005, /* 0064(:1422): DRD2A: EU0=0 EU1=0 EU2=0 EU3=5 EXT init=0 WS=0 RS=0 */ + 0x0cccf841, /* 0068(:1422): DRD2B1: *idx3 = EU3(); EU3(idx1,var1) */ + 0x81c60000, /* 006C(:1428): LCD: idx1 = var3 + var12; idx1 once var0; idx1 += inc0 */ + 0xc399021b, /* 0070(:1430): LCDEXT: idx2 = var7; idx2 > var8; idx2 += inc3 */ + 0x80198000, /* 0074(:1430): LCD: idx3 = var0; idx3 once var0; idx3 += inc0 */ + 0x00008400, /* 0078(:1431): DRD1A: idx1 = var0; FN=0 init=0 WS=0 RS=0 */ + 0x00000f08, /* 007C(:1432): DRD1A: var3 = idx1; FN=0 init=0 WS=0 RS=0 */ + 0x81988000, /* 0080(:1435): LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */ + 0x10000788, /* 0084(:1436): DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x6000000a, /* 0088(:1437): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf05f, /* 008C(:1437): DRD2B1: idx0 = EU3(); EU3(var1) */ + 0xc2188209, /* 0090(:1440): LCDEXT: idx1 = var4; idx1 != var8; idx1 += inc1 */ + 0x80190000, /* 0094(:1440): LCD: idx2 = var0; idx2 once var0; idx2 += inc0 */ + 0x040001f8, /* 0098(:1441): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ + 0x000001f8, /* 009C(:0): NOP */ +}; +u32 MCD_ENetXmit_TDT[]= +{ + 0x80004000, /* 0000(:1516): LCDEXT: idx0 = 0x00000000; ; */ + 0x81988000, /* 0004(:1516): LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */ + 0x10000788, /* 0008(:1517): DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x6000000a, /* 000C(:1518): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf05f, /* 0010(:1518): DRD2B1: idx0 = EU3(); EU3(var1) */ + 0x98180309, /* 0014(:1521): LCD: idx0 = idx0; idx0 != var12; idx0 += inc1 */ + 0x80004003, /* 0018(:1523): LCDEXT: idx1 = 0x00000003; ; */ + 0x81c60004, /* 001C(:1523): LCD: idx2 = var3 + var12 + 4; idx2 once var0; idx2 += inc0 */ + 0x7000000e, /* 0020(:1524): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */ + 0x014cf05f, /* 0024(:1524): DRD2B1: var5 = EU3(); EU3(var1) */ + 0x7000000c, /* 0028(:1525): DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT MORE init=0 WS=0 RS=0 */ + 0x028cf05f, /* 002C(:1525): DRD2B1: var10 = EU3(); EU3(var1) */ + 0x7000000d, /* 0030(:1526): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x018cf05f, /* 0034(:1526): DRD2B1: var6 = EU3(); EU3(var1) */ + 0x70000004, /* 0038(:1527): DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */ + 0x01ccf04d, /* 003C(:1527): DRD2B1: var7 = EU3(); EU3(var1,var13) */ + 0x10000b90, /* 0040(:1528): DRD1A: var2 = *idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x60000004, /* 0044(:1529): DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT init=0 WS=0 RS=0 */ + 0x020cf0a1, /* 0048(:1529): DRD2B1: var8 = EU3(); EU3(var2,idx1) */ + 0xc3188312, /* 004C(:1532): LCDEXT: idx1 = var6; idx1 > var12; idx1 += inc2 */ + 0x83c70000, /* 0050(:1532): LCD: idx2 = var7 + var14; idx2 once var0; idx2 += inc0 */ + 0x00001f10, /* 0054(:1533): DRD1A: var7 = idx2; FN=0 init=0 WS=0 RS=0 */ + 0xc583a3c3, /* 0058(:1535): LCDEXT: idx1 = var11, idx2 = var7; idx2 >= var15; idx1 += inc0, idx2 += inc3 */ + 0x81042325, /* 005C(:1535): LCD: idx3 = var2, idx4 = var8; idx4 == var12; idx3 += inc4, idx4 += inc5 */ + 0x03e0c798, /* 0060(:1540): DRD1A: *idx1 = *idx3; FN=0 init=31 WS=0 RS=0 */ + 0xd8990000, /* 0064(:1543): LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */ + 0x9999e000, /* 0068(:1543): LCD: idx3 = idx3; ; idx3 += inc0 */ + 0x000acf98, /* 006C(:1544): DRD1A: *idx3 = *idx3; FN=0 init=0 WS=1 RS=1 */ + 0xd8992306, /* 0070(:1546): LCDEXT: idx1 = idx1, idx2 = idx2; idx2 > var12; idx1 += inc0, idx2 += inc6 */ + 0x9999e03f, /* 0074(:1546): LCD: idx3 = idx3; ; idx3 += inc7 */ + 0x03eac798, /* 0078(:1549): DRD1A: *idx1 = *idx3; FN=0 init=31 WS=1 RS=1 */ + 0xd8990000, /* 007C(:1552): LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */ + 0x9999e000, /* 0080(:1552): LCD: idx3 = idx3; ; idx3 += inc0 */ + 0x000acf98, /* 0084(:1553): DRD1A: *idx3 = *idx3; FN=0 init=0 WS=1 RS=1 */ + 0xd8990000, /* 0088(:1555): LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */ + 0x99832302, /* 008C(:1555): LCD: idx3 = idx3, idx4 = var6; idx4 > var12; idx3 += inc0, idx4 += inc2 */ + 0x0beac798, /* 0090(:1558): DRD1A: *idx1 = *idx3; FN=0 TFD init=31 WS=1 RS=1 */ + 0x81988000, /* 0094(:1560): LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */ + 0x6000000b, /* 0098(:1561): DRD2A: EU0=0 EU1=0 EU2=0 EU3=11 EXT init=0 WS=0 RS=0 */ + 0x0c4cfc5f, /* 009C(:1561): DRD2B1: *idx1 = EU3(); EU3(*idx1) */ + 0x81c80000, /* 00A0(:1563): LCD: idx1 = var3 + var16; idx1 once var0; idx1 += inc0 */ + 0xc5190312, /* 00A4(:1565): LCDEXT: idx2 = var10; idx2 > var12; idx2 += inc2 */ + 0x80198000, /* 00A8(:1565): LCD: idx3 = var0; idx3 once var0; idx3 += inc0 */ + 0x00008400, /* 00AC(:1566): DRD1A: idx1 = var0; FN=0 init=0 WS=0 RS=0 */ + 0x00000f08, /* 00B0(:1567): DRD1A: var3 = idx1; FN=0 init=0 WS=0 RS=0 */ + 0x81988000, /* 00B4(:1570): LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */ + 0x10000788, /* 00B8(:1571): DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x6000000a, /* 00BC(:1572): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf05f, /* 00C0(:1572): DRD2B1: idx0 = EU3(); EU3(var1) */ + 0xc2988309, /* 00C4(:1575): LCDEXT: idx1 = var5; idx1 != var12; idx1 += inc1 */ + 0x80190000, /* 00C8(:1575): LCD: idx2 = var0; idx2 once var0; idx2 += inc0 */ + 0x040001f8, /* 00CC(:1576): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ + 0x000001f8, /* 00D0(:0): NOP */ +}; + +#ifdef MCD_INCLUDE_EU +MCD_bufDesc MCD_singleBufDescs[NCHANNELS]; +#endif diff --git a/mcdapirev0p3/MCD_tasksInit.c b/mcdapirev0p3/MCD_tasksInit.c new file mode 100644 index 0000000..fd651b2 --- /dev/null +++ b/mcdapirev0p3/MCD_tasksInit.c @@ -0,0 +1,224 @@ +/* + * File: MCD_tasksInit.c + * Purpose: Functions for initializing variable tables of different + * types of tasks. + * + * Notes: + */ + +/* + * Do not edit! + */ + +#include "MCD_dma.h" + +extern dmaRegs *MCD_dmaBar; + + +/* + * Task 0 + */ + +void MCD_startDmaChainNoEu(int *currBD, short srcIncr, short destIncr, int xferSize, short xferSizeIncr, int *cSave, volatile TaskTableEntry *taskTable, int channel) +{ + + MCD_SET_VAR(taskTable+channel, 2, (u32)currBD); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr)); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr)); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 11, (u32)xferSize); /* var[11] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr)); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 0, (u32)cSave); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 3, (u32)0x00000000); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000000); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 12, (u32)0x00000000); /* var[12] */ + MCD_SET_VAR(taskTable+channel, 13, (u32)0x80000000); /* var[13] */ + MCD_SET_VAR(taskTable+channel, 14, (u32)0x00000010); /* var[14] */ + MCD_SET_VAR(taskTable+channel, 15, (u32)0x00000004); /* var[15] */ + MCD_SET_VAR(taskTable+channel, 16, (u32)0x08000000); /* var[16] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000); /* inc[3] */ + MCD_SET_VAR(taskTable+channel, 28, (u32)0x80000000); /* inc[4] */ + MCD_SET_VAR(taskTable+channel, 29, (u32)0x80000001); /* inc[5] */ + MCD_SET_VAR(taskTable+channel, 30, (u32)0x40000000); /* inc[6] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} + + +/* + * Task 1 + */ + +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) +{ + + MCD_SET_VAR(taskTable+channel, 7, (u32)srcAddr); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr)); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 2, (u32)destAddr); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr)); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 3, (u32)dmaSize); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr)); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)flags); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)currBD); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 0, (u32)cSave); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000004); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x08000000); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000); /* inc[3] */ + MCD_SET_VAR(taskTable+channel, 28, (u32)0x80000001); /* inc[4] */ + MCD_SET_VAR(taskTable+channel, 29, (u32)0x40000000); /* inc[5] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} + + +/* + * Task 2 + */ + +void MCD_startDmaChainEu(int *currBD, short srcIncr, short destIncr, int xferSize, short xferSizeIncr, int *cSave, volatile TaskTableEntry *taskTable, int channel) +{ + + MCD_SET_VAR(taskTable+channel, 3, (u32)currBD); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr)); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr)); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 12, (u32)xferSize); /* var[12] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr)); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 0, (u32)cSave); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 2, (u32)0x00000000); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000000); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 11, (u32)0x00000000); /* var[11] */ + MCD_SET_VAR(taskTable+channel, 13, (u32)0x00000000); /* var[13] */ + MCD_SET_VAR(taskTable+channel, 14, (u32)0x80000000); /* var[14] */ + MCD_SET_VAR(taskTable+channel, 15, (u32)0x00000010); /* var[15] */ + MCD_SET_VAR(taskTable+channel, 16, (u32)0x00000001); /* var[16] */ + MCD_SET_VAR(taskTable+channel, 17, (u32)0x00000004); /* var[17] */ + MCD_SET_VAR(taskTable+channel, 18, (u32)0x08000000); /* var[18] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000); /* inc[3] */ + MCD_SET_VAR(taskTable+channel, 28, (u32)0x80000000); /* inc[4] */ + MCD_SET_VAR(taskTable+channel, 29, (u32)0xc0000000); /* inc[5] */ + MCD_SET_VAR(taskTable+channel, 30, (u32)0x80000001); /* inc[6] */ + MCD_SET_VAR(taskTable+channel, 31, (u32)0x40000000); /* inc[7] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} + + +/* + * Task 3 + */ + +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) +{ + + MCD_SET_VAR(taskTable+channel, 8, (u32)srcAddr); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr)); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 3, (u32)destAddr); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr)); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)dmaSize); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr)); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)flags); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 2, (u32)currBD); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 0, (u32)cSave); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000001); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 11, (u32)0x00000004); /* var[11] */ + MCD_SET_VAR(taskTable+channel, 12, (u32)0x08000000); /* var[12] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000); /* inc[3] */ + MCD_SET_VAR(taskTable+channel, 28, (u32)0xc0000000); /* inc[4] */ + MCD_SET_VAR(taskTable+channel, 29, (u32)0x80000000); /* inc[5] */ + MCD_SET_VAR(taskTable+channel, 30, (u32)0x80000001); /* inc[6] */ + MCD_SET_VAR(taskTable+channel, 31, (u32)0x40000000); /* inc[7] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} + + +/* + * Task 4 + */ + +void MCD_startDmaENetRcv(char *bDBase, char *currBD, char *rcvFifoPtr, volatile TaskTableEntry *taskTable, int channel) +{ + + MCD_SET_VAR(taskTable+channel, 0, (u32)bDBase); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 3, (u32)currBD); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)rcvFifoPtr); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 2, (u32)0x00000000); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x0000ffff); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x30000000); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 11, (u32)0x0fffffff); /* var[11] */ + MCD_SET_VAR(taskTable+channel, 12, (u32)0x00000008); /* var[12] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)0x00000000); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)0x60000000); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)0x20000004); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0x40000000); /* inc[3] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} + + +/* + * Task 5 + */ + +void MCD_startDmaENetXmit(char *bDBase, char *currBD, char *xmitFifoPtr, volatile TaskTableEntry *taskTable, int channel) +{ + + MCD_SET_VAR(taskTable+channel, 0, (u32)bDBase); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 3, (u32)currBD); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 11, (u32)xmitFifoPtr); /* var[11] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 2, (u32)0x00000000); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000000); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 12, (u32)0x00000000); /* var[12] */ + MCD_SET_VAR(taskTable+channel, 13, (u32)0x0000ffff); /* var[13] */ + MCD_SET_VAR(taskTable+channel, 14, (u32)0xffffffff); /* var[14] */ + MCD_SET_VAR(taskTable+channel, 15, (u32)0x00000004); /* var[15] */ + MCD_SET_VAR(taskTable+channel, 16, (u32)0x00000008); /* var[16] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)0x00000000); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)0x60000000); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)0x40000000); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0xc000fffc); /* inc[3] */ + MCD_SET_VAR(taskTable+channel, 28, (u32)0xe0000004); /* inc[4] */ + MCD_SET_VAR(taskTable+channel, 29, (u32)0x80000000); /* inc[5] */ + MCD_SET_VAR(taskTable+channel, 30, (u32)0x4000ffff); /* inc[6] */ + MCD_SET_VAR(taskTable+channel, 31, (u32)0xe0000001); /* inc[7] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} diff --git a/mcdapirev0p3/Multichannel_DMA_API_User's_Guide.pdf b/mcdapirev0p3/Multichannel_DMA_API_User's_Guide.pdf new file mode 100644 index 0000000000000000000000000000000000000000..50b85e11c865ec6b98edd1e7ea62e7dd41d4add0 GIT binary patch literal 138124 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 OdrlQA`Zo=5`u_mP&ZCR~ literal 0 HcmV?d00001 diff --git a/mcdapirev0p3/ReleaseNotes.txt b/mcdapirev0p3/ReleaseNotes.txt new file mode 100644 index 0000000..f10ee17 --- /dev/null +++ b/mcdapirev0p3/ReleaseNotes.txt @@ -0,0 +1,26 @@ +Multi-channel DMA API Release Notes + +Version 0.3 + +* MCD_INCLUDE_EU functionality supported(microcode changes for all tasks +except ethernet). +* Fixed bug when using MCD_END_FRAME which would cause the DMA to transfer +zero bytes and then complete. +* Code cleanup. + + +Version 0.2 (Slight Update) + +* Modified casts and task table implementations that were causing +warnings (and even errors on certain compilers) +* Cosmetic changes to clean up MCD_dmaApi.c and MCD_dma.h +* Fixed table declarations so that MCD_tasks.c will compile if + MCD_INCLUDE_EU is defined (Note: EU functionality still not supported) + +Version 0.1 (Initial release) + +Alpha version +MCD_INCLUDE_EU functionality not supported. +MCD_INCLUDE_JBIG not supported. + + diff --git a/readme.txt b/readme.txt new file mode 100644 index 0000000..c890950 --- /dev/null +++ b/readme.txt @@ -0,0 +1,152 @@ +//------------------------------------------------------------------------ +// Readme.txt +//------------------------------------------------------------------------ +This project is configure to get you up and running quickly using +CodeWarrior with the Freescale MCF5475 board. + +This project provides full support for the selected board. +The created project provides Standard IO Support through console and terminal window. + +Sample code for the following language: +- C + + +//------------------------------------------------------------------------ +// Memory Maps +//------------------------------------------------------------------------ +The Hardware has the following memory map: + +# MCF5484 Derivative Memory map definitions from linker command files: +# __MBAR, __MMUBAR, __RAMBAR0, __RAMBAR0_SIZE, __RAMBAR1, __RAMBAR1_SIZE +# linker symbols must be defined in the linker command file. + +# Memory mapped registers + ___MBAR = 0x10000000; + ___MMUBAR = 0x11000000; +# 4KB on-chip Core SRAM0 + ___RAMBAR0 = 0x20000000; + ___RAMBAR0_SIZE = 0x00001000; +# 4KB on-chip Core SRAM1 + ___RAMBAR1 = 0x20001000; + ___RAMBAR1_SIZE = 0x00001000; +# 32KB on-chip System SRAM + ___SYS_SRAM = 0x10010000; + ___SYS_SRAM_SIZE = 0x00008000; + + + +//------------------------------------------------------------------------ +// Project Structure +//------------------------------------------------------------------------ +The project generated contains various files/groups: +- readme.txt: information for this project +- Sources: application source codes, user customizable startup + code, uart library, exception table +- Includes: derivative and board header files, ... +- Libs: runtime and libs +- Project Settings: linker command files for the different build + targets, the initialization and memory configuration files for + the hardware debugging, the common startup code, etc... + +//------------------------------------------------------------------------ +// Build Targets +//------------------------------------------------------------------------ +- INTERNAL_RAM: +This project target is setup to load and debug code from internal RAM. +It should be used during your application development. +This is the very basic project that outputs to the UART. +You needs to connect a Terminal Program to see the output. + + + +=================================================================== +WARNING regarding debugging new project wizard code with CCS-SIM +=================================================================== +The CCS-SIM is an instruction set simulator, it does not implement +any peripherals. +The new project generated by the wizard are using startup code +performing some hardware peripheral initializations. +When debugging with the CCS-SIM it might happen that the simulation +stuck on loop using non implemented peripheral register flag as +condition (PLL initialization as example). +In this case, you should either: +- move the PC to next statement +- use a skip point +- define a simulator specific macro which used when define allos you +to comment out the unwanted code in order to debug with CCS-SIM + + +=================================================================== +WARNING regarding code located in RAM +=================================================================== +Many possible ColdFire target processors have an external bus, so +you can use large external RAM devices for debugging applications +during development. But some processors do not have an external +bus, so you must accommodate applications in on-chip memory. +Although this on-chip RAM accommodates this CodeWarrior project, +it probably is too small for full development of your application. +Accordingly, for a processor without external bus, you should locate +your applications in flash memory. + +//------------------------------------------------------------------------ +// Flashing the code +//------------------------------------------------------------------------ +1. Select the appropriate project target and build it +2. Make sure the correct remote connection is selected in the Remote + Connection debugger panel +3. In the CodeWarrior IDE menu, select Project > Set Default Project + and select your project +4. In the CodeWarrior IDE menu, select Project > Set Default Target + and select the project target that has the code you want to flash +5. In the CodeWarrior IDE menu, select Tools > Flash Programmer +6. Go to the flash programmer Target Configuration panel, click Load + Settings +7. Browse to the \cfg sub folder and + select the flash settings xml file matching your build target +8. Check that Use Custom Settings checkbox is not selected +9. Go to the Erase/Blank Check panel, select the All Sectors option and + click Erase +10. Go to Program/Verify panel, click Program +11. Your code should now be flashed + +//------------------------------------------------------------------------ +// Terminal Settings +//------------------------------------------------------------------------ +In case the UART is supported, the terminal should be setup with: +- 19200 bauds, +- 8 data bits, +- no parity, +- 1 stop bit, +- no flow control. + +Please check this file in the project. + +//------------------------------------------------------------------------ +// Getting Started +//------------------------------------------------------------------------ +To build/debug your project, use the CodeWarrior IDE menu Project > Debug +or press F5. This will launch the debugger. Press again F5 in the +debugger (or the CodeWarrior IDE menu Project > Run) to start the +application. The CodeWarrior IDE menu Project > Break stops the +application. + +//------------------------------------------------------------------------ +// Adding your own code +//------------------------------------------------------------------------ +Once everything is working as expected, you can begin adding your own code +to the project. Keep in mind that we provide this as an example of how to +get up and running quickly with CodeWarrior. There are certainly other +ways to handle interrupts and set up your linker command file. Feel free +to modify any of the source files provided. + +//------------------------------------------------------------------------ +// Additional documentation +//------------------------------------------------------------------------ +Read the online documentation provided. In CodeWarrior IDE menu, select +Help > CodeWarrior Help. + +//------------------------------------------------------------------------ +// Contacting Freescale +//------------------------------------------------------------------------ +For bug reports, technical questions, and suggestions, please use the +forms installed in the Release_Notes folder. diff --git a/sources/BaS.c b/sources/BaS.c index 08303aa..53344dd 100644 --- a/sources/BaS.c +++ b/sources/BaS.c @@ -7,8 +7,12 @@ #include "MCF5475.h" #include "startcf.h" -extern unsigned long far __SP_AFTER_RESET[]; -extern unsigned long far __Bas_base[]; +#include "MCD_dma.h" +#define MBAR_BASE_ADRS 0xff000000 +#define MMAP_DMA 0x00008000 +#define MMAP_SRAM 0x00010000 + +extern unsigned long far __SDRAM_SIZE; /* imported routines */ extern int mmu_init(); @@ -27,11 +31,12 @@ void warte_10ms(void) { warte_10ms: move.l d0,-(sp) - move.l MCF_SLT0_SCNT,d0 - sub.l #1320000,d0 + move.l #1330000,d0 + move.l d0,MCF_SLT0_STCNT warte_d6: - cmp.l MCF_SLT0_SCNT,d0 - bcs warte_d6 + move.b MCF_SLT0_SSR,d0 + btst.b #0,d0 + beq warte_d6 move.l (sp)+,d0 } } @@ -42,11 +47,12 @@ void warte_1ms(void) { warte_1ms: move.l d0,-(sp) - move.l MCF_SLT0_SCNT,d0 - sub.l #132000,d0 + move.l #133000,d0 + move.l d0,MCF_SLT0_STCNT warte_d6: - cmp.l MCF_SLT0_SCNT,d0 - bcs warte_d6 + move.b MCF_SLT0_SSR,d0 + btst.b #0,d0 + beq warte_d6 move.l (sp)+,d0 } } @@ -57,11 +63,12 @@ void warte_100us(void) { warte_100us: move.l d0,-(sp) - move.l MCF_SLT0_SCNT,d0 - sub.l #13200,d0 + move.l #13300,d0 + move.l d0,MCF_SLT0_STCNT warte_d6: - cmp.l MCF_SLT0_SCNT,d0 - bcs warte_d6 + move.b MCF_SLT0_SSR,d0 + btst.b #0,d0 + beq warte_d6 move.l (sp)+,d0 } } @@ -72,11 +79,12 @@ void warte_50us(void) { warte_50us: move.l d0,-(sp) - move.l MCF_SLT0_SCNT,d0 - sub.l #6600,d0 + move.l #6650,d0 + move.l d0,MCF_SLT0_STCNT warte_d6: - cmp.l MCF_SLT0_SCNT,d0 - bcs warte_d6 + move.b MCF_SLT0_SSR,d0 + btst.b #0,d0 + beq warte_d6 move.l (sp)+,d0 } } @@ -86,11 +94,12 @@ void warte_10us(void) { warte_10us: move.l d0,-(sp) - move.l MCF_SLT0_SCNT,d0 - sub.l #1320,d0 + move.l #1330,d0 + move.l d0,MCF_SLT0_STCNT warte_d6: - cmp.l MCF_SLT0_SCNT,d0 - bcs warte_d6 + move.b MCF_SLT0_SSR,d0 + btst.b #0,d0 + beq warte_d6 move.l (sp)+,d0 } } @@ -101,20 +110,27 @@ void warte_1us(void) { warte_1us: move.l d0,-(sp) - move.l MCF_SLT0_SCNT,d0 - sub.l #132,d0 + move.l #133,d0 + move.l d0,MCF_SLT0_STCNT warte_d6: - cmp.l MCF_SLT0_SCNT,d0 - bcs warte_d6 + move.b MCF_SLT0_SSR,d0 + btst.b #0,d0 + beq warte_d6 move.l (sp)+,d0 } } /********************************************************************/ +#define ide_dma_tnr 7 + void BaS(void) { +/*********************************************/ +// SD-Card abfragen int az_sectors; int sd_status,i; + int dma_init_status,dma_run_status,dma_status; + az_sectors = sd_card_init(); @@ -122,12 +138,15 @@ void BaS(void) { sd_card_idle(); } - +/*********************************************/ +// FireTOS laden? asm -{ - move.b DIP_SWITCH,d0 // dip schalter adresse + { + move.b DIP_SWITCH,d0 btst.b #6,d0 beq firetos_kopieren +/**************************************/ +// PIC initieren und daten anfordern lea MCF_PSC0_PSCTB_8BIT,a6 lea MCF_PSC3_PSCTB_8BIT,a3 lea MCF_PSC3_PSCRB_8BIT,a4 @@ -141,8 +160,10 @@ void BaS(void) move.b d1,(a6) move.b (a4),d2 move.b d2,(a6) - move.l #0x0a0d,(a6) move.b #0x01,(a3) // RTC DATEN ANFORDERN + move.l #'OK!',(a6) + move.l #0x0a0d,(a6) +/**************************************/ // TOS kopieren lea 0x00e00000,a0 lea 0xe0600000,a1 // default tos @@ -155,6 +176,13 @@ firetos_kopieren: lea 0xe0400000,a1 lea 0xe0500000,a2 // 1MB cptos_loop: + move.l (a1)+,(a0)+ + move.l (a1)+,(a0)+ + move.l (a1)+,(a0)+ + move.l (a1)+,(a0)+ + move.l (a1)+,(a0)+ + move.l (a1)+,(a0)+ + move.l (a1)+,(a0)+ move.l (a1)+,(a0)+ cmp.l a2,a1 blt cptos_loop @@ -165,7 +193,7 @@ div_inits: move.b DIP_SWITCH,d0 // dip schalter adresse btst.b #6,d0 beq video_setup -// rtc daten, mmu set, etc nur wenn switch 6 = off +// rtc daten laden, mmu set, etc nur wenn switch 6 = off -> kein init wenn FireTOS lea 0xffff8961,a0 clr.l d1 moveq #64,d2 @@ -179,13 +207,11 @@ loop_sr: addq.l #1,d1 cmp.b d1,d2 bne loop_sr -/* - // Set the NVRAM checksum as invalid + move.b #63,(a0) move.b 2(a0),d0 add #1,d0 move.b d0,2(a0) -*/ not_rtc: bsr mmu_init bsr vec_init @@ -221,33 +247,9 @@ not_rtc: nop nop /********************************************************************/ -/* IDE reset -/********************************************************************/ - lea 0xffff8802,a0 - move.b #14,-2(a0) - move.b #0x80,(a0) - bsr warte_1ms - clr.b (a0) -/********************************************************************/ -/* video setup -/********************************************************************/ video_setup: - lea 0xf0000410,a0 -// 25MHz - move.l #0x032002ba,(a0)+ // horizontal 640x480 - move.l #0x020c020a,(a0)+ // vertikal 640x480 - move.l #0x0190015d,(a0)+ // horizontal 320x240 - move.l #0x020C020A,(a0)+ // vertikal 320x240 */ -/* -// 32MHz - move.l #0x037002ba,(a0)+ // horizontal 640x480 - move.l #0x020d020a,(a0)+ // vertikal 640x480 - move.l #0x02A001e0,(a0)+ // horizontal 320x240 - move.l #0x05a00160,(a0)+ // vertikal 320x240 -*/ - lea -0x20(a0),a0 - move.l #0x01070002,(a0) // fifo on, refresh on, ddrcs und cke on, video dac on, -/********************************************************************/ +// nichts +/*******************************************************************/ /* memory setup /********************************************************************/ lea 0x400,a0 @@ -272,7 +274,7 @@ mem_clr_loop: move.l #0x5555aaaa,d0 // memval3 move.l d0,0x51a // ttram - move.l #__Bas_base,d0 // ende ttram + move.l #__SDRAM_SIZE,d0 // ende ttram move.l d0,0x5a4 move.l #0x1357bd13,d0 // ramvalid move.l d0,0x5a8 @@ -292,13 +294,69 @@ mem_clr_loop: move.b d0,0xfffffa11 nop + } +/* +// init_dma: + dma_init_status = + MCD_initDma( + (dmaRegs*) (MBAR_BASE_ADRS + MMAP_DMA), + (void*) (MBAR_BASE_ADRS + MMAP_SRAM), + (MCD_RELOC_TASKS) + ); + + for (i=0; i<64; i++) + { + + dma_run_status = + MCD_startDma(ide_dma_tnr, //int channel, the channel on which to run the DMA + (char*) (0x60004000), //s8 *srcAddr, the address to move data from, or physical buffer-descriptor address + 4, //s16 srcIncr, the amount to increment the source address per transfer + (char*) (0x60000000), //s8 *destAddr, the address to move data to + 4, //s16 destIncr, the amount to increment the destination address per transfer + 4*389120, //u32 dmaSize, the number of bytes to transfer independent of the transfer size + 4, //u32 xferSize, the number bytes in of each data movement (1, 2, or 4) + 0, //u32 initiator, what device initiates the DMA + 5, //int priority, priority of the DMA + MCD_SINGLE_DMA+ + MCD_TT_FLAGS_CW+ //u32 flags, flags describing the DMA + MCD_TT_FLAGS_RL+ + MCD_TT_FLAGS_SP, + MCD_NO_BYTE_SWAP+ + MCD_NO_BIT_REV //u32 funcDesc a description of byte swapping, bit swapping, and CRC actions + ); + while (MCD_dmaStatus(ide_dma_tnr)!=6); + } + + dma_status = + MCD_dmaStatus(ide_dma_tnr); + + MCD_killDma(ide_dma_tnr); +*/ + asm + { // test auf protect mode --------------------- move.b DIP_SWITCH,d0 btst #7,d0 beq no_protect // nein-> move.w #0x0700,sr no_protect: + } + MCF_PSC0_PSCTB_8BIT = 0x0a0d; + MCF_PSC0_PSCTB_8BIT = 'BaS '; + MCF_PSC0_PSCTB_8BIT = 'comp'; + MCF_PSC0_PSCTB_8BIT = 'lete'; + MCF_PSC0_PSCTB_8BIT = 'd'; + MCF_PSC0_PSCTB_8BIT = 0x0a0d; + MCF_PSC0_PSCTB_8BIT = '----'; + MCF_PSC0_PSCTB_8BIT = '----'; + MCF_PSC0_PSCTB_8BIT = '----'; + MCF_PSC0_PSCTB_8BIT = '-'; + MCF_PSC0_PSCTB_8BIT = 0x0a0d; + MCF_PSC0_PSCTB_8BIT = 0x0a0d; + asm + { + nop + bsr warte_10ms jmp 0xe00030 - -} + } } diff --git a/sources/MCD_dmaApi.c b/sources/MCD_dmaApi.c new file mode 100644 index 0000000..839fce1 --- /dev/null +++ b/sources/MCD_dmaApi.c @@ -0,0 +1,933 @@ +/* + * File: MCD_dmaApi.c + * Purpose: Main C file for multi-channel DMA API. + * + * Notes: + */ + +#include "MCD_dma.h" +#include "MCD_tasksInit.h" +#include "MCD_progCheck.h" + +/********************************************************************/ +/* + * This is an API-internal pointer to the DMA's registers + */ +dmaRegs *MCD_dmaBar; + +/* + * These are the real and model task tables as generated by the + * build process + */ +extern TaskTableEntry MCD_realTaskTableSrc[NCHANNELS]; +extern TaskTableEntry MCD_modelTaskTableSrc[NUMOFVARIANTS]; + +/* + * However, this (usually) gets relocated to on-chip SRAM, at which + * point we access them as these tables + */ +volatile TaskTableEntry *MCD_taskTable; +TaskTableEntry *MCD_modelTaskTable; + + +/* + * MCD_chStatus[] is an array of status indicators for remembering + * whether a DMA has ever been attempted on each channel, pausing + * status, etc. + */ +static int MCD_chStatus[NCHANNELS] = +{ + MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, + MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, + MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, + MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA +}; + +/* + * Prototypes for local functions + */ +static void MCD_memcpy (int *dest, int *src, u32 size); +static void MCD_resmActions (int channel); + +/* + * Buffer descriptors used for storage of progress info for single Dmas + * Also used as storage for the DMA for CRCs for single DMAs + * Otherwise, the DMA does not parse these buffer descriptors + */ +#ifdef MCD_INCLUDE_EU +extern MCD_bufDesc MCD_singleBufDescs[NCHANNELS]; +#else +MCD_bufDesc MCD_singleBufDescs[NCHANNELS]; +#endif +MCD_bufDesc *MCD_relocBuffDesc; + + +/* + * Defines for the debug control register's functions + */ +#define DBG_CTL_COMP1_TASK (0x00002000) /* have comparator 1 look for a task # */ +#define DBG_CTL_ENABLE (DBG_CTL_AUTO_ARM | \ + DBG_CTL_BREAK | \ + DBG_CTL_INT_BREAK | \ + DBG_CTL_COMP1_TASK) +#define DBG_CTL_DISABLE (DBG_CTL_AUTO_ARM | \ + DBG_CTL_INT_BREAK | \ + DBG_CTL_COMP1_TASK) +#define DBG_KILL_ALL_STAT (0xFFFFFFFF) + +/* + * Offset to context save area where progress info is stored + */ +#define CSAVE_OFFSET 10 + +/* + * Defines for Byte Swapping + */ +#define MCD_BYTE_SWAP_KILLER 0xFFF8888F +#define MCD_NO_BYTE_SWAP_ATALL 0x00040000 + +/* + * Execution Unit Identifiers + */ +#define MAC 0 /* legacy - not used */ +#define LUAC 1 /* legacy - not used */ +#define CRC 2 /* legacy - not used */ +#define LURC 3 /* Logic Unit with CRC */ + +/* + * Task Identifiers + */ +#define TASK_CHAINNOEU 0 +#define TASK_SINGLENOEU 1 +#ifdef MCD_INCLUDE_EU +#define TASK_CHAINEU 2 +#define TASK_SINGLEEU 3 +#define TASK_FECRX 4 +#define TASK_FECTX 5 +#else +#define TASK_CHAINEU 0 +#define TASK_SINGLEEU 1 +#define TASK_FECRX 2 +#define TASK_FECTX 3 +#endif + +/* + * Structure to remember which variant is on which channel + * TBD- need this? + */ +typedef struct MCD_remVariants_struct MCD_remVariant; +struct MCD_remVariants_struct +{ + int remDestRsdIncr[NCHANNELS]; /* -1,0,1 */ + int remSrcRsdIncr[NCHANNELS]; /* -1,0,1 */ + s16 remDestIncr[NCHANNELS]; /* DestIncr */ + s16 remSrcIncr[NCHANNELS]; /* srcIncr */ + u32 remXferSize[NCHANNELS]; /* xferSize */ +}; + +/* + * Structure to remember the startDma parameters for each channel + */ +MCD_remVariant MCD_remVariants; +/********************************************************************/ +/* + * Function: MCD_initDma + * Purpose: Initializes the DMA API by setting up a pointer to the DMA + * registers, relocating and creating the appropriate task + * structures, and setting up some global settings + * Arguments: + * dmaBarAddr - pointer to the multichannel DMA registers + * taskTableDest - location to move DMA task code and structs to + * flags - operational parameters + * Return Value: + * MCD_TABLE_UNALIGNED if taskTableDest is not 512-byte aligned + * MCD_OK otherwise + */ +extern u32 MCD_funcDescTab0[]; + +int MCD_initDma (dmaRegs *dmaBarAddr, void *taskTableDest, u32 flags) +{ + int i; + TaskTableEntry *entryPtr; + + /* setup the local pointer to register set */ + MCD_dmaBar = dmaBarAddr; + + /* do we need to move/create a task table */ + if ((flags & MCD_RELOC_TASKS) != 0) + { + int fixedSize; + u32 *fixedPtr; + /*int *tablePtr = taskTableDest;TBD*/ + int varTabsOffset, funcDescTabsOffset, contextSavesOffset; + int taskDescTabsOffset; + int taskTableSize, varTabsSize, funcDescTabsSize, contextSavesSize; + int taskDescTabSize; + + int i; + + /* check if physical address is aligned on 512 byte boundary */ + if (((u32)taskTableDest & 0x000001ff) != 0) + return(MCD_TABLE_UNALIGNED); + + MCD_taskTable = taskTableDest; /* set up local pointer to task Table */ + + /* + * Create a task table: + * - compute aligned base offsets for variable tables and + * function descriptor tables, then + * - loop through the task table and setup the pointers + * - copy over model task table with the the actual task descriptor + * tables + */ + + taskTableSize = NCHANNELS * sizeof(TaskTableEntry); + /* align variable tables to size */ + varTabsOffset = taskTableSize + (u32)taskTableDest; + if ((varTabsOffset & (VAR_TAB_SIZE - 1)) != 0) + varTabsOffset = (varTabsOffset + VAR_TAB_SIZE) & (~VAR_TAB_SIZE); + /* align function descriptor tables */ + varTabsSize = NCHANNELS * VAR_TAB_SIZE; + funcDescTabsOffset = varTabsOffset + varTabsSize; + + if ((funcDescTabsOffset & (FUNCDESC_TAB_SIZE - 1)) != 0) + funcDescTabsOffset = (funcDescTabsOffset + FUNCDESC_TAB_SIZE) & + (~FUNCDESC_TAB_SIZE); + + funcDescTabsSize = FUNCDESC_TAB_NUM * FUNCDESC_TAB_SIZE; + contextSavesOffset = funcDescTabsOffset + funcDescTabsSize; + contextSavesSize = (NCHANNELS * CONTEXT_SAVE_SIZE); + fixedSize = taskTableSize + varTabsSize + funcDescTabsSize + + contextSavesSize; + + /* zero the thing out */ + fixedPtr = (u32 *)taskTableDest; + for (i = 0;i<(fixedSize/4);i++) + fixedPtr[i] = 0; + + entryPtr = (TaskTableEntry*)MCD_taskTable; + /* set up fixed pointers */ + for (i = 0; i < NCHANNELS; i++) + { + entryPtr[i].varTab = (u32)varTabsOffset; /* update ptr to local value */ + entryPtr[i].FDTandFlags = (u32)funcDescTabsOffset | MCD_TT_FLAGS_DEF; + entryPtr[i].contextSaveSpace = (u32)contextSavesOffset; + varTabsOffset += VAR_TAB_SIZE; +#ifdef MCD_INCLUDE_EU /* if not there is only one, just point to the same one */ + funcDescTabsOffset += FUNCDESC_TAB_SIZE; +#endif + contextSavesOffset += CONTEXT_SAVE_SIZE; + } + /* copy over the function descriptor table */ + for ( i = 0; i < FUNCDESC_TAB_NUM; i++) + { + MCD_memcpy((void*)(entryPtr[i].FDTandFlags & ~MCD_TT_FLAGS_MASK), + (void*)MCD_funcDescTab0, FUNCDESC_TAB_SIZE); + } + + /* copy model task table to where the context saves stuff leaves off*/ + MCD_modelTaskTable = (TaskTableEntry*)contextSavesOffset; + + MCD_memcpy ((void*)MCD_modelTaskTable, (void*)MCD_modelTaskTableSrc, + NUMOFVARIANTS * sizeof(TaskTableEntry)); + + entryPtr = MCD_modelTaskTable; /* point to local version of + model task table */ + taskDescTabsOffset = (u32)MCD_modelTaskTable + + (NUMOFVARIANTS * sizeof(TaskTableEntry)); + + /* copy actual task code and update TDT ptrs in local model task table */ + for (i = 0; i < NUMOFVARIANTS; i++) + { + taskDescTabSize = entryPtr[i].TDTend - entryPtr[i].TDTstart + 4; + MCD_memcpy ((void*)taskDescTabsOffset, (void*)entryPtr[i].TDTstart, taskDescTabSize); + entryPtr[i].TDTstart = (u32)taskDescTabsOffset; + taskDescTabsOffset += taskDescTabSize; + entryPtr[i].TDTend = (u32)taskDescTabsOffset - 4; + } +#ifdef MCD_INCLUDE_EU /* Tack single DMA BDs onto end of code so API controls + where they are since DMA might write to them */ + MCD_relocBuffDesc = (MCD_bufDesc*)(entryPtr[NUMOFVARIANTS - 1].TDTend + 4); +#else /* DMA does not touch them so they can be wherever and we don't need to + waste SRAM on them */ + MCD_relocBuffDesc = MCD_singleBufDescs; +#endif + } + else + { + /* point the would-be relocated task tables and the + buffer descriptors to the ones the linker generated */ + + if (((u32)MCD_realTaskTableSrc & 0x000001ff) != 0) + return(MCD_TABLE_UNALIGNED); + + /* need to add code to make sure that every thing else is aligned properly TBD*/ + /* this is problematic if we init more than once or after running tasks, + need to add variable to see if we have aleady init'd */ + entryPtr = MCD_realTaskTableSrc; + for (i = 0; i < NCHANNELS; i++) + { + if (((entryPtr[i].varTab & (VAR_TAB_SIZE - 1)) != 0) || + ((entryPtr[i].FDTandFlags & (FUNCDESC_TAB_SIZE - 1)) != 0)) + return(MCD_TABLE_UNALIGNED); + } + + MCD_taskTable = MCD_realTaskTableSrc; + MCD_modelTaskTable = MCD_modelTaskTableSrc; + MCD_relocBuffDesc = MCD_singleBufDescs; + } + + + /* Make all channels as totally inactive, and remember them as such: */ + + MCD_dmaBar->taskbar = (u32) MCD_taskTable; + for (i = 0; i < NCHANNELS; i++) + { + MCD_dmaBar->taskControl[i] = 0x0; + MCD_chStatus[i] = MCD_NO_DMA; + } + + /* Set up pausing mechanism to inactive state: */ + MCD_dmaBar->debugComp1 = 0; /* no particular values yet for either comparator registers */ + MCD_dmaBar->debugComp2 = 0; + MCD_dmaBar->debugControl = DBG_CTL_DISABLE; + MCD_dmaBar->debugStatus = DBG_KILL_ALL_STAT; + + /* enable or disable commbus prefetch, really need an ifdef or + something to keep from trying to set this in the 8220 */ + if ((flags & MCD_COMM_PREFETCH_EN) != 0) + MCD_dmaBar->ptdControl &= ~PTD_CTL_COMM_PREFETCH; + else + MCD_dmaBar->ptdControl |= PTD_CTL_COMM_PREFETCH; + + return(MCD_OK); +} +/*********************** End of MCD_initDma() ***********************/ + +/********************************************************************/ +/* Function: MCD_dmaStatus + * Purpose: Returns the status of the DMA on the requested channel + * Arguments: channel - channel number + * Returns: Predefined status indicators + */ +int MCD_dmaStatus (int channel) +{ + u16 tcrValue; + + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + tcrValue = MCD_dmaBar->taskControl[channel]; + if ((tcrValue & TASK_CTL_EN) == 0) + { /* nothing running */ + /* if last reported with task enabled */ + if ( MCD_chStatus[channel] == MCD_RUNNING + || MCD_chStatus[channel] == MCD_IDLE) + MCD_chStatus[channel] = MCD_DONE; + } + else /* something is running */ + { + /* There are three possibilities: paused, running or idle. */ + if ( MCD_chStatus[channel] == MCD_RUNNING + || MCD_chStatus[channel] == MCD_IDLE) + { + MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT; + /* This register is selected to know which initiator is + actually asserted. */ + if ((MCD_dmaBar->ptdDebug >> channel ) & 0x1 ) + MCD_chStatus[channel] = MCD_RUNNING; + else + MCD_chStatus[channel] = MCD_IDLE; + /* do not change the status if it is already paused. */ + } + } + return MCD_chStatus[channel]; +} +/******************** End of MCD_dmaStatus() ************************/ + +/********************************************************************/ +/* Function: MCD_startDma + * Ppurpose: Starts a particular kind of DMA + * Arguments: see below + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + */ + +int MCD_startDma ( + int channel, /* the channel on which to run the DMA */ + s8 *srcAddr, /* the address to move data from, or physical buffer-descriptor address */ + s16 srcIncr, /* the amount to increment the source address per transfer */ + s8 *destAddr, /* the address to move data to */ + s16 destIncr, /* the amount to increment the destination address per transfer */ + u32 dmaSize, /* the number of bytes to transfer independent of the transfer size */ + u32 xferSize, /* the number bytes in of each data movement (1, 2, or 4) */ + u32 initiator, /* what device initiates the DMA */ + int priority, /* priority of the DMA */ + u32 flags, /* flags describing the DMA */ + u32 funcDesc /* a description of byte swapping, bit swapping, and CRC actions */ +#ifdef MCD_NEED_ADDR_TRANS + s8 *srcAddrVirt /* virtual buffer descriptor address TBD*/ +#endif +) +{ + int srcRsdIncr, destRsdIncr; + int *cSave; + short xferSizeIncr; + int tcrCount = 0; +#ifdef MCD_INCLUDE_EU + u32 *realFuncArray; +#endif + + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + /* tbd - need to determine the proper response to a bad funcDesc when not + including EU functions, for now, assign a benign funcDesc, but maybe + should return an error */ +#ifndef MCD_INCLUDE_EU + funcDesc = MCD_FUNC_NOEU1; +#endif + +#ifdef MCD_DEBUG +printf("startDma:Setting up params\n"); +#endif + /* Set us up for task-wise priority. We don't technically need to do this on every start, but + since the register involved is in the same longword as other registers that users are in control + of, setting it more than once is probably preferable. That since the documentation doesn't seem + to be completely consistent about the nature of the PTD control register. */ + MCD_dmaBar->ptdControl |= (u16) 0x8000; +#if 1 /* Not sure what we need to keep here rtm TBD */ + /* Calculate additional parameters to the regular DMA calls. */ + srcRsdIncr = srcIncr < 0 ? -1 : (srcIncr > 0 ? 1 : 0); + destRsdIncr = destIncr < 0 ? -1 : (destIncr > 0 ? 1 : 0); + + xferSizeIncr = (xferSize & 0xffff) | 0x20000000; + + /* Remember for each channel which variant is running. */ + MCD_remVariants.remSrcRsdIncr[channel] = srcRsdIncr; + MCD_remVariants.remDestRsdIncr[channel] = destRsdIncr; + MCD_remVariants.remDestIncr[channel] = destIncr; + MCD_remVariants.remSrcIncr[channel] = srcIncr; + MCD_remVariants.remXferSize[channel] = xferSize; +#endif + + cSave = (int*)(MCD_taskTable[channel].contextSaveSpace) + CSAVE_OFFSET + CURRBD; + +#ifdef MCD_INCLUDE_EU /* may move this to EU specific calls */ + realFuncArray = (u32 *) (MCD_taskTable[channel].FDTandFlags & 0xffffff00); + /* Modify the LURC's normal and byte-residue-loop functions according to parameter. */ + realFuncArray[(LURC*16)] = xferSize == 4 ? + funcDesc : xferSize == 2 ? + funcDesc & 0xfffff00f : funcDesc & 0xffff000f; + realFuncArray[(LURC*16+1)] = (funcDesc & MCD_BYTE_SWAP_KILLER) | MCD_NO_BYTE_SWAP_ATALL; +#endif + /* Write the initiator field in the TCR, and also set the initiator-hold + bit. Note that,due to a hardware quirk, this could collide with an + MDE access to the initiator-register file, so we have to verify that the write + reads back correctly. */ + + MCD_dmaBar->taskControl[channel] = + (initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM; + + while(((MCD_dmaBar->taskControl[channel] & 0x1fff) != + ((initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM)) && + (tcrCount < 1000)) + { + tcrCount++; + /*MCD_dmaBar->ptd_tcr[channel] = (initiator << 8) | 0x0020;*/ + MCD_dmaBar->taskControl[channel] = + (initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM; + } + + MCD_dmaBar->priority[channel] = (u8)priority & PRIORITY_PRI_MASK; + /* should be albe to handle this stuff with only one write to ts reg - tbd */ + if (channel < 8 && channel >= 0) + { + MCD_dmaBar->taskSize0 &= ~(0xf << (7-channel)*4); + MCD_dmaBar->taskSize0 |= (xferSize & 3) << (((7 - channel)*4) + 2); + MCD_dmaBar->taskSize0 |= (xferSize & 3) << ((7 - channel)*4); + } + else + { + MCD_dmaBar->taskSize1 &= ~(0xf << (15-channel)*4); + MCD_dmaBar->taskSize1 |= (xferSize & 3) << (((15 - channel)*4) + 2); + MCD_dmaBar->taskSize1 |= (xferSize & 3) << ((15 - channel)*4); + } + + /* setup task table flags/options which mostly control the line buffers */ + MCD_taskTable[channel].FDTandFlags &= ~MCD_TT_FLAGS_MASK; + MCD_taskTable[channel].FDTandFlags |= (MCD_TT_FLAGS_MASK & flags); + + if (flags & MCD_FECTX_DMA) + { + /* TDTStart and TDTEnd */ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_FECTX].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_FECTX].TDTend; + MCD_startDmaENetXmit(srcAddr, srcAddr, destAddr, MCD_taskTable, channel); + } + else if (flags & MCD_FECRX_DMA) + { + /* TDTStart and TDTEnd */ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_FECRX].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_FECRX].TDTend; + MCD_startDmaENetRcv(srcAddr, srcAddr, destAddr, MCD_taskTable, channel); + } + else if(flags & MCD_SINGLE_DMA) + { + /* this buffer descriptor is used for storing off initial parameters for later + progress query calculation and for the DMA to write the resulting checksum + The DMA does not use this to determine how to operate, that info is passed + with the init routine*/ + MCD_relocBuffDesc[channel].srcAddr = srcAddr; + MCD_relocBuffDesc[channel].destAddr = destAddr; + MCD_relocBuffDesc[channel].lastDestAddr = destAddr; /* definitely not its final value */ + MCD_relocBuffDesc[channel].dmaSize = dmaSize; + MCD_relocBuffDesc[channel].flags = 0; /* not used */ + MCD_relocBuffDesc[channel].csumResult = 0; /* not used */ + MCD_relocBuffDesc[channel].next = 0; /* not used */ + + /* Initialize the progress-querying stuff to show no progress:*/ + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET] = (int)srcAddr; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET] = (int)destAddr; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET] = 0; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET] = + (u32) &(MCD_relocBuffDesc[channel]); + /* tbd - need to keep the user from trying to call the EU routine + when MCD_INCLUDE_EU is not defined */ + if( funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2) + { + /* TDTStart and TDTEnd */ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_SINGLENOEU].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_SINGLENOEU].TDTend; + MCD_startDmaSingleNoEu(srcAddr, srcIncr, destAddr, destIncr, dmaSize, + xferSizeIncr, flags, (int *)&(MCD_relocBuffDesc[channel]), cSave, + MCD_taskTable, channel); + } + else + { + /* TDTStart and TDTEnd */ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_SINGLEEU].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_SINGLEEU].TDTend; + MCD_startDmaSingleEu(srcAddr, srcIncr, destAddr, destIncr, dmaSize, + xferSizeIncr, flags, (int *)&(MCD_relocBuffDesc[channel]), cSave, + MCD_taskTable, channel); + } + } + else + { /* chained DMAS */ + /* Initialize the progress-querying stuff to show no progress:*/ +#if 1 /* (!defined(MCD_NEED_ADDR_TRANS)) */ + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET] + = (int)((MCD_bufDesc*) srcAddr)->srcAddr; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET] + = (int)((MCD_bufDesc*) srcAddr)->destAddr; +#else /* if using address translation, need the virtual addr of the first buffdesc */ + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET] + = (int)((MCD_bufDesc*) srcAddrVirt)->srcAddr; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET] + = (int)((MCD_bufDesc*) srcAddrVirt)->destAddr; +#endif + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET] = 0; + ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET] = (u32) srcAddr; + + if( funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2) + { + /*TDTStart and TDTEnd*/ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_CHAINNOEU].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_CHAINNOEU].TDTend; + MCD_startDmaChainNoEu((int *)srcAddr, srcIncr, destIncr, xferSize, + xferSizeIncr, cSave, MCD_taskTable, channel); + } + else + { + /*TDTStart and TDTEnd*/ + MCD_taskTable[channel].TDTstart = MCD_modelTaskTable[TASK_CHAINEU].TDTstart; + MCD_taskTable[channel].TDTend = MCD_modelTaskTable[TASK_CHAINEU].TDTend; + MCD_startDmaChainEu((int *)srcAddr, srcIncr, destIncr, xferSize, + xferSizeIncr, cSave, MCD_taskTable, channel); + } + } + MCD_chStatus[channel] = MCD_IDLE; + return(MCD_OK); +} + +/************************ End of MCD_startDma() *********************/ + +/********************************************************************/ +/* Function: MCD_XferProgrQuery + * Purpose: Returns progress of DMA on requested channel + * Arguments: channel - channel to retrieve progress for + * progRep - pointer to user supplied MCD_XferProg struct + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + * + * Notes: + * MCD_XferProgrQuery() upon completing or after aborting a DMA, or + * while the DMA is in progress, this function returns the first + * DMA-destination address not (or not yet) used in the DMA. When + * encountering a non-ready buffer descriptor, the information for + * the last completed descriptor is returned. + * + * MCD_XferProgQuery() has to avoid the possibility of getting + * partially-updated information in the event that we should happen + * to query DMA progress just as the DMA is updating it. It does that + * by taking advantage of the fact context is not saved frequently for + * the most part. We therefore read it at least twice until we get the + * same information twice in a row. + * + * Because a small, but not insignificant, amount of time is required + * to write out the progress-query information, especially upon + * completion of the DMA, it would be wise to guarantee some time lag + * between successive readings of the progress-query information. + */ + +/* + * How many iterations of the loop below to execute to stabilize values + */ +#define STABTIME 0 + +int MCD_XferProgrQuery (int channel, MCD_XferProg *progRep) +{ + MCD_XferProg prevRep; + int again; /* true if we are to try again to get consistent results */ + int i; /* used as a time-waste counter */ + int destDiffBytes; /* Total number of bytes that we think actually got xfered. */ + int numIterations; /* number of iterations */ + int bytesNotXfered; /* bytes that did not get xfered. */ + s8 *LWAlignedInitDestAddr, *LWAlignedCurrDestAddr; + int subModVal, addModVal; /* Mode values to added and subtracted from the + final destAddr */ + + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + /* Read a trial value for the progress-reporting values*/ + prevRep.lastSrcAddr = + (s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET]; + prevRep.lastDestAddr = + (s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET]; + prevRep.dmaSize = ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET]; + prevRep.currBufDesc = + (MCD_bufDesc*) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET]; + /* Repeatedly reread those values until they match previous values: */ + do { + /* Waste a little bit of time to ensure stability: */ + for (i = 0; i < STABTIME; i++) + i += i >> 2; /* make sure this loop does something so that it doesn't get optimized out */ + /* Check them again: */ + progRep->lastSrcAddr = + (s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[SRCPTR + CSAVE_OFFSET]; + progRep->lastDestAddr = + (s8 *) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DESTPTR + CSAVE_OFFSET]; + progRep->dmaSize = ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[DCOUNT + CSAVE_OFFSET]; + progRep->currBufDesc = + (MCD_bufDesc*) ((volatile int*) MCD_taskTable[channel].contextSaveSpace)[CURRBD + CSAVE_OFFSET]; + /* See if they match: */ + if ( prevRep.lastSrcAddr != progRep->lastSrcAddr + || prevRep.lastDestAddr != progRep->lastDestAddr + || prevRep.dmaSize != progRep->dmaSize + || prevRep.currBufDesc != progRep->currBufDesc) + { + /* If they don't match, remember previous values and try again:*/ + prevRep.lastSrcAddr = progRep->lastSrcAddr; + prevRep.lastDestAddr = progRep->lastDestAddr; + prevRep.dmaSize = progRep->dmaSize; + prevRep.currBufDesc = progRep->currBufDesc; + again = MCD_TRUE; + } + else + again = MCD_FALSE; + } while (again == MCD_TRUE); + + + /* Update the dCount, srcAddr and destAddr */ + /* To calculate dmaCount, we consider destination address. C + overs M1,P1,Z for destination */ + switch(MCD_remVariants.remDestRsdIncr[channel]) { + case MINUS1: + subModVal = ((int)progRep->lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) - 1); + addModVal = ((int)progRep->currBufDesc->destAddr) & ((MCD_remVariants.remXferSize[channel]) - 1); + LWAlignedInitDestAddr = (progRep->currBufDesc->destAddr) - addModVal; + LWAlignedCurrDestAddr = (progRep->lastDestAddr) - subModVal; + destDiffBytes = LWAlignedInitDestAddr - LWAlignedCurrDestAddr; + bytesNotXfered = (destDiffBytes/MCD_remVariants.remDestIncr[channel]) * + ( MCD_remVariants.remDestIncr[channel] + + MCD_remVariants.remXferSize[channel]); + progRep->dmaSize = destDiffBytes - bytesNotXfered + addModVal - subModVal; + break; + case ZERO: + progRep->lastDestAddr = progRep->currBufDesc->destAddr; + break; + case PLUS1: + /* This value has to be subtracted from the final calculated dCount. */ + subModVal = ((int)progRep->currBufDesc->destAddr) & ((MCD_remVariants.remXferSize[channel]) - 1); + /* These bytes are already in lastDestAddr. */ + addModVal = ((int)progRep->lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) - 1); + LWAlignedInitDestAddr = (progRep->currBufDesc->destAddr) - subModVal; + LWAlignedCurrDestAddr = (progRep->lastDestAddr) - addModVal; + destDiffBytes = (progRep->lastDestAddr - LWAlignedInitDestAddr); + numIterations = ( LWAlignedCurrDestAddr - LWAlignedInitDestAddr)/MCD_remVariants.remDestIncr[channel]; + bytesNotXfered = numIterations * + ( MCD_remVariants.remDestIncr[channel] + - MCD_remVariants.remXferSize[channel]); + progRep->dmaSize = destDiffBytes - bytesNotXfered - subModVal; + break; + default: + break; + } + + /* This covers M1,P1,Z for source */ + switch(MCD_remVariants.remSrcRsdIncr[channel]) { + case MINUS1: + progRep->lastSrcAddr = + progRep->currBufDesc->srcAddr + + ( MCD_remVariants.remSrcIncr[channel] * + (progRep->dmaSize/MCD_remVariants.remXferSize[channel])); + break; + case ZERO: + progRep->lastSrcAddr = progRep->currBufDesc->srcAddr; + break; + case PLUS1: + progRep->lastSrcAddr = + progRep->currBufDesc->srcAddr + + ( MCD_remVariants.remSrcIncr[channel] * + (progRep->dmaSize/MCD_remVariants.remXferSize[channel])); + break; + default: break; + } + + return(MCD_OK); +} +/******************* End of MCD_XferProgrQuery() ********************/ + +/********************************************************************/ +/* MCD_resmActions() does the majority of the actions of a DMA resume. + * It is called from MCD_killDma() and MCD_resumeDma(). It has to be + * a separate function because the kill function has to negate the task + * enable before resuming it, but the resume function has to do nothing + * if there is no DMA on that channel (i.e., if the enable bit is 0). + */ +static void MCD_resmActions (int channel) +{ + MCD_dmaBar->debugControl = DBG_CTL_DISABLE; + MCD_dmaBar->debugStatus = MCD_dmaBar->debugStatus; + MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT; /* This register is selected to know + which initiator is actually asserted. */ + if((MCD_dmaBar->ptdDebug >> channel ) & 0x1) + MCD_chStatus[channel] = MCD_RUNNING; + else + MCD_chStatus[channel] = MCD_IDLE; +} +/********************* End of MCD_resmActions() *********************/ + +/********************************************************************/ +/* Function: MCD_killDma + * Purpose: Halt the DMA on the requested channel, without any + * intention of resuming the DMA. + * Arguments: channel - requested channel + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + * + * Notes: + * A DMA may be killed from any state, including paused state, and it + * always goes to the MCD_HALTED state even if it is killed while in + * the MCD_NO_DMA or MCD_IDLE states. + */ +int MCD_killDma (int channel) +{ + /* MCD_XferProg progRep; */ + + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + MCD_dmaBar->taskControl[channel] = 0x0; + MCD_resumeDma (channel); + /* + * This must be after the write to the TCR so that the task doesn't + * start up again momentarily, and before the status assignment so + * as to override whatever MCD_resumeDma() may do to the channel + * status. + */ + MCD_chStatus[channel] = MCD_HALTED; + + /* + * Update the current buffer descriptor's lastDestAddr field + * + * MCD_XferProgrQuery (channel, &progRep); + * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr; + */ + return(MCD_OK); +} +/************************ End of MCD_killDma() **********************/ + +/********************************************************************/ +/* Function: MCD_continDma + * Purpose: Continue a DMA which as stopped due to encountering an + * unready buffer descriptor. + * Arguments: channel - channel to continue the DMA on + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + * + * Notes: + * This routine does not check to see if there is a task which can + * be continued. Also this routine should not be used with single DMAs. + */ +int MCD_continDma (int channel) +{ + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + MCD_dmaBar->taskControl[channel] |= TASK_CTL_EN; + MCD_chStatus[channel] = MCD_RUNNING; + + return(MCD_OK); +} +/********************** End of MCD_continDma() **********************/ + +/********************************************************************* + * MCD_pauseDma() and MCD_resumeDma() below use the DMA's debug unit + * to freeze a task and resume it. We freeze a task by breakpointing + * on the stated task. That is, not any specific place in the task, + * but any time that task executes. In particular, when that task + * executes, we want to freeze that task and only that task. + * + * The bits of the debug control register influence interrupts vs. + * breakpoints as follows: + * - Bits 14 and 0 enable or disable debug functions. If enabled, you + * will get the interrupt but you may or may not get a breakpoint. + * - Bits 2 and 1 decide whether you also get a breakpoint in addition + * to an interrupt. + * + * The debug unit can do these actions in response to either internally + * detected breakpoint conditions from the comparators, or in response + * to the external breakpoint pin, or both. + * - Bits 14 and 1 perform the above-described functions for + * internally-generated conditions, i.e., the debug comparators. + * - Bits 0 and 2 perform the above-described functions for external + * conditions, i.e., the breakpoint external pin. + * + * Note that, although you "always" get the interrupt when you turn + * the debug functions, the interrupt can nevertheless, if desired, be + * masked by the corresponding bit in the PTD's IMR. Note also that + * this means that bits 14 and 0 must enable debug functions before + * bits 1 and 2, respectively, have any effect. + * + * NOTE: It's extremely important to not pause more than one DMA channel + * at a time. + ********************************************************************/ + +/********************************************************************/ +/* Function: MCD_pauseDma + * Purpose: Pauses the DMA on a given channel (if any DMA is running + * on that channel). + * Arguments: channel + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + */ +int MCD_pauseDma (int channel) +{ + /* MCD_XferProg progRep; */ + + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + if (MCD_dmaBar->taskControl[channel] & TASK_CTL_EN) + { + MCD_dmaBar->debugComp1 = channel; + MCD_dmaBar->debugControl = DBG_CTL_ENABLE | (1 << (channel + 16)); + MCD_chStatus[channel] = MCD_PAUSED; + + /* + * Update the current buffer descriptor's lastDestAddr field + * + * MCD_XferProgrQuery (channel, &progRep); + * progRep.currBufDesc->lastDestAddr = progRep.lastDestAddr; + */ + } + return(MCD_OK); +} +/************************* End of MCD_pauseDma() ********************/ + +/********************************************************************/ +/* Function: MCD_resumeDma + * Purpose: Resumes the DMA on a given channel (if any DMA is + * running on that channel). + * Arguments: channel - channel on which to resume DMA + * Returns: MCD_CHANNEL_INVALID if channel is invalid, else MCD_OK + */ +int MCD_resumeDma (int channel) +{ + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + if (MCD_dmaBar->taskControl[channel] & TASK_CTL_EN) + MCD_resmActions (channel); + + return(MCD_OK); +} +/************************ End of MCD_resumeDma() ********************/ + +/********************************************************************/ +/* Function: MCD_csumQuery + * Purpose: Provide the checksum after performing a non-chained DMA + * Arguments: channel - channel to report on + * csum - pointer to where to write the checksum/CRC + * Returns: MCD_ERROR if the channel is invalid, else MCD_OK + * + * Notes: + * + */ +int MCD_csumQuery (int channel, u32 *csum) +{ +#ifdef MCD_INCLUDE_EU + if((channel < 0) || (channel >= NCHANNELS)) + return(MCD_CHANNEL_INVALID); + + *csum = MCD_relocBuffDesc[channel].csumResult; + return(MCD_OK); +#else + return(MCD_ERROR); +#endif +} +/*********************** End of MCD_resumeDma() *********************/ + +/********************************************************************/ +/* Function: MCD_getCodeSize + * Purpose: Provide the size requirements of the microcoded tasks + * Returns: Size in bytes + */ +int MCD_getCodeSize(void) +{ +#ifdef MCD_INCLUDE_EU + return(0x2b5c); +#else + return(0x173c); +#endif +} +/********************** End of MCD_getCodeSize() ********************/ + +/********************************************************************/ +/* Function: MCD_getVersion + * Purpose: Provide the version string and number + * Arguments: longVersion - user supplied pointer to a pointer to a char + * which points to the version string + * Returns: Version number and version string (by reference) + */ +char MCD_versionString[] = "Multi-channel DMA API Alpha v0.3 (2004-04-26)"; +#define MCD_REV_MAJOR 0x00 +#define MCD_REV_MINOR 0x03 + +int MCD_getVersion(char **longVersion) +{ + *longVersion = MCD_versionString; + return((MCD_REV_MAJOR << 8) | MCD_REV_MINOR); +} +/********************** End of MCD_getVersion() *********************/ + +/********************************************************************/ +/* Private version of memcpy() + * Note that everything this is used for is longword-aligned. + */ +static void MCD_memcpy (int *dest, int *src, u32 size) +{ + u32 i; + + for (i = 0; i < size; i += sizeof(int), dest++, src++) + *dest = *src; +} +/********************************************************************/ diff --git a/sources/MCD_tasks.c b/sources/MCD_tasks.c new file mode 100644 index 0000000..76e8e37 --- /dev/null +++ b/sources/MCD_tasks.c @@ -0,0 +1,2449 @@ +/* + * File: MCD_tasks.c + * Purpose: Contains task code and structures for Multi-channel DMA + * + * Notes: + */ + +#include "MCD_dma.h" + +u32 MCD_varTab0[]; +u32 MCD_varTab1[]; +u32 MCD_varTab2[]; +u32 MCD_varTab3[]; +u32 MCD_varTab4[]; +u32 MCD_varTab5[]; +u32 MCD_varTab6[]; +u32 MCD_varTab7[]; +u32 MCD_varTab8[]; +u32 MCD_varTab9[]; +u32 MCD_varTab10[]; +u32 MCD_varTab11[]; +u32 MCD_varTab12[]; +u32 MCD_varTab13[]; +u32 MCD_varTab14[]; +u32 MCD_varTab15[]; + +u32 MCD_funcDescTab0[]; +#ifdef MCD_INCLUDE_EU +u32 MCD_funcDescTab1[]; +u32 MCD_funcDescTab2[]; +u32 MCD_funcDescTab3[]; +u32 MCD_funcDescTab4[]; +u32 MCD_funcDescTab5[]; +u32 MCD_funcDescTab6[]; +u32 MCD_funcDescTab7[]; +u32 MCD_funcDescTab8[]; +u32 MCD_funcDescTab9[]; +u32 MCD_funcDescTab10[]; +u32 MCD_funcDescTab11[]; +u32 MCD_funcDescTab12[]; +u32 MCD_funcDescTab13[]; +u32 MCD_funcDescTab14[]; +u32 MCD_funcDescTab15[]; +#endif + +u32 MCD_contextSave0[]; +u32 MCD_contextSave1[]; +u32 MCD_contextSave2[]; +u32 MCD_contextSave3[]; +u32 MCD_contextSave4[]; +u32 MCD_contextSave5[]; +u32 MCD_contextSave6[]; +u32 MCD_contextSave7[]; +u32 MCD_contextSave8[]; +u32 MCD_contextSave9[]; +u32 MCD_contextSave10[]; +u32 MCD_contextSave11[]; +u32 MCD_contextSave12[]; +u32 MCD_contextSave13[]; +u32 MCD_contextSave14[]; +u32 MCD_contextSave15[]; + +u32 MCD_realTaskTableSrc[] = +{ + 0x00000000, + 0x00000000, + (u32)MCD_varTab0, /* Task 0 Variable Table */ + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ + 0x00000000, + 0x00000000, + (u32)MCD_contextSave0, /* Task 0 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab1, /* Task 1 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab1, /* Task 1 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave1, /* Task 1 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab2, /* Task 2 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab2, /* Task 2 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave2, /* Task 2 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab3, /* Task 3 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab3, /* Task 3 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave3, /* Task 3 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab4, /* Task 4 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab4, /* Task 4 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave4, /* Task 4 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab5, /* Task 5 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab5, /* Task 5 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave5, /* Task 5 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab6, /* Task 6 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab6, /* Task 6 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave6, /* Task 6 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab7, /* Task 7 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab7, /* Task 7 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave7, /* Task 7 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab8, /* Task 8 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab8, /* Task 8 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave8, /* Task 8 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab9, /* Task 9 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab9, /* Task 9 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave9, /* Task 9 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab10, /* Task 10 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab10, /* Task 10 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave10, /* Task 10 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab11, /* Task 11 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab11, /* Task 11 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave11, /* Task 11 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab12, /* Task 12 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab12, /* Task 12 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave12, /* Task 12 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab13, /* Task 13 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab13, /* Task 13 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave13, /* Task 13 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab14, /* Task 14 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab14, /* Task 14 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave14, /* Task 14 context save space */ + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_varTab15, /* Task 15 Variable Table */ +#ifdef MCD_INCLUDE_EU + (u32)MCD_funcDescTab15, /* Task 15 Function Descriptor Table & Flags */ +#else + (u32)MCD_funcDescTab0, /* Task 0 Function Descriptor Table & Flags */ +#endif + 0x00000000, + 0x00000000, + (u32)MCD_contextSave15, /* Task 15 context save space */ + 0x00000000, +}; + + +u32 MCD_varTab0[] = +{ /* Task 0 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + + +u32 MCD_varTab1[] = +{ /* Task 1 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab2[]= +{ /* Task 2 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab3[]= +{ /* Task 3 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab4[]= +{ /* Task 4 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab5[]= +{ /* Task 5 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab6[]= +{ /* Task 6 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab7[]= +{ /* Task 7 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab8[]= +{ /* Task 8 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab9[]= +{ /* Task 9 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab10[]= +{ /* Task 10 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab11[]= +{ /* Task 11 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab12[]= +{ /* Task 12 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab13[]= +{ /* Task 13 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab14[]= +{ /* Task 14 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_varTab15[]= +{ /* Task 15 Variable Table */ + 0x00000000, /* var[0] */ + 0x00000000, /* var[1] */ + 0x00000000, /* var[2] */ + 0x00000000, /* var[3] */ + 0x00000000, /* var[4] */ + 0x00000000, /* var[5] */ + 0x00000000, /* var[6] */ + 0x00000000, /* var[7] */ + 0x00000000, /* var[8] */ + 0x00000000, /* var[9] */ + 0x00000000, /* var[10] */ + 0x00000000, /* var[11] */ + 0x00000000, /* var[12] */ + 0x00000000, /* var[13] */ + 0x00000000, /* var[14] */ + 0x00000000, /* var[15] */ + 0x00000000, /* var[16] */ + 0x00000000, /* var[17] */ + 0x00000000, /* var[18] */ + 0x00000000, /* var[19] */ + 0x00000000, /* var[20] */ + 0x00000000, /* var[21] */ + 0x00000000, /* var[22] */ + 0x00000000, /* var[23] */ + 0xe0000000, /* inc[0] */ + 0x20000000, /* inc[1] */ + 0x2000ffff, /* inc[2] */ + 0x00000000, /* inc[3] */ + 0x00000000, /* inc[4] */ + 0x00000000, /* inc[5] */ + 0x00000000, /* inc[6] */ + 0x00000000, /* inc[7] */ +}; + +u32 MCD_funcDescTab0[]= +{ /* Task 0 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +#ifdef MCD_INCLUDE_EU +u32 MCD_funcDescTab1[]= +{ /* Task 1 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab2[]= +{ /* Task 2 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab3[]= +{ /* Task 3 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab4[]= +{ /* Task 4 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab5[]= +{ /* Task 5 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab6[]= +{ /* Task 6 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab7[]= +{ /* Task 7 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab8[]= +{ /* Task 8 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab9[]= +{ /* Task 9 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab10[]= +{ /* Task 10 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab11[]= +{ /* Task 11 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab12[]= +{ /* Task 12 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab13[]= +{ /* Task 13 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab14[]= +{ /* Task 14 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; + +u32 MCD_funcDescTab15[]= +{ /* Task 15 Function Descriptor Table */ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0xa0045670, /* mainFunc(), EU# 3 */ + 0xa0000000, /* rsduFunc(), EU# 3 */ + 0xa0000000, /* crcAccumVal(), EU# 3 */ + 0x20000000, /* setCrcAccum(), EU# 3 */ + 0x21800000, /* and(), EU# 3 */ + 0x21e00000, /* or(), EU# 3 */ + 0x20400000, /* add(), EU# 3 */ + 0x20500000, /* sub(), EU# 3 */ + 0x205a0000, /* andNot(), EU# 3 */ + 0x20a00000, /* shiftR(), EU# 3 */ + 0x202fa000, /* andReadyBit(), EU# 3 */ + 0x202f9000, /* andNotReadyBit(), EU# 3 */ + 0x202ea000, /* andWrapBit(), EU# 3 */ + 0x202da000, /* andLastBit(), EU# 3 */ + 0x202e2000, /* andInterruptBit(), EU# 3 */ + 0x202f2000, /* andCrcRestartBit(), EU# 3 */ +}; +#endif /*MCD_INCLUDE_EU*/ + +u32 MCD_contextSave0[128]; /* Task 0 context save space */ +u32 MCD_contextSave1[128]; /* Task 1 context save space */ +u32 MCD_contextSave2[128]; /* Task 2 context save space */ +u32 MCD_contextSave3[128]; /* Task 3 context save space */ +u32 MCD_contextSave4[128]; /* Task 4 context save space */ +u32 MCD_contextSave5[128]; /* Task 5 context save space */ +u32 MCD_contextSave6[128]; /* Task 6 context save space */ +u32 MCD_contextSave7[128]; /* Task 7 context save space */ +u32 MCD_contextSave8[128]; /* Task 8 context save space */ +u32 MCD_contextSave9[128]; /* Task 9 context save space */ +u32 MCD_contextSave10[128]; /* Task 10 context save space */ +u32 MCD_contextSave11[128]; /* Task 11 context save space */ +u32 MCD_contextSave12[128]; /* Task 12 context save space */ +u32 MCD_contextSave13[128]; /* Task 13 context save space */ +u32 MCD_contextSave14[128]; /* Task 14 context save space */ +u32 MCD_contextSave15[128]; /* Task 15 context save space */ + + +u32 MCD_ChainNoEu_TDT[]; +u32 MCD_SingleNoEu_TDT[]; +#ifdef MCD_INCLUDE_EU +u32 MCD_ChainEu_TDT[]; +u32 MCD_SingleEu_TDT[]; +#endif +u32 MCD_ENetRcv_TDT[]; +u32 MCD_ENetXmit_TDT[]; + +u32 MCD_modelTaskTableSrc[]= +{ + (u32)MCD_ChainNoEu_TDT, + (u32)&((u8*)MCD_ChainNoEu_TDT)[0x0000016c], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_SingleNoEu_TDT, + (u32)&((u8*)MCD_SingleNoEu_TDT)[0x000000d4], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, +#ifdef MCD_INCLUDE_EU + (u32)MCD_ChainEu_TDT, + (u32)&((u8*)MCD_ChainEu_TDT)[0x000001b4], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_SingleEu_TDT, + (u32)&((u8*)MCD_SingleEu_TDT)[0x00000124], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, +#endif + (u32)MCD_ENetRcv_TDT, + (u32)&((u8*)MCD_ENetRcv_TDT)[0x0000009c], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + (u32)MCD_ENetXmit_TDT, + (u32)&((u8*)MCD_ENetXmit_TDT)[0x000000d0], + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, +}; +u32 MCD_ChainNoEu_TDT[]= +{ + 0x80004000, /* 0000(:370): LCDEXT: idx0 = 0x00000000; ; */ + 0x8118801b, /* 0004(:370): LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */ + 0xb8c60018, /* 0008(:371): LCD: idx2 = *(idx1 + var12); idx2 once var0; idx2 += inc3 */ + 0x10002b10, /* 000C(:372): DRD1A: var10 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x7000000d, /* 0010(:373): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x018cf89f, /* 0014(:373): DRD2B1: var6 = EU3(); EU3(idx2) */ + 0x6000000a, /* 0018(:374): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf89f, /* 001C(:374): DRD2B1: idx0 = EU3(); EU3(idx2) */ + 0x000001f8, /* 0020(:0): NOP */ + 0x98180364, /* 0024(:378): LCD: idx0 = idx0; idx0 == var13; idx0 += inc4 */ + 0x8118801b, /* 0028(:380): LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */ + 0xf8c6001a, /* 002C(:381): LCDEXT: idx2 = *(idx1 + var12 + 8); idx2 once var0; idx2 += inc3 */ + 0xb8c6601b, /* 0030(:382): LCD: idx3 = *(idx1 + var12 + 12); ; idx3 += inc3 */ + 0x10002710, /* 0034(:384): DRD1A: var9 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x00000f18, /* 0038(:385): DRD1A: var3 = idx3; FN=0 init=0 WS=0 RS=0 */ + 0xb8c6001d, /* 003C(:387): LCD: idx2 = *(idx1 + var12 + 20); idx2 once var0; idx2 += inc3 */ + 0x10001310, /* 0040(:388): DRD1A: var4 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x60000007, /* 0044(:389): DRD2A: EU0=0 EU1=0 EU2=0 EU3=7 EXT init=0 WS=0 RS=0 */ + 0x014cf88b, /* 0048(:389): DRD2B1: var5 = EU3(); EU3(idx2,var11) */ + 0x98c6001c, /* 004C(:391): LCD: idx2 = idx1 + var12 + 4; idx2 once var0; idx2 += inc3 */ + 0x00000710, /* 0050(:392): DRD1A: var1 = idx2; FN=0 init=0 WS=0 RS=0 */ + 0x98c70018, /* 0054(:393): LCD: idx2 = idx1 + var14; idx2 once var0; idx2 += inc3 */ + 0x10001f10, /* 0058(:394): DRD1A: var7 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c818, /* 005C(:395): DRD1A: *idx2 = var3; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 0060(:0): NOP */ + 0xc1476018, /* 0064(:399): LCDEXT: idx1 = var2 + var14; ; idx1 += inc3 */ + 0xc003231d, /* 0068(:399): LCDEXT: idx2 = var0, idx3 = var6; idx3 == var12; idx2 += inc3, idx3 += inc5 */ + 0x811a601b, /* 006C(:400): LCD: idx4 = var2; ; idx4 += inc3 */ + 0xc1862102, /* 0070(:403): LCDEXT: idx5 = var3, idx6 = var12; idx6 < var4; idx5 += inc0, idx6 += inc2 */ + 0x849be009, /* 0074(:403): LCD: idx7 = var9; ; idx7 += inc1 */ + 0x03fed7b8, /* 0078(:406): DRD1A: *idx7; FN=0 init=31 WS=3 RS=3 */ + 0xda9b001b, /* 007C(:408): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 0080(:408): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x1000cb20, /* 0084(:409): DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0088(:410): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 008C(:410): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb28, /* 0090(:411): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0094(:412): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 0098(:412): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb30, /* 009C(:413): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00A0(:414): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 00A4(:414): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb38, /* 00A8(:415): DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c728, /* 00AC(:416): DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 00B0(:0): NOP */ + 0xc1476018, /* 00B4(:420): LCDEXT: idx1 = var2 + var14; ; idx1 += inc3 */ + 0xc003241d, /* 00B8(:420): LCDEXT: idx2 = var0, idx3 = var6; idx3 == var16; idx2 += inc3, idx3 += inc5 */ + 0x811a601b, /* 00BC(:421): LCD: idx4 = var2; ; idx4 += inc3 */ + 0xda9b001b, /* 00C0(:424): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00C4(:424): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x0000d3a0, /* 00C8(:425): DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */ + 0xc1862102, /* 00CC(:427): LCDEXT: idx5 = var3, idx6 = var12; idx6 < var4; idx5 += inc0, idx6 += inc2 */ + 0x849be009, /* 00D0(:427): LCD: idx7 = var9; ; idx7 += inc1 */ + 0x0bfed7b8, /* 00D4(:430): DRD1A: *idx7; FN=0 TFD init=31 WS=3 RS=3 */ + 0xda9b001b, /* 00D8(:432): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00DC(:432): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x1000cb20, /* 00E0(:433): DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00E4(:434): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 00E8(:434): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb28, /* 00EC(:435): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00F0(:436): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 00F4(:436): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb30, /* 00F8(:437): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00FC(:438): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88f, /* 0100(:438): DRD2B1: idx2 = EU3(); EU3(idx2,var15) */ + 0x1000cb38, /* 0104(:439): DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c728, /* 0108(:440): DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 010C(:0): NOP */ + 0x8118801b, /* 0110(:444): LCD: idx1 = var2; idx1 once var0; idx1 += inc3 */ + 0xd8c60018, /* 0114(:446): LCDEXT: idx2 = idx1 + var12; idx2 once var0; idx2 += inc3 */ + 0x98c6601c, /* 0118(:446): LCD: idx3 = idx1 + var12 + 4; ; idx3 += inc3 */ + 0x6000000b, /* 011C(:447): DRD2A: EU0=0 EU1=0 EU2=0 EU3=11 EXT init=0 WS=0 RS=0 */ + 0x0c8cfc9f, /* 0120(:447): DRD2B1: *idx2 = EU3(); EU3(*idx2) */ + 0x000001f8, /* 0124(:0): NOP */ + 0xa146001e, /* 0128(:450): LCD: idx1 = *(var2 + var12 + 24); idx1 once var0; idx1 += inc3 */ + 0x10000b08, /* 012C(:451): DRD1A: var2 = idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x10002050, /* 0130(:452): DRD1A: var8 = var10; FN=0 MORE init=0 WS=0 RS=0 */ + 0xb8c60018, /* 0134(:453): LCD: idx2 = *(idx1 + var12); idx2 once var0; idx2 += inc3 */ + 0x10002b10, /* 0138(:454): DRD1A: var10 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x7000000a, /* 013C(:455): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT MORE init=0 WS=0 RS=0 */ + 0x080cf89f, /* 0140(:455): DRD2B1: idx0 = EU3(); EU3(idx2) */ + 0x6000000d, /* 0144(:456): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT init=0 WS=0 RS=0 */ + 0x018cf89f, /* 0148(:456): DRD2B1: var6 = EU3(); EU3(idx2) */ + 0x000001f8, /* 014C(:0): NOP */ + 0x8618801b, /* 0150(:462): LCD: idx1 = var12; idx1 once var0; idx1 += inc3 */ + 0x7000000e, /* 0154(:463): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */ + 0x084cf21f, /* 0158(:463): DRD2B1: idx1 = EU3(); EU3(var8) */ + 0xd8990336, /* 015C(:464): LCDEXT: idx2 = idx1; idx2 > var12; idx2 += inc6 */ + 0x8019801b, /* 0160(:464): LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */ + 0x040001f8, /* 0164(:465): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ + 0x000001f8, /* 0168(:0): NOP */ + 0x000001f8, /* 016C(:0): NOP */ +}; +u32 MCD_SingleNoEu_TDT[]= +{ + 0x8198001b, /* 0000(:657): LCD: idx0 = var3; idx0 once var0; idx0 += inc3 */ + 0x7000000d, /* 0004(:658): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x080cf81f, /* 0008(:658): DRD2B1: idx0 = EU3(); EU3(idx0) */ + 0x8198801b, /* 000C(:659): LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */ + 0x6000000e, /* 0010(:660): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */ + 0x084cf85f, /* 0014(:660): DRD2B1: idx1 = EU3(); EU3(idx1) */ + 0x000001f8, /* 0018(:0): NOP */ + 0x8298001b, /* 001C(:664): LCD: idx0 = var5; idx0 once var0; idx0 += inc3 */ + 0x7000000d, /* 0020(:665): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x010cf81f, /* 0024(:665): DRD2B1: var4 = EU3(); EU3(idx0) */ + 0x6000000e, /* 0028(:666): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */ + 0x018cf81f, /* 002C(:666): DRD2B1: var6 = EU3(); EU3(idx0) */ + 0xc202601b, /* 0030(:669): LCDEXT: idx0 = var4, idx1 = var4; ; idx0 += inc3, idx1 += inc3 */ + 0xc002221c, /* 0034(:669): LCDEXT: idx2 = var0, idx3 = var4; idx3 == var8; idx2 += inc3, idx3 += inc4 */ + 0x809a601b, /* 0038(:670): LCD: idx4 = var1; ; idx4 += inc3 */ + 0xc10420c2, /* 003C(:673): LCDEXT: idx5 = var2, idx6 = var8; idx6 < var3; idx5 += inc0, idx6 += inc2 */ + 0x839be009, /* 0040(:673): LCD: idx7 = var7; ; idx7 += inc1 */ + 0x03fed7b8, /* 0044(:676): DRD1A: *idx7; FN=0 init=31 WS=3 RS=3 */ + 0xda9b001b, /* 0048(:678): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 004C(:678): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000006, /* 0050(:680): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 0054(:680): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x1000cb28, /* 0058(:681): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 005C(:682): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 0060(:682): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x1000cb30, /* 0064(:683): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0068(:684): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 006C(:684): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x0000cb38, /* 0070(:685): DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 0074(:0): NOP */ + 0xc202601b, /* 0078(:689): LCDEXT: idx0 = var4, idx1 = var4; ; idx0 += inc3, idx1 += inc3 */ + 0xc002229c, /* 007C(:689): LCDEXT: idx2 = var0, idx3 = var4; idx3 == var10; idx2 += inc3, idx3 += inc4 */ + 0x809a601b, /* 0080(:690): LCD: idx4 = var1; ; idx4 += inc3 */ + 0xda9b001b, /* 0084(:693): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 0088(:693): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x0000d3a0, /* 008C(:694): DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */ + 0xc10420c2, /* 0090(:696): LCDEXT: idx5 = var2, idx6 = var8; idx6 < var3; idx5 += inc0, idx6 += inc2 */ + 0x839be009, /* 0094(:696): LCD: idx7 = var7; ; idx7 += inc1 */ + 0x0bfed7b8, /* 0098(:699): DRD1A: *idx7; FN=0 TFD init=31 WS=3 RS=3 */ + 0xda9b001b, /* 009C(:701): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00A0(:701): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000006, /* 00A4(:703): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 00A8(:703): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x1000cb28, /* 00AC(:704): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00B0(:705): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 00B4(:705): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x1000cb30, /* 00B8(:706): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00BC(:707): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf889, /* 00C0(:707): DRD2B1: idx2 = EU3(); EU3(idx2,var9) */ + 0x0000cb38, /* 00C4(:708): DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 00C8(:0): NOP */ + 0xc318022d, /* 00CC(:712): LCDEXT: idx0 = var6; idx0 > var8; idx0 += inc5 */ + 0x8018801b, /* 00D0(:712): LCD: idx1 = var0; idx1 once var0; idx1 += inc3 */ + 0x040001f8, /* 00D4(:713): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ +}; +#ifdef MCD_INCLUDE_EU +u32 MCD_ChainEu_TDT[]= +{ + 0x80004000, /* 0000(:947): LCDEXT: idx0 = 0x00000000; ; */ + 0x8198801b, /* 0004(:947): LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */ + 0xb8c68018, /* 0008(:948): LCD: idx2 = *(idx1 + var13); idx2 once var0; idx2 += inc3 */ + 0x10002f10, /* 000C(:949): DRD1A: var11 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x7000000d, /* 0010(:950): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x01ccf89f, /* 0014(:950): DRD2B1: var7 = EU3(); EU3(idx2) */ + 0x6000000a, /* 0018(:951): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf89f, /* 001C(:951): DRD2B1: idx0 = EU3(); EU3(idx2) */ + 0x000001f8, /* 0020(:0): NOP */ + 0x981803a4, /* 0024(:955): LCD: idx0 = idx0; idx0 == var14; idx0 += inc4 */ + 0x8198801b, /* 0028(:957): LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */ + 0xf8c6801a, /* 002C(:958): LCDEXT: idx2 = *(idx1 + var13 + 8); idx2 once var0; idx2 += inc3 */ + 0xb8c6e01b, /* 0030(:959): LCD: idx3 = *(idx1 + var13 + 12); ; idx3 += inc3 */ + 0x10002b10, /* 0034(:961): DRD1A: var10 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x00001318, /* 0038(:962): DRD1A: var4 = idx3; FN=0 init=0 WS=0 RS=0 */ + 0xb8c6801d, /* 003C(:964): LCD: idx2 = *(idx1 + var13 + 20); idx2 once var0; idx2 += inc3 */ + 0x10001710, /* 0040(:965): DRD1A: var5 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x60000007, /* 0044(:966): DRD2A: EU0=0 EU1=0 EU2=0 EU3=7 EXT init=0 WS=0 RS=0 */ + 0x018cf88c, /* 0048(:966): DRD2B1: var6 = EU3(); EU3(idx2,var12) */ + 0x98c6801c, /* 004C(:968): LCD: idx2 = idx1 + var13 + 4; idx2 once var0; idx2 += inc3 */ + 0x00000b10, /* 0050(:969): DRD1A: var2 = idx2; FN=0 init=0 WS=0 RS=0 */ + 0x98c78018, /* 0054(:970): LCD: idx2 = idx1 + var15; idx2 once var0; idx2 += inc3 */ + 0x10002310, /* 0058(:971): DRD1A: var8 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c820, /* 005C(:972): DRD1A: *idx2 = var4; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 0060(:0): NOP */ + 0x8698801b, /* 0064(:976): LCD: idx1 = var13; idx1 once var0; idx1 += inc3 */ + 0x7000000f, /* 0068(:977): DRD2A: EU0=0 EU1=0 EU2=0 EU3=15 EXT MORE init=0 WS=0 RS=0 */ + 0x084cf2df, /* 006C(:977): DRD2B1: idx1 = EU3(); EU3(var11) */ + 0xd899042d, /* 0070(:978): LCDEXT: idx2 = idx1; idx2 >= var16; idx2 += inc5 */ + 0x8019801b, /* 0074(:978): LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */ + 0x60000003, /* 0078(:979): DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */ + 0x2cd7c7df, /* 007C(:979): DRD2B2: EU3(var13) */ + 0xd8990364, /* 0080(:980): LCDEXT: idx2 = idx1; idx2 == var13; idx2 += inc4 */ + 0x8019801b, /* 0084(:980): LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */ + 0x60000003, /* 0088(:981): DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */ + 0x2c17c7df, /* 008C(:981): DRD2B2: EU3(var1) */ + 0x000001f8, /* 0090(:0): NOP */ + 0xc1c7e018, /* 0094(:984): LCDEXT: idx1 = var3 + var15; ; idx1 += inc3 */ + 0xc003a35e, /* 0098(:984): LCDEXT: idx2 = var0, idx3 = var7; idx3 == var13; idx2 += inc3, idx3 += inc6 */ + 0x819a601b, /* 009C(:985): LCD: idx4 = var3; ; idx4 += inc3 */ + 0xc206a142, /* 00A0(:988): LCDEXT: idx5 = var4, idx6 = var13; idx6 < var5; idx5 += inc0, idx6 += inc2 */ + 0x851be009, /* 00A4(:988): LCD: idx7 = var10; ; idx7 += inc1 */ + 0x63fe0000, /* 00A8(:991): DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 EXT init=31 WS=3 RS=3 */ + 0x0d4cfddf, /* 00AC(:991): DRD2B1: *idx5 = EU3(); EU3(*idx7) */ + 0xda9b001b, /* 00B0(:993): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00B4(:993): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000002, /* 00B8(:994): DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */ + 0x004cf81f, /* 00BC(:994): DRD2B1: var1 = EU3(); EU3(idx0) */ + 0x1000cb20, /* 00C0(:995): DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00C4(:996): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 00C8(:996): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb28, /* 00CC(:997): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00D0(:998): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 00D4(:998): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb30, /* 00D8(:999): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00DC(:1000): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 00E0(:1000): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb38, /* 00E4(:1001): DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c728, /* 00E8(:1002): DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 00EC(:0): NOP */ + 0xc1c7e018, /* 00F0(:1006): LCDEXT: idx1 = var3 + var15; ; idx1 += inc3 */ + 0xc003a49e, /* 00F4(:1006): LCDEXT: idx2 = var0, idx3 = var7; idx3 == var18; idx2 += inc3, idx3 += inc6 */ + 0x819a601b, /* 00F8(:1007): LCD: idx4 = var3; ; idx4 += inc3 */ + 0xda9b001b, /* 00FC(:1010): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 0100(:1010): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x0000d3a0, /* 0104(:1011): DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */ + 0xc206a142, /* 0108(:1013): LCDEXT: idx5 = var4, idx6 = var13; idx6 < var5; idx5 += inc0, idx6 += inc2 */ + 0x851be009, /* 010C(:1013): LCD: idx7 = var10; ; idx7 += inc1 */ + 0x6bfe0000, /* 0110(:1016): DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 TFD EXT init=31 WS=3 RS=3 */ + 0x0d4cfddf, /* 0114(:1016): DRD2B1: *idx5 = EU3(); EU3(*idx7) */ + 0xda9b001b, /* 0118(:1018): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 011C(:1018): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000002, /* 0120(:1019): DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */ + 0x004cf81f, /* 0124(:1019): DRD2B1: var1 = EU3(); EU3(idx0) */ + 0x1000cb20, /* 0128(:1020): DRD1A: *idx2 = idx4; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 012C(:1021): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 0130(:1021): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb28, /* 0134(:1022): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0138(:1023): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 013C(:1023): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb30, /* 0140(:1024): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0144(:1025): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf891, /* 0148(:1025): DRD2B1: idx2 = EU3(); EU3(idx2,var17) */ + 0x1000cb38, /* 014C(:1026): DRD1A: *idx2 = idx7; FN=0 MORE init=0 WS=0 RS=0 */ + 0x0000c728, /* 0150(:1027): DRD1A: *idx1 = idx5; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 0154(:0): NOP */ + 0x8198801b, /* 0158(:1031): LCD: idx1 = var3; idx1 once var0; idx1 += inc3 */ + 0xd8c68018, /* 015C(:1033): LCDEXT: idx2 = idx1 + var13; idx2 once var0; idx2 += inc3 */ + 0x98c6e01c, /* 0160(:1033): LCD: idx3 = idx1 + var13 + 4; ; idx3 += inc3 */ + 0x6000000b, /* 0164(:1034): DRD2A: EU0=0 EU1=0 EU2=0 EU3=11 EXT init=0 WS=0 RS=0 */ + 0x0c8cfc9f, /* 0168(:1034): DRD2B1: *idx2 = EU3(); EU3(*idx2) */ + 0x0000cc08, /* 016C(:1035): DRD1A: *idx3 = var1; FN=0 init=0 WS=0 RS=0 */ + 0xa1c6801e, /* 0170(:1038): LCD: idx1 = *(var3 + var13 + 24); idx1 once var0; idx1 += inc3 */ + 0x10000f08, /* 0174(:1039): DRD1A: var3 = idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x10002458, /* 0178(:1040): DRD1A: var9 = var11; FN=0 MORE init=0 WS=0 RS=0 */ + 0xb8c68018, /* 017C(:1041): LCD: idx2 = *(idx1 + var13); idx2 once var0; idx2 += inc3 */ + 0x10002f10, /* 0180(:1042): DRD1A: var11 = idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x7000000a, /* 0184(:1043): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT MORE init=0 WS=0 RS=0 */ + 0x080cf89f, /* 0188(:1043): DRD2B1: idx0 = EU3(); EU3(idx2) */ + 0x6000000d, /* 018C(:1044): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT init=0 WS=0 RS=0 */ + 0x01ccf89f, /* 0190(:1044): DRD2B1: var7 = EU3(); EU3(idx2) */ + 0x000001f8, /* 0194(:0): NOP */ + 0x8698801b, /* 0198(:1050): LCD: idx1 = var13; idx1 once var0; idx1 += inc3 */ + 0x7000000e, /* 019C(:1051): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */ + 0x084cf25f, /* 01A0(:1051): DRD2B1: idx1 = EU3(); EU3(var9) */ + 0xd899037f, /* 01A4(:1052): LCDEXT: idx2 = idx1; idx2 > var13; idx2 += inc7 */ + 0x8019801b, /* 01A8(:1052): LCD: idx3 = var0; idx3 once var0; idx3 += inc3 */ + 0x040001f8, /* 01AC(:1053): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ + 0x000001f8, /* 01B0(:0): NOP */ + 0x000001f8, /* 01B4(:0): NOP */ +}; +u32 MCD_SingleEu_TDT[]= +{ + 0x8218001b, /* 0000(:1248): LCD: idx0 = var4; idx0 once var0; idx0 += inc3 */ + 0x7000000d, /* 0004(:1249): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x080cf81f, /* 0008(:1249): DRD2B1: idx0 = EU3(); EU3(idx0) */ + 0x8218801b, /* 000C(:1250): LCD: idx1 = var4; idx1 once var0; idx1 += inc3 */ + 0x6000000e, /* 0010(:1251): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */ + 0x084cf85f, /* 0014(:1251): DRD2B1: idx1 = EU3(); EU3(idx1) */ + 0x000001f8, /* 0018(:0): NOP */ + 0x8318001b, /* 001C(:1255): LCD: idx0 = var6; idx0 once var0; idx0 += inc3 */ + 0x7000000d, /* 0020(:1256): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x014cf81f, /* 0024(:1256): DRD2B1: var5 = EU3(); EU3(idx0) */ + 0x6000000e, /* 0028(:1257): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT init=0 WS=0 RS=0 */ + 0x01ccf81f, /* 002C(:1257): DRD2B1: var7 = EU3(); EU3(idx0) */ + 0x8498001b, /* 0030(:1260): LCD: idx0 = var9; idx0 once var0; idx0 += inc3 */ + 0x7000000f, /* 0034(:1261): DRD2A: EU0=0 EU1=0 EU2=0 EU3=15 EXT MORE init=0 WS=0 RS=0 */ + 0x080cf19f, /* 0038(:1261): DRD2B1: idx0 = EU3(); EU3(var6) */ + 0xd81882a4, /* 003C(:1262): LCDEXT: idx1 = idx0; idx1 >= var10; idx1 += inc4 */ + 0x8019001b, /* 0040(:1262): LCD: idx2 = var0; idx2 once var0; idx2 += inc3 */ + 0x60000003, /* 0044(:1263): DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */ + 0x2c97c7df, /* 0048(:1263): DRD2B2: EU3(var9) */ + 0xd818826d, /* 004C(:1264): LCDEXT: idx1 = idx0; idx1 == var9; idx1 += inc5 */ + 0x8019001b, /* 0050(:1264): LCD: idx2 = var0; idx2 once var0; idx2 += inc3 */ + 0x60000003, /* 0054(:1265): DRD2A: EU0=0 EU1=0 EU2=0 EU3=3 EXT init=0 WS=0 RS=0 */ + 0x2c17c7df, /* 0058(:1265): DRD2B2: EU3(var1) */ + 0x000001f8, /* 005C(:0): NOP */ + 0xc282e01b, /* 0060(:1268): LCDEXT: idx0 = var5, idx1 = var5; ; idx0 += inc3, idx1 += inc3 */ + 0xc002a25e, /* 0064(:1268): LCDEXT: idx2 = var0, idx3 = var5; idx3 == var9; idx2 += inc3, idx3 += inc6 */ + 0x811a601b, /* 0068(:1269): LCD: idx4 = var2; ; idx4 += inc3 */ + 0xc184a102, /* 006C(:1272): LCDEXT: idx5 = var3, idx6 = var9; idx6 < var4; idx5 += inc0, idx6 += inc2 */ + 0x841be009, /* 0070(:1272): LCD: idx7 = var8; ; idx7 += inc1 */ + 0x63fe0000, /* 0074(:1275): DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 EXT init=31 WS=3 RS=3 */ + 0x0d4cfddf, /* 0078(:1275): DRD2B1: *idx5 = EU3(); EU3(*idx7) */ + 0xda9b001b, /* 007C(:1277): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 0080(:1277): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000002, /* 0084(:1279): DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */ + 0x004cf99f, /* 0088(:1279): DRD2B1: var1 = EU3(); EU3(idx6) */ + 0x70000006, /* 008C(:1280): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 0090(:1280): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x1000cb28, /* 0094(:1281): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0098(:1282): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 009C(:1282): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x1000cb30, /* 00A0(:1283): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00A4(:1284): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 00A8(:1284): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x0000cb38, /* 00AC(:1285): DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 00B0(:0): NOP */ + 0xc282e01b, /* 00B4(:1289): LCDEXT: idx0 = var5, idx1 = var5; ; idx0 += inc3, idx1 += inc3 */ + 0xc002a31e, /* 00B8(:1289): LCDEXT: idx2 = var0, idx3 = var5; idx3 == var12; idx2 += inc3, idx3 += inc6 */ + 0x811a601b, /* 00BC(:1290): LCD: idx4 = var2; ; idx4 += inc3 */ + 0xda9b001b, /* 00C0(:1293): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00C4(:1293): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x0000d3a0, /* 00C8(:1294): DRD1A: *idx4; FN=0 init=0 WS=0 RS=0 */ + 0xc184a102, /* 00CC(:1296): LCDEXT: idx5 = var3, idx6 = var9; idx6 < var4; idx5 += inc0, idx6 += inc2 */ + 0x841be009, /* 00D0(:1296): LCD: idx7 = var8; ; idx7 += inc1 */ + 0x6bfe0000, /* 00D4(:1299): DRD2A: EU0=0 EU1=0 EU2=0 EU3=0 TFD EXT init=31 WS=3 RS=3 */ + 0x0d4cfddf, /* 00D8(:1299): DRD2B1: *idx5 = EU3(); EU3(*idx7) */ + 0xda9b001b, /* 00DC(:1301): LCDEXT: idx5 = idx5, idx6 = idx6; idx5 once var0; idx5 += inc3, idx6 += inc3 */ + 0x9b9be01b, /* 00E0(:1301): LCD: idx7 = idx7; ; idx7 += inc3 */ + 0x70000002, /* 00E4(:1303): DRD2A: EU0=0 EU1=0 EU2=0 EU3=2 EXT MORE init=0 WS=0 RS=0 */ + 0x004cf99f, /* 00E8(:1303): DRD2B1: var1 = EU3(); EU3(idx6) */ + 0x70000006, /* 00EC(:1304): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 00F0(:1304): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x1000cb28, /* 00F4(:1305): DRD1A: *idx2 = idx5; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 00F8(:1306): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 00FC(:1306): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x1000cb30, /* 0100(:1307): DRD1A: *idx2 = idx6; FN=0 MORE init=0 WS=0 RS=0 */ + 0x70000006, /* 0104(:1308): DRD2A: EU0=0 EU1=0 EU2=0 EU3=6 EXT MORE init=0 WS=0 RS=0 */ + 0x088cf88b, /* 0108(:1308): DRD2B1: idx2 = EU3(); EU3(idx2,var11) */ + 0x0000cb38, /* 010C(:1309): DRD1A: *idx2 = idx7; FN=0 init=0 WS=0 RS=0 */ + 0x000001f8, /* 0110(:0): NOP */ + 0x8144801c, /* 0114(:1312): LCD: idx0 = var2 + var9 + 4; idx0 once var0; idx0 += inc3 */ + 0x0000c008, /* 0118(:1313): DRD1A: *idx0 = var1; FN=0 init=0 WS=0 RS=0 */ + 0xc398027f, /* 011C(:1315): LCDEXT: idx0 = var7; idx0 > var9; idx0 += inc7 */ + 0x8018801b, /* 0120(:1315): LCD: idx1 = var0; idx1 once var0; idx1 += inc3 */ + 0x040001f8, /* 0124(:1316): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ +}; +#endif +u32 MCD_ENetRcv_TDT[]= +{ + 0x80004000, /* 0000(:1389): LCDEXT: idx0 = 0x00000000; ; */ + 0x81988000, /* 0004(:1389): LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */ + 0x10000788, /* 0008(:1390): DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x6000000a, /* 000C(:1391): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf05f, /* 0010(:1391): DRD2B1: idx0 = EU3(); EU3(var1) */ + 0x98180209, /* 0014(:1394): LCD: idx0 = idx0; idx0 != var8; idx0 += inc1 */ + 0x81c40004, /* 0018(:1396): LCD: idx1 = var3 + var8 + 4; idx1 once var0; idx1 += inc0 */ + 0x7000000e, /* 001C(:1397): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */ + 0x010cf05f, /* 0020(:1397): DRD2B1: var4 = EU3(); EU3(var1) */ + 0x7000000c, /* 0024(:1398): DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT MORE init=0 WS=0 RS=0 */ + 0x01ccf05f, /* 0028(:1398): DRD2B1: var7 = EU3(); EU3(var1) */ + 0x70000004, /* 002C(:1399): DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */ + 0x014cf049, /* 0030(:1399): DRD2B1: var5 = EU3(); EU3(var1,var9) */ + 0x70000004, /* 0034(:1400): DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */ + 0x004cf04a, /* 0038(:1400): DRD2B1: var1 = EU3(); EU3(var1,var10) */ + 0x00000b88, /* 003C(:1403): DRD1A: var2 = *idx1; FN=0 init=0 WS=0 RS=0 */ + 0xc4030150, /* 0040(:1406): LCDEXT: idx1 = var8, idx2 = var6; idx1 < var5; idx1 += inc2, idx2 += inc0 */ + 0x8119e012, /* 0044(:1406): LCD: idx3 = var2; ; idx3 += inc2 */ + 0x03e0cf90, /* 0048(:1409): DRD1A: *idx3 = *idx2; FN=0 init=31 WS=0 RS=0 */ + 0x81188000, /* 004C(:1412): LCD: idx1 = var2; idx1 once var0; idx1 += inc0 */ + 0x000ac788, /* 0050(:1413): DRD1A: *idx1 = *idx1; FN=0 init=0 WS=1 RS=1 */ + 0xc4030000, /* 0054(:1415): LCDEXT: idx1 = var8, idx2 = var6; idx1 once var0; idx1 += inc0, idx2 += inc0 */ + 0x8199e000, /* 0058(:1415): LCD: idx3 = var3; ; idx3 += inc0 */ + 0x70000004, /* 005C(:1421): DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */ + 0x084cfc8b, /* 0060(:1421): DRD2B1: idx1 = EU3(); EU3(*idx2,var11) */ + 0x60000005, /* 0064(:1422): DRD2A: EU0=0 EU1=0 EU2=0 EU3=5 EXT init=0 WS=0 RS=0 */ + 0x0cccf841, /* 0068(:1422): DRD2B1: *idx3 = EU3(); EU3(idx1,var1) */ + 0x81c60000, /* 006C(:1428): LCD: idx1 = var3 + var12; idx1 once var0; idx1 += inc0 */ + 0xc399021b, /* 0070(:1430): LCDEXT: idx2 = var7; idx2 > var8; idx2 += inc3 */ + 0x80198000, /* 0074(:1430): LCD: idx3 = var0; idx3 once var0; idx3 += inc0 */ + 0x00008400, /* 0078(:1431): DRD1A: idx1 = var0; FN=0 init=0 WS=0 RS=0 */ + 0x00000f08, /* 007C(:1432): DRD1A: var3 = idx1; FN=0 init=0 WS=0 RS=0 */ + 0x81988000, /* 0080(:1435): LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */ + 0x10000788, /* 0084(:1436): DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x6000000a, /* 0088(:1437): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf05f, /* 008C(:1437): DRD2B1: idx0 = EU3(); EU3(var1) */ + 0xc2188209, /* 0090(:1440): LCDEXT: idx1 = var4; idx1 != var8; idx1 += inc1 */ + 0x80190000, /* 0094(:1440): LCD: idx2 = var0; idx2 once var0; idx2 += inc0 */ + 0x040001f8, /* 0098(:1441): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ + 0x000001f8, /* 009C(:0): NOP */ +}; +u32 MCD_ENetXmit_TDT[]= +{ + 0x80004000, /* 0000(:1516): LCDEXT: idx0 = 0x00000000; ; */ + 0x81988000, /* 0004(:1516): LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */ + 0x10000788, /* 0008(:1517): DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x6000000a, /* 000C(:1518): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf05f, /* 0010(:1518): DRD2B1: idx0 = EU3(); EU3(var1) */ + 0x98180309, /* 0014(:1521): LCD: idx0 = idx0; idx0 != var12; idx0 += inc1 */ + 0x80004003, /* 0018(:1523): LCDEXT: idx1 = 0x00000003; ; */ + 0x81c60004, /* 001C(:1523): LCD: idx2 = var3 + var12 + 4; idx2 once var0; idx2 += inc0 */ + 0x7000000e, /* 0020(:1524): DRD2A: EU0=0 EU1=0 EU2=0 EU3=14 EXT MORE init=0 WS=0 RS=0 */ + 0x014cf05f, /* 0024(:1524): DRD2B1: var5 = EU3(); EU3(var1) */ + 0x7000000c, /* 0028(:1525): DRD2A: EU0=0 EU1=0 EU2=0 EU3=12 EXT MORE init=0 WS=0 RS=0 */ + 0x028cf05f, /* 002C(:1525): DRD2B1: var10 = EU3(); EU3(var1) */ + 0x7000000d, /* 0030(:1526): DRD2A: EU0=0 EU1=0 EU2=0 EU3=13 EXT MORE init=0 WS=0 RS=0 */ + 0x018cf05f, /* 0034(:1526): DRD2B1: var6 = EU3(); EU3(var1) */ + 0x70000004, /* 0038(:1527): DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT MORE init=0 WS=0 RS=0 */ + 0x01ccf04d, /* 003C(:1527): DRD2B1: var7 = EU3(); EU3(var1,var13) */ + 0x10000b90, /* 0040(:1528): DRD1A: var2 = *idx2; FN=0 MORE init=0 WS=0 RS=0 */ + 0x60000004, /* 0044(:1529): DRD2A: EU0=0 EU1=0 EU2=0 EU3=4 EXT init=0 WS=0 RS=0 */ + 0x020cf0a1, /* 0048(:1529): DRD2B1: var8 = EU3(); EU3(var2,idx1) */ + 0xc3188312, /* 004C(:1532): LCDEXT: idx1 = var6; idx1 > var12; idx1 += inc2 */ + 0x83c70000, /* 0050(:1532): LCD: idx2 = var7 + var14; idx2 once var0; idx2 += inc0 */ + 0x00001f10, /* 0054(:1533): DRD1A: var7 = idx2; FN=0 init=0 WS=0 RS=0 */ + 0xc583a3c3, /* 0058(:1535): LCDEXT: idx1 = var11, idx2 = var7; idx2 >= var15; idx1 += inc0, idx2 += inc3 */ + 0x81042325, /* 005C(:1535): LCD: idx3 = var2, idx4 = var8; idx4 == var12; idx3 += inc4, idx4 += inc5 */ + 0x03e0c798, /* 0060(:1540): DRD1A: *idx1 = *idx3; FN=0 init=31 WS=0 RS=0 */ + 0xd8990000, /* 0064(:1543): LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */ + 0x9999e000, /* 0068(:1543): LCD: idx3 = idx3; ; idx3 += inc0 */ + 0x000acf98, /* 006C(:1544): DRD1A: *idx3 = *idx3; FN=0 init=0 WS=1 RS=1 */ + 0xd8992306, /* 0070(:1546): LCDEXT: idx1 = idx1, idx2 = idx2; idx2 > var12; idx1 += inc0, idx2 += inc6 */ + 0x9999e03f, /* 0074(:1546): LCD: idx3 = idx3; ; idx3 += inc7 */ + 0x03eac798, /* 0078(:1549): DRD1A: *idx1 = *idx3; FN=0 init=31 WS=1 RS=1 */ + 0xd8990000, /* 007C(:1552): LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */ + 0x9999e000, /* 0080(:1552): LCD: idx3 = idx3; ; idx3 += inc0 */ + 0x000acf98, /* 0084(:1553): DRD1A: *idx3 = *idx3; FN=0 init=0 WS=1 RS=1 */ + 0xd8990000, /* 0088(:1555): LCDEXT: idx1 = idx1, idx2 = idx2; idx1 once var0; idx1 += inc0, idx2 += inc0 */ + 0x99832302, /* 008C(:1555): LCD: idx3 = idx3, idx4 = var6; idx4 > var12; idx3 += inc0, idx4 += inc2 */ + 0x0beac798, /* 0090(:1558): DRD1A: *idx1 = *idx3; FN=0 TFD init=31 WS=1 RS=1 */ + 0x81988000, /* 0094(:1560): LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */ + 0x6000000b, /* 0098(:1561): DRD2A: EU0=0 EU1=0 EU2=0 EU3=11 EXT init=0 WS=0 RS=0 */ + 0x0c4cfc5f, /* 009C(:1561): DRD2B1: *idx1 = EU3(); EU3(*idx1) */ + 0x81c80000, /* 00A0(:1563): LCD: idx1 = var3 + var16; idx1 once var0; idx1 += inc0 */ + 0xc5190312, /* 00A4(:1565): LCDEXT: idx2 = var10; idx2 > var12; idx2 += inc2 */ + 0x80198000, /* 00A8(:1565): LCD: idx3 = var0; idx3 once var0; idx3 += inc0 */ + 0x00008400, /* 00AC(:1566): DRD1A: idx1 = var0; FN=0 init=0 WS=0 RS=0 */ + 0x00000f08, /* 00B0(:1567): DRD1A: var3 = idx1; FN=0 init=0 WS=0 RS=0 */ + 0x81988000, /* 00B4(:1570): LCD: idx1 = var3; idx1 once var0; idx1 += inc0 */ + 0x10000788, /* 00B8(:1571): DRD1A: var1 = *idx1; FN=0 MORE init=0 WS=0 RS=0 */ + 0x6000000a, /* 00BC(:1572): DRD2A: EU0=0 EU1=0 EU2=0 EU3=10 EXT init=0 WS=0 RS=0 */ + 0x080cf05f, /* 00C0(:1572): DRD2B1: idx0 = EU3(); EU3(var1) */ + 0xc2988309, /* 00C4(:1575): LCDEXT: idx1 = var5; idx1 != var12; idx1 += inc1 */ + 0x80190000, /* 00C8(:1575): LCD: idx2 = var0; idx2 once var0; idx2 += inc0 */ + 0x040001f8, /* 00CC(:1576): DRD1A: FN=0 INT init=0 WS=0 RS=0 */ + 0x000001f8, /* 00D0(:0): NOP */ +}; + +#ifdef MCD_INCLUDE_EU +MCD_bufDesc MCD_singleBufDescs[NCHANNELS]; +#endif diff --git a/sources/MCD_tasksInit.c b/sources/MCD_tasksInit.c new file mode 100644 index 0000000..fd651b2 --- /dev/null +++ b/sources/MCD_tasksInit.c @@ -0,0 +1,224 @@ +/* + * File: MCD_tasksInit.c + * Purpose: Functions for initializing variable tables of different + * types of tasks. + * + * Notes: + */ + +/* + * Do not edit! + */ + +#include "MCD_dma.h" + +extern dmaRegs *MCD_dmaBar; + + +/* + * Task 0 + */ + +void MCD_startDmaChainNoEu(int *currBD, short srcIncr, short destIncr, int xferSize, short xferSizeIncr, int *cSave, volatile TaskTableEntry *taskTable, int channel) +{ + + MCD_SET_VAR(taskTable+channel, 2, (u32)currBD); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr)); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr)); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 11, (u32)xferSize); /* var[11] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr)); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 0, (u32)cSave); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 3, (u32)0x00000000); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000000); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 12, (u32)0x00000000); /* var[12] */ + MCD_SET_VAR(taskTable+channel, 13, (u32)0x80000000); /* var[13] */ + MCD_SET_VAR(taskTable+channel, 14, (u32)0x00000010); /* var[14] */ + MCD_SET_VAR(taskTable+channel, 15, (u32)0x00000004); /* var[15] */ + MCD_SET_VAR(taskTable+channel, 16, (u32)0x08000000); /* var[16] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000); /* inc[3] */ + MCD_SET_VAR(taskTable+channel, 28, (u32)0x80000000); /* inc[4] */ + MCD_SET_VAR(taskTable+channel, 29, (u32)0x80000001); /* inc[5] */ + MCD_SET_VAR(taskTable+channel, 30, (u32)0x40000000); /* inc[6] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} + + +/* + * Task 1 + */ + +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) +{ + + MCD_SET_VAR(taskTable+channel, 7, (u32)srcAddr); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr)); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 2, (u32)destAddr); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr)); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 3, (u32)dmaSize); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr)); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)flags); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)currBD); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 0, (u32)cSave); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000004); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x08000000); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000); /* inc[3] */ + MCD_SET_VAR(taskTable+channel, 28, (u32)0x80000001); /* inc[4] */ + MCD_SET_VAR(taskTable+channel, 29, (u32)0x40000000); /* inc[5] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} + + +/* + * Task 2 + */ + +void MCD_startDmaChainEu(int *currBD, short srcIncr, short destIncr, int xferSize, short xferSizeIncr, int *cSave, volatile TaskTableEntry *taskTable, int channel) +{ + + MCD_SET_VAR(taskTable+channel, 3, (u32)currBD); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr)); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr)); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 12, (u32)xferSize); /* var[12] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr)); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 0, (u32)cSave); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 2, (u32)0x00000000); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000000); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 11, (u32)0x00000000); /* var[11] */ + MCD_SET_VAR(taskTable+channel, 13, (u32)0x00000000); /* var[13] */ + MCD_SET_VAR(taskTable+channel, 14, (u32)0x80000000); /* var[14] */ + MCD_SET_VAR(taskTable+channel, 15, (u32)0x00000010); /* var[15] */ + MCD_SET_VAR(taskTable+channel, 16, (u32)0x00000001); /* var[16] */ + MCD_SET_VAR(taskTable+channel, 17, (u32)0x00000004); /* var[17] */ + MCD_SET_VAR(taskTable+channel, 18, (u32)0x08000000); /* var[18] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000); /* inc[3] */ + MCD_SET_VAR(taskTable+channel, 28, (u32)0x80000000); /* inc[4] */ + MCD_SET_VAR(taskTable+channel, 29, (u32)0xc0000000); /* inc[5] */ + MCD_SET_VAR(taskTable+channel, 30, (u32)0x80000001); /* inc[6] */ + MCD_SET_VAR(taskTable+channel, 31, (u32)0x40000000); /* inc[7] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} + + +/* + * Task 3 + */ + +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) +{ + + MCD_SET_VAR(taskTable+channel, 8, (u32)srcAddr); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)(0xe000 << 16) | (0xffff & srcIncr)); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 3, (u32)destAddr); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)(0xe000 << 16) | (0xffff & destIncr)); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)dmaSize); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)(0x2000 << 16) | (0xffff & xferSizeIncr)); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)flags); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 2, (u32)currBD); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 0, (u32)cSave); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000001); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 11, (u32)0x00000004); /* var[11] */ + MCD_SET_VAR(taskTable+channel, 12, (u32)0x08000000); /* var[12] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0x00000000); /* inc[3] */ + MCD_SET_VAR(taskTable+channel, 28, (u32)0xc0000000); /* inc[4] */ + MCD_SET_VAR(taskTable+channel, 29, (u32)0x80000000); /* inc[5] */ + MCD_SET_VAR(taskTable+channel, 30, (u32)0x80000001); /* inc[6] */ + MCD_SET_VAR(taskTable+channel, 31, (u32)0x40000000); /* inc[7] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} + + +/* + * Task 4 + */ + +void MCD_startDmaENetRcv(char *bDBase, char *currBD, char *rcvFifoPtr, volatile TaskTableEntry *taskTable, int channel) +{ + + MCD_SET_VAR(taskTable+channel, 0, (u32)bDBase); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 3, (u32)currBD); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)rcvFifoPtr); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 2, (u32)0x00000000); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x0000ffff); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x30000000); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 11, (u32)0x0fffffff); /* var[11] */ + MCD_SET_VAR(taskTable+channel, 12, (u32)0x00000008); /* var[12] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)0x00000000); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)0x60000000); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)0x20000004); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0x40000000); /* inc[3] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} + + +/* + * Task 5 + */ + +void MCD_startDmaENetXmit(char *bDBase, char *currBD, char *xmitFifoPtr, volatile TaskTableEntry *taskTable, int channel) +{ + + MCD_SET_VAR(taskTable+channel, 0, (u32)bDBase); /* var[0] */ + MCD_SET_VAR(taskTable+channel, 3, (u32)currBD); /* var[3] */ + MCD_SET_VAR(taskTable+channel, 11, (u32)xmitFifoPtr); /* var[11] */ + MCD_SET_VAR(taskTable+channel, 1, (u32)0x00000000); /* var[1] */ + MCD_SET_VAR(taskTable+channel, 2, (u32)0x00000000); /* var[2] */ + MCD_SET_VAR(taskTable+channel, 4, (u32)0x00000000); /* var[4] */ + MCD_SET_VAR(taskTable+channel, 5, (u32)0x00000000); /* var[5] */ + MCD_SET_VAR(taskTable+channel, 6, (u32)0x00000000); /* var[6] */ + MCD_SET_VAR(taskTable+channel, 7, (u32)0x00000000); /* var[7] */ + MCD_SET_VAR(taskTable+channel, 8, (u32)0x00000000); /* var[8] */ + MCD_SET_VAR(taskTable+channel, 9, (u32)0x00000000); /* var[9] */ + MCD_SET_VAR(taskTable+channel, 10, (u32)0x00000000); /* var[10] */ + MCD_SET_VAR(taskTable+channel, 12, (u32)0x00000000); /* var[12] */ + MCD_SET_VAR(taskTable+channel, 13, (u32)0x0000ffff); /* var[13] */ + MCD_SET_VAR(taskTable+channel, 14, (u32)0xffffffff); /* var[14] */ + MCD_SET_VAR(taskTable+channel, 15, (u32)0x00000004); /* var[15] */ + MCD_SET_VAR(taskTable+channel, 16, (u32)0x00000008); /* var[16] */ + MCD_SET_VAR(taskTable+channel, 24, (u32)0x00000000); /* inc[0] */ + MCD_SET_VAR(taskTable+channel, 25, (u32)0x60000000); /* inc[1] */ + MCD_SET_VAR(taskTable+channel, 26, (u32)0x40000000); /* inc[2] */ + MCD_SET_VAR(taskTable+channel, 27, (u32)0xc000fffc); /* inc[3] */ + MCD_SET_VAR(taskTable+channel, 28, (u32)0xe0000004); /* inc[4] */ + MCD_SET_VAR(taskTable+channel, 29, (u32)0x80000000); /* inc[5] */ + MCD_SET_VAR(taskTable+channel, 30, (u32)0x4000ffff); /* inc[6] */ + MCD_SET_VAR(taskTable+channel, 31, (u32)0xe0000001); /* inc[7] */ + + /* Set the task's Enable bit in its Task Control Register */ + MCD_dmaBar->taskControl[channel] |= (u16)0x8000; +} diff --git a/sources/alt und div/BaS.c.neu b/sources/alt und div/BaS.c.neu new file mode 100644 index 0000000..25ebdb6 --- /dev/null +++ b/sources/alt und div/BaS.c.neu @@ -0,0 +1,350 @@ +/* + * BaS + * + */ + + +#include "MCF5475.h" +#include "startcf.h" + +#include "MCD_dma.h" +#define MBAR_BASE_ADRS 0xff000000 +#define MMAP_DMA 0x00008000 +#define MMAP_SRAM 0x00010000 + +extern unsigned long far __SP_AFTER_RESET[]; +extern unsigned long far __Bas_base[]; + + /* imported routines */ +extern int mmu_init(); +extern int mmutr_miss(); +extern int vec_init(); +extern int illegal_table_make(); +extern int cf68k_initialize(); + +/********************************************************************/ + /* warte_routinen /* +********************************************************************/ + +void warte_10ms(void) +{ + asm + { +warte_10ms: + move.l d0,-(sp) + move.l MCF_SLT0_SCNT,d0 + sub.l #1320000,d0 + warte_d6: + cmp.l MCF_SLT0_SCNT,d0 + bcs warte_d6 + move.l (sp)+,d0 + } +} + +void warte_1ms(void) +{ + asm + { +warte_1ms: + move.l d0,-(sp) + move.l MCF_SLT0_SCNT,d0 + sub.l #132000,d0 + warte_d6: + cmp.l MCF_SLT0_SCNT,d0 + bcs warte_d6 + move.l (sp)+,d0 + } +} + +void warte_100us(void) +{ + asm + { + warte_100us: + move.l d0,-(sp) + move.l MCF_SLT0_SCNT,d0 + sub.l #13200,d0 + warte_d6: + cmp.l MCF_SLT0_SCNT,d0 + bcs warte_d6 + move.l (sp)+,d0 + } +} + +void warte_50us(void) +{ + asm + { +warte_50us: + move.l d0,-(sp) + move.l MCF_SLT0_SCNT,d0 + sub.l #6600,d0 + warte_d6: + cmp.l MCF_SLT0_SCNT,d0 + bcs warte_d6 + move.l (sp)+,d0 + } +} +void warte_10us(void) +{ + asm + { +warte_10us: + move.l d0,-(sp) + move.l MCF_SLT0_SCNT,d0 + sub.l #1320,d0 + warte_d6: + cmp.l MCF_SLT0_SCNT,d0 + bcs warte_d6 + move.l (sp)+,d0 + } +} + +void warte_1us(void) +{ + asm + { +warte_1us: + move.l d0,-(sp) + move.l MCF_SLT0_SCNT,d0 + sub.l #132,d0 + warte_d6: + cmp.l MCF_SLT0_SCNT,d0 + bcs warte_d6 + move.l (sp)+,d0 + } +} + +/********************************************************************/ +void BaS(void) +{ + int az_sectors; + int sd_status,i; + int status; + int dma_task_nr = 0; + + + az_sectors = sd_card_init(); + + if(az_sectors>0) + { + sd_card_idle(); + } + +/* variablenbereich setzen*/ + +asm +{ + lea 0x1fc00000,a5 + lea 0x1fd00000,a6 +} + +init_dma: + status = + MCD_initDma( + (dmaRegs*) (MBAR_BASE_ADRS + MMAP_DMA), + (void*) (MBAR_BASE_ADRS + MMAP_SRAM), + (MCD_RELOC_TASKS) + ); + + status = MCD_startDma(0, /*int channel, /* the channel on which to run the DMA */ + (char*) (0xfff00000), /*s8 *srcAddr, /* the address to move data from, or physical buffer-descriptor address */ + 0, /*s16 srcIncr, /* the amount to increment the source address per transfer */ + (char*) (0x12345678), /*s8 *destAddr, /* the address to move data to */ + 2, /*s16 destIncr, /* the amount to increment the destination address per transfer */ + 512, /*u32 dmaSize, /* the number of bytes to transfer independent of the transfer size */ + 2, /*u32 xferSize, /* the number bytes in of each data movement (1, 2, or 4) */ + 3, /*u32 initiator, /* what device initiates the DMA */ + 4, /*int priority, /* priority of the DMA */ + MCD_SINGLE_DMA+ + MCD_TT_FLAGS_CW+ + MCD_TT_FLAGS_RL+ + MCD_TT_FLAGS_SP, /*u32 flags, /* flags describing the DMA */ + MCD_NO_BYTE_SWAP+ + MCD_NO_BIT_REV /*u32 funcDesc /* a description of byte swapping, bit swapping, and CRC actions */ + ); + + status = + MCD_dmaStatus(0); + + MCD_killDma(0); + + + asm +{ + move.b DIP_SWITCH,d0 // dip schalter adresse + btst.b #6,d0 + beq firetos_kopieren + lea MCF_PSC0_PSCTB_8BIT,a6 + lea MCF_PSC3_PSCTB_8BIT,a3 + lea MCF_PSC3_PSCRB_8BIT,a4 + lea MCF_PSC3_PSCRFCNT,a5 + move.l #'ACPF',(a3) // SEND SYNC MARKE, MCF BEREIT + bsr warte_10ms + move.l #'PIC ',(a6) + move.b (a4),d0 + move.b d0,(a6) + move.b (a4),d1 + move.b d1,(a6) + move.b (a4),d2 + move.b d2,(a6) + move.l #0x0a0d,(a6) + move.b #0x01,(a3) // RTC DATEN ANFORDERN +// TOS kopieren + lea 0x00e00000,a0 + lea 0xe0600000,a1 // default tos + lea 0xe0700000,a2 // 1MB + move.b DIP_SWITCH,d0 // dip schalter adresse + btst.b #6,d0 + bne cptos_loop +firetos_kopieren: + lea 0x00e00000,a0 + lea 0xe0400000,a1 + lea 0xe0500000,a2 // 1MB +cptos_loop: + move.l (a1)+,(a0)+ + cmp.l a2,a1 + blt cptos_loop +/***************************************************************/ +/* div inits +/***************************************************************/ +div_inits: + move.b DIP_SWITCH,d0 // dip schalter adresse + btst.b #6,d0 + beq video_setup +// rtc daten, mmu set, etc nur wenn switch 6 = off + lea 0xffff8961,a0 + clr.l d1 + moveq #64,d2 + move.b (a4),d0 + cmp.b #0x81,d0 + bne not_rtc +loop_sr: + move.b (a4),d0 + move.b d1,(a0) + move.b d0,2(a0) + addq.l #1,d1 + cmp.b d1,d2 + bne loop_sr + + move.b #63,(a0) + move.b 2(a0),d0 + add #1,d0 + move.b d0,2(a0) +not_rtc: + bsr mmu_init + bsr vec_init + bsr illegal_table_make + +// interrupts + clr.l 0xf0010004 // disable all interrupts + lea MCF_EPORT_EPPAR,a0 + move.w #0xaaa8,(a0) // falling edge all, + +// timer 0 on mit int -> video change ------------------------------------------- + move.l #MCF_GPT_GMS_ICT(1)|MCF_GPT_GMS_IEN|MCF_GPT_GMS_TMS(1),d0 //caputre mit int on rising edge + move.l d0,MCF_GPT0_GMS + moveq.l #0x3f,d0 // max prority interrutp + move.b d0,MCF_INTC_ICR62 // setzen +// ------------------------------------------------- + move.b #0xfe,d0 + move.b d0,0xf0010004 // enable int 1-7 + nop + lea MCF_EPORT_EPIER,a0 + move.b #0xfe,(a0) // int 1-7 on + nop + lea MCF_EPORT_EPFR,a0 + move.b #0xff,(a0) // alle pending interrupts löschen + nop + lea MCF_INTC_IMRL,a0 + move.l #0xFFFFFF00,(a0) // int 1-7 on + lea MCF_INTC_IMRH,a0 + move.l #0xBFFFFFFE,(a0) // psc3 and timer 0 int on + + move.l #MCF_MMU_MMUCR_EN,d0 + move.l d0,MCF_MMU_MMUCR // mmu on + nop + nop +/********************************************************************/ +/* IDE reset +/********************************************************************/ + lea 0xffff8802,a0 + move.b #14,-2(a0) + move.b #0x80,(a0) + bsr warte_1ms + clr.b (a0) +/********************************************************************/ +/* video setup +/********************************************************************/ +video_setup: + lea 0xf0000410,a0 +// 25MHz + move.l #0x032002ba,(a0)+ // horizontal 640x480 + move.l #0x020c020a,(a0)+ // vertikal 640x480 + move.l #0x0190015d,(a0)+ // horizontal 320x240 + move.l #0x020C020A,(a0)+ // vertikal 320x240 */ +/* +// 32MHz + move.l #0x037002ba,(a0)+ // horizontal 640x480 + move.l #0x020d020a,(a0)+ // vertikal 640x480 + move.l #0x02A001e0,(a0)+ // horizontal 320x240 + move.l #0x05a00160,(a0)+ // vertikal 320x240 +*/ + lea -0x20(a0),a0 + move.l #0x01070002,(a0) // fifo on, refresh on, ddrcs und cke on, video dac on, +/********************************************************************/ +/* memory setup +/********************************************************************/ + lea 0x400,a0 + lea 0x800,a1 +mem_clr_loop: + clr.l (a0)+ + clr.l (a0)+ + clr.l (a0)+ + clr.l (a0)+ + cmp.l a0,a1 + bgt mem_clr_loop + + moveq #0x48,d0 + move.b d0,0xffff8007 +// stram + move.l #0xe00000,d0 // ende stram + move.l d0,0x42e + move.l #0x752019f3,d0 // memvalid + move.l d0,0x420 + move.l #0x237698aa,d0 // memval2 + move.l d0,0x43a + move.l #0x5555aaaa,d0 // memval3 + move.l d0,0x51a +// ttram + move.l #__Bas_base,d0 // ende ttram + move.l d0,0x5a4 + move.l #0x1357bd13,d0 // ramvalid + move.l d0,0x5a8 + +// init acia + moveq #3,d0 + move.b d0,0xfffffc00 + nop + move.b d0,0xfffffc04 + nop + moveq #0x96,d0 + move.b d0,0xfffffc00 + moveq #-1,d0 + nop + move.b d0,0xfffffa0f + nop + move.b d0,0xfffffa11 + nop + +// test auf protect mode --------------------- + move.b DIP_SWITCH,d0 + btst #7,d0 + beq no_protect // nein-> + move.w #0x0700,sr +no_protect: + + jmp 0xe00030 + +} +} diff --git a/sources/alt und div/BaS.c.normal b/sources/alt und div/BaS.c.normal new file mode 100644 index 0000000..a801c3e --- /dev/null +++ b/sources/alt und div/BaS.c.normal @@ -0,0 +1,312 @@ +/* + * BaS + * + */ + + +#include "MCF5475.h" +#include "startcf.h" + +#include "MCD_dma.h" +#define MBAR_BASE_ADRS 0xff000000 +#define MMAP_DMA 0x00008000 +#define MMAP_SRAM 0x00010000 + +extern unsigned long far __SP_AFTER_RESET[]; +extern unsigned long far __Bas_base[]; + + /* imported routines */ +extern int mmu_init(); +extern int mmutr_miss(); +extern int vec_init(); +extern int illegal_table_make(); +extern int cf68k_initialize(); + +/********************************************************************/ + /* warte_routinen /* +********************************************************************/ + +void warte_10ms(void) +{ + asm + { +warte_10ms: + move.l d0,-(sp) + move.l MCF_SLT0_SCNT,d0 + sub.l #1320000,d0 + warte_d6: + cmp.l MCF_SLT0_SCNT,d0 + bcs warte_d6 + move.l (sp)+,d0 + } +} + +void warte_1ms(void) +{ + asm + { +warte_1ms: + move.l d0,-(sp) + move.l MCF_SLT0_SCNT,d0 + sub.l #132000,d0 + warte_d6: + cmp.l MCF_SLT0_SCNT,d0 + bcs warte_d6 + move.l (sp)+,d0 + } +} + +void warte_100us(void) +{ + asm + { + warte_100us: + move.l d0,-(sp) + move.l MCF_SLT0_SCNT,d0 + sub.l #13200,d0 + warte_d6: + cmp.l MCF_SLT0_SCNT,d0 + bcs warte_d6 + move.l (sp)+,d0 + } +} + +void warte_50us(void) +{ + asm + { +warte_50us: + move.l d0,-(sp) + move.l MCF_SLT0_SCNT,d0 + sub.l #6600,d0 + warte_d6: + cmp.l MCF_SLT0_SCNT,d0 + bcs warte_d6 + move.l (sp)+,d0 + } +} +void warte_10us(void) +{ + asm + { +warte_10us: + move.l d0,-(sp) + move.l MCF_SLT0_SCNT,d0 + sub.l #1320,d0 + warte_d6: + cmp.l MCF_SLT0_SCNT,d0 + bcs warte_d6 + move.l (sp)+,d0 + } +} + +void warte_1us(void) +{ + asm + { +warte_1us: + move.l d0,-(sp) + move.l MCF_SLT0_SCNT,d0 + sub.l #132,d0 + warte_d6: + cmp.l MCF_SLT0_SCNT,d0 + bcs warte_d6 + move.l (sp)+,d0 + } +} + +/********************************************************************/ +void BaS(void) +{ + int az_sectors; + int sd_status,i; + int status; + int dma_task_nr = 0; + + + az_sectors = sd_card_init(); + + if(az_sectors>0) + { + sd_card_idle(); + } + + + asm +{ + move.b DIP_SWITCH,d0 // dip schalter adresse + btst.b #6,d0 + beq firetos_kopieren + lea MCF_PSC0_PSCTB_8BIT,a6 + lea MCF_PSC3_PSCTB_8BIT,a3 + lea MCF_PSC3_PSCRB_8BIT,a4 + lea MCF_PSC3_PSCRFCNT,a5 + move.l #'ACPF',(a3) // SEND SYNC MARKE, MCF BEREIT + bsr warte_10ms + move.l #'PIC ',(a6) + move.b (a4),d0 + move.b d0,(a6) + move.b (a4),d1 + move.b d1,(a6) + move.b (a4),d2 + move.b d2,(a6) + move.l #0x0a0d,(a6) + move.b #0x01,(a3) // RTC DATEN ANFORDERN +// TOS kopieren + lea 0x00e00000,a0 + lea 0xe0600000,a1 // default tos + lea 0xe0700000,a2 // 1MB + move.b DIP_SWITCH,d0 // dip schalter adresse + btst.b #6,d0 + bne cptos_loop +firetos_kopieren: + lea 0x00e00000,a0 + lea 0xe0400000,a1 + lea 0xe0500000,a2 // 1MB +cptos_loop: + move.l (a1)+,(a0)+ + cmp.l a2,a1 + blt cptos_loop +/***************************************************************/ +/* div inits +/***************************************************************/ +div_inits: + move.b DIP_SWITCH,d0 // dip schalter adresse + btst.b #6,d0 + beq video_setup +// rtc daten, mmu set, etc nur wenn switch 6 = off + lea 0xffff8961,a0 + clr.l d1 + moveq #64,d2 + move.b (a4),d0 + cmp.b #0x81,d0 + bne not_rtc +loop_sr: + move.b (a4),d0 + move.b d1,(a0) + move.b d0,2(a0) + addq.l #1,d1 + cmp.b d1,d2 + bne loop_sr + + move.b #63,(a0) + move.b 2(a0),d0 + add #1,d0 + move.b d0,2(a0) +not_rtc: + bsr mmu_init + bsr vec_init + bsr illegal_table_make + +// interrupts + clr.l 0xf0010004 // disable all interrupts + lea MCF_EPORT_EPPAR,a0 + move.w #0xaaa8,(a0) // falling edge all, + +// timer 0 on mit int -> video change ------------------------------------------- + move.l #MCF_GPT_GMS_ICT(1)|MCF_GPT_GMS_IEN|MCF_GPT_GMS_TMS(1),d0 //caputre mit int on rising edge + move.l d0,MCF_GPT0_GMS + moveq.l #0x3f,d0 // max prority interrutp + move.b d0,MCF_INTC_ICR62 // setzen +// ------------------------------------------------- + move.b #0xfe,d0 + move.b d0,0xf0010004 // enable int 1-7 + nop + lea MCF_EPORT_EPIER,a0 + move.b #0xfe,(a0) // int 1-7 on + nop + lea MCF_EPORT_EPFR,a0 + move.b #0xff,(a0) // alle pending interrupts löschen + nop + lea MCF_INTC_IMRL,a0 + move.l #0xFFFFFF00,(a0) // int 1-7 on + lea MCF_INTC_IMRH,a0 + move.l #0xBFFFFFFE,(a0) // psc3 and timer 0 int on + + move.l #MCF_MMU_MMUCR_EN,d0 + move.l d0,MCF_MMU_MMUCR // mmu on + nop + nop +/********************************************************************/ +/* IDE reset +/********************************************************************/ + lea 0xffff8802,a0 + move.b #14,-2(a0) + move.b #0x80,(a0) + bsr warte_1ms + clr.b (a0) +/********************************************************************/ +/* video setup +/********************************************************************/ +video_setup: + lea 0xf0000410,a0 +// 25MHz + move.l #0x032002ba,(a0)+ // horizontal 640x480 + move.l #0x020c020a,(a0)+ // vertikal 640x480 + move.l #0x0190015d,(a0)+ // horizontal 320x240 + move.l #0x020C020A,(a0)+ // vertikal 320x240 */ +/* +// 32MHz + move.l #0x037002ba,(a0)+ // horizontal 640x480 + move.l #0x020d020a,(a0)+ // vertikal 640x480 + move.l #0x02A001e0,(a0)+ // horizontal 320x240 + move.l #0x05a00160,(a0)+ // vertikal 320x240 +*/ + lea -0x20(a0),a0 + move.l #0x01070002,(a0) // fifo on, refresh on, ddrcs und cke on, video dac on, +/********************************************************************/ +/* memory setup +/********************************************************************/ + lea 0x400,a0 + lea 0x800,a1 +mem_clr_loop: + clr.l (a0)+ + clr.l (a0)+ + clr.l (a0)+ + clr.l (a0)+ + cmp.l a0,a1 + bgt mem_clr_loop + + moveq #0x48,d0 + move.b d0,0xffff8007 +// stram + move.l #0xe00000,d0 // ende stram + move.l d0,0x42e + move.l #0x752019f3,d0 // memvalid + move.l d0,0x420 + move.l #0x237698aa,d0 // memval2 + move.l d0,0x43a + move.l #0x5555aaaa,d0 // memval3 + move.l d0,0x51a +// ttram + move.l #__Bas_base,d0 // ende ttram + move.l d0,0x5a4 + move.l #0x1357bd13,d0 // ramvalid + move.l d0,0x5a8 + +// init acia + moveq #3,d0 + move.b d0,0xfffffc00 + nop + move.b d0,0xfffffc04 + nop + moveq #0x96,d0 + move.b d0,0xfffffc00 + moveq #-1,d0 + nop + move.b d0,0xfffffa0f + nop + move.b d0,0xfffffa11 + nop + +// test auf protect mode --------------------- + move.b DIP_SWITCH,d0 + btst #7,d0 + beq no_protect // nein-> + move.w #0x0700,sr +no_protect: + + jmp 0xe00030 + +} +} diff --git a/sources/div.s b/sources/alt und div/div.s similarity index 100% rename from sources/div.s rename to sources/alt und div/div.s diff --git a/sources/sd_ide.c b/sources/alt und div/sd_ide.c similarity index 100% rename from sources/sd_ide.c rename to sources/alt und div/sd_ide.c diff --git a/sources/ewf.s b/sources/ewf.s index 7f5a644..7b740d6 100644 --- a/sources/ewf.s +++ b/sources/ewf.s @@ -1,6 +1,7 @@ /*************************************************************************************************/ // extension word format: a0 zeigt auf code, in a1 ist ay, d0/d1 wird zerstört //------------------------------------------------------------------------------ +#ifdef ii_on .include "ii_macro.h" @@ -1561,5 +1562,5 @@ ewff_lln: add.l d0,a1 add.l d0,a1 rts -/**************************************************************************************************************** - +/************************************************************************/ +#endif diff --git a/sources/exceptions.s b/sources/exceptions.s index e0494c0..f313eff 100644 --- a/sources/exceptions.s +++ b/sources/exceptions.s @@ -4,7 +4,7 @@ .include "startcf.h" -.extern ___Bas_base +.extern ___SDRAM_SIZE .extern ___SUP_SP .extern ___BOOT_FLASH .extern ___RAMBAR0 @@ -362,7 +362,7 @@ access_mmu: btst #1,d0 bne bus_error move.l MCF_MMU_MMUAR,d0 - cmp.l #___Bas_base,d0 // max User RAM Bereich + cmp.l #___SDRAM_SIZE,d0 // max User RAM Bereich bge bus_error // grösser -> bus error bra _mmutr_miss bus_error: @@ -421,13 +421,13 @@ flpoow: nop irq1: irq 0x64,1,0x02 -irq2: // hbl +irq2: //vsync // move.b #3,2(a7) // rte irq 0x68,2,0x04 irq3: irq 0x6c,3,0x08 -irq4: // vbl +irq4: // vsync irq 0x70,4,0x10 irq5: // acp irq 0x74,5,0x20 diff --git a/sources/illegal_instruction.s b/sources/illegal_instruction.s index 21461b3..afecc00 100644 --- a/sources/illegal_instruction.s +++ b/sources/illegal_instruction.s @@ -1,7 +1,9 @@ .public _illegal_instruction .public _illegal_table_make + .include "startcf.h" +#ifdef ii_on .include "ii_macro.h" .include "ii_func.h" .include "ii_op.h" @@ -19,6 +21,7 @@ .include "ii_movep.h" .include "ii_ewf.h" .include "ii_move.h" +#endif .extern _ii_shift_vec .extern ewf diff --git a/sources/last.c b/sources/last.c deleted file mode 100644 index 0cb3a3e..0000000 --- a/sources/last.c +++ /dev/null @@ -1,11 +0,0 @@ -// letztes file der liste -// wichtig als endpunkt des kopierens - -void copy_end(void) -{ - asm - { -copy_end: - nop - } -} \ No newline at end of file diff --git a/sources/last.s b/sources/last.s deleted file mode 100644 index c9dfe7a..0000000 --- a/sources/last.s +++ /dev/null @@ -1,10 +0,0 @@ -// letztes file der liste -// wichtig als endpunkt des kopierens - -.global copy_end - -.text - nop -copy_end: - nop -.asciz 'ende copy'; \ No newline at end of file diff --git a/sources/sd_card.c b/sources/sd_card.c index 58c48bd..e733dd4 100644 --- a/sources/sd_card.c +++ b/sources/sd_card.c @@ -5,7 +5,7 @@ #define __MBAR 0xff000000 #define MCF_SLT0_SCNT __MBAR + 0x908 #define MCF_PSC0_PSCTB_8BIT __MBAR + 0x860C -#define MCF_PAD_PAR_DSPI __MBAR + 0xA50 +#define MCF_PAD_PAR_DSPI __MBAR + 0xa30 #define MCF_DSPI_DMCR __MBAR + 0x8A00 //dspi control #define dspi_dtar0 0x0c @@ -115,7 +115,7 @@ int sd_card_init(void) move.l #'SD-C',(a1) move.l #'ard ',(a1) - move.l buffer,a5 // basis addresse (diesen bereich brauchen wir nicht mehr!) + move.l buffer,a3 // basis addresse (diesen bereich brauchen wir nicht mehr!) move.l #0x1fffffff,d0 // normal dspi move.l d0,MCF_PAD_PAR_DSPI lea MCF_DSPI_DMCR,a0 @@ -301,11 +301,11 @@ read_cid: move.b #0x95,d4 bsr sd_com - move.l a5,a2 // adresse setzen + move.l a3,a2 // adresse setzen bsr sd_rcv_info // name ausgeben - lea 1(a5),a2 + lea 1(a3),a2 moveq #7,d7 sd_nam_loop: move.b (a2)+,(a1) @@ -330,19 +330,19 @@ read_csd: move.b #0x01,d4 bsr sd_com - move.l a5,a2 // adresse setzen + move.l a3,a2 // adresse setzen bsr sd_rcv_info - mvz.b (a5),d0 + mvz.b (a3),d0 lsr.l #6,d0 bne sd_csd2 // format v2 - move.l 6(a5),d1 + move.l 6(a3),d1 moveq #14,d0 // bit 73..62 c_size lsr.l d0,d1 // bits extrahieren and.l #0xfff,d1 // 12 bits addq.l #1,d1 - mvz.w 9(a5),d0 + mvz.w 9(a3),d0 lsr.l #7,d0 // bits 49..47 and.l #0x7,d0 // 3 bits moveq.l #8,d2 // x256 (dif v1 v2) @@ -350,7 +350,7 @@ read_csd: lsr.l d2,d1 bra sd_print_size sd_csd2: - mvz.w 8(a5),d1 + mvz.w 8(a3),d1 addq.l #1,d1 sd_print_size: swap d1 @@ -468,7 +468,7 @@ sd_rs_end: int sd_card_sector_read(long sec_nr,long buf_adr) { - int status ; + int status=0 ; asm { lea MCF_DSPI_DMCR,a0 @@ -554,7 +554,7 @@ sd_send_end: int sd_card_sector_write(long sec_nr,long buf_adr) { - int status; + int status=0; asm { lea MCF_DSPI_DMCR,a0 diff --git a/sources/sd_card.s b/sources/sd_card.s deleted file mode 100644 index c51147c..0000000 --- a/sources/sd_card.s +++ /dev/null @@ -1,406 +0,0 @@ -/********************************************************************/ -// sd card -/********************************************************************/ -#define dspi_dtar0 0x0c -#define dspi_dsr 0x2c -#define dspi_dtfr 0x34 -#define dspi_drfr 0x38 - -.text -sd_test: - lea MCF_PSC0_PSCTB_8BIT,a6 - move.l #'SD-C',(a6) - move.l #'ard ',(a6) - - move.l #__Bas_base,a5 // basis addresse (diesen bereich brauchen wir nicht mehr!) - move.l #0x1fffffff,d0 // normal dspi - move.l d0,MCF_PAD_PAR_DSPI - lea MCF_DSPI_DMCR,a0 - move.l #0x800d3c00,(a0) // 8 bit cs5 on - move.l #0x38558897,d0 - move.l d0,dspi_dtar0(a0) // 400kHz - move.l #0x082000ff,d4 // tx vorbesetzen - mov3q.l #-1,dspi_dsr(a0) - - bsr warte_1ms - move.l #0xc00d3c00,(a0) // 8 bit 4MHz clocken cs off - bsr warte_10ms - move.l #0x800d3c00,(a0) // 8 bit 4MHz normal cs on - bsr sd_com - bsr sd_com - bsr sd_com - bsr sd_com - bsr sd_com - bsr sd_com - bsr sd_com - bsr sd_com - bsr sd_com - bsr sd_com - move.l #0x802d3c00,(a0) // 8 bit 4MHz normal cs off - clr.b d4 - bsr sd_com - bsr sd_com - move.l #0x800d3c00,(a0) // 8 bit 4MHz normal cs on - move.b #0xff,d4 - bsr sd_com - bsr sd_com - move.l #0x802d3c00,(a0) // 8 bit 4MHz normal cs off - bsr warte_10ms - -// sd idle - move.l #100,d6 // 100 versuche - move.l #10,d3 // 10 versuche -sd_idle: - move.b #0xff,d4 // receive byt - bsr sd_com - move.b #0x40,d4 - bsr sd_com - move.b #00,d4 - bsr sd_com - move.b #00,d4 - bsr sd_com - move.b #00,d4 - bsr sd_com - move.b #00,d4 - bsr sd_com - move.b #0x95,d4 - bsr sd_com - - move.b #0xff,d4 // receive byt - bsr sd_com - cmp.b #0x01,d5 - beq idle_end - bsr sd_com - cmp.b #0x01,d5 - beq idle_end - bsr sd_com - cmp.b #0x01,d5 - beq idle_end - bsr sd_com - cmp.b #0x01,d5 - beq idle_end - bsr sd_com - cmp.b #0x01,d5 - beq idle_end - bsr sd_com - cmp.b #0x01,d5 - beq idle_end - subq.l #1,d6 - beq sd_not - bra sd_idle -idle_end: -// cdm 8 -read_ic: - move.b #0xff,d4 // receive byt - bsr sd_com - move.b #0x48,d4 - bsr sd_com - move.b #00,d4 - bsr sd_com - move.b #00,d4 - bsr sd_com - move.b #0x01,d4 - bsr sd_com - move.b #0xaa,d4 - bsr sd_com - move.b #0x87,d4 - bsr sd_com - - bsr sd_get_status - cmp.b #5,d5 - beq sd_v1 - cmp.b #1,d5 - bne read_ic - - move.b #0xff,d4 - bsr sd_com - move.b d5,d0 - bsr sd_com - move.b d5,d1 - bsr sd_com - move.b d5,d2 - bsr sd_com - cmp.b #0xaa,d5 - bne sd_testd3 - - move.l #'SDHC',(a6) - move.b #' ',(a6) -sd_v1: - -// cdm 58 -read_ocr: - move.b #0xff,d4 // receive byt - bsr sd_com - move.b #0x7a,d4 - bsr sd_com - move.b #00,d4 - bsr sd_com - move.b #00,d4 - bsr sd_com - move.b #0x00,d4 - bsr sd_com - move.b #0x00,d4 - bsr sd_com - move.b #0x01,d4 - bsr sd_com - - bsr sd_get_status - move.l #'Ver1',d6 - cmp.b #5,d5 - beq read_ocr - cmp.b #1,d5 - bne read_ocr - - move.b #0xff,d4 - bsr sd_com - move.b d5,d0 - bsr sd_com - move.b d5,d1 - bsr sd_com - move.b d5,d2 - bsr sd_com - -// acdm 41 - move.l #20000,d6 // 20000 versuche ready can bis 1 sec gehen -wait_of_aktiv: - move.b #0xff,d4 // receive byt - bsr sd_com - move.b #0x77,d4 - bsr sd_com - move.b #00,d4 - bsr sd_com - move.b #00,d4 - bsr sd_com - move.b #00,d4 - bsr sd_com - move.b #00,d4 - bsr sd_com - move.b #0x95,d4 - bsr sd_com - - bsr sd_get_status - cmp.b #0x05,d5 - beq wait_of_aktiv - -wait_of_aktiv2: - move.b #0xff,d4 // receive byt - bsr sd_com - move.b #0x69,d4 - bsr sd_com - move.b #0x40,d4 - bsr sd_com - move.b #0x00,d4 - bsr sd_com - move.b #0x00,d4 - bsr sd_com - move.b #0x00,d4 - bsr sd_com - move.b #0x95,d4 - bsr sd_com - - bsr sd_get_status - tst.b d5 - beq sd_init_ok - cmp.b #0x05,d5 - beq wait_of_aktiv2 - subq.l #1,d6 - bne wait_of_aktiv -sd_testd3: - subq.l #1,d3 - bne sd_idle - bra sd_error - -sd_init_ok: -// cdm 10 -read_cid: - move.b #0xff,d4 // receive byt - bsr sd_com - move.b #0x4a,d4 - bsr sd_com - move.b #00,d4 - bsr sd_com - move.b #00,d4 - bsr sd_com - move.b #0x00,d4 - bsr sd_com - move.b #0x00,d4 - bsr sd_com - move.b #0x95,d4 - bsr sd_com - - move.l a5,a4 // adresse setzen - bsr sd_rcv_info - -// name ausgeben - lea 1(a5),a4 - moveq #7,d7 -sd_nam_loop: - move.b (a4)+,(a6) - subq.l #1,d7 - bne sd_nam_loop - move.b #' ',(a6) - -// cdm 9 -read_csd: - move.b #0xff,d4 // receive byt - bsr sd_com - move.b #0x49,d4 - bsr sd_com - move.b #00,d4 - bsr sd_com - move.b #00,d4 - bsr sd_com - move.b #0x00,d4 - bsr sd_com - move.b #0x00,d4 - bsr sd_com - move.b #0x01,d4 - bsr sd_com - - move.l a5,a4 // adresse setzen - bsr sd_rcv_info - - mvz.b (a5),d0 - lsr.l #6,d0 - - bne sd_csd2 // format v2 - move.l 6(a5),d1 - moveq #14,d0 // bit 73..62 c_size - lsr.l d0,d1 // bits extrahieren - and.l #0xfff,d1 // 12 bits - addq.l #1,d1 - mvz.w 9(a5),d0 - lsr.l #7,d0 // bits 49..47 - and.l #0x7,d0 // 3 bits - moveq.l #8,d2 // x256 (dif v1 v2) - sub.l d0,d2 - lsr.l d2,d1 - bra sd_print_size -sd_csd2: - mvz.w 8(a5),d1 - addq.l #1,d1 -sd_print_size: - swap d1 - lsl.l #1,d1 - bcc sd_16G - move.l #'32GB',(a6) - bra sd_ok -sd_16G: - lsl.l #1,d1 - bcc sd_8G - move.l #'16GB',(a6) - bra sd_ok -sd_8G: - lsl.l #1,d1 - bcc sd_4G - move.l #' 8GB',(a6) - bra sd_ok -sd_4G: - lsl.l #1,d1 - bcc sd_2G - move.l #' 4GB',(a6) - bra sd_ok -sd_2G: - lsl.l #1,d1 - bcc sd_1G - move.l #' 2GB',(a6) - bra sd_ok -sd_1G: - lsl.l #1,d1 - bcc sd_512M - move.l #' 1GB',(a6) - bra sd_ok -sd_512M: - lsl.l #1,d1 - bcc sd_256M - move.b #'5',(a6) - move.l #'12MB',(a6) - bra sd_ok -sd_256M: - lsl.l #1,d1 - bcc sd_128M - move.b #'2',(a6) - move.l #'56MB',(a6) - bra sd_ok -sd_128M: - lsl.l #1,d1 - bcc sd_64M - move.b #'1',(a6) - move.l #'28MB',(a6) - bra sd_ok -sd_64M: - lsl.l #1,d1 - bcc sd_32M - move.l #'64MB',(a6) - bra sd_ok -sd_32M: - lsl.l #1,d1 - bcc sd_16M - move.l #'32MB',(a6) - bra sd_ok -sd_16M: - lsl.l #1,d1 - bcc sd_8M - move.l #'16MB',(a6) - bra sd_ok -sd_8M: - move.l #'<9MB',(a6) -sd_ok: - move.l #' OK!',(a6) - move.l #0x0a0d,(a6) - halt - halt - rts -// subs ende ------------------------------- -sd_V1: - move.l #'non!',(a6) - move.l #0x0a0d,(a6) - halt - halt - rts -sd_error: - move.l #'Erro',(a6) - move.l #'r!',(a6) - move.l #0x0a0d,(a6) - halt - halt - rts -sd_not: - move.l #'non!',(a6) - move.l #0x0a0d,(a6) - halt - halt - rts - -// status holen ------------------------------- -sd_get_status: - move.b #0xff,d4 - bsr sd_com - cmp.b #0xff,d5 - beq sd_get_status - rts -// byt senden und holen --------------------- -sd_com: - move.l d4,dspi_dtfr(a0) -wait_auf_complett: - btst.b #7,dspi_dsr(a0) - beq wait_auf_complett - move.l dspi_drfr(a0),d5 - mov3q.l #-1,dspi_dsr(a0) // clr status register - rts - -// daten holen ---------------------------- -sd_rcv_info: - moveq #18,d3 // 16 byts + 2 byts crc - move.b #0xff,d4 -sd_rcv_rb_w: - bsr sd_get_status - cmp.b #0xfe,d5 // daten bereit? - bne sd_rcv_rb_w // nein-> -sd_rcv_rd_rb: - bsr sd_com - move.b d5,(a4)+ - subq.l #1,d3 - bne sd_rcv_rd_rb - rts -/******************************************/ diff --git a/sources/sd_ide.s b/sources/sd_ide.s deleted file mode 100644 index 4d31184..0000000 --- a/sources/sd_ide.s +++ /dev/null @@ -1,458 +0,0 @@ - - -//.include "startcf.h" - -//.extern ___MBAR -//#define MCF_SLT0_SCNT ___MBAR+0x908 - -//.global ide_test - -.text -/* -sd_test: - clr.w MCF_PAD_PAR_DSPI - lea MCF_GPIO_PPDSDR_DSPI,a2 // data in - lea MCF_GPIO_PODR_DSPI,a1 // data out - move.b #0x00,(a1) // alle auf 0 - lea MCF_GPIO_PDDR_DSPI,a0 - move.b #0x7d,(a0) // din = input rest output - - bsr warten_20ms - - move.b #0x7f,(a1) // alle auf 1 - - bsr sd_16clk - bsr sd_16clk - bsr sd_16clk - bsr sd_16clk - bsr sd_16clk - bsr sd_16clk - bsr sd_16clk - bsr sd_16clk -// sd idle -sd_idle: - bsr sd_16clk - moveq #0x40,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #0x95,d4 - bsr sd_com - - bsr sd_receive - - cmp.b #0x05,d5 - beq sd_test - cmp.b #0x01,d5 - beq wait_of_aktiv - cmp.b #0x04,d5 - beq sd_init_ok - cmp.b #0x00,d5 - beq sd_init_ok - bra sd_idle - -// acdm 41 -wait_of_aktiv: - bsr sd_16clk - - moveq #0x77,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #0x01,d4 - bsr sd_com - - bsr sd_receive - - bsr sd_16clk - - move.l #0xff,d6 - moveq #0x69,d4 - bsr sd_com - and d5,d6 - moveq #00,d4 - bsr sd_com - and d5,d6 - moveq #00,d4 - bsr sd_com - and d5,d6 - moveq #0x02,d4 - bsr sd_com - and d5,d6 - moveq #00,d4 - bsr sd_com - and d5,d6 - moveq #0x01,d4 - bsr sd_com - and d5,d6 - - bsr sd_receive - - cmp.b #0x00,d5 - beq sd_init_ok - cmp.b #0x05,d5 - beq sd_test - bra wait_of_aktiv - -sd_init_ok: - -// blockgrösse 512byt -sd_bg: - bsr sd_16clk - moveq #0x50,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #02,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #0x01,d4 - bsr sd_com - - bsr sd_receive - - cmp.b #0x00,d5 - bne sd_bg - -// read block -sd_rb: - bsr sd_16clk - moveq #0x51,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #0x08,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #0x01,d4 - bsr sd_com - - bsr sd_receive - - cmp.b #0x00,d5 - bne sd_rb - - lea 0xc00000,a4 - move.l #513,d7 -rd_rb: - bsr sd_receive - move.b d5,(a4)+ - subq.l #1,d7 - bne rd_rb - -// write block -sd_wb: - bsr sd_16clk - moveq #0x58,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #0x08,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #0x01,d4 - bsr sd_com - - bsr sd_receive - - cmp.b #0x00,d5 - bne sd_wb - - lea 0xc00000,a4 - move.l #513,d7 - moveq.l #0x66,d4 -wr_wb: - bsr sd_com -// subq.l #1,d4 - moveq #0x66,d4 - subq.l #1,d7 - bne wr_wb - - bsr sd_receive - -wr_wb_el: - moveq #0xff,d4 - bsr sd_com - cmp.b #0xff,d5 - bne wr_wb_el - - -// read block 2 -sd_rb2: - bsr sd_16clk - moveq #0x51,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #0x08,d4 - bsr sd_com - moveq #00,d4 - bsr sd_com - moveq #0x01,d4 - bsr sd_com - - bsr sd_receive - - cmp.b #0x00,d5 - bne sd_rb2 - - lea 0xc00400,a4 - move.l #513,d7 -rd_rb2: - bsr sd_receive - move.b d5,(a4)+ - subq.l #1,d7 - bne rd_rb2 - - - nop - nop - - rts - -sd_receive: - moveq #0xff,d4 - bsr sd_com - cmp.b #0xff,d5 - beq sd_receive - rts - -sd_com: - bclr.b #6,(a1) -sd_comb: - bsr warten_10us - moveq #7,d2 - clr.l d5 -sd_com_loop: - btst d2,d4 - beq sd_com2 - bset.b #0,(a1) - bra sd_com2_1 -sd_com2: - bclr.b #0,(a1) -sd_com2_1: - bsr sd_clk - and.l #0x02,d3 - beq sd_com3 - bset.b d2,d5 -sd_com3: - subq.l #1,d2 - bge sd_com_loop - bsr warten_10us - bset.b #6,(a1) - bset.b #0,(a1) - bsr warten_200us - rts -sd_clk: - tst.b 0xfffff700 - tst.b 0xfffff700 - bset.b #2,(a1) - tst.b 0xfffff700 - tst.b 0xfffff700 - move.b (a2),d3 - tst.b 0xfffff700 - bclr.b #2,(a1) - rts - -sd_15clk: - move #15,d0 - bra sd_16clk -sd_16clk: - moveq #16,d0 -sd_16clk1: - bsr sd_clk - subq.l #1,d0 - bne sd_16clk1 - bsr warten_10us - rts -// warteschleife ca. 20ms -warten_20ms: - move.l a0,-(sp) - move.l d6,-(sp) - move.l d1,-(sp) - move.l d0,-(sp) - lea MCF_SLT0_SCNT,a0 - move.l (a0),d0 - move.l #700000,d6 - bra warten_loop -// warteschleife ca. 200us -warten_200us: - move.l a0,-(sp) - move.l d6,-(sp) - move.l d1,-(sp) - move.l d0,-(sp) - lea MCF_SLT0_SCNT,a0 - move.l (a0),d0 - move.l #7000,d6 - bra warten_loop -// warteschleife ca. 10us -warten_10us: - move.l a0,-(sp) - move.l d6,-(sp) - move.l d1,-(sp) - move.l d0,-(sp) - lea MCF_SLT0_SCNT,a0 - move.l (a0),d0 - move.l #333,d6 -warten_loop: - move.l (a0),d1 - sub.l d0,d1 - add.l d6,d1 - bpl warten_loop - move.l (sp)+,d0 - move.l (sp)+,d1 - move.l (sp)+,d6 - move.l (sp)+,a0 - rts; -/********************************************************************/ -#define cmd_reg (0x1d) -#define status_reg (0x1d) -#define seccnt (0x09) - -ide_test: - lea 0xfff00040,a0 - lea 0xc00000,a1 - move.b #0xec,cmd_reg(a0) //identify devcie cmd - bsr wait_int - bsr ds_rx -// read sector normal - move.b #1,seccnt(a0) // 1 sector - move.b #0x20,cmd_reg(a0) // read cmd - bsr wait_int - bsr ds_rx - -// write testpattern sector - move.b #1,seccnt(a0) // 1 sector - move.b #0x30,cmd_reg(a0) // write cmd - bsr drq_wait -// write pattern - move.l #256,d0 -ide_test_loop3: - move.w #0xa55a,(a0) - subq.l #1,d0 - bne ide_test_loop3 - bsr wait_int -// read testpattern sector - move.b #1,seccnt(a0) // 1 sector - move.b #0x20,cmd_reg(a0) // read - bsr wait_int - bsr ds_rx -// sector restauriern - move.b #1,seccnt(a0) // 1 sector - move.b #0x30,cmd_reg(a0) // write - lea -0x400(a1),a1 // vorletzer - bsr drq_wait - bsr ds_tx - bsr wait_int -// fertig und zurück - nop - rts -// wait auf int -wait_int: - move.b 0xfffffa01,d0 - btst #5,d0 - bne wait_int - move.b status_reg(a0),d0 - rts -// wait auf drq -drq_wait: - move.b status_reg(a0),d0 - btst #3,d0 - beq drq_wait - rts - -// 1 sector lesen word -ds_rx: - move.l #256,d0 -ds_rx_loop: - move.w (a0),(a1)+ - subq.l #1,d0 - bne ds_rx_loop - rts -// 1 sector lesen long -ds_rxl: - move.l #128,d0 -ds_rxl_loop: - move.l (a0),(a1)+ - subq.l #1,d0 - bne ds_rxl_loop - rts -// 1 sector schreiben word -ds_tx: - move.l #256,d0 -ds_tx_loop: - move.w (a1)+,(a0) - subq.l #1,d0 - bne ds_tx_loop - rts -// 1 sector schreiben word -ds_txl: - move.l #128,d0 -ds_txl_loop: - move.l (a1)+,(a0) - subq.l #1,d0 - bne ds_txl_loop - rts -// warteschleife ca. 20ms -warten_20ms: - move.l a0,-(sp) - move.l d6,-(sp) - move.l d1,-(sp) - move.l d0,-(sp) - lea MCF_SLT0_SCNT,a0 - move.l (a0),d0 - move.l #700000,d6 - bra warten_loop -// warteschleife ca. 200us -warten_200us: - move.l a0,-(sp) - move.l d6,-(sp) - move.l d1,-(sp) - move.l d0,-(sp) - lea MCF_SLT0_SCNT,a0 - move.l (a0),d0 - move.l #7000,d6 - bra warten_loop -// warteschleife ca. 10us -warten_10us: - move.l a0,-(sp) - move.l d6,-(sp) - move.l d1,-(sp) - move.l d0,-(sp) - lea MCF_SLT0_SCNT,a0 - move.l (a0),d0 - move.l #333,d6 -warten_loop: - move.l (a0),d1 - sub.l d0,d1 - add.l d6,d1 - bpl warten_loop - move.l (sp)+,d0 - move.l (sp)+,d1 - move.l (sp)+,d6 - move.l (sp)+,a0 - rts; -/********************************************************************/ diff --git a/sources/set_ide_access_mode.c b/sources/set_ide_access_mode.c new file mode 100644 index 0000000..9e779e7 --- /dev/null +++ b/sources/set_ide_access_mode.c @@ -0,0 +1,134 @@ + +/****************************************** +// setze zugriffsgeschwindigkeit cf card +/********************************************************************/ + +#include "MCF5475.h" + +#define error_reg (0x05) +#define seccnt (0x09) +#define stasec (0x0d) +#define cmd_reg (0x1d) +#define status_reg (0x1d) +#define wati (200) + +extern void warte_10ms(); +extern void warte_10us(); + +void ds_rx(void) +{ + asm + { +// 1 sector lesen word + ds_rx: + move.l #128,d0 + move.l a1,a0 + ds_rx_loop: + move.l (a2),(a0)+ + subq.l #1,d0 + bne ds_rx_loop + } + +}; + +void test_drive(void) +{ + asm + { + moveq.l #11,d1 // default access (3) mode not wait (+8) +// reset + ide_reset: + clr.b 0x19(a2) + move.b #0x8,cmd_reg(a2) // device reset + move.l #wati,d0 // max. 2s warten + wait_ready: + tst.b status_reg(a2) // comando fertig? + bpl ide_ready // nein + subq.l #1,d0 + bmi dam_nok // nicht da -> default werwenden + bsr warte_10ms + bra wait_ready + + ide_ready: + clr.b 0x19(a2) + move.b #0xec,cmd_reg(a2) // identify devcie + move.l #wati,d0 // max. 2s warten + wait_busy: + tst.b status_reg(a2) // laufwerk bereit? + bpl ide_busy + subq.l #1,d0 + bmi dam_nok // nicht da -> default werwenden + bsr warte_10ms + bra wait_busy + ide_busy: + clr.l (a1) + btst #3,status_reg(a2) + beq non_data + bsr ds_rx + tst.l (a1) + bne dam_ok + non_data: + subq.l #1,d3 + bmi dam_nok + bra ide_ready + dam_ok: + tst.b status_reg(a2) // interrupt rückstellen + + lea MCF_PSC0_PSCTB_8BIT,a2 // name ausgeben + lea 54(a1),a0 + moveq.l #40,d0 + name_loop: + move.b (a0)+,(a2) + subq.l #1,d0 + bne name_loop + move.l #' OK!',(a2) + move.l #0x0a0d,(a2) + + moveq.l #3,d1 + clr.l d0 + move.w 2*68(a1),d0 // pio cycle time + lsr.l #5,d0 // :32(ns) + subq.l #1,d0 + bmi siam_fertig + move.w d0,d1 + siam_fertig: + cmp.w #3,d1 // grösser als max? + ble dam_nok + moveq.l #3,d1 // sonst default + dam_nok: + } +}; + + +void set_ide_access_mode(void) +{ + + asm + { + lea 0xf0040000,a3 + bset.b #1,(a3) // ide reset + bsr warte_10ms + move.w #0x1033,(a3) // 1.cf 2.ide, ide int activ, scsi int disable, speed = min + bsr warte_10ms + lea 0xfff00000,a2 + lea 0xc00000,a1 + } + test_drive(); + asm + { + move.b d1,d2 + } + asm + { + lea 0xfff00040,a2 + lea 0xc00000,a1 + } + test_drive(); + asm + { + lsl.l #4,d1 + or.l d1,d2 + move.b d2,1(a3) + } +/********************************************************************/ +}; diff --git a/sources/startcf.c b/sources/startcf.c index 7249338..768d6c8 100644 --- a/sources/startcf.c +++ b/sources/startcf.c @@ -19,11 +19,12 @@ #ifdef __cplusplus #pragma cplusplus off #endif -#pragma PID off +#pragma PID off #pragma PIC off #include "MCF5475.h" - +#include "startcf.h" +#include "RuntimeConfig.h" /* imported data */ @@ -31,53 +32,99 @@ extern unsigned long far _SP_INIT, _SDA_BASE; extern unsigned long far _START_BSS, _END_BSS; extern unsigned long far _START_SBSS, _END_SBSS; extern unsigned long far __DATA_RAM, __DATA_ROM, __DATA_END; -extern unsigned long far __Bas_base; extern unsigned long far __SUP_SP,__BOOT_FLASH; extern unsigned long far rt_mbar; +extern unsigned long far _S_romp; /* imported routines */ -extern int BaS(int, char **); /* exported routines */ extern void __initialize_hardware(void); -extern void init_slt(void); +extern void BaS(void); void _startup(void) { asm -{ - bra warmstart - jmp __BOOT_FLASH + 8 // ist zugleich reset vector - /* disable interrupts */ -warmstart: -// disable interrupts - move.w #0x2700,sr -// Initialize MBAR - MOVE.L #__MBAR,D0 - MOVEC D0,MBAR - move.l d0,rt_mbar -// mmu off - move.l #__MMUBAR+1,d0 - movec d0,MMUBAR //mmubar setzen - clr.l d0 - move.l d0,MCF_MMU_MMUCR // mmu off - /* Initialize RAMBARs: locate SRAM and validate it */ \ - move.l #__RAMBAR0 + 0x7,d0 // supervisor only - movec d0,RAMBAR0 - move.l #__RAMBAR1 + 0x1,d0 // on for all - movec d0,RAMBAR1 + { + bra warmstart + jmp __BOOT_FLASH + 8 // ist zugleich reset vector + /* disable interrupts */ + warmstart: + // disable interrupts + move.w #0x2700,sr + // Initialize MBAR + MOVE.L #__MBAR,D0 + MOVEC D0,MBAR + move.l d0,rt_mbar + // mmu off + move.l #__MMUBAR+1,d0 + movec d0,MMUBAR //mmubar setzen + clr.l d0 + move.l d0,MCF_MMU_MMUCR // mmu off + /* Initialize RAMBARs: locate SRAM and validate it */ \ + move.l #__RAMBAR0 + 0x7,d0 // supervisor only + movec d0,RAMBAR0 + move.l #__RAMBAR1 + 0x1,d0 // on for all + movec d0,RAMBAR1 -// STACKPOINTER AUF ENDE SRAM1 - lea __SUP_SP,a7 + // STACKPOINTER AUF ENDE SRAM1 + lea __SUP_SP,a7 + +// hardware initieren + jsr __initialize_hardware + + // STACKPOINTER AUF ENDE SRAM1 + lea __SUP_SP,a7 + + /* setup A6 dummy stackframe */ + movea.l #0,a6 + link a6,#0 + + /* setup A5 */ + lea _SDA_BASE,a5 + + +/* copy all ROM sections to their RAM locations ... */ + /* + * _S_romp is a null terminated array of + * typedef struct RomInfo { + * unsigned long Source; + * unsigned long Target; + * unsigned long Size; + * } RomInfo; + * + * Watch out if you're rebasing using _PICPID_DELTA + */ + lea _S_romp, a0 + move.l (a0),a1 + move.l 4(a0),a2 + move.l 8(a0),d0 + lsr.l #2,d0 + crr_loop: + move.l (a1)+,(a2)+ + subq.l #1,d0 + bne crr_loop + + /* call main(int, char **) */ + pea __argv + clr.l -(sp) /* clearing a long is ok since it's caller cleanup */ + jsr BaS + addq.l #8, sp -// instruction cache on - move.l #0x000C8100,d0 - movec d0,cacr - nop -// initialize any hardware specific issues - bra __initialize_hardware + unlk a6 + + /* should never reach here but just in case */ + jsr warmstart + illegal + rts + + /* exit will never return */ + __argv: + dc.l 0 + }; } -} \ No newline at end of file + + diff --git a/sources/sysinit.c b/sources/sysinit.c index 18fd613..babebc0 100644 --- a/sources/sysinit.c +++ b/sources/sysinit.c @@ -7,18 +7,20 @@ */ #include "MCF5475.h" #include "startcf.h" - +#include "RuntimeConfig.h" extern unsigned long far __VRAM; -extern unsigned long far __Bas_base; -extern unsigned long far BaS; extern unsigned long far __BOOT_FLASH[]; -extern int copy_end(); -extern int warte_10us(); -extern int warte_1ms(); -extern int warte_10ms(); -extern int warte_50us(); + +extern void warte_10us(); +extern void warte_1ms(); +extern void set_ide_access_mode(); extern unsigned long far rt_cacr; +extern unsigned long far rt_acr0; +extern unsigned long far rt_acr1; +extern unsigned long far rt_acr2; +extern unsigned long far rt_acr3; +extern unsigned long far rt_mmubar; /********************************************************************/ // init SLICE TIMER 0 @@ -119,7 +121,17 @@ void init_seriel(void) MCF_PSC3_PSCCR = 0x05; MCF_INTC_ICR32 = 0x3F; //MAXIMALE PRIORITY/**********/ - MCF_PSC0_PSCTB_8BIT = 0x0a0d; + MCF_PSC0_PSCTB_8BIT = 0x0a0a0a0d; + MCF_PSC0_PSCTB_8BIT = 'BaS '; + MCF_PSC0_PSCTB_8BIT = '13.0'; + MCF_PSC0_PSCTB_8BIT = '5.20'; + MCF_PSC0_PSCTB_8BIT = '17'; + MCF_PSC0_PSCTB_8BIT = 0x0a0d; + MCF_PSC0_PSCTB_8BIT = '===='; + MCF_PSC0_PSCTB_8BIT = '===='; + MCF_PSC0_PSCTB_8BIT = '===='; + MCF_PSC0_PSCTB_8BIT = '=='; + MCF_PSC0_PSCTB_8BIT = 0x0a0d; MCF_PSC0_PSCTB_8BIT = 'SERI'; MCF_PSC0_PSCTB_8BIT = 'AL O'; MCF_PSC0_PSCTB_8BIT = 'K! '; @@ -175,39 +187,43 @@ void init_ddram(void) /********************************************************************/ void init_fbcs() { - MCF_PSC0_PSCTB_8BIT = 'FBCS'; - /* Flash */ - MCF_FBCS0_CSAR = 0xE0000000; // FLASH ADRESS - MCF_FBCS0_CSCR = 0x00001180; // 16 bit 4ws aa - MCF_FBCS0_CSMR = 0x007F0001; // 8MB on + MCF_PSC0_PSCTB_8BIT = 'FBCS'; - MCF_FBCS1_CSAR = 0xFFF00000; // ATARI I/O ADRESS + MCF_FBCS1_CSAR = 0xFFF80000; // FFF8'0000-FFFF'FFFF: ATARI I/O ADRESS MCF_FBCS1_CSCR = MCF_FBCS_CSCR_PS_16 // 16BIT PORT - | MCF_FBCS_CSCR_WS(8) // DEFAULT 8WS - | MCF_FBCS_CSCR_AA; // AA - MCF_FBCS1_CSMR = (MCF_FBCS_CSMR_BAM_1M + | MCF_FBCS_CSCR_WS(63) // DEFAULT 63WS + | MCF_FBCS_CSCR_AA; // AA + MCF_FBCS1_CSMR = (MCF_FBCS_CSMR_BAM_512K | MCF_FBCS_CSMR_V); MCF_FBCS2_CSAR = 0xF0000000; // NEUER I/O ADRESS-BEREICH MCF_FBCS2_CSCR = MCF_FBCS_CSCR_PS_32 // 32BIT PORT - | MCF_FBCS_CSCR_WS(8) // DEFAULT 4WS + | MCF_FBCS_CSCR_WS(8) // DEFAULT 8WS | MCF_FBCS_CSCR_AA; // AA MCF_FBCS2_CSMR = (MCF_FBCS_CSMR_BAM_128M // F000'0000-F7FF'FFFF | MCF_FBCS_CSMR_V); - MCF_FBCS3_CSAR = 0xF8000000; // NEUER I/O ADRESS-BEREICH + MCF_FBCS3_CSAR = 0xFFF00000; // IDE I/O ADRESS-BEREICH BURST! MCF_FBCS3_CSCR = MCF_FBCS_CSCR_PS_16 // 16BIT PORT + | MCF_FBCS_CSCR_WS(16) // DEFAULT 16WS + | MCF_FBCS_CSCR_BSTR // Burst read enable + | MCF_FBCS_CSCR_BSTW // Burst write enable | MCF_FBCS_CSCR_AA; // AA - MCF_FBCS3_CSMR = (MCF_FBCS_CSMR_BAM_64M // F800'0000-FBFF'FFFF + MCF_FBCS3_CSMR = (MCF_FBCS_CSMR_BAM_512K // FFF0'0000-FFF7'FFFF | MCF_FBCS_CSMR_V); - MCF_FBCS4_CSAR = 0x40000000; // VIDEO RAM BEREICH, #FB_CS3 WIRD NICHT BENÜTZT, DECODE DIREKT AUF DEM FPGA + MCF_FBCS4_CSAR = 0x40000000; // VIDEO RAM BEREICH, MCF_FBCS4_CSCR = MCF_FBCS_CSCR_PS_32 // 32BIT PORT | MCF_FBCS_CSCR_BSTR // BURST READ ENABLE | MCF_FBCS_CSCR_BSTW; // BURST WRITE ENABLE MCF_FBCS4_CSMR = (MCF_FBCS_CSMR_BAM_1G // 4000'0000-7FFF'FFFF | MCF_FBCS_CSMR_V); + /* Flash */ + MCF_FBCS0_CSAR = 0xE0000000; // FLASH ADRESS + MCF_FBCS0_CSCR = 0x00001180; // 16 bit 4ws aa + MCF_FBCS0_CSMR = 0x007F0001; // 8MB on + MCF_PSC0_PSCTB_8BIT = ' OK!'; MCF_PSC0_PSCTB_8BIT = 0x0a0d; } @@ -241,23 +257,87 @@ test_STATUS: jsr warte_10us // warten lea 0xE0700000,a0 // startadresse fpga daten + moveq #0x4,d2 + moveq #0x6,d3 + moveq #0xc,d4 + moveq #0xe,d5 word_send_loop: cmp.l #0xE0800000,a0 bgt fpga_error move.b (a0)+,d0 // 32 bit holen - moveq #8,d1 // 32 bit ausgeben -bit_send_loop: lsr.l #1,d0 // bit rausschieben - bcs bit_is_1 - bclr #3,(a1) - bra bit_send -bit_is_1: - bset #3,(a1) -bit_send: - bset #1,(a1) // clock=high - bclr #1,(a1) // clock=low - subq.l #1,d1 - bne bit_send_loop // wiederholen bis fertig + bcs bit_is_10 // data bit3, #config bit2, clock bit1 + move.b d2,(a1) // data low, config high, clk low + move.b d3,(a1) // data low, config high, clk high + bra bit_send0 +bit_is_10: + move.b d4,(a1) // clk low, config high, data high + move.b d5,(a1) // clk high, config high, data high +bit_send0: + lsr.l #1,d0 // bit rausschieben + bcs bit_is_11 // data bit3, #config bit2, clock bit1 + move.b d2,(a1) // data low, config high, clk low + move.b d3,(a1) // data low, config high, clk high + bra bit_send1 +bit_is_11: + move.b d4,(a1) // clk low, config high, data high + move.b d5,(a1) // clk high, config high, data high +bit_send1: + lsr.l #1,d0 // bit rausschieben + bcs bit_is_12 // data bit3, #config bit2, clock bit1 + move.b d2,(a1) // data low, config high, clk low + move.b d3,(a1) // data low, config high, clk high + bra bit_send2 +bit_is_12: + move.b d4,(a1) // clk low, config high, data high + move.b d5,(a1) // clk high, config high, data high +bit_send2: + lsr.l #1,d0 // bit rausschieben + bcs bit_is_13 // data bit3, #config bit2, clock bit1 + move.b d2,(a1) // data low, config high, clk low + move.b d3,(a1) // data low, config high, clk high + bra bit_send3 +bit_is_13: + move.b d4,(a1) // clk low, config high, data high + move.b d5,(a1) // clk high, config high, data high +bit_send3: + lsr.l #1,d0 // bit rausschieben + bcs bit_is_14 // data bit3, #config bit2, clock bit1 + move.b d2,(a1) // data low, config high, clk low + move.b d3,(a1) // data low, config high, clk high + bra bit_send4 +bit_is_14: + move.b d4,(a1) // clk low, config high, data high + move.b d5,(a1) // clk high, config high, data high +bit_send4: + lsr.l #1,d0 // bit rausschieben + bcs bit_is_15 // data bit3, #config bit2, clock bit1 + move.b d2,(a1) // data low, config high, clk low + move.b d3,(a1) // data low, config high, clk high + bra bit_send5 +bit_is_15: + move.b d4,(a1) // clk low, config high, data high + move.b d5,(a1) // clk high, config high, data high +bit_send5: + lsr.l #1,d0 // bit rausschieben + bcs bit_is_16 // data bit3, #config bit2, clock bit1 + move.b d2,(a1) // data low, config high, clk low + move.b d3,(a1) // data low, config high, clk high + bra bit_send6 +bit_is_16: + move.b d4,(a1) // clk low, config high, data high + move.b d5,(a1) // clk high, config high, data high +bit_send6: + lsr.l #1,d0 // bit rausschieben + bcs bit_is_17 // data bit3, #config bit2, clock bit1 + move.b d2,(a1) // data low, config high, clk low + move.b d3,(a1) // data low, config high, clk high + bra bit_send7 +bit_is_17: + move.b d4,(a1) // clk low, config high, data high + move.b d5,(a1) // clk high, config high, data high +bit_send7: +// test auf fertig btst #5,(a2) // fpga fertig, conf_done=high? beq word_send_loop // nein, next word-> move.l #4000,d1 @@ -267,8 +347,31 @@ overclk: bclr #1,(a1) // clock=low subq.l #1,d1 bne overclk // weiter bis fertig +// datum des FPGA files ausgeben + jsr warte_10us // warten + lea MCF_PSC0_PSCTB_8BIT,a3 + move.l #': Da',(a3) + move.l #'te: ',(a3) + move.l 0xf0040100,d1 + moveq #8,d0 +date_loop: + btst #0,d0 + bne kein_punkt + btst #2,d0 + beq kein_punkt + move.b #'.',(a3) +kein_punkt: + move.l d0,d3 // index + subq.l #1,d3 // -1 + lsl.l #2,d3 // *2 + move.l d1,d2 + lsr.l d3,d2 // und schieben + and.l #0x0f,d2 + add.l #'0',d2 + move.b d2,(a3) + subq.l #1,d0 + bgt date_loop bra init_fpga_end - //--------------------------------------------------------- wait_pll: lea MCF_SLT0_SCNT,a3 @@ -322,7 +425,7 @@ asm move.w #1,0x44(a0) // M low = 1 bsr wait_pll - move.w #145,0x04(a0) // M high = 145 = 146MHz + move.w #65,0x04(a0) // M high = 65 = 65MHz bsr wait_pll clr.b (a1) // set @@ -368,7 +471,7 @@ void init_video_ddr(void) /********************************************************************/ /* video mit auflösung 1280x1000 137MHz /* /********************************************************************/ - +/* void video_1280_1024(void) { extern int wait_pll; @@ -381,7 +484,7 @@ extern int wait_pll; //testmuster 1 lea __VRAM,a2 - lea __VRAM+0x600000,a3 + lea __VRAM+0x120000,a3 clr.l d0 move.l #0x1000102,d1 loop5: move.l d0,(a2)+ @@ -409,35 +512,48 @@ flo6: cmp.l a2,a3 bgt loop5 // screen setzen -//horizontal 1280 +//horizontal 1024 lea 0xffff8282,a0 - move.w #1800,(a0)+ - move.w #1380,(a0)+ - move.w #99,(a0)+ - move.w #100,(a0)+ - move.w #1379,(a0)+ - move.w #1500,(a0) -//vertical 1024 + move.w #1344,(a0)+ + move.w #1184,(a0)+ + move.w #159,(a0)+ + move.w #160,(a0)+ + move.w #1183,(a0)+ + move.w #1208,(a0) +//vertical 768 lea 0xffff82a2,a0 - move.w #1150,(a0)+ - move.w #1074,(a0)+ - move.w #49,(a0)+ - move.w #50,(a0)+ - move.w #1073,(a0)+ - move.w #1100,(a0)+ + move.w #806,(a0)+ + move.w #797,(a0)+ + move.w #28,(a0)+ + move.w #29,(a0)+ + move.w #796,(a0)+ + move.w #800,(a0)+ // acp video on - move.l #0x01070207,d0 + move.l #0x0107820b,d0 // acp video, color1, pll pixelclk, dac on move.l d0,0xf0000400 - + lea 0xffff8200,a0 + clr.w (a0) + clr.b 3(a0) + clr.b 0xd(a0) + move.w #0x400,10(a0) + move.w #0x182,0xc0(a0) + clr.w 0xc2(a0) // clut setzen lea 0xf0000000,a0 move.l #0xffffffff,(a0)+ move.l #0xff,(a0)+ move.l #0xff00,(a0)+ move.l #0xff0000,(a0) - -// halt +/* + lea 0xffff8200,a0 + move.w #6,0xc0(a0) + move.w #7,0x40(a0) + move.w #7,0x42(a0) + move.w #7,0x44(a0) + move.w #7,0x46(a0) + move.b #1,0x60(a0) + halt } @@ -767,70 +883,64 @@ ac97_end: } /********************************************************************/ - void __initialize_hardware(void) { _init_hardware: -asm -{ - // instruction cache on - move.l #0x000C8120,d0 + init_ddram(); + asm + { + // instruction cache on + move.l #0x007fe000,d0 + movec d0,acr0 + move.l d0,rt_acr0 + movec d0,acr2 + move.l d0,rt_acr2 + clr.l d0 + movec d0,acr1 + move.l d0,rt_acr1 + movec d0,acr3 + move.l d0,rt_acr3 + move.l d0,MCF_MMU_MMUCR + + + move.l #0x050c8120,d0 move.l d0,rt_cacr movec d0,cacr nop -} - init_gpio(); - init_seriel(); - init_slt(); - init_fbcs(); - init_ddram(); -// Ports nicht initialisieren wenn DIP Switch 5 = on -asm -{ - move.b DIP_SWITCH,d0 // dip schalter adresse - btst.b #6,d0 - beq not_init_ports -} + + } + init_gpio(); + init_seriel(); + init_slt(); + init_fbcs(); + + init_fpga(); + init_video_ddr(); + vdi_on(); + // Ports nicht initialisieren wenn DIP Switch 6 = on + asm + { + // IDE reset + lea 0xffff8802,a0 // IDE reset + move.b #14,-2(a0) + move.b #0x80,(a0) + bsr warte_1ms + clr.b (a0) + // dip switch + move.b DIP_SWITCH,d0 // dip schalter adresse + move.b d0,0xF0040002 // acp conf +2 + // ACP_CONF setzen und Ports nicht initialisieren wenn DIP Switch 6 = on + btst.b #6,d0 + beq not_init_ports + } init_PCI(); //pci braucht zeit - not_init_ports: - init_fpga(); - init_video_ddr(); - vdi_on(); -// Ports nicht initialisieren wenn DIP Switch 5 = on -asm -{ - move.b DIP_SWITCH,d0 // dip schalter adresse - btst.b #6,d0 - beq not_init_ports2 -} - test_upd720101(); -// video_1280_1024(); init_ac97(); -not_init_ports2: + test_upd720101(); +// video_1280_1024(); + asm + { +not_init_ports: + } + set_ide_access_mode(); -asm -{ -/*****************************************************/ -/* BaS kopieren -/*****************************************************/ - lea copy_start,a0 - lea BaS,a1 - sub.l a0,a1 - move.l #__Bas_base,a2 - move.l a2,a3 - add.l a1,a3 - lea copy_end,a4 -BaS_kopieren_loop: // immer 16 bytes - move.l (a0)+,(a2)+ - move.l (a0)+,(a2)+ - move.l (a0)+,(a2)+ - move.l (a0)+,(a2)+ - cmp.l a4,a0 - blt BaS_kopieren_loop -/*****************************************************/ - jmp (a3) - copy_start: -/********************************************************************/ } -} - diff --git a/sources/sysinit.c.alt b/sources/sysinit.c.alt new file mode 100644 index 0000000..6527b6c --- /dev/null +++ b/sources/sysinit.c.alt @@ -0,0 +1,874 @@ +/* + * File: sysinit.c + * Purpose: Power-on Reset configuration of the COLDARI board. + * + * Notes: + * + */ +#include "MCF5475.h" +#include "startcf.h" +#include "RuntimeConfig.h" +extern unsigned long far __VRAM; +extern unsigned long far __BOOT_FLASH[]; + +extern void warte_10us(); +extern void set_ide_access_mode(); + +extern unsigned long far rt_cacr; +extern unsigned long far rt_acr0; +extern unsigned long far rt_acr1; +extern unsigned long far rt_acr2; +extern unsigned long far rt_acr3; +extern unsigned long far rt_mmubar; + +/********************************************************************/ +// init SLICE TIMER 0 +// all = 32.538 sec = 30.736mHz +// BYT0 = 127.1ms/tick = 7.876Hz offset 0 +// BYT1 = 496.5us/tick = 2.014kHz offset 1 +// BYT2 = 1.939us/tick = 515.6kHz offset 2 +// BYT3 = 7.576ns/tick = 132.00MHz offset 3 +// count down!!! 132MHz!!! +/********************************************************************/ + +void init_slt(void) +{ + asm + { + lea MCF_SLT0_STCNT,a0 + move.l #0xffffffff,(a0) + lea MCF_SLT0_SCR,a0 + move.b #0x05,(a0) + + } + MCF_PSC0_PSCTB_8BIT = 'SLT '; + MCF_PSC0_PSCTB_8BIT = 'OK! '; + MCF_PSC0_PSCTB_8BIT = 0x0a0d; +} + +/********************************************************************/ +// init GPIO ETC. +/********************************************************************/ + +void init_gpio(void) +{ + + +// PAD REGISTER P.S.:FBCTL UND FBCS WERDEN RICHTIG GESETZT BEIM RESET + MCF_PAD_PAR_DMA = 0b11111111; // NORMAL ALS DREQ DACK + MCF_PAD_PAR_FECI2CIRQ = 0b1111001111001111; // FEC0 NORMAL, FEC1 ALS I/O, I2C, #INT5..6 + MCF_PAD_PAR_PCIBG = 0b0000001000111111; // #PCI_BG4=#TBST,#PIC_BG3=I/O,#PCI_BG2..0=NORMAL + MCF_PAD_PAR_PCIBR = 0b0000001000111111; // #PCI_BR4=#INT4,#PIC_BR3=INPUT,#PCI_BR2..0=NORMAL + MCF_PAD_PAR_PSC3 = 0b00001100; // PSC3=TX,RX CTS+RTS=I/O + MCF_PAD_PAR_PSC1 = 0b11111100; // PSC1 NORMAL SERIELL + MCF_PAD_PAR_PSC0 = 0b11111100; // PSC0 NORMAL SERIELL + MCF_PAD_PAR_DSPI = 0b0001111111111111; // DSPI NORMAL + MCF_PAD_PAR_TIMER = 0b00101101; // TIN3..2=#IRQ3..2;TOUT3..2=NORMAL +// ALLE OUTPUTS NORMAL LOW + +// ALLE DIR NORMAL INPUT = 0 + MCF_GPIO_PDDR_FEC1L = 0b00011110; // OUT: 4=LED,3=PRG_DQ0,2=#FPGA_CONFIG,1=PRG_CLK(FPGA) + +} + +/********************************************************************/ +// init seriel +/********************************************************************/ + +void init_seriel(void) +{ + +// PSC0: SER1 ---------- + MCF_PSC0_PSCSICR = 0; // UART + MCF_PSC0_PSCCSR = 0xDD; + MCF_PSC0_PSCCTUR = 0x00; + MCF_PSC0_PSCCTLR = 36; // BAUD RATE = 115200 + MCF_PSC0_PSCCR = 0x20; + MCF_PSC0_PSCCR = 0x30; + MCF_PSC0_PSCCR = 0x40; + MCF_PSC0_PSCCR = 0x50; + MCF_PSC0_PSCCR = 0x10; + MCF_PSC0_PSCIMR = 0x8700; + MCF_PSC0_PSCACR = 0x03; + MCF_PSC0_PSCMR1= 0xb3; + MCF_PSC0_PSCMR2= 0x07; + MCF_PSC0_PSCRFCR = 0x0F; + MCF_PSC0_PSCTFCR = 0x0F; + MCF_PSC0_PSCRFAR = 0x00F0; + MCF_PSC0_PSCTFAR = 0x00F0; + MCF_PSC0_PSCOPSET = 0x01; + MCF_PSC0_PSCCR = 0x05; +// PSC3: PIC ---------- + MCF_PSC3_PSCSICR = 0; // UART + MCF_PSC3_PSCCSR = 0xDD; + MCF_PSC3_PSCCTUR = 0x00; + MCF_PSC3_PSCCTLR = 36; // BAUD RATE = 115200 + MCF_PSC3_PSCCR = 0x20; + MCF_PSC3_PSCCR = 0x30; + MCF_PSC3_PSCCR = 0x40; + MCF_PSC3_PSCCR = 0x50; + MCF_PSC3_PSCCR = 0x10; + MCF_PSC3_PSCIMR = 0x0200; // receiver interrupt enable + MCF_PSC3_PSCACR = 0x03; + MCF_PSC3_PSCMR1= 0xb3; + MCF_PSC3_PSCMR2= 0x07; + MCF_PSC3_PSCRFCR = 0x0F; + MCF_PSC3_PSCTFCR = 0x0F; + MCF_PSC3_PSCRFAR = 0x00F0; + MCF_PSC3_PSCTFAR = 0x00F0; + MCF_PSC3_PSCOPSET = 0x01; + MCF_PSC3_PSCCR = 0x05; + MCF_INTC_ICR32 = 0x3F; //MAXIMALE PRIORITY/**********/ + + MCF_PSC0_PSCTB_8BIT = 0x0a0d; + MCF_PSC0_PSCTB_8BIT = 'SERI'; + MCF_PSC0_PSCTB_8BIT = 'AL O'; + MCF_PSC0_PSCTB_8BIT = 'K! '; + MCF_PSC0_PSCTB_8BIT = 0x0a0d; +} +/********************************************************************/ + /* Initialize DDR DIMMs on the EVB board */ +/********************************************************************/ + /* + * Check to see if the SDRAM has already been initialized + * by a run control tool + */ + + +void init_ddram(void) +{ + MCF_PSC0_PSCTB_8BIT = 'DDRA'; + if (!(MCF_SDRAMC_SDCR & MCF_SDRAMC_SDCR_REF)) + { + + /* Basic configuration and initialization */ + MCF_SDRAMC_SDRAMDS = 0x000002AA; // SDRAMDS configuration + MCF_SDRAMC_CS0CFG = 0x0000001A; // SDRAM CS0 configuration (128Mbytes 0000_0000 - 07FF_FFFF) + MCF_SDRAMC_CS1CFG = 0x0800001A; // SDRAM CS1 configuration (128Mbytes 0800_0000 - 0FFF_FFFF) + MCF_SDRAMC_CS2CFG = 0x1000001A; // SDRAM CS2 configuration (128Mbytes 1000_0000 - 07FF_FFFF) + MCF_SDRAMC_CS3CFG = 0x1800001A; // SDRAM CS3 configuration (128Mbytes 1800_0000 - 1FFF_FFFF) +// MCF_SDRAMC_SDCFG1 = 0x53722938; // SDCFG1 + MCF_SDRAMC_SDCFG1 = 0x73622830; // SDCFG1 +// MCF_SDRAMC_SDCFG2 = 0x24330000; // SDCFG2 + MCF_SDRAMC_SDCFG2 = 0x46770000; // SDCFG2 +// MCF_SDRAMC_SDCR = 0xE10F0002; // SDCR + IPALL + MCF_SDRAMC_SDCR = 0xE10D0002; // SDCR + IPALL + MCF_SDRAMC_SDMR = 0x40010000; // SDMR (write to LEMR) +// MCF_SDRAMC_SDMR = 0x05890000; // SDRM (write to LMR) + MCF_SDRAMC_SDMR = 0x048D0000; // SDRM (write to LMR) +// MCF_SDRAMC_SDCR = 0xE10F0002; // SDCR + IPALL + MCF_SDRAMC_SDCR = 0xE10D0002; // SDCR + IPALL +// MCF_SDRAMC_SDCR = 0xE10F0004; // SDCR + IREF (first refresh) + MCF_SDRAMC_SDCR = 0xE10D0004; // SDCR + IREF (first refresh) +// MCF_SDRAMC_SDCR = 0xE10F0004; // SDCR + IREF (second refresh) + MCF_SDRAMC_SDCR = 0xE10D0004; // SDCR + IREF (second refresh) +/// MCF_SDRAMC_SDMR = 0x01890000; // SDMR (write to LMR) + MCF_SDRAMC_SDMR = 0x008D0000; // SDMR (write to LMR) +// MCF_SDRAMC_SDCR = 0x710F0F00; // SDCR (lock SDMR and enable refresh) + MCF_SDRAMC_SDCR = 0x710D0F00; // SDCR (lock SDMR and enable refresh) + } + MCF_PSC0_PSCTB_8BIT = 'M OK'; + MCF_PSC0_PSCTB_8BIT = '! '; + MCF_PSC0_PSCTB_8BIT = 0x0a0d; +} +/********************************************************************/ + /* init FB_CSx /* +/********************************************************************/ +void init_fbcs() +{ + MCF_PSC0_PSCTB_8BIT = 'FBCS'; + + MCF_FBCS1_CSAR = 0xFFF00000; // ATARI I/O ADRESS + MCF_FBCS1_CSCR = MCF_FBCS_CSCR_PS_16 // 16BIT PORT + | MCF_FBCS_CSCR_WS(32) // DEFAULT 32WS + | MCF_FBCS_CSCR_BSTR // Burst read enable + | MCF_FBCS_CSCR_BSTW // Burst write enable + | MCF_FBCS_CSCR_AA; // AA + MCF_FBCS1_CSMR = (MCF_FBCS_CSMR_BAM_1M + | MCF_FBCS_CSMR_V); + + MCF_FBCS2_CSAR = 0xF0000000; // NEUER I/O ADRESS-BEREICH + MCF_FBCS2_CSCR = MCF_FBCS_CSCR_PS_32 // 32BIT PORT + | MCF_FBCS_CSCR_WS(8) // DEFAULT 8WS + | MCF_FBCS_CSCR_AA; // AA + MCF_FBCS2_CSMR = (MCF_FBCS_CSMR_BAM_128M // F000'0000-F7FF'FFFF + | MCF_FBCS_CSMR_V); + + MCF_FBCS3_CSAR = 0xF8000000; // NEUER I/O ADRESS-BEREICH + MCF_FBCS3_CSCR = MCF_FBCS_CSCR_PS_16 // 16BIT PORT + | MCF_FBCS_CSCR_WS(32) // DEFAULT 32WS + | MCF_FBCS_CSCR_BSTR // Burst read enable + | MCF_FBCS_CSCR_BSTW // Burst write enable + | MCF_FBCS_CSCR_AA; // AA + MCF_FBCS3_CSMR = (MCF_FBCS_CSMR_BAM_64M // F800'0000-FBFF'FFFF + | MCF_FBCS_CSMR_V); + + MCF_FBCS4_CSAR = 0x40000000; // VIDEO RAM BEREICH, + MCF_FBCS4_CSCR = MCF_FBCS_CSCR_PS_32 // 32BIT PORT + | MCF_FBCS_CSCR_BSTR // BURST READ ENABLE + | MCF_FBCS_CSCR_BSTW; // BURST WRITE ENABLE + MCF_FBCS4_CSMR = (MCF_FBCS_CSMR_BAM_1G // 4000'0000-7FFF'FFFF + | MCF_FBCS_CSMR_V); + + /* Flash */ + MCF_FBCS0_CSAR = 0xE0000000; // FLASH ADRESS + MCF_FBCS0_CSCR = 0x00001180; // 16 bit 4ws aa + MCF_FBCS0_CSMR = 0x007F0001; // 8MB on + + MCF_PSC0_PSCTB_8BIT = ' OK!'; + MCF_PSC0_PSCTB_8BIT = 0x0a0d; +} + +/********************************************************************/ + /* FPGA LADEN /* +/********************************************************************/ + + +void init_fpga(void) +{ + + MCF_PSC0_PSCTB_8BIT = 'FPGA'; +asm + { + lea MCF_GPIO_PODR_FEC1L,a1 // register adresse:write + lea MCF_GPIO_PPDSDR_FEC1L,a2 // reads + bclr #1,(a1) // clk auf low + bclr #2,(a1) // #config=low +test_nSTATUS: + btst #0,(a2) // nSTATUS==0 + bne test_nSTATUS // nein-> + btst #5,(a2) // conf done==0 + bne test_nSTATUS // nein-> + jsr warte_10us // warten + bset #2,(a1) // #config=high + jsr warte_10us // warten +test_STATUS: + btst #0,(a2) // status high? + beq test_STATUS // nein-> + jsr warte_10us // warten + + lea 0xE0700000,a0 // startadresse fpga daten +word_send_loop: + cmp.l #0xE0800000,a0 + bgt fpga_error + move.b (a0)+,d0 // 32 bit holen + moveq #8,d1 // 32 bit ausgeben +bit_send_loop: + lsr.l #1,d0 // bit rausschieben + bcs bit_is_1 + bclr #3,(a1) + bra bit_send +bit_is_1: + bset #3,(a1) +bit_send: + bset #1,(a1) // clock=high + bclr #1,(a1) // clock=low + subq.l #1,d1 + bne bit_send_loop // wiederholen bis fertig + btst #5,(a2) // fpga fertig, conf_done=high? + beq word_send_loop // nein, next word-> + move.l #4000,d1 +overclk: + bset #1,(a1) // clock=high + nop + bclr #1,(a1) // clock=low + subq.l #1,d1 + bne overclk // weiter bis fertig +// datum des FPGA files ausgeben + jsr warte_10us // warten + lea MCF_PSC0_PSCTB_8BIT,a3 + move.l #': Da',(a3) + move.l #'te: ',(a3) + move.l 0xf0040100,d1 + moveq #8,d0 +date_loop: + btst #0,d0 + bne kein_punkt + btst #2,d0 + beq kein_punkt + move.b #'.',(a3) +kein_punkt: + move.l d0,d3 // index + subq.l #1,d3 // -1 + lsl.l #2,d3 // *2 + move.l d1,d2 + lsr.l d3,d2 // und schieben + and.l #0x0f,d2 + add.l #'0',d2 + move.b d2,(a3) + subq.l #1,d0 + bgt date_loop + bra init_fpga_end +//--------------------------------------------------------- +wait_pll: + lea MCF_SLT0_SCNT,a3 + move.l (a3),d0 + move.l #100000,d6 // ca 1ms +wait_pll_loop: + tst.w (a1) + bpl wait_pll_ok + move.l (a3),d1 + sub.l d0,d1 + add.l d6,d1 + bpl wait_pll_loop +wait_pll_ok: + rts +// fertig +fpga_error: + } + MCF_PSC0_PSCTB_8BIT = ' NOT'; +init_fpga_end: + MCF_PSC0_PSCTB_8BIT = ' OK!'; + MCF_PSC0_PSCTB_8BIT = 0x0a0d; + +// init pll + MCF_PSC0_PSCTB_8BIT = 'PLL '; +asm +{ + lea 0xf0000600,a0 + lea 0xf0000800,a1 + bsr wait_pll + move.w #27,0x48(a0) // loopfilter r + bsr wait_pll + move.w #1,0x08(a0) // charge pump I + bsr wait_pll + move.w #12,0x0(a0) // N counter high = 12 + bsr wait_pll + move.w #12,0x40(a0) // N counter low = 12 + bsr wait_pll + move.w #1,0x114(a0) // ck1 bypass + bsr wait_pll + move.w #1,0x118(a0) // ck2 bypass + bsr wait_pll + move.w #1,0x11c(a0) // ck3 bypass + bsr wait_pll + move.w #1,0x10(a0) // ck0 high = 1 + bsr wait_pll + move.w #1,0x50(a0) // ck0 low = 1 + + bsr wait_pll + move.w #1,0x144(a0) // M odd division + bsr wait_pll + move.w #1,0x44(a0) // M low = 1 + + bsr wait_pll + move.w #65,0x04(a0) // M high = 65 = 65MHz + + bsr wait_pll + clr.b (a1) // set +} + MCF_PSC0_PSCTB_8BIT = 'SET!'; + MCF_PSC0_PSCTB_8BIT = 0x0a0d; +} + +/********************************************************************/ + /* INIT VIDEO DDR RAM /* +/********************************************************************/ + +void init_video_ddr(void) +{ + asm + { + +// init video ram + moveq.l #0xB,d0 + move.w d0,0xF0000400 //set cke=1, cs=1 config=1 + nop + lea __VRAM,a0 //zeiger auf video ram + nop + move.l #0x00050400,(a0) //IPALL + nop + move.l #0x00072000,(a0) //load EMR pll on + nop + move.l #0x00070122,(a0) //load MR: reset pll, cl=2 BURST=4lw + nop + move.l #0x00050400,(a0) //IPALL + nop + move.l #0x00060000,(a0) //auto refresh + nop + move.l #0x00060000,(a0) //auto refresh + nop + move.l #0000070022,(a0) //load MR dll on + nop + move.l #0x01070002,d0 // fifo on, refresh on, ddrcs und cke on, video dac on, + move.l d0,0xf0000400 + } +} + +/********************************************************************/ + /* video mit auflösung 1280x1000 137MHz /* +/********************************************************************/ + +void video_1280_1024(void) +{ +extern int wait_pll; + + asm + { + + +// SPEICHER FÜLLEM + +//testmuster 1 + lea __VRAM,a2 + lea __VRAM+0x120000,a3 + clr.l d0 + move.l #0x1000102,d1 +loop5: move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + move.l d0,(a2)+ + add.l d1,d0 +flo6: cmp.l a2,a3 + bgt loop5 + +// screen setzen +//horizontal 1024 + lea 0xffff8282,a0 + move.w #1344,(a0)+ + move.w #1184,(a0)+ + move.w #159,(a0)+ + move.w #160,(a0)+ + move.w #1183,(a0)+ + move.w #1208,(a0) +//vertical 768 + lea 0xffff82a2,a0 + move.w #806,(a0)+ + move.w #797,(a0)+ + move.w #28,(a0)+ + move.w #29,(a0)+ + move.w #796,(a0)+ + move.w #800,(a0)+ +// acp video on + move.l #0x0107820b,d0 // acp video, color1, pll pixelclk, dac on + move.l d0,0xf0000400 + + lea 0xffff8200,a0 + clr.w (a0) + clr.b 3(a0) + clr.b 0xd(a0) + move.w #0x400,10(a0) + move.w #0x182,0xc0(a0) + clr.w 0xc2(a0) +// clut setzen + lea 0xf0000000,a0 + move.l #0xffffffff,(a0)+ + move.l #0xff,(a0)+ + move.l #0xff00,(a0)+ + move.l #0xff0000,(a0) +/* + lea 0xffff8200,a0 + move.w #6,0xc0(a0) + move.w #7,0x40(a0) + move.w #7,0x42(a0) + move.w #7,0x44(a0) + move.w #7,0x46(a0) + move.b #1,0x60(a0) +*/ +// halt + + } + +} +/********************************************************************/ + /* INIT PCI /* +/********************************************************************/ + +#define PCI_MEMORY_OFFSET (0x80000000) +#define PCI_MEMORY_SIZE (0x40000000) +#define PCI_IO_OFFSET (0xD0000000) +#define PCI_IO_SIZE (0x10000000) + + +void init_PCI(void) +{ + + MCF_PSC0_PSCTB_8BIT = 'PCI '; +asm + { + // Setup the arbiter + move.l #MCF_PCIARB_PACR_INTMPRI \ + + MCF_PCIARB_PACR_EXTMPRI(0x1F) \ + + MCF_PCIARB_PACR_INTMINTEN \ + + MCF_PCIARB_PACR_EXTMINTEN(0x1F),D0 + move.l D0,MCF_PCIARB_PACR + // Setup burst parameters + move.l #MCF_PCI_PCICR1_CACHELINESIZE(4) + MCF_PCI_PCICR1_LATTIMER(32),D0 + move.l D0,MCF_PCI_PCICR1 + move.l #MCF_PCI_PCICR2_MINGNT(16) + MCF_PCI_PCICR2_MAXLAT(16),D0 + move.l D0,MCF_PCI_PCICR2 + // Turn on error signaling + move.l #MCF_PCI_PCIICR_TAE + MCF_PCI_PCIICR_IAE + MCF_PCI_PCIICR_REE + 32,D0 + move.l D0,MCF_PCI_PCIICR + move.l #MCF_PCI_PCIGSCR_SEE,D0 + or.l D0,MCF_PCI_PCIGSCR + // Configure Initiator Windows */ + move.l #PCI_MEMORY_OFFSET + ((PCI_MEMORY_SIZE - 1) >> 8),D0 + clr.w D0 + move.l D0,MCF_PCI_PCIIW0BTAR // Initiator Window 0 Base / Translation Address Register + + move.l #PCI_IO_OFFSET+((PCI_IO_SIZE-1)>>8),D0 + clr.w D0 + move.l D0,MCF_PCI_PCIIW1BTAR // Initiator Window 1 Base / Translation Address Register + + clr.l MCF_PCI_PCIIW2BTAR // not used + + move.l #MCF_PCI_PCIIWCR_WINCTRL0_MEMRDLINE + MCF_PCI_PCIIWCR_WINCTRL1_IO,D0 + move.l D0,MCF_PCI_PCIIWCR // Initiator Window Configuration Register + + /* Clear PCI Reset and wait for devices to reset */ + move.l #~MCF_PCI_PCIGSCR_PR,D0 + and.l D0,MCF_PCI_PCIGSCR + } + + MCF_PSC0_PSCTB_8BIT = 'OK! '; + MCF_PSC0_PSCTB_8BIT = 0x0a0d; +} +/********************************************************************/ + /* test UPC720101 (USB) /* +/********************************************************************/ + +void test_upd720101(void) +{ + + MCF_PSC0_PSCTB_8BIT = 'NEC '; +asm + { + // SELECT UPD720101 AD17 + MOVE.L #MCF_PCI_PCICAR_E+MCF_PCI_PCICAR_DEVNUM(17)+MCF_PCI_PCICAR_FUNCNUM(0)+MCF_PCI_PCICAR_DWORD(0),D0 + MOVE.L D0,MCF_PCI_PCICAR + LEA PCI_IO_OFFSET,A0 + MOVE.L (A0),D1 + move.l #0x33103500,d0 + cmp.l d0,d1 + beq nec_ok + } + MCF_PSC0_PSCTB_8BIT = 'NOT '; + goto nec_not_ok; +nec_ok: + asm + { + MOVE.L #MCF_PCI_PCICAR_E+MCF_PCI_PCICAR_DEVNUM(17)+MCF_PCI_PCICAR_FUNCNUM(0)+MCF_PCI_PCICAR_DWORD(57),D0 + MOVE.L D0,MCF_PCI_PCICAR + move.b #0x20,(a0) + } +nec_not_ok: + asm + { + MOVE.L #MCF_PCI_PCICAR_DEVNUM(17)+MCF_PCI_PCICAR_FUNCNUM(0)+MCF_PCI_PCICAR_DWORD(57),D0 + MOVE.L D0,MCF_PCI_PCICAR + } + MCF_PSC0_PSCTB_8BIT = 'OK! '; + MCF_PSC0_PSCTB_8BIT = 0x0a0d; +} + +/********************************************************************/ + /* TFP410 (vdi) einschalten /* +/********************************************************************/ + +void vdi_on(void) +{ + uint8 RBYT, DBYT; + int versuche, startzeit; + + + MCF_PSC0_PSCTB_8BIT = 'DVI '; + MCF_I2C_I2FDR = 0x3c; // 100kHz standard + versuche = 0; +loop_i2c: + if (versuche++>10) goto next; + MCF_I2C_I2ICR = 0x0; + MCF_I2C_I2CR = 0x0; + MCF_I2C_I2CR = 0xA; + RBYT = MCF_I2C_I2DR; + MCF_I2C_I2SR = 0x0; + MCF_I2C_I2CR = 0x0; + MCF_I2C_I2ICR = 0x01; + + MCF_I2C_I2CR = 0xb0; + + MCF_I2C_I2DR = 0x7a; // ADRESSE TFP410 + while(!(MCF_I2C_I2SR & MCF_I2C_I2SR_IIF)) ; // warten auf fertig + MCF_I2C_I2SR &= 0xfd; // clear bit + + if (MCF_I2C_I2SR & MCF_I2C_I2SR_RXAK) goto loop_i2c; // ack erhalten? -> nein + +tpf_410_ACK_OK: + MCF_I2C_I2DR = 0x00; // SUB ADRESS 0 + while(!(MCF_I2C_I2SR & MCF_I2C_I2SR_IIF)) ; + MCF_I2C_I2SR &= 0xfd; + + MCF_I2C_I2CR |= 0x4; // repeat start + + MCF_I2C_I2DR = 0x7b; // beginn read + while(!(MCF_I2C_I2SR & MCF_I2C_I2SR_IIF)) ; // warten auf fertig + MCF_I2C_I2SR &= 0xfd; // clear bit + + if (MCF_I2C_I2SR & MCF_I2C_I2SR_RXAK) goto loop_i2c; // ack erhalten? -> nein + + + MCF_I2C_I2CR &= 0xef; // switch to rx + DBYT = MCF_I2C_I2DR; // dummy read + + while(!(MCF_I2C_I2SR & MCF_I2C_I2SR_IIF)) ; + MCF_I2C_I2SR &= 0xfd; + + MCF_I2C_I2CR |= 0x08; // txak=1 + + RBYT = MCF_I2C_I2DR; + + while(!(MCF_I2C_I2SR & MCF_I2C_I2SR_IIF)) ; + MCF_I2C_I2SR &= 0xfd; + + MCF_I2C_I2CR = 0x80; // stop + DBYT = MCF_I2C_I2DR; // dummy read + + if (RBYT!=0x4c) goto loop_i2c; + + +i2c_ok: + MCF_I2C_I2CR = 0x0; // stop + MCF_I2C_I2SR = 0x0; // clear sr + while((MCF_I2C_I2SR & MCF_I2C_I2SR_IBB)) ; // wait auf bus free + + MCF_I2C_I2CR = 0xb0; // on tx master + MCF_I2C_I2DR = 0x7A; + while(!(MCF_I2C_I2SR & MCF_I2C_I2SR_IIF)) ; // warten auf fertig + MCF_I2C_I2SR &= 0xfd; // clear bit + + if (MCF_I2C_I2SR & MCF_I2C_I2SR_RXAK) goto loop_i2c; // ack erhalten? -> nein + + MCF_I2C_I2DR = 0x08; // SUB ADRESS 8 + while(!(MCF_I2C_I2SR & MCF_I2C_I2SR_IIF)) ; + MCF_I2C_I2SR &= 0xfd; + + MCF_I2C_I2DR = 0xbf; // ctl1: power on, T:M:D:S: enable + while(!(MCF_I2C_I2SR & MCF_I2C_I2SR_IIF)) ; // warten auf fertig + MCF_I2C_I2SR &= 0xfd; // clear bit + + MCF_I2C_I2CR = 0x80; // stop + DBYT = MCF_I2C_I2DR; // dummy read + MCF_I2C_I2SR = 0x0; // clear sr + + while((MCF_I2C_I2SR & MCF_I2C_I2SR_IBB)) ; // wait auf bus free + + MCF_I2C_I2CR = 0xb0; + MCF_I2C_I2DR = 0x7A; + while(!(MCF_I2C_I2SR & MCF_I2C_I2SR_IIF)) ; // warten auf fertig + MCF_I2C_I2SR &= 0xfd; // clear bit + + if (MCF_I2C_I2SR & MCF_I2C_I2SR_RXAK) goto loop_i2c; // ack erhalten? -> nein + + MCF_I2C_I2DR = 0x08; // SUB ADRESS 8 + while(!(MCF_I2C_I2SR & MCF_I2C_I2SR_IIF)) ; + MCF_I2C_I2SR &= 0xfd; + + MCF_I2C_I2CR |= 0x4; // repeat start + MCF_I2C_I2DR = 0x7b; // beginn read + while(!(MCF_I2C_I2SR & MCF_I2C_I2SR_IIF)) ; // warten auf fertig + MCF_I2C_I2SR &= 0xfd; // clear bit + + if (MCF_I2C_I2SR & MCF_I2C_I2SR_RXAK) goto loop_i2c; // ack erhalten? -> nein + + MCF_I2C_I2CR &= 0xef; // switch to rx + + DBYT = MCF_I2C_I2DR; // dummy read + + while(!(MCF_I2C_I2SR & MCF_I2C_I2SR_IIF)) ; + MCF_I2C_I2SR &= 0xfd; + + MCF_I2C_I2CR |= 0x08; // txak=1 + + warte_50us(); + RBYT = MCF_I2C_I2DR; + + while(!(MCF_I2C_I2SR & MCF_I2C_I2SR_IIF)) ; + MCF_I2C_I2SR &= 0xfd; + + MCF_I2C_I2CR = 0x80; // stop + DBYT = MCF_I2C_I2DR; // dummy read + + if (RBYT!=0xbf) goto loop_i2c; + + goto dvi_ok; +next: + MCF_PSC0_PSCTB_8BIT = 'NOT '; +dvi_ok: + MCF_PSC0_PSCTB_8BIT = 'OK! '; + MCF_PSC0_PSCTB_8BIT = 0x0a0d; + MCF_I2C_I2CR = 0x0; // i2c off +} + +/********************************************************************/ + /* AC97 /* +/********************************************************************/ +void init_ac97(void) +{ +// PSC2: AC97 ---------- + int i,k,zm,x,va,vb,vc; + + MCF_PSC0_PSCTB_8BIT = 'AC97'; + MCF_PAD_PAR_PSC2 = MCF_PAD_PAR_PSC2_PAR_RTS2_RTS // PSC2=TX,RX BCLK,CTS->AC'97 + | MCF_PAD_PAR_PSC2_PAR_CTS2_BCLK + | MCF_PAD_PAR_PSC2_PAR_TXD2 + | MCF_PAD_PAR_PSC2_PAR_RXD2; + MCF_PSC2_PSCMR1 = 0x0; + MCF_PSC2_PSCMR2 = 0x0; + MCF_PSC2_PSCIMR = 0x0300; + MCF_PSC2_PSCSICR = 0x03; //AC97 + MCF_PSC2_PSCRFCR = 0x0f000000; + MCF_PSC2_PSCTFCR = 0x0f000000; + MCF_PSC2_PSCRFAR = 0x00F0; + MCF_PSC2_PSCTFAR = 0x00F0; + + for ( zm = 0; zm<100000; zm++) // wiederholen bis synchron + { + MCF_PSC2_PSCCR = 0x20; + MCF_PSC2_PSCCR = 0x30; + MCF_PSC2_PSCCR = 0x40; + MCF_PSC2_PSCCR = 0x05; +// MASTER VOLUME -0dB + MCF_PSC2_PSCTB_AC97 = 0xE0000000; //START SLOT1 + SLOT2, FIRST FRAME + MCF_PSC2_PSCTB_AC97 = 0x02000000; //SLOT1:WR REG MASTER VOLUME adr 0x02 + for ( i = 2; i<13; i++ ) + { + MCF_PSC2_PSCTB_AC97 = 0x0; //SLOT2-12:WR REG ALLES 0 + } + // read register + MCF_PSC2_PSCTB_AC97 = 0xc0000000; //START SLOT1 + SLOT2, FIRST FRAME + MCF_PSC2_PSCTB_AC97 = 0x82000000; //SLOT1:master volume + for ( i = 2; i<13; i++ ) + { + MCF_PSC2_PSCTB_AC97 = 0x00000000; //SLOT2-12:RD REG ALLES 0 + } + warte_50us(); + va = MCF_PSC2_PSCTB_AC97; + if ((va & 0x80000fff)==0x80000800) + { + vb = MCF_PSC2_PSCTB_AC97; + vc = MCF_PSC2_PSCTB_AC97; + if ((va & 0xE0000fff)==0xE0000800 & vb==0x02000000 & vc==0x00000000) + { + goto livo; + } + } + } + MCF_PSC0_PSCTB_8BIT = ' NOT'; +livo: +// AUX VOLUME ->-0dB + MCF_PSC2_PSCTB_AC97 = 0xE0000000; //START SLOT1 + SLOT2, FIRST FRAME + MCF_PSC2_PSCTB_AC97 = 0x16000000; //SLOT1:WR REG AUX VOLUME adr 0x16 + MCF_PSC2_PSCTB_AC97 = 0x06060000; //SLOT1:VOLUME + for ( i = 3; i<13; i++ ) + { + MCF_PSC2_PSCTB_AC97 = 0x0; //SLOT2-12:WR REG ALLES 0 + } + +// line in VOLUME +12dB + MCF_PSC2_PSCTB_AC97 = 0xE0000000; //START SLOT1 + SLOT2, FIRST FRAME + MCF_PSC2_PSCTB_AC97 = 0x10000000; //SLOT1:WR REG MASTER VOLUME adr 0x02 + for ( i = 2; i<13; i++ ) + { + MCF_PSC2_PSCTB_AC97 = 0x0; //SLOT2-12:WR REG ALLES 0 + } +// cd in VOLUME 0dB + MCF_PSC2_PSCTB_AC97 = 0xE0000000; //START SLOT1 + SLOT2, FIRST FRAME + MCF_PSC2_PSCTB_AC97 = 0x12000000; //SLOT1:WR REG MASTER VOLUME adr 0x02 + for ( i = 2; i<13; i++ ) + { + MCF_PSC2_PSCTB_AC97 = 0x0; //SLOT2-12:WR REG ALLES 0 + } +// mono out VOLUME 0dB + MCF_PSC2_PSCTB_AC97 = 0xE0000000; //START SLOT1 + SLOT2, FIRST FRAME + MCF_PSC2_PSCTB_AC97 = 0x06000000; //SLOT1:WR REG MASTER VOLUME adr 0x02 + MCF_PSC2_PSCTB_AC97 = 0x00000000; //SLOT1:WR REG MASTER VOLUME adr 0x02 + for ( i = 3; i<13; i++ ) + { + MCF_PSC2_PSCTB_AC97 = 0x0; //SLOT2-12:WR REG ALLES 0 + } + MCF_PSC2_PSCTFCR |= MCF_PSC_PSCTFCR_WFR; //set EOF + MCF_PSC2_PSCTB_AC97 = 0x00000000; //last data + +ac97_end: + MCF_PSC0_PSCTB_8BIT = ' OK!'; + MCF_PSC0_PSCTB_8BIT = 0x0a0d; + +} +/********************************************************************/ +void __initialize_hardware(void) +{ +_init_hardware: + init_ddram(); + asm + { + // instruction cache on + move.l #0x007fe000,d0 + movec d0,acr0 + move.l d0,rt_acr0 + movec d0,acr2 + move.l d0,rt_acr2 + clr.l d0 + movec d0,acr1 + move.l d0,rt_acr1 + movec d0,acr3 + move.l d0,rt_acr3 + move.l d0,MCF_MMU_MMUCR + + + move.l #0x050c8120,d0 + move.l d0,rt_cacr + movec d0,cacr + nop + + } + init_gpio(); + init_seriel(); + init_slt(); + init_fbcs(); + +// ACP_CONF setzen und Ports nicht initialisieren wenn DIP Switch 6 = on + asm + { + move.b DIP_SWITCH,d0 // dip schalter adresse + btst.b #6,d0 + beq not_init_ports + } + init_PCI(); //pci braucht zeit +not_init_ports: + init_fpga(); + init_video_ddr(); + vdi_on(); +// Ports nicht initialisieren wenn DIP Switch 6 = on + asm + { + move.b DIP_SWITCH,d0 // dip schalter adresse + move.b d0,0xF0040002 // acp conf +2 + btst.b #6,d0 + beq not_init_ports2 + } + test_upd720101(); + init_ac97(); + asm + { +not_init_ports2: + } +// video_1280_1024(); + set_ide_access_mode(); + +}