1: //========================================================================================
     2: //  HD63450.java
     3: //    en:DMA controller
     4: //    ja:DMAコントローラ
     5: //  Copyright (C) 2003-2026 Makoto Kamada
     6: //
     7: //  This file is part of the XEiJ (X68000 Emulator in Java).
     8: //  You can use, modify and redistribute the XEiJ if the conditions are met.
     9: //  Read the XEiJ License for more details.
    10: //  https://stdkmd.net/xeij/
    11: //========================================================================================
    12: 
    13: package xeij;
    14: 
    15: import java.lang.*;  //Boolean,Character,Class,Comparable,Double,Exception,Float,IllegalArgumentException,Integer,Long,Math,Number,Object,Runnable,SecurityException,String,StringBuilder,System
    16: 
    17: public class HD63450 {
    18: 
    19:   //フラグ
    20:   //                                          3210
    21:   public static final int DMA_DEBUG_TRACE = 0b0000;  //トレースするチャンネルをセット
    22: 
    23:   public static final boolean DMA_ALERT_HIMEM = true;  //MAR,DAR,BARにハイメモリのアドレスが書き込まれた報告する
    24: 
    25:   //レジスタ
    26:   //  DMA_CERはread-only、その他はread/write
    27:   //  DMA_DCR,DMA_SCR,DMA_MTC,DMA_MAR,DMA_DAR,DMA_MFC,DMA_DFCに動作中(dmaACT[i]!=0)に書き込むとDMA_TIMING_ERRORになる
    28: 
    29:   //Channel Status Register (R/W)
    30:   public static final int DMA_CSR = 0x00;
    31:   public static final int DMA_COC = 0b10000000;  //Channel Operation Complete。1=チャンネル動作完了
    32:   public static final int DMA_BLC = 0b01000000;  //BLock transfer Complete。1=ブロック転送完了
    33:   public static final int DMA_NDT = 0b00100000;  //Normal Device Termination。1=正常終了
    34:   public static final int DMA_ERR = 0b00010000;  //ERRor。1=エラーあり
    35:   public static final int DMA_ACT = 0b00001000;  //channel ACTive。1=チャンネル動作中
    36:   public static final int DMA_DIT = 0b00000100;  //! 非対応。~DONE Input Transition。1=~DONE入力があった
    37:   public static final int DMA_PCT = 0b00000010;  //~PCL Transition。1=~PCLの立下りがあった
    38:   public static final int DMA_PCS = 0b00000001;  //~PCL Status。~PCLの状態
    39: 
    40:   //Channel Error Register (R)
    41:   public static final int DMA_CER = 0x01;
    42:   public static final int DMA_ERROR_CODE           = 0b00011111;  //エラーコード
    43:   public static final int DMA_NO_ERROR             = 0b00000000;  //  エラーなし
    44:   public static final int DMA_CONFIGURATION_ERROR  = 0b00000001;  //  コンフィギュレーションエラー
    45:   public static final int DMA_TIMING_ERROR         = 0b00000010;  //  動作タイミングエラー
    46:   public static final int DMA_MEMORY_ADDRESS_ERROR = 0b00000101;  //  アドレスエラー(メモリアドレス)
    47:   public static final int DMA_DEVICE_ADDRESS_ERROR = 0b00000110;  //  アドレスエラー(デバイスアドレス)
    48:   public static final int DMA_BASE_ADDRESS_ERROR   = 0b00000111;  //  アドレスエラー(ベースアドレス)
    49:   public static final int DMA_MEMORY_BUS_ERROR     = 0b00001001;  //  バスエラー(メモリアドレス)
    50:   public static final int DMA_DEVICE_BUS_ERROR     = 0b00001010;  //  バスエラー(デバイスアドレス)
    51:   public static final int DMA_BASE_BUS_ERROR       = 0b00001011;  //  バスエラー(ベースアドレス)
    52:   public static final int DMA_MEMORY_COUNT_ERROR   = 0b00001101;  //  カウントエラー(メモリカウンタ)
    53:   public static final int DMA_BASE_COUNT_ERROR     = 0b00001111;  //  カウントエラー(ベースカウンタ)
    54:   public static final int DMA_EXTERNAL_ABORT       = 0b00010000;  //! 非対応。外部強制停止
    55:   public static final int DMA_SOFTWARE_ABORT       = 0b00010001;  //  ソフトウェア強制停止
    56: 
    57:   //Device Control Register (R/W)
    58:   public static final int DMA_DCR = 0x04;
    59:   public static final int DMA_XRM                    = 0b11000000;  //eXternal Request Mode
    60:   public static final int DMA_BURST_TRANSFER         = 0b00000000;  //  バースト転送モード
    61:   public static final int DMA_NO_HOLD_CYCLE_STEAL    = 0b10000000;  //  ホールドなしサイクルスチールモード
    62:   public static final int DMA_HOLD_CYCLE_STEAL       = 0b11000000;  //! 非対応。ホールドありサイクルスチールモード。ホールドなしサイクルスチールモードと同じ
    63:   public static final int DMA_DTYP                   = 0b00110000;  //Device TYPe
    64:   public static final int DMA_HD68000_COMPATIBLE     = 0b00000000;  //  HD68000コンパチブル(デュアルアドレスモード)
    65:   public static final int DMA_HD6800_COMPATIBLE      = 0b00010000;  //! 非対応。HD6800コンパチブル(デュアルアドレスモード)
    66:   public static final int DMA_ACK_DEVICE             = 0b00100000;  //! 非対応。~ACK付きデバイス(シングルアドレスモード)
    67:   public static final int DMA_ACK_READY_DEVICE       = 0b00110000;  //! 非対応。~ACK,~READY付きデバイス(シングルアドレスモード)
    68:   public static final int DMA_DPS                    = 0b00001000;  //Device Port Size
    69:   public static final int DMA_PORT_8_BIT             = 0b00000000;  //  8ビットポート
    70:   public static final int DMA_PORT_16_BIT            = 0b00001000;  //  16ビットポート
    71:   public static final int DMA_PCL                    = 0b00000011;  //Peripheral Control Line
    72:   public static final int DMA_STATUS_INPUT           = 0b00000000;  //  STATUS入力
    73:   public static final int DMA_STATUS_INPUT_INTERRUPT = 0b00000001;  //! 非対応。割り込みありSTATUS入力
    74:   public static final int DMA_EIGHTH_START_PULSE     = 0b00000010;  //! 非対応。1/8スタートパルス
    75:   public static final int DMA_ABORT_INPUT            = 0b00000011;  //! 非対応。ABORT入力
    76: 
    77:   //Operation Control Register (R/W)
    78:   public static final int DMA_OCR = 0x05;
    79:   public static final int DMA_DIR                 = 0b10000000;  //DIRection
    80:   public static final int DMA_MEMORY_TO_DEVICE    = 0b00000000;  //  メモリ→デバイス。DMA_MAR→DMA_DAR
    81:   public static final int DMA_DEVICE_TO_MEMORY    = 0b10000000;  //  デバイス→メモリ。DMA_DAR→DMA_MAR
    82:   public static final int DMA_BTD                 = 0b01000000;  //! 非対応。multi Block Transfer with ~DONE mode
    83:   public static final int DMA_SIZE                = 0b00110000;  //operand SIZE
    84:   public static final int DMA_BYTE_SIZE           = 0b00000000;  //  8ビット
    85:   public static final int DMA_WORD_SIZE           = 0b00010000;  //  16ビット
    86:   public static final int DMA_LONG_WORD_SIZE      = 0b00100000;  //  32ビット
    87:   public static final int DMA_UNPACKED_8_BIT      = 0b00110000;  //  パックなし8ビット
    88:   public static final int DMA_CHAIN               = 0b00001100;  //CHAINing operation
    89:   public static final int DMA_NO_CHAINING         = 0b00000000;  //  チェインなし
    90:   public static final int DMA_ARRAY_CHAINING      = 0b00001000;  //  アレイチェイン
    91:   public static final int DMA_LINK_ARRAY_CHAINING = 0b00001100;  //  リンクアレイチェイン
    92:   public static final int DMA_REQG                = 0b00000011;  //DMA REQuest Generation method
    93:   public static final int DMA_AUTO_REQUEST        = 0b00000000;  //  オートリクエスト限定速度。転送中にバスを開放する
    94:   public static final int DMA_AUTO_REQUEST_MAX    = 0b00000001;  //  オートリクエスト最大速度。転送中にバスを開放しない
    95:   public static final int DMA_EXTERNAL_REQUEST    = 0b00000010;  //  外部転送要求
    96:   public static final int DMA_DUAL_REQUEST        = 0b00000011;  //  最初はオートリクエスト、2番目から外部転送要求
    97: 
    98:   //Sequence Control Register (R/W)
    99:   public static final int DMA_SCR = 0x06;
   100:   public static final int DMA_MAC =        0b00001100;  //Memory Address register Count
   101:   public static final int DMA_STATIC_MAR = 0b00000000;  //  DMA_MAR固定
   102:   public static final int DMA_INC_MAR    = 0b00000100;  //  DMA_MAR++
   103:   public static final int DMA_DEC_MAR    = 0b00001000;  //  DMA_MAR--
   104:   public static final int DMA_DAC =        0b00000011;  //Device Address register Count
   105:   public static final int DMA_STATIC_DAR = 0b00000000;  //  DMA_DAR固定
   106:   public static final int DMA_INC_DAR    = 0b00000001;  //  DMA_DAR++
   107:   public static final int DMA_DEC_DAR    = 0b00000010;  //  DMA_DAR--
   108: 
   109:   //Channel Control Register (R/W)
   110:   public static final int DMA_CCR = 0x07;
   111:   public static final int DMA_STR = 0b10000000;  //STaRt operation。1=動作開始
   112:   public static final int DMA_CNT = 0b01000000;  //CoNTinue operation。1=コンティニューあり
   113:   public static final int DMA_HLT = 0b00100000;  //Halt operation。1=動作一時停止
   114:   public static final int DMA_SAB = 0b00010000;  //Software ABort。1=動作中止
   115:   public static final int DMA_ITE = 0b00001000;  //InTerrupt Enable。1=割り込み許可
   116: 
   117:   //Transfer Counter, Address Register
   118:   public static final int DMA_MTC = 0x0a;  //Memory Transfer Counter (R/W)
   119:   public static final int DMA_MAR = 0x0c;  //Memory Address Register (R/W)
   120:   public static final int DMA_DAR = 0x14;  //Device Address Register (R/W)
   121:   public static final int DMA_BTC = 0x1a;  //Base Transfer Counter (R/W)
   122:   public static final int DMA_BAR = 0x1c;  //Base Address Register (R/W)
   123: 
   124:   //Interrupt Vector
   125:   public static final int DMA_NIV = 0x25;  //Normal Interrupt Vector (R/W)
   126:   public static final int DMA_EIV = 0x27;  //Error Interrupt Vector (R/W)
   127: 
   128:   //Function Codes
   129:   public static final int DMA_MFC = 0x29;  //Memory Function Codes (R/W)
   130:   public static final int DMA_FC2 = 0b00000100;  //Function Code 2
   131:   public static final int DMA_FC1 = 0b00000010;  //! 非対応。Function Code 1
   132:   public static final int DMA_FC0 = 0b00000001;  //! 非対応。Function Code 0
   133: 
   134:   //Channel Priority Register (R/W)
   135:   public static final int DMA_CPR = 0x2d;
   136:   public static final int DMA_CP = 0b00000011;  //! 未対応。Channel Priority。0=高,1,2,3=低
   137: 
   138:   //Function Codes
   139:   public static final int DMA_DFC = 0x31;  //Device Function Codes (R/W)
   140:   public static final int DMA_BFC = 0x39;  //Base Function Codes (R/W)
   141: 
   142:   //General Control Register (R/W)
   143:   public static final int DMA_GCR = 0xff;
   144:   public static final int DMA_BT = 0b00001100;  //Burst Time。0=16clk,1=32clk,2=64clk,3=128clk
   145:   public static final int DMA_BR = 0b00000011;  //Bandwidth Ratio。0=1/2,1=1/4,2=1/8,3=1/16
   146: 
   147:   //レジスタ
   148:   //  すべてゼロ拡張
   149:   public static final int[] dmaPCS = new int[4];         //DMA_CSR bit0
   150:   public static final int[] dmaPCT = new int[4];         //        bit1
   151:   public static final int[] dmaDIT = new int[4];         //        bit2
   152:   public static final int[] dmaACT = new int[4];         //        bit3
   153:   public static final int[] dmaERR = new int[4];         //        bit4
   154:   public static final int[] dmaNDT = new int[4];         //        bit5
   155:   public static final int[] dmaBLC = new int[4];         //        bit6
   156:   public static final int[] dmaCOC = new int[4];         //        bit7
   157:   public static final int[] dmaErrorCode = new int[4];   //DMA_CER bit0-4
   158:   public static final int[] dmaPCL = new int[4];         //DMA_DCR bit0-1
   159:   public static final int[] dmaDPS = new int[4];         //        bit3
   160:   public static final int[] dmaDTYP = new int[4];        //        bit4-5
   161:   public static final int[] dmaXRM = new int[4];         //        bit6-7
   162:   public static final int[] dmaREQG = new int[4];        //DMA_OCR bit0-1
   163:   public static final int[] dmaCHAIN = new int[4];       //        bit2-3
   164:   public static final int[] dmaSIZE = new int[4];        //        bit4-5
   165:   public static final int[] dmaBTD = new int[4];         //        bit6
   166:   public static final int[] dmaDIR = new int[4];         //        bit7
   167:   public static final int[] dmaDAC = new int[4];         //DMA_SCR bit0-1
   168:   public static final int[] dmaDACValue = new int[4];    //           dmaDAC==(DMA_INC_DAR?1:dmaDAC==DMA_DEC_DAR?-1:0)*(dmaDPS==DMA_PORT_8_BIT?2:1)
   169:   public static final int[] dmaMAC = new int[4];         //        bit2-3
   170:   public static final int[] dmaMACValue = new int[4];    //           dmaMAC==DMA_INC_MAR?1:dmaMAC==DMA_DEC_MAR?-1:0
   171:   public static final int[] dmaITE = new int[4];         //DMA_CCR bit3
   172:   public static final int[] dmaSAB = new int[4];         //        bit4
   173:   public static final int[] dmaHLT = new int[4];         //        bit5
   174:   public static final int[] dmaCNT = new int[4];         //        bit6
   175:   public static final int[] dmaSTR = new int[4];         //        bit7
   176:   public static final int[] dmaMTC = new int[4];         //DMA_MTC bit0-15
   177:   public static final int[] dmaMAR = new int[4];         //DMA_MAR bit0-31
   178:   public static final int[] dmaDAR = new int[4];         //DMA_DAR bit0-31
   179:   public static final int[] dmaBTC = new int[4];         //DMA_BTC bit0-15
   180:   public static final int[] dmaBAR = new int[4];         //DMA_BAR bit0-31
   181:   public static final int[] dmaNIV = new int[4];         //DMA_NIV bit0-7
   182:   public static final int[] dmaEIV = new int[4];         //DMA_EIV bit0-7
   183:   public static final int[] dmaMFC = new int[4];         //DMA_MFC bit2
   184:   public static final MemoryMappedDevice[][] dmaMFCMap = new MemoryMappedDevice[4][];  //  DataBreakPoint.DBP_ON?dmaMFC[i]==0?udm:sdm:dmaMFC[i]==0?um:sm
   185:   public static final int[] dmaCP = new int[4];          //DMA_CPR bit0-1
   186:   public static final int[] dmaDFC = new int[4];         //DMA_DFC bit2
   187:   public static final MemoryMappedDevice[][] dmaDFCMap = new MemoryMappedDevice[4][];  //  DataBreakPoint.DBP_ON?dmaDFC[i]==0?udm:sdm:dmaDFC[i]==0?um:sm
   188:   public static final int[] dmaBFC = new int[4];         //DMA_BFC bit2
   189:   public static final MemoryMappedDevice[][] dmaBFCMap = new MemoryMappedDevice[4][];  //  DataBreakPoint.DBP_ON?dmaBFC[i]==0?udm:sdm:dmaBFC[i]==0?um:sm
   190:   public static int dmaBR;                               //DMA_GCR bit0-1。0=1/2,1=1/4,2=1/8,3=1/16
   191:   public static int dmaBT;                               //        bit2-3。0=16clk,1=32clk,2=64clk,3=128clk
   192:   public static long dmaBurstSpan;  //バースト期間。XEiJ.dmaCycleUnit<<(4+(dmaBT>>2))。MC68450 5-6
   193:   public static long dmaBurstInterval;  //バースト間隔。dmaBurstSpan<<(1+(dmaBR&3))
   194:   public static long dmaBurstStart;  //バースト開始時刻
   195:   public static long dmaBurstEnd;  //バースト終了時刻
   196:   public static long[] dmaRequestTime = new long[4];  //動作開始時刻。オートリクエスト最大速度のとき次の予約を入れる時刻
   197: 
   198:   public static final int[] dmaReqPin = new int[4];  //REQピンの状態。0または1
   199: 
   200:   //割り込み
   201:   public static final int[] dmaInnerRequest = new int[8];  //割り込み要求カウンタ
   202:   public static final int[] dmaInnerAcknowleged = new int[8];  //割り込み受付カウンタ
   203: 
   204:   //クロック
   205:   public static final long[] dmaInnerClock = new long[4];  //転送要求時刻(XEiJ.TMR_FREQ単位)
   206: 
   207:   //パックあり
   208:   public static final int[] dmaMemoryCarry = new int[4];  //メモリでパックするために繰り越したデータ
   209:   public static final int[] dmaDeviceCarry = new int[4];  //デバイスでパックするために繰り越したデータ
   210: 
   211:   //サイクル数補正
   212:   public static final int[] dmaAdditionalCycles = new int[4];  //追加のサイクル数
   213: 
   214:   //アクセスサイクル数
   215:   public static int dmaReadCycles;  //1ワードリードの所要サイクル数
   216:   public static int dmaWriteCycles;  //1ワードライトの所要サイクル数
   217: 
   218:   public static final TickerQueue.Ticker[] dmaTickerArray = new TickerQueue.Ticker[] {
   219:     new TickerQueue.Ticker () {
   220:       @Override protected void tick () {
   221:         dmaTransfer (0);
   222:       }
   223:     },
   224:     new TickerQueue.Ticker () {
   225:       @Override protected void tick () {
   226:         dmaTransfer (1);
   227:       }
   228:     },
   229:     new TickerQueue.Ticker () {
   230:       @Override protected void tick () {
   231:         dmaTransfer (2);
   232:       }
   233:     },
   234:     new TickerQueue.Ticker () {
   235:       @Override protected void tick () {
   236:         dmaTransfer (3);
   237:       }
   238:     },
   239:   };
   240: 
   241:   //dmaInit ()
   242:   //  DMAコントローラを初期化する
   243:   public static void dmaInit () {
   244:     //レジスタ
   245:     //dmaPCS = new int[4];
   246:     //dmaPCT = new int[4];
   247:     //dmaDIT = new int[4];
   248:     //dmaACT = new int[4];
   249:     //dmaERR = new int[4];
   250:     //dmaNDT = new int[4];
   251:     //dmaBLC = new int[4];
   252:     //dmaCOC = new int[4];
   253:     //dmaErrorCode = new int[4];
   254:     //dmaPCL = new int[4];
   255:     //dmaDPS = new int[4];
   256:     //dmaDTYP = new int[4];
   257:     //dmaXRM = new int[4];
   258:     //dmaREQG = new int[4];
   259:     //dmaCHAIN = new int[4];
   260:     //dmaSIZE = new int[4];
   261:     //dmaBTD = new int[4];
   262:     //dmaDIR = new int[4];
   263:     //dmaDAC = new int[4];
   264:     //dmaDACValue = new int[4];
   265:     //dmaMAC = new int[4];
   266:     //dmaMACValue = new int[4];
   267:     //dmaITE = new int[4];
   268:     //dmaSAB = new int[4];
   269:     //dmaHLT = new int[4];
   270:     //dmaCNT = new int[4];
   271:     //dmaSTR = new int[4];
   272:     //dmaMTC = new int[4];
   273:     //dmaMAR = new int[4];
   274:     //dmaDAR = new int[4];
   275:     //dmaBTC = new int[4];
   276:     //dmaBAR = new int[4];
   277:     //dmaNIV = new int[4];
   278:     //dmaEIV = new int[4];
   279:     //dmaMFC = new int[4];
   280:     //dmaMFCMap = new MMD[4];
   281:     //dmaCP = new int[4];
   282:     //dmaDFC = new int[4];
   283:     //dmaDFCMap = new MMD[4];
   284:     //dmaBFC = new int[4];
   285:     //dmaBFCMap = new MMD[4];
   286:     //dmaRequestTime = new long[4];
   287:     //dmaPCSはresetでは操作しない
   288:     dmaPCS[0] = 1;  //EXVSYNC
   289:     dmaPCS[1] = 1;  //VCC
   290:     dmaPCS[2] = 1;  //EXPCL
   291:     dmaPCS[3] = 1;  //ADPCMREQ。PCL3とREQ3は直結
   292:     //dmaReqPinはresetでは操作しない
   293:     dmaReqPin[0] = 1;
   294:     dmaReqPin[1] = 1;
   295:     dmaReqPin[2] = 1;
   296:     dmaReqPin[3] = 1;
   297:     //割り込み
   298:     //dmaInnerRequest = new int[8];
   299:     //dmaInnerAcknowleged = new int[8];
   300:     //クロック
   301:     //dmaInnerClock = new long[4];
   302:     //パックあり
   303:     //dmaMemoryCarry = new int[4];
   304:     //dmaDeviceCarry = new int[4];
   305:     //サイクル数補正
   306:     //dmaAdditionalCycles = new int[4];
   307:     dmaReset ();
   308:   }  //dmaInit()
   309: 
   310:   //リセット
   311:   public static void dmaReset () {
   312:     //レジスタ
   313:     for (int i = 0; i < 4; i++) {
   314:       //dmaPCSはresetでは操作しない
   315:       dmaPCT[i] = 0;
   316:       dmaDIT[i] = 0;
   317:       dmaACT[i] = 0;
   318:       dmaERR[i] = 0;
   319:       dmaNDT[i] = 0;
   320:       dmaBLC[i] = 0;
   321:       dmaCOC[i] = 0;
   322:       dmaErrorCode[i] = 0;
   323:       dmaPCL[i] = 0;
   324:       dmaDPS[i] = 0;
   325:       dmaDTYP[i] = 0;
   326:       dmaXRM[i] = 0;
   327:       dmaREQG[i] = 0;
   328:       dmaCHAIN[i] = 0;
   329:       dmaSIZE[i] = 0;
   330:       dmaBTD[i] = 0;
   331:       dmaDIR[i] = 0;
   332:       dmaDAC[i] = 0;
   333:       dmaDACValue[i] = 0;
   334:       dmaMAC[i] = 0;
   335:       dmaMACValue[i] = 0;
   336:       dmaITE[i] = 0;
   337:       dmaSAB[i] = 0;
   338:       dmaHLT[i] = 0;
   339:       dmaCNT[i] = 0;
   340:       dmaSTR[i] = 0;
   341:       dmaMTC[i] = 0;
   342:       dmaMAR[i] = 0;
   343:       dmaDAR[i] = 0;
   344:       dmaBTC[i] = 0;
   345:       dmaBAR[i] = 0;
   346:       dmaNIV[i] = 0x0f;  //割り込みベクタの初期値は未初期化割り込みを示す0x0f
   347:       dmaEIV[i] = 0x0f;
   348:       dmaMFC[i] = 0;
   349:       if (DataBreakPoint.DBP_ON) {
   350:         dmaMFCMap[i] = DataBreakPoint.dbpUserMap;
   351:       } else {
   352:         dmaMFCMap[i] = XEiJ.busUserMap;
   353:       }
   354:       dmaCP[i] = 0;
   355:       dmaDFC[i] = 0;
   356:       if (DataBreakPoint.DBP_ON) {
   357:         dmaDFCMap[i] = DataBreakPoint.dbpUserMap;
   358:       } else {
   359:         dmaDFCMap[i] = XEiJ.busUserMap;
   360:       }
   361:       dmaBFC[i] = 0;
   362:       if (DataBreakPoint.DBP_ON) {
   363:         dmaBFCMap[i] = DataBreakPoint.dbpUserMap;
   364:       } else {
   365:         dmaBFCMap[i] = XEiJ.busUserMap;
   366:       }
   367:       dmaRequestTime[i] = XEiJ.FAR_FUTURE;
   368:     }
   369:     dmaBR = 0;
   370:     dmaBT = 0;
   371:     dmaBurstSpan = XEiJ.dmaCycleUnit << (4 + (dmaBT >> 2));
   372:     dmaBurstInterval = dmaBurstSpan << (1 + (dmaBR & 3));
   373:     dmaBurstStart = XEiJ.FAR_FUTURE;
   374:     dmaBurstEnd = 0L;
   375:     //割り込み
   376:     for (int i = 0; i < 8; i++) {
   377:       dmaInnerRequest[i] = 0;
   378:       dmaInnerAcknowleged[i] = 0;
   379:     }
   380:     //クロック
   381:     for (int i = 0; i < 4; i++) {
   382:       dmaInnerClock[i] = XEiJ.FAR_FUTURE;
   383:       TickerQueue.tkqRemove (dmaTickerArray[i]);
   384:     }
   385:   }  //dmaReset()
   386: 
   387:   //割り込み受付
   388:   //  コアが割り込み要求を受け付けたときに呼び出す
   389:   //  割り込みベクタ番号を返す
   390:   //  割り込み要求を取り下げる場合は0を返す
   391:   //  オートベクタを使用するデバイスはオートベクタの番号を返すこと
   392:   public static int dmaAcknowledge () {
   393:     for (int i = 0; i < 8; i++) {  //! 未対応。本来はチャンネルプライオリティに従うべき
   394:       int request = dmaInnerRequest[i];
   395:       if (dmaInnerAcknowleged[i] != request) {
   396:         dmaInnerAcknowleged[i] = request;
   397:         return (i & 1) == 0 ? dmaNIV[i >> 1] : dmaEIV[i >> 1];
   398:       }
   399:     }
   400:     return 0;
   401:   }  //dmaAcknowledge()
   402: 
   403:   //割り込み終了
   404:   //  コアが割り込み処理を終了したときに呼び出す
   405:   //  まだ処理されていない割り込みが残っていたら再度割り込み要求を出す
   406:   public static void dmaDone () {
   407:     for (int i = 0; i < 8; i++) {  //! 未対応。本来はチャンネルプライオリティに従うべき
   408:       if (dmaInnerRequest[i] != dmaInnerAcknowleged[i]) {
   409:         XEiJ.mpuIRR |= XEiJ.MPU_DMA_INTERRUPT_MASK;
   410:         return;
   411:       }
   412:     }
   413:   }  //dmaDone()
   414: 
   415:   //dmaStart (i)
   416:   //  DMA転送開始
   417:   public static void dmaStart (int i) {
   418:     if (DMA_DEBUG_TRACE != 0 && (DMA_DEBUG_TRACE & 1 << i) != 0) {
   419:       System.out.printf ("%d %08x dmaStart(%d)\n", XEiJ.mpuClockTime, XEiJ.regPC0, i);
   420:       System.out.printf ("CSR=0x%02x,CER=0x%02x,DCR=0x%02x,OCR=0x%02x,SCR=0x%02x,CCR=0x%02x,MTC=0x%04x,MAR=0x%08x,DAR=0x%08x,BTC=0x%04x,BAR=0x%08x\n",
   421:                          dmaCOC[i] | dmaBLC[i] | dmaNDT[i] | dmaERR[i] | dmaACT[i] | dmaDIT[i] | dmaPCT[i] | dmaPCS[i],  //CSR
   422:                          dmaErrorCode[i],  //CER
   423:                          dmaXRM[i] | dmaDTYP[i] | dmaDPS[i] | dmaPCL[i],  //DCR
   424:                          dmaDIR[i] | dmaBTD[i] | dmaSIZE[i] | dmaCHAIN[i] | dmaREQG[i],  //OCR
   425:                          dmaMAC[i] | dmaDAC[i],  //SCR
   426:                          dmaSTR[i] | dmaCNT[i] | dmaHLT[i] | dmaSAB[i] | dmaITE[i],  //CCR
   427:                          dmaMTC[i], dmaMAR[i], dmaDAR[i], dmaBTC[i], dmaBAR[i]);
   428:     }
   429:     //タイミングを確認する
   430:     if ((dmaCOC[i] | dmaBLC[i] | dmaNDT[i] | dmaERR[i] | dmaACT[i]) != 0) {  //DMA_CSRがクリアされていない状態でSTRをセットしようとした
   431:       dmaErrorExit (i, DMA_TIMING_ERROR);
   432:       return;
   433:     }
   434:     //設定を確認する
   435:     if (((dmaDTYP[i] == DMA_HD68000_COMPATIBLE || dmaDTYP[i] == DMA_HD6800_COMPATIBLE) &&  //デュアルアドレスモードで
   436:          dmaDPS[i] == DMA_PORT_16_BIT && dmaSIZE[i] == DMA_BYTE_SIZE &&  //DMA_DPSが16ビットでSIZEが8ビットで
   437:          (dmaREQG[i] == DMA_EXTERNAL_REQUEST || dmaREQG[i] == DMA_DUAL_REQUEST)) ||  //外部転送要求のとき、または
   438:         dmaXRM[i] == 0b01000000 || dmaMAC[i] == 0b00001100 || dmaDAC[i] == 0b00000011 || dmaCHAIN[i] == 0b00000100 ||  //不正な値が指定されたとき
   439:         (dmaSIZE[i] == 0b00000011 && !((dmaDTYP[i] == DMA_HD68000_COMPATIBLE || dmaDTYP[i] == DMA_HD6800_COMPATIBLE) && dmaDPS[i] == DMA_PORT_8_BIT))) {
   440:       dmaErrorExit (i, DMA_CONFIGURATION_ERROR);
   441:       return;
   442:     }
   443:     if (dmaDPS[i] == DMA_PORT_16_BIT &&  //16ビットポートかつ
   444:         dmaSIZE[i] == DMA_UNPACKED_8_BIT) {  //パックなし8ビット
   445:       dmaErrorExit (i, DMA_CONFIGURATION_ERROR);  //コンフィギュレーションエラー
   446:       return;
   447:     }
   448:     //パックありの準備
   449:     dmaMemoryCarry[i] = -1;
   450:     dmaDeviceCarry[i] = -1;
   451:     //strには書き込まない
   452:     //チャンネル動作開始
   453:     dmaRequestTime[i] = XEiJ.mpuClockTime;
   454:     dmaACT[i] = DMA_ACT;
   455:     if (dmaCHAIN[i] == DMA_ARRAY_CHAINING) {  //アレイチェインモードのとき
   456:       if (dmaBTC[i] == 0) {  //カウントエラー
   457:         dmaErrorExit (i, DMA_BASE_COUNT_ERROR);
   458:         return;
   459:       }
   460:       if ((dmaBAR[i] & 1) != 0) {  //アドレスエラー
   461:         dmaErrorExit (i, DMA_BASE_ADDRESS_ERROR);
   462:         return;
   463:       }
   464:       try {
   465:         XEiJ.busWaitTime = XEiJ.busWaitCycles ? XEiJ.dmaWaitTime : XEiJ.dmaNoWaitTime;
   466:         MemoryMappedDevice[] mm = dmaBFCMap[i];
   467:         int a = dmaBAR[i];
   468:         dmaMAR[i] = mm[a >>> XEiJ.BUS_PAGE_BITS].mmdRws (a) << 16 | mm[a + 2 >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a + 2);
   469:         dmaMTC[i] = mm[a + 4 >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a + 4);
   470:         dmaBAR[i] += 6;
   471:         XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles * 3;
   472:         XEiJ.busWaitTime = XEiJ.busWaitCycles ? XEiJ.mpuWaitTime : XEiJ.mpuNoWaitTime;
   473:       } catch (M68kException e) {  //バスエラー
   474:         XEiJ.busWaitTime = XEiJ.busWaitCycles ? XEiJ.mpuWaitTime : XEiJ.mpuNoWaitTime;
   475:         dmaErrorExit (i, DMA_BASE_BUS_ERROR);
   476:         return;
   477:       }
   478:       dmaBTC[i]--;
   479:     } else if (dmaCHAIN[i] == DMA_LINK_ARRAY_CHAINING) {  //リンクアレイチェインモードのとき
   480:       if ((dmaBAR[i] & 1) != 0) {  //アドレスエラー
   481:         dmaErrorExit (i, DMA_BASE_ADDRESS_ERROR);
   482:         return;
   483:       }
   484:       try {
   485:         XEiJ.busWaitTime = XEiJ.busWaitCycles ? XEiJ.dmaWaitTime : XEiJ.dmaNoWaitTime;
   486:         MemoryMappedDevice[] mm = dmaBFCMap[i];
   487:         int a = dmaBAR[i];
   488:         dmaMAR[i] = mm[a >>> XEiJ.BUS_PAGE_BITS].mmdRws (a) << 16 | mm[a + 2 >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a + 2);
   489:         dmaMTC[i] = mm[a + 4 >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a + 4);
   490:         dmaBAR[i] = mm[a + 6 >>> XEiJ.BUS_PAGE_BITS].mmdRws (a + 6) << 16 | mm[a + 8 >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a + 8);
   491:         XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles * 5;
   492:         XEiJ.busWaitTime = XEiJ.busWaitCycles ? XEiJ.mpuWaitTime : XEiJ.mpuNoWaitTime;
   493:       } catch (M68kException e) {  //バスエラー
   494:         XEiJ.busWaitTime = XEiJ.busWaitCycles ? XEiJ.mpuWaitTime : XEiJ.mpuNoWaitTime;
   495:         dmaErrorExit (i, DMA_BASE_BUS_ERROR);
   496:         return;
   497:       }
   498:     }
   499:     //カウントを確認する
   500:     //  アレイチェーンとリンクアレイチェーンはMTCが確定してから行うこと
   501:     if (dmaMTC[i] == 0) {  //カウントが0
   502:       dmaErrorExit (i, DMA_MEMORY_COUNT_ERROR);  //カウントエラー
   503:       return;
   504:     }
   505:     //サイクル数補正を準備する
   506:     //  アレイチェーンとリンクアレイチェーンはMARが確定してから行うこと
   507:     dmaAdditionalCycles[i] = (dmaDPS[i] == DMA_PORT_8_BIT ?  //8ビットポート
   508:                               dmaSIZE[i] == DMA_BYTE_SIZE ?  //パックあり
   509:                               (dmaMAR[i] & 1) == 0 && dmaMACValue[i] == 0 ? 6 :  //メモリが偶数アドレスかつカウントしないとき6、
   510:                               (dmaMAR[i] & 1) != 0 && dmaMACValue[i] == 0 ? 8 :  //メモリが奇数アドレスかつカウントしないとき8、
   511:                               dmaDIR[i] == DMA_MEMORY_TO_DEVICE ? 8 : 10 :  //メモリからデバイスへは8、デバイスからメモリへは10
   512:                               dmaSIZE[i] == DMA_WORD_SIZE || dmaSIZE[i] == DMA_LONG_WORD_SIZE ?  //ワードまたはロング
   513:                               dmaDIR[i] == DMA_MEMORY_TO_DEVICE ? 4 : 0 :  //メモリからデバイスへは4、デバイスからメモリへは0
   514:                               0  //パックなしは0
   515:                               :  //16ビットポート
   516:                               dmaSIZE[i] == DMA_BYTE_SIZE ?  //パックあり
   517:                               4 + //基本は4
   518:                               ((dmaMAR[i] & 1) != 0 && dmaMACValue[i] == 0 ? 1 : 0) +  //メモリが奇数アドレスかつカウントしないとき1追加
   519:                               ((dmaDAR[i] & 1) != 0 && dmaDACValue[i] == 0 ? 1 : 0) :  //デバイスが奇数アドレスかつカウントしないとき1追加
   520:                               0);  //ワードまたはロングまたはパックなしは0
   521:     if (dmaREQG[i] == DMA_AUTO_REQUEST) {  //オートリクエスト限定速度
   522:       dmaBurstStart = XEiJ.mpuClockTime;  //今回のバースト開始時刻
   523:       dmaBurstEnd = dmaBurstStart + dmaBurstSpan;  //今回のバースト終了時刻
   524:       dmaTransfer (i);  //最初のデータを転送する
   525:     } else if (dmaREQG[i] != DMA_EXTERNAL_REQUEST) {  //オートリクエスト最大速度または最初はオートリクエスト、2番目から外部転送要求
   526:       dmaTransfer (i);  //最初のデータを転送する
   527:     }
   528:   }  //dmaStart(int)
   529: 
   530:   //dmaContinue (i)
   531:   //  転送継続
   532:   public static void dmaContinue (int i) {
   533:     if (DMA_DEBUG_TRACE != 0 && (DMA_DEBUG_TRACE & 1 << i) != 0) {
   534:       System.out.printf ("%d %08x dmaContinue(%d)\n", XEiJ.mpuClockTime, XEiJ.regPC0, i);
   535:     }
   536:     if (dmaREQG[i] == DMA_AUTO_REQUEST) {  //オートリクエスト限定速度
   537:       if (XEiJ.mpuClockTime < dmaBurstEnd) {  //バースト継続
   538:         //現在時刻に次の予約を入れる
   539:         //dmaInnerClock[i] = XEiJ.mpuClockTime;
   540:         //動作開始時刻に次の予約を入れる
   541:         dmaInnerClock[i] = dmaRequestTime[i];
   542:         TickerQueue.tkqAdd (dmaTickerArray[i], dmaInnerClock[i]);
   543:       } else {  //バースト終了
   544:         dmaBurstStart += dmaBurstInterval;  //次回のバースト開始時刻
   545:         if (dmaBurstStart < XEiJ.mpuClockTime) {
   546:           dmaBurstStart = XEiJ.mpuClockTime + dmaBurstInterval;  //間に合っていないとき1周だけ延期する
   547:         }
   548:         dmaBurstEnd = dmaBurstStart + dmaBurstSpan;  //次回のバースト終了時刻
   549:         //次回のバースト開始時刻に次の予約を入れる
   550:         dmaInnerClock[i] = dmaBurstStart;
   551:         TickerQueue.tkqAdd (dmaTickerArray[i], dmaInnerClock[i]);
   552:       }
   553:     } else if (dmaREQG[i] == DMA_AUTO_REQUEST_MAX) {  //オートリクエスト最大速度
   554:       //現在時刻に次の予約を入れる
   555:       //dmaInnerClock[i] = XEiJ.mpuClockTime;
   556:       //動作開始時刻に次の予約を入れる
   557:       dmaInnerClock[i] = dmaRequestTime[i];
   558:       TickerQueue.tkqAdd (dmaTickerArray[i], dmaInnerClock[i]);
   559:     }
   560:   }  //dmaContinue(int)
   561: 
   562:   //dmaHalt (i,hlt)
   563:   //  停止と再開
   564:   public static void dmaHalt (int i, int hlt) {
   565:     if (DMA_DEBUG_TRACE != 0 && (DMA_DEBUG_TRACE & 1 << i) != 0) {
   566:       System.out.printf ("%d %08x dmaHalt(%d,%d)\n", XEiJ.mpuClockTime, XEiJ.regPC0, i, hlt);
   567:     }
   568:     if ((~dmaHLT[i] & hlt) != 0) {  //動作→停止
   569:       if (dmaACT[i] == 0) {  //動作中でないときHLTをセットしようとした
   570:         dmaErrorExit (i, DMA_TIMING_ERROR);
   571:         return;
   572:       }
   573:       dmaHLT[i] = DMA_HLT;
   574:       dmaRequestTime[i] = XEiJ.FAR_FUTURE;
   575:       if (dmaInnerClock[i] != XEiJ.FAR_FUTURE) {
   576:         dmaInnerClock[i] = XEiJ.FAR_FUTURE;
   577:         TickerQueue.tkqRemove (dmaTickerArray[i]);
   578:       }
   579:     } else if ((dmaHLT[i] & ~hlt) != 0) {  //停止→動作
   580:       dmaHLT[i] = 0;
   581:       if (dmaACT[i] == 0) {
   582:         return;
   583:       }
   584:       dmaRequestTime[i] = XEiJ.mpuClockTime;
   585:       if (dmaREQG[i] == DMA_AUTO_REQUEST) {  //オートリクエスト限定速度
   586:         dmaBurstStart = XEiJ.mpuClockTime;
   587:         dmaBurstEnd = dmaBurstStart + dmaBurstSpan;
   588:       }
   589:       dmaContinue (i);
   590:     }
   591:   }
   592: 
   593:   //dmaComplete (i)
   594:   //  転送終了
   595:   //  dmaBLC,dmaNDTは個別に設定すること
   596:   public static void dmaComplete (int i) {
   597:     if (DMA_DEBUG_TRACE != 0 && (DMA_DEBUG_TRACE & 1 << i) != 0) {
   598:       System.out.printf ("%d %08x dmaComplete(%d)\n", XEiJ.mpuClockTime, XEiJ.regPC0, i);
   599:     }
   600:     dmaRequestTime[i] = XEiJ.FAR_FUTURE;
   601:     dmaCOC[i] = DMA_COC;
   602:     dmaERR[i] = 0;
   603:     dmaACT[i] = 0;
   604:     dmaSTR[i] = 0;
   605:     dmaCNT[i] = 0;
   606:     dmaSAB[i] = 0;
   607:     dmaErrorCode[i] = 0;
   608:     if (dmaITE[i] != 0) {  //インタラプトイネーブル
   609:       dmaInnerRequest[i << 1]++;
   610:       XEiJ.mpuIRR |= XEiJ.MPU_DMA_INTERRUPT_MASK;
   611:     }
   612:     if (dmaInnerClock[i] != XEiJ.FAR_FUTURE) {
   613:       dmaInnerClock[i] = XEiJ.FAR_FUTURE;
   614:       TickerQueue.tkqRemove (dmaTickerArray[i]);
   615:     }
   616:   }  //dmaComplete(int)
   617: 
   618:   //dmaErrorExit (i, code)
   619:   //  エラー終了
   620:   //  dmaBLC,dmaNDTは操作しない
   621:   public static void dmaErrorExit (int i, int code) {
   622:     if (DMA_DEBUG_TRACE != 0 && (DMA_DEBUG_TRACE & 1 << i) != 0) {
   623:       System.out.printf ("%d %08x dmaErrorExit(%d,%d)\n", XEiJ.mpuClockTime, XEiJ.regPC0, i, code);
   624:     }
   625:     dmaRequestTime[i] = XEiJ.FAR_FUTURE;
   626:     dmaCOC[i] = DMA_COC;
   627:     dmaERR[i] = DMA_ERR;
   628:     dmaACT[i] = 0;
   629:     dmaSTR[i] = 0;
   630:     dmaCNT[i] = 0;
   631:     dmaHLT[i] = 0;
   632:     dmaSAB[i] = 0;
   633:     dmaErrorCode[i] = code;
   634:     if (dmaITE[i] != 0) {  //インタラプトイネーブル
   635:       dmaInnerRequest[i << 1 | 1]++;
   636:       XEiJ.mpuIRR |= XEiJ.MPU_DMA_INTERRUPT_MASK;
   637:     }
   638:     if (dmaInnerClock[i] != XEiJ.FAR_FUTURE) {
   639:       dmaInnerClock[i] = XEiJ.FAR_FUTURE;
   640:       TickerQueue.tkqRemove (dmaTickerArray[i]);
   641:     }
   642:   }  //dmaErrorExit(int,int)
   643: 
   644:   //dmaFallPCL (i) {
   645:   public static void dmaFallPCL (int i) {
   646:     if (DMA_DEBUG_TRACE != 0 && (DMA_DEBUG_TRACE & 1 << i) != 0) {
   647:       System.out.printf ("%d %08x dmaFallPCL(%d)\n", XEiJ.mpuClockTime, XEiJ.regPC0, i);
   648:     }
   649:     if (dmaPCS[i] != 0) {
   650:       dmaPCS[i] = 0;
   651:       dmaPCT[i] = DMA_PCT;
   652:     }
   653:   }  //dmaFallPCL
   654: 
   655:   //dmaRisePCL (i)
   656:   public static void dmaRisePCL (int i) {
   657:     if (DMA_DEBUG_TRACE != 0 && (DMA_DEBUG_TRACE & 1 << i) != 0) {
   658:       System.out.printf ("%d %08x dmaRisePCL(%d)\n", XEiJ.mpuClockTime, XEiJ.regPC0, i);
   659:     }
   660:     dmaPCS[i] = DMA_PCS;
   661:   }  //dmaRisePCL
   662: 
   663:   //dmaFallREQ (i) {
   664:   //  外部転送要求
   665:   public static void dmaFallREQ (int i) {
   666:     dmaFallREQ (i, 0);
   667:   }
   668:   public static void dmaFallREQ (int i, long time) {
   669:     if (DMA_DEBUG_TRACE != 0 && (DMA_DEBUG_TRACE & 1 << i) != 0) {
   670:       System.out.printf ("%d %08x dmaFallREQ(%d)\n", XEiJ.mpuClockTime, XEiJ.regPC0, i);
   671:     }
   672:     dmaReqPin[i] = 0;
   673:     if (dmaACT[i] != 0 &&  //動作中
   674:         (dmaREQG[i] & (DMA_EXTERNAL_REQUEST & DMA_DUAL_REQUEST)) != 0) {  //外部転送要求または最初はオートリクエスト、2番目から外部転送要求
   675:       //現在時刻から1clk後に次の予約を入れる
   676:       //  0clk後だとADPCMの再生に失敗する場合がある
   677:       dmaInnerClock[i] = time != 0 ? time : XEiJ.mpuClockTime + XEiJ.dmaCycleUnit * 1;
   678:       TickerQueue.tkqAdd (dmaTickerArray[i], dmaInnerClock[i]);
   679:     }
   680:   }  //dmaFallREQ
   681: 
   682:   //dmaRiseREQ (i)
   683:   //  外部転送要求解除
   684:   public static void dmaRiseREQ (int i) {
   685:     if (DMA_DEBUG_TRACE != 0 && (DMA_DEBUG_TRACE & 1 << i) != 0) {
   686:       System.out.printf ("%d %08x dmaRiseREQ(%d)\n", XEiJ.mpuClockTime, XEiJ.regPC0, i);
   687:     }
   688:     dmaReqPin[i] = 1;
   689:     dmaInnerClock[i] = XEiJ.FAR_FUTURE;
   690:     TickerQueue.tkqRemove (dmaTickerArray[i]);
   691:   }  //dmaRiseREQ
   692: 
   693:   //dmaTransfer (i)
   694:   //  1データ転送する
   695:   @SuppressWarnings ("fallthrough") public static void dmaTransfer (int i) {
   696:     if (DMA_DEBUG_TRACE != 0 && (DMA_DEBUG_TRACE & 1 << i) != 0) {
   697:       System.out.printf ("%d %08x dmaTransfer(%d,0x%08x,0x%08x,%d)\n", XEiJ.mpuClockTime, XEiJ.regPC0, i,
   698:                          dmaDIR[i] == DMA_MEMORY_TO_DEVICE ? dmaMAR[i] : dmaDAR[i],
   699:                          dmaDIR[i] == DMA_MEMORY_TO_DEVICE ? dmaDAR[i] : dmaMAR[i],
   700:                          dmaSIZE[i] == DMA_BYTE_SIZE || dmaSIZE[i] == DMA_UNPACKED_8_BIT ? 1 : dmaSIZE[i] == DMA_WORD_SIZE ? 2 : 4);
   701:     }
   702:     if (dmaHLT[i] != 0) {  //一時停止中
   703:       return;  //何もしない
   704:     }
   705:   transfer:
   706:     {
   707:       int code = 0;
   708:       try {
   709:         XEiJ.busWaitTime = XEiJ.busWaitCycles ? XEiJ.dmaWaitTime : XEiJ.dmaNoWaitTime;
   710:         switch (dmaSIZE[i]) {
   711:         case DMA_BYTE_SIZE:  //バイト、パックあり
   712:           if (dmaDIR[i] == DMA_MEMORY_TO_DEVICE) {  //メモリからデバイスへ
   713:             //メモリから読み出す
   714:             code = DMA_MEMORY_BUS_ERROR;
   715:             MemoryMappedDevice[] mm = dmaMFCMap[i];
   716:             int a = dmaMAR[i];  //メモリアドレス
   717:             int ac = dmaMACValue[i];  //メモリアドレスカウント
   718:             int data = dmaMemoryCarry[i];  //繰り越したデータ
   719:             if (0 <= data) {  //繰り越したデータがある。繰り越したデータを使う
   720:               dmaMemoryCarry[i] = -1;
   721:             } else if ((a & 1) == 0 && ac == 1 && 2 <= dmaMTC[i]) {  //偶数アドレスで1ずつ増えて最後ではない
   722:               data = mm[a >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a);  //ワードで読み出す
   723:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles;
   724:               dmaMemoryCarry[i] = data & 255;  //下位バイトを繰り越す
   725:               data >>= 8;  //上位バイトを使う
   726:             } else if ((a & 1) != 0 && ac == -1 && 2 <= dmaMTC[i]) {  //奇数アドレスで1ずつ減って最後ではない
   727:               data = mm[(a - 1) >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a - 1);  //ワードで読み出す
   728:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles;
   729:               dmaMemoryCarry[i] = data >> 8;  //上位バイトを繰り越す
   730:               data &= 255;  //下位バイトを使う
   731:             } else {  //その他
   732:               data = mm[a >>> XEiJ.BUS_PAGE_BITS].mmdRbz (a);  //バイトで読み出して使う
   733:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles;
   734:             }
   735:             dmaMAR[i] = a + ac;  //メモリアドレスを更新する
   736:             //EXACKの処理
   737:             if (i == 2) {
   738:               if (MercuryUnit.MU4_ON && MercuryUnit.mu4On) {
   739:                 MercuryUnit.mu4ExackStart ();
   740:               }
   741:             }
   742:             //デバイスへ書き込む
   743:             code = DMA_DEVICE_BUS_ERROR;
   744:             mm = dmaDFCMap[i];
   745:             a = dmaDAR[i];  //デバイスアドレス
   746:             ac = dmaDACValue[i];  //デバイスアドレスカウント
   747:             int carry = dmaDeviceCarry[i];  //繰り越したデータ
   748:             if (0 <= carry) {  //繰り越したデータがある
   749:               if ((a & 1) != 0) {  //奇数アドレス
   750:                 data = carry << 8 | data;  //繰り越したデータを上位バイト、今回のデータを下位バイトとする
   751:                 mm[(a - 1) >>> XEiJ.BUS_PAGE_BITS].mmdWw (a - 1, data);  //偶数アドレスにワードで書き込む
   752:               } else {  //偶数アドレス
   753:                 data = data << 8 | carry;  //今回のデータを上位バイト、繰り越したデータを下位バイトとする
   754:                 mm[a >>> XEiJ.BUS_PAGE_BITS].mmdWw (a, data);  //ワードで書き込む
   755:               }
   756:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaWriteCycles;
   757:               dmaDeviceCarry[i] = -1;
   758:             } else if (((a & 1) == 0 ? ac == 1 : ac == -1) && 2 <= dmaMTC[i]) {  //偶数アドレスで1ずつ増えるか奇数アドレスで1ずつ減って、最後ではない
   759:               dmaDeviceCarry[i] = data;  //繰り越す
   760:             } else {  //その他
   761:               mm[a >>> XEiJ.BUS_PAGE_BITS].mmdWb (a, data);  //今回のデータをバイトで書き込む
   762:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaWriteCycles;
   763:             }
   764:             dmaDAR[i] = a + ac;  //デバイスアドレスを更新する
   765:           } else {  //デバイスからメモリへ
   766:             //EXACKの処理
   767:             if (i == 2) {
   768:               if (MercuryUnit.MU4_ON && MercuryUnit.mu4On) {
   769:                 MercuryUnit.mu4ExackStart ();
   770:               }
   771:             }
   772:             //デバイスから読み出す
   773:             code = DMA_DEVICE_BUS_ERROR;
   774:             MemoryMappedDevice[] mm = dmaDFCMap[i];
   775:             int a = dmaDAR[i];  //デバイスアドレス
   776:             int ac = dmaDACValue[i];  //デバイスアドレスカウント
   777:             int data = dmaDeviceCarry[i];  //繰り越したデータ
   778:             if (0 <= data) {  //繰り越したデータがある。繰り越したデータを使う
   779:               dmaDeviceCarry[i] = -1;
   780:             } else if ((a & 1) == 0 && ac == 1 && 2 <= dmaMTC[i]) {  //偶数アドレスで1ずつ増えて最後ではない
   781:               data = mm[a >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a);  //ワードで読み出す
   782:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles;
   783:               dmaDeviceCarry[i] = data & 255;  //下位バイトを繰り越す
   784:               data >>= 8;  //上位バイトを使う
   785:             } else if ((a & 1) != 0 && ac == -1 && 2 <= dmaMTC[i]) {  //奇数アドレスで1ずつ減って最後ではない
   786:               data = mm[(a - 1) >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a - 1);  //ワードで読み出す
   787:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles;
   788:               dmaDeviceCarry[i] = data >> 8;  //上位バイトを繰り越す
   789:               data &= 255;  //下位バイトを使う
   790:             } else {  //その他
   791:               data = mm[a >>> XEiJ.BUS_PAGE_BITS].mmdRbz (a);  //バイトで読み出して使う
   792:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles;
   793:             }
   794:             dmaDAR[i] = a + ac;  //デバイスアドレスを更新する
   795:             //メモリへ書き込む
   796:             code = DMA_MEMORY_BUS_ERROR;
   797:             mm = dmaMFCMap[i];
   798:             a = dmaMAR[i];  //メモリアドレス
   799:             ac = dmaMACValue[i];  //メモリアドレスカウント
   800:             int carry = dmaMemoryCarry[i];  //繰り越したデータ
   801:             if (0 <= carry) {  //繰り越したデータがある
   802:               if ((a & 1) != 0) {  //奇数アドレス
   803:                 data = carry << 8 | data;  //繰り越したデータを上位バイト、今回のデータを下位バイトとする
   804:                 mm[(a - 1) >>> XEiJ.BUS_PAGE_BITS].mmdWw (a - 1, data);  //偶数アドレスにワードで書き込む
   805:               } else {  //偶数アドレス
   806:                 data = data << 8 | carry;  //今回のデータを上位バイト、繰り越したデータを下位バイトとする
   807:                 mm[a >>> XEiJ.BUS_PAGE_BITS].mmdWw (a, data);  //ワードで書き込む
   808:               }
   809:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaWriteCycles;
   810:               dmaMemoryCarry[i] = -1;
   811:             } else if (((a & 1) == 0 ? ac == 1 : ac == -1) && 2 <= dmaMTC[i]) {  //偶数アドレスで1ずつ増えるか奇数アドレスで1ずつ減って、最後ではない
   812:               dmaMemoryCarry[i] = data;  //繰り越す
   813:             } else {  //その他
   814:               mm[a >>> XEiJ.BUS_PAGE_BITS].mmdWb (a, data);  //今回のデータをバイトで書き込む
   815:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaWriteCycles;
   816:             }
   817:             dmaMAR[i] = a + ac;  //メモリアドレスを更新する
   818:           }
   819:           break;
   820:           //
   821:         case DMA_WORD_SIZE:  //ワード
   822:           if (dmaDIR[i] == DMA_MEMORY_TO_DEVICE) {  //メモリからデバイスへ
   823:             //メモリから読み出す
   824:             code = DMA_MEMORY_BUS_ERROR;
   825:             MemoryMappedDevice[] mm = dmaMFCMap[i];
   826:             int a = dmaMAR[i];  //メモリアドレス
   827:             int ac = dmaMACValue[i];  //メモリアドレスカウント
   828:             if ((a & 1) != 0) {  //アドレスエラー
   829:               dmaErrorExit (i, DMA_MEMORY_ADDRESS_ERROR);
   830:               break transfer;
   831:             }
   832:             int data = mm[a >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a);  //ワードで読み出す
   833:             XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles;
   834:             dmaMAR[i] = a + ac * 2;  //メモリアドレスを更新する
   835:             //EXACKの処理
   836:             if (i == 2) {
   837:               if (MercuryUnit.MU4_ON && MercuryUnit.mu4On) {
   838:                 MercuryUnit.mu4ExackStart ();
   839:               }
   840:             }
   841:             //デバイスへ書き込む
   842:             code = DMA_DEVICE_BUS_ERROR;
   843:             mm = dmaDFCMap[i];
   844:             a = dmaDAR[i];  //デバイスアドレス
   845:             ac = dmaDACValue[i];  //デバイスアドレスカウント
   846:             if (dmaDPS[i] == DMA_PORT_8_BIT) {  //8ビットポート
   847:               mm[a >>> XEiJ.BUS_PAGE_BITS].mmdWb (a, data >> 8);  //上位バイトをバイトで書き込む
   848:               mm[(a + 2) >>> XEiJ.BUS_PAGE_BITS].mmdWb (a + 2, data);  //下位バイトをバイトで書き込む
   849:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaWriteCycles * 2;
   850:             } else {  //16ビットポート
   851:               if ((a & 1) != 0) {  //アドレスエラー
   852:                 dmaErrorExit (i, DMA_DEVICE_ADDRESS_ERROR);
   853:                 break transfer;
   854:               }
   855:               mm[a >>> XEiJ.BUS_PAGE_BITS].mmdWw (a, data);  //ワードで書き込む
   856:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaWriteCycles;
   857:             }
   858:             dmaDAR[i] = a + ac * 2;  //デバイスアドレスを更新する
   859:           } else {  //デバイスからメモリへ
   860:             //EXACKの処理
   861:             if (i == 2) {
   862:               if (MercuryUnit.MU4_ON && MercuryUnit.mu4On) {
   863:                 MercuryUnit.mu4ExackStart ();
   864:               }
   865:             }
   866:             //デバイスから読み出す
   867:             code = DMA_DEVICE_BUS_ERROR;
   868:             MemoryMappedDevice[] mm = dmaDFCMap[i];
   869:             int a = dmaDAR[i];  //デバイスアドレス
   870:             int ac = dmaDACValue[i];  //デバイスアドレスカウント
   871:             int data;
   872:             if (dmaDPS[i] == DMA_PORT_8_BIT) {  //8ビットポート
   873:               data = mm[a >>> XEiJ.BUS_PAGE_BITS].mmdRbz (a) << 8;  //上位バイトをバイトで読み出す
   874:               data |= mm[(a + 2) >>> XEiJ.BUS_PAGE_BITS].mmdRbz (a + 2);  //下位バイトをバイトで読み出す
   875:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles * 2;
   876:             } else {  //16ビットポート
   877:               if ((a & 1) != 0) {  //アドレスエラー
   878:                 dmaErrorExit (i, DMA_DEVICE_ADDRESS_ERROR);
   879:                 break transfer;
   880:               }
   881:               data = mm[a >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a);  //ワードで読み出す
   882:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles;
   883:             }
   884:             dmaDAR[i] = a + ac * 2;  //デバイスアドレスを更新する
   885:             //メモリへ書き込む
   886:             code = DMA_MEMORY_BUS_ERROR;
   887:             mm = dmaMFCMap[i];
   888:             a = dmaMAR[i];  //メモリアドレス
   889:             ac = dmaMACValue[i];  //メモリアドレスカウント
   890:             if ((a & 1) != 0) {  //アドレスエラー
   891:               dmaErrorExit (i, DMA_MEMORY_ADDRESS_ERROR);
   892:               break transfer;
   893:             }
   894:             mm[a >>> XEiJ.BUS_PAGE_BITS].mmdWw (a, data);  //ワードで書き込む
   895:             XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaWriteCycles;
   896:             dmaMAR[i] = a + ac * 2;  //メモリアドレスを更新する
   897:           }
   898:           break;
   899:           //
   900:         case DMA_LONG_WORD_SIZE:  //ロング
   901:           if (dmaDIR[i] == DMA_MEMORY_TO_DEVICE) {  //メモリからデバイスへ
   902:             //メモリから読み出す
   903:             code = DMA_MEMORY_BUS_ERROR;
   904:             MemoryMappedDevice[] mm = dmaMFCMap[i];
   905:             int a = dmaMAR[i];  //メモリアドレス
   906:             int ac = dmaMACValue[i];  //メモリアドレスカウント
   907:             if ((a & 1) != 0) {  //アドレスエラー
   908:               dmaErrorExit (i, DMA_MEMORY_ADDRESS_ERROR);
   909:               break transfer;
   910:             }
   911:             int data = mm[a >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a) << 16;  //上位ワードをワードで読み出す
   912:             data |= mm[(a + 2) >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a + 2);  //下位ワードをワードで読み出す
   913:             XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles * 2;
   914:             dmaMAR[i] = a + ac * 4;  //メモリアドレスを更新する
   915:             //EXACKの処理
   916:             if (i == 2) {
   917:               if (MercuryUnit.MU4_ON && MercuryUnit.mu4On) {
   918:                 MercuryUnit.mu4ExackStart ();
   919:               }
   920:             }
   921:             //デバイスへ書き込む
   922:             code = DMA_DEVICE_BUS_ERROR;
   923:             mm = dmaDFCMap[i];
   924:             a = dmaDAR[i];  //デバイスアドレス
   925:             ac = dmaDACValue[i];  //デバイスアドレスカウント
   926:             if (dmaDPS[i] == DMA_PORT_8_BIT) {  //8ビットポート
   927:               mm[a >>> XEiJ.BUS_PAGE_BITS].mmdWb (a, data >> 24);  //上位ワードの上位バイトをバイトで書き込む
   928:               mm[(a + 2) >>> XEiJ.BUS_PAGE_BITS].mmdWb (a + 2, data >> 16);  //上位ワードの下位バイトをバイトで書き込む
   929:               mm[(a + 4) >>> XEiJ.BUS_PAGE_BITS].mmdWb (a + 4, data >> 8);  //下位ワードの上位バイトをバイトで書き込む
   930:               mm[(a + 6) >>> XEiJ.BUS_PAGE_BITS].mmdWb (a + 6, data);  //下位ワードの下位バイトをバイトで書き込む
   931:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaWriteCycles * 4;
   932:             } else {  //16ビットポート
   933:               if ((a & 1) != 0) {  //アドレスエラー
   934:                 dmaErrorExit (i, DMA_DEVICE_ADDRESS_ERROR);
   935:                 break transfer;
   936:               }
   937:               mm[a >>> XEiJ.BUS_PAGE_BITS].mmdWw (a, data >> 16);  //上位ワードをワードで書き込む
   938:               mm[(a + 2) >>> XEiJ.BUS_PAGE_BITS].mmdWw (a + 2, data);  //下位ワードをワードで書き込む
   939:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaWriteCycles * 2;
   940:             }
   941:             dmaDAR[i] = a + ac * 4;  //デバイスアドレスを更新する
   942:           } else {  //デバイスからメモリへ
   943:             //EXACKの処理
   944:             if (i == 2) {
   945:               if (MercuryUnit.MU4_ON && MercuryUnit.mu4On) {
   946:                 MercuryUnit.mu4ExackStart ();
   947:               }
   948:             }
   949:             //デバイスから読み出す
   950:             code = DMA_DEVICE_BUS_ERROR;
   951:             MemoryMappedDevice[] mm = dmaDFCMap[i];
   952:             int a = dmaDAR[i];  //デバイスアドレス
   953:             int ac = dmaDACValue[i];  //デバイスアドレスカウント
   954:             int data;
   955:             if (dmaDPS[i] == DMA_PORT_8_BIT) {  //8ビットポート
   956:               data = mm[a >>> XEiJ.BUS_PAGE_BITS].mmdRbz (a) << 24;  //上位ワードの上位バイトをバイトで読み出す
   957:               data |= mm[(a + 2) >>> XEiJ.BUS_PAGE_BITS].mmdRbz (a + 2) << 16;  //上位ワードの下位バイトをバイトで読み出す
   958:               data |= mm[(a + 4) >>> XEiJ.BUS_PAGE_BITS].mmdRbz (a + 4) << 8;  //下位ワードの上位バイトをバイトで読み出す
   959:               data |= mm[(a + 6) >>> XEiJ.BUS_PAGE_BITS].mmdRbz (a + 6);  //下位ワードの下位バイトをバイトで読み出す
   960:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles * 4;
   961:             } else {  //16ビットポート
   962:               if ((a & 1) != 0) {  //アドレスエラー
   963:                 dmaErrorExit (i, DMA_DEVICE_ADDRESS_ERROR);
   964:                 break transfer;
   965:               }
   966:               data = mm[a >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a) << 16;  //上位ワードをワードで読み出す
   967:               data |= mm[(a + 2) >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a + 2);  //下位ワードをワードで読み出す
   968:               XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles * 2;
   969:             }
   970:             dmaDAR[i] = a + ac * 4;  //デバイスアドレスを更新する
   971:             //メモリへ書き込む
   972:             code = DMA_MEMORY_BUS_ERROR;
   973:             mm = dmaMFCMap[i];
   974:             a = dmaMAR[i];  //メモリアドレス
   975:             ac = dmaMACValue[i];  //メモリアドレスカウント
   976:             if ((a & 1) != 0) {  //アドレスエラー
   977:               dmaErrorExit (i, DMA_MEMORY_ADDRESS_ERROR);
   978:               break transfer;
   979:             }
   980:             mm[a >>> XEiJ.BUS_PAGE_BITS].mmdWw (a, data >> 16);  //上位ワードをワードで書き込む
   981:             mm[(a + 2) >>> XEiJ.BUS_PAGE_BITS].mmdWw (a + 2, data);  //下位ワードをワードで書き込む
   982:             XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaWriteCycles * 2;
   983:             dmaMAR[i] = a + ac * 4;  //メモリアドレスを更新する
   984:           }
   985:           break;
   986:           //
   987:         case DMA_UNPACKED_8_BIT:  //バイト、パックなし
   988:           if (dmaDIR[i] == DMA_MEMORY_TO_DEVICE) {  //メモリからデバイスへ
   989:             //メモリから読み出す
   990:             code = DMA_MEMORY_BUS_ERROR;
   991:             MemoryMappedDevice[] mm = dmaMFCMap[i];
   992:             int a = dmaMAR[i];  //メモリアドレス
   993:             int ac = dmaMACValue[i];  //メモリアドレスカウント
   994:             int data = mm[a >>> XEiJ.BUS_PAGE_BITS].mmdRbz (a);  //バイトで読み出す
   995:             XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles;
   996:             dmaMAR[i] = a + ac;  //メモリアドレスを更新する
   997:             //EXACKの処理
   998:             if (i == 2) {
   999:               if (MercuryUnit.MU4_ON && MercuryUnit.mu4On) {
  1000:                 MercuryUnit.mu4ExackStart ();
  1001:               }
  1002:             }
  1003:             //デバイスへ書き込む
  1004:             code = DMA_DEVICE_BUS_ERROR;
  1005:             mm = dmaDFCMap[i];
  1006:             a = dmaDAR[i];  //デバイスアドレス
  1007:             ac = dmaDACValue[i];  //デバイスアドレスカウント
  1008:             mm[a >>> XEiJ.BUS_PAGE_BITS].mmdWb (a, data);  //バイトで書き込む
  1009:             XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaWriteCycles;
  1010:             dmaDAR[i] = a + ac;  //デバイスアドレスを更新する
  1011:           } else {  //デバイスからメモリへ
  1012:             //EXACKの処理
  1013:             if (i == 2) {
  1014:               if (MercuryUnit.MU4_ON && MercuryUnit.mu4On) {
  1015:                 MercuryUnit.mu4ExackStart ();
  1016:               }
  1017:             }
  1018:             //デバイスから読み出す
  1019:             code = DMA_DEVICE_BUS_ERROR;
  1020:             MemoryMappedDevice[] mm = dmaDFCMap[i];
  1021:             int a = dmaDAR[i];  //デバイスアドレス
  1022:             int ac = dmaDACValue[i];  //デバイスアドレスカウント
  1023:             int data = mm[a >>> XEiJ.BUS_PAGE_BITS].mmdRbz (a);  //バイトで読み出す
  1024:             XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles;
  1025:             dmaDAR[i] = a + ac;  //デバイスアドレスを更新する
  1026:             //メモリへ書き込む
  1027:             code = DMA_MEMORY_BUS_ERROR;
  1028:             mm = dmaMFCMap[i];
  1029:             a = dmaMAR[i];  //メモリアドレス
  1030:             ac = dmaMACValue[i];  //メモリアドレスカウント
  1031:             mm[a >>> XEiJ.BUS_PAGE_BITS].mmdWb (a, data);  //バイトで書き込む
  1032:             XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaWriteCycles;
  1033:             dmaMAR[i] = a + ac;  //メモリアドレスを更新する
  1034:           }
  1035:           break;
  1036:         }  //switch dmaSIZE[i]
  1037:         //サイクル数を補正する
  1038:         XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaAdditionalCycles[i];
  1039:         XEiJ.busWaitTime = XEiJ.busWaitCycles ? XEiJ.mpuWaitTime : XEiJ.mpuNoWaitTime;
  1040:       } catch (M68kException e) {
  1041:         XEiJ.busWaitTime = XEiJ.busWaitCycles ? XEiJ.mpuWaitTime : XEiJ.mpuNoWaitTime;
  1042:         dmaErrorExit (i, code);
  1043:         break transfer;
  1044:       }
  1045:       dmaMTC[i]--;
  1046:       if (dmaMTC[i] != 0) {  //継続
  1047:         dmaContinue (i);
  1048:       } else if (dmaCHAIN[i] == DMA_ARRAY_CHAINING) {  //アレイチェーンモードのとき
  1049:         if (dmaBTC[i] != 0) {  //継続
  1050:           //アドレスエラーのチェックは不要
  1051:           try {
  1052:             XEiJ.busWaitTime = XEiJ.busWaitCycles ? XEiJ.dmaWaitTime : XEiJ.dmaNoWaitTime;
  1053:             MemoryMappedDevice[] mm = dmaBFCMap[i];
  1054:             int a = dmaBAR[i];
  1055:             dmaMAR[i] = mm[a >>> XEiJ.BUS_PAGE_BITS].mmdRws (a) << 16 | mm[a + 2 >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a + 2);
  1056:             dmaMTC[i] = mm[a + 4 >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a + 4);
  1057:             dmaBAR[i] += 6;
  1058:             XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles * 3;
  1059:             XEiJ.busWaitTime = XEiJ.busWaitCycles ? XEiJ.mpuWaitTime : XEiJ.mpuNoWaitTime;
  1060:           } catch (M68kException e) {  //バスエラー
  1061:             XEiJ.busWaitTime = XEiJ.busWaitCycles ? XEiJ.mpuWaitTime : XEiJ.mpuNoWaitTime;
  1062:             dmaErrorExit (i, DMA_BASE_BUS_ERROR);
  1063:             break transfer;
  1064:           }
  1065:           dmaBTC[i]--;
  1066:           if (dmaMTC[i] == 0) {  //カウントエラー
  1067:             dmaErrorExit (i, DMA_MEMORY_COUNT_ERROR);
  1068:             break transfer;
  1069:           }
  1070:           if ((dmaSIZE[i] == DMA_WORD_SIZE || dmaSIZE[i] == DMA_LONG_WORD_SIZE) && (dmaMAR[i] & 1) != 0) {  //アドレスエラー
  1071:             dmaErrorExit (i, DMA_MEMORY_ADDRESS_ERROR);
  1072:             break transfer;
  1073:           }
  1074:           dmaContinue (i);
  1075:         } else {  //終了
  1076:           dmaBLC[i] = DMA_BLC;
  1077:           dmaNDT[i] = 0;
  1078:           dmaComplete (i);
  1079:         }
  1080:       } else if (dmaCHAIN[i] == DMA_LINK_ARRAY_CHAINING) {  //リンクアレイチェーンモードのとき
  1081:         if (dmaBAR[i] != 0) {  //継続
  1082:           if ((dmaBAR[i] & 1) != 0) {  //アドレスエラー
  1083:             dmaErrorExit (i, DMA_BASE_ADDRESS_ERROR);
  1084:             break transfer;
  1085:           }
  1086:           try {
  1087:             XEiJ.busWaitTime = XEiJ.busWaitCycles ? XEiJ.dmaWaitTime : XEiJ.dmaNoWaitTime;
  1088:             MemoryMappedDevice[] mm = dmaBFCMap[i];
  1089:             int a = dmaBAR[i];
  1090:             dmaMAR[i] = mm[a >>> XEiJ.BUS_PAGE_BITS].mmdRws (a) << 16 | mm[a + 2 >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a + 2);
  1091:             dmaMTC[i] = mm[a + 4 >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a + 4);
  1092:             dmaBAR[i] = mm[a + 6 >>> XEiJ.BUS_PAGE_BITS].mmdRws (a + 6) << 16 | mm[a + 8 >>> XEiJ.BUS_PAGE_BITS].mmdRwz (a + 8);
  1093:             XEiJ.mpuClockTime += XEiJ.dmaCycleUnit * dmaReadCycles * 5;
  1094:             XEiJ.busWaitTime = XEiJ.busWaitCycles ? XEiJ.mpuWaitTime : XEiJ.mpuNoWaitTime;
  1095:           } catch (M68kException e) {  //バスエラー
  1096:             XEiJ.busWaitTime = XEiJ.busWaitCycles ? XEiJ.mpuWaitTime : XEiJ.mpuNoWaitTime;
  1097:             dmaErrorExit (i, DMA_BASE_BUS_ERROR);
  1098:             break transfer;
  1099:           }
  1100:           if (dmaMTC[i] == 0) {  //カウントエラー
  1101:             dmaErrorExit (i, DMA_MEMORY_COUNT_ERROR);
  1102:             break transfer;
  1103:           }
  1104:           if ((dmaSIZE[i] == DMA_WORD_SIZE || dmaSIZE[i] == DMA_LONG_WORD_SIZE) && (dmaMAR[i] & 1) != 0) {  //アドレスエラー
  1105:             dmaErrorExit (i, DMA_MEMORY_ADDRESS_ERROR);
  1106:             break transfer;
  1107:           }
  1108:           dmaContinue (i);
  1109:         } else {  //終了
  1110:           dmaBLC[i] = DMA_BLC;
  1111:           dmaNDT[i] = 0;
  1112:           dmaComplete (i);
  1113:         }
  1114:       } else if (dmaCNT[i] != 0) {  //コンティニューモードのとき
  1115:         dmaBLC[i] = DMA_BLC;
  1116:         dmaCNT[i] = 0;
  1117:         if (dmaITE[i] != 0) {  //インタラプトイネーブル
  1118:           dmaInnerRequest[i << 1]++;
  1119:           XEiJ.mpuIRR |= XEiJ.MPU_DMA_INTERRUPT_MASK;
  1120:         }
  1121:         dmaMTC[i] = dmaBTC[i];
  1122:         dmaMAR[i] = dmaBAR[i];
  1123:         if (dmaMTC[i] == 0) {  //カウントエラー
  1124:           dmaErrorExit (i, DMA_MEMORY_COUNT_ERROR);
  1125:           break transfer;
  1126:         }
  1127:         if ((dmaSIZE[i] == DMA_WORD_SIZE || dmaSIZE[i] == DMA_LONG_WORD_SIZE) && (dmaMAR[i] & 1) != 0) {  //アドレスエラー
  1128:           dmaErrorExit (i, DMA_MEMORY_ADDRESS_ERROR);
  1129:           break transfer;
  1130:         }
  1131:         dmaContinue (i);
  1132:       } else {  //終了
  1133:         dmaBLC[i] = 0;
  1134:         dmaNDT[i] = 0;
  1135:         dmaComplete (i);
  1136:       }
  1137:     }  //transfer
  1138:   }  //dmaTransfer
  1139: 
  1140: 
  1141: 
  1142:   public static int dmaReadByte (int a) {
  1143:     int d;
  1144:     int al = a & 0xff;
  1145:     if (al == DMA_GCR) {
  1146:       d = dmaBT | dmaBR;
  1147:       if (DMA_DEBUG_TRACE != 0) {
  1148:         System.out.printf ("%d %08x dmaRbz(0x%08x)=0x%02x\n", XEiJ.mpuClockTime, XEiJ.regPC0, a, d);
  1149:       }
  1150:     } else {
  1151:       int i = al >> 6;  //チャンネル
  1152:       switch (al & 0x3f) {
  1153:       case DMA_CSR:
  1154:         d = dmaCOC[i] | dmaBLC[i] | dmaNDT[i] | dmaERR[i] | dmaACT[i] | dmaDIT[i] | dmaPCT[i] | dmaPCS[i];
  1155:         break;
  1156:       case DMA_CER:
  1157:         d = dmaErrorCode[i];
  1158:         break;
  1159:       case DMA_DCR:
  1160:         d = dmaXRM[i] | dmaDTYP[i] | dmaDPS[i] | dmaPCL[i];
  1161:         break;
  1162:       case DMA_OCR:
  1163:         d = dmaDIR[i] | dmaBTD[i] | dmaSIZE[i] | dmaCHAIN[i] | dmaREQG[i];
  1164:         break;
  1165:       case DMA_SCR:
  1166:         d = dmaMAC[i] | dmaDAC[i];
  1167:         break;
  1168:       case DMA_CCR:
  1169:         d = dmaSTR[i] | dmaCNT[i] | dmaHLT[i] | dmaSAB[i] | dmaITE[i];
  1170:         break;
  1171:       case DMA_MTC:
  1172:         d = dmaMTC[i] >> 8;
  1173:         break;
  1174:       case DMA_MTC + 1:
  1175:         d = dmaMTC[i] & 0xff;
  1176:         break;
  1177:       case DMA_MAR:
  1178:         d = dmaMAR[i] >>> 24;
  1179:         break;
  1180:       case DMA_MAR + 1:
  1181:         d = dmaMAR[i] >> 16 & 0xff;
  1182:         break;
  1183:       case DMA_MAR + 2:
  1184:         d = (char) dmaMAR[i] >> 8;
  1185:         break;
  1186:       case DMA_MAR + 3:
  1187:         d = dmaMAR[i] & 0xff;
  1188:         break;
  1189:       case DMA_DAR:
  1190:         d = dmaDAR[i] >>> 24;
  1191:         break;
  1192:       case DMA_DAR + 1:
  1193:         d = dmaDAR[i] >> 16 & 0xff;
  1194:         break;
  1195:       case DMA_DAR + 2:
  1196:         d = (char) dmaDAR[i] >> 8;
  1197:         break;
  1198:       case DMA_DAR + 3:
  1199:         d = dmaDAR[i] & 0xff;
  1200:         break;
  1201:       case DMA_BTC:
  1202:         d = dmaBTC[i] >> 8;
  1203:         break;
  1204:       case DMA_BTC + 1:
  1205:         d = dmaBTC[i] & 0xff;
  1206:         break;
  1207:       case DMA_BAR:
  1208:         d = dmaBAR[i] >>> 24;
  1209:         break;
  1210:       case DMA_BAR + 1:
  1211:         d = dmaBAR[i] >> 16 & 0xff;
  1212:         break;
  1213:       case DMA_BAR + 2:
  1214:         d = (char) dmaBAR[i] >> 8;
  1215:         break;
  1216:       case DMA_BAR + 3:
  1217:         d = dmaBAR[i] & 0xff;
  1218:         break;
  1219:       case DMA_NIV:
  1220:         d = dmaNIV[i];
  1221:         break;
  1222:       case DMA_EIV:
  1223:         d = dmaEIV[i];
  1224:         break;
  1225:       case DMA_MFC:
  1226:         d = dmaMFC[i];
  1227:         break;
  1228:       case DMA_CPR:
  1229:         d = dmaCP[i];
  1230:         break;
  1231:       case DMA_DFC:
  1232:         d = dmaDFC[i];
  1233:         break;
  1234:       case DMA_BFC:
  1235:         d = dmaBFC[i];
  1236:         break;
  1237:       default:
  1238:         d = 0;
  1239:       }
  1240:       if (DMA_DEBUG_TRACE != 0 && (DMA_DEBUG_TRACE & 1 << i) != 0) {
  1241:         System.out.printf ("%d %08x dmaRbz(0x%08x)=0x%02x\n", XEiJ.mpuClockTime, XEiJ.regPC0, a, d);
  1242:       }
  1243:     }
  1244:     return d;
  1245:   }  //dmaReadByte
  1246: 
  1247:   public static int dmaReadWord (int a) {
  1248:     int d;
  1249:     int al = a & 0xff;
  1250:     int i = al >> 6;  //チャンネル
  1251:     switch (al & 0x3f) {
  1252:     case DMA_MTC:
  1253:       d = dmaMTC[i];
  1254:       break;
  1255:     case DMA_MAR:
  1256:       d = dmaMAR[i] >>> 16;
  1257:       break;
  1258:     case DMA_MAR + 2:
  1259:       d = (char) dmaMAR[i];
  1260:       break;
  1261:     case DMA_DAR:
  1262:       d = dmaDAR[i] >>> 16;
  1263:       break;
  1264:     case DMA_DAR + 2:
  1265:       d = (char) dmaDAR[i];
  1266:       break;
  1267:     case DMA_BTC:
  1268:       d = dmaBTC[i];
  1269:       break;
  1270:     case DMA_BAR:
  1271:       d = dmaBAR[i] >>> 16;
  1272:       break;
  1273:     case DMA_BAR + 2:
  1274:       d = (char) dmaBAR[i];
  1275:       break;
  1276:     default:
  1277:       d = dmaReadByte (a) << 8 | dmaReadByte (a + 1);
  1278:     }
  1279:     if (DMA_DEBUG_TRACE != 0 && (DMA_DEBUG_TRACE & 1 << i) != 0) {
  1280:       System.out.printf ("%d %08x dmaRwz(0x%08x)=0x%04x\n", XEiJ.mpuClockTime, XEiJ.regPC0, a, d);
  1281:     }
  1282:     return d;
  1283:   }  //dmaReadWord
  1284: 
  1285:   public static int dmaReadLong (int a) {
  1286:     a &= XEiJ.BUS_MOTHER_MASK;
  1287:     int d;
  1288:     int al = a & 0xff;
  1289:     int i = al >> 6;  //チャンネル
  1290:     switch (al & 0x3f) {
  1291:     case DMA_MAR:
  1292:       d = dmaMAR[i];
  1293:       break;
  1294:     case DMA_DAR:
  1295:       d = dmaDAR[i];
  1296:       break;
  1297:     case DMA_BAR:
  1298:       d = dmaBAR[i];
  1299:       break;
  1300:     default:
  1301:       d = dmaReadWord (a) << 16 | dmaReadWord (a + 2);
  1302:     }
  1303:     if (DMA_DEBUG_TRACE != 0 && (DMA_DEBUG_TRACE & 1 << i) != 0) {
  1304:       System.out.printf ("%d %08x dmaRls(0x%08x)=0x%08x\n", XEiJ.mpuClockTime, XEiJ.regPC0, a, d);
  1305:     }
  1306:     return d;
  1307:   }  //dmaReadLong
  1308: 
  1309:   public static void dmaWriteByte (int a, int d) {
  1310:     d &= 0xff;
  1311:     int al = a & 0xff;
  1312:     if (al == DMA_GCR) {
  1313:       if (DMA_DEBUG_TRACE != 0) {
  1314:         System.out.printf ("%d %08x dmaWb(0x%08x,0x%02x)\n", XEiJ.mpuClockTime, XEiJ.regPC0, a, d);
  1315:       }
  1316:       dmaBT = d & DMA_BT;
  1317:       dmaBR = d & DMA_BR;
  1318:       dmaBurstSpan = XEiJ.dmaCycleUnit << (4 + (dmaBT >> 2));
  1319:       dmaBurstInterval = dmaBurstSpan << (1 + (dmaBR & 3));
  1320:       return;
  1321:     }
  1322:     int i = al >> 6;  //チャンネル
  1323:     if (DMA_DEBUG_TRACE != 0 && (DMA_DEBUG_TRACE & 1 << i) != 0) {
  1324:       System.out.printf ("%d %08x dmaWb(0x%08x,0x%02x)\n", XEiJ.mpuClockTime, XEiJ.regPC0, a, d);
  1325:     }
  1326:     switch (al & 0x3f) {
  1327:     case DMA_CSR:
  1328:       //HD63450,-Y,-P,-PS,-CP CMOS DMAC 1989 p37
  1329:       //  COC,PCT,BTC,NDT,ERR,DITは1を書き込むかリセットするとクリアされる
  1330:       //  PCSは書き込んでも変化しない
  1331:       //  ACTは転送が終了するかリセットするとクリアされる
  1332:       if ((d & DMA_COC) != 0) {
  1333:         dmaCOC[i] = 0;
  1334:       }
  1335:       if ((d & DMA_PCT) != 0) {
  1336:         dmaPCT[i] = 0;
  1337:       }
  1338:       if ((d & DMA_BLC) != 0) {
  1339:         dmaBLC[i] = 0;  //名前注意
  1340:       }
  1341:       if ((d & DMA_NDT) != 0) {
  1342:         dmaNDT[i] = 0;
  1343:       }
  1344:       if ((d & DMA_ERR) != 0) {
  1345:         dmaERR[i] = 0;
  1346:         dmaErrorCode[i] = 0;  //CSRのERRに1を書き込んでクリアするとCERも同時にクリアされる
  1347:       }
  1348:       if ((d & DMA_DIT) != 0) {
  1349:         dmaDIT[i] = 0;
  1350:       }
  1351:       return;
  1352:     case DMA_CER:
  1353:       //DMA_CERはread-only
  1354:       return;
  1355:     case DMA_DCR:
  1356:       if (dmaACT[i] != 0) {
  1357:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1358:         return;
  1359:       }
  1360:       dmaXRM[i] = d & DMA_XRM;
  1361:       dmaDTYP[i] = d & DMA_DTYP;
  1362:       dmaDPS[i] = d & DMA_DPS;
  1363:       dmaDACValue[i] = (dmaDAC[i] == DMA_INC_DAR ? 1 : dmaDAC[i] == DMA_DEC_DAR ? -1 : 0) * (dmaDPS[i] == DMA_PORT_8_BIT ? 2 : 1);
  1364:       dmaPCL[i] = d & DMA_PCL;
  1365:       return;
  1366:     case DMA_OCR:
  1367:       dmaDIR[i] = d & DMA_DIR;
  1368:       dmaBTD[i] = d & DMA_BTD;
  1369:       dmaSIZE[i] = d & DMA_SIZE;
  1370:       dmaCHAIN[i] = d & DMA_CHAIN;
  1371:       dmaREQG[i] = d & DMA_REQG;
  1372:       return;
  1373:     case DMA_SCR:
  1374:       if (dmaACT[i] != 0) {
  1375:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1376:         return;
  1377:       }
  1378:       dmaMAC[i] = d & DMA_MAC;
  1379:       dmaMACValue[i] = dmaMAC[i] == DMA_INC_MAR ? 1 : dmaMAC[i] == DMA_DEC_MAR ? -1 : 0;
  1380:       dmaDAC[i] = d & DMA_DAC;
  1381:       dmaDACValue[i] = (dmaDAC[i] == DMA_INC_DAR ? 1 : dmaDAC[i] == DMA_DEC_DAR ? -1 : 0) * (dmaDPS[i] == DMA_PORT_8_BIT ? 2 : 1);
  1382:       return;
  1383:     case DMA_CCR:
  1384:       if (dmaHLT[i] != (d & DMA_HLT)) {
  1385:         dmaHalt (i, (d & DMA_HLT));
  1386:       }
  1387:       dmaITE[i] = d & DMA_ITE;
  1388:       //DMA_CNT
  1389:       if ((d & DMA_CNT) != 0) {
  1390:         if ((dmaACT[i] == 0 && (d & DMA_STR) == 0) || dmaBLC[i] != 0) {  //動作中でないかブロック転送完了済みの状態でDMA_CNTをセットしようとした
  1391:           dmaErrorExit (i, DMA_TIMING_ERROR);
  1392:           return;
  1393:         }
  1394:         if (dmaCHAIN[i] != DMA_NO_CHAINING) {  //チェインモードのときDMA_CNTをセットしようとした
  1395:           dmaErrorExit (i, DMA_CONFIGURATION_ERROR);
  1396:           return;
  1397:         }
  1398:         dmaCNT[i] = DMA_CNT;  //DMA_CNTに0を書き込んでもクリアされない
  1399:       }
  1400:       //DMA_SAB
  1401:       if ((d & DMA_SAB) != 0) {
  1402:         //dmaSABには書き込まない。SABは読み出すと常に0
  1403:         dmaCOC[i] = 0;
  1404:         dmaBLC[i] = 0;
  1405:         dmaNDT[i] = 0;
  1406:         dmaHLT[i] = 0;
  1407:         dmaCNT[i] = 0;
  1408:         if (dmaACT[i] != 0 || (d & DMA_STR) != 0) {  //動作中
  1409:           dmaErrorExit (i, DMA_SOFTWARE_ABORT);
  1410:         }
  1411:         return;
  1412:       }
  1413:       //DMA_STR
  1414:       if ((d & DMA_STR) != 0) {
  1415:         dmaStart (i);
  1416:       }
  1417:       return;
  1418:     case DMA_MTC:
  1419:       if (dmaACT[i] != 0) {
  1420:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1421:         return;
  1422:       }
  1423:       dmaMTC[i] = d << 8 | (dmaMTC[i] & 0xff);
  1424:       return;
  1425:     case DMA_MTC + 1:
  1426:       if (dmaACT[i] != 0) {
  1427:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1428:         return;
  1429:       }
  1430:       dmaMTC[i] = (dmaMTC[i] & ~0xff) | d;
  1431:       return;
  1432:     case DMA_MAR:
  1433:       if (dmaACT[i] != 0) {
  1434:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1435:         return;
  1436:       }
  1437:       dmaMAR[i] = d << 24 | (dmaMAR[i] & ~(0xff << 24));
  1438:       return;
  1439:     case DMA_MAR + 1:
  1440:       if (dmaACT[i] != 0) {
  1441:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1442:         return;
  1443:       }
  1444:       dmaMAR[i] = d << 16 | (dmaMAR[i] & ~(0xff << 16));
  1445:       return;
  1446:     case DMA_MAR + 2:
  1447:       if (dmaACT[i] != 0) {
  1448:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1449:         return;
  1450:       }
  1451:       dmaMAR[i] = (dmaMAR[i] & ~(0xff << 8)) | d << 8;
  1452:       return;
  1453:     case DMA_MAR + 3:
  1454:       if (dmaACT[i] != 0) {
  1455:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1456:         return;
  1457:       }
  1458:       dmaMAR[i] = (dmaMAR[i] & ~0xff) | d;
  1459:       return;
  1460:     case DMA_DAR:
  1461:       if (dmaACT[i] != 0) {
  1462:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1463:         return;
  1464:       }
  1465:       dmaDAR[i] = d << 24 | (dmaDAR[i] & ~(0xff << 24));
  1466:       return;
  1467:     case DMA_DAR + 1:
  1468:       if (dmaACT[i] != 0) {
  1469:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1470:         return;
  1471:       }
  1472:       dmaDAR[i] = d << 16 | (dmaDAR[i] & ~(0xff << 16));
  1473:       return;
  1474:     case DMA_DAR + 2:
  1475:       if (dmaACT[i] != 0) {
  1476:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1477:         return;
  1478:       }
  1479:       dmaDAR[i] = (dmaDAR[i] & ~(0xff << 8)) | d << 8;
  1480:       return;
  1481:     case DMA_DAR + 3:
  1482:       if (dmaACT[i] != 0) {
  1483:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1484:         return;
  1485:       }
  1486:       dmaDAR[i] = (dmaDAR[i] & ~0xff) | d;
  1487:       return;
  1488:     case DMA_BTC:
  1489:       dmaBTC[i] = d << 8 | (dmaBTC[i] & 0xff);
  1490:       return;
  1491:     case DMA_BTC + 1:
  1492:       dmaBTC[i] = (dmaBTC[i] & ~0xff) | d;
  1493:       return;
  1494:     case DMA_BAR:
  1495:       dmaBAR[i] = d << 24 | (dmaBAR[i] & ~(0xff << 24));
  1496:       return;
  1497:     case DMA_BAR + 1:
  1498:       dmaBAR[i] = d << 16 | (dmaBAR[i] & ~(0xff << 16));
  1499:       return;
  1500:     case DMA_BAR + 2:
  1501:       dmaBAR[i] = (dmaBAR[i] & ~(0xff << 8)) | d << 8;
  1502:       return;
  1503:     case DMA_BAR + 3:
  1504:       dmaBAR[i] = (dmaBAR[i] & ~0xff) | d;
  1505:       return;
  1506:     case DMA_NIV:
  1507:       dmaNIV[i] = d;
  1508:       return;
  1509:     case DMA_EIV:
  1510:       dmaEIV[i] = d;
  1511:       return;
  1512:     case DMA_MFC:
  1513:       if (dmaACT[i] != 0) {
  1514:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1515:         return;
  1516:       }
  1517:       dmaMFC[i] = d & DMA_FC2;
  1518:       if (DataBreakPoint.DBP_ON) {
  1519:         dmaMFCMap[i] = dmaMFC[i] == 0 ? DataBreakPoint.dbpUserMap : DataBreakPoint.dbpSuperMap;
  1520:       } else {
  1521:         dmaMFCMap[i] = dmaMFC[i] == 0 ? XEiJ.busUserMap : XEiJ.busSuperMap;
  1522:       }
  1523:       return;
  1524:     case DMA_CPR:
  1525:       dmaCP[i] = d & DMA_CP;
  1526:       return;
  1527:     case DMA_DFC:
  1528:       if (dmaACT[i] != 0) {
  1529:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1530:         return;
  1531:       }
  1532:       dmaDFC[i] = d & DMA_FC2;
  1533:       if (DataBreakPoint.DBP_ON) {
  1534:         dmaDFCMap[i] = dmaDFC[i] == 0 ? DataBreakPoint.dbpUserMap : DataBreakPoint.dbpSuperMap;
  1535:       } else {
  1536:         dmaDFCMap[i] = dmaDFC[i] == 0 ? XEiJ.busUserMap : XEiJ.busSuperMap;
  1537:       }
  1538:       return;
  1539:     case DMA_BFC:
  1540:       dmaBFC[i] = d & DMA_FC2;
  1541:       if (DataBreakPoint.DBP_ON) {
  1542:         dmaBFCMap[i] = dmaBFC[i] == 0 ? DataBreakPoint.dbpUserMap : DataBreakPoint.dbpSuperMap;
  1543:       } else {
  1544:         dmaBFCMap[i] = dmaBFC[i] == 0 ? XEiJ.busUserMap : XEiJ.busSuperMap;
  1545:       }
  1546:       return;
  1547:     default:
  1548:       return;
  1549:     }
  1550:   }  //dmaWriteByte
  1551: 
  1552:   public static void dmaWriteWord (int a, int d) {
  1553:     d = (char) d;
  1554:     int al = a & 0xff;
  1555:     int i = al >> 6;  //チャンネル
  1556:     if (DMA_DEBUG_TRACE != 0 && (DMA_DEBUG_TRACE & 1 << i) != 0) {
  1557:       System.out.printf ("%d %08x dmaWw(0x%08x,0x%04x)\n", XEiJ.mpuClockTime, XEiJ.regPC0, a, d);
  1558:     }
  1559:     switch (al & 0x3f) {
  1560:     case DMA_MTC:
  1561:       if (dmaACT[i] != 0) {
  1562:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1563:       } else {
  1564:         dmaMTC[i] = d;
  1565:       }
  1566:       return;
  1567:     case DMA_MAR:
  1568:       if (dmaACT[i] != 0) {
  1569:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1570:       } else {
  1571:         dmaMAR[i] = d << 16 | (char) dmaMAR[i];
  1572:       }
  1573:       return;
  1574:     case DMA_MAR + 2:
  1575:       if (dmaACT[i] != 0) {
  1576:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1577:       } else {
  1578:         dmaMAR[i] = (dmaMAR[i] & ~0xffff) | d;
  1579:       }
  1580:       return;
  1581:     case DMA_DAR:
  1582:       if (dmaACT[i] != 0) {
  1583:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1584:       } else {
  1585:         dmaDAR[i] = d << 16 | (char) dmaDAR[i];
  1586:       }
  1587:       return;
  1588:     case DMA_DAR + 2:
  1589:       if (dmaACT[i] != 0) {
  1590:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1591:       } else {
  1592:         dmaDAR[i] = (dmaDAR[i] & ~0xffff) | d;
  1593:       }
  1594:       return;
  1595:     case DMA_BTC:
  1596:       dmaBTC[i] = (char) d;
  1597:       return;
  1598:     case DMA_BAR:
  1599:       dmaBAR[i] = d << 16 | (char) dmaBAR[i];
  1600:       return;
  1601:     case DMA_BAR + 2:
  1602:       dmaBAR[i] = (dmaBAR[i] & ~0xffff) | d;
  1603:       return;
  1604:     default:
  1605:       dmaWriteByte (a, d >> 8);
  1606:       dmaWriteByte (a + 1, d);
  1607:     }
  1608:   }  //dmaWriteWord
  1609: 
  1610:   public static void dmaWriteLong (int a, int d) {
  1611:     int al = a & 0xff;
  1612:     int i = al >> 6;  //チャンネル
  1613:     if (DMA_DEBUG_TRACE != 0 && (DMA_DEBUG_TRACE & 1 << i) != 0) {
  1614:       System.out.printf ("%d %08x dmaWl(0x%08x,0x%08x)\n", XEiJ.mpuClockTime, XEiJ.regPC0, a, d);
  1615:     }
  1616:     switch (al & 0x3f) {
  1617:     case DMA_MAR:
  1618:       if (dmaACT[i] != 0) {
  1619:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1620:       } else {
  1621:         dmaMAR[i] = d;
  1622:         if (DMA_ALERT_HIMEM) {
  1623:           if ((d & 0xff000000) != 0 && Model.MPU_MC68020 <= XEiJ.currentMPU) {
  1624:             System.out.printf ("%08x DMA_MAR[%d]=%08X\n", XEiJ.regPC0, i, d);
  1625:           }
  1626:         }
  1627:       }
  1628:       return;
  1629:     case DMA_DAR:
  1630:       if (dmaACT[i] != 0) {
  1631:         dmaErrorExit (i, DMA_TIMING_ERROR);
  1632:       } else {
  1633:         dmaDAR[i] = d;
  1634:         if (DMA_ALERT_HIMEM) {
  1635:           if ((d & 0xff000000) != 0 && Model.MPU_MC68020 <= XEiJ.currentMPU) {
  1636:             System.out.printf ("%08x DMA_DAR[%d]=%08X\n", XEiJ.regPC0, i, d);
  1637:           }
  1638:         }
  1639:       }
  1640:       return;
  1641:     case DMA_BAR:
  1642:       dmaBAR[i] = d;
  1643:       if (DMA_ALERT_HIMEM) {
  1644:         if ((d & 0xff000000) != 0 && Model.MPU_MC68020 <= XEiJ.currentMPU) {
  1645:           System.out.printf ("%08x DMA_BAR[%d]=%08X\n", XEiJ.regPC0, i, d);
  1646:         }
  1647:       }
  1648:       return;
  1649:     default:
  1650:       dmaWriteWord (a, d >> 16);
  1651:       dmaWriteWord (a + 2, d);
  1652:     }
  1653:   }
  1654: 
  1655: 
  1656: 
  1657: }  //class HD63450
  1658: 
  1659: 
  1660: